mirror of
https://github.com/hashcat/hashcat.git
synced 2025-02-16 17:42:04 +00:00
Update cpu rule engine to support passwords up to length 256
This commit is contained in:
jsteube
parent
1ed6576c25
commit
f5ee3db5a6
@ -95,7 +95,6 @@ but this is nededed for VS compiler which doesn't have inline keyword but has __
|
||||
#define EXEC_CACHE 128
|
||||
#define SPEED_CACHE 128
|
||||
#define SPEED_MAXAGE 4096
|
||||
#define BLOCK_SIZE 64
|
||||
#define EXPECTED_ITERATIONS 10000
|
||||
|
||||
#if defined (_WIN)
|
||||
|
||||
@ -8,7 +8,8 @@
|
||||
|
||||
#include <string.h>
|
||||
|
||||
#define RP_RULE_BUFSIZ 0x100
|
||||
#define RP_RULE_SIZE 256
|
||||
#define RP_PASSWORD_SIZE 256
|
||||
|
||||
#define INCR_RULES 10000
|
||||
|
||||
@ -23,7 +24,7 @@ bool class_alpha (const u8 c);
|
||||
int conv_ctoi (const u8 c);
|
||||
int conv_itoc (const u8 c);
|
||||
|
||||
int generate_random_rule (char rule_buf[RP_RULE_BUFSIZ], const u32 rp_gen_func_min, const u32 rp_gen_func_max);
|
||||
int generate_random_rule (char rule_buf[RP_RULE_SIZE], const u32 rp_gen_func_min, const u32 rp_gen_func_max);
|
||||
|
||||
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);
|
||||
|
||||
@ -11,7 +11,7 @@
|
||||
#define RULE_RC_SYNTAX_ERROR -1
|
||||
#define RULE_RC_REJECT_ERROR -2
|
||||
|
||||
int _old_apply_rule (char *rule, int rule_len, char in[BLOCK_SIZE], int in_len, char out[BLOCK_SIZE]);
|
||||
int _old_apply_rule (char *rule, int rule_len, char in[RP_PASSWORD_SIZE], int in_len, char out[RP_PASSWORD_SIZE]);
|
||||
|
||||
int run_rule_engine (const int rule_len, const char *rule_buf);
|
||||
|
||||
|
||||
@ -13,6 +13,7 @@
|
||||
#include "shared.h"
|
||||
#include "thread.h"
|
||||
#include "filehandling.h"
|
||||
#include "rp.h"
|
||||
#include "rp_cpu.h"
|
||||
#include "dispatch.h"
|
||||
|
||||
@ -180,11 +181,11 @@ static int calc_stdin (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_par
|
||||
|
||||
// post-process rule engine
|
||||
|
||||
char rule_buf_out[BLOCK_SIZE];
|
||||
char rule_buf_out[RP_PASSWORD_SIZE];
|
||||
|
||||
if (run_rule_engine ((int) user_options_extra->rule_len_l, user_options->rule_buf_l))
|
||||
{
|
||||
if (line_len >= BLOCK_SIZE) continue;
|
||||
if (line_len >= RP_PASSWORD_SIZE) continue;
|
||||
|
||||
memset (rule_buf_out, 0, sizeof (rule_buf_out));
|
||||
|
||||
@ -496,7 +497,7 @@ static int calc (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param)
|
||||
char *line_buf;
|
||||
u32 line_len;
|
||||
|
||||
char rule_buf_out[BLOCK_SIZE];
|
||||
char rule_buf_out[RP_PASSWORD_SIZE];
|
||||
|
||||
for ( ; words_cur < words_off; words_cur++) get_next_word (hashcat_ctx_tmp, fd, &line_buf, &line_len);
|
||||
|
||||
@ -510,7 +511,7 @@ static int calc (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param)
|
||||
|
||||
if (run_rule_engine ((int) user_options_extra->rule_len_l, user_options->rule_buf_l))
|
||||
{
|
||||
if (line_len >= BLOCK_SIZE) continue;
|
||||
if (line_len >= RP_PASSWORD_SIZE) continue;
|
||||
|
||||
memset (rule_buf_out, 0, sizeof (rule_buf_out));
|
||||
|
||||
|
||||
@ -263,10 +263,10 @@ void check_hash (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, pl
|
||||
|
||||
// debug
|
||||
|
||||
u8 debug_rule_buf[BLOCK_SIZE] = { 0 };
|
||||
u8 debug_rule_buf[RP_PASSWORD_SIZE] = { 0 };
|
||||
int debug_rule_len = 0; // -1 error
|
||||
|
||||
u8 debug_plain_ptr[BLOCK_SIZE] = { 0 };
|
||||
u8 debug_plain_ptr[RP_PASSWORD_SIZE] = { 0 };
|
||||
int debug_plain_len = 0;
|
||||
|
||||
build_debugdata (hashcat_ctx, device_param, plain, debug_rule_buf, &debug_rule_len, debug_plain_ptr, &debug_plain_len);
|
||||
|
||||
@ -10,6 +10,7 @@
|
||||
#include "thread.h"
|
||||
#include "timer.h"
|
||||
#include "tuningdb.h"
|
||||
#include "rp.h"
|
||||
#include "rp_cpu.h"
|
||||
#include "mpsp.h"
|
||||
#include "straight.h"
|
||||
@ -2038,11 +2039,11 @@ int run_cracker (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, co
|
||||
|
||||
char *line_buf_new = line_buf;
|
||||
|
||||
char rule_buf_out[BLOCK_SIZE];
|
||||
char rule_buf_out[RP_PASSWORD_SIZE];
|
||||
|
||||
if (run_rule_engine (user_options_extra->rule_len_r, user_options->rule_buf_r))
|
||||
{
|
||||
if (line_len >= BLOCK_SIZE) continue;
|
||||
if (line_len >= RP_PASSWORD_SIZE) continue;
|
||||
|
||||
memset (rule_buf_out, 0, sizeof (rule_buf_out));
|
||||
|
||||
@ -2155,11 +2156,11 @@ int run_cracker (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, co
|
||||
|
||||
char *line_buf_new = line_buf;
|
||||
|
||||
char rule_buf_out[BLOCK_SIZE];
|
||||
char rule_buf_out[RP_PASSWORD_SIZE];
|
||||
|
||||
if (run_rule_engine (user_options_extra->rule_len_r, user_options->rule_buf_r))
|
||||
{
|
||||
if (line_len >= BLOCK_SIZE) continue;
|
||||
if (line_len >= RP_PASSWORD_SIZE) continue;
|
||||
|
||||
memset (rule_buf_out, 0, sizeof (rule_buf_out));
|
||||
|
||||
|
||||
16
src/rp.c
16
src/rp.c
@ -137,7 +137,7 @@ int conv_itoc (const u8 c)
|
||||
return -1;
|
||||
}
|
||||
|
||||
int generate_random_rule (char rule_buf[RP_RULE_BUFSIZ], const u32 rp_gen_func_min, const u32 rp_gen_func_max)
|
||||
int generate_random_rule (char rule_buf[RP_RULE_SIZE], const u32 rp_gen_func_min, const u32 rp_gen_func_max)
|
||||
{
|
||||
u32 rp_gen_num = get_random_num (rp_gen_func_min, rp_gen_func_max);
|
||||
|
||||
@ -731,9 +731,6 @@ int kernel_rules_load (hashcat_ctx_t *hashcat_ctx, kernel_rule_t **out_buf, u32
|
||||
|
||||
char *rp_file = user_options->rp_files[i];
|
||||
|
||||
char in[BLOCK_SIZE] = { 0 };
|
||||
char out[BLOCK_SIZE] = { 0 };
|
||||
|
||||
FILE *fp = NULL;
|
||||
|
||||
u32 rule_line = 0;
|
||||
@ -767,8 +764,11 @@ int kernel_rules_load (hashcat_ctx_t *hashcat_ctx, kernel_rule_t **out_buf, u32
|
||||
kernel_rules_avail += INCR_RULES;
|
||||
}
|
||||
|
||||
memset (in, 0, BLOCK_SIZE);
|
||||
memset (out, 0, BLOCK_SIZE);
|
||||
char in[RP_PASSWORD_SIZE];
|
||||
char out[RP_PASSWORD_SIZE];
|
||||
|
||||
memset (in, 0, sizeof (in));
|
||||
memset (out, 0, sizeof (out));
|
||||
|
||||
int result = _old_apply_rule (rule_buf, rule_len, in, 1, out);
|
||||
|
||||
@ -872,11 +872,11 @@ int kernel_rules_generate (hashcat_ctx_t *hashcat_ctx, kernel_rule_t **out_buf,
|
||||
u32 kernel_rules_cnt = 0;
|
||||
kernel_rule_t *kernel_rules_buf = hccalloc (user_options->rp_gen, sizeof (kernel_rule_t));
|
||||
|
||||
char *rule_buf = (char *) hcmalloc (RP_RULE_BUFSIZ);
|
||||
char *rule_buf = (char *) hcmalloc (RP_RULE_SIZE);
|
||||
|
||||
for (kernel_rules_cnt = 0; kernel_rules_cnt < user_options->rp_gen; kernel_rules_cnt++)
|
||||
{
|
||||
memset (rule_buf, 0, RP_RULE_BUFSIZ);
|
||||
memset (rule_buf, 0, RP_RULE_SIZE);
|
||||
|
||||
int rule_len = (int) generate_random_rule (rule_buf, user_options->rp_gen_func_min, user_options->rp_gen_func_max);
|
||||
|
||||
|
||||
103
src/rp_cpu.c
103
src/rp_cpu.c
@ -11,7 +11,8 @@
|
||||
#define NEXT_RULEPOS(rp) if (++(rp) == rule_len) return (RULE_RC_SYNTAX_ERROR)
|
||||
#define NEXT_RPTOI(r,rp,up) if (((up) = conv_pos ((r)[(rp)], pos_mem)) == -1) return (RULE_RC_SYNTAX_ERROR)
|
||||
|
||||
static int conv_pos (const u8 c, const int pos_mem) {
|
||||
static int conv_pos (const u8 c, const int pos_mem)
|
||||
{
|
||||
if (c == RULE_LAST_REJECTED_SAVED_POS)
|
||||
{
|
||||
return pos_mem;
|
||||
@ -44,7 +45,7 @@ static void MANGLE_SWITCH (char *arr, const int l, const int r)
|
||||
arr[l] = c;
|
||||
}
|
||||
|
||||
static int mangle_lrest (char arr[BLOCK_SIZE], int arr_len)
|
||||
static int mangle_lrest (char arr[RP_PASSWORD_SIZE], int arr_len)
|
||||
{
|
||||
int pos;
|
||||
|
||||
@ -53,7 +54,7 @@ static int mangle_lrest (char arr[BLOCK_SIZE], int arr_len)
|
||||
return (arr_len);
|
||||
}
|
||||
|
||||
static int mangle_urest (char arr[BLOCK_SIZE], int arr_len)
|
||||
static int mangle_urest (char arr[RP_PASSWORD_SIZE], int arr_len)
|
||||
{
|
||||
int pos;
|
||||
|
||||
@ -62,7 +63,7 @@ static int mangle_urest (char arr[BLOCK_SIZE], int arr_len)
|
||||
return (arr_len);
|
||||
}
|
||||
|
||||
static int mangle_trest (char arr[BLOCK_SIZE], int arr_len)
|
||||
static int mangle_trest (char arr[RP_PASSWORD_SIZE], int arr_len)
|
||||
{
|
||||
int pos;
|
||||
|
||||
@ -71,7 +72,7 @@ static int mangle_trest (char arr[BLOCK_SIZE], int arr_len)
|
||||
return (arr_len);
|
||||
}
|
||||
|
||||
static int mangle_reverse (char arr[BLOCK_SIZE], int arr_len)
|
||||
static int mangle_reverse (char arr[RP_PASSWORD_SIZE], int arr_len)
|
||||
{
|
||||
int l;
|
||||
|
||||
@ -87,18 +88,18 @@ static int mangle_reverse (char arr[BLOCK_SIZE], int arr_len)
|
||||
return (arr_len);
|
||||
}
|
||||
|
||||
static int mangle_double (char arr[BLOCK_SIZE], int arr_len)
|
||||
static int mangle_double (char arr[RP_PASSWORD_SIZE], int arr_len)
|
||||
{
|
||||
if ((arr_len * 2) >= BLOCK_SIZE) return (arr_len);
|
||||
if ((arr_len * 2) >= RP_PASSWORD_SIZE) return (arr_len);
|
||||
|
||||
memcpy (&arr[arr_len], arr, (size_t) arr_len);
|
||||
|
||||
return (arr_len * 2);
|
||||
}
|
||||
|
||||
static int mangle_double_times (char arr[BLOCK_SIZE], int arr_len, int times)
|
||||
static int mangle_double_times (char arr[RP_PASSWORD_SIZE], int arr_len, int times)
|
||||
{
|
||||
if (((arr_len * times) + arr_len) >= BLOCK_SIZE) return (arr_len);
|
||||
if (((arr_len * times) + arr_len) >= RP_PASSWORD_SIZE) return (arr_len);
|
||||
|
||||
int orig_len = arr_len;
|
||||
|
||||
@ -114,9 +115,9 @@ static int mangle_double_times (char arr[BLOCK_SIZE], int arr_len, int times)
|
||||
return (arr_len);
|
||||
}
|
||||
|
||||
static int mangle_reflect (char arr[BLOCK_SIZE], int arr_len)
|
||||
static int mangle_reflect (char arr[RP_PASSWORD_SIZE], int arr_len)
|
||||
{
|
||||
if ((arr_len * 2) >= BLOCK_SIZE) return (arr_len);
|
||||
if ((arr_len * 2) >= RP_PASSWORD_SIZE) return (arr_len);
|
||||
|
||||
mangle_double (arr, arr_len);
|
||||
|
||||
@ -125,7 +126,7 @@ static int mangle_reflect (char arr[BLOCK_SIZE], int arr_len)
|
||||
return (arr_len * 2);
|
||||
}
|
||||
|
||||
static int mangle_rotate_left (char arr[BLOCK_SIZE], int arr_len)
|
||||
static int mangle_rotate_left (char arr[RP_PASSWORD_SIZE], int arr_len)
|
||||
{
|
||||
int l;
|
||||
int r;
|
||||
@ -138,7 +139,7 @@ static int mangle_rotate_left (char arr[BLOCK_SIZE], int arr_len)
|
||||
return (arr_len);
|
||||
}
|
||||
|
||||
static int mangle_rotate_right (char arr[BLOCK_SIZE], int arr_len)
|
||||
static int mangle_rotate_right (char arr[RP_PASSWORD_SIZE], int arr_len)
|
||||
{
|
||||
int l;
|
||||
int r;
|
||||
@ -151,18 +152,18 @@ static int mangle_rotate_right (char arr[BLOCK_SIZE], int arr_len)
|
||||
return (arr_len);
|
||||
}
|
||||
|
||||
static int mangle_append (char arr[BLOCK_SIZE], int arr_len, char c)
|
||||
static int mangle_append (char arr[RP_PASSWORD_SIZE], int arr_len, char c)
|
||||
{
|
||||
if ((arr_len + 1) >= BLOCK_SIZE) return (arr_len);
|
||||
if ((arr_len + 1) >= RP_PASSWORD_SIZE) return (arr_len);
|
||||
|
||||
arr[arr_len] = c;
|
||||
|
||||
return (arr_len + 1);
|
||||
}
|
||||
|
||||
static int mangle_prepend (char arr[BLOCK_SIZE], int arr_len, char c)
|
||||
static int mangle_prepend (char arr[RP_PASSWORD_SIZE], int arr_len, char c)
|
||||
{
|
||||
if ((arr_len + 1) >= BLOCK_SIZE) return (arr_len);
|
||||
if ((arr_len + 1) >= RP_PASSWORD_SIZE) return (arr_len);
|
||||
|
||||
int arr_pos;
|
||||
|
||||
@ -176,7 +177,7 @@ static int mangle_prepend (char arr[BLOCK_SIZE], int arr_len, char c)
|
||||
return (arr_len + 1);
|
||||
}
|
||||
|
||||
static int mangle_delete_at (char arr[BLOCK_SIZE], int arr_len, int upos)
|
||||
static int mangle_delete_at (char arr[RP_PASSWORD_SIZE], int arr_len, int upos)
|
||||
{
|
||||
if (upos >= arr_len) return (arr_len);
|
||||
|
||||
@ -190,7 +191,7 @@ static int mangle_delete_at (char arr[BLOCK_SIZE], int arr_len, int upos)
|
||||
return (arr_len - 1);
|
||||
}
|
||||
|
||||
static int mangle_extract (char arr[BLOCK_SIZE], int arr_len, int upos, int ulen)
|
||||
static int mangle_extract (char arr[RP_PASSWORD_SIZE], int arr_len, int upos, int ulen)
|
||||
{
|
||||
if (upos >= arr_len) return (arr_len);
|
||||
|
||||
@ -206,7 +207,7 @@ static int mangle_extract (char arr[BLOCK_SIZE], int arr_len, int upos, int ulen
|
||||
return (ulen);
|
||||
}
|
||||
|
||||
static int mangle_omit (char arr[BLOCK_SIZE], int arr_len, int upos, int ulen)
|
||||
static int mangle_omit (char arr[RP_PASSWORD_SIZE], int arr_len, int upos, int ulen)
|
||||
{
|
||||
if (upos >= arr_len) return (arr_len);
|
||||
|
||||
@ -222,11 +223,11 @@ static int mangle_omit (char arr[BLOCK_SIZE], int arr_len, int upos, int ulen)
|
||||
return (arr_len - ulen);
|
||||
}
|
||||
|
||||
static int mangle_insert (char arr[BLOCK_SIZE], int arr_len, int upos, char c)
|
||||
static int mangle_insert (char arr[RP_PASSWORD_SIZE], int arr_len, int upos, char c)
|
||||
{
|
||||
if (upos > arr_len) return (arr_len);
|
||||
|
||||
if ((arr_len + 1) >= BLOCK_SIZE) return (arr_len);
|
||||
if ((arr_len + 1) >= RP_PASSWORD_SIZE) return (arr_len);
|
||||
|
||||
int arr_pos;
|
||||
|
||||
@ -240,9 +241,9 @@ static int mangle_insert (char arr[BLOCK_SIZE], int arr_len, int upos, char c)
|
||||
return (arr_len + 1);
|
||||
}
|
||||
|
||||
static 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)
|
||||
static int mangle_insert_multi (char arr[RP_PASSWORD_SIZE], int arr_len, int arr_pos, char arr2[RP_PASSWORD_SIZE], int arr2_len, int arr2_pos, int arr2_cpy)
|
||||
{
|
||||
if ((arr_len + arr2_cpy) > BLOCK_SIZE) return (RULE_RC_REJECT_ERROR);
|
||||
if ((arr_len + arr2_cpy) > RP_PASSWORD_SIZE) return (RULE_RC_REJECT_ERROR);
|
||||
|
||||
if (arr_pos > arr_len) return (RULE_RC_REJECT_ERROR);
|
||||
|
||||
@ -261,7 +262,7 @@ static int mangle_insert_multi (char arr[BLOCK_SIZE], int arr_len, int arr_pos,
|
||||
return (arr_len + arr2_cpy);
|
||||
}
|
||||
|
||||
static int mangle_overstrike (char arr[BLOCK_SIZE], int arr_len, int upos, char c)
|
||||
static int mangle_overstrike (char arr[RP_PASSWORD_SIZE], int arr_len, int upos, char c)
|
||||
{
|
||||
if (upos >= arr_len) return (arr_len);
|
||||
|
||||
@ -270,7 +271,7 @@ static int mangle_overstrike (char arr[BLOCK_SIZE], int arr_len, int upos, char
|
||||
return (arr_len);
|
||||
}
|
||||
|
||||
static int mangle_truncate_at (char arr[BLOCK_SIZE], int arr_len, int upos)
|
||||
static int mangle_truncate_at (char arr[RP_PASSWORD_SIZE], int arr_len, int upos)
|
||||
{
|
||||
if (upos >= arr_len) return (arr_len);
|
||||
|
||||
@ -279,7 +280,7 @@ static int mangle_truncate_at (char arr[BLOCK_SIZE], int arr_len, int upos)
|
||||
return (upos);
|
||||
}
|
||||
|
||||
static int mangle_replace (char arr[BLOCK_SIZE], int arr_len, char oldc, char newc)
|
||||
static int mangle_replace (char arr[RP_PASSWORD_SIZE], int arr_len, char oldc, char newc)
|
||||
{
|
||||
int arr_pos;
|
||||
|
||||
@ -293,7 +294,7 @@ static int mangle_replace (char arr[BLOCK_SIZE], int arr_len, char oldc, char ne
|
||||
return (arr_len);
|
||||
}
|
||||
|
||||
static int mangle_purgechar (char arr[BLOCK_SIZE], int arr_len, char c)
|
||||
static int mangle_purgechar (char arr[RP_PASSWORD_SIZE], int arr_len, char c)
|
||||
{
|
||||
int arr_pos;
|
||||
|
||||
@ -311,11 +312,11 @@ static int mangle_purgechar (char arr[BLOCK_SIZE], int arr_len, char c)
|
||||
return (ret_len);
|
||||
}
|
||||
|
||||
static int mangle_dupeblock_prepend (char arr[BLOCK_SIZE], int arr_len, int ulen)
|
||||
static int mangle_dupeblock_prepend (char arr[RP_PASSWORD_SIZE], int arr_len, int ulen)
|
||||
{
|
||||
if (ulen > arr_len) return (arr_len);
|
||||
|
||||
if ((arr_len + ulen) >= BLOCK_SIZE) return (arr_len);
|
||||
if ((arr_len + ulen) >= RP_PASSWORD_SIZE) return (arr_len);
|
||||
|
||||
char cs[100] = { 0 };
|
||||
|
||||
@ -333,11 +334,11 @@ static int mangle_dupeblock_prepend (char arr[BLOCK_SIZE], int arr_len, int ulen
|
||||
return (arr_len);
|
||||
}
|
||||
|
||||
static int mangle_dupeblock_append (char arr[BLOCK_SIZE], int arr_len, int ulen)
|
||||
static int mangle_dupeblock_append (char arr[RP_PASSWORD_SIZE], int arr_len, int ulen)
|
||||
{
|
||||
if (ulen > arr_len) return (arr_len);
|
||||
|
||||
if ((arr_len + ulen) >= BLOCK_SIZE) return (arr_len);
|
||||
if ((arr_len + ulen) >= RP_PASSWORD_SIZE) return (arr_len);
|
||||
|
||||
int upos = arr_len - ulen;
|
||||
|
||||
@ -353,10 +354,10 @@ static int mangle_dupeblock_append (char arr[BLOCK_SIZE], int arr_len, int ulen)
|
||||
return (arr_len);
|
||||
}
|
||||
|
||||
static int mangle_dupechar_at (char arr[BLOCK_SIZE], int arr_len, int upos, int ulen)
|
||||
static int mangle_dupechar_at (char arr[RP_PASSWORD_SIZE], int arr_len, int upos, int ulen)
|
||||
{
|
||||
if ( arr_len == 0) return (arr_len);
|
||||
if ((arr_len + ulen) >= BLOCK_SIZE) return (arr_len);
|
||||
if ((arr_len + ulen) >= RP_PASSWORD_SIZE) return (arr_len);
|
||||
|
||||
char c = arr[upos];
|
||||
|
||||
@ -370,10 +371,10 @@ static int mangle_dupechar_at (char arr[BLOCK_SIZE], int arr_len, int upos, int
|
||||
return (arr_len);
|
||||
}
|
||||
|
||||
static int mangle_dupechar (char arr[BLOCK_SIZE], int arr_len)
|
||||
static int mangle_dupechar (char arr[RP_PASSWORD_SIZE], int arr_len)
|
||||
{
|
||||
if ( arr_len == 0) return (arr_len);
|
||||
if ((arr_len + arr_len) >= BLOCK_SIZE) return (arr_len);
|
||||
if ((arr_len + arr_len) >= RP_PASSWORD_SIZE) return (arr_len);
|
||||
|
||||
int arr_pos;
|
||||
|
||||
@ -389,7 +390,7 @@ static int mangle_dupechar (char arr[BLOCK_SIZE], int arr_len)
|
||||
return (arr_len * 2);
|
||||
}
|
||||
|
||||
static int mangle_switch_at_check (char arr[BLOCK_SIZE], int arr_len, int upos, int upos2)
|
||||
static int mangle_switch_at_check (char arr[RP_PASSWORD_SIZE], int arr_len, int upos, int upos2)
|
||||
{
|
||||
if (upos >= arr_len) return (arr_len);
|
||||
if (upos2 >= arr_len) return (arr_len);
|
||||
@ -399,14 +400,14 @@ static int mangle_switch_at_check (char arr[BLOCK_SIZE], int arr_len, int upos,
|
||||
return (arr_len);
|
||||
}
|
||||
|
||||
static int mangle_switch_at (char arr[BLOCK_SIZE], int arr_len, int upos, int upos2)
|
||||
static int mangle_switch_at (char arr[RP_PASSWORD_SIZE], int arr_len, int upos, int upos2)
|
||||
{
|
||||
MANGLE_SWITCH (arr, upos, upos2);
|
||||
|
||||
return (arr_len);
|
||||
}
|
||||
|
||||
static int mangle_chr_shiftl (char arr[BLOCK_SIZE], int arr_len, int upos)
|
||||
static int mangle_chr_shiftl (char arr[RP_PASSWORD_SIZE], int arr_len, int upos)
|
||||
{
|
||||
if (upos >= arr_len) return (arr_len);
|
||||
|
||||
@ -415,7 +416,7 @@ static int mangle_chr_shiftl (char arr[BLOCK_SIZE], int arr_len, int upos)
|
||||
return (arr_len);
|
||||
}
|
||||
|
||||
static int mangle_chr_shiftr (char arr[BLOCK_SIZE], int arr_len, int upos)
|
||||
static int mangle_chr_shiftr (char arr[RP_PASSWORD_SIZE], int arr_len, int upos)
|
||||
{
|
||||
if (upos >= arr_len) return (arr_len);
|
||||
|
||||
@ -424,7 +425,7 @@ static int mangle_chr_shiftr (char arr[BLOCK_SIZE], int arr_len, int upos)
|
||||
return (arr_len);
|
||||
}
|
||||
|
||||
static int mangle_chr_incr (char arr[BLOCK_SIZE], int arr_len, int upos)
|
||||
static int mangle_chr_incr (char arr[RP_PASSWORD_SIZE], int arr_len, int upos)
|
||||
{
|
||||
if (upos >= arr_len) return (arr_len);
|
||||
|
||||
@ -433,7 +434,7 @@ static int mangle_chr_incr (char arr[BLOCK_SIZE], int arr_len, int upos)
|
||||
return (arr_len);
|
||||
}
|
||||
|
||||
static int mangle_chr_decr (char arr[BLOCK_SIZE], int arr_len, int upos)
|
||||
static int mangle_chr_decr (char arr[RP_PASSWORD_SIZE], int arr_len, int upos)
|
||||
{
|
||||
if (upos >= arr_len) return (arr_len);
|
||||
|
||||
@ -442,7 +443,7 @@ static int mangle_chr_decr (char arr[BLOCK_SIZE], int arr_len, int upos)
|
||||
return (arr_len);
|
||||
}
|
||||
|
||||
static int mangle_title_sep (char arr[BLOCK_SIZE], int arr_len, char c)
|
||||
static int mangle_title_sep (char arr[RP_PASSWORD_SIZE], int arr_len, char c)
|
||||
{
|
||||
int upper_next = 1;
|
||||
|
||||
@ -472,16 +473,17 @@ static int mangle_title_sep (char arr[BLOCK_SIZE], int arr_len, char c)
|
||||
return (arr_len);
|
||||
}
|
||||
|
||||
int _old_apply_rule (char *rule, int rule_len, char in[BLOCK_SIZE], int in_len, char out[BLOCK_SIZE])
|
||||
int _old_apply_rule (char *rule, int rule_len, char in[RP_PASSWORD_SIZE], int in_len, char out[RP_PASSWORD_SIZE])
|
||||
{
|
||||
char mem[BLOCK_SIZE] = { 0 };
|
||||
char mem[RP_PASSWORD_SIZE] = { 0 };
|
||||
|
||||
int pos_mem = -1;
|
||||
|
||||
if (in == NULL) return (RULE_RC_REJECT_ERROR);
|
||||
|
||||
if (out == NULL) return (RULE_RC_REJECT_ERROR);
|
||||
|
||||
if (in_len < 1 || in_len > BLOCK_SIZE) return (RULE_RC_REJECT_ERROR);
|
||||
if (in_len < 1 || in_len > RP_PASSWORD_SIZE) return (RULE_RC_REJECT_ERROR);
|
||||
|
||||
if (rule_len < 1) return (RULE_RC_REJECT_ERROR);
|
||||
|
||||
@ -736,14 +738,14 @@ int _old_apply_rule (char *rule, int rule_len, char in[BLOCK_SIZE], int in_len,
|
||||
|
||||
case RULE_OP_MANGLE_APPEND_MEMORY:
|
||||
if (mem_len < 1) return (RULE_RC_REJECT_ERROR);
|
||||
if ((out_len + mem_len) >= BLOCK_SIZE) return (RULE_RC_REJECT_ERROR);
|
||||
if ((out_len + mem_len) >= RP_PASSWORD_SIZE) return (RULE_RC_REJECT_ERROR);
|
||||
memcpy (out + out_len, mem, mem_len);
|
||||
out_len += mem_len;
|
||||
break;
|
||||
|
||||
case RULE_OP_MANGLE_PREPEND_MEMORY:
|
||||
if (mem_len < 1) return (RULE_RC_REJECT_ERROR);
|
||||
if ((mem_len + out_len) >= BLOCK_SIZE) return (RULE_RC_REJECT_ERROR);
|
||||
if ((mem_len + out_len) >= RP_PASSWORD_SIZE) return (RULE_RC_REJECT_ERROR);
|
||||
memcpy (mem + mem_len, out, out_len);
|
||||
out_len += mem_len;
|
||||
memcpy (out, mem, out_len);
|
||||
@ -814,7 +816,8 @@ int _old_apply_rule (char *rule, int rule_len, char in[BLOCK_SIZE], int in_len,
|
||||
if ((upos + 1) > out_len) return (RULE_RC_REJECT_ERROR);
|
||||
NEXT_RULEPOS (rule_pos);
|
||||
int c; int cnt;
|
||||
for (c = 0, cnt = 0; c < out_len && cnt < upos; c++) {
|
||||
for (c = 0, cnt = 0; c < out_len && cnt < upos; c++)
|
||||
{
|
||||
if (out[c] == rule[rule_pos])
|
||||
{
|
||||
cnt++;
|
||||
@ -834,7 +837,7 @@ int _old_apply_rule (char *rule, int rule_len, char in[BLOCK_SIZE], int in_len,
|
||||
}
|
||||
}
|
||||
|
||||
memset (out + out_len, 0, BLOCK_SIZE - out_len);
|
||||
memset (out + out_len, 0, RP_PASSWORD_SIZE - out_len);
|
||||
|
||||
return (out_len);
|
||||
}
|
||||
|
||||
@ -10,6 +10,7 @@
|
||||
#include "convert.h"
|
||||
#include "dictstat.h"
|
||||
#include "thread.h"
|
||||
#include "rp.h"
|
||||
#include "rp_cpu.h"
|
||||
#include "shared.h"
|
||||
#include "wordlist.h"
|
||||
@ -203,9 +204,9 @@ void get_next_word (hashcat_ctx_t *hashcat_ctx, FILE *fd, char **out_buf, u32 *o
|
||||
|
||||
if (run_rule_engine (user_options_extra->rule_len_l, user_options->rule_buf_l))
|
||||
{
|
||||
if (len >= BLOCK_SIZE) continue;
|
||||
if (len >= RP_PASSWORD_SIZE) continue;
|
||||
|
||||
char rule_buf_out[BLOCK_SIZE];
|
||||
char rule_buf_out[RP_PASSWORD_SIZE];
|
||||
|
||||
memset (rule_buf_out, 0, sizeof (rule_buf_out));
|
||||
|
||||
@ -400,9 +401,9 @@ int count_words (hashcat_ctx_t *hashcat_ctx, FILE *fd, const char *dictfile, u64
|
||||
|
||||
if (run_rule_engine (user_options_extra->rule_len_l, user_options->rule_buf_l))
|
||||
{
|
||||
if (len >= BLOCK_SIZE) continue;
|
||||
if (len >= RP_PASSWORD_SIZE) continue;
|
||||
|
||||
char rule_buf_out[BLOCK_SIZE];
|
||||
char rule_buf_out[RP_PASSWORD_SIZE];
|
||||
|
||||
memset (rule_buf_out, 0, sizeof (rule_buf_out));
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user