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_STOP_AT_CHECKPOINT
)
8369 if (data
.devices_status
!= STATUS_RUNNING
) return;
8372 // this feature only makes sense if --restore-disable was not specified
8374 if (data
.restore_disable
== 1)
8376 log_info ("WARNING: this feature is disabled when --restore-disable was specified");
8381 // check if monitoring of Restore Point updates should be enabled or disabled
8383 if (data
.devices_status
!= STATUS_STOP_AT_CHECKPOINT
)
8385 data
.devices_status
= STATUS_STOP_AT_CHECKPOINT
;
8387 // save the current restore point value
8389 data
.checkpoint_cur_words
= get_lowest_words_done ();
8391 log_info ("Checkpoint enabled: will quit at next Restore Point update");
8395 data
.devices_status
= STATUS_RUNNING
;
8397 // reset the global value for checkpoint checks
8399 data
.checkpoint_cur_words
= 0;
8401 log_info ("Checkpoint disabled: Restore Point updates will no longer be monitored");
8407 if (data
.devices_status
== STATUS_INIT
) return;
8408 if (data
.devices_status
== STATUS_STARTING
) return;
8410 data
.devices_status
= STATUS_ABORTED
;
8415 if (data
.devices_status
== STATUS_INIT
) return;
8416 if (data
.devices_status
== STATUS_STARTING
) return;
8418 data
.devices_status
= STATUS_QUIT
;
8422 uint
get_vliw_by_device_name (const char *device_name
)
8426 if (strcmp (device_name
, "Capeverde" ) == 0) vliw
= 1;
8427 if (strcmp (device_name
, "Pitcairn" ) == 0) vliw
= 1;
8428 if (strcmp (device_name
, "Tahiti" ) == 0) vliw
= 1;
8429 if (strcmp (device_name
, "ATI RV710" ) == 0) vliw
= 1;
8430 if (strcmp (device_name
, "ATI RV730" ) == 0) vliw
= 1;
8431 if (strcmp (device_name
, "ATI RV770" ) == 0) vliw
= 4;
8432 if (strcmp (device_name
, "Cayman" ) == 0) vliw
= 4;
8433 if (strcmp (device_name
, "Devastator" ) == 0) vliw
= 4;
8434 if (strcmp (device_name
, "Scrapper" ) == 0) vliw
= 4;
8435 if (strcmp (device_name
, "Barts" ) == 0) vliw
= 5;
8436 if (strcmp (device_name
, "BeaverCreek" ) == 0) vliw
= 5;
8437 if (strcmp (device_name
, "Caicos" ) == 0) vliw
= 5;
8438 if (strcmp (device_name
, "Cedar" ) == 0) vliw
= 5;
8439 if (strcmp (device_name
, "Cypress" ) == 0) vliw
= 5;
8440 if (strcmp (device_name
, "Juniper" ) == 0) vliw
= 5;
8441 if (strcmp (device_name
, "Loveland" ) == 0) vliw
= 5;
8442 if (strcmp (device_name
, "Redwood" ) == 0) vliw
= 5;
8443 if (strcmp (device_name
, "Turks" ) == 0) vliw
= 5;
8444 if (strcmp (device_name
, "WinterPark" ) == 0) vliw
= 5;
8445 if (strcmp (device_name
, "Oland" ) == 0) vliw
= 1;
8446 if (strcmp (device_name
, "Cats" ) == 0) vliw
= 1;
8447 if (strcmp (device_name
, "Raccoons" ) == 0) vliw
= 1;
8448 if (strcmp (device_name
, "Bonaire" ) == 0) vliw
= 1;
8449 if (strcmp (device_name
, "Hawaii" ) == 0) vliw
= 1;
8450 if (strcmp (device_name
, "Spectre" ) == 0) vliw
= 1;
8451 if (strcmp (device_name
, "Spooky" ) == 0) vliw
= 1;
8452 if (strcmp (device_name
, "Kalindi" ) == 0) vliw
= 1;
8453 if (strcmp (device_name
, "Hainan" ) == 0) vliw
= 1;
8454 if (strcmp (device_name
, "Iceland" ) == 0) vliw
= 1;
8455 if (strcmp (device_name
, "Tonga" ) == 0) vliw
= 1;
8456 if (strcmp (device_name
, "Mullins" ) == 0) vliw
= 1;
8457 if (strcmp (device_name
, "Fiji" ) == 0) vliw
= 1;
8459 if (strncmp (device_name
, "ATI Radeon HD 4", 15) == 0) vliw
= 1;
8460 if (strncmp (device_name
, "ATI Radeon HD 5", 15) == 0) vliw
= 5;
8461 if (strncmp (device_name
, "ATI Radeon HD 6", 15) == 0) vliw
= 4;
8462 if (strncmp (device_name
, "ATI Radeon HD 7", 15) == 0) vliw
= 4;
8463 if (strncmp (device_name
, "ATI Radeon HD 79", 16) == 0) vliw
= 1;
8464 if (strncmp (device_name
, "ATI Radeon HD 8", 15) == 0) vliw
= 1;
8465 if (strncmp (device_name
, "AMD Radeon R9", 13) == 0) vliw
= 1;
8470 uint
get_vliw_by_compute_capability (const uint major
, const uint minor
)
8474 if (major
== 1 && minor
== 0) vliw
= 1;
8475 if (major
== 1 && minor
== 1) vliw
= 1;
8476 if (major
== 1 && minor
== 2) vliw
= 1;
8477 if (major
== 1 && minor
== 3) vliw
= 1;
8478 if (major
== 2 && minor
== 0) vliw
= 1;
8479 if (major
== 2 && minor
== 1) vliw
= 2;
8480 if (major
== 3 && minor
== 0) vliw
= 2;
8481 if (major
== 3 && minor
== 5) vliw
= 2;
8482 if (major
== 3 && minor
== 7) vliw
= 2;
8483 if (major
== 5 && minor
== 0) vliw
= 2;
8484 if (major
== 5 && minor
== 2) vliw
= 2;
8491 void load_kernel (const char *kernel_file
, int num_devices
, size_t *kernel_lengths
, const unsigned char **kernel_sources
)
8495 if ((fp
= fopen (kernel_file
, "rb")) != NULL
)
8499 memset (&st
, 0, sizeof (st
));
8501 stat (kernel_file
, &st
);
8503 unsigned char *buf
= (unsigned char *) mymalloc (st
.st_size
+ 1);
8505 size_t num_read
= fread (buf
, sizeof (unsigned char), st
.st_size
, fp
);
8507 if (num_read
!= (size_t) st
.st_size
)
8509 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8516 buf
[st
.st_size
] = 0;
8518 for (int i
= 0; i
< num_devices
; i
++)
8520 kernel_lengths
[i
] = (size_t) st
.st_size
;
8522 kernel_sources
[i
] = buf
;
8527 log_error ("ERROR: %s: %s", kernel_file
, strerror (errno
));
8535 void writeProgramBin (char *dst
, unsigned char *binary
, size_t binary_size
)
8537 FILE *fp
= fopen (dst
, "wb");
8539 fwrite (binary
, sizeof (unsigned char), binary_size
, fp
);
8550 restore_data_t
*init_restore (int argc
, char **argv
)
8552 restore_data_t
*rd
= (restore_data_t
*) mymalloc (sizeof (restore_data_t
));
8554 if (data
.restore_disable
== 0)
8556 FILE *fp
= fopen (data
.eff_restore_file
, "rb");
8560 size_t nread
= fread (rd
, sizeof (restore_data_t
), 1, fp
);
8564 log_error ("ERROR: cannot read %s", data
.eff_restore_file
);
8573 char pidbin
[BUFSIZ
];
8578 memset (pidbin
, 0, sizeof (pidbin
));
8580 snprintf (pidbin
, sizeof (pidbin
) - 1, "/proc/%d/cmdline", rd
->pid
);
8582 FILE *fd
= fopen (pidbin
, "rb");
8586 pidbin_len
= fread (pidbin
, 1, BUFSIZ
, fd
);
8588 pidbin
[pidbin_len
] = 0;
8592 char *argv0_r
= strrchr (argv
[0], '/');
8594 char *pidbin_r
= strrchr (pidbin
, '/');
8596 if (argv0_r
== NULL
) argv0_r
= argv
[0];
8598 if (pidbin_r
== NULL
) pidbin_r
= pidbin
;
8600 if (strcmp (argv0_r
, pidbin_r
) == 0)
8602 log_error ("ERROR: already an instance %s running on pid %d", pidbin
, rd
->pid
);
8609 HANDLE hProcess
= OpenProcess (PROCESS_ALL_ACCESS
, FALSE
, rd
->pid
);
8611 char pidbin2
[BUFSIZ
];
8615 memset (pidbin2
, 0, sizeof (pidbin2
));
8617 pidbin_len
= GetModuleFileName (NULL
, pidbin
, BUFSIZ
);
8618 pidbin2_len
= GetModuleFileNameEx (hProcess
, NULL
, pidbin2
, BUFSIZ
);
8620 pidbin
[pidbin_len
] = 0;
8621 pidbin2
[pidbin2_len
] = 0;
8625 if (strcmp (pidbin
, pidbin2
) == 0)
8627 log_error ("ERROR: already an instance %s running on pid %d", pidbin2
, rd
->pid
);
8635 if (rd
->version_bin
< RESTORE_MIN
)
8637 log_error ("ERROR: cannot use outdated %s. Please remove it.", data
.eff_restore_file
);
8644 memset (rd
, 0, sizeof (restore_data_t
));
8646 rd
->version_bin
= VERSION_BIN
;
8649 rd
->pid
= getpid ();
8651 rd
->pid
= GetCurrentProcessId ();
8654 if (getcwd (rd
->cwd
, 255) == NULL
)
8667 void read_restore (const char *eff_restore_file
, restore_data_t
*rd
)
8669 FILE *fp
= fopen (eff_restore_file
, "rb");
8673 log_error ("ERROR: restore file '%s': %s", eff_restore_file
, strerror (errno
));
8678 if (fread (rd
, sizeof (restore_data_t
), 1, fp
) != 1)
8680 log_error ("ERROR: cannot read %s", eff_restore_file
);
8685 rd
->argv
= (char **) mycalloc (rd
->argc
, sizeof (char *));
8687 for (uint i
= 0; i
< rd
->argc
; i
++)
8691 if (fgets (buf
, BUFSIZ
- 1, fp
) == NULL
)
8693 log_error ("ERROR: cannot read %s", eff_restore_file
);
8698 size_t len
= strlen (buf
);
8700 if (len
) buf
[len
- 1] = 0;
8702 rd
->argv
[i
] = mystrdup (buf
);
8709 char *nwd
= getcwd (new_cwd
, sizeof (new_cwd
));
8713 log_error ("Restore file is corrupted");
8716 if (strncmp (new_cwd
, rd
->cwd
, sizeof (new_cwd
)) != 0)
8718 if (getcwd (rd
->cwd
, sizeof (rd
->cwd
)) == NULL
)
8720 log_error ("ERROR: could not determine current user path: %s", strerror (errno
));
8725 log_info ("WARNING: Found old restore file, updating path to %s...", new_cwd
);
8729 if (chdir (rd
->cwd
))
8731 log_error ("ERROR: cannot chdir to %s: %s", rd
->cwd
, strerror (errno
));
8737 uint64_t get_lowest_words_done ()
8739 uint64_t words_cur
= -1;
8741 for (uint device_id
= 0; device_id
< data
.devices_cnt
; device_id
++)
8743 hc_device_param_t
*device_param
= &data
.devices_param
[device_id
];
8745 const uint64_t words_done
= device_param
->words_done
;
8747 if (words_done
< words_cur
) words_cur
= words_done
;
8753 void write_restore (const char *new_restore_file
, restore_data_t
*rd
)
8755 uint64_t words_cur
= get_lowest_words_done ();
8757 rd
->words_cur
= words_cur
;
8759 FILE *fp
= fopen (new_restore_file
, "wb");
8763 log_error ("ERROR: %s: %s", new_restore_file
, strerror (errno
));
8768 if (setvbuf (fp
, NULL
, _IONBF
, 0))
8770 log_error ("ERROR: setvbuf file '%s': %s", new_restore_file
, strerror (errno
));
8775 fwrite (rd
, sizeof (restore_data_t
), 1, fp
);
8777 for (uint i
= 0; i
< rd
->argc
; i
++)
8779 fprintf (fp
, "%s", rd
->argv
[i
]);
8785 fsync (fileno (fp
));
8790 void cycle_restore ()
8792 const char *eff_restore_file
= data
.eff_restore_file
;
8793 const char *new_restore_file
= data
.new_restore_file
;
8795 restore_data_t
*rd
= data
.rd
;
8797 write_restore (new_restore_file
, rd
);
8801 memset (&st
, 0, sizeof(st
));
8803 if (stat (eff_restore_file
, &st
) == 0)
8805 if (unlink (eff_restore_file
))
8807 log_info ("WARN: unlink file '%s': %s", eff_restore_file
, strerror (errno
));
8811 if (rename (new_restore_file
, eff_restore_file
))
8813 log_info ("WARN: rename file '%s' to '%s': %s", new_restore_file
, eff_restore_file
, strerror (errno
));
8817 void check_checkpoint ()
8819 // if (data.restore_disable == 1) break; (this is already implied by previous checks)
8821 uint64_t words_cur
= get_lowest_words_done ();
8823 if (words_cur
!= data
.checkpoint_cur_words
)
8833 uint
set_gpu_accel (uint hash_mode
)
8837 case 0: return GET_ACCEL (0);
8838 case 10: return GET_ACCEL (10);
8839 case 11: return GET_ACCEL (11);
8840 case 12: return GET_ACCEL (12);
8841 case 20: return GET_ACCEL (20);
8842 case 21: return GET_ACCEL (21);
8843 case 22: return GET_ACCEL (22);
8844 case 23: return GET_ACCEL (23);
8845 case 30: return GET_ACCEL (30);
8846 case 40: return GET_ACCEL (40);
8847 case 50: return GET_ACCEL (50);
8848 case 60: return GET_ACCEL (60);
8849 case 100: return GET_ACCEL (100);
8850 case 101: return GET_ACCEL (101);
8851 case 110: return GET_ACCEL (110);
8852 case 111: return GET_ACCEL (111);
8853 case 112: return GET_ACCEL (112);
8854 case 120: return GET_ACCEL (120);
8855 case 121: return GET_ACCEL (121);
8856 case 122: return GET_ACCEL (122);
8857 case 124: return GET_ACCEL (124);
8858 case 130: return GET_ACCEL (130);
8859 case 131: return GET_ACCEL (131);
8860 case 132: return GET_ACCEL (132);
8861 case 133: return GET_ACCEL (133);
8862 case 140: return GET_ACCEL (140);
8863 case 141: return GET_ACCEL (141);
8864 case 150: return GET_ACCEL (150);
8865 case 160: return GET_ACCEL (160);
8866 case 190: return GET_ACCEL (190);
8867 case 200: return GET_ACCEL (200);
8868 case 300: return GET_ACCEL (300);
8869 case 400: return GET_ACCEL (400);
8870 case 500: return GET_ACCEL (500);
8871 case 501: return GET_ACCEL (501);
8872 case 900: return GET_ACCEL (900);
8873 case 910: return GET_ACCEL (910);
8874 case 1000: return GET_ACCEL (1000);
8875 case 1100: return GET_ACCEL (1100);
8876 case 1400: return GET_ACCEL (1400);
8877 case 1410: return GET_ACCEL (1410);
8878 case 1420: return GET_ACCEL (1420);
8879 case 1421: return GET_ACCEL (1421);
8880 case 1430: return GET_ACCEL (1430);
8881 case 1440: return GET_ACCEL (1440);
8882 case 1441: return GET_ACCEL (1441);
8883 case 1450: return GET_ACCEL (1450);
8884 case 1460: return GET_ACCEL (1460);
8885 case 1500: return GET_ACCEL (1500);
8886 case 1600: return GET_ACCEL (1600);
8887 case 1700: return GET_ACCEL (1700);
8888 case 1710: return GET_ACCEL (1710);
8889 case 1711: return GET_ACCEL (1711);
8890 case 1720: return GET_ACCEL (1720);
8891 case 1722: return GET_ACCEL (1722);
8892 case 1730: return GET_ACCEL (1730);
8893 case 1731: return GET_ACCEL (1731);
8894 case 1740: return GET_ACCEL (1740);
8895 case 1750: return GET_ACCEL (1750);
8896 case 1760: return GET_ACCEL (1760);
8897 case 1800: return GET_ACCEL (1800);
8898 case 2100: return GET_ACCEL (2100);
8899 case 2400: return GET_ACCEL (2400);
8900 case 2410: return GET_ACCEL (2410);
8901 case 2500: return GET_ACCEL (2500);
8902 case 2600: return GET_ACCEL (2600);
8903 case 2611: return GET_ACCEL (2611);
8904 case 2612: return GET_ACCEL (2612);
8905 case 2711: return GET_ACCEL (2711);
8906 case 2811: return GET_ACCEL (2811);
8907 case 3000: return GET_ACCEL (3000);
8908 case 3100: return GET_ACCEL (3100);
8909 case 3200: return GET_ACCEL (3200);
8910 case 3710: return GET_ACCEL (3710);
8911 case 3711: return GET_ACCEL (3711);
8912 case 3800: return GET_ACCEL (3800);
8913 case 4300: return GET_ACCEL (4300);
8914 case 4400: return GET_ACCEL (4400);
8915 case 4500: return GET_ACCEL (4500);
8916 case 4700: return GET_ACCEL (4700);
8917 case 4800: return GET_ACCEL (4800);
8918 case 4900: return GET_ACCEL (4900);
8919 case 5000: return GET_ACCEL (5000);
8920 case 5100: return GET_ACCEL (5100);
8921 case 5200: return GET_ACCEL (5200);
8922 case 5300: return GET_ACCEL (5300);
8923 case 5400: return GET_ACCEL (5400);
8924 case 5500: return GET_ACCEL (5500);
8925 case 5600: return GET_ACCEL (5600);
8926 case 5700: return GET_ACCEL (5700);
8927 case 5800: return GET_ACCEL (5800);
8928 case 6000: return GET_ACCEL (6000);
8929 case 6100: return GET_ACCEL (6100);
8930 case 6211: return GET_ACCEL (6211);
8931 case 6212: return GET_ACCEL (6212);
8932 case 6213: return GET_ACCEL (6213);
8933 case 6221: return GET_ACCEL (6221);
8934 case 6222: return GET_ACCEL (6222);
8935 case 6223: return GET_ACCEL (6223);
8936 case 6231: return GET_ACCEL (6231);
8937 case 6232: return GET_ACCEL (6232);
8938 case 6233: return GET_ACCEL (6233);
8939 case 6241: return GET_ACCEL (6241);
8940 case 6242: return GET_ACCEL (6242);
8941 case 6243: return GET_ACCEL (6243);
8942 case 6300: return GET_ACCEL (6300);
8943 case 6400: return GET_ACCEL (6400);
8944 case 6500: return GET_ACCEL (6500);
8945 case 6600: return GET_ACCEL (6600);
8946 case 6700: return GET_ACCEL (6700);
8947 case 6800: return GET_ACCEL (6800);
8948 case 6900: return GET_ACCEL (6900);
8949 case 7100: return GET_ACCEL (7100);
8950 case 7200: return GET_ACCEL (7200);
8951 case 7300: return GET_ACCEL (7300);
8952 case 7400: return GET_ACCEL (7400);
8953 case 7500: return GET_ACCEL (7500);
8954 case 7600: return GET_ACCEL (7600);
8955 case 7700: return GET_ACCEL (7700);
8956 case 7800: return GET_ACCEL (7800);
8957 case 7900: return GET_ACCEL (7900);
8958 case 8000: return GET_ACCEL (8000);
8959 case 8100: return GET_ACCEL (8100);
8960 case 8200: return GET_ACCEL (8200);
8961 case 8300: return GET_ACCEL (8300);
8962 case 8400: return GET_ACCEL (8400);
8963 case 8500: return GET_ACCEL (8500);
8964 case 8600: return GET_ACCEL (8600);
8965 case 8700: return GET_ACCEL (8700);
8966 case 8800: return GET_ACCEL (8800);
8967 case 8900: return GET_ACCEL (8900);
8968 case 9000: return GET_ACCEL (9000);
8969 case 9100: return GET_ACCEL (9100);
8970 case 9200: return GET_ACCEL (9200);
8971 case 9300: return GET_ACCEL (9300);
8972 case 9400: return GET_ACCEL (9400);
8973 case 9500: return GET_ACCEL (9500);
8974 case 9600: return GET_ACCEL (9600);
8975 case 9700: return GET_ACCEL (9700);
8976 case 9710: return GET_ACCEL (9710);
8977 case 9720: return GET_ACCEL (9720);
8978 case 9800: return GET_ACCEL (9800);
8979 case 9810: return GET_ACCEL (9810);
8980 case 9820: return GET_ACCEL (9820);
8981 case 9900: return GET_ACCEL (9900);
8982 case 10000: return GET_ACCEL (10000);
8983 case 10100: return GET_ACCEL (10100);
8984 case 10200: return GET_ACCEL (10200);
8985 case 10300: return GET_ACCEL (10300);
8986 case 10400: return GET_ACCEL (10400);
8987 case 10410: return GET_ACCEL (10410);
8988 case 10420: return GET_ACCEL (10420);
8989 case 10500: return GET_ACCEL (10500);
8990 case 10600: return GET_ACCEL (10600);
8991 case 10700: return GET_ACCEL (10700);
8992 case 10800: return GET_ACCEL (10800);
8993 case 10900: return GET_ACCEL (10900);
8994 case 11000: return GET_ACCEL (11000);
8995 case 11100: return GET_ACCEL (11100);
8996 case 11200: return GET_ACCEL (11200);
8997 case 11300: return GET_ACCEL (11300);
8998 case 11400: return GET_ACCEL (11400);
8999 case 11500: return GET_ACCEL (11500);
9000 case 11600: return GET_ACCEL (11600);
9001 case 11700: return GET_ACCEL (11700);
9002 case 11800: return GET_ACCEL (11800);
9003 case 11900: return GET_ACCEL (11900);
9004 case 12000: return GET_ACCEL (12000);
9005 case 12100: return GET_ACCEL (12100);
9006 case 12200: return GET_ACCEL (12200);
9007 case 12300: return GET_ACCEL (12300);
9008 case 12400: return GET_ACCEL (12400);
9009 case 12500: return GET_ACCEL (12500);
9010 case 12600: return GET_ACCEL (12600);
9011 case 12700: return GET_ACCEL (12700);
9012 case 12800: return GET_ACCEL (12800);
9018 uint
set_gpu_loops (uint hash_mode
)
9022 case 0: return GET_LOOPS (0);
9023 case 10: return GET_LOOPS (10);
9024 case 11: return GET_LOOPS (11);
9025 case 12: return GET_LOOPS (12);
9026 case 20: return GET_LOOPS (20);
9027 case 21: return GET_LOOPS (21);
9028 case 22: return GET_LOOPS (22);
9029 case 23: return GET_LOOPS (23);
9030 case 30: return GET_LOOPS (30);
9031 case 40: return GET_LOOPS (40);
9032 case 50: return GET_LOOPS (50);
9033 case 60: return GET_LOOPS (60);
9034 case 100: return GET_LOOPS (100);
9035 case 101: return GET_LOOPS (101);
9036 case 110: return GET_LOOPS (110);
9037 case 111: return GET_LOOPS (111);
9038 case 112: return GET_LOOPS (112);
9039 case 120: return GET_LOOPS (120);
9040 case 121: return GET_LOOPS (121);
9041 case 122: return GET_LOOPS (122);
9042 case 124: return GET_LOOPS (124);
9043 case 130: return GET_LOOPS (130);
9044 case 131: return GET_LOOPS (131);
9045 case 132: return GET_LOOPS (132);
9046 case 133: return GET_LOOPS (133);
9047 case 140: return GET_LOOPS (140);
9048 case 141: return GET_LOOPS (141);
9049 case 150: return GET_LOOPS (150);
9050 case 160: return GET_LOOPS (160);
9051 case 190: return GET_LOOPS (190);
9052 case 200: return GET_LOOPS (200);
9053 case 300: return GET_LOOPS (300);
9054 case 400: return GET_LOOPS (400);
9055 case 500: return GET_LOOPS (500);
9056 case 501: return GET_LOOPS (501);
9057 case 900: return GET_LOOPS (900);
9058 case 910: return GET_LOOPS (910);
9059 case 1000: return GET_LOOPS (1000);
9060 case 1100: return GET_LOOPS (1100);
9061 case 1400: return GET_LOOPS (1400);
9062 case 1410: return GET_LOOPS (1410);
9063 case 1420: return GET_LOOPS (1420);
9064 case 1421: return GET_LOOPS (1421);
9065 case 1430: return GET_LOOPS (1430);
9066 case 1440: return GET_LOOPS (1440);
9067 case 1441: return GET_LOOPS (1441);
9068 case 1450: return GET_LOOPS (1450);
9069 case 1460: return GET_LOOPS (1460);
9070 case 1500: return GET_LOOPS (1500);
9071 case 1600: return GET_LOOPS (1600);
9072 case 1700: return GET_LOOPS (1700);
9073 case 1710: return GET_LOOPS (1710);
9074 case 1711: return GET_LOOPS (1711);
9075 case 1720: return GET_LOOPS (1720);
9076 case 1722: return GET_LOOPS (1722);
9077 case 1730: return GET_LOOPS (1730);
9078 case 1731: return GET_LOOPS (1731);
9079 case 1740: return GET_LOOPS (1740);
9080 case 1750: return GET_LOOPS (1750);
9081 case 1760: return GET_LOOPS (1760);
9082 case 1800: return GET_LOOPS (1800);
9083 case 2100: return GET_LOOPS (2100);
9084 case 2400: return GET_LOOPS (2400);
9085 case 2410: return GET_LOOPS (2410);
9086 case 2500: return GET_LOOPS (2500);
9087 case 2600: return GET_LOOPS (2600);
9088 case 2611: return GET_LOOPS (2611);
9089 case 2612: return GET_LOOPS (2612);
9090 case 2711: return GET_LOOPS (2711);
9091 case 2811: return GET_LOOPS (2811);
9092 case 3000: return GET_LOOPS (3000);
9093 case 3100: return GET_LOOPS (3100);
9094 case 3200: return GET_LOOPS (3200);
9095 case 3710: return GET_LOOPS (3710);
9096 case 3711: return GET_LOOPS (3711);
9097 case 3800: return GET_LOOPS (3800);
9098 case 4300: return GET_LOOPS (4300);
9099 case 4400: return GET_LOOPS (4400);
9100 case 4500: return GET_LOOPS (4500);
9101 case 4700: return GET_LOOPS (4700);
9102 case 4800: return GET_LOOPS (4800);
9103 case 4900: return GET_LOOPS (4900);
9104 case 5000: return GET_LOOPS (5000);
9105 case 5100: return GET_LOOPS (5100);
9106 case 5200: return GET_LOOPS (5200);
9107 case 5300: return GET_LOOPS (5300);
9108 case 5400: return GET_LOOPS (5400);
9109 case 5500: return GET_LOOPS (5500);
9110 case 5600: return GET_LOOPS (5600);
9111 case 5700: return GET_LOOPS (5700);
9112 case 5800: return GET_LOOPS (5800);
9113 case 6000: return GET_LOOPS (6000);
9114 case 6100: return GET_LOOPS (6100);
9115 case 6211: return GET_LOOPS (6211);
9116 case 6212: return GET_LOOPS (6212);
9117 case 6213: return GET_LOOPS (6213);
9118 case 6221: return GET_LOOPS (6221);
9119 case 6222: return GET_LOOPS (6222);
9120 case 6223: return GET_LOOPS (6223);
9121 case 6231: return GET_LOOPS (6231);
9122 case 6232: return GET_LOOPS (6232);
9123 case 6233: return GET_LOOPS (6233);
9124 case 6241: return GET_LOOPS (6241);
9125 case 6242: return GET_LOOPS (6242);
9126 case 6243: return GET_LOOPS (6243);
9127 case 6300: return GET_LOOPS (6300);
9128 case 6400: return GET_LOOPS (6400);
9129 case 6500: return GET_LOOPS (6500);
9130 case 6600: return GET_LOOPS (6600);
9131 case 6700: return GET_LOOPS (6700);
9132 case 6800: return GET_LOOPS (6800);
9133 case 6900: return GET_LOOPS (6900);
9134 case 7100: return GET_LOOPS (7100);
9135 case 7200: return GET_LOOPS (7200);
9136 case 7300: return GET_LOOPS (7300);
9137 case 7400: return GET_LOOPS (7400);
9138 case 7500: return GET_LOOPS (7500);
9139 case 7600: return GET_LOOPS (7600);
9140 case 7700: return GET_LOOPS (7700);
9141 case 7800: return GET_LOOPS (7800);
9142 case 7900: return GET_LOOPS (7900);
9143 case 8000: return GET_LOOPS (8000);
9144 case 8100: return GET_LOOPS (8100);
9145 case 8200: return GET_LOOPS (8200);
9146 case 8300: return GET_LOOPS (8300);
9147 case 8400: return GET_LOOPS (8400);
9148 case 8500: return GET_LOOPS (8500);
9149 case 8600: return GET_LOOPS (8600);
9150 case 8700: return GET_LOOPS (8700);
9151 case 8800: return GET_LOOPS (8800);
9152 case 8900: return GET_LOOPS (8900);
9153 case 9000: return GET_LOOPS (9000);
9154 case 9100: return GET_LOOPS (9100);
9155 case 9200: return GET_LOOPS (9200);
9156 case 9300: return GET_LOOPS (9300);
9157 case 9400: return GET_LOOPS (9400);
9158 case 9500: return GET_LOOPS (9500);
9159 case 9600: return GET_LOOPS (9600);
9160 case 9700: return GET_LOOPS (9700);
9161 case 9710: return GET_LOOPS (9710);
9162 case 9720: return GET_LOOPS (9720);
9163 case 9800: return GET_LOOPS (9800);
9164 case 9810: return GET_LOOPS (9810);
9165 case 9820: return GET_LOOPS (9820);
9166 case 9900: return GET_LOOPS (9900);
9167 case 10000: return GET_LOOPS (10000);
9168 case 10100: return GET_LOOPS (10100);
9169 case 10200: return GET_LOOPS (10200);
9170 case 10300: return GET_LOOPS (10300);
9171 case 10400: return GET_LOOPS (10400);
9172 case 10410: return GET_LOOPS (10410);
9173 case 10420: return GET_LOOPS (10420);
9174 case 10500: return GET_LOOPS (10500);
9175 case 10600: return GET_LOOPS (10600);
9176 case 10700: return GET_LOOPS (10700);
9177 case 10800: return GET_LOOPS (10800);
9178 case 10900: return GET_LOOPS (10900);
9179 case 11000: return GET_LOOPS (11000);
9180 case 11100: return GET_LOOPS (11100);
9181 case 11200: return GET_LOOPS (11200);
9182 case 11300: return GET_LOOPS (11300);
9183 case 11400: return GET_LOOPS (11400);
9184 case 11500: return GET_LOOPS (11500);
9185 case 11600: return GET_LOOPS (11600);
9186 case 11700: return GET_LOOPS (11700);
9187 case 11800: return GET_LOOPS (11800);
9188 case 11900: return GET_LOOPS (11900);
9189 case 12000: return GET_LOOPS (12000);
9190 case 12100: return GET_LOOPS (12100);
9191 case 12200: return GET_LOOPS (12200);
9192 case 12300: return GET_LOOPS (12300);
9193 case 12400: return GET_LOOPS (12400);
9194 case 12500: return GET_LOOPS (12500);
9195 case 12600: return GET_LOOPS (12600);
9196 case 12700: return GET_LOOPS (12700);
9197 case 12800: return GET_LOOPS (12800);
9207 uint
parse_and_store_salt (char *out
, char *in
, uint salt_len
)
9211 if (salt_len
> sizeof(tmp
))
9216 memset (tmp
, 0, sizeof (tmp
));
9217 memcpy (tmp
, in
, salt_len
);
9219 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9221 if ((salt_len
% 2) == 0)
9223 uint new_salt_len
= salt_len
/ 2;
9225 for (uint i
= 0, j
= 0; i
< new_salt_len
; i
+= 1, j
+= 2)
9227 char p0
= tmp
[j
+ 0];
9228 char p1
= tmp
[j
+ 1];
9230 tmp
[i
] = hex_convert (p1
) << 0;
9231 tmp
[i
] |= hex_convert (p0
) << 4;
9234 salt_len
= new_salt_len
;
9241 else if (data
.opts_type
& OPTS_TYPE_ST_BASE64
)
9243 salt_len
= base64_decode (base64_to_int
, in
, salt_len
, tmp
);
9246 memset (tmp
+ salt_len
, 0, sizeof (tmp
) - salt_len
);
9248 if (data
.opts_type
& OPTS_TYPE_ST_UNICODE
)
9252 uint
*tmp_uint
= (uint
*) tmp
;
9254 tmp_uint
[9] = ((tmp_uint
[4] >> 8) & 0x00FF0000) | ((tmp_uint
[4] >> 16) & 0x000000FF);
9255 tmp_uint
[8] = ((tmp_uint
[4] << 8) & 0x00FF0000) | ((tmp_uint
[4] >> 0) & 0x000000FF);
9256 tmp_uint
[7] = ((tmp_uint
[3] >> 8) & 0x00FF0000) | ((tmp_uint
[3] >> 16) & 0x000000FF);
9257 tmp_uint
[6] = ((tmp_uint
[3] << 8) & 0x00FF0000) | ((tmp_uint
[3] >> 0) & 0x000000FF);
9258 tmp_uint
[5] = ((tmp_uint
[2] >> 8) & 0x00FF0000) | ((tmp_uint
[2] >> 16) & 0x000000FF);
9259 tmp_uint
[4] = ((tmp_uint
[2] << 8) & 0x00FF0000) | ((tmp_uint
[2] >> 0) & 0x000000FF);
9260 tmp_uint
[3] = ((tmp_uint
[1] >> 8) & 0x00FF0000) | ((tmp_uint
[1] >> 16) & 0x000000FF);
9261 tmp_uint
[2] = ((tmp_uint
[1] << 8) & 0x00FF0000) | ((tmp_uint
[1] >> 0) & 0x000000FF);
9262 tmp_uint
[1] = ((tmp_uint
[0] >> 8) & 0x00FF0000) | ((tmp_uint
[0] >> 16) & 0x000000FF);
9263 tmp_uint
[0] = ((tmp_uint
[0] << 8) & 0x00FF0000) | ((tmp_uint
[0] >> 0) & 0x000000FF);
9265 salt_len
= salt_len
* 2;
9273 if (data
.opts_type
& OPTS_TYPE_ST_LOWER
)
9275 lowercase (tmp
, salt_len
);
9278 if (data
.opts_type
& OPTS_TYPE_ST_UPPER
)
9280 uppercase (tmp
, salt_len
);
9283 uint len
= salt_len
;
9285 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
9290 if (data
.opts_type
& OPTS_TYPE_ST_ADD01
)
9295 if (data
.opts_type
& OPTS_TYPE_ST_GENERATE_LE
)
9297 uint
*tmp_uint
= (uint
*) tmp
;
9303 for (uint i
= 0; i
< max
; i
++)
9305 tmp_uint
[i
] = byte_swap_32 (tmp_uint
[i
]);
9308 // Important: we may need to increase the length of memcpy since
9309 // we don't want to "loose" some swapped bytes (could happen if
9310 // they do not perfectly fit in the 4-byte blocks)
9311 // Memcpy does always copy the bytes in the BE order, but since
9312 // we swapped them, some important bytes could be in positions
9313 // we normally skip with the original len
9315 if (len
% 4) len
+= 4 - (len
% 4);
9318 memcpy (out
, tmp
, len
);
9323 int bcrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9325 if ((input_len
< DISPLAY_LEN_MIN_3200
) || (input_len
> DISPLAY_LEN_MAX_3200
)) return (PARSER_GLOBAL_LENGTH
);
9327 if ((memcmp (SIGNATURE_BCRYPT1
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT2
, input_buf
, 4)) && (memcmp (SIGNATURE_BCRYPT3
, input_buf
, 4))) return (PARSER_SIGNATURE_UNMATCHED
);
9329 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9331 salt_t
*salt
= hash_buf
->salt
;
9333 memcpy ((char *) salt
->salt_sign
, input_buf
, 6);
9335 char *iter_pos
= input_buf
+ 4;
9337 salt
->salt_iter
= 1 << atoi (iter_pos
);
9339 char *salt_pos
= strchr (iter_pos
, '$');
9341 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9347 salt
->salt_len
= salt_len
;
9351 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9353 base64_decode (bf64_to_int
, salt_pos
, 22, tmp_buf
);
9355 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9357 memcpy (salt_buf_ptr
, tmp_buf
, 16);
9359 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
9360 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
9361 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
9362 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
9364 char *hash_pos
= salt_pos
+ 22;
9366 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9368 base64_decode (bf64_to_int
, hash_pos
, 31, tmp_buf
);
9370 memcpy (digest
, tmp_buf
, 24);
9372 digest
[0] = byte_swap_32 (digest
[0]);
9373 digest
[1] = byte_swap_32 (digest
[1]);
9374 digest
[2] = byte_swap_32 (digest
[2]);
9375 digest
[3] = byte_swap_32 (digest
[3]);
9376 digest
[4] = byte_swap_32 (digest
[4]);
9377 digest
[5] = byte_swap_32 (digest
[5]);
9379 digest
[5] &= ~0xff; // its just 23 not 24 !
9384 int cisco4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9386 if ((input_len
< DISPLAY_LEN_MIN_5700
) || (input_len
> DISPLAY_LEN_MAX_5700
)) return (PARSER_GLOBAL_LENGTH
);
9388 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9392 memset (tmp_buf
, 0, sizeof (tmp_buf
));
9394 base64_decode (itoa64_to_int
, input_buf
, 43, tmp_buf
);
9396 memcpy (digest
, tmp_buf
, 32);
9398 digest
[0] = byte_swap_32 (digest
[0]);
9399 digest
[1] = byte_swap_32 (digest
[1]);
9400 digest
[2] = byte_swap_32 (digest
[2]);
9401 digest
[3] = byte_swap_32 (digest
[3]);
9402 digest
[4] = byte_swap_32 (digest
[4]);
9403 digest
[5] = byte_swap_32 (digest
[5]);
9404 digest
[6] = byte_swap_32 (digest
[6]);
9405 digest
[7] = byte_swap_32 (digest
[7]);
9407 digest
[0] -= SHA256M_A
;
9408 digest
[1] -= SHA256M_B
;
9409 digest
[2] -= SHA256M_C
;
9410 digest
[3] -= SHA256M_D
;
9411 digest
[4] -= SHA256M_E
;
9412 digest
[5] -= SHA256M_F
;
9413 digest
[6] -= SHA256M_G
;
9414 digest
[7] -= SHA256M_H
;
9419 int lm_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9421 if ((input_len
< DISPLAY_LEN_MIN_3000
) || (input_len
> DISPLAY_LEN_MAX_3000
)) return (PARSER_GLOBAL_LENGTH
);
9423 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9425 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9426 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9428 digest
[0] = byte_swap_32 (digest
[0]);
9429 digest
[1] = byte_swap_32 (digest
[1]);
9433 IP (digest
[0], digest
[1], tt
);
9435 digest
[0] = digest
[0];
9436 digest
[1] = digest
[1];
9443 int osx1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9445 if ((input_len
< DISPLAY_LEN_MIN_122
) || (input_len
> DISPLAY_LEN_MAX_122
)) return (PARSER_GLOBAL_LENGTH
);
9447 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9449 salt_t
*salt
= hash_buf
->salt
;
9451 char *hash_pos
= input_buf
+ 8;
9453 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
9454 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
9455 digest
[2] = hex_to_uint (&hash_pos
[16]);
9456 digest
[3] = hex_to_uint (&hash_pos
[24]);
9457 digest
[4] = hex_to_uint (&hash_pos
[32]);
9459 digest
[0] -= SHA1M_A
;
9460 digest
[1] -= SHA1M_B
;
9461 digest
[2] -= SHA1M_C
;
9462 digest
[3] -= SHA1M_D
;
9463 digest
[4] -= SHA1M_E
;
9467 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9469 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9471 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9473 salt
->salt_len
= salt_len
;
9478 int osx512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9480 if ((input_len
< DISPLAY_LEN_MIN_1722
) || (input_len
> DISPLAY_LEN_MAX_1722
)) return (PARSER_GLOBAL_LENGTH
);
9482 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
9484 salt_t
*salt
= hash_buf
->salt
;
9486 char *hash_pos
= input_buf
+ 8;
9488 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
9489 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
9490 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
9491 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
9492 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
9493 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
9494 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
9495 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
9497 digest
[0] -= SHA512M_A
;
9498 digest
[1] -= SHA512M_B
;
9499 digest
[2] -= SHA512M_C
;
9500 digest
[3] -= SHA512M_D
;
9501 digest
[4] -= SHA512M_E
;
9502 digest
[5] -= SHA512M_F
;
9503 digest
[6] -= SHA512M_G
;
9504 digest
[7] -= SHA512M_H
;
9508 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9510 salt_len
= parse_and_store_salt (salt_buf_ptr
, input_buf
, salt_len
);
9512 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9514 salt
->salt_len
= salt_len
;
9519 int osc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9521 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9523 if ((input_len
< DISPLAY_LEN_MIN_21H
) || (input_len
> DISPLAY_LEN_MAX_21H
)) return (PARSER_GLOBAL_LENGTH
);
9527 if ((input_len
< DISPLAY_LEN_MIN_21
) || (input_len
> DISPLAY_LEN_MAX_21
)) return (PARSER_GLOBAL_LENGTH
);
9530 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9532 salt_t
*salt
= hash_buf
->salt
;
9534 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9535 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9536 digest
[2] = hex_to_uint (&input_buf
[16]);
9537 digest
[3] = hex_to_uint (&input_buf
[24]);
9539 digest
[0] = byte_swap_32 (digest
[0]);
9540 digest
[1] = byte_swap_32 (digest
[1]);
9541 digest
[2] = byte_swap_32 (digest
[2]);
9542 digest
[3] = byte_swap_32 (digest
[3]);
9544 digest
[0] -= MD5M_A
;
9545 digest
[1] -= MD5M_B
;
9546 digest
[2] -= MD5M_C
;
9547 digest
[3] -= MD5M_D
;
9549 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9551 uint salt_len
= input_len
- 32 - 1;
9553 char *salt_buf
= input_buf
+ 32 + 1;
9555 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9557 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9559 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9561 salt
->salt_len
= salt_len
;
9566 int netscreen_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9568 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9570 if ((input_len
< DISPLAY_LEN_MIN_22H
) || (input_len
> DISPLAY_LEN_MAX_22H
)) return (PARSER_GLOBAL_LENGTH
);
9574 if ((input_len
< DISPLAY_LEN_MIN_22
) || (input_len
> DISPLAY_LEN_MAX_22
)) return (PARSER_GLOBAL_LENGTH
);
9579 char clean_input_buf
[32];
9581 char sig
[6] = { 'n', 'r', 'c', 's', 't', 'n' };
9582 int pos
[6] = { 0, 6, 12, 17, 23, 29 };
9584 for (int i
= 0, j
= 0, k
= 0; i
< 30; i
++)
9588 if (sig
[j
] != input_buf
[i
]) return (PARSER_SIGNATURE_UNMATCHED
);
9594 clean_input_buf
[k
] = input_buf
[i
];
9602 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9604 salt_t
*salt
= hash_buf
->salt
;
9606 char a
, b
, c
, d
, e
, f
;
9608 a
= base64_to_int (clean_input_buf
[ 0] & 0x7f);
9609 b
= base64_to_int (clean_input_buf
[ 1] & 0x7f);
9610 c
= base64_to_int (clean_input_buf
[ 2] & 0x7f);
9611 d
= base64_to_int (clean_input_buf
[ 3] & 0x7f);
9612 e
= base64_to_int (clean_input_buf
[ 4] & 0x7f);
9613 f
= base64_to_int (clean_input_buf
[ 5] & 0x7f);
9615 digest
[0] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9616 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9618 a
= base64_to_int (clean_input_buf
[ 6] & 0x7f);
9619 b
= base64_to_int (clean_input_buf
[ 7] & 0x7f);
9620 c
= base64_to_int (clean_input_buf
[ 8] & 0x7f);
9621 d
= base64_to_int (clean_input_buf
[ 9] & 0x7f);
9622 e
= base64_to_int (clean_input_buf
[10] & 0x7f);
9623 f
= base64_to_int (clean_input_buf
[11] & 0x7f);
9625 digest
[1] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9626 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9628 a
= base64_to_int (clean_input_buf
[12] & 0x7f);
9629 b
= base64_to_int (clean_input_buf
[13] & 0x7f);
9630 c
= base64_to_int (clean_input_buf
[14] & 0x7f);
9631 d
= base64_to_int (clean_input_buf
[15] & 0x7f);
9632 e
= base64_to_int (clean_input_buf
[16] & 0x7f);
9633 f
= base64_to_int (clean_input_buf
[17] & 0x7f);
9635 digest
[2] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9636 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9638 a
= base64_to_int (clean_input_buf
[18] & 0x7f);
9639 b
= base64_to_int (clean_input_buf
[19] & 0x7f);
9640 c
= base64_to_int (clean_input_buf
[20] & 0x7f);
9641 d
= base64_to_int (clean_input_buf
[21] & 0x7f);
9642 e
= base64_to_int (clean_input_buf
[22] & 0x7f);
9643 f
= base64_to_int (clean_input_buf
[23] & 0x7f);
9645 digest
[3] = (((a
<< 12) | (b
<< 6) | (c
)) << 16)
9646 | (((d
<< 12) | (e
<< 6) | (f
)) << 0);
9648 digest
[0] = byte_swap_32 (digest
[0]);
9649 digest
[1] = byte_swap_32 (digest
[1]);
9650 digest
[2] = byte_swap_32 (digest
[2]);
9651 digest
[3] = byte_swap_32 (digest
[3]);
9653 digest
[0] -= MD5M_A
;
9654 digest
[1] -= MD5M_B
;
9655 digest
[2] -= MD5M_C
;
9656 digest
[3] -= MD5M_D
;
9658 if (input_buf
[30] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
9660 uint salt_len
= input_len
- 30 - 1;
9662 char *salt_buf
= input_buf
+ 30 + 1;
9664 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9666 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9668 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9670 salt
->salt_len
= salt_len
;
9672 memcpy (salt_buf_ptr
+ salt_len
, ":Administration Tools:", 22);
9674 salt
->salt_len
+= 22;
9679 int smf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9681 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9683 if ((input_len
< DISPLAY_LEN_MIN_121H
) || (input_len
> DISPLAY_LEN_MAX_121H
)) return (PARSER_GLOBAL_LENGTH
);
9687 if ((input_len
< DISPLAY_LEN_MIN_121
) || (input_len
> DISPLAY_LEN_MAX_121
)) return (PARSER_GLOBAL_LENGTH
);
9690 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9692 salt_t
*salt
= hash_buf
->salt
;
9694 digest
[0] = hex_to_uint (&input_buf
[ 0]);
9695 digest
[1] = hex_to_uint (&input_buf
[ 8]);
9696 digest
[2] = hex_to_uint (&input_buf
[16]);
9697 digest
[3] = hex_to_uint (&input_buf
[24]);
9698 digest
[4] = hex_to_uint (&input_buf
[32]);
9700 digest
[0] -= SHA1M_A
;
9701 digest
[1] -= SHA1M_B
;
9702 digest
[2] -= SHA1M_C
;
9703 digest
[3] -= SHA1M_D
;
9704 digest
[4] -= SHA1M_E
;
9706 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
9708 uint salt_len
= input_len
- 40 - 1;
9710 char *salt_buf
= input_buf
+ 40 + 1;
9712 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9714 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
9716 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9718 salt
->salt_len
= salt_len
;
9723 int dcc2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9725 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
9727 if ((input_len
< DISPLAY_LEN_MIN_2100H
) || (input_len
> DISPLAY_LEN_MAX_2100H
)) return (PARSER_GLOBAL_LENGTH
);
9731 if ((input_len
< DISPLAY_LEN_MIN_2100
) || (input_len
> DISPLAY_LEN_MAX_2100
)) return (PARSER_GLOBAL_LENGTH
);
9734 if (memcmp (SIGNATURE_DCC2
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
9736 char *iter_pos
= input_buf
+ 6;
9738 salt_t
*salt
= hash_buf
->salt
;
9740 salt
->salt_iter
= atoi (iter_pos
) - 1;
9742 char *salt_pos
= strchr (iter_pos
, '#');
9744 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9748 char *digest_pos
= strchr (salt_pos
, '#');
9750 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
9754 uint salt_len
= digest_pos
- salt_pos
- 1;
9756 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9758 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
9759 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
9760 digest
[2] = hex_to_uint (&digest_pos
[16]);
9761 digest
[3] = hex_to_uint (&digest_pos
[24]);
9763 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
9765 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
9767 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
9769 salt
->salt_len
= salt_len
;
9774 int wpa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9776 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9778 salt_t
*salt
= hash_buf
->salt
;
9780 wpa_t
*wpa
= (wpa_t
*) hash_buf
->esalt
;
9784 memcpy (&in
, input_buf
, input_len
);
9786 if (in
.eapol_size
< 1 || in
.eapol_size
> 255) return (PARSER_HCCAP_EAPOL_SIZE
);
9788 memcpy (digest
, in
.keymic
, 16);
9791 http://www.one-net.eu/jsw/j_sec/m_ptype.html
9792 The phrase "Pairwise key expansion"
9793 Access Point Address (Referred to as Authenticator Address AA)
9794 Supplicant Address (referred to as Supplicant Address SA)
9795 Access Point Nonce (referred to as Authenticator Anonce)
9796 Wireless Device Nonce (referred to as Supplicant Nonce Snonce)
9799 uint salt_len
= strlen (in
.essid
);
9801 memcpy (salt
->salt_buf
, in
.essid
, salt_len
);
9803 salt
->salt_len
= salt_len
;
9805 salt
->salt_iter
= ROUNDS_WPA2
- 1;
9807 unsigned char *pke_ptr
= (unsigned char *) wpa
->pke
;
9809 memcpy (pke_ptr
, "Pairwise key expansion", 23);
9811 if (memcmp (in
.mac1
, in
.mac2
, 6) < 0)
9813 memcpy (pke_ptr
+ 23, in
.mac1
, 6);
9814 memcpy (pke_ptr
+ 29, in
.mac2
, 6);
9818 memcpy (pke_ptr
+ 23, in
.mac2
, 6);
9819 memcpy (pke_ptr
+ 29, in
.mac1
, 6);
9822 if (memcmp (in
.nonce1
, in
.nonce2
, 32) < 0)
9824 memcpy (pke_ptr
+ 35, in
.nonce1
, 32);
9825 memcpy (pke_ptr
+ 67, in
.nonce2
, 32);
9829 memcpy (pke_ptr
+ 35, in
.nonce2
, 32);
9830 memcpy (pke_ptr
+ 67, in
.nonce1
, 32);
9833 for (int i
= 0; i
< 25; i
++)
9835 wpa
->pke
[i
] = byte_swap_32 (wpa
->pke
[i
]);
9838 wpa
->keyver
= in
.keyver
;
9840 if (wpa
->keyver
> 255)
9842 log_info ("ATTENTION!");
9843 log_info (" The WPA/WPA2 key version in your .hccap file is invalid!");
9844 log_info (" This could be due to a recent aircrack-ng bug.");
9845 log_info (" The key version was automatically reset to a reasonable value.");
9848 wpa
->keyver
&= 0xff;
9851 wpa
->eapol_size
= in
.eapol_size
;
9853 unsigned char *eapol_ptr
= (unsigned char *) wpa
->eapol
;
9855 memcpy (eapol_ptr
, in
.eapol
, wpa
->eapol_size
);
9857 memset (eapol_ptr
+ wpa
->eapol_size
, 0, 256 - wpa
->eapol_size
);
9859 eapol_ptr
[wpa
->eapol_size
] = (unsigned char) 0x80;
9861 if (wpa
->keyver
== 1)
9867 digest
[0] = byte_swap_32 (digest
[0]);
9868 digest
[1] = byte_swap_32 (digest
[1]);
9869 digest
[2] = byte_swap_32 (digest
[2]);
9870 digest
[3] = byte_swap_32 (digest
[3]);
9872 for (int i
= 0; i
< 64; i
++)
9874 wpa
->eapol
[i
] = byte_swap_32 (wpa
->eapol
[i
]);
9878 salt
->salt_buf
[10] = digest
[1];
9879 salt
->salt_buf
[11] = digest
[2];
9884 int psafe2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9886 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9888 salt_t
*salt
= hash_buf
->salt
;
9892 log_error ("Password Safe v2 container not specified");
9897 FILE *fp
= fopen (input_buf
, "rb");
9901 log_error ("%s: %s", input_buf
, strerror (errno
));
9910 uint32_t salt
[5]; // unused, but makes better valid check
9911 uint32_t iv
[2]; // unused, but makes better valid check
9917 int n
= fread (&buf
, sizeof (psafe2_hdr
), 1, fp
);
9921 if (n
!= 1) return (PARSER_PSAFE2_FILE_SIZE
);
9923 salt
->salt_buf
[0] = buf
.random
[0];
9924 salt
->salt_buf
[1] = buf
.random
[1];
9927 salt
->salt_iter
= 1000;
9929 digest
[0] = byte_swap_32 (buf
.hash
[0]);
9930 digest
[1] = byte_swap_32 (buf
.hash
[1]);
9931 digest
[2] = byte_swap_32 (buf
.hash
[2]);
9932 digest
[3] = byte_swap_32 (buf
.hash
[3]);
9933 digest
[4] = byte_swap_32 (buf
.hash
[4]);
9938 int psafe3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
9940 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
9942 salt_t
*salt
= hash_buf
->salt
;
9946 log_error (".psafe3 not specified");
9951 FILE *fp
= fopen (input_buf
, "rb");
9955 log_error ("%s: %s", input_buf
, strerror (errno
));
9962 int n
= fread (&in
, sizeof (psafe3_t
), 1, fp
);
9966 data
.hashfile
= input_buf
; // we will need this in case it gets cracked
9968 if (memcmp (SIGNATURE_PSAFE3
, in
.signature
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
9970 if (n
!= 1) return (PARSER_PSAFE3_FILE_SIZE
);
9972 salt
->salt_iter
= in
.iterations
+ 1;
9974 salt
->salt_buf
[0] = in
.salt_buf
[0];
9975 salt
->salt_buf
[1] = in
.salt_buf
[1];
9976 salt
->salt_buf
[2] = in
.salt_buf
[2];
9977 salt
->salt_buf
[3] = in
.salt_buf
[3];
9978 salt
->salt_buf
[4] = in
.salt_buf
[4];
9979 salt
->salt_buf
[5] = in
.salt_buf
[5];
9980 salt
->salt_buf
[6] = in
.salt_buf
[6];
9981 salt
->salt_buf
[7] = in
.salt_buf
[7];
9983 salt
->salt_len
= 32;
9985 digest
[0] = in
.hash_buf
[0];
9986 digest
[1] = in
.hash_buf
[1];
9987 digest
[2] = in
.hash_buf
[2];
9988 digest
[3] = in
.hash_buf
[3];
9989 digest
[4] = in
.hash_buf
[4];
9990 digest
[5] = in
.hash_buf
[5];
9991 digest
[6] = in
.hash_buf
[6];
9992 digest
[7] = in
.hash_buf
[7];
9994 digest
[0] = byte_swap_32 (digest
[0]);
9995 digest
[1] = byte_swap_32 (digest
[1]);
9996 digest
[2] = byte_swap_32 (digest
[2]);
9997 digest
[3] = byte_swap_32 (digest
[3]);
9998 digest
[4] = byte_swap_32 (digest
[4]);
9999 digest
[5] = byte_swap_32 (digest
[5]);
10000 digest
[6] = byte_swap_32 (digest
[6]);
10001 digest
[7] = byte_swap_32 (digest
[7]);
10003 return (PARSER_OK
);
10006 int phpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10008 if ((input_len
< DISPLAY_LEN_MIN_400
) || (input_len
> DISPLAY_LEN_MAX_400
)) return (PARSER_GLOBAL_LENGTH
);
10010 if ((memcmp (SIGNATURE_PHPASS1
, input_buf
, 3)) && (memcmp (SIGNATURE_PHPASS2
, input_buf
, 3))) return (PARSER_SIGNATURE_UNMATCHED
);
10012 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10014 salt_t
*salt
= hash_buf
->salt
;
10016 char *iter_pos
= input_buf
+ 3;
10018 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
10020 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
10022 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
10024 salt
->salt_iter
= salt_iter
;
10026 char *salt_pos
= iter_pos
+ 1;
10030 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10032 salt
->salt_len
= salt_len
;
10034 char *hash_pos
= salt_pos
+ salt_len
;
10036 phpass_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10038 return (PARSER_OK
);
10041 int md5crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10043 if (memcmp (SIGNATURE_MD5CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
10045 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10047 salt_t
*salt
= hash_buf
->salt
;
10049 char *salt_pos
= input_buf
+ 3;
10051 uint iterations_len
= 0;
10053 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10057 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10059 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10060 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10064 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10068 iterations_len
+= 8;
10072 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10075 if ((input_len
< DISPLAY_LEN_MIN_500
) || (input_len
> (DISPLAY_LEN_MAX_500
+ iterations_len
))) return (PARSER_GLOBAL_LENGTH
);
10077 char *hash_pos
= strchr (salt_pos
, '$');
10079 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10081 uint salt_len
= hash_pos
- salt_pos
;
10083 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10085 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10087 salt
->salt_len
= salt_len
;
10091 uint hash_len
= input_len
- 3 - iterations_len
- salt_len
- 1;
10093 if (hash_len
!= 22) return (PARSER_HASH_LENGTH
);
10095 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10097 return (PARSER_OK
);
10100 int md5apr1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10102 if (memcmp (SIGNATURE_MD5APR1
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
10104 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10106 salt_t
*salt
= hash_buf
->salt
;
10108 char *salt_pos
= input_buf
+ 6;
10110 uint iterations_len
= 0;
10112 if (memcmp (salt_pos
, "rounds=", 7) == 0)
10116 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
10118 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
10119 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
10123 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
10127 iterations_len
+= 8;
10131 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
10134 if ((input_len
< DISPLAY_LEN_MIN_1600
) || (input_len
> DISPLAY_LEN_MAX_1600
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
10136 char *hash_pos
= strchr (salt_pos
, '$');
10138 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10140 uint salt_len
= hash_pos
- salt_pos
;
10142 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
10144 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
10146 salt
->salt_len
= salt_len
;
10150 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
10152 return (PARSER_OK
);
10155 int episerver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10157 if ((input_len
< DISPLAY_LEN_MIN_141
) || (input_len
> DISPLAY_LEN_MAX_141
)) return (PARSER_GLOBAL_LENGTH
);
10159 if (memcmp (SIGNATURE_EPISERVER
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
10161 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10163 salt_t
*salt
= hash_buf
->salt
;
10165 char *salt_pos
= input_buf
+ 14;
10167 char *hash_pos
= strchr (salt_pos
, '*');
10169 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10173 uint salt_len
= hash_pos
- salt_pos
- 1;
10175 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10177 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
10179 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10181 salt
->salt_len
= salt_len
;
10183 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
10185 base64_decode (base64_to_int
, hash_pos
, 27, tmp_buf
);
10187 memcpy (digest
, tmp_buf
, 20);
10189 digest
[0] = byte_swap_32 (digest
[0]);
10190 digest
[1] = byte_swap_32 (digest
[1]);
10191 digest
[2] = byte_swap_32 (digest
[2]);
10192 digest
[3] = byte_swap_32 (digest
[3]);
10193 digest
[4] = byte_swap_32 (digest
[4]);
10195 digest
[0] -= SHA1M_A
;
10196 digest
[1] -= SHA1M_B
;
10197 digest
[2] -= SHA1M_C
;
10198 digest
[3] -= SHA1M_D
;
10199 digest
[4] -= SHA1M_E
;
10201 return (PARSER_OK
);
10204 int descrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10206 if ((input_len
< DISPLAY_LEN_MIN_1500
) || (input_len
> DISPLAY_LEN_MAX_1500
)) return (PARSER_GLOBAL_LENGTH
);
10208 unsigned char c12
= itoa64_to_int (input_buf
[12]);
10210 if (c12
& 3) return (PARSER_HASH_VALUE
);
10212 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10214 salt_t
*salt
= hash_buf
->salt
;
10216 // for ascii_digest
10217 salt
->salt_sign
[0] = input_buf
[0];
10218 salt
->salt_sign
[1] = input_buf
[1];
10220 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[0])
10221 | itoa64_to_int (input_buf
[1]) << 6;
10223 salt
->salt_len
= 2;
10227 memset (tmp_buf
, 0, sizeof (tmp_buf
));
10229 base64_decode (itoa64_to_int
, input_buf
+ 2, 11, tmp_buf
);
10231 memcpy (digest
, tmp_buf
, 8);
10235 IP (digest
[0], digest
[1], tt
);
10240 return (PARSER_OK
);
10243 int md4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10245 if ((input_len
< DISPLAY_LEN_MIN_900
) || (input_len
> DISPLAY_LEN_MAX_900
)) return (PARSER_GLOBAL_LENGTH
);
10247 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10249 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10250 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10251 digest
[2] = hex_to_uint (&input_buf
[16]);
10252 digest
[3] = hex_to_uint (&input_buf
[24]);
10254 digest
[0] = byte_swap_32 (digest
[0]);
10255 digest
[1] = byte_swap_32 (digest
[1]);
10256 digest
[2] = byte_swap_32 (digest
[2]);
10257 digest
[3] = byte_swap_32 (digest
[3]);
10259 digest
[0] -= MD4M_A
;
10260 digest
[1] -= MD4M_B
;
10261 digest
[2] -= MD4M_C
;
10262 digest
[3] -= MD4M_D
;
10264 return (PARSER_OK
);
10267 int md4s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10269 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10271 if ((input_len
< DISPLAY_LEN_MIN_910H
) || (input_len
> DISPLAY_LEN_MAX_910H
)) return (PARSER_GLOBAL_LENGTH
);
10275 if ((input_len
< DISPLAY_LEN_MIN_910
) || (input_len
> DISPLAY_LEN_MAX_910
)) return (PARSER_GLOBAL_LENGTH
);
10278 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10280 salt_t
*salt
= hash_buf
->salt
;
10282 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10283 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10284 digest
[2] = hex_to_uint (&input_buf
[16]);
10285 digest
[3] = hex_to_uint (&input_buf
[24]);
10287 digest
[0] = byte_swap_32 (digest
[0]);
10288 digest
[1] = byte_swap_32 (digest
[1]);
10289 digest
[2] = byte_swap_32 (digest
[2]);
10290 digest
[3] = byte_swap_32 (digest
[3]);
10292 digest
[0] -= MD4M_A
;
10293 digest
[1] -= MD4M_B
;
10294 digest
[2] -= MD4M_C
;
10295 digest
[3] -= MD4M_D
;
10297 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10299 uint salt_len
= input_len
- 32 - 1;
10301 char *salt_buf
= input_buf
+ 32 + 1;
10303 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10305 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10307 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10309 salt
->salt_len
= salt_len
;
10311 return (PARSER_OK
);
10314 int md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10316 if ((input_len
< DISPLAY_LEN_MIN_0
) || (input_len
> DISPLAY_LEN_MAX_0
)) return (PARSER_GLOBAL_LENGTH
);
10318 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10320 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10321 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10322 digest
[2] = hex_to_uint (&input_buf
[16]);
10323 digest
[3] = hex_to_uint (&input_buf
[24]);
10325 digest
[0] = byte_swap_32 (digest
[0]);
10326 digest
[1] = byte_swap_32 (digest
[1]);
10327 digest
[2] = byte_swap_32 (digest
[2]);
10328 digest
[3] = byte_swap_32 (digest
[3]);
10330 digest
[0] -= MD5M_A
;
10331 digest
[1] -= MD5M_B
;
10332 digest
[2] -= MD5M_C
;
10333 digest
[3] -= MD5M_D
;
10335 return (PARSER_OK
);
10338 int md5half_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10340 if ((input_len
< DISPLAY_LEN_MIN_5100
) || (input_len
> DISPLAY_LEN_MAX_5100
)) return (PARSER_GLOBAL_LENGTH
);
10342 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10344 digest
[0] = hex_to_uint (&input_buf
[0]);
10345 digest
[1] = hex_to_uint (&input_buf
[8]);
10349 digest
[0] = byte_swap_32 (digest
[0]);
10350 digest
[1] = byte_swap_32 (digest
[1]);
10352 return (PARSER_OK
);
10355 int md5s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10357 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10359 if ((input_len
< DISPLAY_LEN_MIN_10H
) || (input_len
> DISPLAY_LEN_MAX_10H
)) return (PARSER_GLOBAL_LENGTH
);
10363 if ((input_len
< DISPLAY_LEN_MIN_10
) || (input_len
> DISPLAY_LEN_MAX_10
)) return (PARSER_GLOBAL_LENGTH
);
10366 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10368 salt_t
*salt
= hash_buf
->salt
;
10370 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10371 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10372 digest
[2] = hex_to_uint (&input_buf
[16]);
10373 digest
[3] = hex_to_uint (&input_buf
[24]);
10375 digest
[0] = byte_swap_32 (digest
[0]);
10376 digest
[1] = byte_swap_32 (digest
[1]);
10377 digest
[2] = byte_swap_32 (digest
[2]);
10378 digest
[3] = byte_swap_32 (digest
[3]);
10380 digest
[0] -= MD5M_A
;
10381 digest
[1] -= MD5M_B
;
10382 digest
[2] -= MD5M_C
;
10383 digest
[3] -= MD5M_D
;
10385 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10387 uint salt_len
= input_len
- 32 - 1;
10389 char *salt_buf
= input_buf
+ 32 + 1;
10391 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10393 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10395 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10397 salt
->salt_len
= salt_len
;
10399 return (PARSER_OK
);
10402 int md5pix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10404 if ((input_len
< DISPLAY_LEN_MIN_2400
) || (input_len
> DISPLAY_LEN_MAX_2400
)) return (PARSER_GLOBAL_LENGTH
);
10406 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10408 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10409 | itoa64_to_int (input_buf
[ 1]) << 6
10410 | itoa64_to_int (input_buf
[ 2]) << 12
10411 | itoa64_to_int (input_buf
[ 3]) << 18;
10412 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10413 | itoa64_to_int (input_buf
[ 5]) << 6
10414 | itoa64_to_int (input_buf
[ 6]) << 12
10415 | itoa64_to_int (input_buf
[ 7]) << 18;
10416 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10417 | itoa64_to_int (input_buf
[ 9]) << 6
10418 | itoa64_to_int (input_buf
[10]) << 12
10419 | itoa64_to_int (input_buf
[11]) << 18;
10420 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10421 | itoa64_to_int (input_buf
[13]) << 6
10422 | itoa64_to_int (input_buf
[14]) << 12
10423 | itoa64_to_int (input_buf
[15]) << 18;
10425 digest
[0] -= MD5M_A
;
10426 digest
[1] -= MD5M_B
;
10427 digest
[2] -= MD5M_C
;
10428 digest
[3] -= MD5M_D
;
10430 digest
[0] &= 0x00ffffff;
10431 digest
[1] &= 0x00ffffff;
10432 digest
[2] &= 0x00ffffff;
10433 digest
[3] &= 0x00ffffff;
10435 return (PARSER_OK
);
10438 int md5asa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10440 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10442 if ((input_len
< DISPLAY_LEN_MIN_2410H
) || (input_len
> DISPLAY_LEN_MAX_2410H
)) return (PARSER_GLOBAL_LENGTH
);
10446 if ((input_len
< DISPLAY_LEN_MIN_2410
) || (input_len
> DISPLAY_LEN_MAX_2410
)) return (PARSER_GLOBAL_LENGTH
);
10449 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10451 salt_t
*salt
= hash_buf
->salt
;
10453 digest
[0] = itoa64_to_int (input_buf
[ 0]) << 0
10454 | itoa64_to_int (input_buf
[ 1]) << 6
10455 | itoa64_to_int (input_buf
[ 2]) << 12
10456 | itoa64_to_int (input_buf
[ 3]) << 18;
10457 digest
[1] = itoa64_to_int (input_buf
[ 4]) << 0
10458 | itoa64_to_int (input_buf
[ 5]) << 6
10459 | itoa64_to_int (input_buf
[ 6]) << 12
10460 | itoa64_to_int (input_buf
[ 7]) << 18;
10461 digest
[2] = itoa64_to_int (input_buf
[ 8]) << 0
10462 | itoa64_to_int (input_buf
[ 9]) << 6
10463 | itoa64_to_int (input_buf
[10]) << 12
10464 | itoa64_to_int (input_buf
[11]) << 18;
10465 digest
[3] = itoa64_to_int (input_buf
[12]) << 0
10466 | itoa64_to_int (input_buf
[13]) << 6
10467 | itoa64_to_int (input_buf
[14]) << 12
10468 | itoa64_to_int (input_buf
[15]) << 18;
10470 digest
[0] -= MD5M_A
;
10471 digest
[1] -= MD5M_B
;
10472 digest
[2] -= MD5M_C
;
10473 digest
[3] -= MD5M_D
;
10475 digest
[0] &= 0x00ffffff;
10476 digest
[1] &= 0x00ffffff;
10477 digest
[2] &= 0x00ffffff;
10478 digest
[3] &= 0x00ffffff;
10480 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10482 uint salt_len
= input_len
- 16 - 1;
10484 char *salt_buf
= input_buf
+ 16 + 1;
10486 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10488 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10490 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10492 salt
->salt_len
= salt_len
;
10494 return (PARSER_OK
);
10497 void transform_netntlmv1_key (const uint8_t *nthash
, uint8_t *key
)
10499 key
[0] = (nthash
[0] >> 0);
10500 key
[1] = (nthash
[0] << 7) | (nthash
[1] >> 1);
10501 key
[2] = (nthash
[1] << 6) | (nthash
[2] >> 2);
10502 key
[3] = (nthash
[2] << 5) | (nthash
[3] >> 3);
10503 key
[4] = (nthash
[3] << 4) | (nthash
[4] >> 4);
10504 key
[5] = (nthash
[4] << 3) | (nthash
[5] >> 5);
10505 key
[6] = (nthash
[5] << 2) | (nthash
[6] >> 6);
10506 key
[7] = (nthash
[6] << 1);
10518 int netntlmv1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10520 if ((input_len
< DISPLAY_LEN_MIN_5500
) || (input_len
> DISPLAY_LEN_MAX_5500
)) return (PARSER_GLOBAL_LENGTH
);
10522 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10524 salt_t
*salt
= hash_buf
->salt
;
10526 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10532 char *user_pos
= input_buf
;
10534 char *unused_pos
= strchr (user_pos
, ':');
10536 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10538 uint user_len
= unused_pos
- user_pos
;
10540 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10544 char *domain_pos
= strchr (unused_pos
, ':');
10546 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10548 uint unused_len
= domain_pos
- unused_pos
;
10550 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10554 char *srvchall_pos
= strchr (domain_pos
, ':');
10556 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10558 uint domain_len
= srvchall_pos
- domain_pos
;
10560 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10564 char *hash_pos
= strchr (srvchall_pos
, ':');
10566 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10568 uint srvchall_len
= hash_pos
- srvchall_pos
;
10570 // if (srvchall_len != 0) return (PARSER_SALT_LENGTH);
10574 char *clichall_pos
= strchr (hash_pos
, ':');
10576 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10578 uint hash_len
= clichall_pos
- hash_pos
;
10580 if (hash_len
!= 48) return (PARSER_HASH_LENGTH
);
10584 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10586 if (clichall_len
!= 16) return (PARSER_SALT_LENGTH
);
10589 * store some data for later use
10592 netntlm
->user_len
= user_len
* 2;
10593 netntlm
->domain_len
= domain_len
* 2;
10594 netntlm
->srvchall_len
= srvchall_len
/ 2;
10595 netntlm
->clichall_len
= clichall_len
/ 2;
10597 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10598 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10601 * handle username and domainname
10604 for (uint i
= 0; i
< user_len
; i
++)
10606 *userdomain_ptr
++ = user_pos
[i
];
10607 *userdomain_ptr
++ = 0;
10610 for (uint i
= 0; i
< domain_len
; i
++)
10612 *userdomain_ptr
++ = domain_pos
[i
];
10613 *userdomain_ptr
++ = 0;
10617 * handle server challenge encoding
10620 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10622 const char p0
= srvchall_pos
[i
+ 0];
10623 const char p1
= srvchall_pos
[i
+ 1];
10625 *chall_ptr
++ = hex_convert (p1
) << 0
10626 | hex_convert (p0
) << 4;
10630 * handle client challenge encoding
10633 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10635 const char p0
= clichall_pos
[i
+ 0];
10636 const char p1
= clichall_pos
[i
+ 1];
10638 *chall_ptr
++ = hex_convert (p1
) << 0
10639 | hex_convert (p0
) << 4;
10646 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10648 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, clichall_pos
, clichall_len
);
10650 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10652 salt
->salt_len
= salt_len
;
10654 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
10655 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
10656 digest
[2] = hex_to_uint (&hash_pos
[16]);
10657 digest
[3] = hex_to_uint (&hash_pos
[24]);
10659 digest
[0] = byte_swap_32 (digest
[0]);
10660 digest
[1] = byte_swap_32 (digest
[1]);
10661 digest
[2] = byte_swap_32 (digest
[2]);
10662 digest
[3] = byte_swap_32 (digest
[3]);
10664 /* special case, last 8 byte do not need to be checked since they are brute-forced next */
10666 uint digest_tmp
[2];
10668 digest_tmp
[0] = hex_to_uint (&hash_pos
[32]);
10669 digest_tmp
[1] = hex_to_uint (&hash_pos
[40]);
10671 digest_tmp
[0] = byte_swap_32 (digest_tmp
[0]);
10672 digest_tmp
[1] = byte_swap_32 (digest_tmp
[1]);
10674 /* special case 2: ESS */
10676 if (srvchall_len
== 48)
10678 if ((netntlm
->chall_buf
[2] == 0) && (netntlm
->chall_buf
[3] == 0) && (netntlm
->chall_buf
[4] == 0) && (netntlm
->chall_buf
[5] == 0))
10682 w
[ 0] = netntlm
->chall_buf
[6];
10683 w
[ 1] = netntlm
->chall_buf
[7];
10684 w
[ 2] = netntlm
->chall_buf
[0];
10685 w
[ 3] = netntlm
->chall_buf
[1];
10708 salt
->salt_buf
[0] = dgst
[0];
10709 salt
->salt_buf
[1] = dgst
[1];
10713 /* precompute netntlmv1 exploit start */
10715 for (uint i
= 0; i
< 0x10000; i
++)
10717 uint key_md4
[2] = { i
, 0 };
10718 uint key_des
[2] = { 0, 0 };
10720 transform_netntlmv1_key ((uint8_t *) key_md4
, (uint8_t *) key_des
);
10725 _des_keysetup (key_des
, Kc
, Kd
, c_skb
);
10727 uint data3
[2] = { salt
->salt_buf
[0], salt
->salt_buf
[1] };
10729 _des_encrypt (data3
, Kc
, Kd
, c_SPtrans
);
10731 if (data3
[0] != digest_tmp
[0]) continue;
10732 if (data3
[1] != digest_tmp
[1]) continue;
10734 salt
->salt_buf
[2] = i
;
10736 salt
->salt_len
= 24;
10741 salt
->salt_buf_pc
[0] = digest_tmp
[0];
10742 salt
->salt_buf_pc
[1] = digest_tmp
[1];
10744 /* precompute netntlmv1 exploit stop */
10748 IP (digest
[0], digest
[1], tt
);
10749 IP (digest
[2], digest
[3], tt
);
10751 digest
[0] = ROTATE_RIGHT (digest
[0], 29);
10752 digest
[1] = ROTATE_RIGHT (digest
[1], 29);
10753 digest
[2] = ROTATE_RIGHT (digest
[2], 29);
10754 digest
[3] = ROTATE_RIGHT (digest
[3], 29);
10756 IP (salt
->salt_buf
[0], salt
->salt_buf
[1], tt
);
10758 salt
->salt_buf
[0] = ROTATE_LEFT (salt
->salt_buf
[0], 3);
10759 salt
->salt_buf
[1] = ROTATE_LEFT (salt
->salt_buf
[1], 3);
10761 return (PARSER_OK
);
10764 int netntlmv2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10766 if ((input_len
< DISPLAY_LEN_MIN_5600
) || (input_len
> DISPLAY_LEN_MAX_5600
)) return (PARSER_GLOBAL_LENGTH
);
10768 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10770 salt_t
*salt
= hash_buf
->salt
;
10772 netntlm_t
*netntlm
= (netntlm_t
*) hash_buf
->esalt
;
10778 char *user_pos
= input_buf
;
10780 char *unused_pos
= strchr (user_pos
, ':');
10782 if (unused_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10784 uint user_len
= unused_pos
- user_pos
;
10786 if (user_len
> 60) return (PARSER_SALT_LENGTH
);
10790 char *domain_pos
= strchr (unused_pos
, ':');
10792 if (domain_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10794 uint unused_len
= domain_pos
- unused_pos
;
10796 if (unused_len
!= 0) return (PARSER_SALT_LENGTH
);
10800 char *srvchall_pos
= strchr (domain_pos
, ':');
10802 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10804 uint domain_len
= srvchall_pos
- domain_pos
;
10806 if (domain_len
> 45) return (PARSER_SALT_LENGTH
);
10810 char *hash_pos
= strchr (srvchall_pos
, ':');
10812 if (srvchall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10814 uint srvchall_len
= hash_pos
- srvchall_pos
;
10816 if (srvchall_len
!= 16) return (PARSER_SALT_LENGTH
);
10820 char *clichall_pos
= strchr (hash_pos
, ':');
10822 if (clichall_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
10824 uint hash_len
= clichall_pos
- hash_pos
;
10826 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
10830 uint clichall_len
= input_len
- user_len
- 1 - unused_len
- 1 - domain_len
- 1 - srvchall_len
- 1 - hash_len
- 1;
10832 if (clichall_len
> 1024) return (PARSER_SALT_LENGTH
);
10834 if (clichall_len
% 2) return (PARSER_SALT_VALUE
);
10837 * store some data for later use
10840 netntlm
->user_len
= user_len
* 2;
10841 netntlm
->domain_len
= domain_len
* 2;
10842 netntlm
->srvchall_len
= srvchall_len
/ 2;
10843 netntlm
->clichall_len
= clichall_len
/ 2;
10845 char *userdomain_ptr
= (char *) netntlm
->userdomain_buf
;
10846 char *chall_ptr
= (char *) netntlm
->chall_buf
;
10849 * handle username and domainname
10852 for (uint i
= 0; i
< user_len
; i
++)
10854 *userdomain_ptr
++ = toupper (user_pos
[i
]);
10855 *userdomain_ptr
++ = 0;
10858 for (uint i
= 0; i
< domain_len
; i
++)
10860 *userdomain_ptr
++ = domain_pos
[i
];
10861 *userdomain_ptr
++ = 0;
10864 *userdomain_ptr
++ = 0x80;
10867 * handle server challenge encoding
10870 for (uint i
= 0; i
< srvchall_len
; i
+= 2)
10872 const char p0
= srvchall_pos
[i
+ 0];
10873 const char p1
= srvchall_pos
[i
+ 1];
10875 *chall_ptr
++ = hex_convert (p1
) << 0
10876 | hex_convert (p0
) << 4;
10880 * handle client challenge encoding
10883 for (uint i
= 0; i
< clichall_len
; i
+= 2)
10885 const char p0
= clichall_pos
[i
+ 0];
10886 const char p1
= clichall_pos
[i
+ 1];
10888 *chall_ptr
++ = hex_convert (p1
) << 0
10889 | hex_convert (p0
) << 4;
10892 *chall_ptr
++ = 0x80;
10895 * handle hash itself
10898 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
10899 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
10900 digest
[2] = hex_to_uint (&hash_pos
[16]);
10901 digest
[3] = hex_to_uint (&hash_pos
[24]);
10903 digest
[0] = byte_swap_32 (digest
[0]);
10904 digest
[1] = byte_swap_32 (digest
[1]);
10905 digest
[2] = byte_swap_32 (digest
[2]);
10906 digest
[3] = byte_swap_32 (digest
[3]);
10909 * reuse challange data as salt_buf, its the buffer that is most likely unique
10912 salt
->salt_buf
[0] = 0;
10913 salt
->salt_buf
[1] = 0;
10914 salt
->salt_buf
[2] = 0;
10915 salt
->salt_buf
[3] = 0;
10916 salt
->salt_buf
[4] = 0;
10917 salt
->salt_buf
[5] = 0;
10918 salt
->salt_buf
[6] = 0;
10919 salt
->salt_buf
[7] = 0;
10923 uptr
= (uint
*) netntlm
->userdomain_buf
;
10925 for (uint i
= 0; i
< 16; i
+= 16)
10927 md5_64 (uptr
, salt
->salt_buf
);
10930 uptr
= (uint
*) netntlm
->chall_buf
;
10932 for (uint i
= 0; i
< 256; i
+= 16)
10934 md5_64 (uptr
, salt
->salt_buf
);
10937 salt
->salt_len
= 16;
10939 return (PARSER_OK
);
10942 int joomla_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10944 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10946 if ((input_len
< DISPLAY_LEN_MIN_11H
) || (input_len
> DISPLAY_LEN_MAX_11H
)) return (PARSER_GLOBAL_LENGTH
);
10950 if ((input_len
< DISPLAY_LEN_MIN_11
) || (input_len
> DISPLAY_LEN_MAX_11
)) return (PARSER_GLOBAL_LENGTH
);
10953 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
10955 salt_t
*salt
= hash_buf
->salt
;
10957 digest
[0] = hex_to_uint (&input_buf
[ 0]);
10958 digest
[1] = hex_to_uint (&input_buf
[ 8]);
10959 digest
[2] = hex_to_uint (&input_buf
[16]);
10960 digest
[3] = hex_to_uint (&input_buf
[24]);
10962 digest
[0] = byte_swap_32 (digest
[0]);
10963 digest
[1] = byte_swap_32 (digest
[1]);
10964 digest
[2] = byte_swap_32 (digest
[2]);
10965 digest
[3] = byte_swap_32 (digest
[3]);
10967 digest
[0] -= MD5M_A
;
10968 digest
[1] -= MD5M_B
;
10969 digest
[2] -= MD5M_C
;
10970 digest
[3] -= MD5M_D
;
10972 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
10974 uint salt_len
= input_len
- 32 - 1;
10976 char *salt_buf
= input_buf
+ 32 + 1;
10978 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
10980 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
10982 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
10984 salt
->salt_len
= salt_len
;
10986 return (PARSER_OK
);
10989 int postgresql_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
10991 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
10993 if ((input_len
< DISPLAY_LEN_MIN_12H
) || (input_len
> DISPLAY_LEN_MAX_12H
)) return (PARSER_GLOBAL_LENGTH
);
10997 if ((input_len
< DISPLAY_LEN_MIN_12
) || (input_len
> DISPLAY_LEN_MAX_12
)) return (PARSER_GLOBAL_LENGTH
);
11000 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11002 salt_t
*salt
= hash_buf
->salt
;
11004 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11005 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11006 digest
[2] = hex_to_uint (&input_buf
[16]);
11007 digest
[3] = hex_to_uint (&input_buf
[24]);
11009 digest
[0] = byte_swap_32 (digest
[0]);
11010 digest
[1] = byte_swap_32 (digest
[1]);
11011 digest
[2] = byte_swap_32 (digest
[2]);
11012 digest
[3] = byte_swap_32 (digest
[3]);
11014 digest
[0] -= MD5M_A
;
11015 digest
[1] -= MD5M_B
;
11016 digest
[2] -= MD5M_C
;
11017 digest
[3] -= MD5M_D
;
11019 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11021 uint salt_len
= input_len
- 32 - 1;
11023 char *salt_buf
= input_buf
+ 32 + 1;
11025 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11027 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11029 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11031 salt
->salt_len
= salt_len
;
11033 return (PARSER_OK
);
11036 int md5md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11038 if ((input_len
< DISPLAY_LEN_MIN_2600
) || (input_len
> DISPLAY_LEN_MAX_2600
)) return (PARSER_GLOBAL_LENGTH
);
11040 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11042 salt_t
*salt
= hash_buf
->salt
;
11044 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11045 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11046 digest
[2] = hex_to_uint (&input_buf
[16]);
11047 digest
[3] = hex_to_uint (&input_buf
[24]);
11049 digest
[0] = byte_swap_32 (digest
[0]);
11050 digest
[1] = byte_swap_32 (digest
[1]);
11051 digest
[2] = byte_swap_32 (digest
[2]);
11052 digest
[3] = byte_swap_32 (digest
[3]);
11054 digest
[0] -= MD5M_A
;
11055 digest
[1] -= MD5M_B
;
11056 digest
[2] -= MD5M_C
;
11057 digest
[3] -= MD5M_D
;
11060 * This is a virtual salt. While the algorithm is basically not salted
11061 * we can exploit the salt buffer to set the 0x80 and the w[14] value.
11062 * This way we can save a special md5md5 kernel and reuse the one from vbull.
11065 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11067 uint salt_len
= parse_and_store_salt (salt_buf_ptr
, (char *) "", 0);
11069 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11071 salt
->salt_len
= salt_len
;
11073 return (PARSER_OK
);
11076 int vb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11078 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11080 if ((input_len
< DISPLAY_LEN_MIN_2611H
) || (input_len
> DISPLAY_LEN_MAX_2611H
)) return (PARSER_GLOBAL_LENGTH
);
11084 if ((input_len
< DISPLAY_LEN_MIN_2611
) || (input_len
> DISPLAY_LEN_MAX_2611
)) return (PARSER_GLOBAL_LENGTH
);
11087 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11089 salt_t
*salt
= hash_buf
->salt
;
11091 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11092 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11093 digest
[2] = hex_to_uint (&input_buf
[16]);
11094 digest
[3] = hex_to_uint (&input_buf
[24]);
11096 digest
[0] = byte_swap_32 (digest
[0]);
11097 digest
[1] = byte_swap_32 (digest
[1]);
11098 digest
[2] = byte_swap_32 (digest
[2]);
11099 digest
[3] = byte_swap_32 (digest
[3]);
11101 digest
[0] -= MD5M_A
;
11102 digest
[1] -= MD5M_B
;
11103 digest
[2] -= MD5M_C
;
11104 digest
[3] -= MD5M_D
;
11106 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11108 uint salt_len
= input_len
- 32 - 1;
11110 char *salt_buf
= input_buf
+ 32 + 1;
11112 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11114 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11116 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11118 salt
->salt_len
= salt_len
;
11120 return (PARSER_OK
);
11123 int vb30_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11125 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11127 if ((input_len
< DISPLAY_LEN_MIN_2711H
) || (input_len
> DISPLAY_LEN_MAX_2711H
)) return (PARSER_GLOBAL_LENGTH
);
11131 if ((input_len
< DISPLAY_LEN_MIN_2711
) || (input_len
> DISPLAY_LEN_MAX_2711
)) return (PARSER_GLOBAL_LENGTH
);
11134 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11136 salt_t
*salt
= hash_buf
->salt
;
11138 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11139 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11140 digest
[2] = hex_to_uint (&input_buf
[16]);
11141 digest
[3] = hex_to_uint (&input_buf
[24]);
11143 digest
[0] = byte_swap_32 (digest
[0]);
11144 digest
[1] = byte_swap_32 (digest
[1]);
11145 digest
[2] = byte_swap_32 (digest
[2]);
11146 digest
[3] = byte_swap_32 (digest
[3]);
11148 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11150 uint salt_len
= input_len
- 32 - 1;
11152 char *salt_buf
= input_buf
+ 32 + 1;
11154 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11156 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11158 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11160 salt
->salt_len
= salt_len
;
11162 return (PARSER_OK
);
11165 int dcc_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11167 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11169 if ((input_len
< DISPLAY_LEN_MIN_1100H
) || (input_len
> DISPLAY_LEN_MAX_1100H
)) return (PARSER_GLOBAL_LENGTH
);
11173 if ((input_len
< DISPLAY_LEN_MIN_1100
) || (input_len
> DISPLAY_LEN_MAX_1100
)) return (PARSER_GLOBAL_LENGTH
);
11176 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11178 salt_t
*salt
= hash_buf
->salt
;
11180 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11181 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11182 digest
[2] = hex_to_uint (&input_buf
[16]);
11183 digest
[3] = hex_to_uint (&input_buf
[24]);
11185 digest
[0] = byte_swap_32 (digest
[0]);
11186 digest
[1] = byte_swap_32 (digest
[1]);
11187 digest
[2] = byte_swap_32 (digest
[2]);
11188 digest
[3] = byte_swap_32 (digest
[3]);
11190 digest
[0] -= MD4M_A
;
11191 digest
[1] -= MD4M_B
;
11192 digest
[2] -= MD4M_C
;
11193 digest
[3] -= MD4M_D
;
11195 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11197 uint salt_len
= input_len
- 32 - 1;
11199 char *salt_buf
= input_buf
+ 32 + 1;
11201 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11203 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11205 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11207 salt
->salt_len
= salt_len
;
11209 return (PARSER_OK
);
11212 int ipb2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11214 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11216 if ((input_len
< DISPLAY_LEN_MIN_2811H
) || (input_len
> DISPLAY_LEN_MAX_2811H
)) return (PARSER_GLOBAL_LENGTH
);
11220 if ((input_len
< DISPLAY_LEN_MIN_2811
) || (input_len
> DISPLAY_LEN_MAX_2811
)) return (PARSER_GLOBAL_LENGTH
);
11223 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11225 salt_t
*salt
= hash_buf
->salt
;
11227 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11228 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11229 digest
[2] = hex_to_uint (&input_buf
[16]);
11230 digest
[3] = hex_to_uint (&input_buf
[24]);
11232 digest
[0] = byte_swap_32 (digest
[0]);
11233 digest
[1] = byte_swap_32 (digest
[1]);
11234 digest
[2] = byte_swap_32 (digest
[2]);
11235 digest
[3] = byte_swap_32 (digest
[3]);
11237 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11239 uint salt_len
= input_len
- 32 - 1;
11241 char *salt_buf
= input_buf
+ 32 + 1;
11243 uint salt_pc_block
[16];
11245 memset (salt_pc_block
, 0, sizeof (salt_pc_block
));
11247 char *salt_pc_block_ptr
= (char *) salt_pc_block
;
11249 salt_len
= parse_and_store_salt (salt_pc_block_ptr
, salt_buf
, salt_len
);
11251 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11253 salt_pc_block_ptr
[salt_len
] = (unsigned char) 0x80;
11255 salt_pc_block
[14] = salt_len
* 8;
11257 uint salt_pc_digest
[4];
11259 salt_pc_digest
[0] = MAGIC_A
;
11260 salt_pc_digest
[1] = MAGIC_B
;
11261 salt_pc_digest
[2] = MAGIC_C
;
11262 salt_pc_digest
[3] = MAGIC_D
;
11264 md5_64 (salt_pc_block
, salt_pc_digest
);
11266 salt_pc_digest
[0] = byte_swap_32 (salt_pc_digest
[0]);
11267 salt_pc_digest
[1] = byte_swap_32 (salt_pc_digest
[1]);
11268 salt_pc_digest
[2] = byte_swap_32 (salt_pc_digest
[2]);
11269 salt_pc_digest
[3] = byte_swap_32 (salt_pc_digest
[3]);
11271 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11273 memcpy (salt_buf_ptr
, salt_buf
, salt_len
);
11275 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
11277 bin_to_hex_lower (salt_pc_digest
[0], salt_buf_pc_ptr
+ 0);
11278 bin_to_hex_lower (salt_pc_digest
[1], salt_buf_pc_ptr
+ 8);
11279 bin_to_hex_lower (salt_pc_digest
[2], salt_buf_pc_ptr
+ 16);
11280 bin_to_hex_lower (salt_pc_digest
[3], salt_buf_pc_ptr
+ 24);
11282 salt
->salt_len
= 32; // changed, was salt_len before -- was a bug? 32 should be correct
11284 return (PARSER_OK
);
11287 int sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11289 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11291 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11293 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11294 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11295 digest
[2] = hex_to_uint (&input_buf
[16]);
11296 digest
[3] = hex_to_uint (&input_buf
[24]);
11297 digest
[4] = hex_to_uint (&input_buf
[32]);
11299 digest
[0] -= SHA1M_A
;
11300 digest
[1] -= SHA1M_B
;
11301 digest
[2] -= SHA1M_C
;
11302 digest
[3] -= SHA1M_D
;
11303 digest
[4] -= SHA1M_E
;
11305 return (PARSER_OK
);
11308 int sha1linkedin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11310 if ((input_len
< DISPLAY_LEN_MIN_100
) || (input_len
> DISPLAY_LEN_MAX_100
)) return (PARSER_GLOBAL_LENGTH
);
11312 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11314 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11315 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11316 digest
[2] = hex_to_uint (&input_buf
[16]);
11317 digest
[3] = hex_to_uint (&input_buf
[24]);
11318 digest
[4] = hex_to_uint (&input_buf
[32]);
11320 return (PARSER_OK
);
11323 int sha1s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11325 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11327 if ((input_len
< DISPLAY_LEN_MIN_110H
) || (input_len
> DISPLAY_LEN_MAX_110H
)) return (PARSER_GLOBAL_LENGTH
);
11331 if ((input_len
< DISPLAY_LEN_MIN_110
) || (input_len
> DISPLAY_LEN_MAX_110
)) return (PARSER_GLOBAL_LENGTH
);
11334 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11336 salt_t
*salt
= hash_buf
->salt
;
11338 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11339 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11340 digest
[2] = hex_to_uint (&input_buf
[16]);
11341 digest
[3] = hex_to_uint (&input_buf
[24]);
11342 digest
[4] = hex_to_uint (&input_buf
[32]);
11344 digest
[0] -= SHA1M_A
;
11345 digest
[1] -= SHA1M_B
;
11346 digest
[2] -= SHA1M_C
;
11347 digest
[3] -= SHA1M_D
;
11348 digest
[4] -= SHA1M_E
;
11350 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11352 uint salt_len
= input_len
- 40 - 1;
11354 char *salt_buf
= input_buf
+ 40 + 1;
11356 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11358 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11360 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11362 salt
->salt_len
= salt_len
;
11364 return (PARSER_OK
);
11367 int sha1b64_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11369 if ((input_len
< DISPLAY_LEN_MIN_101
) || (input_len
> DISPLAY_LEN_MAX_101
)) return (PARSER_GLOBAL_LENGTH
);
11371 if (memcmp (SIGNATURE_SHA1B64
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
11373 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11377 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11379 base64_decode (base64_to_int
, input_buf
+ 5, input_len
- 5, tmp_buf
);
11381 memcpy (digest
, tmp_buf
, 20);
11383 digest
[0] = byte_swap_32 (digest
[0]);
11384 digest
[1] = byte_swap_32 (digest
[1]);
11385 digest
[2] = byte_swap_32 (digest
[2]);
11386 digest
[3] = byte_swap_32 (digest
[3]);
11387 digest
[4] = byte_swap_32 (digest
[4]);
11389 digest
[0] -= SHA1M_A
;
11390 digest
[1] -= SHA1M_B
;
11391 digest
[2] -= SHA1M_C
;
11392 digest
[3] -= SHA1M_D
;
11393 digest
[4] -= SHA1M_E
;
11395 return (PARSER_OK
);
11398 int sha1b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11400 if ((input_len
< DISPLAY_LEN_MIN_111
) || (input_len
> DISPLAY_LEN_MAX_111
)) return (PARSER_GLOBAL_LENGTH
);
11402 if (memcmp (SIGNATURE_SSHA1B64_lower
, input_buf
, 6) && memcmp (SIGNATURE_SSHA1B64_upper
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11404 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11406 salt_t
*salt
= hash_buf
->salt
;
11410 memset (tmp_buf
, 0, sizeof (tmp_buf
));
11412 int tmp_len
= base64_decode (base64_to_int
, input_buf
+ 6, input_len
- 6, tmp_buf
);
11414 memcpy (digest
, tmp_buf
, 20);
11416 salt
->salt_len
= tmp_len
- 20;
11418 memcpy (salt
->salt_buf
, tmp_buf
+ 20, salt
->salt_len
);
11420 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
11422 char *ptr
= (char *) salt
->salt_buf
;
11424 ptr
[salt
->salt_len
] = 0x80;
11427 digest
[0] = byte_swap_32 (digest
[0]);
11428 digest
[1] = byte_swap_32 (digest
[1]);
11429 digest
[2] = byte_swap_32 (digest
[2]);
11430 digest
[3] = byte_swap_32 (digest
[3]);
11431 digest
[4] = byte_swap_32 (digest
[4]);
11433 digest
[0] -= SHA1M_A
;
11434 digest
[1] -= SHA1M_B
;
11435 digest
[2] -= SHA1M_C
;
11436 digest
[3] -= SHA1M_D
;
11437 digest
[4] -= SHA1M_E
;
11439 return (PARSER_OK
);
11442 int mssql2000_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11444 if ((input_len
< DISPLAY_LEN_MIN_131
) || (input_len
> DISPLAY_LEN_MAX_131
)) return (PARSER_GLOBAL_LENGTH
);
11446 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11448 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11450 salt_t
*salt
= hash_buf
->salt
;
11452 char *salt_buf
= input_buf
+ 6;
11456 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11458 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11460 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11462 salt
->salt_len
= salt_len
;
11464 char *hash_pos
= input_buf
+ 6 + 8 + 40;
11466 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
11467 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
11468 digest
[2] = hex_to_uint (&hash_pos
[16]);
11469 digest
[3] = hex_to_uint (&hash_pos
[24]);
11470 digest
[4] = hex_to_uint (&hash_pos
[32]);
11472 digest
[0] -= SHA1M_A
;
11473 digest
[1] -= SHA1M_B
;
11474 digest
[2] -= SHA1M_C
;
11475 digest
[3] -= SHA1M_D
;
11476 digest
[4] -= SHA1M_E
;
11478 return (PARSER_OK
);
11481 int mssql2005_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11483 if ((input_len
< DISPLAY_LEN_MIN_132
) || (input_len
> DISPLAY_LEN_MAX_132
)) return (PARSER_GLOBAL_LENGTH
);
11485 if (memcmp (SIGNATURE_MSSQL
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11487 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11489 salt_t
*salt
= hash_buf
->salt
;
11491 char *salt_buf
= input_buf
+ 6;
11495 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11497 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11499 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11501 salt
->salt_len
= salt_len
;
11503 char *hash_pos
= input_buf
+ 6 + 8;
11505 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
11506 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
11507 digest
[2] = hex_to_uint (&hash_pos
[16]);
11508 digest
[3] = hex_to_uint (&hash_pos
[24]);
11509 digest
[4] = hex_to_uint (&hash_pos
[32]);
11511 digest
[0] -= SHA1M_A
;
11512 digest
[1] -= SHA1M_B
;
11513 digest
[2] -= SHA1M_C
;
11514 digest
[3] -= SHA1M_D
;
11515 digest
[4] -= SHA1M_E
;
11517 return (PARSER_OK
);
11520 int mssql2012_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11522 if ((input_len
< DISPLAY_LEN_MIN_1731
) || (input_len
> DISPLAY_LEN_MAX_1731
)) return (PARSER_GLOBAL_LENGTH
);
11524 if (memcmp (SIGNATURE_MSSQL2012
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
11526 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11528 salt_t
*salt
= hash_buf
->salt
;
11530 char *salt_buf
= input_buf
+ 6;
11534 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11536 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11538 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11540 salt
->salt_len
= salt_len
;
11542 char *hash_pos
= input_buf
+ 6 + 8;
11544 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
11545 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
11546 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
11547 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
11548 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
11549 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
11550 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
11551 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
11553 digest
[0] -= SHA512M_A
;
11554 digest
[1] -= SHA512M_B
;
11555 digest
[2] -= SHA512M_C
;
11556 digest
[3] -= SHA512M_D
;
11557 digest
[4] -= SHA512M_E
;
11558 digest
[5] -= SHA512M_F
;
11559 digest
[6] -= SHA512M_G
;
11560 digest
[7] -= SHA512M_H
;
11562 return (PARSER_OK
);
11565 int oracleh_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11567 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11569 if ((input_len
< DISPLAY_LEN_MIN_3100H
) || (input_len
> DISPLAY_LEN_MAX_3100H
)) return (PARSER_GLOBAL_LENGTH
);
11573 if ((input_len
< DISPLAY_LEN_MIN_3100
) || (input_len
> DISPLAY_LEN_MAX_3100
)) return (PARSER_GLOBAL_LENGTH
);
11576 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11578 salt_t
*salt
= hash_buf
->salt
;
11580 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11581 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11585 digest
[0] = byte_swap_32 (digest
[0]);
11586 digest
[1] = byte_swap_32 (digest
[1]);
11588 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11590 uint salt_len
= input_len
- 16 - 1;
11592 char *salt_buf
= input_buf
+ 16 + 1;
11594 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11596 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11598 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11600 salt
->salt_len
= salt_len
;
11602 return (PARSER_OK
);
11605 int oracles_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11607 if ((input_len
< DISPLAY_LEN_MIN_112
) || (input_len
> DISPLAY_LEN_MAX_112
)) return (PARSER_GLOBAL_LENGTH
);
11609 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11611 salt_t
*salt
= hash_buf
->salt
;
11613 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11614 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11615 digest
[2] = hex_to_uint (&input_buf
[16]);
11616 digest
[3] = hex_to_uint (&input_buf
[24]);
11617 digest
[4] = hex_to_uint (&input_buf
[32]);
11619 digest
[0] -= SHA1M_A
;
11620 digest
[1] -= SHA1M_B
;
11621 digest
[2] -= SHA1M_C
;
11622 digest
[3] -= SHA1M_D
;
11623 digest
[4] -= SHA1M_E
;
11625 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11627 uint salt_len
= input_len
- 40 - 1;
11629 char *salt_buf
= input_buf
+ 40 + 1;
11631 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11633 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11635 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11637 salt
->salt_len
= salt_len
;
11639 return (PARSER_OK
);
11642 int oraclet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11644 if ((input_len
< DISPLAY_LEN_MIN_12300
) || (input_len
> DISPLAY_LEN_MAX_12300
)) return (PARSER_GLOBAL_LENGTH
);
11646 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11648 salt_t
*salt
= hash_buf
->salt
;
11650 char *hash_pos
= input_buf
;
11652 digest
[ 0] = hex_to_uint (&hash_pos
[ 0]);
11653 digest
[ 1] = hex_to_uint (&hash_pos
[ 8]);
11654 digest
[ 2] = hex_to_uint (&hash_pos
[ 16]);
11655 digest
[ 3] = hex_to_uint (&hash_pos
[ 24]);
11656 digest
[ 4] = hex_to_uint (&hash_pos
[ 32]);
11657 digest
[ 5] = hex_to_uint (&hash_pos
[ 40]);
11658 digest
[ 6] = hex_to_uint (&hash_pos
[ 48]);
11659 digest
[ 7] = hex_to_uint (&hash_pos
[ 56]);
11660 digest
[ 8] = hex_to_uint (&hash_pos
[ 64]);
11661 digest
[ 9] = hex_to_uint (&hash_pos
[ 72]);
11662 digest
[10] = hex_to_uint (&hash_pos
[ 80]);
11663 digest
[11] = hex_to_uint (&hash_pos
[ 88]);
11664 digest
[12] = hex_to_uint (&hash_pos
[ 96]);
11665 digest
[13] = hex_to_uint (&hash_pos
[104]);
11666 digest
[14] = hex_to_uint (&hash_pos
[112]);
11667 digest
[15] = hex_to_uint (&hash_pos
[120]);
11669 char *salt_pos
= input_buf
+ 128;
11671 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
11672 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
11673 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
11674 salt
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
11676 salt
->salt_iter
= ROUNDS_ORACLET
- 1;
11677 salt
->salt_len
= 16;
11679 return (PARSER_OK
);
11682 int sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11684 if ((input_len
< DISPLAY_LEN_MIN_1400
) || (input_len
> DISPLAY_LEN_MAX_1400
)) return (PARSER_GLOBAL_LENGTH
);
11686 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11688 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11689 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11690 digest
[2] = hex_to_uint (&input_buf
[16]);
11691 digest
[3] = hex_to_uint (&input_buf
[24]);
11692 digest
[4] = hex_to_uint (&input_buf
[32]);
11693 digest
[5] = hex_to_uint (&input_buf
[40]);
11694 digest
[6] = hex_to_uint (&input_buf
[48]);
11695 digest
[7] = hex_to_uint (&input_buf
[56]);
11697 digest
[0] -= SHA256M_A
;
11698 digest
[1] -= SHA256M_B
;
11699 digest
[2] -= SHA256M_C
;
11700 digest
[3] -= SHA256M_D
;
11701 digest
[4] -= SHA256M_E
;
11702 digest
[5] -= SHA256M_F
;
11703 digest
[6] -= SHA256M_G
;
11704 digest
[7] -= SHA256M_H
;
11706 return (PARSER_OK
);
11709 int sha256s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11711 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11713 if ((input_len
< DISPLAY_LEN_MIN_1410H
) || (input_len
> DISPLAY_LEN_MAX_1410H
)) return (PARSER_GLOBAL_LENGTH
);
11717 if ((input_len
< DISPLAY_LEN_MIN_1410
) || (input_len
> DISPLAY_LEN_MAX_1410
)) return (PARSER_GLOBAL_LENGTH
);
11720 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11722 salt_t
*salt
= hash_buf
->salt
;
11724 digest
[0] = hex_to_uint (&input_buf
[ 0]);
11725 digest
[1] = hex_to_uint (&input_buf
[ 8]);
11726 digest
[2] = hex_to_uint (&input_buf
[16]);
11727 digest
[3] = hex_to_uint (&input_buf
[24]);
11728 digest
[4] = hex_to_uint (&input_buf
[32]);
11729 digest
[5] = hex_to_uint (&input_buf
[40]);
11730 digest
[6] = hex_to_uint (&input_buf
[48]);
11731 digest
[7] = hex_to_uint (&input_buf
[56]);
11733 digest
[0] -= SHA256M_A
;
11734 digest
[1] -= SHA256M_B
;
11735 digest
[2] -= SHA256M_C
;
11736 digest
[3] -= SHA256M_D
;
11737 digest
[4] -= SHA256M_E
;
11738 digest
[5] -= SHA256M_F
;
11739 digest
[6] -= SHA256M_G
;
11740 digest
[7] -= SHA256M_H
;
11742 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11744 uint salt_len
= input_len
- 64 - 1;
11746 char *salt_buf
= input_buf
+ 64 + 1;
11748 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11750 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11752 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11754 salt
->salt_len
= salt_len
;
11756 return (PARSER_OK
);
11759 int sha384_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11761 if ((input_len
< DISPLAY_LEN_MIN_10800
) || (input_len
> DISPLAY_LEN_MAX_10800
)) return (PARSER_GLOBAL_LENGTH
);
11763 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11765 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
11766 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
11767 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
11768 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
11769 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
11770 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
11774 digest
[0] -= SHA384M_A
;
11775 digest
[1] -= SHA384M_B
;
11776 digest
[2] -= SHA384M_C
;
11777 digest
[3] -= SHA384M_D
;
11778 digest
[4] -= SHA384M_E
;
11779 digest
[5] -= SHA384M_F
;
11783 return (PARSER_OK
);
11786 int sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11788 if ((input_len
< DISPLAY_LEN_MIN_1700
) || (input_len
> DISPLAY_LEN_MAX_1700
)) return (PARSER_GLOBAL_LENGTH
);
11790 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11792 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
11793 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
11794 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
11795 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
11796 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
11797 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
11798 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
11799 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
11801 digest
[0] -= SHA512M_A
;
11802 digest
[1] -= SHA512M_B
;
11803 digest
[2] -= SHA512M_C
;
11804 digest
[3] -= SHA512M_D
;
11805 digest
[4] -= SHA512M_E
;
11806 digest
[5] -= SHA512M_F
;
11807 digest
[6] -= SHA512M_G
;
11808 digest
[7] -= SHA512M_H
;
11810 return (PARSER_OK
);
11813 int sha512s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11815 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
11817 if ((input_len
< DISPLAY_LEN_MIN_1710H
) || (input_len
> DISPLAY_LEN_MAX_1710H
)) return (PARSER_GLOBAL_LENGTH
);
11821 if ((input_len
< DISPLAY_LEN_MIN_1710
) || (input_len
> DISPLAY_LEN_MAX_1710
)) return (PARSER_GLOBAL_LENGTH
);
11824 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11826 salt_t
*salt
= hash_buf
->salt
;
11828 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
11829 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
11830 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
11831 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
11832 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
11833 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
11834 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
11835 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
11837 digest
[0] -= SHA512M_A
;
11838 digest
[1] -= SHA512M_B
;
11839 digest
[2] -= SHA512M_C
;
11840 digest
[3] -= SHA512M_D
;
11841 digest
[4] -= SHA512M_E
;
11842 digest
[5] -= SHA512M_F
;
11843 digest
[6] -= SHA512M_G
;
11844 digest
[7] -= SHA512M_H
;
11846 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
11848 uint salt_len
= input_len
- 128 - 1;
11850 char *salt_buf
= input_buf
+ 128 + 1;
11852 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
11854 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
11856 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
11858 salt
->salt_len
= salt_len
;
11860 return (PARSER_OK
);
11863 int sha512crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11865 if (memcmp (SIGNATURE_SHA512CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
11867 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11869 salt_t
*salt
= hash_buf
->salt
;
11871 char *salt_pos
= input_buf
+ 3;
11873 uint iterations_len
= 0;
11875 if (memcmp (salt_pos
, "rounds=", 7) == 0)
11879 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
11881 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
11882 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
11886 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
11890 iterations_len
+= 8;
11894 salt
->salt_iter
= ROUNDS_SHA512CRYPT
;
11897 if ((input_len
< DISPLAY_LEN_MIN_1800
) || (input_len
> DISPLAY_LEN_MAX_1800
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
11899 char *hash_pos
= strchr (salt_pos
, '$');
11901 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11903 uint salt_len
= hash_pos
- salt_pos
;
11905 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
11907 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
11909 salt
->salt_len
= salt_len
;
11913 sha512crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
11915 return (PARSER_OK
);
11918 int keccak_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11920 if ((input_len
< DISPLAY_LEN_MIN_5000
) || (input_len
> DISPLAY_LEN_MAX_5000
)) return (PARSER_GLOBAL_LENGTH
);
11922 if (input_len
% 16) return (PARSER_GLOBAL_LENGTH
);
11924 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
11926 salt_t
*salt
= hash_buf
->salt
;
11928 uint keccak_mdlen
= input_len
/ 2;
11930 for (uint i
= 0; i
< keccak_mdlen
/ 8; i
++)
11932 digest
[i
] = hex_to_uint64_t (&input_buf
[i
* 16]);
11934 digest
[i
] = byte_swap_64 (digest
[i
]);
11937 salt
->keccak_mdlen
= keccak_mdlen
;
11939 return (PARSER_OK
);
11942 int ikepsk_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
11944 if ((input_len
< DISPLAY_LEN_MIN_5300
) || (input_len
> DISPLAY_LEN_MAX_5300
)) return (PARSER_GLOBAL_LENGTH
);
11946 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
11948 salt_t
*salt
= hash_buf
->salt
;
11950 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
11953 * Parse that strange long line
11960 in_off
[0] = strtok (input_buf
, ":");
11962 in_len
[0] = strlen (in_off
[0]);
11966 for (i
= 1; i
< 9; i
++)
11968 in_off
[i
] = strtok (NULL
, ":");
11970 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
11972 in_len
[i
] = strlen (in_off
[i
]);
11977 ptr
= (char *) ikepsk
->msg_buf
;
11979 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_char (in_off
[0] + i
);
11980 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_char (in_off
[1] + i
);
11981 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_char (in_off
[2] + i
);
11982 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_char (in_off
[3] + i
);
11983 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_char (in_off
[4] + i
);
11984 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_char (in_off
[5] + i
);
11988 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
11990 ptr
= (char *) ikepsk
->nr_buf
;
11992 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_char (in_off
[6] + i
);
11993 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_char (in_off
[7] + i
);
11997 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12000 * Store to database
12005 digest
[0] = hex_to_uint (&ptr
[ 0]);
12006 digest
[1] = hex_to_uint (&ptr
[ 8]);
12007 digest
[2] = hex_to_uint (&ptr
[16]);
12008 digest
[3] = hex_to_uint (&ptr
[24]);
12010 digest
[0] = byte_swap_32 (digest
[0]);
12011 digest
[1] = byte_swap_32 (digest
[1]);
12012 digest
[2] = byte_swap_32 (digest
[2]);
12013 digest
[3] = byte_swap_32 (digest
[3]);
12015 salt
->salt_len
= 32;
12017 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12018 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12019 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12020 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12021 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12022 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12023 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12024 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12026 return (PARSER_OK
);
12029 int ikepsk_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12031 if ((input_len
< DISPLAY_LEN_MIN_5400
) || (input_len
> DISPLAY_LEN_MAX_5400
)) return (PARSER_GLOBAL_LENGTH
);
12033 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12035 salt_t
*salt
= hash_buf
->salt
;
12037 ikepsk_t
*ikepsk
= (ikepsk_t
*) hash_buf
->esalt
;
12040 * Parse that strange long line
12047 in_off
[0] = strtok (input_buf
, ":");
12049 in_len
[0] = strlen (in_off
[0]);
12053 for (i
= 1; i
< 9; i
++)
12055 in_off
[i
] = strtok (NULL
, ":");
12057 if (in_off
[i
] == NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12059 in_len
[i
] = strlen (in_off
[i
]);
12064 ptr
= (char *) ikepsk
->msg_buf
;
12066 for (i
= 0; i
< in_len
[0]; i
+= 2) *ptr
++ = hex_to_char (in_off
[0] + i
);
12067 for (i
= 0; i
< in_len
[1]; i
+= 2) *ptr
++ = hex_to_char (in_off
[1] + i
);
12068 for (i
= 0; i
< in_len
[2]; i
+= 2) *ptr
++ = hex_to_char (in_off
[2] + i
);
12069 for (i
= 0; i
< in_len
[3]; i
+= 2) *ptr
++ = hex_to_char (in_off
[3] + i
);
12070 for (i
= 0; i
< in_len
[4]; i
+= 2) *ptr
++ = hex_to_char (in_off
[4] + i
);
12071 for (i
= 0; i
< in_len
[5]; i
+= 2) *ptr
++ = hex_to_char (in_off
[5] + i
);
12075 ikepsk
->msg_len
= (in_len
[0] + in_len
[1] + in_len
[2] + in_len
[3] + in_len
[4] + in_len
[5]) / 2;
12077 ptr
= (char *) ikepsk
->nr_buf
;
12079 for (i
= 0; i
< in_len
[6]; i
+= 2) *ptr
++ = hex_to_char (in_off
[6] + i
);
12080 for (i
= 0; i
< in_len
[7]; i
+= 2) *ptr
++ = hex_to_char (in_off
[7] + i
);
12084 ikepsk
->nr_len
= (in_len
[6] + in_len
[7]) / 2;
12087 * Store to database
12092 digest
[0] = hex_to_uint (&ptr
[ 0]);
12093 digest
[1] = hex_to_uint (&ptr
[ 8]);
12094 digest
[2] = hex_to_uint (&ptr
[16]);
12095 digest
[3] = hex_to_uint (&ptr
[24]);
12096 digest
[4] = hex_to_uint (&ptr
[32]);
12098 salt
->salt_len
= 32;
12100 salt
->salt_buf
[0] = ikepsk
->nr_buf
[0];
12101 salt
->salt_buf
[1] = ikepsk
->nr_buf
[1];
12102 salt
->salt_buf
[2] = ikepsk
->nr_buf
[2];
12103 salt
->salt_buf
[3] = ikepsk
->nr_buf
[3];
12104 salt
->salt_buf
[4] = ikepsk
->nr_buf
[4];
12105 salt
->salt_buf
[5] = ikepsk
->nr_buf
[5];
12106 salt
->salt_buf
[6] = ikepsk
->nr_buf
[6];
12107 salt
->salt_buf
[7] = ikepsk
->nr_buf
[7];
12109 return (PARSER_OK
);
12112 int ripemd160_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12114 if ((input_len
< DISPLAY_LEN_MIN_6000
) || (input_len
> DISPLAY_LEN_MAX_6000
)) return (PARSER_GLOBAL_LENGTH
);
12116 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12118 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12119 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12120 digest
[2] = hex_to_uint (&input_buf
[16]);
12121 digest
[3] = hex_to_uint (&input_buf
[24]);
12122 digest
[4] = hex_to_uint (&input_buf
[32]);
12124 digest
[0] = byte_swap_32 (digest
[0]);
12125 digest
[1] = byte_swap_32 (digest
[1]);
12126 digest
[2] = byte_swap_32 (digest
[2]);
12127 digest
[3] = byte_swap_32 (digest
[3]);
12128 digest
[4] = byte_swap_32 (digest
[4]);
12130 return (PARSER_OK
);
12133 int whirlpool_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12135 if ((input_len
< DISPLAY_LEN_MIN_6100
) || (input_len
> DISPLAY_LEN_MAX_6100
)) return (PARSER_GLOBAL_LENGTH
);
12137 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12139 digest
[ 0] = hex_to_uint (&input_buf
[ 0]);
12140 digest
[ 1] = hex_to_uint (&input_buf
[ 8]);
12141 digest
[ 2] = hex_to_uint (&input_buf
[ 16]);
12142 digest
[ 3] = hex_to_uint (&input_buf
[ 24]);
12143 digest
[ 4] = hex_to_uint (&input_buf
[ 32]);
12144 digest
[ 5] = hex_to_uint (&input_buf
[ 40]);
12145 digest
[ 6] = hex_to_uint (&input_buf
[ 48]);
12146 digest
[ 7] = hex_to_uint (&input_buf
[ 56]);
12147 digest
[ 8] = hex_to_uint (&input_buf
[ 64]);
12148 digest
[ 9] = hex_to_uint (&input_buf
[ 72]);
12149 digest
[10] = hex_to_uint (&input_buf
[ 80]);
12150 digest
[11] = hex_to_uint (&input_buf
[ 88]);
12151 digest
[12] = hex_to_uint (&input_buf
[ 96]);
12152 digest
[13] = hex_to_uint (&input_buf
[104]);
12153 digest
[14] = hex_to_uint (&input_buf
[112]);
12154 digest
[15] = hex_to_uint (&input_buf
[120]);
12156 return (PARSER_OK
);
12159 int androidpin_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12161 if ((input_len
< DISPLAY_LEN_MIN_5800
) || (input_len
> DISPLAY_LEN_MAX_5800
)) return (PARSER_GLOBAL_LENGTH
);
12163 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12165 salt_t
*salt
= hash_buf
->salt
;
12167 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12168 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12169 digest
[2] = hex_to_uint (&input_buf
[16]);
12170 digest
[3] = hex_to_uint (&input_buf
[24]);
12171 digest
[4] = hex_to_uint (&input_buf
[32]);
12173 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12175 uint salt_len
= input_len
- 40 - 1;
12177 char *salt_buf
= input_buf
+ 40 + 1;
12179 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12181 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12183 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12185 salt
->salt_len
= salt_len
;
12187 salt
->salt_iter
= ROUNDS_ANDROIDPIN
- 1;
12189 return (PARSER_OK
);
12192 int truecrypt_parse_hash_1k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12194 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12196 salt_t
*salt
= hash_buf
->salt
;
12198 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12200 if (input_len
== 0)
12202 log_error ("TrueCrypt container not specified");
12207 FILE *fp
= fopen (input_buf
, "rb");
12211 log_error ("%s: %s", input_buf
, strerror (errno
));
12218 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12222 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12224 memcpy (tc
->salt_buf
, buf
, 64);
12226 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12228 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12230 salt
->salt_len
= 4;
12232 salt
->salt_iter
= 1000 - 1;
12234 digest
[0] = tc
->data_buf
[0];
12236 return (PARSER_OK
);
12239 int truecrypt_parse_hash_2k (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12241 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12243 salt_t
*salt
= hash_buf
->salt
;
12245 tc_t
*tc
= (tc_t
*) hash_buf
->esalt
;
12247 if (input_len
== 0)
12249 log_error ("TrueCrypt container not specified");
12254 FILE *fp
= fopen (input_buf
, "rb");
12258 log_error ("%s: %s", input_buf
, strerror (errno
));
12265 int n
= fread (buf
, 1, sizeof (buf
), fp
);
12269 if (n
!= 512) return (PARSER_TC_FILE_SIZE
);
12271 memcpy (tc
->salt_buf
, buf
, 64);
12273 memcpy (tc
->data_buf
, buf
+ 64, 512 - 64);
12275 salt
->salt_buf
[0] = tc
->salt_buf
[0];
12277 salt
->salt_len
= 4;
12279 salt
->salt_iter
= 2000 - 1;
12281 digest
[0] = tc
->data_buf
[0];
12283 return (PARSER_OK
);
12286 int md5aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12288 if ((input_len
< DISPLAY_LEN_MIN_6300
) || (input_len
> DISPLAY_LEN_MAX_6300
)) return (PARSER_GLOBAL_LENGTH
);
12290 if (memcmp (SIGNATURE_MD5AIX
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
12292 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12294 salt_t
*salt
= hash_buf
->salt
;
12296 char *salt_pos
= input_buf
+ 6;
12298 char *hash_pos
= strchr (salt_pos
, '$');
12300 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12302 uint salt_len
= hash_pos
- salt_pos
;
12304 if (salt_len
< 8) return (PARSER_SALT_LENGTH
);
12306 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12308 salt
->salt_len
= salt_len
;
12310 salt
->salt_iter
= 1000;
12314 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12316 return (PARSER_OK
);
12319 int sha1aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12321 if ((input_len
< DISPLAY_LEN_MIN_6700
) || (input_len
> DISPLAY_LEN_MAX_6700
)) return (PARSER_GLOBAL_LENGTH
);
12323 if (memcmp (SIGNATURE_SHA1AIX
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
12325 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12327 salt_t
*salt
= hash_buf
->salt
;
12329 char *iter_pos
= input_buf
+ 7;
12331 char *salt_pos
= strchr (iter_pos
, '$');
12333 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12337 char *hash_pos
= strchr (salt_pos
, '$');
12339 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12341 uint salt_len
= hash_pos
- salt_pos
;
12343 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12345 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12347 salt
->salt_len
= salt_len
;
12349 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12351 salt
->salt_sign
[0] = atoi (salt_iter
);
12353 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12357 sha1aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12359 digest
[0] = byte_swap_32 (digest
[0]);
12360 digest
[1] = byte_swap_32 (digest
[1]);
12361 digest
[2] = byte_swap_32 (digest
[2]);
12362 digest
[3] = byte_swap_32 (digest
[3]);
12363 digest
[4] = byte_swap_32 (digest
[4]);
12365 return (PARSER_OK
);
12368 int sha256aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12370 if ((input_len
< DISPLAY_LEN_MIN_6400
) || (input_len
> DISPLAY_LEN_MAX_6400
)) return (PARSER_GLOBAL_LENGTH
);
12372 if (memcmp (SIGNATURE_SHA256AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12374 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12376 salt_t
*salt
= hash_buf
->salt
;
12378 char *iter_pos
= input_buf
+ 9;
12380 char *salt_pos
= strchr (iter_pos
, '$');
12382 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12386 char *hash_pos
= strchr (salt_pos
, '$');
12388 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12390 uint salt_len
= hash_pos
- salt_pos
;
12392 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12394 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12396 salt
->salt_len
= salt_len
;
12398 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12400 salt
->salt_sign
[0] = atoi (salt_iter
);
12402 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12406 sha256aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12408 digest
[0] = byte_swap_32 (digest
[0]);
12409 digest
[1] = byte_swap_32 (digest
[1]);
12410 digest
[2] = byte_swap_32 (digest
[2]);
12411 digest
[3] = byte_swap_32 (digest
[3]);
12412 digest
[4] = byte_swap_32 (digest
[4]);
12413 digest
[5] = byte_swap_32 (digest
[5]);
12414 digest
[6] = byte_swap_32 (digest
[6]);
12415 digest
[7] = byte_swap_32 (digest
[7]);
12417 return (PARSER_OK
);
12420 int sha512aix_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12422 if ((input_len
< DISPLAY_LEN_MIN_6500
) || (input_len
> DISPLAY_LEN_MAX_6500
)) return (PARSER_GLOBAL_LENGTH
);
12424 if (memcmp (SIGNATURE_SHA512AIX
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12426 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12428 salt_t
*salt
= hash_buf
->salt
;
12430 char *iter_pos
= input_buf
+ 9;
12432 char *salt_pos
= strchr (iter_pos
, '$');
12434 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12438 char *hash_pos
= strchr (salt_pos
, '$');
12440 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12442 uint salt_len
= hash_pos
- salt_pos
;
12444 if (salt_len
< 16) return (PARSER_SALT_LENGTH
);
12446 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12448 salt
->salt_len
= salt_len
;
12450 char salt_iter
[3] = { iter_pos
[0], iter_pos
[1], 0 };
12452 salt
->salt_sign
[0] = atoi (salt_iter
);
12454 salt
->salt_iter
= (1 << atoi (salt_iter
)) - 1;
12458 sha512aix_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12460 digest
[0] = byte_swap_64 (digest
[0]);
12461 digest
[1] = byte_swap_64 (digest
[1]);
12462 digest
[2] = byte_swap_64 (digest
[2]);
12463 digest
[3] = byte_swap_64 (digest
[3]);
12464 digest
[4] = byte_swap_64 (digest
[4]);
12465 digest
[5] = byte_swap_64 (digest
[5]);
12466 digest
[6] = byte_swap_64 (digest
[6]);
12467 digest
[7] = byte_swap_64 (digest
[7]);
12469 return (PARSER_OK
);
12472 int agilekey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12474 if ((input_len
< DISPLAY_LEN_MIN_6600
) || (input_len
> DISPLAY_LEN_MAX_6600
)) return (PARSER_GLOBAL_LENGTH
);
12476 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12478 salt_t
*salt
= hash_buf
->salt
;
12480 agilekey_t
*agilekey
= (agilekey_t
*) hash_buf
->esalt
;
12486 char *iterations_pos
= input_buf
;
12488 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12490 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12492 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12494 if (iterations_len
> 6) return (PARSER_SALT_LENGTH
);
12498 char *cipherbuf_pos
= strchr (saltbuf_pos
, ':');
12500 if (cipherbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12502 uint saltbuf_len
= cipherbuf_pos
- saltbuf_pos
;
12504 if (saltbuf_len
!= 16) return (PARSER_SALT_LENGTH
);
12506 uint cipherbuf_len
= input_len
- iterations_len
- 1 - saltbuf_len
- 1;
12508 if (cipherbuf_len
!= 2080) return (PARSER_HASH_LENGTH
);
12513 * pbkdf2 iterations
12516 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12519 * handle salt encoding
12522 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
12524 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
12526 const char p0
= saltbuf_pos
[i
+ 0];
12527 const char p1
= saltbuf_pos
[i
+ 1];
12529 *saltbuf_ptr
++ = hex_convert (p1
) << 0
12530 | hex_convert (p0
) << 4;
12533 salt
->salt_len
= saltbuf_len
/ 2;
12536 * handle cipher encoding
12539 uint
*tmp
= (uint
*) mymalloc (32);
12541 char *cipherbuf_ptr
= (char *) tmp
;
12543 for (uint i
= 2016; i
< cipherbuf_len
; i
+= 2)
12545 const char p0
= cipherbuf_pos
[i
+ 0];
12546 const char p1
= cipherbuf_pos
[i
+ 1];
12548 *cipherbuf_ptr
++ = hex_convert (p1
) << 0
12549 | hex_convert (p0
) << 4;
12552 // iv is stored at salt_buf 4 (length 16)
12553 // data is stored at salt_buf 8 (length 16)
12555 salt
->salt_buf
[ 4] = byte_swap_32 (tmp
[0]);
12556 salt
->salt_buf
[ 5] = byte_swap_32 (tmp
[1]);
12557 salt
->salt_buf
[ 6] = byte_swap_32 (tmp
[2]);
12558 salt
->salt_buf
[ 7] = byte_swap_32 (tmp
[3]);
12560 salt
->salt_buf
[ 8] = byte_swap_32 (tmp
[4]);
12561 salt
->salt_buf
[ 9] = byte_swap_32 (tmp
[5]);
12562 salt
->salt_buf
[10] = byte_swap_32 (tmp
[6]);
12563 salt
->salt_buf
[11] = byte_swap_32 (tmp
[7]);
12567 for (uint i
= 0, j
= 0; i
< 1040; i
+= 1, j
+= 2)
12569 const char p0
= cipherbuf_pos
[j
+ 0];
12570 const char p1
= cipherbuf_pos
[j
+ 1];
12572 agilekey
->cipher
[i
] = hex_convert (p1
) << 0
12573 | hex_convert (p0
) << 4;
12580 digest
[0] = 0x10101010;
12581 digest
[1] = 0x10101010;
12582 digest
[2] = 0x10101010;
12583 digest
[3] = 0x10101010;
12585 return (PARSER_OK
);
12588 int lastpass_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12590 if ((input_len
< DISPLAY_LEN_MIN_6800
) || (input_len
> DISPLAY_LEN_MAX_6800
)) return (PARSER_GLOBAL_LENGTH
);
12592 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12594 salt_t
*salt
= hash_buf
->salt
;
12596 char *hashbuf_pos
= input_buf
;
12598 char *iterations_pos
= strchr (hashbuf_pos
, ':');
12600 if (iterations_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12602 uint hash_len
= iterations_pos
- hashbuf_pos
;
12604 if ((hash_len
!= 32) && (hash_len
!= 64)) return (PARSER_HASH_LENGTH
);
12608 char *saltbuf_pos
= strchr (iterations_pos
, ':');
12610 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12612 uint iterations_len
= saltbuf_pos
- iterations_pos
;
12616 uint salt_len
= input_len
- hash_len
- 1 - iterations_len
- 1;
12618 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
12620 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12622 salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, salt_len
);
12624 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12626 salt
->salt_len
= salt_len
;
12628 salt
->salt_iter
= atoi (iterations_pos
) - 1;
12630 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
12631 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
12632 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
12633 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
12635 return (PARSER_OK
);
12638 int gost_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12640 if ((input_len
< DISPLAY_LEN_MIN_6900
) || (input_len
> DISPLAY_LEN_MAX_6900
)) return (PARSER_GLOBAL_LENGTH
);
12642 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12644 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12645 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12646 digest
[2] = hex_to_uint (&input_buf
[16]);
12647 digest
[3] = hex_to_uint (&input_buf
[24]);
12648 digest
[4] = hex_to_uint (&input_buf
[32]);
12649 digest
[5] = hex_to_uint (&input_buf
[40]);
12650 digest
[6] = hex_to_uint (&input_buf
[48]);
12651 digest
[7] = hex_to_uint (&input_buf
[56]);
12653 digest
[0] = byte_swap_32 (digest
[0]);
12654 digest
[1] = byte_swap_32 (digest
[1]);
12655 digest
[2] = byte_swap_32 (digest
[2]);
12656 digest
[3] = byte_swap_32 (digest
[3]);
12657 digest
[4] = byte_swap_32 (digest
[4]);
12658 digest
[5] = byte_swap_32 (digest
[5]);
12659 digest
[6] = byte_swap_32 (digest
[6]);
12660 digest
[7] = byte_swap_32 (digest
[7]);
12662 return (PARSER_OK
);
12665 int sha256crypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12667 if (memcmp (SIGNATURE_SHA256CRYPT
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
12669 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12671 salt_t
*salt
= hash_buf
->salt
;
12673 char *salt_pos
= input_buf
+ 3;
12675 uint iterations_len
= 0;
12677 if (memcmp (salt_pos
, "rounds=", 7) == 0)
12681 for (iterations_len
= 0; salt_pos
[0] >= '0' && salt_pos
[0] <= '9' && iterations_len
< 7; iterations_len
++, salt_pos
+= 1) continue;
12683 if (iterations_len
== 0 ) return (PARSER_SALT_ITERATION
);
12684 if (salt_pos
[0] != '$') return (PARSER_SIGNATURE_UNMATCHED
);
12688 salt
->salt_iter
= atoi (salt_pos
- iterations_len
);
12692 iterations_len
+= 8;
12696 salt
->salt_iter
= ROUNDS_SHA256CRYPT
;
12699 if ((input_len
< DISPLAY_LEN_MIN_7400
) || (input_len
> DISPLAY_LEN_MAX_7400
+ iterations_len
)) return (PARSER_GLOBAL_LENGTH
);
12701 char *hash_pos
= strchr (salt_pos
, '$');
12703 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12705 uint salt_len
= hash_pos
- salt_pos
;
12707 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
12709 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
12711 salt
->salt_len
= salt_len
;
12715 sha256crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
12717 return (PARSER_OK
);
12720 int sha512osx_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12722 uint max_len
= DISPLAY_LEN_MAX_7100
+ (2 * 128);
12724 if ((input_len
< DISPLAY_LEN_MIN_7100
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12726 if (memcmp (SIGNATURE_SHA512OSX
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
12728 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12730 salt_t
*salt
= hash_buf
->salt
;
12732 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12734 char *iter_pos
= input_buf
+ 4;
12736 char *salt_pos
= strchr (iter_pos
, '$');
12738 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12742 char *hash_pos
= strchr (salt_pos
, '$');
12744 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12746 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12750 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
12751 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
12752 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
12753 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
12754 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
12755 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
12756 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
12757 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
12759 uint salt_len
= hash_pos
- salt_pos
- 1;
12761 if ((salt_len
% 2) != 0) return (PARSER_SALT_LENGTH
);
12763 salt
->salt_len
= salt_len
/ 2;
12765 pbkdf2_sha512
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
12766 pbkdf2_sha512
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
12767 pbkdf2_sha512
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
12768 pbkdf2_sha512
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
12769 pbkdf2_sha512
->salt_buf
[4] = hex_to_uint (&salt_pos
[32]);
12770 pbkdf2_sha512
->salt_buf
[5] = hex_to_uint (&salt_pos
[40]);
12771 pbkdf2_sha512
->salt_buf
[6] = hex_to_uint (&salt_pos
[48]);
12772 pbkdf2_sha512
->salt_buf
[7] = hex_to_uint (&salt_pos
[56]);
12774 pbkdf2_sha512
->salt_buf
[0] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[0]);
12775 pbkdf2_sha512
->salt_buf
[1] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[1]);
12776 pbkdf2_sha512
->salt_buf
[2] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[2]);
12777 pbkdf2_sha512
->salt_buf
[3] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[3]);
12778 pbkdf2_sha512
->salt_buf
[4] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[4]);
12779 pbkdf2_sha512
->salt_buf
[5] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[5]);
12780 pbkdf2_sha512
->salt_buf
[6] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[6]);
12781 pbkdf2_sha512
->salt_buf
[7] = byte_swap_32 (pbkdf2_sha512
->salt_buf
[7]);
12782 pbkdf2_sha512
->salt_buf
[8] = 0x01000000;
12783 pbkdf2_sha512
->salt_buf
[9] = 0x80;
12785 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12787 salt
->salt_iter
= atoi (iter_pos
) - 1;
12789 return (PARSER_OK
);
12792 int episerver4_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12794 if ((input_len
< DISPLAY_LEN_MIN_1441
) || (input_len
> DISPLAY_LEN_MAX_1441
)) return (PARSER_GLOBAL_LENGTH
);
12796 if (memcmp (SIGNATURE_EPISERVER4
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
12798 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12800 salt_t
*salt
= hash_buf
->salt
;
12802 char *salt_pos
= input_buf
+ 14;
12804 char *hash_pos
= strchr (salt_pos
, '*');
12806 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12810 uint salt_len
= hash_pos
- salt_pos
- 1;
12812 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12814 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
12816 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12818 salt
->salt_len
= salt_len
;
12820 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
12822 base64_decode (base64_to_int
, hash_pos
, 43, tmp_buf
);
12824 memcpy (digest
, tmp_buf
, 32);
12826 digest
[0] = byte_swap_32 (digest
[0]);
12827 digest
[1] = byte_swap_32 (digest
[1]);
12828 digest
[2] = byte_swap_32 (digest
[2]);
12829 digest
[3] = byte_swap_32 (digest
[3]);
12830 digest
[4] = byte_swap_32 (digest
[4]);
12831 digest
[5] = byte_swap_32 (digest
[5]);
12832 digest
[6] = byte_swap_32 (digest
[6]);
12833 digest
[7] = byte_swap_32 (digest
[7]);
12835 digest
[0] -= SHA256M_A
;
12836 digest
[1] -= SHA256M_B
;
12837 digest
[2] -= SHA256M_C
;
12838 digest
[3] -= SHA256M_D
;
12839 digest
[4] -= SHA256M_E
;
12840 digest
[5] -= SHA256M_F
;
12841 digest
[6] -= SHA256M_G
;
12842 digest
[7] -= SHA256M_H
;
12844 return (PARSER_OK
);
12847 int sha512grub_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12849 uint max_len
= DISPLAY_LEN_MAX_7200
+ (8 * 128);
12851 if ((input_len
< DISPLAY_LEN_MIN_7200
) || (input_len
> max_len
)) return (PARSER_GLOBAL_LENGTH
);
12853 if (memcmp (SIGNATURE_SHA512GRUB
, input_buf
, 19)) return (PARSER_SIGNATURE_UNMATCHED
);
12855 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12857 salt_t
*salt
= hash_buf
->salt
;
12859 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
12861 char *iter_pos
= input_buf
+ 19;
12863 char *salt_pos
= strchr (iter_pos
, '.');
12865 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12869 char *hash_pos
= strchr (salt_pos
, '.');
12871 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
12873 if (((input_len
- (hash_pos
- input_buf
) - 1) % 128) != 0) return (PARSER_GLOBAL_LENGTH
);
12877 digest
[0] = hex_to_uint64_t (&hash_pos
[ 0]);
12878 digest
[1] = hex_to_uint64_t (&hash_pos
[ 16]);
12879 digest
[2] = hex_to_uint64_t (&hash_pos
[ 32]);
12880 digest
[3] = hex_to_uint64_t (&hash_pos
[ 48]);
12881 digest
[4] = hex_to_uint64_t (&hash_pos
[ 64]);
12882 digest
[5] = hex_to_uint64_t (&hash_pos
[ 80]);
12883 digest
[6] = hex_to_uint64_t (&hash_pos
[ 96]);
12884 digest
[7] = hex_to_uint64_t (&hash_pos
[112]);
12886 uint salt_len
= hash_pos
- salt_pos
- 1;
12890 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
12894 for (i
= 0; i
< salt_len
; i
++)
12896 salt_buf_ptr
[i
] = hex_to_char (&salt_pos
[i
* 2]);
12899 salt_buf_ptr
[salt_len
+ 3] = 0x01;
12900 salt_buf_ptr
[salt_len
+ 4] = 0x80;
12902 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
12904 salt
->salt_len
= salt_len
;
12906 salt
->salt_iter
= atoi (iter_pos
) - 1;
12908 return (PARSER_OK
);
12911 int sha512b64s_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12913 if ((input_len
< DISPLAY_LEN_MIN_1711
) || (input_len
> DISPLAY_LEN_MAX_1711
)) return (PARSER_GLOBAL_LENGTH
);
12915 if (memcmp (SIGNATURE_SHA512B64S
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
12917 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
12919 salt_t
*salt
= hash_buf
->salt
;
12923 memset (tmp_buf
, 0, sizeof (tmp_buf
));
12925 int tmp_len
= base64_decode (base64_to_int
, input_buf
+ 9, input_len
- 9, tmp_buf
);
12927 memcpy (digest
, tmp_buf
, 64);
12929 digest
[0] = byte_swap_64 (digest
[0]);
12930 digest
[1] = byte_swap_64 (digest
[1]);
12931 digest
[2] = byte_swap_64 (digest
[2]);
12932 digest
[3] = byte_swap_64 (digest
[3]);
12933 digest
[4] = byte_swap_64 (digest
[4]);
12934 digest
[5] = byte_swap_64 (digest
[5]);
12935 digest
[6] = byte_swap_64 (digest
[6]);
12936 digest
[7] = byte_swap_64 (digest
[7]);
12938 digest
[0] -= SHA512M_A
;
12939 digest
[1] -= SHA512M_B
;
12940 digest
[2] -= SHA512M_C
;
12941 digest
[3] -= SHA512M_D
;
12942 digest
[4] -= SHA512M_E
;
12943 digest
[5] -= SHA512M_F
;
12944 digest
[6] -= SHA512M_G
;
12945 digest
[7] -= SHA512M_H
;
12947 salt
->salt_len
= tmp_len
- 64;
12949 memcpy (salt
->salt_buf
, tmp_buf
+ 64, salt
->salt_len
);
12951 if (data
.opts_type
& OPTS_TYPE_ST_ADD80
)
12953 char *ptr
= (char *) salt
->salt_buf
;
12955 ptr
[salt
->salt_len
] = 0x80;
12958 return (PARSER_OK
);
12961 int hmacmd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
12963 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
12965 if ((input_len
< DISPLAY_LEN_MIN_50H
) || (input_len
> DISPLAY_LEN_MAX_50H
)) return (PARSER_GLOBAL_LENGTH
);
12969 if ((input_len
< DISPLAY_LEN_MIN_50
) || (input_len
> DISPLAY_LEN_MAX_50
)) return (PARSER_GLOBAL_LENGTH
);
12972 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
12974 salt_t
*salt
= hash_buf
->salt
;
12976 digest
[0] = hex_to_uint (&input_buf
[ 0]);
12977 digest
[1] = hex_to_uint (&input_buf
[ 8]);
12978 digest
[2] = hex_to_uint (&input_buf
[16]);
12979 digest
[3] = hex_to_uint (&input_buf
[24]);
12981 digest
[0] = byte_swap_32 (digest
[0]);
12982 digest
[1] = byte_swap_32 (digest
[1]);
12983 digest
[2] = byte_swap_32 (digest
[2]);
12984 digest
[3] = byte_swap_32 (digest
[3]);
12986 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
12988 uint salt_len
= input_len
- 32 - 1;
12990 char *salt_buf
= input_buf
+ 32 + 1;
12992 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
12994 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
12996 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
12998 salt
->salt_len
= salt_len
;
13000 return (PARSER_OK
);
13003 int hmacsha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13005 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13007 if ((input_len
< DISPLAY_LEN_MIN_150H
) || (input_len
> DISPLAY_LEN_MAX_150H
)) return (PARSER_GLOBAL_LENGTH
);
13011 if ((input_len
< DISPLAY_LEN_MIN_150
) || (input_len
> DISPLAY_LEN_MAX_150
)) return (PARSER_GLOBAL_LENGTH
);
13014 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13016 salt_t
*salt
= hash_buf
->salt
;
13018 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13019 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13020 digest
[2] = hex_to_uint (&input_buf
[16]);
13021 digest
[3] = hex_to_uint (&input_buf
[24]);
13022 digest
[4] = hex_to_uint (&input_buf
[32]);
13024 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13026 uint salt_len
= input_len
- 40 - 1;
13028 char *salt_buf
= input_buf
+ 40 + 1;
13030 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13032 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13034 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13036 salt
->salt_len
= salt_len
;
13038 return (PARSER_OK
);
13041 int hmacsha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13043 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13045 if ((input_len
< DISPLAY_LEN_MIN_1450H
) || (input_len
> DISPLAY_LEN_MAX_1450H
)) return (PARSER_GLOBAL_LENGTH
);
13049 if ((input_len
< DISPLAY_LEN_MIN_1450
) || (input_len
> DISPLAY_LEN_MAX_1450
)) return (PARSER_GLOBAL_LENGTH
);
13052 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13054 salt_t
*salt
= hash_buf
->salt
;
13056 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13057 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13058 digest
[2] = hex_to_uint (&input_buf
[16]);
13059 digest
[3] = hex_to_uint (&input_buf
[24]);
13060 digest
[4] = hex_to_uint (&input_buf
[32]);
13061 digest
[5] = hex_to_uint (&input_buf
[40]);
13062 digest
[6] = hex_to_uint (&input_buf
[48]);
13063 digest
[7] = hex_to_uint (&input_buf
[56]);
13065 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13067 uint salt_len
= input_len
- 64 - 1;
13069 char *salt_buf
= input_buf
+ 64 + 1;
13071 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13073 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13075 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13077 salt
->salt_len
= salt_len
;
13079 return (PARSER_OK
);
13082 int hmacsha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13084 if (data
.opts_type
& OPTS_TYPE_ST_HEX
)
13086 if ((input_len
< DISPLAY_LEN_MIN_1750H
) || (input_len
> DISPLAY_LEN_MAX_1750H
)) return (PARSER_GLOBAL_LENGTH
);
13090 if ((input_len
< DISPLAY_LEN_MIN_1750
) || (input_len
> DISPLAY_LEN_MAX_1750
)) return (PARSER_GLOBAL_LENGTH
);
13093 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
13095 salt_t
*salt
= hash_buf
->salt
;
13097 digest
[0] = hex_to_uint64_t (&input_buf
[ 0]);
13098 digest
[1] = hex_to_uint64_t (&input_buf
[ 16]);
13099 digest
[2] = hex_to_uint64_t (&input_buf
[ 32]);
13100 digest
[3] = hex_to_uint64_t (&input_buf
[ 48]);
13101 digest
[4] = hex_to_uint64_t (&input_buf
[ 64]);
13102 digest
[5] = hex_to_uint64_t (&input_buf
[ 80]);
13103 digest
[6] = hex_to_uint64_t (&input_buf
[ 96]);
13104 digest
[7] = hex_to_uint64_t (&input_buf
[112]);
13106 if (input_buf
[128] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13108 uint salt_len
= input_len
- 128 - 1;
13110 char *salt_buf
= input_buf
+ 128 + 1;
13112 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13114 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13116 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13118 salt
->salt_len
= salt_len
;
13120 return (PARSER_OK
);
13123 int krb5pa_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13125 if ((input_len
< DISPLAY_LEN_MIN_7500
) || (input_len
> DISPLAY_LEN_MAX_7500
)) return (PARSER_GLOBAL_LENGTH
);
13127 if (memcmp (SIGNATURE_KRB5PA
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
13129 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13131 salt_t
*salt
= hash_buf
->salt
;
13133 krb5pa_t
*krb5pa
= (krb5pa_t
*) hash_buf
->esalt
;
13139 char *user_pos
= input_buf
+ 10 + 1;
13141 char *realm_pos
= strchr (user_pos
, '$');
13143 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13145 uint user_len
= realm_pos
- user_pos
;
13147 if (user_len
>= 64) return (PARSER_SALT_LENGTH
);
13151 char *salt_pos
= strchr (realm_pos
, '$');
13153 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13155 uint realm_len
= salt_pos
- realm_pos
;
13157 if (realm_len
>= 64) return (PARSER_SALT_LENGTH
);
13161 char *data_pos
= strchr (salt_pos
, '$');
13163 if (data_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13165 uint salt_len
= data_pos
- salt_pos
;
13167 if (salt_len
>= 128) return (PARSER_SALT_LENGTH
);
13171 uint data_len
= input_len
- 10 - 1 - user_len
- 1 - realm_len
- 1 - salt_len
- 1;
13173 if (data_len
!= ((36 + 16) * 2)) return (PARSER_SALT_LENGTH
);
13179 memcpy (krb5pa
->user
, user_pos
, user_len
);
13180 memcpy (krb5pa
->realm
, realm_pos
, realm_len
);
13181 memcpy (krb5pa
->salt
, salt_pos
, salt_len
);
13183 char *timestamp_ptr
= (char *) krb5pa
->timestamp
;
13185 for (uint i
= 0; i
< (36 * 2); i
+= 2)
13187 const char p0
= data_pos
[i
+ 0];
13188 const char p1
= data_pos
[i
+ 1];
13190 *timestamp_ptr
++ = hex_convert (p1
) << 0
13191 | hex_convert (p0
) << 4;
13194 char *checksum_ptr
= (char *) krb5pa
->checksum
;
13196 for (uint i
= (36 * 2); i
< ((36 + 16) * 2); i
+= 2)
13198 const char p0
= data_pos
[i
+ 0];
13199 const char p1
= data_pos
[i
+ 1];
13201 *checksum_ptr
++ = hex_convert (p1
) << 0
13202 | hex_convert (p0
) << 4;
13206 * copy some data to generic buffers to make sorting happy
13209 salt
->salt_buf
[0] = krb5pa
->timestamp
[0];
13210 salt
->salt_buf
[1] = krb5pa
->timestamp
[1];
13211 salt
->salt_buf
[2] = krb5pa
->timestamp
[2];
13212 salt
->salt_buf
[3] = krb5pa
->timestamp
[3];
13213 salt
->salt_buf
[4] = krb5pa
->timestamp
[4];
13214 salt
->salt_buf
[5] = krb5pa
->timestamp
[5];
13215 salt
->salt_buf
[6] = krb5pa
->timestamp
[6];
13216 salt
->salt_buf
[7] = krb5pa
->timestamp
[7];
13217 salt
->salt_buf
[8] = krb5pa
->timestamp
[8];
13219 salt
->salt_len
= 36;
13221 digest
[0] = krb5pa
->checksum
[0];
13222 digest
[1] = krb5pa
->checksum
[1];
13223 digest
[2] = krb5pa
->checksum
[2];
13224 digest
[3] = krb5pa
->checksum
[3];
13226 return (PARSER_OK
);
13229 int sapb_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13231 if ((input_len
< DISPLAY_LEN_MIN_7700
) || (input_len
> DISPLAY_LEN_MAX_7700
)) return (PARSER_GLOBAL_LENGTH
);
13233 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13235 salt_t
*salt
= hash_buf
->salt
;
13241 char *salt_pos
= input_buf
;
13243 char *hash_pos
= strchr (salt_pos
, '$');
13245 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13247 uint salt_len
= hash_pos
- salt_pos
;
13249 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13253 uint hash_len
= input_len
- 1 - salt_len
;
13255 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13263 for (uint i
= 0; i
< salt_len
; i
++)
13265 if (salt_pos
[i
] == ' ') continue;
13270 // SAP user names cannot be longer than 12 characters
13271 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13273 // SAP user name cannot start with ! or ?
13274 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13280 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13282 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13284 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13286 salt
->salt_len
= salt_len
;
13288 digest
[0] = hex_to_uint (&hash_pos
[0]);
13289 digest
[1] = hex_to_uint (&hash_pos
[8]);
13293 digest
[0] = byte_swap_32 (digest
[0]);
13294 digest
[1] = byte_swap_32 (digest
[1]);
13296 return (PARSER_OK
);
13299 int sapg_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13301 if ((input_len
< DISPLAY_LEN_MIN_7800
) || (input_len
> DISPLAY_LEN_MAX_7800
)) return (PARSER_GLOBAL_LENGTH
);
13303 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13305 salt_t
*salt
= hash_buf
->salt
;
13311 char *salt_pos
= input_buf
;
13313 char *hash_pos
= strchr (salt_pos
, '$');
13315 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13317 uint salt_len
= hash_pos
- salt_pos
;
13319 if (salt_len
>= 40) return (PARSER_SALT_LENGTH
);
13323 uint hash_len
= input_len
- 1 - salt_len
;
13325 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
13333 for (uint i
= 0; i
< salt_len
; i
++)
13335 if (salt_pos
[i
] == ' ') continue;
13340 // SAP user names cannot be longer than 12 characters
13341 if (user_len
> 12) return (PARSER_SALT_LENGTH
);
13343 // SAP user name cannot start with ! or ?
13344 if (salt_pos
[0] == '!' || salt_pos
[0] == '?') return (PARSER_SALT_VALUE
);
13350 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13352 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13354 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13356 salt
->salt_len
= salt_len
;
13358 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13359 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13360 digest
[2] = hex_to_uint (&hash_pos
[16]);
13361 digest
[3] = hex_to_uint (&hash_pos
[24]);
13362 digest
[4] = hex_to_uint (&hash_pos
[32]);
13364 return (PARSER_OK
);
13367 int drupal7_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13369 if ((input_len
< DISPLAY_LEN_MIN_7900
) || (input_len
> DISPLAY_LEN_MAX_7900
)) return (PARSER_GLOBAL_LENGTH
);
13371 if (memcmp (SIGNATURE_DRUPAL7
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
13373 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
13375 salt_t
*salt
= hash_buf
->salt
;
13377 char *iter_pos
= input_buf
+ 3;
13379 uint salt_iter
= 1 << itoa64_to_int (iter_pos
[0]);
13381 if (salt_iter
> 0x80000000) return (PARSER_SALT_ITERATION
);
13383 memcpy ((char *) salt
->salt_sign
, input_buf
, 4);
13385 salt
->salt_iter
= salt_iter
;
13387 char *salt_pos
= iter_pos
+ 1;
13391 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt_len
);
13393 salt
->salt_len
= salt_len
;
13395 char *hash_pos
= salt_pos
+ salt_len
;
13397 drupal7_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
13401 char *tmp
= (char *) salt
->salt_buf_pc
;
13403 tmp
[0] = hash_pos
[42];
13407 digest
[ 0] = byte_swap_64 (digest
[ 0]);
13408 digest
[ 1] = byte_swap_64 (digest
[ 1]);
13409 digest
[ 2] = byte_swap_64 (digest
[ 2]);
13410 digest
[ 3] = byte_swap_64 (digest
[ 3]);
13416 return (PARSER_OK
);
13419 int sybasease_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13421 if ((input_len
< DISPLAY_LEN_MIN_8000
) || (input_len
> DISPLAY_LEN_MAX_8000
)) return (PARSER_GLOBAL_LENGTH
);
13423 if (memcmp (SIGNATURE_SYBASEASE
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13425 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13427 salt_t
*salt
= hash_buf
->salt
;
13429 char *salt_buf
= input_buf
+ 6;
13431 uint salt_len
= 16;
13433 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13435 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13437 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13439 salt
->salt_len
= salt_len
;
13441 char *hash_pos
= input_buf
+ 6 + 16;
13443 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13444 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13445 digest
[2] = hex_to_uint (&hash_pos
[16]);
13446 digest
[3] = hex_to_uint (&hash_pos
[24]);
13447 digest
[4] = hex_to_uint (&hash_pos
[32]);
13448 digest
[5] = hex_to_uint (&hash_pos
[40]);
13449 digest
[6] = hex_to_uint (&hash_pos
[48]);
13450 digest
[7] = hex_to_uint (&hash_pos
[56]);
13452 return (PARSER_OK
);
13455 int mysql323_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13457 if ((input_len
< DISPLAY_LEN_MIN_200
) || (input_len
> DISPLAY_LEN_MAX_200
)) return (PARSER_GLOBAL_LENGTH
);
13459 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13461 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13462 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13466 return (PARSER_OK
);
13469 int rakp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13471 if ((input_len
< DISPLAY_LEN_MIN_7300
) || (input_len
> DISPLAY_LEN_MAX_7300
)) return (PARSER_GLOBAL_LENGTH
);
13473 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13475 salt_t
*salt
= hash_buf
->salt
;
13477 rakp_t
*rakp
= (rakp_t
*) hash_buf
->esalt
;
13479 char *saltbuf_pos
= input_buf
;
13481 char *hashbuf_pos
= strchr (saltbuf_pos
, ':');
13483 if (hashbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13485 uint saltbuf_len
= hashbuf_pos
- saltbuf_pos
;
13487 if (saltbuf_len
< 64) return (PARSER_SALT_LENGTH
);
13488 if (saltbuf_len
> 512) return (PARSER_SALT_LENGTH
);
13490 if (saltbuf_len
& 1) return (PARSER_SALT_LENGTH
); // muss gerade sein wegen hex
13494 uint hashbuf_len
= input_len
- saltbuf_len
- 1;
13496 if (hashbuf_len
!= 40) return (PARSER_HASH_LENGTH
);
13498 char *salt_ptr
= (char *) saltbuf_pos
;
13499 char *rakp_ptr
= (char *) rakp
->salt_buf
;
13504 for (i
= 0, j
= 0; i
< saltbuf_len
; i
+= 2, j
+= 1)
13506 rakp_ptr
[j
] = hex_to_char (&salt_ptr
[i
]);
13509 rakp_ptr
[j
] = 0x80;
13511 rakp
->salt_len
= j
;
13513 for (i
= 0; i
< 64; i
++)
13515 rakp
->salt_buf
[i
] = byte_swap_32 (rakp
->salt_buf
[i
]);
13518 salt
->salt_buf
[0] = rakp
->salt_buf
[0];
13519 salt
->salt_buf
[1] = rakp
->salt_buf
[1];
13520 salt
->salt_buf
[2] = rakp
->salt_buf
[2];
13521 salt
->salt_buf
[3] = rakp
->salt_buf
[3];
13522 salt
->salt_buf
[4] = rakp
->salt_buf
[4];
13523 salt
->salt_buf
[5] = rakp
->salt_buf
[5];
13524 salt
->salt_buf
[6] = rakp
->salt_buf
[6];
13525 salt
->salt_buf
[7] = rakp
->salt_buf
[7];
13527 salt
->salt_len
= 32; // muss min. 32 haben
13529 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
13530 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
13531 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
13532 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
13533 digest
[4] = hex_to_uint (&hashbuf_pos
[32]);
13535 return (PARSER_OK
);
13538 int netscaler_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13540 if ((input_len
< DISPLAY_LEN_MIN_8100
) || (input_len
> DISPLAY_LEN_MAX_8100
)) return (PARSER_GLOBAL_LENGTH
);
13542 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13544 salt_t
*salt
= hash_buf
->salt
;
13546 if (memcmp (SIGNATURE_NETSCALER
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
13548 char *salt_pos
= input_buf
+ 1;
13550 memcpy (salt
->salt_buf
, salt_pos
, 8);
13552 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
13553 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
13555 salt
->salt_len
= 8;
13557 char *hash_pos
= salt_pos
+ 8;
13559 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
13560 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
13561 digest
[2] = hex_to_uint (&hash_pos
[16]);
13562 digest
[3] = hex_to_uint (&hash_pos
[24]);
13563 digest
[4] = hex_to_uint (&hash_pos
[32]);
13565 digest
[0] -= SHA1M_A
;
13566 digest
[1] -= SHA1M_B
;
13567 digest
[2] -= SHA1M_C
;
13568 digest
[3] -= SHA1M_D
;
13569 digest
[4] -= SHA1M_E
;
13571 return (PARSER_OK
);
13574 int chap_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13576 if ((input_len
< DISPLAY_LEN_MIN_4800
) || (input_len
> DISPLAY_LEN_MAX_4800
)) return (PARSER_GLOBAL_LENGTH
);
13578 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13580 salt_t
*salt
= hash_buf
->salt
;
13582 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13583 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13584 digest
[2] = hex_to_uint (&input_buf
[16]);
13585 digest
[3] = hex_to_uint (&input_buf
[24]);
13587 digest
[0] = byte_swap_32 (digest
[0]);
13588 digest
[1] = byte_swap_32 (digest
[1]);
13589 digest
[2] = byte_swap_32 (digest
[2]);
13590 digest
[3] = byte_swap_32 (digest
[3]);
13592 digest
[0] -= MD5M_A
;
13593 digest
[1] -= MD5M_B
;
13594 digest
[2] -= MD5M_C
;
13595 digest
[3] -= MD5M_D
;
13597 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13599 char *salt_buf_ptr
= input_buf
+ 32 + 1;
13601 uint32_t *salt_buf
= salt
->salt_buf
;
13603 salt_buf
[0] = hex_to_uint (&salt_buf_ptr
[ 0]);
13604 salt_buf
[1] = hex_to_uint (&salt_buf_ptr
[ 8]);
13605 salt_buf
[2] = hex_to_uint (&salt_buf_ptr
[16]);
13606 salt_buf
[3] = hex_to_uint (&salt_buf_ptr
[24]);
13608 salt_buf
[0] = byte_swap_32 (salt_buf
[0]);
13609 salt_buf
[1] = byte_swap_32 (salt_buf
[1]);
13610 salt_buf
[2] = byte_swap_32 (salt_buf
[2]);
13611 salt_buf
[3] = byte_swap_32 (salt_buf
[3]);
13613 salt
->salt_len
= 16 + 1;
13615 if (input_buf
[65] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13617 char *idbyte_buf_ptr
= input_buf
+ 32 + 1 + 32 + 1;
13619 salt_buf
[4] = hex_to_char (&idbyte_buf_ptr
[0]) & 0xff;
13621 return (PARSER_OK
);
13624 int cloudkey_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13626 if ((input_len
< DISPLAY_LEN_MIN_8200
) || (input_len
> DISPLAY_LEN_MAX_8200
)) return (PARSER_GLOBAL_LENGTH
);
13628 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13630 salt_t
*salt
= hash_buf
->salt
;
13632 cloudkey_t
*cloudkey
= (cloudkey_t
*) hash_buf
->esalt
;
13638 char *hashbuf_pos
= input_buf
;
13640 char *saltbuf_pos
= strchr (hashbuf_pos
, ':');
13642 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13644 const uint hashbuf_len
= saltbuf_pos
- hashbuf_pos
;
13646 if (hashbuf_len
!= 64) return (PARSER_HASH_LENGTH
);
13650 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13652 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13654 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13656 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
13660 char *databuf_pos
= strchr (iteration_pos
, ':');
13662 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13664 const uint iteration_len
= databuf_pos
- iteration_pos
;
13666 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13667 if (iteration_len
> 8) return (PARSER_SALT_ITERATION
);
13669 const uint databuf_len
= input_len
- hashbuf_len
- 1 - saltbuf_len
- 1 - iteration_len
- 1;
13671 if (databuf_len
< 1) return (PARSER_SALT_LENGTH
);
13672 if (databuf_len
> 2048) return (PARSER_SALT_LENGTH
);
13678 digest
[0] = hex_to_uint (&hashbuf_pos
[ 0]);
13679 digest
[1] = hex_to_uint (&hashbuf_pos
[ 8]);
13680 digest
[2] = hex_to_uint (&hashbuf_pos
[16]);
13681 digest
[3] = hex_to_uint (&hashbuf_pos
[24]);
13682 digest
[4] = hex_to_uint (&hashbuf_pos
[32]);
13683 digest
[5] = hex_to_uint (&hashbuf_pos
[40]);
13684 digest
[6] = hex_to_uint (&hashbuf_pos
[48]);
13685 digest
[7] = hex_to_uint (&hashbuf_pos
[56]);
13689 char *saltbuf_ptr
= (char *) salt
->salt_buf
;
13691 for (uint i
= 0; i
< saltbuf_len
; i
+= 2)
13693 const char p0
= saltbuf_pos
[i
+ 0];
13694 const char p1
= saltbuf_pos
[i
+ 1];
13696 *saltbuf_ptr
++ = hex_convert (p1
) << 0
13697 | hex_convert (p0
) << 4;
13700 salt
->salt_buf
[4] = 0x01000000;
13701 salt
->salt_buf
[5] = 0x80;
13703 salt
->salt_len
= saltbuf_len
/ 2;
13707 salt
->salt_iter
= atoi (iteration_pos
) - 1;
13711 char *databuf_ptr
= (char *) cloudkey
->data_buf
;
13713 for (uint i
= 0; i
< databuf_len
; i
+= 2)
13715 const char p0
= databuf_pos
[i
+ 0];
13716 const char p1
= databuf_pos
[i
+ 1];
13718 *databuf_ptr
++ = hex_convert (p1
) << 0
13719 | hex_convert (p0
) << 4;
13722 *databuf_ptr
++ = 0x80;
13724 for (uint i
= 0; i
< 512; i
++)
13726 cloudkey
->data_buf
[i
] = byte_swap_32 (cloudkey
->data_buf
[i
]);
13729 cloudkey
->data_len
= databuf_len
/ 2;
13731 return (PARSER_OK
);
13734 int nsec3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13736 if ((input_len
< DISPLAY_LEN_MIN_8300
) || (input_len
> DISPLAY_LEN_MAX_8300
)) return (PARSER_GLOBAL_LENGTH
);
13738 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13740 salt_t
*salt
= hash_buf
->salt
;
13746 char *hashbuf_pos
= input_buf
;
13748 char *domainbuf_pos
= strchr (hashbuf_pos
, ':');
13750 if (domainbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13752 const uint hashbuf_len
= domainbuf_pos
- hashbuf_pos
;
13754 if (hashbuf_len
!= 32) return (PARSER_HASH_LENGTH
);
13758 if (domainbuf_pos
[0] != '.') return (PARSER_SALT_VALUE
);
13760 char *saltbuf_pos
= strchr (domainbuf_pos
, ':');
13762 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13764 const uint domainbuf_len
= saltbuf_pos
- domainbuf_pos
;
13766 if (domainbuf_len
>= 32) return (PARSER_SALT_LENGTH
);
13770 char *iteration_pos
= strchr (saltbuf_pos
, ':');
13772 if (iteration_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13774 const uint saltbuf_len
= iteration_pos
- saltbuf_pos
;
13776 if (saltbuf_len
>= 28) return (PARSER_SALT_LENGTH
); // 28 = 32 - 4; 4 = length
13778 if ((domainbuf_len
+ saltbuf_len
) >= 48) return (PARSER_SALT_LENGTH
);
13782 const uint iteration_len
= input_len
- hashbuf_len
- 1 - domainbuf_len
- 1 - saltbuf_len
- 1;
13784 if (iteration_len
< 1) return (PARSER_SALT_ITERATION
);
13785 if (iteration_len
> 5) return (PARSER_SALT_ITERATION
);
13787 // ok, the plan for this algorithm is the following:
13788 // we have 2 salts here, the domain-name and a random salt
13789 // while both are used in the initial transformation,
13790 // only the random salt is used in the following iterations
13791 // so we create two buffer, one that includes domain-name (stored into salt_buf_pc[])
13792 // and one that includes only the real salt (stored into salt_buf[]).
13793 // the domain-name length is put into array position 7 of salt_buf_pc[] since there is not salt_pc_len
13795 char tmp_buf
[100]; memset (tmp_buf
, 0, sizeof (tmp_buf
));
13797 base32_decode (itoa32_to_int
, hashbuf_pos
, 32, tmp_buf
);
13799 memcpy (digest
, tmp_buf
, 20);
13801 digest
[0] = byte_swap_32 (digest
[0]);
13802 digest
[1] = byte_swap_32 (digest
[1]);
13803 digest
[2] = byte_swap_32 (digest
[2]);
13804 digest
[3] = byte_swap_32 (digest
[3]);
13805 digest
[4] = byte_swap_32 (digest
[4]);
13809 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13811 memcpy (salt_buf_pc_ptr
, domainbuf_pos
, domainbuf_len
);
13813 char *len_ptr
= NULL
;
13815 for (uint i
= 0; i
< domainbuf_len
; i
++)
13817 if (salt_buf_pc_ptr
[i
] == '.')
13819 len_ptr
= &salt_buf_pc_ptr
[i
];
13829 salt
->salt_buf_pc
[7] = domainbuf_len
;
13833 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13835 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, saltbuf_pos
, saltbuf_len
);
13837 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13839 salt
->salt_len
= salt_len
;
13843 salt
->salt_iter
= atoi (iteration_pos
);
13845 return (PARSER_OK
);
13848 int wbb3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13850 if ((input_len
< DISPLAY_LEN_MIN_8400
) || (input_len
> DISPLAY_LEN_MAX_8400
)) return (PARSER_GLOBAL_LENGTH
);
13852 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13854 salt_t
*salt
= hash_buf
->salt
;
13856 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13857 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13858 digest
[2] = hex_to_uint (&input_buf
[16]);
13859 digest
[3] = hex_to_uint (&input_buf
[24]);
13860 digest
[4] = hex_to_uint (&input_buf
[32]);
13862 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
13864 uint salt_len
= input_len
- 40 - 1;
13866 char *salt_buf
= input_buf
+ 40 + 1;
13868 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13870 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
13872 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13874 salt
->salt_len
= salt_len
;
13876 return (PARSER_OK
);
13879 int racf_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13881 const uint8_t ascii_to_ebcdic
[] =
13883 0x00, 0x01, 0x02, 0x03, 0x37, 0x2d, 0x2e, 0x2f, 0x16, 0x05, 0x25, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
13884 0x10, 0x11, 0x12, 0x13, 0x3c, 0x3d, 0x32, 0x26, 0x18, 0x19, 0x3f, 0x27, 0x1c, 0x1d, 0x1e, 0x1f,
13885 0x40, 0x4f, 0x7f, 0x7b, 0x5b, 0x6c, 0x50, 0x7d, 0x4d, 0x5d, 0x5c, 0x4e, 0x6b, 0x60, 0x4b, 0x61,
13886 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0x7a, 0x5e, 0x4c, 0x7e, 0x6e, 0x6f,
13887 0x7c, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6,
13888 0xd7, 0xd8, 0xd9, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0x4a, 0xe0, 0x5a, 0x5f, 0x6d,
13889 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
13890 0x97, 0x98, 0x99, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xc0, 0x6a, 0xd0, 0xa1, 0x07,
13891 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x09, 0x0a, 0x1b,
13892 0x30, 0x31, 0x1a, 0x33, 0x34, 0x35, 0x36, 0x08, 0x38, 0x39, 0x3a, 0x3b, 0x04, 0x14, 0x3e, 0xe1,
13893 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
13894 0x58, 0x59, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75,
13895 0x76, 0x77, 0x78, 0x80, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e,
13896 0x9f, 0xa0, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
13897 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xda, 0xdb,
13898 0xdc, 0xdd, 0xde, 0xdf, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
13901 if ((input_len
< DISPLAY_LEN_MIN_8500
) || (input_len
> DISPLAY_LEN_MAX_8500
)) return (PARSER_GLOBAL_LENGTH
);
13903 if (memcmp (SIGNATURE_RACF
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
13905 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13907 salt_t
*salt
= hash_buf
->salt
;
13909 char *salt_pos
= input_buf
+ 6 + 1;
13911 char *digest_pos
= strchr (salt_pos
, '*');
13913 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
13915 uint salt_len
= digest_pos
- salt_pos
;
13917 if (salt_len
> 8) return (PARSER_SALT_LENGTH
);
13919 uint hash_len
= input_len
- 1 - salt_len
- 1 - 6;
13921 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
13925 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
13926 char *salt_buf_pc_ptr
= (char *) salt
->salt_buf_pc
;
13928 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
13930 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
13932 salt
->salt_len
= salt_len
;
13934 for (uint i
= 0; i
< salt_len
; i
++)
13936 salt_buf_pc_ptr
[i
] = ascii_to_ebcdic
[(int) salt_buf_ptr
[i
]];
13938 for (uint i
= salt_len
; i
< 8; i
++)
13940 salt_buf_pc_ptr
[i
] = 0x40;
13945 IP (salt
->salt_buf_pc
[0], salt
->salt_buf_pc
[1], tt
);
13947 salt
->salt_buf_pc
[0] = ROTATE_LEFT (salt
->salt_buf_pc
[0], 3u);
13948 salt
->salt_buf_pc
[1] = ROTATE_LEFT (salt
->salt_buf_pc
[1], 3u);
13950 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
13951 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
13953 digest
[0] = byte_swap_32 (digest
[0]);
13954 digest
[1] = byte_swap_32 (digest
[1]);
13956 IP (digest
[0], digest
[1], tt
);
13958 digest
[0] = ROTATE_RIGHT (digest
[0], 29);
13959 digest
[1] = ROTATE_RIGHT (digest
[1], 29);
13963 return (PARSER_OK
);
13966 int lotus5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13968 if ((input_len
< DISPLAY_LEN_MIN_8600
) || (input_len
> DISPLAY_LEN_MAX_8600
)) return (PARSER_GLOBAL_LENGTH
);
13970 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13972 digest
[0] = hex_to_uint (&input_buf
[ 0]);
13973 digest
[1] = hex_to_uint (&input_buf
[ 8]);
13974 digest
[2] = hex_to_uint (&input_buf
[16]);
13975 digest
[3] = hex_to_uint (&input_buf
[24]);
13977 digest
[0] = byte_swap_32 (digest
[0]);
13978 digest
[1] = byte_swap_32 (digest
[1]);
13979 digest
[2] = byte_swap_32 (digest
[2]);
13980 digest
[3] = byte_swap_32 (digest
[3]);
13982 return (PARSER_OK
);
13985 int lotus6_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
13987 if ((input_len
< DISPLAY_LEN_MIN_8700
) || (input_len
> DISPLAY_LEN_MAX_8700
)) return (PARSER_GLOBAL_LENGTH
);
13989 if ((input_buf
[0] != '(') || (input_buf
[1] != 'G') || (input_buf
[21] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
13991 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
13993 salt_t
*salt
= hash_buf
->salt
;
13997 memset (tmp_buf
, 0, sizeof (tmp_buf
));
13999 base64_decode (lotus64_to_int
, input_buf
+ 2, input_len
- 3, tmp_buf
);
14001 tmp_buf
[3] += -4; // dont ask!
14003 memcpy (salt
->salt_buf
, tmp_buf
, 5);
14005 salt
->salt_len
= 5;
14007 memcpy (digest
, tmp_buf
+ 5, 9);
14009 // yes, only 9 byte are needed to crack, but 10 to display
14011 salt
->salt_buf_pc
[7] = input_buf
[20];
14013 return (PARSER_OK
);
14016 int lotus8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14018 if ((input_len
< DISPLAY_LEN_MIN_9100
) || (input_len
> DISPLAY_LEN_MAX_9100
)) return (PARSER_GLOBAL_LENGTH
);
14020 if ((input_buf
[0] != '(') || (input_buf
[1] != 'H') || (input_buf
[DISPLAY_LEN_MAX_9100
- 1] != ')')) return (PARSER_SIGNATURE_UNMATCHED
);
14022 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14024 salt_t
*salt
= hash_buf
->salt
;
14028 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14030 base64_decode (lotus64_to_int
, input_buf
+ 2, input_len
- 3, tmp_buf
);
14032 tmp_buf
[3] += -4; // dont ask!
14036 memcpy (salt
->salt_buf
, tmp_buf
, 16);
14038 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)
14042 char tmp_iter_buf
[11];
14044 memcpy (tmp_iter_buf
, tmp_buf
+ 16, 10);
14046 tmp_iter_buf
[10] = 0;
14048 salt
->salt_iter
= atoi (tmp_iter_buf
);
14050 if (salt
->salt_iter
< 1) // well, the limit hopefully is much higher
14052 return (PARSER_SALT_ITERATION
);
14055 salt
->salt_iter
--; // first round in init
14057 // 2 additional bytes for display only
14059 salt
->salt_buf_pc
[0] = tmp_buf
[26];
14060 salt
->salt_buf_pc
[1] = tmp_buf
[27];
14064 memcpy (digest
, tmp_buf
+ 28, 8);
14066 digest
[0] = byte_swap_32 (digest
[0]);
14067 digest
[1] = byte_swap_32 (digest
[1]);
14071 return (PARSER_OK
);
14074 int hmailserver_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14076 if ((input_len
< DISPLAY_LEN_MIN_1421
) || (input_len
> DISPLAY_LEN_MAX_1421
)) return (PARSER_GLOBAL_LENGTH
);
14078 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14080 salt_t
*salt
= hash_buf
->salt
;
14082 char *salt_buf_pos
= input_buf
;
14084 char *hash_buf_pos
= salt_buf_pos
+ 6;
14086 digest
[0] = hex_to_uint (&hash_buf_pos
[ 0]);
14087 digest
[1] = hex_to_uint (&hash_buf_pos
[ 8]);
14088 digest
[2] = hex_to_uint (&hash_buf_pos
[16]);
14089 digest
[3] = hex_to_uint (&hash_buf_pos
[24]);
14090 digest
[4] = hex_to_uint (&hash_buf_pos
[32]);
14091 digest
[5] = hex_to_uint (&hash_buf_pos
[40]);
14092 digest
[6] = hex_to_uint (&hash_buf_pos
[48]);
14093 digest
[7] = hex_to_uint (&hash_buf_pos
[56]);
14095 digest
[0] -= SHA256M_A
;
14096 digest
[1] -= SHA256M_B
;
14097 digest
[2] -= SHA256M_C
;
14098 digest
[3] -= SHA256M_D
;
14099 digest
[4] -= SHA256M_E
;
14100 digest
[5] -= SHA256M_F
;
14101 digest
[6] -= SHA256M_G
;
14102 digest
[7] -= SHA256M_H
;
14104 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14106 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf_pos
, 6);
14108 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14110 salt
->salt_len
= salt_len
;
14112 return (PARSER_OK
);
14115 int phps_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14117 if ((input_len
< DISPLAY_LEN_MIN_2612
) || (input_len
> DISPLAY_LEN_MAX_2612
)) return (PARSER_GLOBAL_LENGTH
);
14119 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14121 if (memcmp (SIGNATURE_PHPS
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14123 salt_t
*salt
= hash_buf
->salt
;
14125 char *salt_buf
= input_buf
+ 6;
14127 char *digest_buf
= strchr (salt_buf
, '$');
14129 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14131 uint salt_len
= digest_buf
- salt_buf
;
14133 digest_buf
++; // skip the '$' symbol
14135 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14137 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14139 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14141 salt
->salt_len
= salt_len
;
14143 digest
[0] = hex_to_uint (&digest_buf
[ 0]);
14144 digest
[1] = hex_to_uint (&digest_buf
[ 8]);
14145 digest
[2] = hex_to_uint (&digest_buf
[16]);
14146 digest
[3] = hex_to_uint (&digest_buf
[24]);
14148 digest
[0] = byte_swap_32 (digest
[0]);
14149 digest
[1] = byte_swap_32 (digest
[1]);
14150 digest
[2] = byte_swap_32 (digest
[2]);
14151 digest
[3] = byte_swap_32 (digest
[3]);
14153 digest
[0] -= MD5M_A
;
14154 digest
[1] -= MD5M_B
;
14155 digest
[2] -= MD5M_C
;
14156 digest
[3] -= MD5M_D
;
14158 return (PARSER_OK
);
14161 int mediawiki_b_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14163 if ((input_len
< DISPLAY_LEN_MIN_3711
) || (input_len
> DISPLAY_LEN_MAX_3711
)) return (PARSER_GLOBAL_LENGTH
);
14165 if (memcmp (SIGNATURE_MEDIAWIKI_B
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14167 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14169 salt_t
*salt
= hash_buf
->salt
;
14171 char *salt_buf
= input_buf
+ 3;
14173 char *digest_buf
= strchr (salt_buf
, '$');
14175 if (digest_buf
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14177 uint salt_len
= digest_buf
- salt_buf
;
14179 digest_buf
++; // skip the '$' symbol
14181 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14183 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14185 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14187 salt_buf_ptr
[salt_len
] = 0x2d;
14189 salt
->salt_len
= salt_len
+ 1;
14191 digest
[0] = hex_to_uint (&digest_buf
[ 0]);
14192 digest
[1] = hex_to_uint (&digest_buf
[ 8]);
14193 digest
[2] = hex_to_uint (&digest_buf
[16]);
14194 digest
[3] = hex_to_uint (&digest_buf
[24]);
14196 digest
[0] = byte_swap_32 (digest
[0]);
14197 digest
[1] = byte_swap_32 (digest
[1]);
14198 digest
[2] = byte_swap_32 (digest
[2]);
14199 digest
[3] = byte_swap_32 (digest
[3]);
14201 digest
[0] -= MD5M_A
;
14202 digest
[1] -= MD5M_B
;
14203 digest
[2] -= MD5M_C
;
14204 digest
[3] -= MD5M_D
;
14206 return (PARSER_OK
);
14209 int peoplesoft_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14211 if ((input_len
< DISPLAY_LEN_MIN_133
) || (input_len
> DISPLAY_LEN_MAX_133
)) return (PARSER_GLOBAL_LENGTH
);
14213 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14217 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14219 base64_decode (base64_to_int
, input_buf
, input_len
, tmp_buf
);
14221 memcpy (digest
, tmp_buf
, 20);
14223 digest
[0] = byte_swap_32 (digest
[0]);
14224 digest
[1] = byte_swap_32 (digest
[1]);
14225 digest
[2] = byte_swap_32 (digest
[2]);
14226 digest
[3] = byte_swap_32 (digest
[3]);
14227 digest
[4] = byte_swap_32 (digest
[4]);
14229 digest
[0] -= SHA1M_A
;
14230 digest
[1] -= SHA1M_B
;
14231 digest
[2] -= SHA1M_C
;
14232 digest
[3] -= SHA1M_D
;
14233 digest
[4] -= SHA1M_E
;
14235 return (PARSER_OK
);
14238 int skype_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14240 if ((input_len
< DISPLAY_LEN_MIN_23
) || (input_len
> DISPLAY_LEN_MAX_23
)) return (PARSER_GLOBAL_LENGTH
);
14242 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14244 salt_t
*salt
= hash_buf
->salt
;
14246 digest
[0] = hex_to_uint (&input_buf
[ 0]);
14247 digest
[1] = hex_to_uint (&input_buf
[ 8]);
14248 digest
[2] = hex_to_uint (&input_buf
[16]);
14249 digest
[3] = hex_to_uint (&input_buf
[24]);
14251 digest
[0] = byte_swap_32 (digest
[0]);
14252 digest
[1] = byte_swap_32 (digest
[1]);
14253 digest
[2] = byte_swap_32 (digest
[2]);
14254 digest
[3] = byte_swap_32 (digest
[3]);
14256 digest
[0] -= MD5M_A
;
14257 digest
[1] -= MD5M_B
;
14258 digest
[2] -= MD5M_C
;
14259 digest
[3] -= MD5M_D
;
14261 if (input_buf
[32] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14263 uint salt_len
= input_len
- 32 - 1;
14265 char *salt_buf
= input_buf
+ 32 + 1;
14267 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14269 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
14271 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
14274 * add static "salt" part
14277 memcpy (salt_buf_ptr
+ salt_len
, "\nskyper\n", 8);
14281 salt
->salt_len
= salt_len
;
14283 return (PARSER_OK
);
14286 int androidfde_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14288 if ((input_len
< DISPLAY_LEN_MIN_8800
) || (input_len
> DISPLAY_LEN_MAX_8800
)) return (PARSER_GLOBAL_LENGTH
);
14290 if (memcmp (SIGNATURE_ANDROIDFDE
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
14292 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14294 salt_t
*salt
= hash_buf
->salt
;
14296 androidfde_t
*androidfde
= (androidfde_t
*) hash_buf
->esalt
;
14302 char *saltlen_pos
= input_buf
+ 1 + 3 + 1;
14304 char *saltbuf_pos
= strchr (saltlen_pos
, '$');
14306 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14308 uint saltlen_len
= saltbuf_pos
- saltlen_pos
;
14310 if (saltlen_len
!= 2) return (PARSER_SALT_LENGTH
);
14314 char *keylen_pos
= strchr (saltbuf_pos
, '$');
14316 if (keylen_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14318 uint saltbuf_len
= keylen_pos
- saltbuf_pos
;
14320 if (saltbuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14324 char *keybuf_pos
= strchr (keylen_pos
, '$');
14326 if (keybuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14328 uint keylen_len
= keybuf_pos
- keylen_pos
;
14330 if (keylen_len
!= 2) return (PARSER_SALT_LENGTH
);
14334 char *databuf_pos
= strchr (keybuf_pos
, '$');
14336 if (databuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14338 uint keybuf_len
= databuf_pos
- keybuf_pos
;
14340 if (keybuf_len
!= 32) return (PARSER_SALT_LENGTH
);
14344 uint data_len
= input_len
- 1 - 3 - 1 - saltlen_len
- 1 - saltbuf_len
- 1 - keylen_len
- 1 - keybuf_len
- 1;
14346 if (data_len
!= 3072) return (PARSER_SALT_LENGTH
);
14352 digest
[0] = hex_to_uint (&keybuf_pos
[ 0]);
14353 digest
[1] = hex_to_uint (&keybuf_pos
[ 8]);
14354 digest
[2] = hex_to_uint (&keybuf_pos
[16]);
14355 digest
[3] = hex_to_uint (&keybuf_pos
[24]);
14357 salt
->salt_buf
[0] = hex_to_uint (&saltbuf_pos
[ 0]);
14358 salt
->salt_buf
[1] = hex_to_uint (&saltbuf_pos
[ 8]);
14359 salt
->salt_buf
[2] = hex_to_uint (&saltbuf_pos
[16]);
14360 salt
->salt_buf
[3] = hex_to_uint (&saltbuf_pos
[24]);
14362 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
14363 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
14364 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
14365 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
14367 salt
->salt_len
= 16;
14368 salt
->salt_iter
= ROUNDS_ANDROIDFDE
- 1;
14370 for (uint i
= 0, j
= 0; i
< 3072; i
+= 8, j
+= 1)
14372 androidfde
->data
[j
] = hex_to_uint (&databuf_pos
[i
]);
14375 return (PARSER_OK
);
14378 int scrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14380 if ((input_len
< DISPLAY_LEN_MIN_8900
) || (input_len
> DISPLAY_LEN_MAX_8900
)) return (PARSER_GLOBAL_LENGTH
);
14382 if (memcmp (SIGNATURE_SCRYPT
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
14384 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14386 salt_t
*salt
= hash_buf
->salt
;
14392 // first is the N salt parameter
14394 char *N_pos
= input_buf
+ 6;
14396 if (N_pos
[0] != ':') return (PARSER_SEPARATOR_UNMATCHED
);
14400 salt
->scrypt_N
= atoi (N_pos
);
14404 char *r_pos
= strchr (N_pos
, ':');
14406 if (r_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14410 salt
->scrypt_r
= atoi (r_pos
);
14414 char *p_pos
= strchr (r_pos
, ':');
14416 if (p_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14420 salt
->scrypt_p
= atoi (p_pos
);
14424 char *saltbuf_pos
= strchr (p_pos
, ':');
14426 if (saltbuf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14430 char *hash_pos
= strchr (saltbuf_pos
, ':');
14432 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14440 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14442 int tmp_len
= base64_decode (base64_to_int
, saltbuf_pos
, hash_pos
- saltbuf_pos
, tmp_buf
);
14444 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14446 memcpy (salt_buf_ptr
, tmp_buf
, tmp_len
);
14448 salt
->salt_len
= tmp_len
;
14449 salt
->salt_iter
= 1;
14451 // digest - base64 decode
14453 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14455 tmp_len
= input_len
- (hash_pos
- input_buf
);
14457 if (tmp_len
!= 44) return (PARSER_GLOBAL_LENGTH
);
14459 base64_decode (base64_to_int
, hash_pos
, tmp_len
, tmp_buf
);
14461 memcpy (digest
, tmp_buf
, 32);
14463 return (PARSER_OK
);
14466 int juniper_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14468 if ((input_len
< DISPLAY_LEN_MIN_501
) || (input_len
> DISPLAY_LEN_MAX_501
)) return (PARSER_GLOBAL_LENGTH
);
14470 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14472 salt_t
*salt
= hash_buf
->salt
;
14478 char decrypted
[76]; // iv + hash
14480 juniper_decrypt_hash (input_buf
, decrypted
);
14482 char *md5crypt_hash
= decrypted
+ 12;
14484 if (memcmp (md5crypt_hash
, "$1$danastre$", 12)) return (PARSER_SALT_VALUE
);
14486 salt
->salt_iter
= ROUNDS_MD5CRYPT
;
14488 char *salt_pos
= md5crypt_hash
+ 3;
14490 char *hash_pos
= strchr (salt_pos
, '$'); // or simply salt_pos + 8
14492 salt
->salt_len
= hash_pos
- salt_pos
; // should be 8
14494 memcpy ((char *) salt
->salt_buf
, salt_pos
, salt
->salt_len
);
14498 md5crypt_decode ((unsigned char *) digest
, (unsigned char *) hash_pos
);
14500 return (PARSER_OK
);
14503 int cisco8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14505 if ((input_len
< DISPLAY_LEN_MIN_9200
) || (input_len
> DISPLAY_LEN_MAX_9200
)) return (PARSER_GLOBAL_LENGTH
);
14507 if (memcmp (SIGNATURE_CISCO8
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14509 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14511 salt_t
*salt
= hash_buf
->salt
;
14513 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
14519 // first is *raw* salt
14521 char *salt_pos
= input_buf
+ 3;
14523 char *hash_pos
= strchr (salt_pos
, '$');
14525 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14527 uint salt_len
= hash_pos
- salt_pos
;
14529 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14533 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
14535 memcpy (salt_buf_ptr
, salt_pos
, 14);
14537 salt_buf_ptr
[17] = 0x01;
14538 salt_buf_ptr
[18] = 0x80;
14540 // add some stuff to normal salt to make sorted happy
14542 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
14543 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
14544 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
14545 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
14547 salt
->salt_len
= salt_len
;
14548 salt
->salt_iter
= ROUNDS_CISCO8
- 1;
14550 // base64 decode hash
14554 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14556 uint hash_len
= input_len
- 3 - salt_len
- 1;
14558 int tmp_len
= base64_decode (itoa64_to_int
, hash_pos
, hash_len
, tmp_buf
);
14560 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14562 memcpy (digest
, tmp_buf
, 32);
14564 digest
[0] = byte_swap_32 (digest
[0]);
14565 digest
[1] = byte_swap_32 (digest
[1]);
14566 digest
[2] = byte_swap_32 (digest
[2]);
14567 digest
[3] = byte_swap_32 (digest
[3]);
14568 digest
[4] = byte_swap_32 (digest
[4]);
14569 digest
[5] = byte_swap_32 (digest
[5]);
14570 digest
[6] = byte_swap_32 (digest
[6]);
14571 digest
[7] = byte_swap_32 (digest
[7]);
14573 return (PARSER_OK
);
14576 int cisco9_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14578 if ((input_len
< DISPLAY_LEN_MIN_9300
) || (input_len
> DISPLAY_LEN_MAX_9300
)) return (PARSER_GLOBAL_LENGTH
);
14580 if (memcmp (SIGNATURE_CISCO9
, input_buf
, 3)) return (PARSER_SIGNATURE_UNMATCHED
);
14582 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14584 salt_t
*salt
= hash_buf
->salt
;
14590 // first is *raw* salt
14592 char *salt_pos
= input_buf
+ 3;
14594 char *hash_pos
= strchr (salt_pos
, '$');
14596 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14598 uint salt_len
= hash_pos
- salt_pos
;
14600 if (salt_len
!= 14) return (PARSER_SALT_LENGTH
);
14602 salt
->salt_len
= salt_len
;
14605 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
14607 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
14608 salt_buf_ptr
[salt_len
] = 0;
14610 // base64 decode hash
14614 memset (tmp_buf
, 0, sizeof (tmp_buf
));
14616 uint hash_len
= input_len
- 3 - salt_len
- 1;
14618 int tmp_len
= base64_decode (itoa64_to_int
, hash_pos
, hash_len
, tmp_buf
);
14620 if (tmp_len
!= 32) return (PARSER_HASH_LENGTH
);
14622 memcpy (digest
, tmp_buf
, 32);
14625 salt
->scrypt_N
= 16384;
14626 salt
->scrypt_r
= 1;
14627 salt
->scrypt_p
= 1;
14628 salt
->salt_iter
= 1;
14630 return (PARSER_OK
);
14633 int office2007_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14635 if ((input_len
< DISPLAY_LEN_MIN_9400
) || (input_len
> DISPLAY_LEN_MAX_9400
)) return (PARSER_GLOBAL_LENGTH
);
14637 if (memcmp (SIGNATURE_OFFICE2007
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14639 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14641 salt_t
*salt
= hash_buf
->salt
;
14643 office2007_t
*office2007
= (office2007_t
*) hash_buf
->esalt
;
14649 char *version_pos
= input_buf
+ 8 + 1;
14651 char *verifierHashSize_pos
= strchr (version_pos
, '*');
14653 if (verifierHashSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14655 uint32_t version_len
= verifierHashSize_pos
- version_pos
;
14657 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14659 verifierHashSize_pos
++;
14661 char *keySize_pos
= strchr (verifierHashSize_pos
, '*');
14663 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14665 uint32_t verifierHashSize_len
= keySize_pos
- verifierHashSize_pos
;
14667 if (verifierHashSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14671 char *saltSize_pos
= strchr (keySize_pos
, '*');
14673 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14675 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
14677 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14681 char *osalt_pos
= strchr (saltSize_pos
, '*');
14683 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14685 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
14687 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14691 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14693 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14695 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14697 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14699 encryptedVerifier_pos
++;
14701 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14703 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14705 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14707 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14709 encryptedVerifierHash_pos
++;
14711 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;
14713 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
14715 const uint version
= atoi (version_pos
);
14717 if (version
!= 2007) return (PARSER_SALT_VALUE
);
14719 const uint verifierHashSize
= atoi (verifierHashSize_pos
);
14721 if (verifierHashSize
!= 20) return (PARSER_SALT_VALUE
);
14723 const uint keySize
= atoi (keySize_pos
);
14725 if ((keySize
!= 128) && (keySize
!= 256)) return (PARSER_SALT_VALUE
);
14727 office2007
->keySize
= keySize
;
14729 const uint saltSize
= atoi (saltSize_pos
);
14731 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14737 salt
->salt_len
= 16;
14738 salt
->salt_iter
= ROUNDS_OFFICE2007
;
14740 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
14741 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
14742 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
14743 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
14749 office2007
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
14750 office2007
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
14751 office2007
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
14752 office2007
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
14754 office2007
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
14755 office2007
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
14756 office2007
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
14757 office2007
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
14758 office2007
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
14764 digest
[0] = office2007
->encryptedVerifierHash
[0];
14765 digest
[1] = office2007
->encryptedVerifierHash
[1];
14766 digest
[2] = office2007
->encryptedVerifierHash
[2];
14767 digest
[3] = office2007
->encryptedVerifierHash
[3];
14769 return (PARSER_OK
);
14772 int office2010_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14774 if ((input_len
< DISPLAY_LEN_MIN_9500
) || (input_len
> DISPLAY_LEN_MAX_9500
)) return (PARSER_GLOBAL_LENGTH
);
14776 if (memcmp (SIGNATURE_OFFICE2010
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14778 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14780 salt_t
*salt
= hash_buf
->salt
;
14782 office2010_t
*office2010
= (office2010_t
*) hash_buf
->esalt
;
14788 char *version_pos
= input_buf
+ 8 + 1;
14790 char *spinCount_pos
= strchr (version_pos
, '*');
14792 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14794 uint32_t version_len
= spinCount_pos
- version_pos
;
14796 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14800 char *keySize_pos
= strchr (spinCount_pos
, '*');
14802 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14804 uint32_t spinCount_len
= keySize_pos
- spinCount_pos
;
14806 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14810 char *saltSize_pos
= strchr (keySize_pos
, '*');
14812 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14814 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
14816 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14820 char *osalt_pos
= strchr (saltSize_pos
, '*');
14822 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14824 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
14826 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14830 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14832 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14834 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14836 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14838 encryptedVerifier_pos
++;
14840 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14842 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14844 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14846 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14848 encryptedVerifierHash_pos
++;
14850 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;
14852 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
14854 const uint version
= atoi (version_pos
);
14856 if (version
!= 2010) return (PARSER_SALT_VALUE
);
14858 const uint spinCount
= atoi (spinCount_pos
);
14860 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
14862 const uint keySize
= atoi (keySize_pos
);
14864 if (keySize
!= 128) return (PARSER_SALT_VALUE
);
14866 const uint saltSize
= atoi (saltSize_pos
);
14868 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
14874 salt
->salt_len
= 16;
14875 salt
->salt_iter
= spinCount
;
14877 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
14878 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
14879 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
14880 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
14886 office2010
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
14887 office2010
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
14888 office2010
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
14889 office2010
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
14891 office2010
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
14892 office2010
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
14893 office2010
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
14894 office2010
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
14895 office2010
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
14896 office2010
->encryptedVerifierHash
[5] = hex_to_uint (&encryptedVerifierHash_pos
[40]);
14897 office2010
->encryptedVerifierHash
[6] = hex_to_uint (&encryptedVerifierHash_pos
[48]);
14898 office2010
->encryptedVerifierHash
[7] = hex_to_uint (&encryptedVerifierHash_pos
[56]);
14904 digest
[0] = office2010
->encryptedVerifierHash
[0];
14905 digest
[1] = office2010
->encryptedVerifierHash
[1];
14906 digest
[2] = office2010
->encryptedVerifierHash
[2];
14907 digest
[3] = office2010
->encryptedVerifierHash
[3];
14909 return (PARSER_OK
);
14912 int office2013_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
14914 if ((input_len
< DISPLAY_LEN_MIN_9600
) || (input_len
> DISPLAY_LEN_MAX_9600
)) return (PARSER_GLOBAL_LENGTH
);
14916 if (memcmp (SIGNATURE_OFFICE2013
, input_buf
, 8)) return (PARSER_SIGNATURE_UNMATCHED
);
14918 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
14920 salt_t
*salt
= hash_buf
->salt
;
14922 office2013_t
*office2013
= (office2013_t
*) hash_buf
->esalt
;
14928 char *version_pos
= input_buf
+ 8 + 1;
14930 char *spinCount_pos
= strchr (version_pos
, '*');
14932 if (spinCount_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14934 uint32_t version_len
= spinCount_pos
- version_pos
;
14936 if (version_len
!= 4) return (PARSER_SALT_LENGTH
);
14940 char *keySize_pos
= strchr (spinCount_pos
, '*');
14942 if (keySize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14944 uint32_t spinCount_len
= keySize_pos
- spinCount_pos
;
14946 if (spinCount_len
!= 6) return (PARSER_SALT_LENGTH
);
14950 char *saltSize_pos
= strchr (keySize_pos
, '*');
14952 if (saltSize_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14954 uint32_t keySize_len
= saltSize_pos
- keySize_pos
;
14956 if (keySize_len
!= 3) return (PARSER_SALT_LENGTH
);
14960 char *osalt_pos
= strchr (saltSize_pos
, '*');
14962 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14964 uint32_t saltSize_len
= osalt_pos
- saltSize_pos
;
14966 if (saltSize_len
!= 2) return (PARSER_SALT_LENGTH
);
14970 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
14972 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14974 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
14976 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
14978 encryptedVerifier_pos
++;
14980 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
14982 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
14984 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
14986 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
14988 encryptedVerifierHash_pos
++;
14990 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;
14992 if (encryptedVerifierHash_len
!= 64) return (PARSER_SALT_LENGTH
);
14994 const uint version
= atoi (version_pos
);
14996 if (version
!= 2013) return (PARSER_SALT_VALUE
);
14998 const uint spinCount
= atoi (spinCount_pos
);
15000 if (spinCount
!= 100000) return (PARSER_SALT_VALUE
);
15002 const uint keySize
= atoi (keySize_pos
);
15004 if (keySize
!= 256) return (PARSER_SALT_VALUE
);
15006 const uint saltSize
= atoi (saltSize_pos
);
15008 if (saltSize
!= 16) return (PARSER_SALT_VALUE
);
15014 salt
->salt_len
= 16;
15015 salt
->salt_iter
= spinCount
;
15017 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15018 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15019 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15020 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15026 office2013
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15027 office2013
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15028 office2013
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15029 office2013
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15031 office2013
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15032 office2013
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15033 office2013
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15034 office2013
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15035 office2013
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
15036 office2013
->encryptedVerifierHash
[5] = hex_to_uint (&encryptedVerifierHash_pos
[40]);
15037 office2013
->encryptedVerifierHash
[6] = hex_to_uint (&encryptedVerifierHash_pos
[48]);
15038 office2013
->encryptedVerifierHash
[7] = hex_to_uint (&encryptedVerifierHash_pos
[56]);
15044 digest
[0] = office2013
->encryptedVerifierHash
[0];
15045 digest
[1] = office2013
->encryptedVerifierHash
[1];
15046 digest
[2] = office2013
->encryptedVerifierHash
[2];
15047 digest
[3] = office2013
->encryptedVerifierHash
[3];
15049 return (PARSER_OK
);
15052 int oldoffice01_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15054 if ((input_len
< DISPLAY_LEN_MIN_9700
) || (input_len
> DISPLAY_LEN_MAX_9700
)) return (PARSER_GLOBAL_LENGTH
);
15056 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15058 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15060 salt_t
*salt
= hash_buf
->salt
;
15062 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15068 char *version_pos
= input_buf
+ 11;
15070 char *osalt_pos
= strchr (version_pos
, '*');
15072 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15074 uint32_t version_len
= osalt_pos
- version_pos
;
15076 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15080 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15082 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15084 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15086 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15088 encryptedVerifier_pos
++;
15090 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15092 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15094 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15096 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15098 encryptedVerifierHash_pos
++;
15100 uint32_t encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15102 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15104 const uint version
= *version_pos
- 0x30;
15106 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15112 oldoffice01
->version
= version
;
15114 oldoffice01
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15115 oldoffice01
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15116 oldoffice01
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15117 oldoffice01
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15119 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15120 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15121 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15122 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15124 oldoffice01
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15125 oldoffice01
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15126 oldoffice01
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15127 oldoffice01
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15129 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15130 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15131 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15132 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15138 salt
->salt_len
= 16;
15140 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15141 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15142 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15143 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15145 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15146 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15147 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15148 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15150 // this is a workaround as office produces multiple documents with the same salt
15152 salt
->salt_len
+= 32;
15154 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15155 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15156 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15157 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15158 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15159 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15160 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15161 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15167 digest
[0] = oldoffice01
->encryptedVerifierHash
[0];
15168 digest
[1] = oldoffice01
->encryptedVerifierHash
[1];
15169 digest
[2] = oldoffice01
->encryptedVerifierHash
[2];
15170 digest
[3] = oldoffice01
->encryptedVerifierHash
[3];
15172 return (PARSER_OK
);
15175 int oldoffice01cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15177 return oldoffice01_parse_hash (input_buf
, input_len
, hash_buf
);
15180 int oldoffice01cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15182 if ((input_len
< DISPLAY_LEN_MIN_9720
) || (input_len
> DISPLAY_LEN_MAX_9720
)) return (PARSER_GLOBAL_LENGTH
);
15184 if ((memcmp (SIGNATURE_OLDOFFICE0
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE1
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15186 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15188 salt_t
*salt
= hash_buf
->salt
;
15190 oldoffice01_t
*oldoffice01
= (oldoffice01_t
*) hash_buf
->esalt
;
15196 char *version_pos
= input_buf
+ 11;
15198 char *osalt_pos
= strchr (version_pos
, '*');
15200 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15202 uint32_t version_len
= osalt_pos
- version_pos
;
15204 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15208 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15210 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15212 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15214 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15216 encryptedVerifier_pos
++;
15218 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15220 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15222 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15224 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15226 encryptedVerifierHash_pos
++;
15228 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15230 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15232 uint32_t encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15234 if (encryptedVerifierHash_len
!= 32) return (PARSER_SALT_LENGTH
);
15238 uint32_t rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15240 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15242 const uint version
= *version_pos
- 0x30;
15244 if (version
!= 0 && version
!= 1) return (PARSER_SALT_VALUE
);
15250 oldoffice01
->version
= version
;
15252 oldoffice01
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15253 oldoffice01
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15254 oldoffice01
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15255 oldoffice01
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15257 oldoffice01
->encryptedVerifier
[0] = byte_swap_32 (oldoffice01
->encryptedVerifier
[0]);
15258 oldoffice01
->encryptedVerifier
[1] = byte_swap_32 (oldoffice01
->encryptedVerifier
[1]);
15259 oldoffice01
->encryptedVerifier
[2] = byte_swap_32 (oldoffice01
->encryptedVerifier
[2]);
15260 oldoffice01
->encryptedVerifier
[3] = byte_swap_32 (oldoffice01
->encryptedVerifier
[3]);
15262 oldoffice01
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15263 oldoffice01
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15264 oldoffice01
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15265 oldoffice01
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15267 oldoffice01
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[0]);
15268 oldoffice01
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[1]);
15269 oldoffice01
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[2]);
15270 oldoffice01
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice01
->encryptedVerifierHash
[3]);
15272 oldoffice01
->rc4key
[1] = 0;
15273 oldoffice01
->rc4key
[0] = 0;
15275 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15276 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15277 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15278 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15279 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15280 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15281 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15282 oldoffice01
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15283 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15284 oldoffice01
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15286 oldoffice01
->rc4key
[0] = byte_swap_32 (oldoffice01
->rc4key
[0]);
15287 oldoffice01
->rc4key
[1] = byte_swap_32 (oldoffice01
->rc4key
[1]);
15293 salt
->salt_len
= 16;
15295 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15296 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15297 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15298 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15300 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15301 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15302 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15303 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15305 // this is a workaround as office produces multiple documents with the same salt
15307 salt
->salt_len
+= 32;
15309 salt
->salt_buf
[ 4] = oldoffice01
->encryptedVerifier
[0];
15310 salt
->salt_buf
[ 5] = oldoffice01
->encryptedVerifier
[1];
15311 salt
->salt_buf
[ 6] = oldoffice01
->encryptedVerifier
[2];
15312 salt
->salt_buf
[ 7] = oldoffice01
->encryptedVerifier
[3];
15313 salt
->salt_buf
[ 8] = oldoffice01
->encryptedVerifierHash
[0];
15314 salt
->salt_buf
[ 9] = oldoffice01
->encryptedVerifierHash
[1];
15315 salt
->salt_buf
[10] = oldoffice01
->encryptedVerifierHash
[2];
15316 salt
->salt_buf
[11] = oldoffice01
->encryptedVerifierHash
[3];
15322 digest
[0] = oldoffice01
->rc4key
[0];
15323 digest
[1] = oldoffice01
->rc4key
[1];
15327 return (PARSER_OK
);
15330 int oldoffice34_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15332 if ((input_len
< DISPLAY_LEN_MIN_9800
) || (input_len
> DISPLAY_LEN_MAX_9800
)) return (PARSER_GLOBAL_LENGTH
);
15334 if ((memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) && (memcmp (SIGNATURE_OLDOFFICE4
, input_buf
, 12))) return (PARSER_SIGNATURE_UNMATCHED
);
15336 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15338 salt_t
*salt
= hash_buf
->salt
;
15340 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15346 char *version_pos
= input_buf
+ 11;
15348 char *osalt_pos
= strchr (version_pos
, '*');
15350 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15352 uint32_t version_len
= osalt_pos
- version_pos
;
15354 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15358 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15360 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15362 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15364 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15366 encryptedVerifier_pos
++;
15368 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15370 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15372 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15374 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15376 encryptedVerifierHash_pos
++;
15378 uint32_t encryptedVerifierHash_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1;
15380 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15382 const uint version
= *version_pos
- 0x30;
15384 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15390 oldoffice34
->version
= version
;
15392 oldoffice34
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15393 oldoffice34
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15394 oldoffice34
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15395 oldoffice34
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15397 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15398 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15399 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15400 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15402 oldoffice34
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15403 oldoffice34
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15404 oldoffice34
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15405 oldoffice34
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15406 oldoffice34
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
15408 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15409 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15410 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15411 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15412 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15418 salt
->salt_len
= 16;
15420 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15421 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15422 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15423 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15425 // this is a workaround as office produces multiple documents with the same salt
15427 salt
->salt_len
+= 32;
15429 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15430 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15431 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15432 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15433 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15434 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15435 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15436 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15442 digest
[0] = oldoffice34
->encryptedVerifierHash
[0];
15443 digest
[1] = oldoffice34
->encryptedVerifierHash
[1];
15444 digest
[2] = oldoffice34
->encryptedVerifierHash
[2];
15445 digest
[3] = oldoffice34
->encryptedVerifierHash
[3];
15447 return (PARSER_OK
);
15450 int oldoffice34cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15452 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15454 return oldoffice34_parse_hash (input_buf
, input_len
, hash_buf
);
15457 int oldoffice34cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15459 if ((input_len
< DISPLAY_LEN_MIN_9820
) || (input_len
> DISPLAY_LEN_MAX_9820
)) return (PARSER_GLOBAL_LENGTH
);
15461 if (memcmp (SIGNATURE_OLDOFFICE3
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
15463 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15465 salt_t
*salt
= hash_buf
->salt
;
15467 oldoffice34_t
*oldoffice34
= (oldoffice34_t
*) hash_buf
->esalt
;
15473 char *version_pos
= input_buf
+ 11;
15475 char *osalt_pos
= strchr (version_pos
, '*');
15477 if (osalt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15479 uint32_t version_len
= osalt_pos
- version_pos
;
15481 if (version_len
!= 1) return (PARSER_SALT_LENGTH
);
15485 char *encryptedVerifier_pos
= strchr (osalt_pos
, '*');
15487 if (encryptedVerifier_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15489 uint32_t osalt_len
= encryptedVerifier_pos
- osalt_pos
;
15491 if (osalt_len
!= 32) return (PARSER_SALT_LENGTH
);
15493 encryptedVerifier_pos
++;
15495 char *encryptedVerifierHash_pos
= strchr (encryptedVerifier_pos
, '*');
15497 if (encryptedVerifierHash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15499 uint32_t encryptedVerifier_len
= encryptedVerifierHash_pos
- encryptedVerifier_pos
;
15501 if (encryptedVerifier_len
!= 32) return (PARSER_SALT_LENGTH
);
15503 encryptedVerifierHash_pos
++;
15505 char *rc4key_pos
= strchr (encryptedVerifierHash_pos
, ':');
15507 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15509 uint32_t encryptedVerifierHash_len
= rc4key_pos
- encryptedVerifierHash_pos
;
15511 if (encryptedVerifierHash_len
!= 40) return (PARSER_SALT_LENGTH
);
15515 uint32_t rc4key_len
= input_len
- 11 - version_len
- 1 - osalt_len
- 1 - encryptedVerifier_len
- 1 - encryptedVerifierHash_len
- 1;
15517 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
15519 const uint version
= *version_pos
- 0x30;
15521 if (version
!= 3 && version
!= 4) return (PARSER_SALT_VALUE
);
15527 oldoffice34
->version
= version
;
15529 oldoffice34
->encryptedVerifier
[0] = hex_to_uint (&encryptedVerifier_pos
[ 0]);
15530 oldoffice34
->encryptedVerifier
[1] = hex_to_uint (&encryptedVerifier_pos
[ 8]);
15531 oldoffice34
->encryptedVerifier
[2] = hex_to_uint (&encryptedVerifier_pos
[16]);
15532 oldoffice34
->encryptedVerifier
[3] = hex_to_uint (&encryptedVerifier_pos
[24]);
15534 oldoffice34
->encryptedVerifier
[0] = byte_swap_32 (oldoffice34
->encryptedVerifier
[0]);
15535 oldoffice34
->encryptedVerifier
[1] = byte_swap_32 (oldoffice34
->encryptedVerifier
[1]);
15536 oldoffice34
->encryptedVerifier
[2] = byte_swap_32 (oldoffice34
->encryptedVerifier
[2]);
15537 oldoffice34
->encryptedVerifier
[3] = byte_swap_32 (oldoffice34
->encryptedVerifier
[3]);
15539 oldoffice34
->encryptedVerifierHash
[0] = hex_to_uint (&encryptedVerifierHash_pos
[ 0]);
15540 oldoffice34
->encryptedVerifierHash
[1] = hex_to_uint (&encryptedVerifierHash_pos
[ 8]);
15541 oldoffice34
->encryptedVerifierHash
[2] = hex_to_uint (&encryptedVerifierHash_pos
[16]);
15542 oldoffice34
->encryptedVerifierHash
[3] = hex_to_uint (&encryptedVerifierHash_pos
[24]);
15543 oldoffice34
->encryptedVerifierHash
[4] = hex_to_uint (&encryptedVerifierHash_pos
[32]);
15545 oldoffice34
->encryptedVerifierHash
[0] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[0]);
15546 oldoffice34
->encryptedVerifierHash
[1] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[1]);
15547 oldoffice34
->encryptedVerifierHash
[2] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[2]);
15548 oldoffice34
->encryptedVerifierHash
[3] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[3]);
15549 oldoffice34
->encryptedVerifierHash
[4] = byte_swap_32 (oldoffice34
->encryptedVerifierHash
[4]);
15551 oldoffice34
->rc4key
[1] = 0;
15552 oldoffice34
->rc4key
[0] = 0;
15554 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
15555 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
15556 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
15557 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
15558 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
15559 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
15560 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
15561 oldoffice34
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
15562 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
15563 oldoffice34
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
15565 oldoffice34
->rc4key
[0] = byte_swap_32 (oldoffice34
->rc4key
[0]);
15566 oldoffice34
->rc4key
[1] = byte_swap_32 (oldoffice34
->rc4key
[1]);
15572 salt
->salt_len
= 16;
15574 salt
->salt_buf
[0] = hex_to_uint (&osalt_pos
[ 0]);
15575 salt
->salt_buf
[1] = hex_to_uint (&osalt_pos
[ 8]);
15576 salt
->salt_buf
[2] = hex_to_uint (&osalt_pos
[16]);
15577 salt
->salt_buf
[3] = hex_to_uint (&osalt_pos
[24]);
15579 // this is a workaround as office produces multiple documents with the same salt
15581 salt
->salt_len
+= 32;
15583 salt
->salt_buf
[ 4] = oldoffice34
->encryptedVerifier
[0];
15584 salt
->salt_buf
[ 5] = oldoffice34
->encryptedVerifier
[1];
15585 salt
->salt_buf
[ 6] = oldoffice34
->encryptedVerifier
[2];
15586 salt
->salt_buf
[ 7] = oldoffice34
->encryptedVerifier
[3];
15587 salt
->salt_buf
[ 8] = oldoffice34
->encryptedVerifierHash
[0];
15588 salt
->salt_buf
[ 9] = oldoffice34
->encryptedVerifierHash
[1];
15589 salt
->salt_buf
[10] = oldoffice34
->encryptedVerifierHash
[2];
15590 salt
->salt_buf
[11] = oldoffice34
->encryptedVerifierHash
[3];
15596 digest
[0] = oldoffice34
->rc4key
[0];
15597 digest
[1] = oldoffice34
->rc4key
[1];
15601 return (PARSER_OK
);
15604 int radmin2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15606 if ((input_len
< DISPLAY_LEN_MIN_9900
) || (input_len
> DISPLAY_LEN_MAX_9900
)) return (PARSER_GLOBAL_LENGTH
);
15608 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15610 digest
[0] = hex_to_uint (&input_buf
[ 0]);
15611 digest
[1] = hex_to_uint (&input_buf
[ 8]);
15612 digest
[2] = hex_to_uint (&input_buf
[16]);
15613 digest
[3] = hex_to_uint (&input_buf
[24]);
15615 digest
[0] = byte_swap_32 (digest
[0]);
15616 digest
[1] = byte_swap_32 (digest
[1]);
15617 digest
[2] = byte_swap_32 (digest
[2]);
15618 digest
[3] = byte_swap_32 (digest
[3]);
15620 return (PARSER_OK
);
15623 int djangosha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15625 if ((input_len
< DISPLAY_LEN_MIN_124
) || (input_len
> DISPLAY_LEN_MAX_124
)) return (PARSER_GLOBAL_LENGTH
);
15627 if ((memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5)) && (memcmp (SIGNATURE_DJANGOSHA1
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15629 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15631 salt_t
*salt
= hash_buf
->salt
;
15633 char *signature_pos
= input_buf
;
15635 char *salt_pos
= strchr (signature_pos
, '$');
15637 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15639 uint32_t signature_len
= salt_pos
- signature_pos
;
15641 if (signature_len
!= 4) return (PARSER_SIGNATURE_UNMATCHED
);
15645 char *hash_pos
= strchr (salt_pos
, '$');
15647 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15649 uint32_t salt_len
= hash_pos
- salt_pos
;
15651 if (salt_len
> 32) return (PARSER_SALT_LENGTH
);
15655 uint32_t hash_len
= input_len
- signature_len
- 1 - salt_len
- 1;
15657 if (hash_len
!= 40) return (PARSER_SALT_LENGTH
);
15659 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
15660 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
15661 digest
[2] = hex_to_uint (&hash_pos
[16]);
15662 digest
[3] = hex_to_uint (&hash_pos
[24]);
15663 digest
[4] = hex_to_uint (&hash_pos
[32]);
15665 digest
[0] -= SHA1M_A
;
15666 digest
[1] -= SHA1M_B
;
15667 digest
[2] -= SHA1M_C
;
15668 digest
[3] -= SHA1M_D
;
15669 digest
[4] -= SHA1M_E
;
15671 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15673 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15675 salt
->salt_len
= salt_len
;
15677 return (PARSER_OK
);
15680 int djangopbkdf2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15682 if ((input_len
< DISPLAY_LEN_MIN_10000
) || (input_len
> DISPLAY_LEN_MAX_10000
)) return (PARSER_GLOBAL_LENGTH
);
15684 if (memcmp (SIGNATURE_DJANGOPBKDF2
, input_buf
, 14)) return (PARSER_SIGNATURE_UNMATCHED
);
15686 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15688 salt_t
*salt
= hash_buf
->salt
;
15690 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
15696 char *iter_pos
= input_buf
+ 14;
15698 const int iter
= atoi (iter_pos
);
15700 if (iter
< 1) return (PARSER_SALT_ITERATION
);
15702 salt
->salt_iter
= iter
- 1;
15704 char *salt_pos
= strchr (iter_pos
, '$');
15706 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15710 char *hash_pos
= strchr (salt_pos
, '$');
15712 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15714 const uint salt_len
= hash_pos
- salt_pos
;
15718 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
15720 memcpy (salt_buf_ptr
, salt_pos
, salt_len
);
15722 salt
->salt_len
= salt_len
;
15724 salt_buf_ptr
[salt_len
+ 3] = 0x01;
15725 salt_buf_ptr
[salt_len
+ 4] = 0x80;
15727 // add some stuff to normal salt to make sorted happy
15729 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
15730 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
15731 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
15732 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
15733 salt
->salt_buf
[4] = salt
->salt_iter
;
15735 // base64 decode hash
15739 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15741 uint hash_len
= input_len
- (hash_pos
- input_buf
);
15743 if (hash_len
!= 44) return (PARSER_HASH_LENGTH
);
15745 base64_decode (base64_to_int
, hash_pos
, hash_len
, tmp_buf
);
15747 memcpy (digest
, tmp_buf
, 32);
15749 digest
[0] = byte_swap_32 (digest
[0]);
15750 digest
[1] = byte_swap_32 (digest
[1]);
15751 digest
[2] = byte_swap_32 (digest
[2]);
15752 digest
[3] = byte_swap_32 (digest
[3]);
15753 digest
[4] = byte_swap_32 (digest
[4]);
15754 digest
[5] = byte_swap_32 (digest
[5]);
15755 digest
[6] = byte_swap_32 (digest
[6]);
15756 digest
[7] = byte_swap_32 (digest
[7]);
15758 return (PARSER_OK
);
15761 int siphash_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15763 if ((input_len
< DISPLAY_LEN_MIN_10100
) || (input_len
> DISPLAY_LEN_MAX_10100
)) return (PARSER_GLOBAL_LENGTH
);
15765 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15767 salt_t
*salt
= hash_buf
->salt
;
15769 digest
[0] = hex_to_uint (&input_buf
[ 0]);
15770 digest
[1] = hex_to_uint (&input_buf
[ 8]);
15774 digest
[0] = byte_swap_32 (digest
[0]);
15775 digest
[1] = byte_swap_32 (digest
[1]);
15777 if (input_buf
[16] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15778 if (input_buf
[18] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15779 if (input_buf
[20] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15781 char iter_c
= input_buf
[17];
15782 char iter_d
= input_buf
[19];
15784 // atm only defaults, let's see if there's more request
15785 if (iter_c
!= '2') return (PARSER_SALT_ITERATION
);
15786 if (iter_d
!= '4') return (PARSER_SALT_ITERATION
);
15788 char *salt_buf
= input_buf
+ 16 + 1 + 1 + 1 + 1 + 1;
15790 salt
->salt_buf
[0] = hex_to_uint (&salt_buf
[ 0]);
15791 salt
->salt_buf
[1] = hex_to_uint (&salt_buf
[ 8]);
15792 salt
->salt_buf
[2] = hex_to_uint (&salt_buf
[16]);
15793 salt
->salt_buf
[3] = hex_to_uint (&salt_buf
[24]);
15795 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
15796 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
15797 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
15798 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
15800 salt
->salt_len
= 16;
15802 return (PARSER_OK
);
15805 int crammd5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15807 if ((input_len
< DISPLAY_LEN_MIN_10200
) || (input_len
> DISPLAY_LEN_MAX_10200
)) return (PARSER_GLOBAL_LENGTH
);
15809 if (memcmp (SIGNATURE_CRAM_MD5
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15811 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15813 cram_md5_t
*cram_md5
= (cram_md5_t
*) hash_buf
->esalt
;
15815 salt_t
*salt
= hash_buf
->salt
;
15817 char *salt_pos
= input_buf
+ 10;
15819 char *hash_pos
= strchr (salt_pos
, '$');
15821 uint salt_len
= hash_pos
- salt_pos
;
15823 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15827 uint hash_len
= input_len
- 10 - salt_len
- 1;
15829 // base64 decode salt
15833 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15835 salt_len
= base64_decode (base64_to_int
, salt_pos
, salt_len
, tmp_buf
);
15837 if (salt_len
> 55) return (PARSER_SALT_LENGTH
);
15839 tmp_buf
[salt_len
] = 0x80;
15841 memcpy (&salt
->salt_buf
, tmp_buf
, salt_len
+ 1);
15843 salt
->salt_len
= salt_len
;
15845 // base64 decode salt
15847 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15849 hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_len
, tmp_buf
);
15851 uint user_len
= hash_len
- 32;
15853 char *tmp_hash
= tmp_buf
+ user_len
;
15855 user_len
--; // skip the trailing space
15857 digest
[0] = hex_to_uint (&tmp_hash
[ 0]);
15858 digest
[1] = hex_to_uint (&tmp_hash
[ 8]);
15859 digest
[2] = hex_to_uint (&tmp_hash
[16]);
15860 digest
[3] = hex_to_uint (&tmp_hash
[24]);
15862 digest
[0] = byte_swap_32 (digest
[0]);
15863 digest
[1] = byte_swap_32 (digest
[1]);
15864 digest
[2] = byte_swap_32 (digest
[2]);
15865 digest
[3] = byte_swap_32 (digest
[3]);
15867 // store username for host only (output hash if cracked)
15869 memset (cram_md5
->user
, 0, sizeof (cram_md5
->user
));
15870 memcpy (cram_md5
->user
, tmp_buf
, user_len
);
15872 return (PARSER_OK
);
15875 int saph_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15877 if ((input_len
< DISPLAY_LEN_MIN_10300
) || (input_len
> DISPLAY_LEN_MAX_10300
)) return (PARSER_GLOBAL_LENGTH
);
15879 if (memcmp (SIGNATURE_SAPH_SHA1
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
15881 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15883 salt_t
*salt
= hash_buf
->salt
;
15885 char *iter_pos
= input_buf
+ 10;
15887 uint32_t iter
= atoi (iter_pos
);
15891 return (PARSER_SALT_ITERATION
);
15894 iter
--; // first iteration is special
15896 salt
->salt_iter
= iter
;
15898 char *base64_pos
= strchr (iter_pos
, '}');
15900 if (base64_pos
== NULL
)
15902 return (PARSER_SIGNATURE_UNMATCHED
);
15907 // base64 decode salt
15909 uint32_t base64_len
= input_len
- (base64_pos
- input_buf
);
15913 memset (tmp_buf
, 0, sizeof (tmp_buf
));
15915 uint32_t decoded_len
= base64_decode (base64_to_int
, base64_pos
, base64_len
, tmp_buf
);
15917 if (decoded_len
< 24)
15919 return (PARSER_SALT_LENGTH
);
15924 uint salt_len
= decoded_len
- 20;
15926 if (salt_len
< 4) return (PARSER_SALT_LENGTH
);
15927 if (salt_len
> 16) return (PARSER_SALT_LENGTH
);
15929 memcpy (&salt
->salt_buf
, tmp_buf
+ 20, salt_len
);
15931 salt
->salt_len
= salt_len
;
15935 uint32_t *digest_ptr
= (uint32_t*) tmp_buf
;
15937 digest
[0] = byte_swap_32 (digest_ptr
[0]);
15938 digest
[1] = byte_swap_32 (digest_ptr
[1]);
15939 digest
[2] = byte_swap_32 (digest_ptr
[2]);
15940 digest
[3] = byte_swap_32 (digest_ptr
[3]);
15941 digest
[4] = byte_swap_32 (digest_ptr
[4]);
15943 return (PARSER_OK
);
15946 int redmine_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15948 if ((input_len
< DISPLAY_LEN_MIN_7600
) || (input_len
> DISPLAY_LEN_MAX_7600
)) return (PARSER_GLOBAL_LENGTH
);
15950 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15952 salt_t
*salt
= hash_buf
->salt
;
15954 digest
[0] = hex_to_uint (&input_buf
[ 0]);
15955 digest
[1] = hex_to_uint (&input_buf
[ 8]);
15956 digest
[2] = hex_to_uint (&input_buf
[16]);
15957 digest
[3] = hex_to_uint (&input_buf
[24]);
15958 digest
[4] = hex_to_uint (&input_buf
[32]);
15960 if (input_buf
[40] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
15962 uint salt_len
= input_len
- 40 - 1;
15964 char *salt_buf
= input_buf
+ 40 + 1;
15966 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
15968 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
15970 if (salt_len
!= 32) return (PARSER_SALT_LENGTH
);
15972 salt
->salt_len
= salt_len
;
15974 return (PARSER_OK
);
15977 int pdf11_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
15979 if ((input_len
< DISPLAY_LEN_MIN_10400
) || (input_len
> DISPLAY_LEN_MAX_10400
)) return (PARSER_GLOBAL_LENGTH
);
15981 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
15983 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
15985 salt_t
*salt
= hash_buf
->salt
;
15987 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
15993 char *V_pos
= input_buf
+ 5;
15995 char *R_pos
= strchr (V_pos
, '*');
15997 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
15999 uint32_t V_len
= R_pos
- V_pos
;
16003 char *bits_pos
= strchr (R_pos
, '*');
16005 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16007 uint32_t R_len
= bits_pos
- R_pos
;
16011 char *P_pos
= strchr (bits_pos
, '*');
16013 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16015 uint32_t bits_len
= P_pos
- bits_pos
;
16019 char *enc_md_pos
= strchr (P_pos
, '*');
16021 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16023 uint32_t P_len
= enc_md_pos
- P_pos
;
16027 char *id_len_pos
= strchr (enc_md_pos
, '*');
16029 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16031 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16035 char *id_buf_pos
= strchr (id_len_pos
, '*');
16037 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16039 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16043 char *u_len_pos
= strchr (id_buf_pos
, '*');
16045 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16047 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16049 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16053 char *u_buf_pos
= strchr (u_len_pos
, '*');
16055 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16057 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16061 char *o_len_pos
= strchr (u_buf_pos
, '*');
16063 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16065 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16067 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16071 char *o_buf_pos
= strchr (o_len_pos
, '*');
16073 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16075 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16079 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;
16081 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16085 const int V
= atoi (V_pos
);
16086 const int R
= atoi (R_pos
);
16087 const int P
= atoi (P_pos
);
16089 if (V
!= 1) return (PARSER_SALT_VALUE
);
16090 if (R
!= 2) return (PARSER_SALT_VALUE
);
16092 const int enc_md
= atoi (enc_md_pos
);
16094 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16096 const int id_len
= atoi (id_len_pos
);
16097 const int u_len
= atoi (u_len_pos
);
16098 const int o_len
= atoi (o_len_pos
);
16100 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16101 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16102 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16104 const int bits
= atoi (bits_pos
);
16106 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16108 // copy data to esalt
16114 pdf
->enc_md
= enc_md
;
16116 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16117 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16118 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16119 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16120 pdf
->id_len
= id_len
;
16122 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16123 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16124 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16125 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16126 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16127 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16128 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16129 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16130 pdf
->u_len
= u_len
;
16132 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16133 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16134 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16135 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16136 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16137 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16138 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16139 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16140 pdf
->o_len
= o_len
;
16142 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16143 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16144 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16145 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16147 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16148 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16149 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16150 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16151 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16152 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16153 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16154 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16156 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16157 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16158 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16159 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16160 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16161 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16162 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16163 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16165 // we use ID for salt, maybe needs to change, we will see...
16167 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16168 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16169 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16170 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16171 salt
->salt_len
= pdf
->id_len
;
16173 digest
[0] = pdf
->u_buf
[0];
16174 digest
[1] = pdf
->u_buf
[1];
16175 digest
[2] = pdf
->u_buf
[2];
16176 digest
[3] = pdf
->u_buf
[3];
16178 return (PARSER_OK
);
16181 int pdf11cm1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16183 return pdf11_parse_hash (input_buf
, input_len
, hash_buf
);
16186 int pdf11cm2_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16188 if ((input_len
< DISPLAY_LEN_MIN_10420
) || (input_len
> DISPLAY_LEN_MAX_10420
)) return (PARSER_GLOBAL_LENGTH
);
16190 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16192 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16194 salt_t
*salt
= hash_buf
->salt
;
16196 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16202 char *V_pos
= input_buf
+ 5;
16204 char *R_pos
= strchr (V_pos
, '*');
16206 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16208 uint32_t V_len
= R_pos
- V_pos
;
16212 char *bits_pos
= strchr (R_pos
, '*');
16214 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16216 uint32_t R_len
= bits_pos
- R_pos
;
16220 char *P_pos
= strchr (bits_pos
, '*');
16222 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16224 uint32_t bits_len
= P_pos
- bits_pos
;
16228 char *enc_md_pos
= strchr (P_pos
, '*');
16230 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16232 uint32_t P_len
= enc_md_pos
- P_pos
;
16236 char *id_len_pos
= strchr (enc_md_pos
, '*');
16238 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16240 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16244 char *id_buf_pos
= strchr (id_len_pos
, '*');
16246 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16248 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16252 char *u_len_pos
= strchr (id_buf_pos
, '*');
16254 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16256 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16258 if (id_buf_len
!= 32) return (PARSER_SALT_LENGTH
);
16262 char *u_buf_pos
= strchr (u_len_pos
, '*');
16264 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16266 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16270 char *o_len_pos
= strchr (u_buf_pos
, '*');
16272 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16274 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16276 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16280 char *o_buf_pos
= strchr (o_len_pos
, '*');
16282 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16284 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16288 char *rc4key_pos
= strchr (o_buf_pos
, ':');
16290 if (rc4key_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16292 uint32_t o_buf_len
= rc4key_pos
- o_buf_pos
;
16294 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16298 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;
16300 if (rc4key_len
!= 10) return (PARSER_SALT_LENGTH
);
16304 const int V
= atoi (V_pos
);
16305 const int R
= atoi (R_pos
);
16306 const int P
= atoi (P_pos
);
16308 if (V
!= 1) return (PARSER_SALT_VALUE
);
16309 if (R
!= 2) return (PARSER_SALT_VALUE
);
16311 const int enc_md
= atoi (enc_md_pos
);
16313 if ((enc_md
!= 0) && (enc_md
!= 1)) return (PARSER_SALT_VALUE
);
16315 const int id_len
= atoi (id_len_pos
);
16316 const int u_len
= atoi (u_len_pos
);
16317 const int o_len
= atoi (o_len_pos
);
16319 if (id_len
!= 16) return (PARSER_SALT_VALUE
);
16320 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16321 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16323 const int bits
= atoi (bits_pos
);
16325 if (bits
!= 40) return (PARSER_SALT_VALUE
);
16327 // copy data to esalt
16333 pdf
->enc_md
= enc_md
;
16335 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16336 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16337 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16338 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16339 pdf
->id_len
= id_len
;
16341 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16342 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16343 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16344 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16345 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16346 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16347 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16348 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16349 pdf
->u_len
= u_len
;
16351 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16352 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16353 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16354 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16355 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16356 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16357 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16358 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16359 pdf
->o_len
= o_len
;
16361 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16362 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16363 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16364 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16366 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16367 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16368 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16369 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16370 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16371 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16372 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16373 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16375 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16376 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16377 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16378 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16379 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16380 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16381 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16382 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16384 pdf
->rc4key
[1] = 0;
16385 pdf
->rc4key
[0] = 0;
16387 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[0]) << 28;
16388 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[1]) << 24;
16389 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[2]) << 20;
16390 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[3]) << 16;
16391 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[4]) << 12;
16392 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[5]) << 8;
16393 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[6]) << 4;
16394 pdf
->rc4key
[0] |= hex_convert (rc4key_pos
[7]) << 0;
16395 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[8]) << 28;
16396 pdf
->rc4key
[1] |= hex_convert (rc4key_pos
[9]) << 24;
16398 pdf
->rc4key
[0] = byte_swap_32 (pdf
->rc4key
[0]);
16399 pdf
->rc4key
[1] = byte_swap_32 (pdf
->rc4key
[1]);
16401 // we use ID for salt, maybe needs to change, we will see...
16403 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16404 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16405 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16406 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16407 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16408 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16409 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16410 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16411 salt
->salt_len
= pdf
->id_len
+ 16;
16413 digest
[0] = pdf
->rc4key
[0];
16414 digest
[1] = pdf
->rc4key
[1];
16418 return (PARSER_OK
);
16421 int pdf14_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16423 if ((input_len
< DISPLAY_LEN_MIN_10500
) || (input_len
> DISPLAY_LEN_MAX_10500
)) return (PARSER_GLOBAL_LENGTH
);
16425 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16427 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16429 salt_t
*salt
= hash_buf
->salt
;
16431 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16437 char *V_pos
= input_buf
+ 5;
16439 char *R_pos
= strchr (V_pos
, '*');
16441 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16443 uint32_t V_len
= R_pos
- V_pos
;
16447 char *bits_pos
= strchr (R_pos
, '*');
16449 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16451 uint32_t R_len
= bits_pos
- R_pos
;
16455 char *P_pos
= strchr (bits_pos
, '*');
16457 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16459 uint32_t bits_len
= P_pos
- bits_pos
;
16463 char *enc_md_pos
= strchr (P_pos
, '*');
16465 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16467 uint32_t P_len
= enc_md_pos
- P_pos
;
16471 char *id_len_pos
= strchr (enc_md_pos
, '*');
16473 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16475 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16479 char *id_buf_pos
= strchr (id_len_pos
, '*');
16481 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16483 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16487 char *u_len_pos
= strchr (id_buf_pos
, '*');
16489 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16491 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16493 if ((id_buf_len
!= 32) && (id_buf_len
!= 64)) return (PARSER_SALT_LENGTH
);
16497 char *u_buf_pos
= strchr (u_len_pos
, '*');
16499 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16501 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16505 char *o_len_pos
= strchr (u_buf_pos
, '*');
16507 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16509 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16511 if (u_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16515 char *o_buf_pos
= strchr (o_len_pos
, '*');
16517 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16519 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16523 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;
16525 if (o_buf_len
!= 64) return (PARSER_SALT_LENGTH
);
16529 const int V
= atoi (V_pos
);
16530 const int R
= atoi (R_pos
);
16531 const int P
= atoi (P_pos
);
16535 if ((V
== 2) && (R
== 3)) vr_ok
= 1;
16536 if ((V
== 4) && (R
== 4)) vr_ok
= 1;
16538 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16540 const int id_len
= atoi (id_len_pos
);
16541 const int u_len
= atoi (u_len_pos
);
16542 const int o_len
= atoi (o_len_pos
);
16544 if ((id_len
!= 16) && (id_len
!= 32)) return (PARSER_SALT_VALUE
);
16546 if (u_len
!= 32) return (PARSER_SALT_VALUE
);
16547 if (o_len
!= 32) return (PARSER_SALT_VALUE
);
16549 const int bits
= atoi (bits_pos
);
16551 if (bits
!= 128) return (PARSER_SALT_VALUE
);
16557 enc_md
= atoi (enc_md_pos
);
16560 // copy data to esalt
16566 pdf
->enc_md
= enc_md
;
16568 pdf
->id_buf
[0] = hex_to_uint (&id_buf_pos
[ 0]);
16569 pdf
->id_buf
[1] = hex_to_uint (&id_buf_pos
[ 8]);
16570 pdf
->id_buf
[2] = hex_to_uint (&id_buf_pos
[16]);
16571 pdf
->id_buf
[3] = hex_to_uint (&id_buf_pos
[24]);
16575 pdf
->id_buf
[4] = hex_to_uint (&id_buf_pos
[32]);
16576 pdf
->id_buf
[5] = hex_to_uint (&id_buf_pos
[40]);
16577 pdf
->id_buf
[6] = hex_to_uint (&id_buf_pos
[48]);
16578 pdf
->id_buf
[7] = hex_to_uint (&id_buf_pos
[56]);
16581 pdf
->id_len
= id_len
;
16583 pdf
->u_buf
[0] = hex_to_uint (&u_buf_pos
[ 0]);
16584 pdf
->u_buf
[1] = hex_to_uint (&u_buf_pos
[ 8]);
16585 pdf
->u_buf
[2] = hex_to_uint (&u_buf_pos
[16]);
16586 pdf
->u_buf
[3] = hex_to_uint (&u_buf_pos
[24]);
16587 pdf
->u_buf
[4] = hex_to_uint (&u_buf_pos
[32]);
16588 pdf
->u_buf
[5] = hex_to_uint (&u_buf_pos
[40]);
16589 pdf
->u_buf
[6] = hex_to_uint (&u_buf_pos
[48]);
16590 pdf
->u_buf
[7] = hex_to_uint (&u_buf_pos
[56]);
16591 pdf
->u_len
= u_len
;
16593 pdf
->o_buf
[0] = hex_to_uint (&o_buf_pos
[ 0]);
16594 pdf
->o_buf
[1] = hex_to_uint (&o_buf_pos
[ 8]);
16595 pdf
->o_buf
[2] = hex_to_uint (&o_buf_pos
[16]);
16596 pdf
->o_buf
[3] = hex_to_uint (&o_buf_pos
[24]);
16597 pdf
->o_buf
[4] = hex_to_uint (&o_buf_pos
[32]);
16598 pdf
->o_buf
[5] = hex_to_uint (&o_buf_pos
[40]);
16599 pdf
->o_buf
[6] = hex_to_uint (&o_buf_pos
[48]);
16600 pdf
->o_buf
[7] = hex_to_uint (&o_buf_pos
[56]);
16601 pdf
->o_len
= o_len
;
16603 pdf
->id_buf
[0] = byte_swap_32 (pdf
->id_buf
[0]);
16604 pdf
->id_buf
[1] = byte_swap_32 (pdf
->id_buf
[1]);
16605 pdf
->id_buf
[2] = byte_swap_32 (pdf
->id_buf
[2]);
16606 pdf
->id_buf
[3] = byte_swap_32 (pdf
->id_buf
[3]);
16610 pdf
->id_buf
[4] = byte_swap_32 (pdf
->id_buf
[4]);
16611 pdf
->id_buf
[5] = byte_swap_32 (pdf
->id_buf
[5]);
16612 pdf
->id_buf
[6] = byte_swap_32 (pdf
->id_buf
[6]);
16613 pdf
->id_buf
[7] = byte_swap_32 (pdf
->id_buf
[7]);
16616 pdf
->u_buf
[0] = byte_swap_32 (pdf
->u_buf
[0]);
16617 pdf
->u_buf
[1] = byte_swap_32 (pdf
->u_buf
[1]);
16618 pdf
->u_buf
[2] = byte_swap_32 (pdf
->u_buf
[2]);
16619 pdf
->u_buf
[3] = byte_swap_32 (pdf
->u_buf
[3]);
16620 pdf
->u_buf
[4] = byte_swap_32 (pdf
->u_buf
[4]);
16621 pdf
->u_buf
[5] = byte_swap_32 (pdf
->u_buf
[5]);
16622 pdf
->u_buf
[6] = byte_swap_32 (pdf
->u_buf
[6]);
16623 pdf
->u_buf
[7] = byte_swap_32 (pdf
->u_buf
[7]);
16625 pdf
->o_buf
[0] = byte_swap_32 (pdf
->o_buf
[0]);
16626 pdf
->o_buf
[1] = byte_swap_32 (pdf
->o_buf
[1]);
16627 pdf
->o_buf
[2] = byte_swap_32 (pdf
->o_buf
[2]);
16628 pdf
->o_buf
[3] = byte_swap_32 (pdf
->o_buf
[3]);
16629 pdf
->o_buf
[4] = byte_swap_32 (pdf
->o_buf
[4]);
16630 pdf
->o_buf
[5] = byte_swap_32 (pdf
->o_buf
[5]);
16631 pdf
->o_buf
[6] = byte_swap_32 (pdf
->o_buf
[6]);
16632 pdf
->o_buf
[7] = byte_swap_32 (pdf
->o_buf
[7]);
16634 // precompute rc4 data for later use
16650 uint salt_pc_block
[32];
16652 char *salt_pc_ptr
= (char *) salt_pc_block
;
16654 memcpy (salt_pc_ptr
, padding
, 32);
16655 memcpy (salt_pc_ptr
+ 32, pdf
->id_buf
, pdf
->id_len
);
16657 uint salt_pc_digest
[4];
16659 md5_complete_no_limit (salt_pc_digest
, salt_pc_block
, 32 + pdf
->id_len
);
16661 pdf
->rc4data
[0] = salt_pc_digest
[0];
16662 pdf
->rc4data
[1] = salt_pc_digest
[1];
16664 // we use ID for salt, maybe needs to change, we will see...
16666 salt
->salt_buf
[0] = pdf
->id_buf
[0];
16667 salt
->salt_buf
[1] = pdf
->id_buf
[1];
16668 salt
->salt_buf
[2] = pdf
->id_buf
[2];
16669 salt
->salt_buf
[3] = pdf
->id_buf
[3];
16670 salt
->salt_buf
[4] = pdf
->u_buf
[0];
16671 salt
->salt_buf
[5] = pdf
->u_buf
[1];
16672 salt
->salt_buf
[6] = pdf
->o_buf
[0];
16673 salt
->salt_buf
[7] = pdf
->o_buf
[1];
16674 salt
->salt_len
= pdf
->id_len
+ 16;
16676 salt
->salt_iter
= ROUNDS_PDF14
;
16678 digest
[0] = pdf
->u_buf
[0];
16679 digest
[1] = pdf
->u_buf
[1];
16683 return (PARSER_OK
);
16686 int pdf17l3_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16688 int ret
= pdf17l8_parse_hash (input_buf
, input_len
, hash_buf
);
16690 if (ret
!= PARSER_OK
)
16695 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16697 salt_t
*salt
= hash_buf
->salt
;
16699 digest
[0] -= SHA256M_A
;
16700 digest
[1] -= SHA256M_B
;
16701 digest
[2] -= SHA256M_C
;
16702 digest
[3] -= SHA256M_D
;
16703 digest
[4] -= SHA256M_E
;
16704 digest
[5] -= SHA256M_F
;
16705 digest
[6] -= SHA256M_G
;
16706 digest
[7] -= SHA256M_H
;
16708 salt
->salt_buf
[2] = 0x80;
16710 return (PARSER_OK
);
16713 int pdf17l8_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16715 if ((input_len
< DISPLAY_LEN_MIN_10600
) || (input_len
> DISPLAY_LEN_MAX_10600
)) return (PARSER_GLOBAL_LENGTH
);
16717 if ((memcmp (SIGNATURE_PDF
, input_buf
, 5)) && (memcmp (SIGNATURE_PDF
, input_buf
, 5))) return (PARSER_SIGNATURE_UNMATCHED
);
16719 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16721 salt_t
*salt
= hash_buf
->salt
;
16723 pdf_t
*pdf
= (pdf_t
*) hash_buf
->esalt
;
16729 char *V_pos
= input_buf
+ 5;
16731 char *R_pos
= strchr (V_pos
, '*');
16733 if (R_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16735 uint32_t V_len
= R_pos
- V_pos
;
16739 char *bits_pos
= strchr (R_pos
, '*');
16741 if (bits_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16743 uint32_t R_len
= bits_pos
- R_pos
;
16747 char *P_pos
= strchr (bits_pos
, '*');
16749 if (P_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16751 uint32_t bits_len
= P_pos
- bits_pos
;
16755 char *enc_md_pos
= strchr (P_pos
, '*');
16757 if (enc_md_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16759 uint32_t P_len
= enc_md_pos
- P_pos
;
16763 char *id_len_pos
= strchr (enc_md_pos
, '*');
16765 if (id_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16767 uint32_t enc_md_len
= id_len_pos
- enc_md_pos
;
16771 char *id_buf_pos
= strchr (id_len_pos
, '*');
16773 if (id_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16775 uint32_t id_len_len
= id_buf_pos
- id_len_pos
;
16779 char *u_len_pos
= strchr (id_buf_pos
, '*');
16781 if (u_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16783 uint32_t id_buf_len
= u_len_pos
- id_buf_pos
;
16787 char *u_buf_pos
= strchr (u_len_pos
, '*');
16789 if (u_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16791 uint32_t u_len_len
= u_buf_pos
- u_len_pos
;
16795 char *o_len_pos
= strchr (u_buf_pos
, '*');
16797 if (o_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16799 uint32_t u_buf_len
= o_len_pos
- u_buf_pos
;
16803 char *o_buf_pos
= strchr (o_len_pos
, '*');
16805 if (o_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16807 uint32_t o_len_len
= o_buf_pos
- o_len_pos
;
16811 char *last
= strchr (o_buf_pos
, '*');
16813 if (last
== NULL
) last
= input_buf
+ input_len
;
16815 uint32_t o_buf_len
= last
- o_buf_pos
;
16819 const int V
= atoi (V_pos
);
16820 const int R
= atoi (R_pos
);
16824 if ((V
== 5) && (R
== 5)) vr_ok
= 1;
16825 if ((V
== 5) && (R
== 6)) vr_ok
= 1;
16827 if (vr_ok
== 0) return (PARSER_SALT_VALUE
);
16829 const int bits
= atoi (bits_pos
);
16831 if (bits
!= 256) return (PARSER_SALT_VALUE
);
16833 int enc_md
= atoi (enc_md_pos
);
16835 if (enc_md
!= 1) return (PARSER_SALT_VALUE
);
16837 const uint id_len
= atoi (id_len_pos
);
16838 const uint u_len
= atoi (u_len_pos
);
16839 const uint o_len
= atoi (o_len_pos
);
16841 if (V_len
> 6) return (PARSER_SALT_LENGTH
);
16842 if (R_len
> 6) return (PARSER_SALT_LENGTH
);
16843 if (P_len
> 6) return (PARSER_SALT_LENGTH
);
16844 if (id_len_len
> 6) return (PARSER_SALT_LENGTH
);
16845 if (u_len_len
> 6) return (PARSER_SALT_LENGTH
);
16846 if (o_len_len
> 6) return (PARSER_SALT_LENGTH
);
16847 if (bits_len
> 6) return (PARSER_SALT_LENGTH
);
16848 if (enc_md_len
> 6) return (PARSER_SALT_LENGTH
);
16850 if ((id_len
* 2) != id_buf_len
) return (PARSER_SALT_VALUE
);
16851 if ((u_len
* 2) != u_buf_len
) return (PARSER_SALT_VALUE
);
16852 if ((o_len
* 2) != o_buf_len
) return (PARSER_SALT_VALUE
);
16854 // copy data to esalt
16856 if (u_len
< 40) return (PARSER_SALT_VALUE
);
16858 for (int i
= 0, j
= 0; i
< 8 + 2; i
+= 1, j
+= 8)
16860 pdf
->u_buf
[i
] = hex_to_uint (&u_buf_pos
[j
]);
16863 salt
->salt_buf
[0] = pdf
->u_buf
[8];
16864 salt
->salt_buf
[1] = pdf
->u_buf
[9];
16866 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
16867 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
16869 salt
->salt_len
= 8;
16870 salt
->salt_iter
= ROUNDS_PDF17L8
;
16872 digest
[0] = pdf
->u_buf
[0];
16873 digest
[1] = pdf
->u_buf
[1];
16874 digest
[2] = pdf
->u_buf
[2];
16875 digest
[3] = pdf
->u_buf
[3];
16876 digest
[4] = pdf
->u_buf
[4];
16877 digest
[5] = pdf
->u_buf
[5];
16878 digest
[6] = pdf
->u_buf
[6];
16879 digest
[7] = pdf
->u_buf
[7];
16881 return (PARSER_OK
);
16884 int pbkdf2_sha256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16886 if ((input_len
< DISPLAY_LEN_MIN_10900
) || (input_len
> DISPLAY_LEN_MAX_10900
)) return (PARSER_GLOBAL_LENGTH
);
16888 if (memcmp (SIGNATURE_PBKDF2_SHA256
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
16890 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16892 salt_t
*salt
= hash_buf
->salt
;
16894 pbkdf2_sha256_t
*pbkdf2_sha256
= (pbkdf2_sha256_t
*) hash_buf
->esalt
;
16902 char *iter_pos
= input_buf
+ 7;
16904 uint32_t iter
= atoi (iter_pos
);
16906 if (iter
< 1) return (PARSER_SALT_ITERATION
);
16907 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
16909 // first is *raw* salt
16911 char *salt_pos
= strchr (iter_pos
, ':');
16913 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16917 char *hash_pos
= strchr (salt_pos
, ':');
16919 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
16921 uint32_t salt_len
= hash_pos
- salt_pos
;
16923 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
16927 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
16929 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
16933 char *salt_buf_ptr
= (char *) pbkdf2_sha256
->salt_buf
;
16935 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
16937 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
16939 salt_buf_ptr
[salt_len
+ 3] = 0x01;
16940 salt_buf_ptr
[salt_len
+ 4] = 0x80;
16942 salt
->salt_len
= salt_len
;
16943 salt
->salt_iter
= iter
- 1;
16949 memset (tmp_buf
, 0, sizeof (tmp_buf
));
16951 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
16953 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
16955 memcpy (digest
, tmp_buf
, 16);
16957 digest
[0] = byte_swap_32 (digest
[0]);
16958 digest
[1] = byte_swap_32 (digest
[1]);
16959 digest
[2] = byte_swap_32 (digest
[2]);
16960 digest
[3] = byte_swap_32 (digest
[3]);
16962 // add some stuff to normal salt to make sorted happy
16964 salt
->salt_buf
[0] = pbkdf2_sha256
->salt_buf
[0];
16965 salt
->salt_buf
[1] = pbkdf2_sha256
->salt_buf
[1];
16966 salt
->salt_buf
[2] = pbkdf2_sha256
->salt_buf
[2];
16967 salt
->salt_buf
[3] = pbkdf2_sha256
->salt_buf
[3];
16968 salt
->salt_buf
[4] = salt
->salt_iter
;
16970 return (PARSER_OK
);
16973 int prestashop_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
16975 if ((input_len
< DISPLAY_LEN_MIN_11000
) || (input_len
> DISPLAY_LEN_MAX_11000
)) return (PARSER_GLOBAL_LENGTH
);
16977 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
16979 salt_t
*salt
= hash_buf
->salt
;
16981 digest
[0] = hex_to_uint (&input_buf
[ 0]);
16982 digest
[1] = hex_to_uint (&input_buf
[ 8]);
16983 digest
[2] = hex_to_uint (&input_buf
[16]);
16984 digest
[3] = hex_to_uint (&input_buf
[24]);
16986 digest
[0] = byte_swap_32 (digest
[0]);
16987 digest
[1] = byte_swap_32 (digest
[1]);
16988 digest
[2] = byte_swap_32 (digest
[2]);
16989 digest
[3] = byte_swap_32 (digest
[3]);
16991 if (input_buf
[32] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
16993 uint salt_len
= input_len
- 32 - 1;
16995 char *salt_buf
= input_buf
+ 32 + 1;
16997 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
16999 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17001 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17003 salt
->salt_len
= salt_len
;
17005 return (PARSER_OK
);
17008 int postgresql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17010 if ((input_len
< DISPLAY_LEN_MIN_11100
) || (input_len
> DISPLAY_LEN_MAX_11100
)) return (PARSER_GLOBAL_LENGTH
);
17012 if (memcmp (SIGNATURE_POSTGRESQL_AUTH
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
17014 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17016 salt_t
*salt
= hash_buf
->salt
;
17018 char *user_pos
= input_buf
+ 10;
17020 char *salt_pos
= strchr (user_pos
, '*');
17022 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17026 char *hash_pos
= strchr (salt_pos
, '*');
17030 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17032 if (hash_len
!= 32) return (PARSER_HASH_LENGTH
);
17034 uint user_len
= salt_pos
- user_pos
- 1;
17036 uint salt_len
= hash_pos
- salt_pos
- 1;
17038 if (salt_len
!= 8) return (PARSER_SALT_LENGTH
);
17044 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
17045 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
17046 digest
[2] = hex_to_uint (&hash_pos
[16]);
17047 digest
[3] = hex_to_uint (&hash_pos
[24]);
17049 digest
[0] = byte_swap_32 (digest
[0]);
17050 digest
[1] = byte_swap_32 (digest
[1]);
17051 digest
[2] = byte_swap_32 (digest
[2]);
17052 digest
[3] = byte_swap_32 (digest
[3]);
17054 digest
[0] -= MD5M_A
;
17055 digest
[1] -= MD5M_B
;
17056 digest
[2] -= MD5M_C
;
17057 digest
[3] -= MD5M_D
;
17063 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17065 // first 4 bytes are the "challenge"
17067 salt_buf_ptr
[0] = hex_to_char (&salt_pos
[0]);
17068 salt_buf_ptr
[1] = hex_to_char (&salt_pos
[2]);
17069 salt_buf_ptr
[2] = hex_to_char (&salt_pos
[4]);
17070 salt_buf_ptr
[3] = hex_to_char (&salt_pos
[6]);
17072 // append the user name
17074 user_len
= parse_and_store_salt (salt_buf_ptr
+ 4, user_pos
, user_len
);
17076 salt
->salt_len
= 4 + user_len
;
17078 return (PARSER_OK
);
17081 int mysql_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17083 if ((input_len
< DISPLAY_LEN_MIN_11200
) || (input_len
> DISPLAY_LEN_MAX_11200
)) return (PARSER_GLOBAL_LENGTH
);
17085 if (memcmp (SIGNATURE_MYSQL_AUTH
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17087 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17089 salt_t
*salt
= hash_buf
->salt
;
17091 char *salt_pos
= input_buf
+ 9;
17093 char *hash_pos
= strchr (salt_pos
, '*');
17095 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17099 uint hash_len
= input_len
- (hash_pos
- input_buf
);
17101 if (hash_len
!= 40) return (PARSER_HASH_LENGTH
);
17103 uint salt_len
= hash_pos
- salt_pos
- 1;
17105 if (salt_len
!= 40) return (PARSER_SALT_LENGTH
);
17111 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
17112 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
17113 digest
[2] = hex_to_uint (&hash_pos
[16]);
17114 digest
[3] = hex_to_uint (&hash_pos
[24]);
17115 digest
[4] = hex_to_uint (&hash_pos
[32]);
17121 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17123 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17125 salt
->salt_len
= salt_len
;
17127 return (PARSER_OK
);
17130 int bitcoin_wallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17132 if ((input_len
< DISPLAY_LEN_MIN_11300
) || (input_len
> DISPLAY_LEN_MAX_11300
)) return (PARSER_GLOBAL_LENGTH
);
17134 if (memcmp (SIGNATURE_BITCOIN_WALLET
, input_buf
, 9)) return (PARSER_SIGNATURE_UNMATCHED
);
17136 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17138 salt_t
*salt
= hash_buf
->salt
;
17140 bitcoin_wallet_t
*bitcoin_wallet
= (bitcoin_wallet_t
*) hash_buf
->esalt
;
17146 char *cry_master_len_pos
= input_buf
+ 9;
17148 char *cry_master_buf_pos
= strchr (cry_master_len_pos
, '$');
17150 if (cry_master_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17152 uint32_t cry_master_len_len
= cry_master_buf_pos
- cry_master_len_pos
;
17154 cry_master_buf_pos
++;
17156 char *cry_salt_len_pos
= strchr (cry_master_buf_pos
, '$');
17158 if (cry_salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17160 uint32_t cry_master_buf_len
= cry_salt_len_pos
- cry_master_buf_pos
;
17162 cry_salt_len_pos
++;
17164 char *cry_salt_buf_pos
= strchr (cry_salt_len_pos
, '$');
17166 if (cry_salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17168 uint32_t cry_salt_len_len
= cry_salt_buf_pos
- cry_salt_len_pos
;
17170 cry_salt_buf_pos
++;
17172 char *cry_rounds_pos
= strchr (cry_salt_buf_pos
, '$');
17174 if (cry_rounds_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17176 uint32_t cry_salt_buf_len
= cry_rounds_pos
- cry_salt_buf_pos
;
17180 char *ckey_len_pos
= strchr (cry_rounds_pos
, '$');
17182 if (ckey_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17184 uint32_t cry_rounds_len
= ckey_len_pos
- cry_rounds_pos
;
17188 char *ckey_buf_pos
= strchr (ckey_len_pos
, '$');
17190 if (ckey_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17192 uint32_t ckey_len_len
= ckey_buf_pos
- ckey_len_pos
;
17196 char *public_key_len_pos
= strchr (ckey_buf_pos
, '$');
17198 if (public_key_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17200 uint32_t ckey_buf_len
= public_key_len_pos
- ckey_buf_pos
;
17202 public_key_len_pos
++;
17204 char *public_key_buf_pos
= strchr (public_key_len_pos
, '$');
17206 if (public_key_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17208 uint32_t public_key_len_len
= public_key_buf_pos
- public_key_len_pos
;
17210 public_key_buf_pos
++;
17212 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;
17214 const uint cry_master_len
= atoi (cry_master_len_pos
);
17215 const uint cry_salt_len
= atoi (cry_salt_len_pos
);
17216 const uint ckey_len
= atoi (ckey_len_pos
);
17217 const uint public_key_len
= atoi (public_key_len_pos
);
17219 if (cry_master_buf_len
!= cry_master_len
) return (PARSER_SALT_VALUE
);
17220 if (cry_salt_buf_len
!= cry_salt_len
) return (PARSER_SALT_VALUE
);
17221 if (ckey_buf_len
!= ckey_len
) return (PARSER_SALT_VALUE
);
17222 if (public_key_buf_len
!= public_key_len
) return (PARSER_SALT_VALUE
);
17224 for (uint i
= 0, j
= 0; i
< cry_master_len
; i
+= 1, j
+= 8)
17226 bitcoin_wallet
->cry_master_buf
[i
] = hex_to_uint (&cry_master_buf_pos
[j
]);
17228 bitcoin_wallet
->cry_master_buf
[i
] = byte_swap_32 (bitcoin_wallet
->cry_master_buf
[i
]);
17231 for (uint i
= 0, j
= 0; i
< ckey_len
; i
+= 1, j
+= 8)
17233 bitcoin_wallet
->ckey_buf
[i
] = hex_to_uint (&ckey_buf_pos
[j
]);
17235 bitcoin_wallet
->ckey_buf
[i
] = byte_swap_32 (bitcoin_wallet
->ckey_buf
[i
]);
17238 for (uint i
= 0, j
= 0; i
< public_key_len
; i
+= 1, j
+= 8)
17240 bitcoin_wallet
->public_key_buf
[i
] = hex_to_uint (&public_key_buf_pos
[j
]);
17242 bitcoin_wallet
->public_key_buf
[i
] = byte_swap_32 (bitcoin_wallet
->public_key_buf
[i
]);
17245 bitcoin_wallet
->cry_master_len
= cry_master_len
/ 2;
17246 bitcoin_wallet
->ckey_len
= ckey_len
/ 2;
17247 bitcoin_wallet
->public_key_len
= public_key_len
/ 2;
17250 * store digest (should be unique enought, hopefully)
17253 digest
[0] = bitcoin_wallet
->cry_master_buf
[0];
17254 digest
[1] = bitcoin_wallet
->cry_master_buf
[1];
17255 digest
[2] = bitcoin_wallet
->cry_master_buf
[2];
17256 digest
[3] = bitcoin_wallet
->cry_master_buf
[3];
17262 if (cry_rounds_len
>= 7) return (PARSER_SALT_VALUE
);
17264 const uint cry_rounds
= atoi (cry_rounds_pos
);
17266 salt
->salt_iter
= cry_rounds
- 1;
17268 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17270 const uint salt_len
= parse_and_store_salt (salt_buf_ptr
, cry_salt_buf_pos
, cry_salt_buf_len
);
17272 salt
->salt_len
= salt_len
;
17274 return (PARSER_OK
);
17277 int sip_auth_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17279 if ((input_len
< DISPLAY_LEN_MIN_11400
) || (input_len
> DISPLAY_LEN_MAX_11400
)) return (PARSER_GLOBAL_LENGTH
);
17281 if (memcmp (SIGNATURE_SIP_AUTH
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
17283 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17285 salt_t
*salt
= hash_buf
->salt
;
17287 sip_t
*sip
= (sip_t
*) hash_buf
->esalt
;
17289 // work with a temporary copy of input_buf (s.t. we can manipulate it directly)
17291 char temp_input_buf
[input_len
+ 1];
17293 memset (temp_input_buf
, 0, sizeof (temp_input_buf
));
17294 memcpy (temp_input_buf
, input_buf
, input_len
);
17298 char *URI_server_pos
= temp_input_buf
+ 6;
17300 char *URI_client_pos
= strchr (URI_server_pos
, '*');
17302 if (URI_client_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17304 URI_client_pos
[0] = 0;
17307 uint URI_server_len
= strlen (URI_server_pos
);
17309 if (URI_server_len
> 512) return (PARSER_SALT_LENGTH
);
17313 char *user_pos
= strchr (URI_client_pos
, '*');
17315 if (user_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17320 uint URI_client_len
= strlen (URI_client_pos
);
17322 if (URI_client_len
> 512) return (PARSER_SALT_LENGTH
);
17326 char *realm_pos
= strchr (user_pos
, '*');
17328 if (realm_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17333 uint user_len
= strlen (user_pos
);
17335 if (user_len
> 116) return (PARSER_SALT_LENGTH
);
17339 char *method_pos
= strchr (realm_pos
, '*');
17341 if (method_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17346 uint realm_len
= strlen (realm_pos
);
17348 if (realm_len
> 116) return (PARSER_SALT_LENGTH
);
17352 char *URI_prefix_pos
= strchr (method_pos
, '*');
17354 if (URI_prefix_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17356 URI_prefix_pos
[0] = 0;
17359 uint method_len
= strlen (method_pos
);
17361 if (method_len
> 246) return (PARSER_SALT_LENGTH
);
17365 char *URI_resource_pos
= strchr (URI_prefix_pos
, '*');
17367 if (URI_resource_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17369 URI_resource_pos
[0] = 0;
17370 URI_resource_pos
++;
17372 uint URI_prefix_len
= strlen (URI_prefix_pos
);
17374 if (URI_prefix_len
> 245) return (PARSER_SALT_LENGTH
);
17378 char *URI_suffix_pos
= strchr (URI_resource_pos
, '*');
17380 if (URI_suffix_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17382 URI_suffix_pos
[0] = 0;
17385 uint URI_resource_len
= strlen (URI_resource_pos
);
17387 if (URI_resource_len
< 1) return (PARSER_SALT_LENGTH
);
17388 if (URI_resource_len
> 246) return (PARSER_SALT_LENGTH
);
17392 char *nonce_pos
= strchr (URI_suffix_pos
, '*');
17394 if (nonce_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17399 uint URI_suffix_len
= strlen (URI_suffix_pos
);
17401 if (URI_suffix_len
> 245) return (PARSER_SALT_LENGTH
);
17405 char *nonce_client_pos
= strchr (nonce_pos
, '*');
17407 if (nonce_client_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17409 nonce_client_pos
[0] = 0;
17410 nonce_client_pos
++;
17412 uint nonce_len
= strlen (nonce_pos
);
17414 if (nonce_len
< 1) return (PARSER_SALT_LENGTH
);
17415 if (nonce_len
> 50) return (PARSER_SALT_LENGTH
);
17419 char *nonce_count_pos
= strchr (nonce_client_pos
, '*');
17421 if (nonce_count_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17423 nonce_count_pos
[0] = 0;
17426 uint nonce_client_len
= strlen (nonce_client_pos
);
17428 if (nonce_client_len
> 50) return (PARSER_SALT_LENGTH
);
17432 char *qop_pos
= strchr (nonce_count_pos
, '*');
17434 if (qop_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17439 uint nonce_count_len
= strlen (nonce_count_pos
);
17441 if (nonce_count_len
> 50) return (PARSER_SALT_LENGTH
);
17445 char *directive_pos
= strchr (qop_pos
, '*');
17447 if (directive_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17449 directive_pos
[0] = 0;
17452 uint qop_len
= strlen (qop_pos
);
17454 if (qop_len
> 50) return (PARSER_SALT_LENGTH
);
17458 char *digest_pos
= strchr (directive_pos
, '*');
17460 if (digest_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17465 uint directive_len
= strlen (directive_pos
);
17467 if (directive_len
!= 3) return (PARSER_SALT_LENGTH
);
17469 if (memcmp (directive_pos
, "MD5", 3))
17471 log_info ("ERROR: only the MD5 directive is currently supported\n");
17473 return (PARSER_SIP_AUTH_DIRECTIVE
);
17477 * first (pre-)compute: HA2 = md5 ($method . ":" . $uri)
17482 uint md5_max_len
= 4 * 64;
17484 uint md5_remaining_len
= md5_max_len
;
17486 uint tmp_md5_buf
[md5_max_len
/ 4];
17488 memset (tmp_md5_buf
, 0, sizeof (tmp_md5_buf
));
17490 char *tmp_md5_ptr
= (char *) tmp_md5_buf
;
17492 snprintf (tmp_md5_ptr
, md5_remaining_len
, "%s:", method_pos
);
17494 md5_len
+= method_len
+ 1;
17495 tmp_md5_ptr
+= method_len
+ 1;
17497 if (URI_prefix_len
> 0)
17499 md5_remaining_len
= md5_max_len
- md5_len
;
17501 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s:", URI_prefix_pos
);
17503 md5_len
+= URI_prefix_len
+ 1;
17504 tmp_md5_ptr
+= URI_prefix_len
+ 1;
17507 md5_remaining_len
= md5_max_len
- md5_len
;
17509 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, "%s", URI_resource_pos
);
17511 md5_len
+= URI_resource_len
;
17512 tmp_md5_ptr
+= URI_resource_len
;
17514 if (URI_suffix_len
> 0)
17516 md5_remaining_len
= md5_max_len
- md5_len
;
17518 snprintf (tmp_md5_ptr
, md5_remaining_len
+ 1, ":%s", URI_suffix_pos
);
17520 md5_len
+= 1 + URI_suffix_len
;
17523 uint tmp_digest
[4];
17525 md5_complete_no_limit (tmp_digest
, tmp_md5_buf
, md5_len
);
17527 tmp_digest
[0] = byte_swap_32 (tmp_digest
[0]);
17528 tmp_digest
[1] = byte_swap_32 (tmp_digest
[1]);
17529 tmp_digest
[2] = byte_swap_32 (tmp_digest
[2]);
17530 tmp_digest
[3] = byte_swap_32 (tmp_digest
[3]);
17536 char *esalt_buf_ptr
= (char *) sip
->esalt_buf
;
17538 uint esalt_len
= 0;
17540 uint max_esalt_len
= sizeof (sip
->esalt_buf
); // 151 = (64 + 64 + 55) - 32, where 32 is the hexadecimal MD5 HA1 hash
17542 // there are 2 possibilities for the esalt:
17544 if ((strcmp (qop_pos
, "auth") == 0) || (strcmp (qop_pos
, "auth-int") == 0))
17546 esalt_len
= 1 + nonce_len
+ 1 + nonce_count_len
+ 1 + nonce_client_len
+ 1 + qop_len
+ 1 + 32;
17548 if (esalt_len
> max_esalt_len
) return (PARSER_SALT_LENGTH
);
17550 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%s:%s:%s:%08x%08x%08x%08x",
17562 esalt_len
= 1 + nonce_len
+ 1 + 32;
17564 if (esalt_len
> max_esalt_len
) return (PARSER_SALT_LENGTH
);
17566 snprintf (esalt_buf_ptr
, max_esalt_len
, ":%s:%08x%08x%08x%08x",
17574 // add 0x80 to esalt
17576 esalt_buf_ptr
[esalt_len
] = 0x80;
17578 sip
->esalt_len
= esalt_len
;
17584 char *sip_salt_ptr
= (char *) sip
->salt_buf
;
17586 uint salt_len
= user_len
+ 1 + realm_len
+ 1;
17588 uint max_salt_len
= 119;
17590 if (salt_len
> max_salt_len
) return (PARSER_SALT_LENGTH
);
17592 snprintf (sip_salt_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17594 sip
->salt_len
= salt_len
;
17597 * fake salt (for sorting)
17600 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17604 uint fake_salt_len
= salt_len
;
17606 if (fake_salt_len
> max_salt_len
)
17608 fake_salt_len
= max_salt_len
;
17611 snprintf (salt_buf_ptr
, max_salt_len
+ 1, "%s:%s:", user_pos
, realm_pos
);
17613 salt
->salt_len
= fake_salt_len
;
17619 digest
[0] = hex_to_uint (&digest_pos
[ 0]);
17620 digest
[1] = hex_to_uint (&digest_pos
[ 8]);
17621 digest
[2] = hex_to_uint (&digest_pos
[16]);
17622 digest
[3] = hex_to_uint (&digest_pos
[24]);
17624 digest
[0] = byte_swap_32 (digest
[0]);
17625 digest
[1] = byte_swap_32 (digest
[1]);
17626 digest
[2] = byte_swap_32 (digest
[2]);
17627 digest
[3] = byte_swap_32 (digest
[3]);
17629 return (PARSER_OK
);
17632 int crc32_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17634 if ((input_len
< DISPLAY_LEN_MIN_11500
) || (input_len
> DISPLAY_LEN_MAX_11500
)) return (PARSER_GLOBAL_LENGTH
);
17636 if (input_buf
[8] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
17638 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17640 salt_t
*salt
= hash_buf
->salt
;
17644 char *digest_pos
= input_buf
;
17646 digest
[0] = hex_to_uint (&digest_pos
[0]);
17653 char *salt_buf
= input_buf
+ 8 + 1;
17657 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
17659 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
17661 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17663 salt
->salt_len
= salt_len
;
17665 return (PARSER_OK
);
17668 int seven_zip_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17670 if ((input_len
< DISPLAY_LEN_MIN_11600
) || (input_len
> DISPLAY_LEN_MAX_11600
)) return (PARSER_GLOBAL_LENGTH
);
17672 if (memcmp (SIGNATURE_SEVEN_ZIP
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17674 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17676 salt_t
*salt
= hash_buf
->salt
;
17678 seven_zip_t
*seven_zip
= (seven_zip_t
*) hash_buf
->esalt
;
17684 char *p_buf_pos
= input_buf
+ 4;
17686 char *NumCyclesPower_pos
= strchr (p_buf_pos
, '$');
17688 if (NumCyclesPower_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17690 uint32_t p_buf_len
= NumCyclesPower_pos
- p_buf_pos
;
17692 NumCyclesPower_pos
++;
17694 char *salt_len_pos
= strchr (NumCyclesPower_pos
, '$');
17696 if (salt_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17698 uint32_t NumCyclesPower_len
= salt_len_pos
- NumCyclesPower_pos
;
17702 char *salt_buf_pos
= strchr (salt_len_pos
, '$');
17704 if (salt_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17706 uint32_t salt_len_len
= salt_buf_pos
- salt_len_pos
;
17710 char *iv_len_pos
= strchr (salt_buf_pos
, '$');
17712 if (iv_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17714 uint32_t salt_buf_len
= iv_len_pos
- salt_buf_pos
;
17718 char *iv_buf_pos
= strchr (iv_len_pos
, '$');
17720 if (iv_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17722 uint32_t iv_len_len
= iv_buf_pos
- iv_len_pos
;
17726 char *crc_buf_pos
= strchr (iv_buf_pos
, '$');
17728 if (crc_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17730 uint32_t iv_buf_len
= crc_buf_pos
- iv_buf_pos
;
17734 char *data_len_pos
= strchr (crc_buf_pos
, '$');
17736 if (data_len_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17738 uint32_t crc_buf_len
= data_len_pos
- crc_buf_pos
;
17742 char *unpack_size_pos
= strchr (data_len_pos
, '$');
17744 if (unpack_size_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17746 uint32_t data_len_len
= unpack_size_pos
- data_len_pos
;
17750 char *data_buf_pos
= strchr (unpack_size_pos
, '$');
17752 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17754 uint32_t unpack_size_len
= data_buf_pos
- unpack_size_pos
;
17758 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;
17760 const uint iter
= atoi (NumCyclesPower_pos
);
17761 const uint crc
= atoi (crc_buf_pos
);
17762 const uint p_buf
= atoi (p_buf_pos
);
17763 const uint salt_len
= atoi (salt_len_pos
);
17764 const uint iv_len
= atoi (iv_len_pos
);
17765 const uint unpack_size
= atoi (unpack_size_pos
);
17766 const uint data_len
= atoi (data_len_pos
);
17772 if (p_buf
!= 0) return (PARSER_SALT_VALUE
);
17773 if (salt_len
!= 0) return (PARSER_SALT_VALUE
);
17775 if ((data_len
* 2) != data_buf_len
) return (PARSER_SALT_VALUE
);
17777 if (data_len
> 384) return (PARSER_SALT_VALUE
);
17779 if (unpack_size
> data_len
) return (PARSER_SALT_VALUE
);
17785 seven_zip
->iv_buf
[0] = hex_to_uint (&iv_buf_pos
[ 0]);
17786 seven_zip
->iv_buf
[1] = hex_to_uint (&iv_buf_pos
[ 8]);
17787 seven_zip
->iv_buf
[2] = hex_to_uint (&iv_buf_pos
[16]);
17788 seven_zip
->iv_buf
[3] = hex_to_uint (&iv_buf_pos
[24]);
17790 seven_zip
->iv_len
= iv_len
;
17792 memcpy (seven_zip
->salt_buf
, salt_buf_pos
, salt_buf_len
); // we just need that for later ascii_digest()
17794 seven_zip
->salt_len
= 0;
17796 seven_zip
->crc
= crc
;
17798 for (uint i
= 0, j
= 0; j
< data_buf_len
; i
+= 1, j
+= 8)
17800 seven_zip
->data_buf
[i
] = hex_to_uint (&data_buf_pos
[j
]);
17802 seven_zip
->data_buf
[i
] = byte_swap_32 (seven_zip
->data_buf
[i
]);
17805 seven_zip
->data_len
= data_len
;
17807 seven_zip
->unpack_size
= unpack_size
;
17811 salt
->salt_buf
[0] = seven_zip
->data_buf
[0];
17812 salt
->salt_buf
[1] = seven_zip
->data_buf
[1];
17813 salt
->salt_buf
[2] = seven_zip
->data_buf
[2];
17814 salt
->salt_buf
[3] = seven_zip
->data_buf
[3];
17816 salt
->salt_len
= 16;
17818 salt
->salt_sign
[0] = iter
;
17820 salt
->salt_iter
= 1 << iter
;
17831 return (PARSER_OK
);
17834 int gost2012sbog_256_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17836 if ((input_len
< DISPLAY_LEN_MIN_11700
) || (input_len
> DISPLAY_LEN_MAX_11700
)) return (PARSER_GLOBAL_LENGTH
);
17838 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17840 digest
[0] = hex_to_uint (&input_buf
[ 0]);
17841 digest
[1] = hex_to_uint (&input_buf
[ 8]);
17842 digest
[2] = hex_to_uint (&input_buf
[16]);
17843 digest
[3] = hex_to_uint (&input_buf
[24]);
17844 digest
[4] = hex_to_uint (&input_buf
[32]);
17845 digest
[5] = hex_to_uint (&input_buf
[40]);
17846 digest
[6] = hex_to_uint (&input_buf
[48]);
17847 digest
[7] = hex_to_uint (&input_buf
[56]);
17849 digest
[0] = byte_swap_32 (digest
[0]);
17850 digest
[1] = byte_swap_32 (digest
[1]);
17851 digest
[2] = byte_swap_32 (digest
[2]);
17852 digest
[3] = byte_swap_32 (digest
[3]);
17853 digest
[4] = byte_swap_32 (digest
[4]);
17854 digest
[5] = byte_swap_32 (digest
[5]);
17855 digest
[6] = byte_swap_32 (digest
[6]);
17856 digest
[7] = byte_swap_32 (digest
[7]);
17858 return (PARSER_OK
);
17861 int gost2012sbog_512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17863 if ((input_len
< DISPLAY_LEN_MIN_11800
) || (input_len
> DISPLAY_LEN_MAX_11800
)) return (PARSER_GLOBAL_LENGTH
);
17865 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17867 digest
[ 0] = hex_to_uint (&input_buf
[ 0]);
17868 digest
[ 1] = hex_to_uint (&input_buf
[ 8]);
17869 digest
[ 2] = hex_to_uint (&input_buf
[ 16]);
17870 digest
[ 3] = hex_to_uint (&input_buf
[ 24]);
17871 digest
[ 4] = hex_to_uint (&input_buf
[ 32]);
17872 digest
[ 5] = hex_to_uint (&input_buf
[ 40]);
17873 digest
[ 6] = hex_to_uint (&input_buf
[ 48]);
17874 digest
[ 7] = hex_to_uint (&input_buf
[ 56]);
17875 digest
[ 8] = hex_to_uint (&input_buf
[ 64]);
17876 digest
[ 9] = hex_to_uint (&input_buf
[ 72]);
17877 digest
[10] = hex_to_uint (&input_buf
[ 80]);
17878 digest
[11] = hex_to_uint (&input_buf
[ 88]);
17879 digest
[12] = hex_to_uint (&input_buf
[ 96]);
17880 digest
[13] = hex_to_uint (&input_buf
[104]);
17881 digest
[14] = hex_to_uint (&input_buf
[112]);
17882 digest
[15] = hex_to_uint (&input_buf
[120]);
17884 digest
[ 0] = byte_swap_32 (digest
[ 0]);
17885 digest
[ 1] = byte_swap_32 (digest
[ 1]);
17886 digest
[ 2] = byte_swap_32 (digest
[ 2]);
17887 digest
[ 3] = byte_swap_32 (digest
[ 3]);
17888 digest
[ 4] = byte_swap_32 (digest
[ 4]);
17889 digest
[ 5] = byte_swap_32 (digest
[ 5]);
17890 digest
[ 6] = byte_swap_32 (digest
[ 6]);
17891 digest
[ 7] = byte_swap_32 (digest
[ 7]);
17892 digest
[ 8] = byte_swap_32 (digest
[ 8]);
17893 digest
[ 9] = byte_swap_32 (digest
[ 9]);
17894 digest
[10] = byte_swap_32 (digest
[10]);
17895 digest
[11] = byte_swap_32 (digest
[11]);
17896 digest
[12] = byte_swap_32 (digest
[12]);
17897 digest
[13] = byte_swap_32 (digest
[13]);
17898 digest
[14] = byte_swap_32 (digest
[14]);
17899 digest
[15] = byte_swap_32 (digest
[15]);
17901 return (PARSER_OK
);
17904 int pbkdf2_md5_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17906 if ((input_len
< DISPLAY_LEN_MIN_11900
) || (input_len
> DISPLAY_LEN_MAX_11900
)) return (PARSER_GLOBAL_LENGTH
);
17908 if (memcmp (SIGNATURE_PBKDF2_MD5
, input_buf
, 4)) return (PARSER_SIGNATURE_UNMATCHED
);
17910 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17912 salt_t
*salt
= hash_buf
->salt
;
17914 pbkdf2_md5_t
*pbkdf2_md5
= (pbkdf2_md5_t
*) hash_buf
->esalt
;
17922 char *iter_pos
= input_buf
+ 4;
17924 uint32_t iter
= atoi (iter_pos
);
17926 if (iter
< 1) return (PARSER_SALT_ITERATION
);
17927 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
17929 // first is *raw* salt
17931 char *salt_pos
= strchr (iter_pos
, ':');
17933 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17937 char *hash_pos
= strchr (salt_pos
, ':');
17939 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
17941 uint32_t salt_len
= hash_pos
- salt_pos
;
17943 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
17947 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
17949 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
17953 char *salt_buf_ptr
= (char *) pbkdf2_md5
->salt_buf
;
17955 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
17957 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
17959 salt_buf_ptr
[salt_len
+ 3] = 0x01;
17960 salt_buf_ptr
[salt_len
+ 4] = 0x80;
17962 salt
->salt_len
= salt_len
;
17963 salt
->salt_iter
= iter
- 1;
17969 memset (tmp_buf
, 0, sizeof (tmp_buf
));
17971 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
17973 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
17975 memcpy (digest
, tmp_buf
, 16);
17977 // add some stuff to normal salt to make sorted happy
17979 salt
->salt_buf
[0] = pbkdf2_md5
->salt_buf
[0];
17980 salt
->salt_buf
[1] = pbkdf2_md5
->salt_buf
[1];
17981 salt
->salt_buf
[2] = pbkdf2_md5
->salt_buf
[2];
17982 salt
->salt_buf
[3] = pbkdf2_md5
->salt_buf
[3];
17983 salt
->salt_buf
[4] = salt
->salt_iter
;
17985 return (PARSER_OK
);
17988 int pbkdf2_sha1_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
17990 if ((input_len
< DISPLAY_LEN_MIN_12000
) || (input_len
> DISPLAY_LEN_MAX_12000
)) return (PARSER_GLOBAL_LENGTH
);
17992 if (memcmp (SIGNATURE_PBKDF2_SHA1
, input_buf
, 5)) return (PARSER_SIGNATURE_UNMATCHED
);
17994 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
17996 salt_t
*salt
= hash_buf
->salt
;
17998 pbkdf2_sha1_t
*pbkdf2_sha1
= (pbkdf2_sha1_t
*) hash_buf
->esalt
;
18006 char *iter_pos
= input_buf
+ 5;
18008 uint32_t iter
= atoi (iter_pos
);
18010 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18011 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18013 // first is *raw* salt
18015 char *salt_pos
= strchr (iter_pos
, ':');
18017 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18021 char *hash_pos
= strchr (salt_pos
, ':');
18023 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18025 uint32_t salt_len
= hash_pos
- salt_pos
;
18027 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18031 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18033 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18037 char *salt_buf_ptr
= (char *) pbkdf2_sha1
->salt_buf
;
18039 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18041 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18043 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18044 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18046 salt
->salt_len
= salt_len
;
18047 salt
->salt_iter
= iter
- 1;
18053 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18055 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
18057 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18059 memcpy (digest
, tmp_buf
, 16);
18061 digest
[0] = byte_swap_32 (digest
[0]);
18062 digest
[1] = byte_swap_32 (digest
[1]);
18063 digest
[2] = byte_swap_32 (digest
[2]);
18064 digest
[3] = byte_swap_32 (digest
[3]);
18066 // add some stuff to normal salt to make sorted happy
18068 salt
->salt_buf
[0] = pbkdf2_sha1
->salt_buf
[0];
18069 salt
->salt_buf
[1] = pbkdf2_sha1
->salt_buf
[1];
18070 salt
->salt_buf
[2] = pbkdf2_sha1
->salt_buf
[2];
18071 salt
->salt_buf
[3] = pbkdf2_sha1
->salt_buf
[3];
18072 salt
->salt_buf
[4] = salt
->salt_iter
;
18074 return (PARSER_OK
);
18077 int pbkdf2_sha512_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18079 if ((input_len
< DISPLAY_LEN_MIN_12100
) || (input_len
> DISPLAY_LEN_MAX_12100
)) return (PARSER_GLOBAL_LENGTH
);
18081 if (memcmp (SIGNATURE_PBKDF2_SHA512
, input_buf
, 7)) return (PARSER_SIGNATURE_UNMATCHED
);
18083 uint64_t *digest
= (uint64_t *) hash_buf
->digest
;
18085 salt_t
*salt
= hash_buf
->salt
;
18087 pbkdf2_sha512_t
*pbkdf2_sha512
= (pbkdf2_sha512_t
*) hash_buf
->esalt
;
18095 char *iter_pos
= input_buf
+ 7;
18097 uint32_t iter
= atoi (iter_pos
);
18099 if (iter
< 1) return (PARSER_SALT_ITERATION
);
18100 if (iter
> 999999) return (PARSER_SALT_ITERATION
);
18102 // first is *raw* salt
18104 char *salt_pos
= strchr (iter_pos
, ':');
18106 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18110 char *hash_pos
= strchr (salt_pos
, ':');
18112 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18114 uint32_t salt_len
= hash_pos
- salt_pos
;
18116 if (salt_len
> 64) return (PARSER_SALT_LENGTH
);
18120 uint32_t hash_b64_len
= input_len
- (hash_pos
- input_buf
);
18122 if (hash_b64_len
> 88) return (PARSER_HASH_LENGTH
);
18126 char *salt_buf_ptr
= (char *) pbkdf2_sha512
->salt_buf
;
18128 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_pos
, salt_len
);
18130 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18132 salt_buf_ptr
[salt_len
+ 3] = 0x01;
18133 salt_buf_ptr
[salt_len
+ 4] = 0x80;
18135 salt
->salt_len
= salt_len
;
18136 salt
->salt_iter
= iter
- 1;
18142 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18144 int hash_len
= base64_decode (base64_to_int
, hash_pos
, hash_b64_len
, tmp_buf
);
18146 if (hash_len
< 16) return (PARSER_HASH_LENGTH
);
18148 memcpy (digest
, tmp_buf
, 64);
18150 digest
[0] = byte_swap_64 (digest
[0]);
18151 digest
[1] = byte_swap_64 (digest
[1]);
18152 digest
[2] = byte_swap_64 (digest
[2]);
18153 digest
[3] = byte_swap_64 (digest
[3]);
18154 digest
[4] = byte_swap_64 (digest
[4]);
18155 digest
[5] = byte_swap_64 (digest
[5]);
18156 digest
[6] = byte_swap_64 (digest
[6]);
18157 digest
[7] = byte_swap_64 (digest
[7]);
18159 // add some stuff to normal salt to make sorted happy
18161 salt
->salt_buf
[0] = pbkdf2_sha512
->salt_buf
[0];
18162 salt
->salt_buf
[1] = pbkdf2_sha512
->salt_buf
[1];
18163 salt
->salt_buf
[2] = pbkdf2_sha512
->salt_buf
[2];
18164 salt
->salt_buf
[3] = pbkdf2_sha512
->salt_buf
[3];
18165 salt
->salt_buf
[4] = salt
->salt_iter
;
18167 return (PARSER_OK
);
18170 int ecryptfs_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18172 if ((input_len
< DISPLAY_LEN_MIN_12200
) || (input_len
> DISPLAY_LEN_MAX_12200
)) return (PARSER_GLOBAL_LENGTH
);
18174 if (memcmp (SIGNATURE_ECRYPTFS
, input_buf
, 10)) return (PARSER_SIGNATURE_UNMATCHED
);
18176 uint
*digest
= (uint
*) hash_buf
->digest
;
18178 salt_t
*salt
= hash_buf
->salt
;
18184 char *salt_pos
= input_buf
+ 10 + 2 + 2; // skip over "0$" and "1$"
18186 char *hash_pos
= strchr (salt_pos
, '$');
18188 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18190 uint32_t salt_len
= hash_pos
- salt_pos
;
18192 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18196 uint32_t hash_len
= input_len
- 10 - 2 - 2 - salt_len
- 1;
18198 if (hash_len
!= 16) return (PARSER_HASH_LENGTH
);
18202 digest
[ 0] = hex_to_uint (&hash_pos
[0]);
18203 digest
[ 1] = hex_to_uint (&hash_pos
[8]);
18221 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[0]);
18222 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[8]);
18224 salt
->salt_iter
= ROUNDS_ECRYPTFS
;
18225 salt
->salt_len
= 8;
18227 return (PARSER_OK
);
18230 int bsdicrypt_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18232 if ((input_len
< DISPLAY_LEN_MIN_12400
) || (input_len
> DISPLAY_LEN_MAX_12400
)) return (PARSER_GLOBAL_LENGTH
);
18234 if (memcmp (SIGNATURE_BSDICRYPT
, input_buf
, 1)) return (PARSER_SIGNATURE_UNMATCHED
);
18236 unsigned char c19
= itoa64_to_int (input_buf
[19]);
18238 if (c19
& 3) return (PARSER_HASH_VALUE
);
18240 salt_t
*salt
= hash_buf
->salt
;
18242 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18246 salt
->salt_iter
= itoa64_to_int (input_buf
[1])
18247 | itoa64_to_int (input_buf
[2]) << 6
18248 | itoa64_to_int (input_buf
[3]) << 12
18249 | itoa64_to_int (input_buf
[4]) << 18;
18253 salt
->salt_buf
[0] = itoa64_to_int (input_buf
[5])
18254 | itoa64_to_int (input_buf
[6]) << 6
18255 | itoa64_to_int (input_buf
[7]) << 12
18256 | itoa64_to_int (input_buf
[8]) << 18;
18258 salt
->salt_len
= 4;
18262 memset (tmp_buf
, 0, sizeof (tmp_buf
));
18264 base64_decode (itoa64_to_int
, input_buf
+ 9, 11, tmp_buf
);
18266 memcpy (digest
, tmp_buf
, 8);
18270 IP (digest
[0], digest
[1], tt
);
18272 digest
[0] = ROTATE_RIGHT (digest
[0], 31);
18273 digest
[1] = ROTATE_RIGHT (digest
[1], 31);
18277 return (PARSER_OK
);
18280 int rar3hp_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18282 if ((input_len
< DISPLAY_LEN_MIN_12500
) || (input_len
> DISPLAY_LEN_MAX_12500
)) return (PARSER_GLOBAL_LENGTH
);
18284 if (memcmp (SIGNATURE_RAR3
, input_buf
, 6)) return (PARSER_SIGNATURE_UNMATCHED
);
18286 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18288 salt_t
*salt
= hash_buf
->salt
;
18294 char *type_pos
= input_buf
+ 6 + 1;
18296 char *salt_pos
= strchr (type_pos
, '*');
18298 if (salt_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18300 uint32_t type_len
= salt_pos
- type_pos
;
18302 if (type_len
!= 1) return (PARSER_SALT_LENGTH
);
18306 char *crypted_pos
= strchr (salt_pos
, '*');
18308 if (crypted_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18310 uint32_t salt_len
= crypted_pos
- salt_pos
;
18312 if (salt_len
!= 16) return (PARSER_SALT_LENGTH
);
18316 uint32_t crypted_len
= input_len
- 6 - 1 - type_len
- 1 - salt_len
- 1;
18318 if (crypted_len
!= 32) return (PARSER_SALT_LENGTH
);
18324 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[0]);
18325 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[8]);
18327 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18328 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18330 salt
->salt_buf
[2] = hex_to_uint (&crypted_pos
[ 0]);
18331 salt
->salt_buf
[3] = hex_to_uint (&crypted_pos
[ 8]);
18332 salt
->salt_buf
[4] = hex_to_uint (&crypted_pos
[16]);
18333 salt
->salt_buf
[5] = hex_to_uint (&crypted_pos
[24]);
18335 salt
->salt_len
= 24;
18336 salt
->salt_iter
= ROUNDS_RAR3
;
18338 // there's no hash for rar3. the data which is in crypted_pos is some encrypted data and
18339 // if it matches the value \xc4\x3d\x7b\x00\x40\x07\x00 after decrypt we know that we successfully cracked it.
18341 digest
[0] = 0xc43d7b00;
18342 digest
[1] = 0x40070000;
18346 return (PARSER_OK
);
18349 int cf10_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18351 if ((input_len
< DISPLAY_LEN_MIN_12600
) || (input_len
> DISPLAY_LEN_MAX_12600
)) return (PARSER_GLOBAL_LENGTH
);
18353 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18355 salt_t
*salt
= hash_buf
->salt
;
18357 digest
[0] = hex_to_uint (&input_buf
[ 0]);
18358 digest
[1] = hex_to_uint (&input_buf
[ 8]);
18359 digest
[2] = hex_to_uint (&input_buf
[16]);
18360 digest
[3] = hex_to_uint (&input_buf
[24]);
18361 digest
[4] = hex_to_uint (&input_buf
[32]);
18362 digest
[5] = hex_to_uint (&input_buf
[40]);
18363 digest
[6] = hex_to_uint (&input_buf
[48]);
18364 digest
[7] = hex_to_uint (&input_buf
[56]);
18366 if (input_buf
[64] != data
.separator
) return (PARSER_SEPARATOR_UNMATCHED
);
18368 uint salt_len
= input_len
- 64 - 1;
18370 char *salt_buf
= input_buf
+ 64 + 1;
18372 char *salt_buf_ptr
= (char *) salt
->salt_buf
;
18374 salt_len
= parse_and_store_salt (salt_buf_ptr
, salt_buf
, salt_len
);
18376 if (salt_len
== UINT_MAX
) return (PARSER_SALT_LENGTH
);
18378 salt
->salt_len
= salt_len
;
18381 * we can precompute the first sha256 transform
18386 w
[ 0] = byte_swap_32 (salt
->salt_buf
[ 0]);
18387 w
[ 1] = byte_swap_32 (salt
->salt_buf
[ 1]);
18388 w
[ 2] = byte_swap_32 (salt
->salt_buf
[ 2]);
18389 w
[ 3] = byte_swap_32 (salt
->salt_buf
[ 3]);
18390 w
[ 4] = byte_swap_32 (salt
->salt_buf
[ 4]);
18391 w
[ 5] = byte_swap_32 (salt
->salt_buf
[ 5]);
18392 w
[ 6] = byte_swap_32 (salt
->salt_buf
[ 6]);
18393 w
[ 7] = byte_swap_32 (salt
->salt_buf
[ 7]);
18394 w
[ 8] = byte_swap_32 (salt
->salt_buf
[ 8]);
18395 w
[ 9] = byte_swap_32 (salt
->salt_buf
[ 9]);
18396 w
[10] = byte_swap_32 (salt
->salt_buf
[10]);
18397 w
[11] = byte_swap_32 (salt
->salt_buf
[11]);
18398 w
[12] = byte_swap_32 (salt
->salt_buf
[12]);
18399 w
[13] = byte_swap_32 (salt
->salt_buf
[13]);
18400 w
[14] = byte_swap_32 (salt
->salt_buf
[14]);
18401 w
[15] = byte_swap_32 (salt
->salt_buf
[15]);
18405 pc256
[0] = SHA256M_A
;
18406 pc256
[1] = SHA256M_B
;
18407 pc256
[2] = SHA256M_C
;
18408 pc256
[3] = SHA256M_D
;
18409 pc256
[4] = SHA256M_E
;
18410 pc256
[5] = SHA256M_F
;
18411 pc256
[6] = SHA256M_G
;
18412 pc256
[7] = SHA256M_H
;
18414 sha256_64 (w
, pc256
);
18416 salt
->salt_buf_pc
[0] = pc256
[0];
18417 salt
->salt_buf_pc
[1] = pc256
[1];
18418 salt
->salt_buf_pc
[2] = pc256
[2];
18419 salt
->salt_buf_pc
[3] = pc256
[3];
18420 salt
->salt_buf_pc
[4] = pc256
[4];
18421 salt
->salt_buf_pc
[5] = pc256
[5];
18422 salt
->salt_buf_pc
[6] = pc256
[6];
18423 salt
->salt_buf_pc
[7] = pc256
[7];
18425 digest
[0] -= pc256
[0];
18426 digest
[1] -= pc256
[1];
18427 digest
[2] -= pc256
[2];
18428 digest
[3] -= pc256
[3];
18429 digest
[4] -= pc256
[4];
18430 digest
[5] -= pc256
[5];
18431 digest
[6] -= pc256
[6];
18432 digest
[7] -= pc256
[7];
18434 return (PARSER_OK
);
18437 int mywallet_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18439 if ((input_len
< DISPLAY_LEN_MIN_12700
) || (input_len
> DISPLAY_LEN_MAX_12700
)) return (PARSER_GLOBAL_LENGTH
);
18441 if (memcmp (SIGNATURE_MYWALLET
, input_buf
, 12)) return (PARSER_SIGNATURE_UNMATCHED
);
18443 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18445 salt_t
*salt
= hash_buf
->salt
;
18451 char *data_len_pos
= input_buf
+ 1 + 10 + 1;
18453 char *data_buf_pos
= strchr (data_len_pos
, '$');
18455 if (data_buf_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18457 uint32_t data_len_len
= data_buf_pos
- data_len_pos
;
18459 if (data_len_len
< 1) return (PARSER_SALT_LENGTH
);
18460 if (data_len_len
> 5) return (PARSER_SALT_LENGTH
);
18464 uint32_t data_buf_len
= input_len
- 1 - 10 - 1 - data_len_len
- 1;
18466 if (data_buf_len
< 64) return (PARSER_HASH_LENGTH
);
18468 if (data_buf_len
% 16) return (PARSER_HASH_LENGTH
);
18470 uint32_t data_len
= atoi (data_len_pos
);
18472 if ((data_len
* 2) != data_buf_len
) return (PARSER_HASH_LENGTH
);
18478 char *salt_pos
= data_buf_pos
;
18480 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
18481 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
18482 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]);
18483 salt
->salt_buf
[3] = hex_to_uint (&salt_pos
[24]);
18485 // this is actually the CT, which is also the hash later (if matched)
18487 salt
->salt_buf
[4] = hex_to_uint (&salt_pos
[32]);
18488 salt
->salt_buf
[5] = hex_to_uint (&salt_pos
[40]);
18489 salt
->salt_buf
[6] = hex_to_uint (&salt_pos
[48]);
18490 salt
->salt_buf
[7] = hex_to_uint (&salt_pos
[56]);
18492 salt
->salt_len
= 32; // note we need to fix this to 16 in kernel
18494 salt
->salt_iter
= 10 - 1;
18500 digest
[0] = salt
->salt_buf
[4];
18501 digest
[1] = salt
->salt_buf
[5];
18502 digest
[2] = salt
->salt_buf
[6];
18503 digest
[3] = salt
->salt_buf
[7];
18505 return (PARSER_OK
);
18508 int ms_drsr_parse_hash (char *input_buf
, uint input_len
, hash_t
*hash_buf
)
18510 if ((input_len
< DISPLAY_LEN_MIN_12800
) || (input_len
> DISPLAY_LEN_MAX_12800
)) return (PARSER_GLOBAL_LENGTH
);
18512 if (memcmp (SIGNATURE_MS_DRSR
, input_buf
, 11)) return (PARSER_SIGNATURE_UNMATCHED
);
18514 uint32_t *digest
= (uint32_t *) hash_buf
->digest
;
18516 salt_t
*salt
= hash_buf
->salt
;
18522 char *salt_pos
= input_buf
+ 11 + 1;
18524 char *iter_pos
= strchr (salt_pos
, ',');
18526 if (iter_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18528 uint32_t salt_len
= iter_pos
- salt_pos
;
18530 if (salt_len
!= 20) return (PARSER_SALT_LENGTH
);
18534 char *hash_pos
= strchr (iter_pos
, ',');
18536 if (hash_pos
== NULL
) return (PARSER_SEPARATOR_UNMATCHED
);
18538 uint32_t iter_len
= hash_pos
- iter_pos
;
18540 if (iter_len
> 5) return (PARSER_SALT_LENGTH
);
18544 uint32_t hash_len
= input_len
- 11 - 1 - salt_len
- 1 - iter_len
- 1;
18546 if (hash_len
!= 64) return (PARSER_HASH_LENGTH
);
18552 salt
->salt_buf
[0] = hex_to_uint (&salt_pos
[ 0]);
18553 salt
->salt_buf
[1] = hex_to_uint (&salt_pos
[ 8]);
18554 salt
->salt_buf
[2] = hex_to_uint (&salt_pos
[16]) & 0xffff0000;
18555 salt
->salt_buf
[3] = 0x00018000;
18557 salt
->salt_buf
[0] = byte_swap_32 (salt
->salt_buf
[0]);
18558 salt
->salt_buf
[1] = byte_swap_32 (salt
->salt_buf
[1]);
18559 salt
->salt_buf
[2] = byte_swap_32 (salt
->salt_buf
[2]);
18560 salt
->salt_buf
[3] = byte_swap_32 (salt
->salt_buf
[3]);
18562 salt
->salt_len
= salt_len
/ 2;
18564 salt
->salt_iter
= atoi (iter_pos
) - 1;
18570 digest
[0] = hex_to_uint (&hash_pos
[ 0]);
18571 digest
[1] = hex_to_uint (&hash_pos
[ 8]);
18572 digest
[2] = hex_to_uint (&hash_pos
[16]);
18573 digest
[3] = hex_to_uint (&hash_pos
[24]);
18574 digest
[4] = hex_to_uint (&hash_pos
[32]);
18575 digest
[5] = hex_to_uint (&hash_pos
[40]);
18576 digest
[6] = hex_to_uint (&hash_pos
[48]);
18577 digest
[7] = hex_to_uint (&hash_pos
[56]);
18579 return (PARSER_OK
);
18583 * parallel running threads
18588 BOOL WINAPI
sigHandler_default (DWORD sig
)
18592 case CTRL_CLOSE_EVENT
:
18595 * special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
18596 * if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
18597 * function otherwise it is to late (e.g. after returning from this function)
18602 SetConsoleCtrlHandler (NULL
, TRUE
);
18609 case CTRL_LOGOFF_EVENT
:
18610 case CTRL_SHUTDOWN_EVENT
:
18614 SetConsoleCtrlHandler (NULL
, TRUE
);
18622 BOOL WINAPI
sigHandler_benchmark (DWORD sig
)
18626 case CTRL_CLOSE_EVENT
:
18630 SetConsoleCtrlHandler (NULL
, TRUE
);
18637 case CTRL_LOGOFF_EVENT
:
18638 case CTRL_SHUTDOWN_EVENT
:
18642 SetConsoleCtrlHandler (NULL
, TRUE
);
18650 void hc_signal (BOOL
WINAPI (callback
) (DWORD
))
18652 if (callback
== NULL
)
18654 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, FALSE
);
18658 SetConsoleCtrlHandler ((PHANDLER_ROUTINE
) callback
, TRUE
);
18664 void sigHandler_default (int sig
)
18668 signal (sig
, NULL
);
18671 void sigHandler_benchmark (int sig
)
18675 signal (sig
, NULL
);
18678 void hc_signal (void (callback
) (int))
18680 if (callback
== NULL
) callback
= SIG_DFL
;
18682 signal (SIGINT
, callback
);
18683 signal (SIGTERM
, callback
);
18684 signal (SIGABRT
, callback
);
18689 void status_display ();
18691 void *thread_keypress (void *p
)
18693 int benchmark
= *((int *) p
);
18695 uint quiet
= data
.quiet
;
18699 while ((data
.devices_status
!= STATUS_EXHAUSTED
) && (data
.devices_status
!= STATUS_CRACKED
) && (data
.devices_status
!= STATUS_ABORTED
) && (data
.devices_status
!= STATUS_QUIT
))
18701 int ch
= tty_getchar();
18703 if (ch
== -1) break;
18705 if (ch
== 0) continue;
18711 hc_thread_mutex_lock (mux_display
);
18726 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18727 if (quiet
== 0) fflush (stdout
);
18739 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18740 if (quiet
== 0) fflush (stdout
);
18752 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18753 if (quiet
== 0) fflush (stdout
);
18765 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18766 if (quiet
== 0) fflush (stdout
);
18774 if (benchmark
== 1) break;
18776 stop_at_checkpoint ();
18780 if (quiet
== 0) fprintf (stdout
, "%s", PROMPT
);
18781 if (quiet
== 0) fflush (stdout
);
18789 if (benchmark
== 1)
18801 hc_thread_mutex_unlock (mux_display
);
18813 bool class_num (char c
)
18815 return ((c
>= '0') && (c
<= '9'));
18818 bool class_lower (char c
)
18820 return ((c
>= 'a') && (c
<= 'z'));
18823 bool class_upper (char c
)
18825 return ((c
>= 'A') && (c
<= 'Z'));
18828 bool class_alpha (char c
)
18830 return (class_lower (c
) || class_upper (c
));
18833 char conv_ctoi (char c
)
18839 else if (class_upper (c
))
18841 return c
- 'A' + (char) 10;
18844 return (char) (-1);
18847 char conv_itoc (char c
)
18855 return c
+ 'A' - (char) 10;
18858 return (char) (-1);
18865 #define INCR_POS if (++rule_pos == rule_len) return (-1)
18866 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
18867 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
18868 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
18869 #define MAX_GPU_RULES 14
18870 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
18871 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
18872 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
18874 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
18875 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
18876 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
18877 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
18879 int cpu_rule_to_gpu_rule (char rule_buf
[BUFSIZ
], uint rule_len
, gpu_rule_t
*rule
)
18884 for (rule_pos
= 0, rule_cnt
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_GPU_RULES
; rule_pos
++, rule_cnt
++)
18886 switch (rule_buf
[rule_pos
])
18892 case RULE_OP_MANGLE_NOOP
:
18893 SET_NAME (rule
, rule_buf
[rule_pos
]);
18896 case RULE_OP_MANGLE_LREST
:
18897 SET_NAME (rule
, rule_buf
[rule_pos
]);
18900 case RULE_OP_MANGLE_UREST
:
18901 SET_NAME (rule
, rule_buf
[rule_pos
]);
18904 case RULE_OP_MANGLE_LREST_UFIRST
:
18905 SET_NAME (rule
, rule_buf
[rule_pos
]);
18908 case RULE_OP_MANGLE_UREST_LFIRST
:
18909 SET_NAME (rule
, rule_buf
[rule_pos
]);
18912 case RULE_OP_MANGLE_TREST
:
18913 SET_NAME (rule
, rule_buf
[rule_pos
]);
18916 case RULE_OP_MANGLE_TOGGLE_AT
:
18917 SET_NAME (rule
, rule_buf
[rule_pos
]);
18918 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18921 case RULE_OP_MANGLE_REVERSE
:
18922 SET_NAME (rule
, rule_buf
[rule_pos
]);
18925 case RULE_OP_MANGLE_DUPEWORD
:
18926 SET_NAME (rule
, rule_buf
[rule_pos
]);
18929 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
18930 SET_NAME (rule
, rule_buf
[rule_pos
]);
18931 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18934 case RULE_OP_MANGLE_REFLECT
:
18935 SET_NAME (rule
, rule_buf
[rule_pos
]);
18938 case RULE_OP_MANGLE_ROTATE_LEFT
:
18939 SET_NAME (rule
, rule_buf
[rule_pos
]);
18942 case RULE_OP_MANGLE_ROTATE_RIGHT
:
18943 SET_NAME (rule
, rule_buf
[rule_pos
]);
18946 case RULE_OP_MANGLE_APPEND
:
18947 SET_NAME (rule
, rule_buf
[rule_pos
]);
18948 SET_P0 (rule
, rule_buf
[rule_pos
]);
18951 case RULE_OP_MANGLE_PREPEND
:
18952 SET_NAME (rule
, rule_buf
[rule_pos
]);
18953 SET_P0 (rule
, rule_buf
[rule_pos
]);
18956 case RULE_OP_MANGLE_DELETE_FIRST
:
18957 SET_NAME (rule
, rule_buf
[rule_pos
]);
18960 case RULE_OP_MANGLE_DELETE_LAST
:
18961 SET_NAME (rule
, rule_buf
[rule_pos
]);
18964 case RULE_OP_MANGLE_DELETE_AT
:
18965 SET_NAME (rule
, rule_buf
[rule_pos
]);
18966 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18969 case RULE_OP_MANGLE_EXTRACT
:
18970 SET_NAME (rule
, rule_buf
[rule_pos
]);
18971 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18972 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
18975 case RULE_OP_MANGLE_OMIT
:
18976 SET_NAME (rule
, rule_buf
[rule_pos
]);
18977 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18978 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
18981 case RULE_OP_MANGLE_INSERT
:
18982 SET_NAME (rule
, rule_buf
[rule_pos
]);
18983 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18984 SET_P1 (rule
, rule_buf
[rule_pos
]);
18987 case RULE_OP_MANGLE_OVERSTRIKE
:
18988 SET_NAME (rule
, rule_buf
[rule_pos
]);
18989 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18990 SET_P1 (rule
, rule_buf
[rule_pos
]);
18993 case RULE_OP_MANGLE_TRUNCATE_AT
:
18994 SET_NAME (rule
, rule_buf
[rule_pos
]);
18995 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
18998 case RULE_OP_MANGLE_REPLACE
:
18999 SET_NAME (rule
, rule_buf
[rule_pos
]);
19000 SET_P0 (rule
, rule_buf
[rule_pos
]);
19001 SET_P1 (rule
, rule_buf
[rule_pos
]);
19004 case RULE_OP_MANGLE_PURGECHAR
:
19008 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19012 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19013 SET_NAME (rule
, rule_buf
[rule_pos
]);
19014 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19017 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19018 SET_NAME (rule
, rule_buf
[rule_pos
]);
19019 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19022 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19023 SET_NAME (rule
, rule_buf
[rule_pos
]);
19026 case RULE_OP_MANGLE_SWITCH_FIRST
:
19027 SET_NAME (rule
, rule_buf
[rule_pos
]);
19030 case RULE_OP_MANGLE_SWITCH_LAST
:
19031 SET_NAME (rule
, rule_buf
[rule_pos
]);
19034 case RULE_OP_MANGLE_SWITCH_AT
:
19035 SET_NAME (rule
, rule_buf
[rule_pos
]);
19036 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19037 SET_P1_CONV (rule
, rule_buf
[rule_pos
]);
19040 case RULE_OP_MANGLE_CHR_SHIFTL
:
19041 SET_NAME (rule
, rule_buf
[rule_pos
]);
19042 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19045 case RULE_OP_MANGLE_CHR_SHIFTR
:
19046 SET_NAME (rule
, rule_buf
[rule_pos
]);
19047 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19050 case RULE_OP_MANGLE_CHR_INCR
:
19051 SET_NAME (rule
, rule_buf
[rule_pos
]);
19052 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19055 case RULE_OP_MANGLE_CHR_DECR
:
19056 SET_NAME (rule
, rule_buf
[rule_pos
]);
19057 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19060 case RULE_OP_MANGLE_REPLACE_NP1
:
19061 SET_NAME (rule
, rule_buf
[rule_pos
]);
19062 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19065 case RULE_OP_MANGLE_REPLACE_NM1
:
19066 SET_NAME (rule
, rule_buf
[rule_pos
]);
19067 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19070 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19071 SET_NAME (rule
, rule_buf
[rule_pos
]);
19072 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19075 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19076 SET_NAME (rule
, rule_buf
[rule_pos
]);
19077 SET_P0_CONV (rule
, rule_buf
[rule_pos
]);
19080 case RULE_OP_MANGLE_TITLE
:
19081 SET_NAME (rule
, rule_buf
[rule_pos
]);
19090 if (rule_pos
< rule_len
) return (-1);
19095 int gpu_rule_to_cpu_rule (char rule_buf
[BUFSIZ
], gpu_rule_t
*rule
)
19099 uint rule_len
= BUFSIZ
- 1; // maximum possible len
19103 for (rule_cnt
= 0, rule_pos
= 0; rule_pos
< rule_len
&& rule_cnt
< MAX_GPU_RULES
; rule_pos
++, rule_cnt
++)
19107 if (rule_cnt
> 0) rule_buf
[rule_pos
++] = ' ';
19111 case RULE_OP_MANGLE_NOOP
:
19112 rule_buf
[rule_pos
] = rule_cmd
;
19115 case RULE_OP_MANGLE_LREST
:
19116 rule_buf
[rule_pos
] = rule_cmd
;
19119 case RULE_OP_MANGLE_UREST
:
19120 rule_buf
[rule_pos
] = rule_cmd
;
19123 case RULE_OP_MANGLE_LREST_UFIRST
:
19124 rule_buf
[rule_pos
] = rule_cmd
;
19127 case RULE_OP_MANGLE_UREST_LFIRST
:
19128 rule_buf
[rule_pos
] = rule_cmd
;
19131 case RULE_OP_MANGLE_TREST
:
19132 rule_buf
[rule_pos
] = rule_cmd
;
19135 case RULE_OP_MANGLE_TOGGLE_AT
:
19136 rule_buf
[rule_pos
] = rule_cmd
;
19137 GET_P0_CONV (rule
);
19140 case RULE_OP_MANGLE_REVERSE
:
19141 rule_buf
[rule_pos
] = rule_cmd
;
19144 case RULE_OP_MANGLE_DUPEWORD
:
19145 rule_buf
[rule_pos
] = rule_cmd
;
19148 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19149 rule_buf
[rule_pos
] = rule_cmd
;
19150 GET_P0_CONV (rule
);
19153 case RULE_OP_MANGLE_REFLECT
:
19154 rule_buf
[rule_pos
] = rule_cmd
;
19157 case RULE_OP_MANGLE_ROTATE_LEFT
:
19158 rule_buf
[rule_pos
] = rule_cmd
;
19161 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19162 rule_buf
[rule_pos
] = rule_cmd
;
19165 case RULE_OP_MANGLE_APPEND
:
19166 rule_buf
[rule_pos
] = rule_cmd
;
19170 case RULE_OP_MANGLE_PREPEND
:
19171 rule_buf
[rule_pos
] = rule_cmd
;
19175 case RULE_OP_MANGLE_DELETE_FIRST
:
19176 rule_buf
[rule_pos
] = rule_cmd
;
19179 case RULE_OP_MANGLE_DELETE_LAST
:
19180 rule_buf
[rule_pos
] = rule_cmd
;
19183 case RULE_OP_MANGLE_DELETE_AT
:
19184 rule_buf
[rule_pos
] = rule_cmd
;
19185 GET_P0_CONV (rule
);
19188 case RULE_OP_MANGLE_EXTRACT
:
19189 rule_buf
[rule_pos
] = rule_cmd
;
19190 GET_P0_CONV (rule
);
19191 GET_P1_CONV (rule
);
19194 case RULE_OP_MANGLE_OMIT
:
19195 rule_buf
[rule_pos
] = rule_cmd
;
19196 GET_P0_CONV (rule
);
19197 GET_P1_CONV (rule
);
19200 case RULE_OP_MANGLE_INSERT
:
19201 rule_buf
[rule_pos
] = rule_cmd
;
19202 GET_P0_CONV (rule
);
19206 case RULE_OP_MANGLE_OVERSTRIKE
:
19207 rule_buf
[rule_pos
] = rule_cmd
;
19208 GET_P0_CONV (rule
);
19212 case RULE_OP_MANGLE_TRUNCATE_AT
:
19213 rule_buf
[rule_pos
] = rule_cmd
;
19214 GET_P0_CONV (rule
);
19217 case RULE_OP_MANGLE_REPLACE
:
19218 rule_buf
[rule_pos
] = rule_cmd
;
19223 case RULE_OP_MANGLE_PURGECHAR
:
19227 case RULE_OP_MANGLE_TOGGLECASE_REC
:
19231 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
19232 rule_buf
[rule_pos
] = rule_cmd
;
19233 GET_P0_CONV (rule
);
19236 case RULE_OP_MANGLE_DUPECHAR_LAST
:
19237 rule_buf
[rule_pos
] = rule_cmd
;
19238 GET_P0_CONV (rule
);
19241 case RULE_OP_MANGLE_DUPECHAR_ALL
:
19242 rule_buf
[rule_pos
] = rule_cmd
;
19245 case RULE_OP_MANGLE_SWITCH_FIRST
:
19246 rule_buf
[rule_pos
] = rule_cmd
;
19249 case RULE_OP_MANGLE_SWITCH_LAST
:
19250 rule_buf
[rule_pos
] = rule_cmd
;
19253 case RULE_OP_MANGLE_SWITCH_AT
:
19254 rule_buf
[rule_pos
] = rule_cmd
;
19255 GET_P0_CONV (rule
);
19256 GET_P1_CONV (rule
);
19259 case RULE_OP_MANGLE_CHR_SHIFTL
:
19260 rule_buf
[rule_pos
] = rule_cmd
;
19261 GET_P0_CONV (rule
);
19264 case RULE_OP_MANGLE_CHR_SHIFTR
:
19265 rule_buf
[rule_pos
] = rule_cmd
;
19266 GET_P0_CONV (rule
);
19269 case RULE_OP_MANGLE_CHR_INCR
:
19270 rule_buf
[rule_pos
] = rule_cmd
;
19271 GET_P0_CONV (rule
);
19274 case RULE_OP_MANGLE_CHR_DECR
:
19275 rule_buf
[rule_pos
] = rule_cmd
;
19276 GET_P0_CONV (rule
);
19279 case RULE_OP_MANGLE_REPLACE_NP1
:
19280 rule_buf
[rule_pos
] = rule_cmd
;
19281 GET_P0_CONV (rule
);
19284 case RULE_OP_MANGLE_REPLACE_NM1
:
19285 rule_buf
[rule_pos
] = rule_cmd
;
19286 GET_P0_CONV (rule
);
19289 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
19290 rule_buf
[rule_pos
] = rule_cmd
;
19291 GET_P0_CONV (rule
);
19294 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
19295 rule_buf
[rule_pos
] = rule_cmd
;
19296 GET_P0_CONV (rule
);
19299 case RULE_OP_MANGLE_TITLE
:
19300 rule_buf
[rule_pos
] = rule_cmd
;
19304 return rule_pos
- 1;
19322 * CPU rules : this is from hashcat sources, cpu based rules
19325 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
19326 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
19328 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
19329 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
19330 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
19332 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
19333 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
19334 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
19336 int mangle_lrest (char arr
[BLOCK_SIZE
], int arr_len
)
19340 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_LOWER_AT (arr
, pos
);
19345 int mangle_urest (char arr
[BLOCK_SIZE
], int arr_len
)
19349 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_UPPER_AT (arr
, pos
);
19354 int mangle_trest (char arr
[BLOCK_SIZE
], int arr_len
)
19358 for (pos
= 0; pos
< arr_len
; pos
++) MANGLE_TOGGLE_AT (arr
, pos
);
19363 int mangle_reverse (char arr
[BLOCK_SIZE
], int arr_len
)
19368 for (l
= 0; l
< arr_len
; l
++)
19370 r
= arr_len
- 1 - l
;
19374 MANGLE_SWITCH (arr
, l
, r
);
19380 int mangle_double (char arr
[BLOCK_SIZE
], int arr_len
)
19382 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19384 memcpy (&arr
[arr_len
], arr
, (size_t) arr_len
);
19386 return (arr_len
* 2);
19389 int mangle_double_times (char arr
[BLOCK_SIZE
], int arr_len
, int times
)
19391 if (((arr_len
* times
) + arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19393 int orig_len
= arr_len
;
19397 for (i
= 0; i
< times
; i
++)
19399 memcpy (&arr
[arr_len
], arr
, orig_len
);
19401 arr_len
+= orig_len
;
19407 int mangle_reflect (char arr
[BLOCK_SIZE
], int arr_len
)
19409 if ((arr_len
* 2) >= BLOCK_SIZE
) return (arr_len
);
19411 mangle_double (arr
, arr_len
);
19413 mangle_reverse (arr
+ arr_len
, arr_len
);
19415 return (arr_len
* 2);
19418 int mangle_rotate_left (char arr
[BLOCK_SIZE
], int arr_len
)
19423 for (l
= 0, r
= arr_len
- 1; r
> 0; r
--)
19425 MANGLE_SWITCH (arr
, l
, r
);
19431 int mangle_rotate_right (char arr
[BLOCK_SIZE
], int arr_len
)
19436 for (l
= 0, r
= arr_len
- 1; l
< r
; l
++)
19438 MANGLE_SWITCH (arr
, l
, r
);
19444 int mangle_append (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19446 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19450 return (arr_len
+ 1);
19453 int mangle_prepend (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19455 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19459 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19461 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19466 return (arr_len
+ 1);
19469 int mangle_delete_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19471 if (upos
>= arr_len
) return (arr_len
);
19475 for (arr_pos
= upos
; arr_pos
< arr_len
- 1; arr_pos
++)
19477 arr
[arr_pos
] = arr
[arr_pos
+ 1];
19480 return (arr_len
- 1);
19483 int mangle_extract (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19485 if (upos
>= arr_len
) return (arr_len
);
19487 if ((upos
+ ulen
) > arr_len
) return (arr_len
);
19491 for (arr_pos
= 0; arr_pos
< ulen
; arr_pos
++)
19493 arr
[arr_pos
] = arr
[upos
+ arr_pos
];
19499 int mangle_omit (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19501 if (upos
>= arr_len
) return (arr_len
);
19503 if ((upos
+ ulen
) >= arr_len
) return (arr_len
);
19507 for (arr_pos
= upos
; arr_pos
< arr_len
- ulen
; arr_pos
++)
19509 arr
[arr_pos
] = arr
[arr_pos
+ ulen
];
19512 return (arr_len
- ulen
);
19515 int mangle_insert (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19517 if (upos
>= arr_len
) return (arr_len
);
19519 if ((arr_len
+ 1) >= BLOCK_SIZE
) return (arr_len
);
19523 for (arr_pos
= arr_len
- 1; arr_pos
> upos
- 1; arr_pos
--)
19525 arr
[arr_pos
+ 1] = arr
[arr_pos
];
19530 return (arr_len
+ 1);
19533 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
)
19535 if ((arr_len
+ arr2_cpy
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
19537 if (arr_pos
> arr_len
) return (RULE_RC_REJECT_ERROR
);
19539 if (arr2_pos
> arr2_len
) return (RULE_RC_REJECT_ERROR
);
19541 if ((arr2_pos
+ arr2_cpy
) > arr2_len
) return (RULE_RC_REJECT_ERROR
);
19543 if (arr2_cpy
< 1) return (RULE_RC_SYNTAX_ERROR
);
19545 memcpy (arr2
, arr2
+ arr2_pos
, arr2_len
- arr2_pos
);
19547 memcpy (arr2
+ arr2_cpy
, arr
+ arr_pos
, arr_len
- arr_pos
);
19549 memcpy (arr
+ arr_pos
, arr2
, arr_len
- arr_pos
+ arr2_cpy
);
19551 return (arr_len
+ arr2_cpy
);
19554 int mangle_overstrike (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, char c
)
19556 if (upos
>= arr_len
) return (arr_len
);
19563 int mangle_truncate_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19565 if (upos
>= arr_len
) return (arr_len
);
19567 memset (arr
+ upos
, 0, arr_len
- upos
);
19572 int mangle_replace (char arr
[BLOCK_SIZE
], int arr_len
, char oldc
, char newc
)
19576 for (arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19578 if (arr
[arr_pos
] != oldc
) continue;
19580 arr
[arr_pos
] = newc
;
19586 int mangle_purgechar (char arr
[BLOCK_SIZE
], int arr_len
, char c
)
19592 for (ret_len
= 0, arr_pos
= 0; arr_pos
< arr_len
; arr_pos
++)
19594 if (arr
[arr_pos
] == c
) continue;
19596 arr
[ret_len
] = arr
[arr_pos
];
19604 int mangle_dupeblock_prepend (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19606 if (ulen
> arr_len
) return (arr_len
);
19608 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19612 memcpy (cs
, arr
, ulen
);
19616 for (i
= 0; i
< ulen
; i
++)
19620 arr_len
= mangle_insert (arr
, arr_len
, i
, c
);
19626 int mangle_dupeblock_append (char arr
[BLOCK_SIZE
], int arr_len
, int ulen
)
19628 if (ulen
> arr_len
) return (arr_len
);
19630 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19632 int upos
= arr_len
- ulen
;
19636 for (i
= 0; i
< ulen
; i
++)
19638 char c
= arr
[upos
+ i
];
19640 arr_len
= mangle_append (arr
, arr_len
, c
);
19646 int mangle_dupechar_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int ulen
)
19648 if ( arr_len
== 0) return (arr_len
);
19649 if ((arr_len
+ ulen
) >= BLOCK_SIZE
) return (arr_len
);
19651 char c
= arr
[upos
];
19655 for (i
= 0; i
< ulen
; i
++)
19657 arr_len
= mangle_insert (arr
, arr_len
, upos
, c
);
19663 int mangle_dupechar (char arr
[BLOCK_SIZE
], int arr_len
)
19665 if ( arr_len
== 0) return (arr_len
);
19666 if ((arr_len
+ arr_len
) >= BLOCK_SIZE
) return (arr_len
);
19670 for (arr_pos
= arr_len
- 1; arr_pos
> -1; arr_pos
--)
19672 int new_pos
= arr_pos
* 2;
19674 arr
[new_pos
] = arr
[arr_pos
];
19676 arr
[new_pos
+ 1] = arr
[arr_pos
];
19679 return (arr_len
* 2);
19682 int mangle_switch_at_check (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
19684 if (upos
>= arr_len
) return (arr_len
);
19685 if (upos2
>= arr_len
) return (arr_len
);
19687 MANGLE_SWITCH (arr
, upos
, upos2
);
19692 int mangle_switch_at (char arr
[BLOCK_SIZE
], int arr_len
, int upos
, int upos2
)
19694 MANGLE_SWITCH (arr
, upos
, upos2
);
19699 int mangle_chr_shiftl (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19701 if (upos
>= arr_len
) return (arr_len
);
19708 int mangle_chr_shiftr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19710 if (upos
>= arr_len
) return (arr_len
);
19717 int mangle_chr_incr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19719 if (upos
>= arr_len
) return (arr_len
);
19726 int mangle_chr_decr (uint8_t arr
[BLOCK_SIZE
], int arr_len
, int upos
)
19728 if (upos
>= arr_len
) return (arr_len
);
19735 int mangle_title (char arr
[BLOCK_SIZE
], int arr_len
)
19737 int upper_next
= 1;
19741 for (pos
= 0; pos
< arr_len
; pos
++)
19743 if (arr
[pos
] == ' ')
19754 MANGLE_UPPER_AT (arr
, pos
);
19758 MANGLE_LOWER_AT (arr
, pos
);
19765 int generate_random_rule (char rule_buf
[RP_RULE_BUFSIZ
], uint32_t rp_gen_func_min
, uint32_t rp_gen_func_max
)
19767 uint32_t rp_gen_num
= get_random_num (rp_gen_func_min
, rp_gen_func_max
);
19771 uint32_t rule_pos
= 0;
19773 for (j
= 0; j
< rp_gen_num
; j
++)
19780 switch ((char) get_random_num (0, 9))
19783 r
= get_random_num (0, sizeof (grp_op_nop
));
19784 rule_buf
[rule_pos
++] = grp_op_nop
[r
];
19788 r
= get_random_num (0, sizeof (grp_op_pos_p0
));
19789 rule_buf
[rule_pos
++] = grp_op_pos_p0
[r
];
19790 p1
= get_random_num (0, sizeof (grp_pos
));
19791 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19795 r
= get_random_num (0, sizeof (grp_op_pos_p1
));
19796 rule_buf
[rule_pos
++] = grp_op_pos_p1
[r
];
19797 p1
= get_random_num (1, 6);
19798 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19802 r
= get_random_num (0, sizeof (grp_op_chr
));
19803 rule_buf
[rule_pos
++] = grp_op_chr
[r
];
19804 p1
= get_random_num (0x20, 0x7e);
19805 rule_buf
[rule_pos
++] = (char) p1
;
19809 r
= get_random_num (0, sizeof (grp_op_chr_chr
));
19810 rule_buf
[rule_pos
++] = grp_op_chr_chr
[r
];
19811 p1
= get_random_num (0x20, 0x7e);
19812 rule_buf
[rule_pos
++] = (char) p1
;
19813 p2
= get_random_num (0x20, 0x7e);
19815 p2
= get_random_num (0x20, 0x7e);
19816 rule_buf
[rule_pos
++] = (char) p2
;
19820 r
= get_random_num (0, sizeof (grp_op_pos_chr
));
19821 rule_buf
[rule_pos
++] = grp_op_pos_chr
[r
];
19822 p1
= get_random_num (0, sizeof (grp_pos
));
19823 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19824 p2
= get_random_num (0x20, 0x7e);
19825 rule_buf
[rule_pos
++] = (char) p2
;
19829 r
= get_random_num (0, sizeof (grp_op_pos_pos0
));
19830 rule_buf
[rule_pos
++] = grp_op_pos_pos0
[r
];
19831 p1
= get_random_num (0, sizeof (grp_pos
));
19832 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19833 p2
= get_random_num (0, sizeof (grp_pos
));
19835 p2
= get_random_num (0, sizeof (grp_pos
));
19836 rule_buf
[rule_pos
++] = grp_pos
[p2
];
19840 r
= get_random_num (0, sizeof (grp_op_pos_pos1
));
19841 rule_buf
[rule_pos
++] = grp_op_pos_pos1
[r
];
19842 p1
= get_random_num (0, sizeof (grp_pos
));
19843 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19844 p2
= get_random_num (1, sizeof (grp_pos
));
19846 p2
= get_random_num (1, sizeof (grp_pos
));
19847 rule_buf
[rule_pos
++] = grp_pos
[p2
];
19851 r
= get_random_num (0, sizeof (grp_op_pos1_pos2_pos3
));
19852 rule_buf
[rule_pos
++] = grp_op_pos1_pos2_pos3
[r
];
19853 p1
= get_random_num (0, sizeof (grp_pos
));
19854 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19855 p2
= get_random_num (1, sizeof (grp_pos
));
19856 rule_buf
[rule_pos
++] = grp_pos
[p1
];
19857 p3
= get_random_num (0, sizeof (grp_pos
));
19858 rule_buf
[rule_pos
++] = grp_pos
[p3
];
19866 int _old_apply_rule (char *rule
, int rule_len
, char in
[BLOCK_SIZE
], int in_len
, char out
[BLOCK_SIZE
])
19868 char mem
[BLOCK_SIZE
];
19870 if (in
== NULL
) return (RULE_RC_REJECT_ERROR
);
19872 if (out
== NULL
) return (RULE_RC_REJECT_ERROR
);
19874 if (in_len
< 1) return (RULE_RC_REJECT_ERROR
);
19876 if (rule_len
< 1) return (RULE_RC_REJECT_ERROR
);
19878 int out_len
= in_len
;
19879 int mem_len
= in_len
;
19881 memcpy (out
, in
, out_len
);
19885 for (rule_pos
= 0; rule_pos
< rule_len
; rule_pos
++)
19887 int upos
; int upos2
;
19890 switch (rule
[rule_pos
])
19895 case RULE_OP_MANGLE_NOOP
:
19898 case RULE_OP_MANGLE_LREST
:
19899 out_len
= mangle_lrest (out
, out_len
);
19902 case RULE_OP_MANGLE_UREST
:
19903 out_len
= mangle_urest (out
, out_len
);
19906 case RULE_OP_MANGLE_LREST_UFIRST
:
19907 out_len
= mangle_lrest (out
, out_len
);
19908 if (out_len
) MANGLE_UPPER_AT (out
, 0);
19911 case RULE_OP_MANGLE_UREST_LFIRST
:
19912 out_len
= mangle_urest (out
, out_len
);
19913 if (out_len
) MANGLE_LOWER_AT (out
, 0);
19916 case RULE_OP_MANGLE_TREST
:
19917 out_len
= mangle_trest (out
, out_len
);
19920 case RULE_OP_MANGLE_TOGGLE_AT
:
19921 NEXT_RULEPOS (rule_pos
);
19922 NEXT_RPTOI (rule
, rule_pos
, upos
);
19923 if (upos
< out_len
) MANGLE_TOGGLE_AT (out
, upos
);
19926 case RULE_OP_MANGLE_REVERSE
:
19927 out_len
= mangle_reverse (out
, out_len
);
19930 case RULE_OP_MANGLE_DUPEWORD
:
19931 out_len
= mangle_double (out
, out_len
);
19934 case RULE_OP_MANGLE_DUPEWORD_TIMES
:
19935 NEXT_RULEPOS (rule_pos
);
19936 NEXT_RPTOI (rule
, rule_pos
, ulen
);
19937 out_len
= mangle_double_times (out
, out_len
, ulen
);
19940 case RULE_OP_MANGLE_REFLECT
:
19941 out_len
= mangle_reflect (out
, out_len
);
19944 case RULE_OP_MANGLE_ROTATE_LEFT
:
19945 mangle_rotate_left (out
, out_len
);
19948 case RULE_OP_MANGLE_ROTATE_RIGHT
:
19949 mangle_rotate_right (out
, out_len
);
19952 case RULE_OP_MANGLE_APPEND
:
19953 NEXT_RULEPOS (rule_pos
);
19954 out_len
= mangle_append (out
, out_len
, rule
[rule_pos
]);
19957 case RULE_OP_MANGLE_PREPEND
:
19958 NEXT_RULEPOS (rule_pos
);
19959 out_len
= mangle_prepend (out
, out_len
, rule
[rule_pos
]);
19962 case RULE_OP_MANGLE_DELETE_FIRST
:
19963 out_len
= mangle_delete_at (out
, out_len
, 0);
19966 case RULE_OP_MANGLE_DELETE_LAST
:
19967 out_len
= mangle_delete_at (out
, out_len
, (out_len
) ? out_len
- 1 : 0);
19970 case RULE_OP_MANGLE_DELETE_AT
:
19971 NEXT_RULEPOS (rule_pos
);
19972 NEXT_RPTOI (rule
, rule_pos
, upos
);
19973 out_len
= mangle_delete_at (out
, out_len
, upos
);
19976 case RULE_OP_MANGLE_EXTRACT
:
19977 NEXT_RULEPOS (rule_pos
);
19978 NEXT_RPTOI (rule
, rule_pos
, upos
);
19979 NEXT_RULEPOS (rule_pos
);
19980 NEXT_RPTOI (rule
, rule_pos
, ulen
);
19981 out_len
= mangle_extract (out
, out_len
, upos
, ulen
);
19984 case RULE_OP_MANGLE_OMIT
:
19985 NEXT_RULEPOS (rule_pos
);
19986 NEXT_RPTOI (rule
, rule_pos
, upos
);
19987 NEXT_RULEPOS (rule_pos
);
19988 NEXT_RPTOI (rule
, rule_pos
, ulen
);
19989 out_len
= mangle_omit (out
, out_len
, upos
, ulen
);
19992 case RULE_OP_MANGLE_INSERT
:
19993 NEXT_RULEPOS (rule_pos
);
19994 NEXT_RPTOI (rule
, rule_pos
, upos
);
19995 NEXT_RULEPOS (rule_pos
);
19996 out_len
= mangle_insert (out
, out_len
, upos
, rule
[rule_pos
]);
19999 case RULE_OP_MANGLE_OVERSTRIKE
:
20000 NEXT_RULEPOS (rule_pos
);
20001 NEXT_RPTOI (rule
, rule_pos
, upos
);
20002 NEXT_RULEPOS (rule_pos
);
20003 out_len
= mangle_overstrike (out
, out_len
, upos
, rule
[rule_pos
]);
20006 case RULE_OP_MANGLE_TRUNCATE_AT
:
20007 NEXT_RULEPOS (rule_pos
);
20008 NEXT_RPTOI (rule
, rule_pos
, upos
);
20009 out_len
= mangle_truncate_at (out
, out_len
, upos
);
20012 case RULE_OP_MANGLE_REPLACE
:
20013 NEXT_RULEPOS (rule_pos
);
20014 NEXT_RULEPOS (rule_pos
);
20015 out_len
= mangle_replace (out
, out_len
, rule
[rule_pos
- 1], rule
[rule_pos
]);
20018 case RULE_OP_MANGLE_PURGECHAR
:
20019 NEXT_RULEPOS (rule_pos
);
20020 out_len
= mangle_purgechar (out
, out_len
, rule
[rule_pos
]);
20023 case RULE_OP_MANGLE_TOGGLECASE_REC
:
20027 case RULE_OP_MANGLE_DUPECHAR_FIRST
:
20028 NEXT_RULEPOS (rule_pos
);
20029 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20030 out_len
= mangle_dupechar_at (out
, out_len
, 0, ulen
);
20033 case RULE_OP_MANGLE_DUPECHAR_LAST
:
20034 NEXT_RULEPOS (rule_pos
);
20035 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20036 out_len
= mangle_dupechar_at (out
, out_len
, out_len
- 1, ulen
);
20039 case RULE_OP_MANGLE_DUPECHAR_ALL
:
20040 out_len
= mangle_dupechar (out
, out_len
);
20043 case RULE_OP_MANGLE_DUPEBLOCK_FIRST
:
20044 NEXT_RULEPOS (rule_pos
);
20045 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20046 out_len
= mangle_dupeblock_prepend (out
, out_len
, ulen
);
20049 case RULE_OP_MANGLE_DUPEBLOCK_LAST
:
20050 NEXT_RULEPOS (rule_pos
);
20051 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20052 out_len
= mangle_dupeblock_append (out
, out_len
, ulen
);
20055 case RULE_OP_MANGLE_SWITCH_FIRST
:
20056 if (out_len
>= 2) mangle_switch_at (out
, out_len
, 0, 1);
20059 case RULE_OP_MANGLE_SWITCH_LAST
:
20060 if (out_len
>= 2) mangle_switch_at (out
, out_len
, out_len
- 1, out_len
- 2);
20063 case RULE_OP_MANGLE_SWITCH_AT
:
20064 NEXT_RULEPOS (rule_pos
);
20065 NEXT_RPTOI (rule
, rule_pos
, upos
);
20066 NEXT_RULEPOS (rule_pos
);
20067 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20068 out_len
= mangle_switch_at_check (out
, out_len
, upos
, upos2
);
20071 case RULE_OP_MANGLE_CHR_SHIFTL
:
20072 NEXT_RULEPOS (rule_pos
);
20073 NEXT_RPTOI (rule
, rule_pos
, upos
);
20074 mangle_chr_shiftl ((uint8_t *) out
, out_len
, upos
);
20077 case RULE_OP_MANGLE_CHR_SHIFTR
:
20078 NEXT_RULEPOS (rule_pos
);
20079 NEXT_RPTOI (rule
, rule_pos
, upos
);
20080 mangle_chr_shiftr ((uint8_t *) out
, out_len
, upos
);
20083 case RULE_OP_MANGLE_CHR_INCR
:
20084 NEXT_RULEPOS (rule_pos
);
20085 NEXT_RPTOI (rule
, rule_pos
, upos
);
20086 mangle_chr_incr ((uint8_t *) out
, out_len
, upos
);
20089 case RULE_OP_MANGLE_CHR_DECR
:
20090 NEXT_RULEPOS (rule_pos
);
20091 NEXT_RPTOI (rule
, rule_pos
, upos
);
20092 mangle_chr_decr ((uint8_t *) out
, out_len
, upos
);
20095 case RULE_OP_MANGLE_REPLACE_NP1
:
20096 NEXT_RULEPOS (rule_pos
);
20097 NEXT_RPTOI (rule
, rule_pos
, upos
);
20098 if ((upos
>= 0) && ((upos
+ 1) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
+ 1]);
20101 case RULE_OP_MANGLE_REPLACE_NM1
:
20102 NEXT_RULEPOS (rule_pos
);
20103 NEXT_RPTOI (rule
, rule_pos
, upos
);
20104 if ((upos
>= 1) && ((upos
+ 0) < out_len
)) mangle_overstrike (out
, out_len
, upos
, out
[upos
- 1]);
20107 case RULE_OP_MANGLE_TITLE
:
20108 out_len
= mangle_title (out
, out_len
);
20111 case RULE_OP_MANGLE_EXTRACT_MEMORY
:
20112 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20113 NEXT_RULEPOS (rule_pos
);
20114 NEXT_RPTOI (rule
, rule_pos
, upos
);
20115 NEXT_RULEPOS (rule_pos
);
20116 NEXT_RPTOI (rule
, rule_pos
, ulen
);
20117 NEXT_RULEPOS (rule_pos
);
20118 NEXT_RPTOI (rule
, rule_pos
, upos2
);
20119 if ((out_len
= mangle_insert_multi (out
, out_len
, upos2
, mem
, mem_len
, upos
, ulen
)) < 1) return (out_len
);
20122 case RULE_OP_MANGLE_APPEND_MEMORY
:
20123 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20124 if ((out_len
+ mem_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20125 memcpy (out
+ out_len
, mem
, mem_len
);
20126 out_len
+= mem_len
;
20129 case RULE_OP_MANGLE_PREPEND_MEMORY
:
20130 if (mem_len
< 1) return (RULE_RC_REJECT_ERROR
);
20131 if ((mem_len
+ out_len
) > BLOCK_SIZE
) return (RULE_RC_REJECT_ERROR
);
20132 memcpy (mem
+ mem_len
, out
, out_len
);
20133 out_len
+= mem_len
;
20134 memcpy (out
, mem
, out_len
);
20137 case RULE_OP_MEMORIZE_WORD
:
20138 memcpy (mem
, out
, out_len
);
20142 case RULE_OP_REJECT_LESS
:
20143 NEXT_RULEPOS (rule_pos
);
20144 NEXT_RPTOI (rule
, rule_pos
, upos
);
20145 if (out_len
> upos
) return (RULE_RC_REJECT_ERROR
);
20148 case RULE_OP_REJECT_GREATER
:
20149 NEXT_RULEPOS (rule_pos
);
20150 NEXT_RPTOI (rule
, rule_pos
, upos
);
20151 if (out_len
< upos
) return (RULE_RC_REJECT_ERROR
);
20154 case RULE_OP_REJECT_CONTAIN
:
20155 NEXT_RULEPOS (rule_pos
);
20156 if (strchr (out
, rule
[rule_pos
]) != NULL
) return (RULE_RC_REJECT_ERROR
);
20159 case RULE_OP_REJECT_NOT_CONTAIN
:
20160 NEXT_RULEPOS (rule_pos
);
20161 if (strchr (out
, rule
[rule_pos
]) == NULL
) return (RULE_RC_REJECT_ERROR
);
20164 case RULE_OP_REJECT_EQUAL_FIRST
:
20165 NEXT_RULEPOS (rule_pos
);
20166 if (out
[0] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20169 case RULE_OP_REJECT_EQUAL_LAST
:
20170 NEXT_RULEPOS (rule_pos
);
20171 if (out
[out_len
- 1] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20174 case RULE_OP_REJECT_EQUAL_AT
:
20175 NEXT_RULEPOS (rule_pos
);
20176 NEXT_RPTOI (rule
, rule_pos
, upos
);
20177 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20178 NEXT_RULEPOS (rule_pos
);
20179 if (out
[upos
] != rule
[rule_pos
]) return (RULE_RC_REJECT_ERROR
);
20182 case RULE_OP_REJECT_CONTAINS
:
20183 NEXT_RULEPOS (rule_pos
);
20184 NEXT_RPTOI (rule
, rule_pos
, upos
);
20185 if ((upos
+ 1) > out_len
) return (RULE_RC_REJECT_ERROR
);
20186 NEXT_RULEPOS (rule_pos
);
20187 int c
; int cnt
; for (c
= 0, cnt
= 0; c
< out_len
; c
++) if (out
[c
] == rule
[rule_pos
]) cnt
++;
20188 if (cnt
< upos
) return (RULE_RC_REJECT_ERROR
);
20191 case RULE_OP_REJECT_MEMORY
:
20192 if ((out_len
== mem_len
) && (memcmp (out
, mem
, out_len
) == 0)) return (RULE_RC_REJECT_ERROR
);
20196 return (RULE_RC_SYNTAX_ERROR
);
20201 memset (out
+ out_len
, 0, BLOCK_SIZE
- out_len
);