1 /**
2 * Author......: Jens Steube <jens.steube@gmail.com>
3 * License.....: MIT
4 */
5
6 #include "common.h"
7 #include "rp.h"
8 #include "engine.h"
9
10 #include "des-sse2.c"
11 #include "descrypt-sse2.c"
12 #include "md4-sse2.c"
13 #include "md5-sse2.c"
14 #include "sha1-sse2.c"
15 #include "sha256-sse2.c"
16 #include "sha256.c"
17 #include "sha512-sse2.c"
18 #include "sha512.c"
19 #include "keccak-sse2.c"
20 #include "gost-sse2.c"
21 #ifdef __AVX2__
22 #include "bcrypt-sse2.c"
23 #else
24 #include "bcrypt-raw.c"
25 #endif
26
strhashtype(const uint hash_mode)27 char *strhashtype (const uint hash_mode)
28 {
29 switch (hash_mode)
30 {
31 case 0: return ((char *) HT_00000); break;
32 case 10: return ((char *) HT_00010); break;
33 case 11: return ((char *) HT_00011); break;
34 case 12: return ((char *) HT_00012); break;
35 case 20: return ((char *) HT_00020); break;
36 case 21: return ((char *) HT_00021); break;
37 case 23: return ((char *) HT_00023); break;
38 case 30: return ((char *) HT_00030); break;
39 case 40: return ((char *) HT_00040); break;
40 case 50: return ((char *) HT_00050); break;
41 case 60: return ((char *) HT_00060); break;
42 case 100: return ((char *) HT_00100); break;
43 case 101: return ((char *) HT_00101); break;
44 case 110: return ((char *) HT_00110); break;
45 case 111: return ((char *) HT_00111); break;
46 case 112: return ((char *) HT_00112); break;
47 case 120: return ((char *) HT_00120); break;
48 case 121: return ((char *) HT_00121); break;
49 case 122: return ((char *) HT_00122); break;
50 case 123: return ((char *) HT_00123); break;
51 case 124: return ((char *) HT_00124); break;
52 case 130: return ((char *) HT_00130); break;
53 case 131: return ((char *) HT_00131); break;
54 case 132: return ((char *) HT_00132); break;
55 case 133: return ((char *) HT_00133); break;
56 case 140: return ((char *) HT_00140); break;
57 case 141: return ((char *) HT_00141); break;
58 case 150: return ((char *) HT_00150); break;
59 case 160: return ((char *) HT_00160); break;
60 case 200: return ((char *) HT_00200); break;
61 case 300: return ((char *) HT_00300); break;
62 case 400: return ((char *) HT_00400); break;
63 case 500: return ((char *) HT_00500); break;
64 case 501: return ((char *) HT_00501); break;
65 case 666: return ((char *) HT_00666); break;
66 case 900: return ((char *) HT_00900); break;
67 case 1000: return ((char *) HT_01000); break;
68 case 1100: return ((char *) HT_01100); break;
69 case 1400: return ((char *) HT_01400); break;
70 case 1410: return ((char *) HT_01410); break;
71 case 1420: return ((char *) HT_01420); break;
72 case 1421: return ((char *) HT_01421); break;
73 case 1430: return ((char *) HT_01430); break;
74 case 1431: return ((char *) HT_01431); break;
75 case 1440: return ((char *) HT_01440); break;
76 case 1441: return ((char *) HT_01441); break;
77 case 1450: return ((char *) HT_01450); break;
78 case 1460: return ((char *) HT_01460); break;
79 case 1500: return ((char *) HT_01500); break;
80 case 1600: return ((char *) HT_01600); break;
81 case 1700: return ((char *) HT_01700); break;
82 case 1710: return ((char *) HT_01710); break;
83 case 1711: return ((char *) HT_01711); break;
84 case 1720: return ((char *) HT_01720); break;
85 case 1722: return ((char *) HT_01722); break;
86 case 1730: return ((char *) HT_01730); break;
87 case 1731: return ((char *) HT_01731); break;
88 case 1740: return ((char *) HT_01740); break;
89 case 1750: return ((char *) HT_01750); break;
90 case 1760: return ((char *) HT_01760); break;
91 case 1800: return ((char *) HT_01800); break;
92 case 2400: return ((char *) HT_02400); break;
93 case 2410: return ((char *) HT_02410); break;
94 case 2500: return ((char *) HT_02500); break;
95 case 2600: return ((char *) HT_02600); break;
96 case 2611: return ((char *) HT_02611); break;
97 case 2612: return ((char *) HT_02612); break;
98 case 2711: return ((char *) HT_02711); break;
99 case 2811: return ((char *) HT_02811); break;
100 case 3200: return ((char *) HT_03200); break;
101 case 3300: return ((char *) HT_03300); break;
102 case 3500: return ((char *) HT_03500); break;
103 case 3610: return ((char *) HT_03610); break;
104 case 3710: return ((char *) HT_03710); break;
105 case 3711: return ((char *) HT_03711); break;
106 case 3720: return ((char *) HT_03720); break;
107 case 3721: return ((char *) HT_03721); break;
108 case 3800: return ((char *) HT_03800); break;
109 case 3910: return ((char *) HT_03910); break;
110 case 4010: return ((char *) HT_04010); break;
111 case 4110: return ((char *) HT_04110); break;
112 case 4210: return ((char *) HT_04210); break;
113 case 4300: return ((char *) HT_04300); break;
114 case 4400: return ((char *) HT_04400); break;
115 case 4500: return ((char *) HT_04500); break;
116 case 4600: return ((char *) HT_04600); break;
117 case 4700: return ((char *) HT_04700); break;
118 case 4800: return ((char *) HT_04800); break;
119 case 4900: return ((char *) HT_04900); break;
120 case 5000: return ((char *) HT_05000); break;
121 case 5100: return ((char *) HT_05100); break;
122 case 5200: return ((char *) HT_05200); break;
123 case 5300: return ((char *) HT_05300); break;
124 case 5400: return ((char *) HT_05400); break;
125 case 5500: return ((char *) HT_05500); break;
126 case 5600: return ((char *) HT_05600); break;
127 case 5700: return ((char *) HT_05700); break;
128 case 5800: return ((char *) HT_05800); break;
129 case 6300: return ((char *) HT_06300); break;
130 case 6400: return ((char *) HT_06400); break;
131 case 6500: return ((char *) HT_06500); break;
132 case 6700: return ((char *) HT_06700); break;
133 case 6900: return ((char *) HT_06900); break;
134 case 7000: return ((char *) HT_07000); break;
135 case 7100: return ((char *) HT_07100); break;
136 case 7200: return ((char *) HT_07200); break;
137 case 7300: return ((char *) HT_07300); break;
138 case 7400: return ((char *) HT_07400); break;
139 case 7600: return ((char *) HT_07600); break;
140 case 7900: return ((char *) HT_07900); break;
141 case 8400: return ((char *) HT_08400); break;
142 case 8900: return ((char *) HT_08900); break;
143 case 9200: return ((char *) HT_09200); break;
144 case 9300: return ((char *) HT_09300); break;
145 case 9900: return ((char *) HT_09900); break;
146 case 10000: return ((char *) HT_10000); break;
147 case 10200: return ((char *) HT_10200); break;
148 case 10300: return ((char *) HT_10300); break;
149 case 11000: return ((char *) HT_11000); break;
150 case 11100: return ((char *) HT_11100); break;
151 case 11200: return ((char *) HT_11200); break;
152 case 11400: return ((char *) HT_11400); break;
153 case 99999: return ((char *) HT_99999); break;
154 }
155
156 return ((char *) "Unknown");
157 }
158
159 const char BASE64A_TAB[64] =
160 {
161 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
162 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
163 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
164 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
165 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
166 '+', '/'
167 };
168
169 const char BASE64B_TAB[64] =
170 {
171 '.', '/',
172 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
173 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
174 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
175 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
176 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'
177 };
178
179 static thread_parameter_t thread_parameters[MAX_THREADS] __attribute__ ((aligned (16)));
180
181 static MUTEX lock_store;
182
get_thread_words_total(uint32_t num_threads)183 uint64_t get_thread_words_total (uint32_t num_threads)
184 {
185 uint64_t thread_words_total = 0;
186
187 uint32_t thread_id;
188
189 for (thread_id = 0; thread_id < num_threads; thread_id++)
190 {
191 thread_words_total += thread_parameters[thread_id].thread_words_done;
192 }
193
194 return (thread_words_total);
195 }
196
get_thread_plains_total(uint32_t num_threads)197 uint64_t get_thread_plains_total (uint32_t num_threads)
198 {
199 uint64_t thread_plains_total = 0;
200
201 uint32_t thread_id;
202
203 for (thread_id = 0; thread_id < num_threads; thread_id++)
204 {
205 thread_plains_total += thread_parameters[thread_id].thread_plains_done;
206 }
207
208 return (thread_plains_total);
209 }
210
base64a_int2char(int i)211 char base64a_int2char (int i)
212 {
213 return BASE64A_TAB[i & 0x3f];
214 }
215
base64a_char2int(char c)216 int base64a_char2int (char c)
217 {
218 char *p = strchr (BASE64A_TAB, c);
219
220 if (p == NULL) return (-1);
221
222 return (p - BASE64A_TAB);
223 }
224
base64b_int2char(int i)225 char base64b_int2char (int i)
226 {
227 return BASE64B_TAB[i & 0x3f];
228 }
229
base64b_char2int(char c)230 int base64b_char2int (char c)
231 {
232 char *p = strchr (BASE64B_TAB, c);
233
234 if (p == NULL) return (-1);
235
236 return (p - BASE64B_TAB);
237 }
238
int_to_itoa64(const char c)239 char int_to_itoa64 (const char c)
240 {
241 if (c == 0) return '.';
242 else if (c == 1) return '/';
243 else if (c < 12) return '0' + c - 2;
244 else if (c < 38) return 'A' + c - 12;
245 else if (c < 64) return 'a' + c - 38;
246
247 return 0;
248 }
249
int_to_base64(const char c)250 char int_to_base64 (const char c)
251 {
252 if (c < 26) return 'A' + c;
253 else if (c < 52) return 'a' + c - 26;
254 else if (c < 62) return '0' + c - 52;
255 else if (c == 62) return '+';
256 else if (c == 63) return '/';
257
258 return 0;
259 }
260
itoa64_to_int(const char c)261 char itoa64_to_int (const char c)
262 {
263 if (c == '.') return 0;
264 else if (c == '/') return 1;
265 else if ((c >= '0') && (c <= '9')) return c - '0' + 2;
266 else if ((c >= 'A') && (c <= 'Z')) return c - 'A' + 12;
267 else if ((c >= 'a') && (c <= 'z')) return c - 'a' + 38;
268
269 return 0;
270 }
271
base64_to_int(const char c)272 char base64_to_int (const char c)
273 {
274 if ((c >= 'A') && (c <= 'Z')) return c - 'A';
275 else if ((c >= 'a') && (c <= 'z')) return c - 'a' + 26;
276 else if ((c >= '0') && (c <= '9')) return c - '0' + 52;
277 else if (c == '+') return 62;
278 else if (c == '/') return 63;
279
280 return 0;
281 }
282
int_to_bf64(const char c)283 char int_to_bf64 (const char c)
284 {
285 if (c == 0) return '.';
286 else if (c == 1) return '/';
287 else if (c < 28) return 'A' + c - 2;
288 else if (c < 54) return 'a' + c - 28;
289 else if (c < 64) return '0' + c - 54;
290
291 return 0;
292 }
293
bf64_to_int(const char c)294 char bf64_to_int (const char c)
295 {
296 if (c == '.') return 0;
297 else if (c == '/') return 1;
298 else if ((c >= 'A') && (c <= 'Z')) return c - 'A' + 2;
299 else if ((c >= 'a') && (c <= 'z')) return c - 'a' + 28;
300 else if ((c >= '0') && (c <= '9')) return c - '0' + 54;
301
302 return 0;
303 }
304
base64_decode(char (* f)(const char),char * in_buf,int in_len,char * out_buf)305 int base64_decode (char (*f) (const char), char *in_buf, int in_len, char *out_buf)
306 {
307 char *in_ptr = in_buf;
308
309 char *out_ptr = out_buf;
310
311 int i,out_len;
312
313 for (i = 0; i < in_len; i += 4)
314 {
315 char out_val0 = f (in_ptr[0] & 0x7f);
316 char out_val1 = f (in_ptr[1] & 0x7f);
317 char out_val2 = f (in_ptr[2] & 0x7f);
318 char out_val3 = f (in_ptr[3] & 0x7f);
319
320 out_ptr[0] = ((out_val0 << 2) & 0xfc) | ((out_val1 >> 4) & 0x03);
321 out_ptr[1] = ((out_val1 << 4) & 0xf0) | ((out_val2 >> 2) & 0x0f);
322 out_ptr[2] = ((out_val2 << 6) & 0xc0) | ((out_val3 >> 0) & 0x3f);
323
324 in_ptr += 4;
325 out_ptr += 3;
326 }
327
328 for (i = 0; i < in_len; i++)
329 {
330 if (in_buf[i] != '=') continue;
331
332 in_len = i;
333 }
334
335 out_len = (in_len * 6) / 8;
336
337 return out_len;
338 }
339
base64_encode(char (* f)(const char),char * in_buf,int in_len,char * out_buf)340 int base64_encode (char (*f) (const char), char *in_buf, int in_len, char *out_buf)
341 {
342 char *in_ptr = in_buf;
343
344 char *out_ptr = out_buf;
345
346 int i,out_len;
347
348 for (i = 0; i < in_len; i += 3)
349 {
350 char out_val0 = f ((in_ptr[0] >> 2) & 0x3f);
351 char out_val1 = f (((in_ptr[0] << 4) & 0x30)
352 |((in_ptr[1] >> 4) & 0x0f));
353 char out_val2 = f (((in_ptr[1] << 2) & 0x3c)
354 |((in_ptr[2] >> 6) & 0x03));
355 char out_val3 = f ((in_ptr[2] >> 0) & 0x3f);
356
357 out_ptr[0] = out_val0 & 0x7f;
358 out_ptr[1] = out_val1 & 0x7f;
359 out_ptr[2] = out_val2 & 0x7f;
360 out_ptr[3] = out_val3 & 0x7f;
361
362 in_ptr += 3;
363 out_ptr += 4;
364 }
365
366 out_len = (in_len * 8) / 6;
367
368 for (i = 0; i < (3 - (in_len % 3)); i++)
369 {
370 out_len++;
371
372 out_buf[out_len] = '=';
373 }
374
375 return out_len;
376 }
377
descrypt_decode(unsigned char digest[DIGEST_SIZE_DESCRYPT],unsigned char buf[HASH_SIZE_DESCRYPT])378 void descrypt_decode (unsigned char digest[DIGEST_SIZE_DESCRYPT], unsigned char buf[HASH_SIZE_DESCRYPT])
379 {
380 char tmp_buf[100];
381 uint tmp_digest[2];
382
383 memset (tmp_buf, 0, sizeof (tmp_buf));
384
385 base64_decode (itoa64_to_int, (char*)buf, 11, tmp_buf);
386
387 memcpy (tmp_digest, tmp_buf, 8);
388
389 uint32_t tt;
390
391 IP (tmp_digest[0], tmp_digest[1], tt);
392
393 tmp_digest[0] = ROTR32 (tmp_digest[0], 31);
394 tmp_digest[1] = ROTR32 (tmp_digest[1], 31);
395
396 memcpy (digest, tmp_digest, 8);
397 }
398
descrypt_encode(unsigned char digest[DIGEST_SIZE_DESCRYPT],unsigned char buf[HASH_SIZE_DESCRYPT])399 void descrypt_encode (unsigned char digest[DIGEST_SIZE_DESCRYPT], unsigned char buf[HASH_SIZE_DESCRYPT])
400 {
401 uint tmp_digest[2];
402 char tmp_buf[16];
403
404 memset (tmp_buf, 0, sizeof (tmp_buf));
405
406 memcpy (tmp_digest, digest, 8);
407
408 tmp_digest[0] = ROTL32 (tmp_digest[0], 31);
409 tmp_digest[1] = ROTL32 (tmp_digest[1], 31);
410
411 uint32_t tt;
412
413 FP (tmp_digest[1], tmp_digest[0], tt);
414
415 memcpy (tmp_buf, &tmp_digest, 8);
416
417 base64_encode (int_to_itoa64, tmp_buf, 8, (char*)buf);
418 }
419
phpass_decode(unsigned char digest[DIGEST_SIZE_MD5],unsigned char buf[HASH_SIZE_PHPASS])420 void phpass_decode (unsigned char digest[DIGEST_SIZE_MD5], unsigned char buf[HASH_SIZE_PHPASS])
421 {
422 int l;
423
424 l = base64b_char2int (buf[ 0]) << 0;
425 l |= base64b_char2int (buf[ 1]) << 6;
426 l |= base64b_char2int (buf[ 2]) << 12;
427 l |= base64b_char2int (buf[ 3]) << 18;
428
429 digest[ 0] = (l >> 0) & 0xff;
430 digest[ 1] = (l >> 8) & 0xff;
431 digest[ 2] = (l >> 16) & 0xff;
432
433 l = base64b_char2int (buf[ 4]) << 0;
434 l |= base64b_char2int (buf[ 5]) << 6;
435 l |= base64b_char2int (buf[ 6]) << 12;
436 l |= base64b_char2int (buf[ 7]) << 18;
437
438 digest[ 3] = (l >> 0) & 0xff;
439 digest[ 4] = (l >> 8) & 0xff;
440 digest[ 5] = (l >> 16) & 0xff;
441
442 l = base64b_char2int (buf[ 8]) << 0;
443 l |= base64b_char2int (buf[ 9]) << 6;
444 l |= base64b_char2int (buf[10]) << 12;
445 l |= base64b_char2int (buf[11]) << 18;
446
447 digest[ 6] = (l >> 0) & 0xff;
448 digest[ 7] = (l >> 8) & 0xff;
449 digest[ 8] = (l >> 16) & 0xff;
450
451 l = base64b_char2int (buf[12]) << 0;
452 l |= base64b_char2int (buf[13]) << 6;
453 l |= base64b_char2int (buf[14]) << 12;
454 l |= base64b_char2int (buf[15]) << 18;
455
456 digest[ 9] = (l >> 0) & 0xff;
457 digest[10] = (l >> 8) & 0xff;
458 digest[11] = (l >> 16) & 0xff;
459
460 l = base64b_char2int (buf[16]) << 0;
461 l |= base64b_char2int (buf[17]) << 6;
462 l |= base64b_char2int (buf[18]) << 12;
463 l |= base64b_char2int (buf[19]) << 18;
464
465 digest[12] = (l >> 0) & 0xff;
466 digest[13] = (l >> 8) & 0xff;
467 digest[14] = (l >> 16) & 0xff;
468
469 l = base64b_char2int (buf[20]) << 0;
470 l |= base64b_char2int (buf[21]) << 6;
471
472 digest[15] = (l >> 0) & 0xff;
473 }
474
phpass_encode(unsigned char digest[DIGEST_SIZE_MD5],unsigned char buf[HASH_SIZE_PHPASS])475 void phpass_encode (unsigned char digest[DIGEST_SIZE_MD5], unsigned char buf[HASH_SIZE_PHPASS])
476 {
477 int l;
478
479 l = (digest[ 0] << 0) | (digest[ 1] << 8) | (digest[ 2] << 16);
480
481 buf[ 0] = base64b_int2char (l); l >>= 6;
482 buf[ 1] = base64b_int2char (l); l >>= 6;
483 buf[ 2] = base64b_int2char (l); l >>= 6;
484 buf[ 3] = base64b_int2char (l);
485
486 l = (digest[ 3] << 0) | (digest[ 4] << 8) | (digest[ 5] << 16);
487
488 buf[ 4] = base64b_int2char (l); l >>= 6;
489 buf[ 5] = base64b_int2char (l); l >>= 6;
490 buf[ 6] = base64b_int2char (l); l >>= 6;
491 buf[ 7] = base64b_int2char (l);
492
493 l = (digest[ 6] << 0) | (digest[ 7] << 8) | (digest[ 8] << 16);
494
495 buf[ 8] = base64b_int2char (l); l >>= 6;
496 buf[ 9] = base64b_int2char (l); l >>= 6;
497 buf[10] = base64b_int2char (l); l >>= 6;
498 buf[11] = base64b_int2char (l);
499
500 l = (digest[ 9] << 0) | (digest[10] << 8) | (digest[11] << 16);
501
502 buf[12] = base64b_int2char (l); l >>= 6;
503 buf[13] = base64b_int2char (l); l >>= 6;
504 buf[14] = base64b_int2char (l); l >>= 6;
505 buf[15] = base64b_int2char (l);
506
507 l = (digest[12] << 0) | (digest[13] << 8) | (digest[14] << 16);
508
509 buf[16] = base64b_int2char (l); l >>= 6;
510 buf[17] = base64b_int2char (l); l >>= 6;
511 buf[18] = base64b_int2char (l); l >>= 6;
512 buf[19] = base64b_int2char (l);
513
514 l = (digest[15] << 0);
515
516 buf[20] = base64b_int2char (l); l >>= 6;
517 buf[21] = base64b_int2char (l);
518 }
519
md5unix_decode(unsigned char digest[DIGEST_SIZE_MD5],unsigned char buf[HASH_SIZE_MD5UNIX])520 void md5unix_decode (unsigned char digest[DIGEST_SIZE_MD5], unsigned char buf[HASH_SIZE_MD5UNIX])
521 {
522 int l;
523
524 l = base64b_char2int (buf[ 0]) << 0;
525 l |= base64b_char2int (buf[ 1]) << 6;
526 l |= base64b_char2int (buf[ 2]) << 12;
527 l |= base64b_char2int (buf[ 3]) << 18;
528
529 digest[ 0] = (l >> 16) & 0xff;
530 digest[ 6] = (l >> 8) & 0xff;
531 digest[12] = (l >> 0) & 0xff;
532
533 l = base64b_char2int (buf[ 4]) << 0;
534 l |= base64b_char2int (buf[ 5]) << 6;
535 l |= base64b_char2int (buf[ 6]) << 12;
536 l |= base64b_char2int (buf[ 7]) << 18;
537
538 digest[ 1] = (l >> 16) & 0xff;
539 digest[ 7] = (l >> 8) & 0xff;
540 digest[13] = (l >> 0) & 0xff;
541
542 l = base64b_char2int (buf[ 8]) << 0;
543 l |= base64b_char2int (buf[ 9]) << 6;
544 l |= base64b_char2int (buf[10]) << 12;
545 l |= base64b_char2int (buf[11]) << 18;
546
547 digest[ 2] = (l >> 16) & 0xff;
548 digest[ 8] = (l >> 8) & 0xff;
549 digest[14] = (l >> 0) & 0xff;
550
551 l = base64b_char2int (buf[12]) << 0;
552 l |= base64b_char2int (buf[13]) << 6;
553 l |= base64b_char2int (buf[14]) << 12;
554 l |= base64b_char2int (buf[15]) << 18;
555
556 digest[ 3] = (l >> 16) & 0xff;
557 digest[ 9] = (l >> 8) & 0xff;
558 digest[15] = (l >> 0) & 0xff;
559
560 l = base64b_char2int (buf[16]) << 0;
561 l |= base64b_char2int (buf[17]) << 6;
562 l |= base64b_char2int (buf[18]) << 12;
563 l |= base64b_char2int (buf[19]) << 18;
564
565 digest[ 4] = (l >> 16) & 0xff;
566 digest[10] = (l >> 8) & 0xff;
567 digest[ 5] = (l >> 0) & 0xff;
568
569 l = base64b_char2int (buf[20]) << 0;
570 l |= base64b_char2int (buf[21]) << 6;
571
572 digest[11] = (l >> 0) & 0xff;
573 }
574
md5unix_encode(unsigned char digest[DIGEST_SIZE_MD5],unsigned char buf[HASH_SIZE_MD5UNIX])575 void md5unix_encode (unsigned char digest[DIGEST_SIZE_MD5], unsigned char buf[HASH_SIZE_MD5UNIX])
576 {
577 int l;
578
579 l = (digest[ 0] << 16) | (digest[ 6] << 8) | (digest[12] << 0);
580
581 buf[ 0] = base64b_int2char (l); l >>= 6;
582 buf[ 1] = base64b_int2char (l); l >>= 6;
583 buf[ 2] = base64b_int2char (l); l >>= 6;
584 buf[ 3] = base64b_int2char (l); l >>= 6;
585
586 l = (digest[ 1] << 16) | (digest[ 7] << 8) | (digest[13] << 0);
587
588 buf[ 4] = base64b_int2char (l); l >>= 6;
589 buf[ 5] = base64b_int2char (l); l >>= 6;
590 buf[ 6] = base64b_int2char (l); l >>= 6;
591 buf[ 7] = base64b_int2char (l); l >>= 6;
592
593 l = (digest[ 2] << 16) | (digest[ 8] << 8) | (digest[14] << 0);
594
595 buf[ 8] = base64b_int2char (l); l >>= 6;
596 buf[ 9] = base64b_int2char (l); l >>= 6;
597 buf[10] = base64b_int2char (l); l >>= 6;
598 buf[11] = base64b_int2char (l); l >>= 6;
599
600 l = (digest[ 3] << 16) | (digest[ 9] << 8) | (digest[15] << 0);
601
602 buf[12] = base64b_int2char (l); l >>= 6;
603 buf[13] = base64b_int2char (l); l >>= 6;
604 buf[14] = base64b_int2char (l); l >>= 6;
605 buf[15] = base64b_int2char (l); l >>= 6;
606
607 l = (digest[ 4] << 16) | (digest[10] << 8) | (digest[ 5] << 0);
608
609 buf[16] = base64b_int2char (l); l >>= 6;
610 buf[17] = base64b_int2char (l); l >>= 6;
611 buf[18] = base64b_int2char (l); l >>= 6;
612 buf[19] = base64b_int2char (l); l >>= 6;
613
614 l = (digest[11] << 0);
615
616 buf[20] = base64b_int2char (l); l >>= 6;
617 buf[21] = base64b_int2char (l); l >>= 6;
618 }
619
md5sun_decode(unsigned char digest[DIGEST_SIZE_MD5],unsigned char buf[HASH_SIZE_MD5SUN])620 void md5sun_decode (unsigned char digest[DIGEST_SIZE_MD5], unsigned char buf[HASH_SIZE_MD5SUN])
621 {
622 int l;
623
624 l = base64b_char2int (buf[ 0]) << 0;
625 l |= base64b_char2int (buf[ 1]) << 6;
626 l |= base64b_char2int (buf[ 2]) << 12;
627 l |= base64b_char2int (buf[ 3]) << 18;
628
629 digest[ 0] = (l >> 16) & 0xff;
630 digest[ 6] = (l >> 8) & 0xff;
631 digest[12] = (l >> 0) & 0xff;
632
633 l = base64b_char2int (buf[ 4]) << 0;
634 l |= base64b_char2int (buf[ 5]) << 6;
635 l |= base64b_char2int (buf[ 6]) << 12;
636 l |= base64b_char2int (buf[ 7]) << 18;
637
638 digest[ 1] = (l >> 16) & 0xff;
639 digest[ 7] = (l >> 8) & 0xff;
640 digest[13] = (l >> 0) & 0xff;
641
642 l = base64b_char2int (buf[ 8]) << 0;
643 l |= base64b_char2int (buf[ 9]) << 6;
644 l |= base64b_char2int (buf[10]) << 12;
645 l |= base64b_char2int (buf[11]) << 18;
646
647 digest[ 2] = (l >> 16) & 0xff;
648 digest[ 8] = (l >> 8) & 0xff;
649 digest[14] = (l >> 0) & 0xff;
650
651 l = base64b_char2int (buf[12]) << 0;
652 l |= base64b_char2int (buf[13]) << 6;
653 l |= base64b_char2int (buf[14]) << 12;
654 l |= base64b_char2int (buf[15]) << 18;
655
656 digest[ 3] = (l >> 16) & 0xff;
657 digest[ 9] = (l >> 8) & 0xff;
658 digest[15] = (l >> 0) & 0xff;
659
660 l = base64b_char2int (buf[16]) << 0;
661 l |= base64b_char2int (buf[17]) << 6;
662 l |= base64b_char2int (buf[18]) << 12;
663 l |= base64b_char2int (buf[19]) << 18;
664
665 digest[ 4] = (l >> 16) & 0xff;
666 digest[10] = (l >> 8) & 0xff;
667 digest[ 5] = (l >> 0) & 0xff;
668
669 l = base64b_char2int (buf[20]) << 0;
670 l |= base64b_char2int (buf[21]) << 6;
671
672 digest[11] = (l >> 0) & 0xff;
673 }
674
md5sun_encode(unsigned char digest[DIGEST_SIZE_MD5],unsigned char buf[HASH_SIZE_MD5SUN])675 void md5sun_encode (unsigned char digest[DIGEST_SIZE_MD5], unsigned char buf[HASH_SIZE_MD5SUN])
676 {
677 int l;
678
679 l = (digest[ 0] << 16) | (digest[ 6] << 8) | (digest[12] << 0);
680
681 buf[ 0] = base64b_int2char (l); l >>= 6;
682 buf[ 1] = base64b_int2char (l); l >>= 6;
683 buf[ 2] = base64b_int2char (l); l >>= 6;
684 buf[ 3] = base64b_int2char (l); l >>= 6;
685
686 l = (digest[ 1] << 16) | (digest[ 7] << 8) | (digest[13] << 0);
687
688 buf[ 4] = base64b_int2char (l); l >>= 6;
689 buf[ 5] = base64b_int2char (l); l >>= 6;
690 buf[ 6] = base64b_int2char (l); l >>= 6;
691 buf[ 7] = base64b_int2char (l); l >>= 6;
692
693 l = (digest[ 2] << 16) | (digest[ 8] << 8) | (digest[14] << 0);
694
695 buf[ 8] = base64b_int2char (l); l >>= 6;
696 buf[ 9] = base64b_int2char (l); l >>= 6;
697 buf[10] = base64b_int2char (l); l >>= 6;
698 buf[11] = base64b_int2char (l); l >>= 6;
699
700 l = (digest[ 3] << 16) | (digest[ 9] << 8) | (digest[15] << 0);
701
702 buf[12] = base64b_int2char (l); l >>= 6;
703 buf[13] = base64b_int2char (l); l >>= 6;
704 buf[14] = base64b_int2char (l); l >>= 6;
705 buf[15] = base64b_int2char (l); l >>= 6;
706
707 l = (digest[ 4] << 16) | (digest[10] << 8) | (digest[ 5] << 0);
708
709 buf[16] = base64b_int2char (l); l >>= 6;
710 buf[17] = base64b_int2char (l); l >>= 6;
711 buf[18] = base64b_int2char (l); l >>= 6;
712 buf[19] = base64b_int2char (l); l >>= 6;
713
714 l = (digest[11] << 0);
715
716 buf[20] = base64b_int2char (l); l >>= 6;
717 buf[21] = base64b_int2char (l); l >>= 6;
718 }
719
md5apr_decode(unsigned char digest[DIGEST_SIZE_MD5],unsigned char buf[HASH_SIZE_MD5APR])720 void md5apr_decode (unsigned char digest[DIGEST_SIZE_MD5], unsigned char buf[HASH_SIZE_MD5APR])
721 {
722 int l;
723
724 l = base64b_char2int (buf[ 0]) << 0;
725 l |= base64b_char2int (buf[ 1]) << 6;
726 l |= base64b_char2int (buf[ 2]) << 12;
727 l |= base64b_char2int (buf[ 3]) << 18;
728
729 digest[ 0] = (l >> 16) & 0xff;
730 digest[ 6] = (l >> 8) & 0xff;
731 digest[12] = (l >> 0) & 0xff;
732
733 l = base64b_char2int (buf[ 4]) << 0;
734 l |= base64b_char2int (buf[ 5]) << 6;
735 l |= base64b_char2int (buf[ 6]) << 12;
736 l |= base64b_char2int (buf[ 7]) << 18;
737
738 digest[ 1] = (l >> 16) & 0xff;
739 digest[ 7] = (l >> 8) & 0xff;
740 digest[13] = (l >> 0) & 0xff;
741
742 l = base64b_char2int (buf[ 8]) << 0;
743 l |= base64b_char2int (buf[ 9]) << 6;
744 l |= base64b_char2int (buf[10]) << 12;
745 l |= base64b_char2int (buf[11]) << 18;
746
747 digest[ 2] = (l >> 16) & 0xff;
748 digest[ 8] = (l >> 8) & 0xff;
749 digest[14] = (l >> 0) & 0xff;
750
751 l = base64b_char2int (buf[12]) << 0;
752 l |= base64b_char2int (buf[13]) << 6;
753 l |= base64b_char2int (buf[14]) << 12;
754 l |= base64b_char2int (buf[15]) << 18;
755
756 digest[ 3] = (l >> 16) & 0xff;
757 digest[ 9] = (l >> 8) & 0xff;
758 digest[15] = (l >> 0) & 0xff;
759
760 l = base64b_char2int (buf[16]) << 0;
761 l |= base64b_char2int (buf[17]) << 6;
762 l |= base64b_char2int (buf[18]) << 12;
763 l |= base64b_char2int (buf[19]) << 18;
764
765 digest[ 4] = (l >> 16) & 0xff;
766 digest[10] = (l >> 8) & 0xff;
767 digest[ 5] = (l >> 0) & 0xff;
768
769 l = base64b_char2int (buf[20]) << 0;
770 l |= base64b_char2int (buf[21]) << 6;
771
772 digest[11] = (l >> 0) & 0xff;
773 }
774
md5apr_encode(unsigned char digest[DIGEST_SIZE_MD5],unsigned char buf[HASH_SIZE_MD5APR])775 void md5apr_encode (unsigned char digest[DIGEST_SIZE_MD5], unsigned char buf[HASH_SIZE_MD5APR])
776 {
777 int l;
778
779 l = (digest[ 0] << 16) | (digest[ 6] << 8) | (digest[12] << 0);
780
781 buf[ 0] = base64b_int2char (l); l >>= 6;
782 buf[ 1] = base64b_int2char (l); l >>= 6;
783 buf[ 2] = base64b_int2char (l); l >>= 6;
784 buf[ 3] = base64b_int2char (l); l >>= 6;
785
786 l = (digest[ 1] << 16) | (digest[ 7] << 8) | (digest[13] << 0);
787
788 buf[ 4] = base64b_int2char (l); l >>= 6;
789 buf[ 5] = base64b_int2char (l); l >>= 6;
790 buf[ 6] = base64b_int2char (l); l >>= 6;
791 buf[ 7] = base64b_int2char (l); l >>= 6;
792
793 l = (digest[ 2] << 16) | (digest[ 8] << 8) | (digest[14] << 0);
794
795 buf[ 8] = base64b_int2char (l); l >>= 6;
796 buf[ 9] = base64b_int2char (l); l >>= 6;
797 buf[10] = base64b_int2char (l); l >>= 6;
798 buf[11] = base64b_int2char (l); l >>= 6;
799
800 l = (digest[ 3] << 16) | (digest[ 9] << 8) | (digest[15] << 0);
801
802 buf[12] = base64b_int2char (l); l >>= 6;
803 buf[13] = base64b_int2char (l); l >>= 6;
804 buf[14] = base64b_int2char (l); l >>= 6;
805 buf[15] = base64b_int2char (l); l >>= 6;
806
807 l = (digest[ 4] << 16) | (digest[10] << 8) | (digest[ 5] << 0);
808
809 buf[16] = base64b_int2char (l); l >>= 6;
810 buf[17] = base64b_int2char (l); l >>= 6;
811 buf[18] = base64b_int2char (l); l >>= 6;
812 buf[19] = base64b_int2char (l); l >>= 6;
813
814 l = (digest[11] << 0);
815
816 buf[20] = base64b_int2char (l); l >>= 6;
817 buf[21] = base64b_int2char (l); l >>= 6;
818 }
819
sha512unix_decode(unsigned char digest[DIGEST_SIZE_SHA512],unsigned char buf[HASH_SIZE_SHA512UNIX])820 void sha512unix_decode (unsigned char digest[DIGEST_SIZE_SHA512], unsigned char buf[HASH_SIZE_SHA512UNIX])
821 {
822 int l;
823
824 l = base64b_char2int (buf[ 0]) << 0;
825 l |= base64b_char2int (buf[ 1]) << 6;
826 l |= base64b_char2int (buf[ 2]) << 12;
827 l |= base64b_char2int (buf[ 3]) << 18;
828
829 digest[ 0] = (l >> 16) & 0xff;
830 digest[21] = (l >> 8) & 0xff;
831 digest[42] = (l >> 0) & 0xff;
832
833 l = base64b_char2int (buf[ 4]) << 0;
834 l |= base64b_char2int (buf[ 5]) << 6;
835 l |= base64b_char2int (buf[ 6]) << 12;
836 l |= base64b_char2int (buf[ 7]) << 18;
837
838 digest[22] = (l >> 16) & 0xff;
839 digest[43] = (l >> 8) & 0xff;
840 digest[ 1] = (l >> 0) & 0xff;
841
842 l = base64b_char2int (buf[ 8]) << 0;
843 l |= base64b_char2int (buf[ 9]) << 6;
844 l |= base64b_char2int (buf[10]) << 12;
845 l |= base64b_char2int (buf[11]) << 18;
846
847 digest[44] = (l >> 16) & 0xff;
848 digest[ 2] = (l >> 8) & 0xff;
849 digest[23] = (l >> 0) & 0xff;
850
851 l = base64b_char2int (buf[12]) << 0;
852 l |= base64b_char2int (buf[13]) << 6;
853 l |= base64b_char2int (buf[14]) << 12;
854 l |= base64b_char2int (buf[15]) << 18;
855
856 digest[ 3] = (l >> 16) & 0xff;
857 digest[24] = (l >> 8) & 0xff;
858 digest[45] = (l >> 0) & 0xff;
859
860 l = base64b_char2int (buf[16]) << 0;
861 l |= base64b_char2int (buf[17]) << 6;
862 l |= base64b_char2int (buf[18]) << 12;
863 l |= base64b_char2int (buf[19]) << 18;
864
865 digest[25] = (l >> 16) & 0xff;
866 digest[46] = (l >> 8) & 0xff;
867 digest[ 4] = (l >> 0) & 0xff;
868
869 l = base64b_char2int (buf[20]) << 0;
870 l |= base64b_char2int (buf[21]) << 6;
871 l |= base64b_char2int (buf[22]) << 12;
872 l |= base64b_char2int (buf[23]) << 18;
873
874 digest[47] = (l >> 16) & 0xff;
875 digest[ 5] = (l >> 8) & 0xff;
876 digest[26] = (l >> 0) & 0xff;
877
878 l = base64b_char2int (buf[24]) << 0;
879 l |= base64b_char2int (buf[25]) << 6;
880 l |= base64b_char2int (buf[26]) << 12;
881 l |= base64b_char2int (buf[27]) << 18;
882
883 digest[ 6] = (l >> 16) & 0xff;
884 digest[27] = (l >> 8) & 0xff;
885 digest[48] = (l >> 0) & 0xff;
886
887 l = base64b_char2int (buf[28]) << 0;
888 l |= base64b_char2int (buf[29]) << 6;
889 l |= base64b_char2int (buf[30]) << 12;
890 l |= base64b_char2int (buf[31]) << 18;
891
892 digest[28] = (l >> 16) & 0xff;
893 digest[49] = (l >> 8) & 0xff;
894 digest[ 7] = (l >> 0) & 0xff;
895
896 l = base64b_char2int (buf[32]) << 0;
897 l |= base64b_char2int (buf[33]) << 6;
898 l |= base64b_char2int (buf[34]) << 12;
899 l |= base64b_char2int (buf[35]) << 18;
900
901 digest[50] = (l >> 16) & 0xff;
902 digest[ 8] = (l >> 8) & 0xff;
903 digest[29] = (l >> 0) & 0xff;
904
905 l = base64b_char2int (buf[36]) << 0;
906 l |= base64b_char2int (buf[37]) << 6;
907 l |= base64b_char2int (buf[38]) << 12;
908 l |= base64b_char2int (buf[39]) << 18;
909
910 digest[ 9] = (l >> 16) & 0xff;
911 digest[30] = (l >> 8) & 0xff;
912 digest[51] = (l >> 0) & 0xff;
913
914 l = base64b_char2int (buf[40]) << 0;
915 l |= base64b_char2int (buf[41]) << 6;
916 l |= base64b_char2int (buf[42]) << 12;
917 l |= base64b_char2int (buf[43]) << 18;
918
919 digest[31] = (l >> 16) & 0xff;
920 digest[52] = (l >> 8) & 0xff;
921 digest[10] = (l >> 0) & 0xff;
922
923 l = base64b_char2int (buf[44]) << 0;
924 l |= base64b_char2int (buf[45]) << 6;
925 l |= base64b_char2int (buf[46]) << 12;
926 l |= base64b_char2int (buf[47]) << 18;
927
928 digest[53] = (l >> 16) & 0xff;
929 digest[11] = (l >> 8) & 0xff;
930 digest[32] = (l >> 0) & 0xff;
931
932 l = base64b_char2int (buf[48]) << 0;
933 l |= base64b_char2int (buf[49]) << 6;
934 l |= base64b_char2int (buf[50]) << 12;
935 l |= base64b_char2int (buf[51]) << 18;
936
937 digest[12] = (l >> 16) & 0xff;
938 digest[33] = (l >> 8) & 0xff;
939 digest[54] = (l >> 0) & 0xff;
940
941 l = base64b_char2int (buf[52]) << 0;
942 l |= base64b_char2int (buf[53]) << 6;
943 l |= base64b_char2int (buf[54]) << 12;
944 l |= base64b_char2int (buf[55]) << 18;
945
946 digest[34] = (l >> 16) & 0xff;
947 digest[55] = (l >> 8) & 0xff;
948 digest[13] = (l >> 0) & 0xff;
949
950 l = base64b_char2int (buf[56]) << 0;
951 l |= base64b_char2int (buf[57]) << 6;
952 l |= base64b_char2int (buf[58]) << 12;
953 l |= base64b_char2int (buf[59]) << 18;
954
955 digest[56] = (l >> 16) & 0xff;
956 digest[14] = (l >> 8) & 0xff;
957 digest[35] = (l >> 0) & 0xff;
958
959 l = base64b_char2int (buf[60]) << 0;
960 l |= base64b_char2int (buf[61]) << 6;
961 l |= base64b_char2int (buf[62]) << 12;
962 l |= base64b_char2int (buf[63]) << 18;
963
964 digest[15] = (l >> 16) & 0xff;
965 digest[36] = (l >> 8) & 0xff;
966 digest[57] = (l >> 0) & 0xff;
967
968 l = base64b_char2int (buf[64]) << 0;
969 l |= base64b_char2int (buf[65]) << 6;
970 l |= base64b_char2int (buf[66]) << 12;
971 l |= base64b_char2int (buf[67]) << 18;
972
973 digest[37] = (l >> 16) & 0xff;
974 digest[58] = (l >> 8) & 0xff;
975 digest[16] = (l >> 0) & 0xff;
976
977 l = base64b_char2int (buf[68]) << 0;
978 l |= base64b_char2int (buf[69]) << 6;
979 l |= base64b_char2int (buf[70]) << 12;
980 l |= base64b_char2int (buf[71]) << 18;
981
982 digest[59] = (l >> 16) & 0xff;
983 digest[17] = (l >> 8) & 0xff;
984 digest[38] = (l >> 0) & 0xff;
985
986 l = base64b_char2int (buf[72]) << 0;
987 l |= base64b_char2int (buf[73]) << 6;
988 l |= base64b_char2int (buf[74]) << 12;
989 l |= base64b_char2int (buf[75]) << 18;
990
991 digest[18] = (l >> 16) & 0xff;
992 digest[39] = (l >> 8) & 0xff;
993 digest[60] = (l >> 0) & 0xff;
994
995 l = base64b_char2int (buf[76]) << 0;
996 l |= base64b_char2int (buf[77]) << 6;
997 l |= base64b_char2int (buf[78]) << 12;
998 l |= base64b_char2int (buf[79]) << 18;
999
1000 digest[40] = (l >> 16) & 0xff;
1001 digest[61] = (l >> 8) & 0xff;
1002 digest[19] = (l >> 0) & 0xff;
1003
1004 l = base64b_char2int (buf[80]) << 0;
1005 l |= base64b_char2int (buf[81]) << 6;
1006 l |= base64b_char2int (buf[82]) << 12;
1007 l |= base64b_char2int (buf[83]) << 18;
1008
1009 digest[62] = (l >> 16) & 0xff;
1010 digest[20] = (l >> 8) & 0xff;
1011 digest[41] = (l >> 0) & 0xff;
1012
1013 l = base64b_char2int (buf[84]) << 0;
1014 l |= base64b_char2int (buf[85]) << 6;
1015
1016 digest[63] = (l >> 0) & 0xff;
1017 }
1018
sha512unix_encode(unsigned char digest[DIGEST_SIZE_SHA512],unsigned char buf[HASH_SIZE_SHA512UNIX])1019 void sha512unix_encode (unsigned char digest[DIGEST_SIZE_SHA512], unsigned char buf[HASH_SIZE_SHA512UNIX])
1020 {
1021 int l;
1022
1023 l = (digest[ 0] << 16) | (digest[21] << 8) | (digest[42] << 0);
1024
1025 buf[ 0] = base64b_int2char (l); l >>= 6;
1026 buf[ 1] = base64b_int2char (l); l >>= 6;
1027 buf[ 2] = base64b_int2char (l); l >>= 6;
1028 buf[ 3] = base64b_int2char (l); l >>= 6;
1029
1030 l = (digest[22] << 16) | (digest[43] << 8) | (digest[ 1] << 0);
1031
1032 buf[ 4] = base64b_int2char (l); l >>= 6;
1033 buf[ 5] = base64b_int2char (l); l >>= 6;
1034 buf[ 6] = base64b_int2char (l); l >>= 6;
1035 buf[ 7] = base64b_int2char (l); l >>= 6;
1036
1037 l = (digest[44] << 16) | (digest[ 2] << 8) | (digest[23] << 0);
1038
1039 buf[ 8] = base64b_int2char (l); l >>= 6;
1040 buf[ 9] = base64b_int2char (l); l >>= 6;
1041 buf[10] = base64b_int2char (l); l >>= 6;
1042 buf[11] = base64b_int2char (l); l >>= 6;
1043
1044 l = (digest[ 3] << 16) | (digest[24] << 8) | (digest[45] << 0);
1045
1046 buf[12] = base64b_int2char (l); l >>= 6;
1047 buf[13] = base64b_int2char (l); l >>= 6;
1048 buf[14] = base64b_int2char (l); l >>= 6;
1049 buf[15] = base64b_int2char (l); l >>= 6;
1050
1051 l = (digest[25] << 16) | (digest[46] << 8) | (digest[ 4] << 0);
1052
1053 buf[16] = base64b_int2char (l); l >>= 6;
1054 buf[17] = base64b_int2char (l); l >>= 6;
1055 buf[18] = base64b_int2char (l); l >>= 6;
1056 buf[19] = base64b_int2char (l); l >>= 6;
1057
1058 l = (digest[47] << 16) | (digest[ 5] << 8) | (digest[26] << 0);
1059
1060 buf[20] = base64b_int2char (l); l >>= 6;
1061 buf[21] = base64b_int2char (l); l >>= 6;
1062 buf[22] = base64b_int2char (l); l >>= 6;
1063 buf[23] = base64b_int2char (l); l >>= 6;
1064
1065 l = (digest[ 6] << 16) | (digest[27] << 8) | (digest[48] << 0);
1066
1067 buf[24] = base64b_int2char (l); l >>= 6;
1068 buf[25] = base64b_int2char (l); l >>= 6;
1069 buf[26] = base64b_int2char (l); l >>= 6;
1070 buf[27] = base64b_int2char (l); l >>= 6;
1071
1072 l = (digest[28] << 16) | (digest[49] << 8) | (digest[ 7] << 0);
1073
1074 buf[28] = base64b_int2char (l); l >>= 6;
1075 buf[29] = base64b_int2char (l); l >>= 6;
1076 buf[30] = base64b_int2char (l); l >>= 6;
1077 buf[31] = base64b_int2char (l); l >>= 6;
1078
1079 l = (digest[50] << 16) | (digest[ 8] << 8) | (digest[29] << 0);
1080
1081 buf[32] = base64b_int2char (l); l >>= 6;
1082 buf[33] = base64b_int2char (l); l >>= 6;
1083 buf[34] = base64b_int2char (l); l >>= 6;
1084 buf[35] = base64b_int2char (l); l >>= 6;
1085
1086 l = (digest[ 9] << 16) | (digest[30] << 8) | (digest[51] << 0);
1087
1088 buf[36] = base64b_int2char (l); l >>= 6;
1089 buf[37] = base64b_int2char (l); l >>= 6;
1090 buf[38] = base64b_int2char (l); l >>= 6;
1091 buf[39] = base64b_int2char (l); l >>= 6;
1092
1093 l = (digest[31] << 16) | (digest[52] << 8) | (digest[10] << 0);
1094
1095 buf[40] = base64b_int2char (l); l >>= 6;
1096 buf[41] = base64b_int2char (l); l >>= 6;
1097 buf[42] = base64b_int2char (l); l >>= 6;
1098 buf[43] = base64b_int2char (l); l >>= 6;
1099
1100 l = (digest[53] << 16) | (digest[11] << 8) | (digest[32] << 0);
1101
1102 buf[44] = base64b_int2char (l); l >>= 6;
1103 buf[45] = base64b_int2char (l); l >>= 6;
1104 buf[46] = base64b_int2char (l); l >>= 6;
1105 buf[47] = base64b_int2char (l); l >>= 6;
1106
1107 l = (digest[12] << 16) | (digest[33] << 8) | (digest[54] << 0);
1108
1109 buf[48] = base64b_int2char (l); l >>= 6;
1110 buf[49] = base64b_int2char (l); l >>= 6;
1111 buf[50] = base64b_int2char (l); l >>= 6;
1112 buf[51] = base64b_int2char (l); l >>= 6;
1113
1114 l = (digest[34] << 16) | (digest[55] << 8) | (digest[13] << 0);
1115
1116 buf[52] = base64b_int2char (l); l >>= 6;
1117 buf[53] = base64b_int2char (l); l >>= 6;
1118 buf[54] = base64b_int2char (l); l >>= 6;
1119 buf[55] = base64b_int2char (l); l >>= 6;
1120
1121 l = (digest[56] << 16) | (digest[14] << 8) | (digest[35] << 0);
1122
1123 buf[56] = base64b_int2char (l); l >>= 6;
1124 buf[57] = base64b_int2char (l); l >>= 6;
1125 buf[58] = base64b_int2char (l); l >>= 6;
1126 buf[59] = base64b_int2char (l); l >>= 6;
1127
1128 l = (digest[15] << 16) | (digest[36] << 8) | (digest[57] << 0);
1129
1130 buf[60] = base64b_int2char (l); l >>= 6;
1131 buf[61] = base64b_int2char (l); l >>= 6;
1132 buf[62] = base64b_int2char (l); l >>= 6;
1133 buf[63] = base64b_int2char (l); l >>= 6;
1134
1135 l = (digest[37] << 16) | (digest[58] << 8) | (digest[16] << 0);
1136
1137 buf[64] = base64b_int2char (l); l >>= 6;
1138 buf[65] = base64b_int2char (l); l >>= 6;
1139 buf[66] = base64b_int2char (l); l >>= 6;
1140 buf[67] = base64b_int2char (l); l >>= 6;
1141
1142 l = (digest[59] << 16) | (digest[17] << 8) | (digest[38] << 0);
1143
1144 buf[68] = base64b_int2char (l); l >>= 6;
1145 buf[69] = base64b_int2char (l); l >>= 6;
1146 buf[70] = base64b_int2char (l); l >>= 6;
1147 buf[71] = base64b_int2char (l); l >>= 6;
1148
1149 l = (digest[18] << 16) | (digest[39] << 8) | (digest[60] << 0);
1150
1151 buf[72] = base64b_int2char (l); l >>= 6;
1152 buf[73] = base64b_int2char (l); l >>= 6;
1153 buf[74] = base64b_int2char (l); l >>= 6;
1154 buf[75] = base64b_int2char (l); l >>= 6;
1155
1156 l = (digest[40] << 16) | (digest[61] << 8) | (digest[19] << 0);
1157
1158 buf[76] = base64b_int2char (l); l >>= 6;
1159 buf[77] = base64b_int2char (l); l >>= 6;
1160 buf[78] = base64b_int2char (l); l >>= 6;
1161 buf[79] = base64b_int2char (l); l >>= 6;
1162
1163 l = (digest[62] << 16) | (digest[20] << 8) | (digest[41] << 0);
1164
1165 buf[80] = base64b_int2char (l); l >>= 6;
1166 buf[81] = base64b_int2char (l); l >>= 6;
1167 buf[82] = base64b_int2char (l); l >>= 6;
1168 buf[83] = base64b_int2char (l); l >>= 6;
1169
1170 l = 0 | (digest[63] << 0);
1171
1172 buf[84] = base64b_int2char (l); l >>= 6;
1173 buf[85] = base64b_int2char (l); l >>= 6;
1174 }
1175
sha1b64_decode(unsigned char digest[DIGEST_SIZE_SHA1],unsigned char buf[HASH_SIZE_SHA1B64])1176 void sha1b64_decode (unsigned char digest[DIGEST_SIZE_SHA1], unsigned char buf[HASH_SIZE_SHA1B64])
1177 {
1178 int l;
1179
1180 l = base64a_char2int (buf[ 3]) << 0;
1181 l |= base64a_char2int (buf[ 2]) << 6;
1182 l |= base64a_char2int (buf[ 1]) << 12;
1183 l |= base64a_char2int (buf[ 0]) << 18;
1184
1185 digest[ 2] = (l >> 0) & 0xff;
1186 digest[ 1] = (l >> 8) & 0xff;
1187 digest[ 0] = (l >> 16) & 0xff;
1188
1189 l = base64a_char2int (buf[ 7]) << 0;
1190 l |= base64a_char2int (buf[ 6]) << 6;
1191 l |= base64a_char2int (buf[ 5]) << 12;
1192 l |= base64a_char2int (buf[ 4]) << 18;
1193
1194 digest[ 5] = (l >> 0) & 0xff;
1195 digest[ 4] = (l >> 8) & 0xff;
1196 digest[ 3] = (l >> 16) & 0xff;
1197
1198 l = base64a_char2int (buf[11]) << 0;
1199 l |= base64a_char2int (buf[10]) << 6;
1200 l |= base64a_char2int (buf[ 9]) << 12;
1201 l |= base64a_char2int (buf[ 8]) << 18;
1202
1203 digest[ 8] = (l >> 0) & 0xff;
1204 digest[ 7] = (l >> 8) & 0xff;
1205 digest[ 6] = (l >> 16) & 0xff;
1206
1207 l = base64a_char2int (buf[15]) << 0;
1208 l |= base64a_char2int (buf[14]) << 6;
1209 l |= base64a_char2int (buf[13]) << 12;
1210 l |= base64a_char2int (buf[12]) << 18;
1211
1212 digest[11] = (l >> 0) & 0xff;
1213 digest[10] = (l >> 8) & 0xff;
1214 digest[ 9] = (l >> 16) & 0xff;
1215
1216 l = base64a_char2int (buf[19]) << 0;
1217 l |= base64a_char2int (buf[18]) << 6;
1218 l |= base64a_char2int (buf[17]) << 12;
1219 l |= base64a_char2int (buf[16]) << 18;
1220
1221 digest[14] = (l >> 0) & 0xff;
1222 digest[13] = (l >> 8) & 0xff;
1223 digest[12] = (l >> 16) & 0xff;
1224
1225 l = base64a_char2int (buf[23]) << 0;
1226 l |= base64a_char2int (buf[22]) << 6;
1227 l |= base64a_char2int (buf[21]) << 12;
1228 l |= base64a_char2int (buf[20]) << 18;
1229
1230 digest[17] = (l >> 0) & 0xff;
1231 digest[16] = (l >> 8) & 0xff;
1232 digest[15] = (l >> 16) & 0xff;
1233
1234 l = 0;
1235 l |= base64a_char2int (buf[26]) << 6;
1236 l |= base64a_char2int (buf[25]) << 12;
1237 l |= base64a_char2int (buf[24]) << 18;
1238
1239 digest[19] = (l >> 8) & 0xff;
1240 digest[18] = (l >> 16) & 0xff;
1241 }
1242
sha1b64_encode(unsigned char digest[DIGEST_SIZE_SHA1],unsigned char buf[HASH_SIZE_SHA1B64])1243 void sha1b64_encode (unsigned char digest[DIGEST_SIZE_SHA1], unsigned char buf[HASH_SIZE_SHA1B64])
1244 {
1245 int l;
1246
1247 l = (digest[ 0] << 16) | (digest[ 1] << 8) | (digest[ 2] << 0);
1248
1249 buf[ 3] = base64a_int2char (l); l >>= 6;
1250 buf[ 2] = base64a_int2char (l); l >>= 6;
1251 buf[ 1] = base64a_int2char (l); l >>= 6;
1252 buf[ 0] = base64a_int2char (l);
1253
1254 l = (digest[ 3] << 16) | (digest[ 4] << 8) | (digest[ 5] << 0);
1255
1256 buf[ 7] = base64a_int2char (l); l >>= 6;
1257 buf[ 6] = base64a_int2char (l); l >>= 6;
1258 buf[ 5] = base64a_int2char (l); l >>= 6;
1259 buf[ 4] = base64a_int2char (l);
1260
1261 l = (digest[ 6] << 16) | (digest[ 7] << 8) | (digest[ 8] << 0);
1262
1263 buf[11] = base64a_int2char (l); l >>= 6;
1264 buf[10] = base64a_int2char (l); l >>= 6;
1265 buf[ 9] = base64a_int2char (l); l >>= 6;
1266 buf[ 8] = base64a_int2char (l);
1267
1268 l = (digest[ 9] << 16) | (digest[10] << 8) | (digest[11] << 0);
1269
1270 buf[15] = base64a_int2char (l); l >>= 6;
1271 buf[14] = base64a_int2char (l); l >>= 6;
1272 buf[13] = base64a_int2char (l); l >>= 6;
1273 buf[12] = base64a_int2char (l);
1274
1275 l = (digest[12] << 16) | (digest[13] << 8) | (digest[14] << 0);
1276
1277 buf[19] = base64a_int2char (l); l >>= 6;
1278 buf[18] = base64a_int2char (l); l >>= 6;
1279 buf[17] = base64a_int2char (l); l >>= 6;
1280 buf[16] = base64a_int2char (l);
1281
1282 l = (digest[15] << 16) | (digest[16] << 8) | (digest[17] << 0);
1283
1284 buf[23] = base64a_int2char (l); l >>= 6;
1285 buf[22] = base64a_int2char (l); l >>= 6;
1286 buf[21] = base64a_int2char (l); l >>= 6;
1287 buf[20] = base64a_int2char (l);
1288
1289 l = (digest[18] << 16) | (digest[19] << 8);
1290
1291 buf[27] = '='; l >>= 6;
1292 buf[26] = base64a_int2char (l); l >>= 6;
1293 buf[25] = base64a_int2char (l); l >>= 6;
1294 buf[24] = base64a_int2char (l);
1295 }
1296
sha1b64s_decode(unsigned char digest[DIGEST_SIZE_SHA1],unsigned char salt[BLOCK_SIZE],uint32_t in_len,uint32_t * out_len,char * buf)1297 void sha1b64s_decode (unsigned char digest[DIGEST_SIZE_SHA1], unsigned char salt[BLOCK_SIZE], uint32_t in_len, uint32_t *out_len, char *buf)
1298 {
1299 char tmp_buf[in_len / 4 * 3];
1300
1301 *out_len = base64_decode (base64_to_int, buf, in_len, tmp_buf);
1302
1303 memcpy (digest, tmp_buf, 20);
1304
1305 memcpy (salt, tmp_buf + 20, *out_len - 20);
1306
1307 // substract sha1 length from total output
1308 *out_len -= 20;
1309 }
1310
sha1b64s_encode(unsigned char digest[DIGEST_SIZE_SHA1],unsigned char salt[BLOCK_SIZE],uint32_t salt_len,char * buf)1311 void sha1b64s_encode (unsigned char digest[DIGEST_SIZE_SHA1], unsigned char salt[BLOCK_SIZE], uint32_t salt_len, char *buf)
1312 {
1313 char tmp_buf[20 + salt_len + 3];
1314
1315 memcpy (tmp_buf, digest, 20);
1316
1317 memcpy (tmp_buf + 20, salt, salt_len);
1318
1319 memset (tmp_buf + 20 + salt_len, 0, 3);
1320
1321 uint32_t out_len;
1322
1323 out_len = base64_encode (int_to_base64, tmp_buf, 20 + salt_len, buf);
1324
1325 buf[out_len + 1] = 0;
1326 }
1327
sha256b64_decode(unsigned char digest[DIGEST_SIZE_SHA256],unsigned char buf[HASH_SIZE_SHA256B64])1328 void sha256b64_decode (unsigned char digest[DIGEST_SIZE_SHA256], unsigned char buf[HASH_SIZE_SHA256B64])
1329 {
1330 int l;
1331
1332 l = base64a_char2int (buf[ 3]) << 0;
1333 l |= base64a_char2int (buf[ 2]) << 6;
1334 l |= base64a_char2int (buf[ 1]) << 12;
1335 l |= base64a_char2int (buf[ 0]) << 18;
1336
1337 digest[ 2] = (l >> 0) & 0xff;
1338 digest[ 1] = (l >> 8) & 0xff;
1339 digest[ 0] = (l >> 16) & 0xff;
1340
1341 l = base64a_char2int (buf[ 7]) << 0;
1342 l |= base64a_char2int (buf[ 6]) << 6;
1343 l |= base64a_char2int (buf[ 5]) << 12;
1344 l |= base64a_char2int (buf[ 4]) << 18;
1345
1346 digest[ 5] = (l >> 0) & 0xff;
1347 digest[ 4] = (l >> 8) & 0xff;
1348 digest[ 3] = (l >> 16) & 0xff;
1349
1350 l = base64a_char2int (buf[11]) << 0;
1351 l |= base64a_char2int (buf[10]) << 6;
1352 l |= base64a_char2int (buf[ 9]) << 12;
1353 l |= base64a_char2int (buf[ 8]) << 18;
1354
1355 digest[ 8] = (l >> 0) & 0xff;
1356 digest[ 7] = (l >> 8) & 0xff;
1357 digest[ 6] = (l >> 16) & 0xff;
1358
1359 l = base64a_char2int (buf[15]) << 0;
1360 l |= base64a_char2int (buf[14]) << 6;
1361 l |= base64a_char2int (buf[13]) << 12;
1362 l |= base64a_char2int (buf[12]) << 18;
1363
1364 digest[11] = (l >> 0) & 0xff;
1365 digest[10] = (l >> 8) & 0xff;
1366 digest[ 9] = (l >> 16) & 0xff;
1367
1368 l = base64a_char2int (buf[19]) << 0;
1369 l |= base64a_char2int (buf[18]) << 6;
1370 l |= base64a_char2int (buf[17]) << 12;
1371 l |= base64a_char2int (buf[16]) << 18;
1372
1373 digest[14] = (l >> 0) & 0xff;
1374 digest[13] = (l >> 8) & 0xff;
1375 digest[12] = (l >> 16) & 0xff;
1376
1377 l = base64a_char2int (buf[23]) << 0;
1378 l |= base64a_char2int (buf[22]) << 6;
1379 l |= base64a_char2int (buf[21]) << 12;
1380 l |= base64a_char2int (buf[20]) << 18;
1381
1382 digest[17] = (l >> 0) & 0xff;
1383 digest[16] = (l >> 8) & 0xff;
1384 digest[15] = (l >> 16) & 0xff;
1385
1386 l = base64a_char2int (buf[27]) << 0;
1387 l |= base64a_char2int (buf[26]) << 6;
1388 l |= base64a_char2int (buf[25]) << 12;
1389 l |= base64a_char2int (buf[24]) << 18;
1390
1391 digest[20] = (l >> 0) & 0xff;
1392 digest[19] = (l >> 8) & 0xff;
1393 digest[18] = (l >> 16) & 0xff;
1394
1395 l = base64a_char2int (buf[31]) << 0;
1396 l |= base64a_char2int (buf[30]) << 6;
1397 l |= base64a_char2int (buf[29]) << 12;
1398 l |= base64a_char2int (buf[28]) << 18;
1399
1400 digest[23] = (l >> 0) & 0xff;
1401 digest[22] = (l >> 8) & 0xff;
1402 digest[21] = (l >> 16) & 0xff;
1403
1404 l = base64a_char2int (buf[35]) << 0;
1405 l |= base64a_char2int (buf[34]) << 6;
1406 l |= base64a_char2int (buf[33]) << 12;
1407 l |= base64a_char2int (buf[32]) << 18;
1408
1409 digest[26] = (l >> 0) & 0xff;
1410 digest[25] = (l >> 8) & 0xff;
1411 digest[24] = (l >> 16) & 0xff;
1412
1413 l = base64a_char2int (buf[39]) << 0;
1414 l |= base64a_char2int (buf[38]) << 6;
1415 l |= base64a_char2int (buf[37]) << 12;
1416 l |= base64a_char2int (buf[36]) << 18;
1417
1418 digest[29] = (l >> 0) & 0xff;
1419 digest[28] = (l >> 8) & 0xff;
1420 digest[27] = (l >> 16) & 0xff;
1421
1422 l = 0;
1423 l |= base64a_char2int (buf[42]) << 6;
1424 l |= base64a_char2int (buf[41]) << 12;
1425 l |= base64a_char2int (buf[40]) << 18;
1426
1427 digest[32] = (l >> 0) & 0xff;
1428 digest[31] = (l >> 8) & 0xff;
1429 digest[30] = (l >> 16) & 0xff;
1430 }
1431
sha256b64_encode(unsigned char digest[DIGEST_SIZE_SHA256],unsigned char buf[HASH_SIZE_SHA256B64])1432 void sha256b64_encode (unsigned char digest[DIGEST_SIZE_SHA256], unsigned char buf[HASH_SIZE_SHA256B64])
1433 {
1434 int l;
1435
1436 l = (digest[ 0] << 16) | (digest[ 1] << 8) | (digest[ 2] << 0);
1437
1438 buf[ 3] = base64a_int2char (l); l >>= 6;
1439 buf[ 2] = base64a_int2char (l); l >>= 6;
1440 buf[ 1] = base64a_int2char (l); l >>= 6;
1441 buf[ 0] = base64a_int2char (l);
1442
1443 l = (digest[ 3] << 16) | (digest[ 4] << 8) | (digest[ 5] << 0);
1444
1445 buf[ 7] = base64a_int2char (l); l >>= 6;
1446 buf[ 6] = base64a_int2char (l); l >>= 6;
1447 buf[ 5] = base64a_int2char (l); l >>= 6;
1448 buf[ 4] = base64a_int2char (l);
1449
1450 l = (digest[ 6] << 16) | (digest[ 7] << 8) | (digest[ 8] << 0);
1451
1452 buf[11] = base64a_int2char (l); l >>= 6;
1453 buf[10] = base64a_int2char (l); l >>= 6;
1454 buf[ 9] = base64a_int2char (l); l >>= 6;
1455 buf[ 8] = base64a_int2char (l);
1456
1457 l = (digest[ 9] << 16) | (digest[10] << 8) | (digest[11] << 0);
1458
1459 buf[15] = base64a_int2char (l); l >>= 6;
1460 buf[14] = base64a_int2char (l); l >>= 6;
1461 buf[13] = base64a_int2char (l); l >>= 6;
1462 buf[12] = base64a_int2char (l);
1463
1464 l = (digest[12] << 16) | (digest[13] << 8) | (digest[14] << 0);
1465
1466 buf[19] = base64a_int2char (l); l >>= 6;
1467 buf[18] = base64a_int2char (l); l >>= 6;
1468 buf[17] = base64a_int2char (l); l >>= 6;
1469 buf[16] = base64a_int2char (l);
1470
1471 l = (digest[15] << 16) | (digest[16] << 8) | (digest[17] << 0);
1472
1473 buf[23] = base64a_int2char (l); l >>= 6;
1474 buf[22] = base64a_int2char (l); l >>= 6;
1475 buf[21] = base64a_int2char (l); l >>= 6;
1476 buf[20] = base64a_int2char (l);
1477
1478 l = (digest[18] << 16) | (digest[19] << 8) | (digest[20] << 0);
1479
1480 buf[27] = base64a_int2char (l); l >>= 6;
1481 buf[26] = base64a_int2char (l); l >>= 6;
1482 buf[25] = base64a_int2char (l); l >>= 6;
1483 buf[24] = base64a_int2char (l);
1484
1485 l = (digest[21] << 16) | (digest[22] << 8) | (digest[23] << 0);
1486
1487 buf[31] = base64a_int2char (l); l >>= 6;
1488 buf[30] = base64a_int2char (l); l >>= 6;
1489 buf[29] = base64a_int2char (l); l >>= 6;
1490 buf[28] = base64a_int2char (l);
1491
1492 l = (digest[24] << 16) | (digest[25] << 8) | (digest[26] << 0);
1493
1494 buf[35] = base64a_int2char (l); l >>= 6;
1495 buf[34] = base64a_int2char (l); l >>= 6;
1496 buf[33] = base64a_int2char (l); l >>= 6;
1497 buf[32] = base64a_int2char (l);
1498
1499 l = (digest[27] << 16) | (digest[28] << 8) | (digest[29] << 0);
1500
1501 buf[39] = base64a_int2char (l); l >>= 6;
1502 buf[38] = base64a_int2char (l); l >>= 6;
1503 buf[37] = base64a_int2char (l); l >>= 6;
1504 buf[36] = base64a_int2char (l);
1505
1506 l = (digest[30] << 16) | (digest[31] << 8) | (digest[32] << 0);
1507
1508 buf[43] = '='; l >>= 6;
1509 buf[42] = base64a_int2char (l); l >>= 6;
1510 buf[41] = base64a_int2char (l); l >>= 6;
1511 buf[40] = base64a_int2char (l);
1512 }
1513
sha1aix_decode(unsigned char digest[DIGEST_SIZE_SHA1],unsigned char buf[HASH_SIZE_SHA1AIX])1514 void sha1aix_decode (unsigned char digest[DIGEST_SIZE_SHA1], unsigned char buf[HASH_SIZE_SHA1AIX])
1515 {
1516 int l;
1517
1518 l = base64b_char2int (buf[ 0]) << 0;
1519 l |= base64b_char2int (buf[ 1]) << 6;
1520 l |= base64b_char2int (buf[ 2]) << 12;
1521 l |= base64b_char2int (buf[ 3]) << 18;
1522
1523 digest[ 2] = (l >> 0) & 0xff;
1524 digest[ 1] = (l >> 8) & 0xff;
1525 digest[ 0] = (l >> 16) & 0xff;
1526
1527 l = base64b_char2int (buf[ 4]) << 0;
1528 l |= base64b_char2int (buf[ 5]) << 6;
1529 l |= base64b_char2int (buf[ 6]) << 12;
1530 l |= base64b_char2int (buf[ 7]) << 18;
1531
1532 digest[ 5] = (l >> 0) & 0xff;
1533 digest[ 4] = (l >> 8) & 0xff;
1534 digest[ 3] = (l >> 16) & 0xff;
1535
1536 l = base64b_char2int (buf[ 8]) << 0;
1537 l |= base64b_char2int (buf[ 9]) << 6;
1538 l |= base64b_char2int (buf[10]) << 12;
1539 l |= base64b_char2int (buf[11]) << 18;
1540
1541 digest[ 8] = (l >> 0) & 0xff;
1542 digest[ 7] = (l >> 8) & 0xff;
1543 digest[ 6] = (l >> 16) & 0xff;
1544
1545 l = base64b_char2int (buf[12]) << 0;
1546 l |= base64b_char2int (buf[13]) << 6;
1547 l |= base64b_char2int (buf[14]) << 12;
1548 l |= base64b_char2int (buf[15]) << 18;
1549
1550 digest[11] = (l >> 0) & 0xff;
1551 digest[10] = (l >> 8) & 0xff;
1552 digest[ 9] = (l >> 16) & 0xff;
1553
1554 l = base64b_char2int (buf[16]) << 0;
1555 l |= base64b_char2int (buf[17]) << 6;
1556 l |= base64b_char2int (buf[18]) << 12;
1557 l |= base64b_char2int (buf[19]) << 18;
1558
1559 digest[14] = (l >> 0) & 0xff;
1560 digest[13] = (l >> 8) & 0xff;
1561 digest[12] = (l >> 16) & 0xff;
1562
1563 l = base64b_char2int (buf[20]) << 0;
1564 l |= base64b_char2int (buf[21]) << 6;
1565 l |= base64b_char2int (buf[22]) << 12;
1566 l |= base64b_char2int (buf[23]) << 18;
1567
1568 digest[17] = (l >> 0) & 0xff;
1569 digest[16] = (l >> 8) & 0xff;
1570 digest[15] = (l >> 16) & 0xff;
1571
1572 l = base64b_char2int (buf[24]) << 0;
1573 l |= base64b_char2int (buf[25]) << 6;
1574 l |= base64b_char2int (buf[26]) << 12;
1575
1576 digest[19] = (l >> 8) & 0xff;
1577 digest[18] = (l >> 16) & 0xff;
1578 }
1579
sha1aix_encode(unsigned char digest[DIGEST_SIZE_SHA1],unsigned char buf[HASH_SIZE_SHA1AIX])1580 void sha1aix_encode (unsigned char digest[DIGEST_SIZE_SHA1], unsigned char buf[HASH_SIZE_SHA1AIX])
1581 {
1582 int l;
1583
1584 l = (digest[ 2] << 0) | (digest[ 1] << 8) | (digest[ 0] << 16);
1585
1586 buf[ 0] = base64b_int2char (l); l >>= 6;
1587 buf[ 1] = base64b_int2char (l); l >>= 6;
1588 buf[ 2] = base64b_int2char (l); l >>= 6;
1589 buf[ 3] = base64b_int2char (l);
1590
1591 l = (digest[ 5] << 0) | (digest[ 4] << 8) | (digest[ 3] << 16);
1592
1593 buf[ 4] = base64b_int2char (l); l >>= 6;
1594 buf[ 5] = base64b_int2char (l); l >>= 6;
1595 buf[ 6] = base64b_int2char (l); l >>= 6;
1596 buf[ 7] = base64b_int2char (l);
1597
1598 l = (digest[ 8] << 0) | (digest[ 7] << 8) | (digest[ 6] << 16);
1599
1600 buf[ 8] = base64b_int2char (l); l >>= 6;
1601 buf[ 9] = base64b_int2char (l); l >>= 6;
1602 buf[10] = base64b_int2char (l); l >>= 6;
1603 buf[11] = base64b_int2char (l);
1604
1605 l = (digest[11] << 0) | (digest[10] << 8) | (digest[ 9] << 16);
1606
1607 buf[12] = base64b_int2char (l); l >>= 6;
1608 buf[13] = base64b_int2char (l); l >>= 6;
1609 buf[14] = base64b_int2char (l); l >>= 6;
1610 buf[15] = base64b_int2char (l);
1611
1612 l = (digest[14] << 0) | (digest[13] << 8) | (digest[12] << 16);
1613
1614 buf[16] = base64b_int2char (l); l >>= 6;
1615 buf[17] = base64b_int2char (l); l >>= 6;
1616 buf[18] = base64b_int2char (l); l >>= 6;
1617 buf[19] = base64b_int2char (l);
1618
1619 l = (digest[17] << 0) | (digest[16] << 8) | (digest[15] << 16);
1620
1621 buf[20] = base64b_int2char (l); l >>= 6;
1622 buf[21] = base64b_int2char (l); l >>= 6;
1623 buf[22] = base64b_int2char (l); l >>= 6;
1624 buf[23] = base64b_int2char (l);
1625
1626 l = 0 | (digest[19] << 8) | (digest[18] << 16);
1627
1628 buf[24] = base64b_int2char (l); l >>= 6;
1629 buf[25] = base64b_int2char (l); l >>= 6;
1630 buf[26] = base64b_int2char (l);
1631 }
1632
sha256aix_decode(unsigned char digest[DIGEST_SIZE_SHA256],unsigned char buf[HASH_SIZE_SHA256AIX])1633 void sha256aix_decode (unsigned char digest[DIGEST_SIZE_SHA256], unsigned char buf[HASH_SIZE_SHA256AIX])
1634 {
1635 int l;
1636
1637 l = base64b_char2int (buf[ 0]) << 0;
1638 l |= base64b_char2int (buf[ 1]) << 6;
1639 l |= base64b_char2int (buf[ 2]) << 12;
1640 l |= base64b_char2int (buf[ 3]) << 18;
1641
1642 digest[ 2] = (l >> 0) & 0xff;
1643 digest[ 1] = (l >> 8) & 0xff;
1644 digest[ 0] = (l >> 16) & 0xff;
1645
1646 l = base64b_char2int (buf[ 4]) << 0;
1647 l |= base64b_char2int (buf[ 5]) << 6;
1648 l |= base64b_char2int (buf[ 6]) << 12;
1649 l |= base64b_char2int (buf[ 7]) << 18;
1650
1651 digest[ 5] = (l >> 0) & 0xff;
1652 digest[ 4] = (l >> 8) & 0xff;
1653 digest[ 3] = (l >> 16) & 0xff;
1654
1655 l = base64b_char2int (buf[ 8]) << 0;
1656 l |= base64b_char2int (buf[ 9]) << 6;
1657 l |= base64b_char2int (buf[10]) << 12;
1658 l |= base64b_char2int (buf[11]) << 18;
1659
1660 digest[ 8] = (l >> 0) & 0xff;
1661 digest[ 7] = (l >> 8) & 0xff;
1662 digest[ 6] = (l >> 16) & 0xff;
1663
1664 l = base64b_char2int (buf[12]) << 0;
1665 l |= base64b_char2int (buf[13]) << 6;
1666 l |= base64b_char2int (buf[14]) << 12;
1667 l |= base64b_char2int (buf[15]) << 18;
1668
1669 digest[11] = (l >> 0) & 0xff;
1670 digest[10] = (l >> 8) & 0xff;
1671 digest[ 9] = (l >> 16) & 0xff;
1672
1673 l = base64b_char2int (buf[16]) << 0;
1674 l |= base64b_char2int (buf[17]) << 6;
1675 l |= base64b_char2int (buf[18]) << 12;
1676 l |= base64b_char2int (buf[19]) << 18;
1677
1678 digest[14] = (l >> 0) & 0xff;
1679 digest[13] = (l >> 8) & 0xff;
1680 digest[12] = (l >> 16) & 0xff;
1681
1682 l = base64b_char2int (buf[20]) << 0;
1683 l |= base64b_char2int (buf[21]) << 6;
1684 l |= base64b_char2int (buf[22]) << 12;
1685 l |= base64b_char2int (buf[23]) << 18;
1686
1687 digest[17] = (l >> 0) & 0xff;
1688 digest[16] = (l >> 8) & 0xff;
1689 digest[15] = (l >> 16) & 0xff;
1690
1691 l = base64b_char2int (buf[24]) << 0;
1692 l |= base64b_char2int (buf[25]) << 6;
1693 l |= base64b_char2int (buf[26]) << 12;
1694 l |= base64b_char2int (buf[27]) << 18;
1695
1696 digest[20] = (l >> 0) & 0xff;
1697 digest[19] = (l >> 8) & 0xff;
1698 digest[18] = (l >> 16) & 0xff;
1699
1700 l = base64b_char2int (buf[28]) << 0;
1701 l |= base64b_char2int (buf[29]) << 6;
1702 l |= base64b_char2int (buf[30]) << 12;
1703 l |= base64b_char2int (buf[31]) << 18;
1704
1705 digest[23] = (l >> 0) & 0xff;
1706 digest[22] = (l >> 8) & 0xff;
1707 digest[21] = (l >> 16) & 0xff;
1708
1709 l = base64b_char2int (buf[32]) << 0;
1710 l |= base64b_char2int (buf[33]) << 6;
1711 l |= base64b_char2int (buf[34]) << 12;
1712 l |= base64b_char2int (buf[35]) << 18;
1713
1714 digest[26] = (l >> 0) & 0xff;
1715 digest[25] = (l >> 8) & 0xff;
1716 digest[24] = (l >> 16) & 0xff;
1717
1718 l = base64b_char2int (buf[36]) << 0;
1719 l |= base64b_char2int (buf[37]) << 6;
1720 l |= base64b_char2int (buf[38]) << 12;
1721 l |= base64b_char2int (buf[39]) << 18;
1722
1723 digest[29] = (l >> 0) & 0xff;
1724 digest[28] = (l >> 8) & 0xff;
1725 digest[27] = (l >> 16) & 0xff;
1726
1727 l = base64b_char2int (buf[40]) << 0;
1728 l |= base64b_char2int (buf[41]) << 6;
1729 l |= base64b_char2int (buf[42]) << 12;
1730
1731 //digest[32] = (l >> 0) & 0xff;
1732 digest[31] = (l >> 8) & 0xff;
1733 digest[30] = (l >> 16) & 0xff;
1734 }
1735
sha256aix_encode(unsigned char digest[DIGEST_SIZE_SHA256],unsigned char buf[HASH_SIZE_SHA256AIX])1736 void sha256aix_encode (unsigned char digest[DIGEST_SIZE_SHA256], unsigned char buf[HASH_SIZE_SHA256AIX])
1737 {
1738 int l;
1739
1740 l = (digest[ 2] << 0) | (digest[ 1] << 8) | (digest[ 0] << 16);
1741
1742 buf[ 0] = base64b_int2char (l); l >>= 6;
1743 buf[ 1] = base64b_int2char (l); l >>= 6;
1744 buf[ 2] = base64b_int2char (l); l >>= 6;
1745 buf[ 3] = base64b_int2char (l);
1746
1747 l = (digest[ 5] << 0) | (digest[ 4] << 8) | (digest[ 3] << 16);
1748
1749 buf[ 4] = base64b_int2char (l); l >>= 6;
1750 buf[ 5] = base64b_int2char (l); l >>= 6;
1751 buf[ 6] = base64b_int2char (l); l >>= 6;
1752 buf[ 7] = base64b_int2char (l);
1753
1754 l = (digest[ 8] << 0) | (digest[ 7] << 8) | (digest[ 6] << 16);
1755
1756 buf[ 8] = base64b_int2char (l); l >>= 6;
1757 buf[ 9] = base64b_int2char (l); l >>= 6;
1758 buf[10] = base64b_int2char (l); l >>= 6;
1759 buf[11] = base64b_int2char (l);
1760
1761 l = (digest[11] << 0) | (digest[10] << 8) | (digest[ 9] << 16);
1762
1763 buf[12] = base64b_int2char (l); l >>= 6;
1764 buf[13] = base64b_int2char (l); l >>= 6;
1765 buf[14] = base64b_int2char (l); l >>= 6;
1766 buf[15] = base64b_int2char (l);
1767
1768 l = (digest[14] << 0) | (digest[13] << 8) | (digest[12] << 16);
1769
1770 buf[16] = base64b_int2char (l); l >>= 6;
1771 buf[17] = base64b_int2char (l); l >>= 6;
1772 buf[18] = base64b_int2char (l); l >>= 6;
1773 buf[19] = base64b_int2char (l);
1774
1775 l = (digest[17] << 0) | (digest[16] << 8) | (digest[15] << 16);
1776
1777 buf[20] = base64b_int2char (l); l >>= 6;
1778 buf[21] = base64b_int2char (l); l >>= 6;
1779 buf[22] = base64b_int2char (l); l >>= 6;
1780 buf[23] = base64b_int2char (l);
1781
1782 l = (digest[20] << 0) | (digest[19] << 8) | (digest[18] << 16);
1783
1784 buf[24] = base64b_int2char (l); l >>= 6;
1785 buf[25] = base64b_int2char (l); l >>= 6;
1786 buf[26] = base64b_int2char (l); l >>= 6;
1787 buf[27] = base64b_int2char (l);
1788
1789 l = (digest[23] << 0) | (digest[22] << 8) | (digest[21] << 16);
1790
1791 buf[28] = base64b_int2char (l); l >>= 6;
1792 buf[29] = base64b_int2char (l); l >>= 6;
1793 buf[30] = base64b_int2char (l); l >>= 6;
1794 buf[31] = base64b_int2char (l);
1795
1796 l = (digest[26] << 0) | (digest[25] << 8) | (digest[24] << 16);
1797
1798 buf[32] = base64b_int2char (l); l >>= 6;
1799 buf[33] = base64b_int2char (l); l >>= 6;
1800 buf[34] = base64b_int2char (l); l >>= 6;
1801 buf[35] = base64b_int2char (l);
1802
1803 l = (digest[29] << 0) | (digest[28] << 8) | (digest[27] << 16);
1804
1805 buf[36] = base64b_int2char (l); l >>= 6;
1806 buf[37] = base64b_int2char (l); l >>= 6;
1807 buf[38] = base64b_int2char (l); l >>= 6;
1808 buf[39] = base64b_int2char (l);
1809
1810 l = 0 | (digest[31] << 8) | (digest[30] << 16);
1811
1812 buf[40] = base64b_int2char (l); l >>= 6;
1813 buf[41] = base64b_int2char (l); l >>= 6;
1814 buf[42] = base64b_int2char (l);
1815 }
1816
sha512aix_decode(unsigned char digest[DIGEST_SIZE_SHA512],unsigned char buf[HASH_SIZE_SHA512AIX])1817 void sha512aix_decode (unsigned char digest[DIGEST_SIZE_SHA512], unsigned char buf[HASH_SIZE_SHA512AIX])
1818 {
1819 int l;
1820
1821 l = base64b_char2int (buf[ 0]) << 0;
1822 l |= base64b_char2int (buf[ 1]) << 6;
1823 l |= base64b_char2int (buf[ 2]) << 12;
1824 l |= base64b_char2int (buf[ 3]) << 18;
1825
1826 digest[ 2] = (l >> 0) & 0xff;
1827 digest[ 1] = (l >> 8) & 0xff;
1828 digest[ 0] = (l >> 16) & 0xff;
1829
1830 l = base64b_char2int (buf[ 4]) << 0;
1831 l |= base64b_char2int (buf[ 5]) << 6;
1832 l |= base64b_char2int (buf[ 6]) << 12;
1833 l |= base64b_char2int (buf[ 7]) << 18;
1834
1835 digest[ 5] = (l >> 0) & 0xff;
1836 digest[ 4] = (l >> 8) & 0xff;
1837 digest[ 3] = (l >> 16) & 0xff;
1838
1839 l = base64b_char2int (buf[ 8]) << 0;
1840 l |= base64b_char2int (buf[ 9]) << 6;
1841 l |= base64b_char2int (buf[10]) << 12;
1842 l |= base64b_char2int (buf[11]) << 18;
1843
1844 digest[ 8] = (l >> 0) & 0xff;
1845 digest[ 7] = (l >> 8) & 0xff;
1846 digest[ 6] = (l >> 16) & 0xff;
1847
1848 l = base64b_char2int (buf[12]) << 0;
1849 l |= base64b_char2int (buf[13]) << 6;
1850 l |= base64b_char2int (buf[14]) << 12;
1851 l |= base64b_char2int (buf[15]) << 18;
1852
1853 digest[11] = (l >> 0) & 0xff;
1854 digest[10] = (l >> 8) & 0xff;
1855 digest[ 9] = (l >> 16) & 0xff;
1856
1857 l = base64b_char2int (buf[16]) << 0;
1858 l |= base64b_char2int (buf[17]) << 6;
1859 l |= base64b_char2int (buf[18]) << 12;
1860 l |= base64b_char2int (buf[19]) << 18;
1861
1862 digest[14] = (l >> 0) & 0xff;
1863 digest[13] = (l >> 8) & 0xff;
1864 digest[12] = (l >> 16) & 0xff;
1865
1866 l = base64b_char2int (buf[20]) << 0;
1867 l |= base64b_char2int (buf[21]) << 6;
1868 l |= base64b_char2int (buf[22]) << 12;
1869 l |= base64b_char2int (buf[23]) << 18;
1870
1871 digest[17] = (l >> 0) & 0xff;
1872 digest[16] = (l >> 8) & 0xff;
1873 digest[15] = (l >> 16) & 0xff;
1874
1875 l = base64b_char2int (buf[24]) << 0;
1876 l |= base64b_char2int (buf[25]) << 6;
1877 l |= base64b_char2int (buf[26]) << 12;
1878 l |= base64b_char2int (buf[27]) << 18;
1879
1880 digest[20] = (l >> 0) & 0xff;
1881 digest[19] = (l >> 8) & 0xff;
1882 digest[18] = (l >> 16) & 0xff;
1883
1884 l = base64b_char2int (buf[28]) << 0;
1885 l |= base64b_char2int (buf[29]) << 6;
1886 l |= base64b_char2int (buf[30]) << 12;
1887 l |= base64b_char2int (buf[31]) << 18;
1888
1889 digest[23] = (l >> 0) & 0xff;
1890 digest[22] = (l >> 8) & 0xff;
1891 digest[21] = (l >> 16) & 0xff;
1892
1893 l = base64b_char2int (buf[32]) << 0;
1894 l |= base64b_char2int (buf[33]) << 6;
1895 l |= base64b_char2int (buf[34]) << 12;
1896 l |= base64b_char2int (buf[35]) << 18;
1897
1898 digest[26] = (l >> 0) & 0xff;
1899 digest[25] = (l >> 8) & 0xff;
1900 digest[24] = (l >> 16) & 0xff;
1901
1902 l = base64b_char2int (buf[36]) << 0;
1903 l |= base64b_char2int (buf[37]) << 6;
1904 l |= base64b_char2int (buf[38]) << 12;
1905 l |= base64b_char2int (buf[39]) << 18;
1906
1907 digest[29] = (l >> 0) & 0xff;
1908 digest[28] = (l >> 8) & 0xff;
1909 digest[27] = (l >> 16) & 0xff;
1910
1911 l = base64b_char2int (buf[40]) << 0;
1912 l |= base64b_char2int (buf[41]) << 6;
1913 l |= base64b_char2int (buf[42]) << 12;
1914 l |= base64b_char2int (buf[43]) << 18;
1915
1916 digest[32] = (l >> 0) & 0xff;
1917 digest[31] = (l >> 8) & 0xff;
1918 digest[30] = (l >> 16) & 0xff;
1919
1920 l = base64b_char2int (buf[44]) << 0;
1921 l |= base64b_char2int (buf[45]) << 6;
1922 l |= base64b_char2int (buf[46]) << 12;
1923 l |= base64b_char2int (buf[47]) << 18;
1924
1925 digest[35] = (l >> 0) & 0xff;
1926 digest[34] = (l >> 8) & 0xff;
1927 digest[33] = (l >> 16) & 0xff;
1928
1929 l = base64b_char2int (buf[48]) << 0;
1930 l |= base64b_char2int (buf[49]) << 6;
1931 l |= base64b_char2int (buf[50]) << 12;
1932 l |= base64b_char2int (buf[51]) << 18;
1933
1934 digest[38] = (l >> 0) & 0xff;
1935 digest[37] = (l >> 8) & 0xff;
1936 digest[36] = (l >> 16) & 0xff;
1937
1938 l = base64b_char2int (buf[52]) << 0;
1939 l |= base64b_char2int (buf[53]) << 6;
1940 l |= base64b_char2int (buf[54]) << 12;
1941 l |= base64b_char2int (buf[55]) << 18;
1942
1943 digest[41] = (l >> 0) & 0xff;
1944 digest[40] = (l >> 8) & 0xff;
1945 digest[39] = (l >> 16) & 0xff;
1946
1947 l = base64b_char2int (buf[56]) << 0;
1948 l |= base64b_char2int (buf[57]) << 6;
1949 l |= base64b_char2int (buf[58]) << 12;
1950 l |= base64b_char2int (buf[59]) << 18;
1951
1952 digest[44] = (l >> 0) & 0xff;
1953 digest[43] = (l >> 8) & 0xff;
1954 digest[42] = (l >> 16) & 0xff;
1955
1956 l = base64b_char2int (buf[60]) << 0;
1957 l |= base64b_char2int (buf[61]) << 6;
1958 l |= base64b_char2int (buf[62]) << 12;
1959 l |= base64b_char2int (buf[63]) << 18;
1960
1961 digest[47] = (l >> 0) & 0xff;
1962 digest[46] = (l >> 8) & 0xff;
1963 digest[45] = (l >> 16) & 0xff;
1964
1965 l = base64b_char2int (buf[64]) << 0;
1966 l |= base64b_char2int (buf[65]) << 6;
1967 l |= base64b_char2int (buf[66]) << 12;
1968 l |= base64b_char2int (buf[67]) << 18;
1969
1970 digest[50] = (l >> 0) & 0xff;
1971 digest[49] = (l >> 8) & 0xff;
1972 digest[48] = (l >> 16) & 0xff;
1973
1974 l = base64b_char2int (buf[68]) << 0;
1975 l |= base64b_char2int (buf[69]) << 6;
1976 l |= base64b_char2int (buf[70]) << 12;
1977 l |= base64b_char2int (buf[71]) << 18;
1978
1979 digest[53] = (l >> 0) & 0xff;
1980 digest[52] = (l >> 8) & 0xff;
1981 digest[51] = (l >> 16) & 0xff;
1982
1983 l = base64b_char2int (buf[72]) << 0;
1984 l |= base64b_char2int (buf[73]) << 6;
1985 l |= base64b_char2int (buf[74]) << 12;
1986 l |= base64b_char2int (buf[75]) << 18;
1987
1988 digest[56] = (l >> 0) & 0xff;
1989 digest[55] = (l >> 8) & 0xff;
1990 digest[54] = (l >> 16) & 0xff;
1991
1992 l = base64b_char2int (buf[76]) << 0;
1993 l |= base64b_char2int (buf[77]) << 6;
1994 l |= base64b_char2int (buf[78]) << 12;
1995 l |= base64b_char2int (buf[79]) << 18;
1996
1997 digest[59] = (l >> 0) & 0xff;
1998 digest[58] = (l >> 8) & 0xff;
1999 digest[57] = (l >> 16) & 0xff;
2000
2001 l = base64b_char2int (buf[80]) << 0;
2002 l |= base64b_char2int (buf[81]) << 6;
2003 l |= base64b_char2int (buf[82]) << 12;
2004 l |= base64b_char2int (buf[83]) << 18;
2005
2006 digest[62] = (l >> 0) & 0xff;
2007 digest[61] = (l >> 8) & 0xff;
2008 digest[60] = (l >> 16) & 0xff;
2009
2010 l = base64b_char2int (buf[84]) << 0;
2011 l |= base64b_char2int (buf[85]) << 6;
2012
2013 digest[63] = (l >> 16) & 0xff;
2014 }
2015
sha512aix_encode(unsigned char digest[DIGEST_SIZE_SHA512],unsigned char buf[HASH_SIZE_SHA512AIX])2016 void sha512aix_encode (unsigned char digest[DIGEST_SIZE_SHA512], unsigned char buf[HASH_SIZE_SHA512AIX])
2017 {
2018 int l;
2019
2020 l = (digest[ 2] << 0) | (digest[ 1] << 8) | (digest[ 0] << 16);
2021
2022 buf[ 0] = base64b_int2char (l); l >>= 6;
2023 buf[ 1] = base64b_int2char (l); l >>= 6;
2024 buf[ 2] = base64b_int2char (l); l >>= 6;
2025 buf[ 3] = base64b_int2char (l);
2026
2027 l = (digest[ 5] << 0) | (digest[ 4] << 8) | (digest[ 3] << 16);
2028
2029 buf[ 4] = base64b_int2char (l); l >>= 6;
2030 buf[ 5] = base64b_int2char (l); l >>= 6;
2031 buf[ 6] = base64b_int2char (l); l >>= 6;
2032 buf[ 7] = base64b_int2char (l);
2033
2034 l = (digest[ 8] << 0) | (digest[ 7] << 8) | (digest[ 6] << 16);
2035
2036 buf[ 8] = base64b_int2char (l); l >>= 6;
2037 buf[ 9] = base64b_int2char (l); l >>= 6;
2038 buf[10] = base64b_int2char (l); l >>= 6;
2039 buf[11] = base64b_int2char (l);
2040
2041 l = (digest[11] << 0) | (digest[10] << 8) | (digest[ 9] << 16);
2042
2043 buf[12] = base64b_int2char (l); l >>= 6;
2044 buf[13] = base64b_int2char (l); l >>= 6;
2045 buf[14] = base64b_int2char (l); l >>= 6;
2046 buf[15] = base64b_int2char (l);
2047
2048 l = (digest[14] << 0) | (digest[13] << 8) | (digest[12] << 16);
2049
2050 buf[16] = base64b_int2char (l); l >>= 6;
2051 buf[17] = base64b_int2char (l); l >>= 6;
2052 buf[18] = base64b_int2char (l); l >>= 6;
2053 buf[19] = base64b_int2char (l);
2054
2055 l = (digest[17] << 0) | (digest[16] << 8) | (digest[15] << 16);
2056
2057 buf[20] = base64b_int2char (l); l >>= 6;
2058 buf[21] = base64b_int2char (l); l >>= 6;
2059 buf[22] = base64b_int2char (l); l >>= 6;
2060 buf[23] = base64b_int2char (l);
2061
2062 l = (digest[20] << 0) | (digest[19] << 8) | (digest[18] << 16);
2063
2064 buf[24] = base64b_int2char (l); l >>= 6;
2065 buf[25] = base64b_int2char (l); l >>= 6;
2066 buf[26] = base64b_int2char (l); l >>= 6;
2067 buf[27] = base64b_int2char (l);
2068
2069 l = (digest[23] << 0) | (digest[22] << 8) | (digest[21] << 16);
2070
2071 buf[28] = base64b_int2char (l); l >>= 6;
2072 buf[29] = base64b_int2char (l); l >>= 6;
2073 buf[30] = base64b_int2char (l); l >>= 6;
2074 buf[31] = base64b_int2char (l);
2075
2076 l = (digest[26] << 0) | (digest[25] << 8) | (digest[24] << 16);
2077
2078 buf[32] = base64b_int2char (l); l >>= 6;
2079 buf[33] = base64b_int2char (l); l >>= 6;
2080 buf[34] = base64b_int2char (l); l >>= 6;
2081 buf[35] = base64b_int2char (l);
2082
2083 l = (digest[29] << 0) | (digest[28] << 8) | (digest[27] << 16);
2084
2085 buf[36] = base64b_int2char (l); l >>= 6;
2086 buf[37] = base64b_int2char (l); l >>= 6;
2087 buf[38] = base64b_int2char (l); l >>= 6;
2088 buf[39] = base64b_int2char (l);
2089
2090 l = (digest[32] << 0) | (digest[31] << 8) | (digest[30] << 16);
2091
2092 buf[40] = base64b_int2char (l); l >>= 6;
2093 buf[41] = base64b_int2char (l); l >>= 6;
2094 buf[42] = base64b_int2char (l); l >>= 6;
2095 buf[43] = base64b_int2char (l);
2096
2097 l = (digest[35] << 0) | (digest[34] << 8) | (digest[33] << 16);
2098
2099 buf[44] = base64b_int2char (l); l >>= 6;
2100 buf[45] = base64b_int2char (l); l >>= 6;
2101 buf[46] = base64b_int2char (l); l >>= 6;
2102 buf[47] = base64b_int2char (l);
2103
2104 l = (digest[38] << 0) | (digest[37] << 8) | (digest[36] << 16);
2105
2106 buf[48] = base64b_int2char (l); l >>= 6;
2107 buf[49] = base64b_int2char (l); l >>= 6;
2108 buf[50] = base64b_int2char (l); l >>= 6;
2109 buf[51] = base64b_int2char (l);
2110
2111 l = (digest[41] << 0) | (digest[40] << 8) | (digest[39] << 16);
2112
2113 buf[52] = base64b_int2char (l); l >>= 6;
2114 buf[53] = base64b_int2char (l); l >>= 6;
2115 buf[54] = base64b_int2char (l); l >>= 6;
2116 buf[55] = base64b_int2char (l);
2117
2118 l = (digest[44] << 0) | (digest[43] << 8) | (digest[42] << 16);
2119
2120 buf[56] = base64b_int2char (l); l >>= 6;
2121 buf[57] = base64b_int2char (l); l >>= 6;
2122 buf[58] = base64b_int2char (l); l >>= 6;
2123 buf[59] = base64b_int2char (l);
2124
2125 l = (digest[47] << 0) | (digest[46] << 8) | (digest[45] << 16);
2126
2127 buf[60] = base64b_int2char (l); l >>= 6;
2128 buf[61] = base64b_int2char (l); l >>= 6;
2129 buf[62] = base64b_int2char (l); l >>= 6;
2130 buf[63] = base64b_int2char (l);
2131
2132 l = (digest[50] << 0) | (digest[49] << 8) | (digest[48] << 16);
2133
2134 buf[64] = base64b_int2char (l); l >>= 6;
2135 buf[65] = base64b_int2char (l); l >>= 6;
2136 buf[66] = base64b_int2char (l); l >>= 6;
2137 buf[67] = base64b_int2char (l);
2138
2139 l = (digest[53] << 0) | (digest[52] << 8) | (digest[51] << 16);
2140
2141 buf[68] = base64b_int2char (l); l >>= 6;
2142 buf[69] = base64b_int2char (l); l >>= 6;
2143 buf[70] = base64b_int2char (l); l >>= 6;
2144 buf[71] = base64b_int2char (l);
2145
2146 l = (digest[56] << 0) | (digest[55] << 8) | (digest[54] << 16);
2147
2148 buf[72] = base64b_int2char (l); l >>= 6;
2149 buf[73] = base64b_int2char (l); l >>= 6;
2150 buf[74] = base64b_int2char (l); l >>= 6;
2151 buf[75] = base64b_int2char (l);
2152
2153 l = (digest[59] << 0) | (digest[58] << 8) | (digest[57] << 16);
2154
2155 buf[76] = base64b_int2char (l); l >>= 6;
2156 buf[77] = base64b_int2char (l); l >>= 6;
2157 buf[78] = base64b_int2char (l); l >>= 6;
2158 buf[79] = base64b_int2char (l);
2159
2160 l = (digest[62] << 0) | (digest[61] << 8) | (digest[60] << 16);
2161
2162 buf[80] = base64b_int2char (l); l >>= 6;
2163 buf[81] = base64b_int2char (l); l >>= 6;
2164 buf[82] = base64b_int2char (l); l >>= 6;
2165 buf[83] = base64b_int2char (l);
2166
2167 l = 0 | 0 | (digest[63] << 16);
2168
2169 buf[84] = base64b_int2char (l); l >>= 6;
2170 buf[85] = base64b_int2char (l); l >>= 6;
2171 }
2172
sha1fortigate_decode(unsigned char digest[DIGEST_SIZE_SHA1],unsigned char salt[BLOCK_SIZE],char * buf)2173 void sha1fortigate_decode (unsigned char digest[DIGEST_SIZE_SHA1], unsigned char salt[BLOCK_SIZE], char *buf)
2174 {
2175 char tmp_buf[SALT_SIZE_SHA1FORTIGATE + HASH_SIZE_SHA1];
2176
2177 base64_decode (base64_to_int, buf, 44, tmp_buf);
2178
2179 memcpy (salt, tmp_buf, SALT_SIZE_SHA1FORTIGATE);
2180
2181 memcpy (digest, tmp_buf + SALT_SIZE_SHA1FORTIGATE, HASH_SIZE_SHA1);
2182 }
2183
sha1fortigate_encode(unsigned char digest[DIGEST_SIZE_SHA1],unsigned char salt[BLOCK_SIZE],char * buf)2184 void sha1fortigate_encode (unsigned char digest[DIGEST_SIZE_SHA1], unsigned char salt[BLOCK_SIZE], char *buf)
2185 {
2186 char tmp_buf[SALT_SIZE_SHA1FORTIGATE + HASH_SIZE_SHA1FORTIGATE + 3];
2187 /* Salt */
2188 memcpy (tmp_buf, salt, SALT_SIZE_SHA1FORTIGATE);
2189
2190 /* Digest */
2191 memcpy (tmp_buf + SALT_SIZE_SHA1FORTIGATE, digest, HASH_SIZE_SHA1FORTIGATE);
2192
2193 memset (tmp_buf + SALT_SIZE_SHA1FORTIGATE + HASH_SIZE_SHA1FORTIGATE, 0, 3);
2194
2195 base64_encode (int_to_base64, tmp_buf, SALT_SIZE_SHA1FORTIGATE + HASH_SIZE_SHA1FORTIGATE, buf);
2196 }
2197
md5cisco_decode(char in_buf[HASH_SIZE_MD5CISCO],uint32_t out_buf[4])2198 void md5cisco_decode (char in_buf[HASH_SIZE_MD5CISCO], uint32_t out_buf[4])
2199 {
2200 char *ptr_in = in_buf;
2201
2202 uint32_t *ptr_out = out_buf;
2203
2204 uint32_t j;
2205
2206 for (j = 0; j < HASH_SIZE_MD5CISCO; j++)
2207 {
2208 *ptr_out += base64b_char2int (*ptr_in++);//<< 0
2209 *ptr_out += base64b_char2int (*ptr_in++) << 6;
2210 *ptr_out += base64b_char2int (*ptr_in++) << 12;
2211 *ptr_out += base64b_char2int (*ptr_in++) << 18;
2212 ptr_out += 1;
2213 }
2214 }
2215
md5cisco_encode(uint32_t in_buf[4],unsigned char * out_buf)2216 void md5cisco_encode (uint32_t in_buf[4], unsigned char *out_buf)
2217 {
2218 uint32_t *ptr_in = in_buf;
2219
2220 unsigned char *ptr_out = out_buf;
2221
2222 uint32_t j;
2223
2224 for (j = 0; j < 4; j++)
2225 {
2226 *ptr_out++ = base64b_int2char (*ptr_in);//>> 0
2227 *ptr_out++ = base64b_int2char (*ptr_in >> 6);
2228 *ptr_out++ = base64b_int2char (*ptr_in >> 12);
2229 *ptr_out++ = base64b_int2char (*ptr_in >> 18);
2230 ptr_in += 1;
2231 }
2232 }
2233
bcrypt_encode(char digest[DIGEST_SIZE_BCRYPT],char salt[16],char * bcrypt_str)2234 void bcrypt_encode (char digest[DIGEST_SIZE_BCRYPT], char salt[16], char *bcrypt_str)
2235 {
2236 base64_encode (int_to_bf64, salt, 16, bcrypt_str);
2237 base64_encode (int_to_bf64, digest, DIGEST_SIZE_BCRYPT, bcrypt_str + SALT_SIZE_MIN_BCRYPT);
2238
2239 bcrypt_str[SALT_SIZE_MIN_BCRYPT + HASH_SIZE_BCRYPT] = 0;
2240 }
2241
bcrypt_decode(char digest[DIGEST_SIZE_BCRYPT],char salt[16],char * hash_buf,char * salt_buf)2242 void bcrypt_decode (char digest[DIGEST_SIZE_BCRYPT], char salt[16], char *hash_buf, char *salt_buf)
2243 {
2244 base64_decode (bf64_to_int, salt_buf, SALT_SIZE_MIN_BCRYPT, salt);
2245 base64_decode (bf64_to_int, hash_buf, HASH_SIZE_BCRYPT, digest);
2246 }
2247
sha256unix_decode(unsigned char digest[DIGEST_SIZE_SHA256],unsigned char buf[HASH_SIZE_SHA256UNIX])2248 void sha256unix_decode (unsigned char digest[DIGEST_SIZE_SHA256], unsigned char buf[HASH_SIZE_SHA256UNIX])
2249 {
2250 int l;
2251
2252 l = base64b_char2int (buf[ 0]) << 0;
2253 l |= base64b_char2int (buf[ 1]) << 6;
2254 l |= base64b_char2int (buf[ 2]) << 12;
2255 l |= base64b_char2int (buf[ 3]) << 18;
2256
2257 digest[ 0] = (l >> 16) & 0xff;
2258 digest[10] = (l >> 8) & 0xff;
2259 digest[20] = (l >> 0) & 0xff;
2260
2261 l = base64b_char2int (buf[ 4]) << 0;
2262 l |= base64b_char2int (buf[ 5]) << 6;
2263 l |= base64b_char2int (buf[ 6]) << 12;
2264 l |= base64b_char2int (buf[ 7]) << 18;
2265
2266 digest[21] = (l >> 16) & 0xff;
2267 digest[ 1] = (l >> 8) & 0xff;
2268 digest[11] = (l >> 0) & 0xff;
2269
2270 l = base64b_char2int (buf[ 8]) << 0;
2271 l |= base64b_char2int (buf[ 9]) << 6;
2272 l |= base64b_char2int (buf[10]) << 12;
2273 l |= base64b_char2int (buf[11]) << 18;
2274
2275 digest[12] = (l >> 16) & 0xff;
2276 digest[22] = (l >> 8) & 0xff;
2277 digest[ 2] = (l >> 0) & 0xff;
2278
2279 l = base64b_char2int (buf[12]) << 0;
2280 l |= base64b_char2int (buf[13]) << 6;
2281 l |= base64b_char2int (buf[14]) << 12;
2282 l |= base64b_char2int (buf[15]) << 18;
2283
2284 digest[ 3] = (l >> 16) & 0xff;
2285 digest[13] = (l >> 8) & 0xff;
2286 digest[23] = (l >> 0) & 0xff;
2287
2288 l = base64b_char2int (buf[16]) << 0;
2289 l |= base64b_char2int (buf[17]) << 6;
2290 l |= base64b_char2int (buf[18]) << 12;
2291 l |= base64b_char2int (buf[19]) << 18;
2292
2293 digest[24] = (l >> 16) & 0xff;
2294 digest[ 4] = (l >> 8) & 0xff;
2295 digest[14] = (l >> 0) & 0xff;
2296
2297 l = base64b_char2int (buf[20]) << 0;
2298 l |= base64b_char2int (buf[21]) << 6;
2299 l |= base64b_char2int (buf[22]) << 12;
2300 l |= base64b_char2int (buf[23]) << 18;
2301
2302 digest[15] = (l >> 16) & 0xff;
2303 digest[25] = (l >> 8) & 0xff;
2304 digest[ 5] = (l >> 0) & 0xff;
2305
2306 l = base64b_char2int (buf[24]) << 0;
2307 l |= base64b_char2int (buf[25]) << 6;
2308 l |= base64b_char2int (buf[26]) << 12;
2309 l |= base64b_char2int (buf[27]) << 18;
2310
2311 digest[ 6] = (l >> 16) & 0xff;
2312 digest[16] = (l >> 8) & 0xff;
2313 digest[26] = (l >> 0) & 0xff;
2314
2315 l = base64b_char2int (buf[28]) << 0;
2316 l |= base64b_char2int (buf[29]) << 6;
2317 l |= base64b_char2int (buf[30]) << 12;
2318 l |= base64b_char2int (buf[31]) << 18;
2319
2320 digest[27] = (l >> 16) & 0xff;
2321 digest[ 7] = (l >> 8) & 0xff;
2322 digest[17] = (l >> 0) & 0xff;
2323
2324 l = base64b_char2int (buf[32]) << 0;
2325 l |= base64b_char2int (buf[33]) << 6;
2326 l |= base64b_char2int (buf[34]) << 12;
2327 l |= base64b_char2int (buf[35]) << 18;
2328
2329 digest[18] = (l >> 16) & 0xff;
2330 digest[28] = (l >> 8) & 0xff;
2331 digest[ 8] = (l >> 0) & 0xff;
2332
2333 l = base64b_char2int (buf[36]) << 0;
2334 l |= base64b_char2int (buf[37]) << 6;
2335 l |= base64b_char2int (buf[38]) << 12;
2336 l |= base64b_char2int (buf[39]) << 18;
2337
2338 digest[ 9] = (l >> 16) & 0xff;
2339 digest[19] = (l >> 8) & 0xff;
2340 digest[29] = (l >> 0) & 0xff;
2341
2342 l = base64b_char2int (buf[40]) << 0;
2343 l |= base64b_char2int (buf[41]) << 6;
2344 l |= base64b_char2int (buf[42]) << 12;
2345
2346 //digest[32] = (l >> 0) & 0xff;
2347 digest[31] = (l >> 8) & 0xff;
2348 digest[30] = (l >> 0) & 0xff;
2349
2350
2351 }
2352
sha256unix_encode(unsigned char digest[DIGEST_SIZE_SHA256],unsigned char buf[HASH_SIZE_SHA256UNIX])2353 void sha256unix_encode (unsigned char digest[DIGEST_SIZE_SHA256], unsigned char buf[HASH_SIZE_SHA256UNIX])
2354 {
2355 int l;
2356
2357 l = (digest[ 0] << 16) | (digest[10] << 8) | (digest[20] << 0);
2358
2359 buf[ 0] = base64b_int2char (l); l >>= 6;
2360 buf[ 1] = base64b_int2char (l); l >>= 6;
2361 buf[ 2] = base64b_int2char (l); l >>= 6;
2362 buf[ 3] = base64b_int2char (l); l >>= 6;
2363
2364 l = (digest[21] << 16) | (digest[ 1] << 8) | (digest[11] << 0);
2365
2366 buf[ 4] = base64b_int2char (l); l >>= 6;
2367 buf[ 5] = base64b_int2char (l); l >>= 6;
2368 buf[ 6] = base64b_int2char (l); l >>= 6;
2369 buf[ 7] = base64b_int2char (l); l >>= 6;
2370
2371 l = (digest[12] << 16) | (digest[22] << 8) | (digest[ 2] << 0);
2372
2373 buf[ 8] = base64b_int2char (l); l >>= 6;
2374 buf[ 9] = base64b_int2char (l); l >>= 6;
2375 buf[10] = base64b_int2char (l); l >>= 6;
2376 buf[11] = base64b_int2char (l); l >>= 6;
2377
2378 l = (digest[ 3] << 16) | (digest[13] << 8) | (digest[23] << 0);
2379
2380 buf[12] = base64b_int2char (l); l >>= 6;
2381 buf[13] = base64b_int2char (l); l >>= 6;
2382 buf[14] = base64b_int2char (l); l >>= 6;
2383 buf[15] = base64b_int2char (l); l >>= 6;
2384
2385 l = (digest[24] << 16) | (digest[ 4] << 8) | (digest[14] << 0);
2386
2387 buf[16] = base64b_int2char (l); l >>= 6;
2388 buf[17] = base64b_int2char (l); l >>= 6;
2389 buf[18] = base64b_int2char (l); l >>= 6;
2390 buf[19] = base64b_int2char (l); l >>= 6;
2391
2392 l = (digest[15] << 16) | (digest[25] << 8) | (digest[ 5] << 0);
2393
2394 buf[20] = base64b_int2char (l); l >>= 6;
2395 buf[21] = base64b_int2char (l); l >>= 6;
2396 buf[22] = base64b_int2char (l); l >>= 6;
2397 buf[23] = base64b_int2char (l); l >>= 6;
2398
2399 l = (digest[ 6] << 16) | (digest[16] << 8) | (digest[26] << 0);
2400
2401 buf[24] = base64b_int2char (l); l >>= 6;
2402 buf[25] = base64b_int2char (l); l >>= 6;
2403 buf[26] = base64b_int2char (l); l >>= 6;
2404 buf[27] = base64b_int2char (l); l >>= 6;
2405
2406 l = (digest[27] << 16) | (digest[ 7] << 8) | (digest[17] << 0);
2407
2408 buf[28] = base64b_int2char (l); l >>= 6;
2409 buf[29] = base64b_int2char (l); l >>= 6;
2410 buf[30] = base64b_int2char (l); l >>= 6;
2411 buf[31] = base64b_int2char (l); l >>= 6;
2412
2413 l = (digest[18] << 16) | (digest[28] << 8) | (digest[ 8] << 0);
2414
2415 buf[32] = base64b_int2char (l); l >>= 6;
2416 buf[33] = base64b_int2char (l); l >>= 6;
2417 buf[34] = base64b_int2char (l); l >>= 6;
2418 buf[35] = base64b_int2char (l); l >>= 6;
2419
2420 l = (digest[ 9] << 16) | (digest[19] << 8) | (digest[29] << 0);
2421
2422 buf[36] = base64b_int2char (l); l >>= 6;
2423 buf[37] = base64b_int2char (l); l >>= 6;
2424 buf[38] = base64b_int2char (l); l >>= 6;
2425 buf[39] = base64b_int2char (l); l >>= 6;
2426
2427 l = 0 | (digest[31] << 8) | (digest[30] << 0);
2428
2429 buf[40] = base64b_int2char (l); l >>= 6;
2430 buf[41] = base64b_int2char (l); l >>= 6;
2431 buf[42] = base64b_int2char (l);
2432 }
2433
sha512b64s_decode(unsigned char digest[DIGEST_SIZE_SHA512],unsigned char salt[BLOCK_SIZE],uint32_t in_len,uint32_t * out_len,char * buf)2434 void sha512b64s_decode (unsigned char digest[DIGEST_SIZE_SHA512], unsigned char salt[BLOCK_SIZE], uint32_t in_len, uint32_t *out_len, char *buf)
2435 {
2436 char tmp_buf[in_len / 4 * 3];
2437
2438 *out_len = base64_decode (base64_to_int, buf, in_len, tmp_buf);
2439
2440 memcpy (digest, tmp_buf, 64);
2441
2442 memcpy (salt, tmp_buf + 64, *out_len - 64);
2443
2444 *out_len -= 64;
2445 }
2446
sha512b64s_encode(unsigned char digest[DIGEST_SIZE_SHA512],unsigned char salt[BLOCK_SIZE],uint32_t salt_len,char * buf)2447 void sha512b64s_encode (unsigned char digest[DIGEST_SIZE_SHA512], unsigned char salt[BLOCK_SIZE], uint32_t salt_len, char *buf)
2448 {
2449 char tmp_buf[64 + salt_len + 3];
2450
2451 memcpy (tmp_buf, digest, 64);
2452
2453 memcpy (tmp_buf + 64, salt, salt_len);
2454
2455 memset (tmp_buf + 64 + salt_len, 0, 3);
2456
2457 uint32_t out_len;
2458
2459 out_len = base64_encode (int_to_base64, tmp_buf, 64 + salt_len, buf);
2460
2461 buf[out_len + 1] = 0;
2462 }
2463
drupal7_decode(unsigned char digest[DIGEST_SIZE_SHA512],unsigned char buf[HASH_SIZE_DRUPAL7])2464 void drupal7_decode (unsigned char digest[DIGEST_SIZE_SHA512], unsigned char buf[HASH_SIZE_DRUPAL7])
2465 {
2466 int l;
2467
2468 l = base64b_char2int (buf[ 0]) << 0;
2469 l |= base64b_char2int (buf[ 1]) << 6;
2470 l |= base64b_char2int (buf[ 2]) << 12;
2471 l |= base64b_char2int (buf[ 3]) << 18;
2472
2473 digest[ 0] = (l >> 0) & 0xff;
2474 digest[ 1] = (l >> 8) & 0xff;
2475 digest[ 2] = (l >> 16) & 0xff;
2476
2477 l = base64b_char2int (buf[ 4]) << 0;
2478 l |= base64b_char2int (buf[ 5]) << 6;
2479 l |= base64b_char2int (buf[ 6]) << 12;
2480 l |= base64b_char2int (buf[ 7]) << 18;
2481
2482 digest[ 3] = (l >> 0) & 0xff;
2483 digest[ 4] = (l >> 8) & 0xff;
2484 digest[ 5] = (l >> 16) & 0xff;
2485
2486 l = base64b_char2int (buf[ 8]) << 0;
2487 l |= base64b_char2int (buf[ 9]) << 6;
2488 l |= base64b_char2int (buf[10]) << 12;
2489 l |= base64b_char2int (buf[11]) << 18;
2490
2491 digest[ 6] = (l >> 0) & 0xff;
2492 digest[ 7] = (l >> 8) & 0xff;
2493 digest[ 8] = (l >> 16) & 0xff;
2494
2495 l = base64b_char2int (buf[12]) << 0;
2496 l |= base64b_char2int (buf[13]) << 6;
2497 l |= base64b_char2int (buf[14]) << 12;
2498 l |= base64b_char2int (buf[15]) << 18;
2499
2500 digest[ 9] = (l >> 0) & 0xff;
2501 digest[10] = (l >> 8) & 0xff;
2502 digest[11] = (l >> 16) & 0xff;
2503
2504 l = base64b_char2int (buf[16]) << 0;
2505 l |= base64b_char2int (buf[17]) << 6;
2506 l |= base64b_char2int (buf[18]) << 12;
2507 l |= base64b_char2int (buf[19]) << 18;
2508
2509 digest[12] = (l >> 0) & 0xff;
2510 digest[13] = (l >> 8) & 0xff;
2511 digest[14] = (l >> 16) & 0xff;
2512
2513 l = base64b_char2int (buf[20]) << 0;
2514 l |= base64b_char2int (buf[21]) << 6;
2515 l |= base64b_char2int (buf[22]) << 12;
2516 l |= base64b_char2int (buf[23]) << 18;
2517
2518 digest[15] = (l >> 0) & 0xff;
2519 digest[16] = (l >> 8) & 0xff;
2520 digest[17] = (l >> 16) & 0xff;
2521
2522 l = base64b_char2int (buf[24]) << 0;
2523 l |= base64b_char2int (buf[25]) << 6;
2524 l |= base64b_char2int (buf[26]) << 12;
2525 l |= base64b_char2int (buf[27]) << 18;
2526
2527 digest[18] = (l >> 0) & 0xff;
2528 digest[19] = (l >> 8) & 0xff;
2529 digest[20] = (l >> 16) & 0xff;
2530
2531 l = base64b_char2int (buf[28]) << 0;
2532 l |= base64b_char2int (buf[29]) << 6;
2533 l |= base64b_char2int (buf[30]) << 12;
2534 l |= base64b_char2int (buf[31]) << 18;
2535
2536 digest[21] = (l >> 0) & 0xff;
2537 digest[22] = (l >> 8) & 0xff;
2538 digest[23] = (l >> 16) & 0xff;
2539
2540 l = base64b_char2int (buf[32]) << 0;
2541 l |= base64b_char2int (buf[33]) << 6;
2542 l |= base64b_char2int (buf[34]) << 12;
2543 l |= base64b_char2int (buf[35]) << 18;
2544
2545 digest[24] = (l >> 0) & 0xff;
2546 digest[25] = (l >> 8) & 0xff;
2547 digest[26] = (l >> 16) & 0xff;
2548
2549 l = base64b_char2int (buf[36]) << 0;
2550 l |= base64b_char2int (buf[37]) << 6;
2551 l |= base64b_char2int (buf[38]) << 12;
2552 l |= base64b_char2int (buf[39]) << 18;
2553
2554 digest[27] = (l >> 0) & 0xff;
2555 digest[28] = (l >> 8) & 0xff;
2556 digest[29] = (l >> 16) & 0xff;
2557
2558 l = base64b_char2int (buf[40]) << 0;
2559 l |= base64b_char2int (buf[41]) << 6;
2560 l |= base64b_char2int (buf[42]) << 12;
2561
2562 digest[30] = (l >> 0) & 0xff;
2563 digest[31] = (l >> 8) & 0xff;
2564 }
2565
drupal7_encode(unsigned char digest[DIGEST_SIZE_SHA512],unsigned char buf[HASH_SIZE_DRUPAL7])2566 void drupal7_encode (unsigned char digest[DIGEST_SIZE_SHA512], unsigned char buf[HASH_SIZE_DRUPAL7])
2567 {
2568 int l;
2569
2570 l = (digest[ 0] << 0) | (digest[ 1] << 8) | (digest[ 2] << 16);
2571
2572 buf[ 0] = base64b_int2char (l); l >>= 6;
2573 buf[ 1] = base64b_int2char (l); l >>= 6;
2574 buf[ 2] = base64b_int2char (l); l >>= 6;
2575 buf[ 3] = base64b_int2char (l);
2576
2577 l = (digest[ 3] << 0) | (digest[ 4] << 8) | (digest[ 5] << 16);
2578
2579 buf[ 4] = base64b_int2char (l); l >>= 6;
2580 buf[ 5] = base64b_int2char (l); l >>= 6;
2581 buf[ 6] = base64b_int2char (l); l >>= 6;
2582 buf[ 7] = base64b_int2char (l);
2583
2584 l = (digest[ 6] << 0) | (digest[ 7] << 8) | (digest[ 8] << 16);
2585
2586 buf[ 8] = base64b_int2char (l); l >>= 6;
2587 buf[ 9] = base64b_int2char (l); l >>= 6;
2588 buf[10] = base64b_int2char (l); l >>= 6;
2589 buf[11] = base64b_int2char (l);
2590
2591 l = (digest[ 9] << 0) | (digest[10] << 8) | (digest[11] << 16);
2592
2593 buf[12] = base64b_int2char (l); l >>= 6;
2594 buf[13] = base64b_int2char (l); l >>= 6;
2595 buf[14] = base64b_int2char (l); l >>= 6;
2596 buf[15] = base64b_int2char (l);
2597
2598 l = (digest[12] << 0) | (digest[13] << 8) | (digest[14] << 16);
2599
2600 buf[16] = base64b_int2char (l); l >>= 6;
2601 buf[17] = base64b_int2char (l); l >>= 6;
2602 buf[18] = base64b_int2char (l); l >>= 6;
2603 buf[19] = base64b_int2char (l);
2604
2605 l = (digest[15] << 0) | (digest[16] << 8) | (digest[17] << 16);
2606
2607 buf[20] = base64b_int2char (l); l >>= 6;
2608 buf[21] = base64b_int2char (l); l >>= 6;
2609 buf[22] = base64b_int2char (l); l >>= 6;
2610 buf[23] = base64b_int2char (l);
2611
2612 l = (digest[18] << 0) | (digest[19] << 8) | (digest[20] << 16);
2613
2614 buf[24] = base64b_int2char (l); l >>= 6;
2615 buf[25] = base64b_int2char (l); l >>= 6;
2616 buf[26] = base64b_int2char (l); l >>= 6;
2617 buf[27] = base64b_int2char (l);
2618
2619 l = (digest[21] << 0) | (digest[22] << 8) | (digest[23] << 16);
2620
2621 buf[28] = base64b_int2char (l); l >>= 6;
2622 buf[29] = base64b_int2char (l); l >>= 6;
2623 buf[30] = base64b_int2char (l); l >>= 6;
2624 buf[31] = base64b_int2char (l);
2625
2626 l = (digest[24] << 0) | (digest[25] << 8) | (digest[26] << 16);
2627
2628 buf[32] = base64b_int2char (l); l >>= 6;
2629 buf[33] = base64b_int2char (l); l >>= 6;
2630 buf[34] = base64b_int2char (l); l >>= 6;
2631 buf[35] = base64b_int2char (l);
2632
2633 l = (digest[27] << 0) | (digest[28] << 8) | (digest[29] << 16);
2634
2635 buf[36] = base64b_int2char (l); l >>= 6;
2636 buf[37] = base64b_int2char (l); l >>= 6;
2637 buf[38] = base64b_int2char (l); l >>= 6;
2638 buf[39] = base64b_int2char (l);
2639
2640 l = (digest[30] << 0) | (digest[31] << 8) | (digest[32] << 16);
2641
2642 buf[40] = base64b_int2char (l); l >>= 6;
2643 buf[41] = base64b_int2char (l); l >>= 6;
2644 buf[42] = base64b_int2char (l);
2645 }
2646
sort_by_pot(const void * v1,const void * v2)2647 int sort_by_pot (const void *v1, const void *v2)
2648 {
2649 const pot_t *p1 = (const pot_t *) v1;
2650 const pot_t *p2 = (const pot_t *) v2;
2651
2652 const hash_t *h1 = &p1->hash;
2653 const hash_t *h2 = &p2->hash;
2654
2655 uint n;
2656
2657 const salt_t *s1 = h1->salt;
2658 const salt_t *s2 = h2->salt;
2659
2660 if (s1 && s2)
2661 {
2662 n = MIN (s1->salt_plain_len, s2->salt_plain_len);
2663
2664 uint pos = 0;
2665
2666 while (pos < n)
2667 {
2668 if (s1->salt_plain_buf[pos] > s2->salt_plain_buf[pos]) return ( 1);
2669 if (s1->salt_plain_buf[pos] < s2->salt_plain_buf[pos]) return (-1);
2670
2671 pos++;
2672 }
2673 }
2674
2675 const digest_t *d1 = &h1->digest;
2676 const digest_t *d2 = &h2->digest;
2677
2678 n = strlen (d2->plain);
2679
2680 while (n--)
2681 {
2682 if (d1->plain[n] > d2->plain[n]) return ( 1);
2683 if (d1->plain[n] < d2->plain[n]) return (-1);
2684 }
2685
2686 return (0);
2687 }
2688
format_plain(FILE * fp,char * plain,uint plain_len,uint32_t output_autohex)2689 void format_plain (FILE *fp, char *plain, uint plain_len, uint32_t output_autohex)
2690 {
2691 unsigned char *plain_ptr = (unsigned char*) plain;
2692
2693 int needs_hexify = 0;
2694
2695 if (output_autohex == 1)
2696 {
2697 uint i;
2698
2699 for (i = 0; i < plain_len; i++)
2700 {
2701 if (plain_ptr[i] < 0x20)
2702 {
2703 needs_hexify = 1;
2704
2705 break;
2706 }
2707
2708 if (plain_ptr[i] > 0x7f)
2709 {
2710 needs_hexify = 1;
2711
2712 break;
2713 }
2714 }
2715 }
2716
2717 if (needs_hexify == 1)
2718 {
2719 fprintf (fp, "$HEX[");
2720
2721 uint i;
2722
2723 for (i = 0; i < plain_len; i++)
2724 {
2725 fprintf (fp, "%02x", plain_ptr[i]);
2726 }
2727
2728 fprintf (fp, "]");
2729 }
2730 else
2731 {
2732 fwrite (plain_ptr, plain_len, 1, fp);
2733 }
2734 }
2735
format_output(FILE * fp,engine_parameter_t * engine_parameter,char * out_buf,char * plain_ptr,uint plain_len,uint64_t pos)2736 void format_output (FILE *fp, engine_parameter_t *engine_parameter, char *out_buf, char *plain_ptr, uint plain_len, uint64_t pos)
2737 {
2738 uint output_format = engine_parameter->output_format;
2739 char separator = engine_parameter->separator;
2740
2741 uint32_t output_autohex = engine_parameter->output_autohex;
2742
2743 // hash[:salt] for --left / --show
2744
2745 if (out_buf != NULL)
2746 {
2747 if (output_format % 2)
2748 {
2749 fputs (out_buf, fp);
2750 }
2751 }
2752
2753 uint format = output_format;
2754
2755 if ((format >= 9) && (format <= 15)) format = format - 8;
2756
2757 // plain
2758
2759 if (format > 1)
2760 {
2761 if (format < 4)
2762 {
2763 if (format == 3) fputc (separator, fp);
2764
2765 format_plain (fp, plain_ptr, plain_len, output_autohex);
2766 }
2767 else if (format < 8)
2768 {
2769 if (format == 7) fputc (separator, fp);
2770
2771 if (format == 6 || format == 7)
2772 {
2773 format_plain (fp, plain_ptr, plain_len, output_autohex);
2774 }
2775
2776 if (format != 4) fputc (separator, fp);
2777
2778 uint32_t i;
2779
2780 for (i = 0; i < plain_len; i++)
2781 {
2782 fprintf (fp, "%02x", (unsigned char) plain_ptr[i]);
2783 }
2784 }
2785 }
2786
2787 // crackpos
2788 if ((output_format >= 8) && (output_format <= 15))
2789 {
2790 if (output_format != 8) fputc (separator, fp);
2791
2792 fprintf (fp, "%llu", (long long unsigned int) pos);
2793 }
2794
2795 fputc ('\n', fp);
2796 }
2797
handle_show_request(FILE * out_fp,engine_parameter_t * engine_parameter,pot_t * pot,char * input_buf,int input_len,char * hash_buf,char * salt_buf,uint32_t salt_len,uint user_len)2798 void handle_show_request (FILE *out_fp, engine_parameter_t *engine_parameter, pot_t *pot, char *input_buf, int input_len, char *hash_buf, char *salt_buf, uint32_t salt_len, uint user_len)
2799 {
2800 if (pot == NULL || out_fp == NULL) return;
2801
2802 uint pot_cnt = pot->pot_cnt;
2803
2804 pot_t pot_key;
2805
2806 pot_key.hash.salt = (salt_t *) mymalloc (sizeof (salt_t));
2807 pot_key.hash.salt->salt_plain_buf = salt_buf;
2808 pot_key.hash.salt->salt_plain_len = salt_len;
2809
2810 pot_key.hash.digest.plain = hash_buf;
2811
2812 pot_t *pot_ptr = (pot_t *) bsearch (&pot_key, pot, pot_cnt, sizeof (pot_t), sort_by_pot);
2813
2814 if (pot_ptr)
2815 {
2816 input_buf[input_len] = 0;
2817
2818 // special case (username should be printed)
2819
2820 if (engine_parameter->username)
2821 {
2822 uint i;
2823
2824 for (i = 0; i < user_len; i++) fputc (input_buf[i], out_fp);
2825
2826 fputc (engine_parameter->separator, out_fp);
2827
2828 // advance the input buf (s.t. we do no print the username again and again)
2829
2830 input_buf = input_buf + user_len + 1;
2831 }
2832
2833 format_output (out_fp, engine_parameter, input_buf, pot_ptr->plain_buf, pot_ptr->plain_len, 0);
2834 }
2835
2836 free (pot_key.hash.salt);
2837 }
2838
handle_left_request(FILE * out_fp,engine_parameter_t * engine_parameter,pot_t * pot,char * input_buf,int input_len,char * hash_buf,char * salt_buf,uint32_t salt_len)2839 void handle_left_request (FILE *out_fp, engine_parameter_t *engine_parameter, pot_t *pot, char *input_buf, int input_len, char *hash_buf, char *salt_buf, uint32_t salt_len)
2840 {
2841 if (out_fp == NULL) return;
2842
2843 uint print = 0;
2844
2845 if (pot != NULL)
2846 {
2847 uint pot_cnt = pot->pot_cnt;
2848
2849 pot_t pot_key;
2850
2851 pot_key.hash.salt = (salt_t *) mymalloc (sizeof (salt_t));
2852 pot_key.hash.salt->salt_plain_buf = salt_buf;
2853 pot_key.hash.salt->salt_plain_len = salt_len;
2854
2855 pot_key.hash.digest.plain = hash_buf;
2856
2857 pot_t *pot_ptr = (pot_t *) bsearch (&pot_key, pot, pot_cnt, sizeof (pot_t), sort_by_pot);
2858
2859 free (pot_key.hash.salt);
2860
2861 if (pot_ptr == NULL) print = 1;
2862 }
2863 else
2864 {
2865 print = 1;
2866 }
2867
2868 if (print == 1)
2869 {
2870 input_buf[input_len] = 0;
2871
2872 format_output (out_fp, engine_parameter, input_buf, NULL, 0, 0);
2873 }
2874 }
2875
2876 /*
2877 char hex_convert (char c)
2878 {
2879 if ((c >= '0') && (c <= '9')) return (c - '0');
2880 if ((c >= 'A') && (c <= 'F')) return (c - 'A' + 10);
2881 if ((c >= 'a') && (c <= 'f')) return (c - 'a' + 10);
2882
2883 return (-1);
2884 }
2885 */
2886
is_valid_hex_char(const char c)2887 uint is_valid_hex_char (const char c)
2888 {
2889 if ((c >= '0') && (c <= '9')) return 1;
2890 if ((c >= 'A') && (c <= 'F')) return 1;
2891 if ((c >= 'a') && (c <= 'f')) return 1;
2892
2893 return 0;
2894 }
2895
hex_convert(const char c)2896 char hex_convert (const char c)
2897 {
2898 return (c & 15) + (c >> 6) * 9;
2899 }
2900
hex_to_char(char hex[2])2901 char hex_to_char (char hex[2])
2902 {
2903 char v = 0;
2904
2905 v |= (hex_convert (hex[1]) << 0);
2906 v |= (hex_convert (hex[0]) << 4);
2907
2908 return (v);
2909 }
2910
hex_to_uint(char hex[8])2911 uint32_t hex_to_uint (char hex[ 8])
2912 {
2913 uint32_t v = 0;
2914
2915 v |= ((uint32_t) hex_convert (hex[7]) << 0);
2916 v |= ((uint32_t) hex_convert (hex[6]) << 4);
2917 v |= ((uint32_t) hex_convert (hex[5]) << 8);
2918 v |= ((uint32_t) hex_convert (hex[4]) << 12);
2919 v |= ((uint32_t) hex_convert (hex[3]) << 16);
2920 v |= ((uint32_t) hex_convert (hex[2]) << 20);
2921 v |= ((uint32_t) hex_convert (hex[1]) << 24);
2922 v |= ((uint32_t) hex_convert (hex[0]) << 28);
2923
2924 return (v);
2925 }
2926
hex_to_uint64(char hex[16])2927 uint64_t hex_to_uint64 (char hex[16])
2928 {
2929 uint64_t v = 0;
2930
2931 v |= ((uint64_t) hex_convert (hex[15]) << 0);
2932 v |= ((uint64_t) hex_convert (hex[14]) << 4);
2933 v |= ((uint64_t) hex_convert (hex[13]) << 8);
2934 v |= ((uint64_t) hex_convert (hex[12]) << 12);
2935 v |= ((uint64_t) hex_convert (hex[11]) << 16);
2936 v |= ((uint64_t) hex_convert (hex[10]) << 20);
2937 v |= ((uint64_t) hex_convert (hex[ 9]) << 24);
2938 v |= ((uint64_t) hex_convert (hex[ 8]) << 28);
2939 v |= ((uint64_t) hex_convert (hex[ 7]) << 32);
2940 v |= ((uint64_t) hex_convert (hex[ 6]) << 36);
2941 v |= ((uint64_t) hex_convert (hex[ 5]) << 40);
2942 v |= ((uint64_t) hex_convert (hex[ 4]) << 44);
2943 v |= ((uint64_t) hex_convert (hex[ 3]) << 48);
2944 v |= ((uint64_t) hex_convert (hex[ 2]) << 52);
2945 v |= ((uint64_t) hex_convert (hex[ 1]) << 56);
2946 v |= ((uint64_t) hex_convert (hex[ 0]) << 60);
2947
2948 return (v);
2949 }
2950
uint_to_hex_lower(uint32_t uint,char hex[8])2951 void uint_to_hex_lower (uint32_t uint, char hex[8])
2952 {
2953 hex[0] = uint >> 28 & 15;
2954 hex[1] = uint >> 24 & 15;
2955 hex[2] = uint >> 20 & 15;
2956 hex[3] = uint >> 16 & 15;
2957 hex[4] = uint >> 12 & 15;
2958 hex[5] = uint >> 8 & 15;
2959 hex[6] = uint >> 4 & 15;
2960 hex[7] = uint >> 0 & 15;
2961
2962 uint32_t add;
2963
2964 hex[0] += 6; add = ((hex[0] & 0x10) >> 4) * 39; hex[0] += 42 + add;
2965 hex[1] += 6; add = ((hex[1] & 0x10) >> 4) * 39; hex[1] += 42 + add;
2966 hex[2] += 6; add = ((hex[2] & 0x10) >> 4) * 39; hex[2] += 42 + add;
2967 hex[3] += 6; add = ((hex[3] & 0x10) >> 4) * 39; hex[3] += 42 + add;
2968 hex[4] += 6; add = ((hex[4] & 0x10) >> 4) * 39; hex[4] += 42 + add;
2969 hex[5] += 6; add = ((hex[5] & 0x10) >> 4) * 39; hex[5] += 42 + add;
2970 hex[6] += 6; add = ((hex[6] & 0x10) >> 4) * 39; hex[6] += 42 + add;
2971 hex[7] += 6; add = ((hex[7] & 0x10) >> 4) * 39; hex[7] += 42 + add;
2972 }
2973
uint_to_hex_upper(uint32_t uint,char hex[8])2974 void uint_to_hex_upper (uint32_t uint, char hex[8])
2975 {
2976 hex[0] = uint >> 28 & 15;
2977 hex[1] = uint >> 24 & 15;
2978 hex[2] = uint >> 20 & 15;
2979 hex[3] = uint >> 16 & 15;
2980 hex[4] = uint >> 12 & 15;
2981 hex[5] = uint >> 8 & 15;
2982 hex[6] = uint >> 4 & 15;
2983 hex[7] = uint >> 0 & 15;
2984
2985 uint32_t add;
2986
2987 hex[0] += 6; add = ((hex[0] & 0x10) >> 4) * 7; hex[0] += 42 + add;
2988 hex[1] += 6; add = ((hex[1] & 0x10) >> 4) * 7; hex[1] += 42 + add;
2989 hex[2] += 6; add = ((hex[2] & 0x10) >> 4) * 7; hex[2] += 42 + add;
2990 hex[3] += 6; add = ((hex[3] & 0x10) >> 4) * 7; hex[3] += 42 + add;
2991 hex[4] += 6; add = ((hex[4] & 0x10) >> 4) * 7; hex[4] += 42 + add;
2992 hex[5] += 6; add = ((hex[5] & 0x10) >> 4) * 7; hex[5] += 42 + add;
2993 hex[6] += 6; add = ((hex[6] & 0x10) >> 4) * 7; hex[6] += 42 + add;
2994 hex[7] += 6; add = ((hex[7] & 0x10) >> 4) * 7; hex[7] += 42 + add;
2995 }
2996
make_unicode(uint8_t * out,uint8_t * in,int size)2997 void make_unicode (uint8_t *out, uint8_t *in, int size)
2998 {
2999 while (size--)
3000 {
3001 *out++ = *in++;
3002 *out++ = 0;
3003 }
3004 }
3005
make_unicode_upper(uint8_t * out,uint8_t * in,int size)3006 void make_unicode_upper (uint8_t *out, uint8_t *in, int size)
3007 {
3008 while (size--)
3009 {
3010 *out++ = toupper (*in++);
3011 *out++ = 0;
3012 }
3013 }
3014
plain_unicode(plain_t * in,plain_t * out)3015 void plain_unicode (plain_t *in, plain_t *out)
3016 {
3017 make_unicode (out[0].buf8, in[0].buf8, in[0].len);
3018 make_unicode (out[1].buf8, in[1].buf8, in[1].len);
3019 make_unicode (out[2].buf8, in[2].buf8, in[2].len);
3020 make_unicode (out[3].buf8, in[3].buf8, in[3].len);
3021
3022 out[0].len = in[0].len * 2;
3023 out[1].len = in[1].len * 2;
3024 out[2].len = in[2].len * 2;
3025 out[3].len = in[3].len * 2;
3026 }
3027
plain_unicode_and_upper(plain_t * in,plain_t * out)3028 void plain_unicode_and_upper (plain_t *in, plain_t *out)
3029 {
3030 make_unicode_upper (out[0].buf8, in[0].buf8, in[0].len);
3031 make_unicode_upper (out[1].buf8, in[1].buf8, in[1].len);
3032 make_unicode_upper (out[2].buf8, in[2].buf8, in[2].len);
3033 make_unicode_upper (out[3].buf8, in[3].buf8, in[3].len);
3034
3035 out[0].len = in[0].len * 2;
3036 out[1].len = in[1].len * 2;
3037 out[2].len = in[2].len * 2;
3038 out[3].len = in[3].len * 2;
3039 }
3040
compare_digest_plain(const void * p1,const void * p2)3041 int compare_digest_plain (const void *p1, const void *p2)
3042 {
3043 const digest_t **d1 = (const digest_t **) p1;
3044 const digest_t **d2 = (const digest_t **) p2;
3045
3046 return memcmp ((*d1)->buf.plain, (*d2)->buf.plain, DIGEST_SIZE_PLAIN);
3047 }
3048
compare_digest_md5(const void * p1,const void * p2)3049 int compare_digest_md5 (const void *p1, const void *p2)
3050 {
3051 const digest_t **d1 = (const digest_t **) p1;
3052 const digest_t **d2 = (const digest_t **) p2;
3053
3054 return memcmp ((*d1)->buf.md5, (*d2)->buf.md5, DIGEST_SIZE_MD5);
3055 }
3056
compare_digest_sha1(const void * p1,const void * p2)3057 int compare_digest_sha1 (const void *p1, const void *p2)
3058 {
3059 const digest_t **d1 = (const digest_t **) p1;
3060 const digest_t **d2 = (const digest_t **) p2;
3061
3062 return memcmp ((*d1)->buf.sha1, (*d2)->buf.sha1, DIGEST_SIZE_SHA1);
3063 }
3064
compare_digest_mysql(const void * p1,const void * p2)3065 int compare_digest_mysql (const void *p1, const void *p2)
3066 {
3067 const digest_t **d1 = (const digest_t **) p1;
3068 const digest_t **d2 = (const digest_t **) p2;
3069
3070 return memcmp ((*d1)->buf.mysql, (*d2)->buf.mysql, DIGEST_SIZE_MYSQL);
3071 }
3072
compare_digest_md4(const void * p1,const void * p2)3073 int compare_digest_md4 (const void *p1, const void *p2)
3074 {
3075 const digest_t **d1 = (const digest_t **) p1;
3076 const digest_t **d2 = (const digest_t **) p2;
3077
3078 return memcmp ((*d1)->buf.md4, (*d2)->buf.md4, DIGEST_SIZE_MD4);
3079 }
3080
compare_digest_sha256(const void * p1,const void * p2)3081 int compare_digest_sha256 (const void *p1, const void *p2)
3082 {
3083 const digest_t **d1 = (const digest_t **) p1;
3084 const digest_t **d2 = (const digest_t **) p2;
3085
3086 return memcmp ((*d1)->buf.sha256, (*d2)->buf.sha256, DIGEST_SIZE_SHA256);
3087 }
3088
compare_digest_sha512(const void * p1,const void * p2)3089 int compare_digest_sha512 (const void *p1, const void *p2)
3090 {
3091 const digest_t **d1 = (const digest_t **) p1;
3092 const digest_t **d2 = (const digest_t **) p2;
3093
3094 return memcmp ((*d1)->buf.sha512, (*d2)->buf.sha512, DIGEST_SIZE_SHA512);
3095 }
3096
compare_digest_descrypt(const void * p1,const void * p2)3097 int compare_digest_descrypt (const void *p1, const void *p2)
3098 {
3099 const digest_t **d1 = (const digest_t **) p1;
3100 const digest_t **d2 = (const digest_t **) p2;
3101
3102 return memcmp ((*d1)->buf.descrypt, (*d2)->buf.descrypt, DIGEST_SIZE_DESCRYPT);
3103 }
3104
compare_digest_keccak(const void * p1,const void * p2)3105 int compare_digest_keccak (const void *p1, const void *p2)
3106 {
3107 const digest_t **d1 = (const digest_t **) p1;
3108 const digest_t **d2 = (const digest_t **) p2;
3109
3110 return memcmp ((*d1)->buf.keccak, (*d2)->buf.keccak, DIGEST_SIZE_KECCAK);
3111 }
3112
compare_digest_netntlmv1(const void * p1,const void * p2)3113 int compare_digest_netntlmv1 (const void *p1, const void *p2)
3114 {
3115 const digest_t **d1 = (const digest_t **) p1;
3116 const digest_t **d2 = (const digest_t **) p2;
3117
3118 return memcmp ((*d1)->buf.md4, (*d2)->buf.md4, DIGEST_SIZE_NETNTLMv1);
3119 }
3120
compare_digest_gost(const void * p1,const void * p2)3121 int compare_digest_gost (const void *p1, const void *p2)
3122 {
3123 const digest_t **d1 = (const digest_t **) p1;
3124 const digest_t **d2 = (const digest_t **) p2;
3125
3126 return memcmp ((*d1)->buf.gost, (*d2)->buf.gost, DIGEST_SIZE_GOST);
3127 }
3128
compare_digest_bcrypt(const void * p1,const void * p2)3129 int compare_digest_bcrypt (const void *p1, const void *p2)
3130 {
3131 const digest_t **d1 = (const digest_t **) p1;
3132 const digest_t **d2 = (const digest_t **) p2;
3133
3134 return memcmp ((*d1)->buf.bcrypt, (*d2)->buf.bcrypt, DIGEST_SIZE_BCRYPT);
3135 }
3136
get_index_md5(digest_t * digest)3137 uint32_t get_index_md5 (digest_t *digest)
3138 {
3139 return (digest->buf.md5[0] >> INDEX_BITS);
3140 }
3141
get_index_sha1(digest_t * digest)3142 uint32_t get_index_sha1 (digest_t *digest)
3143 {
3144 return (digest->buf.sha1[0] >> INDEX_BITS);
3145 }
3146
get_index_mysql(digest_t * digest)3147 uint32_t get_index_mysql (digest_t *digest)
3148 {
3149 return (digest->buf.mysql[0] >> INDEX_BITS);
3150 }
3151
get_index_md4(digest_t * digest)3152 uint32_t get_index_md4 (digest_t *digest)
3153 {
3154 return (digest->buf.md4[0] >> INDEX_BITS);
3155 }
3156
get_index_sha256(digest_t * digest)3157 uint32_t get_index_sha256 (digest_t *digest)
3158 {
3159 return (digest->buf.sha256[0] >> INDEX_BITS);
3160 }
3161
get_index_sha512(digest_t * digest)3162 uint32_t get_index_sha512 (digest_t *digest)
3163 {
3164 return ((uint32_t) digest->buf.sha512[0] >> INDEX_BITS);
3165 }
3166
get_index_gost(digest_t * digest)3167 uint32_t get_index_gost (digest_t *digest)
3168 {
3169 return (digest->buf.gost[0] >> INDEX_BITS);
3170 }
3171
get_index_plain(digest_t * digest)3172 uint32_t get_index_plain (digest_t *digest)
3173 {
3174 return (digest->buf.md5[0] >> INDEX_BITS);
3175 }
3176
get_index_zero(digest_t * digest)3177 uint32_t get_index_zero (digest_t *digest __attribute__((unused)))
3178 {
3179 return (0);
3180 }
3181
transpose_to_di4_sse2(const __m128i * s0,const __m128i * s1,const __m128i * s2,const __m128i * s3,__m128i * p2)3182 void transpose_to_di4_sse2 (const __m128i *s0, const __m128i *s1, const __m128i *s2, const __m128i *s3, __m128i *p2)
3183 {
3184 int i;
3185 int j;
3186
3187 for (i = 0, j = 0; i < 16; i += 4, j += 1)
3188 {
3189 // const __m128i i0 = s0[j];
3190 // const __m128i i1 = s1[j];
3191 // const __m128i i2 = s2[j];
3192 // const __m128i i3 = s3[j];
3193
3194 #define i0 s0[j]
3195 #define i1 s1[j]
3196 #define i2 s2[j]
3197 #define i3 s3[j]
3198
3199 const __m128i t0 = _mm_unpacklo_epi32 (i0, i1);
3200 const __m128i t1 = _mm_unpacklo_epi32 (i2, i3);
3201 const __m128i t2 = _mm_unpackhi_epi32 (i0, i1);
3202 const __m128i t3 = _mm_unpackhi_epi32 (i2, i3);
3203
3204 p2[i + 0] = _mm_unpacklo_epi64 (t0, t1);
3205 p2[i + 1] = _mm_unpackhi_epi64 (t0, t1);
3206 p2[i + 2] = _mm_unpacklo_epi64 (t2, t3);
3207 p2[i + 3] = _mm_unpackhi_epi64 (t2, t3);
3208 }
3209 }
3210
plain_init(plain_t * in)3211 void plain_init (plain_t *in)
3212 {
3213 in->len = 0; in++;
3214 in->len = 0; in++;
3215 in->len = 0; in++;
3216 in->len = 0;
3217 }
3218
plain_init_64(plain_t * in)3219 void plain_init_64 (plain_t *in)
3220 {
3221 in->len = 0; in++;
3222 in->len = 0;
3223 }
3224
3225 // transforms
3226
md4_transform(plain_t * plains,digest_md4_sse2_t * digests)3227 void md4_transform (plain_t *plains, digest_md4_sse2_t *digests)
3228 {
3229 __m128i block[16];
3230
3231 transpose_to_di4_sse2 (plains[0].buf128, plains[1].buf128, plains[2].buf128, plains[3].buf128, block);
3232
3233 hashcat_md4_64 (digests->buf128, block);
3234 }
3235
md5_transform(plain_t * plains,digest_md5_sse2_t * digests)3236 void md5_transform (plain_t *plains, digest_md5_sse2_t *digests)
3237 {
3238 __m128i block[16];
3239
3240 transpose_to_di4_sse2 (plains[0].buf128, plains[1].buf128, plains[2].buf128, plains[3].buf128, block);
3241
3242 hashcat_md5_64 (digests->buf128, block);
3243 }
3244
sha1_transform(plain_t * plains,digest_sha1_sse2_t * digests)3245 void sha1_transform (plain_t *plains, digest_sha1_sse2_t *digests)
3246 {
3247 __m128i block[16];
3248
3249 transpose_to_di4_sse2 (plains[0].buf128, plains[1].buf128, plains[2].buf128, plains[3].buf128, block);
3250
3251 hashcat_sha1_64 (digests->buf128, block);
3252 }
3253
sha256_transform(plain_t * plains,digest_sha256_sse2_t * digests)3254 void sha256_transform (plain_t *plains, digest_sha256_sse2_t *digests)
3255 {
3256 __m128i block[16];
3257
3258 transpose_to_di4_sse2 (plains[0].buf128, plains[1].buf128, plains[2].buf128, plains[3].buf128, block);
3259
3260 hashcat_sha256_64 (digests->buf128, block);
3261 }
3262
sha512_transform(plain_t * plains,digest_sha512_sse2_t * digests)3263 void sha512_transform (plain_t *plains, digest_sha512_sse2_t *digests)
3264 {
3265 uint64_t block[16][2] __attribute__ ((aligned (16)));
3266 uint64_t digest[8][2] __attribute__ ((aligned (16)));
3267
3268 int i;
3269
3270 for (i = 0; i < 16; i++)
3271 {
3272 block[i][0] = plains[0].buf64[i];
3273 block[i][1] = plains[1].buf64[i];
3274 }
3275
3276 for (i = 0; i < 8; i++)
3277 {
3278 digest[i][0] = digests->buf64[(i * 4) + 0];
3279 digest[i][1] = digests->buf64[(i * 4) + 1];
3280 }
3281
3282 hashcat_sha512_64 ((__m128i *) digest, (__m128i *) block);
3283
3284 for (i = 0; i < 8; i++)
3285 {
3286 digests->buf64[(i * 4) + 0] = digest[i][0];
3287 digests->buf64[(i * 4) + 1] = digest[i][1];
3288 }
3289
3290 for (i = 0; i < 16; i++)
3291 {
3292 block[i][0] = plains[2].buf64[i];
3293 block[i][1] = plains[3].buf64[i];
3294 }
3295
3296 for (i = 0; i < 8; i++)
3297 {
3298 digest[i][0] = digests->buf64[(i * 4) + 2];
3299 digest[i][1] = digests->buf64[(i * 4) + 3];
3300 }
3301
3302 hashcat_sha512_64 ((__m128i *) digest, (__m128i *) block);
3303
3304 for (i = 0; i < 8; i++)
3305 {
3306 digests->buf64[(i * 4) + 2] = digest[i][0];
3307 digests->buf64[(i * 4) + 3] = digest[i][1];
3308 }
3309 }
3310
3311 // full featured
3312
md4_init_sse2(digest_md4_sse2_t * digests)3313 void md4_init_sse2 (digest_md4_sse2_t *digests)
3314 {
3315 uint32_t *ptr = digests->buf32;
3316
3317 *ptr++ = MD4M_A;
3318 *ptr++ = MD4M_A;
3319 *ptr++ = MD4M_A;
3320 *ptr++ = MD4M_A;
3321 *ptr++ = MD4M_B;
3322 *ptr++ = MD4M_B;
3323 *ptr++ = MD4M_B;
3324 *ptr++ = MD4M_B;
3325 *ptr++ = MD4M_C;
3326 *ptr++ = MD4M_C;
3327 *ptr++ = MD4M_C;
3328 *ptr++ = MD4M_C;
3329 *ptr++ = MD4M_D;
3330 *ptr++ = MD4M_D;
3331 *ptr++ = MD4M_D;
3332 *ptr = MD4M_D;
3333 }
3334
md5_init_sse2(digest_md5_sse2_t * digests)3335 void md5_init_sse2 (digest_md5_sse2_t *digests)
3336 {
3337 uint32_t *ptr = digests->buf32;
3338
3339 *ptr++ = MD5M_A;
3340 *ptr++ = MD5M_A;
3341 *ptr++ = MD5M_A;
3342 *ptr++ = MD5M_A;
3343 *ptr++ = MD5M_B;
3344 *ptr++ = MD5M_B;
3345 *ptr++ = MD5M_B;
3346 *ptr++ = MD5M_B;
3347 *ptr++ = MD5M_C;
3348 *ptr++ = MD5M_C;
3349 *ptr++ = MD5M_C;
3350 *ptr++ = MD5M_C;
3351 *ptr++ = MD5M_D;
3352 *ptr++ = MD5M_D;
3353 *ptr++ = MD5M_D;
3354 *ptr = MD5M_D;
3355 }
3356
sha1_init_sse2(digest_sha1_sse2_t * digests)3357 void sha1_init_sse2 (digest_sha1_sse2_t *digests)
3358 {
3359 uint32_t *ptr = digests->buf32;
3360
3361 *ptr++ = SHA1M_A;
3362 *ptr++ = SHA1M_A;
3363 *ptr++ = SHA1M_A;
3364 *ptr++ = SHA1M_A;
3365 *ptr++ = SHA1M_B;
3366 *ptr++ = SHA1M_B;
3367 *ptr++ = SHA1M_B;
3368 *ptr++ = SHA1M_B;
3369 *ptr++ = SHA1M_C;
3370 *ptr++ = SHA1M_C;
3371 *ptr++ = SHA1M_C;
3372 *ptr++ = SHA1M_C;
3373 *ptr++ = SHA1M_D;
3374 *ptr++ = SHA1M_D;
3375 *ptr++ = SHA1M_D;
3376 *ptr++ = SHA1M_D;
3377 *ptr++ = SHA1M_E;
3378 *ptr++ = SHA1M_E;
3379 *ptr++ = SHA1M_E;
3380 *ptr = SHA1M_E;
3381 }
3382
sha256_init_sse2(digest_sha256_sse2_t * digests)3383 void sha256_init_sse2 (digest_sha256_sse2_t *digests)
3384 {
3385 uint32_t *ptr = digests->buf32;
3386
3387 *ptr++ = SHA256M_A;
3388 *ptr++ = SHA256M_A;
3389 *ptr++ = SHA256M_A;
3390 *ptr++ = SHA256M_A;
3391 *ptr++ = SHA256M_B;
3392 *ptr++ = SHA256M_B;
3393 *ptr++ = SHA256M_B;
3394 *ptr++ = SHA256M_B;
3395 *ptr++ = SHA256M_C;
3396 *ptr++ = SHA256M_C;
3397 *ptr++ = SHA256M_C;
3398 *ptr++ = SHA256M_C;
3399 *ptr++ = SHA256M_D;
3400 *ptr++ = SHA256M_D;
3401 *ptr++ = SHA256M_D;
3402 *ptr++ = SHA256M_D;
3403 *ptr++ = SHA256M_E;
3404 *ptr++ = SHA256M_E;
3405 *ptr++ = SHA256M_E;
3406 *ptr++ = SHA256M_E;
3407 *ptr++ = SHA256M_F;
3408 *ptr++ = SHA256M_F;
3409 *ptr++ = SHA256M_F;
3410 *ptr++ = SHA256M_F;
3411 *ptr++ = SHA256M_G;
3412 *ptr++ = SHA256M_G;
3413 *ptr++ = SHA256M_G;
3414 *ptr++ = SHA256M_G;
3415 *ptr++ = SHA256M_H;
3416 *ptr++ = SHA256M_H;
3417 *ptr++ = SHA256M_H;
3418 *ptr = SHA256M_H;
3419 }
3420
sha512_init_sse2(digest_sha512_sse2_t * digests)3421 void sha512_init_sse2 (digest_sha512_sse2_t *digests)
3422 {
3423 uint64_t *ptr = digests->buf64;
3424
3425 *ptr++ = SHA512M_A;
3426 *ptr++ = SHA512M_A;
3427 *ptr++ = SHA512M_A;
3428 *ptr++ = SHA512M_A;
3429 *ptr++ = SHA512M_B;
3430 *ptr++ = SHA512M_B;
3431 *ptr++ = SHA512M_B;
3432 *ptr++ = SHA512M_B;
3433 *ptr++ = SHA512M_C;
3434 *ptr++ = SHA512M_C;
3435 *ptr++ = SHA512M_C;
3436 *ptr++ = SHA512M_C;
3437 *ptr++ = SHA512M_D;
3438 *ptr++ = SHA512M_D;
3439 *ptr++ = SHA512M_D;
3440 *ptr++ = SHA512M_D;
3441 *ptr++ = SHA512M_E;
3442 *ptr++ = SHA512M_E;
3443 *ptr++ = SHA512M_E;
3444 *ptr++ = SHA512M_E;
3445 *ptr++ = SHA512M_F;
3446 *ptr++ = SHA512M_F;
3447 *ptr++ = SHA512M_F;
3448 *ptr++ = SHA512M_F;
3449 *ptr++ = SHA512M_G;
3450 *ptr++ = SHA512M_G;
3451 *ptr++ = SHA512M_G;
3452 *ptr++ = SHA512M_G;
3453 *ptr++ = SHA512M_H;
3454 *ptr++ = SHA512M_H;
3455 *ptr++ = SHA512M_H;
3456 *ptr = SHA512M_H;
3457 }
3458
md4_update_sse2(plain_t * plains_dst,digest_md4_sse2_t * digests,plain_t * plains_src)3459 void md4_update_sse2 (plain_t *plains_dst, digest_md4_sse2_t *digests, plain_t *plains_src)
3460 {
3461 uint8_t *buf[4];
3462
3463 buf[0] = plains_src[0].buf8;
3464 buf[1] = plains_src[1].buf8;
3465 buf[2] = plains_src[2].buf8;
3466 buf[3] = plains_src[3].buf8;
3467
3468 int len[4];
3469
3470 len[0] = plains_src[0].len;
3471 len[1] = plains_src[1].len;
3472 len[2] = plains_src[2].len;
3473 len[3] = plains_src[3].len;
3474
3475 int left[4];
3476
3477 left[0] = plains_dst[0].len & 0x3f;
3478 left[1] = plains_dst[1].len & 0x3f;
3479 left[2] = plains_dst[2].len & 0x3f;
3480 left[3] = plains_dst[3].len & 0x3f;
3481
3482 int need_update = 0;
3483
3484 plains_dst[0].len += len[0];
3485 plains_dst[1].len += len[1];
3486 plains_dst[2].len += len[2];
3487 plains_dst[3].len += len[3];
3488
3489 int i;
3490
3491 for (i = 0; i < 4; i++)
3492 {
3493 if ((left[i] + len[i]) < 64)
3494 {
3495 memcpy (plains_dst[i].buf8 + left[i], buf[i], len[i]);
3496
3497 continue;
3498 }
3499
3500 memcpy (plains_dst[i].buf8 + left[i], buf[i], 64 - left[i]);
3501
3502 need_update |= 1 << i;
3503 }
3504
3505 if (need_update == 0) return;
3506
3507 // this is to not modify digests that do not require a transform
3508 // otherwise we will copy the tmp digests to the actual digests later
3509
3510 digest_md4_sse2_t digests_tmp;
3511
3512 memcpy (&digests_tmp, digests, sizeof (digest_md4_sse2_t));
3513
3514 md4_transform (plains_dst, &digests_tmp);
3515
3516 // usually a while () whould come next to iterate through the entire input buffer space
3517 // but in our case not since we can guarantee input buffer had just a maximum length of 64
3518
3519 for (i = 0; i < 4; i++)
3520 {
3521 if (need_update & (1 << i))
3522 {
3523 digests->buf32[i + 0] = digests_tmp.buf32[i + 0];
3524 digests->buf32[i + 4] = digests_tmp.buf32[i + 4];
3525 digests->buf32[i + 8] = digests_tmp.buf32[i + 8];
3526 digests->buf32[i + 12] = digests_tmp.buf32[i + 12];
3527
3528 buf[i] += 64 - left[i];
3529 len[i] -= 64 - left[i];
3530
3531 memcpy (plains_dst[i].buf8, buf[i], len[i]);
3532 }
3533 }
3534 }
3535
md5_update_sse2(plain_t * plains_dst,digest_md5_sse2_t * digests,plain_t * plains_src)3536 void md5_update_sse2 (plain_t *plains_dst, digest_md5_sse2_t *digests, plain_t *plains_src)
3537 {
3538 uint8_t *buf[4];
3539
3540 buf[0] = plains_src[0].buf8;
3541 buf[1] = plains_src[1].buf8;
3542 buf[2] = plains_src[2].buf8;
3543 buf[3] = plains_src[3].buf8;
3544
3545 int len[4];
3546
3547 len[0] = plains_src[0].len;
3548 len[1] = plains_src[1].len;
3549 len[2] = plains_src[2].len;
3550 len[3] = plains_src[3].len;
3551
3552 int left[4];
3553
3554 left[0] = plains_dst[0].len & 0x3f;
3555 left[1] = plains_dst[1].len & 0x3f;
3556 left[2] = plains_dst[2].len & 0x3f;
3557 left[3] = plains_dst[3].len & 0x3f;
3558
3559 int need_update = 0;
3560
3561 plains_dst[0].len += len[0];
3562 plains_dst[1].len += len[1];
3563 plains_dst[2].len += len[2];
3564 plains_dst[3].len += len[3];
3565
3566 int i;
3567
3568 for (i = 0; i < 4; i++)
3569 {
3570 if ((left[i] + len[i]) < 64)
3571 {
3572 memcpy (plains_dst[i].buf8 + left[i], buf[i], len[i]);
3573
3574 continue;
3575 }
3576
3577 memcpy (plains_dst[i].buf8 + left[i], buf[i], 64 - left[i]);
3578
3579 need_update |= 1 << i;
3580 }
3581
3582 if (need_update == 0) return;
3583
3584 // this is to not modify digests that do not require a transform
3585 // otherwise we will copy the tmp digests to the actual digests later
3586
3587 digest_md5_sse2_t digests_tmp;
3588
3589 memcpy (&digests_tmp, digests, sizeof (digest_md5_sse2_t));
3590
3591 md5_transform (plains_dst, &digests_tmp);
3592
3593 // usually a while () whould come next to iterate through the entire input buffer space
3594 // but in our case not since we can guarantee input buffer had just a maximum length of 64
3595
3596 for (i = 0; i < 4; i++)
3597 {
3598 if (need_update & (1 << i))
3599 {
3600 digests->buf32[i + 0] = digests_tmp.buf32[i + 0];
3601 digests->buf32[i + 4] = digests_tmp.buf32[i + 4];
3602 digests->buf32[i + 8] = digests_tmp.buf32[i + 8];
3603 digests->buf32[i + 12] = digests_tmp.buf32[i + 12];
3604
3605 buf[i] += 64 - left[i];
3606 len[i] -= 64 - left[i];
3607
3608 memcpy (plains_dst[i].buf8, buf[i], len[i]);
3609 }
3610 }
3611 }
3612
sha1_update_sse2(plain_t * plains_dst,digest_sha1_sse2_t * digests,plain_t * plains_src)3613 void sha1_update_sse2 (plain_t *plains_dst, digest_sha1_sse2_t *digests, plain_t *plains_src)
3614 {
3615 uint8_t *buf[4];
3616
3617 buf[0] = plains_src[0].buf8;
3618 buf[1] = plains_src[1].buf8;
3619 buf[2] = plains_src[2].buf8;
3620 buf[3] = plains_src[3].buf8;
3621
3622 int len[4];
3623
3624 len[0] = plains_src[0].len;
3625 len[1] = plains_src[1].len;
3626 len[2] = plains_src[2].len;
3627 len[3] = plains_src[3].len;
3628
3629 int left[4];
3630
3631 left[0] = plains_dst[0].len & 0x3f;
3632 left[1] = plains_dst[1].len & 0x3f;
3633 left[2] = plains_dst[2].len & 0x3f;
3634 left[3] = plains_dst[3].len & 0x3f;
3635
3636 int need_update = 0;
3637
3638 plains_dst[0].len += len[0];
3639 plains_dst[1].len += len[1];
3640 plains_dst[2].len += len[2];
3641 plains_dst[3].len += len[3];
3642
3643 int i;
3644
3645 for (i = 0; i < 4; i++)
3646 {
3647 if ((left[i] + len[i]) < 64)
3648 {
3649 memcpy (plains_dst[i].buf8 + left[i], buf[i], len[i]);
3650
3651 continue;
3652 }
3653
3654 memcpy (plains_dst[i].buf8 + left[i], buf[i], 64 - left[i]);
3655
3656 need_update |= 1 << i;
3657 }
3658
3659 if (need_update == 0) return;
3660
3661 // this is to not modify digests that do not require a transform
3662 // otherwise we will copy the tmp digests to the actual digests later
3663
3664 digest_sha1_sse2_t digests_tmp;
3665
3666 memcpy (&digests_tmp, digests, sizeof (digest_sha1_sse2_t));
3667
3668 sha1_transform (plains_dst, &digests_tmp);
3669
3670 // usually a while () whould come next to iterate through the entire input buffer space
3671 // but in our case not since we can guarantee input buffer had just a maximum length of 64
3672
3673 for (i = 0; i < 4; i++)
3674 {
3675 if (need_update & (1 << i))
3676 {
3677 digests->buf32[i + 0] = digests_tmp.buf32[i + 0];
3678 digests->buf32[i + 4] = digests_tmp.buf32[i + 4];
3679 digests->buf32[i + 8] = digests_tmp.buf32[i + 8];
3680 digests->buf32[i + 12] = digests_tmp.buf32[i + 12];
3681 digests->buf32[i + 16] = digests_tmp.buf32[i + 16];
3682
3683 buf[i] += 64 - left[i];
3684 len[i] -= 64 - left[i];
3685
3686 memcpy (plains_dst[i].buf8, buf[i], len[i]);
3687 }
3688 }
3689 }
3690
sha256_update_sse2(plain_t * plains_dst,digest_sha256_sse2_t * digests,plain_t * plains_src)3691 void sha256_update_sse2 (plain_t *plains_dst, digest_sha256_sse2_t *digests, plain_t *plains_src)
3692 {
3693 uint8_t *buf[4];
3694
3695 buf[0] = plains_src[0].buf8;
3696 buf[1] = plains_src[1].buf8;
3697 buf[2] = plains_src[2].buf8;
3698 buf[3] = plains_src[3].buf8;
3699
3700 int len[4];
3701
3702 len[0] = plains_src[0].len;
3703 len[1] = plains_src[1].len;
3704 len[2] = plains_src[2].len;
3705 len[3] = plains_src[3].len;
3706
3707 int left[4];
3708
3709 left[0] = plains_dst[0].len & 0x3f;
3710 left[1] = plains_dst[1].len & 0x3f;
3711 left[2] = plains_dst[2].len & 0x3f;
3712 left[3] = plains_dst[3].len & 0x3f;
3713
3714 int need_update = 0;
3715
3716 plains_dst[0].len += len[0];
3717 plains_dst[1].len += len[1];
3718 plains_dst[2].len += len[2];
3719 plains_dst[3].len += len[3];
3720
3721 int i;
3722
3723 for (i = 0; i < 4; i++)
3724 {
3725 if ((left[i] + len[i]) < 64)
3726 {
3727 memcpy (plains_dst[i].buf8 + left[i], buf[i], len[i]);
3728
3729 continue;
3730 }
3731
3732 memcpy (plains_dst[i].buf8 + left[i], buf[i], 64 - left[i]);
3733
3734 need_update |= 1 << i;
3735 }
3736
3737 if (need_update == 0) return;
3738
3739 // this is to not modify digests that do not require a transform
3740 // otherwise we will copy the tmp digests to the actual digests later
3741
3742 digest_sha256_sse2_t digests_tmp;
3743
3744 memcpy (&digests_tmp, digests, sizeof (digest_sha256_sse2_t));
3745
3746 sha256_transform (plains_dst, &digests_tmp);
3747
3748 // usually a while () whould come next to iterate through the entire input buffer space
3749 // but in our case not since we can guarantee input buffer had just a maximum length of 64
3750
3751 for (i = 0; i < 4; i++)
3752 {
3753 if (need_update & (1 << i))
3754 {
3755 digests->buf32[i + 0] = digests_tmp.buf32[i + 0];
3756 digests->buf32[i + 4] = digests_tmp.buf32[i + 4];
3757 digests->buf32[i + 8] = digests_tmp.buf32[i + 8];
3758 digests->buf32[i + 12] = digests_tmp.buf32[i + 12];
3759 digests->buf32[i + 16] = digests_tmp.buf32[i + 16];
3760 digests->buf32[i + 20] = digests_tmp.buf32[i + 20];
3761 digests->buf32[i + 24] = digests_tmp.buf32[i + 24];
3762 digests->buf32[i + 28] = digests_tmp.buf32[i + 28];
3763
3764 buf[i] += 64 - left[i];
3765 len[i] -= 64 - left[i];
3766
3767 memcpy (plains_dst[i].buf8, buf[i], len[i]);
3768 }
3769 }
3770 }
3771
sha512_update_sse2(plain_t * plains_dst,digest_sha512_sse2_t * digests,plain_t * plains_src)3772 void sha512_update_sse2 (plain_t *plains_dst, digest_sha512_sse2_t *digests, plain_t *plains_src)
3773 {
3774 uint8_t *buf[4];
3775
3776 buf[0] = plains_src[0].buf8;
3777 buf[1] = plains_src[1].buf8;
3778 buf[2] = plains_src[2].buf8;
3779 buf[3] = plains_src[3].buf8;
3780
3781 int len[4];
3782
3783 len[0] = plains_src[0].len;
3784 len[1] = plains_src[1].len;
3785 len[2] = plains_src[2].len;
3786 len[3] = plains_src[3].len;
3787
3788 int left[4];
3789
3790 left[0] = plains_dst[0].len & 0x7f;
3791 left[1] = plains_dst[1].len & 0x7f;
3792 left[2] = plains_dst[2].len & 0x7f;
3793 left[3] = plains_dst[3].len & 0x7f;
3794
3795 int need_update = 0;
3796
3797 plains_dst[0].len += len[0];
3798 plains_dst[1].len += len[1];
3799 plains_dst[2].len += len[2];
3800 plains_dst[3].len += len[3];
3801
3802 int i;
3803
3804 for (i = 0; i < 4; i++)
3805 {
3806 if ((left[i] + len[i]) < 128)
3807 {
3808 memcpy (plains_dst[i].buf8 + left[i], buf[i], len[i]);
3809
3810 continue;
3811 }
3812
3813 memcpy (plains_dst[i].buf8 + left[i], buf[i], 128 - left[i]);
3814
3815 need_update |= 1 << i;
3816 }
3817
3818 if (need_update == 0) return;
3819
3820 // this is to not modify digests that do not require a transform
3821 // otherwise we will copy the tmp digests to the actual digests later
3822
3823 digest_sha512_sse2_t digests_tmp;
3824
3825 memcpy (&digests_tmp, digests, sizeof (digest_sha512_sse2_t));
3826
3827 sha512_transform (plains_dst, &digests_tmp);
3828
3829 // usually a while () whould come next to iterate through the entire input buffer space
3830 // but in our case not since we can guarantee input buffer had just a maximum length of 128
3831
3832 for (i = 0; i < 4; i++)
3833 {
3834 if (need_update & (1 << i))
3835 {
3836 digests->buf64[i + 0] = digests_tmp.buf64[i + 0];
3837 digests->buf64[i + 4] = digests_tmp.buf64[i + 4];
3838 digests->buf64[i + 8] = digests_tmp.buf64[i + 8];
3839 digests->buf64[i + 12] = digests_tmp.buf64[i + 12];
3840 digests->buf64[i + 16] = digests_tmp.buf64[i + 16];
3841 digests->buf64[i + 20] = digests_tmp.buf64[i + 20];
3842 digests->buf64[i + 24] = digests_tmp.buf64[i + 24];
3843 digests->buf64[i + 28] = digests_tmp.buf64[i + 28];
3844
3845 buf[i] += 128 - left[i];
3846 len[i] -= 128 - left[i];
3847
3848 memcpy (plains_dst[i].buf8, buf[i], len[i]);
3849 }
3850 }
3851 }
3852
md4_final_sse2(plain_t * plains,digest_md4_sse2_t * digests)3853 void md4_final_sse2 (plain_t *plains, digest_md4_sse2_t *digests)
3854 {
3855 uint8_t *buf[4];
3856
3857 buf[0] = plains[0].buf8;
3858 buf[1] = plains[1].buf8;
3859 buf[2] = plains[2].buf8;
3860 buf[3] = plains[3].buf8;
3861
3862 int len[4];
3863
3864 len[0] = plains[0].len;
3865 len[1] = plains[1].len;
3866 len[2] = plains[2].len;
3867 len[3] = plains[3].len;
3868
3869 int left[4];
3870
3871 left[0] = len[0] & 0x3f;
3872 left[1] = len[1] & 0x3f;
3873 left[2] = len[2] & 0x3f;
3874 left[3] = len[3] & 0x3f;
3875
3876 int need_update = 0;
3877
3878 int i;
3879
3880 for (i = 0; i < 4; i++)
3881 {
3882 memset (buf[i] + left[i], 0, 64 - left[i]);
3883
3884 buf[i][left[i]] = 0x80;
3885
3886 if (left[i] < 56)
3887 {
3888 plains[i].buf[14] = len[i] * 8;
3889 plains[i].buf[15] = 0;
3890
3891 continue;
3892 }
3893
3894 need_update |= 1 << i;
3895 }
3896
3897 if (need_update)
3898 {
3899 digest_md4_sse2_t digests_tmp;
3900
3901 memcpy (&digests_tmp, digests, sizeof (digest_md4_sse2_t));
3902
3903 md4_transform (plains, &digests_tmp);
3904
3905 for (i = 0; i < 4; i++)
3906 {
3907 if (need_update & (1 << i))
3908 {
3909 digests->buf32[i + 0] = digests_tmp.buf32[i + 0];
3910 digests->buf32[i + 4] = digests_tmp.buf32[i + 4];
3911 digests->buf32[i + 8] = digests_tmp.buf32[i + 8];
3912 digests->buf32[i + 12] = digests_tmp.buf32[i + 12];
3913
3914 memset (buf[i], 0, 64);
3915
3916 plains[i].buf[14] = len[i] * 8;
3917 }
3918 }
3919 }
3920
3921 md4_transform (plains, digests);
3922 }
3923
md5_final_sse2(plain_t * plains,digest_md5_sse2_t * digests)3924 void md5_final_sse2 (plain_t *plains, digest_md5_sse2_t *digests)
3925 {
3926 uint8_t *buf[4];
3927
3928 buf[0] = plains[0].buf8;
3929 buf[1] = plains[1].buf8;
3930 buf[2] = plains[2].buf8;
3931 buf[3] = plains[3].buf8;
3932
3933 int len[4];
3934
3935 len[0] = plains[0].len;
3936 len[1] = plains[1].len;
3937 len[2] = plains[2].len;
3938 len[3] = plains[3].len;
3939
3940 int left[4];
3941
3942 left[0] = len[0] & 0x3f;
3943 left[1] = len[1] & 0x3f;
3944 left[2] = len[2] & 0x3f;
3945 left[3] = len[3] & 0x3f;
3946
3947 int need_update = 0;
3948
3949 int i;
3950
3951 for (i = 0; i < 4; i++)
3952 {
3953 memset (buf[i] + left[i], 0, 64 - left[i]);
3954
3955 buf[i][left[i]] = 0x80;
3956
3957 if (left[i] < 56)
3958 {
3959 plains[i].buf[14] = len[i] * 8;
3960 plains[i].buf[15] = 0;
3961
3962 continue;
3963 }
3964
3965 need_update |= 1 << i;
3966 }
3967
3968 if (need_update)
3969 {
3970 digest_md5_sse2_t digests_tmp;
3971
3972 memcpy (&digests_tmp, digests, sizeof (digest_md5_sse2_t));
3973
3974 md5_transform (plains, &digests_tmp);
3975
3976 for (i = 0; i < 4; i++)
3977 {
3978 if (need_update & (1 << i))
3979 {
3980 digests->buf32[i + 0] = digests_tmp.buf32[i + 0];
3981 digests->buf32[i + 4] = digests_tmp.buf32[i + 4];
3982 digests->buf32[i + 8] = digests_tmp.buf32[i + 8];
3983 digests->buf32[i + 12] = digests_tmp.buf32[i + 12];
3984
3985 memset (buf[i], 0, 64);
3986
3987 plains[i].buf[14] = len[i] * 8;
3988 }
3989 }
3990 }
3991
3992 md5_transform (plains, digests);
3993 }
3994
sha1_final_sse2(plain_t * plains,digest_sha1_sse2_t * digests)3995 void sha1_final_sse2 (plain_t *plains, digest_sha1_sse2_t *digests)
3996 {
3997 uint8_t *buf[4];
3998
3999 buf[0] = plains[0].buf8;
4000 buf[1] = plains[1].buf8;
4001 buf[2] = plains[2].buf8;
4002 buf[3] = plains[3].buf8;
4003
4004 int len[4];
4005
4006 len[0] = plains[0].len;
4007 len[1] = plains[1].len;
4008 len[2] = plains[2].len;
4009 len[3] = plains[3].len;
4010
4011 int left[4];
4012
4013 left[0] = len[0] & 0x3f;
4014 left[1] = len[1] & 0x3f;
4015 left[2] = len[2] & 0x3f;
4016 left[3] = len[3] & 0x3f;
4017
4018 int need_update = 0;
4019
4020 int i;
4021
4022 for (i = 0; i < 4; i++)
4023 {
4024 memset (buf[i] + left[i], 0, 64 - left[i]);
4025
4026 buf[i][left[i]] = 0x80;
4027
4028 if (left[i] < 56)
4029 {
4030 plains[i].buf[14] = 0;
4031 plains[i].buf[15] = len[i] * 8;
4032
4033 BYTESWAP (plains[i].buf[15]);
4034
4035 continue;
4036 }
4037
4038 need_update |= 1 << i;
4039 }
4040
4041 if (need_update)
4042 {
4043 digest_sha1_sse2_t digests_tmp;
4044
4045 memcpy (&digests_tmp, digests, sizeof (digest_sha1_sse2_t));
4046
4047 sha1_transform (plains, &digests_tmp);
4048
4049 for (i = 0; i < 4; i++)
4050 {
4051 if (need_update & (1 << i))
4052 {
4053 digests->buf32[i + 0] = digests_tmp.buf32[i + 0];
4054 digests->buf32[i + 4] = digests_tmp.buf32[i + 4];
4055 digests->buf32[i + 8] = digests_tmp.buf32[i + 8];
4056 digests->buf32[i + 12] = digests_tmp.buf32[i + 12];
4057 digests->buf32[i + 16] = digests_tmp.buf32[i + 16];
4058
4059 memset (buf[i], 0, 64);
4060
4061 plains[i].buf[15] = len[i] * 8;
4062
4063 BYTESWAP (plains[i].buf[15]);
4064 }
4065 }
4066 }
4067
4068 sha1_transform (plains, digests);
4069 }
4070
sha256_final_sse2(plain_t * plains,digest_sha256_sse2_t * digests)4071 void sha256_final_sse2 (plain_t *plains, digest_sha256_sse2_t *digests)
4072 {
4073 uint8_t *buf[4];
4074
4075 buf[0] = plains[0].buf8;
4076 buf[1] = plains[1].buf8;
4077 buf[2] = plains[2].buf8;
4078 buf[3] = plains[3].buf8;
4079
4080 int len[4];
4081
4082 len[0] = plains[0].len;
4083 len[1] = plains[1].len;
4084 len[2] = plains[2].len;
4085 len[3] = plains[3].len;
4086
4087 int left[4];
4088
4089 left[0] = len[0] & 0x3f;
4090 left[1] = len[1] & 0x3f;
4091 left[2] = len[2] & 0x3f;
4092 left[3] = len[3] & 0x3f;
4093
4094 int need_update = 0;
4095
4096 int i;
4097
4098 for (i = 0; i < 4; i++)
4099 {
4100 memset (buf[i] + left[i], 0, 64 - left[i]);
4101
4102 buf[i][left[i]] = 0x80;
4103
4104 if (left[i] < 56)
4105 {
4106 plains[i].buf[14] = 0;
4107 plains[i].buf[15] = len[i] * 8;
4108
4109 BYTESWAP (plains[i].buf[15]);
4110
4111 continue;
4112 }
4113
4114 need_update |= 1 << i;
4115 }
4116
4117 if (need_update)
4118 {
4119 digest_sha256_sse2_t digests_tmp;
4120
4121 memcpy (&digests_tmp, digests, sizeof (digest_sha256_sse2_t));
4122
4123 sha256_transform (plains, &digests_tmp);
4124
4125 for (i = 0; i < 4; i++)
4126 {
4127 if (need_update & (1 << i))
4128 {
4129 digests->buf32[i + 0] = digests_tmp.buf32[i + 0];
4130 digests->buf32[i + 4] = digests_tmp.buf32[i + 4];
4131 digests->buf32[i + 8] = digests_tmp.buf32[i + 8];
4132 digests->buf32[i + 12] = digests_tmp.buf32[i + 12];
4133 digests->buf32[i + 16] = digests_tmp.buf32[i + 16];
4134 digests->buf32[i + 20] = digests_tmp.buf32[i + 20];
4135 digests->buf32[i + 24] = digests_tmp.buf32[i + 24];
4136 digests->buf32[i + 28] = digests_tmp.buf32[i + 28];
4137
4138 memset (buf[i], 0, 64);
4139
4140 plains[i].buf[15] = len[i] * 8;
4141
4142 BYTESWAP (plains[i].buf[15]);
4143 }
4144 }
4145 }
4146
4147 sha256_transform (plains, digests);
4148 }
4149
sha256_init(hc_sha256_ctx * ctx)4150 void sha256_init (hc_sha256_ctx *ctx)
4151 {
4152 ctx->state[0] = SHA256M_A;
4153 ctx->state[1] = SHA256M_B;
4154 ctx->state[2] = SHA256M_C;
4155 ctx->state[3] = SHA256M_D;
4156 ctx->state[4] = SHA256M_E;
4157 ctx->state[5] = SHA256M_F;
4158 ctx->state[6] = SHA256M_G;
4159 ctx->state[7] = SHA256M_H;
4160
4161 ctx->len = 0;
4162 }
4163
sha256_update(hc_sha256_ctx * ctx,const char * buf,int len)4164 void sha256_update (hc_sha256_ctx *ctx, const char *buf, int len)
4165 {
4166 int left = ctx->len & 0x3f;
4167
4168 ctx->len += len;
4169
4170 if (left + len < 64)
4171 {
4172 memcpy (ctx->buf + left, buf, len);
4173
4174 return;
4175 }
4176
4177 memcpy (ctx->buf + left, buf, 64 - left);
4178
4179 BYTESWAP (ctx->w[ 0]);
4180 BYTESWAP (ctx->w[ 1]);
4181 BYTESWAP (ctx->w[ 2]);
4182 BYTESWAP (ctx->w[ 3]);
4183 BYTESWAP (ctx->w[ 4]);
4184 BYTESWAP (ctx->w[ 5]);
4185 BYTESWAP (ctx->w[ 6]);
4186 BYTESWAP (ctx->w[ 7]);
4187 BYTESWAP (ctx->w[ 8]);
4188 BYTESWAP (ctx->w[ 9]);
4189 BYTESWAP (ctx->w[10]);
4190 BYTESWAP (ctx->w[11]);
4191 BYTESWAP (ctx->w[12]);
4192 BYTESWAP (ctx->w[13]);
4193 BYTESWAP (ctx->w[14]);
4194 BYTESWAP (ctx->w[15]);
4195
4196 hashcat_sha256 (ctx->state, ctx->w);
4197
4198 buf += 64 - left;
4199 len -= 64 - left;
4200
4201 while (len >= 64)
4202 {
4203
4204 memcpy (ctx->buf, buf, 64);
4205
4206 BYTESWAP (ctx->w[ 0]);
4207 BYTESWAP (ctx->w[ 1]);
4208 BYTESWAP (ctx->w[ 2]);
4209 BYTESWAP (ctx->w[ 3]);
4210 BYTESWAP (ctx->w[ 4]);
4211 BYTESWAP (ctx->w[ 5]);
4212 BYTESWAP (ctx->w[ 6]);
4213 BYTESWAP (ctx->w[ 7]);
4214 BYTESWAP (ctx->w[ 8]);
4215 BYTESWAP (ctx->w[ 9]);
4216 BYTESWAP (ctx->w[10]);
4217 BYTESWAP (ctx->w[11]);
4218 BYTESWAP (ctx->w[12]);
4219 BYTESWAP (ctx->w[13]);
4220 BYTESWAP (ctx->w[14]);
4221 BYTESWAP (ctx->w[15]);
4222
4223 hashcat_sha256 (ctx->state, ctx->w);
4224
4225 buf += 64;
4226 len -= 64;
4227 }
4228
4229 memcpy (ctx->buf, buf, len);
4230 }
4231
sha256_final(hc_sha256_ctx * ctx)4232 void sha256_final (hc_sha256_ctx *ctx)
4233 {
4234 int left = ctx->len & 0x3f;
4235
4236 memset (ctx->buf + left, 0, 64 - left);
4237
4238 ctx->buf[left] = 0x80;
4239
4240 BYTESWAP (ctx->w[ 0]);
4241 BYTESWAP (ctx->w[ 1]);
4242 BYTESWAP (ctx->w[ 2]);
4243 BYTESWAP (ctx->w[ 3]);
4244 BYTESWAP (ctx->w[ 4]);
4245 BYTESWAP (ctx->w[ 5]);
4246 BYTESWAP (ctx->w[ 6]);
4247 BYTESWAP (ctx->w[ 7]);
4248 BYTESWAP (ctx->w[ 8]);
4249 BYTESWAP (ctx->w[ 9]);
4250 BYTESWAP (ctx->w[10]);
4251 BYTESWAP (ctx->w[11]);
4252 BYTESWAP (ctx->w[12]);
4253 BYTESWAP (ctx->w[13]);
4254
4255 if (left >= 56)
4256 {
4257 BYTESWAP (ctx->w[14]);
4258 BYTESWAP (ctx->w[15]);
4259
4260 hashcat_sha256 (ctx->state, ctx->w);
4261
4262 ctx->w[ 0] = 0;
4263 ctx->w[ 1] = 0;
4264 ctx->w[ 2] = 0;
4265 ctx->w[ 3] = 0;
4266 ctx->w[ 4] = 0;
4267 ctx->w[ 5] = 0;
4268 ctx->w[ 6] = 0;
4269 ctx->w[ 7] = 0;
4270 ctx->w[ 8] = 0;
4271 ctx->w[ 9] = 0;
4272 ctx->w[10] = 0;
4273 ctx->w[11] = 0;
4274 ctx->w[12] = 0;
4275 ctx->w[13] = 0;
4276 }
4277
4278 ctx->w[14] = 0;
4279 ctx->w[15] = ctx->len * 8;
4280
4281 hashcat_sha256 (ctx->state, ctx->w);
4282
4283 BYTESWAP (ctx->state[0]);
4284 BYTESWAP (ctx->state[1]);
4285 BYTESWAP (ctx->state[2]);
4286 BYTESWAP (ctx->state[3]);
4287 BYTESWAP (ctx->state[4]);
4288 BYTESWAP (ctx->state[5]);
4289 BYTESWAP (ctx->state[6]);
4290 BYTESWAP (ctx->state[7]);
4291 }
4292
sha512_final_sse2(plain_t * plains,digest_sha512_sse2_t * digests)4293 void sha512_final_sse2 (plain_t *plains, digest_sha512_sse2_t *digests)
4294 {
4295 uint8_t *buf[4];
4296
4297 buf[0] = plains[0].buf8;
4298 buf[1] = plains[1].buf8;
4299 buf[2] = plains[2].buf8;
4300 buf[3] = plains[3].buf8;
4301
4302 int len[4];
4303
4304 len[0] = plains[0].len;
4305 len[1] = plains[1].len;
4306 len[2] = plains[2].len;
4307 len[3] = plains[3].len;
4308
4309 int left[4];
4310
4311 left[0] = len[0] & 0x7f;
4312 left[1] = len[1] & 0x7f;
4313 left[2] = len[2] & 0x7f;
4314 left[3] = len[3] & 0x7f;
4315
4316 int need_update = 0;
4317
4318 int i;
4319
4320 for (i = 0; i < 4; i++)
4321 {
4322 memset (buf[i] + left[i], 0, 128 - left[i]);
4323
4324 buf[i][left[i]] = 0x80;
4325
4326 if (left[i] < 112)
4327 {
4328 plains[i].buf64[14] = 0;
4329 plains[i].buf64[15] = len[i] * 8;
4330
4331 BYTESWAP64 (plains[i].buf64[15]);
4332
4333 continue;
4334 }
4335
4336 need_update |= 1 << i;
4337 }
4338
4339 if (need_update)
4340 {
4341 digest_sha512_sse2_t digests_tmp;
4342
4343 memcpy (&digests_tmp, digests, sizeof (digest_sha512_sse2_t));
4344
4345 sha512_transform (plains, &digests_tmp);
4346
4347 for (i = 0; i < 4; i++)
4348 {
4349 if (need_update & (1 << i))
4350 {
4351 digests->buf64[i + 0] = digests_tmp.buf64[i + 0];
4352 digests->buf64[i + 4] = digests_tmp.buf64[i + 4];
4353 digests->buf64[i + 8] = digests_tmp.buf64[i + 8];
4354 digests->buf64[i + 12] = digests_tmp.buf64[i + 12];
4355 digests->buf64[i + 16] = digests_tmp.buf64[i + 16];
4356 digests->buf64[i + 20] = digests_tmp.buf64[i + 20];
4357 digests->buf64[i + 24] = digests_tmp.buf64[i + 24];
4358 digests->buf64[i + 28] = digests_tmp.buf64[i + 28];
4359
4360 memset (buf[i], 0, 128);
4361
4362 plains[i].buf64[15] = len[i] * 8;
4363
4364 BYTESWAP64 (plains[i].buf64[15]);
4365 }
4366 }
4367 }
4368
4369 sha512_transform (plains, digests);
4370 }
4371
4372 // ctx
4373
sha512_init(hc_sha512_ctx * ctx)4374 void sha512_init (hc_sha512_ctx *ctx)
4375 {
4376 ctx->state[0] = SHA512M_A;
4377 ctx->state[1] = SHA512M_B;
4378 ctx->state[2] = SHA512M_C;
4379 ctx->state[3] = SHA512M_D;
4380 ctx->state[4] = SHA512M_E;
4381 ctx->state[5] = SHA512M_F;
4382 ctx->state[6] = SHA512M_G;
4383 ctx->state[7] = SHA512M_H;
4384
4385 ctx->len = 0;
4386 }
4387
sha512_update(hc_sha512_ctx * ctx,const char * buf,int len)4388 void sha512_update (hc_sha512_ctx *ctx, const char *buf, int len)
4389 {
4390 int left = ctx->len & 0x7f;
4391
4392 ctx->len += len;
4393
4394 if (left + len < 128)
4395 {
4396 memcpy (ctx->buf + left, buf, len);
4397
4398 return;
4399 }
4400
4401 memcpy (ctx->buf + left, buf, 128 - left);
4402
4403 BYTESWAP64 (ctx->w[ 0]);
4404 BYTESWAP64 (ctx->w[ 1]);
4405 BYTESWAP64 (ctx->w[ 2]);
4406 BYTESWAP64 (ctx->w[ 3]);
4407 BYTESWAP64 (ctx->w[ 4]);
4408 BYTESWAP64 (ctx->w[ 5]);
4409 BYTESWAP64 (ctx->w[ 6]);
4410 BYTESWAP64 (ctx->w[ 7]);
4411 BYTESWAP64 (ctx->w[ 8]);
4412 BYTESWAP64 (ctx->w[ 9]);
4413 BYTESWAP64 (ctx->w[10]);
4414 BYTESWAP64 (ctx->w[11]);
4415 BYTESWAP64 (ctx->w[12]);
4416 BYTESWAP64 (ctx->w[13]);
4417 BYTESWAP64 (ctx->w[14]);
4418 BYTESWAP64 (ctx->w[15]);
4419
4420 hashcat_sha512 (ctx->state, ctx->w);
4421
4422 buf += 128 - left;
4423 len -= 128 - left;
4424
4425 while (len >= 128)
4426 {
4427 memcpy (ctx->buf, buf, 128);
4428
4429 BYTESWAP64 (ctx->w[ 0]);
4430 BYTESWAP64 (ctx->w[ 1]);
4431 BYTESWAP64 (ctx->w[ 2]);
4432 BYTESWAP64 (ctx->w[ 3]);
4433 BYTESWAP64 (ctx->w[ 4]);
4434 BYTESWAP64 (ctx->w[ 5]);
4435 BYTESWAP64 (ctx->w[ 6]);
4436 BYTESWAP64 (ctx->w[ 7]);
4437 BYTESWAP64 (ctx->w[ 8]);
4438 BYTESWAP64 (ctx->w[ 9]);
4439 BYTESWAP64 (ctx->w[10]);
4440 BYTESWAP64 (ctx->w[11]);
4441 BYTESWAP64 (ctx->w[12]);
4442 BYTESWAP64 (ctx->w[13]);
4443 BYTESWAP64 (ctx->w[14]);
4444 BYTESWAP64 (ctx->w[15]);
4445
4446 hashcat_sha512 (ctx->state, ctx->w);
4447
4448 buf += 128;
4449 len -= 128;
4450 }
4451
4452 memcpy (ctx->buf, buf, len);
4453 }
4454
sha512_final(hc_sha512_ctx * ctx)4455 void sha512_final (hc_sha512_ctx *ctx)
4456 {
4457 int left = ctx->len & 0x7f;
4458
4459 memset (ctx->buf + left, 0, 128 - left);
4460
4461 ctx->buf[left] = 0x80;
4462
4463 BYTESWAP64 (ctx->w[ 0]);
4464 BYTESWAP64 (ctx->w[ 1]);
4465 BYTESWAP64 (ctx->w[ 2]);
4466 BYTESWAP64 (ctx->w[ 3]);
4467 BYTESWAP64 (ctx->w[ 4]);
4468 BYTESWAP64 (ctx->w[ 5]);
4469 BYTESWAP64 (ctx->w[ 6]);
4470 BYTESWAP64 (ctx->w[ 7]);
4471 BYTESWAP64 (ctx->w[ 8]);
4472 BYTESWAP64 (ctx->w[ 9]);
4473 BYTESWAP64 (ctx->w[10]);
4474 BYTESWAP64 (ctx->w[11]);
4475 BYTESWAP64 (ctx->w[12]);
4476 BYTESWAP64 (ctx->w[13]);
4477
4478 if (left >= 112)
4479 {
4480 BYTESWAP64 (ctx->w[14]);
4481 BYTESWAP64 (ctx->w[15]);
4482
4483 hashcat_sha512 (ctx->state, ctx->w);
4484
4485 ctx->w[ 0] = 0;
4486 ctx->w[ 1] = 0;
4487 ctx->w[ 2] = 0;
4488 ctx->w[ 3] = 0;
4489 ctx->w[ 4] = 0;
4490 ctx->w[ 5] = 0;
4491 ctx->w[ 6] = 0;
4492 ctx->w[ 7] = 0;
4493 ctx->w[ 8] = 0;
4494 ctx->w[ 9] = 0;
4495 ctx->w[10] = 0;
4496 ctx->w[11] = 0;
4497 ctx->w[12] = 0;
4498 ctx->w[13] = 0;
4499 }
4500
4501 ctx->w[14] = 0;
4502 ctx->w[15] = ctx->len * 8;
4503
4504 hashcat_sha512 (ctx->state, ctx->w);
4505
4506 BYTESWAP64 (ctx->state[0]);
4507 BYTESWAP64 (ctx->state[1]);
4508 BYTESWAP64 (ctx->state[2]);
4509 BYTESWAP64 (ctx->state[3]);
4510 BYTESWAP64 (ctx->state[4]);
4511 BYTESWAP64 (ctx->state[5]);
4512 BYTESWAP64 (ctx->state[6]);
4513 BYTESWAP64 (ctx->state[7]);
4514 }
4515
4516 // max55
4517
md4_update_sse2_max55(plain_t * plains_dst,plain_t * plains_src)4518 void md4_update_sse2_max55 (plain_t *plains_dst, plain_t *plains_src)
4519 {
4520 int i;
4521
4522 for (i = 0; i < 4; i++)
4523 {
4524 plain_t *src = plains_src + i;
4525 plain_t *dst = plains_dst + i;
4526
4527 const uint32_t len = dst->len + src->len;
4528
4529 if (len >= 56) continue;
4530
4531 memcpy (dst->buf8 + dst->len, src->buf8, src->len);
4532
4533 dst->len = len;
4534 }
4535 }
4536
md5_update_sse2_max55(plain_t * plains_dst,plain_t * plains_src)4537 void md5_update_sse2_max55 (plain_t *plains_dst, plain_t *plains_src)
4538 {
4539 int i;
4540
4541 for (i = 0; i < 4; i++)
4542 {
4543 plain_t *src = plains_src + i;
4544 plain_t *dst = plains_dst + i;
4545
4546 const uint32_t len = dst->len + src->len;
4547
4548 if (len >= 56) continue;
4549
4550 memcpy (dst->buf8 + dst->len, src->buf8, src->len);
4551
4552 dst->len = len;
4553 }
4554 }
4555
sha1_update_sse2_max55(plain_t * plains_dst,plain_t * plains_src)4556 void sha1_update_sse2_max55 (plain_t *plains_dst, plain_t *plains_src)
4557 {
4558 int i;
4559
4560 for (i = 0; i < 4; i++)
4561 {
4562 plain_t *src = plains_src + i;
4563 plain_t *dst = plains_dst + i;
4564
4565 const uint32_t len = dst->len + src->len;
4566
4567 if (len >= 56) continue;
4568
4569 memcpy (dst->buf8 + dst->len, src->buf8, src->len);
4570
4571 dst->len = len;
4572 }
4573 }
4574
sha256_update_sse2_max55(plain_t * plains_dst,plain_t * plains_src)4575 void sha256_update_sse2_max55 (plain_t *plains_dst, plain_t *plains_src)
4576 {
4577 int i;
4578
4579 for (i = 0; i < 4; i++)
4580 {
4581 plain_t *src = plains_src + i;
4582 plain_t *dst = plains_dst + i;
4583
4584 const uint32_t len = dst->len + src->len;
4585
4586 if (len >= 56) continue;
4587
4588 memcpy (dst->buf8 + dst->len, src->buf8, src->len);
4589
4590 dst->len = len;
4591 }
4592 }
4593
md4_final_sse2_max55(plain_t * plains,digest_md4_sse2_t * digests)4594 void md4_final_sse2_max55 (plain_t *plains, digest_md4_sse2_t *digests)
4595 {
4596 int i;
4597
4598 for (i = 0; i < 4; i++)
4599 {
4600 plain_t *ptr = plains + i;
4601
4602 memset (ptr->buf8 + ptr->len, 0, 64 - ptr->len);
4603
4604 ptr->buf8[ptr->len] = 0x80;
4605
4606 ptr->buf[14] = ptr->len * 8;
4607 }
4608
4609 md4_transform (plains, digests);
4610 }
4611
md5_final_sse2_max55(plain_t * plains,digest_md5_sse2_t * digests)4612 void md5_final_sse2_max55 (plain_t *plains, digest_md5_sse2_t *digests)
4613 {
4614 int i;
4615
4616 for (i = 0; i < 4; i++)
4617 {
4618 plain_t *ptr = plains + i;
4619
4620 memset (ptr->buf8 + ptr->len, 0, 64 - ptr->len);
4621
4622 ptr->buf8[ptr->len] = 0x80;
4623
4624 ptr->buf[14] = ptr->len * 8;
4625 }
4626
4627 md5_transform (plains, digests);
4628 }
4629
sha1_final_sse2_max55(plain_t * plains,digest_sha1_sse2_t * digests)4630 void sha1_final_sse2_max55 (plain_t *plains, digest_sha1_sse2_t *digests)
4631 {
4632 int i;
4633
4634 for (i = 0; i < 4; i++)
4635 {
4636 plain_t *ptr = plains + i;
4637
4638 memset (ptr->buf8 + ptr->len, 0, 64 - ptr->len);
4639
4640 ptr->buf8[ptr->len] = 0x80;
4641
4642 ptr->buf[15] = ptr->len * 8;
4643
4644 BYTESWAP (ptr->buf[15]);
4645 }
4646
4647 sha1_transform (plains, digests);
4648 }
4649
sha256_final_sse2_max55(plain_t * plains,digest_sha256_sse2_t * digests)4650 void sha256_final_sse2_max55 (plain_t *plains, digest_sha256_sse2_t *digests)
4651 {
4652 int i;
4653
4654 for (i = 0; i < 4; i++)
4655 {
4656 plain_t *ptr = plains + i;
4657
4658 memset (ptr->buf8 + ptr->len, 0, 64 - ptr->len);
4659
4660 ptr->buf8[ptr->len] = 0x80;
4661
4662 ptr->buf[15] = ptr->len * 8;
4663
4664 BYTESWAP (ptr->buf[15]);
4665 }
4666
4667 sha256_transform (plains, digests);
4668 }
4669
4670 /**
4671 * old helper -- kill them with fire�����
4672 */
4673
descrypt_64(plain_t * plains,digest_t * digests)4674 void descrypt_64 (plain_t *plains, digest_t *digests)
4675 {
4676 uint32_t i, j;
4677
4678 uint32_t digest[2][4] __attribute__ ((aligned (16)));
4679 uint32_t blocks[4][4] __attribute__ ((aligned (16)));
4680
4681 for (j = 0; j < 4; j++)
4682 {
4683 for (i = 0; i < 4; i++)
4684 {
4685 blocks[i][j] = plains[j].buf[i];
4686 }
4687 }
4688
4689 hashcat_descrypt_64_sse2 ((__m128i *)digest, (__m128i *)blocks);
4690
4691 for (j = 0; j < 2; j++)
4692 {
4693 for (i = 0; i < 4; i++)
4694 {
4695 digests[i].buf.descrypt[j] = digest[j][i];
4696 }
4697 }
4698 }
4699
sha512(plain_t * plains,digest_t * digests)4700 void sha512 (plain_t *plains, digest_t *digests)
4701 {
4702 int j;
4703
4704 for (j = 0; j < 4; j++)
4705 {
4706 uint64_t digest[8];
4707
4708 digest[0] = SHA512M_A;
4709 digest[1] = SHA512M_B;
4710 digest[2] = SHA512M_C;
4711 digest[3] = SHA512M_D;
4712 digest[4] = SHA512M_E;
4713 digest[5] = SHA512M_F;
4714 digest[6] = SHA512M_G;
4715 digest[7] = SHA512M_H;
4716
4717 int len = plains[j].len;
4718
4719 uint64_t block[16];
4720
4721 int off;
4722
4723 int left;
4724
4725 for (left = len, off = 0; left >= 128; left -= 128, off += 16)
4726 {
4727 int i;
4728
4729 for (i = 0; i < 16; i++)
4730 {
4731 block[i] = plains[j].buf64[off + i];
4732
4733 BYTESWAP64 (block[i]);
4734 }
4735
4736 hashcat_sha512 (digest, block);
4737 }
4738
4739 if (left >= 112)
4740 {
4741 int i;
4742
4743 for (i = 0; i < 16; i++)
4744 {
4745 block[i] = plains[j].buf64[off + i];
4746
4747 BYTESWAP64 (block[i]);
4748 }
4749
4750 hashcat_sha512 (digest, block);
4751
4752 for (i = 0; i < 14; i++)
4753 {
4754 block[i] = 0;
4755 }
4756
4757 block[14] = 0;
4758 block[15] = len * 8;
4759
4760 hashcat_sha512 (digest, block);
4761 }
4762 else
4763 {
4764 int i;
4765
4766 for (i = 0; i < 14; i++)
4767 {
4768 block[i] = plains[j].buf64[off + i];
4769
4770 BYTESWAP64 (block[i]);
4771 }
4772
4773 block[14] = 0;
4774 block[15] = len * 8;
4775
4776 hashcat_sha512 (digest, block);
4777 }
4778
4779 digests[j].buf.sha512[0] = digest[0];
4780 digests[j].buf.sha512[1] = digest[1];
4781 digests[j].buf.sha512[2] = digest[2];
4782 digests[j].buf.sha512[3] = digest[3];
4783 digests[j].buf.sha512[4] = digest[4];
4784 digests[j].buf.sha512[5] = digest[5];
4785 digests[j].buf.sha512[6] = digest[6];
4786 digests[j].buf.sha512[7] = digest[7];
4787 }
4788 }
4789
keccak(plain_t * plains,digest_t * digests)4790 void keccak (plain_t *plains, digest_t *digests)
4791 {
4792 uint32_t i;
4793 uint32_t j;
4794
4795 uint64_t digest_l[25][2] __attribute__ ((aligned (16)));
4796 uint64_t digest_r[25][2] __attribute__ ((aligned (16)));
4797
4798 for (j = 0; j < 2; j++)
4799 {
4800 uint32_t j2 = j * 2;
4801
4802 for (i = 0; i < 25; i++)
4803 {
4804 digest_l[i][j] = plains[j2 + 0].buf64[i];
4805 digest_r[i][j] = plains[j2 + 1].buf64[i];
4806 }
4807 }
4808
4809 hashcat_keccak_64 ((__m128i *) digest_l);
4810 hashcat_keccak_64 ((__m128i *) digest_r);
4811
4812 for (j = 0; j < 2; j++)
4813 {
4814 uint32_t j2 = j * 2;
4815
4816 for (i = 0; i < 8; i++)
4817 {
4818 digests[j2 + 0].buf.keccak[i] = digest_l[i][j];
4819 digests[j2 + 1].buf.keccak[i] = digest_r[i][j];
4820 }
4821 }
4822 }
4823
gost_64(plain_t * plains,digest_t * digests)4824 void gost_64 (plain_t *plains, digest_t *digests)
4825 {
4826 uint32_t digest[ 8][4] __attribute__ ((aligned (16)));
4827 uint32_t blocks[16][4] __attribute__ ((aligned (16)));
4828
4829 uint32_t i, j;
4830
4831 for (j = 0; j < 4; j++)
4832 {
4833 for (i = 0; i < 16; i++)
4834 {
4835 blocks[i][j] = plains[j].buf[i];
4836 }
4837 }
4838
4839 // SSE2
4840 hashcat_gost_64_sse2 ((__m128i *)digest, (__m128i *)blocks);
4841
4842 // normal
4843 // hashcat_gost_64 (digest, blocks);
4844
4845 for (j = 0; j < 8; j++)
4846 {
4847 for (i = 0; i < 4; i++)
4848 {
4849 digests[i].buf.gost[j] = digest[j][i];
4850 }
4851 }
4852 }
4853
4854 // void bcrypt_64_sse2 (plain_t *plains, plain_t *salt, digest_bcrypt_sse2_t *digests)
4855 // {
4856 // __m128i block_words[16];
4857 // __m128i block_salts[16];
4858 //
4859 // uint32_t i;
4860 //
4861 // for (i = 0; i < 4; i++) plains[i].buf[15] = plains[i].len;
4862 //
4863 // transpose_to_di4_sse2 (plains[0].buf128, plains[1].buf128, plains[2].buf128, plains[3].buf128, block_words);
4864 // transpose_to_di4_sse2 (salt[0].buf128, salt[1].buf128, salt[2].buf128, salt[3].buf128, block_salts);
4865 //
4866 // hashcat_bcrypt_64_sse2 (digests->buf128, block_words, block_salts);
4867 // }
4868
bcrypt_64(plain_t * plains,plain_t * salt,uint32_t iterations,digest_bcrypt_sse2_t * digests)4869 void bcrypt_64 (plain_t *plains, plain_t *salt, uint32_t iterations, digest_bcrypt_sse2_t *digests)
4870 {
4871 #ifdef __AVX2__
4872 hashcat_bcrypt_64 (digests->buf128, plains, salt, iterations);
4873 #else
4874 hashcat_bcrypt_64 (digests->buf32, plains, salt, iterations);
4875 #endif
4876 }
4877
4878 uint64_t words_step_size = 1;
4879
end(thread_parameter_t * thread_parameter)4880 void end (thread_parameter_t *thread_parameter)
4881 {
4882 // update thread_words_done w/ the final number of words checked
4883 thread_parameter->thread_words_done += words_step_size;
4884
4885 // check if we did exceed the maximum word cnt (only possible if words_step_size > 1)
4886 uint64_t thread_words_total = get_thread_words_total (thread_parameter->num_threads);
4887 words_t *words = thread_parameter->db->words;
4888
4889 if (thread_words_total > words->words_cnt)
4890 {
4891 thread_parameter->thread_words_done -= thread_words_total - words->words_cnt;
4892 }
4893
4894 thread_parameter->done ();
4895 }
4896
indb_single(thread_parameter_t * thread_parameter,plain_t * plains,digest_t * digests,salt_t * salt)4897 void indb_single (thread_parameter_t *thread_parameter, plain_t *plains, digest_t *digests, salt_t *salt)
4898 {
4899 uint32_t i;
4900
4901 for (i = 0; i < 4; i++)
4902 {
4903 digest_t *digest_ptr = &digests[i];
4904
4905 if (thread_parameter->compare_digest (&digest_ptr, &thread_parameter->quick_digest) != 0) continue;
4906
4907 ACMutexLock (lock_store);
4908
4909 thread_parameter->quick_digest->found = 1;
4910
4911 thread_parameter->store_out (&plains[i], digest_ptr, salt);
4912
4913 thread_parameter->db->salts_found++;
4914
4915 end (thread_parameter);
4916
4917 ACMutexUnlock (lock_store);
4918 }
4919 }
4920
indb_multi(thread_parameter_t * thread_parameter,plain_t * plains,digest_t * digests,salt_t * salt)4921 void indb_multi (thread_parameter_t *thread_parameter, plain_t *plains, digest_t *digests, salt_t *salt)
4922 {
4923 uint32_t i;
4924
4925 for (i = 0; i < 4; i++)
4926 {
4927 index_t *index = salt->indexes_buf[thread_parameter->get_index (&digests[i])];
4928
4929 if (index == NULL) continue;
4930
4931 if (index->digests_cnt == 0) continue;
4932
4933 digest_t *digest_ptr = &digests[i];
4934
4935 digest_t **digest;
4936
4937 if ((digest = bsearch (&digest_ptr, index->digests_buf, index->digests_cnt, sizeof (digest_t *), thread_parameter->compare_digest)) != NULL)
4938 {
4939 ACMutexLock (lock_store);
4940
4941 if ((*digest)->found == 0)
4942 {
4943 (*digest)->found = 1;
4944
4945 thread_parameter->store_out (&plains[i], digest_ptr, salt);
4946
4947 index->digests_found++;
4948
4949 if (index->digests_found == index->digests_cnt) salt->indexes_found++;
4950
4951 db_t *db = thread_parameter->db;
4952
4953 if (salt->indexes_found == salt->indexes_cnt) db->salts_found++;
4954
4955 if (db->salts_found == db->salts_cnt) end (thread_parameter);
4956 }
4957
4958 ACMutexUnlock (lock_store);
4959 }
4960 }
4961 }
4962
transpose_md5_digest(digest_md5_sse2_t * in,digest_t * out)4963 void transpose_md5_digest (digest_md5_sse2_t *in, digest_t *out)
4964 {
4965 uint32_t *ptr = in->buf32;
4966
4967 out[0].buf.md5[0] = *ptr++;
4968 out[1].buf.md5[0] = *ptr++;
4969 out[2].buf.md5[0] = *ptr++;
4970 out[3].buf.md5[0] = *ptr++;
4971 out[0].buf.md5[1] = *ptr++;
4972 out[1].buf.md5[1] = *ptr++;
4973 out[2].buf.md5[1] = *ptr++;
4974 out[3].buf.md5[1] = *ptr++;
4975 out[0].buf.md5[2] = *ptr++;
4976 out[1].buf.md5[2] = *ptr++;
4977 out[2].buf.md5[2] = *ptr++;
4978 out[3].buf.md5[2] = *ptr++;
4979 out[0].buf.md5[3] = *ptr++;
4980 out[1].buf.md5[3] = *ptr++;
4981 out[2].buf.md5[3] = *ptr++;
4982 out[3].buf.md5[3] = *ptr;
4983 }
4984
transpose_md4_digest(digest_md4_sse2_t * in,digest_t * out)4985 void transpose_md4_digest (digest_md4_sse2_t *in, digest_t *out)
4986 {
4987 uint32_t *ptr = in->buf32;
4988
4989 out[0].buf.md4[0] = *ptr++;
4990 out[1].buf.md4[0] = *ptr++;
4991 out[2].buf.md4[0] = *ptr++;
4992 out[3].buf.md4[0] = *ptr++;
4993 out[0].buf.md4[1] = *ptr++;
4994 out[1].buf.md4[1] = *ptr++;
4995 out[2].buf.md4[1] = *ptr++;
4996 out[3].buf.md4[1] = *ptr++;
4997 out[0].buf.md4[2] = *ptr++;
4998 out[1].buf.md4[2] = *ptr++;
4999 out[2].buf.md4[2] = *ptr++;
5000 out[3].buf.md4[2] = *ptr++;
5001 out[0].buf.md4[3] = *ptr++;
5002 out[1].buf.md4[3] = *ptr++;
5003 out[2].buf.md4[3] = *ptr++;
5004 out[3].buf.md4[3] = *ptr;
5005 }
5006
transpose_sha1_digest(digest_sha1_sse2_t * in,digest_t * out)5007 void transpose_sha1_digest (digest_sha1_sse2_t *in, digest_t *out)
5008 {
5009 uint32_t *ptr = in->buf32;
5010
5011 out[0].buf.sha1[0] = *ptr++;
5012 out[1].buf.sha1[0] = *ptr++;
5013 out[2].buf.sha1[0] = *ptr++;
5014 out[3].buf.sha1[0] = *ptr++;
5015 out[0].buf.sha1[1] = *ptr++;
5016 out[1].buf.sha1[1] = *ptr++;
5017 out[2].buf.sha1[1] = *ptr++;
5018 out[3].buf.sha1[1] = *ptr++;
5019 out[0].buf.sha1[2] = *ptr++;
5020 out[1].buf.sha1[2] = *ptr++;
5021 out[2].buf.sha1[2] = *ptr++;
5022 out[3].buf.sha1[2] = *ptr++;
5023 out[0].buf.sha1[3] = *ptr++;
5024 out[1].buf.sha1[3] = *ptr++;
5025 out[2].buf.sha1[3] = *ptr++;
5026 out[3].buf.sha1[3] = *ptr++;
5027 out[0].buf.sha1[4] = *ptr++;
5028 out[1].buf.sha1[4] = *ptr++;
5029 out[2].buf.sha1[4] = *ptr++;
5030 out[3].buf.sha1[4] = *ptr;
5031 }
5032
transpose_sha256_digest(digest_sha256_sse2_t * in,digest_t * out)5033 void transpose_sha256_digest (digest_sha256_sse2_t *in, digest_t *out)
5034 {
5035 uint32_t *ptr = in->buf32;
5036
5037 out[0].buf.sha256[0] = *ptr++;
5038 out[1].buf.sha256[0] = *ptr++;
5039 out[2].buf.sha256[0] = *ptr++;
5040 out[3].buf.sha256[0] = *ptr++;
5041 out[0].buf.sha256[1] = *ptr++;
5042 out[1].buf.sha256[1] = *ptr++;
5043 out[2].buf.sha256[1] = *ptr++;
5044 out[3].buf.sha256[1] = *ptr++;
5045 out[0].buf.sha256[2] = *ptr++;
5046 out[1].buf.sha256[2] = *ptr++;
5047 out[2].buf.sha256[2] = *ptr++;
5048 out[3].buf.sha256[2] = *ptr++;
5049 out[0].buf.sha256[3] = *ptr++;
5050 out[1].buf.sha256[3] = *ptr++;
5051 out[2].buf.sha256[3] = *ptr++;
5052 out[3].buf.sha256[3] = *ptr++;
5053 out[0].buf.sha256[4] = *ptr++;
5054 out[1].buf.sha256[4] = *ptr++;
5055 out[2].buf.sha256[4] = *ptr++;
5056 out[3].buf.sha256[4] = *ptr++;
5057 out[0].buf.sha256[5] = *ptr++;
5058 out[1].buf.sha256[5] = *ptr++;
5059 out[2].buf.sha256[5] = *ptr++;
5060 out[3].buf.sha256[5] = *ptr++;
5061 out[0].buf.sha256[6] = *ptr++;
5062 out[1].buf.sha256[6] = *ptr++;
5063 out[2].buf.sha256[6] = *ptr++;
5064 out[3].buf.sha256[6] = *ptr++;
5065 out[0].buf.sha256[7] = *ptr++;
5066 out[1].buf.sha256[7] = *ptr++;
5067 out[2].buf.sha256[7] = *ptr++;
5068 out[3].buf.sha256[7] = *ptr;
5069 }
5070
transpose_sha512_digest(digest_sha512_sse2_t * in,digest_t * out)5071 void transpose_sha512_digest (digest_sha512_sse2_t *in, digest_t *out)
5072 {
5073 uint64_t *ptr = in->buf64;
5074
5075 out[0].buf.sha512[0] = *ptr++;
5076 out[1].buf.sha512[0] = *ptr++;
5077 out[2].buf.sha512[0] = *ptr++;
5078 out[3].buf.sha512[0] = *ptr++;
5079 out[0].buf.sha512[1] = *ptr++;
5080 out[1].buf.sha512[1] = *ptr++;
5081 out[2].buf.sha512[1] = *ptr++;
5082 out[3].buf.sha512[1] = *ptr++;
5083 out[0].buf.sha512[2] = *ptr++;
5084 out[1].buf.sha512[2] = *ptr++;
5085 out[2].buf.sha512[2] = *ptr++;
5086 out[3].buf.sha512[2] = *ptr++;
5087 out[0].buf.sha512[3] = *ptr++;
5088 out[1].buf.sha512[3] = *ptr++;
5089 out[2].buf.sha512[3] = *ptr++;
5090 out[3].buf.sha512[3] = *ptr++;
5091 out[0].buf.sha512[4] = *ptr++;
5092 out[1].buf.sha512[4] = *ptr++;
5093 out[2].buf.sha512[4] = *ptr++;
5094 out[3].buf.sha512[4] = *ptr++;
5095 out[0].buf.sha512[5] = *ptr++;
5096 out[1].buf.sha512[5] = *ptr++;
5097 out[2].buf.sha512[5] = *ptr++;
5098 out[3].buf.sha512[5] = *ptr++;
5099 out[0].buf.sha512[6] = *ptr++;
5100 out[1].buf.sha512[6] = *ptr++;
5101 out[2].buf.sha512[6] = *ptr++;
5102 out[3].buf.sha512[6] = *ptr++;
5103 out[0].buf.sha512[7] = *ptr++;
5104 out[1].buf.sha512[7] = *ptr++;
5105 out[2].buf.sha512[7] = *ptr++;
5106 out[3].buf.sha512[7] = *ptr;
5107 }
5108
transpose_bcrypt_digest(digest_bcrypt_sse2_t * in,digest_t * out)5109 void transpose_bcrypt_digest (digest_bcrypt_sse2_t *in, digest_t *out)
5110 {
5111 uint32_t *ptr = in->buf32;
5112
5113 out[0].buf.bcrypt[0] = *ptr++;
5114 out[1].buf.bcrypt[0] = *ptr++;
5115 out[2].buf.bcrypt[0] = *ptr++;
5116 out[3].buf.bcrypt[0] = *ptr++;
5117 out[0].buf.bcrypt[1] = *ptr++;
5118 out[1].buf.bcrypt[1] = *ptr++;
5119 out[2].buf.bcrypt[1] = *ptr++;
5120 out[3].buf.bcrypt[1] = *ptr++;
5121 out[0].buf.bcrypt[2] = *ptr++;
5122 out[1].buf.bcrypt[2] = *ptr++;
5123 out[2].buf.bcrypt[2] = *ptr++;
5124 out[3].buf.bcrypt[2] = *ptr++;
5125 out[0].buf.bcrypt[3] = *ptr++;
5126 out[1].buf.bcrypt[3] = *ptr++;
5127 out[2].buf.bcrypt[3] = *ptr++;
5128 out[3].buf.bcrypt[3] = *ptr++;
5129 out[0].buf.bcrypt[4] = *ptr++;
5130 out[1].buf.bcrypt[4] = *ptr++;
5131 out[2].buf.bcrypt[4] = *ptr++;
5132 out[3].buf.bcrypt[4] = *ptr++;
5133 out[0].buf.bcrypt[5] = *ptr++;
5134 out[1].buf.bcrypt[5] = *ptr++;
5135 out[2].buf.bcrypt[5] = *ptr++;
5136 out[3].buf.bcrypt[5] = *ptr;
5137 }
5138
hashing_00000(thread_parameter_t * thread_parameter,plain_t * in)5139 void hashing_00000 (thread_parameter_t *thread_parameter, plain_t *in)
5140 {
5141 db_t *db = thread_parameter->db;
5142
5143 digest_md5_sse2_t digests;
5144
5145 md5_init_sse2 (&digests);
5146
5147 md5_final_sse2_max55 (in, &digests);
5148
5149 digest_t dgst[4];
5150
5151 transpose_md5_digest (&digests, dgst);
5152
5153 thread_parameter->indb (thread_parameter, in, dgst, db->salts_buf[0]);
5154 }
5155
hashing_00010(thread_parameter_t * thread_parameter,plain_t * in)5156 void hashing_00010 (thread_parameter_t *thread_parameter, plain_t *in)
5157 {
5158 digest_t dgst[4];
5159
5160 digest_md5_sse2_t digests;
5161
5162 plain_t plains[4];
5163
5164 db_t *db = thread_parameter->db;
5165
5166 uint32_t salts_idx;
5167
5168 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
5169 {
5170 salt_t *salt = db->salts_buf[salts_idx];
5171
5172 if (salt->indexes_found == salt->indexes_cnt) continue;
5173
5174 plain_init (plains);
5175
5176 md5_init_sse2 (&digests);
5177
5178 md5_update_sse2_max55 (plains, in);
5179
5180 md5_update_sse2_max55 (plains, salt->salt_plain_struct);
5181
5182 md5_final_sse2_max55 (plains, &digests);
5183
5184 transpose_md5_digest (&digests, dgst);
5185
5186 thread_parameter->indb (thread_parameter, in, dgst, salt);
5187 }
5188 }
5189
hashing_00020(thread_parameter_t * thread_parameter,plain_t * in)5190 void hashing_00020 (thread_parameter_t *thread_parameter, plain_t *in)
5191 {
5192 digest_md5_sse2_t digests;
5193
5194 digest_t dgst[4];
5195
5196 plain_t plains[4];
5197
5198 db_t *db = thread_parameter->db;
5199
5200 uint32_t salts_idx;
5201
5202 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
5203 {
5204 salt_t *salt = db->salts_buf[salts_idx];
5205
5206 if (salt->indexes_found == salt->indexes_cnt) continue;
5207
5208 plain_init (plains);
5209
5210 md5_init_sse2 (&digests);
5211
5212 md5_update_sse2_max55 (plains, salt->salt_plain_struct);
5213
5214 md5_update_sse2_max55 (plains, in);
5215
5216 md5_final_sse2_max55 (plains, &digests);
5217
5218 transpose_md5_digest (&digests, dgst);
5219
5220 thread_parameter->indb (thread_parameter, in, dgst, salt);
5221 }
5222 }
5223
hashing_00030(thread_parameter_t * thread_parameter,plain_t * in)5224 void hashing_00030 (thread_parameter_t *thread_parameter, plain_t *in)
5225 {
5226 plain_t plains[4];
5227
5228 digest_md5_sse2_t digests;
5229
5230 digest_t dgst[4];
5231
5232 plain_t in_u[4];
5233
5234 plain_unicode (in, in_u);
5235
5236 db_t *db = thread_parameter->db;
5237
5238 uint32_t salts_idx;
5239
5240 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
5241 {
5242 salt_t *salt = db->salts_buf[salts_idx];
5243
5244 if (salt->indexes_found == salt->indexes_cnt) continue;
5245
5246 plain_init (plains);
5247
5248 md5_init_sse2 (&digests);
5249
5250 md5_update_sse2_max55 (plains, in_u);
5251
5252 md5_update_sse2_max55 (plains, salt->salt_plain_struct);
5253
5254 md5_final_sse2_max55 (plains, &digests);
5255
5256 transpose_md5_digest (&digests, dgst);
5257
5258 thread_parameter->indb (thread_parameter, in, dgst, salt);
5259 }
5260 }
5261
hashing_00040(thread_parameter_t * thread_parameter,plain_t * in)5262 void hashing_00040 (thread_parameter_t *thread_parameter, plain_t *in)
5263 {
5264 plain_t plains[4];
5265
5266 digest_md5_sse2_t digests;
5267
5268 digest_t dgst[4];
5269
5270 plain_t in_u[4];
5271
5272 plain_unicode (in, in_u);
5273
5274 db_t *db = thread_parameter->db;
5275
5276 uint32_t salts_idx;
5277
5278 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
5279 {
5280 salt_t *salt = db->salts_buf[salts_idx];
5281
5282 if (salt->indexes_found == salt->indexes_cnt) continue;
5283
5284 plain_init (plains);
5285
5286 md5_init_sse2 (&digests);
5287
5288 md5_update_sse2_max55 (plains, salt->salt_plain_struct);
5289
5290 md5_update_sse2_max55 (plains, in_u);
5291
5292 md5_final_sse2_max55 (plains, &digests);
5293
5294 transpose_md5_digest (&digests, dgst);
5295
5296 thread_parameter->indb (thread_parameter, in, dgst, salt);
5297 }
5298 }
5299
hashing_00050(thread_parameter_t * thread_parameter,plain_t * plains)5300 void hashing_00050 (thread_parameter_t *thread_parameter, plain_t *plains)
5301 {
5302 digest_t digests[4];
5303
5304 plain_t plains_tmp[4];
5305
5306 char *ptrs_tmp[4];
5307
5308 ptrs_tmp[0] = (char *) &plains_tmp[0].buf;
5309 ptrs_tmp[1] = (char *) &plains_tmp[1].buf;
5310 ptrs_tmp[2] = (char *) &plains_tmp[2].buf;
5311 ptrs_tmp[3] = (char *) &plains_tmp[3].buf;
5312
5313 uint32_t ipad_dgst[4][4] __attribute__ ((aligned (16)));
5314 uint32_t opad_dgst[4][4] __attribute__ ((aligned (16)));
5315
5316 uint32_t ipad_buf[16][4] __attribute__ ((aligned (16)));
5317 uint32_t opad_buf[16][4] __attribute__ ((aligned (16)));
5318
5319 db_t *db = thread_parameter->db;
5320
5321 uint32_t i;
5322 uint32_t j;
5323
5324 for (i = 0; i < 4; i++)
5325 {
5326 for (j = 0; j < 16; j++)
5327 {
5328 ipad_buf[j][i] = 0x36363636 ^ plains[i].buf[j];
5329 opad_buf[j][i] = 0x5c5c5c5c ^ plains[i].buf[j];
5330 }
5331
5332 ipad_dgst[0][i] = MD5M_A;
5333 ipad_dgst[1][i] = MD5M_B;
5334 ipad_dgst[2][i] = MD5M_C;
5335 ipad_dgst[3][i] = MD5M_D;
5336
5337 opad_dgst[0][i] = MD5M_A;
5338 opad_dgst[1][i] = MD5M_B;
5339 opad_dgst[2][i] = MD5M_C;
5340 opad_dgst[3][i] = MD5M_D;
5341 }
5342
5343 hashcat_md5_64 ((__m128i *) ipad_dgst, (__m128i *) ipad_buf);
5344 hashcat_md5_64 ((__m128i *) opad_dgst, (__m128i *) opad_buf);
5345
5346 uint32_t salts_idx;
5347
5348 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
5349 {
5350 salt_t *salt = db->salts_buf[salts_idx];
5351
5352 if (salt->indexes_found == salt->indexes_cnt) continue;
5353
5354 uint32_t ipad_dgst_tmp[4][4] __attribute__ ((aligned (16)));
5355 uint32_t opad_dgst_tmp[4][4] __attribute__ ((aligned (16)));
5356
5357 for (i = 0; i < 4; i++)
5358 {
5359 for (j = 0; j < 4; j++)
5360 {
5361 ipad_dgst_tmp[j][i] = ipad_dgst[j][i];
5362 opad_dgst_tmp[j][i] = opad_dgst[j][i];
5363 }
5364 }
5365
5366 for (i = 0; i < 4; i++)
5367 {
5368 memcpy (ptrs_tmp[i], salt->salt_plain_buf, salt->salt_plain_len);
5369
5370 memset (ptrs_tmp[i] + salt->salt_plain_len, 0, BLOCK_SIZE - salt->salt_plain_len);
5371
5372 ptrs_tmp[i][salt->salt_plain_len] = 0x80;
5373
5374 for (j = 0; j < 14; j++)
5375 {
5376 ipad_buf[j][i] = plains_tmp[i].buf[j];
5377 }
5378
5379 ipad_buf[14][i] = (64 + salt->salt_plain_len) * 8;
5380 ipad_buf[15][i] = 0;
5381 }
5382
5383 hashcat_md5_64 ((__m128i *) ipad_dgst_tmp, (__m128i *) ipad_buf);
5384
5385 for (i = 0; i < 4; i++)
5386 {
5387 for (j = 0; j < 4; j++)
5388 {
5389 opad_buf[j][i] = ipad_dgst_tmp[j][i];
5390 }
5391
5392 opad_buf[ 4][i] = 0x80;
5393 opad_buf[ 5][i] = 0;
5394 opad_buf[ 6][i] = 0;
5395 opad_buf[ 7][i] = 0;
5396 opad_buf[ 8][i] = 0;
5397 opad_buf[ 9][i] = 0;
5398 opad_buf[10][i] = 0;
5399 opad_buf[11][i] = 0;
5400 opad_buf[12][i] = 0;
5401 opad_buf[13][i] = 0;
5402 opad_buf[14][i] = (64 + 16) * 8;
5403 opad_buf[15][i] = 0;
5404 }
5405
5406 hashcat_md5_64 ((__m128i *) opad_dgst_tmp, (__m128i *) opad_buf);
5407
5408 for (i = 0; i < 4; i++)
5409 {
5410 for (j = 0; j < 4; j++)
5411 {
5412 digests[i].buf.md5[j] = opad_dgst_tmp[j][i];
5413 }
5414 }
5415
5416 thread_parameter->indb (thread_parameter, plains, digests, salt);
5417 }
5418 }
5419
hashing_00060(thread_parameter_t * thread_parameter,plain_t * plains)5420 void hashing_00060 (thread_parameter_t *thread_parameter, plain_t *plains)
5421 {
5422 digest_t digests[4];
5423
5424 plain_t plains_tmp[4];
5425
5426 char *ptrs[4];
5427
5428 ptrs[0] = (char *) &plains[0].buf;
5429 ptrs[1] = (char *) &plains[1].buf;
5430 ptrs[2] = (char *) &plains[2].buf;
5431 ptrs[3] = (char *) &plains[3].buf;
5432
5433 char *ptrs_tmp[4];
5434
5435 ptrs_tmp[0] = (char *) &plains_tmp[0].buf;
5436 ptrs_tmp[1] = (char *) &plains_tmp[1].buf;
5437 ptrs_tmp[2] = (char *) &plains_tmp[2].buf;
5438 ptrs_tmp[3] = (char *) &plains_tmp[3].buf;
5439
5440 uint32_t ipad_dgst[4][4] __attribute__ ((aligned (16)));
5441 uint32_t opad_dgst[4][4] __attribute__ ((aligned (16)));
5442
5443 uint32_t ipad_buf[16][4] __attribute__ ((aligned (16)));
5444 uint32_t opad_buf[16][4] __attribute__ ((aligned (16)));
5445
5446 db_t *db = thread_parameter->db;
5447
5448 uint32_t i;
5449 uint32_t j;
5450
5451 uint32_t salts_idx;
5452
5453 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
5454 {
5455 salt_t *salt = db->salts_buf[salts_idx];
5456
5457 if (salt->indexes_found == salt->indexes_cnt) continue;
5458
5459 for (i = 0; i < 4; i++)
5460 {
5461 for (j = 0; j < 4; j++)
5462 {
5463 ipad_dgst[j][i] = salt->ipad_prehashed_buf[j];
5464 opad_dgst[j][i] = salt->opad_prehashed_buf[j];
5465 }
5466 }
5467
5468 for (i = 0; i < 4; i++)
5469 {
5470 memcpy (ptrs_tmp[i], ptrs[i], plains[i].len);
5471
5472 memset (ptrs_tmp[i] + plains[i].len, 0, BLOCK_SIZE - plains[i].len);
5473
5474 ptrs_tmp[i][plains[i].len] = 0x80;
5475
5476 for (j = 0; j < 14; j++)
5477 {
5478 ipad_buf[j][i] = plains_tmp[i].buf[j];
5479 }
5480
5481 ipad_buf[14][i] = (64 + plains[i].len) * 8;
5482 ipad_buf[15][i] = 0;
5483 }
5484
5485 hashcat_md5_64 ((__m128i *) ipad_dgst, (__m128i *) ipad_buf);
5486
5487 for (i = 0; i < 4; i++)
5488 {
5489 for (j = 0; j < 4; j++)
5490 {
5491 opad_buf[j][i] = ipad_dgst[j][i];
5492 }
5493
5494 opad_buf[ 4][i] = 0x80;
5495 opad_buf[ 5][i] = 0;
5496 opad_buf[ 6][i] = 0;
5497 opad_buf[ 7][i] = 0;
5498 opad_buf[ 8][i] = 0;
5499 opad_buf[ 9][i] = 0;
5500 opad_buf[10][i] = 0;
5501 opad_buf[11][i] = 0;
5502 opad_buf[12][i] = 0;
5503 opad_buf[13][i] = 0;
5504 opad_buf[14][i] = (64 + 16) * 8;
5505 opad_buf[15][i] = 0;
5506 }
5507
5508 hashcat_md5_64 ((__m128i *) opad_dgst, (__m128i *) opad_buf);
5509
5510 for (i = 0; i < 4; i++)
5511 {
5512 for (j = 0; j < 4; j++)
5513 {
5514 digests[i].buf.md5[j] = opad_dgst[j][i];
5515 }
5516 }
5517
5518 thread_parameter->indb (thread_parameter, plains, digests, salt);
5519 }
5520 }
5521
hashing_00100(thread_parameter_t * thread_parameter,plain_t * in)5522 void hashing_00100 (thread_parameter_t *thread_parameter, plain_t *in)
5523 {
5524 digest_sha1_sse2_t digests;
5525
5526 digest_t dgst[4];
5527
5528 db_t *db = thread_parameter->db;
5529
5530 sha1_init_sse2 (&digests);
5531
5532 sha1_final_sse2_max55 (in, &digests);
5533
5534 transpose_sha1_digest (&digests, dgst);
5535
5536 thread_parameter->indb (thread_parameter, in, dgst, db->salts_buf[0]);
5537 }
5538
hashing_00110(thread_parameter_t * thread_parameter,plain_t * in)5539 void hashing_00110 (thread_parameter_t *thread_parameter, plain_t *in)
5540 {
5541 digest_sha1_sse2_t digests;
5542
5543 digest_t dgst[4];
5544
5545 plain_t plains[4];
5546
5547 db_t *db = thread_parameter->db;
5548
5549 uint32_t salts_idx;
5550
5551 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
5552 {
5553 salt_t *salt = db->salts_buf[salts_idx];
5554
5555 if (salt->indexes_found == salt->indexes_cnt) continue;
5556
5557 sha1_init_sse2 (&digests);
5558
5559 plain_init (plains);
5560
5561 sha1_update_sse2_max55 (plains, in);
5562
5563 sha1_update_sse2_max55 (plains, salt->salt_plain_struct);
5564
5565 sha1_final_sse2_max55 (plains, &digests);
5566
5567 transpose_sha1_digest (&digests, dgst);
5568
5569 thread_parameter->indb (thread_parameter, in, dgst, salt);
5570 }
5571 }
5572
hashing_00120(thread_parameter_t * thread_parameter,plain_t * in)5573 void hashing_00120 (thread_parameter_t *thread_parameter, plain_t *in)
5574 {
5575 digest_sha1_sse2_t digests;
5576
5577 digest_t dgst[4];
5578
5579 plain_t plains[4];
5580
5581 db_t *db = thread_parameter->db;
5582
5583 uint32_t salts_idx;
5584
5585 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
5586 {
5587 salt_t *salt = db->salts_buf[salts_idx];
5588
5589 if (salt->indexes_found == salt->indexes_cnt) continue;
5590
5591 plain_init (plains);
5592
5593 sha1_init_sse2 (&digests);
5594
5595 sha1_update_sse2_max55 (plains, salt->salt_plain_struct);
5596
5597 sha1_update_sse2_max55 (plains, in);
5598
5599 sha1_final_sse2_max55 (plains, &digests);
5600
5601 transpose_sha1_digest (&digests, dgst);
5602
5603 thread_parameter->indb (thread_parameter, in, dgst, salt);
5604 }
5605 }
5606
hashing_00123(thread_parameter_t * thread_parameter,plain_t * in)5607 void hashing_00123 (thread_parameter_t *thread_parameter, plain_t *in)
5608 {
5609 digest_sha1_sse2_t digests;
5610
5611 digest_t dgst[4];
5612
5613 plain_t plains[4];
5614
5615 uint i;
5616
5617 for (i = 0; i < 4; i++) in[i].len += 1;
5618
5619 db_t *db = thread_parameter->db;
5620
5621 uint32_t salts_idx;
5622
5623 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
5624 {
5625 salt_t *salt = db->salts_buf[salts_idx];
5626
5627 if (salt->indexes_found == salt->indexes_cnt) continue;
5628
5629 plain_init (plains);
5630
5631 sha1_init_sse2 (&digests);
5632
5633 sha1_update_sse2_max55 (plains, salt->salt_plain_struct);
5634
5635 sha1_update_sse2_max55 (plains, in);
5636
5637 sha1_final_sse2_max55 (plains, &digests);
5638
5639 transpose_sha1_digest (&digests, dgst);
5640
5641 thread_parameter->indb (thread_parameter, in, dgst, salt);
5642 }
5643 }
5644
hashing_00130(thread_parameter_t * thread_parameter,plain_t * in)5645 void hashing_00130 (thread_parameter_t *thread_parameter, plain_t *in)
5646 {
5647 plain_t plains[4];
5648
5649 digest_sha1_sse2_t digests;
5650
5651 digest_t dgst[4];
5652
5653 plain_t in_u[4];
5654
5655 plain_unicode (in, in_u);
5656
5657 db_t *db = thread_parameter->db;
5658
5659 uint32_t salts_idx;
5660
5661 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
5662 {
5663 salt_t *salt = db->salts_buf[salts_idx];
5664
5665 if (salt->indexes_found == salt->indexes_cnt) continue;
5666
5667 plain_init (plains);
5668
5669 sha1_init_sse2 (&digests);
5670
5671 sha1_update_sse2_max55 (plains, in_u);
5672
5673 sha1_update_sse2_max55 (plains, salt->salt_plain_struct);
5674
5675 sha1_final_sse2_max55 (plains, &digests);
5676
5677 transpose_sha1_digest (&digests, dgst);
5678
5679 thread_parameter->indb (thread_parameter, in, dgst, salt);
5680 }
5681 }
5682
hashing_00131(thread_parameter_t * thread_parameter,plain_t * in)5683 void hashing_00131 (thread_parameter_t *thread_parameter, plain_t *in)
5684 {
5685 digest_sha1_sse2_t digests;
5686
5687 digest_t dgst[4];
5688
5689 plain_t plains[4];
5690
5691 plain_t in_uu[4];
5692
5693 plain_unicode_and_upper (in, in_uu);
5694
5695 db_t *db = thread_parameter->db;
5696
5697 uint32_t salts_idx;
5698
5699 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
5700 {
5701 salt_t *salt = db->salts_buf[salts_idx];
5702
5703 if (salt->indexes_found == salt->indexes_cnt) continue;
5704
5705 plain_init (plains);
5706
5707 sha1_init_sse2 (&digests);
5708
5709 sha1_update_sse2_max55 (plains, in_uu);
5710
5711 sha1_update_sse2_max55 (plains, salt->salt_plain_struct);
5712
5713 sha1_final_sse2_max55 (plains, &digests);
5714
5715 transpose_sha1_digest (&digests, dgst);
5716
5717 thread_parameter->indb (thread_parameter, in, dgst, salt);
5718 }
5719 }
5720
hashing_00133(thread_parameter_t * thread_parameter,plain_t * in)5721 void hashing_00133 (thread_parameter_t *thread_parameter, plain_t *in)
5722 {
5723 digest_sha1_sse2_t digests;
5724
5725 digest_t dgst[4];
5726
5727 plain_t in_u[4];
5728
5729 plain_unicode (in, in_u);
5730
5731 db_t *db = thread_parameter->db;
5732
5733 sha1_init_sse2 (&digests);
5734
5735 sha1_final_sse2_max55 (in_u, &digests);
5736
5737 transpose_sha1_digest (&digests, dgst);
5738
5739 thread_parameter->indb (thread_parameter, in, dgst, db->salts_buf[0]);
5740 }
5741
hashing_00140(thread_parameter_t * thread_parameter,plain_t * in)5742 void hashing_00140 (thread_parameter_t *thread_parameter, plain_t *in)
5743 {
5744 digest_sha1_sse2_t digests;
5745
5746 digest_t dgst[4];
5747
5748 plain_t plains[4];
5749
5750 db_t *db = thread_parameter->db;
5751
5752 plain_t in_u[4];
5753
5754 plain_unicode (in, in_u);
5755
5756 uint32_t salts_idx;
5757
5758 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
5759 {
5760 salt_t *salt = db->salts_buf[salts_idx];
5761
5762 if (salt->indexes_found == salt->indexes_cnt) continue;
5763
5764 plain_init (plains);
5765
5766 sha1_init_sse2 (&digests);
5767
5768 sha1_update_sse2_max55 (plains, salt->salt_plain_struct);
5769
5770 sha1_update_sse2_max55 (plains, in_u);
5771
5772 sha1_final_sse2_max55 (plains, &digests);
5773
5774 transpose_sha1_digest (&digests, dgst);
5775
5776 thread_parameter->indb (thread_parameter, in, dgst, salt);
5777 }
5778 }
5779
hashing_00150(thread_parameter_t * thread_parameter,plain_t * plains)5780 void hashing_00150 (thread_parameter_t *thread_parameter, plain_t *plains)
5781 {
5782 digest_t digests[4];
5783
5784 plain_t plains_tmp[4];
5785
5786 char *ptrs_tmp[4];
5787
5788 ptrs_tmp[0] = (char *) &plains_tmp[0].buf;
5789 ptrs_tmp[1] = (char *) &plains_tmp[1].buf;
5790 ptrs_tmp[2] = (char *) &plains_tmp[2].buf;
5791 ptrs_tmp[3] = (char *) &plains_tmp[3].buf;
5792
5793 uint32_t ipad_dgst[5][4] __attribute__ ((aligned (16)));
5794 uint32_t opad_dgst[5][4] __attribute__ ((aligned (16)));
5795
5796 uint32_t ipad_buf[16][4] __attribute__ ((aligned (16)));
5797 uint32_t opad_buf[16][4] __attribute__ ((aligned (16)));
5798
5799 db_t *db = thread_parameter->db;
5800
5801 uint32_t i;
5802 uint32_t j;
5803
5804 for (i = 0; i < 4; i++)
5805 {
5806 for (j = 0; j < 16; j++)
5807 {
5808 ipad_buf[j][i] = 0x36363636 ^ plains[i].buf[j];
5809 opad_buf[j][i] = 0x5c5c5c5c ^ plains[i].buf[j];
5810 }
5811
5812 ipad_dgst[0][i] = SHA1M_A;
5813 ipad_dgst[1][i] = SHA1M_B;
5814 ipad_dgst[2][i] = SHA1M_C;
5815 ipad_dgst[3][i] = SHA1M_D;
5816 ipad_dgst[4][i] = SHA1M_E;
5817
5818 opad_dgst[0][i] = SHA1M_A;
5819 opad_dgst[1][i] = SHA1M_B;
5820 opad_dgst[2][i] = SHA1M_C;
5821 opad_dgst[3][i] = SHA1M_D;
5822 opad_dgst[4][i] = SHA1M_E;
5823 }
5824
5825 hashcat_sha1_64 ((__m128i *) ipad_dgst, (__m128i *) ipad_buf);
5826 hashcat_sha1_64 ((__m128i *) opad_dgst, (__m128i *) opad_buf);
5827
5828 uint32_t salts_idx;
5829
5830 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
5831 {
5832 salt_t *salt = db->salts_buf[salts_idx];
5833
5834 if (salt->indexes_found == salt->indexes_cnt) continue;
5835
5836 uint32_t ipad_dgst_tmp[5][4] __attribute__ ((aligned (16)));
5837 uint32_t opad_dgst_tmp[5][4] __attribute__ ((aligned (16)));
5838
5839 for (i = 0; i < 4; i++)
5840 {
5841 for (j = 0; j < 5; j++)
5842 {
5843 ipad_dgst_tmp[j][i] = ipad_dgst[j][i];
5844 opad_dgst_tmp[j][i] = opad_dgst[j][i];
5845 }
5846 }
5847
5848 for (i = 0; i < 4; i++)
5849 {
5850 memcpy (ptrs_tmp[i], salt->salt_plain_buf, salt->salt_plain_len);
5851
5852 memset (ptrs_tmp[i] + salt->salt_plain_len, 0, BLOCK_SIZE - salt->salt_plain_len);
5853
5854 ptrs_tmp[i][salt->salt_plain_len] = 0x80;
5855
5856 for (j = 0; j < 14; j++) ipad_buf[j][i] = plains_tmp[i].buf[j];
5857
5858 ipad_buf[14][i] = 0;
5859 ipad_buf[15][i] = (64 + salt->salt_plain_len) * 8;
5860
5861 BYTESWAP (ipad_buf[15][i]);
5862 }
5863
5864 hashcat_sha1_64 ((__m128i *) ipad_dgst_tmp, (__m128i *) ipad_buf);
5865
5866 for (i = 0; i < 4; i++)
5867 {
5868 for (j = 0; j < 5; j++)
5869 {
5870 opad_buf[j][i] = ipad_dgst_tmp[j][i];
5871 }
5872
5873 opad_buf[ 5][i] = 0x80000000;
5874 opad_buf[ 6][i] = 0;
5875 opad_buf[ 7][i] = 0;
5876 opad_buf[ 8][i] = 0;
5877 opad_buf[ 9][i] = 0;
5878 opad_buf[10][i] = 0;
5879 opad_buf[11][i] = 0;
5880 opad_buf[12][i] = 0;
5881 opad_buf[13][i] = 0;
5882 opad_buf[14][i] = 0;
5883 opad_buf[15][i] = (64 + 20) * 8;
5884 }
5885
5886 for (i = 0; i < 4; i++) for (j = 0; j < 16; j++) BYTESWAP (opad_buf[j][i]);
5887
5888 hashcat_sha1_64 ((__m128i *) opad_dgst_tmp, (__m128i *) opad_buf);
5889
5890 for (i = 0; i < 4; i++)
5891 {
5892 for (j = 0; j < 5; j++)
5893 {
5894 digests[i].buf.sha1[j] = opad_dgst_tmp[j][i];
5895 }
5896 }
5897
5898 thread_parameter->indb (thread_parameter, plains, digests, salt);
5899 }
5900 }
5901
hashing_00160(thread_parameter_t * thread_parameter,plain_t * plains)5902 void hashing_00160 (thread_parameter_t *thread_parameter, plain_t *plains)
5903 {
5904 digest_t digests[4];
5905
5906 plain_t plains_tmp[4];
5907
5908 char *ptrs[4];
5909
5910 ptrs[0] = (char *) &plains[0].buf;
5911 ptrs[1] = (char *) &plains[1].buf;
5912 ptrs[2] = (char *) &plains[2].buf;
5913 ptrs[3] = (char *) &plains[3].buf;
5914
5915 char *ptrs_tmp[4];
5916
5917 ptrs_tmp[0] = (char *) &plains_tmp[0].buf;
5918 ptrs_tmp[1] = (char *) &plains_tmp[1].buf;
5919 ptrs_tmp[2] = (char *) &plains_tmp[2].buf;
5920 ptrs_tmp[3] = (char *) &plains_tmp[3].buf;
5921
5922 uint32_t ipad_dgst[5][4] __attribute__ ((aligned (16)));
5923 uint32_t opad_dgst[5][4] __attribute__ ((aligned (16)));
5924
5925 uint32_t ipad_buf[16][4] __attribute__ ((aligned (16)));
5926 uint32_t opad_buf[16][4] __attribute__ ((aligned (16)));
5927
5928 db_t *db = thread_parameter->db;
5929
5930 uint32_t i;
5931 uint32_t j;
5932
5933 uint32_t salts_idx;
5934
5935 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
5936 {
5937 salt_t *salt = db->salts_buf[salts_idx];
5938
5939 if (salt->indexes_found == salt->indexes_cnt) continue;
5940
5941 for (i = 0; i < 4; i++)
5942 {
5943 for (j = 0; j < 5; j++)
5944 {
5945 ipad_dgst[j][i] = salt->ipad_prehashed_buf[j];
5946 opad_dgst[j][i] = salt->opad_prehashed_buf[j];
5947 }
5948 }
5949
5950 for (i = 0; i < 4; i++)
5951 {
5952 memcpy (ptrs_tmp[i], ptrs[i], plains[i].len);
5953
5954 memset (ptrs_tmp[i] + plains[i].len, 0, BLOCK_SIZE - plains[i].len);
5955
5956 ptrs_tmp[i][plains[i].len] = 0x80;
5957
5958 for (j = 0; j < 14; j++)
5959 {
5960 ipad_buf[j][i] = plains_tmp[i].buf[j];
5961
5962 BYTESWAP (ipad_buf[j][i]);
5963 }
5964
5965 ipad_buf[14][i] = 0;
5966 ipad_buf[15][i] = (64 + plains[i].len) * 8;
5967 }
5968
5969 for (i = 0; i < 4; i++) for (j = 0; j < 16; j++) BYTESWAP (ipad_buf[j][i]);
5970
5971 hashcat_sha1_64 ((__m128i *) ipad_dgst, (__m128i *) ipad_buf);
5972
5973 for (i = 0; i < 4; i++)
5974 {
5975 for (j = 0; j < 5; j++)
5976 {
5977 opad_buf[j][i] = ipad_dgst[j][i];
5978 }
5979
5980 opad_buf[ 5][i] = 0x80000000;
5981 opad_buf[ 6][i] = 0;
5982 opad_buf[ 7][i] = 0;
5983 opad_buf[ 8][i] = 0;
5984 opad_buf[ 9][i] = 0;
5985 opad_buf[10][i] = 0;
5986 opad_buf[11][i] = 0;
5987 opad_buf[12][i] = 0;
5988 opad_buf[13][i] = 0;
5989 opad_buf[14][i] = 0;
5990 opad_buf[15][i] = (64 + 20) * 8;
5991 }
5992
5993 for (i = 0; i < 4; i++) for (j = 0; j < 16; j++) BYTESWAP (opad_buf[j][i]);
5994
5995 hashcat_sha1_64 ((__m128i *) opad_dgst, (__m128i *) opad_buf);
5996
5997 for (i = 0; i < 4; i++)
5998 {
5999 for (j = 0; j < 5; j++)
6000 {
6001 digests[i].buf.sha1[j] = opad_dgst[j][i];
6002 }
6003 }
6004
6005 thread_parameter->indb (thread_parameter, plains, digests, salt);
6006 }
6007 }
6008
hashing_00200(thread_parameter_t * thread_parameter,plain_t * plains)6009 void hashing_00200 (thread_parameter_t *thread_parameter, plain_t *plains)
6010 {
6011 digest_t digests[4];
6012
6013 plain_t plains_tmp[4];
6014
6015 unsigned char *ptrs[4];
6016
6017 memset (ptrs, 0, sizeof (ptrs));
6018
6019 ptrs[0] = (unsigned char *) &plains[0].buf;
6020 ptrs[1] = (unsigned char *) &plains[1].buf;
6021 ptrs[2] = (unsigned char *) &plains[2].buf;
6022 ptrs[3] = (unsigned char *) &plains[3].buf;
6023
6024 unsigned char *ptrs_tmp[4];
6025
6026 memset (ptrs_tmp, 0, sizeof (ptrs_tmp));
6027
6028 ptrs_tmp[0] = (unsigned char *) &plains_tmp[0].buf;
6029 ptrs_tmp[1] = (unsigned char *) &plains_tmp[1].buf;
6030 ptrs_tmp[2] = (unsigned char *) &plains_tmp[2].buf;
6031 ptrs_tmp[3] = (unsigned char *) &plains_tmp[3].buf;
6032
6033 db_t *db = thread_parameter->db;
6034
6035 uint32_t i;
6036
6037 for (i = 0; i < 4; i++)
6038 {
6039 uint32_t nr0 = 0x50305735;
6040 uint32_t nr1 = 0x12345671;
6041
6042 uint32_t add = 7;
6043
6044 unsigned char *ptr = ptrs[i];
6045
6046 for (; *ptr; ptr++)
6047 {
6048 nr0 ^= (((nr0 & 63) + add) * *ptr) + (nr0 << 8);
6049 nr1 += (nr1 << 8) ^ nr0;
6050 add += *ptr;
6051 }
6052
6053 digests[i].buf.mysql[0] = nr0 & 0x7fffffff;
6054 digests[i].buf.mysql[1] = nr1 & 0x7fffffff;
6055 }
6056
6057 thread_parameter->indb (thread_parameter, plains, digests, db->salts_buf[0]);
6058 }
6059
hashing_00300(thread_parameter_t * thread_parameter,plain_t * in)6060 void hashing_00300 (thread_parameter_t *thread_parameter, plain_t *in)
6061 {
6062 digest_sha1_sse2_t digests;
6063
6064 digest_t dgst[4];
6065
6066 plain_t plains[4];
6067
6068 db_t *db = thread_parameter->db;
6069
6070 uint32_t salts_idx;
6071
6072 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
6073 {
6074 salt_t *salt = db->salts_buf[salts_idx];
6075
6076 if (salt->indexes_found == salt->indexes_cnt) continue;
6077
6078 sha1_init_sse2 (&digests);
6079
6080 sha1_final_sse2_max55 (in, &digests);
6081
6082 transpose_sha1_digest (&digests, dgst);
6083
6084 uint32_t i;
6085
6086 for (i = 0; i < 4; i++)
6087 {
6088 BYTESWAP (dgst[i].buf.sha1[0]);
6089 BYTESWAP (dgst[i].buf.sha1[1]);
6090 BYTESWAP (dgst[i].buf.sha1[2]);
6091 BYTESWAP (dgst[i].buf.sha1[3]);
6092 BYTESWAP (dgst[i].buf.sha1[4]);
6093
6094 plains[i].buf[0] = dgst[i].buf.sha1[0];
6095 plains[i].buf[1] = dgst[i].buf.sha1[1];
6096 plains[i].buf[2] = dgst[i].buf.sha1[2];
6097 plains[i].buf[3] = dgst[i].buf.sha1[3];
6098 plains[i].buf[4] = dgst[i].buf.sha1[4];
6099
6100 plains[i].len = 20;
6101 }
6102
6103 sha1_init_sse2 (&digests);
6104
6105 sha1_final_sse2_max55 (plains, &digests);
6106
6107 transpose_sha1_digest (&digests, dgst);
6108
6109 thread_parameter->indb (thread_parameter, in, dgst, salt);
6110 }
6111 }
6112
hashing_00400(thread_parameter_t * thread_parameter,plain_t * in)6113 void hashing_00400 (thread_parameter_t *thread_parameter, plain_t *in)
6114 {
6115 digest_md5_sse2_t digests;
6116
6117 digest_t dgst[4];
6118
6119 plain_t plains[4];
6120
6121 char *ptrs[4];
6122
6123 ptrs[0] = (char *) &in[0].buf;
6124 ptrs[1] = (char *) &in[1].buf;
6125 ptrs[2] = (char *) &in[2].buf;
6126 ptrs[3] = (char *) &in[3].buf;
6127
6128 char *ptrs_tmp[4];
6129
6130 ptrs_tmp[0] = (char *) &plains[0].buf;
6131 ptrs_tmp[1] = (char *) &plains[1].buf;
6132 ptrs_tmp[2] = (char *) &plains[2].buf;
6133 ptrs_tmp[3] = (char *) &plains[3].buf;
6134
6135 db_t *db = thread_parameter->db;
6136
6137 uint32_t salts_idx;
6138
6139 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
6140 {
6141 salt_t *salt = db->salts_buf[salts_idx];
6142
6143 if (salt->indexes_found == salt->indexes_cnt) continue;
6144
6145 plain_init (plains);
6146
6147 md5_init_sse2 (&digests);
6148
6149 md5_update_sse2_max55 (plains, salt->salt_plain_struct);
6150
6151 md5_update_sse2_max55 (plains, in);
6152
6153 md5_final_sse2_max55 (plains, &digests);
6154
6155 transpose_md5_digest (&digests, dgst);
6156
6157 uint32_t i;
6158
6159 for (i = 0; i < 4; i++)
6160 {
6161 plains[i].len = 16 + in[i].len;
6162
6163 memcpy (ptrs_tmp[i] + 16, ptrs[i], in[i].len);
6164 }
6165
6166 uint32_t count;
6167
6168 for (count = 0; count < salt->iterations; count++)
6169 {
6170 for (i = 0; i < 4; i++)
6171 {
6172 plains[i].buf[0] = dgst[i].buf.md5[0];
6173 plains[i].buf[1] = dgst[i].buf.md5[1];
6174 plains[i].buf[2] = dgst[i].buf.md5[2];
6175 plains[i].buf[3] = dgst[i].buf.md5[3];
6176 }
6177
6178 md5_init_sse2 (&digests);
6179
6180 md5_final_sse2 (plains, &digests);
6181
6182 transpose_md5_digest (&digests, dgst);
6183 }
6184
6185 thread_parameter->indb (thread_parameter, in, dgst, salt);
6186 }
6187 }
6188
hashing_00500(thread_parameter_t * thread_parameter,plain_t * in)6189 void hashing_00500 (thread_parameter_t *thread_parameter, plain_t *in)
6190 {
6191 digest_md5_sse2_t digests;
6192
6193 digest_t dgst[4];
6194
6195 plain_t plains[4];
6196
6197 char *ptrs[4];
6198
6199 ptrs[0] = (char *) &in[0].buf;
6200 ptrs[1] = (char *) &in[1].buf;
6201 ptrs[2] = (char *) &in[2].buf;
6202 ptrs[3] = (char *) &in[3].buf;
6203
6204 char *ptrs_tmp[4];
6205
6206 ptrs_tmp[0] = (char *) &plains[0].buf;
6207 ptrs_tmp[1] = (char *) &plains[1].buf;
6208 ptrs_tmp[2] = (char *) &plains[2].buf;
6209 ptrs_tmp[3] = (char *) &plains[3].buf;
6210
6211 db_t *db = thread_parameter->db;
6212
6213 uint32_t salts_idx;
6214
6215 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
6216 {
6217 salt_t *salt = db->salts_buf[salts_idx];
6218
6219 if (salt->indexes_found == salt->indexes_cnt) continue;
6220
6221 plain_init (plains);
6222
6223 md5_init_sse2 (&digests);
6224
6225 md5_update_sse2_max55 (plains, in);
6226
6227 md5_update_sse2_max55 (plains, salt->salt_plain_struct);
6228
6229 md5_update_sse2_max55 (plains, in);
6230
6231 md5_final_sse2_max55 (plains, &digests);
6232
6233 transpose_md5_digest (&digests, dgst);
6234
6235 uint32_t i;
6236
6237 for (i = 0; i < 4; i++)
6238 {
6239 if (in[i].len > 16) continue;
6240
6241 plains[i].len = in[i].len + MD5UNIX_SIGN + salt->salt_plain_len;
6242
6243 /* The password first, since that is what is most unknown */
6244 /* Then our magic string */
6245 /* Then the raw salt */
6246 /* Then just as many characters of the MD5(pw,salt,pw) */
6247
6248 memcpy (ptrs_tmp[i], ptrs[i], in[i].len);
6249 memcpy (ptrs_tmp[i] + in[i].len, MD5UNIX_MAGIC, MD5UNIX_SIGN);
6250 memcpy (ptrs_tmp[i] + in[i].len + MD5UNIX_SIGN, salt->salt_plain_buf, salt->salt_plain_len);
6251 memcpy (ptrs_tmp[i] + plains[i].len, dgst[i].buf.md5, in[i].len);
6252
6253 plains[i].len += in[i].len;
6254
6255 /* Then something really weird... */
6256
6257 switch (in[i].len)
6258 {
6259 case 1:
6260 ptrs_tmp[i][plains[i].len + 0] = 0;
6261 plains[i].len += 1;
6262 break;
6263
6264 case 2:
6265 ptrs_tmp[i][plains[i].len + 0] = ptrs[i][0];
6266 ptrs_tmp[i][plains[i].len + 1] = 0;
6267 plains[i].len += 2;
6268 break;
6269
6270 case 3:
6271 ptrs_tmp[i][plains[i].len + 0] = 0;
6272 ptrs_tmp[i][plains[i].len + 1] = 0;
6273 plains[i].len += 2;
6274 break;
6275
6276 case 4:
6277 ptrs_tmp[i][plains[i].len + 0] = ptrs[i][0];
6278 ptrs_tmp[i][plains[i].len + 1] = ptrs[i][0];
6279 ptrs_tmp[i][plains[i].len + 2] = 0;
6280 plains[i].len += 3;
6281 break;
6282
6283 case 5:
6284 ptrs_tmp[i][plains[i].len + 0] = 0;
6285 ptrs_tmp[i][plains[i].len + 1] = ptrs[i][0];
6286 ptrs_tmp[i][plains[i].len + 2] = 0;
6287 plains[i].len += 3;
6288 break;
6289
6290 case 6:
6291 ptrs_tmp[i][plains[i].len + 0] = ptrs[i][0];
6292 ptrs_tmp[i][plains[i].len + 1] = 0;
6293 ptrs_tmp[i][plains[i].len + 2] = 0;
6294 plains[i].len += 3;
6295 break;
6296
6297 case 7:
6298 ptrs_tmp[i][plains[i].len + 0] = 0;
6299 ptrs_tmp[i][plains[i].len + 1] = 0;
6300 ptrs_tmp[i][plains[i].len + 2] = 0;
6301 plains[i].len += 3;
6302 break;
6303
6304 case 8:
6305 ptrs_tmp[i][plains[i].len + 0] = ptrs[i][0];
6306 ptrs_tmp[i][plains[i].len + 1] = ptrs[i][0];
6307 ptrs_tmp[i][plains[i].len + 2] = ptrs[i][0];
6308 ptrs_tmp[i][plains[i].len + 3] = 0;
6309 plains[i].len += 4;
6310 break;
6311
6312 case 9:
6313 ptrs_tmp[i][plains[i].len + 0] = 0;
6314 ptrs_tmp[i][plains[i].len + 1] = ptrs[i][0];
6315 ptrs_tmp[i][plains[i].len + 2] = ptrs[i][0];
6316 ptrs_tmp[i][plains[i].len + 3] = 0;
6317 plains[i].len += 4;
6318 break;
6319
6320 case 10:
6321 ptrs_tmp[i][plains[i].len + 0] = ptrs[i][0];
6322 ptrs_tmp[i][plains[i].len + 1] = 0;
6323 ptrs_tmp[i][plains[i].len + 2] = ptrs[i][0];
6324 ptrs_tmp[i][plains[i].len + 3] = 0;
6325 plains[i].len += 4;
6326 break;
6327
6328 case 11:
6329 ptrs_tmp[i][plains[i].len + 0] = 0;
6330 ptrs_tmp[i][plains[i].len + 1] = 0;
6331 ptrs_tmp[i][plains[i].len + 2] = ptrs[i][0];
6332 ptrs_tmp[i][plains[i].len + 3] = 0;
6333 plains[i].len += 4;
6334 break;
6335
6336 case 12:
6337 ptrs_tmp[i][plains[i].len + 0] = ptrs[i][0];
6338 ptrs_tmp[i][plains[i].len + 1] = ptrs[i][0];
6339 ptrs_tmp[i][plains[i].len + 2] = 0;
6340 ptrs_tmp[i][plains[i].len + 3] = 0;
6341 plains[i].len += 4;
6342 break;
6343
6344 case 13:
6345 ptrs_tmp[i][plains[i].len + 0] = 0;
6346 ptrs_tmp[i][plains[i].len + 1] = ptrs[i][0];
6347 ptrs_tmp[i][plains[i].len + 2] = 0;
6348 ptrs_tmp[i][plains[i].len + 3] = 0;
6349 plains[i].len += 4;
6350 break;
6351
6352 case 14:
6353 ptrs_tmp[i][plains[i].len + 0] = ptrs[i][0];
6354 ptrs_tmp[i][plains[i].len + 1] = 0;
6355 ptrs_tmp[i][plains[i].len + 2] = 0;
6356 ptrs_tmp[i][plains[i].len + 3] = 0;
6357 plains[i].len += 4;
6358 break;
6359
6360 case 15:
6361 ptrs_tmp[i][plains[i].len + 0] = 0;
6362 ptrs_tmp[i][plains[i].len + 1] = 0;
6363 ptrs_tmp[i][plains[i].len + 2] = 0;
6364 ptrs_tmp[i][plains[i].len + 3] = 0;
6365 plains[i].len += 4;
6366 break;
6367 }
6368
6369 /*
6370 int pl;
6371
6372 for (pl = in[i].len; pl; pl >>= 1)
6373 {
6374 if ((plains[i].len + 1) < PLAIN_SIZE_MD5)
6375 {
6376 ptrs_tmp[i][plains[i].len] = (pl & 1) ? '\0' : ptrs[i][0];
6377
6378 plains[i].len++;
6379 }
6380 }
6381 */
6382 }
6383
6384 md5_init_sse2 (&digests);
6385
6386 md5_final_sse2_max55 (plains, &digests);
6387
6388 transpose_md5_digest (&digests, dgst);
6389
6390 /* and now, just to make sure things don't run too fast */
6391
6392 uint32_t j;
6393
6394 for (j = 0; j < salt->iterations; j++)
6395 {
6396 int a1 = j & 1;
6397 int m3 = j % 3;
6398 int m7 = j % 7;
6399
6400 for (i = 0; i < 4; i++)
6401 {
6402 if (in[i].len > 16) continue;
6403
6404 memset (ptrs_tmp[i], 0, BLOCK_SIZE);
6405
6406 plains[i].len = 0;
6407
6408 if (a1)
6409 {
6410 memcpy (ptrs_tmp[i] + plains[i].len, ptrs[i], in[i].len);
6411
6412 plains[i].len += in[i].len;
6413 }
6414 else
6415 {
6416 memcpy (ptrs_tmp[i] + plains[i].len, dgst[i].buf.md5, 16);
6417
6418 plains[i].len += 16;
6419 }
6420
6421 if (m3)
6422 {
6423 memcpy (ptrs_tmp[i] + plains[i].len, salt->salt_plain_buf, salt->salt_plain_len);
6424
6425 plains[i].len += salt->salt_plain_len;
6426 }
6427
6428 if (m7)
6429 {
6430 memcpy (ptrs_tmp[i] + plains[i].len, ptrs[i], in[i].len);
6431
6432 plains[i].len += in[i].len;
6433 }
6434
6435 if (a1)
6436 {
6437 memcpy (ptrs_tmp[i] + plains[i].len, dgst[i].buf.md5, 16);
6438
6439 plains[i].len += 16;
6440 }
6441 else
6442 {
6443 memcpy (ptrs_tmp[i] + plains[i].len, ptrs[i], in[i].len);
6444
6445 plains[i].len += in[i].len;
6446 }
6447 }
6448
6449 md5_init_sse2 (&digests);
6450
6451 md5_final_sse2_max55 (plains, &digests);
6452
6453 transpose_md5_digest (&digests, dgst);
6454 }
6455
6456 thread_parameter->indb (thread_parameter, in , dgst, salt);
6457 }
6458 }
6459
hashing_00666(thread_parameter_t * thread_parameter,plain_t * plains)6460 void hashing_00666 (thread_parameter_t *thread_parameter, plain_t *plains)
6461 {
6462 thread_parameter->fake = 1;
6463
6464 char *ptrs[4];
6465
6466 ptrs[0] = (char *) &plains[0].buf;
6467 ptrs[1] = (char *) &plains[1].buf;
6468 ptrs[2] = (char *) &plains[2].buf;
6469 ptrs[3] = (char *) &plains[3].buf;
6470
6471 if (plains[0].len) puts (ptrs[0]);
6472 if (plains[1].len) puts (ptrs[1]);
6473 if (plains[2].len) puts (ptrs[2]);
6474 if (plains[3].len) puts (ptrs[3]);
6475 }
6476
hashing_00900(thread_parameter_t * thread_parameter,plain_t * in)6477 void hashing_00900 (thread_parameter_t *thread_parameter, plain_t *in)
6478 {
6479 digest_md4_sse2_t digests;
6480
6481 digest_t dgst[4];
6482
6483 db_t *db = thread_parameter->db;
6484
6485 md4_init_sse2 (&digests);
6486
6487 md4_final_sse2_max55 (in, &digests);
6488
6489 transpose_md4_digest (&digests, dgst);
6490
6491 thread_parameter->indb (thread_parameter, in, dgst, db->salts_buf[0]);
6492 }
6493
hashing_01000(thread_parameter_t * thread_parameter,plain_t * in)6494 void hashing_01000 (thread_parameter_t *thread_parameter, plain_t *in)
6495 {
6496 digest_md4_sse2_t digests;
6497
6498 digest_t dgst[4];
6499
6500 plain_t in_u[4];
6501
6502 db_t *db = thread_parameter->db;
6503
6504 plain_unicode (in, in_u);
6505
6506 md4_init_sse2 (&digests);
6507
6508 md4_final_sse2_max55 (in_u, &digests);
6509
6510 transpose_md4_digest (&digests, dgst);
6511
6512 thread_parameter->indb (thread_parameter, in, dgst, db->salts_buf[0]);
6513 }
6514
hashing_01100(thread_parameter_t * thread_parameter,plain_t * in)6515 void hashing_01100 (thread_parameter_t *thread_parameter, plain_t *in)
6516 {
6517 digest_md4_sse2_t digests;
6518
6519 digest_t dgst[4];
6520
6521 plain_t in_u[4];
6522
6523 plain_t plains_tmp[4];
6524
6525 db_t *db = thread_parameter->db;
6526
6527 plain_unicode (in, in_u);
6528
6529 md4_init_sse2 (&digests);
6530
6531 md4_final_sse2_max55 (in_u, &digests);
6532
6533 transpose_md4_digest (&digests, dgst);
6534
6535 int i;
6536
6537 for (i = 0; i < 4; i++)
6538 {
6539 memcpy (plains_tmp[i].buf8, dgst[i].buf.md4, 16);
6540
6541 plains_tmp[i].len = 16;
6542 }
6543
6544 uint32_t salts_idx;
6545
6546 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
6547 {
6548 salt_t *salt = db->salts_buf[salts_idx];
6549
6550 if (salt->indexes_found == salt->indexes_cnt) continue;
6551
6552 plain_t plains[4];
6553
6554 plain_init (plains);
6555
6556 md4_init_sse2 (&digests);
6557
6558 md4_update_sse2_max55 (plains, plains_tmp);
6559
6560 md4_update_sse2_max55 (plains, salt->salt_plain_struct);
6561
6562 md4_final_sse2_max55 (plains, &digests);
6563
6564 transpose_md4_digest (&digests, dgst);
6565
6566 thread_parameter->indb (thread_parameter, in, dgst, salt);
6567 }
6568 }
6569
hashing_01400(thread_parameter_t * thread_parameter,plain_t * in)6570 void hashing_01400 (thread_parameter_t *thread_parameter, plain_t *in)
6571 {
6572 digest_sha256_sse2_t digests;
6573
6574 digest_t dgst[4];
6575
6576 db_t *db = thread_parameter->db;
6577
6578 sha256_init_sse2 (&digests);
6579
6580 sha256_final_sse2 (in, &digests);
6581
6582 transpose_sha256_digest (&digests, dgst);
6583
6584 thread_parameter->indb (thread_parameter, in, dgst, db->salts_buf[0]);
6585 }
6586
hashing_01410(thread_parameter_t * thread_parameter,plain_t * in)6587 void hashing_01410 (thread_parameter_t *thread_parameter, plain_t *in)
6588 {
6589 digest_sha256_sse2_t digests;
6590
6591 digest_t dgst[4];
6592
6593 plain_t plains[4];
6594
6595 db_t *db = thread_parameter->db;
6596
6597 uint32_t salts_idx;
6598
6599 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
6600 {
6601 salt_t *salt = db->salts_buf[salts_idx];
6602
6603 if (salt->indexes_found == salt->indexes_cnt) continue;
6604
6605 plain_init (plains);
6606
6607 sha256_init_sse2 (&digests);
6608
6609 sha256_update_sse2_max55 (plains, in);
6610
6611 sha256_update_sse2_max55 (plains, salt->salt_plain_struct);
6612
6613 sha256_final_sse2_max55 (plains, &digests);
6614
6615 transpose_sha256_digest (&digests, dgst);
6616
6617 thread_parameter->indb (thread_parameter, in, dgst, salt);
6618 }
6619 }
6620
hashing_01420(thread_parameter_t * thread_parameter,plain_t * in)6621 void hashing_01420 (thread_parameter_t *thread_parameter, plain_t *in)
6622 {
6623 digest_sha256_sse2_t digests;
6624
6625 digest_t dgst[4];
6626
6627 plain_t plains[4];
6628
6629 db_t *db = thread_parameter->db;
6630
6631 uint32_t salts_idx;
6632
6633 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
6634 {
6635 salt_t *salt = db->salts_buf[salts_idx];
6636
6637 if (salt->indexes_found == salt->indexes_cnt) continue;
6638
6639 plain_init (plains);
6640
6641 sha256_init_sse2 (&digests);
6642
6643 sha256_update_sse2_max55 (plains, salt->salt_plain_struct);
6644
6645 sha256_update_sse2_max55 (plains, in);
6646
6647 sha256_final_sse2_max55 (plains, &digests);
6648
6649 transpose_sha256_digest (&digests, dgst);
6650
6651 thread_parameter->indb (thread_parameter, in, dgst, salt);
6652 }
6653 }
6654
hashing_01430(thread_parameter_t * thread_parameter,plain_t * in)6655 void hashing_01430 (thread_parameter_t *thread_parameter, plain_t *in)
6656 {
6657 digest_sha256_sse2_t digests;
6658
6659 digest_t dgst[4];
6660
6661 plain_t plains[4];
6662
6663 plain_t in_u[4];
6664
6665 db_t *db = thread_parameter->db;
6666
6667 uint32_t salts_idx;
6668
6669 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
6670 {
6671 salt_t *salt = db->salts_buf[salts_idx];
6672
6673 if (salt->indexes_found == salt->indexes_cnt) continue;
6674
6675 plain_init (plains);
6676
6677 plain_unicode (in, in_u);
6678
6679 sha256_init_sse2 (&digests);
6680
6681 sha256_update_sse2_max55 (plains, in_u);
6682
6683 sha256_update_sse2_max55 (plains, salt->salt_plain_struct);
6684
6685 sha256_final_sse2_max55 (plains, &digests);
6686
6687 transpose_sha256_digest (&digests, dgst);
6688
6689 thread_parameter->indb (thread_parameter, in, dgst, salt);
6690 }
6691 }
6692
hashing_01431(thread_parameter_t * thread_parameter,plain_t * in)6693 void hashing_01431 (thread_parameter_t *thread_parameter, plain_t *in)
6694 {
6695 digest_sha256_sse2_t digests;
6696
6697 digest_t dgst[4];
6698
6699 plain_t in_u[4];
6700
6701 db_t *db = thread_parameter->db;
6702
6703 plain_unicode (in, in_u);
6704
6705 sha256_init_sse2 (&digests);
6706
6707 sha256_final_sse2 (in_u, &digests);
6708
6709 transpose_sha256_digest (&digests, dgst);
6710
6711 thread_parameter->indb (thread_parameter, in, dgst, db->salts_buf[0]);
6712 }
6713
hashing_01440(thread_parameter_t * thread_parameter,plain_t * in)6714 void hashing_01440 (thread_parameter_t *thread_parameter, plain_t *in)
6715 {
6716 digest_sha256_sse2_t digests;
6717
6718 digest_t dgst[4];
6719
6720 plain_t plains[4];
6721
6722 plain_t in_u[4];
6723
6724 db_t *db = thread_parameter->db;
6725
6726 uint32_t salts_idx;
6727
6728 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
6729 {
6730 salt_t *salt = db->salts_buf[salts_idx];
6731
6732 if (salt->indexes_found == salt->indexes_cnt) continue;
6733
6734 plain_init (plains);
6735
6736 plain_unicode (in, in_u);
6737
6738 sha256_init_sse2 (&digests);
6739
6740 sha256_update_sse2_max55 (plains, salt->salt_plain_struct);
6741
6742 sha256_update_sse2_max55 (plains, in_u);
6743
6744 sha256_final_sse2_max55 (plains, &digests);
6745
6746 transpose_sha256_digest (&digests, dgst);
6747
6748 thread_parameter->indb (thread_parameter, in, dgst, salt);
6749 }
6750 }
6751
hashing_01450(thread_parameter_t * thread_parameter,plain_t * plains)6752 void hashing_01450 (thread_parameter_t *thread_parameter, plain_t *plains)
6753 {
6754 digest_t digests[4];
6755
6756 plain_t plains_tmp[4];
6757
6758 char *ptrs_tmp[4];
6759
6760 ptrs_tmp[0] = (char *) &plains_tmp[0].buf;
6761 ptrs_tmp[1] = (char *) &plains_tmp[1].buf;
6762 ptrs_tmp[2] = (char *) &plains_tmp[2].buf;
6763 ptrs_tmp[3] = (char *) &plains_tmp[3].buf;
6764
6765 uint32_t ipad_dgst[8][4] __attribute__ ((aligned (16)));
6766 uint32_t opad_dgst[8][4] __attribute__ ((aligned (16)));
6767
6768 uint32_t ipad_buf[16][4] __attribute__ ((aligned (16)));
6769 uint32_t opad_buf[16][4] __attribute__ ((aligned (16)));
6770
6771 db_t *db = thread_parameter->db;
6772
6773 uint32_t i;
6774 uint32_t j;
6775 uint32_t l;
6776
6777 for (i = 0; i < 4; i++)
6778 {
6779 for (j = 0; j < 16; j++)
6780 {
6781 ipad_buf[j][i] = 0x36363636 ^ plains[i].buf[j];
6782 opad_buf[j][i] = 0x5c5c5c5c ^ plains[i].buf[j];
6783 }
6784
6785 ipad_dgst[0][i] = SHA256M_A;
6786 ipad_dgst[1][i] = SHA256M_B;
6787 ipad_dgst[2][i] = SHA256M_C;
6788 ipad_dgst[3][i] = SHA256M_D;
6789 ipad_dgst[4][i] = SHA256M_E;
6790 ipad_dgst[5][i] = SHA256M_F;
6791 ipad_dgst[6][i] = SHA256M_G;
6792 ipad_dgst[7][i] = SHA256M_H;
6793
6794 opad_dgst[0][i] = SHA256M_A;
6795 opad_dgst[1][i] = SHA256M_B;
6796 opad_dgst[2][i] = SHA256M_C;
6797 opad_dgst[3][i] = SHA256M_D;
6798 opad_dgst[4][i] = SHA256M_E;
6799 opad_dgst[5][i] = SHA256M_F;
6800 opad_dgst[6][i] = SHA256M_G;
6801 opad_dgst[7][i] = SHA256M_H;
6802 }
6803
6804 hashcat_sha256_64 ((__m128i *) ipad_dgst, (__m128i *) ipad_buf);
6805 hashcat_sha256_64 ((__m128i *) opad_dgst, (__m128i *) opad_buf);
6806
6807 uint32_t salts_idx;
6808
6809 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
6810 {
6811 salt_t *salt = db->salts_buf[salts_idx];
6812
6813 if (salt->indexes_found == salt->indexes_cnt) continue;
6814
6815 uint32_t ipad_dgst_tmp[8][4] __attribute__ ((aligned (16)));
6816 uint32_t opad_dgst_tmp[8][4] __attribute__ ((aligned (16)));
6817
6818 for (i = 0; i < 4; i++)
6819 {
6820 for (j = 0; j < 8; j++)
6821 {
6822 ipad_dgst_tmp[j][i] = ipad_dgst[j][i];
6823 opad_dgst_tmp[j][i] = opad_dgst[j][i];
6824 }
6825 }
6826
6827 for (i = 0; i < 4; i++)
6828 {
6829 memcpy (ptrs_tmp[i], salt->salt_plain_buf, salt->salt_plain_len);
6830
6831 memset (ptrs_tmp[i] + salt->salt_plain_len, 0, BLOCK_SIZE - salt->salt_plain_len);
6832
6833 ptrs_tmp[i][salt->salt_plain_len] = 0x80;
6834
6835 for (j = 0; j < 14; j++) ipad_buf[j][i] = plains_tmp[i].buf[j];
6836
6837 ipad_buf[14][i] = 0;
6838 ipad_buf[15][i] = (64 + salt->salt_plain_len) * 8;
6839 }
6840
6841 for (i = 14; i < 16; i++) for (l = 0; l < 4; l++) BYTESWAP (ipad_buf[i][l]);
6842
6843 hashcat_sha256_64 ((__m128i *) ipad_dgst_tmp, (__m128i *) ipad_buf);
6844
6845 for (i = 0; i < 4; i++)
6846 {
6847 for (j = 0; j < 8; j++)
6848 {
6849 opad_buf[j][i] = ipad_dgst_tmp[j][i];
6850 }
6851
6852 opad_buf[ 8][i] = 0x80000000;
6853 opad_buf[ 9][i] = 0;
6854 opad_buf[10][i] = 0;
6855 opad_buf[11][i] = 0;
6856 opad_buf[12][i] = 0;
6857 opad_buf[13][i] = 0;
6858 opad_buf[14][i] = 0;
6859 opad_buf[15][i] = (64 + 32) * 8;
6860 }
6861
6862 for (i = 0; i < 16; i++) for (l = 0; l < 4; l++) BYTESWAP (opad_buf[i][l]);
6863
6864 hashcat_sha256_64 ((__m128i *) opad_dgst_tmp, (__m128i *) opad_buf);
6865
6866 for (i = 0; i < 4; i++)
6867 {
6868 for (j = 0; j < 8; j++)
6869 {
6870 digests[i].buf.sha256[j] = opad_dgst_tmp[j][i];
6871 }
6872 }
6873
6874 thread_parameter->indb (thread_parameter, plains, digests, salt);
6875 }
6876 }
6877
hashing_01460(thread_parameter_t * thread_parameter,plain_t * plains)6878 void hashing_01460 (thread_parameter_t *thread_parameter, plain_t *plains)
6879 {
6880 digest_t digests[4];
6881
6882 plain_t plains_tmp[4];
6883
6884 char *ptrs[4];
6885
6886 ptrs[0] = (char *) &plains[0].buf;
6887 ptrs[1] = (char *) &plains[1].buf;
6888 ptrs[2] = (char *) &plains[2].buf;
6889 ptrs[3] = (char *) &plains[3].buf;
6890
6891 char *ptrs_tmp[4];
6892
6893 ptrs_tmp[0] = (char *) &plains_tmp[0].buf;
6894 ptrs_tmp[1] = (char *) &plains_tmp[1].buf;
6895 ptrs_tmp[2] = (char *) &plains_tmp[2].buf;
6896 ptrs_tmp[3] = (char *) &plains_tmp[3].buf;
6897
6898 uint32_t ipad_dgst[8][4] __attribute__ ((aligned (16)));
6899 uint32_t opad_dgst[8][4] __attribute__ ((aligned (16)));
6900
6901 uint32_t ipad_buf[16][4] __attribute__ ((aligned (16)));
6902 uint32_t opad_buf[16][4] __attribute__ ((aligned (16)));
6903
6904 db_t *db = thread_parameter->db;
6905
6906 uint32_t i;
6907 uint32_t j;
6908 uint32_t l;
6909
6910 uint32_t salts_idx;
6911
6912 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
6913 {
6914 salt_t *salt = db->salts_buf[salts_idx];
6915
6916 if (salt->indexes_found == salt->indexes_cnt) continue;
6917
6918 for (i = 0; i < 4; i++)
6919 {
6920 for (j = 0; j < 8; j++)
6921 {
6922 ipad_dgst[j][i] = salt->ipad_prehashed_buf[j];
6923 opad_dgst[j][i] = salt->opad_prehashed_buf[j];
6924 }
6925 }
6926
6927 for (i = 0; i < 4; i++)
6928 {
6929 memcpy (ptrs_tmp[i], ptrs[i], plains[i].len);
6930
6931 memset (ptrs_tmp[i] + plains[i].len, 0, BLOCK_SIZE - plains[i].len);
6932
6933 ptrs_tmp[i][plains[i].len] = 0x80;
6934
6935 for (j = 0; j < 14; j++) ipad_buf[j][i] = plains_tmp[i].buf[j];
6936
6937 ipad_buf[14][i] = 0;
6938 ipad_buf[15][i] = (64 + plains[i].len) * 8;
6939 }
6940
6941 for (i = 14; i < 16; i++) for (l = 0; l < 4; l++) BYTESWAP (ipad_buf[i][l]);
6942
6943 hashcat_sha256_64 ((__m128i *) ipad_dgst, (__m128i *) ipad_buf);
6944
6945 for (i = 0; i < 4; i++)
6946 {
6947 for (j = 0; j < 8; j++)
6948 {
6949 opad_buf[j][i] = ipad_dgst[j][i];
6950 }
6951
6952 opad_buf[ 8][i] = 0x80000000;
6953 opad_buf[ 9][i] = 0;
6954 opad_buf[10][i] = 0;
6955 opad_buf[11][i] = 0;
6956 opad_buf[12][i] = 0;
6957 opad_buf[13][i] = 0;
6958 opad_buf[14][i] = 0;
6959 opad_buf[15][i] = (64 + 32) * 8;
6960 }
6961
6962 for (i = 0; i < 16; i++) for (l = 0; l < 4; l++) BYTESWAP (opad_buf[i][l]);
6963
6964 hashcat_sha256_64 ((__m128i *) opad_dgst, (__m128i *) opad_buf);
6965
6966 for (i = 0; i < 4; i++)
6967 {
6968 for (j = 0; j < 8; j++)
6969 {
6970 digests[i].buf.sha256[j] = opad_dgst[j][i];
6971 }
6972 }
6973
6974 thread_parameter->indb (thread_parameter, plains, digests, salt);
6975 }
6976 }
6977
hashing_01500(thread_parameter_t * thread_parameter,plain_t * plains)6978 void hashing_01500 (thread_parameter_t *thread_parameter, plain_t *plains)
6979 {
6980 digest_t digests[4];
6981
6982 plain_t plains_tmp[4];
6983
6984 memcpy (plains_tmp, plains, sizeof (plains_tmp));
6985
6986 db_t *db = thread_parameter->db;
6987
6988 uint32_t salts_idx;
6989
6990 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
6991 {
6992 salt_t *salt = db->salts_buf[salts_idx];
6993
6994 if (salt->indexes_found == salt->indexes_cnt) continue;
6995
6996 const uint des_salt = itoa64_to_int (salt->salt_plain_buf[0])
6997 | itoa64_to_int (salt->salt_plain_buf[1]) << 6;
6998
6999 plains_tmp[0].buf[2] = des_salt;
7000 plains_tmp[1].buf[2] = des_salt;
7001 plains_tmp[2].buf[2] = des_salt;
7002 plains_tmp[3].buf[2] = des_salt;
7003
7004 descrypt_64 (plains_tmp, digests);
7005
7006 /* TODO : search for buffer overflow when plains is filled */
7007 /* plains[0].buf[2] = plains[0].buf[3] = plains[0].buf[4] = 0;
7008 plains[1].buf[2] = plains[1].buf[3] = plains[1].buf[4] = 0;
7009 plains[2].buf[2] = plains[2].buf[3] = plains[2].buf[4] = 0;
7010 plains[2].buf[2] = plains[2].buf[3] = plains[3].buf[4] = 0;
7011 */
7012 thread_parameter->indb (thread_parameter, plains, digests, salt);
7013 }
7014 }
7015
hashing_01600(thread_parameter_t * thread_parameter,plain_t * in)7016 void hashing_01600 (thread_parameter_t *thread_parameter, plain_t *in)
7017 {
7018 digest_md5_sse2_t digests;
7019
7020 digest_t dgst[4];
7021
7022 plain_t plains[4];
7023
7024 char *ptrs[4];
7025
7026 ptrs[0] = (char *) &in[0].buf;
7027 ptrs[1] = (char *) &in[1].buf;
7028 ptrs[2] = (char *) &in[2].buf;
7029 ptrs[3] = (char *) &in[3].buf;
7030
7031 char *ptrs_tmp[4];
7032
7033 ptrs_tmp[0] = (char *) &plains[0].buf;
7034 ptrs_tmp[1] = (char *) &plains[1].buf;
7035 ptrs_tmp[2] = (char *) &plains[2].buf;
7036 ptrs_tmp[3] = (char *) &plains[3].buf;
7037
7038 db_t *db = thread_parameter->db;
7039
7040 uint32_t salts_idx;
7041
7042 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
7043 {
7044 salt_t *salt = db->salts_buf[salts_idx];
7045
7046 if (salt->indexes_found == salt->indexes_cnt) continue;
7047
7048 plain_init (plains);
7049
7050 md5_init_sse2 (&digests);
7051
7052 md5_update_sse2_max55 (plains, in);
7053
7054 md5_update_sse2_max55 (plains, salt->salt_plain_struct);
7055
7056 md5_update_sse2_max55 (plains, in);
7057
7058 md5_final_sse2_max55 (plains, &digests);
7059
7060 transpose_md5_digest (&digests, dgst);
7061
7062 uint32_t i;
7063
7064 for (i = 0; i < 4; i++)
7065 {
7066 if (in[i].len > 16) continue;
7067
7068 plains[i].len = in[i].len + MD5APR_SIGN + salt->salt_plain_len;
7069
7070 /* The password first, since that is what is most unknown */
7071 /* Then our magic string */
7072 /* Then the raw salt */
7073 /* Then just as many characters of the MD5(pw,salt,pw) */
7074
7075 memcpy (ptrs_tmp[i], ptrs[i], in[i].len);
7076 memcpy (ptrs_tmp[i] + in[i].len, MD5APR_MAGIC, MD5APR_SIGN);
7077 memcpy (ptrs_tmp[i] + in[i].len + MD5APR_SIGN, salt->salt_plain_buf, salt->salt_plain_len);
7078 memcpy (ptrs_tmp[i] + plains[i].len, dgst[i].buf.md5, in[i].len);
7079
7080 plains[i].len += in[i].len;
7081
7082 /* Then something really weird... */
7083
7084 switch (in[i].len)
7085 {
7086 case 1:
7087 ptrs_tmp[i][plains[i].len + 0] = 0;
7088 plains[i].len += 1;
7089 break;
7090
7091 case 2:
7092 ptrs_tmp[i][plains[i].len + 0] = ptrs[i][0];
7093 ptrs_tmp[i][plains[i].len + 1] = 0;
7094 plains[i].len += 2;
7095 break;
7096
7097 case 3:
7098 ptrs_tmp[i][plains[i].len + 0] = 0;
7099 ptrs_tmp[i][plains[i].len + 1] = 0;
7100 plains[i].len += 2;
7101 break;
7102
7103 case 4:
7104 ptrs_tmp[i][plains[i].len + 0] = ptrs[i][0];
7105 ptrs_tmp[i][plains[i].len + 1] = ptrs[i][0];
7106 ptrs_tmp[i][plains[i].len + 2] = 0;
7107 plains[i].len += 3;
7108 break;
7109
7110 case 5:
7111 ptrs_tmp[i][plains[i].len + 0] = 0;
7112 ptrs_tmp[i][plains[i].len + 1] = ptrs[i][0];
7113 ptrs_tmp[i][plains[i].len + 2] = 0;
7114 plains[i].len += 3;
7115 break;
7116
7117 case 6:
7118 ptrs_tmp[i][plains[i].len + 0] = ptrs[i][0];
7119 ptrs_tmp[i][plains[i].len + 1] = 0;
7120 ptrs_tmp[i][plains[i].len + 2] = 0;
7121 plains[i].len += 3;
7122 break;
7123
7124 case 7:
7125 ptrs_tmp[i][plains[i].len + 0] = 0;
7126 ptrs_tmp[i][plains[i].len + 1] = 0;
7127 ptrs_tmp[i][plains[i].len + 2] = 0;
7128 plains[i].len += 3;
7129 break;
7130
7131 case 8:
7132 ptrs_tmp[i][plains[i].len + 0] = ptrs[i][0];
7133 ptrs_tmp[i][plains[i].len + 1] = ptrs[i][0];
7134 ptrs_tmp[i][plains[i].len + 2] = ptrs[i][0];
7135 ptrs_tmp[i][plains[i].len + 3] = 0;
7136 plains[i].len += 4;
7137 break;
7138
7139 case 9:
7140 ptrs_tmp[i][plains[i].len + 0] = 0;
7141 ptrs_tmp[i][plains[i].len + 1] = ptrs[i][0];
7142 ptrs_tmp[i][plains[i].len + 2] = ptrs[i][0];
7143 ptrs_tmp[i][plains[i].len + 3] = 0;
7144 plains[i].len += 4;
7145 break;
7146
7147 case 10:
7148 ptrs_tmp[i][plains[i].len + 0] = ptrs[i][0];
7149 ptrs_tmp[i][plains[i].len + 1] = 0;
7150 ptrs_tmp[i][plains[i].len + 2] = ptrs[i][0];
7151 ptrs_tmp[i][plains[i].len + 3] = 0;
7152 plains[i].len += 4;
7153 break;
7154
7155 case 11:
7156 ptrs_tmp[i][plains[i].len + 0] = 0;
7157 ptrs_tmp[i][plains[i].len + 1] = 0;
7158 ptrs_tmp[i][plains[i].len + 2] = ptrs[i][0];
7159 ptrs_tmp[i][plains[i].len + 3] = 0;
7160 plains[i].len += 4;
7161 break;
7162
7163 case 12:
7164 ptrs_tmp[i][plains[i].len + 0] = ptrs[i][0];
7165 ptrs_tmp[i][plains[i].len + 1] = ptrs[i][0];
7166 ptrs_tmp[i][plains[i].len + 2] = 0;
7167 ptrs_tmp[i][plains[i].len + 3] = 0;
7168 plains[i].len += 4;
7169 break;
7170
7171 case 13:
7172 ptrs_tmp[i][plains[i].len + 0] = 0;
7173 ptrs_tmp[i][plains[i].len + 1] = ptrs[i][0];
7174 ptrs_tmp[i][plains[i].len + 2] = 0;
7175 ptrs_tmp[i][plains[i].len + 3] = 0;
7176 plains[i].len += 4;
7177 break;
7178
7179 case 14:
7180 ptrs_tmp[i][plains[i].len + 0] = ptrs[i][0];
7181 ptrs_tmp[i][plains[i].len + 1] = 0;
7182 ptrs_tmp[i][plains[i].len + 2] = 0;
7183 ptrs_tmp[i][plains[i].len + 3] = 0;
7184 plains[i].len += 4;
7185 break;
7186
7187 case 15:
7188 ptrs_tmp[i][plains[i].len + 0] = 0;
7189 ptrs_tmp[i][plains[i].len + 1] = 0;
7190 ptrs_tmp[i][plains[i].len + 2] = 0;
7191 ptrs_tmp[i][plains[i].len + 3] = 0;
7192 plains[i].len += 4;
7193 break;
7194 }
7195 }
7196
7197 md5_init_sse2 (&digests);
7198
7199 md5_final_sse2_max55 (plains, &digests);
7200
7201 transpose_md5_digest (&digests, dgst);
7202
7203 /* and now, just to make sure things don't run too fast */
7204
7205 uint32_t j;
7206
7207 for (j = 0; j < salt->iterations; j++)
7208 {
7209 int a1 = j & 1;
7210 int m3 = j % 3;
7211 int m7 = j % 7;
7212
7213 for (i = 0; i < 4; i++)
7214 {
7215 if (in[i].len > 16) continue;
7216
7217 memset (ptrs_tmp[i], 0, BLOCK_SIZE);
7218
7219 plains[i].len = 0;
7220
7221 if (a1)
7222 {
7223 memcpy (ptrs_tmp[i] + plains[i].len, ptrs[i], in[i].len);
7224
7225 plains[i].len += in[i].len;
7226 }
7227 else
7228 {
7229 memcpy (ptrs_tmp[i] + plains[i].len, dgst[i].buf.md5, 16);
7230
7231 plains[i].len += 16;
7232 }
7233
7234 if (m3)
7235 {
7236 memcpy (ptrs_tmp[i] + plains[i].len, salt->salt_plain_buf, salt->salt_plain_len);
7237
7238 plains[i].len += salt->salt_plain_len;
7239 }
7240
7241 if (m7)
7242 {
7243 memcpy (ptrs_tmp[i] + plains[i].len, ptrs[i], in[i].len);
7244
7245 plains[i].len += in[i].len;
7246 }
7247
7248 if (a1)
7249 {
7250 memcpy (ptrs_tmp[i] + plains[i].len, dgst[i].buf.md5, 16);
7251
7252 plains[i].len += 16;
7253 }
7254 else
7255 {
7256 memcpy (ptrs_tmp[i] + plains[i].len, ptrs[i], in[i].len);
7257
7258 plains[i].len += in[i].len;
7259 }
7260 }
7261
7262 md5_init_sse2 (&digests);
7263
7264 md5_final_sse2_max55 (plains, &digests);
7265
7266 transpose_md5_digest (&digests, dgst);
7267 }
7268
7269 thread_parameter->indb (thread_parameter, in, dgst, salt);
7270 }
7271 }
7272
hashing_01700(thread_parameter_t * thread_parameter,plain_t * in)7273 void hashing_01700 (thread_parameter_t *thread_parameter, plain_t *in)
7274 {
7275 digest_sha512_sse2_t digests;
7276
7277 digest_t dgst[4];
7278
7279 db_t *db = thread_parameter->db;
7280
7281 sha512_init_sse2 (&digests);
7282
7283 sha512_final_sse2 (in, &digests);
7284
7285 transpose_sha512_digest (&digests, dgst);
7286
7287 thread_parameter->indb (thread_parameter, in, dgst, db->salts_buf[0]);
7288 }
7289
hashing_01710(thread_parameter_t * thread_parameter,plain_t * in)7290 void hashing_01710 (thread_parameter_t *thread_parameter, plain_t *in)
7291 {
7292 digest_sha512_sse2_t digests;
7293
7294 digest_t dgst[4];
7295
7296 plain_t plains[4];
7297
7298 db_t *db = thread_parameter->db;
7299
7300 uint32_t salts_idx;
7301
7302 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
7303 {
7304 salt_t *salt = db->salts_buf[salts_idx];
7305
7306 if (salt->indexes_found == salt->indexes_cnt) continue;
7307
7308 plain_init (plains);
7309
7310 sha512_init_sse2 (&digests);
7311
7312 sha512_update_sse2 (plains, &digests, in);
7313
7314 sha512_update_sse2 (plains, &digests, salt->salt_plain_struct);
7315
7316 sha512_final_sse2 (plains, &digests);
7317
7318 transpose_sha512_digest (&digests, dgst);
7319
7320 thread_parameter->indb (thread_parameter, in, dgst, salt);
7321 }
7322 }
7323
hashing_01720(thread_parameter_t * thread_parameter,plain_t * in)7324 void hashing_01720 (thread_parameter_t *thread_parameter, plain_t *in)
7325 {
7326 digest_sha512_sse2_t digests;
7327
7328 digest_t dgst[4];
7329
7330 plain_t plains[4];
7331
7332 db_t *db = thread_parameter->db;
7333
7334 uint32_t salts_idx;
7335
7336 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
7337 {
7338 salt_t *salt = db->salts_buf[salts_idx];
7339
7340 if (salt->indexes_found == salt->indexes_cnt) continue;
7341
7342 plain_init (plains);
7343
7344 sha512_init_sse2 (&digests);
7345
7346 sha512_update_sse2 (plains, &digests, salt->salt_plain_struct);
7347
7348 sha512_update_sse2 (plains, &digests, in);
7349
7350 sha512_final_sse2 (plains, &digests);
7351
7352 transpose_sha512_digest (&digests, dgst);
7353
7354 thread_parameter->indb (thread_parameter, in, dgst, salt);
7355 }
7356 }
7357
hashing_01722(thread_parameter_t * thread_parameter,plain_t * in)7358 void hashing_01722 (thread_parameter_t *thread_parameter, plain_t *in)
7359 {
7360 digest_sha512_sse2_t digests;
7361
7362 digest_t dgst[4];
7363
7364 plain_t plains[4];
7365
7366 db_t *db = thread_parameter->db;
7367
7368 uint32_t salts_idx;
7369
7370 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
7371 {
7372 salt_t *salt = db->salts_buf[salts_idx];
7373
7374 if (salt->indexes_found == salt->indexes_cnt) continue;
7375
7376 plain_init (plains);
7377
7378 sha512_init_sse2 (&digests);
7379
7380 sha512_update_sse2 (plains, &digests, salt->salt_plain_struct);
7381
7382 sha512_update_sse2 (plains, &digests, in);
7383
7384 sha512_final_sse2 (plains, &digests);
7385
7386 transpose_sha512_digest (&digests, dgst);
7387
7388 thread_parameter->indb (thread_parameter, in, dgst, salt);
7389 }
7390 }
7391
hashing_01730(thread_parameter_t * thread_parameter,plain_t * in)7392 void hashing_01730 (thread_parameter_t *thread_parameter, plain_t *in)
7393 {
7394 digest_sha512_sse2_t digests;
7395
7396 digest_t dgst[4];
7397
7398 plain_t plains[4];
7399
7400 plain_t in_u[4];
7401
7402 plain_unicode (in, in_u);
7403
7404 db_t *db = thread_parameter->db;
7405
7406 uint32_t salts_idx;
7407
7408 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
7409 {
7410 salt_t *salt = db->salts_buf[salts_idx];
7411
7412 if (salt->indexes_found == salt->indexes_cnt) continue;
7413
7414 plain_init (plains);
7415
7416 sha512_init_sse2 (&digests);
7417
7418 sha512_update_sse2 (plains, &digests, in_u);
7419
7420 sha512_update_sse2 (plains, &digests, salt->salt_plain_struct);
7421
7422 sha512_final_sse2 (plains, &digests);
7423
7424 transpose_sha512_digest (&digests, dgst);
7425
7426 thread_parameter->indb (thread_parameter, in, dgst, salt);
7427 }
7428 }
7429
hashing_01740(thread_parameter_t * thread_parameter,plain_t * in)7430 void hashing_01740 (thread_parameter_t *thread_parameter, plain_t *in)
7431 {
7432 digest_sha512_sse2_t digests;
7433
7434 digest_t dgst[4];
7435
7436 plain_t plains[4];
7437
7438 plain_t in_u[4];
7439
7440 plain_unicode (in, in_u);
7441
7442 db_t *db = thread_parameter->db;
7443
7444 uint32_t salts_idx;
7445
7446 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
7447 {
7448 salt_t *salt = db->salts_buf[salts_idx];
7449
7450 if (salt->indexes_found == salt->indexes_cnt) continue;
7451
7452 plain_init (plains);
7453
7454 sha512_init_sse2 (&digests);
7455
7456 sha512_update_sse2 (plains, &digests, salt->salt_plain_struct);
7457
7458 sha512_update_sse2 (plains, &digests, in_u);
7459
7460 sha512_final_sse2 (plains, &digests);
7461
7462 transpose_sha512_digest (&digests, dgst);
7463
7464 thread_parameter->indb (thread_parameter, in, dgst, salt);
7465 }
7466 }
7467
hashing_01750(thread_parameter_t * thread_parameter,plain_t * plains)7468 void hashing_01750 (thread_parameter_t *thread_parameter, plain_t *plains)
7469 {
7470 digest_t digests[4];
7471
7472 plain_t plains_tmp[4];
7473
7474 char *ptrs_tmp[4];
7475
7476 ptrs_tmp[0] = (char *) &plains_tmp[0].buf64;
7477 ptrs_tmp[1] = (char *) &plains_tmp[1].buf64;
7478 ptrs_tmp[2] = (char *) &plains_tmp[2].buf64;
7479 ptrs_tmp[3] = (char *) &plains_tmp[3].buf64;
7480
7481 uint64_t ipad_dgst[8][2] __attribute__ ((aligned (16)));
7482 uint64_t opad_dgst[8][2] __attribute__ ((aligned (16)));
7483
7484 uint64_t ipad_buf[16][2] __attribute__ ((aligned (16)));
7485 uint64_t opad_buf[16][2] __attribute__ ((aligned (16)));
7486
7487 db_t *db = thread_parameter->db;
7488
7489 /*
7490 * dirty workaround
7491 */
7492
7493 uint32_t k;
7494
7495 for (k = 0; k < 4; k += 2)
7496 {
7497 uint32_t i;
7498 uint32_t j;
7499
7500 for (i = 0; i < 2; i++)
7501 {
7502 for (j = 0; j < 16; j++)
7503 {
7504 ipad_buf[j][i] = 0x3636363636363636 ^ plains[i + k].buf64[j];
7505 opad_buf[j][i] = 0x5c5c5c5c5c5c5c5c ^ plains[i + k].buf64[j];
7506 }
7507
7508 ipad_dgst[0][i] = SHA512M_A;
7509 ipad_dgst[1][i] = SHA512M_B;
7510 ipad_dgst[2][i] = SHA512M_C;
7511 ipad_dgst[3][i] = SHA512M_D;
7512 ipad_dgst[4][i] = SHA512M_E;
7513 ipad_dgst[5][i] = SHA512M_F;
7514 ipad_dgst[6][i] = SHA512M_G;
7515 ipad_dgst[7][i] = SHA512M_H;
7516
7517 opad_dgst[0][i] = SHA512M_A;
7518 opad_dgst[1][i] = SHA512M_B;
7519 opad_dgst[2][i] = SHA512M_C;
7520 opad_dgst[3][i] = SHA512M_D;
7521 opad_dgst[4][i] = SHA512M_E;
7522 opad_dgst[5][i] = SHA512M_F;
7523 opad_dgst[6][i] = SHA512M_G;
7524 opad_dgst[7][i] = SHA512M_H;
7525 }
7526
7527 hashcat_sha512_64 ((__m128i *) ipad_dgst, (__m128i *) ipad_buf);
7528 hashcat_sha512_64 ((__m128i *) opad_dgst, (__m128i *) opad_buf);
7529
7530 uint32_t salts_idx;
7531
7532 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
7533 {
7534 salt_t *salt = db->salts_buf[salts_idx];
7535
7536 if (salt->indexes_found == salt->indexes_cnt) continue;
7537
7538 uint64_t ipad_dgst_tmp[8][2] __attribute__ ((aligned (16)));
7539 uint64_t opad_dgst_tmp[8][2] __attribute__ ((aligned (16)));
7540
7541 for (i = 0; i < 2; i++)
7542 {
7543 for (j = 0; j < 8; j++)
7544 {
7545 ipad_dgst_tmp[j][i] = ipad_dgst[j][i];
7546 opad_dgst_tmp[j][i] = opad_dgst[j][i];
7547 }
7548 }
7549
7550 for (i = 0; i < 2; i++)
7551 {
7552 memcpy (ptrs_tmp[i], salt->salt_plain_buf, salt->salt_plain_len);
7553
7554 memset (ptrs_tmp[i] + salt->salt_plain_len, 0, 128 - salt->salt_plain_len);
7555
7556 ptrs_tmp[i][salt->salt_plain_len] = 0x80;
7557
7558 for (j = 0; j < 14; j++) ipad_buf[j][i] = plains_tmp[i].buf64[j];
7559
7560 ipad_buf[14][i] = 0;
7561 ipad_buf[15][i] = (128 + salt->salt_plain_len) * 8;
7562
7563 BYTESWAP64 (ipad_buf[15][i]);
7564 }
7565
7566 hashcat_sha512_64 ((__m128i *) ipad_dgst_tmp, (__m128i *) ipad_buf);
7567
7568 for (i = 0; i < 2; i++)
7569 {
7570 for (j = 0; j < 8; j++)
7571 {
7572 opad_buf[j][i] = ipad_dgst_tmp[j][i];
7573 }
7574
7575 opad_buf[ 8][i] = 0x8000000000000000;
7576 opad_buf[ 9][i] = 0;
7577 opad_buf[10][i] = 0;
7578 opad_buf[11][i] = 0;
7579 opad_buf[12][i] = 0;
7580 opad_buf[13][i] = 0;
7581 opad_buf[14][i] = 0;
7582 opad_buf[15][i] = (128 + 64) * 8;
7583 }
7584
7585 for (i = 0; i < 2; i++) for (j = 0; j < 16; j++) BYTESWAP64 (opad_buf[j][i]);
7586
7587 hashcat_sha512_64 ((__m128i *) opad_dgst_tmp, (__m128i *) opad_buf);
7588
7589 for (i = 0; i < 2; i++)
7590 {
7591 for (j = 0; j < 8; j++)
7592 {
7593 digests[i].buf.sha512[j] = opad_dgst_tmp[j][i];
7594 }
7595 }
7596
7597 thread_parameter->indb (thread_parameter, &plains[k], digests, salt);
7598 }
7599 }
7600 }
7601
hashing_01760(thread_parameter_t * thread_parameter,plain_t * plains)7602 void hashing_01760 (thread_parameter_t *thread_parameter, plain_t *plains)
7603 {
7604 digest_t digests[4];
7605
7606 plain_t plains_tmp[4];
7607
7608 char *ptrs[4];
7609
7610 ptrs[0] = (char *) &plains[0].buf64;
7611 ptrs[1] = (char *) &plains[1].buf64;
7612 ptrs[2] = (char *) &plains[2].buf64;
7613 ptrs[3] = (char *) &plains[3].buf64;
7614
7615 char *ptrs_tmp[4];
7616
7617 ptrs_tmp[0] = (char *) &plains_tmp[0].buf64;
7618 ptrs_tmp[1] = (char *) &plains_tmp[1].buf64;
7619 ptrs_tmp[2] = (char *) &plains_tmp[2].buf64;
7620 ptrs_tmp[3] = (char *) &plains_tmp[3].buf64;
7621
7622 uint64_t ipad_dgst[8][2] __attribute__ ((aligned (16)));
7623 uint64_t opad_dgst[8][2] __attribute__ ((aligned (16)));
7624
7625 uint64_t ipad_buf[16][2] __attribute__ ((aligned (16)));
7626 uint64_t opad_buf[16][2] __attribute__ ((aligned (16)));
7627
7628 db_t *db = thread_parameter->db;
7629
7630 uint32_t i;
7631 uint32_t j;
7632
7633 uint32_t salts_idx;
7634
7635 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
7636 {
7637 salt_t *salt = db->salts_buf[salts_idx];
7638
7639 if (salt->indexes_found == salt->indexes_cnt) continue;
7640
7641 /*
7642 * dirty workaround
7643 */
7644
7645 uint32_t k;
7646
7647 for (k = 0; k < 4; k += 2)
7648 {
7649 for (i = 0; i < 2; i++)
7650 {
7651 for (j = 0; j < 8; j++)
7652 {
7653 ipad_dgst[j][i] = salt->ipad_prehashed_buf64[j];
7654 opad_dgst[j][i] = salt->opad_prehashed_buf64[j];
7655 }
7656 }
7657
7658 for (i = 0; i < 2; i++)
7659 {
7660 memcpy (ptrs_tmp[i], ptrs[i + k], plains[i + k].len);
7661
7662 memset (ptrs_tmp[i] + plains[i + k].len, 0, 128 - plains[i + k].len);
7663
7664 ptrs_tmp[i][plains[i + k].len] = 0x80;
7665
7666 for (j = 0; j < 14; j++) ipad_buf[j][i] = plains_tmp[i].buf64[j];
7667
7668 ipad_buf[14][i] = 0;
7669 ipad_buf[15][i] = (128 + plains[i + k].len) * 8;
7670
7671 BYTESWAP64 (ipad_buf[15][i]);
7672 }
7673
7674 hashcat_sha512_64 ((__m128i *) ipad_dgst, (__m128i *) ipad_buf);
7675
7676 for (i = 0; i < 2; i++)
7677 {
7678 for (j = 0; j < 8; j++)
7679 {
7680 opad_buf[j][i] = ipad_dgst[j][i];
7681 }
7682
7683 opad_buf[ 8][i] = 0x8000000000000000;
7684 opad_buf[ 9][i] = 0;
7685 opad_buf[10][i] = 0;
7686 opad_buf[11][i] = 0;
7687 opad_buf[12][i] = 0;
7688 opad_buf[13][i] = 0;
7689 opad_buf[14][i] = 0;
7690 opad_buf[15][i] = (128 + 64) * 8;
7691 }
7692
7693 for (i = 0; i < 2; i++) for (j = 0; j < 16; j++) BYTESWAP64 (opad_buf[j][i]);
7694
7695 hashcat_sha512_64 ((__m128i *) opad_dgst, (__m128i *) opad_buf);
7696
7697 for (i = 0; i < 2; i++)
7698 {
7699 for (j = 0; j < 8; j++)
7700 {
7701 digests[i].buf.sha512[j] = opad_dgst[j][i];
7702 }
7703 }
7704
7705 thread_parameter->indb (thread_parameter, &plains[k], digests, salt);
7706 }
7707 }
7708 }
7709
hashing_01800(thread_parameter_t * thread_parameter,plain_t * in)7710 void hashing_01800 (thread_parameter_t *thread_parameter, plain_t *in)
7711 {
7712 db_t *db = thread_parameter->db;
7713
7714 uint32_t salts_idx;
7715
7716 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
7717 {
7718 salt_t *salt = db->salts_buf[salts_idx];
7719
7720 if (salt->indexes_found == salt->indexes_cnt) continue;
7721
7722 char *salt_buf = salt->salt_plain_buf;
7723 int salt_len = salt->salt_plain_len;
7724
7725 char *password0_buf = (char *) in[0].buf64;
7726 char *password1_buf = (char *) in[1].buf64;
7727 char *password2_buf = (char *) in[2].buf64;
7728 char *password3_buf = (char *) in[3].buf64;
7729 int password0_len = in[0].len;
7730 int password1_len = in[1].len;
7731 int password2_len = in[2].len;
7732 int password3_len = in[3].len;
7733
7734 hc_sha512_ctx ctx0;
7735 hc_sha512_ctx ctx1;
7736 hc_sha512_ctx ctx2;
7737 hc_sha512_ctx ctx3;
7738 hc_sha512_ctx alt_ctx0;
7739 hc_sha512_ctx alt_ctx1;
7740 hc_sha512_ctx alt_ctx2;
7741 hc_sha512_ctx alt_ctx3;
7742
7743 hc_sha512_ctx p_bytes0;
7744 hc_sha512_ctx p_bytes1;
7745 hc_sha512_ctx p_bytes2;
7746 hc_sha512_ctx p_bytes3;
7747 hc_sha512_ctx s_bytes0;
7748 hc_sha512_ctx s_bytes1;
7749 hc_sha512_ctx s_bytes2;
7750 hc_sha512_ctx s_bytes3;
7751
7752 /* Prepare for the real work. */
7753 sha512_init (&ctx0);
7754 sha512_init (&ctx1);
7755 sha512_init (&ctx2);
7756 sha512_init (&ctx3);
7757
7758 /* Add the key string. */
7759 sha512_update (&ctx0, password0_buf, password0_len);
7760 sha512_update (&ctx1, password1_buf, password1_len);
7761 sha512_update (&ctx2, password2_buf, password2_len);
7762 sha512_update (&ctx3, password3_buf, password3_len);
7763
7764 /* The last part is the salt string. This must be at most 16
7765 characters and it ends at the first `$' character (for
7766 compatibility with existing implementations). */
7767 sha512_update (&ctx0, salt_buf, salt_len);
7768 sha512_update (&ctx1, salt_buf, salt_len);
7769 sha512_update (&ctx2, salt_buf, salt_len);
7770 sha512_update (&ctx3, salt_buf, salt_len);
7771
7772 /* Compute alternate SHA512 sum with input KEY, SALT, and KEY. The
7773 final result will be added to the first context. */
7774 sha512_init (&alt_ctx0);
7775 sha512_init (&alt_ctx1);
7776 sha512_init (&alt_ctx2);
7777 sha512_init (&alt_ctx3);
7778
7779 /* Add key. */
7780 sha512_update (&alt_ctx0, password0_buf, password0_len);
7781 sha512_update (&alt_ctx1, password1_buf, password1_len);
7782 sha512_update (&alt_ctx2, password2_buf, password2_len);
7783 sha512_update (&alt_ctx3, password3_buf, password3_len);
7784
7785 /* Add salt. */
7786 sha512_update (&alt_ctx0, salt_buf, salt_len);
7787 sha512_update (&alt_ctx1, salt_buf, salt_len);
7788 sha512_update (&alt_ctx2, salt_buf, salt_len);
7789 sha512_update (&alt_ctx3, salt_buf, salt_len);
7790
7791 /* Add key again. */
7792 sha512_update (&alt_ctx0, password0_buf, password0_len);
7793 sha512_update (&alt_ctx1, password1_buf, password1_len);
7794 sha512_update (&alt_ctx2, password2_buf, password2_len);
7795 sha512_update (&alt_ctx3, password3_buf, password3_len);
7796
7797 /* Now get result of this (64 bytes) and add it to the other context. */
7798 sha512_final (&alt_ctx0);
7799 sha512_final (&alt_ctx1);
7800 sha512_final (&alt_ctx2);
7801 sha512_final (&alt_ctx3);
7802
7803 /* Add for any character in the key one byte of the alternate sum. */
7804
7805 sha512_update (&ctx0, (char *) alt_ctx0.state, password0_len);
7806 sha512_update (&ctx1, (char *) alt_ctx1.state, password1_len);
7807 sha512_update (&ctx2, (char *) alt_ctx2.state, password2_len);
7808 sha512_update (&ctx3, (char *) alt_ctx3.state, password3_len);
7809
7810 /* Take the binary representation of the length of the key and for every
7811 1 add the alternate sum, for every 0 the key. */
7812
7813 int cnt;
7814
7815 for (cnt = password0_len; cnt > 0; cnt >>= 1)
7816 {
7817 if ((cnt & 1) != 0)
7818 sha512_update (&ctx0, (char *) alt_ctx0.state, 64);
7819 else
7820 sha512_update (&ctx0, password0_buf, password0_len);
7821 }
7822
7823 for (cnt = password1_len; cnt > 0; cnt >>= 1)
7824 {
7825 if ((cnt & 1) != 0)
7826 sha512_update (&ctx1, (char *) alt_ctx1.state, 64);
7827 else
7828 sha512_update (&ctx1, password1_buf, password1_len);
7829 }
7830
7831 for (cnt = password2_len; cnt > 0; cnt >>= 1)
7832 {
7833 if ((cnt & 1) != 0)
7834 sha512_update (&ctx2, (char *) alt_ctx2.state, 64);
7835 else
7836 sha512_update (&ctx2, password2_buf, password2_len);
7837 }
7838
7839 for (cnt = password3_len; cnt > 0; cnt >>= 1)
7840 {
7841 if ((cnt & 1) != 0)
7842 sha512_update (&ctx3, (char *) alt_ctx3.state, 64);
7843 else
7844 sha512_update (&ctx3, password3_buf, password3_len);
7845 }
7846
7847 /* Create intermediate result. */
7848 sha512_final (&ctx0);
7849 sha512_final (&ctx1);
7850 sha512_final (&ctx2);
7851 sha512_final (&ctx3);
7852
7853 /* Start computation of P byte sequence. */
7854 sha512_init (&p_bytes0);
7855 sha512_init (&p_bytes1);
7856 sha512_init (&p_bytes2);
7857 sha512_init (&p_bytes3);
7858
7859 /* For every character in the password add the entire password. */
7860 for (cnt = 0; cnt < password0_len; cnt++)
7861 {
7862 sha512_update (&p_bytes0, password0_buf, password0_len);
7863 }
7864
7865 for (cnt = 0; cnt < password1_len; cnt++)
7866 {
7867 sha512_update (&p_bytes1, password1_buf, password1_len);
7868 }
7869
7870 for (cnt = 0; cnt < password2_len; cnt++)
7871 {
7872 sha512_update (&p_bytes2, password2_buf, password2_len);
7873 }
7874
7875 for (cnt = 0; cnt < password3_len; cnt++)
7876 {
7877 sha512_update (&p_bytes3, password3_buf, password3_len);
7878 }
7879
7880 /* Finish the state. */
7881 sha512_final (&p_bytes0);
7882 sha512_final (&p_bytes1);
7883 sha512_final (&p_bytes2);
7884 sha512_final (&p_bytes3);
7885
7886 /* Start computation of S byte sequence. */
7887 sha512_init (&s_bytes0);
7888 sha512_init (&s_bytes1);
7889 sha512_init (&s_bytes2);
7890 sha512_init (&s_bytes3);
7891
7892 /* For every character in the password add the entire password. */
7893 for (cnt = 0; cnt < 16 + ((unsigned char*) ctx0.state)[0]; cnt++)
7894 {
7895 sha512_update (&s_bytes0, salt_buf, salt_len);
7896 }
7897
7898 for (cnt = 0; cnt < 16 + ((unsigned char*) ctx1.state)[0]; cnt++)
7899 {
7900 sha512_update (&s_bytes1, salt_buf, salt_len);
7901 }
7902
7903 for (cnt = 0; cnt < 16 + ((unsigned char*) ctx2.state)[0]; cnt++)
7904 {
7905 sha512_update (&s_bytes2, salt_buf, salt_len);
7906 }
7907
7908 for (cnt = 0; cnt < 16 + ((unsigned char*) ctx3.state)[0]; cnt++)
7909 {
7910 sha512_update (&s_bytes3, salt_buf, salt_len);
7911 }
7912
7913 /* Finish the state. */
7914 sha512_final (&s_bytes0);
7915 sha512_final (&s_bytes1);
7916 sha512_final (&s_bytes2);
7917 sha512_final (&s_bytes3);
7918
7919 /* sse2 specific */
7920
7921 plain_t plain_alt_ctx[4];
7922
7923 plain_alt_ctx[0].buf64[0] = ctx0.state[0];
7924 plain_alt_ctx[0].buf64[1] = ctx0.state[1];
7925 plain_alt_ctx[0].buf64[2] = ctx0.state[2];
7926 plain_alt_ctx[0].buf64[3] = ctx0.state[3];
7927 plain_alt_ctx[0].buf64[4] = ctx0.state[4];
7928 plain_alt_ctx[0].buf64[5] = ctx0.state[5];
7929 plain_alt_ctx[0].buf64[6] = ctx0.state[6];
7930 plain_alt_ctx[0].buf64[7] = ctx0.state[7];
7931 plain_alt_ctx[1].buf64[0] = ctx1.state[0];
7932 plain_alt_ctx[1].buf64[1] = ctx1.state[1];
7933 plain_alt_ctx[1].buf64[2] = ctx1.state[2];
7934 plain_alt_ctx[1].buf64[3] = ctx1.state[3];
7935 plain_alt_ctx[1].buf64[4] = ctx1.state[4];
7936 plain_alt_ctx[1].buf64[5] = ctx1.state[5];
7937 plain_alt_ctx[1].buf64[6] = ctx1.state[6];
7938 plain_alt_ctx[1].buf64[7] = ctx1.state[7];
7939 plain_alt_ctx[2].buf64[0] = ctx2.state[0];
7940 plain_alt_ctx[2].buf64[1] = ctx2.state[1];
7941 plain_alt_ctx[2].buf64[2] = ctx2.state[2];
7942 plain_alt_ctx[2].buf64[3] = ctx2.state[3];
7943 plain_alt_ctx[2].buf64[4] = ctx2.state[4];
7944 plain_alt_ctx[2].buf64[5] = ctx2.state[5];
7945 plain_alt_ctx[2].buf64[6] = ctx2.state[6];
7946 plain_alt_ctx[2].buf64[7] = ctx2.state[7];
7947 plain_alt_ctx[3].buf64[0] = ctx3.state[0];
7948 plain_alt_ctx[3].buf64[1] = ctx3.state[1];
7949 plain_alt_ctx[3].buf64[2] = ctx3.state[2];
7950 plain_alt_ctx[3].buf64[3] = ctx3.state[3];
7951 plain_alt_ctx[3].buf64[4] = ctx3.state[4];
7952 plain_alt_ctx[3].buf64[5] = ctx3.state[5];
7953 plain_alt_ctx[3].buf64[6] = ctx3.state[6];
7954 plain_alt_ctx[3].buf64[7] = ctx3.state[7];
7955
7956 plain_alt_ctx[0].len = 64;
7957 plain_alt_ctx[1].len = 64;
7958 plain_alt_ctx[2].len = 64;
7959 plain_alt_ctx[3].len = 64;
7960
7961 plain_t plain_p_bytes[4];
7962
7963 plain_p_bytes[0].buf64[0] = p_bytes0.state[0];
7964 plain_p_bytes[0].buf64[1] = p_bytes0.state[1];
7965 plain_p_bytes[0].buf64[2] = p_bytes0.state[2];
7966 plain_p_bytes[0].buf64[3] = p_bytes0.state[3];
7967 plain_p_bytes[0].buf64[4] = p_bytes0.state[4];
7968 plain_p_bytes[0].buf64[5] = p_bytes0.state[5];
7969 plain_p_bytes[0].buf64[6] = p_bytes0.state[6];
7970 plain_p_bytes[0].buf64[7] = p_bytes0.state[7];
7971 plain_p_bytes[1].buf64[0] = p_bytes1.state[0];
7972 plain_p_bytes[1].buf64[1] = p_bytes1.state[1];
7973 plain_p_bytes[1].buf64[2] = p_bytes1.state[2];
7974 plain_p_bytes[1].buf64[3] = p_bytes1.state[3];
7975 plain_p_bytes[1].buf64[4] = p_bytes1.state[4];
7976 plain_p_bytes[1].buf64[5] = p_bytes1.state[5];
7977 plain_p_bytes[1].buf64[6] = p_bytes1.state[6];
7978 plain_p_bytes[1].buf64[7] = p_bytes1.state[7];
7979 plain_p_bytes[2].buf64[0] = p_bytes2.state[0];
7980 plain_p_bytes[2].buf64[1] = p_bytes2.state[1];
7981 plain_p_bytes[2].buf64[2] = p_bytes2.state[2];
7982 plain_p_bytes[2].buf64[3] = p_bytes2.state[3];
7983 plain_p_bytes[2].buf64[4] = p_bytes2.state[4];
7984 plain_p_bytes[2].buf64[5] = p_bytes2.state[5];
7985 plain_p_bytes[2].buf64[6] = p_bytes2.state[6];
7986 plain_p_bytes[2].buf64[7] = p_bytes2.state[7];
7987 plain_p_bytes[3].buf64[0] = p_bytes3.state[0];
7988 plain_p_bytes[3].buf64[1] = p_bytes3.state[1];
7989 plain_p_bytes[3].buf64[2] = p_bytes3.state[2];
7990 plain_p_bytes[3].buf64[3] = p_bytes3.state[3];
7991 plain_p_bytes[3].buf64[4] = p_bytes3.state[4];
7992 plain_p_bytes[3].buf64[5] = p_bytes3.state[5];
7993 plain_p_bytes[3].buf64[6] = p_bytes3.state[6];
7994 plain_p_bytes[3].buf64[7] = p_bytes3.state[7];
7995
7996 plain_p_bytes[0].len = password0_len;
7997 plain_p_bytes[1].len = password1_len;
7998 plain_p_bytes[2].len = password2_len;
7999 plain_p_bytes[3].len = password3_len;
8000
8001 plain_t plain_s_bytes[4];
8002
8003 plain_s_bytes[0].buf64[0] = s_bytes0.state[0];
8004 plain_s_bytes[0].buf64[1] = s_bytes0.state[1];
8005 plain_s_bytes[0].buf64[2] = s_bytes0.state[2];
8006 plain_s_bytes[0].buf64[3] = s_bytes0.state[3];
8007 plain_s_bytes[0].buf64[4] = s_bytes0.state[4];
8008 plain_s_bytes[0].buf64[5] = s_bytes0.state[5];
8009 plain_s_bytes[0].buf64[6] = s_bytes0.state[6];
8010 plain_s_bytes[0].buf64[7] = s_bytes0.state[7];
8011 plain_s_bytes[1].buf64[0] = s_bytes1.state[0];
8012 plain_s_bytes[1].buf64[1] = s_bytes1.state[1];
8013 plain_s_bytes[1].buf64[2] = s_bytes1.state[2];
8014 plain_s_bytes[1].buf64[3] = s_bytes1.state[3];
8015 plain_s_bytes[1].buf64[4] = s_bytes1.state[4];
8016 plain_s_bytes[1].buf64[5] = s_bytes1.state[5];
8017 plain_s_bytes[1].buf64[6] = s_bytes1.state[6];
8018 plain_s_bytes[1].buf64[7] = s_bytes1.state[7];
8019 plain_s_bytes[2].buf64[0] = s_bytes2.state[0];
8020 plain_s_bytes[2].buf64[1] = s_bytes2.state[1];
8021 plain_s_bytes[2].buf64[2] = s_bytes2.state[2];
8022 plain_s_bytes[2].buf64[3] = s_bytes2.state[3];
8023 plain_s_bytes[2].buf64[4] = s_bytes2.state[4];
8024 plain_s_bytes[2].buf64[5] = s_bytes2.state[5];
8025 plain_s_bytes[2].buf64[6] = s_bytes2.state[6];
8026 plain_s_bytes[2].buf64[7] = s_bytes2.state[7];
8027 plain_s_bytes[3].buf64[0] = s_bytes3.state[0];
8028 plain_s_bytes[3].buf64[1] = s_bytes3.state[1];
8029 plain_s_bytes[3].buf64[2] = s_bytes3.state[2];
8030 plain_s_bytes[3].buf64[3] = s_bytes3.state[3];
8031 plain_s_bytes[3].buf64[4] = s_bytes3.state[4];
8032 plain_s_bytes[3].buf64[5] = s_bytes3.state[5];
8033 plain_s_bytes[3].buf64[6] = s_bytes3.state[6];
8034 plain_s_bytes[3].buf64[7] = s_bytes3.state[7];
8035
8036 plain_s_bytes[0].len = salt_len;
8037 plain_s_bytes[1].len = salt_len;
8038 plain_s_bytes[2].len = salt_len;
8039 plain_s_bytes[3].len = salt_len;
8040
8041 /* Repeatedly run the collected hash value through SHA512 to
8042 burn CPU cycles. */
8043
8044 for (cnt = 0; cnt < (int) salt->iterations; cnt++)
8045 {
8046 /* New context. */
8047
8048 digest_sha512_sse2_t sse2_ctx;
8049
8050 sha512_init_sse2 (&sse2_ctx);
8051
8052 plain_t sse2_plain[4];
8053
8054 plain_init (sse2_plain);
8055
8056 /* Add key or last result. */
8057 if ((cnt & 1) != 0)
8058 sha512_update_sse2 (sse2_plain, &sse2_ctx, plain_p_bytes);
8059 else
8060 sha512_update_sse2 (sse2_plain, &sse2_ctx, plain_alt_ctx);
8061
8062 /* Add salt for numbers not divisible by 3. */
8063 if (cnt % 3 != 0)
8064 sha512_update_sse2 (sse2_plain, &sse2_ctx, plain_s_bytes);
8065
8066 /* Add key for numbers not divisible by 7. */
8067 if (cnt % 7 != 0)
8068 sha512_update_sse2 (sse2_plain, &sse2_ctx, plain_p_bytes);
8069
8070 /* Add key or last result. */
8071 if ((cnt & 1) != 0)
8072 sha512_update_sse2 (sse2_plain, &sse2_ctx, plain_alt_ctx);
8073 else
8074 sha512_update_sse2 (sse2_plain, &sse2_ctx, plain_p_bytes);
8075
8076 /* Create intermediate [SIC] result. */
8077 sha512_final_sse2 (sse2_plain, &sse2_ctx);
8078
8079 plain_alt_ctx[0].buf64[0] = sse2_ctx.buf64[ 0];
8080 plain_alt_ctx[1].buf64[0] = sse2_ctx.buf64[ 1];
8081 plain_alt_ctx[2].buf64[0] = sse2_ctx.buf64[ 2];
8082 plain_alt_ctx[3].buf64[0] = sse2_ctx.buf64[ 3];
8083 plain_alt_ctx[0].buf64[1] = sse2_ctx.buf64[ 4];
8084 plain_alt_ctx[1].buf64[1] = sse2_ctx.buf64[ 5];
8085 plain_alt_ctx[2].buf64[1] = sse2_ctx.buf64[ 6];
8086 plain_alt_ctx[3].buf64[1] = sse2_ctx.buf64[ 7];
8087 plain_alt_ctx[0].buf64[2] = sse2_ctx.buf64[ 8];
8088 plain_alt_ctx[1].buf64[2] = sse2_ctx.buf64[ 9];
8089 plain_alt_ctx[2].buf64[2] = sse2_ctx.buf64[10];
8090 plain_alt_ctx[3].buf64[2] = sse2_ctx.buf64[11];
8091 plain_alt_ctx[0].buf64[3] = sse2_ctx.buf64[12];
8092 plain_alt_ctx[1].buf64[3] = sse2_ctx.buf64[13];
8093 plain_alt_ctx[2].buf64[3] = sse2_ctx.buf64[14];
8094 plain_alt_ctx[3].buf64[3] = sse2_ctx.buf64[15];
8095 plain_alt_ctx[0].buf64[4] = sse2_ctx.buf64[16];
8096 plain_alt_ctx[1].buf64[4] = sse2_ctx.buf64[17];
8097 plain_alt_ctx[2].buf64[4] = sse2_ctx.buf64[18];
8098 plain_alt_ctx[3].buf64[4] = sse2_ctx.buf64[19];
8099 plain_alt_ctx[0].buf64[5] = sse2_ctx.buf64[20];
8100 plain_alt_ctx[1].buf64[5] = sse2_ctx.buf64[21];
8101 plain_alt_ctx[2].buf64[5] = sse2_ctx.buf64[22];
8102 plain_alt_ctx[3].buf64[5] = sse2_ctx.buf64[23];
8103 plain_alt_ctx[0].buf64[6] = sse2_ctx.buf64[24];
8104 plain_alt_ctx[1].buf64[6] = sse2_ctx.buf64[25];
8105 plain_alt_ctx[2].buf64[6] = sse2_ctx.buf64[26];
8106 plain_alt_ctx[3].buf64[6] = sse2_ctx.buf64[27];
8107 plain_alt_ctx[0].buf64[7] = sse2_ctx.buf64[28];
8108 plain_alt_ctx[1].buf64[7] = sse2_ctx.buf64[29];
8109 plain_alt_ctx[2].buf64[7] = sse2_ctx.buf64[30];
8110 plain_alt_ctx[3].buf64[7] = sse2_ctx.buf64[31];
8111
8112 BYTESWAP64 (plain_alt_ctx[0].buf64[0]);
8113 BYTESWAP64 (plain_alt_ctx[0].buf64[1]);
8114 BYTESWAP64 (plain_alt_ctx[0].buf64[2]);
8115 BYTESWAP64 (plain_alt_ctx[0].buf64[3]);
8116 BYTESWAP64 (plain_alt_ctx[0].buf64[4]);
8117 BYTESWAP64 (plain_alt_ctx[0].buf64[5]);
8118 BYTESWAP64 (plain_alt_ctx[0].buf64[6]);
8119 BYTESWAP64 (plain_alt_ctx[0].buf64[7]);
8120 BYTESWAP64 (plain_alt_ctx[1].buf64[0]);
8121 BYTESWAP64 (plain_alt_ctx[1].buf64[1]);
8122 BYTESWAP64 (plain_alt_ctx[1].buf64[2]);
8123 BYTESWAP64 (plain_alt_ctx[1].buf64[3]);
8124 BYTESWAP64 (plain_alt_ctx[1].buf64[4]);
8125 BYTESWAP64 (plain_alt_ctx[1].buf64[5]);
8126 BYTESWAP64 (plain_alt_ctx[1].buf64[6]);
8127 BYTESWAP64 (plain_alt_ctx[1].buf64[7]);
8128 BYTESWAP64 (plain_alt_ctx[2].buf64[0]);
8129 BYTESWAP64 (plain_alt_ctx[2].buf64[1]);
8130 BYTESWAP64 (plain_alt_ctx[2].buf64[2]);
8131 BYTESWAP64 (plain_alt_ctx[2].buf64[3]);
8132 BYTESWAP64 (plain_alt_ctx[2].buf64[4]);
8133 BYTESWAP64 (plain_alt_ctx[2].buf64[5]);
8134 BYTESWAP64 (plain_alt_ctx[2].buf64[6]);
8135 BYTESWAP64 (plain_alt_ctx[2].buf64[7]);
8136 BYTESWAP64 (plain_alt_ctx[3].buf64[0]);
8137 BYTESWAP64 (plain_alt_ctx[3].buf64[1]);
8138 BYTESWAP64 (plain_alt_ctx[3].buf64[2]);
8139 BYTESWAP64 (plain_alt_ctx[3].buf64[3]);
8140 BYTESWAP64 (plain_alt_ctx[3].buf64[4]);
8141 BYTESWAP64 (plain_alt_ctx[3].buf64[5]);
8142 BYTESWAP64 (plain_alt_ctx[3].buf64[6]);
8143 BYTESWAP64 (plain_alt_ctx[3].buf64[7]);
8144 }
8145
8146 digest_t digest[4];
8147
8148 digest[0].buf.sha512[0] = plain_alt_ctx[0].buf64[0];
8149 digest[0].buf.sha512[1] = plain_alt_ctx[0].buf64[1];
8150 digest[0].buf.sha512[2] = plain_alt_ctx[0].buf64[2];
8151 digest[0].buf.sha512[3] = plain_alt_ctx[0].buf64[3];
8152 digest[0].buf.sha512[4] = plain_alt_ctx[0].buf64[4];
8153 digest[0].buf.sha512[5] = plain_alt_ctx[0].buf64[5];
8154 digest[0].buf.sha512[6] = plain_alt_ctx[0].buf64[6];
8155 digest[0].buf.sha512[7] = plain_alt_ctx[0].buf64[7];
8156 digest[1].buf.sha512[0] = plain_alt_ctx[1].buf64[0];
8157 digest[1].buf.sha512[1] = plain_alt_ctx[1].buf64[1];
8158 digest[1].buf.sha512[2] = plain_alt_ctx[1].buf64[2];
8159 digest[1].buf.sha512[3] = plain_alt_ctx[1].buf64[3];
8160 digest[1].buf.sha512[4] = plain_alt_ctx[1].buf64[4];
8161 digest[1].buf.sha512[5] = plain_alt_ctx[1].buf64[5];
8162 digest[1].buf.sha512[6] = plain_alt_ctx[1].buf64[6];
8163 digest[1].buf.sha512[7] = plain_alt_ctx[1].buf64[7];
8164 digest[2].buf.sha512[0] = plain_alt_ctx[2].buf64[0];
8165 digest[2].buf.sha512[1] = plain_alt_ctx[2].buf64[1];
8166 digest[2].buf.sha512[2] = plain_alt_ctx[2].buf64[2];
8167 digest[2].buf.sha512[3] = plain_alt_ctx[2].buf64[3];
8168 digest[2].buf.sha512[4] = plain_alt_ctx[2].buf64[4];
8169 digest[2].buf.sha512[5] = plain_alt_ctx[2].buf64[5];
8170 digest[2].buf.sha512[6] = plain_alt_ctx[2].buf64[6];
8171 digest[2].buf.sha512[7] = plain_alt_ctx[2].buf64[7];
8172 digest[3].buf.sha512[0] = plain_alt_ctx[3].buf64[0];
8173 digest[3].buf.sha512[1] = plain_alt_ctx[3].buf64[1];
8174 digest[3].buf.sha512[2] = plain_alt_ctx[3].buf64[2];
8175 digest[3].buf.sha512[3] = plain_alt_ctx[3].buf64[3];
8176 digest[3].buf.sha512[4] = plain_alt_ctx[3].buf64[4];
8177 digest[3].buf.sha512[5] = plain_alt_ctx[3].buf64[5];
8178 digest[3].buf.sha512[6] = plain_alt_ctx[3].buf64[6];
8179 digest[3].buf.sha512[7] = plain_alt_ctx[3].buf64[7];
8180
8181 thread_parameter->indb (thread_parameter, in, digest, salt);
8182 }
8183 }
8184
hashing_02400(thread_parameter_t * thread_parameter,plain_t * in)8185 void hashing_02400 (thread_parameter_t *thread_parameter, plain_t *in)
8186 {
8187 db_t *db = thread_parameter->db;
8188
8189 plain_t plains_tmp[4];
8190
8191 memcpy (plains_tmp, in, 4 * sizeof (plain_t));
8192
8193 plains_tmp[0].len = 16;
8194 plains_tmp[1].len = 16;
8195 plains_tmp[2].len = 16;
8196 plains_tmp[3].len = 16;
8197
8198 digest_md5_sse2_t digests;
8199
8200 md5_init_sse2 (&digests);
8201
8202 md5_final_sse2_max55 (plains_tmp, &digests);
8203
8204 digest_t dgst[4];
8205
8206 transpose_md5_digest (&digests, dgst);
8207
8208 dgst[0].buf.md5[0] &= 0xffffff;
8209 dgst[0].buf.md5[1] &= 0xffffff;
8210 dgst[0].buf.md5[2] &= 0xffffff;
8211 dgst[0].buf.md5[3] &= 0xffffff;
8212 dgst[1].buf.md5[0] &= 0xffffff;
8213 dgst[1].buf.md5[1] &= 0xffffff;
8214 dgst[1].buf.md5[2] &= 0xffffff;
8215 dgst[1].buf.md5[3] &= 0xffffff;
8216 dgst[2].buf.md5[0] &= 0xffffff;
8217 dgst[2].buf.md5[1] &= 0xffffff;
8218 dgst[2].buf.md5[2] &= 0xffffff;
8219 dgst[2].buf.md5[3] &= 0xffffff;
8220 dgst[3].buf.md5[0] &= 0xffffff;
8221 dgst[3].buf.md5[1] &= 0xffffff;
8222 dgst[3].buf.md5[2] &= 0xffffff;
8223 dgst[3].buf.md5[3] &= 0xffffff;
8224
8225 thread_parameter->indb (thread_parameter, in, dgst, db->salts_buf[0]);
8226 }
8227
hashing_02410(thread_parameter_t * thread_parameter,plain_t * in)8228 void hashing_02410 (thread_parameter_t *thread_parameter, plain_t *in)
8229 {
8230 db_t *db = thread_parameter->db;
8231
8232 plain_t plains[4];
8233
8234 char *ptrs_tmp[4];
8235
8236 ptrs_tmp[0] = (char *) &plains[0].buf;
8237 ptrs_tmp[1] = (char *) &plains[1].buf;
8238 ptrs_tmp[2] = (char *) &plains[2].buf;
8239 ptrs_tmp[3] = (char *) &plains[3].buf;
8240
8241 uint32_t salts_idx;
8242
8243 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
8244 {
8245 salt_t *salt = db->salts_buf[salts_idx];
8246
8247 if (salt->indexes_found == salt->indexes_cnt) continue;
8248
8249 uint32_t i;
8250
8251 for (i = 0; i < 4; i++)
8252 {
8253 memset (ptrs_tmp[i], 0, 16);
8254
8255 memcpy (ptrs_tmp[i], in[i].buf, in[i].len);
8256
8257 // not a bug, salt_prehashed_len is the one we need to use here, truncated/max length is 4:
8258 memcpy (ptrs_tmp[i] + in[i].len, salt->salt_plain_buf, salt->salt_prehashed_len);
8259
8260 plains[i].len = 16;
8261 }
8262
8263 digest_md5_sse2_t digests;
8264
8265 md5_init_sse2 (&digests);
8266
8267 md5_final_sse2_max55 (plains, &digests);
8268
8269 digest_t dgst[4];
8270
8271 transpose_md5_digest (&digests, dgst);
8272
8273 dgst[0].buf.md5[0] &= 0xffffff;
8274 dgst[0].buf.md5[1] &= 0xffffff;
8275 dgst[0].buf.md5[2] &= 0xffffff;
8276 dgst[0].buf.md5[3] &= 0xffffff;
8277 dgst[1].buf.md5[0] &= 0xffffff;
8278 dgst[1].buf.md5[1] &= 0xffffff;
8279 dgst[1].buf.md5[2] &= 0xffffff;
8280 dgst[1].buf.md5[3] &= 0xffffff;
8281 dgst[2].buf.md5[0] &= 0xffffff;
8282 dgst[2].buf.md5[1] &= 0xffffff;
8283 dgst[2].buf.md5[2] &= 0xffffff;
8284 dgst[2].buf.md5[3] &= 0xffffff;
8285 dgst[3].buf.md5[0] &= 0xffffff;
8286 dgst[3].buf.md5[1] &= 0xffffff;
8287 dgst[3].buf.md5[2] &= 0xffffff;
8288 dgst[3].buf.md5[3] &= 0xffffff;
8289
8290 thread_parameter->indb (thread_parameter, in, dgst, salt);
8291 }
8292 }
8293
hashing_02500(thread_parameter_t * thread_parameter,plain_t * plains)8294 void hashing_02500 (thread_parameter_t *thread_parameter, plain_t *plains)
8295 {
8296 digest_t digests[4];
8297
8298 plain_t plains_tmp[4];
8299
8300 char *ptrs_tmp[4];
8301
8302 ptrs_tmp[0] = (char *) &plains_tmp[0].buf;
8303 ptrs_tmp[1] = (char *) &plains_tmp[1].buf;
8304 ptrs_tmp[2] = (char *) &plains_tmp[2].buf;
8305 ptrs_tmp[3] = (char *) &plains_tmp[3].buf;
8306
8307 uint32_t ipad[5][4] __attribute__ ((aligned (16)));
8308 uint32_t opad[5][4] __attribute__ ((aligned (16)));
8309
8310 uint32_t ipad_buf[16][4] __attribute__ ((aligned (16)));
8311 uint32_t opad_buf[16][4] __attribute__ ((aligned (16)));
8312
8313 db_t *db = thread_parameter->db;
8314
8315 uint32_t i;
8316 uint32_t j;
8317 uint32_t l;
8318
8319 for (i = 0; i < 4; i++)
8320 {
8321 for (j = 0; j < 16; j++)
8322 {
8323 ipad_buf[j][i] = 0x36363636 ^ plains[i].buf[j];
8324 opad_buf[j][i] = 0x5c5c5c5c ^ plains[i].buf[j];
8325 }
8326
8327 ipad[0][i] = SHA1M_A;
8328 ipad[1][i] = SHA1M_B;
8329 ipad[2][i] = SHA1M_C;
8330 ipad[3][i] = SHA1M_D;
8331 ipad[4][i] = SHA1M_E;
8332
8333 opad[0][i] = SHA1M_A;
8334 opad[1][i] = SHA1M_B;
8335 opad[2][i] = SHA1M_C;
8336 opad[3][i] = SHA1M_D;
8337 opad[4][i] = SHA1M_E;
8338 }
8339
8340 hashcat_sha1_64 ((__m128i *) ipad, (__m128i *) ipad_buf);
8341 hashcat_sha1_64 ((__m128i *) opad, (__m128i *) opad_buf);
8342
8343 uint32_t salts_idx;
8344
8345 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
8346 {
8347 salt_t *salt = db->salts_buf[salts_idx];
8348
8349 if (salt->indexes_found == salt->indexes_cnt) continue;
8350
8351 /**
8352 * init hmac0
8353 */
8354
8355 uint32_t tmp0[5][4] __attribute__ ((aligned (16)));
8356 uint32_t out0[5][4] __attribute__ ((aligned (16)));
8357
8358 for (i = 0; i < 4; i++)
8359 {
8360 tmp0[0][i] = ipad[0][i];
8361 tmp0[1][i] = ipad[1][i];
8362 tmp0[2][i] = ipad[2][i];
8363 tmp0[3][i] = ipad[3][i];
8364 tmp0[4][i] = ipad[4][i];
8365 }
8366
8367 for (i = 0; i < 4; i++)
8368 {
8369 memcpy (ptrs_tmp[i], salt->salt_plain_buf, salt->salt_plain_len);
8370
8371 memset (ptrs_tmp[i] + salt->salt_plain_len, 0, BLOCK_SIZE - salt->salt_plain_len);
8372
8373 ptrs_tmp[i][salt->salt_plain_len + 3] = 0x01;
8374 ptrs_tmp[i][salt->salt_plain_len + 4] = 0x80;
8375
8376 for (j = 0; j < 14; j++) ipad_buf[j][i] = plains_tmp[i].buf[j];
8377
8378 ipad_buf[14][i] = 0;
8379 ipad_buf[15][i] = (64 + salt->salt_plain_len + 4) * 8;
8380
8381 BYTESWAP (ipad_buf[15][i]);
8382 }
8383
8384 hashcat_sha1_64 ((__m128i *) tmp0, (__m128i *) ipad_buf);
8385
8386 for (i = 0; i < 4; i++)
8387 {
8388 opad_buf[ 0][i] = tmp0[0][i];
8389 opad_buf[ 1][i] = tmp0[1][i];
8390 opad_buf[ 2][i] = tmp0[2][i];
8391 opad_buf[ 3][i] = tmp0[3][i];
8392 opad_buf[ 4][i] = tmp0[4][i];
8393 opad_buf[ 5][i] = 0x80000000;
8394 opad_buf[ 6][i] = 0;
8395 opad_buf[ 7][i] = 0;
8396 opad_buf[ 8][i] = 0;
8397 opad_buf[ 9][i] = 0;
8398 opad_buf[10][i] = 0;
8399 opad_buf[11][i] = 0;
8400 opad_buf[12][i] = 0;
8401 opad_buf[13][i] = 0;
8402 opad_buf[14][i] = 0;
8403 opad_buf[15][i] = (64 + 20) * 8;
8404 }
8405
8406 for (i = 0; i < 4; i++)
8407 {
8408 tmp0[0][i] = opad[0][i];
8409 tmp0[1][i] = opad[1][i];
8410 tmp0[2][i] = opad[2][i];
8411 tmp0[3][i] = opad[3][i];
8412 tmp0[4][i] = opad[4][i];
8413 }
8414
8415 for (i = 0; i < 4; i++) for (j = 0; j < 16; j++) BYTESWAP (opad_buf[j][i]);
8416
8417 hashcat_sha1_64 ((__m128i *) tmp0, (__m128i *) opad_buf);
8418
8419 for (i = 0; i < 4; i++)
8420 {
8421 out0[0][i] = tmp0[0][i];
8422 out0[1][i] = tmp0[1][i];
8423 out0[2][i] = tmp0[2][i];
8424 out0[3][i] = tmp0[3][i];
8425 out0[4][i] = tmp0[4][i];
8426 }
8427
8428 /**
8429 * init hmac1
8430 */
8431
8432 uint32_t tmp1[5][4] __attribute__ ((aligned (16)));
8433 uint32_t out1[5][4] __attribute__ ((aligned (16)));
8434
8435 for (i = 0; i < 4; i++)
8436 {
8437 tmp1[0][i] = ipad[0][i];
8438 tmp1[1][i] = ipad[1][i];
8439 tmp1[2][i] = ipad[2][i];
8440 tmp1[3][i] = ipad[3][i];
8441 tmp1[4][i] = ipad[4][i];
8442 }
8443
8444 for (i = 0; i < 4; i++)
8445 {
8446 memcpy (ptrs_tmp[i], salt->salt_plain_buf, salt->salt_plain_len);
8447
8448 memset (ptrs_tmp[i] + salt->salt_plain_len, 0, BLOCK_SIZE - salt->salt_plain_len);
8449
8450 ptrs_tmp[i][salt->salt_plain_len + 3] = 0x02;
8451 ptrs_tmp[i][salt->salt_plain_len + 4] = 0x80;
8452
8453 for (j = 0; j < 14; j++) ipad_buf[j][i] = plains_tmp[i].buf[j];
8454
8455 ipad_buf[14][i] = 0;
8456 ipad_buf[15][i] = (64 + salt->salt_plain_len + 4) * 8;
8457
8458 BYTESWAP (ipad_buf[15][i]);
8459 }
8460
8461 hashcat_sha1_64 ((__m128i *) tmp1, (__m128i *) ipad_buf);
8462
8463 for (i = 0; i < 4; i++)
8464 {
8465 opad_buf[ 0][i] = tmp1[0][i];
8466 opad_buf[ 1][i] = tmp1[1][i];
8467 opad_buf[ 2][i] = tmp1[2][i];
8468 opad_buf[ 3][i] = tmp1[3][i];
8469 opad_buf[ 4][i] = tmp1[4][i];
8470 opad_buf[ 5][i] = 0x80000000;
8471 opad_buf[ 6][i] = 0;
8472 opad_buf[ 7][i] = 0;
8473 opad_buf[ 8][i] = 0;
8474 opad_buf[ 9][i] = 0;
8475 opad_buf[10][i] = 0;
8476 opad_buf[11][i] = 0;
8477 opad_buf[12][i] = 0;
8478 opad_buf[13][i] = 0;
8479 opad_buf[14][i] = 0;
8480 opad_buf[15][i] = (64 + 20) * 8;
8481 }
8482
8483 for (i = 0; i < 4; i++)
8484 {
8485 tmp1[0][i] = opad[0][i];
8486 tmp1[1][i] = opad[1][i];
8487 tmp1[2][i] = opad[2][i];
8488 tmp1[3][i] = opad[3][i];
8489 tmp1[4][i] = opad[4][i];
8490 }
8491
8492 for (i = 0; i < 4; i++) for (j = 0; j < 16; j++) BYTESWAP (opad_buf[j][i]);
8493
8494 hashcat_sha1_64 ((__m128i *) tmp1, (__m128i *) opad_buf);
8495
8496 for (i = 0; i < 4; i++)
8497 {
8498 out1[0][i] = tmp1[0][i];
8499 out1[1][i] = tmp1[1][i];
8500 out1[2][i] = tmp1[2][i];
8501 out1[3][i] = tmp1[3][i];
8502 out1[4][i] = tmp1[4][i];
8503 }
8504
8505 /**
8506 * loop hmac0
8507 */
8508
8509 for (j = 0; j < 4096 - 1; j++)
8510 {
8511 for (i = 0; i < 4; i++)
8512 {
8513 ipad_buf[ 0][i] = tmp0[0][i];
8514 ipad_buf[ 1][i] = tmp0[1][i];
8515 ipad_buf[ 2][i] = tmp0[2][i];
8516 ipad_buf[ 3][i] = tmp0[3][i];
8517 ipad_buf[ 4][i] = tmp0[4][i];
8518 ipad_buf[ 5][i] = 0x80000000;
8519 ipad_buf[ 6][i] = 0;
8520 ipad_buf[ 7][i] = 0;
8521 ipad_buf[ 8][i] = 0;
8522 ipad_buf[ 9][i] = 0;
8523 ipad_buf[10][i] = 0;
8524 ipad_buf[11][i] = 0;
8525 ipad_buf[12][i] = 0;
8526 ipad_buf[13][i] = 0;
8527 ipad_buf[14][i] = 0;
8528 ipad_buf[15][i] = (64 + 20) * 8;
8529 }
8530
8531 for (i = 0; i < 4; i++)
8532 {
8533 tmp0[0][i] = ipad[0][i];
8534 tmp0[1][i] = ipad[1][i];
8535 tmp0[2][i] = ipad[2][i];
8536 tmp0[3][i] = ipad[3][i];
8537 tmp0[4][i] = ipad[4][i];
8538 }
8539
8540 for (i = 0; i < 4; i++) for (l = 0; l < 16; l++) BYTESWAP (ipad_buf[l][i]);
8541
8542 hashcat_sha1_64 ((__m128i *) tmp0, (__m128i *) ipad_buf);
8543
8544 for (i = 0; i < 4; i++)
8545 {
8546 opad_buf[ 0][i] = tmp0[0][i];
8547 opad_buf[ 1][i] = tmp0[1][i];
8548 opad_buf[ 2][i] = tmp0[2][i];
8549 opad_buf[ 3][i] = tmp0[3][i];
8550 opad_buf[ 4][i] = tmp0[4][i];
8551 opad_buf[ 5][i] = 0x80000000;
8552 opad_buf[ 6][i] = 0;
8553 opad_buf[ 7][i] = 0;
8554 opad_buf[ 8][i] = 0;
8555 opad_buf[ 9][i] = 0;
8556 opad_buf[10][i] = 0;
8557 opad_buf[11][i] = 0;
8558 opad_buf[12][i] = 0;
8559 opad_buf[13][i] = 0;
8560 opad_buf[14][i] = 0;
8561 opad_buf[15][i] = (64 + 20) * 8;
8562 }
8563
8564 for (i = 0; i < 4; i++)
8565 {
8566 tmp0[0][i] = opad[0][i];
8567 tmp0[1][i] = opad[1][i];
8568 tmp0[2][i] = opad[2][i];
8569 tmp0[3][i] = opad[3][i];
8570 tmp0[4][i] = opad[4][i];
8571 }
8572
8573 for (i = 0; i < 4; i++) for (l = 0; l < 16; l++) BYTESWAP (opad_buf[l][i]);
8574
8575 hashcat_sha1_64 ((__m128i *) tmp0, (__m128i *) opad_buf);
8576
8577 for (i = 0; i < 4; i++)
8578 {
8579 out0[0][i] ^= tmp0[0][i];
8580 out0[1][i] ^= tmp0[1][i];
8581 out0[2][i] ^= tmp0[2][i];
8582 out0[3][i] ^= tmp0[3][i];
8583 out0[4][i] ^= tmp0[4][i];
8584 }
8585 }
8586
8587 /**
8588 * loop hmac1
8589 */
8590
8591 for (j = 0; j < 4096 - 1; j++)
8592 {
8593 for (i = 0; i < 4; i++)
8594 {
8595 ipad_buf[ 0][i] = tmp1[0][i];
8596 ipad_buf[ 1][i] = tmp1[1][i];
8597 ipad_buf[ 2][i] = tmp1[2][i];
8598 ipad_buf[ 3][i] = tmp1[3][i];
8599 ipad_buf[ 4][i] = tmp1[4][i];
8600 ipad_buf[ 5][i] = 0x80000000;
8601 ipad_buf[ 6][i] = 0;
8602 ipad_buf[ 7][i] = 0;
8603 ipad_buf[ 8][i] = 0;
8604 ipad_buf[ 9][i] = 0;
8605 ipad_buf[10][i] = 0;
8606 ipad_buf[11][i] = 0;
8607 ipad_buf[12][i] = 0;
8608 ipad_buf[13][i] = 0;
8609 ipad_buf[14][i] = 0;
8610 ipad_buf[15][i] = (64 + 20) * 8;
8611 }
8612
8613 for (i = 0; i < 4; i++)
8614 {
8615 tmp1[0][i] = ipad[0][i];
8616 tmp1[1][i] = ipad[1][i];
8617 tmp1[2][i] = ipad[2][i];
8618 tmp1[3][i] = ipad[3][i];
8619 tmp1[4][i] = ipad[4][i];
8620 }
8621
8622 for (i = 0; i < 4; i++) for (l = 0; l < 16; l++) BYTESWAP (ipad_buf[l][i]);
8623
8624 hashcat_sha1_64 ((__m128i *) tmp1, (__m128i *) ipad_buf);
8625
8626 for (i = 0; i < 4; i++)
8627 {
8628 opad_buf[ 0][i] = tmp1[0][i];
8629 opad_buf[ 1][i] = tmp1[1][i];
8630 opad_buf[ 2][i] = tmp1[2][i];
8631 opad_buf[ 3][i] = tmp1[3][i];
8632 opad_buf[ 4][i] = tmp1[4][i];
8633 opad_buf[ 5][i] = 0x80000000;
8634 opad_buf[ 6][i] = 0;
8635 opad_buf[ 7][i] = 0;
8636 opad_buf[ 8][i] = 0;
8637 opad_buf[ 9][i] = 0;
8638 opad_buf[10][i] = 0;
8639 opad_buf[11][i] = 0;
8640 opad_buf[12][i] = 0;
8641 opad_buf[13][i] = 0;
8642 opad_buf[14][i] = 0;
8643 opad_buf[15][i] = (64 + 20) * 8;
8644 }
8645
8646 for (i = 0; i < 4; i++)
8647 {
8648 tmp1[0][i] = opad[0][i];
8649 tmp1[1][i] = opad[1][i];
8650 tmp1[2][i] = opad[2][i];
8651 tmp1[3][i] = opad[3][i];
8652 tmp1[4][i] = opad[4][i];
8653 }
8654
8655 for (i = 0; i < 4; i++) for (l = 0; l < 16; l++) BYTESWAP (opad_buf[l][i]);
8656
8657 hashcat_sha1_64 ((__m128i *) tmp1, (__m128i *) opad_buf);
8658
8659 for (i = 0; i < 4; i++)
8660 {
8661 out1[0][i] ^= tmp1[0][i];
8662 out1[1][i] ^= tmp1[1][i];
8663 out1[2][i] ^= tmp1[2][i];
8664 out1[3][i] ^= tmp1[3][i];
8665 out1[4][i] ^= tmp1[4][i];
8666 }
8667 }
8668
8669 /**
8670 * finalize
8671 */
8672
8673 for (i = 0; i < 4; i++)
8674 {
8675 for (j = 0; j < 16; j++)
8676 {
8677 ipad_buf[j][i] = 0x36363636;
8678 opad_buf[j][i] = 0x5c5c5c5c;
8679 }
8680
8681 ipad_buf[0][i] ^= out0[0][i];
8682 ipad_buf[1][i] ^= out0[1][i];
8683 ipad_buf[2][i] ^= out0[2][i];
8684 ipad_buf[3][i] ^= out0[3][i];
8685 ipad_buf[4][i] ^= out0[4][i];
8686 ipad_buf[5][i] ^= out1[0][i];
8687 ipad_buf[6][i] ^= out1[1][i];
8688 ipad_buf[7][i] ^= out1[2][i];
8689
8690 opad_buf[0][i] ^= out0[0][i];
8691 opad_buf[1][i] ^= out0[1][i];
8692 opad_buf[2][i] ^= out0[2][i];
8693 opad_buf[3][i] ^= out0[3][i];
8694 opad_buf[4][i] ^= out0[4][i];
8695 opad_buf[5][i] ^= out1[0][i];
8696 opad_buf[6][i] ^= out1[1][i];
8697 opad_buf[7][i] ^= out1[2][i];
8698
8699 ipad[0][i] = SHA1M_A;
8700 ipad[1][i] = SHA1M_B;
8701 ipad[2][i] = SHA1M_C;
8702 ipad[3][i] = SHA1M_D;
8703 ipad[4][i] = SHA1M_E;
8704
8705 opad[0][i] = SHA1M_A;
8706 opad[1][i] = SHA1M_B;
8707 opad[2][i] = SHA1M_C;
8708 opad[3][i] = SHA1M_D;
8709 opad[4][i] = SHA1M_E;
8710 }
8711
8712 for (i = 0; i < 4; i++) for (j = 0; j < 16; j++) BYTESWAP (ipad_buf[j][i]);
8713 for (i = 0; i < 4; i++) for (j = 0; j < 16; j++) BYTESWAP (opad_buf[j][i]);
8714
8715 hashcat_sha1_64 ((__m128i *) ipad, (__m128i *) ipad_buf);
8716 hashcat_sha1_64 ((__m128i *) opad, (__m128i *) opad_buf);
8717
8718 for (i = 0; i < 4; i++)
8719 {
8720 tmp0[0][i] = ipad[0][i];
8721 tmp0[1][i] = ipad[1][i];
8722 tmp0[2][i] = ipad[2][i];
8723 tmp0[3][i] = ipad[3][i];
8724 tmp0[4][i] = ipad[4][i];
8725 }
8726
8727 for (i = 0; i < 4; i++)
8728 {
8729 ipad_buf[ 0][i] = salt->wpa->pke[ 0];
8730 ipad_buf[ 1][i] = salt->wpa->pke[ 1];
8731 ipad_buf[ 2][i] = salt->wpa->pke[ 2];
8732 ipad_buf[ 3][i] = salt->wpa->pke[ 3];
8733 ipad_buf[ 4][i] = salt->wpa->pke[ 4];
8734 ipad_buf[ 5][i] = salt->wpa->pke[ 5];
8735 ipad_buf[ 6][i] = salt->wpa->pke[ 6];
8736 ipad_buf[ 7][i] = salt->wpa->pke[ 7];
8737 ipad_buf[ 8][i] = salt->wpa->pke[ 8];
8738 ipad_buf[ 9][i] = salt->wpa->pke[ 9];
8739 ipad_buf[10][i] = salt->wpa->pke[10];
8740 ipad_buf[11][i] = salt->wpa->pke[11];
8741 ipad_buf[12][i] = salt->wpa->pke[12];
8742 ipad_buf[13][i] = salt->wpa->pke[13];
8743 ipad_buf[14][i] = salt->wpa->pke[14];
8744 ipad_buf[15][i] = salt->wpa->pke[15];
8745 }
8746
8747 for (i = 0; i < 4; i++) for (j = 0; j < 16; j++) BYTESWAP (ipad_buf[j][i]);
8748
8749 hashcat_sha1_64 ((__m128i *) tmp0, (__m128i *) ipad_buf);
8750
8751 for (i = 0; i < 4; i++)
8752 {
8753 ipad_buf[ 0][i] = salt->wpa->pke[16];
8754 ipad_buf[ 1][i] = salt->wpa->pke[17];
8755 ipad_buf[ 2][i] = salt->wpa->pke[18];
8756 ipad_buf[ 3][i] = salt->wpa->pke[19];
8757 ipad_buf[ 4][i] = salt->wpa->pke[20];
8758 ipad_buf[ 5][i] = salt->wpa->pke[21];
8759 ipad_buf[ 6][i] = salt->wpa->pke[22];
8760 ipad_buf[ 7][i] = salt->wpa->pke[23];
8761 ipad_buf[ 8][i] = salt->wpa->pke[24];
8762 ipad_buf[ 9][i] = 0x80000000;
8763 ipad_buf[10][i] = 0;
8764 ipad_buf[11][i] = 0;
8765 ipad_buf[12][i] = 0;
8766 ipad_buf[13][i] = 0;
8767 ipad_buf[14][i] = 0;
8768 ipad_buf[15][i] = (64 + 100) * 8;
8769 }
8770
8771 for (i = 0; i < 4; i++) for (j = 0; j < 16; j++) BYTESWAP (ipad_buf[j][i]);
8772
8773 hashcat_sha1_64 ((__m128i *) tmp0, (__m128i *) ipad_buf);
8774
8775 for (i = 0; i < 4; i++)
8776 {
8777 opad_buf[ 0][i] = tmp0[0][i];
8778 opad_buf[ 1][i] = tmp0[1][i];
8779 opad_buf[ 2][i] = tmp0[2][i];
8780 opad_buf[ 3][i] = tmp0[3][i];
8781 opad_buf[ 4][i] = tmp0[4][i];
8782 opad_buf[ 5][i] = 0x80000000;
8783 opad_buf[ 6][i] = 0;
8784 opad_buf[ 7][i] = 0;
8785 opad_buf[ 8][i] = 0;
8786 opad_buf[ 9][i] = 0;
8787 opad_buf[10][i] = 0;
8788 opad_buf[11][i] = 0;
8789 opad_buf[12][i] = 0;
8790 opad_buf[13][i] = 0;
8791 opad_buf[14][i] = 0;
8792 opad_buf[15][i] = (64 + 20) * 8;
8793 }
8794
8795 for (i = 0; i < 4; i++)
8796 {
8797 tmp0[0][i] = opad[0][i];
8798 tmp0[1][i] = opad[1][i];
8799 tmp0[2][i] = opad[2][i];
8800 tmp0[3][i] = opad[3][i];
8801 tmp0[4][i] = opad[4][i];
8802 }
8803
8804 for (i = 0; i < 4; i++) for (j = 0; j < 16; j++) BYTESWAP (opad_buf[j][i]);
8805
8806 hashcat_sha1_64 ((__m128i *) tmp0, (__m128i *) opad_buf);
8807
8808 if (salt->wpa->keyver == 1)
8809 {
8810 /**
8811 * md5
8812 */
8813
8814 for (i = 0; i < 4; i++)
8815 {
8816 BYTESWAP (tmp0[0][i]);
8817 BYTESWAP (tmp0[1][i]);
8818 BYTESWAP (tmp0[2][i]);
8819 BYTESWAP (tmp0[3][i]);
8820 }
8821
8822 for (i = 0; i < 4; i++)
8823 {
8824 for (j = 0; j < 16; j++)
8825 {
8826 ipad_buf[j][i] = 0x36363636;
8827 opad_buf[j][i] = 0x5c5c5c5c;
8828 }
8829
8830 ipad_buf[0][i] ^= tmp0[0][i];
8831 ipad_buf[1][i] ^= tmp0[1][i];
8832 ipad_buf[2][i] ^= tmp0[2][i];
8833 ipad_buf[3][i] ^= tmp0[3][i];
8834
8835 opad_buf[0][i] ^= tmp0[0][i];
8836 opad_buf[1][i] ^= tmp0[1][i];
8837 opad_buf[2][i] ^= tmp0[2][i];
8838 opad_buf[3][i] ^= tmp0[3][i];
8839
8840 ipad[0][i] = MD5M_A;
8841 ipad[1][i] = MD5M_B;
8842 ipad[2][i] = MD5M_C;
8843 ipad[3][i] = MD5M_D;
8844
8845 opad[0][i] = MD5M_A;
8846 opad[1][i] = MD5M_B;
8847 opad[2][i] = MD5M_C;
8848 opad[3][i] = MD5M_D;
8849 }
8850
8851 hashcat_md5_64 ((__m128i *) ipad, (__m128i *) ipad_buf);
8852 hashcat_md5_64 ((__m128i *) opad, (__m128i *) opad_buf);
8853
8854 for (i = 0; i < 4; i++)
8855 {
8856 tmp0[0][i] = ipad[0][i];
8857 tmp0[1][i] = ipad[1][i];
8858 tmp0[2][i] = ipad[2][i];
8859 tmp0[3][i] = ipad[3][i];
8860 }
8861
8862 int eapol_size = salt->wpa->eapol_size;
8863
8864 int eapol_left;
8865 int eapol_off;
8866
8867 for (eapol_left = eapol_size, eapol_off = 0; eapol_left >= 56; eapol_left -= 64, eapol_off += 16)
8868 {
8869 for (i = 0; i < 4; i++)
8870 {
8871 ipad_buf[ 0][i] = salt->wpa->eapol[eapol_off + 0];
8872 ipad_buf[ 1][i] = salt->wpa->eapol[eapol_off + 1];
8873 ipad_buf[ 2][i] = salt->wpa->eapol[eapol_off + 2];
8874 ipad_buf[ 3][i] = salt->wpa->eapol[eapol_off + 3];
8875 ipad_buf[ 4][i] = salt->wpa->eapol[eapol_off + 4];
8876 ipad_buf[ 5][i] = salt->wpa->eapol[eapol_off + 5];
8877 ipad_buf[ 6][i] = salt->wpa->eapol[eapol_off + 6];
8878 ipad_buf[ 7][i] = salt->wpa->eapol[eapol_off + 7];
8879 ipad_buf[ 8][i] = salt->wpa->eapol[eapol_off + 8];
8880 ipad_buf[ 9][i] = salt->wpa->eapol[eapol_off + 9];
8881 ipad_buf[10][i] = salt->wpa->eapol[eapol_off + 10];
8882 ipad_buf[11][i] = salt->wpa->eapol[eapol_off + 11];
8883 ipad_buf[12][i] = salt->wpa->eapol[eapol_off + 12];
8884 ipad_buf[13][i] = salt->wpa->eapol[eapol_off + 13];
8885 ipad_buf[14][i] = salt->wpa->eapol[eapol_off + 14];
8886 ipad_buf[15][i] = salt->wpa->eapol[eapol_off + 15];
8887 }
8888
8889 hashcat_md5_64 ((__m128i *) tmp0, (__m128i *) ipad_buf);
8890 }
8891
8892 for (i = 0; i < 4; i++)
8893 {
8894 ipad_buf[ 0][i] = salt->wpa->eapol[eapol_off + 0];
8895 ipad_buf[ 1][i] = salt->wpa->eapol[eapol_off + 1];
8896 ipad_buf[ 2][i] = salt->wpa->eapol[eapol_off + 2];
8897 ipad_buf[ 3][i] = salt->wpa->eapol[eapol_off + 3];
8898 ipad_buf[ 4][i] = salt->wpa->eapol[eapol_off + 4];
8899 ipad_buf[ 5][i] = salt->wpa->eapol[eapol_off + 5];
8900 ipad_buf[ 6][i] = salt->wpa->eapol[eapol_off + 6];
8901 ipad_buf[ 7][i] = salt->wpa->eapol[eapol_off + 7];
8902 ipad_buf[ 8][i] = salt->wpa->eapol[eapol_off + 8];
8903 ipad_buf[ 9][i] = salt->wpa->eapol[eapol_off + 9];
8904 ipad_buf[10][i] = salt->wpa->eapol[eapol_off + 10];
8905 ipad_buf[11][i] = salt->wpa->eapol[eapol_off + 11];
8906 ipad_buf[12][i] = salt->wpa->eapol[eapol_off + 12];
8907 ipad_buf[13][i] = salt->wpa->eapol[eapol_off + 13];
8908 ipad_buf[14][i] = (64 + eapol_size) * 8;
8909 ipad_buf[15][i] = 0;
8910 }
8911
8912 hashcat_md5_64 ((__m128i *) tmp0, (__m128i *) ipad_buf);
8913
8914 for (i = 0; i < 4; i++)
8915 {
8916 opad_buf[ 0][i] = tmp0[0][i];
8917 opad_buf[ 1][i] = tmp0[1][i];
8918 opad_buf[ 2][i] = tmp0[2][i];
8919 opad_buf[ 3][i] = tmp0[3][i];
8920 opad_buf[ 4][i] = 0x80;
8921 opad_buf[ 5][i] = 0;
8922 opad_buf[ 6][i] = 0;
8923 opad_buf[ 7][i] = 0;
8924 opad_buf[ 8][i] = 0;
8925 opad_buf[ 9][i] = 0;
8926 opad_buf[10][i] = 0;
8927 opad_buf[11][i] = 0;
8928 opad_buf[12][i] = 0;
8929 opad_buf[13][i] = 0;
8930 opad_buf[14][i] = (64 + 16) * 8;
8931 opad_buf[15][i] = 0;
8932 }
8933
8934 for (i = 0; i < 4; i++)
8935 {
8936 tmp0[0][i] = opad[0][i];
8937 tmp0[1][i] = opad[1][i];
8938 tmp0[2][i] = opad[2][i];
8939 tmp0[3][i] = opad[3][i];
8940 }
8941
8942 hashcat_md5_64 ((__m128i *) tmp0, (__m128i *) opad_buf);
8943 }
8944 else
8945 {
8946 /**
8947 * sha1
8948 */
8949
8950 for (i = 0; i < 4; i++)
8951 {
8952 for (j = 0; j < 16; j++)
8953 {
8954 ipad_buf[j][i] = 0x36363636;
8955 opad_buf[j][i] = 0x5c5c5c5c;
8956 }
8957
8958 ipad_buf[0][i] ^= tmp0[0][i];
8959 ipad_buf[1][i] ^= tmp0[1][i];
8960 ipad_buf[2][i] ^= tmp0[2][i];
8961 ipad_buf[3][i] ^= tmp0[3][i];
8962
8963 opad_buf[0][i] ^= tmp0[0][i];
8964 opad_buf[1][i] ^= tmp0[1][i];
8965 opad_buf[2][i] ^= tmp0[2][i];
8966 opad_buf[3][i] ^= tmp0[3][i];
8967
8968 ipad[0][i] = SHA1M_A;
8969 ipad[1][i] = SHA1M_B;
8970 ipad[2][i] = SHA1M_C;
8971 ipad[3][i] = SHA1M_D;
8972 ipad[4][i] = SHA1M_E;
8973
8974 opad[0][i] = SHA1M_A;
8975 opad[1][i] = SHA1M_B;
8976 opad[2][i] = SHA1M_C;
8977 opad[3][i] = SHA1M_D;
8978 opad[4][i] = SHA1M_E;
8979 }
8980
8981 for (i = 0; i < 4; i++) for (j = 0; j < 16; j++) BYTESWAP (ipad_buf[j][i]);
8982 for (i = 0; i < 4; i++) for (j = 0; j < 16; j++) BYTESWAP (opad_buf[j][i]);
8983
8984 hashcat_sha1_64 ((__m128i *) ipad, (__m128i *) ipad_buf);
8985 hashcat_sha1_64 ((__m128i *) opad, (__m128i *) opad_buf);
8986
8987 for (i = 0; i < 4; i++)
8988 {
8989 tmp0[0][i] = ipad[0][i];
8990 tmp0[1][i] = ipad[1][i];
8991 tmp0[2][i] = ipad[2][i];
8992 tmp0[3][i] = ipad[3][i];
8993 tmp0[4][i] = ipad[4][i];
8994 }
8995
8996 int eapol_size = salt->wpa->eapol_size;
8997
8998 int eapol_left;
8999 int eapol_off;
9000
9001 for (eapol_left = eapol_size, eapol_off = 0; eapol_left >= 56; eapol_left -= 64, eapol_off += 16)
9002 {
9003 for (i = 0; i < 4; i++)
9004 {
9005 ipad_buf[ 0][i] = salt->wpa->eapol[eapol_off + 0];
9006 ipad_buf[ 1][i] = salt->wpa->eapol[eapol_off + 1];
9007 ipad_buf[ 2][i] = salt->wpa->eapol[eapol_off + 2];
9008 ipad_buf[ 3][i] = salt->wpa->eapol[eapol_off + 3];
9009 ipad_buf[ 4][i] = salt->wpa->eapol[eapol_off + 4];
9010 ipad_buf[ 5][i] = salt->wpa->eapol[eapol_off + 5];
9011 ipad_buf[ 6][i] = salt->wpa->eapol[eapol_off + 6];
9012 ipad_buf[ 7][i] = salt->wpa->eapol[eapol_off + 7];
9013 ipad_buf[ 8][i] = salt->wpa->eapol[eapol_off + 8];
9014 ipad_buf[ 9][i] = salt->wpa->eapol[eapol_off + 9];
9015 ipad_buf[10][i] = salt->wpa->eapol[eapol_off + 10];
9016 ipad_buf[11][i] = salt->wpa->eapol[eapol_off + 11];
9017 ipad_buf[12][i] = salt->wpa->eapol[eapol_off + 12];
9018 ipad_buf[13][i] = salt->wpa->eapol[eapol_off + 13];
9019 ipad_buf[14][i] = salt->wpa->eapol[eapol_off + 14];
9020 ipad_buf[15][i] = salt->wpa->eapol[eapol_off + 15];
9021 }
9022
9023 for (i = 0; i < 4; i++) for (j = 0; j < 16; j++) BYTESWAP (ipad_buf[j][i]);
9024
9025 hashcat_sha1_64 ((__m128i *) tmp0, (__m128i *) ipad_buf);
9026 }
9027
9028 for (i = 0; i < 4; i++)
9029 {
9030 ipad_buf[ 0][i] = salt->wpa->eapol[eapol_off + 0];
9031 ipad_buf[ 1][i] = salt->wpa->eapol[eapol_off + 1];
9032 ipad_buf[ 2][i] = salt->wpa->eapol[eapol_off + 2];
9033 ipad_buf[ 3][i] = salt->wpa->eapol[eapol_off + 3];
9034 ipad_buf[ 4][i] = salt->wpa->eapol[eapol_off + 4];
9035 ipad_buf[ 5][i] = salt->wpa->eapol[eapol_off + 5];
9036 ipad_buf[ 6][i] = salt->wpa->eapol[eapol_off + 6];
9037 ipad_buf[ 7][i] = salt->wpa->eapol[eapol_off + 7];
9038 ipad_buf[ 8][i] = salt->wpa->eapol[eapol_off + 8];
9039 ipad_buf[ 9][i] = salt->wpa->eapol[eapol_off + 9];
9040 ipad_buf[10][i] = salt->wpa->eapol[eapol_off + 10];
9041 ipad_buf[11][i] = salt->wpa->eapol[eapol_off + 11];
9042 ipad_buf[12][i] = salt->wpa->eapol[eapol_off + 12];
9043 ipad_buf[13][i] = salt->wpa->eapol[eapol_off + 13];
9044 ipad_buf[14][i] = 0;
9045 ipad_buf[15][i] = (64 + eapol_size) * 8;
9046 }
9047
9048 for (i = 0; i < 4; i++) for (j = 0; j < 16; j++) BYTESWAP (ipad_buf[j][i]);
9049
9050 hashcat_sha1_64 ((__m128i *) tmp0, (__m128i *) ipad_buf);
9051
9052 for (i = 0; i < 4; i++)
9053 {
9054 opad_buf[ 0][i] = tmp0[0][i];
9055 opad_buf[ 1][i] = tmp0[1][i];
9056 opad_buf[ 2][i] = tmp0[2][i];
9057 opad_buf[ 3][i] = tmp0[3][i];
9058 opad_buf[ 4][i] = tmp0[4][i];
9059 opad_buf[ 5][i] = 0x80000000;
9060 opad_buf[ 6][i] = 0;
9061 opad_buf[ 7][i] = 0;
9062 opad_buf[ 8][i] = 0;
9063 opad_buf[ 9][i] = 0;
9064 opad_buf[10][i] = 0;
9065 opad_buf[11][i] = 0;
9066 opad_buf[12][i] = 0;
9067 opad_buf[13][i] = 0;
9068 opad_buf[14][i] = 0;
9069 opad_buf[15][i] = (64 + 20) * 8;
9070 }
9071
9072 for (i = 0; i < 4; i++)
9073 {
9074 tmp0[0][i] = opad[0][i];
9075 tmp0[1][i] = opad[1][i];
9076 tmp0[2][i] = opad[2][i];
9077 tmp0[3][i] = opad[3][i];
9078 tmp0[4][i] = opad[4][i];
9079 }
9080
9081 for (i = 0; i < 4; i++) for (j = 0; j < 16; j++) BYTESWAP (opad_buf[j][i]);
9082
9083 hashcat_sha1_64 ((__m128i *) tmp0, (__m128i *) opad_buf);
9084 }
9085
9086 for (i = 0; i < 4; i++)
9087 {
9088 digests[i].buf.md5[0] = tmp0[0][i];
9089 digests[i].buf.md5[1] = tmp0[1][i];
9090 digests[i].buf.md5[2] = tmp0[2][i];
9091 digests[i].buf.md5[3] = tmp0[3][i];
9092 }
9093
9094 thread_parameter->indb (thread_parameter, plains, digests, salt);
9095 }
9096 }
9097
hashing_02600(thread_parameter_t * thread_parameter,plain_t * in)9098 void hashing_02600 (thread_parameter_t *thread_parameter, plain_t *in)
9099 {
9100 digest_md5_sse2_t digests;
9101
9102 digest_t dgst[4];
9103
9104 plain_t plains[4];
9105
9106 char *ptrs_tmp[4];
9107
9108 ptrs_tmp[0] = (char *) &plains[0].buf;
9109 ptrs_tmp[1] = (char *) &plains[1].buf;
9110 ptrs_tmp[2] = (char *) &plains[2].buf;
9111 ptrs_tmp[3] = (char *) &plains[3].buf;
9112
9113 db_t *db = thread_parameter->db;
9114
9115 md5_init_sse2 (&digests);
9116
9117 md5_final_sse2_max55 (in, &digests);
9118
9119 transpose_md5_digest (&digests, dgst);
9120
9121 uint32_t i;
9122
9123 for (i = 0; i < 4; i++)
9124 {
9125 BYTESWAP (dgst[i].buf.md5[0]);
9126 BYTESWAP (dgst[i].buf.md5[1]);
9127 BYTESWAP (dgst[i].buf.md5[2]);
9128 BYTESWAP (dgst[i].buf.md5[3]);
9129
9130 uint_to_hex_lower (dgst[i].buf.md5[0], &ptrs_tmp[i][0]);
9131 uint_to_hex_lower (dgst[i].buf.md5[1], &ptrs_tmp[i][8]);
9132 uint_to_hex_lower (dgst[i].buf.md5[2], &ptrs_tmp[i][16]);
9133 uint_to_hex_lower (dgst[i].buf.md5[3], &ptrs_tmp[i][24]);
9134
9135 plains[i].len = 32;
9136 }
9137
9138 md5_init_sse2 (&digests);
9139
9140 md5_final_sse2_max55 (plains, &digests);
9141
9142 transpose_md5_digest (&digests, dgst);
9143
9144 thread_parameter->indb (thread_parameter, in, dgst, db->salts_buf[0]);
9145 }
9146
hashing_02611(thread_parameter_t * thread_parameter,plain_t * in)9147 void hashing_02611 (thread_parameter_t *thread_parameter, plain_t *in)
9148 {
9149 digest_md5_sse2_t digests;
9150
9151 digest_t dgst[4];
9152
9153 plain_t plains[4];
9154
9155 char *ptrs_tmp[4];
9156
9157 ptrs_tmp[0] = (char *) &plains[0].buf;
9158 ptrs_tmp[1] = (char *) &plains[1].buf;
9159 ptrs_tmp[2] = (char *) &plains[2].buf;
9160 ptrs_tmp[3] = (char *) &plains[3].buf;
9161
9162 db_t *db = thread_parameter->db;
9163
9164 md5_init_sse2 (&digests);
9165
9166 md5_final_sse2_max55 (in, &digests);
9167
9168 transpose_md5_digest (&digests, dgst);
9169
9170 uint32_t i;
9171
9172 for (i = 0; i < 4; i++)
9173 {
9174 BYTESWAP (dgst[i].buf.md5[0]);
9175 BYTESWAP (dgst[i].buf.md5[1]);
9176 BYTESWAP (dgst[i].buf.md5[2]);
9177 BYTESWAP (dgst[i].buf.md5[3]);
9178
9179 uint_to_hex_lower (dgst[i].buf.md5[0], &ptrs_tmp[i][0]);
9180 uint_to_hex_lower (dgst[i].buf.md5[1], &ptrs_tmp[i][8]);
9181 uint_to_hex_lower (dgst[i].buf.md5[2], &ptrs_tmp[i][16]);
9182 uint_to_hex_lower (dgst[i].buf.md5[3], &ptrs_tmp[i][24]);
9183 }
9184
9185 uint32_t salts_idx;
9186
9187 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
9188 {
9189 salt_t *salt = db->salts_buf[salts_idx];
9190
9191 if (salt->indexes_found == salt->indexes_cnt) continue;
9192
9193 for (i = 0; i < 4; i++)
9194 {
9195 plains[i].len = 32 + salt->salt_plain_len;
9196
9197 memcpy (ptrs_tmp[i] + 32, salt->salt_plain_buf, salt->salt_plain_len);
9198 }
9199
9200 md5_init_sse2 (&digests);
9201
9202 md5_final_sse2_max55 (plains, &digests);
9203
9204 transpose_md5_digest (&digests, dgst);
9205
9206 thread_parameter->indb (thread_parameter, in, dgst, salt);
9207 }
9208 }
9209
hashing_02711(thread_parameter_t * thread_parameter,plain_t * in)9210 void hashing_02711 (thread_parameter_t *thread_parameter, plain_t *in)
9211 {
9212 digest_md5_sse2_t digests;
9213
9214 digest_t dgst[4];
9215
9216 plain_t plains[4];
9217
9218 plain_t plains_tmp[4];
9219
9220 char *ptrs_tmp[4];
9221
9222 ptrs_tmp[0] = (char *) &plains_tmp[0].buf;
9223 ptrs_tmp[1] = (char *) &plains_tmp[1].buf;
9224 ptrs_tmp[2] = (char *) &plains_tmp[2].buf;
9225 ptrs_tmp[3] = (char *) &plains_tmp[3].buf;
9226
9227 db_t *db = thread_parameter->db;
9228
9229 md5_init_sse2 (&digests);
9230
9231 md5_final_sse2_max55 (in, &digests);
9232
9233 transpose_md5_digest (&digests, dgst);
9234
9235 uint32_t i;
9236
9237 for (i = 0; i < 4; i++)
9238 {
9239 BYTESWAP (dgst[i].buf.md5[0]);
9240 BYTESWAP (dgst[i].buf.md5[1]);
9241 BYTESWAP (dgst[i].buf.md5[2]);
9242 BYTESWAP (dgst[i].buf.md5[3]);
9243
9244 uint_to_hex_lower (dgst[i].buf.md5[0], &ptrs_tmp[i][0]);
9245 uint_to_hex_lower (dgst[i].buf.md5[1], &ptrs_tmp[i][8]);
9246 uint_to_hex_lower (dgst[i].buf.md5[2], &ptrs_tmp[i][16]);
9247 uint_to_hex_lower (dgst[i].buf.md5[3], &ptrs_tmp[i][24]);
9248
9249 plains_tmp[i].len = 32;
9250 }
9251
9252 uint32_t salts_idx;
9253
9254 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
9255 {
9256 salt_t *salt = db->salts_buf[salts_idx];
9257
9258 if (salt->indexes_found == salt->indexes_cnt) continue;
9259
9260 plain_init (plains);
9261
9262 md5_init_sse2 (&digests);
9263
9264 md5_update_sse2 (plains, &digests, plains_tmp);
9265
9266 md5_update_sse2 (plains, &digests, salt->salt_plain_struct);
9267
9268 md5_final_sse2 (plains, &digests);
9269
9270 transpose_md5_digest (&digests, dgst);
9271
9272 thread_parameter->indb (thread_parameter, in, dgst, salt);
9273 }
9274 }
9275
hashing_02811(thread_parameter_t * thread_parameter,plain_t * in)9276 void hashing_02811 (thread_parameter_t *thread_parameter, plain_t *in)
9277 {
9278 digest_md5_sse2_t digests;
9279
9280 digest_t dgst[4];
9281
9282 plain_t plains[4];
9283
9284 plain_t plains_tmp[4];
9285
9286 char *ptrs_tmp[4];
9287
9288 ptrs_tmp[0] = (char *) &plains_tmp[0].buf;
9289 ptrs_tmp[1] = (char *) &plains_tmp[1].buf;
9290 ptrs_tmp[2] = (char *) &plains_tmp[2].buf;
9291 ptrs_tmp[3] = (char *) &plains_tmp[3].buf;
9292
9293 db_t *db = thread_parameter->db;
9294
9295 md5_init_sse2 (&digests);
9296
9297 md5_final_sse2_max55 (in, &digests);
9298
9299 transpose_md5_digest (&digests, dgst);
9300
9301 uint32_t i;
9302
9303 for (i = 0; i < 4; i++)
9304 {
9305 BYTESWAP (dgst[i].buf.md5[0]);
9306 BYTESWAP (dgst[i].buf.md5[1]);
9307 BYTESWAP (dgst[i].buf.md5[2]);
9308 BYTESWAP (dgst[i].buf.md5[3]);
9309
9310 uint_to_hex_lower (dgst[i].buf.md5[0], ptrs_tmp[i] + 0);
9311 uint_to_hex_lower (dgst[i].buf.md5[1], ptrs_tmp[i] + 8);
9312 uint_to_hex_lower (dgst[i].buf.md5[2], ptrs_tmp[i] + 16);
9313 uint_to_hex_lower (dgst[i].buf.md5[3], ptrs_tmp[i] + 24);
9314
9315 plains_tmp[i].len = 32;
9316 }
9317
9318 uint32_t salts_idx;
9319
9320 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
9321 {
9322 salt_t *salt = db->salts_buf[salts_idx];
9323
9324 if (salt->indexes_found == salt->indexes_cnt) continue;
9325
9326 plain_init (plains);
9327
9328 md5_init_sse2 (&digests);
9329
9330 md5_update_sse2 (plains, &digests, salt->salt_plain_struct);
9331
9332 md5_update_sse2 (plains, &digests, plains_tmp);
9333
9334 md5_final_sse2 (plains, &digests);
9335
9336 transpose_md5_digest (&digests, dgst);
9337
9338 thread_parameter->indb (thread_parameter, in, dgst, salt);
9339 }
9340 }
9341
md5bit(uint8_t * digest,int bit_num)9342 int md5bit (uint8_t *digest, int bit_num)
9343 {
9344 int byte_off;
9345 int bit_off;
9346
9347 bit_num %= 128; /* keep this bounded for convenience */
9348 byte_off = bit_num / 8;
9349 bit_off = bit_num % 8;
9350
9351 /* return the value of bit N from the digest */
9352 return ((digest[byte_off] & (1 << bit_off)) ? 1 : 0);
9353 }
9354
hashing_03200(thread_parameter_t * thread_parameter,plain_t * in)9355 void hashing_03200 (thread_parameter_t *thread_parameter, plain_t *in)
9356 {
9357 digest_bcrypt_sse2_t digest;
9358
9359 digest_t dgst[4];
9360
9361 db_t *db = thread_parameter->db;
9362
9363 // prepare plain for bcrypt
9364
9365 plain_t bf[4];
9366
9367 plain_init (bf);
9368
9369 int i;
9370
9371 for (i = 0; i < 4; i++)
9372 {
9373 if (in[i].len == 0) continue;
9374
9375 #define BFSZ (18 * 4)
9376
9377 while (bf[i].len < BFSZ)
9378 {
9379 const uint left = BFSZ - bf[i].len;
9380
9381 const uint sz = MIN (in[i].len, left);
9382
9383 memcpy (bf[i].buf8 + bf[i].len, in[i].buf8, sz);
9384
9385 bf[i].len += sz;
9386
9387 bf[i].buf8[bf[i].len] = 0;
9388
9389 bf[i].len++;
9390 }
9391
9392 int j;
9393
9394 for (j = 0; j < 18; j++)
9395 {
9396 BYTESWAP (bf[i].buf[j]);
9397 }
9398 }
9399
9400 uint32_t salts_idx;
9401
9402 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
9403 {
9404 salt_t *salt = db->salts_buf[salts_idx];
9405
9406 if (salt->indexes_found == salt->indexes_cnt) continue;
9407
9408 bcrypt_64 (bf, salt->salt_plain_struct, salt->iterations, &digest);
9409
9410 transpose_bcrypt_digest (&digest, dgst);
9411
9412 thread_parameter->indb (thread_parameter, in, dgst, salt);
9413 }
9414 }
9415
9416 #include "md5.h"
9417
hashing_03300(thread_parameter_t * thread_parameter,plain_t * in)9418 void hashing_03300 (thread_parameter_t *thread_parameter, plain_t *in)
9419 {
9420 digest_md5_sse2_t digests;
9421
9422 digest_t dgst[4];
9423
9424 plain_t plains_tmp[4];
9425
9426 uint8_t *ptrs_dgst[4];
9427
9428 ptrs_dgst[0] = (uint8_t *) dgst[0].buf.md5;
9429 ptrs_dgst[1] = (uint8_t *) dgst[1].buf.md5;
9430 ptrs_dgst[2] = (uint8_t *) dgst[2].buf.md5;
9431 ptrs_dgst[3] = (uint8_t *) dgst[3].buf.md5;
9432
9433 db_t *db = thread_parameter->db;
9434
9435 uint32_t salts_idx;
9436
9437 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
9438 {
9439 salt_t *salt = db->salts_buf[salts_idx];
9440
9441 if (salt->indexes_found == salt->indexes_cnt) continue;
9442
9443 plain_init (plains_tmp);
9444
9445 md5_init_sse2 (&digests);
9446
9447 md5_update_sse2_max55 (plains_tmp, in);
9448
9449 md5_update_sse2_max55 (plains_tmp, salt->salt_plain_struct);
9450
9451 md5_final_sse2_max55 (plains_tmp, &digests);
9452
9453 transpose_md5_digest (&digests, dgst);
9454
9455 /*
9456 * now to delay high-speed md5 implementations that have stuff
9457 * like code inlining, loops unrolled and table lookup
9458 */
9459
9460 uint32_t i;
9461
9462 for (i = 0; i < 4; i++)
9463 {
9464 /* the xor a coin-toss section makes vector datatypes impossible :( */
9465
9466 uint W[16 + 1 + 1];
9467
9468 char *W_ptr = (char *) W;
9469
9470 int round;
9471
9472 for (round = 0; round < (int) salt->iterations; round++)
9473 {
9474 int shift_a = md5bit (ptrs_dgst[i], round + 0);
9475 int shift_b = md5bit (ptrs_dgst[i], round + 64);
9476
9477 /* populate the shift schedules for use later */
9478
9479 int shift_4[16]; /* shift schedule, vals 0..4 */
9480 int shift_7[16]; /* shift schedule, vals 0..1 */
9481
9482 int k;
9483
9484 for (k = 0; k < 16; k++)
9485 {
9486 int s7shift = ptrs_dgst[i][k] % 8;
9487
9488 /* offset 3 -> occasionally span more than 1 int32 fetch */
9489
9490 int l = (k + 3) % 16;
9491
9492 shift_4[k] = ptrs_dgst[i][l] % 5;
9493
9494 shift_7[k] = (ptrs_dgst[i][l] >> s7shift) & 1;
9495 }
9496
9497 /* populate indirect_4 with 4bit values extracted from digest */
9498
9499 int indirect_4[16]; /* extracted array of 4bit values */
9500
9501 for (k = 0; k < 16; k++)
9502 {
9503 /* shift the digest byte and extract four bits */
9504
9505 indirect_4[k] = (ptrs_dgst[i][k] >> shift_4[k]) & 0xf;
9506 }
9507
9508 /*
9509 * populate indirect_7 with 7bit values from digest
9510 * indexed via indirect_4
9511 */
9512
9513 int indirect_7[16]; /* extracted array of 7bit values */
9514
9515 for (k = 0; k < 16; k++)
9516 {
9517 /* shift the digest byte and extract seven bits */
9518
9519 indirect_7[k] = (ptrs_dgst[i][indirect_4[k]] >> shift_7[k]) & 0x7f;
9520 }
9521
9522 /*
9523 * use the 7bit values to indirect into digest,
9524 * and create two 8bit values from the results.
9525 */
9526
9527 int indirect_a = 0;
9528 int indirect_b = 0;
9529
9530 for (k = 0; k < 8; k++)
9531 {
9532 indirect_a |= md5bit (ptrs_dgst[i], indirect_7[k + 0]) << k;
9533 indirect_b |= md5bit (ptrs_dgst[i], indirect_7[k + 8]) << k;
9534 }
9535
9536 /* shall we utilise the top or bottom 7 bits? */
9537
9538 indirect_a = (indirect_a >> shift_a) & 0x7f;
9539 indirect_b = (indirect_b >> shift_b) & 0x7f;
9540
9541 /* extract two data.digest bits */
9542
9543 int bit_a = md5bit (ptrs_dgst[i], indirect_a);
9544 int bit_b = md5bit (ptrs_dgst[i], indirect_b);
9545
9546 /* update with the previous digest */
9547
9548 memcpy (W_ptr, ptrs_dgst[i], 16);
9549
9550 uint pos = 16;
9551
9552 uint total = pos;
9553
9554 /* re-initialise the context */
9555
9556 dgst[i].buf.md5[0] = MAGIC_A;
9557 dgst[i].buf.md5[1] = MAGIC_B;
9558 dgst[i].buf.md5[2] = MAGIC_C;
9559 dgst[i].buf.md5[3] = MAGIC_D;
9560
9561 /* xor a coin-toss; if true, mix-in the constant phrase */
9562
9563 if (bit_a ^ bit_b)
9564 {
9565 memcpy (W_ptr + 16, constant_phrase, 48);
9566
9567 total += 48;
9568
9569 md5_64H (W, dgst[i].buf.md5);
9570
9571 uint constant_off;
9572 uint constant_len = sizeof (constant_phrase);
9573
9574 for (constant_off = 48; constant_off < constant_len - 64; constant_off += 64)
9575 {
9576 memcpy (W_ptr, constant_phrase + constant_off, 64);
9577
9578 total += 64;
9579
9580 md5_64H (W, dgst[i].buf.md5);
9581 }
9582
9583 pos = constant_len - constant_off;
9584
9585 total += pos;
9586
9587 memcpy (W_ptr, constant_phrase + constant_off, pos);
9588 }
9589
9590 /* digest a decimal sprintf of the current roundcount */
9591
9592 uint a_len = 0;
9593
9594 uint a_buf[2] = { 0, 0 };
9595
9596 uint tmp = round;
9597
9598 do
9599 {
9600 uint round_div = tmp / 10;
9601 uint round_mod = tmp % 10;
9602
9603 tmp = round_div;
9604
9605 a_buf[a_len / 4] = (a_buf[a_len / 4] << 8) | (round_mod + 0x30);
9606
9607 a_len++;
9608
9609 } while (tmp);
9610
9611 memcpy (W_ptr + pos, a_buf, a_len);
9612
9613 pos += a_len;
9614
9615 total += a_len;
9616
9617 memset (W_ptr + pos, 0, sizeof (W) - pos);
9618
9619 W_ptr[pos] = 0x80;
9620
9621 if (pos >= 56)
9622 {
9623 md5_64H (W, dgst[i].buf.md5);
9624
9625 W[0] = W[16];
9626 W[1] = W[17];
9627
9628 memset (W_ptr + 8, 0, sizeof (W) - 8);
9629 }
9630
9631 W[14] = total * 8;
9632
9633 md5_64H (W, dgst[i].buf.md5);
9634 }
9635 }
9636
9637 thread_parameter->indb (thread_parameter, in, dgst, salt);
9638 }
9639 }
9640
hashing_03500(thread_parameter_t * thread_parameter,plain_t * in)9641 void hashing_03500 (thread_parameter_t *thread_parameter, plain_t *in)
9642 {
9643 digest_md5_sse2_t digests;
9644
9645 digest_t dgst[4];
9646
9647 plain_t plains[4];
9648
9649 char *ptrs_tmp[4];
9650
9651 ptrs_tmp[0] = (char *) &plains[0].buf;
9652 ptrs_tmp[1] = (char *) &plains[1].buf;
9653 ptrs_tmp[2] = (char *) &plains[2].buf;
9654 ptrs_tmp[3] = (char *) &plains[3].buf;
9655
9656 db_t *db = thread_parameter->db;
9657
9658 md5_init_sse2 (&digests);
9659
9660 md5_final_sse2_max55 (in, &digests);
9661
9662 transpose_md5_digest (&digests, dgst);
9663
9664 uint32_t i;
9665
9666 for (i = 0; i < 4; i++)
9667 {
9668 BYTESWAP (dgst[i].buf.md5[0]);
9669 BYTESWAP (dgst[i].buf.md5[1]);
9670 BYTESWAP (dgst[i].buf.md5[2]);
9671 BYTESWAP (dgst[i].buf.md5[3]);
9672
9673 uint_to_hex_lower (dgst[i].buf.md5[0], &ptrs_tmp[i][0]);
9674 uint_to_hex_lower (dgst[i].buf.md5[1], &ptrs_tmp[i][8]);
9675 uint_to_hex_lower (dgst[i].buf.md5[2], &ptrs_tmp[i][16]);
9676 uint_to_hex_lower (dgst[i].buf.md5[3], &ptrs_tmp[i][24]);
9677
9678 plains[i].len = 32;
9679 }
9680
9681 md5_init_sse2 (&digests);
9682
9683 md5_final_sse2_max55 (plains, &digests);
9684
9685 transpose_md5_digest (&digests, dgst);
9686
9687 for (i = 0; i < 4; i++)
9688 {
9689 BYTESWAP (dgst[i].buf.md5[0]);
9690 BYTESWAP (dgst[i].buf.md5[1]);
9691 BYTESWAP (dgst[i].buf.md5[2]);
9692 BYTESWAP (dgst[i].buf.md5[3]);
9693
9694 uint_to_hex_lower (dgst[i].buf.md5[0], &ptrs_tmp[i][0]);
9695 uint_to_hex_lower (dgst[i].buf.md5[1], &ptrs_tmp[i][8]);
9696 uint_to_hex_lower (dgst[i].buf.md5[2], &ptrs_tmp[i][16]);
9697 uint_to_hex_lower (dgst[i].buf.md5[3], &ptrs_tmp[i][24]);
9698 }
9699
9700 md5_init_sse2 (&digests);
9701
9702 md5_final_sse2_max55 (plains, &digests);
9703
9704 transpose_md5_digest (&digests, dgst);
9705
9706 thread_parameter->indb (thread_parameter, in, dgst, db->salts_buf[0]);
9707 }
9708
hashing_03610(thread_parameter_t * thread_parameter,plain_t * in)9709 void hashing_03610 (thread_parameter_t *thread_parameter, plain_t *in)
9710 {
9711 digest_md5_sse2_t digests;
9712
9713 digest_t dgst[4];
9714
9715 plain_t plains[4];
9716
9717 db_t *db = thread_parameter->db;
9718
9719 uint32_t salts_idx;
9720
9721 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
9722 {
9723 salt_t *salt = db->salts_buf[salts_idx];
9724
9725 if (salt->indexes_found == salt->indexes_cnt) continue;
9726
9727 plain_init (plains);
9728
9729 md5_init_sse2 (&digests);
9730
9731 md5_update_sse2_max55 (plains, salt->salt_plain_struct);
9732
9733 md5_update_sse2_max55 (plains, in);
9734
9735 md5_final_sse2_max55 (plains, &digests);
9736
9737 transpose_md5_digest (&digests, dgst);
9738
9739 thread_parameter->indb (thread_parameter, in, dgst, salt);
9740 }
9741 }
9742
hashing_03710(thread_parameter_t * thread_parameter,plain_t * in)9743 void hashing_03710 (thread_parameter_t *thread_parameter, plain_t *in)
9744 {
9745 digest_md5_sse2_t digests;
9746
9747 digest_t dgst[4];
9748
9749 plain_t plains[4];
9750
9751 plain_t plains_tmp[4];
9752
9753 char *ptrs_tmp[4];
9754
9755 ptrs_tmp[0] = (char *) &plains_tmp[0].buf;
9756 ptrs_tmp[1] = (char *) &plains_tmp[1].buf;
9757 ptrs_tmp[2] = (char *) &plains_tmp[2].buf;
9758 ptrs_tmp[3] = (char *) &plains_tmp[3].buf;
9759
9760 db_t *db = thread_parameter->db;
9761
9762 md5_init_sse2 (&digests);
9763
9764 md5_final_sse2_max55 (in, &digests);
9765
9766 transpose_md5_digest (&digests, dgst);
9767
9768 uint32_t i;
9769
9770 for (i = 0; i < 4; i++)
9771 {
9772 BYTESWAP (dgst[i].buf.md5[0]);
9773 BYTESWAP (dgst[i].buf.md5[1]);
9774 BYTESWAP (dgst[i].buf.md5[2]);
9775 BYTESWAP (dgst[i].buf.md5[3]);
9776
9777 uint_to_hex_lower (dgst[i].buf.md5[0], &ptrs_tmp[i][0]);
9778 uint_to_hex_lower (dgst[i].buf.md5[1], &ptrs_tmp[i][8]);
9779 uint_to_hex_lower (dgst[i].buf.md5[2], &ptrs_tmp[i][16]);
9780 uint_to_hex_lower (dgst[i].buf.md5[3], &ptrs_tmp[i][24]);
9781
9782 plains_tmp[i].len = 32;
9783 }
9784
9785 uint32_t salts_idx;
9786
9787 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
9788 {
9789 salt_t *salt = db->salts_buf[salts_idx];
9790
9791 if (salt->indexes_found == salt->indexes_cnt) continue;
9792
9793 plain_init (plains);
9794
9795 md5_init_sse2 (&digests);
9796
9797 md5_update_sse2_max55 (plains, salt->salt_plain_struct);
9798
9799 md5_update_sse2_max55 (plains, plains_tmp);
9800
9801 md5_final_sse2_max55 (plains, &digests);
9802
9803 transpose_md5_digest (&digests, dgst);
9804
9805 thread_parameter->indb (thread_parameter, in, dgst, salt);
9806 }
9807 }
9808
hashing_03720(thread_parameter_t * thread_parameter,plain_t * in)9809 void hashing_03720 (thread_parameter_t *thread_parameter, plain_t *in)
9810 {
9811 digest_md5_sse2_t digests;
9812
9813 digest_t dgst[4];
9814
9815 plain_t plains[4];
9816
9817 db_t *db = thread_parameter->db;
9818
9819 uint32_t salts_idx;
9820
9821 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
9822 {
9823 salt_t *salt = db->salts_buf[salts_idx];
9824
9825 if (salt->indexes_found == salt->indexes_cnt) continue;
9826
9827 plain_init (plains);
9828
9829 md5_init_sse2 (&digests);
9830
9831 md5_update_sse2_max55 (plains, in);
9832
9833 md5_update_sse2_max55 (plains, salt->salt_plain_struct);
9834
9835 md5_final_sse2_max55 (plains, &digests);
9836
9837 transpose_md5_digest (&digests, dgst);
9838
9839 thread_parameter->indb (thread_parameter, in, dgst, salt);
9840 }
9841 }
9842
hashing_03800(thread_parameter_t * thread_parameter,plain_t * in)9843 void hashing_03800 (thread_parameter_t *thread_parameter, plain_t *in)
9844 {
9845 digest_md5_sse2_t digests;
9846
9847 digest_t dgst[4];
9848
9849 plain_t plains[4];
9850
9851 db_t *db = thread_parameter->db;
9852
9853 uint32_t salts_idx;
9854
9855 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
9856 {
9857 salt_t *salt = db->salts_buf[salts_idx];
9858
9859 if (salt->indexes_found == salt->indexes_cnt) continue;
9860
9861 plain_init (plains);
9862
9863 md5_init_sse2 (&digests);
9864
9865 md5_update_sse2_max55 (plains, salt->salt_plain_struct);
9866
9867 md5_update_sse2_max55 (plains, in);
9868
9869 md5_update_sse2_max55 (plains, salt->salt_plain_struct);
9870
9871 md5_final_sse2_max55 (plains, &digests);
9872
9873 transpose_md5_digest (&digests, dgst);
9874
9875 thread_parameter->indb (thread_parameter, in, dgst, salt);
9876 }
9877 }
9878
hashing_03910(thread_parameter_t * thread_parameter,plain_t * in)9879 void hashing_03910 (thread_parameter_t *thread_parameter, plain_t *in)
9880 {
9881 digest_md5_sse2_t digests;
9882
9883 digest_t dgst[4];
9884
9885 plain_t plains[4];
9886
9887 plain_t plains_tmp[4];
9888
9889 char *ptrs_tmp[4];
9890
9891 ptrs_tmp[0] = (char *) &plains_tmp[0].buf;
9892 ptrs_tmp[1] = (char *) &plains_tmp[1].buf;
9893 ptrs_tmp[2] = (char *) &plains_tmp[2].buf;
9894 ptrs_tmp[3] = (char *) &plains_tmp[3].buf;
9895
9896 db_t *db = thread_parameter->db;
9897
9898 md5_init_sse2 (&digests);
9899
9900 md5_final_sse2_max55 (in, &digests);
9901
9902 transpose_md5_digest (&digests, dgst);
9903
9904 uint32_t i;
9905
9906 for (i = 0; i < 4; i++)
9907 {
9908 BYTESWAP (dgst[i].buf.md5[0]);
9909 BYTESWAP (dgst[i].buf.md5[1]);
9910 BYTESWAP (dgst[i].buf.md5[2]);
9911 BYTESWAP (dgst[i].buf.md5[3]);
9912
9913 uint_to_hex_lower (dgst[i].buf.md5[0], ptrs_tmp[i] + 0);
9914 uint_to_hex_lower (dgst[i].buf.md5[1], ptrs_tmp[i] + 8);
9915 uint_to_hex_lower (dgst[i].buf.md5[2], ptrs_tmp[i] + 16);
9916 uint_to_hex_lower (dgst[i].buf.md5[3], ptrs_tmp[i] + 24);
9917
9918 plains_tmp[i].len = 32;
9919 }
9920
9921 uint32_t salts_idx;
9922
9923 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
9924 {
9925 salt_t *salt = db->salts_buf[salts_idx];
9926
9927 if (salt->indexes_found == salt->indexes_cnt) continue;
9928
9929 plain_init (plains);
9930
9931 md5_init_sse2 (&digests);
9932
9933 md5_update_sse2 (plains, &digests, plains_tmp);
9934
9935 md5_update_sse2 (plains, &digests, salt->salt_plain_struct);
9936
9937 md5_final_sse2 (plains, &digests);
9938
9939 transpose_md5_digest (&digests, dgst);
9940
9941 thread_parameter->indb (thread_parameter, in, dgst, salt);
9942 }
9943 }
9944
hashing_04010(thread_parameter_t * thread_parameter,plain_t * in)9945 void hashing_04010 (thread_parameter_t *thread_parameter, plain_t *in)
9946 {
9947 digest_md5_sse2_t digests;
9948
9949 digest_t dgst[4];
9950
9951 plain_t plains[4];
9952
9953 plain_t plains_tmp[4];
9954
9955 char *ptrs_tmp[4];
9956
9957 memset (ptrs_tmp, 0, sizeof (ptrs_tmp));
9958
9959 ptrs_tmp[0] = (char *) &plains_tmp[0].buf;
9960 ptrs_tmp[1] = (char *) &plains_tmp[1].buf;
9961 ptrs_tmp[2] = (char *) &plains_tmp[2].buf;
9962 ptrs_tmp[3] = (char *) &plains_tmp[3].buf;
9963
9964 db_t *db = thread_parameter->db;
9965
9966 uint32_t i;
9967
9968 for (i = 0; i < 4; i++) plains_tmp[i].len = 32;
9969
9970 uint32_t salts_idx;
9971
9972 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
9973 {
9974 salt_t *salt = db->salts_buf[salts_idx];
9975
9976 if (salt->indexes_found == salt->indexes_cnt) continue;
9977
9978 plain_init (plains);
9979
9980 md5_init_sse2 (&digests);
9981
9982 md5_update_sse2_max55 (plains, salt->salt_plain_struct);
9983
9984 md5_update_sse2_max55 (plains, in);
9985
9986 md5_final_sse2_max55 (plains, &digests);
9987
9988 transpose_md5_digest (&digests, dgst);
9989
9990 for (i = 0; i < 4; i++)
9991 {
9992 BYTESWAP (dgst[i].buf.md5[0]);
9993 BYTESWAP (dgst[i].buf.md5[1]);
9994 BYTESWAP (dgst[i].buf.md5[2]);
9995 BYTESWAP (dgst[i].buf.md5[3]);
9996
9997 uint_to_hex_lower (dgst[i].buf.md5[0], &ptrs_tmp[i][0]);
9998 uint_to_hex_lower (dgst[i].buf.md5[1], &ptrs_tmp[i][8]);
9999 uint_to_hex_lower (dgst[i].buf.md5[2], &ptrs_tmp[i][16]);
10000 uint_to_hex_lower (dgst[i].buf.md5[3], &ptrs_tmp[i][24]);
10001 }
10002
10003 plain_init (plains);
10004
10005 md5_init_sse2 (&digests);
10006
10007 md5_update_sse2_max55 (plains, salt->salt_plain_struct);
10008
10009 md5_update_sse2_max55 (plains, plains_tmp);
10010
10011 md5_final_sse2_max55 (plains, &digests);
10012
10013 transpose_md5_digest (&digests, dgst);
10014
10015 thread_parameter->indb (thread_parameter, in, dgst, salt);
10016 }
10017 }
10018
hashing_04110(thread_parameter_t * thread_parameter,plain_t * in)10019 void hashing_04110 (thread_parameter_t *thread_parameter, plain_t *in)
10020 {
10021 digest_md5_sse2_t digests;
10022
10023 digest_t dgst[4];
10024
10025 plain_t plains[4];
10026
10027 plain_t plains_tmp[4];
10028
10029 char *ptrs_tmp[4];
10030
10031 memset (ptrs_tmp, 0, sizeof (ptrs_tmp));
10032
10033 ptrs_tmp[0] = (char *) &plains_tmp[0].buf;
10034 ptrs_tmp[1] = (char *) &plains_tmp[1].buf;
10035 ptrs_tmp[2] = (char *) &plains_tmp[2].buf;
10036 ptrs_tmp[3] = (char *) &plains_tmp[3].buf;
10037
10038 db_t *db = thread_parameter->db;
10039
10040 uint32_t i;
10041
10042 for (i = 0; i < 4; i++) plains_tmp[i].len = 32;
10043
10044 uint32_t salts_idx;
10045
10046 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
10047 {
10048 salt_t *salt = db->salts_buf[salts_idx];
10049
10050 if (salt->indexes_found == salt->indexes_cnt) continue;
10051
10052 plain_init (plains);
10053
10054 md5_init_sse2 (&digests);
10055
10056 md5_update_sse2_max55 (plains, in);
10057
10058 md5_update_sse2_max55 (plains, salt->salt_plain_struct);
10059
10060 md5_final_sse2_max55 (plains, &digests);
10061
10062 transpose_md5_digest (&digests, dgst);
10063
10064 for (i = 0; i < 4; i++)
10065 {
10066 BYTESWAP (dgst[i].buf.md5[0]);
10067 BYTESWAP (dgst[i].buf.md5[1]);
10068 BYTESWAP (dgst[i].buf.md5[2]);
10069 BYTESWAP (dgst[i].buf.md5[3]);
10070
10071 uint_to_hex_lower (dgst[i].buf.md5[0], &ptrs_tmp[i][0]);
10072 uint_to_hex_lower (dgst[i].buf.md5[1], &ptrs_tmp[i][8]);
10073 uint_to_hex_lower (dgst[i].buf.md5[2], &ptrs_tmp[i][16]);
10074 uint_to_hex_lower (dgst[i].buf.md5[3], &ptrs_tmp[i][24]);
10075 }
10076
10077 plain_init (plains);
10078
10079 md5_init_sse2 (&digests);
10080
10081 md5_update_sse2_max55 (plains, salt->salt_plain_struct);
10082
10083 md5_update_sse2_max55 (plains, plains_tmp);
10084
10085 md5_final_sse2_max55 (plains, &digests);
10086
10087 transpose_md5_digest (&digests, dgst);
10088
10089 thread_parameter->indb (thread_parameter, in, dgst, salt);
10090 }
10091 }
10092
hashing_04210(thread_parameter_t * thread_parameter,plain_t * in)10093 void hashing_04210 (thread_parameter_t *thread_parameter, plain_t *in)
10094 {
10095 digest_md5_sse2_t digests;
10096
10097 digest_t dgst[4];
10098
10099 plain_t plains[4];
10100
10101 plain_t plains_tmp[4];
10102
10103 char *ptrs_tmp[4];
10104
10105 ptrs_tmp[0] = (char *) &plains_tmp[0].buf;
10106 ptrs_tmp[1] = (char *) &plains_tmp[1].buf;
10107 ptrs_tmp[2] = (char *) &plains_tmp[2].buf;
10108 ptrs_tmp[3] = (char *) &plains_tmp[3].buf;
10109
10110 db_t *db = thread_parameter->db;
10111
10112 uint32_t i;
10113
10114 for (i = 0; i < 4; i++) {
10115 ptrs_tmp[i][0] = 0;
10116
10117 plains_tmp[i].len = 1;
10118 }
10119
10120 uint32_t salts_idx;
10121
10122 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
10123 {
10124 salt_t *salt = db->salts_buf[salts_idx];
10125
10126 if (salt->indexes_found == salt->indexes_cnt) continue;
10127
10128 plain_init (plains);
10129
10130 md5_init_sse2 (&digests);
10131
10132 md5_update_sse2_max55 (plains, salt->salt_plain_struct);
10133
10134 md5_update_sse2_max55 (plains, plains_tmp);
10135
10136 md5_update_sse2_max55 (plains, in);
10137
10138 md5_final_sse2_max55 (plains, &digests);
10139
10140 transpose_md5_digest (&digests, dgst);
10141
10142 thread_parameter->indb (thread_parameter, in, dgst, salt);
10143 }
10144 }
10145
hashing_04300(thread_parameter_t * thread_parameter,plain_t * in)10146 void hashing_04300 (thread_parameter_t *thread_parameter, plain_t *in)
10147 {
10148 digest_md5_sse2_t digests;
10149
10150 digest_t dgst[4];
10151
10152 plain_t plains[4];
10153
10154 char *ptrs[4];
10155
10156 ptrs[0] = (char *) &plains[0].buf;
10157 ptrs[1] = (char *) &plains[1].buf;
10158 ptrs[2] = (char *) &plains[2].buf;
10159 ptrs[3] = (char *) &plains[3].buf;
10160
10161 db_t *db = thread_parameter->db;
10162
10163 md5_init_sse2 (&digests);
10164
10165 md5_final_sse2_max55 (in, &digests);
10166
10167 transpose_md5_digest (&digests, dgst);
10168
10169 uint32_t i;
10170
10171 for (i = 0; i < 4; i++)
10172 {
10173 BYTESWAP (dgst[i].buf.md5[0]);
10174 BYTESWAP (dgst[i].buf.md5[1]);
10175 BYTESWAP (dgst[i].buf.md5[2]);
10176 BYTESWAP (dgst[i].buf.md5[3]);
10177
10178 uint_to_hex_upper (dgst[i].buf.md5[0], &ptrs[i][0]);
10179 uint_to_hex_upper (dgst[i].buf.md5[1], &ptrs[i][8]);
10180 uint_to_hex_upper (dgst[i].buf.md5[2], &ptrs[i][16]);
10181 uint_to_hex_upper (dgst[i].buf.md5[3], &ptrs[i][24]);
10182
10183 plains[i].len = 32;
10184 }
10185
10186 md5_init_sse2 (&digests);
10187
10188 md5_final_sse2_max55 (plains, &digests);
10189
10190 transpose_md5_digest (&digests, dgst);
10191
10192 thread_parameter->indb (thread_parameter, in, dgst, db->salts_buf[0]);
10193 }
10194
hashing_04400(thread_parameter_t * thread_parameter,plain_t * in)10195 void hashing_04400 (thread_parameter_t *thread_parameter, plain_t *in)
10196 {
10197 digest_sha1_sse2_t digests_sha1;
10198
10199 digest_md5_sse2_t digests_md5;
10200
10201 digest_t dgst[4];
10202
10203 plain_t plains[4];
10204
10205 char *ptrs[4];
10206
10207 ptrs[0] = (char *) &plains[0].buf;
10208 ptrs[1] = (char *) &plains[1].buf;
10209 ptrs[2] = (char *) &plains[2].buf;
10210 ptrs[3] = (char *) &plains[3].buf;
10211
10212 db_t *db = thread_parameter->db;
10213
10214 sha1_init_sse2 (&digests_sha1);
10215
10216 sha1_final_sse2_max55 (in, &digests_sha1);
10217
10218 transpose_sha1_digest (&digests_sha1, dgst);
10219
10220 uint32_t i;
10221
10222 for (i = 0; i < 4; i++)
10223 {
10224 uint_to_hex_lower (dgst[i].buf.sha1[0], &ptrs[i][0]);
10225 uint_to_hex_lower (dgst[i].buf.sha1[1], &ptrs[i][8]);
10226 uint_to_hex_lower (dgst[i].buf.sha1[2], &ptrs[i][16]);
10227 uint_to_hex_lower (dgst[i].buf.sha1[3], &ptrs[i][24]);
10228 uint_to_hex_lower (dgst[i].buf.sha1[4], &ptrs[i][32]);
10229
10230 plains[i].len = 40;
10231 }
10232
10233 md5_init_sse2 (&digests_md5);
10234
10235 md5_final_sse2_max55 (plains, &digests_md5);
10236
10237 transpose_md5_digest (&digests_md5, dgst);
10238
10239 thread_parameter->indb (thread_parameter, in, dgst, db->salts_buf[0]);
10240 }
10241
hashing_04500(thread_parameter_t * thread_parameter,plain_t * in)10242 void hashing_04500 (thread_parameter_t *thread_parameter, plain_t *in)
10243 {
10244 digest_sha1_sse2_t digests;
10245
10246 digest_t dgst[4];
10247
10248 plain_t plains[4];
10249
10250 char *ptrs[4];
10251
10252 ptrs[0] = (char *) &plains[0].buf;
10253 ptrs[1] = (char *) &plains[1].buf;
10254 ptrs[2] = (char *) &plains[2].buf;
10255 ptrs[3] = (char *) &plains[3].buf;
10256
10257 db_t *db = thread_parameter->db;
10258
10259 sha1_init_sse2 (&digests);
10260
10261 sha1_final_sse2_max55 (in, &digests);
10262
10263 transpose_sha1_digest (&digests, dgst);
10264
10265 uint32_t i;
10266
10267 for (i = 0; i < 4; i++)
10268 {
10269 uint_to_hex_lower (dgst[i].buf.sha1[0], &ptrs[i][0]);
10270 uint_to_hex_lower (dgst[i].buf.sha1[1], &ptrs[i][8]);
10271 uint_to_hex_lower (dgst[i].buf.sha1[2], &ptrs[i][16]);
10272 uint_to_hex_lower (dgst[i].buf.sha1[3], &ptrs[i][24]);
10273 uint_to_hex_lower (dgst[i].buf.sha1[4], &ptrs[i][32]);
10274
10275 plains[i].len = 40;
10276 }
10277
10278 sha1_init_sse2 (&digests);
10279
10280 sha1_final_sse2_max55 (plains, &digests);
10281
10282 transpose_sha1_digest (&digests, dgst);
10283
10284 thread_parameter->indb (thread_parameter, in, dgst, db->salts_buf[0]);
10285 }
10286
hashing_04600(thread_parameter_t * thread_parameter,plain_t * in)10287 void hashing_04600 (thread_parameter_t *thread_parameter, plain_t *in)
10288 {
10289 digest_sha1_sse2_t digests;
10290
10291 digest_t dgst[4];
10292
10293 plain_t plains[4];
10294
10295 char *ptrs[4];
10296
10297 ptrs[0] = (char *) &plains[0].buf;
10298 ptrs[1] = (char *) &plains[1].buf;
10299 ptrs[2] = (char *) &plains[2].buf;
10300 ptrs[3] = (char *) &plains[3].buf;
10301
10302 db_t *db = thread_parameter->db;
10303
10304 sha1_init_sse2 (&digests);
10305
10306 sha1_final_sse2_max55 (in, &digests);
10307
10308 transpose_sha1_digest (&digests, dgst);
10309
10310 uint32_t i;
10311
10312 for (i = 0; i < 4; i++)
10313 {
10314 uint_to_hex_lower (dgst[i].buf.sha1[0], &ptrs[i][0]);
10315 uint_to_hex_lower (dgst[i].buf.sha1[1], &ptrs[i][8]);
10316 uint_to_hex_lower (dgst[i].buf.sha1[2], &ptrs[i][16]);
10317 uint_to_hex_lower (dgst[i].buf.sha1[3], &ptrs[i][24]);
10318 uint_to_hex_lower (dgst[i].buf.sha1[4], &ptrs[i][32]);
10319
10320 plains[i].len = 40;
10321 }
10322
10323 sha1_init_sse2 (&digests);
10324
10325 sha1_final_sse2_max55 (plains, &digests);
10326
10327 transpose_sha1_digest (&digests, dgst);
10328
10329 for (i = 0; i < 4; i++)
10330 {
10331 uint_to_hex_lower (dgst[i].buf.sha1[0], &ptrs[i][0]);
10332 uint_to_hex_lower (dgst[i].buf.sha1[1], &ptrs[i][8]);
10333 uint_to_hex_lower (dgst[i].buf.sha1[2], &ptrs[i][16]);
10334 uint_to_hex_lower (dgst[i].buf.sha1[3], &ptrs[i][24]);
10335 uint_to_hex_lower (dgst[i].buf.sha1[4], &ptrs[i][32]);
10336
10337 plains[i].len = 40;
10338 }
10339
10340 sha1_init_sse2 (&digests);
10341
10342 sha1_final_sse2_max55 (plains, &digests);
10343
10344 transpose_sha1_digest (&digests, dgst);
10345
10346 thread_parameter->indb (thread_parameter, in, dgst, db->salts_buf[0]);
10347 }
10348
hashing_04700(thread_parameter_t * thread_parameter,plain_t * in)10349 void hashing_04700 (thread_parameter_t *thread_parameter, plain_t *in)
10350 {
10351 digest_sha1_sse2_t digests_sha1;
10352
10353 digest_md5_sse2_t digests_md5;
10354
10355 digest_t dgst[4];
10356
10357 plain_t plains[4];
10358
10359 char *ptrs[4];
10360
10361 ptrs[0] = (char *) &plains[0].buf;
10362 ptrs[1] = (char *) &plains[1].buf;
10363 ptrs[2] = (char *) &plains[2].buf;
10364 ptrs[3] = (char *) &plains[3].buf;
10365
10366 db_t *db = thread_parameter->db;
10367
10368 md5_init_sse2 (&digests_md5);
10369
10370 md5_final_sse2_max55 (in, &digests_md5);
10371
10372 transpose_md5_digest (&digests_md5, dgst);
10373
10374 uint32_t i;
10375
10376 for (i = 0; i < 4; i++)
10377 {
10378 BYTESWAP (dgst[i].buf.md5[0]);
10379 BYTESWAP (dgst[i].buf.md5[1]);
10380 BYTESWAP (dgst[i].buf.md5[2]);
10381 BYTESWAP (dgst[i].buf.md5[3]);
10382
10383 uint_to_hex_lower (dgst[i].buf.md5[0], &ptrs[i][0]);
10384 uint_to_hex_lower (dgst[i].buf.md5[1], &ptrs[i][8]);
10385 uint_to_hex_lower (dgst[i].buf.md5[2], &ptrs[i][16]);
10386 uint_to_hex_lower (dgst[i].buf.md5[3], &ptrs[i][24]);
10387
10388 plains[i].len = 32;
10389 }
10390
10391 sha1_init_sse2 (&digests_sha1);
10392
10393 sha1_final_sse2_max55 (plains, &digests_sha1);
10394
10395 transpose_sha1_digest (&digests_sha1, dgst);
10396
10397 thread_parameter->indb (thread_parameter, in, dgst, db->salts_buf[0]);
10398 }
10399
hashing_04800(thread_parameter_t * thread_parameter,plain_t * in)10400 void hashing_04800 (thread_parameter_t *thread_parameter, plain_t *in)
10401 {
10402 digest_md5_sse2_t digests;
10403
10404 digest_t dgst[4];
10405
10406 plain_t plains[4];
10407
10408 plain_t plains_tmp[4];
10409
10410 char *ptrs_tmp[4];
10411
10412 ptrs_tmp[0] = (char *) &plains_tmp[0].buf;
10413 ptrs_tmp[1] = (char *) &plains_tmp[1].buf;
10414 ptrs_tmp[2] = (char *) &plains_tmp[2].buf;
10415 ptrs_tmp[3] = (char *) &plains_tmp[3].buf;
10416
10417 db_t *db = thread_parameter->db;
10418
10419 uint32_t i;
10420
10421 uint32_t salts_idx;
10422
10423 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
10424 {
10425 salt_t *salt = db->salts_buf[salts_idx];
10426
10427 if (salt->indexes_found == salt->indexes_cnt) continue;
10428
10429 for (i = 0; i < 4; i++)
10430 {
10431 ptrs_tmp[i][0] = salt->md5chap_idbyte;
10432
10433 plains_tmp[i].len = 1;
10434 }
10435
10436 plain_init (plains);
10437
10438 md5_init_sse2 (&digests);
10439
10440 md5_update_sse2_max55 (plains, plains_tmp);
10441
10442 md5_update_sse2_max55 (plains, in);
10443
10444 md5_update_sse2_max55 (plains, salt->salt_plain_struct);
10445
10446 md5_final_sse2_max55 (plains, &digests);
10447
10448 transpose_md5_digest (&digests, dgst);
10449
10450 thread_parameter->indb (thread_parameter, in, dgst, salt);
10451 }
10452 }
10453
hashing_04900(thread_parameter_t * thread_parameter,plain_t * in)10454 void hashing_04900 (thread_parameter_t *thread_parameter, plain_t *in)
10455 {
10456 digest_sha1_sse2_t digests;
10457
10458 digest_t dgst[4];
10459
10460 plain_t plains[4];
10461
10462 db_t *db = thread_parameter->db;
10463
10464 uint32_t salts_idx;
10465
10466 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
10467 {
10468 salt_t *salt = db->salts_buf[salts_idx];
10469
10470 if (salt->indexes_found == salt->indexes_cnt) continue;
10471
10472 plain_init (plains);
10473
10474 sha1_init_sse2 (&digests);
10475
10476 sha1_update_sse2_max55 (plains, salt->salt_plain_struct);
10477
10478 sha1_update_sse2_max55 (plains, in);
10479
10480 sha1_update_sse2_max55 (plains, salt->salt_plain_struct);
10481
10482 sha1_final_sse2_max55 (plains, &digests);
10483
10484 transpose_sha1_digest (&digests, dgst);
10485
10486 thread_parameter->indb (thread_parameter, in, dgst, salt);
10487 }
10488 }
10489
hashing_05000(thread_parameter_t * thread_parameter,plain_t * plains)10490 void hashing_05000 (thread_parameter_t *thread_parameter, plain_t *plains)
10491 {
10492 digest_t digests[4];
10493
10494 char *ptrs[4];
10495
10496 ptrs[0] = (char *) &plains[0].buf64;
10497 ptrs[1] = (char *) &plains[1].buf64;
10498 ptrs[2] = (char *) &plains[2].buf64;
10499 ptrs[3] = (char *) &plains[3].buf64;
10500
10501 db_t *db = thread_parameter->db;
10502
10503 uint32_t rsiz = db->salts_buf[0]->keccak_rsiz;
10504 uint32_t mdlen = db->salts_buf[0]->keccak_mdlen;
10505
10506 uint32_t i;
10507 uint32_t j;
10508
10509 for (i = 0; i < 4; i++)
10510 {
10511 ptrs[i][plains[i].len] = 1;
10512
10513 memset (ptrs[i] + plains[i].len + 1, 0, rsiz - (plains[i].len + 1));
10514
10515 ptrs[i][rsiz - 1] |= 0x80;
10516 }
10517
10518 keccak (plains, digests);
10519
10520 for (i = 0; i < 4; i++)
10521 {
10522 for (j = mdlen / 8; j < 25; j++)
10523 {
10524 digests[i].buf.keccak[j] = 0;
10525 }
10526 }
10527
10528 thread_parameter->indb (thread_parameter, plains, digests, db->salts_buf[0]);
10529 }
10530
hashing_05100(thread_parameter_t * thread_parameter,plain_t * in)10531 void hashing_05100 (thread_parameter_t *thread_parameter, plain_t *in)
10532 {
10533 digest_md5_sse2_t digests;
10534
10535 digest_t dgst[4];
10536
10537 db_t *db = thread_parameter->db;
10538
10539 md5_init_sse2 (&digests);
10540
10541 md5_final_sse2_max55 (in, &digests);
10542
10543 transpose_md5_digest (&digests, dgst);
10544
10545 uint32_t b[4];
10546
10547 b[0] = dgst[0].buf.md5[1];
10548 b[1] = dgst[1].buf.md5[1];
10549 b[2] = dgst[2].buf.md5[1];
10550 b[3] = dgst[3].buf.md5[1];
10551
10552 uint32_t c[4];
10553
10554 c[0] = dgst[0].buf.md5[2];
10555 c[1] = dgst[1].buf.md5[2];
10556 c[2] = dgst[2].buf.md5[2];
10557 c[3] = dgst[3].buf.md5[2];
10558
10559 uint32_t d[4];
10560
10561 d[0] = dgst[0].buf.md5[3];
10562 d[1] = dgst[1].buf.md5[3];
10563 d[2] = dgst[2].buf.md5[3];
10564 d[3] = dgst[3].buf.md5[3];
10565
10566 dgst[0].buf.md5[2] = 0;
10567 dgst[0].buf.md5[3] = 0;
10568 dgst[1].buf.md5[2] = 0;
10569 dgst[1].buf.md5[3] = 0;
10570 dgst[2].buf.md5[2] = 0;
10571 dgst[2].buf.md5[3] = 0;
10572 dgst[3].buf.md5[2] = 0;
10573 dgst[3].buf.md5[3] = 0;
10574
10575 // beginning
10576
10577 thread_parameter->indb (thread_parameter, in, dgst, db->salts_buf[0]);
10578
10579 // middle
10580
10581 dgst[0].buf.md5[0] = b[0];
10582 dgst[0].buf.md5[1] = c[0];
10583 dgst[1].buf.md5[0] = b[1];
10584 dgst[1].buf.md5[1] = c[1];
10585 dgst[2].buf.md5[0] = b[2];
10586 dgst[2].buf.md5[1] = c[2];
10587 dgst[3].buf.md5[0] = b[3];
10588 dgst[3].buf.md5[1] = c[3];
10589
10590 thread_parameter->indb (thread_parameter, in, dgst, db->salts_buf[0]);
10591
10592 // end
10593
10594 dgst[0].buf.md5[0] = c[0];
10595 dgst[0].buf.md5[1] = d[0];
10596 dgst[1].buf.md5[0] = c[1];
10597 dgst[1].buf.md5[1] = d[1];
10598 dgst[2].buf.md5[0] = c[2];
10599 dgst[2].buf.md5[1] = d[2];
10600 dgst[3].buf.md5[0] = c[3];
10601 dgst[3].buf.md5[1] = d[3];
10602
10603 thread_parameter->indb (thread_parameter, in, dgst, db->salts_buf[0]);
10604 }
10605
hashing_05200(thread_parameter_t * thread_parameter,plain_t * in)10606 void hashing_05200 (thread_parameter_t *thread_parameter, plain_t *in)
10607 {
10608 digest_sha256_sse2_t digests;
10609
10610 digest_t dgst[4];
10611
10612 plain_t plains[4];
10613
10614 db_t *db = thread_parameter->db;
10615
10616 uint32_t salts_idx;
10617
10618 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
10619 {
10620 salt_t *salt = db->salts_buf[salts_idx];
10621
10622 if (salt->indexes_found == salt->indexes_cnt) continue;
10623
10624 plain_init (plains);
10625
10626 sha256_init_sse2 (&digests);
10627
10628 sha256_update_sse2_max55 (plains, in);
10629
10630 sha256_update_sse2_max55 (plains, salt->salt_plain_struct);
10631
10632 sha256_final_sse2_max55 (plains, &digests);
10633
10634 transpose_sha256_digest (&digests, dgst);
10635
10636 uint32_t i;
10637
10638 for (i = 0; i < 4; i++)
10639 {
10640 BYTESWAP (dgst[i].buf.sha256[0]);
10641 BYTESWAP (dgst[i].buf.sha256[1]);
10642 BYTESWAP (dgst[i].buf.sha256[2]);
10643 BYTESWAP (dgst[i].buf.sha256[3]);
10644 BYTESWAP (dgst[i].buf.sha256[4]);
10645 BYTESWAP (dgst[i].buf.sha256[5]);
10646 BYTESWAP (dgst[i].buf.sha256[6]);
10647 BYTESWAP (dgst[i].buf.sha256[7]);
10648 }
10649
10650 uint32_t iter;
10651
10652 for (iter = 0; iter < salt->iterations + 1; iter++)
10653 {
10654 for (i = 0; i < 4; i++)
10655 {
10656 plains[i].buf[ 0] = dgst[i].buf.sha256[0];
10657 plains[i].buf[ 1] = dgst[i].buf.sha256[1];
10658 plains[i].buf[ 2] = dgst[i].buf.sha256[2];
10659 plains[i].buf[ 3] = dgst[i].buf.sha256[3];
10660 plains[i].buf[ 4] = dgst[i].buf.sha256[4];
10661 plains[i].buf[ 5] = dgst[i].buf.sha256[5];
10662 plains[i].buf[ 6] = dgst[i].buf.sha256[6];
10663 plains[i].buf[ 7] = dgst[i].buf.sha256[7];
10664
10665 plains[i].len = 32;
10666 }
10667
10668 sha256_init_sse2 (&digests);
10669
10670 sha256_final_sse2_max55 (plains, &digests);
10671
10672 transpose_sha256_digest (&digests, dgst);
10673
10674 for (i = 0; i < 4; i++)
10675 {
10676 BYTESWAP (dgst[i].buf.sha256[0]);
10677 BYTESWAP (dgst[i].buf.sha256[1]);
10678 BYTESWAP (dgst[i].buf.sha256[2]);
10679 BYTESWAP (dgst[i].buf.sha256[3]);
10680 BYTESWAP (dgst[i].buf.sha256[4]);
10681 BYTESWAP (dgst[i].buf.sha256[5]);
10682 BYTESWAP (dgst[i].buf.sha256[6]);
10683 BYTESWAP (dgst[i].buf.sha256[7]);
10684 }
10685 }
10686
10687 thread_parameter->indb (thread_parameter, in, dgst, salt);
10688 }
10689 }
10690
hashing_05300(thread_parameter_t * thread_parameter,plain_t * plains)10691 void hashing_05300 (thread_parameter_t *thread_parameter, plain_t *plains)
10692 {
10693 digest_t digests[4];
10694
10695 db_t *db = thread_parameter->db;
10696
10697 uint32_t i;
10698 uint32_t j;
10699
10700 uint32_t salts_idx;
10701
10702 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
10703 {
10704 salt_t *salt = db->salts_buf[salts_idx];
10705
10706 if (salt->indexes_found == salt->indexes_cnt) continue;
10707
10708 uint32_t ipad_dgst[4][4] __attribute__ ((aligned (16)));
10709 uint32_t opad_dgst[4][4] __attribute__ ((aligned (16)));
10710
10711 uint32_t ipad_buf[16][4] __attribute__ ((aligned (16)));
10712 uint32_t opad_buf[16][4] __attribute__ ((aligned (16)));
10713
10714 uint32_t ipad_dgst_tmp[4][4] __attribute__ ((aligned (16)));
10715 uint32_t opad_dgst_tmp[4][4] __attribute__ ((aligned (16)));
10716
10717 /**
10718 * NR part
10719 */
10720
10721 for (i = 0; i < 4; i++)
10722 {
10723 for (j = 0; j < 16; j++)
10724 {
10725 ipad_buf[j][i] = 0x36363636 ^ plains[i].buf[j];
10726 opad_buf[j][i] = 0x5c5c5c5c ^ plains[i].buf[j];
10727 }
10728
10729 ipad_dgst[0][i] = MD5M_A;
10730 ipad_dgst[1][i] = MD5M_B;
10731 ipad_dgst[2][i] = MD5M_C;
10732 ipad_dgst[3][i] = MD5M_D;
10733
10734 opad_dgst[0][i] = MD5M_A;
10735 opad_dgst[1][i] = MD5M_B;
10736 opad_dgst[2][i] = MD5M_C;
10737 opad_dgst[3][i] = MD5M_D;
10738 }
10739
10740 hashcat_md5_64 ((__m128i *) ipad_dgst, (__m128i *) ipad_buf);
10741 hashcat_md5_64 ((__m128i *) opad_dgst, (__m128i *) opad_buf);
10742
10743 for (i = 0; i < 4; i++)
10744 {
10745 for (j = 0; j < 4; j++)
10746 {
10747 ipad_dgst_tmp[j][i] = ipad_dgst[j][i];
10748 opad_dgst_tmp[j][i] = opad_dgst[j][i];
10749 }
10750 }
10751
10752 for (i = 0; i < 4; i++)
10753 {
10754 for (j = 0; j < 14; j++)
10755 {
10756 ipad_buf[j][i] = salt->ikepsk->nr_buf[j];
10757 }
10758
10759 ipad_buf[14][i] = (64 + salt->ikepsk->nr_len) * 8;
10760 ipad_buf[15][i] = 0;
10761 }
10762
10763 hashcat_md5_64 ((__m128i *) ipad_dgst_tmp, (__m128i *) ipad_buf);
10764
10765 for (i = 0; i < 4; i++)
10766 {
10767 for (j = 0; j < 4; j++)
10768 {
10769 opad_buf[j][i] = ipad_dgst_tmp[j][i];
10770 }
10771
10772 opad_buf[ 4][i] = 0x80;
10773 opad_buf[ 5][i] = 0;
10774 opad_buf[ 6][i] = 0;
10775 opad_buf[ 7][i] = 0;
10776 opad_buf[ 8][i] = 0;
10777 opad_buf[ 9][i] = 0;
10778 opad_buf[10][i] = 0;
10779 opad_buf[11][i] = 0;
10780 opad_buf[12][i] = 0;
10781 opad_buf[13][i] = 0;
10782 opad_buf[14][i] = (64 + 16) * 8;
10783 opad_buf[15][i] = 0;
10784 }
10785
10786 hashcat_md5_64 ((__m128i *) opad_dgst_tmp, (__m128i *) opad_buf);
10787
10788 for (i = 0; i < 4; i++)
10789 {
10790 for (j = 0; j < 4; j++)
10791 {
10792 digests[i].buf.md5[j] = opad_dgst_tmp[j][i];
10793 }
10794 }
10795
10796 /**
10797 * MSG part
10798 */
10799
10800 for (i = 0; i < 4; i++)
10801 {
10802 for (j = 0; j < 16; j++)
10803 {
10804 ipad_buf[j][i] = 0x36363636;
10805 opad_buf[j][i] = 0x5c5c5c5c;
10806 }
10807
10808 ipad_buf[0][i] ^= digests[i].buf.md5[0];
10809 ipad_buf[1][i] ^= digests[i].buf.md5[1];
10810 ipad_buf[2][i] ^= digests[i].buf.md5[2];
10811 ipad_buf[3][i] ^= digests[i].buf.md5[3];
10812
10813 opad_buf[0][i] ^= digests[i].buf.md5[0];
10814 opad_buf[1][i] ^= digests[i].buf.md5[1];
10815 opad_buf[2][i] ^= digests[i].buf.md5[2];
10816 opad_buf[3][i] ^= digests[i].buf.md5[3];
10817
10818 ipad_dgst[0][i] = MD5M_A;
10819 ipad_dgst[1][i] = MD5M_B;
10820 ipad_dgst[2][i] = MD5M_C;
10821 ipad_dgst[3][i] = MD5M_D;
10822
10823 opad_dgst[0][i] = MD5M_A;
10824 opad_dgst[1][i] = MD5M_B;
10825 opad_dgst[2][i] = MD5M_C;
10826 opad_dgst[3][i] = MD5M_D;
10827 }
10828
10829 hashcat_md5_64 ((__m128i *) ipad_dgst, (__m128i *) ipad_buf);
10830 hashcat_md5_64 ((__m128i *) opad_dgst, (__m128i *) opad_buf);
10831
10832 for (i = 0; i < 4; i++)
10833 {
10834 for (j = 0; j < 4; j++)
10835 {
10836 ipad_dgst_tmp[j][i] = ipad_dgst[j][i];
10837 opad_dgst_tmp[j][i] = opad_dgst[j][i];
10838 }
10839 }
10840
10841 int left;
10842 int off;
10843
10844 for (left = salt->ikepsk->msg_len, off = 0; left >= 56; left -= 64, off += 16)
10845 {
10846 for (i = 0; i < 4; i++)
10847 {
10848 for (j = 0; j < 16; j++)
10849 {
10850 ipad_buf[j][i] = salt->ikepsk->msg_buf[off + j];
10851 }
10852 }
10853
10854 hashcat_md5_64 ((__m128i *) ipad_dgst_tmp, (__m128i *) ipad_buf);
10855 }
10856
10857 for (i = 0; i < 4; i++)
10858 {
10859 for (j = 0; j < 14; j++)
10860 {
10861 ipad_buf[j][i] = salt->ikepsk->msg_buf[off + j];
10862 }
10863
10864 ipad_buf[14][i] = (64 + salt->ikepsk->msg_len) * 8;
10865 ipad_buf[15][i] = 0;
10866 }
10867
10868 hashcat_md5_64 ((__m128i *) ipad_dgst_tmp, (__m128i *) ipad_buf);
10869
10870 for (i = 0; i < 4; i++)
10871 {
10872 for (j = 0; j < 4; j++)
10873 {
10874 opad_buf[j][i] = ipad_dgst_tmp[j][i];
10875 }
10876
10877 opad_buf[ 4][i] = 0x80;
10878 opad_buf[ 5][i] = 0;
10879 opad_buf[ 6][i] = 0;
10880 opad_buf[ 7][i] = 0;
10881 opad_buf[ 8][i] = 0;
10882 opad_buf[ 9][i] = 0;
10883 opad_buf[10][i] = 0;
10884 opad_buf[11][i] = 0;
10885 opad_buf[12][i] = 0;
10886 opad_buf[13][i] = 0;
10887 opad_buf[14][i] = (64 + 16) * 8;
10888 opad_buf[15][i] = 0;
10889 }
10890
10891 hashcat_md5_64 ((__m128i *) opad_dgst_tmp, (__m128i *) opad_buf);
10892
10893 for (i = 0; i < 4; i++)
10894 {
10895 for (j = 0; j < 4; j++)
10896 {
10897 digests[i].buf.md5[j] = opad_dgst_tmp[j][i];
10898 }
10899 }
10900
10901 thread_parameter->indb (thread_parameter, plains, digests, salt);
10902 }
10903 }
10904
hashing_05400(thread_parameter_t * thread_parameter,plain_t * plains)10905 void hashing_05400 (thread_parameter_t *thread_parameter, plain_t *plains)
10906 {
10907 digest_t digests[4];
10908
10909 db_t *db = thread_parameter->db;
10910
10911 uint32_t i;
10912 uint32_t j;
10913 uint32_t l;
10914
10915 uint32_t salts_idx;
10916
10917 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
10918 {
10919 salt_t *salt = db->salts_buf[salts_idx];
10920
10921 if (salt->indexes_found == salt->indexes_cnt) continue;
10922
10923 uint32_t ipad_dgst[5][4] __attribute__ ((aligned (16)));
10924 uint32_t opad_dgst[5][4] __attribute__ ((aligned (16)));
10925
10926 uint32_t ipad_buf[16][4] __attribute__ ((aligned (16)));
10927 uint32_t opad_buf[16][4] __attribute__ ((aligned (16)));
10928
10929 uint32_t ipad_dgst_tmp[5][4] __attribute__ ((aligned (16)));
10930 uint32_t opad_dgst_tmp[5][4] __attribute__ ((aligned (16)));
10931
10932 /**
10933 * NR part
10934 */
10935
10936 for (i = 0; i < 4; i++)
10937 {
10938 for (j = 0; j < 16; j++)
10939 {
10940 ipad_buf[j][i] = 0x36363636 ^ plains[i].buf[j];
10941 opad_buf[j][i] = 0x5c5c5c5c ^ plains[i].buf[j];
10942 }
10943
10944 ipad_dgst[0][i] = SHA1M_A;
10945 ipad_dgst[1][i] = SHA1M_B;
10946 ipad_dgst[2][i] = SHA1M_C;
10947 ipad_dgst[3][i] = SHA1M_D;
10948 ipad_dgst[4][i] = SHA1M_E;
10949
10950 opad_dgst[0][i] = SHA1M_A;
10951 opad_dgst[1][i] = SHA1M_B;
10952 opad_dgst[2][i] = SHA1M_C;
10953 opad_dgst[3][i] = SHA1M_D;
10954 opad_dgst[4][i] = SHA1M_E;
10955 }
10956
10957 hashcat_sha1_64 ((__m128i *) ipad_dgst, (__m128i *) ipad_buf);
10958 hashcat_sha1_64 ((__m128i *) opad_dgst, (__m128i *) opad_buf);
10959
10960 for (i = 0; i < 4; i++)
10961 {
10962 for (j = 0; j < 5; j++)
10963 {
10964 ipad_dgst_tmp[j][i] = ipad_dgst[j][i];
10965 opad_dgst_tmp[j][i] = opad_dgst[j][i];
10966 }
10967 }
10968
10969 for (i = 0; i < 4; i++)
10970 {
10971 for (j = 0; j < 14; j++) ipad_buf[j][i] = salt->ikepsk->nr_buf[j];
10972
10973 ipad_buf[14][i] = 0;
10974 ipad_buf[15][i] = (64 + salt->ikepsk->nr_len) * 8;
10975 }
10976
10977 for (i = 14; i < 16; i++) for (l = 0; l < 4; l++) BYTESWAP (ipad_buf[i][l]);
10978
10979 hashcat_sha1_64 ((__m128i *) ipad_dgst_tmp, (__m128i *) ipad_buf);
10980
10981 for (i = 0; i < 4; i++)
10982 {
10983 for (j = 0; j < 5; j++) opad_buf[j][i] = ipad_dgst_tmp[j][i];
10984
10985 opad_buf[ 5][i] = 0x80000000;
10986 opad_buf[ 6][i] = 0;
10987 opad_buf[ 7][i] = 0;
10988 opad_buf[ 8][i] = 0;
10989 opad_buf[ 9][i] = 0;
10990 opad_buf[10][i] = 0;
10991 opad_buf[11][i] = 0;
10992 opad_buf[12][i] = 0;
10993 opad_buf[13][i] = 0;
10994 opad_buf[14][i] = 0;
10995 opad_buf[15][i] = (64 + 20) * 8;
10996 }
10997
10998 for (i = 0; i < 16; i++) for (l = 0; l < 4; l++) BYTESWAP (opad_buf[i][l]);
10999
11000 hashcat_sha1_64 ((__m128i *) opad_dgst_tmp, (__m128i *) opad_buf);
11001
11002 for (i = 0; i < 4; i++)
11003 {
11004 for (j = 0; j < 5; j++)
11005 {
11006 digests[i].buf.sha1[j] = opad_dgst_tmp[j][i];
11007 }
11008 }
11009
11010 /**
11011 * MSG part
11012 */
11013
11014 for (i = 0; i < 4; i++)
11015 {
11016 for (j = 0; j < 16; j++)
11017 {
11018 ipad_buf[j][i] = 0x36363636;
11019 opad_buf[j][i] = 0x5c5c5c5c;
11020
11021 BYTESWAP (ipad_buf[j][i]);
11022 BYTESWAP (opad_buf[j][i]);
11023 }
11024
11025 ipad_buf[0][i] ^= digests[i].buf.sha1[0];
11026 ipad_buf[1][i] ^= digests[i].buf.sha1[1];
11027 ipad_buf[2][i] ^= digests[i].buf.sha1[2];
11028 ipad_buf[3][i] ^= digests[i].buf.sha1[3];
11029 ipad_buf[4][i] ^= digests[i].buf.sha1[4];
11030
11031 opad_buf[0][i] ^= digests[i].buf.sha1[0];
11032 opad_buf[1][i] ^= digests[i].buf.sha1[1];
11033 opad_buf[2][i] ^= digests[i].buf.sha1[2];
11034 opad_buf[3][i] ^= digests[i].buf.sha1[3];
11035 opad_buf[4][i] ^= digests[i].buf.sha1[4];
11036
11037 ipad_dgst[0][i] = SHA1M_A;
11038 ipad_dgst[1][i] = SHA1M_B;
11039 ipad_dgst[2][i] = SHA1M_C;
11040 ipad_dgst[3][i] = SHA1M_D;
11041 ipad_dgst[4][i] = SHA1M_E;
11042
11043 opad_dgst[0][i] = SHA1M_A;
11044 opad_dgst[1][i] = SHA1M_B;
11045 opad_dgst[2][i] = SHA1M_C;
11046 opad_dgst[3][i] = SHA1M_D;
11047 opad_dgst[4][i] = SHA1M_E;
11048 }
11049
11050 for (i = 0; i < 16; i++) for (l = 0; l < 4; l++) BYTESWAP (ipad_buf[i][l]);
11051 for (i = 0; i < 16; i++) for (l = 0; l < 4; l++) BYTESWAP (opad_buf[i][l]);
11052
11053 hashcat_sha1_64 ((__m128i *) ipad_dgst, (__m128i *) ipad_buf);
11054 hashcat_sha1_64 ((__m128i *) opad_dgst, (__m128i *) opad_buf);
11055
11056 for (i = 0; i < 4; i++)
11057 {
11058 for (j = 0; j < 5; j++)
11059 {
11060 ipad_dgst_tmp[j][i] = ipad_dgst[j][i];
11061 opad_dgst_tmp[j][i] = opad_dgst[j][i];
11062 }
11063 }
11064
11065 int left;
11066 int off;
11067
11068 for (left = salt->ikepsk->msg_len, off = 0; left >= 56; left -= 64, off += 16)
11069 {
11070 for (i = 0; i < 4; i++)
11071 {
11072 for (j = 0; j < 16; j++)
11073 {
11074 ipad_buf[j][i] = salt->ikepsk->msg_buf[off + j];
11075 }
11076 }
11077
11078 hashcat_sha1_64 ((__m128i *) ipad_dgst_tmp, (__m128i *) ipad_buf);
11079 }
11080
11081 for (i = 0; i < 4; i++)
11082 {
11083 for (j = 0; j < 14; j++) ipad_buf[j][i] = salt->ikepsk->msg_buf[off + j];
11084
11085 ipad_buf[14][i] = 0;
11086 ipad_buf[15][i] = (64 + salt->ikepsk->msg_len) * 8;
11087 }
11088
11089 for (i = 14; i < 16; i++) for (l = 0; l < 4; l++) BYTESWAP (ipad_buf[i][l]);
11090
11091 hashcat_sha1_64 ((__m128i *) ipad_dgst_tmp, (__m128i *) ipad_buf);
11092
11093 for (i = 0; i < 4; i++)
11094 {
11095 for (j = 0; j < 5; j++) opad_buf[j][i] = ipad_dgst_tmp[j][i];
11096
11097 opad_buf[ 5][i] = 0x80000000;
11098 opad_buf[ 6][i] = 0;
11099 opad_buf[ 7][i] = 0;
11100 opad_buf[ 8][i] = 0;
11101 opad_buf[ 9][i] = 0;
11102 opad_buf[10][i] = 0;
11103 opad_buf[11][i] = 0;
11104 opad_buf[12][i] = 0;
11105 opad_buf[13][i] = 0;
11106 opad_buf[14][i] = 0;
11107 opad_buf[15][i] = (64 + 20) * 8;
11108 }
11109
11110 for (i = 0; i < 16; i++) for (l = 0; l < 4; l++) BYTESWAP (opad_buf[i][l]);
11111
11112 hashcat_sha1_64 ((__m128i *) opad_dgst_tmp, (__m128i *) opad_buf);
11113
11114 for (i = 0; i < 4; i++)
11115 {
11116 for (j = 0; j < 5; j++)
11117 {
11118 digests[i].buf.sha1[j] = opad_dgst_tmp[j][i];
11119 }
11120 }
11121
11122 thread_parameter->indb (thread_parameter, plains, digests, salt);
11123 }
11124 }
11125
hashing_05500(thread_parameter_t * thread_parameter,plain_t * in)11126 void hashing_05500 (thread_parameter_t *thread_parameter, plain_t *in)
11127 {
11128 static const uint32_t c_SPtrans[8][64] =
11129 {
11130 {
11131 /* nibble 0 */
11132 0x02080800, 0x00080000, 0x02000002, 0x02080802,
11133 0x02000000, 0x00080802, 0x00080002, 0x02000002,
11134 0x00080802, 0x02080800, 0x02080000, 0x00000802,
11135 0x02000802, 0x02000000, 0x00000000, 0x00080002,
11136 0x00080000, 0x00000002, 0x02000800, 0x00080800,
11137 0x02080802, 0x02080000, 0x00000802, 0x02000800,
11138 0x00000002, 0x00000800, 0x00080800, 0x02080002,
11139 0x00000800, 0x02000802, 0x02080002, 0x00000000,
11140 0x00000000, 0x02080802, 0x02000800, 0x00080002,
11141 0x02080800, 0x00080000, 0x00000802, 0x02000800,
11142 0x02080002, 0x00000800, 0x00080800, 0x02000002,
11143 0x00080802, 0x00000002, 0x02000002, 0x02080000,
11144 0x02080802, 0x00080800, 0x02080000, 0x02000802,
11145 0x02000000, 0x00000802, 0x00080002, 0x00000000,
11146 0x00080000, 0x02000000, 0x02000802, 0x02080800,
11147 0x00000002, 0x02080002, 0x00000800, 0x00080802,
11148 },
11149 {
11150 /* nibble 1 */
11151 0x40108010, 0x00000000, 0x00108000, 0x40100000,
11152 0x40000010, 0x00008010, 0x40008000, 0x00108000,
11153 0x00008000, 0x40100010, 0x00000010, 0x40008000,
11154 0x00100010, 0x40108000, 0x40100000, 0x00000010,
11155 0x00100000, 0x40008010, 0x40100010, 0x00008000,
11156 0x00108010, 0x40000000, 0x00000000, 0x00100010,
11157 0x40008010, 0x00108010, 0x40108000, 0x40000010,
11158 0x40000000, 0x00100000, 0x00008010, 0x40108010,
11159 0x00100010, 0x40108000, 0x40008000, 0x00108010,
11160 0x40108010, 0x00100010, 0x40000010, 0x00000000,
11161 0x40000000, 0x00008010, 0x00100000, 0x40100010,
11162 0x00008000, 0x40000000, 0x00108010, 0x40008010,
11163 0x40108000, 0x00008000, 0x00000000, 0x40000010,
11164 0x00000010, 0x40108010, 0x00108000, 0x40100000,
11165 0x40100010, 0x00100000, 0x00008010, 0x40008000,
11166 0x40008010, 0x00000010, 0x40100000, 0x00108000,
11167 },
11168 {
11169 /* nibble 2 */
11170 0x04000001, 0x04040100, 0x00000100, 0x04000101,
11171 0x00040001, 0x04000000, 0x04000101, 0x00040100,
11172 0x04000100, 0x00040000, 0x04040000, 0x00000001,
11173 0x04040101, 0x00000101, 0x00000001, 0x04040001,
11174 0x00000000, 0x00040001, 0x04040100, 0x00000100,
11175 0x00000101, 0x04040101, 0x00040000, 0x04000001,
11176 0x04040001, 0x04000100, 0x00040101, 0x04040000,
11177 0x00040100, 0x00000000, 0x04000000, 0x00040101,
11178 0x04040100, 0x00000100, 0x00000001, 0x00040000,
11179 0x00000101, 0x00040001, 0x04040000, 0x04000101,
11180 0x00000000, 0x04040100, 0x00040100, 0x04040001,
11181 0x00040001, 0x04000000, 0x04040101, 0x00000001,
11182 0x00040101, 0x04000001, 0x04000000, 0x04040101,
11183 0x00040000, 0x04000100, 0x04000101, 0x00040100,
11184 0x04000100, 0x00000000, 0x04040001, 0x00000101,
11185 0x04000001, 0x00040101, 0x00000100, 0x04040000,
11186 },
11187 {
11188 /* nibble 3 */
11189 0x00401008, 0x10001000, 0x00000008, 0x10401008,
11190 0x00000000, 0x10400000, 0x10001008, 0x00400008,
11191 0x10401000, 0x10000008, 0x10000000, 0x00001008,
11192 0x10000008, 0x00401008, 0x00400000, 0x10000000,
11193 0x10400008, 0x00401000, 0x00001000, 0x00000008,
11194 0x00401000, 0x10001008, 0x10400000, 0x00001000,
11195 0x00001008, 0x00000000, 0x00400008, 0x10401000,
11196 0x10001000, 0x10400008, 0x10401008, 0x00400000,
11197 0x10400008, 0x00001008, 0x00400000, 0x10000008,
11198 0x00401000, 0x10001000, 0x00000008, 0x10400000,
11199 0x10001008, 0x00000000, 0x00001000, 0x00400008,
11200 0x00000000, 0x10400008, 0x10401000, 0x00001000,
11201 0x10000000, 0x10401008, 0x00401008, 0x00400000,
11202 0x10401008, 0x00000008, 0x10001000, 0x00401008,
11203 0x00400008, 0x00401000, 0x10400000, 0x10001008,
11204 0x00001008, 0x10000000, 0x10000008, 0x10401000,
11205 },
11206 {
11207 /* nibble 4 */
11208 0x08000000, 0x00010000, 0x00000400, 0x08010420,
11209 0x08010020, 0x08000400, 0x00010420, 0x08010000,
11210 0x00010000, 0x00000020, 0x08000020, 0x00010400,
11211 0x08000420, 0x08010020, 0x08010400, 0x00000000,
11212 0x00010400, 0x08000000, 0x00010020, 0x00000420,
11213 0x08000400, 0x00010420, 0x00000000, 0x08000020,
11214 0x00000020, 0x08000420, 0x08010420, 0x00010020,
11215 0x08010000, 0x00000400, 0x00000420, 0x08010400,
11216 0x08010400, 0x08000420, 0x00010020, 0x08010000,
11217 0x00010000, 0x00000020, 0x08000020, 0x08000400,
11218 0x08000000, 0x00010400, 0x08010420, 0x00000000,
11219 0x00010420, 0x08000000, 0x00000400, 0x00010020,
11220 0x08000420, 0x00000400, 0x00000000, 0x08010420,
11221 0x08010020, 0x08010400, 0x00000420, 0x00010000,
11222 0x00010400, 0x08010020, 0x08000400, 0x00000420,
11223 0x00000020, 0x00010420, 0x08010000, 0x08000020,
11224 },
11225 {
11226 /* nibble 5 */
11227 0x80000040, 0x00200040, 0x00000000, 0x80202000,
11228 0x00200040, 0x00002000, 0x80002040, 0x00200000,
11229 0x00002040, 0x80202040, 0x00202000, 0x80000000,
11230 0x80002000, 0x80000040, 0x80200000, 0x00202040,
11231 0x00200000, 0x80002040, 0x80200040, 0x00000000,
11232 0x00002000, 0x00000040, 0x80202000, 0x80200040,
11233 0x80202040, 0x80200000, 0x80000000, 0x00002040,
11234 0x00000040, 0x00202000, 0x00202040, 0x80002000,
11235 0x00002040, 0x80000000, 0x80002000, 0x00202040,
11236 0x80202000, 0x00200040, 0x00000000, 0x80002000,
11237 0x80000000, 0x00002000, 0x80200040, 0x00200000,
11238 0x00200040, 0x80202040, 0x00202000, 0x00000040,
11239 0x80202040, 0x00202000, 0x00200000, 0x80002040,
11240 0x80000040, 0x80200000, 0x00202040, 0x00000000,
11241 0x00002000, 0x80000040, 0x80002040, 0x80202000,
11242 0x80200000, 0x00002040, 0x00000040, 0x80200040,
11243 },
11244 {
11245 /* nibble 6 */
11246 0x00004000, 0x00000200, 0x01000200, 0x01000004,
11247 0x01004204, 0x00004004, 0x00004200, 0x00000000,
11248 0x01000000, 0x01000204, 0x00000204, 0x01004000,
11249 0x00000004, 0x01004200, 0x01004000, 0x00000204,
11250 0x01000204, 0x00004000, 0x00004004, 0x01004204,
11251 0x00000000, 0x01000200, 0x01000004, 0x00004200,
11252 0x01004004, 0x00004204, 0x01004200, 0x00000004,
11253 0x00004204, 0x01004004, 0x00000200, 0x01000000,
11254 0x00004204, 0x01004000, 0x01004004, 0x00000204,
11255 0x00004000, 0x00000200, 0x01000000, 0x01004004,
11256 0x01000204, 0x00004204, 0x00004200, 0x00000000,
11257 0x00000200, 0x01000004, 0x00000004, 0x01000200,
11258 0x00000000, 0x01000204, 0x01000200, 0x00004200,
11259 0x00000204, 0x00004000, 0x01004204, 0x01000000,
11260 0x01004200, 0x00000004, 0x00004004, 0x01004204,
11261 0x01000004, 0x01004200, 0x01004000, 0x00004004,
11262 },
11263 {
11264 /* nibble 7 */
11265 0x20800080, 0x20820000, 0x00020080, 0x00000000,
11266 0x20020000, 0x00800080, 0x20800000, 0x20820080,
11267 0x00000080, 0x20000000, 0x00820000, 0x00020080,
11268 0x00820080, 0x20020080, 0x20000080, 0x20800000,
11269 0x00020000, 0x00820080, 0x00800080, 0x20020000,
11270 0x20820080, 0x20000080, 0x00000000, 0x00820000,
11271 0x20000000, 0x00800000, 0x20020080, 0x20800080,
11272 0x00800000, 0x00020000, 0x20820000, 0x00000080,
11273 0x00800000, 0x00020000, 0x20000080, 0x20820080,
11274 0x00020080, 0x20000000, 0x00000000, 0x00820000,
11275 0x20800080, 0x20020080, 0x20020000, 0x00800080,
11276 0x20820000, 0x00000080, 0x00800080, 0x20020000,
11277 0x20820080, 0x00800000, 0x20800000, 0x20000080,
11278 0x00820000, 0x00020080, 0x20020080, 0x20800000,
11279 0x00000080, 0x20820000, 0x00820080, 0x00000000,
11280 0x20000000, 0x20800080, 0x00020000, 0x00820080,
11281 },
11282 };
11283
11284 static const uint32_t c_skb[8][64] =
11285 {
11286 {
11287 /* for C bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
11288 0x00000000, 0x00000010, 0x20000000, 0x20000010,
11289 0x00010000, 0x00010010, 0x20010000, 0x20010010,
11290 0x00000800, 0x00000810, 0x20000800, 0x20000810,
11291 0x00010800, 0x00010810, 0x20010800, 0x20010810,
11292 0x00000020, 0x00000030, 0x20000020, 0x20000030,
11293 0x00010020, 0x00010030, 0x20010020, 0x20010030,
11294 0x00000820, 0x00000830, 0x20000820, 0x20000830,
11295 0x00010820, 0x00010830, 0x20010820, 0x20010830,
11296 0x00080000, 0x00080010, 0x20080000, 0x20080010,
11297 0x00090000, 0x00090010, 0x20090000, 0x20090010,
11298 0x00080800, 0x00080810, 0x20080800, 0x20080810,
11299 0x00090800, 0x00090810, 0x20090800, 0x20090810,
11300 0x00080020, 0x00080030, 0x20080020, 0x20080030,
11301 0x00090020, 0x00090030, 0x20090020, 0x20090030,
11302 0x00080820, 0x00080830, 0x20080820, 0x20080830,
11303 0x00090820, 0x00090830, 0x20090820, 0x20090830,
11304 },
11305 {
11306 /* for C bits (numbered as per FIPS 46) 7 8 10 11 12 13 */
11307 0x00000000, 0x02000000, 0x00002000, 0x02002000,
11308 0x00200000, 0x02200000, 0x00202000, 0x02202000,
11309 0x00000004, 0x02000004, 0x00002004, 0x02002004,
11310 0x00200004, 0x02200004, 0x00202004, 0x02202004,
11311 0x00000400, 0x02000400, 0x00002400, 0x02002400,
11312 0x00200400, 0x02200400, 0x00202400, 0x02202400,
11313 0x00000404, 0x02000404, 0x00002404, 0x02002404,
11314 0x00200404, 0x02200404, 0x00202404, 0x02202404,
11315 0x10000000, 0x12000000, 0x10002000, 0x12002000,
11316 0x10200000, 0x12200000, 0x10202000, 0x12202000,
11317 0x10000004, 0x12000004, 0x10002004, 0x12002004,
11318 0x10200004, 0x12200004, 0x10202004, 0x12202004,
11319 0x10000400, 0x12000400, 0x10002400, 0x12002400,
11320 0x10200400, 0x12200400, 0x10202400, 0x12202400,
11321 0x10000404, 0x12000404, 0x10002404, 0x12002404,
11322 0x10200404, 0x12200404, 0x10202404, 0x12202404,
11323 },
11324 {
11325 /* for C bits (numbered as per FIPS 46) 14 15 16 17 19 20 */
11326 0x00000000, 0x00000001, 0x00040000, 0x00040001,
11327 0x01000000, 0x01000001, 0x01040000, 0x01040001,
11328 0x00000002, 0x00000003, 0x00040002, 0x00040003,
11329 0x01000002, 0x01000003, 0x01040002, 0x01040003,
11330 0x00000200, 0x00000201, 0x00040200, 0x00040201,
11331 0x01000200, 0x01000201, 0x01040200, 0x01040201,
11332 0x00000202, 0x00000203, 0x00040202, 0x00040203,
11333 0x01000202, 0x01000203, 0x01040202, 0x01040203,
11334 0x08000000, 0x08000001, 0x08040000, 0x08040001,
11335 0x09000000, 0x09000001, 0x09040000, 0x09040001,
11336 0x08000002, 0x08000003, 0x08040002, 0x08040003,
11337 0x09000002, 0x09000003, 0x09040002, 0x09040003,
11338 0x08000200, 0x08000201, 0x08040200, 0x08040201,
11339 0x09000200, 0x09000201, 0x09040200, 0x09040201,
11340 0x08000202, 0x08000203, 0x08040202, 0x08040203,
11341 0x09000202, 0x09000203, 0x09040202, 0x09040203,
11342 },
11343 {
11344 /* for C bits (numbered as per FIPS 46) 21 23 24 26 27 28 */
11345 0x00000000, 0x00100000, 0x00000100, 0x00100100,
11346 0x00000008, 0x00100008, 0x00000108, 0x00100108,
11347 0x00001000, 0x00101000, 0x00001100, 0x00101100,
11348 0x00001008, 0x00101008, 0x00001108, 0x00101108,
11349 0x04000000, 0x04100000, 0x04000100, 0x04100100,
11350 0x04000008, 0x04100008, 0x04000108, 0x04100108,
11351 0x04001000, 0x04101000, 0x04001100, 0x04101100,
11352 0x04001008, 0x04101008, 0x04001108, 0x04101108,
11353 0x00020000, 0x00120000, 0x00020100, 0x00120100,
11354 0x00020008, 0x00120008, 0x00020108, 0x00120108,
11355 0x00021000, 0x00121000, 0x00021100, 0x00121100,
11356 0x00021008, 0x00121008, 0x00021108, 0x00121108,
11357 0x04020000, 0x04120000, 0x04020100, 0x04120100,
11358 0x04020008, 0x04120008, 0x04020108, 0x04120108,
11359 0x04021000, 0x04121000, 0x04021100, 0x04121100,
11360 0x04021008, 0x04121008, 0x04021108, 0x04121108,
11361 },
11362 {
11363 /* for D bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
11364 0x00000000, 0x10000000, 0x00010000, 0x10010000,
11365 0x00000004, 0x10000004, 0x00010004, 0x10010004,
11366 0x20000000, 0x30000000, 0x20010000, 0x30010000,
11367 0x20000004, 0x30000004, 0x20010004, 0x30010004,
11368 0x00100000, 0x10100000, 0x00110000, 0x10110000,
11369 0x00100004, 0x10100004, 0x00110004, 0x10110004,
11370 0x20100000, 0x30100000, 0x20110000, 0x30110000,
11371 0x20100004, 0x30100004, 0x20110004, 0x30110004,
11372 0x00001000, 0x10001000, 0x00011000, 0x10011000,
11373 0x00001004, 0x10001004, 0x00011004, 0x10011004,
11374 0x20001000, 0x30001000, 0x20011000, 0x30011000,
11375 0x20001004, 0x30001004, 0x20011004, 0x30011004,
11376 0x00101000, 0x10101000, 0x00111000, 0x10111000,
11377 0x00101004, 0x10101004, 0x00111004, 0x10111004,
11378 0x20101000, 0x30101000, 0x20111000, 0x30111000,
11379 0x20101004, 0x30101004, 0x20111004, 0x30111004,
11380 },
11381 {
11382 /* for D bits (numbered as per FIPS 46) 8 9 11 12 13 14 */
11383 0x00000000, 0x08000000, 0x00000008, 0x08000008,
11384 0x00000400, 0x08000400, 0x00000408, 0x08000408,
11385 0x00020000, 0x08020000, 0x00020008, 0x08020008,
11386 0x00020400, 0x08020400, 0x00020408, 0x08020408,
11387 0x00000001, 0x08000001, 0x00000009, 0x08000009,
11388 0x00000401, 0x08000401, 0x00000409, 0x08000409,
11389 0x00020001, 0x08020001, 0x00020009, 0x08020009,
11390 0x00020401, 0x08020401, 0x00020409, 0x08020409,
11391 0x02000000, 0x0A000000, 0x02000008, 0x0A000008,
11392 0x02000400, 0x0A000400, 0x02000408, 0x0A000408,
11393 0x02020000, 0x0A020000, 0x02020008, 0x0A020008,
11394 0x02020400, 0x0A020400, 0x02020408, 0x0A020408,
11395 0x02000001, 0x0A000001, 0x02000009, 0x0A000009,
11396 0x02000401, 0x0A000401, 0x02000409, 0x0A000409,
11397 0x02020001, 0x0A020001, 0x02020009, 0x0A020009,
11398 0x02020401, 0x0A020401, 0x02020409, 0x0A020409,
11399 },
11400 {
11401 /* for D bits (numbered as per FIPS 46) 16 17 18 19 20 21 */
11402 0x00000000, 0x00000100, 0x00080000, 0x00080100,
11403 0x01000000, 0x01000100, 0x01080000, 0x01080100,
11404 0x00000010, 0x00000110, 0x00080010, 0x00080110,
11405 0x01000010, 0x01000110, 0x01080010, 0x01080110,
11406 0x00200000, 0x00200100, 0x00280000, 0x00280100,
11407 0x01200000, 0x01200100, 0x01280000, 0x01280100,
11408 0x00200010, 0x00200110, 0x00280010, 0x00280110,
11409 0x01200010, 0x01200110, 0x01280010, 0x01280110,
11410 0x00000200, 0x00000300, 0x00080200, 0x00080300,
11411 0x01000200, 0x01000300, 0x01080200, 0x01080300,
11412 0x00000210, 0x00000310, 0x00080210, 0x00080310,
11413 0x01000210, 0x01000310, 0x01080210, 0x01080310,
11414 0x00200200, 0x00200300, 0x00280200, 0x00280300,
11415 0x01200200, 0x01200300, 0x01280200, 0x01280300,
11416 0x00200210, 0x00200310, 0x00280210, 0x00280310,
11417 0x01200210, 0x01200310, 0x01280210, 0x01280310,
11418 },
11419 {
11420 /* for D bits (numbered as per FIPS 46) 22 23 24 25 27 28 */
11421 0x00000000, 0x04000000, 0x00040000, 0x04040000,
11422 0x00000002, 0x04000002, 0x00040002, 0x04040002,
11423 0x00002000, 0x04002000, 0x00042000, 0x04042000,
11424 0x00002002, 0x04002002, 0x00042002, 0x04042002,
11425 0x00000020, 0x04000020, 0x00040020, 0x04040020,
11426 0x00000022, 0x04000022, 0x00040022, 0x04040022,
11427 0x00002020, 0x04002020, 0x00042020, 0x04042020,
11428 0x00002022, 0x04002022, 0x00042022, 0x04042022,
11429 0x00000800, 0x04000800, 0x00040800, 0x04040800,
11430 0x00000802, 0x04000802, 0x00040802, 0x04040802,
11431 0x00002800, 0x04002800, 0x00042800, 0x04042800,
11432 0x00002802, 0x04002802, 0x00042802, 0x04042802,
11433 0x00000820, 0x04000820, 0x00040820, 0x04040820,
11434 0x00000822, 0x04000822, 0x00040822, 0x04040822,
11435 0x00002820, 0x04002820, 0x00042820, 0x04042820,
11436 0x00002822, 0x04002822, 0x00042822, 0x04042822
11437 }
11438 };
11439
11440 digest_md4_sse2_t digests;
11441
11442 digest_t dgst[4];
11443
11444 plain_t plains[4];
11445
11446 db_t *db = thread_parameter->db;
11447
11448 plain_unicode (in, plains);
11449
11450 md4_init_sse2 (&digests);
11451
11452 md4_final_sse2_max55 (plains, &digests);
11453
11454 transpose_md4_digest (&digests, dgst);
11455
11456 uint32_t i;
11457
11458 uint32_t salts_idx;
11459
11460 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
11461 {
11462 salt_t *salt = db->salts_buf[salts_idx];
11463
11464 if (salt->indexes_found == salt->indexes_cnt) continue;
11465
11466 for (i = 0; i < 4; i++)
11467 {
11468 if (salt->netntlmv1_pc != (dgst[i].buf.md4[3] >> 16)) continue;
11469
11470 uint32_t *salt_ptr = (uint32_t *) salt->salt_plain_buf;
11471
11472 uint32_t data1[2];
11473 uint32_t data2[2];
11474 uint32_t data3[2];
11475
11476 data1[0] = salt_ptr[0];
11477 data1[1] = salt_ptr[1];
11478 data2[0] = salt_ptr[0];
11479 data2[1] = salt_ptr[1];
11480 data3[0] = salt_ptr[0];
11481 data3[1] = salt_ptr[1];
11482
11483 uint8_t key_des[8];
11484
11485 uint32_t Kc[16];
11486 uint32_t Kd[16];
11487
11488 // DES ROUND 1
11489
11490 uint8_t *key_md4 = (uint8_t *) dgst[i].buf.md4;
11491
11492 transform_netntlmv1_key (key_md4 + 0, key_des);
11493
11494 _des_keysetup ((uint32_t *) key_des, Kc, Kd, c_skb);
11495
11496 _des_encrypt (data1, Kc, Kd, c_SPtrans);
11497
11498 // DES ROUND 2
11499
11500 transform_netntlmv1_key (key_md4 + 7, key_des);
11501
11502 _des_keysetup ((uint32_t *) key_des, Kc, Kd, c_skb);
11503
11504 _des_encrypt (data2, Kc, Kd, c_SPtrans);
11505
11506 // DES ROUND 3
11507
11508 //transform_netntlmv1_key (key_md4 + 14, key_des);
11509
11510 //_des_keysetup ((uint32_t *) key_des, Kc, Kd, c_skb);
11511
11512 //_des_encrypt (data3, Kc, Kd, c_SPtrans);
11513
11514 memcpy (data3, salt->salt_prehashed_buf, 8);
11515
11516 // STORE
11517
11518 dgst[i].buf.md4[0] = data1[0];
11519 dgst[i].buf.md4[1] = data1[1];
11520 dgst[i].buf.md4[2] = data2[0];
11521 dgst[i].buf.md4[3] = data2[1];
11522 dgst[i].buf.md4[4] = data3[0];
11523 dgst[i].buf.md4[5] = data3[1];
11524 }
11525
11526 thread_parameter->indb (thread_parameter, in, dgst, salt);
11527 }
11528 }
11529
hashing_05600(thread_parameter_t * thread_parameter,plain_t * in)11530 void hashing_05600 (thread_parameter_t *thread_parameter, plain_t *in)
11531 {
11532 digest_md4_sse2_t digests;
11533
11534 digest_t dgst[4];
11535
11536 plain_t plains[4];
11537
11538 uint32_t ipad_dgst[4][4] __attribute__ ((aligned (16)));
11539 uint32_t opad_dgst[4][4] __attribute__ ((aligned (16)));
11540
11541 uint32_t ipad_buf[16][4] __attribute__ ((aligned (16)));
11542 uint32_t opad_buf[16][4] __attribute__ ((aligned (16)));
11543
11544 db_t *db = thread_parameter->db;
11545
11546 // unicode password (ntlm)
11547
11548 plain_unicode (in, plains);
11549
11550 md4_init_sse2 (&digests);
11551
11552 md4_final_sse2_max55 (plains, &digests);
11553
11554 transpose_md4_digest (&digests, dgst);
11555
11556 // 1st hmac
11557
11558 uint32_t i;
11559 uint32_t j;
11560
11561 for (i = 0; i < 4; i++)
11562 {
11563 for (j = 0; j < 16; j++)
11564 {
11565 ipad_buf[j][i] = 0x36363636;
11566 opad_buf[j][i] = 0x5c5c5c5c;
11567 }
11568
11569 ipad_buf[0][i] ^= dgst[i].buf.md4[0];
11570 ipad_buf[1][i] ^= dgst[i].buf.md4[1];
11571 ipad_buf[2][i] ^= dgst[i].buf.md4[2];
11572 ipad_buf[3][i] ^= dgst[i].buf.md4[3];
11573
11574 opad_buf[0][i] ^= dgst[i].buf.md4[0];
11575 opad_buf[1][i] ^= dgst[i].buf.md4[1];
11576 opad_buf[2][i] ^= dgst[i].buf.md4[2];
11577 opad_buf[3][i] ^= dgst[i].buf.md4[3];
11578
11579 ipad_dgst[0][i] = MD5M_A;
11580 ipad_dgst[1][i] = MD5M_B;
11581 ipad_dgst[2][i] = MD5M_C;
11582 ipad_dgst[3][i] = MD5M_D;
11583
11584 opad_dgst[0][i] = MD5M_A;
11585 opad_dgst[1][i] = MD5M_B;
11586 opad_dgst[2][i] = MD5M_C;
11587 opad_dgst[3][i] = MD5M_D;
11588 }
11589
11590 hashcat_md5_64 ((__m128i *) ipad_dgst, (__m128i *) ipad_buf);
11591 hashcat_md5_64 ((__m128i *) opad_dgst, (__m128i *) opad_buf);
11592
11593 uint32_t salts_idx;
11594
11595 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
11596 {
11597 salt_t *salt = db->salts_buf[salts_idx];
11598
11599 if (salt->indexes_found == salt->indexes_cnt) continue;
11600
11601 netntlm_t *netntlm = salt->netntlm;
11602
11603 const uint32_t userdomain_len = netntlm->user_len
11604 + netntlm->domain_len;
11605
11606 const uint32_t chall_len = netntlm->srvchall_len
11607 + netntlm->clichall_len;
11608
11609 uint32_t ipad_dgst_tmp[4][4] __attribute__ ((aligned (16)));
11610 uint32_t opad_dgst_tmp[4][4] __attribute__ ((aligned (16)));
11611
11612 for (i = 0; i < 4; i++)
11613 {
11614 for (j = 0; j < 4; j++)
11615 {
11616 ipad_dgst_tmp[j][i] = ipad_dgst[j][i];
11617 opad_dgst_tmp[j][i] = opad_dgst[j][i];
11618 }
11619 }
11620
11621 for (i = 0; i < 4; i++)
11622 {
11623 for (j = 0; j < 14; j++)
11624 {
11625 ipad_buf[j][i] = netntlm->userdomain_buf[j];
11626 }
11627
11628 ipad_buf[14][i] = (64 + userdomain_len) * 8;
11629 ipad_buf[15][i] = 0;
11630 }
11631
11632 hashcat_md5_64 ((__m128i *) ipad_dgst_tmp, (__m128i *) ipad_buf);
11633
11634 for (i = 0; i < 4; i++)
11635 {
11636 for (j = 0; j < 4; j++)
11637 {
11638 opad_buf[j][i] = ipad_dgst_tmp[j][i];
11639 }
11640
11641 opad_buf[ 4][i] = 0x80;
11642 opad_buf[ 5][i] = 0;
11643 opad_buf[ 6][i] = 0;
11644 opad_buf[ 7][i] = 0;
11645 opad_buf[ 8][i] = 0;
11646 opad_buf[ 9][i] = 0;
11647 opad_buf[10][i] = 0;
11648 opad_buf[11][i] = 0;
11649 opad_buf[12][i] = 0;
11650 opad_buf[13][i] = 0;
11651 opad_buf[14][i] = (64 + 16) * 8;
11652 opad_buf[15][i] = 0;
11653 }
11654
11655 hashcat_md5_64 ((__m128i *) opad_dgst_tmp, (__m128i *) opad_buf);
11656
11657 // 2nd hmac based on 1st hmac result
11658
11659 for (i = 0; i < 4; i++)
11660 {
11661 for (j = 0; j < 16; j++)
11662 {
11663 ipad_buf[j][i] = 0x36363636;
11664 opad_buf[j][i] = 0x5c5c5c5c;
11665 }
11666
11667 ipad_buf[0][i] ^= opad_dgst_tmp[0][i];
11668 ipad_buf[1][i] ^= opad_dgst_tmp[1][i];
11669 ipad_buf[2][i] ^= opad_dgst_tmp[2][i];
11670 ipad_buf[3][i] ^= opad_dgst_tmp[3][i];
11671
11672 opad_buf[0][i] ^= opad_dgst_tmp[0][i];
11673 opad_buf[1][i] ^= opad_dgst_tmp[1][i];
11674 opad_buf[2][i] ^= opad_dgst_tmp[2][i];
11675 opad_buf[3][i] ^= opad_dgst_tmp[3][i];
11676
11677 ipad_dgst_tmp[0][i] = MD5M_A;
11678 ipad_dgst_tmp[1][i] = MD5M_B;
11679 ipad_dgst_tmp[2][i] = MD5M_C;
11680 ipad_dgst_tmp[3][i] = MD5M_D;
11681
11682 opad_dgst_tmp[0][i] = MD5M_A;
11683 opad_dgst_tmp[1][i] = MD5M_B;
11684 opad_dgst_tmp[2][i] = MD5M_C;
11685 opad_dgst_tmp[3][i] = MD5M_D;
11686 }
11687
11688 hashcat_md5_64 ((__m128i *) ipad_dgst_tmp, (__m128i *) ipad_buf);
11689 hashcat_md5_64 ((__m128i *) opad_dgst_tmp, (__m128i *) opad_buf);
11690
11691 int left;
11692 int off;
11693
11694 for (left = chall_len, off = 0; left >= 56; left -= 64, off += 16)
11695 {
11696 for (i = 0; i < 4; i++)
11697 {
11698 for (j = 0; j < 16; j++)
11699 {
11700 ipad_buf[j][i] = netntlm->chall_buf[off + j];
11701 }
11702 }
11703
11704 hashcat_md5_64 ((__m128i *) ipad_dgst_tmp, (__m128i *) ipad_buf);
11705 }
11706
11707 for (i = 0; i < 4; i++)
11708 {
11709 for (j = 0; j < 14; j++)
11710 {
11711 ipad_buf[j][i] = netntlm->chall_buf[off + j];
11712 }
11713
11714 ipad_buf[14][i] = (64 + chall_len) * 8;
11715 ipad_buf[15][i] = 0;
11716 }
11717
11718 hashcat_md5_64 ((__m128i *) ipad_dgst_tmp, (__m128i *) ipad_buf);
11719
11720 for (i = 0; i < 4; i++)
11721 {
11722 for (j = 0; j < 4; j++)
11723 {
11724 opad_buf[j][i] = ipad_dgst_tmp[j][i];
11725 }
11726
11727 opad_buf[ 4][i] = 0x80;
11728 opad_buf[ 5][i] = 0;
11729 opad_buf[ 6][i] = 0;
11730 opad_buf[ 7][i] = 0;
11731 opad_buf[ 8][i] = 0;
11732 opad_buf[ 9][i] = 0;
11733 opad_buf[10][i] = 0;
11734 opad_buf[11][i] = 0;
11735 opad_buf[12][i] = 0;
11736 opad_buf[13][i] = 0;
11737 opad_buf[14][i] = (64 + 16) * 8;
11738 opad_buf[15][i] = 0;
11739 }
11740
11741 hashcat_md5_64 ((__m128i *) opad_dgst_tmp, (__m128i *) opad_buf);
11742
11743 for (i = 0; i < 4; i++)
11744 {
11745 for (j = 0; j < 4; j++)
11746 {
11747 dgst[i].buf.md5[j] = opad_dgst_tmp[j][i];
11748 }
11749 }
11750
11751 thread_parameter->indb (thread_parameter, in, dgst, salt);
11752 }
11753 }
11754
hashing_05800(thread_parameter_t * thread_parameter,plain_t * in)11755 void hashing_05800 (thread_parameter_t *thread_parameter, plain_t *in)
11756 {
11757 digest_sha1_sse2_t digests;
11758
11759 digest_t dgst[4];
11760
11761 plain_t plains[4];
11762
11763 plain_t plains_tmp[4];
11764
11765 extern plain_t **plains_iteration;
11766
11767 db_t *db = thread_parameter->db;
11768
11769 uint32_t salts_idx;
11770
11771 uint32_t i;
11772
11773 for (i = 0; i < 4; i++) plains_tmp[i].len = 20;
11774
11775 uint32_t j;
11776
11777 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
11778 {
11779 salt_t *salt = db->salts_buf[salts_idx];
11780
11781 if (salt->indexes_found == salt->indexes_cnt) continue;
11782
11783 j = 0;
11784
11785 plain_init (plains);
11786
11787 sha1_init_sse2 (&digests);
11788
11789 sha1_update_sse2 (plains, &digests, plains_iteration[j]);
11790
11791 sha1_update_sse2 (plains, &digests, in);
11792
11793 sha1_update_sse2 (plains, &digests, salt->salt_plain_struct);
11794
11795 sha1_final_sse2 (plains, &digests);
11796
11797 transpose_sha1_digest (&digests, dgst);
11798
11799 for (j = 1; j < 1024; j++)
11800 {
11801 for (i = 0; i < 4; i++)
11802 {
11803 BYTESWAP (dgst[i].buf.sha1[0]);
11804 BYTESWAP (dgst[i].buf.sha1[1]);
11805 BYTESWAP (dgst[i].buf.sha1[2]);
11806 BYTESWAP (dgst[i].buf.sha1[3]);
11807 BYTESWAP (dgst[i].buf.sha1[4]);
11808
11809 plains_tmp[i].buf[0] = dgst[i].buf.sha1[0];
11810 plains_tmp[i].buf[1] = dgst[i].buf.sha1[1];
11811 plains_tmp[i].buf[2] = dgst[i].buf.sha1[2];
11812 plains_tmp[i].buf[3] = dgst[i].buf.sha1[3];
11813 plains_tmp[i].buf[4] = dgst[i].buf.sha1[4];
11814 }
11815
11816 plain_init (plains);
11817
11818 sha1_init_sse2 (&digests);
11819
11820 sha1_update_sse2 (plains, &digests, plains_tmp);
11821
11822 sha1_update_sse2 (plains, &digests, plains_iteration[j]);
11823
11824 sha1_update_sse2 (plains, &digests, in);
11825
11826 sha1_update_sse2 (plains, &digests, salt->salt_plain_struct);
11827
11828 sha1_final_sse2 (plains, &digests);
11829
11830 transpose_sha1_digest (&digests, dgst);
11831 }
11832
11833 thread_parameter->indb (thread_parameter, in, dgst, salt);
11834 }
11835 }
11836
hashing_06300(thread_parameter_t * thread_parameter,plain_t * in)11837 void hashing_06300 (thread_parameter_t *thread_parameter, plain_t *in)
11838 {
11839 digest_md5_sse2_t digests;
11840
11841 digest_t dgst[4];
11842
11843 plain_t plains[4];
11844
11845 char *ptrs[4];
11846
11847 ptrs[0] = (char *) &in[0].buf;
11848 ptrs[1] = (char *) &in[1].buf;
11849 ptrs[2] = (char *) &in[2].buf;
11850 ptrs[3] = (char *) &in[3].buf;
11851
11852 char *ptrs_tmp[4];
11853
11854 ptrs_tmp[0] = (char *) &plains[0].buf;
11855 ptrs_tmp[1] = (char *) &plains[1].buf;
11856 ptrs_tmp[2] = (char *) &plains[2].buf;
11857 ptrs_tmp[3] = (char *) &plains[3].buf;
11858
11859 db_t *db = thread_parameter->db;
11860
11861 uint32_t salts_idx;
11862
11863 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
11864 {
11865 salt_t *salt = db->salts_buf[salts_idx];
11866
11867 if (salt->indexes_found == salt->indexes_cnt) continue;
11868
11869 plain_init (plains);
11870
11871 md5_init_sse2 (&digests);
11872
11873 md5_update_sse2_max55 (plains, in);
11874
11875 md5_update_sse2_max55 (plains, salt->salt_plain_struct);
11876
11877 md5_update_sse2_max55 (plains, in);
11878
11879 md5_final_sse2_max55 (plains, &digests);
11880
11881 transpose_md5_digest (&digests, dgst);
11882
11883 uint32_t i;
11884
11885 for (i = 0; i < 4; i++)
11886 {
11887 if (in[i].len > 16) continue;
11888
11889 plains[i].len = in[i].len + salt->salt_plain_len;
11890
11891 /* The password first, since that is what is most unknown */
11892 /* Then our magic string */
11893 /* Then the raw salt */
11894 /* Then just as many characters of the MD5(pw,salt,pw) */
11895
11896 memcpy (ptrs_tmp[i], ptrs[i], in[i].len);
11897 memcpy (ptrs_tmp[i] + in[i].len, salt->salt_plain_buf, salt->salt_plain_len);
11898 memcpy (ptrs_tmp[i] + plains[i].len, dgst[i].buf.md5, in[i].len);
11899
11900 plains[i].len += in[i].len;
11901
11902 /* Then something really weird... */
11903
11904 switch (in[i].len)
11905 {
11906 case 1:
11907 ptrs_tmp[i][plains[i].len + 0] = 0;
11908 plains[i].len += 1;
11909 break;
11910
11911 case 2:
11912 ptrs_tmp[i][plains[i].len + 0] = ptrs[i][0];
11913 ptrs_tmp[i][plains[i].len + 1] = 0;
11914 plains[i].len += 2;
11915 break;
11916
11917 case 3:
11918 ptrs_tmp[i][plains[i].len + 0] = 0;
11919 ptrs_tmp[i][plains[i].len + 1] = 0;
11920 plains[i].len += 2;
11921 break;
11922
11923 case 4:
11924 ptrs_tmp[i][plains[i].len + 0] = ptrs[i][0];
11925 ptrs_tmp[i][plains[i].len + 1] = ptrs[i][0];
11926 ptrs_tmp[i][plains[i].len + 2] = 0;
11927 plains[i].len += 3;
11928 break;
11929
11930 case 5:
11931 ptrs_tmp[i][plains[i].len + 0] = 0;
11932 ptrs_tmp[i][plains[i].len + 1] = ptrs[i][0];
11933 ptrs_tmp[i][plains[i].len + 2] = 0;
11934 plains[i].len += 3;
11935 break;
11936
11937 case 6:
11938 ptrs_tmp[i][plains[i].len + 0] = ptrs[i][0];
11939 ptrs_tmp[i][plains[i].len + 1] = 0;
11940 ptrs_tmp[i][plains[i].len + 2] = 0;
11941 plains[i].len += 3;
11942 break;
11943
11944 case 7:
11945 ptrs_tmp[i][plains[i].len + 0] = 0;
11946 ptrs_tmp[i][plains[i].len + 1] = 0;
11947 ptrs_tmp[i][plains[i].len + 2] = 0;
11948 plains[i].len += 3;
11949 break;
11950
11951 case 8:
11952 ptrs_tmp[i][plains[i].len + 0] = ptrs[i][0];
11953 ptrs_tmp[i][plains[i].len + 1] = ptrs[i][0];
11954 ptrs_tmp[i][plains[i].len + 2] = ptrs[i][0];
11955 ptrs_tmp[i][plains[i].len + 3] = 0;
11956 plains[i].len += 4;
11957 break;
11958
11959 case 9:
11960 ptrs_tmp[i][plains[i].len + 0] = 0;
11961 ptrs_tmp[i][plains[i].len + 1] = ptrs[i][0];
11962 ptrs_tmp[i][plains[i].len + 2] = ptrs[i][0];
11963 ptrs_tmp[i][plains[i].len + 3] = 0;
11964 plains[i].len += 4;
11965 break;
11966
11967 case 10:
11968 ptrs_tmp[i][plains[i].len + 0] = ptrs[i][0];
11969 ptrs_tmp[i][plains[i].len + 1] = 0;
11970 ptrs_tmp[i][plains[i].len + 2] = ptrs[i][0];
11971 ptrs_tmp[i][plains[i].len + 3] = 0;
11972 plains[i].len += 4;
11973 break;
11974
11975 case 11:
11976 ptrs_tmp[i][plains[i].len + 0] = 0;
11977 ptrs_tmp[i][plains[i].len + 1] = 0;
11978 ptrs_tmp[i][plains[i].len + 2] = ptrs[i][0];
11979 ptrs_tmp[i][plains[i].len + 3] = 0;
11980 plains[i].len += 4;
11981 break;
11982
11983 case 12:
11984 ptrs_tmp[i][plains[i].len + 0] = ptrs[i][0];
11985 ptrs_tmp[i][plains[i].len + 1] = ptrs[i][0];
11986 ptrs_tmp[i][plains[i].len + 2] = 0;
11987 ptrs_tmp[i][plains[i].len + 3] = 0;
11988 plains[i].len += 4;
11989 break;
11990
11991 case 13:
11992 ptrs_tmp[i][plains[i].len + 0] = 0;
11993 ptrs_tmp[i][plains[i].len + 1] = ptrs[i][0];
11994 ptrs_tmp[i][plains[i].len + 2] = 0;
11995 ptrs_tmp[i][plains[i].len + 3] = 0;
11996 plains[i].len += 4;
11997 break;
11998
11999 case 14:
12000 ptrs_tmp[i][plains[i].len + 0] = ptrs[i][0];
12001 ptrs_tmp[i][plains[i].len + 1] = 0;
12002 ptrs_tmp[i][plains[i].len + 2] = 0;
12003 ptrs_tmp[i][plains[i].len + 3] = 0;
12004 plains[i].len += 4;
12005 break;
12006
12007 case 15:
12008 ptrs_tmp[i][plains[i].len + 0] = 0;
12009 ptrs_tmp[i][plains[i].len + 1] = 0;
12010 ptrs_tmp[i][plains[i].len + 2] = 0;
12011 ptrs_tmp[i][plains[i].len + 3] = 0;
12012 plains[i].len += 4;
12013 break;
12014 }
12015
12016 /*
12017 int pl;
12018
12019 for (pl = in[i].len; pl; pl >>= 1)
12020 {
12021 if ((plains[i].len + 1) < PLAIN_SIZE_MD5)
12022 {
12023 ptrs_tmp[i][plains[i].len] = (pl & 1) ? '\0' : ptrs[i][0];
12024
12025 plains[i].len++;
12026 }
12027 }
12028 */
12029 }
12030
12031 md5_init_sse2 (&digests);
12032
12033 md5_final_sse2_max55 (plains, &digests);
12034
12035 transpose_md5_digest (&digests, dgst);
12036
12037 /* and now, just to make sure things don't run too fast */
12038
12039 uint32_t j;
12040
12041 for (j = 0; j < 1000; j++)
12042 {
12043 int a1 = j & 1;
12044 int m3 = j % 3;
12045 int m7 = j % 7;
12046
12047 for (i = 0; i < 4; i++)
12048 {
12049 if (in[i].len > 16) continue;
12050
12051 memset (ptrs_tmp[i], 0, BLOCK_SIZE);
12052
12053 plains[i].len = 0;
12054
12055 if (a1)
12056 {
12057 memcpy (ptrs_tmp[i] + plains[i].len, ptrs[i], in[i].len);
12058
12059 plains[i].len += in[i].len;
12060 }
12061 else
12062 {
12063 memcpy (ptrs_tmp[i] + plains[i].len, dgst[i].buf.md5, 16);
12064
12065 plains[i].len += 16;
12066 }
12067
12068 if (m3)
12069 {
12070 memcpy (ptrs_tmp[i] + plains[i].len, salt->salt_plain_buf, salt->salt_plain_len);
12071
12072 plains[i].len += salt->salt_plain_len;
12073 }
12074
12075 if (m7)
12076 {
12077 memcpy (ptrs_tmp[i] + plains[i].len, ptrs[i], in[i].len);
12078
12079 plains[i].len += in[i].len;
12080 }
12081
12082 if (a1)
12083 {
12084 memcpy (ptrs_tmp[i] + plains[i].len, dgst[i].buf.md5, 16);
12085
12086 plains[i].len += 16;
12087 }
12088 else
12089 {
12090 memcpy (ptrs_tmp[i] + plains[i].len, ptrs[i], in[i].len);
12091
12092 plains[i].len += in[i].len;
12093 }
12094 }
12095
12096 md5_init_sse2 (&digests);
12097
12098 md5_final_sse2_max55 (plains, &digests);
12099
12100 transpose_md5_digest (&digests, dgst);
12101 }
12102
12103 thread_parameter->indb (thread_parameter, in , dgst, salt);
12104 }
12105 }
12106
hashing_06400(thread_parameter_t * thread_parameter,plain_t * plains)12107 void hashing_06400 (thread_parameter_t *thread_parameter, plain_t *plains)
12108 {
12109 digest_t digests[4];
12110
12111 plain_t plains_tmp[4];
12112
12113 char *ptrs_tmp[4];
12114
12115 ptrs_tmp[0] = (char *) &plains_tmp[0].buf;
12116 ptrs_tmp[1] = (char *) &plains_tmp[1].buf;
12117 ptrs_tmp[2] = (char *) &plains_tmp[2].buf;
12118 ptrs_tmp[3] = (char *) &plains_tmp[3].buf;
12119
12120 uint32_t ipad[8][4] __attribute__ ((aligned (16)));
12121 uint32_t opad[8][4] __attribute__ ((aligned (16)));
12122
12123 uint32_t ipad_buf[16][4] __attribute__ ((aligned (16)));
12124 uint32_t opad_buf[16][4] __attribute__ ((aligned (16)));
12125
12126 db_t *db = thread_parameter->db;
12127
12128 uint32_t i;
12129 uint32_t j;
12130 uint32_t l;
12131
12132 for (i = 0; i < 4; i++)
12133 {
12134 for (j = 0; j < 16; j++)
12135 {
12136 ipad_buf[j][i] = 0x36363636 ^ plains[i].buf[j];
12137 opad_buf[j][i] = 0x5c5c5c5c ^ plains[i].buf[j];
12138 }
12139
12140 ipad[0][i] = SHA256M_A;
12141 ipad[1][i] = SHA256M_B;
12142 ipad[2][i] = SHA256M_C;
12143 ipad[3][i] = SHA256M_D;
12144 ipad[4][i] = SHA256M_E;
12145 ipad[5][i] = SHA256M_F;
12146 ipad[6][i] = SHA256M_G;
12147 ipad[7][i] = SHA256M_H;
12148
12149 opad[0][i] = SHA256M_A;
12150 opad[1][i] = SHA256M_B;
12151 opad[2][i] = SHA256M_C;
12152 opad[3][i] = SHA256M_D;
12153 opad[4][i] = SHA256M_E;
12154 opad[5][i] = SHA256M_F;
12155 opad[6][i] = SHA256M_G;
12156 opad[7][i] = SHA256M_H;
12157 }
12158
12159 hashcat_sha256_64 ((__m128i *) ipad, (__m128i *) ipad_buf);
12160 hashcat_sha256_64 ((__m128i *) opad, (__m128i *) opad_buf);
12161
12162 uint32_t salts_idx;
12163
12164 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
12165 {
12166 salt_t *salt = db->salts_buf[salts_idx];
12167
12168 if (salt->indexes_found == salt->indexes_cnt) continue;
12169
12170 /**
12171 * init hmac
12172 */
12173
12174 uint32_t tmp[8][4] __attribute__ ((aligned (16)));
12175 uint32_t out[8][4] __attribute__ ((aligned (16)));
12176
12177 for (i = 0; i < 4; i++)
12178 {
12179 tmp[0][i] = ipad[0][i];
12180 tmp[1][i] = ipad[1][i];
12181 tmp[2][i] = ipad[2][i];
12182 tmp[3][i] = ipad[3][i];
12183 tmp[4][i] = ipad[4][i];
12184 tmp[5][i] = ipad[5][i];
12185 tmp[6][i] = ipad[6][i];
12186 tmp[7][i] = ipad[7][i];
12187 }
12188
12189 for (i = 0; i < 4; i++)
12190 {
12191 memcpy (ptrs_tmp[i], salt->salt_plain_buf, salt->salt_plain_len);
12192
12193 memset (ptrs_tmp[i] + salt->salt_plain_len, 0, BLOCK_SIZE - salt->salt_plain_len);
12194
12195 ptrs_tmp[i][salt->salt_plain_len + 3] = 0x01;
12196 ptrs_tmp[i][salt->salt_plain_len + 4] = 0x80;
12197
12198 for (j = 0; j < 14; j++) ipad_buf[j][i] = plains_tmp[i].buf[j];
12199
12200 ipad_buf[14][i] = 0;
12201 ipad_buf[15][i] = (64 + salt->salt_plain_len + 4) * 8;
12202 }
12203
12204 for (i = 14; i < 16; i++) for (l = 0; l < 4; l++) BYTESWAP (ipad_buf[i][l]);
12205
12206 hashcat_sha256_64 ((__m128i *) tmp, (__m128i *) ipad_buf);
12207
12208 for (i = 0; i < 4; i++)
12209 {
12210 opad_buf[ 0][i] = tmp[0][i];
12211 opad_buf[ 1][i] = tmp[1][i];
12212 opad_buf[ 2][i] = tmp[2][i];
12213 opad_buf[ 3][i] = tmp[3][i];
12214 opad_buf[ 4][i] = tmp[4][i];
12215 opad_buf[ 5][i] = tmp[5][i];
12216 opad_buf[ 6][i] = tmp[6][i];
12217 opad_buf[ 7][i] = tmp[7][i];
12218 opad_buf[ 8][i] = 0x80000000;
12219 opad_buf[ 9][i] = 0;
12220 opad_buf[10][i] = 0;
12221 opad_buf[11][i] = 0;
12222 opad_buf[12][i] = 0;
12223 opad_buf[13][i] = 0;
12224 opad_buf[14][i] = 0;
12225 opad_buf[15][i] = (64 + 32) * 8;
12226 }
12227
12228 for (i = 0; i < 4; i++)
12229 {
12230 tmp[0][i] = opad[0][i];
12231 tmp[1][i] = opad[1][i];
12232 tmp[2][i] = opad[2][i];
12233 tmp[3][i] = opad[3][i];
12234 tmp[4][i] = opad[4][i];
12235 tmp[5][i] = opad[5][i];
12236 tmp[6][i] = opad[6][i];
12237 tmp[7][i] = opad[7][i];
12238 }
12239
12240 for (i = 0; i < 16; i++) for (l = 0; l < 4; l++) BYTESWAP (opad_buf[i][l]);
12241
12242 hashcat_sha256_64 ((__m128i *) tmp, (__m128i *) opad_buf);
12243
12244 for (i = 0; i < 4; i++)
12245 {
12246 out[0][i] = tmp[0][i];
12247 out[1][i] = tmp[1][i];
12248 out[2][i] = tmp[2][i];
12249 out[3][i] = tmp[3][i];
12250 out[4][i] = tmp[4][i];
12251 out[5][i] = tmp[5][i];
12252 out[6][i] = tmp[6][i];
12253 out[7][i] = tmp[7][i];
12254 }
12255
12256 /**
12257 * loop hmac
12258 */
12259
12260 for (j = 0; j < salt->iterations - 1; j++)
12261 {
12262 for (i = 0; i < 4; i++)
12263 {
12264 ipad_buf[ 0][i] = tmp[0][i];
12265 ipad_buf[ 1][i] = tmp[1][i];
12266 ipad_buf[ 2][i] = tmp[2][i];
12267 ipad_buf[ 3][i] = tmp[3][i];
12268 ipad_buf[ 4][i] = tmp[4][i];
12269 ipad_buf[ 5][i] = tmp[5][i];
12270 ipad_buf[ 6][i] = tmp[6][i];
12271 ipad_buf[ 7][i] = tmp[7][i];
12272 ipad_buf[ 8][i] = 0x80000000;
12273 ipad_buf[ 9][i] = 0;
12274 ipad_buf[10][i] = 0;
12275 ipad_buf[11][i] = 0;
12276 ipad_buf[12][i] = 0;
12277 ipad_buf[13][i] = 0;
12278 ipad_buf[14][i] = 0;
12279 ipad_buf[15][i] = (64 + 32) * 8;
12280 }
12281
12282 for (i = 0; i < 4; i++)
12283 {
12284 tmp[0][i] = ipad[0][i];
12285 tmp[1][i] = ipad[1][i];
12286 tmp[2][i] = ipad[2][i];
12287 tmp[3][i] = ipad[3][i];
12288 tmp[4][i] = ipad[4][i];
12289 tmp[5][i] = ipad[5][i];
12290 tmp[6][i] = ipad[6][i];
12291 tmp[7][i] = ipad[7][i];
12292 }
12293
12294 for (i = 0; i < 4; i++) for (l = 0; l < 16; l++) BYTESWAP (ipad_buf[l][i]);
12295
12296 hashcat_sha256_64 ((__m128i *) tmp, (__m128i *) ipad_buf);
12297
12298 for (i = 0; i < 4; i++)
12299 {
12300 opad_buf[ 0][i] = tmp[0][i];
12301 opad_buf[ 1][i] = tmp[1][i];
12302 opad_buf[ 2][i] = tmp[2][i];
12303 opad_buf[ 3][i] = tmp[3][i];
12304 opad_buf[ 4][i] = tmp[4][i];
12305 opad_buf[ 5][i] = tmp[5][i];
12306 opad_buf[ 6][i] = tmp[6][i];
12307 opad_buf[ 7][i] = tmp[7][i];
12308 opad_buf[ 8][i] = 0x80000000;
12309 opad_buf[ 9][i] = 0;
12310 opad_buf[10][i] = 0;
12311 opad_buf[11][i] = 0;
12312 opad_buf[12][i] = 0;
12313 opad_buf[13][i] = 0;
12314 opad_buf[14][i] = 0;
12315 opad_buf[15][i] = (64 + 32) * 8;
12316 }
12317
12318 for (i = 0; i < 4; i++)
12319 {
12320 tmp[0][i] = opad[0][i];
12321 tmp[1][i] = opad[1][i];
12322 tmp[2][i] = opad[2][i];
12323 tmp[3][i] = opad[3][i];
12324 tmp[4][i] = opad[4][i];
12325 tmp[5][i] = opad[5][i];
12326 tmp[6][i] = opad[6][i];
12327 tmp[7][i] = opad[7][i];
12328 }
12329
12330 for (i = 0; i < 4; i++) for (l = 0; l < 16; l++) BYTESWAP (opad_buf[l][i]);
12331
12332 hashcat_sha256_64 ((__m128i *) tmp, (__m128i *) opad_buf);
12333
12334 for (i = 0; i < 4; i++)
12335 {
12336 out[0][i] ^= tmp[0][i];
12337 out[1][i] ^= tmp[1][i];
12338 out[2][i] ^= tmp[2][i];
12339 out[3][i] ^= tmp[3][i];
12340 out[4][i] ^= tmp[4][i];
12341 out[5][i] ^= tmp[5][i];
12342 out[6][i] ^= tmp[6][i];
12343 out[7][i] ^= tmp[7][i];
12344 }
12345 }
12346
12347 for (i = 0; i < 4; i++)
12348 {
12349 digests[i].buf.sha256[0] = out[0][i];
12350 digests[i].buf.sha256[1] = out[1][i];
12351 digests[i].buf.sha256[2] = out[2][i];
12352 digests[i].buf.sha256[3] = out[3][i];
12353 digests[i].buf.sha256[4] = out[4][i];
12354 digests[i].buf.sha256[5] = out[5][i];
12355 digests[i].buf.sha256[6] = out[6][i];
12356 digests[i].buf.sha256[7] = out[7][i] & 0xffff03ff;
12357 }
12358
12359 thread_parameter->indb (thread_parameter, plains, digests, salt);
12360 }
12361 }
12362
hashing_06500(thread_parameter_t * thread_parameter,plain_t * plains)12363 void hashing_06500 (thread_parameter_t *thread_parameter, plain_t *plains)
12364 {
12365 digest_t digests[4];
12366
12367 plain_t plains_tmp[4];
12368
12369 char *ptrs_tmp[4];
12370
12371 ptrs_tmp[0] = (char *) &plains_tmp[0].buf64;
12372 ptrs_tmp[1] = (char *) &plains_tmp[1].buf64;
12373 ptrs_tmp[2] = (char *) &plains_tmp[2].buf64;
12374 ptrs_tmp[3] = (char *) &plains_tmp[3].buf64;
12375
12376 uint64_t ipad[8][2] __attribute__ ((aligned (16)));
12377 uint64_t opad[8][2] __attribute__ ((aligned (16)));
12378
12379 uint64_t ipad_buf[16][2] __attribute__ ((aligned (16)));
12380 uint64_t opad_buf[16][2] __attribute__ ((aligned (16)));
12381
12382 db_t *db = thread_parameter->db;
12383
12384 /*
12385 * dirty workaround
12386 */
12387
12388 uint32_t k;
12389
12390 for (k = 0; k < 4; k += 2)
12391 {
12392 uint32_t i;
12393 uint32_t j;
12394 uint32_t l;
12395
12396 for (i = 0; i < 2; i++)
12397 {
12398 for (j = 0; j < 16; j++)
12399 {
12400 ipad_buf[j][i] = 0x3636363636363636 ^ plains[i + k].buf64[j];
12401 opad_buf[j][i] = 0x5c5c5c5c5c5c5c5c ^ plains[i + k].buf64[j];
12402 }
12403
12404 ipad[0][i] = SHA512M_A;
12405 ipad[1][i] = SHA512M_B;
12406 ipad[2][i] = SHA512M_C;
12407 ipad[3][i] = SHA512M_D;
12408 ipad[4][i] = SHA512M_E;
12409 ipad[5][i] = SHA512M_F;
12410 ipad[6][i] = SHA512M_G;
12411 ipad[7][i] = SHA512M_H;
12412
12413 opad[0][i] = SHA512M_A;
12414 opad[1][i] = SHA512M_B;
12415 opad[2][i] = SHA512M_C;
12416 opad[3][i] = SHA512M_D;
12417 opad[4][i] = SHA512M_E;
12418 opad[5][i] = SHA512M_F;
12419 opad[6][i] = SHA512M_G;
12420 opad[7][i] = SHA512M_H;
12421 }
12422
12423 hashcat_sha512_64 ((__m128i *) ipad, (__m128i *) ipad_buf);
12424 hashcat_sha512_64 ((__m128i *) opad, (__m128i *) opad_buf);
12425
12426 uint32_t salts_idx;
12427
12428 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
12429 {
12430 salt_t *salt = db->salts_buf[salts_idx];
12431
12432 if (salt->indexes_found == salt->indexes_cnt) continue;
12433
12434 /**
12435 * init hmac
12436 */
12437
12438 uint64_t tmp[8][2] __attribute__ ((aligned (16)));
12439 uint64_t out[8][2] __attribute__ ((aligned (16)));
12440
12441 for (i = 0; i < 2; i++)
12442 {
12443 tmp[0][i] = ipad[0][i];
12444 tmp[1][i] = ipad[1][i];
12445 tmp[2][i] = ipad[2][i];
12446 tmp[3][i] = ipad[3][i];
12447 tmp[4][i] = ipad[4][i];
12448 tmp[5][i] = ipad[5][i];
12449 tmp[6][i] = ipad[6][i];
12450 tmp[7][i] = ipad[7][i];
12451 }
12452
12453 for (i = 0; i < 2; i++)
12454 {
12455 memcpy (ptrs_tmp[i], salt->salt_plain_buf, salt->salt_plain_len);
12456
12457 memset (ptrs_tmp[i] + salt->salt_plain_len, 0, BLOCK_SIZE - salt->salt_plain_len);
12458
12459 ptrs_tmp[i][salt->salt_plain_len + 3] = 0x01;
12460 ptrs_tmp[i][salt->salt_plain_len + 4] = 0x80;
12461
12462 for (j = 0; j < 14; j++) ipad_buf[j][i] = plains_tmp[i].buf64[j];
12463
12464 ipad_buf[14][i] = 0;
12465 ipad_buf[15][i] = (128 + salt->salt_plain_len + 4) * 8;
12466
12467 BYTESWAP64 (ipad_buf[15][i]);
12468 }
12469
12470 hashcat_sha512_64 ((__m128i *) tmp, (__m128i *) ipad_buf);
12471
12472 for (i = 0; i < 2; i++)
12473 {
12474 opad_buf[ 0][i] = tmp[0][i];
12475 opad_buf[ 1][i] = tmp[1][i];
12476 opad_buf[ 2][i] = tmp[2][i];
12477 opad_buf[ 3][i] = tmp[3][i];
12478 opad_buf[ 4][i] = tmp[4][i];
12479 opad_buf[ 5][i] = tmp[5][i];
12480 opad_buf[ 6][i] = tmp[6][i];
12481 opad_buf[ 7][i] = tmp[7][i];
12482 opad_buf[ 8][i] = 0x8000000000000000;
12483 opad_buf[ 9][i] = 0;
12484 opad_buf[10][i] = 0;
12485 opad_buf[11][i] = 0;
12486 opad_buf[12][i] = 0;
12487 opad_buf[13][i] = 0;
12488 opad_buf[14][i] = 0;
12489 opad_buf[15][i] = (128 + 64) * 8;
12490 }
12491
12492 for (i = 0; i < 2; i++)
12493 {
12494 tmp[0][i] = opad[0][i];
12495 tmp[1][i] = opad[1][i];
12496 tmp[2][i] = opad[2][i];
12497 tmp[3][i] = opad[3][i];
12498 tmp[4][i] = opad[4][i];
12499 tmp[5][i] = opad[5][i];
12500 tmp[6][i] = opad[6][i];
12501 tmp[7][i] = opad[7][i];
12502 }
12503
12504 for (j = 0; j < 2; j++) for (l = 0; l < 16; l++) BYTESWAP64 (opad_buf[l][j]);
12505
12506 hashcat_sha512_64 ((__m128i *) tmp, (__m128i *) opad_buf);
12507
12508 for (i = 0; i < 2; i++)
12509 {
12510 out[0][i] = tmp[0][i];
12511 out[1][i] = tmp[1][i];
12512 out[2][i] = tmp[2][i];
12513 out[3][i] = tmp[3][i];
12514 out[4][i] = tmp[4][i];
12515 out[5][i] = tmp[5][i];
12516 out[6][i] = tmp[6][i];
12517 out[7][i] = tmp[7][i];
12518 }
12519
12520 /**
12521 * loop hmac
12522 */
12523
12524 for (j = 0; j < salt->iterations - 1; j++)
12525 {
12526 for (i = 0; i < 2; i++)
12527 {
12528 ipad_buf[ 0][i] = tmp[0][i];
12529 ipad_buf[ 1][i] = tmp[1][i];
12530 ipad_buf[ 2][i] = tmp[2][i];
12531 ipad_buf[ 3][i] = tmp[3][i];
12532 ipad_buf[ 4][i] = tmp[4][i];
12533 ipad_buf[ 5][i] = tmp[5][i];
12534 ipad_buf[ 6][i] = tmp[6][i];
12535 ipad_buf[ 7][i] = tmp[7][i];
12536 ipad_buf[ 8][i] = 0x8000000000000000;
12537 ipad_buf[ 9][i] = 0;
12538 ipad_buf[10][i] = 0;
12539 ipad_buf[11][i] = 0;
12540 ipad_buf[12][i] = 0;
12541 ipad_buf[13][i] = 0;
12542 ipad_buf[14][i] = 0;
12543 ipad_buf[15][i] = (128 + 64) * 8;
12544 }
12545
12546 for (i = 0; i < 2; i++)
12547 {
12548 tmp[0][i] = ipad[0][i];
12549 tmp[1][i] = ipad[1][i];
12550 tmp[2][i] = ipad[2][i];
12551 tmp[3][i] = ipad[3][i];
12552 tmp[4][i] = ipad[4][i];
12553 tmp[5][i] = ipad[5][i];
12554 tmp[6][i] = ipad[6][i];
12555 tmp[7][i] = ipad[7][i];
12556 }
12557
12558 for (i = 0; i < 2; i++) for (l = 0; l < 16; l++) BYTESWAP64 (ipad_buf[l][i]);
12559
12560 hashcat_sha512_64 ((__m128i *) tmp, (__m128i *) ipad_buf);
12561
12562 for (i = 0; i < 2; i++)
12563 {
12564 opad_buf[ 0][i] = tmp[0][i];
12565 opad_buf[ 1][i] = tmp[1][i];
12566 opad_buf[ 2][i] = tmp[2][i];
12567 opad_buf[ 3][i] = tmp[3][i];
12568 opad_buf[ 4][i] = tmp[4][i];
12569 opad_buf[ 5][i] = tmp[5][i];
12570 opad_buf[ 6][i] = tmp[6][i];
12571 opad_buf[ 7][i] = tmp[7][i];
12572 opad_buf[ 8][i] = 0x8000000000000000;
12573 opad_buf[ 9][i] = 0;
12574 opad_buf[10][i] = 0;
12575 opad_buf[11][i] = 0;
12576 opad_buf[12][i] = 0;
12577 opad_buf[13][i] = 0;
12578 opad_buf[14][i] = 0;
12579 opad_buf[15][i] = (128 + 64) * 8;
12580 }
12581
12582 for (i = 0; i < 2; i++)
12583 {
12584 tmp[0][i] = opad[0][i];
12585 tmp[1][i] = opad[1][i];
12586 tmp[2][i] = opad[2][i];
12587 tmp[3][i] = opad[3][i];
12588 tmp[4][i] = opad[4][i];
12589 tmp[5][i] = opad[5][i];
12590 tmp[6][i] = opad[6][i];
12591 tmp[7][i] = opad[7][i];
12592 }
12593
12594 for (i = 0; i < 2; i++) for (l = 0; l < 16; l++) BYTESWAP64 (opad_buf[l][i]);
12595
12596 hashcat_sha512_64 ((__m128i *) tmp, (__m128i *) opad_buf);
12597
12598 for (i = 0; i < 2; i++)
12599 {
12600 out[0][i] ^= tmp[0][i];
12601 out[1][i] ^= tmp[1][i];
12602 out[2][i] ^= tmp[2][i];
12603 out[3][i] ^= tmp[3][i];
12604 out[4][i] ^= tmp[4][i];
12605 out[5][i] ^= tmp[5][i];
12606 out[6][i] ^= tmp[6][i];
12607 out[7][i] ^= tmp[7][i];
12608 }
12609 }
12610
12611 for (i = 0; i < 2; i++)
12612 {
12613 digests[i + k].buf.sha512[0] = out[0][i];
12614 digests[i + k].buf.sha512[1] = out[1][i];
12615 digests[i + k].buf.sha512[2] = out[2][i];
12616 digests[i + k].buf.sha512[3] = out[3][i];
12617 digests[i + k].buf.sha512[4] = out[4][i];
12618 digests[i + k].buf.sha512[5] = out[5][i];
12619 digests[i + k].buf.sha512[6] = out[6][i];
12620 digests[i + k].buf.sha512[7] = out[7][i] & 0xffffffffffffff00;
12621 }
12622
12623 thread_parameter->indb (thread_parameter, plains, digests, salt);
12624 }
12625 }
12626 }
12627
hashing_06700(thread_parameter_t * thread_parameter,plain_t * plains)12628 void hashing_06700 (thread_parameter_t *thread_parameter, plain_t *plains)
12629 {
12630 digest_t digests[4];
12631
12632 plain_t plains_tmp[4];
12633
12634 char *ptrs_tmp[4];
12635
12636 ptrs_tmp[0] = (char *) &plains_tmp[0].buf;
12637 ptrs_tmp[1] = (char *) &plains_tmp[1].buf;
12638 ptrs_tmp[2] = (char *) &plains_tmp[2].buf;
12639 ptrs_tmp[3] = (char *) &plains_tmp[3].buf;
12640
12641 uint32_t ipad[5][4] __attribute__ ((aligned (16)));
12642 uint32_t opad[5][4] __attribute__ ((aligned (16)));
12643
12644 uint32_t ipad_buf[16][4] __attribute__ ((aligned (16)));
12645 uint32_t opad_buf[16][4] __attribute__ ((aligned (16)));
12646
12647 db_t *db = thread_parameter->db;
12648
12649 uint32_t i;
12650 uint32_t j;
12651 uint32_t l;
12652
12653 for (i = 0; i < 4; i++)
12654 {
12655 for (j = 0; j < 16; j++)
12656 {
12657 ipad_buf[j][i] = 0x36363636 ^ plains[i].buf[j];
12658 opad_buf[j][i] = 0x5c5c5c5c ^ plains[i].buf[j];
12659 }
12660
12661 ipad[0][i] = SHA1M_A;
12662 ipad[1][i] = SHA1M_B;
12663 ipad[2][i] = SHA1M_C;
12664 ipad[3][i] = SHA1M_D;
12665 ipad[4][i] = SHA1M_E;
12666
12667 opad[0][i] = SHA1M_A;
12668 opad[1][i] = SHA1M_B;
12669 opad[2][i] = SHA1M_C;
12670 opad[3][i] = SHA1M_D;
12671 opad[4][i] = SHA1M_E;
12672 }
12673
12674 hashcat_sha1_64 ((__m128i *) ipad, (__m128i *) ipad_buf);
12675 hashcat_sha1_64 ((__m128i *) opad, (__m128i *) opad_buf);
12676
12677 uint32_t salts_idx;
12678
12679 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
12680 {
12681 salt_t *salt = db->salts_buf[salts_idx];
12682
12683 if (salt->indexes_found == salt->indexes_cnt) continue;
12684
12685 /**
12686 * init hmac
12687 */
12688
12689 uint32_t tmp[5][4] __attribute__ ((aligned (16)));
12690 uint32_t out[5][4] __attribute__ ((aligned (16)));
12691
12692 for (i = 0; i < 4; i++)
12693 {
12694 tmp[0][i] = ipad[0][i];
12695 tmp[1][i] = ipad[1][i];
12696 tmp[2][i] = ipad[2][i];
12697 tmp[3][i] = ipad[3][i];
12698 tmp[4][i] = ipad[4][i];
12699 }
12700
12701 for (i = 0; i < 4; i++)
12702 {
12703 memcpy (ptrs_tmp[i], salt->salt_plain_buf, salt->salt_plain_len);
12704
12705 memset (ptrs_tmp[i] + salt->salt_plain_len, 0, BLOCK_SIZE - salt->salt_plain_len);
12706
12707 ptrs_tmp[i][salt->salt_plain_len + 3] = 0x01;
12708 ptrs_tmp[i][salt->salt_plain_len + 4] = 0x80;
12709
12710 for (j = 0; j < 14; j++) ipad_buf[j][i] = plains_tmp[i].buf[j];
12711
12712 ipad_buf[14][i] = 0;
12713 ipad_buf[15][i] = (64 + salt->salt_plain_len + 4) * 8;
12714 }
12715
12716 for (i = 14; i < 16; i++) for (l = 0; l < 4; l++) BYTESWAP (ipad_buf[i][l]);
12717
12718 hashcat_sha1_64 ((__m128i *) tmp, (__m128i *) ipad_buf);
12719
12720 for (i = 0; i < 4; i++)
12721 {
12722 opad_buf[ 0][i] = tmp[0][i];
12723 opad_buf[ 1][i] = tmp[1][i];
12724 opad_buf[ 2][i] = tmp[2][i];
12725 opad_buf[ 3][i] = tmp[3][i];
12726 opad_buf[ 4][i] = tmp[4][i];
12727 opad_buf[ 5][i] = 0x80000000;
12728 opad_buf[ 6][i] = 0;
12729 opad_buf[ 7][i] = 0;
12730 opad_buf[ 8][i] = 0;
12731 opad_buf[ 9][i] = 0;
12732 opad_buf[10][i] = 0;
12733 opad_buf[11][i] = 0;
12734 opad_buf[12][i] = 0;
12735 opad_buf[13][i] = 0;
12736 opad_buf[14][i] = 0;
12737 opad_buf[15][i] = (64 + 20) * 8;
12738 }
12739
12740 for (i = 0; i < 4; i++)
12741 {
12742 tmp[0][i] = opad[0][i];
12743 tmp[1][i] = opad[1][i];
12744 tmp[2][i] = opad[2][i];
12745 tmp[3][i] = opad[3][i];
12746 tmp[4][i] = opad[4][i];
12747 }
12748
12749 for (i = 0; i < 16; i++) for (l = 0; l < 4; l++) BYTESWAP (opad_buf[i][l]);
12750
12751 hashcat_sha1_64 ((__m128i *) tmp, (__m128i *) opad_buf);
12752
12753 for (i = 0; i < 4; i++)
12754 {
12755 out[0][i] = tmp[0][i];
12756 out[1][i] = tmp[1][i];
12757 out[2][i] = tmp[2][i];
12758 out[3][i] = tmp[3][i];
12759 out[4][i] = tmp[4][i];
12760 }
12761
12762 /**
12763 * loop hmac
12764 */
12765
12766 for (j = 0; j < salt->iterations - 1; j++)
12767 {
12768 for (i = 0; i < 4; i++)
12769 {
12770 ipad_buf[ 0][i] = tmp[0][i];
12771 ipad_buf[ 1][i] = tmp[1][i];
12772 ipad_buf[ 2][i] = tmp[2][i];
12773 ipad_buf[ 3][i] = tmp[3][i];
12774 ipad_buf[ 4][i] = tmp[4][i];
12775 ipad_buf[ 5][i] = 0x80000000;
12776 ipad_buf[ 6][i] = 0;
12777 ipad_buf[ 7][i] = 0;
12778 ipad_buf[ 8][i] = 0;
12779 ipad_buf[ 9][i] = 0;
12780 ipad_buf[10][i] = 0;
12781 ipad_buf[11][i] = 0;
12782 ipad_buf[12][i] = 0;
12783 ipad_buf[13][i] = 0;
12784 ipad_buf[14][i] = 0;
12785 ipad_buf[15][i] = (64 + 20) * 8;
12786 }
12787
12788 for (i = 0; i < 4; i++)
12789 {
12790 tmp[0][i] = ipad[0][i];
12791 tmp[1][i] = ipad[1][i];
12792 tmp[2][i] = ipad[2][i];
12793 tmp[3][i] = ipad[3][i];
12794 tmp[4][i] = ipad[4][i];
12795 }
12796
12797 for (i = 0; i < 16; i++) for (l = 0; l < 4; l++) BYTESWAP (ipad_buf[i][l]);
12798
12799 hashcat_sha1_64 ((__m128i *) tmp, (__m128i *) ipad_buf);
12800
12801 for (i = 0; i < 4; i++)
12802 {
12803 opad_buf[ 0][i] = tmp[0][i];
12804 opad_buf[ 1][i] = tmp[1][i];
12805 opad_buf[ 2][i] = tmp[2][i];
12806 opad_buf[ 3][i] = tmp[3][i];
12807 opad_buf[ 4][i] = tmp[4][i];
12808 opad_buf[ 5][i] = 0x80000000;
12809 opad_buf[ 6][i] = 0;
12810 opad_buf[ 7][i] = 0;
12811 opad_buf[ 8][i] = 0;
12812 opad_buf[ 9][i] = 0;
12813 opad_buf[10][i] = 0;
12814 opad_buf[11][i] = 0;
12815 opad_buf[12][i] = 0;
12816 opad_buf[13][i] = 0;
12817 opad_buf[14][i] = 0;
12818 opad_buf[15][i] = (64 + 20) * 8;
12819 }
12820
12821 for (i = 0; i < 4; i++)
12822 {
12823 tmp[0][i] = opad[0][i];
12824 tmp[1][i] = opad[1][i];
12825 tmp[2][i] = opad[2][i];
12826 tmp[3][i] = opad[3][i];
12827 tmp[4][i] = opad[4][i];
12828 }
12829
12830 for (i = 0; i < 16; i++) for (l = 0; l < 4; l++) BYTESWAP (opad_buf[i][l]);
12831
12832 hashcat_sha1_64 ((__m128i *) tmp, (__m128i *) opad_buf);
12833
12834 for (i = 0; i < 4; i++)
12835 {
12836 out[0][i] ^= tmp[0][i];
12837 out[1][i] ^= tmp[1][i];
12838 out[2][i] ^= tmp[2][i];
12839 out[3][i] ^= tmp[3][i];
12840 out[4][i] ^= tmp[4][i];
12841 }
12842 }
12843
12844 for (i = 0; i < 4; i++)
12845 {
12846 digests[i].buf.sha1[0] = out[0][i];
12847 digests[i].buf.sha1[1] = out[1][i];
12848 digests[i].buf.sha1[2] = out[2][i];
12849 digests[i].buf.sha1[3] = out[3][i];
12850 digests[i].buf.sha1[4] = out[4][i] & 0xffff03ff;
12851 }
12852
12853 thread_parameter->indb (thread_parameter, plains, digests, salt);
12854 }
12855 }
12856
hashing_06900(thread_parameter_t * thread_parameter,plain_t * plains)12857 void hashing_06900 (thread_parameter_t *thread_parameter, plain_t *plains)
12858 {
12859 digest_t digests[4];
12860
12861 db_t *db = thread_parameter->db;
12862
12863 uint32_t i;
12864
12865 for (i = 0; i < 4; i++)
12866 {
12867 plains[i].buf[15] = plains[i].len * 8;
12868 }
12869
12870 gost_64 (plains, digests);
12871
12872 thread_parameter->indb (thread_parameter, plains, digests, db->salts_buf[0]);
12873 }
12874
hashing_07000(thread_parameter_t * thread_parameter,plain_t * in)12875 void hashing_07000 (thread_parameter_t *thread_parameter, plain_t *in)
12876 {
12877 digest_sha1_sse2_t digests;
12878
12879 digest_t dgst[4];
12880
12881 plain_t plains[4];
12882
12883 db_t *db = thread_parameter->db;
12884
12885 uint32_t salts_idx;
12886
12887 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
12888 {
12889 salt_t *salt = db->salts_buf[salts_idx];
12890
12891 if (salt->indexes_found == salt->indexes_cnt) continue;
12892
12893 plain_init (plains);
12894
12895 sha1_init_sse2 (&digests);
12896
12897 sha1_update_sse2_max55 (plains, salt->salt_plain_struct);
12898
12899 sha1_update_sse2_max55 (plains, in);
12900
12901 sha1_update_sse2_max55 (plains, salt->additional_plain_struct);
12902
12903 sha1_final_sse2_max55 (plains, &digests);
12904
12905 transpose_sha1_digest (&digests, dgst);
12906
12907 thread_parameter->indb (thread_parameter, in, dgst, salt);
12908 }
12909 }
12910
hashing_07100(thread_parameter_t * thread_parameter,plain_t * plains)12911 void hashing_07100 (thread_parameter_t *thread_parameter, plain_t *plains)
12912 {
12913 digest_t digests[4];
12914
12915 plain_t plains_tmp[4];
12916
12917 char *ptrs_tmp[4];
12918
12919 ptrs_tmp[0] = (char *) &plains_tmp[0].buf64;
12920 ptrs_tmp[1] = (char *) &plains_tmp[1].buf64;
12921 ptrs_tmp[2] = (char *) &plains_tmp[2].buf64;
12922 ptrs_tmp[3] = (char *) &plains_tmp[3].buf64;
12923
12924 uint64_t ipad[8][2] __attribute__ ((aligned (16)));
12925 uint64_t opad[8][2] __attribute__ ((aligned (16)));
12926
12927 uint64_t ipad_buf[16][2] __attribute__ ((aligned (16)));
12928 uint64_t opad_buf[16][2] __attribute__ ((aligned (16)));
12929
12930 db_t *db = thread_parameter->db;
12931
12932 uint32_t k;
12933
12934 for (k = 0; k < 4; k += 2)
12935 {
12936 uint32_t i;
12937 uint32_t j;
12938 uint32_t l;
12939
12940 for (i = 0; i < 2; i++)
12941 {
12942 for (j = 0; j < 16; j++)
12943 {
12944 ipad_buf[j][i] = 0x3636363636363636 ^ plains[i + k].buf64[j];
12945 opad_buf[j][i] = 0x5c5c5c5c5c5c5c5c ^ plains[i + k].buf64[j];
12946 }
12947
12948 ipad[0][i] = SHA512M_A;
12949 ipad[1][i] = SHA512M_B;
12950 ipad[2][i] = SHA512M_C;
12951 ipad[3][i] = SHA512M_D;
12952 ipad[4][i] = SHA512M_E;
12953 ipad[5][i] = SHA512M_F;
12954 ipad[6][i] = SHA512M_G;
12955 ipad[7][i] = SHA512M_H;
12956
12957 opad[0][i] = SHA512M_A;
12958 opad[1][i] = SHA512M_B;
12959 opad[2][i] = SHA512M_C;
12960 opad[3][i] = SHA512M_D;
12961 opad[4][i] = SHA512M_E;
12962 opad[5][i] = SHA512M_F;
12963 opad[6][i] = SHA512M_G;
12964 opad[7][i] = SHA512M_H;
12965 }
12966
12967 hashcat_sha512_64 ((__m128i *) ipad, (__m128i *) ipad_buf);
12968 hashcat_sha512_64 ((__m128i *) opad, (__m128i *) opad_buf);
12969
12970 uint32_t salts_idx;
12971
12972 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
12973 {
12974 salt_t *salt = db->salts_buf[salts_idx];
12975
12976 if (salt->indexes_found == salt->indexes_cnt) continue;
12977
12978 /**
12979 * init hmac
12980 */
12981
12982 uint64_t tmp[8][2] __attribute__ ((aligned (16)));
12983 uint64_t out[8][2] __attribute__ ((aligned (16)));
12984
12985 for (i = 0; i < 2; i++)
12986 {
12987 tmp[0][i] = ipad[0][i];
12988 tmp[1][i] = ipad[1][i];
12989 tmp[2][i] = ipad[2][i];
12990 tmp[3][i] = ipad[3][i];
12991 tmp[4][i] = ipad[4][i];
12992 tmp[5][i] = ipad[5][i];
12993 tmp[6][i] = ipad[6][i];
12994 tmp[7][i] = ipad[7][i];
12995 }
12996
12997 for (i = 0; i < 2; i++)
12998 {
12999 memcpy (ptrs_tmp[i], salt->salt_plain_buf, salt->salt_plain_len);
13000
13001 memset (ptrs_tmp[i] + salt->salt_plain_len, 0, BLOCK_SIZE - salt->salt_plain_len);
13002
13003 ptrs_tmp[i][salt->salt_plain_len + 3] = 0x01;
13004 ptrs_tmp[i][salt->salt_plain_len + 4] = 0x80;
13005
13006 for (j = 0; j < 14; j++) ipad_buf[j][i] = plains_tmp[i].buf64[j];
13007
13008 ipad_buf[14][i] = 0;
13009 ipad_buf[15][i] = (128 + salt->salt_plain_len + 4) * 8;
13010
13011 BYTESWAP64 (ipad_buf[15][i]);
13012 }
13013
13014 hashcat_sha512_64 ((__m128i *) tmp, (__m128i *) ipad_buf);
13015
13016 for (i = 0; i < 2; i++)
13017 {
13018 opad_buf[ 0][i] = tmp[0][i];
13019 opad_buf[ 1][i] = tmp[1][i];
13020 opad_buf[ 2][i] = tmp[2][i];
13021 opad_buf[ 3][i] = tmp[3][i];
13022 opad_buf[ 4][i] = tmp[4][i];
13023 opad_buf[ 5][i] = tmp[5][i];
13024 opad_buf[ 6][i] = tmp[6][i];
13025 opad_buf[ 7][i] = tmp[7][i];
13026 opad_buf[ 8][i] = 0x8000000000000000;
13027 opad_buf[ 9][i] = 0;
13028 opad_buf[10][i] = 0;
13029 opad_buf[11][i] = 0;
13030 opad_buf[12][i] = 0;
13031 opad_buf[13][i] = 0;
13032 opad_buf[14][i] = 0;
13033 opad_buf[15][i] = (128 + 64) * 8;
13034 }
13035
13036 for (i = 0; i < 2; i++)
13037 {
13038 tmp[0][i] = opad[0][i];
13039 tmp[1][i] = opad[1][i];
13040 tmp[2][i] = opad[2][i];
13041 tmp[3][i] = opad[3][i];
13042 tmp[4][i] = opad[4][i];
13043 tmp[5][i] = opad[5][i];
13044 tmp[6][i] = opad[6][i];
13045 tmp[7][i] = opad[7][i];
13046 }
13047
13048 for (i = 0; i < 2; i++) for (j = 0; j < 16; j++) BYTESWAP64 (opad_buf[j][i]);
13049
13050 hashcat_sha512_64 ((__m128i *) tmp, (__m128i *) opad_buf);
13051
13052 for (i = 0; i < 2; i++)
13053 {
13054 out[0][i] = tmp[0][i];
13055 out[1][i] = tmp[1][i];
13056 out[2][i] = tmp[2][i];
13057 out[3][i] = tmp[3][i];
13058 out[4][i] = tmp[4][i];
13059 out[5][i] = tmp[5][i];
13060 out[6][i] = tmp[6][i];
13061 out[7][i] = tmp[7][i];
13062 }
13063
13064 /**
13065 * loop hmac
13066 */
13067
13068 for (j = 0; j < salt->iterations - 1; j++)
13069 {
13070 for (i = 0; i < 2; i++)
13071 {
13072 ipad_buf[ 0][i] = tmp[0][i];
13073 ipad_buf[ 1][i] = tmp[1][i];
13074 ipad_buf[ 2][i] = tmp[2][i];
13075 ipad_buf[ 3][i] = tmp[3][i];
13076 ipad_buf[ 4][i] = tmp[4][i];
13077 ipad_buf[ 5][i] = tmp[5][i];
13078 ipad_buf[ 6][i] = tmp[6][i];
13079 ipad_buf[ 7][i] = tmp[7][i];
13080 ipad_buf[ 8][i] = 0x8000000000000000;
13081 ipad_buf[ 9][i] = 0;
13082 ipad_buf[10][i] = 0;
13083 ipad_buf[11][i] = 0;
13084 ipad_buf[12][i] = 0;
13085 ipad_buf[13][i] = 0;
13086 ipad_buf[14][i] = 0;
13087 ipad_buf[15][i] = (128 + 64) * 8;
13088 }
13089
13090 for (i = 0; i < 2; i++)
13091 {
13092 tmp[0][i] = ipad[0][i];
13093 tmp[1][i] = ipad[1][i];
13094 tmp[2][i] = ipad[2][i];
13095 tmp[3][i] = ipad[3][i];
13096 tmp[4][i] = ipad[4][i];
13097 tmp[5][i] = ipad[5][i];
13098 tmp[6][i] = ipad[6][i];
13099 tmp[7][i] = ipad[7][i];
13100 }
13101
13102 for (i = 0; i < 2; i++) for (l = 0; l < 16; l++) BYTESWAP64 (ipad_buf[l][i]);
13103
13104 hashcat_sha512_64 ((__m128i *) tmp, (__m128i *) ipad_buf);
13105
13106 for (i = 0; i < 2; i++)
13107 {
13108 opad_buf[ 0][i] = tmp[0][i];
13109 opad_buf[ 1][i] = tmp[1][i];
13110 opad_buf[ 2][i] = tmp[2][i];
13111 opad_buf[ 3][i] = tmp[3][i];
13112 opad_buf[ 4][i] = tmp[4][i];
13113 opad_buf[ 5][i] = tmp[5][i];
13114 opad_buf[ 6][i] = tmp[6][i];
13115 opad_buf[ 7][i] = tmp[7][i];
13116 opad_buf[ 8][i] = 0x8000000000000000;
13117 opad_buf[ 9][i] = 0;
13118 opad_buf[10][i] = 0;
13119 opad_buf[11][i] = 0;
13120 opad_buf[12][i] = 0;
13121 opad_buf[13][i] = 0;
13122 opad_buf[14][i] = 0;
13123 opad_buf[15][i] = (128 + 64) * 8;
13124 }
13125
13126 for (i = 0; i < 2; i++)
13127 {
13128 tmp[0][i] = opad[0][i];
13129 tmp[1][i] = opad[1][i];
13130 tmp[2][i] = opad[2][i];
13131 tmp[3][i] = opad[3][i];
13132 tmp[4][i] = opad[4][i];
13133 tmp[5][i] = opad[5][i];
13134 tmp[6][i] = opad[6][i];
13135 tmp[7][i] = opad[7][i];
13136 }
13137
13138 for (i = 0; i < 2; i++) for (l = 0; l < 16; l++) BYTESWAP64 (opad_buf[l][i]);
13139
13140 hashcat_sha512_64 ((__m128i *) tmp, (__m128i *) opad_buf);
13141
13142 for (i = 0; i < 2; i++)
13143 {
13144 out[0][i] ^= tmp[0][i];
13145 out[1][i] ^= tmp[1][i];
13146 out[2][i] ^= tmp[2][i];
13147 out[3][i] ^= tmp[3][i];
13148 out[4][i] ^= tmp[4][i];
13149 out[5][i] ^= tmp[5][i];
13150 out[6][i] ^= tmp[6][i];
13151 out[7][i] ^= tmp[7][i];
13152 }
13153 }
13154
13155 for (i = 0; i < 2; i++)
13156 {
13157 digests[i + k].buf.sha512[0] = out[0][i];
13158 digests[i + k].buf.sha512[1] = out[1][i];
13159 digests[i + k].buf.sha512[2] = out[2][i];
13160 digests[i + k].buf.sha512[3] = out[3][i];
13161 digests[i + k].buf.sha512[4] = out[4][i];
13162 digests[i + k].buf.sha512[5] = out[5][i];
13163 digests[i + k].buf.sha512[6] = out[6][i];
13164 digests[i + k].buf.sha512[7] = out[7][i];
13165 }
13166
13167 thread_parameter->indb (thread_parameter, plains, digests, salt);
13168 }
13169 }
13170 }
13171
hashing_07300(thread_parameter_t * thread_parameter,plain_t * plains)13172 void hashing_07300 (thread_parameter_t *thread_parameter, plain_t *plains)
13173 {
13174 digest_t digests[4];
13175
13176 uint32_t ipad_dgst[5][4] __attribute__ ((aligned (16)));
13177 uint32_t opad_dgst[5][4] __attribute__ ((aligned (16)));
13178
13179 uint32_t ipad_buf[16][4] __attribute__ ((aligned (16)));
13180 uint32_t opad_buf[16][4] __attribute__ ((aligned (16)));
13181
13182 db_t *db = thread_parameter->db;
13183
13184 uint32_t i;
13185 uint32_t j;
13186
13187 for (i = 0; i < 4; i++)
13188 {
13189 for (j = 0; j < 16; j++)
13190 {
13191 ipad_buf[j][i] = 0x36363636 ^ plains[i].buf[j];
13192 opad_buf[j][i] = 0x5c5c5c5c ^ plains[i].buf[j];
13193 }
13194
13195 ipad_dgst[0][i] = SHA1M_A;
13196 ipad_dgst[1][i] = SHA1M_B;
13197 ipad_dgst[2][i] = SHA1M_C;
13198 ipad_dgst[3][i] = SHA1M_D;
13199 ipad_dgst[4][i] = SHA1M_E;
13200
13201 opad_dgst[0][i] = SHA1M_A;
13202 opad_dgst[1][i] = SHA1M_B;
13203 opad_dgst[2][i] = SHA1M_C;
13204 opad_dgst[3][i] = SHA1M_D;
13205 opad_dgst[4][i] = SHA1M_E;
13206 }
13207
13208 hashcat_sha1_64 ((__m128i *) ipad_dgst, (__m128i *) ipad_buf);
13209 hashcat_sha1_64 ((__m128i *) opad_dgst, (__m128i *) opad_buf);
13210
13211 uint32_t salts_idx;
13212
13213 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
13214 {
13215 salt_t *salt = db->salts_buf[salts_idx];
13216
13217 if (salt->indexes_found == salt->indexes_cnt) continue;
13218
13219 uint32_t ipad_dgst_tmp[5][4] __attribute__ ((aligned (16)));
13220 uint32_t opad_dgst_tmp[5][4] __attribute__ ((aligned (16)));
13221
13222 for (i = 0; i < 4; i++)
13223 {
13224 for (j = 0; j < 5; j++)
13225 {
13226 ipad_dgst_tmp[j][i] = ipad_dgst[j][i];
13227 opad_dgst_tmp[j][i] = opad_dgst[j][i];
13228 }
13229 }
13230
13231 uint32_t *salt_ptr = (uint32_t *) salt->salt_plain_buf;
13232
13233 int size = salt->salt_plain_len;
13234
13235 int left;
13236 int off;
13237
13238 for (left = size, off = 0; left >= 56; left -= 64, off += 16)
13239 {
13240 for (i = 0; i < 4; i++)
13241 {
13242 for (j = 0; j < 16; j++)
13243 {
13244 ipad_buf[j][i] = salt_ptr[off + j];
13245 }
13246 }
13247
13248 hashcat_sha1_64 ((__m128i *) ipad_dgst_tmp, (__m128i *) ipad_buf);
13249 }
13250
13251 for (i = 0; i < 4; i++)
13252 {
13253 for (j = 0; j < 14; j++)
13254 {
13255 ipad_buf[j][i] = salt_ptr[off + j];
13256 }
13257
13258 ipad_buf[14][i] = 0;
13259 ipad_buf[15][i] = (64 + salt->salt_plain_len) * 8;
13260
13261 BYTESWAP (ipad_buf[15][i]);
13262 }
13263
13264
13265 hashcat_sha1_64 ((__m128i *) ipad_dgst_tmp, (__m128i *) ipad_buf);
13266
13267 for (i = 0; i < 4; i++)
13268 {
13269 for (j = 0; j < 5; j++)
13270 {
13271 opad_buf[j][i] = ipad_dgst_tmp[j][i];
13272 }
13273
13274 opad_buf[ 5][i] = 0x80000000;
13275 opad_buf[ 6][i] = 0;
13276 opad_buf[ 7][i] = 0;
13277 opad_buf[ 8][i] = 0;
13278 opad_buf[ 9][i] = 0;
13279 opad_buf[10][i] = 0;
13280 opad_buf[11][i] = 0;
13281 opad_buf[12][i] = 0;
13282 opad_buf[13][i] = 0;
13283 opad_buf[14][i] = 0;
13284 opad_buf[15][i] = (64 + 20) * 8;
13285 }
13286
13287 for (i = 0; i < 4; i++) for (j = 0; j < 16; j++) BYTESWAP (opad_buf[j][i]);
13288
13289 hashcat_sha1_64 ((__m128i *) opad_dgst_tmp, (__m128i *) opad_buf);
13290
13291 for (i = 0; i < 4; i++)
13292 {
13293 for (j = 0; j < 5; j++)
13294 {
13295 digests[i].buf.sha1[j] = opad_dgst_tmp[j][i];
13296 }
13297 }
13298
13299 thread_parameter->indb (thread_parameter, plains, digests, salt);
13300 }
13301 }
13302
hashing_07400(thread_parameter_t * thread_parameter,plain_t * in)13303 void hashing_07400 (thread_parameter_t *thread_parameter, plain_t *in)
13304 {
13305 db_t *db = thread_parameter->db;
13306
13307 uint32_t salts_idx;
13308
13309 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
13310 {
13311 salt_t *salt = db->salts_buf[salts_idx];
13312
13313 if (salt->indexes_found == salt->indexes_cnt) continue;
13314
13315 char *salt_buf = salt->salt_plain_buf;
13316 int salt_len = salt->salt_plain_len;
13317
13318 char *password0_buf = (char *) in[0].buf;
13319 char *password1_buf = (char *) in[1].buf;
13320 char *password2_buf = (char *) in[2].buf;
13321 char *password3_buf = (char *) in[3].buf;
13322 int password0_len = in[0].len;
13323 int password1_len = in[1].len;
13324 int password2_len = in[2].len;
13325 int password3_len = in[3].len;
13326
13327 hc_sha256_ctx ctx0;
13328 hc_sha256_ctx ctx1;
13329 hc_sha256_ctx ctx2;
13330 hc_sha256_ctx ctx3;
13331 hc_sha256_ctx alt_ctx0;
13332 hc_sha256_ctx alt_ctx1;
13333 hc_sha256_ctx alt_ctx2;
13334 hc_sha256_ctx alt_ctx3;
13335
13336 hc_sha256_ctx p_bytes0;
13337 hc_sha256_ctx p_bytes1;
13338 hc_sha256_ctx p_bytes2;
13339 hc_sha256_ctx p_bytes3;
13340 hc_sha256_ctx s_bytes0;
13341 hc_sha256_ctx s_bytes1;
13342 hc_sha256_ctx s_bytes2;
13343 hc_sha256_ctx s_bytes3;
13344
13345 /* Prepare for the real work. */
13346 sha256_init (&ctx0);
13347 sha256_init (&ctx1);
13348 sha256_init (&ctx2);
13349 sha256_init (&ctx3);
13350
13351 /* Add the key string. */
13352 sha256_update (&ctx0, password0_buf, password0_len);
13353 sha256_update (&ctx1, password1_buf, password1_len);
13354 sha256_update (&ctx2, password2_buf, password2_len);
13355 sha256_update (&ctx3, password3_buf, password3_len);
13356
13357 /* The last part is the salt string. This must be at most 16
13358 characters and it ends at the first `$' character (for
13359 compatibility with existing implementations). */
13360 sha256_update (&ctx0, salt_buf, salt_len);
13361 sha256_update (&ctx1, salt_buf, salt_len);
13362 sha256_update (&ctx2, salt_buf, salt_len);
13363 sha256_update (&ctx3, salt_buf, salt_len);
13364
13365 /* Compute alternate sha256 sum with input KEY, SALT, and KEY. The
13366 final result will be added to the first context. */
13367 sha256_init (&alt_ctx0);
13368 sha256_init (&alt_ctx1);
13369 sha256_init (&alt_ctx2);
13370 sha256_init (&alt_ctx3);
13371
13372 /* Add key. */
13373 sha256_update (&alt_ctx0, password0_buf, password0_len);
13374 sha256_update (&alt_ctx1, password1_buf, password1_len);
13375 sha256_update (&alt_ctx2, password2_buf, password2_len);
13376 sha256_update (&alt_ctx3, password3_buf, password3_len);
13377
13378 /* Add salt. */
13379 sha256_update (&alt_ctx0, salt_buf, salt_len);
13380 sha256_update (&alt_ctx1, salt_buf, salt_len);
13381 sha256_update (&alt_ctx2, salt_buf, salt_len);
13382 sha256_update (&alt_ctx3, salt_buf, salt_len);
13383
13384 /* Add key again. */
13385 sha256_update (&alt_ctx0, password0_buf, password0_len);
13386 sha256_update (&alt_ctx1, password1_buf, password1_len);
13387 sha256_update (&alt_ctx2, password2_buf, password2_len);
13388 sha256_update (&alt_ctx3, password3_buf, password3_len);
13389
13390 /* Now get result of this (32 bytes) and add it to the other context. */
13391 sha256_final (&alt_ctx0);
13392 sha256_final (&alt_ctx1);
13393 sha256_final (&alt_ctx2);
13394 sha256_final (&alt_ctx3);
13395
13396 /* Add for any character in the key one byte of the alternate sum. */
13397
13398 sha256_update (&ctx0, (char *) alt_ctx0.state, password0_len);
13399 sha256_update (&ctx1, (char *) alt_ctx1.state, password1_len);
13400 sha256_update (&ctx2, (char *) alt_ctx2.state, password2_len);
13401 sha256_update (&ctx3, (char *) alt_ctx3.state, password3_len);
13402
13403 /* Take the binary representation of the length of the key and for every
13404 1 add the alternate sum, for every 0 the key. */
13405
13406 int cnt;
13407
13408 for (cnt = password0_len; cnt > 0; cnt >>= 1)
13409 {
13410 if ((cnt & 1) != 0)
13411 sha256_update (&ctx0, (char *) alt_ctx0.state, 32);
13412 else
13413 sha256_update (&ctx0, password0_buf, password0_len);
13414 }
13415
13416 for (cnt = password1_len; cnt > 0; cnt >>= 1)
13417 {
13418 if ((cnt & 1) != 0)
13419 sha256_update (&ctx1, (char *) alt_ctx1.state, 32);
13420 else
13421 sha256_update (&ctx1, password1_buf, password1_len);
13422 }
13423
13424 for (cnt = password2_len; cnt > 0; cnt >>= 1)
13425 {
13426 if ((cnt & 1) != 0)
13427 sha256_update (&ctx2, (char *) alt_ctx2.state, 32);
13428 else
13429 sha256_update (&ctx2, password2_buf, password2_len);
13430 }
13431
13432 for (cnt = password3_len; cnt > 0; cnt >>= 1)
13433 {
13434 if ((cnt & 1) != 0)
13435 sha256_update (&ctx3, (char *) alt_ctx3.state, 32);
13436 else
13437 sha256_update (&ctx3, password3_buf, password3_len);
13438 }
13439
13440 /* Create intermediate result. */
13441 sha256_final (&ctx0);
13442 sha256_final (&ctx1);
13443 sha256_final (&ctx2);
13444 sha256_final (&ctx3);
13445
13446 /* Start computation of P byte sequence. */
13447 sha256_init (&p_bytes0);
13448 sha256_init (&p_bytes1);
13449 sha256_init (&p_bytes2);
13450 sha256_init (&p_bytes3);
13451
13452 /* For every character in the password add the entire password. */
13453 for (cnt = 0; cnt < password0_len; cnt++)
13454 {
13455 sha256_update (&p_bytes0, password0_buf, password0_len);
13456 }
13457
13458 for (cnt = 0; cnt < password1_len; cnt++)
13459 {
13460 sha256_update (&p_bytes1, password1_buf, password1_len);
13461 }
13462
13463 for (cnt = 0; cnt < password2_len; cnt++)
13464 {
13465 sha256_update (&p_bytes2, password2_buf, password2_len);
13466 }
13467
13468 for (cnt = 0; cnt < password3_len; cnt++)
13469 {
13470 sha256_update (&p_bytes3, password3_buf, password3_len);
13471 }
13472
13473 /* Finish the state. */
13474 sha256_final (&p_bytes0);
13475 sha256_final (&p_bytes1);
13476 sha256_final (&p_bytes2);
13477 sha256_final (&p_bytes3);
13478
13479 /* Start computation of S byte sequence. */
13480 sha256_init (&s_bytes0);
13481 sha256_init (&s_bytes1);
13482 sha256_init (&s_bytes2);
13483 sha256_init (&s_bytes3);
13484
13485 /* For every character in the password add the entire password. */
13486 for (cnt = 0; cnt < 16 + ((unsigned char*) ctx0.state)[0]; cnt++)
13487 {
13488 sha256_update (&s_bytes0, salt_buf, salt_len);
13489 }
13490
13491 for (cnt = 0; cnt < 16 + ((unsigned char*) ctx1.state)[0]; cnt++)
13492 {
13493 sha256_update (&s_bytes1, salt_buf, salt_len);
13494 }
13495
13496 for (cnt = 0; cnt < 16 + ((unsigned char*) ctx2.state)[0]; cnt++)
13497 {
13498 sha256_update (&s_bytes2, salt_buf, salt_len);
13499 }
13500
13501 for (cnt = 0; cnt < 16 + ((unsigned char*) ctx3.state)[0]; cnt++)
13502 {
13503 sha256_update (&s_bytes3, salt_buf, salt_len);
13504 }
13505
13506 /* Finish the state. */
13507 sha256_final (&s_bytes0);
13508 sha256_final (&s_bytes1);
13509 sha256_final (&s_bytes2);
13510 sha256_final (&s_bytes3);
13511
13512 /* sse2 specific */
13513
13514 plain_t plain_alt_ctx[4];
13515
13516 plain_alt_ctx[0].buf[0] = ctx0.state[0];
13517 plain_alt_ctx[0].buf[1] = ctx0.state[1];
13518 plain_alt_ctx[0].buf[2] = ctx0.state[2];
13519 plain_alt_ctx[0].buf[3] = ctx0.state[3];
13520 plain_alt_ctx[0].buf[4] = ctx0.state[4];
13521 plain_alt_ctx[0].buf[5] = ctx0.state[5];
13522 plain_alt_ctx[0].buf[6] = ctx0.state[6];
13523 plain_alt_ctx[0].buf[7] = ctx0.state[7];
13524 plain_alt_ctx[1].buf[0] = ctx1.state[0];
13525 plain_alt_ctx[1].buf[1] = ctx1.state[1];
13526 plain_alt_ctx[1].buf[2] = ctx1.state[2];
13527 plain_alt_ctx[1].buf[3] = ctx1.state[3];
13528 plain_alt_ctx[1].buf[4] = ctx1.state[4];
13529 plain_alt_ctx[1].buf[5] = ctx1.state[5];
13530 plain_alt_ctx[1].buf[6] = ctx1.state[6];
13531 plain_alt_ctx[1].buf[7] = ctx1.state[7];
13532 plain_alt_ctx[2].buf[0] = ctx2.state[0];
13533 plain_alt_ctx[2].buf[1] = ctx2.state[1];
13534 plain_alt_ctx[2].buf[2] = ctx2.state[2];
13535 plain_alt_ctx[2].buf[3] = ctx2.state[3];
13536 plain_alt_ctx[2].buf[4] = ctx2.state[4];
13537 plain_alt_ctx[2].buf[5] = ctx2.state[5];
13538 plain_alt_ctx[2].buf[6] = ctx2.state[6];
13539 plain_alt_ctx[2].buf[7] = ctx2.state[7];
13540 plain_alt_ctx[3].buf[0] = ctx3.state[0];
13541 plain_alt_ctx[3].buf[1] = ctx3.state[1];
13542 plain_alt_ctx[3].buf[2] = ctx3.state[2];
13543 plain_alt_ctx[3].buf[3] = ctx3.state[3];
13544 plain_alt_ctx[3].buf[4] = ctx3.state[4];
13545 plain_alt_ctx[3].buf[5] = ctx3.state[5];
13546 plain_alt_ctx[3].buf[6] = ctx3.state[6];
13547 plain_alt_ctx[3].buf[7] = ctx3.state[7];
13548
13549 plain_alt_ctx[0].len = 32;
13550 plain_alt_ctx[1].len = 32;
13551 plain_alt_ctx[2].len = 32;
13552 plain_alt_ctx[3].len = 32;
13553
13554 plain_t plain_p_bytes[4];
13555
13556 plain_p_bytes[0].buf[0] = p_bytes0.state[0];
13557 plain_p_bytes[0].buf[1] = p_bytes0.state[1];
13558 plain_p_bytes[0].buf[2] = p_bytes0.state[2];
13559 plain_p_bytes[0].buf[3] = p_bytes0.state[3];
13560 plain_p_bytes[0].buf[4] = p_bytes0.state[4];
13561 plain_p_bytes[0].buf[5] = p_bytes0.state[5];
13562 plain_p_bytes[0].buf[6] = p_bytes0.state[6];
13563 plain_p_bytes[0].buf[7] = p_bytes0.state[7];
13564 plain_p_bytes[1].buf[0] = p_bytes1.state[0];
13565 plain_p_bytes[1].buf[1] = p_bytes1.state[1];
13566 plain_p_bytes[1].buf[2] = p_bytes1.state[2];
13567 plain_p_bytes[1].buf[3] = p_bytes1.state[3];
13568 plain_p_bytes[1].buf[4] = p_bytes1.state[4];
13569 plain_p_bytes[1].buf[5] = p_bytes1.state[5];
13570 plain_p_bytes[1].buf[6] = p_bytes1.state[6];
13571 plain_p_bytes[1].buf[7] = p_bytes1.state[7];
13572 plain_p_bytes[2].buf[0] = p_bytes2.state[0];
13573 plain_p_bytes[2].buf[1] = p_bytes2.state[1];
13574 plain_p_bytes[2].buf[2] = p_bytes2.state[2];
13575 plain_p_bytes[2].buf[3] = p_bytes2.state[3];
13576 plain_p_bytes[2].buf[4] = p_bytes2.state[4];
13577 plain_p_bytes[2].buf[5] = p_bytes2.state[5];
13578 plain_p_bytes[2].buf[6] = p_bytes2.state[6];
13579 plain_p_bytes[2].buf[7] = p_bytes2.state[7];
13580 plain_p_bytes[3].buf[0] = p_bytes3.state[0];
13581 plain_p_bytes[3].buf[1] = p_bytes3.state[1];
13582 plain_p_bytes[3].buf[2] = p_bytes3.state[2];
13583 plain_p_bytes[3].buf[3] = p_bytes3.state[3];
13584 plain_p_bytes[3].buf[4] = p_bytes3.state[4];
13585 plain_p_bytes[3].buf[5] = p_bytes3.state[5];
13586 plain_p_bytes[3].buf[6] = p_bytes3.state[6];
13587 plain_p_bytes[3].buf[7] = p_bytes3.state[7];
13588
13589 plain_p_bytes[0].len = password0_len;
13590 plain_p_bytes[1].len = password1_len;
13591 plain_p_bytes[2].len = password2_len;
13592 plain_p_bytes[3].len = password3_len;
13593
13594 plain_t plain_s_bytes[4];
13595
13596 plain_s_bytes[0].buf[0] = s_bytes0.state[0];
13597 plain_s_bytes[0].buf[1] = s_bytes0.state[1];
13598 plain_s_bytes[0].buf[2] = s_bytes0.state[2];
13599 plain_s_bytes[0].buf[3] = s_bytes0.state[3];
13600 plain_s_bytes[0].buf[4] = s_bytes0.state[4];
13601 plain_s_bytes[0].buf[5] = s_bytes0.state[5];
13602 plain_s_bytes[0].buf[6] = s_bytes0.state[6];
13603 plain_s_bytes[0].buf[7] = s_bytes0.state[7];
13604 plain_s_bytes[1].buf[0] = s_bytes1.state[0];
13605 plain_s_bytes[1].buf[1] = s_bytes1.state[1];
13606 plain_s_bytes[1].buf[2] = s_bytes1.state[2];
13607 plain_s_bytes[1].buf[3] = s_bytes1.state[3];
13608 plain_s_bytes[1].buf[4] = s_bytes1.state[4];
13609 plain_s_bytes[1].buf[5] = s_bytes1.state[5];
13610 plain_s_bytes[1].buf[6] = s_bytes1.state[6];
13611 plain_s_bytes[1].buf[7] = s_bytes1.state[7];
13612 plain_s_bytes[2].buf[0] = s_bytes2.state[0];
13613 plain_s_bytes[2].buf[1] = s_bytes2.state[1];
13614 plain_s_bytes[2].buf[2] = s_bytes2.state[2];
13615 plain_s_bytes[2].buf[3] = s_bytes2.state[3];
13616 plain_s_bytes[2].buf[4] = s_bytes2.state[4];
13617 plain_s_bytes[2].buf[5] = s_bytes2.state[5];
13618 plain_s_bytes[2].buf[6] = s_bytes2.state[6];
13619 plain_s_bytes[2].buf[7] = s_bytes2.state[7];
13620 plain_s_bytes[3].buf[0] = s_bytes3.state[0];
13621 plain_s_bytes[3].buf[1] = s_bytes3.state[1];
13622 plain_s_bytes[3].buf[2] = s_bytes3.state[2];
13623 plain_s_bytes[3].buf[3] = s_bytes3.state[3];
13624 plain_s_bytes[3].buf[4] = s_bytes3.state[4];
13625 plain_s_bytes[3].buf[5] = s_bytes3.state[5];
13626 plain_s_bytes[3].buf[6] = s_bytes3.state[6];
13627 plain_s_bytes[3].buf[7] = s_bytes3.state[7];
13628
13629 plain_s_bytes[0].len = salt_len;
13630 plain_s_bytes[1].len = salt_len;
13631 plain_s_bytes[2].len = salt_len;
13632 plain_s_bytes[3].len = salt_len;
13633
13634 /* Repeatedly run the collected hash value through sha256 to
13635 burn CPU cycles. */
13636
13637 for (cnt = 0; cnt < (int) salt->iterations; cnt++)
13638 {
13639 /* New context. */
13640
13641 digest_sha256_sse2_t sse2_ctx;
13642
13643 sha256_init_sse2 (&sse2_ctx);
13644
13645 plain_t sse2_plain[4];
13646
13647 plain_init (sse2_plain);
13648
13649 /* Add key or last result. */
13650 if ((cnt & 1) != 0)
13651 sha256_update_sse2 (sse2_plain, &sse2_ctx, plain_p_bytes);
13652 else
13653 sha256_update_sse2 (sse2_plain, &sse2_ctx, plain_alt_ctx);
13654
13655 /* Add salt for numbers not divisible by 3. */
13656 if (cnt % 3 != 0)
13657 sha256_update_sse2 (sse2_plain, &sse2_ctx, plain_s_bytes);
13658
13659 /* Add key for numbers not divisible by 7. */
13660 if (cnt % 7 != 0)
13661 sha256_update_sse2 (sse2_plain, &sse2_ctx, plain_p_bytes);
13662
13663 /* Add key or last result. */
13664 if ((cnt & 1) != 0)
13665 sha256_update_sse2 (sse2_plain, &sse2_ctx, plain_alt_ctx);
13666 else
13667 sha256_update_sse2 (sse2_plain, &sse2_ctx, plain_p_bytes);
13668
13669 /* Create intermediate [SIC] result. */
13670 sha256_final_sse2 (sse2_plain, &sse2_ctx);
13671
13672 plain_alt_ctx[0].buf[0] = sse2_ctx.buf32[ 0];
13673 plain_alt_ctx[1].buf[0] = sse2_ctx.buf32[ 1];
13674 plain_alt_ctx[2].buf[0] = sse2_ctx.buf32[ 2];
13675 plain_alt_ctx[3].buf[0] = sse2_ctx.buf32[ 3];
13676 plain_alt_ctx[0].buf[1] = sse2_ctx.buf32[ 4];
13677 plain_alt_ctx[1].buf[1] = sse2_ctx.buf32[ 5];
13678 plain_alt_ctx[2].buf[1] = sse2_ctx.buf32[ 6];
13679 plain_alt_ctx[3].buf[1] = sse2_ctx.buf32[ 7];
13680 plain_alt_ctx[0].buf[2] = sse2_ctx.buf32[ 8];
13681 plain_alt_ctx[1].buf[2] = sse2_ctx.buf32[ 9];
13682 plain_alt_ctx[2].buf[2] = sse2_ctx.buf32[10];
13683 plain_alt_ctx[3].buf[2] = sse2_ctx.buf32[11];
13684 plain_alt_ctx[0].buf[3] = sse2_ctx.buf32[12];
13685 plain_alt_ctx[1].buf[3] = sse2_ctx.buf32[13];
13686 plain_alt_ctx[2].buf[3] = sse2_ctx.buf32[14];
13687 plain_alt_ctx[3].buf[3] = sse2_ctx.buf32[15];
13688 plain_alt_ctx[0].buf[4] = sse2_ctx.buf32[16];
13689 plain_alt_ctx[1].buf[4] = sse2_ctx.buf32[17];
13690 plain_alt_ctx[2].buf[4] = sse2_ctx.buf32[18];
13691 plain_alt_ctx[3].buf[4] = sse2_ctx.buf32[19];
13692 plain_alt_ctx[0].buf[5] = sse2_ctx.buf32[20];
13693 plain_alt_ctx[1].buf[5] = sse2_ctx.buf32[21];
13694 plain_alt_ctx[2].buf[5] = sse2_ctx.buf32[22];
13695 plain_alt_ctx[3].buf[5] = sse2_ctx.buf32[23];
13696 plain_alt_ctx[0].buf[6] = sse2_ctx.buf32[24];
13697 plain_alt_ctx[1].buf[6] = sse2_ctx.buf32[25];
13698 plain_alt_ctx[2].buf[6] = sse2_ctx.buf32[26];
13699 plain_alt_ctx[3].buf[6] = sse2_ctx.buf32[27];
13700 plain_alt_ctx[0].buf[7] = sse2_ctx.buf32[28];
13701 plain_alt_ctx[1].buf[7] = sse2_ctx.buf32[29];
13702 plain_alt_ctx[2].buf[7] = sse2_ctx.buf32[30];
13703 plain_alt_ctx[3].buf[7] = sse2_ctx.buf32[31];
13704
13705 BYTESWAP (plain_alt_ctx[0].buf[0]);
13706 BYTESWAP (plain_alt_ctx[0].buf[1]);
13707 BYTESWAP (plain_alt_ctx[0].buf[2]);
13708 BYTESWAP (plain_alt_ctx[0].buf[3]);
13709 BYTESWAP (plain_alt_ctx[0].buf[4]);
13710 BYTESWAP (plain_alt_ctx[0].buf[5]);
13711 BYTESWAP (plain_alt_ctx[0].buf[6]);
13712 BYTESWAP (plain_alt_ctx[0].buf[7]);
13713 BYTESWAP (plain_alt_ctx[1].buf[0]);
13714 BYTESWAP (plain_alt_ctx[1].buf[1]);
13715 BYTESWAP (plain_alt_ctx[1].buf[2]);
13716 BYTESWAP (plain_alt_ctx[1].buf[3]);
13717 BYTESWAP (plain_alt_ctx[1].buf[4]);
13718 BYTESWAP (plain_alt_ctx[1].buf[5]);
13719 BYTESWAP (plain_alt_ctx[1].buf[6]);
13720 BYTESWAP (plain_alt_ctx[1].buf[7]);
13721 BYTESWAP (plain_alt_ctx[2].buf[0]);
13722 BYTESWAP (plain_alt_ctx[2].buf[1]);
13723 BYTESWAP (plain_alt_ctx[2].buf[2]);
13724 BYTESWAP (plain_alt_ctx[2].buf[3]);
13725 BYTESWAP (plain_alt_ctx[2].buf[4]);
13726 BYTESWAP (plain_alt_ctx[2].buf[5]);
13727 BYTESWAP (plain_alt_ctx[2].buf[6]);
13728 BYTESWAP (plain_alt_ctx[2].buf[7]);
13729 BYTESWAP (plain_alt_ctx[3].buf[0]);
13730 BYTESWAP (plain_alt_ctx[3].buf[1]);
13731 BYTESWAP (plain_alt_ctx[3].buf[2]);
13732 BYTESWAP (plain_alt_ctx[3].buf[3]);
13733 BYTESWAP (plain_alt_ctx[3].buf[4]);
13734 BYTESWAP (plain_alt_ctx[3].buf[5]);
13735 BYTESWAP (plain_alt_ctx[3].buf[6]);
13736 BYTESWAP (plain_alt_ctx[3].buf[7]);
13737 }
13738
13739 digest_t digest[4];
13740
13741 digest[0].buf.sha256[0] = plain_alt_ctx[0].buf[0];
13742 digest[0].buf.sha256[1] = plain_alt_ctx[0].buf[1];
13743 digest[0].buf.sha256[2] = plain_alt_ctx[0].buf[2];
13744 digest[0].buf.sha256[3] = plain_alt_ctx[0].buf[3];
13745 digest[0].buf.sha256[4] = plain_alt_ctx[0].buf[4];
13746 digest[0].buf.sha256[5] = plain_alt_ctx[0].buf[5];
13747 digest[0].buf.sha256[6] = plain_alt_ctx[0].buf[6];
13748 digest[0].buf.sha256[7] = plain_alt_ctx[0].buf[7];
13749 digest[1].buf.sha256[0] = plain_alt_ctx[1].buf[0];
13750 digest[1].buf.sha256[1] = plain_alt_ctx[1].buf[1];
13751 digest[1].buf.sha256[2] = plain_alt_ctx[1].buf[2];
13752 digest[1].buf.sha256[3] = plain_alt_ctx[1].buf[3];
13753 digest[1].buf.sha256[4] = plain_alt_ctx[1].buf[4];
13754 digest[1].buf.sha256[5] = plain_alt_ctx[1].buf[5];
13755 digest[1].buf.sha256[6] = plain_alt_ctx[1].buf[6];
13756 digest[1].buf.sha256[7] = plain_alt_ctx[1].buf[7];
13757 digest[2].buf.sha256[0] = plain_alt_ctx[2].buf[0];
13758 digest[2].buf.sha256[1] = plain_alt_ctx[2].buf[1];
13759 digest[2].buf.sha256[2] = plain_alt_ctx[2].buf[2];
13760 digest[2].buf.sha256[3] = plain_alt_ctx[2].buf[3];
13761 digest[2].buf.sha256[4] = plain_alt_ctx[2].buf[4];
13762 digest[2].buf.sha256[5] = plain_alt_ctx[2].buf[5];
13763 digest[2].buf.sha256[6] = plain_alt_ctx[2].buf[6];
13764 digest[2].buf.sha256[7] = plain_alt_ctx[2].buf[7];
13765 digest[3].buf.sha256[0] = plain_alt_ctx[3].buf[0];
13766 digest[3].buf.sha256[1] = plain_alt_ctx[3].buf[1];
13767 digest[3].buf.sha256[2] = plain_alt_ctx[3].buf[2];
13768 digest[3].buf.sha256[3] = plain_alt_ctx[3].buf[3];
13769 digest[3].buf.sha256[4] = plain_alt_ctx[3].buf[4];
13770 digest[3].buf.sha256[5] = plain_alt_ctx[3].buf[5];
13771 digest[3].buf.sha256[6] = plain_alt_ctx[3].buf[6];
13772 digest[3].buf.sha256[7] = plain_alt_ctx[3].buf[7];
13773
13774 thread_parameter->indb (thread_parameter, in, digest, salt);
13775 }
13776 }
13777
hashing_07600(thread_parameter_t * thread_parameter,plain_t * in)13778 void hashing_07600 (thread_parameter_t *thread_parameter, plain_t *in)
13779 {
13780 digest_sha1_sse2_t digests;
13781
13782 digest_t dgst[4];
13783
13784 plain_t plains[4];
13785
13786 plain_t plains_tmp[4];
13787
13788 char *ptrs_tmp[4];
13789
13790 ptrs_tmp[0] = (char *) &plains_tmp[0].buf;
13791 ptrs_tmp[1] = (char *) &plains_tmp[1].buf;
13792 ptrs_tmp[2] = (char *) &plains_tmp[2].buf;
13793 ptrs_tmp[3] = (char *) &plains_tmp[3].buf;
13794
13795 db_t *db = thread_parameter->db;
13796
13797 sha1_init_sse2 (&digests);
13798
13799 sha1_final_sse2_max55 (in, &digests);
13800
13801 transpose_sha1_digest (&digests, dgst);
13802
13803 uint32_t i;
13804
13805 for (i = 0; i < 4; i++)
13806 {
13807 uint_to_hex_lower (dgst[i].buf.sha1[0], &ptrs_tmp[i][0]);
13808 uint_to_hex_lower (dgst[i].buf.sha1[1], &ptrs_tmp[i][8]);
13809 uint_to_hex_lower (dgst[i].buf.sha1[2], &ptrs_tmp[i][16]);
13810 uint_to_hex_lower (dgst[i].buf.sha1[3], &ptrs_tmp[i][24]);
13811 uint_to_hex_lower (dgst[i].buf.sha1[4], &ptrs_tmp[i][32]);
13812
13813 plains_tmp[i].len = 40;
13814 }
13815
13816 uint32_t salts_idx;
13817
13818 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
13819 {
13820 salt_t *salt = db->salts_buf[salts_idx];
13821
13822 if (salt->indexes_found == salt->indexes_cnt) continue;
13823
13824 plain_init (plains);
13825
13826 sha1_init_sse2 (&digests);
13827
13828 sha1_update_sse2 (plains, &digests, salt->salt_plain_struct);
13829
13830 sha1_update_sse2 (plains, &digests, plains_tmp);
13831
13832 sha1_final_sse2 (plains, &digests);
13833
13834 transpose_sha1_digest (&digests, dgst);
13835
13836 thread_parameter->indb (thread_parameter, in, dgst, salt);
13837 }
13838 }
13839
hashing_07900(thread_parameter_t * thread_parameter,plain_t * in)13840 void hashing_07900 (thread_parameter_t *thread_parameter, plain_t *in)
13841 {
13842 digest_sha512_sse2_t digests;
13843
13844 digest_t dgst[4];
13845
13846 db_t *db = thread_parameter->db;
13847
13848 plain_t plains[4];
13849
13850 plain_t plains_tmp[4];
13851
13852 uint32_t salts_idx;
13853
13854 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
13855 {
13856 salt_t *salt = db->salts_buf[salts_idx];
13857
13858 if (salt->indexes_found == salt->indexes_cnt) continue;
13859
13860 // initial sha512 ($salt.$pass)
13861
13862 plain_init (plains);
13863
13864 sha512_init_sse2 (&digests);
13865
13866 sha512_update_sse2 (plains, &digests, salt->salt_plain_struct);
13867
13868 sha512_update_sse2 (plains, &digests, in);
13869
13870 sha512_final_sse2 (plains, &digests);
13871
13872 transpose_sha512_digest (&digests, dgst);
13873
13874 uint32_t cnt;
13875
13876 for (cnt = 0; cnt < salt->iterations; cnt++)
13877 {
13878 // loop with both: 64 bit digest + $pass
13879
13880 uint32_t i;
13881
13882 for (i = 0; i < 4; i++)
13883 {
13884 memcpy (plains_tmp[i].buf, dgst[i].buf.sha512, 64);
13885
13886 BYTESWAP64 (plains_tmp[i].buf64[0]);
13887 BYTESWAP64 (plains_tmp[i].buf64[1]);
13888 BYTESWAP64 (plains_tmp[i].buf64[2]);
13889 BYTESWAP64 (plains_tmp[i].buf64[3]);
13890 BYTESWAP64 (plains_tmp[i].buf64[4]);
13891 BYTESWAP64 (plains_tmp[i].buf64[5]);
13892 BYTESWAP64 (plains_tmp[i].buf64[6]);
13893 BYTESWAP64 (plains_tmp[i].buf64[7]);
13894
13895 plains_tmp[i].len = 64;
13896 }
13897
13898 plain_init (plains);
13899
13900 sha512_init_sse2 (&digests);
13901
13902 // previous digest
13903
13904 sha512_update_sse2 (plains, &digests, plains_tmp);
13905
13906 // pass
13907
13908 sha512_update_sse2 (plains, &digests, in);
13909
13910 sha512_final_sse2 (plains, &digests);
13911
13912 transpose_sha512_digest (&digests, dgst);
13913 }
13914
13915 thread_parameter->indb (thread_parameter, in, dgst, salt);
13916 }
13917 }
13918
13919 // similar to aix -m 6400 but without the final bitmask hack ( & 0xffff03ff )
13920
hashing_09200(thread_parameter_t * thread_parameter,plain_t * plains)13921 void hashing_09200 (thread_parameter_t *thread_parameter, plain_t *plains)
13922 {
13923 digest_t digests[4];
13924
13925 plain_t plains_tmp[4];
13926
13927 char *ptrs_tmp[4];
13928
13929 ptrs_tmp[0] = (char *) &plains_tmp[0].buf;
13930 ptrs_tmp[1] = (char *) &plains_tmp[1].buf;
13931 ptrs_tmp[2] = (char *) &plains_tmp[2].buf;
13932 ptrs_tmp[3] = (char *) &plains_tmp[3].buf;
13933
13934 uint32_t ipad[8][4] __attribute__ ((aligned (16)));
13935 uint32_t opad[8][4] __attribute__ ((aligned (16)));
13936
13937 uint32_t ipad_buf[16][4] __attribute__ ((aligned (16)));
13938 uint32_t opad_buf[16][4] __attribute__ ((aligned (16)));
13939
13940 db_t *db = thread_parameter->db;
13941
13942 uint32_t i;
13943 uint32_t j;
13944 uint32_t l;
13945
13946 for (i = 0; i < 4; i++)
13947 {
13948 for (j = 0; j < 16; j++)
13949 {
13950 ipad_buf[j][i] = 0x36363636 ^ plains[i].buf[j];
13951 opad_buf[j][i] = 0x5c5c5c5c ^ plains[i].buf[j];
13952 }
13953
13954 ipad[0][i] = SHA256M_A;
13955 ipad[1][i] = SHA256M_B;
13956 ipad[2][i] = SHA256M_C;
13957 ipad[3][i] = SHA256M_D;
13958 ipad[4][i] = SHA256M_E;
13959 ipad[5][i] = SHA256M_F;
13960 ipad[6][i] = SHA256M_G;
13961 ipad[7][i] = SHA256M_H;
13962
13963 opad[0][i] = SHA256M_A;
13964 opad[1][i] = SHA256M_B;
13965 opad[2][i] = SHA256M_C;
13966 opad[3][i] = SHA256M_D;
13967 opad[4][i] = SHA256M_E;
13968 opad[5][i] = SHA256M_F;
13969 opad[6][i] = SHA256M_G;
13970 opad[7][i] = SHA256M_H;
13971 }
13972
13973 hashcat_sha256_64 ((__m128i *) ipad, (__m128i *) ipad_buf);
13974 hashcat_sha256_64 ((__m128i *) opad, (__m128i *) opad_buf);
13975
13976 uint32_t salts_idx;
13977
13978 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
13979 {
13980 salt_t *salt = db->salts_buf[salts_idx];
13981
13982 if (salt->indexes_found == salt->indexes_cnt) continue;
13983
13984 /**
13985 * init hmac
13986 */
13987
13988 uint32_t tmp[8][4] __attribute__ ((aligned (16)));
13989 uint32_t out[8][4] __attribute__ ((aligned (16)));
13990
13991 for (i = 0; i < 4; i++)
13992 {
13993 tmp[0][i] = ipad[0][i];
13994 tmp[1][i] = ipad[1][i];
13995 tmp[2][i] = ipad[2][i];
13996 tmp[3][i] = ipad[3][i];
13997 tmp[4][i] = ipad[4][i];
13998 tmp[5][i] = ipad[5][i];
13999 tmp[6][i] = ipad[6][i];
14000 tmp[7][i] = ipad[7][i];
14001 }
14002
14003 for (i = 0; i < 4; i++)
14004 {
14005 memcpy (ptrs_tmp[i], salt->salt_plain_buf, salt->salt_plain_len);
14006
14007 memset (ptrs_tmp[i] + salt->salt_plain_len, 0, BLOCK_SIZE - salt->salt_plain_len);
14008
14009 ptrs_tmp[i][salt->salt_plain_len + 3] = 0x01;
14010 ptrs_tmp[i][salt->salt_plain_len + 4] = 0x80;
14011
14012 for (j = 0; j < 14; j++) ipad_buf[j][i] = plains_tmp[i].buf[j];
14013
14014 ipad_buf[14][i] = 0;
14015 ipad_buf[15][i] = (64 + salt->salt_plain_len + 4) * 8;
14016 }
14017
14018 for (i = 14; i < 16; i++) for (l = 0; l < 4; l++) BYTESWAP (ipad_buf[i][l]);
14019
14020 hashcat_sha256_64 ((__m128i *) tmp, (__m128i *) ipad_buf);
14021
14022 for (i = 0; i < 4; i++)
14023 {
14024 opad_buf[ 0][i] = tmp[0][i];
14025 opad_buf[ 1][i] = tmp[1][i];
14026 opad_buf[ 2][i] = tmp[2][i];
14027 opad_buf[ 3][i] = tmp[3][i];
14028 opad_buf[ 4][i] = tmp[4][i];
14029 opad_buf[ 5][i] = tmp[5][i];
14030 opad_buf[ 6][i] = tmp[6][i];
14031 opad_buf[ 7][i] = tmp[7][i];
14032 opad_buf[ 8][i] = 0x80000000;
14033 opad_buf[ 9][i] = 0;
14034 opad_buf[10][i] = 0;
14035 opad_buf[11][i] = 0;
14036 opad_buf[12][i] = 0;
14037 opad_buf[13][i] = 0;
14038 opad_buf[14][i] = 0;
14039 opad_buf[15][i] = (64 + 32) * 8;
14040 }
14041
14042 for (i = 0; i < 4; i++)
14043 {
14044 tmp[0][i] = opad[0][i];
14045 tmp[1][i] = opad[1][i];
14046 tmp[2][i] = opad[2][i];
14047 tmp[3][i] = opad[3][i];
14048 tmp[4][i] = opad[4][i];
14049 tmp[5][i] = opad[5][i];
14050 tmp[6][i] = opad[6][i];
14051 tmp[7][i] = opad[7][i];
14052 }
14053
14054 for (i = 0; i < 16; i++) for (l = 0; l < 4; l++) BYTESWAP (opad_buf[i][l]);
14055
14056 hashcat_sha256_64 ((__m128i *) tmp, (__m128i *) opad_buf);
14057
14058 for (i = 0; i < 4; i++)
14059 {
14060 out[0][i] = tmp[0][i];
14061 out[1][i] = tmp[1][i];
14062 out[2][i] = tmp[2][i];
14063 out[3][i] = tmp[3][i];
14064 out[4][i] = tmp[4][i];
14065 out[5][i] = tmp[5][i];
14066 out[6][i] = tmp[6][i];
14067 out[7][i] = tmp[7][i];
14068 }
14069
14070 /**
14071 * loop hmac
14072 */
14073
14074 for (j = 0; j < salt->iterations - 1; j++)
14075 {
14076 for (i = 0; i < 4; i++)
14077 {
14078 ipad_buf[ 0][i] = tmp[0][i];
14079 ipad_buf[ 1][i] = tmp[1][i];
14080 ipad_buf[ 2][i] = tmp[2][i];
14081 ipad_buf[ 3][i] = tmp[3][i];
14082 ipad_buf[ 4][i] = tmp[4][i];
14083 ipad_buf[ 5][i] = tmp[5][i];
14084 ipad_buf[ 6][i] = tmp[6][i];
14085 ipad_buf[ 7][i] = tmp[7][i];
14086 ipad_buf[ 8][i] = 0x80000000;
14087 ipad_buf[ 9][i] = 0;
14088 ipad_buf[10][i] = 0;
14089 ipad_buf[11][i] = 0;
14090 ipad_buf[12][i] = 0;
14091 ipad_buf[13][i] = 0;
14092 ipad_buf[14][i] = 0;
14093 ipad_buf[15][i] = (64 + 32) * 8;
14094 }
14095
14096 for (i = 0; i < 4; i++)
14097 {
14098 tmp[0][i] = ipad[0][i];
14099 tmp[1][i] = ipad[1][i];
14100 tmp[2][i] = ipad[2][i];
14101 tmp[3][i] = ipad[3][i];
14102 tmp[4][i] = ipad[4][i];
14103 tmp[5][i] = ipad[5][i];
14104 tmp[6][i] = ipad[6][i];
14105 tmp[7][i] = ipad[7][i];
14106 }
14107
14108 for (i = 0; i < 4; i++) for (l = 0; l < 16; l++) BYTESWAP (ipad_buf[l][i]);
14109
14110 hashcat_sha256_64 ((__m128i *) tmp, (__m128i *) ipad_buf);
14111
14112 for (i = 0; i < 4; i++)
14113 {
14114 opad_buf[ 0][i] = tmp[0][i];
14115 opad_buf[ 1][i] = tmp[1][i];
14116 opad_buf[ 2][i] = tmp[2][i];
14117 opad_buf[ 3][i] = tmp[3][i];
14118 opad_buf[ 4][i] = tmp[4][i];
14119 opad_buf[ 5][i] = tmp[5][i];
14120 opad_buf[ 6][i] = tmp[6][i];
14121 opad_buf[ 7][i] = tmp[7][i];
14122 opad_buf[ 8][i] = 0x80000000;
14123 opad_buf[ 9][i] = 0;
14124 opad_buf[10][i] = 0;
14125 opad_buf[11][i] = 0;
14126 opad_buf[12][i] = 0;
14127 opad_buf[13][i] = 0;
14128 opad_buf[14][i] = 0;
14129 opad_buf[15][i] = (64 + 32) * 8;
14130 }
14131
14132 for (i = 0; i < 4; i++)
14133 {
14134 tmp[0][i] = opad[0][i];
14135 tmp[1][i] = opad[1][i];
14136 tmp[2][i] = opad[2][i];
14137 tmp[3][i] = opad[3][i];
14138 tmp[4][i] = opad[4][i];
14139 tmp[5][i] = opad[5][i];
14140 tmp[6][i] = opad[6][i];
14141 tmp[7][i] = opad[7][i];
14142 }
14143
14144 for (i = 0; i < 4; i++) for (l = 0; l < 16; l++) BYTESWAP (opad_buf[l][i]);
14145
14146 hashcat_sha256_64 ((__m128i *) tmp, (__m128i *) opad_buf);
14147
14148 for (i = 0; i < 4; i++)
14149 {
14150 out[0][i] ^= tmp[0][i];
14151 out[1][i] ^= tmp[1][i];
14152 out[2][i] ^= tmp[2][i];
14153 out[3][i] ^= tmp[3][i];
14154 out[4][i] ^= tmp[4][i];
14155 out[5][i] ^= tmp[5][i];
14156 out[6][i] ^= tmp[6][i];
14157 out[7][i] ^= tmp[7][i];
14158 }
14159 }
14160
14161 for (i = 0; i < 4; i++)
14162 {
14163 digests[i].buf.sha256[0] = out[0][i];
14164 digests[i].buf.sha256[1] = out[1][i];
14165 digests[i].buf.sha256[2] = out[2][i];
14166 digests[i].buf.sha256[3] = out[3][i];
14167 digests[i].buf.sha256[4] = out[4][i];
14168 digests[i].buf.sha256[5] = out[5][i];
14169 digests[i].buf.sha256[6] = out[6][i];
14170 digests[i].buf.sha256[7] = out[7][i];
14171 }
14172
14173 thread_parameter->indb (thread_parameter, plains, digests, salt);
14174 }
14175 }
14176
14177 #define GET_SCRYPT_CNT(r,p) (2 * (r) * 16 * (p))
14178 #define GET_SMIX_CNT(r,N) (2 * (r) * 16 * (N))
14179 #define GET_STATE_CNT(r) (2 * (r) * 16)
14180
14181 #ifdef __XOP__
14182 #define ADD_ROTATE_XOR(r,i1,i2,s) \
14183 { \
14184 __m128i T1; \
14185 \
14186 T1 = _mm_add_epi32 ((i1), (i2)); \
14187 T1 = _mm_roti_epi32 (T1, (s)); \
14188 (r) = _mm_xor_si128 ((r), T1); \
14189 }
14190 #else
14191 #define ADD_ROTATE_XOR(r,i1,i2,s) \
14192 { \
14193 __m128i T1; \
14194 __m128i T2; \
14195 \
14196 T1 = _mm_add_epi32 ((i1), (i2)); \
14197 T2 = _mm_srli_epi32 (T1, 32 - (s)); \
14198 T1 = _mm_slli_epi32 (T1, (s)); \
14199 (r) = _mm_xor_si128 ((r), T1); \
14200 (r) = _mm_xor_si128 ((r), T2); \
14201 }
14202 #endif
14203
14204 #define SALSA20_2R() \
14205 { \
14206 ADD_ROTATE_XOR (X1, X0, X3, 7); \
14207 ADD_ROTATE_XOR (X2, X1, X0, 9); \
14208 ADD_ROTATE_XOR (X3, X2, X1, 13); \
14209 ADD_ROTATE_XOR (X0, X3, X2, 18); \
14210 \
14211 X1 = _mm_shuffle_epi32 (X1, 0x93); \
14212 X2 = _mm_shuffle_epi32 (X2, 0x4e); \
14213 X3 = _mm_shuffle_epi32 (X3, 0x39); \
14214 \
14215 ADD_ROTATE_XOR (X3, X0, X1, 7); \
14216 ADD_ROTATE_XOR (X2, X3, X0, 9); \
14217 ADD_ROTATE_XOR (X1, X2, X3, 13); \
14218 ADD_ROTATE_XOR (X0, X1, X2, 18); \
14219 \
14220 X1 = _mm_shuffle_epi32 (X1, 0x39); \
14221 X2 = _mm_shuffle_epi32 (X2, 0x4e); \
14222 X3 = _mm_shuffle_epi32 (X3, 0x93); \
14223 }
14224
14225 #define SALSA20_8_XOR() \
14226 { \
14227 R0 = _mm_xor_si128 (R0, Y0); \
14228 R1 = _mm_xor_si128 (R1, Y1); \
14229 R2 = _mm_xor_si128 (R2, Y2); \
14230 R3 = _mm_xor_si128 (R3, Y3); \
14231 \
14232 __m128i X0 = R0; \
14233 __m128i X1 = R1; \
14234 __m128i X2 = R2; \
14235 __m128i X3 = R3; \
14236 \
14237 SALSA20_2R (); \
14238 SALSA20_2R (); \
14239 SALSA20_2R (); \
14240 SALSA20_2R (); \
14241 \
14242 R0 = _mm_add_epi32 (R0, X0); \
14243 R1 = _mm_add_epi32 (R1, X1); \
14244 R2 = _mm_add_epi32 (R2, X2); \
14245 R3 = _mm_add_epi32 (R3, X3); \
14246 }
14247
scrypt_blockmix_salsa8(__m128i * Bin,__m128i * Bout,const uint32_t r)14248 static void scrypt_blockmix_salsa8 (__m128i *Bin, __m128i *Bout, const uint32_t r)
14249 {
14250 __m128i R0 = Bin[8 * r - 4];
14251 __m128i R1 = Bin[8 * r - 3];
14252 __m128i R2 = Bin[8 * r - 2];
14253 __m128i R3 = Bin[8 * r - 1];
14254
14255 uint32_t idx_y = 0;
14256 uint32_t idx_r1 = 0;
14257 uint32_t idx_r2 = r * 4;
14258
14259 uint32_t i;
14260
14261 for (i = 0; i < r; i++)
14262 {
14263 __m128i Y0;
14264 __m128i Y1;
14265 __m128i Y2;
14266 __m128i Y3;
14267
14268 Y0 = Bin[idx_y++];
14269 Y1 = Bin[idx_y++];
14270 Y2 = Bin[idx_y++];
14271 Y3 = Bin[idx_y++];
14272
14273 SALSA20_8_XOR ();
14274
14275 Bout[idx_r1++] = R0;
14276 Bout[idx_r1++] = R1;
14277 Bout[idx_r1++] = R2;
14278 Bout[idx_r1++] = R3;
14279
14280 Y0 = Bin[idx_y++];
14281 Y1 = Bin[idx_y++];
14282 Y2 = Bin[idx_y++];
14283 Y3 = Bin[idx_y++];
14284
14285 SALSA20_8_XOR ();
14286
14287 Bout[idx_r2++] = R0;
14288 Bout[idx_r2++] = R1;
14289 Bout[idx_r2++] = R2;
14290 Bout[idx_r2++] = R3;
14291 }
14292 }
14293
scrypt_get_key(__m128i * B,const uint32_t r)14294 static inline uint32_t scrypt_get_key (__m128i *B, const uint32_t r)
14295 {
14296 const uint32_t state_cnt = GET_STATE_CNT (r);
14297
14298 const uint32_t state_cnt4 = state_cnt / 4;
14299
14300 uint32_t *key = (uint32_t *) &B[state_cnt4 - 4];
14301
14302 return key[0];
14303 }
14304
scrypt_smix(uint32_t * B,const uint32_t r,const uint32_t N,__m128i * V,__m128i * X,__m128i * Y)14305 static void scrypt_smix (uint32_t *B, const uint32_t r, const uint32_t N, __m128i *V, __m128i *X, __m128i *Y)
14306 {
14307 const uint32_t state_cnt = GET_STATE_CNT (r);
14308
14309 const uint32_t state_cnt4 = state_cnt / 4;
14310
14311 uint32_t *X32 = (uint32_t *) X;
14312
14313 uint32_t i;
14314 uint32_t k;
14315
14316 for (k = 0; k < 2 * r; k++)
14317 {
14318 const uint32_t k16 = k * 16;
14319
14320 X32[k16 + 0] = B[k16 + 0];
14321 X32[k16 + 1] = B[k16 + 5];
14322 X32[k16 + 2] = B[k16 + 10];
14323 X32[k16 + 3] = B[k16 + 15];
14324 X32[k16 + 4] = B[k16 + 4];
14325 X32[k16 + 5] = B[k16 + 9];
14326 X32[k16 + 6] = B[k16 + 14];
14327 X32[k16 + 7] = B[k16 + 3];
14328 X32[k16 + 8] = B[k16 + 8];
14329 X32[k16 + 9] = B[k16 + 13];
14330 X32[k16 + 10] = B[k16 + 2];
14331 X32[k16 + 11] = B[k16 + 7];
14332 X32[k16 + 12] = B[k16 + 12];
14333 X32[k16 + 13] = B[k16 + 1];
14334 X32[k16 + 14] = B[k16 + 6];
14335 X32[k16 + 15] = B[k16 + 11];
14336 }
14337
14338 for (i = 0; i < N; i += 2)
14339 {
14340 const uint32_t i0_state4 = (i + 0) * state_cnt4;
14341 const uint32_t i1_state4 = (i + 1) * state_cnt4;
14342
14343 for (k = 0; k < state_cnt4; k++)
14344 {
14345 V[i0_state4 + k] = X[k];
14346 }
14347
14348 scrypt_blockmix_salsa8 (X, Y, r);
14349
14350 for (k = 0; k < state_cnt4; k++)
14351 {
14352 V[i1_state4 + k] = Y[k];
14353 }
14354
14355 scrypt_blockmix_salsa8 (Y, X, r);
14356 }
14357
14358 for (i = 0; i < N; i += 2)
14359 {
14360 const uint32_t keyX = scrypt_get_key (X, r) & (N - 1);
14361
14362 const uint32_t keyX_state4 = keyX * state_cnt4;
14363
14364 for (k = 0; k < state_cnt4; k++)
14365 {
14366 X[k] ^= V[keyX_state4 + k];
14367 }
14368
14369 scrypt_blockmix_salsa8 (X, Y, r);
14370
14371 const uint32_t keyY = scrypt_get_key (Y, r) & (N - 1);
14372
14373 const uint32_t keyY_state4 = keyY * state_cnt4;
14374
14375 for (k = 0; k < state_cnt4; k++)
14376 {
14377 Y[k] ^= V[keyY_state4 + k];
14378 }
14379
14380 scrypt_blockmix_salsa8 (Y, X, r);
14381 }
14382
14383 for (k = 0; k < 2 * r; k++)
14384 {
14385 const uint32_t k16 = k * 16;
14386
14387 B[k16 + 0] = X32[k16 + 0];
14388 B[k16 + 5] = X32[k16 + 1];
14389 B[k16 + 10] = X32[k16 + 2];
14390 B[k16 + 15] = X32[k16 + 3];
14391 B[k16 + 4] = X32[k16 + 4];
14392 B[k16 + 9] = X32[k16 + 5];
14393 B[k16 + 14] = X32[k16 + 6];
14394 B[k16 + 3] = X32[k16 + 7];
14395 B[k16 + 8] = X32[k16 + 8];
14396 B[k16 + 13] = X32[k16 + 9];
14397 B[k16 + 2] = X32[k16 + 10];
14398 B[k16 + 7] = X32[k16 + 11];
14399 B[k16 + 12] = X32[k16 + 12];
14400 B[k16 + 1] = X32[k16 + 13];
14401 B[k16 + 6] = X32[k16 + 14];
14402 B[k16 + 11] = X32[k16 + 15];
14403 }
14404 }
14405
hashing_08400(thread_parameter_t * thread_parameter,plain_t * in)14406 void hashing_08400 (thread_parameter_t *thread_parameter, plain_t *in)
14407 {
14408 digest_sha1_sse2_t digests;
14409
14410 digest_t dgst[4];
14411
14412 plain_t plains1[4];
14413
14414 char *ptrs1[4];
14415
14416 ptrs1[0] = (char *) &plains1[0].buf;
14417 ptrs1[1] = (char *) &plains1[1].buf;
14418 ptrs1[2] = (char *) &plains1[2].buf;
14419 ptrs1[3] = (char *) &plains1[3].buf;
14420
14421 plain_t plains2[4];
14422
14423 char *ptrs2[4];
14424
14425 ptrs2[0] = (char *) &plains2[0].buf;
14426 ptrs2[1] = (char *) &plains2[1].buf;
14427 ptrs2[2] = (char *) &plains2[2].buf;
14428 ptrs2[3] = (char *) &plains2[3].buf;
14429
14430 plain_t plains3[4];
14431
14432 db_t *db = thread_parameter->db;
14433
14434 // 1st sha1
14435
14436 sha1_init_sse2 (&digests);
14437
14438 sha1_final_sse2_max55 (in, &digests);
14439
14440 transpose_sha1_digest (&digests, dgst);
14441
14442 uint32_t i;
14443
14444 for (i = 0; i < 4; i++)
14445 {
14446 uint_to_hex_lower (dgst[i].buf.sha1[0], &ptrs1[i][0]);
14447 uint_to_hex_lower (dgst[i].buf.sha1[1], &ptrs1[i][8]);
14448 uint_to_hex_lower (dgst[i].buf.sha1[2], &ptrs1[i][16]);
14449 uint_to_hex_lower (dgst[i].buf.sha1[3], &ptrs1[i][24]);
14450 uint_to_hex_lower (dgst[i].buf.sha1[4], &ptrs1[i][32]);
14451
14452 plains1[i].len = 40;
14453 }
14454
14455 uint32_t salts_idx;
14456
14457 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
14458 {
14459 salt_t *salt = db->salts_buf[salts_idx];
14460
14461 if (salt->indexes_found == salt->indexes_cnt) continue;
14462
14463 // 2nd sha1
14464
14465 sha1_init_sse2 (&digests);
14466
14467 plain_init (plains2);
14468
14469 sha1_update_sse2 (plains2, &digests, salt->salt_plain_struct);
14470
14471 sha1_update_sse2 (plains2, &digests, plains1);
14472
14473 sha1_final_sse2 (plains2, &digests);
14474
14475 transpose_sha1_digest (&digests, dgst);
14476
14477 for (i = 0; i < 4; i++)
14478 {
14479 uint_to_hex_lower (dgst[i].buf.sha1[0], &ptrs2[i][0]);
14480 uint_to_hex_lower (dgst[i].buf.sha1[1], &ptrs2[i][8]);
14481 uint_to_hex_lower (dgst[i].buf.sha1[2], &ptrs2[i][16]);
14482 uint_to_hex_lower (dgst[i].buf.sha1[3], &ptrs2[i][24]);
14483 uint_to_hex_lower (dgst[i].buf.sha1[4], &ptrs2[i][32]);
14484
14485 plains2[i].len = 40;
14486 }
14487
14488 // 3rd time
14489
14490 sha1_init_sse2 (&digests);
14491
14492 plain_init (plains3);
14493
14494 sha1_update_sse2 (plains3, &digests, salt->salt_plain_struct);
14495
14496 sha1_update_sse2 (plains3, &digests, plains2);
14497
14498 sha1_final_sse2 (plains3, &digests);
14499
14500 transpose_sha1_digest (&digests, dgst);
14501
14502 thread_parameter->indb (thread_parameter, in, dgst, salt);
14503 }
14504 }
14505
hashing_08900(thread_parameter_t * thread_parameter,plain_t * plains)14506 void hashing_08900 (thread_parameter_t *thread_parameter, plain_t *plains)
14507 {
14508 digest_t digests[4];
14509
14510 plain_t plains_tmp[4];
14511
14512 char *ptrs_tmp[4];
14513
14514 ptrs_tmp[0] = (char *) &plains_tmp[0].buf;
14515 ptrs_tmp[1] = (char *) &plains_tmp[1].buf;
14516 ptrs_tmp[2] = (char *) &plains_tmp[2].buf;
14517 ptrs_tmp[3] = (char *) &plains_tmp[3].buf;
14518
14519 db_t *db = thread_parameter->db;
14520
14521 uint32_t **P = thread_parameter->scrypt_P;
14522
14523 __m128i *V = thread_parameter->scrypt_V;
14524 __m128i *X = thread_parameter->scrypt_X;
14525 __m128i *Y = thread_parameter->scrypt_Y;
14526
14527 /**
14528 * start
14529 */
14530
14531 uint32_t ipad[8][4] __attribute__ ((aligned (16)));
14532 uint32_t opad[8][4] __attribute__ ((aligned (16)));
14533
14534 uint32_t ipad_buf[16][4] __attribute__ ((aligned (16)));
14535 uint32_t opad_buf[16][4] __attribute__ ((aligned (16)));
14536
14537 uint32_t i;
14538 uint32_t j;
14539
14540 for (i = 0; i < 4; i++)
14541 {
14542 for (j = 0; j < 16; j++)
14543 {
14544 ipad_buf[j][i] = 0x36363636 ^ plains[i].buf[j];
14545 opad_buf[j][i] = 0x5c5c5c5c ^ plains[i].buf[j];
14546 }
14547
14548 ipad[0][i] = SHA256M_A;
14549 ipad[1][i] = SHA256M_B;
14550 ipad[2][i] = SHA256M_C;
14551 ipad[3][i] = SHA256M_D;
14552 ipad[4][i] = SHA256M_E;
14553 ipad[5][i] = SHA256M_F;
14554 ipad[6][i] = SHA256M_G;
14555 ipad[7][i] = SHA256M_H;
14556
14557 opad[0][i] = SHA256M_A;
14558 opad[1][i] = SHA256M_B;
14559 opad[2][i] = SHA256M_C;
14560 opad[3][i] = SHA256M_D;
14561 opad[4][i] = SHA256M_E;
14562 opad[5][i] = SHA256M_F;
14563 opad[6][i] = SHA256M_G;
14564 opad[7][i] = SHA256M_H;
14565 }
14566
14567 hashcat_sha256_64 ((__m128i *) ipad, (__m128i *) ipad_buf);
14568 hashcat_sha256_64 ((__m128i *) opad, (__m128i *) opad_buf);
14569
14570 uint32_t salts_idx;
14571
14572 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
14573 {
14574 salt_t *salt = db->salts_buf[salts_idx];
14575
14576 if (salt->indexes_found == salt->indexes_cnt) continue;
14577
14578 uint32_t N = salt->scrypt_N;
14579 uint32_t r = salt->scrypt_r;
14580 uint32_t p = salt->scrypt_p;
14581
14582 const uint32_t scrypt_cnt = GET_SCRYPT_CNT (r, p);
14583 const uint32_t state_cnt = GET_STATE_CNT (r);
14584
14585 /**
14586 * init hmac
14587 */
14588
14589 uint32_t tmp[8][4] __attribute__ ((aligned (16)));
14590
14591 uint32_t l;
14592 uint32_t m;
14593
14594 for (l = 0, m = 1; l < scrypt_cnt; l += 8, m += 1)
14595 {
14596 for (i = 0; i < 4; i++)
14597 {
14598 tmp[0][i] = ipad[0][i];
14599 tmp[1][i] = ipad[1][i];
14600 tmp[2][i] = ipad[2][i];
14601 tmp[3][i] = ipad[3][i];
14602 tmp[4][i] = ipad[4][i];
14603 tmp[5][i] = ipad[5][i];
14604 tmp[6][i] = ipad[6][i];
14605 tmp[7][i] = ipad[7][i];
14606 }
14607
14608 for (i = 0; i < 4; i++)
14609 {
14610 memcpy (ptrs_tmp[i], salt->salt_plain_buf, salt->salt_plain_len);
14611
14612 memset (ptrs_tmp[i] + salt->salt_plain_len, 0, BLOCK_SIZE - salt->salt_plain_len);
14613
14614 ptrs_tmp[i][salt->salt_plain_len + 0] = (m >> 24) & 0xff;
14615 ptrs_tmp[i][salt->salt_plain_len + 1] = (m >> 16) & 0xff;
14616 ptrs_tmp[i][salt->salt_plain_len + 2] = (m >> 8) & 0xff;
14617 ptrs_tmp[i][salt->salt_plain_len + 3] = (m >> 0) & 0xff;
14618 ptrs_tmp[i][salt->salt_plain_len + 4] = 0x80;
14619
14620 for (j = 0; j < 14; j++) ipad_buf[j][i] = plains_tmp[i].buf[j];
14621
14622 ipad_buf[14][i] = 0;
14623 ipad_buf[15][i] = (64 + salt->salt_plain_len + 4) * 8;
14624
14625 BYTESWAP (ipad_buf[15][i]);
14626 }
14627
14628 hashcat_sha256_64 ((__m128i *) tmp, (__m128i *) ipad_buf);
14629
14630 for (i = 0; i < 4; i++)
14631 {
14632 opad_buf[ 0][i] = tmp[0][i];
14633 opad_buf[ 1][i] = tmp[1][i];
14634 opad_buf[ 2][i] = tmp[2][i];
14635 opad_buf[ 3][i] = tmp[3][i];
14636 opad_buf[ 4][i] = tmp[4][i];
14637 opad_buf[ 5][i] = tmp[5][i];
14638 opad_buf[ 6][i] = tmp[6][i];
14639 opad_buf[ 7][i] = tmp[7][i];
14640 opad_buf[ 8][i] = 0x80;
14641 opad_buf[ 9][i] = 0;
14642 opad_buf[10][i] = 0;
14643 opad_buf[11][i] = 0;
14644 opad_buf[12][i] = 0;
14645 opad_buf[13][i] = 0;
14646 opad_buf[14][i] = 0;
14647 opad_buf[15][i] = (64 + 32) * 8;
14648
14649 BYTESWAP (opad_buf[ 0][i]);
14650 BYTESWAP (opad_buf[ 1][i]);
14651 BYTESWAP (opad_buf[ 2][i]);
14652 BYTESWAP (opad_buf[ 3][i]);
14653 BYTESWAP (opad_buf[ 4][i]);
14654 BYTESWAP (opad_buf[ 5][i]);
14655 BYTESWAP (opad_buf[ 6][i]);
14656 BYTESWAP (opad_buf[ 7][i]);
14657 BYTESWAP (opad_buf[15][i]);
14658 }
14659
14660 for (i = 0; i < 4; i++)
14661 {
14662 tmp[0][i] = opad[0][i];
14663 tmp[1][i] = opad[1][i];
14664 tmp[2][i] = opad[2][i];
14665 tmp[3][i] = opad[3][i];
14666 tmp[4][i] = opad[4][i];
14667 tmp[5][i] = opad[5][i];
14668 tmp[6][i] = opad[6][i];
14669 tmp[7][i] = opad[7][i];
14670 }
14671
14672 hashcat_sha256_64 ((__m128i *) tmp, (__m128i *) opad_buf);
14673
14674 for (i = 0; i < 4; i++)
14675 {
14676 BYTESWAP (tmp[0][i]);
14677 BYTESWAP (tmp[1][i]);
14678 BYTESWAP (tmp[2][i]);
14679 BYTESWAP (tmp[3][i]);
14680 BYTESWAP (tmp[4][i]);
14681 BYTESWAP (tmp[5][i]);
14682 BYTESWAP (tmp[6][i]);
14683 BYTESWAP (tmp[7][i]);
14684 }
14685
14686 for (i = 0; i < 4; i++)
14687 {
14688 P[i][l + 0] = tmp[0][i];
14689 P[i][l + 1] = tmp[1][i];
14690 P[i][l + 2] = tmp[2][i];
14691 P[i][l + 3] = tmp[3][i];
14692 P[i][l + 4] = tmp[4][i];
14693 P[i][l + 5] = tmp[5][i];
14694 P[i][l + 6] = tmp[6][i];
14695 P[i][l + 7] = tmp[7][i];
14696 }
14697 }
14698
14699 /*
14700 * salsa8 stuff
14701 */
14702
14703 for (i = 0; i < p; i++)
14704 {
14705 scrypt_smix (&P[0][i * state_cnt], r, N, V, X, Y);
14706 }
14707
14708 for (i = 0; i < p; i++)
14709 {
14710 scrypt_smix (&P[1][i * state_cnt], r, N, V, X, Y);
14711 }
14712
14713 for (i = 0; i < p; i++)
14714 {
14715 scrypt_smix (&P[2][i * state_cnt], r, N, V, X, Y);
14716 }
14717
14718 for (i = 0; i < p; i++)
14719 {
14720 scrypt_smix (&P[3][i * state_cnt], r, N, V, X, Y);
14721 }
14722
14723 /*
14724 * final pbkdf2
14725 */
14726
14727 for (i = 0; i < 4; i++)
14728 {
14729 tmp[0][i] = ipad[0][i];
14730 tmp[1][i] = ipad[1][i];
14731 tmp[2][i] = ipad[2][i];
14732 tmp[3][i] = ipad[3][i];
14733 tmp[4][i] = ipad[4][i];
14734 tmp[5][i] = ipad[5][i];
14735 tmp[6][i] = ipad[6][i];
14736 tmp[7][i] = ipad[7][i];
14737 }
14738
14739 for (l = 0; l < scrypt_cnt; l += 16)
14740 {
14741 for (i = 0; i < 4; i++)
14742 {
14743 ipad_buf[ 0][i] = P[i][l + 0];
14744 ipad_buf[ 1][i] = P[i][l + 1];
14745 ipad_buf[ 2][i] = P[i][l + 2];
14746 ipad_buf[ 3][i] = P[i][l + 3];
14747 ipad_buf[ 4][i] = P[i][l + 4];
14748 ipad_buf[ 5][i] = P[i][l + 5];
14749 ipad_buf[ 6][i] = P[i][l + 6];
14750 ipad_buf[ 7][i] = P[i][l + 7];
14751 ipad_buf[ 8][i] = P[i][l + 8];
14752 ipad_buf[ 9][i] = P[i][l + 9];
14753 ipad_buf[10][i] = P[i][l + 10];
14754 ipad_buf[11][i] = P[i][l + 11];
14755 ipad_buf[12][i] = P[i][l + 12];
14756 ipad_buf[13][i] = P[i][l + 13];
14757 ipad_buf[14][i] = P[i][l + 14];
14758 ipad_buf[15][i] = P[i][l + 15];
14759 }
14760
14761 hashcat_sha256_64 ((__m128i *) tmp, (__m128i *) ipad_buf);
14762 }
14763
14764 for (i = 0; i < 4; i++)
14765 {
14766 ipad_buf[ 0][i] = 0x01000000;
14767 ipad_buf[ 1][i] = 0x80;
14768 ipad_buf[ 2][i] = 0;
14769 ipad_buf[ 3][i] = 0;
14770 ipad_buf[ 4][i] = 0;
14771 ipad_buf[ 5][i] = 0;
14772 ipad_buf[ 6][i] = 0;
14773 ipad_buf[ 7][i] = 0;
14774 ipad_buf[ 8][i] = 0;
14775 ipad_buf[ 9][i] = 0;
14776 ipad_buf[10][i] = 0;
14777 ipad_buf[11][i] = 0;
14778 ipad_buf[12][i] = 0;
14779 ipad_buf[13][i] = 0;
14780 ipad_buf[14][i] = 0;
14781 ipad_buf[15][i] = (64 + (scrypt_cnt * 4) + 4) * 8;
14782
14783 BYTESWAP (ipad_buf[15][i]);
14784 }
14785
14786 hashcat_sha256_64 ((__m128i *) tmp, (__m128i *) ipad_buf);
14787
14788 for (i = 0; i < 4; i++)
14789 {
14790 opad_buf[ 0][i] = tmp[0][i];
14791 opad_buf[ 1][i] = tmp[1][i];
14792 opad_buf[ 2][i] = tmp[2][i];
14793 opad_buf[ 3][i] = tmp[3][i];
14794 opad_buf[ 4][i] = tmp[4][i];
14795 opad_buf[ 5][i] = tmp[5][i];
14796 opad_buf[ 6][i] = tmp[6][i];
14797 opad_buf[ 7][i] = tmp[7][i];
14798 opad_buf[ 8][i] = 0x80;
14799 opad_buf[ 9][i] = 0;
14800 opad_buf[10][i] = 0;
14801 opad_buf[11][i] = 0;
14802 opad_buf[12][i] = 0;
14803 opad_buf[13][i] = 0;
14804 opad_buf[14][i] = 0;
14805 opad_buf[15][i] = (64 + 32) * 8;
14806
14807 BYTESWAP (opad_buf[ 0][i]);
14808 BYTESWAP (opad_buf[ 1][i]);
14809 BYTESWAP (opad_buf[ 2][i]);
14810 BYTESWAP (opad_buf[ 3][i]);
14811 BYTESWAP (opad_buf[ 4][i]);
14812 BYTESWAP (opad_buf[ 5][i]);
14813 BYTESWAP (opad_buf[ 6][i]);
14814 BYTESWAP (opad_buf[ 7][i]);
14815 BYTESWAP (opad_buf[15][i]);
14816 }
14817
14818 for (i = 0; i < 4; i++)
14819 {
14820 tmp[0][i] = opad[0][i];
14821 tmp[1][i] = opad[1][i];
14822 tmp[2][i] = opad[2][i];
14823 tmp[3][i] = opad[3][i];
14824 tmp[4][i] = opad[4][i];
14825 tmp[5][i] = opad[5][i];
14826 tmp[6][i] = opad[6][i];
14827 tmp[7][i] = opad[7][i];
14828 }
14829
14830 hashcat_sha256_64 ((__m128i *) tmp, (__m128i *) opad_buf);
14831
14832 for (i = 0; i < 4; i++)
14833 {
14834 digests[i].buf.sha256[0] = tmp[0][i];
14835 digests[i].buf.sha256[1] = tmp[1][i];
14836 digests[i].buf.sha256[2] = tmp[2][i];
14837 digests[i].buf.sha256[3] = tmp[3][i];
14838 digests[i].buf.sha256[4] = tmp[4][i];
14839 digests[i].buf.sha256[5] = tmp[5][i];
14840 digests[i].buf.sha256[6] = tmp[6][i];
14841 digests[i].buf.sha256[7] = tmp[7][i];
14842 }
14843
14844 thread_parameter->indb (thread_parameter, plains, digests, salt);
14845 }
14846 }
14847
hashing_09900(thread_parameter_t * thread_parameter,plain_t * in)14848 void hashing_09900 (thread_parameter_t *thread_parameter, plain_t *in)
14849 {
14850 // hack: because md5_update_sse2 () only allows in[x].len <= 64
14851
14852 db_t *db = thread_parameter->db;
14853
14854 plain_t plains_tmp[4];
14855
14856 uint32_t i;
14857
14858 for (i = 0; i < 4; i++)
14859 {
14860 memset (plains_tmp[i].buf, 0, 100);
14861 }
14862
14863 plain_t plains[4];
14864
14865 plain_init (plains);
14866
14867 // first the actual password
14868
14869 digest_md5_sse2_t digests;
14870
14871 md5_init_sse2 (&digests);
14872
14873 md5_update_sse2 (plains, &digests, in);
14874
14875 // remaining bytes: 100 - in[x].len
14876
14877 for (i = 0; i < 4; i++)
14878 {
14879 plains_tmp[i].len = 100 - in[i].len;
14880 }
14881
14882 md5_update_sse2 (plains, &digests, plains_tmp); // at most 64
14883
14884 md5_final_sse2 (plains, &digests); // if something is left, we handle it here
14885
14886 digest_t dgst[4];
14887
14888 transpose_md5_digest (&digests, dgst);
14889
14890 thread_parameter->indb (thread_parameter, in, dgst, db->salts_buf[0]);
14891 }
14892
hashing_10300(thread_parameter_t * thread_parameter,plain_t * in)14893 void hashing_10300 (thread_parameter_t *thread_parameter, plain_t *in)
14894 {
14895 digest_sha1_sse2_t digests;
14896
14897 digest_t dgst[4];
14898
14899 db_t *db = thread_parameter->db;
14900
14901 plain_t plains[4];
14902
14903 plain_t plains_tmp[4];
14904
14905 uint32_t salts_idx;
14906
14907 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
14908 {
14909 salt_t *salt = db->salts_buf[salts_idx];
14910
14911 if (salt->indexes_found == salt->indexes_cnt) continue;
14912
14913 // initial sha1 ($pass.$salt)
14914
14915 plain_init (plains);
14916
14917 sha1_init_sse2 (&digests);
14918
14919 sha1_update_sse2_max55 (plains, in);
14920
14921 sha1_update_sse2_max55 (plains, salt->salt_plain_struct);
14922
14923 sha1_final_sse2_max55 (plains, &digests);
14924
14925 transpose_sha1_digest (&digests, dgst);
14926
14927 uint32_t cnt;
14928
14929 for (cnt = 0; cnt < salt->iterations - 1; cnt++)
14930 {
14931 // loop with both: $pass + 20 bit digest
14932
14933 uint32_t i;
14934
14935 for (i = 0; i < 4; i++)
14936 {
14937 memcpy (plains_tmp[i].buf, dgst[i].buf.sha1, 20);
14938
14939 BYTESWAP (plains_tmp[i].buf[0]);
14940 BYTESWAP (plains_tmp[i].buf[1]);
14941 BYTESWAP (plains_tmp[i].buf[2]);
14942 BYTESWAP (plains_tmp[i].buf[3]);
14943 BYTESWAP (plains_tmp[i].buf[4]);
14944
14945 plains_tmp[i].len = 20;
14946 }
14947
14948 plain_init (plains);
14949
14950 sha1_init_sse2 (&digests);
14951
14952 // pass
14953
14954 sha1_update_sse2 (plains, &digests, in);
14955
14956 // previous digest
14957
14958 sha1_update_sse2 (plains, &digests, plains_tmp);
14959
14960 sha1_final_sse2 (plains, &digests);
14961
14962 transpose_sha1_digest (&digests, dgst);
14963 }
14964
14965 thread_parameter->indb (thread_parameter, in, dgst, salt);
14966 }
14967 }
14968
hashing_11000(thread_parameter_t * thread_parameter,plain_t * in)14969 void hashing_11000 (thread_parameter_t *thread_parameter, plain_t *in)
14970 {
14971 digest_md5_sse2_t digests;
14972
14973 digest_t dgst[4];
14974
14975 plain_t plains[4];
14976
14977 db_t *db = thread_parameter->db;
14978
14979 uint32_t salts_idx;
14980
14981 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
14982 {
14983 salt_t *salt = db->salts_buf[salts_idx];
14984
14985 if (salt->indexes_found == salt->indexes_cnt) continue;
14986
14987 plain_init (plains);
14988
14989 md5_init_sse2 (&digests);
14990
14991 md5_update_sse2 (plains, &digests, salt->salt_plain_struct);
14992
14993 md5_update_sse2 (plains, &digests, in);
14994
14995 md5_final_sse2 (plains, &digests);
14996
14997 transpose_md5_digest (&digests, dgst);
14998
14999 thread_parameter->indb (thread_parameter, in, dgst, salt);
15000 }
15001 }
15002
hashing_11100(thread_parameter_t * thread_parameter,plain_t * in)15003 void hashing_11100 (thread_parameter_t *thread_parameter, plain_t *in)
15004 {
15005 digest_md5_sse2_t digests;
15006
15007 digest_t dgst[4];
15008
15009 plain_t plains1[4];
15010
15011 char *ptrs[4];
15012
15013 ptrs[0] = (char *) &plains1[0].buf;
15014 ptrs[1] = (char *) &plains1[1].buf;
15015 ptrs[2] = (char *) &plains1[2].buf;
15016 ptrs[3] = (char *) &plains1[3].buf;
15017
15018 plain_t plains2[4];
15019
15020 db_t *db = thread_parameter->db;
15021
15022 uint32_t salts_idx;
15023
15024 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
15025 {
15026 salt_t *salt = db->salts_buf[salts_idx];
15027
15028 if (salt->indexes_found == salt->indexes_cnt) continue;
15029
15030 // $hash = md5 ($pass.$user_name)
15031
15032 plain_init (plains1);
15033
15034 md5_init_sse2 (&digests);
15035
15036 md5_update_sse2_max55 (plains1, in);
15037
15038 md5_update_sse2_max55 (plains1, salt->additional_plain_struct);
15039
15040 md5_final_sse2_max55 (plains1, &digests);
15041
15042 transpose_md5_digest (&digests, dgst);
15043
15044 uint32_t i;
15045
15046 for (i = 0; i < 4; i++)
15047 {
15048 BYTESWAP (dgst[i].buf.md5[0]);
15049 BYTESWAP (dgst[i].buf.md5[1]);
15050 BYTESWAP (dgst[i].buf.md5[2]);
15051 BYTESWAP (dgst[i].buf.md5[3]);
15052
15053 uint_to_hex_lower (dgst[i].buf.md5[0], &ptrs[i][0]);
15054 uint_to_hex_lower (dgst[i].buf.md5[1], &ptrs[i][8]);
15055 uint_to_hex_lower (dgst[i].buf.md5[2], &ptrs[i][16]);
15056 uint_to_hex_lower (dgst[i].buf.md5[3], &ptrs[i][24]);
15057
15058 plains1[i].len = 32;
15059 }
15060
15061 // md5 ($hash.$salt)
15062
15063 plain_init (plains2);
15064
15065 md5_init_sse2 (&digests);
15066
15067 md5_update_sse2_max55 (plains2, plains1);
15068
15069 md5_update_sse2_max55 (plains2, salt->salt_plain_struct);
15070
15071 md5_final_sse2_max55 (plains2, &digests);
15072
15073 transpose_md5_digest (&digests, dgst);
15074
15075 thread_parameter->indb (thread_parameter, in, dgst, salt);
15076 }
15077 }
15078
hashing_11200(thread_parameter_t * thread_parameter,plain_t * in)15079 void hashing_11200 (thread_parameter_t *thread_parameter, plain_t *in)
15080 {
15081 db_t *db = thread_parameter->db;
15082
15083 digest_sha1_sse2_t digests;
15084
15085 digest_t dgst[4];
15086
15087 plain_t plains1[4];
15088
15089 uint32_t *ptrs1[4];
15090
15091 ptrs1[0] = (uint32_t *) &plains1[0].buf;
15092 ptrs1[1] = (uint32_t *) &plains1[1].buf;
15093 ptrs1[2] = (uint32_t *) &plains1[2].buf;
15094 ptrs1[3] = (uint32_t *) &plains1[3].buf;
15095
15096 plain_t plains1_swapped[4];
15097
15098 uint32_t *ptrs1_swapped[4];
15099
15100 ptrs1_swapped[0] = (uint32_t *) &plains1_swapped[0].buf;
15101 ptrs1_swapped[1] = (uint32_t *) &plains1_swapped[1].buf;
15102 ptrs1_swapped[2] = (uint32_t *) &plains1_swapped[2].buf;
15103 ptrs1_swapped[3] = (uint32_t *) &plains1_swapped[3].buf;
15104
15105 plain_t plains2[4];
15106
15107 uint32_t *ptrs2[4];
15108
15109 ptrs2[0] = (uint32_t *) &plains2[0].buf;
15110 ptrs2[1] = (uint32_t *) &plains2[1].buf;
15111 ptrs2[2] = (uint32_t *) &plains2[2].buf;
15112 ptrs2[3] = (uint32_t *) &plains2[3].buf;
15113
15114 plain_t plains3[4];
15115
15116 // sha1 ($pass)
15117
15118 sha1_init_sse2 (&digests);
15119
15120 sha1_final_sse2_max55 (in, &digests);
15121
15122 transpose_sha1_digest (&digests, dgst);
15123
15124 uint32_t i;
15125
15126 for (i = 0; i < 4; i++)
15127 {
15128 ptrs1[i][0] = dgst[i].buf.sha1[0];
15129 ptrs1[i][1] = dgst[i].buf.sha1[1];
15130 ptrs1[i][2] = dgst[i].buf.sha1[2];
15131 ptrs1[i][3] = dgst[i].buf.sha1[3];
15132 ptrs1[i][4] = dgst[i].buf.sha1[4];
15133
15134 BYTESWAP (dgst[i].buf.sha1[0]);
15135 BYTESWAP (dgst[i].buf.sha1[1]);
15136 BYTESWAP (dgst[i].buf.sha1[2]);
15137 BYTESWAP (dgst[i].buf.sha1[3]);
15138 BYTESWAP (dgst[i].buf.sha1[4]);
15139
15140 ptrs1_swapped[i][0] = dgst[i].buf.sha1[0];
15141 ptrs1_swapped[i][1] = dgst[i].buf.sha1[1];
15142 ptrs1_swapped[i][2] = dgst[i].buf.sha1[2];
15143 ptrs1_swapped[i][3] = dgst[i].buf.sha1[3];
15144 ptrs1_swapped[i][4] = dgst[i].buf.sha1[4];
15145
15146 plains1_swapped[i].len = 20;
15147 }
15148
15149 // sha1 (sha1 ($pass))
15150
15151 sha1_init_sse2 (&digests);
15152
15153 sha1_final_sse2_max55 (plains1_swapped, &digests);
15154
15155 transpose_sha1_digest (&digests, dgst);
15156
15157 for (i = 0; i < 4; i++)
15158 {
15159 BYTESWAP (dgst[i].buf.sha1[0]);
15160 BYTESWAP (dgst[i].buf.sha1[1]);
15161 BYTESWAP (dgst[i].buf.sha1[2]);
15162 BYTESWAP (dgst[i].buf.sha1[3]);
15163 BYTESWAP (dgst[i].buf.sha1[4]);
15164
15165 ptrs2[i][0] = dgst[i].buf.sha1[0];
15166 ptrs2[i][1] = dgst[i].buf.sha1[1];
15167 ptrs2[i][2] = dgst[i].buf.sha1[2];
15168 ptrs2[i][3] = dgst[i].buf.sha1[3];
15169 ptrs2[i][4] = dgst[i].buf.sha1[4];
15170
15171 plains2[i].len = 20;
15172 }
15173
15174 uint32_t salts_idx;
15175
15176 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
15177 {
15178 salt_t *salt = db->salts_buf[salts_idx];
15179
15180 if (salt->indexes_found == salt->indexes_cnt) continue;
15181
15182 // sha1 ($salt . sha1 (sha1 ($pass)))
15183
15184 plain_init (plains3);
15185
15186 sha1_init_sse2 (&digests);
15187
15188 sha1_update_sse2_max55 (plains3, salt->salt_plain_struct);
15189 sha1_update_sse2_max55 (plains3, plains2);
15190
15191 sha1_final_sse2_max55 (plains3, &digests);
15192
15193 transpose_sha1_digest (&digests, dgst);
15194
15195 // the XOR:
15196 // sha1 ($pass) XOR sha1 ($salt . sha1 (sha1 ($pass)))
15197
15198 for (i = 0; i < 4; i++)
15199 {
15200 dgst[i].buf.sha1[0] ^= ptrs1[i][0];
15201 dgst[i].buf.sha1[1] ^= ptrs1[i][1];
15202 dgst[i].buf.sha1[2] ^= ptrs1[i][2];
15203 dgst[i].buf.sha1[3] ^= ptrs1[i][3];
15204 dgst[i].buf.sha1[4] ^= ptrs1[i][4];
15205 }
15206
15207 thread_parameter->indb (thread_parameter, in, dgst, salt);
15208 }
15209 }
15210
hashing_11400(thread_parameter_t * thread_parameter,plain_t * in)15211 void hashing_11400 (thread_parameter_t *thread_parameter, plain_t *in)
15212 {
15213 db_t *db = thread_parameter->db;
15214
15215 digest_md5_sse2_t digests;
15216
15217 digest_t dgst[4];
15218
15219 plain_t plains1[4];
15220
15221 char *ptrs1[4];
15222
15223 ptrs1[0] = (char *) &plains1[0].buf;
15224 ptrs1[1] = (char *) &plains1[1].buf;
15225 ptrs1[2] = (char *) &plains1[2].buf;
15226 ptrs1[3] = (char *) &plains1[3].buf;
15227
15228 plain_t plains2[4];
15229
15230 plain_t plains3[4];
15231
15232 uint32_t salts_idx;
15233
15234 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
15235 {
15236 salt_t *salt = db->salts_buf[salts_idx];
15237
15238 if (salt->indexes_found == salt->indexes_cnt) continue;
15239
15240 // HA1 = md5_max55 ($additional_plain_struct . $pass)
15241
15242 plain_init (plains1);
15243
15244 md5_init_sse2 (&digests);
15245
15246 uint32_t i;
15247
15248 uint remaining_size = salt->additional_plain_struct->len;
15249
15250 uint8_t *salt_plain_struct_ptr = (uint8_t *) salt->additional_plain_struct->buf8;
15251
15252 while (remaining_size > 0)
15253 {
15254 uint current_size = MIN (63, remaining_size);
15255
15256 // set plains3
15257
15258 for (i = 0; i < 4; i++)
15259 {
15260 memcpy (plains3[i].buf8, salt_plain_struct_ptr, current_size);
15261
15262 plains3[i].len = current_size;
15263 }
15264
15265 // MD5
15266
15267 md5_update_sse2 (plains1, &digests, plains3);
15268
15269 // update size and offset
15270
15271 remaining_size -= current_size;
15272 salt_plain_struct_ptr += current_size;
15273 }
15274
15275 md5_update_sse2 (plains1, &digests, in);
15276
15277 md5_final_sse2 (plains1, &digests);
15278
15279 transpose_md5_digest (&digests, dgst);
15280
15281 for (i = 0; i < 4; i++)
15282 {
15283 BYTESWAP (dgst[i].buf.md5[0]);
15284 BYTESWAP (dgst[i].buf.md5[1]);
15285 BYTESWAP (dgst[i].buf.md5[2]);
15286 BYTESWAP (dgst[i].buf.md5[3]);
15287
15288 uint_to_hex_lower (dgst[i].buf.md5[0], &ptrs1[i][0]);
15289 uint_to_hex_lower (dgst[i].buf.md5[1], &ptrs1[i][8]);
15290 uint_to_hex_lower (dgst[i].buf.md5[2], &ptrs1[i][16]);
15291 uint_to_hex_lower (dgst[i].buf.md5[3], &ptrs1[i][24]);
15292
15293 plains1[i].len = 32;
15294 }
15295
15296 // HA2 = md5 ($HA1 . $salt)
15297
15298 plain_init (plains2);
15299
15300 md5_init_sse2 (&digests);
15301
15302 md5_update_sse2 (plains2, &digests, plains1);
15303
15304 remaining_size = salt->salt_plain_struct->len;
15305
15306 salt_plain_struct_ptr = (uint8_t *) salt->salt_plain_struct->buf8;
15307
15308 while (remaining_size > 0)
15309 {
15310 uint current_size = MIN (63, remaining_size);
15311
15312 // set plains3
15313
15314 for (i = 0; i < 4; i++)
15315 {
15316 memcpy (plains3[i].buf8, salt_plain_struct_ptr, current_size);
15317
15318 plains3[i].len = current_size;
15319 }
15320
15321 // MD5
15322
15323 md5_update_sse2 (plains2, &digests, plains3);
15324
15325 // update size and offset
15326
15327 remaining_size -= current_size;
15328 salt_plain_struct_ptr += current_size;
15329 }
15330
15331 md5_final_sse2 (plains2, &digests);
15332
15333 transpose_md5_digest (&digests, dgst);
15334
15335 thread_parameter->indb (thread_parameter, in, dgst, salt);
15336 }
15337 }
15338
hashing_99999(thread_parameter_t * thread_parameter,plain_t * plains)15339 void hashing_99999 (thread_parameter_t *thread_parameter, plain_t *plains)
15340 {
15341 digest_t digests[4];
15342
15343 memcpy (digests[0].buf.plain, plains[0].buf, plains[0].len);
15344 memcpy (digests[1].buf.plain, plains[1].buf, plains[1].len);
15345 memcpy (digests[2].buf.plain, plains[2].buf, plains[2].len);
15346 memcpy (digests[3].buf.plain, plains[3].buf, plains[3].len);
15347
15348 memset (digests[0].buf.plain + plains[0].len, 0, DIGEST_SIZE_PLAIN - plains[0].len);
15349 memset (digests[1].buf.plain + plains[1].len, 0, DIGEST_SIZE_PLAIN - plains[1].len);
15350 memset (digests[2].buf.plain + plains[2].len, 0, DIGEST_SIZE_PLAIN - plains[2].len);
15351 memset (digests[3].buf.plain + plains[3].len, 0, DIGEST_SIZE_PLAIN - plains[3].len);
15352
15353 db_t *db = thread_parameter->db;
15354
15355 thread_parameter->indb (thread_parameter, plains, digests, db->salts_buf[0]);
15356 }
15357
mp_exec(uint64_t val,uint8_t * buf,cs_t * css,int css_cnt)15358 void mp_exec (uint64_t val, uint8_t *buf, cs_t *css, int css_cnt)
15359 {
15360 do
15361 {
15362 const cs_t *cs = css++;
15363
15364 uint32_t len = cs->cs_len;
15365
15366 uint64_t next = val / len;
15367 uint32_t pos = val % len;
15368
15369 const uint8_t c = (uint8_t) cs->cs_buf[pos];
15370
15371 *buf++ = c;
15372
15373 val = next;
15374
15375 } while (--css_cnt);
15376 }
15377
mp_incr(uint64_t cur,uint64_t next,uint8_t * buf,cs_t * css,int css_cnt)15378 void mp_incr (uint64_t cur, uint64_t next, uint8_t *buf, cs_t *css, int css_cnt)
15379 {
15380 do
15381 {
15382 const cs_t *cs = css++;
15383
15384 uint32_t cs_len = cs->cs_len;
15385
15386 uint64_t next_mod = next % cs_len;
15387
15388 const uint8_t c = (uint8_t) cs->cs_buf[next_mod];
15389
15390 *buf++ = c;
15391
15392 uint64_t cur_div = cur / cs_len;
15393 uint64_t next_div = next / cs_len;
15394
15395 if (cur_div == next_div) break;
15396
15397 cur = cur_div;
15398 next = next_div;
15399
15400 } while (--css_cnt);
15401 }
15402
next_permutation(char * word,uint32_t * p,uint32_t k)15403 uint32_t next_permutation (char *word, uint32_t *p, uint32_t k)
15404 {
15405 p[k]--;
15406
15407 uint32_t j = k % 2 * p[k];
15408
15409 char tmp = word[j];
15410
15411 word[j] = word[k];
15412
15413 word[k] = tmp;
15414
15415 for (k = 1; p[k] == 0; k++)
15416 {
15417 p[k] = k;
15418 }
15419
15420 return k;
15421 }
15422
next_tbl(uint8_t * pw_buf,uint32_t v,tbl_t * tbls_buf[BLOCK_SIZE],uint32_t tbls_cnt)15423 uint32_t next_tbl (uint8_t *pw_buf, uint32_t v, tbl_t *tbls_buf[BLOCK_SIZE], uint32_t tbls_cnt)
15424 {
15425 uint32_t pw_len = 0;
15426
15427 uint32_t i;
15428
15429 for (i = 0; i < tbls_cnt; i++)
15430 {
15431 const uint32_t tbl_cnt = tbls_buf[i]->tbl_cnt;
15432
15433 const uint32_t mod = v % tbl_cnt;
15434 const uint32_t div = v / tbl_cnt;
15435
15436 v = div;
15437
15438 hc_wchar_t *hc_wchar_ptr = (hc_wchar_t *) &tbls_buf[i]->tbl_buf[mod];
15439
15440 memcpy (pw_buf + pw_len, hc_wchar_ptr->w_buf, hc_wchar_ptr->w_len);
15441
15442 pw_len += hc_wchar_ptr->w_len;
15443 }
15444
15445 return pw_len;
15446 }
15447
transform_netntlmv1_key(const uint8_t * nthash,uint8_t * key)15448 void transform_netntlmv1_key (const uint8_t *nthash, uint8_t *key)
15449 {
15450 key[0] = (nthash[0] >> 0);
15451 key[1] = (nthash[0] << 7) | (nthash[1] >> 1);
15452 key[2] = (nthash[1] << 6) | (nthash[2] >> 2);
15453 key[3] = (nthash[2] << 5) | (nthash[3] >> 3);
15454 key[4] = (nthash[3] << 4) | (nthash[4] >> 4);
15455 key[5] = (nthash[4] << 3) | (nthash[5] >> 5);
15456 key[6] = (nthash[5] << 2) | (nthash[6] >> 6);
15457 key[7] = (nthash[6] << 1);
15458
15459 key[0] |= 0x01;
15460 key[1] |= 0x01;
15461 key[2] |= 0x01;
15462 key[3] |= 0x01;
15463 key[4] |= 0x01;
15464 key[5] |= 0x01;
15465 key[6] |= 0x01;
15466 key[7] |= 0x01;
15467 }
15468
attack_a5r1()15469 void *attack_a5r1 ()
15470 {
15471 log_info ("Custom-Table-Lookup with rules not supported");
15472
15473 return (NULL);
15474 }
15475
attack_a5r0(thread_parameter_t * thread_parameter)15476 void *attack_a5r0 (thread_parameter_t *thread_parameter)
15477 {
15478 plain_t plains[4];
15479
15480 char *ptrs[4];
15481
15482 memset (plains, 0, sizeof (plains));
15483
15484 if (thread_parameter->hash_type == HASH_TYPE_SHA512 || thread_parameter->hash_type == HASH_TYPE_SHA512UNIX || thread_parameter->hash_type == HASH_TYPE_MSSQL2012 || thread_parameter->hash_type == HASH_TYPE_KECCAK || thread_parameter->hash_type == HASH_TYPE_SHA512AIX || thread_parameter->hash_type == HASH_TYPE_PBKDF2OSX || thread_parameter->hash_type == HASH_TYPE_PBKDF2GRUB || thread_parameter->hash_type == HASH_TYPE_DRUPAL7)
15485 {
15486 ptrs[0] = (char *) &plains[0].buf64;
15487 ptrs[1] = (char *) &plains[1].buf64;
15488 ptrs[2] = (char *) &plains[2].buf64;
15489 ptrs[3] = (char *) &plains[3].buf64;
15490 }
15491 else
15492 {
15493 ptrs[0] = (char *) &plains[0].buf;
15494 ptrs[1] = (char *) &plains[1].buf;
15495 ptrs[2] = (char *) &plains[2].buf;
15496 ptrs[3] = (char *) &plains[3].buf;
15497 }
15498
15499 words_t *words = thread_parameter->db->words;
15500
15501 uint64_t words_skip = (thread_parameter->thread_words_skip == 0) ? 0 : thread_parameter->thread_words_skip;
15502 uint64_t words_limit = (thread_parameter->thread_words_limit == 0) ? words->words_cnt : MIN ((thread_parameter->thread_words_skip + thread_parameter->thread_words_limit), words->words_cnt);
15503 uint64_t words_todo = words_limit - words_skip;
15504 uint64_t words_steps = words_todo / thread_parameter->num_threads;
15505 uint64_t words_left = words_todo % thread_parameter->num_threads;
15506
15507 words_skip += words_steps * thread_parameter->thread_id;
15508
15509 if ((thread_parameter->thread_id + 1) == thread_parameter->num_threads)
15510
15511 words_steps += words_left;
15512
15513 uint64_t words_cur;
15514
15515 for (words_cur = 0; words_cur < words_steps; words_cur++, thread_parameter->thread_words_done++)
15516 {
15517 while (*thread_parameter->hashcat_status == STATUS_PAUSED) hc_sleep (1);
15518
15519 uint64_t words_next = words_skip + words_cur;
15520
15521 tbl_t *tbls_buf[BLOCK_SIZE];
15522
15523 uint32_t tbls_cnt = words->words_len[words_next];
15524
15525 uint32_t total = 1;
15526
15527 uint32_t j;
15528
15529 for (j = 0; j < tbls_cnt; j++)
15530 {
15531 uint8_t c = words->words_buf[words_next][j];
15532
15533 tbls_buf[j] = &thread_parameter->table_buf[c];
15534
15535 total *= tbls_buf[j]->tbl_cnt;
15536 }
15537
15538 uint32_t i;
15539
15540 for (i = 0; i < total; i += 4)
15541 {
15542 uint32_t left = ((i + 4) < total) ? 4 : total - i;
15543
15544 uint32_t j;
15545
15546 for (j = 0; j < left; j++)
15547 {
15548 uint32_t len = next_tbl ((uint8_t *) ptrs[j], i + j, tbls_buf, tbls_cnt);
15549
15550 plains[j].len = len;
15551
15552 plains[j].pos = thread_parameter->thread_plains_done + j; // TODO: needs verification
15553
15554 memset (ptrs[j] + plains[j].len, 0, BLOCK_SIZE - plains[j].len);
15555 }
15556
15557 thread_parameter->hashing (thread_parameter, plains);
15558
15559 thread_parameter->thread_plains_done += left;
15560 }
15561
15562 if (*thread_parameter->hashcat_status == STATUS_QUIT) break;
15563 if (*thread_parameter->hashcat_status == STATUS_BYPASS) break;
15564 }
15565
15566 if ((*thread_parameter->hashcat_status != STATUS_QUIT) && (*thread_parameter->hashcat_status != STATUS_BYPASS))
15567 {
15568 thread_parameter->thread_words_done = words_steps;
15569
15570 thread_parameter->thread_plains_done = words_steps;
15571 }
15572
15573 return (NULL);
15574 }
15575
attack_a4r1()15576 void *attack_a4r1 ()
15577 {
15578 log_info ("Custom-Brute-Force with rules not supported");
15579
15580 return (NULL);
15581 }
15582
attack_a4r0(thread_parameter_t * thread_parameter)15583 void *attack_a4r0 (thread_parameter_t *thread_parameter)
15584 {
15585 plain_t plains[4];
15586
15587 char *ptrs[4];
15588
15589 memset (plains, 0, sizeof (plains));
15590
15591 if (thread_parameter->hash_type == HASH_TYPE_SHA512 || thread_parameter->hash_type == HASH_TYPE_SHA512UNIX || thread_parameter->hash_type == HASH_TYPE_MSSQL2012 || thread_parameter->hash_type == HASH_TYPE_KECCAK || thread_parameter->hash_type == HASH_TYPE_SHA512AIX || thread_parameter->hash_type == HASH_TYPE_PBKDF2OSX || thread_parameter->hash_type == HASH_TYPE_PBKDF2GRUB || thread_parameter->hash_type == HASH_TYPE_DRUPAL7)
15592 {
15593 ptrs[0] = (char *) &plains[0].buf64;
15594 ptrs[1] = (char *) &plains[1].buf64;
15595 ptrs[2] = (char *) &plains[2].buf64;
15596 ptrs[3] = (char *) &plains[3].buf64;
15597 }
15598 else
15599 {
15600 ptrs[0] = (char *) &plains[0].buf;
15601 ptrs[1] = (char *) &plains[1].buf;
15602 ptrs[2] = (char *) &plains[2].buf;
15603 ptrs[3] = (char *) &plains[3].buf;
15604 }
15605
15606 words_t *words = thread_parameter->db->words;
15607
15608 /* word range */
15609
15610 uint64_t words_skip = (thread_parameter->thread_words_skip == 0) ? 0 : thread_parameter->thread_words_skip;
15611 uint64_t words_limit = (thread_parameter->thread_words_limit == 0) ? words->words_cnt : MIN ((thread_parameter->thread_words_skip + thread_parameter->thread_words_limit), words->words_cnt);
15612 uint64_t words_todo = words_limit - words_skip;
15613 uint64_t words_steps = words_todo / thread_parameter->num_threads;
15614 uint64_t words_left = words_todo % thread_parameter->num_threads;
15615
15616 words_skip += words_steps * thread_parameter->thread_id;
15617
15618 if ((thread_parameter->thread_id + 1) == thread_parameter->num_threads)
15619
15620 words_steps += words_left;
15621
15622 /* main loop */
15623
15624 uint64_t words_cur;
15625
15626 for (words_cur = 0; words_cur < words_steps; words_cur++, thread_parameter->thread_words_done++)
15627 {
15628 while (*thread_parameter->hashcat_status == STATUS_PAUSED) hc_sleep (1);
15629
15630 uint64_t words_next = words_skip + words_cur;
15631
15632 plains[0].len = words->words_len[words_next];
15633 plains[1].len = words->words_len[words_next];
15634 plains[2].len = words->words_len[words_next];
15635 plains[3].len = words->words_len[words_next];
15636
15637 memset (ptrs[0] + words->words_len[words_next], 0, BLOCK_SIZE - words->words_len[words_next]);
15638 memset (ptrs[1] + words->words_len[words_next], 0, BLOCK_SIZE - words->words_len[words_next]);
15639 memset (ptrs[2] + words->words_len[words_next], 0, BLOCK_SIZE - words->words_len[words_next]);
15640 memset (ptrs[3] + words->words_len[words_next], 0, BLOCK_SIZE - words->words_len[words_next]);
15641
15642 /* init permutation */
15643
15644 uint32_t p[BLOCK_SIZE];
15645
15646 uint32_t k;
15647
15648 for (k = 0; k < words->words_len[words_next] + 1; k++) p[k] = k;
15649
15650 k = 1;
15651
15652 /* main loop */
15653
15654 uint32_t i = 4;
15655
15656 while (i == 4)
15657 {
15658 for (i = 0; i < 4; i++)
15659 {
15660 if ((k = next_permutation (words->words_buf[words_next], p, k)) == words->words_len[words_next]) break;
15661
15662 memcpy (ptrs[i], words->words_buf[words_next], words->words_len[words_next]);
15663
15664 plains[i].pos = thread_parameter->thread_plains_done + i; // TODO: needs verification
15665 }
15666
15667 int j;
15668
15669 for (j = i; j < 4; j++)
15670 {
15671 memset (ptrs[j], 0, BLOCK_SIZE);
15672
15673 plains[j].len = 0;
15674 }
15675
15676 thread_parameter->hashing (thread_parameter, plains);
15677
15678 thread_parameter->thread_plains_done += 4;
15679 }
15680
15681 if (*thread_parameter->hashcat_status == STATUS_QUIT) break;
15682 if (*thread_parameter->hashcat_status == STATUS_BYPASS) break;
15683 }
15684
15685 if ((*thread_parameter->hashcat_status != STATUS_QUIT) && (*thread_parameter->hashcat_status != STATUS_BYPASS))
15686 {
15687 thread_parameter->thread_words_done = words_steps;
15688
15689 thread_parameter->thread_plains_done = words_steps;
15690 }
15691
15692 return (NULL);
15693 }
15694
attack_a3r1()15695 void *attack_a3r1 ()
15696 {
15697 log_info ("Brute-Force with rules not supported");
15698
15699 return (NULL);
15700 }
15701
attack_a3r0(thread_parameter_t * thread_parameter)15702 void *attack_a3r0 (thread_parameter_t *thread_parameter)
15703 {
15704 plain_t plains[4];
15705
15706 memset (plains, 0, sizeof (plains));
15707
15708 words_t *words = thread_parameter->db->words;
15709
15710 /* word range */
15711
15712 uint64_t words_skip = (thread_parameter->thread_words_skip == 0) ? 0 : thread_parameter->thread_words_skip;
15713 uint64_t words_limit = (thread_parameter->thread_words_limit == 0) ? words->words_cnt : MIN ((thread_parameter->thread_words_skip + thread_parameter->thread_words_limit), words->words_cnt);
15714 uint64_t words_todo = words_limit - words_skip;
15715 uint64_t words_steps = words_todo / thread_parameter->num_threads;
15716 uint64_t words_left = words_todo % thread_parameter->num_threads;
15717
15718 words_skip += words_steps * thread_parameter->thread_id;
15719
15720 if ((thread_parameter->thread_id + 1) == thread_parameter->num_threads)
15721
15722 words_steps += words_left;
15723
15724 /* init buf */
15725
15726 cs_t *css_buf = thread_parameter->css_buf;
15727 uint32_t pw_len = thread_parameter->pw_len;
15728
15729 plains[0].len = pw_len;
15730 plains[1].len = pw_len;
15731 plains[2].len = pw_len;
15732 plains[3].len = pw_len;
15733
15734 uint64 cur[4];
15735
15736 cur[0] = words_skip + 0;
15737 cur[1] = words_skip + 1;
15738 cur[2] = words_skip + 2;
15739 cur[3] = words_skip + 3;
15740
15741 plains[0].pos = thread_parameter->thread_words_done + 0; // TODO: needs verification
15742 plains[1].pos = thread_parameter->thread_words_done + 1; // TODO: needs verification
15743 plains[2].pos = thread_parameter->thread_words_done + 2; // TODO: needs verification
15744 plains[3].pos = thread_parameter->thread_words_done + 3; // TODO: needs verification
15745
15746 mp_exec (cur[0], plains[0].buf8, css_buf, pw_len);
15747 mp_exec (cur[1], plains[1].buf8, css_buf, pw_len);
15748 mp_exec (cur[2], plains[2].buf8, css_buf, pw_len);
15749 mp_exec (cur[3], plains[3].buf8, css_buf, pw_len);
15750
15751 thread_parameter->hashing (thread_parameter, plains);
15752
15753 thread_parameter->thread_words_done += 4;
15754
15755 /* main loop */
15756
15757 uint64_t words_cur;
15758
15759 words_step_size = 4;
15760
15761 for (words_cur = 4; words_cur < words_steps; words_cur += words_step_size)
15762 {
15763 while (*thread_parameter->hashcat_status == STATUS_PAUSED) hc_sleep (1);
15764
15765 uint64_t i;
15766
15767 for (i = 0; i < 4; i++)
15768 {
15769 if ((words_cur + i) == words_steps) break;
15770
15771 mp_incr (cur[i], cur[i] + 4, plains[i].buf8, css_buf, pw_len);
15772
15773 plains[i].pos = thread_parameter->thread_words_done + i; // TODO: needs verification
15774
15775 cur[i] += 4;
15776 }
15777
15778 for ( ; i < 4; i++)
15779 {
15780 plains[i].len = 0;
15781 }
15782
15783 thread_parameter->hashing (thread_parameter, plains);
15784
15785 thread_parameter->thread_words_done += words_step_size;
15786
15787 if (*thread_parameter->hashcat_status == STATUS_QUIT) break;
15788 if (*thread_parameter->hashcat_status == STATUS_BYPASS) break;
15789 }
15790
15791 if ((*thread_parameter->hashcat_status != STATUS_QUIT) && (*thread_parameter->hashcat_status != STATUS_BYPASS))
15792 {
15793 thread_parameter->thread_plains_done = words_steps;
15794 thread_parameter->thread_words_done = words_steps;
15795 }
15796
15797 return (NULL);
15798 }
15799
attack_a1r1(thread_parameter_t * thread_parameter)15800 void *attack_a1r1 (thread_parameter_t *thread_parameter)
15801 {
15802 plain_t plains[4];
15803
15804 char *ptrs[4];
15805
15806 memset (plains, 0, sizeof (plains));
15807
15808 if (thread_parameter->hash_type == HASH_TYPE_SHA512 || thread_parameter->hash_type == HASH_TYPE_SHA512UNIX || thread_parameter->hash_type == HASH_TYPE_MSSQL2012 || thread_parameter->hash_type == HASH_TYPE_KECCAK || thread_parameter->hash_type == HASH_TYPE_SHA512AIX || thread_parameter->hash_type == HASH_TYPE_PBKDF2OSX || thread_parameter->hash_type == HASH_TYPE_PBKDF2GRUB || thread_parameter->hash_type == HASH_TYPE_DRUPAL7)
15809 {
15810 ptrs[0] = (char *) &plains[0].buf64;
15811 ptrs[1] = (char *) &plains[1].buf64;
15812 ptrs[2] = (char *) &plains[2].buf64;
15813 ptrs[3] = (char *) &plains[3].buf64;
15814 }
15815 else
15816 {
15817 ptrs[0] = (char *) &plains[0].buf;
15818 ptrs[1] = (char *) &plains[1].buf;
15819 ptrs[2] = (char *) &plains[2].buf;
15820 ptrs[3] = (char *) &plains[3].buf;
15821 }
15822
15823 words_t *words = thread_parameter->db->words;
15824
15825 rules_t *rules = thread_parameter->db->rules;
15826
15827 /* word range */
15828
15829 uint64_t words_skip = (thread_parameter->thread_words_skip == 0) ? 0 : thread_parameter->thread_words_skip;
15830 uint64_t words_limit = (thread_parameter->thread_words_limit == 0) ? words->words_cnt : MIN ((thread_parameter->thread_words_skip + thread_parameter->thread_words_limit), words->words_cnt);
15831 uint64_t words_todo = words_limit - words_skip;
15832 uint64_t words_steps = words_todo / thread_parameter->num_threads;
15833 uint64_t words_left = words_todo % thread_parameter->num_threads;
15834
15835 words_skip += words_steps * thread_parameter->thread_id;
15836
15837 if ((thread_parameter->thread_id + 1) == thread_parameter->num_threads)
15838
15839 words_steps += words_left;
15840
15841 char * debug_buf;
15842
15843 /* main loop */
15844
15845 uint64_t words_cur;
15846
15847 for (words_cur = 0; words_cur < words_steps; words_cur++, thread_parameter->thread_words_done++)
15848 {
15849 while (*thread_parameter->hashcat_status == STATUS_PAUSED) hc_sleep (1);
15850
15851 uint64_t words_next = words_skip + words_cur;
15852
15853 char orig_plain[BLOCK_SIZE];
15854
15855 memset (orig_plain, 0, sizeof (orig_plain));
15856
15857 memcpy (orig_plain, words->words_buf[words_next], words->words_len[words_next]);
15858
15859 uint32_t rules_idx;
15860
15861 for (rules_idx = 0; rules_idx < rules->rules_cnt; rules_idx += 4)
15862 {
15863 uint32_t l;
15864
15865 for (l = 0; l < words->words_cnt; l++)
15866 {
15867 uint32_t orig_plain_len = words->words_len[words_next] + words->words_len[l];
15868
15869 if (orig_plain_len > thread_parameter->plain_size_max) continue;
15870
15871 memcpy (orig_plain + words->words_len[words_next], words->words_buf[l], words->words_len[l]);
15872
15873 uint32_t i;
15874
15875 //uint limit = MIN (4, words->words_cnt - l);
15876
15877 for (i = 0; i < 4; i++)
15878 {
15879 if ((rules_idx + i) >= rules->rules_cnt)
15880 {
15881 plains[i].len = 0;
15882
15883 continue;
15884 }
15885
15886 int next_len = apply_rule (rules->rules_buf[rules_idx + i], rules->rules_len[rules_idx + i], orig_plain, orig_plain_len, ptrs[i]);
15887
15888 if ((next_len < 0) || ((uint32_t) next_len > thread_parameter->plain_size_max)) continue;
15889
15890 plains[i].len = next_len;
15891
15892 plains[i].pos = thread_parameter->thread_words_done + i; // TODO: needs verification
15893
15894 switch (thread_parameter->debug_mode)
15895 {
15896 case 1:
15897 plains[i].debug_buf = rules->rules_buf[rules_idx + i];
15898 plains[i].debug_len = rules->rules_len[rules_idx + i];
15899 break;
15900
15901 case 2:
15902 plains[i].debug_buf = orig_plain;
15903 plains[i].debug_len = orig_plain_len;
15904 break;
15905
15906 case 3:
15907 {
15908 debug_buf = (char*) mymalloc (sizeof (char) * (orig_plain_len + 1 + rules->rules_len[rules_idx + i] + 1));
15909
15910 memset (debug_buf, 0, orig_plain_len + 1 + rules->rules_len[rules_idx + i] + 1);
15911
15912 uint pos = 0;
15913
15914 memcpy (debug_buf + pos, orig_plain, orig_plain_len);
15915
15916 pos += orig_plain_len;
15917
15918 debug_buf[pos] = thread_parameter->separator;
15919
15920 pos += 1;
15921
15922 memcpy (debug_buf + pos, rules->rules_buf[rules_idx + i], rules->rules_len[rules_idx + i]);
15923
15924 pos += rules->rules_len[rules_idx + i];
15925
15926 plains[i].debug_buf = debug_buf;
15927 plains[i].debug_len = pos;
15928 break;
15929 }
15930 case 4:
15931 {
15932 debug_buf = (char*) mymalloc (sizeof (char) * (orig_plain_len + 1 + rules->rules_len[rules_idx + i] + 1 + next_len + 1));
15933
15934 memset (debug_buf, 0, orig_plain_len + 1 + rules->rules_len[rules_idx + i] + 1 + next_len + 1);
15935
15936 uint pos = 0;
15937
15938 memcpy (debug_buf + pos, orig_plain, orig_plain_len);
15939
15940 pos += orig_plain_len;
15941
15942 debug_buf[pos] = thread_parameter->separator;
15943
15944 pos += 1;
15945
15946 memcpy (debug_buf + pos, rules->rules_buf[rules_idx + i], rules->rules_len[rules_idx + i]);
15947
15948 pos += rules->rules_len[rules_idx + i];
15949
15950 debug_buf[pos] = thread_parameter->separator;
15951
15952 pos += 1;
15953
15954 memcpy (debug_buf + pos, ptrs[i], next_len);
15955
15956 pos += next_len;
15957
15958 plains[i].debug_buf = debug_buf;
15959 plains[i].debug_len = pos;
15960 break;
15961 }
15962 }
15963 }
15964
15965 thread_parameter->hashing (thread_parameter, plains);
15966
15967 thread_parameter->thread_plains_done += 4;
15968
15969 // clean up , free debug buffer etc
15970
15971 if ((thread_parameter->debug_mode == 3) || (thread_parameter->debug_mode == 4))
15972 {
15973 for (i = 0; (i < 4); i++)
15974 {
15975 myfree (plains[i].debug_buf);
15976
15977 plains[i].debug_buf = NULL;
15978 }
15979 }
15980
15981 if (*thread_parameter->hashcat_status == STATUS_QUIT) break;
15982 if (*thread_parameter->hashcat_status == STATUS_BYPASS) break;
15983 }
15984
15985 if (*thread_parameter->hashcat_status == STATUS_QUIT) break;
15986 if (*thread_parameter->hashcat_status == STATUS_BYPASS) break;
15987 }
15988
15989 if (*thread_parameter->hashcat_status == STATUS_QUIT) break;
15990 if (*thread_parameter->hashcat_status == STATUS_BYPASS) break;
15991 }
15992
15993 return (NULL);
15994 }
15995
attack_a1r0(thread_parameter_t * thread_parameter)15996 void *attack_a1r0 (thread_parameter_t *thread_parameter)
15997 {
15998 plain_t plains[4];
15999
16000 char *ptrs[4];
16001
16002 memset (plains, 0, sizeof (plains));
16003
16004 if (thread_parameter->hash_type == HASH_TYPE_SHA512 || thread_parameter->hash_type == HASH_TYPE_SHA512UNIX || thread_parameter->hash_type == HASH_TYPE_MSSQL2012 || thread_parameter->hash_type == HASH_TYPE_KECCAK || thread_parameter->hash_type == HASH_TYPE_SHA512AIX || thread_parameter->hash_type == HASH_TYPE_PBKDF2OSX || thread_parameter->hash_type == HASH_TYPE_PBKDF2GRUB || thread_parameter->hash_type == HASH_TYPE_DRUPAL7)
16005 {
16006 ptrs[0] = (char *) &plains[0].buf64;
16007 ptrs[1] = (char *) &plains[1].buf64;
16008 ptrs[2] = (char *) &plains[2].buf64;
16009 ptrs[3] = (char *) &plains[3].buf64;
16010 }
16011 else
16012 {
16013 ptrs[0] = (char *) &plains[0].buf;
16014 ptrs[1] = (char *) &plains[1].buf;
16015 ptrs[2] = (char *) &plains[2].buf;
16016 ptrs[3] = (char *) &plains[3].buf;
16017 }
16018
16019 words_t *words = thread_parameter->db->words;
16020
16021 /* word range */
16022
16023 uint64_t words_skip = (thread_parameter->thread_words_skip == 0) ? 0 : thread_parameter->thread_words_skip;
16024 uint64_t words_limit = (thread_parameter->thread_words_limit == 0) ? words->words_cnt : MIN ((thread_parameter->thread_words_skip + thread_parameter->thread_words_limit), words->words_cnt);
16025 uint64_t words_todo = words_limit - words_skip;
16026 uint64_t words_steps = words_todo / thread_parameter->num_threads;
16027 uint64_t words_left = words_todo % thread_parameter->num_threads;
16028
16029 words_skip += words_steps * thread_parameter->thread_id;
16030
16031 if ((thread_parameter->thread_id + 1) == thread_parameter->num_threads)
16032
16033 words_steps += words_left;
16034
16035 /* main loop */
16036
16037 uint64_t words_cur;
16038
16039 for (words_cur = 0; words_cur < words_steps; words_cur++, thread_parameter->thread_words_done++)
16040 {
16041 while (*thread_parameter->hashcat_status == STATUS_PAUSED) hc_sleep (1);
16042
16043 uint64_t words_next = words_skip + words_cur;
16044
16045 memcpy (ptrs[0], words->words_buf[words_next], words->words_len[words_next]);
16046 memcpy (ptrs[1], words->words_buf[words_next], words->words_len[words_next]);
16047 memcpy (ptrs[2], words->words_buf[words_next], words->words_len[words_next]);
16048 memcpy (ptrs[3], words->words_buf[words_next], words->words_len[words_next]);
16049
16050 uint32_t l;
16051
16052 for (l = 0; l < words->words_cnt; l += 4)
16053 {
16054 uint32_t i;
16055
16056 uint limit = MIN (4, words->words_cnt - l);
16057
16058 for (i = 0; i < limit; i++)
16059 {
16060 uint32_t next_len = words->words_len[words_next] + words->words_len[l + i];
16061
16062 if (next_len > thread_parameter->plain_size_max) continue;
16063
16064 memset (ptrs[i] + next_len, 0, BLOCK_SIZE - next_len);
16065
16066 memcpy (ptrs[i] + words->words_len[words_next], words->words_buf[l + i], words->words_len[l + i]);
16067
16068 plains[i].len = next_len;
16069
16070 plains[i].pos = thread_parameter->thread_words_done + i; // TODO: needs verification
16071 }
16072
16073 for (; i < 4; i++)
16074 {
16075 // memset () not really needed (but this is what is the main problem):
16076 // memset (ptrs[i], 0, BLOCK_SIZE);
16077
16078 plains[i].len = 0;
16079 }
16080
16081 thread_parameter->hashing (thread_parameter, plains);
16082
16083 thread_parameter->thread_plains_done += 4;
16084
16085 if (*thread_parameter->hashcat_status == STATUS_QUIT) break;
16086 if (*thread_parameter->hashcat_status == STATUS_BYPASS) break;
16087 }
16088
16089 if (*thread_parameter->hashcat_status == STATUS_QUIT) break;
16090 if (*thread_parameter->hashcat_status == STATUS_BYPASS) break;
16091 }
16092
16093 return (NULL);
16094 }
16095
attack_a0r1(thread_parameter_t * thread_parameter)16096 void *attack_a0r1 (thread_parameter_t *thread_parameter)
16097 {
16098 plain_t plains[4];
16099
16100 char *ptrs[4];
16101
16102 memset (plains, 0, sizeof (plains));
16103
16104 if (thread_parameter->hash_type == HASH_TYPE_SHA512 || thread_parameter->hash_type == HASH_TYPE_SHA512UNIX || thread_parameter->hash_type == HASH_TYPE_MSSQL2012 || thread_parameter->hash_type == HASH_TYPE_KECCAK || thread_parameter->hash_type == HASH_TYPE_SHA512AIX || thread_parameter->hash_type == HASH_TYPE_PBKDF2OSX || thread_parameter->hash_type == HASH_TYPE_PBKDF2GRUB || thread_parameter->hash_type == HASH_TYPE_DRUPAL7)
16105 {
16106 ptrs[0] = (char *) &plains[0].buf64;
16107 ptrs[1] = (char *) &plains[1].buf64;
16108 ptrs[2] = (char *) &plains[2].buf64;
16109 ptrs[3] = (char *) &plains[3].buf64;
16110 }
16111 else
16112 {
16113 ptrs[0] = (char *) &plains[0].buf;
16114 ptrs[1] = (char *) &plains[1].buf;
16115 ptrs[2] = (char *) &plains[2].buf;
16116 ptrs[3] = (char *) &plains[3].buf;
16117 }
16118
16119 words_t *words = thread_parameter->db->words;
16120
16121 rules_t *rules = thread_parameter->db->rules;
16122
16123 /* word range */
16124
16125 uint64_t words_skip = (thread_parameter->thread_words_skip == 0) ? 0 : thread_parameter->thread_words_skip;
16126 uint64_t words_limit = (thread_parameter->thread_words_limit == 0) ? words->words_cnt : MIN ((thread_parameter->thread_words_skip + thread_parameter->thread_words_limit), words->words_cnt);
16127 uint64_t words_todo = words_limit - words_skip;
16128 uint64_t words_steps = words_todo / thread_parameter->num_threads;
16129 uint64_t words_left = words_todo % thread_parameter->num_threads;
16130
16131 words_skip += words_steps * thread_parameter->thread_id;
16132
16133 if ((thread_parameter->thread_id + 1) == thread_parameter->num_threads)
16134
16135 words_steps += words_left;
16136
16137 char * debug_buf;
16138
16139 /* main loop */
16140
16141 uint64_t words_cur;
16142
16143 for (words_cur = 0; words_cur < words_steps; words_cur++)
16144 {
16145 while (*thread_parameter->hashcat_status == STATUS_PAUSED) hc_sleep (1);
16146
16147 uint32_t rules_cnt = rules->rules_cnt;
16148
16149 uint32_t rules_idx = 0;
16150
16151 while (rules_idx < rules_cnt)
16152 {
16153 uint64_t words_next = words_skip + words_cur;
16154
16155 uint32_t i;
16156
16157 for (i = 0; ((i < 4) && (rules_idx < rules_cnt)); rules_idx++, thread_parameter->thread_plains_done++)
16158 {
16159 int next_len = apply_rule (rules->rules_buf[rules_idx], rules->rules_len[rules_idx], words->words_buf[words_next], words->words_len[words_next], ptrs[i]);
16160
16161 if ((next_len < 0) || ((uint32_t) next_len > thread_parameter->plain_size_max)) continue;
16162
16163 plains[i].len = next_len;
16164
16165 plains[i].pos = thread_parameter->thread_words_done + i; // TODO: needs verification
16166
16167 switch (thread_parameter->debug_mode)
16168 {
16169 case 1:
16170 plains[i].debug_buf = rules->rules_buf[rules_idx];
16171 plains[i].debug_len = rules->rules_len[rules_idx];
16172 break;
16173
16174 case 2:
16175 plains[i].debug_buf = words->words_buf[words_next];
16176 plains[i].debug_len = words->words_len[words_next];
16177 break;
16178
16179 case 3:
16180 {
16181 debug_buf = (char*) mymalloc (sizeof (char) * (words->words_len[words_next] + 1 + rules->rules_len[rules_idx] + 1));
16182
16183 memset (debug_buf, 0, words->words_len[words_next] + 1 + rules->rules_len[rules_idx] + 1);
16184
16185 uint pos = 0;
16186
16187 memcpy (debug_buf + pos, words->words_buf[words_next], words->words_len[words_next]);
16188
16189 pos += words->words_len[words_next];
16190
16191 debug_buf[pos] = thread_parameter->separator;
16192
16193 pos += 1;
16194
16195 memcpy (debug_buf + pos, rules->rules_buf[rules_idx], rules->rules_len[rules_idx]);
16196
16197 pos += rules->rules_len[rules_idx];
16198
16199 plains[i].debug_buf = debug_buf;
16200 plains[i].debug_len = pos;
16201 break;
16202 }
16203 case 4:
16204 {
16205 debug_buf = (char*) mymalloc (sizeof (char) * (words->words_len[words_next] + 1 + rules->rules_len[rules_idx] + 1 + next_len + 1));
16206
16207 memset (debug_buf, 0, words->words_len[words_next] + 1 + rules->rules_len[rules_idx] + 1 + next_len + 1);
16208
16209 uint pos = 0;
16210
16211 memcpy (debug_buf + pos, words->words_buf[words_next], words->words_len[words_next]);
16212
16213 pos += words->words_len[words_next];
16214
16215 debug_buf[pos] = thread_parameter->separator;
16216
16217 pos += 1;
16218
16219 memcpy (debug_buf + pos, rules->rules_buf[rules_idx], rules->rules_len[rules_idx]);
16220
16221 pos += rules->rules_len[rules_idx];
16222
16223 debug_buf[pos] = thread_parameter->separator;
16224
16225 pos += 1;
16226
16227 memcpy (debug_buf + pos, ptrs[i], next_len);
16228
16229 pos += next_len;
16230
16231 plains[i].debug_buf = debug_buf;
16232 plains[i].debug_len = pos;
16233 break;
16234 }
16235 }
16236
16237 i++;
16238 }
16239
16240 for ( ; i < 4; i++)
16241 {
16242 memset (ptrs[i], 0, 64);
16243
16244 plains[i].len = 0;
16245 }
16246
16247 thread_parameter->hashing (thread_parameter, plains);
16248
16249 // clean up , free debug buffer etc
16250
16251 if ((thread_parameter->debug_mode == 3) || (thread_parameter->debug_mode == 4))
16252 {
16253 for (i = 0; (i < 4); i++)
16254 {
16255 myfree (plains[i].debug_buf);
16256
16257 plains[i].debug_buf = NULL;
16258 }
16259 }
16260
16261 if (*thread_parameter->hashcat_status == STATUS_QUIT) break;
16262 if (*thread_parameter->hashcat_status == STATUS_BYPASS) break;
16263 }
16264
16265 thread_parameter->thread_words_done++;
16266
16267 if (*thread_parameter->hashcat_status == STATUS_QUIT) break;
16268 if (*thread_parameter->hashcat_status == STATUS_BYPASS) break;
16269 }
16270
16271 if ((*thread_parameter->hashcat_status != STATUS_QUIT) && (*thread_parameter->hashcat_status != STATUS_BYPASS))
16272 {
16273 thread_parameter->thread_plains_done = words_steps * rules->rules_cnt;
16274
16275 thread_parameter->thread_words_done = words_steps;
16276 }
16277
16278 return (NULL);
16279 }
16280
attack_a0r0(thread_parameter_t * thread_parameter)16281 void *attack_a0r0 (thread_parameter_t *thread_parameter)
16282 {
16283 plain_t plains[4];
16284
16285 char *ptrs[4];
16286
16287 memset (plains, 0, sizeof (plains));
16288
16289 if (thread_parameter->hash_type == HASH_TYPE_SHA512 || thread_parameter->hash_type == HASH_TYPE_SHA512UNIX || thread_parameter->hash_type == HASH_TYPE_MSSQL2012 || thread_parameter->hash_type == HASH_TYPE_KECCAK || thread_parameter->hash_type == HASH_TYPE_SHA512AIX || thread_parameter->hash_type == HASH_TYPE_PBKDF2OSX || thread_parameter->hash_type == HASH_TYPE_PBKDF2GRUB || thread_parameter->hash_type == HASH_TYPE_DRUPAL7)
16290 {
16291 ptrs[0] = (char *) &plains[0].buf64;
16292 ptrs[1] = (char *) &plains[1].buf64;
16293 ptrs[2] = (char *) &plains[2].buf64;
16294 ptrs[3] = (char *) &plains[3].buf64;
16295 }
16296 else
16297 {
16298 ptrs[0] = (char *) &plains[0].buf;
16299 ptrs[1] = (char *) &plains[1].buf;
16300 ptrs[2] = (char *) &plains[2].buf;
16301 ptrs[3] = (char *) &plains[3].buf;
16302 }
16303
16304 words_t *words = thread_parameter->db->words;
16305
16306 /* word range */
16307
16308 uint64_t words_skip = (thread_parameter->thread_words_skip == 0) ? 0 : thread_parameter->thread_words_skip;
16309 uint64_t words_limit = (thread_parameter->thread_words_limit == 0) ? words->words_cnt : MIN ((thread_parameter->thread_words_skip + thread_parameter->thread_words_limit), words->words_cnt);
16310 uint64_t words_todo = words_limit - words_skip;
16311 uint64_t words_steps = words_todo / thread_parameter->num_threads;
16312 uint64_t words_left = words_todo % thread_parameter->num_threads;
16313
16314 words_skip += words_steps * thread_parameter->thread_id;
16315
16316 if ((thread_parameter->thread_id + 1) == thread_parameter->num_threads)
16317
16318 words_steps += words_left;
16319
16320 /* main loop */
16321
16322 uint64_t words_cur;
16323
16324 words_step_size = 4;
16325
16326 for (words_cur = 0; words_cur < words_steps; words_cur += words_step_size)
16327 {
16328 while (*thread_parameter->hashcat_status == STATUS_PAUSED) hc_sleep (1);
16329
16330 uint64_t words_next = words_skip + words_cur;
16331
16332 uint32_t i;
16333
16334 for (i = 0; i < 4; i++, words_next++)
16335 {
16336 int next_len = words->words_len[words_next];
16337
16338 int zero_len = plains[i].len - next_len;
16339
16340 if (zero_len > 0) memset (ptrs[i] + next_len, 0, zero_len + 1);
16341
16342 memcpy (ptrs[i], words->words_buf[words_next], next_len);
16343
16344 plains[i].len = next_len;
16345
16346 plains[i].pos = thread_parameter->thread_words_done + i;
16347 }
16348
16349 thread_parameter->hashing (thread_parameter, plains);
16350
16351 thread_parameter->thread_plains_done += 4;
16352
16353 thread_parameter->thread_words_done += words_step_size;
16354
16355 if (*thread_parameter->hashcat_status == STATUS_QUIT) break;
16356 if (*thread_parameter->hashcat_status == STATUS_BYPASS) break;
16357 }
16358
16359 if ((*thread_parameter->hashcat_status != STATUS_QUIT) && (*thread_parameter->hashcat_status != STATUS_BYPASS))
16360 {
16361 thread_parameter->thread_plains_done = words_steps;
16362
16363 thread_parameter->thread_words_done = words_steps;
16364 }
16365
16366 return (NULL);
16367 }
16368
run_threads(engine_parameter_t * engine_parameter,db_t * db,void (* store_out)(plain_t *,digest_t *,salt_t *),void (* store_debug)(char *,int),void (* done)(),digest_t * quick_digest)16369 void run_threads (engine_parameter_t *engine_parameter, db_t *db, void (*store_out) (plain_t *, digest_t *, salt_t *), void (*store_debug) (char *, int), void (*done) (), digest_t *quick_digest)
16370 {
16371 unsigned int ids[MAX_THREADS];
16372
16373 memset (ids, 0, sizeof (ids));
16374
16375 THREAD threads[MAX_THREADS];
16376
16377 ACMutexInit (lock_store);
16378
16379 uint32_t thread_id;
16380
16381 for (thread_id = 0; thread_id < engine_parameter->num_threads; thread_id++)
16382 {
16383 thread_parameters[thread_id].thread_id = thread_id;
16384 thread_parameters[thread_id].num_threads = engine_parameter->num_threads;
16385 thread_parameters[thread_id].thread_words_skip = engine_parameter->words_skip;
16386 thread_parameters[thread_id].thread_words_limit = engine_parameter->words_limit;
16387 thread_parameters[thread_id].thread_words_done = 0;
16388 thread_parameters[thread_id].thread_plains_done = 0;
16389 thread_parameters[thread_id].db = db;
16390 thread_parameters[thread_id].store_out = store_out;
16391 thread_parameters[thread_id].store_debug = store_debug;
16392 thread_parameters[thread_id].separator = engine_parameter->separator;
16393 thread_parameters[thread_id].done = done;
16394 thread_parameters[thread_id].hashcat_status = &engine_parameter->hashcat_status;
16395 thread_parameters[thread_id].pw_len = engine_parameter->pw_len;
16396 thread_parameters[thread_id].css_buf = engine_parameter->css_buf;
16397 thread_parameters[thread_id].css_cnt = engine_parameter->css_cnt;
16398 thread_parameters[thread_id].debug_mode = engine_parameter->debug_mode;
16399 thread_parameters[thread_id].debug_file = engine_parameter->file_debug;
16400 thread_parameters[thread_id].plain_size_max = engine_parameter->plain_size_max;
16401 thread_parameters[thread_id].table_buf = engine_parameter->table_buf;
16402 thread_parameters[thread_id].hash_type = engine_parameter->hash_type;
16403
16404 if ((engine_parameter->hash_mode == 8900) || (engine_parameter->hash_mode == 9300))
16405 {
16406 uint32_t max_N = 0;
16407 uint32_t max_r = 0;
16408 uint32_t max_p = 0;
16409
16410 uint32_t salts_idx;
16411
16412 for (salts_idx = 0; salts_idx < db->salts_cnt; salts_idx++)
16413 {
16414 salt_t *salt = db->salts_buf[salts_idx];
16415
16416 max_N = MAX (max_N, salt->scrypt_N);
16417 max_r = MAX (max_r, salt->scrypt_r);
16418 max_p = MAX (max_p, salt->scrypt_p);
16419 }
16420
16421 const uint32_t scrypt_cnt = GET_SCRYPT_CNT (max_r, max_p);
16422 const uint32_t smix_cnt = GET_SMIX_CNT (max_r, max_N);
16423 const uint32_t state_cnt = GET_STATE_CNT (max_r);
16424
16425 thread_parameters[thread_id].scrypt_P[0] = (uint32_t *) mymalloc (scrypt_cnt * sizeof (uint32_t));
16426 thread_parameters[thread_id].scrypt_P[1] = (uint32_t *) mymalloc (scrypt_cnt * sizeof (uint32_t));
16427 thread_parameters[thread_id].scrypt_P[2] = (uint32_t *) mymalloc (scrypt_cnt * sizeof (uint32_t));
16428 thread_parameters[thread_id].scrypt_P[3] = (uint32_t *) mymalloc (scrypt_cnt * sizeof (uint32_t));
16429
16430 thread_parameters[thread_id].scrypt_V = (__m128i *) _mm_malloc (smix_cnt * sizeof (uint32_t), 64);
16431 thread_parameters[thread_id].scrypt_X = (__m128i *) _mm_malloc (state_cnt * sizeof (uint32_t), 64);
16432 thread_parameters[thread_id].scrypt_Y = (__m128i *) _mm_malloc (state_cnt * sizeof (uint32_t), 64);
16433 }
16434
16435 if (quick_digest)
16436 {
16437 thread_parameters[thread_id].indb = indb_single;
16438 thread_parameters[thread_id].quick_digest = quick_digest;
16439 }
16440 else
16441 {
16442 thread_parameters[thread_id].indb = indb_multi;
16443 thread_parameters[thread_id].quick_digest = NULL;
16444 }
16445
16446 switch (engine_parameter->hash_mode)
16447 {
16448 case 0: thread_parameters[thread_id].hashing = hashing_00000; break;
16449 case 10: thread_parameters[thread_id].hashing = hashing_00010; break;
16450 case 20: thread_parameters[thread_id].hashing = hashing_00020; break;
16451 case 30: thread_parameters[thread_id].hashing = hashing_00030; break;
16452 case 40: thread_parameters[thread_id].hashing = hashing_00040; break;
16453 case 50: thread_parameters[thread_id].hashing = hashing_00050; break;
16454 case 60: thread_parameters[thread_id].hashing = hashing_00060; break;
16455 case 100: thread_parameters[thread_id].hashing = hashing_00100; break;
16456 case 110: thread_parameters[thread_id].hashing = hashing_00110; break;
16457 case 120: thread_parameters[thread_id].hashing = hashing_00120; break;
16458 case 130: thread_parameters[thread_id].hashing = hashing_00130; break;
16459 case 140: thread_parameters[thread_id].hashing = hashing_00140; break;
16460 case 150: thread_parameters[thread_id].hashing = hashing_00150; break;
16461 case 160: thread_parameters[thread_id].hashing = hashing_00160; break;
16462 case 200: thread_parameters[thread_id].hashing = hashing_00200; break;
16463 case 300: thread_parameters[thread_id].hashing = hashing_00300; break;
16464 case 400: thread_parameters[thread_id].hashing = hashing_00400; break;
16465 case 500: thread_parameters[thread_id].hashing = hashing_00500; break;
16466 case 666: thread_parameters[thread_id].hashing = hashing_00666; break;
16467 case 900: thread_parameters[thread_id].hashing = hashing_00900; break;
16468 case 1000: thread_parameters[thread_id].hashing = hashing_01000; break;
16469 case 1100: thread_parameters[thread_id].hashing = hashing_01100; break;
16470 case 1400: thread_parameters[thread_id].hashing = hashing_01400; break;
16471 case 1410: thread_parameters[thread_id].hashing = hashing_01410; break;
16472 case 1420: thread_parameters[thread_id].hashing = hashing_01420; break;
16473 case 1430: thread_parameters[thread_id].hashing = hashing_01430; break;
16474 case 1431: thread_parameters[thread_id].hashing = hashing_01431; break;
16475 case 1440: thread_parameters[thread_id].hashing = hashing_01440; break;
16476 case 1441: thread_parameters[thread_id].hashing = hashing_01440; break;
16477 case 1450: thread_parameters[thread_id].hashing = hashing_01450; break;
16478 case 1460: thread_parameters[thread_id].hashing = hashing_01460; break;
16479 case 1500: thread_parameters[thread_id].hashing = hashing_01500; break;
16480 case 1600: thread_parameters[thread_id].hashing = hashing_01600; break;
16481 case 1700: thread_parameters[thread_id].hashing = hashing_01700; break;
16482 case 1710: thread_parameters[thread_id].hashing = hashing_01710; break;
16483 case 1720: thread_parameters[thread_id].hashing = hashing_01720; break;
16484 case 1730: thread_parameters[thread_id].hashing = hashing_01730; break;
16485 case 1740: thread_parameters[thread_id].hashing = hashing_01740; break;
16486 case 1750: thread_parameters[thread_id].hashing = hashing_01750; break;
16487 case 1760: thread_parameters[thread_id].hashing = hashing_01760; break;
16488 case 1800: thread_parameters[thread_id].hashing = hashing_01800; break;
16489 case 2400: thread_parameters[thread_id].hashing = hashing_02400; break;
16490 case 2410: thread_parameters[thread_id].hashing = hashing_02410; break;
16491 case 2500: thread_parameters[thread_id].hashing = hashing_02500; break;
16492 case 2600: thread_parameters[thread_id].hashing = hashing_02600; break;
16493 case 3200: thread_parameters[thread_id].hashing = hashing_03200; break;
16494 case 3300: thread_parameters[thread_id].hashing = hashing_03300; break;
16495 case 3500: thread_parameters[thread_id].hashing = hashing_03500; break;
16496 case 3610: thread_parameters[thread_id].hashing = hashing_03610; break;
16497 case 3710: thread_parameters[thread_id].hashing = hashing_03710; break;
16498 case 3720: thread_parameters[thread_id].hashing = hashing_03720; break;
16499 case 3800: thread_parameters[thread_id].hashing = hashing_03800; break;
16500 case 3910: thread_parameters[thread_id].hashing = hashing_03910; break;
16501 case 4010: thread_parameters[thread_id].hashing = hashing_04010; break;
16502 case 4110: thread_parameters[thread_id].hashing = hashing_04110; break;
16503 case 4210: thread_parameters[thread_id].hashing = hashing_04210; break;
16504 case 4300: thread_parameters[thread_id].hashing = hashing_04300; break;
16505 case 4400: thread_parameters[thread_id].hashing = hashing_04400; break;
16506 case 4500: thread_parameters[thread_id].hashing = hashing_04500; break;
16507 case 4600: thread_parameters[thread_id].hashing = hashing_04600; break;
16508 case 4700: thread_parameters[thread_id].hashing = hashing_04700; break;
16509 case 4800: thread_parameters[thread_id].hashing = hashing_04800; break;
16510 case 4900: thread_parameters[thread_id].hashing = hashing_04900; break;
16511 case 5000: thread_parameters[thread_id].hashing = hashing_05000; break;
16512 case 5100: thread_parameters[thread_id].hashing = hashing_05100; break;
16513 case 5200: thread_parameters[thread_id].hashing = hashing_05200; break;
16514 case 5300: thread_parameters[thread_id].hashing = hashing_05300; break;
16515 case 5400: thread_parameters[thread_id].hashing = hashing_05400; break;
16516 case 5500: thread_parameters[thread_id].hashing = hashing_05500; break;
16517 case 5600: thread_parameters[thread_id].hashing = hashing_05600; break;
16518 case 5700: thread_parameters[thread_id].hashing = hashing_01400; break;
16519 case 5800: thread_parameters[thread_id].hashing = hashing_05800; break;
16520 case 6300: thread_parameters[thread_id].hashing = hashing_06300; break;
16521 case 6400: thread_parameters[thread_id].hashing = hashing_06400; break;
16522 case 6500: thread_parameters[thread_id].hashing = hashing_06500; break;
16523 case 6700: thread_parameters[thread_id].hashing = hashing_06700; break;
16524 case 6900: thread_parameters[thread_id].hashing = hashing_06900; break;
16525 case 7000: thread_parameters[thread_id].hashing = hashing_07000; break;
16526 case 7100: thread_parameters[thread_id].hashing = hashing_07100; break;
16527 case 7200: thread_parameters[thread_id].hashing = hashing_07100; break;
16528 case 7300: thread_parameters[thread_id].hashing = hashing_07300; break;
16529 case 7400: thread_parameters[thread_id].hashing = hashing_07400; break;
16530 case 7900: thread_parameters[thread_id].hashing = hashing_07900; break;
16531 case 8400: thread_parameters[thread_id].hashing = hashing_08400; break;
16532 case 8900: thread_parameters[thread_id].hashing = hashing_08900; break;
16533 case 9200: thread_parameters[thread_id].hashing = hashing_09200; break;
16534 case 9300: thread_parameters[thread_id].hashing = hashing_08900; break;
16535 case 9900: thread_parameters[thread_id].hashing = hashing_09900; break;
16536 case 10200: thread_parameters[thread_id].hashing = hashing_00050; break;
16537 case 10300: thread_parameters[thread_id].hashing = hashing_10300; break;
16538 case 10000: thread_parameters[thread_id].hashing = hashing_09200; break;
16539 case 11000: thread_parameters[thread_id].hashing = hashing_11000; break;
16540 case 11100: thread_parameters[thread_id].hashing = hashing_11100; break;
16541 case 11200: thread_parameters[thread_id].hashing = hashing_11200; break;
16542 case 11400: thread_parameters[thread_id].hashing = hashing_11400; break;
16543 case 99999: thread_parameters[thread_id].hashing = hashing_99999; break;
16544 case 11: thread_parameters[thread_id].hashing = hashing_00010; break;
16545 case 12: thread_parameters[thread_id].hashing = hashing_00010; break;
16546 case 21: thread_parameters[thread_id].hashing = hashing_00020; break;
16547 case 23: thread_parameters[thread_id].hashing = hashing_00020; break;
16548 case 101: thread_parameters[thread_id].hashing = hashing_00100; break;
16549 case 111: thread_parameters[thread_id].hashing = hashing_00110; break;
16550 case 112: thread_parameters[thread_id].hashing = hashing_00110; break;
16551 case 121: thread_parameters[thread_id].hashing = hashing_00120; break;
16552 case 122: thread_parameters[thread_id].hashing = hashing_00120; break;
16553 case 123: thread_parameters[thread_id].hashing = hashing_00123; break;
16554 case 124: thread_parameters[thread_id].hashing = hashing_00120; break;
16555 case 131: thread_parameters[thread_id].hashing = hashing_00131; break;
16556 case 132: thread_parameters[thread_id].hashing = hashing_00130; break;
16557 case 133: thread_parameters[thread_id].hashing = hashing_00133; break;
16558 case 141: thread_parameters[thread_id].hashing = hashing_00140; break;
16559 case 1421: thread_parameters[thread_id].hashing = hashing_01420; break;
16560 case 1711: thread_parameters[thread_id].hashing = hashing_01710; break;
16561 case 1722: thread_parameters[thread_id].hashing = hashing_01722; break;
16562 case 1731: thread_parameters[thread_id].hashing = hashing_01730; break;
16563 case 2611: thread_parameters[thread_id].hashing = hashing_02611; break;
16564 case 2612: thread_parameters[thread_id].hashing = hashing_02611; break;
16565 case 2711: thread_parameters[thread_id].hashing = hashing_02711; break;
16566 case 2811: thread_parameters[thread_id].hashing = hashing_02811; break;
16567 case 3711: thread_parameters[thread_id].hashing = hashing_03710; break;
16568 case 3721: thread_parameters[thread_id].hashing = hashing_03720; break;
16569 case 7600: thread_parameters[thread_id].hashing = hashing_07600; break;
16570 }
16571
16572 if ((engine_parameter->hash_type == HASH_TYPE_MD5) && (engine_parameter->salt_type == SALT_TYPE_NONE))
16573 {
16574 thread_parameters[thread_id].compare_digest = compare_digest_md5;
16575 thread_parameters[thread_id].get_index = get_index_md5;
16576 }
16577 else if ((engine_parameter->hash_type == HASH_TYPE_MD5) && (engine_parameter->salt_type == SALT_TYPE_INCLUDED))
16578 {
16579 thread_parameters[thread_id].compare_digest = compare_digest_md5;
16580 thread_parameters[thread_id].get_index = get_index_zero;
16581 }
16582 else if ((engine_parameter->hash_type == HASH_TYPE_MD5) && (engine_parameter->salt_type == SALT_TYPE_EXTERNAL))
16583 {
16584 thread_parameters[thread_id].compare_digest = compare_digest_md5;
16585 thread_parameters[thread_id].get_index = get_index_md5;
16586 }
16587 else if ((engine_parameter->hash_type == HASH_TYPE_SHA1) && (engine_parameter->salt_type == SALT_TYPE_NONE))
16588 {
16589 thread_parameters[thread_id].compare_digest = compare_digest_sha1;
16590 thread_parameters[thread_id].get_index = get_index_sha1;
16591 }
16592 else if ((engine_parameter->hash_type == HASH_TYPE_SHA1) && (engine_parameter->salt_type == SALT_TYPE_INCLUDED))
16593 {
16594 thread_parameters[thread_id].compare_digest = compare_digest_sha1;
16595 thread_parameters[thread_id].get_index = get_index_zero;
16596 }
16597 else if ((engine_parameter->hash_type == HASH_TYPE_SHA1) && (engine_parameter->salt_type == SALT_TYPE_EXTERNAL))
16598 {
16599 thread_parameters[thread_id].compare_digest = compare_digest_sha1;
16600 thread_parameters[thread_id].get_index = get_index_sha1;
16601 }
16602 else if ((engine_parameter->hash_type == HASH_TYPE_MYSQL) && (engine_parameter->salt_type == SALT_TYPE_NONE))
16603 {
16604 thread_parameters[thread_id].compare_digest = compare_digest_mysql;
16605 thread_parameters[thread_id].get_index = get_index_mysql;
16606 }
16607 else if ((engine_parameter->hash_type == HASH_TYPE_PHPASS) && (engine_parameter->salt_type == SALT_TYPE_EMBEDDED))
16608 {
16609 thread_parameters[thread_id].compare_digest = compare_digest_md5;
16610 thread_parameters[thread_id].get_index = get_index_zero;
16611 }
16612 else if ((engine_parameter->hash_type == HASH_TYPE_MD5UNIX) && (engine_parameter->salt_type == SALT_TYPE_EMBEDDED))
16613 {
16614 thread_parameters[thread_id].compare_digest = compare_digest_md5;
16615 thread_parameters[thread_id].get_index = get_index_zero;
16616 }
16617 else if ((engine_parameter->hash_type == HASH_TYPE_MD5SUN) && (engine_parameter->salt_type == SALT_TYPE_EMBEDDED))
16618 {
16619 thread_parameters[thread_id].compare_digest = compare_digest_md5;
16620 thread_parameters[thread_id].get_index = get_index_zero;
16621 }
16622 else if ((engine_parameter->hash_type == HASH_TYPE_SHA1B64) && (engine_parameter->salt_type == SALT_TYPE_NONE))
16623 {
16624 thread_parameters[thread_id].compare_digest = compare_digest_sha1;
16625 thread_parameters[thread_id].get_index = get_index_sha1;
16626 }
16627 else if ((engine_parameter->hash_type == HASH_TYPE_SHA1B64S) && (engine_parameter->salt_type == SALT_TYPE_EMBEDDED))
16628 {
16629 thread_parameters[thread_id].compare_digest = compare_digest_sha1;
16630 thread_parameters[thread_id].get_index = get_index_zero;
16631 }
16632 else if ((engine_parameter->hash_type == HASH_TYPE_MD4) && (engine_parameter->salt_type == SALT_TYPE_NONE))
16633 {
16634 thread_parameters[thread_id].compare_digest = compare_digest_md4;
16635 thread_parameters[thread_id].get_index = get_index_md4;
16636 }
16637 else if ((engine_parameter->hash_type == HASH_TYPE_DCC) && (engine_parameter->salt_type == SALT_TYPE_EMBEDDED))
16638 {
16639 thread_parameters[thread_id].compare_digest = compare_digest_md4;
16640 thread_parameters[thread_id].get_index = get_index_zero;
16641 }
16642 else if ((engine_parameter->hash_type == HASH_TYPE_MD5CHAP) && (engine_parameter->salt_type == SALT_TYPE_EMBEDDED))
16643 {
16644 thread_parameters[thread_id].compare_digest = compare_digest_md5;
16645 thread_parameters[thread_id].get_index = get_index_zero;
16646 }
16647 else if ((engine_parameter->hash_type == HASH_TYPE_MSSQL2000) && (engine_parameter->salt_type == SALT_TYPE_EMBEDDED))
16648 {
16649 thread_parameters[thread_id].compare_digest = compare_digest_sha1;
16650 thread_parameters[thread_id].get_index = get_index_zero;
16651 }
16652 else if ((engine_parameter->hash_type == HASH_TYPE_MSSQL2005) && (engine_parameter->salt_type == SALT_TYPE_EMBEDDED))
16653 {
16654 thread_parameters[thread_id].compare_digest = compare_digest_sha1;
16655 thread_parameters[thread_id].get_index = get_index_zero;
16656 }
16657 else if ((engine_parameter->hash_type == HASH_TYPE_EPIV6) && (engine_parameter->salt_type == SALT_TYPE_EMBEDDED))
16658 {
16659 thread_parameters[thread_id].compare_digest = compare_digest_sha1;
16660 thread_parameters[thread_id].get_index = get_index_zero;
16661 }
16662 else if ((engine_parameter->hash_type == HASH_TYPE_SHA256) && (engine_parameter->salt_type == SALT_TYPE_NONE))
16663 {
16664 thread_parameters[thread_id].compare_digest = compare_digest_sha256;
16665 thread_parameters[thread_id].get_index = get_index_sha256;
16666 }
16667 else if ((engine_parameter->hash_type == HASH_TYPE_SHA256) && (engine_parameter->salt_type == SALT_TYPE_INCLUDED))
16668 {
16669 thread_parameters[thread_id].compare_digest = compare_digest_sha256;
16670 thread_parameters[thread_id].get_index = get_index_zero;
16671 }
16672 else if ((engine_parameter->hash_type == HASH_TYPE_SHA256) && (engine_parameter->salt_type == SALT_TYPE_EXTERNAL))
16673 {
16674 thread_parameters[thread_id].compare_digest = compare_digest_sha256;
16675 thread_parameters[thread_id].get_index = get_index_sha256;
16676 }
16677 else if ((engine_parameter->hash_type == HASH_TYPE_MD5APR) && (engine_parameter->salt_type == SALT_TYPE_EMBEDDED))
16678 {
16679 thread_parameters[thread_id].compare_digest = compare_digest_md5;
16680 thread_parameters[thread_id].get_index = get_index_zero;
16681 }
16682 else if ((engine_parameter->hash_type == HASH_TYPE_SHA512) && (engine_parameter->salt_type == SALT_TYPE_NONE))
16683 {
16684 thread_parameters[thread_id].compare_digest = compare_digest_sha512;
16685 thread_parameters[thread_id].get_index = get_index_sha512;
16686 }
16687 else if ((engine_parameter->hash_type == HASH_TYPE_SHA512) && (engine_parameter->salt_type == SALT_TYPE_INCLUDED))
16688 {
16689 thread_parameters[thread_id].compare_digest = compare_digest_sha512;
16690 thread_parameters[thread_id].get_index = get_index_zero;
16691 }
16692 else if ((engine_parameter->hash_type == HASH_TYPE_SHA512) && (engine_parameter->salt_type == SALT_TYPE_EXTERNAL))
16693 {
16694 thread_parameters[thread_id].compare_digest = compare_digest_sha512;
16695 thread_parameters[thread_id].get_index = get_index_sha512;
16696 }
16697 else if ((engine_parameter->hash_type == HASH_TYPE_SHA512UNIX) && (engine_parameter->salt_type == SALT_TYPE_EMBEDDED))
16698 {
16699 thread_parameters[thread_id].compare_digest = compare_digest_sha512;
16700 thread_parameters[thread_id].get_index = get_index_zero;
16701 }
16702 else if ((engine_parameter->hash_type == HASH_TYPE_SHA256UNIX) && (engine_parameter->salt_type == SALT_TYPE_EMBEDDED))
16703 {
16704 thread_parameters[thread_id].compare_digest = compare_digest_sha256;
16705 thread_parameters[thread_id].get_index = get_index_zero;
16706 }
16707 else if ((engine_parameter->hash_type == HASH_TYPE_OSX1) && (engine_parameter->salt_type == SALT_TYPE_EMBEDDED))
16708 {
16709 thread_parameters[thread_id].compare_digest = compare_digest_sha1;
16710 thread_parameters[thread_id].get_index = get_index_zero;
16711 }
16712 else if ((engine_parameter->hash_type == HASH_TYPE_OSX512) && (engine_parameter->salt_type == SALT_TYPE_EMBEDDED))
16713 {
16714 thread_parameters[thread_id].compare_digest = compare_digest_sha512;
16715 thread_parameters[thread_id].get_index = get_index_zero;
16716 }
16717 else if ((engine_parameter->hash_type == HASH_TYPE_MSSQL2012) && (engine_parameter->salt_type == SALT_TYPE_EMBEDDED))
16718 {
16719 thread_parameters[thread_id].compare_digest = compare_digest_sha512;
16720 thread_parameters[thread_id].get_index = get_index_zero;
16721 }
16722 else if ((engine_parameter->hash_type == HASH_TYPE_DESCRYPT) && (engine_parameter->salt_type == SALT_TYPE_EMBEDDED))
16723 {
16724 thread_parameters[thread_id].compare_digest = compare_digest_descrypt;
16725 thread_parameters[thread_id].get_index = get_index_zero;
16726 }
16727 else if ((engine_parameter->hash_type == HASH_TYPE_KECCAK) && (engine_parameter->salt_type == SALT_TYPE_EMBEDDED))
16728 {
16729 thread_parameters[thread_id].compare_digest = compare_digest_keccak;
16730 thread_parameters[thread_id].get_index = get_index_zero;
16731 }
16732 else if ((engine_parameter->hash_type == HASH_TYPE_WPA) && (engine_parameter->salt_type == SALT_TYPE_EMBEDDED))
16733 {
16734 thread_parameters[thread_id].compare_digest = compare_digest_md5;
16735 thread_parameters[thread_id].get_index = get_index_zero;
16736 }
16737 else if ((engine_parameter->hash_type == HASH_TYPE_PSAFE3) && (engine_parameter->salt_type == SALT_TYPE_EMBEDDED))
16738 {
16739 thread_parameters[thread_id].compare_digest = compare_digest_sha256;
16740 thread_parameters[thread_id].get_index = get_index_zero;
16741 }
16742 else if ((engine_parameter->hash_type == HASH_TYPE_IKEPSK_MD5) && (engine_parameter->salt_type == SALT_TYPE_EMBEDDED))
16743 {
16744 thread_parameters[thread_id].compare_digest = compare_digest_md5;
16745 thread_parameters[thread_id].get_index = get_index_zero;
16746 }
16747 else if ((engine_parameter->hash_type == HASH_TYPE_IKEPSK_SHA1) && (engine_parameter->salt_type == SALT_TYPE_EMBEDDED))
16748 {
16749 thread_parameters[thread_id].compare_digest = compare_digest_sha1;
16750 thread_parameters[thread_id].get_index = get_index_zero;
16751 }
16752 else if ((engine_parameter->hash_type == HASH_TYPE_NETNTLMv1) && (engine_parameter->salt_type == SALT_TYPE_EMBEDDED))
16753 {
16754 thread_parameters[thread_id].compare_digest = compare_digest_netntlmv1;
16755 thread_parameters[thread_id].get_index = get_index_zero;
16756 }
16757 else if ((engine_parameter->hash_type == HASH_TYPE_NETNTLMv2) && (engine_parameter->salt_type == SALT_TYPE_EMBEDDED))
16758 {
16759 thread_parameters[thread_id].compare_digest = compare_digest_md5;
16760 thread_parameters[thread_id].get_index = get_index_zero;
16761 }
16762 else if (engine_parameter->hash_type == HASH_TYPE_CISCO_SECRET4)
16763 {
16764 thread_parameters[thread_id].compare_digest = compare_digest_sha256;
16765 thread_parameters[thread_id].get_index = get_index_sha256;
16766 }
16767 else if (engine_parameter->hash_type == HASH_TYPE_MD5AIX)
16768 {
16769 thread_parameters[thread_id].compare_digest = compare_digest_md5;
16770 thread_parameters[thread_id].get_index = get_index_zero;
16771 }
16772 else if (engine_parameter->hash_type == HASH_TYPE_SHA1AIX)
16773 {
16774 thread_parameters[thread_id].compare_digest = compare_digest_sha1;
16775 thread_parameters[thread_id].get_index = get_index_zero;
16776 }
16777 else if (engine_parameter->hash_type == HASH_TYPE_SHA256AIX)
16778 {
16779 thread_parameters[thread_id].compare_digest = compare_digest_sha256;
16780 thread_parameters[thread_id].get_index = get_index_zero;
16781 }
16782 else if (engine_parameter->hash_type == HASH_TYPE_SHA512AIX)
16783 {
16784 thread_parameters[thread_id].compare_digest = compare_digest_sha512;
16785 thread_parameters[thread_id].get_index = get_index_zero;
16786 }
16787 else if (engine_parameter->hash_type == HASH_TYPE_GOST)
16788 {
16789 thread_parameters[thread_id].compare_digest = compare_digest_gost;
16790 thread_parameters[thread_id].get_index = get_index_gost;
16791 }
16792 else if (engine_parameter->hash_type == HASH_TYPE_SHA1FORTIGATE)
16793 {
16794 thread_parameters[thread_id].compare_digest = compare_digest_sha1;
16795 thread_parameters[thread_id].get_index = get_index_zero;
16796 }
16797 else if (engine_parameter->hash_type == HASH_TYPE_PBKDF2OSX)
16798 {
16799 thread_parameters[thread_id].compare_digest = compare_digest_sha512;
16800 thread_parameters[thread_id].get_index = get_index_zero;
16801 }
16802 else if (engine_parameter->hash_type == HASH_TYPE_PBKDF2GRUB)
16803 {
16804 thread_parameters[thread_id].compare_digest = compare_digest_sha512;
16805 thread_parameters[thread_id].get_index = get_index_zero;
16806 }
16807 else if (engine_parameter->hash_type == HASH_TYPE_MD5CISCO_PIX)
16808 {
16809 thread_parameters[thread_id].compare_digest = compare_digest_md5;
16810 thread_parameters[thread_id].get_index = get_index_md5;
16811 }
16812 else if (engine_parameter->hash_type == HASH_TYPE_SHA1ORACLE)
16813 {
16814 thread_parameters[thread_id].compare_digest = compare_digest_sha1;
16815 thread_parameters[thread_id].get_index = get_index_zero;
16816 }
16817 else if (engine_parameter->hash_type == HASH_TYPE_HMACRAKP)
16818 {
16819 thread_parameters[thread_id].compare_digest = compare_digest_sha1;
16820 thread_parameters[thread_id].get_index = get_index_zero;
16821 }
16822 else if ((engine_parameter->hash_type == HASH_TYPE_BCRYPT) && (engine_parameter->salt_type == SALT_TYPE_EMBEDDED))
16823 {
16824 thread_parameters[thread_id].compare_digest = compare_digest_bcrypt;
16825 thread_parameters[thread_id].get_index = get_index_zero;
16826 }
16827 else if ((engine_parameter->hash_type == HASH_TYPE_EPIV6_4) && (engine_parameter->salt_type == SALT_TYPE_EMBEDDED))
16828 {
16829 thread_parameters[thread_id].compare_digest = compare_digest_sha256;
16830 thread_parameters[thread_id].get_index = get_index_zero;
16831 }
16832 else if ((engine_parameter->hash_type == HASH_TYPE_SHA512B64S) && (engine_parameter->salt_type == SALT_TYPE_EMBEDDED))
16833 {
16834 thread_parameters[thread_id].compare_digest = compare_digest_sha512;
16835 thread_parameters[thread_id].get_index = get_index_zero;
16836 }
16837 else if ((engine_parameter->hash_type == HASH_TYPE_EPIV4) && (engine_parameter->salt_type == SALT_TYPE_EMBEDDED))
16838 {
16839 thread_parameters[thread_id].compare_digest = compare_digest_sha1;
16840 thread_parameters[thread_id].get_index = get_index_zero;
16841 }
16842 else if ((engine_parameter->hash_type == HASH_TYPE_DJANGOSHA1) && (engine_parameter->salt_type == SALT_TYPE_EMBEDDED))
16843 {
16844 thread_parameters[thread_id].compare_digest = compare_digest_sha1;
16845 thread_parameters[thread_id].get_index = get_index_zero;
16846 }
16847 else if (engine_parameter->hash_type == HASH_TYPE_SCRYPT)
16848 {
16849 thread_parameters[thread_id].compare_digest = compare_digest_sha256;
16850 thread_parameters[thread_id].get_index = get_index_zero;
16851 }
16852 else if (engine_parameter->hash_type == HASH_TYPE_CISCO_SECRET9)
16853 {
16854 thread_parameters[thread_id].compare_digest = compare_digest_sha256;
16855 thread_parameters[thread_id].get_index = get_index_zero;
16856 }
16857 else if (engine_parameter->hash_type == HASH_TYPE_PHPS)
16858 {
16859 thread_parameters[thread_id].compare_digest = compare_digest_md5;
16860 thread_parameters[thread_id].get_index = get_index_zero;
16861 }
16862 else if (engine_parameter->hash_type == HASH_TYPE_HMAIL)
16863 {
16864 thread_parameters[thread_id].compare_digest = compare_digest_sha256;
16865 thread_parameters[thread_id].get_index = get_index_zero;
16866 }
16867 else if (engine_parameter->hash_type == HASH_TYPE_MEDIAWIKI_B)
16868 {
16869 thread_parameters[thread_id].compare_digest = compare_digest_md5;
16870 thread_parameters[thread_id].get_index = get_index_zero;
16871 }
16872 else if (engine_parameter->hash_type == HASH_TYPE_CISCO_SECRET8)
16873 {
16874 thread_parameters[thread_id].compare_digest = compare_digest_sha256;
16875 thread_parameters[thread_id].get_index = get_index_zero;
16876 }
16877 else if (engine_parameter->hash_type == HASH_TYPE_DJANGO_SHA256)
16878 {
16879 thread_parameters[thread_id].compare_digest = compare_digest_sha256;
16880 thread_parameters[thread_id].get_index = get_index_zero;
16881 }
16882 else if (engine_parameter->hash_type == HASH_TYPE_PEOPLESOFT)
16883 {
16884 thread_parameters[thread_id].compare_digest = compare_digest_sha1;
16885 thread_parameters[thread_id].get_index = get_index_sha1;
16886 }
16887 else if (engine_parameter->hash_type == HASH_TYPE_CRAM_MD5)
16888 {
16889 thread_parameters[thread_id].compare_digest = compare_digest_md5;
16890 thread_parameters[thread_id].get_index = get_index_zero;
16891 }
16892 else if (engine_parameter->hash_type == HASH_TYPE_DRUPAL7)
16893 {
16894 thread_parameters[thread_id].compare_digest = compare_digest_sha256; // not a bug (the encoded hash is truncated to 32 bytes)
16895 thread_parameters[thread_id].get_index = get_index_zero;
16896 }
16897 else if (engine_parameter->hash_type == HASH_TYPE_MD5CISCO_ASA)
16898 {
16899 thread_parameters[thread_id].compare_digest = compare_digest_md5;
16900 thread_parameters[thread_id].get_index = get_index_zero;
16901 }
16902 else if (engine_parameter->hash_type == HASH_TYPE_SAP_H_SHA1)
16903 {
16904 thread_parameters[thread_id].compare_digest = compare_digest_sha1;
16905 thread_parameters[thread_id].get_index = get_index_zero;
16906 }
16907 else if (engine_parameter->hash_type == HASH_TYPE_PRESTASHOP)
16908 {
16909 thread_parameters[thread_id].compare_digest = compare_digest_md5;
16910 thread_parameters[thread_id].get_index = get_index_zero;
16911 }
16912 else if (engine_parameter->hash_type == HASH_TYPE_POSTGRESQL_AUTH)
16913 {
16914 thread_parameters[thread_id].compare_digest = compare_digest_md5;
16915 thread_parameters[thread_id].get_index = get_index_zero;
16916 }
16917 else if (engine_parameter->hash_type == HASH_TYPE_MYSQL_AUTH)
16918 {
16919 thread_parameters[thread_id].compare_digest = compare_digest_sha1;
16920 thread_parameters[thread_id].get_index = get_index_zero;
16921 }
16922 else if (engine_parameter->hash_type == HASH_TYPE_SIP_AUTH)
16923 {
16924 thread_parameters[thread_id].compare_digest = compare_digest_md5;
16925 thread_parameters[thread_id].get_index = get_index_zero;
16926 }
16927 else if (engine_parameter->hash_type == HASH_TYPE_SHA256B64)
16928 {
16929 thread_parameters[thread_id].compare_digest = compare_digest_sha256;
16930 thread_parameters[thread_id].get_index = get_index_sha256;
16931 }
16932 else if (engine_parameter->hash_type == HASH_TYPE_PLAIN)
16933 {
16934 thread_parameters[thread_id].compare_digest = compare_digest_plain;
16935 thread_parameters[thread_id].get_index = get_index_plain;
16936 }
16937
16938 if ((engine_parameter->attack_mode == 0) && (db->rules->rules_cnt == 0))
16939 {
16940 ACCreateThreadEx (threads[thread_id], attack_a0r0, &thread_parameters[thread_id], &ids[thread_id]);
16941 }
16942 else if ((engine_parameter->attack_mode == 0) && (db->rules->rules_cnt != 0))
16943 {
16944 ACCreateThreadEx (threads[thread_id], attack_a0r1, &thread_parameters[thread_id], &ids[thread_id]);
16945 }
16946 else if ((engine_parameter->attack_mode == 1) && (db->rules->rules_cnt == 0))
16947 {
16948 ACCreateThreadEx (threads[thread_id], attack_a1r0, &thread_parameters[thread_id], &ids[thread_id]);
16949 }
16950 else if ((engine_parameter->attack_mode == 1) && (db->rules->rules_cnt != 0))
16951 {
16952 ACCreateThreadEx (threads[thread_id], attack_a1r1, &thread_parameters[thread_id], &ids[thread_id]);
16953 }
16954 else if ((engine_parameter->attack_mode == 3) && (db->rules->rules_cnt == 0))
16955 {
16956 ACCreateThreadEx (threads[thread_id], attack_a3r0, &thread_parameters[thread_id], &ids[thread_id]);
16957 }
16958 else if ((engine_parameter->attack_mode == 3) && (db->rules->rules_cnt != 0))
16959 {
16960 ACCreateThreadEx (threads[thread_id], attack_a3r1, &thread_parameters[thread_id], &ids[thread_id]);
16961 }
16962 else if ((engine_parameter->attack_mode == 4) && (db->rules->rules_cnt == 0))
16963 {
16964 ACCreateThreadEx (threads[thread_id], attack_a4r0, &thread_parameters[thread_id], &ids[thread_id]);
16965 }
16966 else if ((engine_parameter->attack_mode == 4) && (db->rules->rules_cnt != 0))
16967 {
16968 ACCreateThreadEx (threads[thread_id], attack_a4r1, &thread_parameters[thread_id], &ids[thread_id]);
16969 }
16970 else if ((engine_parameter->attack_mode == 5) && (db->rules->rules_cnt == 0))
16971 {
16972 ACCreateThreadEx (threads[thread_id], attack_a5r0, &thread_parameters[thread_id], &ids[thread_id]);
16973 }
16974 else if ((engine_parameter->attack_mode == 5) && (db->rules->rules_cnt != 0))
16975 {
16976 ACCreateThreadEx (threads[thread_id], attack_a5r1, &thread_parameters[thread_id], &ids[thread_id]);
16977 }
16978 else if ((engine_parameter->attack_mode == 8) && (db->rules->rules_cnt == 0))
16979 {
16980 ACCreateThreadEx (threads[thread_id], attack_a0r0, &thread_parameters[thread_id], &ids[thread_id]);
16981 }
16982 else if ((engine_parameter->attack_mode == 8) && (db->rules->rules_cnt != 0))
16983 {
16984 ACCreateThreadEx (threads[thread_id], attack_a0r1, &thread_parameters[thread_id], &ids[thread_id]);
16985 }
16986
16987 #ifdef WINDOWS
16988 SetThreadPriority (threads[thread_id], THREAD_PRIORITY_IDLE);
16989 #endif
16990
16991 ids[thread_id] = 0;
16992 }
16993
16994 #ifdef WINDOWS
16995 WaitForMultipleObjects (engine_parameter->num_threads, threads, TRUE, INFINITE);
16996 #endif
16997
16998 for (thread_id = 0; thread_id < engine_parameter->num_threads; thread_id++)
16999 {
17000 #ifdef WINDOWS
17001 CloseHandle (threads[thread_id]);
17002 #endif
17003
17004 #ifdef POSIX
17005 pthread_join (threads[thread_id], NULL);
17006 #endif
17007 }
17008
17009 if ((engine_parameter->hash_mode == 8900) || (engine_parameter->hash_mode == 9300))
17010 {
17011 for (thread_id = 0; thread_id < engine_parameter->num_threads; thread_id++)
17012 {
17013 free (thread_parameters[thread_id].scrypt_P[0]);
17014 free (thread_parameters[thread_id].scrypt_P[1]);
17015 free (thread_parameters[thread_id].scrypt_P[2]);
17016 free (thread_parameters[thread_id].scrypt_P[3]);
17017
17018 _mm_free (thread_parameters[thread_id].scrypt_V);
17019 _mm_free (thread_parameters[thread_id].scrypt_X);
17020 _mm_free (thread_parameters[thread_id].scrypt_Y);
17021 }
17022 }
17023 }
17024