projects / hashcat.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Initial commit
[hashcat.git] / tools / rules_test / cpu_rules.c
1 /**
2 * Author......: Jens Steube <jens.steube@gmail.com>
3 * License.....: MIT
4 */
5
6 #include "cpu_rules.h"
7
8 extern int max_len;
9
10 /**
11 * GPU rules
12 */
13
14 #define INCR_POS if (++rule_pos == rule_len) return (-1)
15 #define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
16 #define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
17 #define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
18 #define MAX_GPU_RULES 14
19 #define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
20 #define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
21 #define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
22
23 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
24 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
25 #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
26 #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
27
28 void gen_cmask (const uint8_t *word, uint8_t *cmask, const uint len)
29 {
30 uint i;
31
32 for (i = 0; i < len; i++)
33 {
34 if (class_alpha (word[i]) == 0)
35 {
36 cmask[i] = 0;
37 }
38 else
39 {
40 cmask[i] = 0xff;
41 }
42 }
43 }
44
45 /**
46 * CPU rules
47 */
48
49 #define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
50 #define NEXT_RPTOI(r,rp,up) if (((up) = conv_ctoi ((r)[(rp)])) == -1) return (RULE_RC_SYNTAX_ERROR)
51
52 #define MANGLE_TOGGLE_AT(a,p) if (class_alpha ((a)[(p)])) (a)[(p)] ^= 0x20
53 #define MANGLE_LOWER_AT(a,p) if (class_upper ((a)[(p)])) (a)[(p)] ^= 0x20
54 #define MANGLE_UPPER_AT(a,p) if (class_lower ((a)[(p)])) (a)[(p)] ^= 0x20
55
56 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); arr[(r)] = arr[(l)]; arr[(l)] = c; } */
57 /* #define MANGLE_SWITCH(a,l,r) { char c = (l); (a)[(r)] = (a)[(l)]; (a)[(l)] = c; } */
58 #define MANGLE_SWITCH(a,l,r) { char c = (a)[(r)]; (a)[(r)] = (a)[(l)]; (a)[(l)] = c; }
59
60 int mangle_lrest (char arr[BLOCK_SIZE], int arr_len)
61 {
62 int pos;
63
64 for (pos = 0; pos < arr_len; pos++) MANGLE_LOWER_AT (arr, pos);
65
66 return (arr_len);
67 }
68
69 int mangle_urest (char arr[BLOCK_SIZE], int arr_len)
70 {
71 int pos;
72
73 for (pos = 0; pos < arr_len; pos++) MANGLE_UPPER_AT (arr, pos);
74
75 return (arr_len);
76 }
77
78 int mangle_trest (char arr[BLOCK_SIZE], int arr_len)
79 {
80 int pos;
81
82 for (pos = 0; pos < arr_len; pos++) MANGLE_TOGGLE_AT (arr, pos);
83
84 return (arr_len);
85 }
86
87 int mangle_reverse (char arr[BLOCK_SIZE], int arr_len)
88 {
89 int l;
90 int r;
91
92 for (l = 0; l < arr_len; l++)
93 {
94 r = arr_len - 1 - l;
95
96 if (l >= r) break;
97
98 MANGLE_SWITCH (arr, l, r);
99 }
100
101 return (arr_len);
102 }
103
104 int mangle_double (char arr[BLOCK_SIZE], int arr_len)
105 {
106 if ((arr_len * 2) >= BLOCK_SIZE) return (arr_len);
107
108 memcpy (&arr[arr_len], arr, (size_t) arr_len);
109
110 return (arr_len * 2);
111 }
112
113 int mangle_double_times (char arr[BLOCK_SIZE], int arr_len, int times)
114 {
115 if (((arr_len * times) + arr_len) >= BLOCK_SIZE) return (arr_len);
116
117 int orig_len = arr_len;
118
119 int i;
120
121 for (i = 0; i < times; i++)
122 {
123 memcpy (&arr[arr_len], arr, orig_len);
124
125 arr_len += orig_len;
126 }
127
128 return (arr_len);
129 }
130
131 int mangle_reflect (char arr[BLOCK_SIZE], int arr_len)
132 {
133 if ((arr_len * 2) >= BLOCK_SIZE) return (arr_len);
134
135 mangle_double (arr, arr_len);
136
137 mangle_reverse (arr + arr_len, arr_len);
138
139 return (arr_len * 2);
140 }
141
142 int mangle_rotate_left (char arr[BLOCK_SIZE], int arr_len)
143 {
144 int l;
145 int r;
146
147 for (l = 0, r = arr_len - 1; r > 0; r--)
148 {
149 MANGLE_SWITCH (arr, l, r);
150 }
151
152 return (arr_len);
153 }
154
155 int mangle_rotate_right (char arr[BLOCK_SIZE], int arr_len)
156 {
157 int l;
158 int r;
159
160 for (l = 0, r = arr_len - 1; l < r; l++)
161 {
162 MANGLE_SWITCH (arr, l, r);
163 }
164
165 return (arr_len);
166 }
167
168 int mangle_append (char arr[BLOCK_SIZE], int arr_len, char c)
169 {
170 if ((arr_len + 1) >= BLOCK_SIZE) return (arr_len);
171
172 arr[arr_len] = c;
173
174 return (arr_len + 1);
175 }
176
177 int mangle_prepend (char arr[BLOCK_SIZE], int arr_len, char c)
178 {
179 if ((arr_len + 1) >= BLOCK_SIZE) return (arr_len);
180
181 int arr_pos;
182
183 for (arr_pos = arr_len - 1; arr_pos > -1; arr_pos--)
184 {
185 arr[arr_pos + 1] = arr[arr_pos];
186 }
187
188 arr[0] = c;
189
190 return (arr_len + 1);
191 }
192
193 int mangle_delete_at (char arr[BLOCK_SIZE], int arr_len, int upos)
194 {
195 if (upos >= arr_len) return (arr_len);
196
197 int arr_pos;
198
199 for (arr_pos = upos; arr_pos < arr_len - 1; arr_pos++)
200 {
201 arr[arr_pos] = arr[arr_pos + 1];
202 }
203
204 return (arr_len - 1);
205 }
206
207 int mangle_extract (char arr[BLOCK_SIZE], int arr_len, int upos, int ulen)
208 {
209 if (upos >= arr_len) return (arr_len);
210
211 if ((upos + ulen) > arr_len) return (arr_len);
212
213 int arr_pos;
214
215 for (arr_pos = 0; arr_pos < ulen; arr_pos++)
216 {
217 arr[arr_pos] = arr[upos + arr_pos];
218 }
219
220 return (ulen);
221 }
222
223 int mangle_omit (char arr[BLOCK_SIZE], int arr_len, int upos, int ulen)
224 {
225 if (upos >= arr_len) return (arr_len);
226
227 if ((upos + ulen) > arr_len) return (arr_len);
228
229 int arr_pos;
230
231 for (arr_pos = upos; arr_pos < arr_len - ulen; arr_pos++)
232 {
233 arr[arr_pos] = arr[arr_pos + ulen];
234 }
235
236 return (arr_len - ulen);
237 }
238
239 int mangle_insert (char arr[BLOCK_SIZE], int arr_len, int upos, char c)
240 {
241 if (upos > arr_len) return (arr_len);
242
243 if ((arr_len + 1) >= BLOCK_SIZE) return (arr_len);
244
245 int arr_pos;
246
247 for (arr_pos = arr_len - 1; arr_pos > upos - 1; arr_pos--)
248 {
249 arr[arr_pos + 1] = arr[arr_pos];
250 }
251
252 arr[upos] = c;
253
254 return (arr_len + 1);
255 }
256
257 int mangle_insert_multi (char arr[BLOCK_SIZE], int arr_len, int arr_pos, char arr2[BLOCK_SIZE], int arr2_len, int arr2_pos, int arr2_cpy)
258 {
259 if ((arr_len + arr2_cpy) > BLOCK_SIZE) return (RULE_RC_REJECT_ERROR);
260
261 if (arr_pos > arr_len) return (RULE_RC_REJECT_ERROR);
262
263 if (arr2_pos > arr2_len) return (RULE_RC_REJECT_ERROR);
264
265 if ((arr2_pos + arr2_cpy) > arr2_len) return (RULE_RC_REJECT_ERROR);
266
267 if (arr2_cpy < 1) return (RULE_RC_SYNTAX_ERROR);
268
269 memcpy (arr2, arr2 + arr2_pos, arr2_len - arr2_pos);
270
271 memcpy (arr2 + arr2_cpy, arr + arr_pos, arr_len - arr_pos);
272
273 memcpy (arr + arr_pos, arr2, arr_len - arr_pos + arr2_cpy);
274
275 return (arr_len + arr2_cpy);
276 }
277
278 int mangle_overstrike (char arr[BLOCK_SIZE], int arr_len, int upos, char c)
279 {
280 if (upos >= arr_len) return (arr_len);
281
282 arr[upos] = c;
283
284 return (arr_len);
285 }
286
287 int mangle_truncate_at (char arr[BLOCK_SIZE], int arr_len, int upos)
288 {
289 if (upos >= arr_len) return (arr_len);
290
291 memset (arr + upos, 0, arr_len - upos);
292
293 return (upos);
294 }
295
296 int mangle_replace (char arr[BLOCK_SIZE], int arr_len, char oldc, char newc)
297 {
298 int arr_pos;
299
300 for (arr_pos = 0; arr_pos < arr_len; arr_pos++)
301 {
302 if (arr[arr_pos] != oldc) continue;
303
304 arr[arr_pos] = newc;
305 }
306
307 return (arr_len);
308 }
309
310 int mangle_purgechar (char arr[BLOCK_SIZE], int arr_len, char c)
311 {
312 int arr_pos;
313
314 int ret_len;
315
316 for (ret_len = 0, arr_pos = 0; arr_pos < arr_len; arr_pos++)
317 {
318 if (arr[arr_pos] == c) continue;
319
320 arr[ret_len] = arr[arr_pos];
321
322 ret_len++;
323 }
324
325 return (ret_len);
326 }
327
328 int mangle_dupeblock_prepend (char arr[BLOCK_SIZE], int arr_len, int ulen)
329 {
330 if (ulen > arr_len) return (arr_len);
331
332 if ((arr_len + ulen) >= BLOCK_SIZE) return (arr_len);
333
334 char cs[100];
335
336 memcpy (cs, arr, ulen);
337
338 int i;
339
340 for (i = 0; i < ulen; i++)
341 {
342 char c = cs[i];
343
344 arr_len = mangle_insert (arr, arr_len, i, c);
345 }
346
347 return (arr_len);
348 }
349
350 int mangle_dupeblock_append (char arr[BLOCK_SIZE], int arr_len, int ulen)
351 {
352 if (ulen > arr_len) return (arr_len);
353
354 if ((arr_len + ulen) >= BLOCK_SIZE) return (arr_len);
355
356 int upos = arr_len - ulen;
357
358 int i;
359
360 for (i = 0; i < ulen; i++)
361 {
362 char c = arr[upos + i];
363
364 arr_len = mangle_append (arr, arr_len, c);
365 }
366
367 return (arr_len);
368 }
369
370 int mangle_dupechar_at (char arr[BLOCK_SIZE], int arr_len, int upos, int ulen)
371 {
372 if ( arr_len == 0) return (arr_len);
373 if ((arr_len + ulen) >= BLOCK_SIZE) return (arr_len);
374
375 char c = arr[upos];
376
377 int i;
378
379 for (i = 0; i < ulen; i++)
380 {
381 arr_len = mangle_insert (arr, arr_len, upos, c);
382 }
383
384 return (arr_len);
385 }
386
387 int mangle_dupechar (char arr[BLOCK_SIZE], int arr_len)
388 {
389 if ( arr_len == 0) return (arr_len);
390 if ((arr_len + arr_len) >= BLOCK_SIZE) return (arr_len);
391
392 int arr_pos;
393
394 for (arr_pos = arr_len - 1; arr_pos > -1; arr_pos--)
395 {
396 int new_pos = arr_pos * 2;
397
398 arr[new_pos] = arr[arr_pos];
399
400 arr[new_pos + 1] = arr[arr_pos];
401 }
402
403 return (arr_len * 2);
404 }
405
406 int mangle_switch_at_check (char arr[BLOCK_SIZE], int arr_len, int upos, int upos2)
407 {
408 if (upos >= arr_len) return (arr_len);
409 if (upos2 >= arr_len) return (arr_len);
410
411 MANGLE_SWITCH (arr, upos, upos2);
412
413 return (arr_len);
414 }
415
416 int mangle_switch_at (char arr[BLOCK_SIZE], int arr_len, int upos, int upos2)
417 {
418 MANGLE_SWITCH (arr, upos, upos2);
419
420 return (arr_len);
421 }
422
423 int mangle_chr_shiftl (uint8_t arr[BLOCK_SIZE], int arr_len, int upos)
424 {
425 if (upos >= arr_len) return (arr_len);
426
427 arr[upos] <<= 1;
428
429 return (arr_len);
430 }
431
432 int mangle_chr_shiftr (uint8_t arr[BLOCK_SIZE], int arr_len, int upos)
433 {
434 if (upos >= arr_len) return (arr_len);
435
436 arr[upos] >>= 1;
437
438 return (arr_len);
439 }
440
441 int mangle_chr_incr (uint8_t arr[BLOCK_SIZE], int arr_len, int upos)
442 {
443 if (upos >= arr_len) return (arr_len);
444
445 arr[upos] += 1;
446
447 return (arr_len);
448 }
449
450 int mangle_chr_decr (uint8_t arr[BLOCK_SIZE], int arr_len, int upos)
451 {
452 if (upos >= arr_len) return (arr_len);
453
454 arr[upos] -= 1;
455
456 return (arr_len);
457 }
458
459 int mangle_title (char arr[BLOCK_SIZE], int arr_len)
460 {
461 int upper_next = 1;
462
463 int pos;
464
465 for (pos = 0; pos < arr_len; pos++)
466 {
467 if (arr[pos] == ' ')
468 {
469 upper_next = 1;
470
471 continue;
472 }
473
474 if (upper_next)
475 {
476 upper_next = 0;
477
478 MANGLE_UPPER_AT (arr, pos);
479 }
480 else
481 {
482 MANGLE_LOWER_AT (arr, pos);
483 }
484 }
485
486 return (arr_len);
487 }
488
489 int generate_random_rule (char rule_buf[RP_RULE_BUFSIZ], uint32_t rp_gen_func_min, uint32_t rp_gen_func_max)
490 {
491 uint32_t rp_gen_num = get_random_num (rp_gen_func_min, rp_gen_func_max);
492
493 uint32_t j;
494
495 uint32_t rule_pos = 0;
496
497 for (j = 0; j < rp_gen_num; j++)
498 {
499 uint32_t r = 0;
500 uint32_t p1 = 0;
501 uint32_t p2 = 0;
502 uint32_t p3 = 0;
503
504 switch ((char) get_random_num (0, 9))
505 {
506 case 0:
507 r = get_random_num (0, sizeof (grp_op_nop));
508 rule_buf[rule_pos++] = grp_op_nop[r];
509 break;
510
511 case 1:
512 r = get_random_num (0, sizeof (grp_op_pos_p0));
513 rule_buf[rule_pos++] = grp_op_pos_p0[r];
514 p1 = get_random_num (0, sizeof (grp_pos));
515 rule_buf[rule_pos++] = grp_pos[p1];
516 break;
517
518 case 2:
519 r = get_random_num (0, sizeof (grp_op_pos_p1));
520 rule_buf[rule_pos++] = grp_op_pos_p1[r];
521 p1 = get_random_num (1, 6);
522 rule_buf[rule_pos++] = grp_pos[p1];
523 break;
524
525 case 3:
526 r = get_random_num (0, sizeof (grp_op_chr));
527 rule_buf[rule_pos++] = grp_op_chr[r];
528 p1 = get_random_num (0x20, 0x7e);
529 rule_buf[rule_pos++] = (char) p1;
530 break;
531
532 case 4:
533 r = get_random_num (0, sizeof (grp_op_chr_chr));
534 rule_buf[rule_pos++] = grp_op_chr_chr[r];
535 p1 = get_random_num (0x20, 0x7e);
536 rule_buf[rule_pos++] = (char) p1;
537 p2 = get_random_num (0x20, 0x7e);
538 while (p1 == p2)
539 p2 = get_random_num (0x20, 0x7e);
540 rule_buf[rule_pos++] = (char) p2;
541 break;
542
543 case 5:
544 r = get_random_num (0, sizeof (grp_op_pos_chr));
545 rule_buf[rule_pos++] = grp_op_pos_chr[r];
546 p1 = get_random_num (0, sizeof (grp_pos));
547 rule_buf[rule_pos++] = grp_pos[p1];
548 p2 = get_random_num (0x20, 0x7e);
549 rule_buf[rule_pos++] = (char) p2;
550 break;
551
552 case 6:
553 r = get_random_num (0, sizeof (grp_op_pos_pos0));
554 rule_buf[rule_pos++] = grp_op_pos_pos0[r];
555 p1 = get_random_num (0, sizeof (grp_pos));
556 rule_buf[rule_pos++] = grp_pos[p1];
557 p2 = get_random_num (0, sizeof (grp_pos));
558 while (p1 == p2)
559 p2 = get_random_num (0, sizeof (grp_pos));
560 rule_buf[rule_pos++] = grp_pos[p2];
561 break;
562
563 case 7:
564 r = get_random_num (0, sizeof (grp_op_pos_pos1));
565 rule_buf[rule_pos++] = grp_op_pos_pos1[r];
566 p1 = get_random_num (0, sizeof (grp_pos));
567 rule_buf[rule_pos++] = grp_pos[p1];
568 p2 = get_random_num (1, sizeof (grp_pos));
569 while (p1 == p2)
570 p2 = get_random_num (1, sizeof (grp_pos));
571 rule_buf[rule_pos++] = grp_pos[p2];
572 break;
573
574 case 8:
575 r = get_random_num (0, sizeof (grp_op_pos1_pos2_pos3));
576 rule_buf[rule_pos++] = grp_op_pos1_pos2_pos3[r];
577 p1 = get_random_num (0, sizeof (grp_pos));
578 rule_buf[rule_pos++] = grp_pos[p1];
579 p2 = get_random_num (1, sizeof (grp_pos));
580 rule_buf[rule_pos++] = grp_pos[p1];
581 p3 = get_random_num (0, sizeof (grp_pos));
582 rule_buf[rule_pos++] = grp_pos[p3];
583 break;
584 }
585 }
586
587 return (rule_pos);
588 }
589
590 int apply_rule_cpu (char *rule, int rule_len, char in[BLOCK_SIZE], int in_len, char out[BLOCK_SIZE])
591 {
592 char mem[BLOCK_SIZE];
593
594 if (in == NULL) return (RULE_RC_REJECT_ERROR);
595
596 if (out == NULL) return (RULE_RC_REJECT_ERROR);
597
598 if (in_len < 1) return (RULE_RC_REJECT_ERROR);
599
600 if (rule_len < 1) return (RULE_RC_REJECT_ERROR);
601
602 int out_len = in_len;
603 int mem_len = in_len;
604
605 memcpy (out, in, out_len);
606
607 int rule_pos;
608
609 for (rule_pos = 0; rule_pos < rule_len; rule_pos++)
610 {
611 int upos; int upos2;
612 int ulen;
613
614 switch (rule[rule_pos])
615 {
616 case ' ':
617 break;
618
619 case RULE_OP_MANGLE_NOOP:
620 break;
621
622 case RULE_OP_MANGLE_LREST:
623 out_len = mangle_lrest (out, out_len);
624 break;
625
626 case RULE_OP_MANGLE_UREST:
627 out_len = mangle_urest (out, out_len);
628 break;
629
630 case RULE_OP_MANGLE_LREST_UFIRST:
631 out_len = mangle_lrest (out, out_len);
632 if (out_len) MANGLE_UPPER_AT (out, 0);
633 break;
634
635 case RULE_OP_MANGLE_UREST_LFIRST:
636 out_len = mangle_urest (out, out_len);
637 if (out_len) MANGLE_LOWER_AT (out, 0);
638 break;
639
640 case RULE_OP_MANGLE_TREST:
641 out_len = mangle_trest (out, out_len);
642 break;
643
644 case RULE_OP_MANGLE_TOGGLE_AT:
645 NEXT_RULEPOS (rule_pos);
646 NEXT_RPTOI (rule, rule_pos, upos);
647 if (upos < out_len) MANGLE_TOGGLE_AT (out, upos);
648 break;
649
650 case RULE_OP_MANGLE_REVERSE:
651 out_len = mangle_reverse (out, out_len);
652 break;
653
654 case RULE_OP_MANGLE_DUPEWORD:
655 out_len = mangle_double (out, out_len);
656 break;
657
658 case RULE_OP_MANGLE_DUPEWORD_TIMES:
659 NEXT_RULEPOS (rule_pos);
660 NEXT_RPTOI (rule, rule_pos, ulen);
661 out_len = mangle_double_times (out, out_len, ulen);
662 break;
663
664 case RULE_OP_MANGLE_REFLECT:
665 out_len = mangle_reflect (out, out_len);
666 break;
667
668 case RULE_OP_MANGLE_ROTATE_LEFT:
669 mangle_rotate_left (out, out_len);
670 break;
671
672 case RULE_OP_MANGLE_ROTATE_RIGHT:
673 mangle_rotate_right (out, out_len);
674 break;
675
676 case RULE_OP_MANGLE_APPEND:
677 NEXT_RULEPOS (rule_pos);
678 out_len = mangle_append (out, out_len, rule[rule_pos]);
679 break;
680
681 case RULE_OP_MANGLE_PREPEND:
682 NEXT_RULEPOS (rule_pos);
683 out_len = mangle_prepend (out, out_len, rule[rule_pos]);
684 break;
685
686 case RULE_OP_MANGLE_DELETE_FIRST:
687 out_len = mangle_delete_at (out, out_len, 0);
688 break;
689
690 case RULE_OP_MANGLE_DELETE_LAST:
691 out_len = mangle_delete_at (out, out_len, (out_len) ? out_len - 1 : 0);
692 break;
693
694 case RULE_OP_MANGLE_DELETE_AT:
695 NEXT_RULEPOS (rule_pos);
696 NEXT_RPTOI (rule, rule_pos, upos);
697 out_len = mangle_delete_at (out, out_len, upos);
698 break;
699
700 case RULE_OP_MANGLE_EXTRACT:
701 NEXT_RULEPOS (rule_pos);
702 NEXT_RPTOI (rule, rule_pos, upos);
703 NEXT_RULEPOS (rule_pos);
704 NEXT_RPTOI (rule, rule_pos, ulen);
705 out_len = mangle_extract (out, out_len, upos, ulen);
706 break;
707
708 case RULE_OP_MANGLE_OMIT:
709 NEXT_RULEPOS (rule_pos);
710 NEXT_RPTOI (rule, rule_pos, upos);
711 NEXT_RULEPOS (rule_pos);
712 NEXT_RPTOI (rule, rule_pos, ulen);
713 out_len = mangle_omit (out, out_len, upos, ulen);
714 break;
715
716 case RULE_OP_MANGLE_INSERT:
717 NEXT_RULEPOS (rule_pos);
718 NEXT_RPTOI (rule, rule_pos, upos);
719 NEXT_RULEPOS (rule_pos);
720 out_len = mangle_insert (out, out_len, upos, rule[rule_pos]);
721 break;
722
723 case RULE_OP_MANGLE_OVERSTRIKE:
724 NEXT_RULEPOS (rule_pos);
725 NEXT_RPTOI (rule, rule_pos, upos);
726 NEXT_RULEPOS (rule_pos);
727 out_len = mangle_overstrike (out, out_len, upos, rule[rule_pos]);
728 break;
729
730 case RULE_OP_MANGLE_TRUNCATE_AT:
731 NEXT_RULEPOS (rule_pos);
732 NEXT_RPTOI (rule, rule_pos, upos);
733 out_len = mangle_truncate_at (out, out_len, upos);
734 break;
735
736 case RULE_OP_MANGLE_REPLACE:
737 NEXT_RULEPOS (rule_pos);
738 NEXT_RULEPOS (rule_pos);
739 out_len = mangle_replace (out, out_len, rule[rule_pos - 1], rule[rule_pos]);
740 break;
741
742 case RULE_OP_MANGLE_PURGECHAR:
743 NEXT_RULEPOS (rule_pos);
744 out_len = mangle_purgechar (out, out_len, rule[rule_pos]);
745 break;
746
747 case RULE_OP_MANGLE_TOGGLECASE_REC:
748 /* todo */
749 break;
750
751 case RULE_OP_MANGLE_DUPECHAR_FIRST:
752 NEXT_RULEPOS (rule_pos);
753 NEXT_RPTOI (rule, rule_pos, ulen);
754 out_len = mangle_dupechar_at (out, out_len, 0, ulen);
755 break;
756
757 case RULE_OP_MANGLE_DUPECHAR_LAST:
758 NEXT_RULEPOS (rule_pos);
759 NEXT_RPTOI (rule, rule_pos, ulen);
760 out_len = mangle_dupechar_at (out, out_len, out_len - 1, ulen);
761 break;
762
763 case RULE_OP_MANGLE_DUPECHAR_ALL:
764 out_len = mangle_dupechar (out, out_len);
765 break;
766
767 case RULE_OP_MANGLE_DUPEBLOCK_FIRST:
768 NEXT_RULEPOS (rule_pos);
769 NEXT_RPTOI (rule, rule_pos, ulen);
770 out_len = mangle_dupeblock_prepend (out, out_len, ulen);
771 break;
772
773 case RULE_OP_MANGLE_DUPEBLOCK_LAST:
774 NEXT_RULEPOS (rule_pos);
775 NEXT_RPTOI (rule, rule_pos, ulen);
776 out_len = mangle_dupeblock_append (out, out_len, ulen);
777 break;
778
779 case RULE_OP_MANGLE_SWITCH_FIRST:
780 if (out_len >= 2) mangle_switch_at (out, out_len, 0, 1);
781 break;
782
783 case RULE_OP_MANGLE_SWITCH_LAST:
784 if (out_len >= 2) mangle_switch_at (out, out_len, out_len - 1, out_len - 2);
785 break;
786
787 case RULE_OP_MANGLE_SWITCH_AT:
788 NEXT_RULEPOS (rule_pos);
789 NEXT_RPTOI (rule, rule_pos, upos);
790 NEXT_RULEPOS (rule_pos);
791 NEXT_RPTOI (rule, rule_pos, upos2);
792 out_len = mangle_switch_at_check (out, out_len, upos, upos2);
793 break;
794
795 case RULE_OP_MANGLE_CHR_SHIFTL:
796 NEXT_RULEPOS (rule_pos);
797 NEXT_RPTOI (rule, rule_pos, upos);
798 mangle_chr_shiftl ((uint8_t *) out, out_len, upos);
799 break;
800
801 case RULE_OP_MANGLE_CHR_SHIFTR:
802 NEXT_RULEPOS (rule_pos);
803 NEXT_RPTOI (rule, rule_pos, upos);
804 mangle_chr_shiftr ((uint8_t *) out, out_len, upos);
805 break;
806
807 case RULE_OP_MANGLE_CHR_INCR:
808 NEXT_RULEPOS (rule_pos);
809 NEXT_RPTOI (rule, rule_pos, upos);
810 mangle_chr_incr ((uint8_t *) out, out_len, upos);
811 break;
812
813 case RULE_OP_MANGLE_CHR_DECR:
814 NEXT_RULEPOS (rule_pos);
815 NEXT_RPTOI (rule, rule_pos, upos);
816 mangle_chr_decr ((uint8_t *) out, out_len, upos);
817 break;
818
819 case RULE_OP_MANGLE_REPLACE_NP1:
820 NEXT_RULEPOS (rule_pos);
821 NEXT_RPTOI (rule, rule_pos, upos);
822 if ((upos >= 0) && ((upos + 1) < out_len)) mangle_overstrike (out, out_len, upos, out[upos + 1]);
823 break;
824
825 case RULE_OP_MANGLE_REPLACE_NM1:
826 NEXT_RULEPOS (rule_pos);
827 NEXT_RPTOI (rule, rule_pos, upos);
828 if ((upos >= 1) && ((upos + 0) < out_len)) mangle_overstrike (out, out_len, upos, out[upos - 1]);
829 break;
830
831 case RULE_OP_MANGLE_TITLE:
832 mangle_title (out, out_len);
833 break;
834
835 case RULE_OP_MANGLE_EXTRACT_MEMORY:
836 if (mem_len < 1) return (RULE_RC_REJECT_ERROR);
837 NEXT_RULEPOS (rule_pos);
838 NEXT_RPTOI (rule, rule_pos, upos);
839 NEXT_RULEPOS (rule_pos);
840 NEXT_RPTOI (rule, rule_pos, ulen);
841 NEXT_RULEPOS (rule_pos);
842 NEXT_RPTOI (rule, rule_pos, upos2);
843 if ((out_len = mangle_insert_multi (out, out_len, upos2, mem, mem_len, upos, ulen)) < 1) return (out_len);
844 break;
845
846 case RULE_OP_MANGLE_APPEND_MEMORY:
847 if (mem_len < 1) return (RULE_RC_REJECT_ERROR);
848 if ((out_len + mem_len) > BLOCK_SIZE) return (RULE_RC_REJECT_ERROR);
849 memcpy (out + out_len, mem, mem_len);
850 out_len += mem_len;
851 break;
852
853 case RULE_OP_MANGLE_PREPEND_MEMORY:
854 if (mem_len < 1) return (RULE_RC_REJECT_ERROR);
855 if ((mem_len + out_len) > BLOCK_SIZE) return (RULE_RC_REJECT_ERROR);
856 memcpy (mem + mem_len, out, out_len);
857 out_len += mem_len;
858 memcpy (out, mem, out_len);
859 break;
860
861 case RULE_OP_MEMORIZE_WORD:
862 memcpy (mem, out, out_len);
863 mem_len = out_len;
864 break;
865
866 case RULE_OP_REJECT_LESS:
867 NEXT_RULEPOS (rule_pos);
868 NEXT_RPTOI (rule, rule_pos, upos);
869 if (out_len > upos) return (RULE_RC_REJECT_ERROR);
870 break;
871
872 case RULE_OP_REJECT_GREATER:
873 NEXT_RULEPOS (rule_pos);
874 NEXT_RPTOI (rule, rule_pos, upos);
875 if (out_len < upos) return (RULE_RC_REJECT_ERROR);
876 break;
877
878 case RULE_OP_REJECT_CONTAIN:
879 NEXT_RULEPOS (rule_pos);
880 if (strchr (out, rule[rule_pos]) != NULL) return (RULE_RC_REJECT_ERROR);
881 break;
882
883 case RULE_OP_REJECT_NOT_CONTAIN:
884 NEXT_RULEPOS (rule_pos);
885 if (strchr (out, rule[rule_pos]) == NULL) return (RULE_RC_REJECT_ERROR);
886 break;
887
888 case RULE_OP_REJECT_EQUAL_FIRST:
889 NEXT_RULEPOS (rule_pos);
890 if (out[0] != rule[rule_pos]) return (RULE_RC_REJECT_ERROR);
891 break;
892
893 case RULE_OP_REJECT_EQUAL_LAST:
894 NEXT_RULEPOS (rule_pos);
895 if (out[out_len - 1] != rule[rule_pos]) return (RULE_RC_REJECT_ERROR);
896 break;
897
898 case RULE_OP_REJECT_EQUAL_AT:
899 NEXT_RULEPOS (rule_pos);
900 NEXT_RPTOI (rule, rule_pos, upos);
901 if ((upos + 1) > out_len) return (RULE_RC_REJECT_ERROR);
902 NEXT_RULEPOS (rule_pos);
903 if (out[upos] != rule[rule_pos]) return (RULE_RC_REJECT_ERROR);
904 break;
905
906 case RULE_OP_REJECT_CONTAINS:
907 NEXT_RULEPOS (rule_pos);
908 NEXT_RPTOI (rule, rule_pos, upos);
909 if ((upos + 1) > out_len) return (RULE_RC_REJECT_ERROR);
910 NEXT_RULEPOS (rule_pos);
911 int c; int cnt; for (c = 0, cnt = 0; c < out_len; c++) if (out[c] == rule[rule_pos]) cnt++;
912 if (cnt < upos) return (RULE_RC_REJECT_ERROR);
913 break;
914
915 case RULE_OP_REJECT_MEMORY:
916 if ((out_len == mem_len) && (memcmp (out, mem, out_len) == 0)) return (RULE_RC_REJECT_ERROR);
917 break;
918
919 default:
920 return (RULE_RC_SYNTAX_ERROR);
921 break;
922 }
923
924 max_len = (out_len > max_len) ? out_len : max_len;
925 }
926
927 memset (out + out_len, 0, BLOCK_SIZE - out_len);
928
929 return (out_len);
930 }
931
932 int cpu_rule_to_gpu_rule (char rule_buf[BUFSIZ], uint rule_len, gpu_rule_t *rule)
933 {
934 uint rule_pos;
935 uint rule_cnt;
936
937 for (rule_pos = 0, rule_cnt = 0; rule_pos < rule_len && rule_cnt < MAX_GPU_RULES; rule_pos++, rule_cnt++)
938 {
939 switch (rule_buf[rule_pos])
940 {
941 case ' ':
942 rule_cnt--;
943 break;
944
945 case RULE_OP_MANGLE_NOOP:
946 SET_NAME (rule, rule_buf[rule_pos]);
947 break;
948
949 case RULE_OP_MANGLE_LREST:
950 SET_NAME (rule, rule_buf[rule_pos]);
951 break;
952
953 case RULE_OP_MANGLE_UREST:
954 SET_NAME (rule, rule_buf[rule_pos]);
955 break;
956
957 case RULE_OP_MANGLE_LREST_UFIRST:
958 SET_NAME (rule, rule_buf[rule_pos]);
959 break;
960
961 case RULE_OP_MANGLE_UREST_LFIRST:
962 SET_NAME (rule, rule_buf[rule_pos]);
963 break;
964
965 case RULE_OP_MANGLE_TREST:
966 SET_NAME (rule, rule_buf[rule_pos]);
967 break;
968
969 case RULE_OP_MANGLE_TOGGLE_AT:
970 SET_NAME (rule, rule_buf[rule_pos]);
971 SET_P0_CONV (rule, rule_buf[rule_pos]);
972 break;
973
974 case RULE_OP_MANGLE_REVERSE:
975 SET_NAME (rule, rule_buf[rule_pos]);
976 break;
977
978 case RULE_OP_MANGLE_DUPEWORD:
979 SET_NAME (rule, rule_buf[rule_pos]);
980 break;
981
982 case RULE_OP_MANGLE_DUPEWORD_TIMES:
983 SET_NAME (rule, rule_buf[rule_pos]);
984 SET_P0_CONV (rule, rule_buf[rule_pos]);
985 break;
986
987 case RULE_OP_MANGLE_REFLECT:
988 SET_NAME (rule, rule_buf[rule_pos]);
989 break;
990
991 case RULE_OP_MANGLE_ROTATE_LEFT:
992 SET_NAME (rule, rule_buf[rule_pos]);
993 break;
994
995 case RULE_OP_MANGLE_ROTATE_RIGHT:
996 SET_NAME (rule, rule_buf[rule_pos]);
997 break;
998
999 case RULE_OP_MANGLE_APPEND:
1000 SET_NAME (rule, rule_buf[rule_pos]);
1001 SET_P0 (rule, rule_buf[rule_pos]);
1002 break;
1003
1004 case RULE_OP_MANGLE_PREPEND:
1005 SET_NAME (rule, rule_buf[rule_pos]);
1006 SET_P0 (rule, rule_buf[rule_pos]);
1007 break;
1008
1009 case RULE_OP_MANGLE_DELETE_FIRST:
1010 SET_NAME (rule, rule_buf[rule_pos]);
1011 break;
1012
1013 case RULE_OP_MANGLE_DELETE_LAST:
1014 SET_NAME (rule, rule_buf[rule_pos]);
1015 break;
1016
1017 case RULE_OP_MANGLE_DELETE_AT:
1018 SET_NAME (rule, rule_buf[rule_pos]);
1019 SET_P0_CONV (rule, rule_buf[rule_pos]);
1020 break;
1021
1022 case RULE_OP_MANGLE_EXTRACT:
1023 SET_NAME (rule, rule_buf[rule_pos]);
1024 SET_P0_CONV (rule, rule_buf[rule_pos]);
1025 SET_P1_CONV (rule, rule_buf[rule_pos]);
1026 break;
1027
1028 case RULE_OP_MANGLE_OMIT:
1029 SET_NAME (rule, rule_buf[rule_pos]);
1030 SET_P0_CONV (rule, rule_buf[rule_pos]);
1031 SET_P1_CONV (rule, rule_buf[rule_pos]);
1032 break;
1033
1034 case RULE_OP_MANGLE_INSERT:
1035 SET_NAME (rule, rule_buf[rule_pos]);
1036 SET_P0_CONV (rule, rule_buf[rule_pos]);
1037 SET_P1 (rule, rule_buf[rule_pos]);
1038 break;
1039
1040 case RULE_OP_MANGLE_OVERSTRIKE:
1041 SET_NAME (rule, rule_buf[rule_pos]);
1042 SET_P0_CONV (rule, rule_buf[rule_pos]);
1043 SET_P1 (rule, rule_buf[rule_pos]);
1044 break;
1045
1046 case RULE_OP_MANGLE_TRUNCATE_AT:
1047 SET_NAME (rule, rule_buf[rule_pos]);
1048 SET_P0_CONV (rule, rule_buf[rule_pos]);
1049 break;
1050
1051 case RULE_OP_MANGLE_REPLACE:
1052 SET_NAME (rule, rule_buf[rule_pos]);
1053 SET_P0 (rule, rule_buf[rule_pos]);
1054 SET_P1 (rule, rule_buf[rule_pos]);
1055 break;
1056
1057 case RULE_OP_MANGLE_PURGECHAR:
1058 return (-1);
1059 break;
1060
1061 case RULE_OP_MANGLE_TOGGLECASE_REC:
1062 return (-1);
1063 break;
1064
1065 case RULE_OP_MANGLE_DUPECHAR_FIRST:
1066 SET_NAME (rule, rule_buf[rule_pos]);
1067 SET_P0_CONV (rule, rule_buf[rule_pos]);
1068 break;
1069
1070 case RULE_OP_MANGLE_DUPECHAR_LAST:
1071 SET_NAME (rule, rule_buf[rule_pos]);
1072 SET_P0_CONV (rule, rule_buf[rule_pos]);
1073 break;
1074
1075 case RULE_OP_MANGLE_DUPECHAR_ALL:
1076 SET_NAME (rule, rule_buf[rule_pos]);
1077 break;
1078
1079 case RULE_OP_MANGLE_SWITCH_FIRST:
1080 SET_NAME (rule, rule_buf[rule_pos]);
1081 break;
1082
1083 case RULE_OP_MANGLE_SWITCH_LAST:
1084 SET_NAME (rule, rule_buf[rule_pos]);
1085 break;
1086
1087 case RULE_OP_MANGLE_SWITCH_AT:
1088 SET_NAME (rule, rule_buf[rule_pos]);
1089 SET_P0_CONV (rule, rule_buf[rule_pos]);
1090 SET_P1_CONV (rule, rule_buf[rule_pos]);
1091 break;
1092
1093 case RULE_OP_MANGLE_CHR_SHIFTL:
1094 SET_NAME (rule, rule_buf[rule_pos]);
1095 SET_P0_CONV (rule, rule_buf[rule_pos]);
1096 break;
1097
1098 case RULE_OP_MANGLE_CHR_SHIFTR:
1099 SET_NAME (rule, rule_buf[rule_pos]);
1100 SET_P0_CONV (rule, rule_buf[rule_pos]);
1101 break;
1102
1103 case RULE_OP_MANGLE_CHR_INCR:
1104 SET_NAME (rule, rule_buf[rule_pos]);
1105 SET_P0_CONV (rule, rule_buf[rule_pos]);
1106 break;
1107
1108 case RULE_OP_MANGLE_CHR_DECR:
1109 SET_NAME (rule, rule_buf[rule_pos]);
1110 SET_P0_CONV (rule, rule_buf[rule_pos]);
1111 break;
1112
1113 case RULE_OP_MANGLE_REPLACE_NP1:
1114 SET_NAME (rule, rule_buf[rule_pos]);
1115 SET_P0_CONV (rule, rule_buf[rule_pos]);
1116 break;
1117
1118 case RULE_OP_MANGLE_REPLACE_NM1:
1119 SET_NAME (rule, rule_buf[rule_pos]);
1120 SET_P0_CONV (rule, rule_buf[rule_pos]);
1121 break;
1122
1123 case RULE_OP_MANGLE_DUPEBLOCK_FIRST:
1124 SET_NAME (rule, rule_buf[rule_pos]);
1125 SET_P0_CONV (rule, rule_buf[rule_pos]);
1126 break;
1127
1128 case RULE_OP_MANGLE_DUPEBLOCK_LAST:
1129 SET_NAME (rule, rule_buf[rule_pos]);
1130 SET_P0_CONV (rule, rule_buf[rule_pos]);
1131 break;
1132
1133 case RULE_OP_MANGLE_TITLE:
1134 SET_NAME (rule, rule_buf[rule_pos]);
1135 break;
1136
1137 default:
1138 return (-1);
1139 break;
1140 }
1141 }
1142
1143 if (rule_pos < rule_len) return (-1);
1144
1145 return (0);
1146 }
1147
1148 /**
1149 * rules common
1150 */
1151
1152 bool class_num (char c)
1153 {
1154 return ((c >= '0') && (c <= '9'));
1155 }
1156
1157 bool class_lower (char c)
1158 {
1159 return ((c >= 'a') && (c <= 'z'));
1160 }
1161
1162 bool class_upper (char c)
1163 {
1164 return ((c >= 'A') && (c <= 'Z'));
1165 }
1166
1167 bool class_alpha (char c)
1168 {
1169 return (class_lower (c) || class_upper (c));
1170 }
1171
1172 char conv_ctoi (char c)
1173 {
1174 if (class_num (c))
1175 {
1176 return c - '0';
1177 }
1178 else if (class_upper (c))
1179 {
1180 return c - 'A' + (char) 10;
1181 }
1182
1183 return (char) (-1);
1184 }
1185
1186 char conv_itoc (char c)
1187 {
1188 if (c < 10)
1189 {
1190 return c + '0';
1191 }
1192 else if (c < 37)
1193 {
1194 return c + 'A' - (char) 10;
1195 }
1196
1197 return (char) (-1);
1198 }
1199
1200 uint get_random_num (uint min, uint max)
1201 {
1202 if (min == max) return (min);
1203
1204 uint data;
1205
1206 FILE *fp = fopen("/dev/urandom", "rb");
1207
1208 if (fp == NULL) exit (1);
1209
1210 if ((fread (&data, 1, sizeof (uint), fp)) != sizeof (uint))
1211 {
1212 exit (1);
1213 }
1214
1215 fclose (fp);
1216
1217 return (uint) ((data % (max - min)) + min);
1218 }
Hashcat additions to support pwdhash