diff --git a/OpenCL/inc_rp.cl b/OpenCL/inc_rp.cl index 0893a272f..8837ab119 100644 --- a/OpenCL/inc_rp.cl +++ b/OpenCL/inc_rp.cl @@ -28,6 +28,50 @@ #define PASTE_PW pw; #endif +CONSTANT_AS u8 s_lookup[128] = +{ + [0 ... 31] = 0, // control characters + [32] = 1, // whitespace + [33 ... 47] = 1, // from '!' to '/' + [48 ... 57] = 0, // digits + [58 ... 64] = 1, // from ':' to '@' + [65 ... 90] = 0, // uppercase + [91 ... 96] = 1, // from '[' to '`' + [97 ... 122] = 0, // lowercase + [123 ... 126] = 1, // from '{' to '~' + [127] = 0 // del +}; + +HC_INLINE bool is_l (u8 c) +{ + return (c >= 'a' && c <= 'z'); +} + +HC_INLINE bool is_u (u8 c) +{ + return (c >= 'A' && c <= 'Z'); +} + +HC_INLINE bool is_d (u8 c) +{ + return (c >= '0' && c <= '9'); +} + +HC_INLINE bool is_lh (u8 c) +{ + return (is_d (c) || (c >= 'a' && c <= 'f')); +} + +HC_INLINE bool is_uh (u8 c) +{ + return (is_d (c) || (c >= 'A' && c <= 'F')); +} + +HC_INLINE bool is_s (u8 c) +{ + return s_lookup[c] == 1; +} + DECLSPEC u32 generate_cmask (const u32 value) { const u32 rmask = ((value & 0x40404040u) >> 1u) @@ -543,6 +587,132 @@ DECLSPEC int mangle_purgechar (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p return (out_len); } +DECLSPEC int mangle_purgeclass_l (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, PRIVATE_AS u8 *buf, const int len) +{ + int out_len = 0; + + for (int pos = 0; pos < len; pos++) + { + if (is_l (buf[pos])) continue; + + buf[out_len] = buf[pos]; + + out_len++; + } + + for (int pos = out_len; pos < len; pos++) + { + buf[pos] = 0; + } + + return (out_len); +} + +DECLSPEC int mangle_purgeclass_u (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, PRIVATE_AS u8 *buf, const int len) +{ + int out_len = 0; + + for (int pos = 0; pos < len; pos++) + { + if (is_u (buf[pos])) continue; + + buf[out_len] = buf[pos]; + + out_len++; + } + + for (int pos = out_len; pos < len; pos++) + { + buf[pos] = 0; + } + + return (out_len); +} + +DECLSPEC int mangle_purgeclass_d (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, PRIVATE_AS u8 *buf, const int len) +{ + int out_len = 0; + + for (int pos = 0; pos < len; pos++) + { + if (is_d (buf[pos])) continue; + + buf[out_len] = buf[pos]; + + out_len++; + } + + for (int pos = out_len; pos < len; pos++) + { + buf[pos] = 0; + } + + return (out_len); +} + +DECLSPEC int mangle_purgeclass_lh (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, PRIVATE_AS u8 *buf, const int len) +{ + int out_len = 0; + + for (int pos = 0; pos < len; pos++) + { + if (is_lh (buf[pos])) continue; + + buf[out_len] = buf[pos]; + + out_len++; + } + + for (int pos = out_len; pos < len; pos++) + { + buf[pos] = 0; + } + + return (out_len); +} + +DECLSPEC int mangle_purgeclass_uh (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, PRIVATE_AS u8 *buf, const int len) +{ + int out_len = 0; + + for (int pos = 0; pos < len; pos++) + { + if (is_uh (buf[pos])) continue; + + buf[out_len] = buf[pos]; + + out_len++; + } + + for (int pos = out_len; pos < len; pos++) + { + buf[pos] = 0; + } + + return (out_len); +} + +DECLSPEC int mangle_purgeclass_s (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, PRIVATE_AS u8 *buf, const int len) +{ + int out_len = 0; + + for (int pos = 0; pos < len; pos++) + { + if (is_s (buf[pos])) continue; + + buf[out_len] = buf[pos]; + + out_len++; + } + + for (int pos = out_len; pos < len; pos++) + { + buf[pos] = 0; + } + + return (out_len); +} + DECLSPEC int mangle_dupechar_first (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, PRIVATE_AS u8 *buf, const int len) { const int out_len = len + p0; @@ -748,21 +918,21 @@ DECLSPEC int apply_rule (const u32 name, MAYBE_UNUSED const u8 p0, MAYBE_UNUSED switch (name) { - case RULE_OP_MANGLE_LREST: out_len = mangle_lrest (p0, p1, buf, out_len); break; - case RULE_OP_MANGLE_LREST_UFIRST: out_len = mangle_lrest_ufirst (p0, p1, buf, out_len); break; - case RULE_OP_MANGLE_UREST: out_len = mangle_urest (p0, p1, buf, out_len); break; - case RULE_OP_MANGLE_UREST_LFIRST: out_len = mangle_urest_lfirst (p0, p1, buf, out_len); break; - case RULE_OP_MANGLE_TREST: out_len = mangle_trest (p0, p1, buf, out_len); break; - case RULE_OP_MANGLE_TOGGLE_AT: out_len = mangle_toggle_at (p0, p1, buf, out_len); break; - case RULE_OP_MANGLE_TOGGLE_AT_SEP: out_len = mangle_toggle_at_sep (p0, p1, buf, out_len); break; - case RULE_OP_MANGLE_REVERSE: out_len = mangle_reverse (p0, p1, buf, out_len); break; - case RULE_OP_MANGLE_DUPEWORD: out_len = mangle_dupeword (p0, p1, buf, out_len); break; + case RULE_OP_MANGLE_LREST: out_len = mangle_lrest (p0, p1, buf, out_len); break; + case RULE_OP_MANGLE_LREST_UFIRST: out_len = mangle_lrest_ufirst (p0, p1, buf, out_len); break; + case RULE_OP_MANGLE_UREST: out_len = mangle_urest (p0, p1, buf, out_len); break; + case RULE_OP_MANGLE_UREST_LFIRST: out_len = mangle_urest_lfirst (p0, p1, buf, out_len); break; + case RULE_OP_MANGLE_TREST: out_len = mangle_trest (p0, p1, buf, out_len); break; + case RULE_OP_MANGLE_TOGGLE_AT: out_len = mangle_toggle_at (p0, p1, buf, out_len); break; + case RULE_OP_MANGLE_TOGGLE_AT_SEP: out_len = mangle_toggle_at_sep (p0, p1, buf, out_len); break; + case RULE_OP_MANGLE_REVERSE: out_len = mangle_reverse (p0, p1, buf, out_len); break; + case RULE_OP_MANGLE_DUPEWORD: out_len = mangle_dupeword (p0, p1, buf, out_len); break; case RULE_OP_MANGLE_DUPEWORD_TIMES: out_len = mangle_dupeword_times (p0, p1, (PRIVATE_AS u8 *) buf, out_len); break; - case RULE_OP_MANGLE_REFLECT: out_len = mangle_reflect (p0, p1, buf, out_len); break; + case RULE_OP_MANGLE_REFLECT: out_len = mangle_reflect (p0, p1, buf, out_len); break; case RULE_OP_MANGLE_APPEND: out_len = mangle_append (p0, p1, (PRIVATE_AS u8 *) buf, out_len); break; case RULE_OP_MANGLE_PREPEND: out_len = mangle_prepend (p0, p1, (PRIVATE_AS u8 *) buf, out_len); break; - case RULE_OP_MANGLE_ROTATE_LEFT: out_len = mangle_rotate_left (p0, p1, buf, out_len); break; - case RULE_OP_MANGLE_ROTATE_RIGHT: out_len = mangle_rotate_right (p0, p1, buf, out_len); break; + case RULE_OP_MANGLE_ROTATE_LEFT: out_len = mangle_rotate_left (p0, p1, buf, out_len); break; + case RULE_OP_MANGLE_ROTATE_RIGHT: out_len = mangle_rotate_right (p0, p1, buf, out_len); break; case RULE_OP_MANGLE_DELETE_FIRST: out_len = mangle_delete_first (p0, p1, (PRIVATE_AS u8 *) buf, out_len); break; case RULE_OP_MANGLE_DELETE_LAST: out_len = mangle_delete_last (p0, p1, (PRIVATE_AS u8 *) buf, out_len); break; case RULE_OP_MANGLE_DELETE_AT: out_len = mangle_delete_at (p0, p1, (PRIVATE_AS u8 *) buf, out_len); break; @@ -773,12 +943,18 @@ DECLSPEC int apply_rule (const u32 name, MAYBE_UNUSED const u8 p0, MAYBE_UNUSED case RULE_OP_MANGLE_TRUNCATE_AT: out_len = mangle_truncate_at (p0, p1, (PRIVATE_AS u8 *) buf, out_len); break; case RULE_OP_MANGLE_REPLACE: out_len = mangle_replace (p0, p1, (PRIVATE_AS u8 *) buf, out_len); break; case RULE_OP_MANGLE_PURGECHAR: out_len = mangle_purgechar (p0, p1, (PRIVATE_AS u8 *) buf, out_len); break; + case RULE_OP_MANGLE_PURGECLASS_L: out_len = mangle_purgeclass_l (p0, p1, (PRIVATE_AS u8 *) buf, out_len); break; + case RULE_OP_MANGLE_PURGECLASS_U: out_len = mangle_purgeclass_u (p0, p1, (PRIVATE_AS u8 *) buf, out_len); break; + case RULE_OP_MANGLE_PURGECLASS_D: out_len = mangle_purgeclass_d (p0, p1, (PRIVATE_AS u8 *) buf, out_len); break; + case RULE_OP_MANGLE_PURGECLASS_LH: out_len = mangle_purgeclass_lh (p0, p1, (PRIVATE_AS u8 *) buf, out_len); break; + case RULE_OP_MANGLE_PURGECLASS_UH: out_len = mangle_purgeclass_uh (p0, p1, (PRIVATE_AS u8 *) buf, out_len); break; + case RULE_OP_MANGLE_PURGECLASS_S: out_len = mangle_purgeclass_s (p0, p1, (PRIVATE_AS u8 *) buf, out_len); break; case RULE_OP_MANGLE_DUPECHAR_FIRST: out_len = mangle_dupechar_first (p0, p1, (PRIVATE_AS u8 *) buf, out_len); break; case RULE_OP_MANGLE_DUPECHAR_LAST: out_len = mangle_dupechar_last (p0, p1, (PRIVATE_AS u8 *) buf, out_len); break; case RULE_OP_MANGLE_DUPECHAR_ALL: out_len = mangle_dupechar_all (p0, p1, (PRIVATE_AS u8 *) buf, out_len); break; - case RULE_OP_MANGLE_SWITCH_FIRST: out_len = mangle_switch_first (p0, p1, buf, out_len); break; - case RULE_OP_MANGLE_SWITCH_LAST: out_len = mangle_switch_last (p0, p1, buf, out_len); break; - case RULE_OP_MANGLE_SWITCH_AT: out_len = mangle_switch_at (p0, p1, buf, out_len); break; + case RULE_OP_MANGLE_SWITCH_FIRST: out_len = mangle_switch_first (p0, p1, buf, out_len); break; + case RULE_OP_MANGLE_SWITCH_LAST: out_len = mangle_switch_last (p0, p1, buf, out_len); break; + case RULE_OP_MANGLE_SWITCH_AT: out_len = mangle_switch_at (p0, p1, buf, out_len); break; case RULE_OP_MANGLE_CHR_SHIFTL: out_len = mangle_chr_shiftl (p0, p1, (PRIVATE_AS u8 *) buf, out_len); break; case RULE_OP_MANGLE_CHR_SHIFTR: out_len = mangle_chr_shiftr (p0, p1, (PRIVATE_AS u8 *) buf, out_len); break; case RULE_OP_MANGLE_CHR_INCR: out_len = mangle_chr_incr (p0, p1, (PRIVATE_AS u8 *) buf, out_len); break; @@ -787,8 +963,8 @@ DECLSPEC int apply_rule (const u32 name, MAYBE_UNUSED const u8 p0, MAYBE_UNUSED case RULE_OP_MANGLE_REPLACE_NM1: out_len = mangle_replace_nm1 (p0, p1, (PRIVATE_AS u8 *) buf, out_len); break; case RULE_OP_MANGLE_DUPEBLOCK_FIRST: out_len = mangle_dupeblock_first (p0, p1, (PRIVATE_AS u8 *) buf, out_len); break; case RULE_OP_MANGLE_DUPEBLOCK_LAST: out_len = mangle_dupeblock_last (p0, p1, (PRIVATE_AS u8 *) buf, out_len); break; - case RULE_OP_MANGLE_TITLE_SEP: out_len = mangle_title_sep (p0, p1, buf, out_len); break; - case RULE_OP_MANGLE_TITLE: out_len = mangle_title_sep (' ', p1, buf, out_len); break; + case RULE_OP_MANGLE_TITLE_SEP: out_len = mangle_title_sep (p0, p1, buf, out_len); break; + case RULE_OP_MANGLE_TITLE: out_len = mangle_title_sep (' ', p1, buf, out_len); break; } return out_len; diff --git a/OpenCL/inc_rp.h b/OpenCL/inc_rp.h index cf376819e..acfda62b1 100644 --- a/OpenCL/inc_rp.h +++ b/OpenCL/inc_rp.h @@ -40,6 +40,12 @@ #define RULE_OP_MANGLE_TRUNCATE_AT '\'' #define RULE_OP_MANGLE_REPLACE 's' #define RULE_OP_MANGLE_PURGECHAR '@' +#define RULE_OP_MANGLE_PURGECLASS_L 0x01 +#define RULE_OP_MANGLE_PURGECLASS_U 0x02 +#define RULE_OP_MANGLE_PURGECLASS_D 0x03 +#define RULE_OP_MANGLE_PURGECLASS_LH 0x04 +#define RULE_OP_MANGLE_PURGECLASS_UH 0x05 +#define RULE_OP_MANGLE_PURGECLASS_S 0x06 #define RULE_OP_MANGLE_TOGGLECASE_REC 'a' #define RULE_OP_MANGLE_DUPECHAR_FIRST 'z' #define RULE_OP_MANGLE_DUPECHAR_LAST 'Z' @@ -103,6 +109,12 @@ DECLSPEC int mangle_overstrike (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 DECLSPEC int mangle_truncate_at (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, PRIVATE_AS u8 *buf, const int len); DECLSPEC int mangle_replace (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, PRIVATE_AS u8 *buf, const int len); DECLSPEC int mangle_purgechar (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, PRIVATE_AS u8 *buf, const int len); +DECLSPEC int mangle_purgeclass_l (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, PRIVATE_AS u8 *buf, const int len); +DECLSPEC int mangle_purgeclass_u (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, PRIVATE_AS u8 *buf, const int len); +DECLSPEC int mangle_purgeclass_d (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, PRIVATE_AS u8 *buf, const int len); +DECLSPEC int mangle_purgeclass_lh (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, PRIVATE_AS u8 *buf, const int len); +DECLSPEC int mangle_purgeclass_uh (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, PRIVATE_AS u8 *buf, const int len); +DECLSPEC int mangle_purgeclass_s (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, PRIVATE_AS u8 *buf, const int len); DECLSPEC int mangle_dupechar_first (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, PRIVATE_AS u8 *buf, const int len); DECLSPEC int mangle_dupechar_last (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, PRIVATE_AS u8 *buf, const int len); DECLSPEC int mangle_dupechar_all (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, PRIVATE_AS u8 *buf, const int len); diff --git a/OpenCL/inc_rp_optimized.cl b/OpenCL/inc_rp_optimized.cl index 5a8d04f4c..094716773 100644 --- a/OpenCL/inc_rp_optimized.cl +++ b/OpenCL/inc_rp_optimized.cl @@ -13,6 +13,50 @@ #define MAYBE_UNUSED #endif +CONSTANT_AS u8 s_lookup_optimized[128] = +{ + [0 ... 31] = 0, // control characters + [32] = 1, // whitespace + [33 ... 47] = 1, // from '!' to '/' + [48 ... 57] = 0, // digits + [58 ... 64] = 1, // from ':' to '@' + [65 ... 90] = 0, // uppercase + [91 ... 96] = 1, // from '[' to '`' + [97 ... 122] = 0, // lowercase + [123 ... 126] = 1, // from '{' to '~' + [127] = 0 // del +}; + +HC_INLINE bool is_l (u8 c) +{ + return (c >= 'a' && c <= 'z'); +} + +HC_INLINE bool is_u (u8 c) +{ + return (c >= 'A' && c <= 'Z'); +} + +HC_INLINE bool is_d (u8 c) +{ + return (c >= '0' && c <= '9'); +} + +HC_INLINE bool is_lh (u8 c) +{ + return (is_d (c) || (c >= 'a' && c <= 'f')); +} + +HC_INLINE bool is_uh (u8 c) +{ + return (is_d (c) || (c >= 'A' && c <= 'F')); +} + +HC_INLINE bool is_s (u8 c) +{ + return s_lookup_optimized[c] == 1; +} + DECLSPEC u32 generate_cmask_optimized (const u32 value) { const u32 rmask = ((value & 0x40404040u) >> 1u) @@ -1824,6 +1868,252 @@ DECLSPEC HC_INLINE_RP u32 rule_op_mangle_purgechar (MAYBE_UNUSED const u32 p0, M return out_len; } +DECLSPEC HC_INLINE_RP u32 rule_op_mangle_purgeclass_l (MAYBE_UNUSED const u32 p0, MAYBE_UNUSED const u32 p1, MAYBE_UNUSED PRIVATE_AS u32 *buf0, MAYBE_UNUSED PRIVATE_AS u32 *buf1, const u32 in_len) +{ + u32 out_len = 0; + + u32 buf_in[8]; + + buf_in[0] = buf0[0]; + buf_in[1] = buf0[1]; + buf_in[2] = buf0[2]; + buf_in[3] = buf0[3]; + buf_in[4] = buf1[0]; + buf_in[5] = buf1[1]; + buf_in[6] = buf1[2]; + buf_in[7] = buf1[3]; + + u32 buf_out[8] = { 0 }; + + PRIVATE_AS u8 *in = (PRIVATE_AS u8 *) buf_in; + PRIVATE_AS u8 *out = (PRIVATE_AS u8 *) buf_out; + + for (u32 pos = 0; pos < in_len; pos++) + { + if (is_l (in[pos])) continue; + + out[out_len] = in[pos]; + + out_len++; + } + + buf0[0] = buf_out[0]; + buf0[1] = buf_out[1]; + buf0[2] = buf_out[2]; + buf0[3] = buf_out[3]; + buf1[0] = buf_out[4]; + buf1[1] = buf_out[5]; + buf1[2] = buf_out[6]; + buf1[3] = buf_out[7]; + + return out_len; +} + +DECLSPEC HC_INLINE_RP u32 rule_op_mangle_purgeclass_u (MAYBE_UNUSED const u32 p0, MAYBE_UNUSED const u32 p1, MAYBE_UNUSED PRIVATE_AS u32 *buf0, MAYBE_UNUSED PRIVATE_AS u32 *buf1, const u32 in_len) +{ + u32 out_len = 0; + + u32 buf_in[8]; + + buf_in[0] = buf0[0]; + buf_in[1] = buf0[1]; + buf_in[2] = buf0[2]; + buf_in[3] = buf0[3]; + buf_in[4] = buf1[0]; + buf_in[5] = buf1[1]; + buf_in[6] = buf1[2]; + buf_in[7] = buf1[3]; + + u32 buf_out[8] = { 0 }; + + PRIVATE_AS u8 *in = (PRIVATE_AS u8 *) buf_in; + PRIVATE_AS u8 *out = (PRIVATE_AS u8 *) buf_out; + + for (u32 pos = 0; pos < in_len; pos++) + { + if (is_u (in[pos])) continue; + + out[out_len] = in[pos]; + + out_len++; + } + + buf0[0] = buf_out[0]; + buf0[1] = buf_out[1]; + buf0[2] = buf_out[2]; + buf0[3] = buf_out[3]; + buf1[0] = buf_out[4]; + buf1[1] = buf_out[5]; + buf1[2] = buf_out[6]; + buf1[3] = buf_out[7]; + + return out_len; +} + +DECLSPEC HC_INLINE_RP u32 rule_op_mangle_purgeclass_d (MAYBE_UNUSED const u32 p0, MAYBE_UNUSED const u32 p1, MAYBE_UNUSED PRIVATE_AS u32 *buf0, MAYBE_UNUSED PRIVATE_AS u32 *buf1, const u32 in_len) +{ + u32 out_len = 0; + + u32 buf_in[8]; + + buf_in[0] = buf0[0]; + buf_in[1] = buf0[1]; + buf_in[2] = buf0[2]; + buf_in[3] = buf0[3]; + buf_in[4] = buf1[0]; + buf_in[5] = buf1[1]; + buf_in[6] = buf1[2]; + buf_in[7] = buf1[3]; + + u32 buf_out[8] = { 0 }; + + PRIVATE_AS u8 *in = (PRIVATE_AS u8 *) buf_in; + PRIVATE_AS u8 *out = (PRIVATE_AS u8 *) buf_out; + + for (u32 pos = 0; pos < in_len; pos++) + { + if (is_d (in[pos])) continue; + + out[out_len] = in[pos]; + + out_len++; + } + + buf0[0] = buf_out[0]; + buf0[1] = buf_out[1]; + buf0[2] = buf_out[2]; + buf0[3] = buf_out[3]; + buf1[0] = buf_out[4]; + buf1[1] = buf_out[5]; + buf1[2] = buf_out[6]; + buf1[3] = buf_out[7]; + + return out_len; +} + +DECLSPEC HC_INLINE_RP u32 rule_op_mangle_purgeclass_lh (MAYBE_UNUSED const u32 p0, MAYBE_UNUSED const u32 p1, MAYBE_UNUSED PRIVATE_AS u32 *buf0, MAYBE_UNUSED PRIVATE_AS u32 *buf1, const u32 in_len) +{ + u32 out_len = 0; + + u32 buf_in[8]; + + buf_in[0] = buf0[0]; + buf_in[1] = buf0[1]; + buf_in[2] = buf0[2]; + buf_in[3] = buf0[3]; + buf_in[4] = buf1[0]; + buf_in[5] = buf1[1]; + buf_in[6] = buf1[2]; + buf_in[7] = buf1[3]; + + u32 buf_out[8] = { 0 }; + + PRIVATE_AS u8 *in = (PRIVATE_AS u8 *) buf_in; + PRIVATE_AS u8 *out = (PRIVATE_AS u8 *) buf_out; + + for (u32 pos = 0; pos < in_len; pos++) + { + if (is_lh (in[pos])) continue; + + out[out_len] = in[pos]; + + out_len++; + } + + buf0[0] = buf_out[0]; + buf0[1] = buf_out[1]; + buf0[2] = buf_out[2]; + buf0[3] = buf_out[3]; + buf1[0] = buf_out[4]; + buf1[1] = buf_out[5]; + buf1[2] = buf_out[6]; + buf1[3] = buf_out[7]; + + return out_len; +} + +DECLSPEC HC_INLINE_RP u32 rule_op_mangle_purgeclass_uh (MAYBE_UNUSED const u32 p0, MAYBE_UNUSED const u32 p1, MAYBE_UNUSED PRIVATE_AS u32 *buf0, MAYBE_UNUSED PRIVATE_AS u32 *buf1, const u32 in_len) +{ + u32 out_len = 0; + + u32 buf_in[8]; + + buf_in[0] = buf0[0]; + buf_in[1] = buf0[1]; + buf_in[2] = buf0[2]; + buf_in[3] = buf0[3]; + buf_in[4] = buf1[0]; + buf_in[5] = buf1[1]; + buf_in[6] = buf1[2]; + buf_in[7] = buf1[3]; + + u32 buf_out[8] = { 0 }; + + PRIVATE_AS u8 *in = (PRIVATE_AS u8 *) buf_in; + PRIVATE_AS u8 *out = (PRIVATE_AS u8 *) buf_out; + + for (u32 pos = 0; pos < in_len; pos++) + { + if (is_uh (in[pos])) continue; + + out[out_len] = in[pos]; + + out_len++; + } + + buf0[0] = buf_out[0]; + buf0[1] = buf_out[1]; + buf0[2] = buf_out[2]; + buf0[3] = buf_out[3]; + buf1[0] = buf_out[4]; + buf1[1] = buf_out[5]; + buf1[2] = buf_out[6]; + buf1[3] = buf_out[7]; + + return out_len; +} + +DECLSPEC HC_INLINE_RP u32 rule_op_mangle_purgeclass_s (MAYBE_UNUSED const u32 p0, MAYBE_UNUSED const u32 p1, MAYBE_UNUSED PRIVATE_AS u32 *buf0, MAYBE_UNUSED PRIVATE_AS u32 *buf1, const u32 in_len) +{ + u32 out_len = 0; + + u32 buf_in[8]; + + buf_in[0] = buf0[0]; + buf_in[1] = buf0[1]; + buf_in[2] = buf0[2]; + buf_in[3] = buf0[3]; + buf_in[4] = buf1[0]; + buf_in[5] = buf1[1]; + buf_in[6] = buf1[2]; + buf_in[7] = buf1[3]; + + u32 buf_out[8] = { 0 }; + + PRIVATE_AS u8 *in = (PRIVATE_AS u8 *) buf_in; + PRIVATE_AS u8 *out = (PRIVATE_AS u8 *) buf_out; + + for (u32 pos = 0; pos < in_len; pos++) + { + if (is_s (in[pos])) continue; + + out[out_len] = in[pos]; + + out_len++; + } + + buf0[0] = buf_out[0]; + buf0[1] = buf_out[1]; + buf0[2] = buf_out[2]; + buf0[3] = buf_out[3]; + buf1[0] = buf_out[4]; + buf1[1] = buf_out[5]; + buf1[2] = buf_out[6]; + buf1[3] = buf_out[7]; + + return out_len; +} + DECLSPEC HC_INLINE_RP u32 rule_op_mangle_dupechar_first (MAYBE_UNUSED const u32 p0, MAYBE_UNUSED const u32 p1, MAYBE_UNUSED PRIVATE_AS u32 *buf0, MAYBE_UNUSED PRIVATE_AS u32 *buf1, const u32 in_len) { if ( in_len == 0) return in_len; @@ -2380,6 +2670,12 @@ DECLSPEC u32 apply_rule_optimized (const u32 name, const u32 p0, const u32 p1, P case RULE_OP_MANGLE_TRUNCATE_AT: out_len = rule_op_mangle_truncate_at (p0, p1, buf0, buf1, out_len); break; case RULE_OP_MANGLE_REPLACE: out_len = rule_op_mangle_replace (p0, p1, buf0, buf1, out_len); break; case RULE_OP_MANGLE_PURGECHAR: out_len = rule_op_mangle_purgechar (p0, p1, buf0, buf1, out_len); break; + case RULE_OP_MANGLE_PURGECLASS_L: out_len = rule_op_mangle_purgeclass_l (p0, p1, buf0, buf1, out_len); break; + case RULE_OP_MANGLE_PURGECLASS_U: out_len = rule_op_mangle_purgeclass_u (p0, p1, buf0, buf1, out_len); break; + case RULE_OP_MANGLE_PURGECLASS_D: out_len = rule_op_mangle_purgeclass_d (p0, p1, buf0, buf1, out_len); break; + case RULE_OP_MANGLE_PURGECLASS_LH: out_len = rule_op_mangle_purgeclass_lh (p0, p1, buf0, buf1, out_len); break; + case RULE_OP_MANGLE_PURGECLASS_UH: out_len = rule_op_mangle_purgeclass_uh (p0, p1, buf0, buf1, out_len); break; + case RULE_OP_MANGLE_PURGECLASS_S: out_len = rule_op_mangle_purgeclass_s (p0, p1, buf0, buf1, out_len); break; //case RULE_OP_MANGLE_TOGGLECASE_REC: out_len = rule_op_mangle_togglecase_rec (p0, p1, buf0, buf1, out_len); break; case RULE_OP_MANGLE_DUPECHAR_FIRST: out_len = rule_op_mangle_dupechar_first (p0, p1, buf0, buf1, out_len); break; case RULE_OP_MANGLE_DUPECHAR_LAST: out_len = rule_op_mangle_dupechar_last (p0, p1, buf0, buf1, out_len); break; diff --git a/OpenCL/inc_rp_optimized.h b/OpenCL/inc_rp_optimized.h index 4caad7220..5b0b7ff99 100644 --- a/OpenCL/inc_rp_optimized.h +++ b/OpenCL/inc_rp_optimized.h @@ -46,6 +46,12 @@ #define RULE_OP_MANGLE_TRUNCATE_AT '\'' #define RULE_OP_MANGLE_REPLACE 's' #define RULE_OP_MANGLE_PURGECHAR '@' +#define RULE_OP_MANGLE_PURGECLASS_L 0x01 +#define RULE_OP_MANGLE_PURGECLASS_U 0x02 +#define RULE_OP_MANGLE_PURGECLASS_D 0x03 +#define RULE_OP_MANGLE_PURGECLASS_LH 0x04 +#define RULE_OP_MANGLE_PURGECLASS_UH 0x05 +#define RULE_OP_MANGLE_PURGECLASS_S 0x06 #define RULE_OP_MANGLE_TOGGLECASE_REC 'a' #define RULE_OP_MANGLE_DUPECHAR_FIRST 'z' #define RULE_OP_MANGLE_DUPECHAR_LAST 'Z' @@ -113,6 +119,12 @@ DECLSPEC u32 search_on_register (const u32 in, const u32 p0); DECLSPEC u32 replace_on_register (const u32 in, const u32 r, const u32 p1); DECLSPEC HC_INLINE_RP u32 rule_op_mangle_replace (MAYBE_UNUSED const u32 p0, MAYBE_UNUSED const u32 p1, MAYBE_UNUSED PRIVATE_AS u32 *buf0, MAYBE_UNUSED PRIVATE_AS u32 *buf1, const u32 in_len); DECLSPEC HC_INLINE_RP u32 rule_op_mangle_purgechar (MAYBE_UNUSED const u32 p0, MAYBE_UNUSED const u32 p1, MAYBE_UNUSED PRIVATE_AS u32 *buf0, MAYBE_UNUSED PRIVATE_AS u32 *buf1, const u32 in_len); +DECLSPEC HC_INLINE_RP u32 rule_op_mangle_purgeclass_l (MAYBE_UNUSED const u32 p0, MAYBE_UNUSED const u32 p1, MAYBE_UNUSED PRIVATE_AS u32 *buf0, MAYBE_UNUSED PRIVATE_AS u32 *buf1, const u32 in_len); +DECLSPEC HC_INLINE_RP u32 rule_op_mangle_purgeclass_u (MAYBE_UNUSED const u32 p0, MAYBE_UNUSED const u32 p1, MAYBE_UNUSED PRIVATE_AS u32 *buf0, MAYBE_UNUSED PRIVATE_AS u32 *buf1, const u32 in_len); +DECLSPEC HC_INLINE_RP u32 rule_op_mangle_purgeclass_d (MAYBE_UNUSED const u32 p0, MAYBE_UNUSED const u32 p1, MAYBE_UNUSED PRIVATE_AS u32 *buf0, MAYBE_UNUSED PRIVATE_AS u32 *buf1, const u32 in_len); +DECLSPEC HC_INLINE_RP u32 rule_op_mangle_purgeclass_lh (MAYBE_UNUSED const u32 p0, MAYBE_UNUSED const u32 p1, MAYBE_UNUSED PRIVATE_AS u32 *buf0, MAYBE_UNUSED PRIVATE_AS u32 *buf1, const u32 in_len); +DECLSPEC HC_INLINE_RP u32 rule_op_mangle_purgeclass_uh (MAYBE_UNUSED const u32 p0, MAYBE_UNUSED const u32 p1, MAYBE_UNUSED PRIVATE_AS u32 *buf0, MAYBE_UNUSED PRIVATE_AS u32 *buf1, const u32 in_len); +DECLSPEC HC_INLINE_RP u32 rule_op_mangle_purgeclass_s (MAYBE_UNUSED const u32 p0, MAYBE_UNUSED const u32 p1, MAYBE_UNUSED PRIVATE_AS u32 *buf0, MAYBE_UNUSED PRIVATE_AS u32 *buf1, const u32 in_len); DECLSPEC HC_INLINE_RP u32 rule_op_mangle_dupechar_first (MAYBE_UNUSED const u32 p0, MAYBE_UNUSED const u32 p1, MAYBE_UNUSED PRIVATE_AS u32 *buf0, MAYBE_UNUSED PRIVATE_AS u32 *buf1, const u32 in_len); DECLSPEC HC_INLINE_RP u32 rule_op_mangle_dupechar_last (MAYBE_UNUSED const u32 p0, MAYBE_UNUSED const u32 p1, MAYBE_UNUSED PRIVATE_AS u32 *buf0, MAYBE_UNUSED PRIVATE_AS u32 *buf1, const u32 in_len); DECLSPEC HC_INLINE_RP u32 rule_op_mangle_dupechar_all (MAYBE_UNUSED const u32 p0, MAYBE_UNUSED const u32 p1, MAYBE_UNUSED PRIVATE_AS u32 *buf0, MAYBE_UNUSED PRIVATE_AS u32 *buf1, const u32 in_len); diff --git a/docs/changes.txt b/docs/changes.txt index 283e3c0d4..1cf719da9 100644 --- a/docs/changes.txt +++ b/docs/changes.txt @@ -133,6 +133,8 @@ - Hardware Monitor: avoid sprintf in src/ext_iokit.c - Help: show supported hash-modes only with -hh - Makefile: prevent make failure with Apple Silicon in case of partial rebuild +- Rules: Extended the Purge (@) rule operation to support Classes +- Rules: Fixed d3ad0ne.rule to support the new Purge (@) rule handling - Rules: Rename best64.rule to best66.rule and remove the unknown section from it * changes v6.2.5 -> v6.2.6 diff --git a/docs/credits.txt b/docs/credits.txt index f126840c8..b4e437557 100644 --- a/docs/credits.txt +++ b/docs/credits.txt @@ -25,6 +25,7 @@ Gabriele "matrix" Gristina (@gm4tr1x) * Apple macOS port * Apple Silicon support * Universal binary on Apple Silicon +* Extended the Purge (@) rule operation to support Classes * Hardware monitor initial code base and maintenance * Test suite initial code base and maintenance * Makefile initial code base diff --git a/docs/rules.txt b/docs/rules.txt index 59233d1ad..c1d5950e0 100644 --- a/docs/rules.txt +++ b/docs/rules.txt @@ -23,7 +23,7 @@ #define RULE_OP_MANGLE_OVERSTRIKE 'o' // overwrite with char X at pos N #define RULE_OP_MANGLE_TRUNCATE_AT '\''// cut the word at pos N #define RULE_OP_MANGLE_REPLACE 's' // replace all chars X with char Y -#define RULE_OP_MANGLE_PURGECHAR '@' // purge all instances of char X +#define RULE_OP_MANGLE_PURGECHAR '@' // purge all instances of char X (@X) or purge all instances of chars in class X (@?X) #define RULE_OP_MANGLE_DUPECHAR_FIRST 'z' // prepend first char of word to itself N times. ex: hello -> hhhello #define RULE_OP_MANGLE_DUPECHAR_LAST 'Z' // append last char of word to itself N times. ex: hello -> hellooo #define RULE_OP_MANGLE_DUPECHAR_ALL 'q' // duplicate all chars. ex: hello -> hheelllloo diff --git a/include/rp.h b/include/rp.h index c5b367276..eb256fb16 100644 --- a/include/rp.h +++ b/include/rp.h @@ -43,10 +43,13 @@ typedef struct } rp_gen_ops_t; -bool class_num (const u8 c); -bool class_lower (const u8 c); -bool class_upper (const u8 c); -bool class_alpha (const u8 c); +bool class_num (const u8 c); +bool class_lower (const u8 c); +bool class_upper (const u8 c); +bool class_lower_hex (const u8 c); +bool class_upper_hex (const u8 c); +bool class_sym (const u8 c); +bool class_alpha (const u8 c); int conv_ctoi (const u8 c); int conv_itoc (const u8 c); diff --git a/include/types.h b/include/types.h index e6ea946f9..e0e42c37b 100644 --- a/include/types.h +++ b/include/types.h @@ -331,6 +331,12 @@ typedef enum rule_functions RULE_OP_MANGLE_TRUNCATE_AT = '\'', RULE_OP_MANGLE_REPLACE = 's', RULE_OP_MANGLE_PURGECHAR = '@', + RULE_OP_MANGLE_PURGECLASS_L = 0x01, + RULE_OP_MANGLE_PURGECLASS_U = 0x02, + RULE_OP_MANGLE_PURGECLASS_D = 0x03, + RULE_OP_MANGLE_PURGECLASS_LH = 0x04, + RULE_OP_MANGLE_PURGECLASS_UH = 0x05, + RULE_OP_MANGLE_PURGECLASS_S = 0x06, RULE_OP_MANGLE_TOGGLECASE_REC = 'a', RULE_OP_MANGLE_DUPECHAR_FIRST = 'z', RULE_OP_MANGLE_DUPECHAR_LAST = 'Z', diff --git a/rules/d3ad0ne.rule b/rules/d3ad0ne.rule index e9005d473..4f39d0dfd 100644 --- a/rules/d3ad0ne.rule +++ b/rules/d3ad0ne.rule @@ -5823,7 +5823,7 @@ O05 o28 *74 O6B *75 $5 *75 $m -*75 @? '7 +*75 @?? '7 *75 D1 *75 D4 *75 D6 diff --git a/src/rp.c b/src/rp.c index 67ebd9322..5a5ccb409 100644 --- a/src/rp.c +++ b/src/rp.c @@ -106,6 +106,21 @@ bool class_upper (const u8 c) return ((c >= 'A') && (c <= 'Z')); } +bool class_lower_hex (const u8 c) +{ + return ((c >= '0') && (c <= '9')) || ((c >= 'a') && (c <= 'f')); +} + +bool class_upper_hex (const u8 c) +{ + return ((c >= '0') && (c <= '9')) || ((c >= 'A') && (c <= 'F')); +} + +bool class_sym (const u8 c) +{ + return ((c == ' ') || ((c >= '!') && (c <= '/')) || ((c >= ':') && (c <= '@')) || ((c >= '[') && (c <= '`')) || ((c >= '{') && (c <= '~'))); +} + bool class_alpha (const u8 c) { return (class_lower (c) || class_upper (c)); @@ -373,6 +388,52 @@ int cpu_rule_to_kernel_rule (char *rule_buf, u32 rule_len, kernel_rule_t *rule) break; case RULE_OP_MANGLE_PURGECHAR: + if ((rule_pos + 1) < rule_len && rule_buf[rule_pos+1] == '?') + { + if ((rule_pos + 2) == rule_len) return -1; + + switch (rule_buf[rule_pos+2]) { + case '?': + SET_NAME (rule, rule_buf[rule_pos]); + SET_P0 (rule, rule_buf[rule_pos]); + INCR_POS; + break; + case 'l': + SET_NAME (rule, RULE_OP_MANGLE_PURGECLASS_L); + INCR_POS; + INCR_POS; + break; + case 'u': + SET_NAME (rule, RULE_OP_MANGLE_PURGECLASS_U); + INCR_POS; + INCR_POS; + break; + case 'd': + SET_NAME (rule, RULE_OP_MANGLE_PURGECLASS_D); + INCR_POS; + INCR_POS; + break; + case 'h': + SET_NAME (rule, RULE_OP_MANGLE_PURGECLASS_LH); + INCR_POS; + INCR_POS; + break; + case 'H': + SET_NAME (rule, RULE_OP_MANGLE_PURGECLASS_UH); + INCR_POS; + INCR_POS; + break; + case 's': + SET_NAME (rule, RULE_OP_MANGLE_PURGECLASS_S); + INCR_POS; + INCR_POS; + break; + default : + return -1; + } + break; + } + SET_NAME (rule, rule_buf[rule_pos]); SET_P0 (rule, rule_buf[rule_pos]); break; @@ -604,6 +665,38 @@ int kernel_rule_to_cpu_rule (char *rule_buf, kernel_rule_t *rule) case RULE_OP_MANGLE_PURGECHAR: rule_buf[rule_pos] = rule_cmd; GET_P0 (rule); + if (rule_buf[rule_pos] == '?') rule_buf[++rule_pos] = '?'; + break; + + case RULE_OP_MANGLE_PURGECLASS_L: + rule_buf[rule_pos++] = RULE_OP_MANGLE_PURGECHAR; + rule_buf[rule_pos++] = '?'; + rule_buf[rule_pos] = 'l'; + break; + case RULE_OP_MANGLE_PURGECLASS_U: + rule_buf[rule_pos++] = RULE_OP_MANGLE_PURGECHAR; + rule_buf[rule_pos++] = '?'; + rule_buf[rule_pos] = 'u'; + break; + case RULE_OP_MANGLE_PURGECLASS_D: + rule_buf[rule_pos++] = RULE_OP_MANGLE_PURGECHAR; + rule_buf[rule_pos++] = '?'; + rule_buf[rule_pos] = 'd'; + break; + case RULE_OP_MANGLE_PURGECLASS_LH: + rule_buf[rule_pos++] = RULE_OP_MANGLE_PURGECHAR; + rule_buf[rule_pos++] = '?'; + rule_buf[rule_pos] = 'h'; + break; + case RULE_OP_MANGLE_PURGECLASS_UH: + rule_buf[rule_pos++] = RULE_OP_MANGLE_PURGECHAR; + rule_buf[rule_pos++] = '?'; + rule_buf[rule_pos] = 'H'; + break; + case RULE_OP_MANGLE_PURGECLASS_S: + rule_buf[rule_pos++] = RULE_OP_MANGLE_PURGECHAR; + rule_buf[rule_pos++] = '?'; + rule_buf[rule_pos] = 's'; break; case RULE_OP_MANGLE_TOGGLECASE_REC: diff --git a/src/rp_cpu.c b/src/rp_cpu.c index fb16aa08e..de836fd10 100644 --- a/src/rp_cpu.c +++ b/src/rp_cpu.c @@ -347,6 +347,114 @@ static int mangle_purgechar (char arr[RP_PASSWORD_SIZE], int arr_len, char c) return (ret_len); } +static int mangle_purgeclass_l (char arr[RP_PASSWORD_SIZE], int arr_len) +{ + int arr_pos; + + int ret_len; + + for (ret_len = 0, arr_pos = 0; arr_pos < arr_len; arr_pos++) + { + if (class_lower (arr[arr_pos])) continue; + + arr[ret_len] = arr[arr_pos]; + + ret_len++; + } + + return (ret_len); +} + +static int mangle_purgeclass_u (char arr[RP_PASSWORD_SIZE], int arr_len) +{ + int arr_pos; + + int ret_len; + + for (ret_len = 0, arr_pos = 0; arr_pos < arr_len; arr_pos++) + { + if (class_upper (arr[arr_pos])) continue; + + arr[ret_len] = arr[arr_pos]; + + ret_len++; + } + + return (ret_len); +} + +static int mangle_purgeclass_d (char arr[RP_PASSWORD_SIZE], int arr_len) +{ + int arr_pos; + + int ret_len; + + for (ret_len = 0, arr_pos = 0; arr_pos < arr_len; arr_pos++) + { + if (class_num (arr[arr_pos])) continue; + + arr[ret_len] = arr[arr_pos]; + + ret_len++; + } + + return (ret_len); +} + +static int mangle_purgeclass_lh (char arr[RP_PASSWORD_SIZE], int arr_len) +{ + int arr_pos; + + int ret_len; + + for (ret_len = 0, arr_pos = 0; arr_pos < arr_len; arr_pos++) + { + if (class_lower_hex (arr[arr_pos])) continue; + + arr[ret_len] = arr[arr_pos]; + + ret_len++; + } + + return (ret_len); +} + +static int mangle_purgeclass_uh (char arr[RP_PASSWORD_SIZE], int arr_len) +{ + int arr_pos; + + int ret_len; + + for (ret_len = 0, arr_pos = 0; arr_pos < arr_len; arr_pos++) + { + if (class_upper_hex (arr[arr_pos])) continue; + + arr[ret_len] = arr[arr_pos]; + + ret_len++; + } + + return (ret_len); +} + +static int mangle_purgeclass_s (char arr[RP_PASSWORD_SIZE], int arr_len) +{ + int arr_pos; + + int ret_len; + + for (ret_len = 0, arr_pos = 0; arr_pos < arr_len; arr_pos++) + { + if (class_sym (arr[arr_pos])) continue; + + arr[ret_len] = arr[arr_pos]; + + ret_len++; + } + + return (ret_len); +} + static int mangle_dupeblock_prepend (char arr[RP_PASSWORD_SIZE], int arr_len, int ulen) { if (ulen > arr_len) return (arr_len); @@ -699,6 +807,23 @@ int _old_apply_rule (const char *rule, int rule_len, char in[RP_PASSWORD_SIZE], case RULE_OP_MANGLE_PURGECHAR: NEXT_RULEPOS (rule_pos); + if (rule_new[rule_pos] == '?') + { + NEXT_RULEPOS (rule_pos); + switch (rule_new[rule_pos]) + { + case '?': out_len = mangle_purgechar (out, out_len, rule_new[rule_pos]); break; + case 'l': out_len = mangle_purgeclass_l (out, out_len); break; + case 'u': out_len = mangle_purgeclass_u (out, out_len); break; + case 'd': out_len = mangle_purgeclass_d (out, out_len); break; + case 'h': out_len = mangle_purgeclass_lh (out, out_len); break; + case 'H': out_len = mangle_purgeclass_uh (out, out_len); break; + case 's': out_len = mangle_purgeclass_s (out, out_len); break; + default : return (RULE_RC_SYNTAX_ERROR); + } + break; + } + out_len = mangle_purgechar (out, out_len, rule_new[rule_pos]); break; @@ -921,7 +1046,9 @@ int run_rule_engine (const int rule_len, const char *rule_buf) if (rule_len == 0) return 0; if (rule_len == 1) + { if (rule_buf[0] == RULE_OP_MANGLE_NOOP) return 0; + } return 1; }