arno/hashcat
1
0
Fork 0
mirror of https://github.com/hashcat/hashcat.git synced 2024-11-22 08:08:10 +00:00
Code Issues Releases Wiki Activity

Rule Engine: Add JtR compatible support for hex notations in rule engine

Browse Source
This commit is contained in:
jsteube 2018-06-14 15:08:00 +02:00
parent a8060f4946
commit b88c956d97
3 changed files with 52 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/rp.h
View File

@ -26,6 +26,8 @@ int conv_itoc (const u8 c);
int generate_random_rule (char rule_buf[RP_RULE_SIZE], const u32 rp_gen_func_min, const u32 rp_gen_func_max);
bool is_hex_notation (char *rule_buf, u32 rule_len, u32 rule_pos);
int cpu_rule_to_kernel_rule (char *rule_buf, u32 rule_len, kernel_rule_t *rule);
int kernel_rule_to_cpu_rule (char *rule_buf, kernel_rule_t *rule);

18
src/rp.c
View File

@ -6,6 +6,7 @@
#include "common.h"
#include "types.h"
#include "memory.h"
#include "convert.h"
#include "event.h"
#include "shared.h"
#include "filehandling.h"
@ -217,8 +218,8 @@ int generate_random_rule (char rule_buf[RP_RULE_SIZE], const u32 rp_gen_func_min
#define INCR_POS if (++rule_pos == rule_len) return (-1)
#define SET_NAME(rule,val) (rule)->cmds[rule_cnt] = ((val) & 0xff) << 0
#define SET_P0(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8
#define SET_P1(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16
#define SET_P0(rule,val) INCR_POS; if (is_hex_notation (rule_buf, rule_len, rule_pos) == true) { (rule)->cmds[rule_cnt] |= (hex_convert (rule_buf[rule_pos + 3] & 0xff) << 8) | (hex_convert (rule_buf[rule_pos + 2] & 0xff) << 12); rule_pos += 4; } else { (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 8; }
#define SET_P1(rule,val) INCR_POS; if (is_hex_notation (rule_buf, rule_len, rule_pos) == true) { (rule)->cmds[rule_cnt] |= (hex_convert (rule_buf[rule_pos + 3] & 0xff) << 16) | (hex_convert (rule_buf[rule_pos + 2] & 0xff) << 20); rule_pos += 4; } else { (rule)->cmds[rule_cnt] |= ((val) & 0xff) << 16; }
#define GET_NAME(rule) rule_cmd = (((rule)->cmds[rule_cnt] >> 0) & 0xff)
#define GET_P0(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 8) & 0xff)
#define GET_P1(rule) INCR_POS; rule_buf[rule_pos] = (((rule)->cmds[rule_cnt] >> 16) & 0xff)
@ -228,6 +229,19 @@ int generate_random_rule (char rule_buf[RP_RULE_SIZE], const u32 rp_gen_func_min
#define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = (char) conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
#define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = (char) conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
bool is_hex_notation (char *rule_buf, u32 rule_len, u32 rule_pos)
{
if ((rule_pos + 4) > rule_len) return false;
if (rule_buf[rule_pos + 0] != '\\') return false;
if (rule_buf[rule_pos + 1] != 'x') return false;
if (is_valid_hex_char (rule_buf[rule_pos + 2]) == false) return false;
if (is_valid_hex_char (rule_buf[rule_pos + 3]) == false) return false;
return true;
}
int cpu_rule_to_kernel_rule (char *rule_buf, u32 rule_len, kernel_rule_t *rule)
{
u32 rule_pos;

48
src/rp_cpu.c
View File

@ -5,6 +5,8 @@
#include "common.h"
#include "types.h"
#include "convert.h"
#include "memory.h"
#include "rp.h"
#include "rp_cpu.h"
@ -490,14 +492,30 @@ int _old_apply_rule (const char *rule, int rule_len, char in[RP_PASSWORD_SIZE],
memcpy (out, in, out_len);
char *rule_new = hcstrdup (rule);
int rule_pos;
for (rule_pos = 0; rule_pos < rule_len; rule_pos++)
{
if (is_hex_notation (rule_new, rule_len, rule_pos))
{
const u8 c = hex_to_u8 (rule_new + rule_pos + 2);
rule_new[rule_pos + 0] = c;
rule_new[rule_pos + 1] = ' ';
rule_new[rule_pos + 2] = ' ';
rule_new[rule_pos + 3] = ' ';
}
}
for (rule_pos = 0; rule_pos < rule_len; rule_pos++)
{
int upos, upos2;
int ulen;
switch (rule[rule_pos])
switch (rule_new[rule_pos])
{
case ' ':
break;
@ -561,12 +579,12 @@ int _old_apply_rule (const char *rule, int rule_len, char in[RP_PASSWORD_SIZE],
case RULE_OP_MANGLE_APPEND:
NEXT_RULEPOS (rule_pos);
out_len = mangle_append (out, out_len, rule[rule_pos]);
out_len = mangle_append (out, out_len, rule_new[rule_pos]);
break;
case RULE_OP_MANGLE_PREPEND:
NEXT_RULEPOS (rule_pos);
out_len = mangle_prepend (out, out_len, rule[rule_pos]);
out_len = mangle_prepend (out, out_len, rule_new[rule_pos]);
break;
case RULE_OP_MANGLE_DELETE_FIRST:
@ -603,14 +621,14 @@ int _old_apply_rule (const char *rule, int rule_len, char in[RP_PASSWORD_SIZE],
NEXT_RULEPOS (rule_pos);
NEXT_RPTOI (rule, rule_pos, upos);
NEXT_RULEPOS (rule_pos);
out_len = mangle_insert (out, out_len, upos, rule[rule_pos]);
out_len = mangle_insert (out, out_len, upos, rule_new[rule_pos]);
break;
case RULE_OP_MANGLE_OVERSTRIKE:
NEXT_RULEPOS (rule_pos);
NEXT_RPTOI (rule, rule_pos, upos);
NEXT_RULEPOS (rule_pos);
out_len = mangle_overstrike (out, out_len, upos, rule[rule_pos]);
out_len = mangle_overstrike (out, out_len, upos, rule_new[rule_pos]);
break;
case RULE_OP_MANGLE_TRUNCATE_AT:
@ -622,12 +640,12 @@ int _old_apply_rule (const char *rule, int rule_len, char in[RP_PASSWORD_SIZE],
case RULE_OP_MANGLE_REPLACE:
NEXT_RULEPOS (rule_pos);
NEXT_RULEPOS (rule_pos);
out_len = mangle_replace (out, out_len, rule[rule_pos - 1], rule[rule_pos]);
out_len = mangle_replace (out, out_len, rule_new[rule_pos - 1], rule_new[rule_pos]);
break;
case RULE_OP_MANGLE_PURGECHAR:
NEXT_RULEPOS (rule_pos);
out_len = mangle_purgechar (out, out_len, rule[rule_pos]);
out_len = mangle_purgechar (out, out_len, rule_new[rule_pos]);
break;
case RULE_OP_MANGLE_TOGGLECASE_REC:
@ -716,7 +734,7 @@ int _old_apply_rule (const char *rule, int rule_len, char in[RP_PASSWORD_SIZE],
case RULE_OP_MANGLE_TITLE_SEP:
NEXT_RULEPOS (rule_pos);
out_len = mangle_title_sep (out, out_len, rule[rule_pos]);
out_len = mangle_title_sep (out, out_len, rule_new[rule_pos]);
break;
case RULE_OP_MANGLE_TITLE:
@ -774,12 +792,12 @@ int _old_apply_rule (const char *rule, int rule_len, char in[RP_PASSWORD_SIZE],
case RULE_OP_REJECT_CONTAIN:
NEXT_RULEPOS (rule_pos);
if (strchr (out, rule[rule_pos]) != NULL) return (RULE_RC_REJECT_ERROR);
if (strchr (out, rule_new[rule_pos]) != NULL) return (RULE_RC_REJECT_ERROR);
break;
case RULE_OP_REJECT_NOT_CONTAIN:
NEXT_RULEPOS (rule_pos);
char *match = strchr (out, rule[rule_pos]);
char *match = strchr (out, rule_new[rule_pos]);
if (match != NULL)
{
pos_mem = (int)(match - out);
@ -792,12 +810,12 @@ int _old_apply_rule (const char *rule, int rule_len, char in[RP_PASSWORD_SIZE],
case RULE_OP_REJECT_EQUAL_FIRST:
NEXT_RULEPOS (rule_pos);
if (out[0] != rule[rule_pos]) return (RULE_RC_REJECT_ERROR);
if (out[0] != rule_new[rule_pos]) return (RULE_RC_REJECT_ERROR);
break;
case RULE_OP_REJECT_EQUAL_LAST:
NEXT_RULEPOS (rule_pos);
if (out[out_len - 1] != rule[rule_pos]) return (RULE_RC_REJECT_ERROR);
if (out[out_len - 1] != rule_new[rule_pos]) return (RULE_RC_REJECT_ERROR);
break;
case RULE_OP_REJECT_EQUAL_AT:
@ -805,7 +823,7 @@ int _old_apply_rule (const char *rule, int rule_len, char in[RP_PASSWORD_SIZE],
NEXT_RPTOI (rule, rule_pos, upos);
if ((upos + 1) > out_len) return (RULE_RC_REJECT_ERROR);
NEXT_RULEPOS (rule_pos);
if (out[upos] != rule[rule_pos]) return (RULE_RC_REJECT_ERROR);
if (out[upos] != rule_new[rule_pos]) return (RULE_RC_REJECT_ERROR);
break;
case RULE_OP_REJECT_CONTAINS:
@ -816,7 +834,7 @@ int _old_apply_rule (const char *rule, int rule_len, char in[RP_PASSWORD_SIZE],
int c; int cnt;
for (c = 0, cnt = 0; c < out_len && cnt < upos; c++)
{
if (out[c] == rule[rule_pos])
if (out[c] == rule_new[rule_pos])
{
cnt++;
pos_mem = c;
@ -837,6 +855,8 @@ int _old_apply_rule (const char *rule, int rule_len, char in[RP_PASSWORD_SIZE],
memset (out + out_len, 0, RP_PASSWORD_SIZE - out_len);
hcfree (rule_new);
return (out_len);
}