From 30bd857730b0127a9247dfcd13d119c067aa33d7 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Sat, 24 Feb 2024 14:10:59 +1100 Subject: [PATCH 01/61] WIP Module and test --- src/modules/module_90000.c | 196 +++++++++++++++++++++++++++++++++++ tools/test_modules/m90000.pm | 154 +++++++++++++++++++++++++++ 2 files changed, 350 insertions(+) create mode 100644 src/modules/module_90000.c create mode 100644 tools/test_modules/m90000.pm diff --git a/src/modules/module_90000.c b/src/modules/module_90000.c new file mode 100644 index 000000000..c92b15ff1 --- /dev/null +++ b/src/modules/module_90000.c @@ -0,0 +1,196 @@ +/** + * Author......: See docs/credits.txt + * License.....: MIT + */ + +#include "common.h" +#include "types.h" +#include "modules.h" +#include "bitops.h" +#include "convert.h" +#include "shared.h" + +static const u32 ATTACK_EXEC = ATTACK_EXEC_INSIDE_KERNEL; +static const u32 DGST_POS0 = 0; +static const u32 DGST_POS1 = 1; +static const u32 DGST_POS2 = 2; +static const u32 DGST_POS3 = 3; +static const u32 DGST_SIZE = DGST_SIZE_4_2; +static const u32 HASH_CATEGORY = HASH_CATEGORY_RAW_CHECKSUM; +static const char *HASH_NAME = "MurmurHash64A"; +static const u64 KERN_TYPE = 90000; +static const u32 OPTI_TYPE = OPTI_TYPE_ZERO_BYTE; +static const u64 OPTS_TYPE = OPTS_TYPE_STOCK_MODULE + | OPTS_TYPE_PT_GENERATE_LE + | OPTS_TYPE_SUGGEST_KG; +static const u32 SALT_TYPE = SALT_TYPE_EMBEDDED; +static const char *ST_PASS = "hashcat"; +static const char *ST_HASH = "73f8142b4326d36a:0"; + +u32 module_attack_exec (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return ATTACK_EXEC; } +u32 module_dgst_pos0 (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS0; } +u32 module_dgst_pos1 (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS1; } +u32 module_dgst_pos2 (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS2; } +u32 module_dgst_pos3 (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS3; } +u32 module_dgst_size (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_SIZE; } +u32 module_hash_category (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return HASH_CATEGORY; } +const char *module_hash_name (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return HASH_NAME; } +u64 module_kern_type (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return KERN_TYPE; } +u32 module_opti_type (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return OPTI_TYPE; } +u64 module_opts_type (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return OPTS_TYPE; } +u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return SALT_TYPE; } +const char *module_st_hash (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return ST_HASH; } +const char *module_st_pass (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return ST_PASS; } + +u32 module_salt_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) +{ + const u32 salt_max = 4; + + return salt_max; +} + +u32 module_salt_min (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) +{ + const u32 salt_min = 4; + + return salt_min; +} + +int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED void *digest_buf, MAYBE_UNUSED salt_t *salt, MAYBE_UNUSED void *esalt_buf, MAYBE_UNUSED void *hook_salt_buf, MAYBE_UNUSED hashinfo_t *hash_info, const char *line_buf, MAYBE_UNUSED const int line_len) +{ + u32 *digest = (u32 *) digest_buf; + + hc_token_t token; + + memset (&token, 0, sizeof (hc_token_t)); + + token.token_cnt = 2; + + token.sep[0] = hashconfig->separator; + token.len[0] = 16; + token.attr[0] = TOKEN_ATTR_FIXED_LENGTH + | TOKEN_ATTR_VERIFY_HEX; + + token.sep[1] = hashconfig->separator; + token.len[1] = 8; + token.attr[1] = TOKEN_ATTR_FIXED_LENGTH + | TOKEN_ATTR_VERIFY_HEX; + + const int rc_tokenizer = input_tokenizer ((const u8 *) line_buf, line_len, &token); + + if (rc_tokenizer != PARSER_OK) return (rc_tokenizer); + + // digest + + const u8 *hash_pos = token.buf[0]; + + digest[0] = hex_to_u32 (hash_pos + 0); + digest[1] = hex_to_u32 (hash_pos + 8); + digest[2] = 0; + digest[3] = 0; + + digest[0] = byte_swap_32 (digest[0]); + digest[1] = byte_swap_32 (digest[1]); + + // seed + + const u8 *salt_pos = token.buf[1]; + const int salt_len = token.len[1]; + + salt->salt_buf[0] = hex_to_u32 (&salt_pos[0]); + + salt->salt_buf[0] = byte_swap_32 (salt->salt_buf[0]); + + salt->salt_len = salt_len / 2; // 4 + + return (PARSER_OK); +} + +int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const void *digest_buf, MAYBE_UNUSED const salt_t *salt, MAYBE_UNUSED const void *esalt_buf, MAYBE_UNUSED const void *hook_salt_buf, MAYBE_UNUSED const hashinfo_t *hash_info, char *line_buf, MAYBE_UNUSED const int line_size) +{ + const u32 *digest = (const u32 *) digest_buf; + + const int line_len = snprintf (line_buf, line_size, "%016x%c%08x", digest[0], hashconfig->separator, salt->salt_buf[0]); + + return line_len; +} + +void module_init (module_ctx_t *module_ctx) +{ + module_ctx->module_context_size = MODULE_CONTEXT_SIZE_CURRENT; + module_ctx->module_interface_version = MODULE_INTERFACE_VERSION_CURRENT; + + module_ctx->module_attack_exec = module_attack_exec; + module_ctx->module_benchmark_esalt = MODULE_DEFAULT; + module_ctx->module_benchmark_hook_salt = MODULE_DEFAULT; + module_ctx->module_benchmark_mask = MODULE_DEFAULT; + module_ctx->module_benchmark_charset = MODULE_DEFAULT; + module_ctx->module_benchmark_salt = MODULE_DEFAULT; + module_ctx->module_build_plain_postprocess = MODULE_DEFAULT; + module_ctx->module_deep_comp_kernel = MODULE_DEFAULT; + module_ctx->module_deprecated_notice = MODULE_DEFAULT; + module_ctx->module_dgst_pos0 = module_dgst_pos0; + module_ctx->module_dgst_pos1 = module_dgst_pos1; + module_ctx->module_dgst_pos2 = module_dgst_pos2; + module_ctx->module_dgst_pos3 = module_dgst_pos3; + module_ctx->module_dgst_size = module_dgst_size; + module_ctx->module_dictstat_disable = MODULE_DEFAULT; + module_ctx->module_esalt_size = MODULE_DEFAULT; + module_ctx->module_extra_buffer_size = MODULE_DEFAULT; + module_ctx->module_extra_tmp_size = MODULE_DEFAULT; + module_ctx->module_extra_tuningdb_block = MODULE_DEFAULT; + module_ctx->module_forced_outfile_format = MODULE_DEFAULT; + module_ctx->module_hash_binary_count = MODULE_DEFAULT; + module_ctx->module_hash_binary_parse = MODULE_DEFAULT; + module_ctx->module_hash_binary_save = MODULE_DEFAULT; + module_ctx->module_hash_decode_postprocess = MODULE_DEFAULT; + module_ctx->module_hash_decode_potfile = MODULE_DEFAULT; + module_ctx->module_hash_decode_zero_hash = MODULE_DEFAULT; + module_ctx->module_hash_decode = module_hash_decode; + module_ctx->module_hash_encode_status = MODULE_DEFAULT; + module_ctx->module_hash_encode_potfile = MODULE_DEFAULT; + module_ctx->module_hash_encode = module_hash_encode; + module_ctx->module_hash_init_selftest = MODULE_DEFAULT; + module_ctx->module_hash_mode = MODULE_DEFAULT; + module_ctx->module_hash_category = module_hash_category; + module_ctx->module_hash_name = module_hash_name; + module_ctx->module_hashes_count_min = MODULE_DEFAULT; + module_ctx->module_hashes_count_max = MODULE_DEFAULT; + module_ctx->module_hlfmt_disable = MODULE_DEFAULT; + module_ctx->module_hook_extra_param_size = MODULE_DEFAULT; + module_ctx->module_hook_extra_param_init = MODULE_DEFAULT; + module_ctx->module_hook_extra_param_term = MODULE_DEFAULT; + module_ctx->module_hook12 = MODULE_DEFAULT; + module_ctx->module_hook23 = MODULE_DEFAULT; + module_ctx->module_hook_salt_size = MODULE_DEFAULT; + module_ctx->module_hook_size = MODULE_DEFAULT; + module_ctx->module_jit_build_options = MODULE_DEFAULT; + module_ctx->module_jit_cache_disable = MODULE_DEFAULT; + module_ctx->module_kernel_accel_max = MODULE_DEFAULT; + module_ctx->module_kernel_accel_min = MODULE_DEFAULT; + module_ctx->module_kernel_loops_max = MODULE_DEFAULT; + module_ctx->module_kernel_loops_min = MODULE_DEFAULT; + module_ctx->module_kernel_threads_max = MODULE_DEFAULT; + module_ctx->module_kernel_threads_min = MODULE_DEFAULT; + module_ctx->module_kern_type = module_kern_type; + module_ctx->module_kern_type_dynamic = MODULE_DEFAULT; + module_ctx->module_opti_type = module_opti_type; + module_ctx->module_opts_type = module_opts_type; + module_ctx->module_outfile_check_disable = MODULE_DEFAULT; + module_ctx->module_outfile_check_nocomp = MODULE_DEFAULT; + module_ctx->module_potfile_custom_check = MODULE_DEFAULT; + module_ctx->module_potfile_disable = MODULE_DEFAULT; + module_ctx->module_potfile_keep_all_hashes = MODULE_DEFAULT; + module_ctx->module_pwdump_column = MODULE_DEFAULT; + module_ctx->module_pw_max = MODULE_DEFAULT; + module_ctx->module_pw_min = MODULE_DEFAULT; + module_ctx->module_salt_max = module_salt_max; + module_ctx->module_salt_min = module_salt_min; + module_ctx->module_salt_type = module_salt_type; + module_ctx->module_separator = MODULE_DEFAULT; + module_ctx->module_st_hash = module_st_hash; + module_ctx->module_st_pass = module_st_pass; + module_ctx->module_tmp_size = MODULE_DEFAULT; + module_ctx->module_unstable_warning = MODULE_DEFAULT; + module_ctx->module_warmup_disable = MODULE_DEFAULT; +} diff --git a/tools/test_modules/m90000.pm b/tools/test_modules/m90000.pm new file mode 100644 index 000000000..82f686627 --- /dev/null +++ b/tools/test_modules/m90000.pm @@ -0,0 +1,154 @@ +#!/usr/bin/env perl + +## +## Author......: See docs/credits.txt +## License.....: MIT +## + +use strict; +use warnings; + +sub module_constraints { [[0, 256], [8, 8], [0, 63], [8, 8], [-1, -1]] } + +sub wrapping_mul +{ + my $a = shift; + my $b = shift; + + return ($a * $b) % 2**64; +} + +sub murmurhash64a +{ + use integer; + + my $word = shift; + my $seed = shift; + + # https://gitlab.com/lschwiderski/vt2_bundle_unpacker/-/blob/master/src/murmur/murmurhash64.rs + # 'm' and 'r' are mixing constants generated offline. + # They're not really 'magic', they just happen to work well. + + my $m = 0xc6a4a7935bd1e995; + my $r = 47; + + my @chars = unpack ("C*", $word); + my $len = length $word; + + my $hash = $seed ^ wrapping_mul ($len, $m); + + my $endpos = $len - ($len & 7) + my $i; + + for ($i = 0; $i < $endpos; $i += 8) + { + my $c0 = $chars[$i + 0]; + my $c1 = $chars[$i + 1]; + my $c2 = $chars[$i + 2]; + my $c3 = $chars[$i + 3]; + my $c4 = $chars[$i + 4]; + my $c5 = $chars[$i + 5]; + my $c6 = $chars[$i + 6]; + my $c7 = $chars[$i + 7]; + + my $k = ($c0 << 0) + | ($c1 << 8) + | ($c2 << 16) + | ($c3 << 24) + | ($c4 << 32) + | ($c5 << 40) + | ($c6 << 48) + | ($c7 << 56); + + $k = wrapping_mul ($k, $m); + $k ^= $k >> $r; + $k = wrapping_mul ($k, $m); + + $hash ^= $k; + $hash = wrapping_mul ($hash, $m); + } + + my $overflow = $len & 7; + + if ($overflow == 7) + { + $hash ^= $chars[$i + 6] << 48; + } + if ($overflow >= 6) + { + $hash ^= $chars[$i + 5] << 40; + } + if ($overflow >= 5) + { + $hash ^= $chars[$i + 4] << 32; + } + if ($overflow >= 4) + { + $hash ^= $chars[$i + 3] << 24; + } + if ($overflow >= 3) + { + $hash ^= $chars[$i + 2] << 16; + } + if ($overflow >= 2) + { + $hash ^= $chars[$i + 1] << 8; + } + if ($overflow >= 1) + { + $hash ^= $chars[$i + 0] << 0; + } + + if ($overflow > 0) + { + $hash = wrapping_mul ($hash, $m); + } + + $hash ^= $hash >> $r; + $hash = wrapping_mul ($hash, $m); + $hash ^= $hash >> $r; + + return $hash; +} + +sub module_generate_hash +{ + my $word = shift; + my $salt = shift; + + my $salt_bin = pack ("H*", $salt); + + my $seed = unpack ("I>", pack ("H*", $salt_bin)); + + my $digest = murmurhash64a ($word, $seed); + + $digest = unpack ("H*", pack ("Q>", $digest)); + + my $hash = sprintf ("%s:%s", $digest, $seed); + return $hash; +} + +sub module_verify_hash +{ + my $line = shift; + + my ($hash, $seed, $word) = split (':', $line); + + return unless defined $hash; + return unless defined $seed; + return unless defined $word; + + return unless length $hash == 16; + return unless length $salt == 8; + + return unless ($hash =~ m/^[0-9a-fA-F]{8}$/); + return unless ($seed =~ m/^[0-9a-fA-F]{8}$/); + + my $word_packed = pack_if_HEX_notation ($word); + + my $new_hash = module_generate_hash ($word_packed, $seed); + + return ($new_hash, $word); +} + +1; From 7317a6ea9d96848142622092e8bec81977f0d7f8 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Sat, 24 Feb 2024 17:11:27 +1100 Subject: [PATCH 02/61] Change module to DGST_SIZE_4_4 --- src/modules/module_90000.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/modules/module_90000.c b/src/modules/module_90000.c index c92b15ff1..211d8cf4d 100644 --- a/src/modules/module_90000.c +++ b/src/modules/module_90000.c @@ -15,7 +15,7 @@ static const u32 DGST_POS0 = 0; static const u32 DGST_POS1 = 1; static const u32 DGST_POS2 = 2; static const u32 DGST_POS3 = 3; -static const u32 DGST_SIZE = DGST_SIZE_4_2; +static const u32 DGST_SIZE = DGST_SIZE_4_4; static const u32 HASH_CATEGORY = HASH_CATEGORY_RAW_CHECKSUM; static const char *HASH_NAME = "MurmurHash64A"; static const u64 KERN_TYPE = 90000; From e9f16561c2bcf48789e37722bc0d87d8b33141da Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Sat, 24 Feb 2024 17:11:49 +1100 Subject: [PATCH 03/61] WIP a0-optimized kernel --- OpenCL/m90000_a0-optimized .cl | 241 +++++++++++++++++++++++++++++++++ 1 file changed, 241 insertions(+) create mode 100644 OpenCL/m90000_a0-optimized .cl diff --git a/OpenCL/m90000_a0-optimized .cl b/OpenCL/m90000_a0-optimized .cl new file mode 100644 index 000000000..8e71c8c36 --- /dev/null +++ b/OpenCL/m90000_a0-optimized .cl @@ -0,0 +1,241 @@ +/** + * Author......: See docs/credits.txt + * License.....: MIT + */ + +//#define NEW_SIMD_CODE + +#ifdef KERNEL_STATIC +#include M2S(INCLUDE_PATH/inc_vendor.h) +#include M2S(INCLUDE_PATH/inc_types.h) +#include M2S(INCLUDE_PATH/inc_platform.cl) +#include M2S(INCLUDE_PATH/inc_common.cl) +#include M2S(INCLUDE_PATH/inc_rp_optimized.h) +#include M2S(INCLUDE_PATH/inc_rp_optimized.cl) +#include M2S(INCLUDE_PATH/inc_simd.cl) +#endif + +DECLSPEC u64 wrapping_mul (u64 a, u64 b) +{ + return (a * b) % pow(2, 64); +} + +DECLSPEC u64 MurmurHash64A (const u32 seed, PRIVATE_AS const u32 *data, const u32 len) +{ + #define M 0xc6a4a7935bd1e995 + #define R 47 + + u64 hash = seed ^ wrapping_mul(len, M); + + const u32 endpos = len - (len & 7); + + // Loop over blocks of 8 + if (endpos >= 8) + { + for (u32 i = 0; i < endpos; i += 8) + { + u64 k = data[i] + | data[i + 1] << 8 + | data[i + 2] << 16 + | data[i + 3] << 24 + | data[i + 4] << 32 + | data[i + 5] << 40 + | data[i + 6] << 48 + | data[i + 7] << 56; + + k = wrapping_mul(k, M); + k ^= k >> R; + k = wrapping_mul(k, M); + + hash ^= k; + hash = wrapping_mul(hash, M); + } + } + + // Overflow + const u32 overflow = length & 7; + + if (overflow == 7) + { + hash ^= data[i + 6] << 48; + } + if (overflow >= 6) + { + hash ^= data[i + 5] << 40; + } + if (overflow >= 5) + { + hash ^= data[i + 4] << 32; + } + if (overflow >= 4) + { + hash ^= data[i + 3] << 24; + } + if (overflow >= 3) + { + hash ^= data[i + 2] << 16; + } + if (overflow >= 2) + { + hash ^= data[i + 1] << 8; + } + if (overflow >= 1) + { + hash ^= data[i]; + } + if (overflow > 0) + { + hash = wrapping_mul(hash, M); + } + + hash ^= hash >> R; + hash = wrapping_mul(hash, M) + hash ^= hash >> R; + + #undef M + #undef R + + return hash; +} + +KERNEL_FQ void m90000_m04 (KERN_ATTR_RULES ()) +{ + /** + * modifier + */ + + const u64 lid = get_local_id (0); + + /** + * base + */ + + const u64 gid = get_global_id (0); + + if (gid >= GID_CNT) return; + + u32 pw_buf0[4]; + u32 pw_buf1[4]; + + pw_buf0[0] = pws[gid].i[0]; + pw_buf0[1] = pws[gid].i[1]; + pw_buf0[2] = pws[gid].i[2]; + pw_buf0[3] = pws[gid].i[3]; + pw_buf1[0] = pws[gid].i[4]; + pw_buf1[1] = pws[gid].i[5]; + pw_buf1[2] = pws[gid].i[6]; + pw_buf1[3] = pws[gid].i[7]; + + const u32 pw_len = pws[gid].pw_len & 63; + + /** + * seed + */ + + const u32 seed = salt_bufs[SALT_POS_HOST].salt_buf[0]; + + /** + * loop + */ + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) + { + u32x w[16] = { 0 }; + + const u32x out_len = apply_rules_vect_optimized (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w + 0, w + 4); + + u64x hash = MurmurHash64A (seed, w, out_len); + + const u32x r0 = (hash >> 32) & 0xffffffff; + const u32x r1 = (hash) & 0xffffffff; + const u32x r2 = 0; + const u32x r3 = 0; + + COMPARE_M_SIMD (r0, r1, r2, r3); + } +} + +KERNEL_FQ void m90000_m08 (KERN_ATTR_RULES ()) +{ +} + +KERNEL_FQ void m90000_m16 (KERN_ATTR_RULES ()) +{ +} + +KERNEL_FQ void m90000_s04 (KERN_ATTR_RULES ()) +{ + /** + * modifier + */ + + const u64 lid = get_local_id (0); + + /** + * base + */ + + const u64 gid = get_global_id (0); + + if (gid >= GID_CNT) return; + + u32 pw_buf0[4]; + u32 pw_buf1[4]; + + pw_buf0[0] = pws[gid].i[0]; + pw_buf0[1] = pws[gid].i[1]; + pw_buf0[2] = pws[gid].i[2]; + pw_buf0[3] = pws[gid].i[3]; + pw_buf1[0] = pws[gid].i[4]; + pw_buf1[1] = pws[gid].i[5]; + pw_buf1[2] = pws[gid].i[6]; + pw_buf1[3] = pws[gid].i[7]; + + const u32 pw_len = pws[gid].pw_len & 63; + + /** + * digest + */ + + const u32 search[4] = + { + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R0], + 0, + 0, + 0 + }; + + /** + * seed + */ + + const u32 seed = salt_bufs[SALT_POS_HOST].salt_buf[0]; + + /** + * loop + */ + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) + { + u32x w[16] = { 0 }; + + const u32x out_len = apply_rules_vect_optimized (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w + 0, w + 4); + + u32x hash = MurmurHash64A (seed, w, out_len); + + const u32x r0 = (hash >> 32) & 0xffffffff; + const u32x r1 = (hash) & 0xffffffff; + const u32x r2 = 0; + const u32x r3 = 0; + + COMPARE_S_SIMD (r0, r1, r2, r3); + } +} + +KERNEL_FQ void m90000_s08 (KERN_ATTR_RULES ()) +{ +} + +KERNEL_FQ void m90000_s16 (KERN_ATTR_RULES ()) +{ +} From b0cae0634766e21a82f19a81b5dc162c3b0269f4 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Sat, 24 Feb 2024 18:24:15 +1100 Subject: [PATCH 04/61] Update .gitignore to ignore Makefile --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index d8ff600bb..943a2d556 100644 --- a/.gitignore +++ b/.gitignore @@ -24,3 +24,4 @@ obj/*.o obj/*.a include/CL tools/luks_tests +src/Makefile From e68a277e9a5a2fa1dedf06007973a732a9c5c4f2 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Sat, 24 Feb 2024 18:26:43 +1100 Subject: [PATCH 05/61] Makefile debug mode --- src/Makefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Makefile b/src/Makefile index 1cd440645..1737225e5 100644 --- a/src/Makefile +++ b/src/Makefile @@ -4,7 +4,7 @@ ## SHARED ?= 0 -DEBUG := 0 +DEBUG := 1 PRODUCTION := 0 PRODUCTION_VERSION := v6.2.6 ENABLE_CUBIN ?= 1 From 4ab9b3f204f438c5b73b703b25ea3d616a423f25 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Sat, 24 Feb 2024 18:27:20 +1100 Subject: [PATCH 06/61] Fix seed length in ST_HASH --- src/modules/module_90000.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/modules/module_90000.c b/src/modules/module_90000.c index 211d8cf4d..f248b2d1d 100644 --- a/src/modules/module_90000.c +++ b/src/modules/module_90000.c @@ -25,7 +25,7 @@ static const u64 OPTS_TYPE = OPTS_TYPE_STOCK_MODULE | OPTS_TYPE_SUGGEST_KG; static const u32 SALT_TYPE = SALT_TYPE_EMBEDDED; static const char *ST_PASS = "hashcat"; -static const char *ST_HASH = "73f8142b4326d36a:0"; +static const char *ST_HASH = "73f8142b4326d36a:00000000"; u32 module_attack_exec (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return ATTACK_EXEC; } u32 module_dgst_pos0 (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS0; } From 72575c547840cf9cd6f677fad7dbe07dd8e8a457 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Sun, 25 Feb 2024 12:37:59 +1100 Subject: [PATCH 07/61] Fix filename --- OpenCL/{m90000_a0-optimized .cl => m90000_a0-optimized.cl} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename OpenCL/{m90000_a0-optimized .cl => m90000_a0-optimized.cl} (100%) diff --git a/OpenCL/m90000_a0-optimized .cl b/OpenCL/m90000_a0-optimized.cl similarity index 100% rename from OpenCL/m90000_a0-optimized .cl rename to OpenCL/m90000_a0-optimized.cl From e307b2e1e960ab96277a4b2c6d60a00304a0f612 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Fri, 22 Mar 2024 16:44:32 +1100 Subject: [PATCH 08/61] Perl module verify works now --- .gitignore | 2 + OpenCL/m90000_a0-optimized.cl | 29 ++--- OpenCL/m90000_a0-pure.cl | 214 ++++++++++++++++++++++++++++++++++ src/modules/module_90000.c | 7 +- tools/test_modules/m90000.pm | 28 +++-- 5 files changed, 256 insertions(+), 24 deletions(-) create mode 100644 OpenCL/m90000_a0-pure.cl diff --git a/.gitignore b/.gitignore index 943a2d556..287afa9ef 100644 --- a/.gitignore +++ b/.gitignore @@ -25,3 +25,5 @@ obj/*.a include/CL tools/luks_tests src/Makefile +.vscode/ +tools/.venv/ \ No newline at end of file diff --git a/OpenCL/m90000_a0-optimized.cl b/OpenCL/m90000_a0-optimized.cl index 8e71c8c36..fa487504a 100644 --- a/OpenCL/m90000_a0-optimized.cl +++ b/OpenCL/m90000_a0-optimized.cl @@ -15,24 +15,23 @@ #include M2S(INCLUDE_PATH/inc_simd.cl) #endif -DECLSPEC u64 wrapping_mul (u64 a, u64 b) -{ - return (a * b) % pow(2, 64); -} - DECLSPEC u64 MurmurHash64A (const u32 seed, PRIVATE_AS const u32 *data, const u32 len) { #define M 0xc6a4a7935bd1e995 #define R 47 - u64 hash = seed ^ wrapping_mul(len, M); + //if ((gid == 0) && (lid == 0)) printf ("%016x\n", data); + //printf ("%016llx\n", test); + u64 hash = seed ^ (len * M); + const u32 endpos = len - (len & 7); // Loop over blocks of 8 + u32 i = 0; if (endpos >= 8) { - for (u32 i = 0; i < endpos; i += 8) + for (i = 0; i < endpos; i += 8) { u64 k = data[i] | data[i + 1] << 8 @@ -43,17 +42,17 @@ DECLSPEC u64 MurmurHash64A (const u32 seed, PRIVATE_AS const u32 *data, const u3 | data[i + 6] << 48 | data[i + 7] << 56; - k = wrapping_mul(k, M); + k *= M; k ^= k >> R; - k = wrapping_mul(k, M); + k *= M; hash ^= k; - hash = wrapping_mul(hash, M); + hash *= M; } } // Overflow - const u32 overflow = length & 7; + const u32 overflow = len & 7; if (overflow == 7) { @@ -85,11 +84,11 @@ DECLSPEC u64 MurmurHash64A (const u32 seed, PRIVATE_AS const u32 *data, const u3 } if (overflow > 0) { - hash = wrapping_mul(hash, M); + hash *= M; } hash ^= hash >> R; - hash = wrapping_mul(hash, M) + hash *= M; hash ^= hash >> R; #undef M @@ -117,6 +116,8 @@ KERNEL_FQ void m90000_m04 (KERN_ATTR_RULES ()) u32 pw_buf0[4]; u32 pw_buf1[4]; + //if ((gid == 0) && (lid == 0)) printf ("%08x\n", pw_buf0); + pw_buf0[0] = pws[gid].i[0]; pw_buf0[1] = pws[gid].i[1]; pw_buf0[2] = pws[gid].i[2]; @@ -146,6 +147,8 @@ KERNEL_FQ void m90000_m04 (KERN_ATTR_RULES ()) u64x hash = MurmurHash64A (seed, w, out_len); + //if ((gid == 0) && (lid == 0)) printf ("%016llx\n", hash); + const u32x r0 = (hash >> 32) & 0xffffffff; const u32x r1 = (hash) & 0xffffffff; const u32x r2 = 0; diff --git a/OpenCL/m90000_a0-pure.cl b/OpenCL/m90000_a0-pure.cl new file mode 100644 index 000000000..10c69ba03 --- /dev/null +++ b/OpenCL/m90000_a0-pure.cl @@ -0,0 +1,214 @@ +/** + * Author......: See docs/credits.txt + * License.....: MIT + */ + +//#define NEW_SIMD_CODE + +#ifdef KERNEL_STATIC +#include M2S(INCLUDE_PATH/inc_vendor.h) +#include M2S(INCLUDE_PATH/inc_types.h) +#include M2S(INCLUDE_PATH/inc_platform.cl) +#include M2S(INCLUDE_PATH/inc_common.cl) +#include M2S(INCLUDE_PATH/inc_rp.h) +#include M2S(INCLUDE_PATH/inc_rp.cl) +#endif + +DECLSPEC u64 MurmurHash64A (const u32 seed, PRIVATE_AS const u32 *data, const u32 len) +{ + #define M 0xc6a4a7935bd1e995 + #define R 47 + + //if ((gid == 0) && (lid == 0)) printf ("%016x\n", data); + //printf ("%016llx\n", test); + + u64 hash = seed ^ (len * M); + + const u32 endpos = len - (len & 7); + + // Loop over blocks of 8 + u32 i = 0; + if (endpos >= 8) + { + for (i = 0; i < endpos; i += 8) + { + u64 k = data[i] + | data[i + 1] << 8 + | data[i + 2] << 16 + | data[i + 3] << 24 + | data[i + 4] << 32 + | data[i + 5] << 40 + | data[i + 6] << 48 + | data[i + 7] << 56; + + k *= M; + k ^= k >> R; + k *= M; + + hash ^= k; + hash *= M; + } + } + + // Overflow + const u32 overflow = len & 7; + + if (overflow == 7) + { + hash ^= data[i + 6] << 48; + } + if (overflow >= 6) + { + hash ^= data[i + 5] << 40; + } + if (overflow >= 5) + { + hash ^= data[i + 4] << 32; + } + if (overflow >= 4) + { + hash ^= data[i + 3] << 24; + } + if (overflow >= 3) + { + hash ^= data[i + 2] << 16; + } + if (overflow >= 2) + { + hash ^= data[i + 1] << 8; + } + if (overflow >= 1) + { + hash ^= data[i]; + } + if (overflow > 0) + { + hash *= M; + } + + hash ^= hash >> R; + hash *= M; + hash ^= hash >> R; + + #undef M + #undef R + + return hash; +} + +KERNEL_FQ void m90000_mxx (KERN_ATTR_RULES ()) +{ + /** + * modifier + */ + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + + if (gid >= GID_CNT) return; + + /** + * base + */ + + COPY_PW (pws[gid]); + u32 pw_buf0[4]; + u32 pw_buf1[4]; + + //if ((gid == 0) && (lid == 0)) printf ("%08x\n", pw_buf0); + + pw_buf0[0] = pws[gid].i[0]; + pw_buf0[1] = pws[gid].i[1]; + pw_buf0[2] = pws[gid].i[2]; + pw_buf0[3] = pws[gid].i[3]; + pw_buf1[0] = pws[gid].i[4]; + pw_buf1[1] = pws[gid].i[5]; + pw_buf1[2] = pws[gid].i[6]; + pw_buf1[3] = pws[gid].i[7]; + + const u32 pw_len = pws[gid].pw_len & 63; + + /** + * seed + */ + + const u32 seed = salt_bufs[SALT_POS_HOST].salt_buf[0]; + + /** + * loop + */ + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos++) + { + pw_t tmp = PASTE_PW; + + tmp.pw_len = apply_rules (rules_buf[il_pos].cmds, tmp.i, tmp.pw_len); + + u64x hash = MurmurHash64A (seed, tmp, tmp.pw_len); + + //if ((gid == 0) && (lid == 0)) printf ("%016llx\n", hash); + + const u32x r0 = (hash >> 32) & 0xffffffff; + const u32x r1 = (hash) & 0xffffffff; + const u32x r2 = 0; + const u32x r3 = 0; + + COMPARE_M_SIMD (r0, r1, r2, r3); + } +} + +KERNEL_FQ void m90000_sxx (KERN_ATTR_RULES ()) +{ + /** + * modifier + */ + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + + if (gid >= GID_CNT) return; + + /** + * seed + */ + + const u32 seed = salt_bufs[SALT_POS_HOST].salt_buf[0]; + + /** + * digest + */ + + const u32 search[4] = + { + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R0], + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R1], + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R2], + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R3] + }; + + /** + * base + */ + + COPY_PW (pws[gid]); + + /** + * loop + */ + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos++) + { + pw_t tmp = PASTE_PW; + + tmp.pw_len = apply_rules (rules_buf[il_pos].cmds, tmp.i, tmp.pw_len); + + u64x hash = MurmurHash64A (seed, tmp.i, tmp.pw_len); + + const u32 r0 = (hash >> 32) & 0xffffffff; + const u32 r1 = (hash) & 0xffffffff; + const u32 r2 = 0; + const u32 r3 = 0; + + COMPARE_S_SCALAR (r0, r1, r2, r3); + } +} diff --git a/src/modules/module_90000.c b/src/modules/module_90000.c index f248b2d1d..dd23370d9 100644 --- a/src/modules/module_90000.c +++ b/src/modules/module_90000.c @@ -19,7 +19,8 @@ static const u32 DGST_SIZE = DGST_SIZE_4_4; static const u32 HASH_CATEGORY = HASH_CATEGORY_RAW_CHECKSUM; static const char *HASH_NAME = "MurmurHash64A"; static const u64 KERN_TYPE = 90000; -static const u32 OPTI_TYPE = OPTI_TYPE_ZERO_BYTE; +static const u32 OPTI_TYPE = OPTI_TYPE_ZERO_BYTE + | OPTI_TYPE_USES_BITS_64; static const u64 OPTS_TYPE = OPTS_TYPE_STOCK_MODULE | OPTS_TYPE_PT_GENERATE_LE | OPTS_TYPE_SUGGEST_KG; @@ -83,11 +84,13 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE // digest const u8 *hash_pos = token.buf[0]; - + digest[0] = hex_to_u32 (hash_pos + 0); digest[1] = hex_to_u32 (hash_pos + 8); digest[2] = 0; digest[3] = 0; + //printf ("digest[0] = %08x\n", digest[0]); + //printf ("digest[1] = %08x\n", digest[1]); digest[0] = byte_swap_32 (digest[0]); digest[1] = byte_swap_32 (digest[1]); diff --git a/tools/test_modules/m90000.pm b/tools/test_modules/m90000.pm index 82f686627..4ca3803b5 100644 --- a/tools/test_modules/m90000.pm +++ b/tools/test_modules/m90000.pm @@ -7,6 +7,7 @@ use strict; use warnings; +use Math::BigInt; sub module_constraints { [[0, 256], [8, 8], [0, 63], [8, 8], [-1, -1]] } @@ -15,7 +16,10 @@ sub wrapping_mul my $a = shift; my $b = shift; - return ($a * $b) % 2**64; + # 2**64 + my $width = Math::BigInt->new("0x10000000000000000"); + + return ($a * $b)->bmod($width); } sub murmurhash64a @@ -29,7 +33,8 @@ sub murmurhash64a # 'm' and 'r' are mixing constants generated offline. # They're not really 'magic', they just happen to work well. - my $m = 0xc6a4a7935bd1e995; + my $m = Math::BigInt->new("0xc6a4a7935bd1e995"); + #my $m = 0xc6a4a7935bd1e995; my $r = 47; my @chars = unpack ("C*", $word); @@ -37,7 +42,7 @@ sub murmurhash64a my $hash = $seed ^ wrapping_mul ($len, $m); - my $endpos = $len - ($len & 7) + my $endpos = $len - ($len & 7); my $i; for ($i = 0; $i < $endpos; $i += 8) @@ -116,9 +121,13 @@ sub module_generate_hash my $word = shift; my $salt = shift; - my $salt_bin = pack ("H*", $salt); + #say ("%s", $word); + #say ("%0x", $salt); - my $seed = unpack ("I>", pack ("H*", $salt_bin)); + #my $salt_bin = pack ("H*", $salt); + + #my $seed = unpack ("I>", pack ("H*", $salt_bin)); + my $seed = $salt; my $digest = murmurhash64a ($word, $seed); @@ -132,21 +141,22 @@ sub module_verify_hash { my $line = shift; - my ($hash, $seed, $word) = split (':', $line); + my ($hash, $seed, $word) = split (':', $line, 3); return unless defined $hash; return unless defined $seed; return unless defined $word; return unless length $hash == 16; - return unless length $salt == 8; + return unless length $seed == 8; - return unless ($hash =~ m/^[0-9a-fA-F]{8}$/); + return unless ($hash =~ m/^[0-9a-fA-F]{16}$/); return unless ($seed =~ m/^[0-9a-fA-F]{8}$/); my $word_packed = pack_if_HEX_notation ($word); + my $seed_packed = pack_if_HEX_notation ($seed); - my $new_hash = module_generate_hash ($word_packed, $seed); + my $new_hash = module_generate_hash ($word_packed, $seed_packed); return ($new_hash, $word); } From 77c0a9ad331e15e4fe47eed8e196350986390045 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Wed, 23 Oct 2024 22:17:18 +1100 Subject: [PATCH 09/61] Fix perl module to use 16 char salts --- tools/test_modules/m90000.pm | 15 ++++++--------- 1 file changed, 6 insertions(+), 9 deletions(-) diff --git a/tools/test_modules/m90000.pm b/tools/test_modules/m90000.pm index 4ca3803b5..e50b47c1e 100644 --- a/tools/test_modules/m90000.pm +++ b/tools/test_modules/m90000.pm @@ -121,19 +121,16 @@ sub module_generate_hash my $word = shift; my $salt = shift; - #say ("%s", $word); - #say ("%0x", $salt); + my $salt_bin = pack ("H*", $salt); - #my $salt_bin = pack ("H*", $salt); - - #my $seed = unpack ("I>", pack ("H*", $salt_bin)); - my $seed = $salt; + my $seed = unpack ("Q>", $salt_bin); my $digest = murmurhash64a ($word, $seed); $digest = unpack ("H*", pack ("Q>", $digest)); - my $hash = sprintf ("%s:%s", $digest, $seed); + my $hash = sprintf ("%s:%016x", $digest, $seed); + return $hash; } @@ -148,10 +145,10 @@ sub module_verify_hash return unless defined $word; return unless length $hash == 16; - return unless length $seed == 8; + return unless length $seed == 16; return unless ($hash =~ m/^[0-9a-fA-F]{16}$/); - return unless ($seed =~ m/^[0-9a-fA-F]{8}$/); + return unless ($seed =~ m/^[0-9a-fA-F]{16}$/); my $word_packed = pack_if_HEX_notation ($word); my $seed_packed = pack_if_HEX_notation ($seed); From dff52c41afdeaa0475fa6128739e0e628a97a4ee Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Wed, 23 Oct 2024 22:29:30 +1100 Subject: [PATCH 10/61] Adjust perl module constraints --- tools/test_modules/m90000.pm | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tools/test_modules/m90000.pm b/tools/test_modules/m90000.pm index e50b47c1e..ffdafbcad 100644 --- a/tools/test_modules/m90000.pm +++ b/tools/test_modules/m90000.pm @@ -9,7 +9,7 @@ use strict; use warnings; use Math::BigInt; -sub module_constraints { [[0, 256], [8, 8], [0, 63], [8, 8], [-1, -1]] } +sub module_constraints { [[-1, -1], [16, 16], [0, 63], [16, 16], [-1, -1]] } sub wrapping_mul { @@ -130,7 +130,7 @@ sub module_generate_hash $digest = unpack ("H*", pack ("Q>", $digest)); my $hash = sprintf ("%s:%016x", $digest, $seed); - + return $hash; } From e9ef88627c550a2ec812954ee9b87aed0e275f59 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Sat, 26 Oct 2024 12:46:08 +1100 Subject: [PATCH 11/61] a0-pure works! --- OpenCL/m90000_a0-pure.cl | 149 ++++++++++++++++++++++++++----------- src/modules/module_90000.c | 104 ++++++++++++++++++++------ 2 files changed, 187 insertions(+), 66 deletions(-) diff --git a/OpenCL/m90000_a0-pure.cl b/OpenCL/m90000_a0-pure.cl index 10c69ba03..861ccaa3a 100644 --- a/OpenCL/m90000_a0-pure.cl +++ b/OpenCL/m90000_a0-pure.cl @@ -12,34 +12,74 @@ #include M2S(INCLUDE_PATH/inc_common.cl) #include M2S(INCLUDE_PATH/inc_rp.h) #include M2S(INCLUDE_PATH/inc_rp.cl) +#include M2S(INCLUDE_PATH/inc_scalar.cl) #endif -DECLSPEC u64 MurmurHash64A (const u32 seed, PRIVATE_AS const u32 *data, const u32 len) +DECLSPEC u64 Wrapping_Mul (u64 a, u64 b) { - #define M 0xc6a4a7935bd1e995 - #define R 47 + return (a * b); +} - //if ((gid == 0) && (lid == 0)) printf ("%016x\n", data); - //printf ("%016llx\n", test); +DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u32 len) +{ + const u64 M = 0xc6a4a7935bd1e995; + const u64 R = 47; + + //const char* tmp = (const char*) data; + //printf ("%.*s\n", (int) len, tmp); + + //printf ("data = %x\n", data); u64 hash = seed ^ (len * M); + + const u64 INITIAL = hash; const u32 endpos = len - (len & 7); - // Loop over blocks of 8 + const u32 nBlocks = len >> 3; // number of 8 byte blocks + const u8 *data2 = (const u8*) data; + + u64 MIDDLE_OF_BLOCK = 0; + + // Loop over blocks of 8 bytes u32 i = 0; + while (i != endpos) { + u64 k = ((u64) data2[i]) + | ((u64) data2[i + 1] << 8) + | ((u64) data2[i + 2] << 16) + | ((u64) data2[i + 3] << 24) + | ((u64) data2[i + 4] << 32) + | ((u64) data2[i + 5] << 40) + | ((u64) data2[i + 6] << 48) + | ((u64) data2[i + 7] << 56); + + if (i == 0) { + MIDDLE_OF_BLOCK = k; + } + + k *= M; + k ^= k >> R; + k *= M; + + hash ^= k; + hash *= M; + + i += 8; + } + /* + if (endpos >= 8) { for (i = 0; i < endpos; i += 8) { - u64 k = data[i] - | data[i + 1] << 8 - | data[i + 2] << 16 - | data[i + 3] << 24 - | data[i + 4] << 32 - | data[i + 5] << 40 - | data[i + 6] << 48 - | data[i + 7] << 56; + u64 k = data2[i] + | data2[i + 1] << 8 + | data2[i + 2] << 16 + | data2[i + 3] << 24 + | data2[i + 4] << 32 + | data2[i + 5] << 40 + | data2[i + 6] << 48 + | data2[i + 7] << 56; k *= M; k ^= k >> R; @@ -49,47 +89,61 @@ DECLSPEC u64 MurmurHash64A (const u32 seed, PRIVATE_AS const u32 *data, const u3 hash *= M; } } + */ + + // Overflow + + const u64 BEFORE_OVERFLOW = hash; + const u32 overflow = len & 7; if (overflow == 7) { - hash ^= data[i + 6] << 48; + hash ^= ((u64) data2[i + 6] << 48); + //const u64 AFTER_OVERFLOW_7 = hash; } if (overflow >= 6) { - hash ^= data[i + 5] << 40; + hash ^= ((u64) data2[i + 5] << 40); } if (overflow >= 5) { - hash ^= data[i + 4] << 32; + hash ^= ((u64) data2[i + 4] << 32); } if (overflow >= 4) { - hash ^= data[i + 3] << 24; + hash ^= ((u64) data2[i + 3] << 24); } if (overflow >= 3) { - hash ^= data[i + 2] << 16; + hash ^= ((u64) data2[i + 2] << 16); } if (overflow >= 2) { - hash ^= data[i + 1] << 8; + hash ^= ((u64) data2[i + 1] << 8); } if (overflow >= 1) { - hash ^= data[i]; + hash ^= ((u64) data2[i]); } if (overflow > 0) { hash *= M; } + const u64 AFTER_OVERFLOW = hash; + hash ^= hash >> R; hash *= M; hash ^= hash >> R; + const u64 TEST = Wrapping_Mul (0xC6A4A7935BD1E995, 0x773e34d9d52c9ef8); + + //printf("debug: %016lx:%016lx:%c%c%c%c%c%c%c%c%c%c len: %d INITIAL: %016lx MIDDLE_O_BLK: %016lx B4OVERFLOW: %016lx overflow: %d AFTER_OVERFLOW: %016lx TEST:%016lx\n", hash, seed, data2[0], data2[1], data2[2], data2[3], data2[4], data2[5], data2[6], data2[7], data2[8], data2[9], len, INITIAL, MIDDLE_OF_BLOCK, BEFORE_OVERFLOW, overflow, AFTER_OVERFLOW, TEST); + //printf("data2 = %.2s, len = %d\n", data2[0], len); + #undef M #undef R @@ -112,27 +166,28 @@ KERNEL_FQ void m90000_mxx (KERN_ATTR_RULES ()) */ COPY_PW (pws[gid]); - u32 pw_buf0[4]; - u32 pw_buf1[4]; - //if ((gid == 0) && (lid == 0)) printf ("%08x\n", pw_buf0); + //if ((gid == 0) && (lid == 0)) printf ("%016lx\n", pw_buf0); + //printf("Hello world\n"); - pw_buf0[0] = pws[gid].i[0]; - pw_buf0[1] = pws[gid].i[1]; - pw_buf0[2] = pws[gid].i[2]; - pw_buf0[3] = pws[gid].i[3]; - pw_buf1[0] = pws[gid].i[4]; - pw_buf1[1] = pws[gid].i[5]; - pw_buf1[2] = pws[gid].i[6]; - pw_buf1[3] = pws[gid].i[7]; - - const u32 pw_len = pws[gid].pw_len & 63; + // why is this here? + // const u32 pw_len = pws[gid].pw_len & 63; /** * seed */ - const u32 seed = salt_bufs[SALT_POS_HOST].salt_buf[0]; + + const u32 seed_lo = salt_bufs[SALT_POS_HOST].salt_buf[0]; + const u32 seed_hi = salt_bufs[SALT_POS_HOST].salt_buf[1]; + const u64 seed = ((u64) seed_hi << 32) | ((u64) seed_lo); // seems to work? + + //u8 *temp_ref_lo = (u8*) &seed_lo; + //u8 *temp_ref_hi = (u8*) &seed_hi; + //u8 *temp_ref = (u8*) &seed; + //if ((gid == 0) && (lid == 0)) printf ("seed = %02x%02x%02x%02x%02x%02x%02x%02x\n", temp_ref_lo[0], temp_ref_lo[1], temp_ref_lo[2], temp_ref_lo[3], temp_ref_hi[0], temp_ref_hi[1], temp_ref_hi[2], temp_ref_hi[3]); + //if ((gid == 0) && (lid == 0)) printf ("seed = %02x%02x%02x%02x%02x%02x%02x%02x\n", temp_ref_lo[0], temp_ref_lo[1], temp_ref_lo[2], temp_ref_lo[3], temp_ref_lo[4], temp_ref_lo[5], temp_ref_lo[6], temp_ref_lo[7]); + //if ((gid == 0) && (lid == 0)) printf ("seed = %02x%02x%02x%02x%02x%02x%02x%02x\n", temp_ref[0], temp_ref[1], temp_ref[2], temp_ref[3], temp_ref[4], temp_ref[5], temp_ref[6], temp_ref[7]); /** * loop @@ -144,16 +199,21 @@ KERNEL_FQ void m90000_mxx (KERN_ATTR_RULES ()) tmp.pw_len = apply_rules (rules_buf[il_pos].cmds, tmp.i, tmp.pw_len); - u64x hash = MurmurHash64A (seed, tmp, tmp.pw_len); + //if ((gid == 0) && (lid == 0) && (il_pos == 0)) printf ("tmp.i = %08x, tmp.pw_len = %x\n", *tmp.i, tmp.pw_len); - //if ((gid == 0) && (lid == 0)) printf ("%016llx\n", hash); + u64x hash = MurmurHash64A (seed, tmp.i, tmp.pw_len); - const u32x r0 = (hash >> 32) & 0xffffffff; - const u32x r1 = (hash) & 0xffffffff; + //if ((gid == 0) && (lid == 0)) printf ("hash = %lu\n", hash); + + //if (il_pos == 0) printf("tmp.i = %lu, tmp.pw_len = %lu\n", tmp.i, tmp.pw_len); + //if (il_pos == 0) printf("seed = %llu\n", seed); + + const u32x r0 = l32_from_64(hash); + const u32x r1 = h32_from_64(hash); const u32x r2 = 0; const u32x r3 = 0; - COMPARE_M_SIMD (r0, r1, r2, r3); + COMPARE_M_SCALAR (r0, r1, r2, r3); } } @@ -172,7 +232,7 @@ KERNEL_FQ void m90000_sxx (KERN_ATTR_RULES ()) * seed */ - const u32 seed = salt_bufs[SALT_POS_HOST].salt_buf[0]; + const u64 seed = salt_bufs[SALT_POS_HOST].salt_buf[0]; /** * digest @@ -192,6 +252,9 @@ KERNEL_FQ void m90000_sxx (KERN_ATTR_RULES ()) COPY_PW (pws[gid]); + //printf ("%016lx\n", seed); + printf("Hello world\n"); + /** * loop */ @@ -204,8 +267,8 @@ KERNEL_FQ void m90000_sxx (KERN_ATTR_RULES ()) u64x hash = MurmurHash64A (seed, tmp.i, tmp.pw_len); - const u32 r0 = (hash >> 32) & 0xffffffff; - const u32 r1 = (hash) & 0xffffffff; + const u32 r0 = l32_from_64 (hash); + const u32 r1 = h32_from_64 (hash); const u32 r2 = 0; const u32 r3 = 0; diff --git a/src/modules/module_90000.c b/src/modules/module_90000.c index dd23370d9..3d26c083e 100644 --- a/src/modules/module_90000.c +++ b/src/modules/module_90000.c @@ -15,18 +15,18 @@ static const u32 DGST_POS0 = 0; static const u32 DGST_POS1 = 1; static const u32 DGST_POS2 = 2; static const u32 DGST_POS3 = 3; -static const u32 DGST_SIZE = DGST_SIZE_4_4; +static const u32 DGST_SIZE = DGST_SIZE_8_2; static const u32 HASH_CATEGORY = HASH_CATEGORY_RAW_CHECKSUM; static const char *HASH_NAME = "MurmurHash64A"; static const u64 KERN_TYPE = 90000; static const u32 OPTI_TYPE = OPTI_TYPE_ZERO_BYTE | OPTI_TYPE_USES_BITS_64; static const u64 OPTS_TYPE = OPTS_TYPE_STOCK_MODULE - | OPTS_TYPE_PT_GENERATE_LE + | OPTS_TYPE_ST_HEX | OPTS_TYPE_SUGGEST_KG; static const u32 SALT_TYPE = SALT_TYPE_EMBEDDED; static const char *ST_PASS = "hashcat"; -static const char *ST_HASH = "73f8142b4326d36a:00000000"; +static const char *ST_HASH = "ef3014941bf1102d:837163b2348dfae1"; u32 module_attack_exec (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return ATTACK_EXEC; } u32 module_dgst_pos0 (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS0; } @@ -45,21 +45,21 @@ const char *module_st_pass (MAYBE_UNUSED const hashconfig_t *hashconfig, u32 module_salt_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { - const u32 salt_max = 4; + const u32 salt_max = 8; return salt_max; } u32 module_salt_min (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { - const u32 salt_min = 4; + const u32 salt_min = 8; return salt_min; } int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED void *digest_buf, MAYBE_UNUSED salt_t *salt, MAYBE_UNUSED void *esalt_buf, MAYBE_UNUSED void *hook_salt_buf, MAYBE_UNUSED hashinfo_t *hash_info, const char *line_buf, MAYBE_UNUSED const int line_len) { - u32 *digest = (u32 *) digest_buf; + u64 *digest = (u64 *) digest_buf; hc_token_t token; @@ -73,7 +73,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE | TOKEN_ATTR_VERIFY_HEX; token.sep[1] = hashconfig->separator; - token.len[1] = 8; + token.len[1] = 16; token.attr[1] = TOKEN_ATTR_FIXED_LENGTH | TOKEN_ATTR_VERIFY_HEX; @@ -84,38 +84,96 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE // digest const u8 *hash_pos = token.buf[0]; - - digest[0] = hex_to_u32 (hash_pos + 0); - digest[1] = hex_to_u32 (hash_pos + 8); - digest[2] = 0; - digest[3] = 0; - //printf ("digest[0] = %08x\n", digest[0]); - //printf ("digest[1] = %08x\n", digest[1]); + // we have 16 chars (hash hex string, big endian) + /* + printf("hash_pos = "); + for (size_t i = 0; i < 16; ++i) { + printf("%c", hash_pos[i]); + } + printf("\n"); + */ - digest[0] = byte_swap_32 (digest[0]); - digest[1] = byte_swap_32 (digest[1]); + digest[0] = ((hex_to_u64 (&hash_pos[0]))); + + digest[0] = byte_swap_64 (digest[0]); + + // now `digest` contains a proper little endian u64 + /* + u8 *temp_ref = (u8*) &digest[0]; + printf("digest[0] = "); + for (size_t i = 0; i < 8; ++i) { + printf("%02x", temp_ref[i]); + } + printf("\n"); + */ // seed const u8 *salt_pos = token.buf[1]; - const int salt_len = token.len[1]; + // const int salt_len = token.len[1]; - salt->salt_buf[0] = hex_to_u32 (&salt_pos[0]); + // `salt_pos` is an array of 16 chars (salt hex string, big endian) + /* + printf("salt_pos = "); + for (size_t i = 0; i < 16; ++i) { + printf("%c", salt_pos[i]); + } + printf("\n"); + */ - salt->salt_buf[0] = byte_swap_32 (salt->salt_buf[0]); + u64 temp_salt = hex_to_u64 (&salt_pos[0]); // convert hex to u64 + temp_salt = byte_swap_64 (temp_salt); // byte swap - salt->salt_len = salt_len / 2; // 4 + salt->salt_buf[0] = (u32) (temp_salt & 0xffffffff); // lo 32 bits + salt->salt_buf[1] = (u32) (temp_salt >> 32); // hi 32 bits + + salt->salt_len = 8; + // now salt->salt_buf[0] has the first half of a u64 + // and salt->salt_buf[1] has the other half + + /* + u8 *temp_ref = (u8*) salt->salt_buf; + printf("salt->salt_buf[0] = "); + for (size_t i = 0; i < 8; ++i) { + printf("%02x", temp_ref[i]); + } + printf("\n"); + */ return (PARSER_OK); } int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const void *digest_buf, MAYBE_UNUSED const salt_t *salt, MAYBE_UNUSED const void *esalt_buf, MAYBE_UNUSED const void *hook_salt_buf, MAYBE_UNUSED const hashinfo_t *hash_info, char *line_buf, MAYBE_UNUSED const int line_size) { - const u32 *digest = (const u32 *) digest_buf; + const u64 *digest = (const u64 *) digest_buf; - const int line_len = snprintf (line_buf, line_size, "%016x%c%08x", digest[0], hashconfig->separator, salt->salt_buf[0]); + const u64 *salt_b = (const u64 *) salt->salt_buf; - return line_len; + // we can not change anything in the original buffer, otherwise destroying sorting + // therefore create some local buffer + + u8 *out_buf = (u8 *) line_buf; + + int out_len = 0; + + u64_to_hex (byte_swap_64 (digest[0]), out_buf + out_len); out_len += 16; + + out_buf[out_len] = (u8) hashconfig->separator; + + out_len += 1; + + u64_to_hex (byte_swap_64 (salt_b[0]), out_buf + out_len); out_len += 16; + + /* + printf("out_buf = "); + for (int i = 0; i < out_len; ++i) { + printf("%c", out_buf[i]); + } + printf("\n"); + */ + + // len should be 33 (16 + 1 + 16) + return out_len; } void module_init (module_ctx_t *module_ctx) From 08bb0eda6041ed7b6e86500ab47857e58f2b6311 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Sat, 26 Oct 2024 12:46:41 +1100 Subject: [PATCH 12/61] Python file for help with testing --- scratch.py | 164 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 164 insertions(+) create mode 100644 scratch.py diff --git a/scratch.py b/scratch.py new file mode 100644 index 000000000..a706b9539 --- /dev/null +++ b/scratch.py @@ -0,0 +1,164 @@ +""" +Adapted from https://gitlab.com/lschwiderski/vt2_bundle_unpacker +murmur/murmurhash64.rs +https://bitsquid.blogspot.com/2011/08/code-snippet-murmur-hash-inverse-pre.html +This appears to be MurmurHash2 (specifically MurmurHash64A) +""" +global INITIAL +global MIDDLE_OF_BLOCK +global BEFORE_OVERFLOW +global OVERFLOW +global AFTER_OVERFLOW_7 +global AFTER_OVERFLOW + +INITIAL = None +MIDDLE_OF_BLOCK = None +BEFORE_OVERFLOW = None +OVERFLOW = None +AFTER_OVERFLOW_7 = None +AFTER_OVERFLOW = None + + + +# 'M' and 'R' are mixing constants generated offline. +# They're not really 'magic', they just happen to work well. +M: int = 0xC6A4A7935BD1E995 # u64 +# Multiplicative inverse of `M` under % 2^64 +M_INVERSE: int = 0x5F7A0EA7E59B19BD # u64 +R: int = 47 # 47 + + +def wrapping_mul(a, b): + # Returns (a * b) mod 2**N, where N is the width of a and b in bits. + # we're only dealing in u64, so N is always 64? + return (a * b) % 2**64 + + +def hash64(key: list[int], seed: int) -> int: + global INITIAL + global MIDDLE_OF_BLOCK + global BEFORE_OVERFLOW + global OVERFLOW + global AFTER_OVERFLOW_7 + global AFTER_OVERFLOW + length = len(key) + h: int = seed ^ wrapping_mul(length, M) + + INITIAL = h + + endpos = length - (length & 7) + + i = 0 + while i != endpos: + k = key[i] + k |= key[i + 1] << 8 + k |= key[i + 2] << 16 + k |= key[i + 3] << 24 + k |= key[i + 4] << 32 + k |= key[i + 5] << 40 + k |= key[i + 6] << 48 + k |= key[i + 7] << 56 + + if i == 0: + MIDDLE_OF_BLOCK = k + + k = wrapping_mul(k, M) + k ^= k >> R + k = wrapping_mul(k, M) + + h ^= k + h = wrapping_mul(h, M) + + i += 8 + + + BEFORE_OVERFLOW = h + overflow = length & 7 + OVERFLOW = overflow + if overflow == 7: + h ^= key[i + 6] << 48 + AFTER_OVERFLOW_7 = h + if overflow >= 6: + h ^= key[i + 5] << 40 + if overflow >= 5: + h ^= key[i + 4] << 32 + if overflow >= 4: + h ^= key[i + 3] << 24 + if overflow >= 3: + h ^= key[i + 2] << 16 + if overflow >= 2: + h ^= key[i + 1] << 8 + if overflow >= 1: + h ^= key[i] + if overflow > 0: + h = wrapping_mul(h, M) + + AFTER_OVERFLOW = h + + h ^= h >> R + h = wrapping_mul(h, M) + h ^= h >> R + return h + + +# don't need hash_inverse? + + +def hash32(key: list[int], seed: int) -> int: + h = hash64(key, seed) + return h >> 32 + + +def test_hash(): + assert 0 == hash64(bytes("", "UTF-8"), 0) + assert 0xC26E8BC196329B0F == hash64(bytes("", "UTF-8"), 10) + assert 0xA14E8DFA2CD117E2 == hash64(bytes("lua", "UTF-8"), 0) + assert 0x069A33456AAD3042 == hash64(bytes("twitch_intervention", "UTF-8"), 0) + + +# test_hash() + +def get_hash(string: str, seed: int) -> int: + key = [ord(char) for char in string] + return hash64(key, seed) + + + + + + +""" +s = "deadbeef" +s_int = int(s, 16) + +expected_bytes = struct.pack(" Date: Sat, 26 Oct 2024 12:46:51 +1100 Subject: [PATCH 13/61] Remove old optimized kernel --- OpenCL/m90000_a0-optimized.cl | 244 ---------------------------------- 1 file changed, 244 deletions(-) delete mode 100644 OpenCL/m90000_a0-optimized.cl diff --git a/OpenCL/m90000_a0-optimized.cl b/OpenCL/m90000_a0-optimized.cl deleted file mode 100644 index fa487504a..000000000 --- a/OpenCL/m90000_a0-optimized.cl +++ /dev/null @@ -1,244 +0,0 @@ -/** - * Author......: See docs/credits.txt - * License.....: MIT - */ - -//#define NEW_SIMD_CODE - -#ifdef KERNEL_STATIC -#include M2S(INCLUDE_PATH/inc_vendor.h) -#include M2S(INCLUDE_PATH/inc_types.h) -#include M2S(INCLUDE_PATH/inc_platform.cl) -#include M2S(INCLUDE_PATH/inc_common.cl) -#include M2S(INCLUDE_PATH/inc_rp_optimized.h) -#include M2S(INCLUDE_PATH/inc_rp_optimized.cl) -#include M2S(INCLUDE_PATH/inc_simd.cl) -#endif - -DECLSPEC u64 MurmurHash64A (const u32 seed, PRIVATE_AS const u32 *data, const u32 len) -{ - #define M 0xc6a4a7935bd1e995 - #define R 47 - - //if ((gid == 0) && (lid == 0)) printf ("%016x\n", data); - //printf ("%016llx\n", test); - - u64 hash = seed ^ (len * M); - - const u32 endpos = len - (len & 7); - - // Loop over blocks of 8 - u32 i = 0; - if (endpos >= 8) - { - for (i = 0; i < endpos; i += 8) - { - u64 k = data[i] - | data[i + 1] << 8 - | data[i + 2] << 16 - | data[i + 3] << 24 - | data[i + 4] << 32 - | data[i + 5] << 40 - | data[i + 6] << 48 - | data[i + 7] << 56; - - k *= M; - k ^= k >> R; - k *= M; - - hash ^= k; - hash *= M; - } - } - - // Overflow - const u32 overflow = len & 7; - - if (overflow == 7) - { - hash ^= data[i + 6] << 48; - } - if (overflow >= 6) - { - hash ^= data[i + 5] << 40; - } - if (overflow >= 5) - { - hash ^= data[i + 4] << 32; - } - if (overflow >= 4) - { - hash ^= data[i + 3] << 24; - } - if (overflow >= 3) - { - hash ^= data[i + 2] << 16; - } - if (overflow >= 2) - { - hash ^= data[i + 1] << 8; - } - if (overflow >= 1) - { - hash ^= data[i]; - } - if (overflow > 0) - { - hash *= M; - } - - hash ^= hash >> R; - hash *= M; - hash ^= hash >> R; - - #undef M - #undef R - - return hash; -} - -KERNEL_FQ void m90000_m04 (KERN_ATTR_RULES ()) -{ - /** - * modifier - */ - - const u64 lid = get_local_id (0); - - /** - * base - */ - - const u64 gid = get_global_id (0); - - if (gid >= GID_CNT) return; - - u32 pw_buf0[4]; - u32 pw_buf1[4]; - - //if ((gid == 0) && (lid == 0)) printf ("%08x\n", pw_buf0); - - pw_buf0[0] = pws[gid].i[0]; - pw_buf0[1] = pws[gid].i[1]; - pw_buf0[2] = pws[gid].i[2]; - pw_buf0[3] = pws[gid].i[3]; - pw_buf1[0] = pws[gid].i[4]; - pw_buf1[1] = pws[gid].i[5]; - pw_buf1[2] = pws[gid].i[6]; - pw_buf1[3] = pws[gid].i[7]; - - const u32 pw_len = pws[gid].pw_len & 63; - - /** - * seed - */ - - const u32 seed = salt_bufs[SALT_POS_HOST].salt_buf[0]; - - /** - * loop - */ - - for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) - { - u32x w[16] = { 0 }; - - const u32x out_len = apply_rules_vect_optimized (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w + 0, w + 4); - - u64x hash = MurmurHash64A (seed, w, out_len); - - //if ((gid == 0) && (lid == 0)) printf ("%016llx\n", hash); - - const u32x r0 = (hash >> 32) & 0xffffffff; - const u32x r1 = (hash) & 0xffffffff; - const u32x r2 = 0; - const u32x r3 = 0; - - COMPARE_M_SIMD (r0, r1, r2, r3); - } -} - -KERNEL_FQ void m90000_m08 (KERN_ATTR_RULES ()) -{ -} - -KERNEL_FQ void m90000_m16 (KERN_ATTR_RULES ()) -{ -} - -KERNEL_FQ void m90000_s04 (KERN_ATTR_RULES ()) -{ - /** - * modifier - */ - - const u64 lid = get_local_id (0); - - /** - * base - */ - - const u64 gid = get_global_id (0); - - if (gid >= GID_CNT) return; - - u32 pw_buf0[4]; - u32 pw_buf1[4]; - - pw_buf0[0] = pws[gid].i[0]; - pw_buf0[1] = pws[gid].i[1]; - pw_buf0[2] = pws[gid].i[2]; - pw_buf0[3] = pws[gid].i[3]; - pw_buf1[0] = pws[gid].i[4]; - pw_buf1[1] = pws[gid].i[5]; - pw_buf1[2] = pws[gid].i[6]; - pw_buf1[3] = pws[gid].i[7]; - - const u32 pw_len = pws[gid].pw_len & 63; - - /** - * digest - */ - - const u32 search[4] = - { - digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R0], - 0, - 0, - 0 - }; - - /** - * seed - */ - - const u32 seed = salt_bufs[SALT_POS_HOST].salt_buf[0]; - - /** - * loop - */ - - for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) - { - u32x w[16] = { 0 }; - - const u32x out_len = apply_rules_vect_optimized (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w + 0, w + 4); - - u32x hash = MurmurHash64A (seed, w, out_len); - - const u32x r0 = (hash >> 32) & 0xffffffff; - const u32x r1 = (hash) & 0xffffffff; - const u32x r2 = 0; - const u32x r3 = 0; - - COMPARE_S_SIMD (r0, r1, r2, r3); - } -} - -KERNEL_FQ void m90000_s08 (KERN_ATTR_RULES ()) -{ -} - -KERNEL_FQ void m90000_s16 (KERN_ATTR_RULES ()) -{ -} From 8b231c7c1b690bb33a2e82a830dd7a1f19ad05f4 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Sat, 26 Oct 2024 13:32:15 +1100 Subject: [PATCH 14/61] Tidy up and get _sxx working --- OpenCL/m90000_a0-pure.cl | 37 +++++++++++++++++++++---------------- 1 file changed, 21 insertions(+), 16 deletions(-) diff --git a/OpenCL/m90000_a0-pure.cl b/OpenCL/m90000_a0-pure.cl index 861ccaa3a..03cc8a5b3 100644 --- a/OpenCL/m90000_a0-pure.cl +++ b/OpenCL/m90000_a0-pure.cl @@ -157,14 +157,15 @@ KERNEL_FQ void m90000_mxx (KERN_ATTR_RULES ()) */ const u64 lid = get_local_id (0); - const u64 gid = get_global_id (0); - - if (gid >= GID_CNT) return; /** * base */ + const u64 gid = get_global_id (0); + + if (gid >= GID_CNT) return; + COPY_PW (pws[gid]); //if ((gid == 0) && (lid == 0)) printf ("%016lx\n", pw_buf0); @@ -174,10 +175,9 @@ KERNEL_FQ void m90000_mxx (KERN_ATTR_RULES ()) // const u32 pw_len = pws[gid].pw_len & 63; /** - * seed + * salt */ - const u32 seed_lo = salt_bufs[SALT_POS_HOST].salt_buf[0]; const u32 seed_hi = salt_bufs[SALT_POS_HOST].salt_buf[1]; const u64 seed = ((u64) seed_hi << 32) | ((u64) seed_lo); // seems to work? @@ -210,10 +210,9 @@ KERNEL_FQ void m90000_mxx (KERN_ATTR_RULES ()) const u32x r0 = l32_from_64(hash); const u32x r1 = h32_from_64(hash); - const u32x r2 = 0; - const u32x r3 = 0; + const u32x z = 0; - COMPARE_M_SCALAR (r0, r1, r2, r3); + COMPARE_M_SCALAR (r0, r1, z, z); } } @@ -224,15 +223,22 @@ KERNEL_FQ void m90000_sxx (KERN_ATTR_RULES ()) */ const u64 lid = get_local_id (0); + + /** + * base + */ + const u64 gid = get_global_id (0); if (gid >= GID_CNT) return; /** - * seed + * salt */ - const u64 seed = salt_bufs[SALT_POS_HOST].salt_buf[0]; + const u32 seed_lo = salt_bufs[SALT_POS_HOST].salt_buf[0]; + const u32 seed_hi = salt_bufs[SALT_POS_HOST].salt_buf[1]; + const u64 seed = ((u64) seed_hi << 32) | ((u64) seed_lo); /** * digest @@ -242,8 +248,8 @@ KERNEL_FQ void m90000_sxx (KERN_ATTR_RULES ()) { digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R0], digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R1], - digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R2], - digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R3] + 0, + 0 }; /** @@ -253,7 +259,7 @@ KERNEL_FQ void m90000_sxx (KERN_ATTR_RULES ()) COPY_PW (pws[gid]); //printf ("%016lx\n", seed); - printf("Hello world\n"); + //printf("Hello world\n"); /** * loop @@ -269,9 +275,8 @@ KERNEL_FQ void m90000_sxx (KERN_ATTR_RULES ()) const u32 r0 = l32_from_64 (hash); const u32 r1 = h32_from_64 (hash); - const u32 r2 = 0; - const u32 r3 = 0; + const u32x z = 0; - COMPARE_S_SCALAR (r0, r1, r2, r3); + COMPARE_S_SCALAR (r0, r1, z, z); } } From d8818d2cb20ae4279eaf15fac6901f5bd13c9d0e Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Sat, 26 Oct 2024 16:20:08 +1100 Subject: [PATCH 15/61] Extract repeated operations to function --- OpenCL/m90000_a0-pure.cl | 55 +++++++++++++++++++++------------------- 1 file changed, 29 insertions(+), 26 deletions(-) diff --git a/OpenCL/m90000_a0-pure.cl b/OpenCL/m90000_a0-pure.cl index 03cc8a5b3..8f546c2b9 100644 --- a/OpenCL/m90000_a0-pure.cl +++ b/OpenCL/m90000_a0-pure.cl @@ -15,15 +15,36 @@ #include M2S(INCLUDE_PATH/inc_scalar.cl) #endif -DECLSPEC u64 Wrapping_Mul (u64 a, u64 b) -{ - return (a * b); +DECLSPEC u64 MurmurHash64A_round (PRIVATE_AS const u8 *data, u64 hash, const u32 cur_pos) { + #define M 0xc6a4a7935bd1e995 + #define R 47 + + u64 k = ((u64) data[cur_pos]) + | ((u64) data[cur_pos + 1] << 8) + | ((u64) data[cur_pos + 2] << 16) + | ((u64) data[cur_pos + 3] << 24) + | ((u64) data[cur_pos + 4] << 32) + | ((u64) data[cur_pos + 5] << 40) + | ((u64) data[cur_pos + 6] << 48) + | ((u64) data[cur_pos + 7] << 56); + + k *= M; + k ^= k >> R; + k *= M; + + hash ^= k; + hash *= M; + + #undef M + #undef R + + return hash; } DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u32 len) { - const u64 M = 0xc6a4a7935bd1e995; - const u64 R = 47; + #define M 0xc6a4a7935bd1e995 + #define R 47 //const char* tmp = (const char*) data; //printf ("%.*s\n", (int) len, tmp); @@ -44,25 +65,7 @@ DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u3 // Loop over blocks of 8 bytes u32 i = 0; while (i != endpos) { - u64 k = ((u64) data2[i]) - | ((u64) data2[i + 1] << 8) - | ((u64) data2[i + 2] << 16) - | ((u64) data2[i + 3] << 24) - | ((u64) data2[i + 4] << 32) - | ((u64) data2[i + 5] << 40) - | ((u64) data2[i + 6] << 48) - | ((u64) data2[i + 7] << 56); - - if (i == 0) { - MIDDLE_OF_BLOCK = k; - } - - k *= M; - k ^= k >> R; - k *= M; - - hash ^= k; - hash *= M; + hash = MurmurHash64A_round(data2, hash, i); i += 8; } @@ -139,9 +142,9 @@ DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u3 hash *= M; hash ^= hash >> R; - const u64 TEST = Wrapping_Mul (0xC6A4A7935BD1E995, 0x773e34d9d52c9ef8); - //printf("debug: %016lx:%016lx:%c%c%c%c%c%c%c%c%c%c len: %d INITIAL: %016lx MIDDLE_O_BLK: %016lx B4OVERFLOW: %016lx overflow: %d AFTER_OVERFLOW: %016lx TEST:%016lx\n", hash, seed, data2[0], data2[1], data2[2], data2[3], data2[4], data2[5], data2[6], data2[7], data2[8], data2[9], len, INITIAL, MIDDLE_OF_BLOCK, BEFORE_OVERFLOW, overflow, AFTER_OVERFLOW, TEST); + + //printf("debug: %016lx:%016lx:%c%c%c%c%c%c%c%c%c%c len: %d INITIAL: %016lx MIDDLE_O_BLK: %016lx B4OVERFLOW: %016lx overflow: %d AFTER_OVERFLOW: %016lx\n", hash, seed, data2[0], data2[1], data2[2], data2[3], data2[4], data2[5], data2[6], data2[7], data2[8], data2[9], len, INITIAL, MIDDLE_OF_BLOCK, BEFORE_OVERFLOW, overflow, AFTER_OVERFLOW); //printf("data2 = %.2s, len = %d\n", data2[0], len); #undef M From b0b33d2aa35658e2b5694f81068edb72ec0e60aa Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Sat, 26 Oct 2024 16:20:19 +1100 Subject: [PATCH 16/61] a1-pure WIP --- OpenCL/m90000_a1-pure.cl | 238 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 238 insertions(+) create mode 100644 OpenCL/m90000_a1-pure.cl diff --git a/OpenCL/m90000_a1-pure.cl b/OpenCL/m90000_a1-pure.cl new file mode 100644 index 000000000..0a0c85cbd --- /dev/null +++ b/OpenCL/m90000_a1-pure.cl @@ -0,0 +1,238 @@ +/** + * Author......: See docs/credits.txt + * License.....: MIT + */ + +//#define NEW_SIMD_CODE + +#ifdef KERNEL_STATIC +#include M2S(INCLUDE_PATH/inc_vendor.h) +#include M2S(INCLUDE_PATH/inc_types.h) +#include M2S(INCLUDE_PATH/inc_platform.cl) +#include M2S(INCLUDE_PATH/inc_common.cl) +#include M2S(INCLUDE_PATH/inc_scalar.cl) +#endif + +DECLSPEC u64 MurmurHash64A_round_g (GLOBAL_AS const u8 *data, u64 hash, const u32 cur_pos) { + #define M 0xc6a4a7935bd1e995 + #define R 47 + + u64 k = ((u64) data[cur_pos]) + | ((u64) data[cur_pos + 1] << 8) + | ((u64) data[cur_pos + 2] << 16) + | ((u64) data[cur_pos + 3] << 24) + | ((u64) data[cur_pos + 4] << 32) + | ((u64) data[cur_pos + 5] << 40) + | ((u64) data[cur_pos + 6] << 48) + | ((u64) data[cur_pos + 7] << 56); + + k *= M; + k ^= k >> R; + k *= M; + + hash ^= k; + hash *= M; + + #undef M + #undef R + + return hash; +} + +DECLSPEC u64 MurmurHash64A_g (const u64 seed, GLOBAL_AS const u32 *data, const u32 len, GLOBAL_AS const u32 *comb_data, const u32 comb_len) +{ + #define M 0xc6a4a7935bd1e995 + #define R 47 + + //const char* tmp = (const char*) data; + //printf ("%.*s\n", (int) len, tmp); + + //printf ("data = %x\n", data); + + u64 hash = seed ^ (len * M); + + const u64 INITIAL = hash; + + const u32 endpos = len - (len & 7); + + const u32 nBlocks = len >> 3; // number of 8 byte blocks + GLOBAL_AS u8 *data2 = (GLOBAL_AS u8*) data; + + // Loop over blocks of 8 bytes + u32 i = 0; + while (i != endpos) { + hash = MurmurHash64A_round_g(data2, hash, i); + + i += 8; + } + + // Overflow + + const u64 BEFORE_OVERFLOW = hash; + + const u32 overflow = len & 7; + + if (overflow == 7) + { + hash ^= ((u64) data2[i + 6] << 48); + //const u64 AFTER_OVERFLOW_7 = hash; + } + if (overflow >= 6) + { + hash ^= ((u64) data2[i + 5] << 40); + } + if (overflow >= 5) + { + hash ^= ((u64) data2[i + 4] << 32); + } + if (overflow >= 4) + { + hash ^= ((u64) data2[i + 3] << 24); + } + if (overflow >= 3) + { + hash ^= ((u64) data2[i + 2] << 16); + } + if (overflow >= 2) + { + hash ^= ((u64) data2[i + 1] << 8); + } + if (overflow >= 1) + { + hash ^= ((u64) data2[i]); + } + if (overflow > 0) + { + hash *= M; + } + + const u64 AFTER_OVERFLOW = hash; + + hash ^= hash >> R; + hash *= M; + hash ^= hash >> R; + + + + printf("d: %016lx:%016lx: %08x %08x %08x %08x %08x len: %d INITIAL: %016lx B4OVERFLOW: %016lx overflow: %d AFTER_OVERFLOW: %016lx\n", hash, seed, data[0], data[1], data[2], data[3], data[4], len, INITIAL, BEFORE_OVERFLOW, overflow, AFTER_OVERFLOW); + //printf("data2 = %.2s, len = %d\n", data2[0], len); + + #undef M + #undef R + + return hash; +} + +KERNEL_FQ void m90000_mxx (KERN_ATTR_BASIC ()) +{ + /** + * modifier + */ + + const u64 lid = get_local_id (0); + + /** + * base + */ + + const u64 gid = get_global_id (0); + + if (gid >= GID_CNT) return; + + //if ((gid == 0) && (lid == 0)) printf ("%016lx\n", pw_buf0); + //printf("Hello world\n"); + + // why is this here? + // const u32 pw_len = pws[gid].pw_len & 63; + + /** + * salt + */ + + + const u32 seed_lo = salt_bufs[SALT_POS_HOST].salt_buf[0]; + const u32 seed_hi = salt_bufs[SALT_POS_HOST].salt_buf[1]; + const u64 seed = ((u64) seed_hi << 32) | ((u64) seed_lo); // seems to work? + + //u8 *temp_ref_lo = (u8*) &seed_lo; + //u8 *temp_ref_hi = (u8*) &seed_hi; + //u8 *temp_ref = (u8*) &seed; + //if ((gid == 0) && (lid == 0)) printf ("seed = %02x%02x%02x%02x%02x%02x%02x%02x\n", temp_ref_lo[0], temp_ref_lo[1], temp_ref_lo[2], temp_ref_lo[3], temp_ref_hi[0], temp_ref_hi[1], temp_ref_hi[2], temp_ref_hi[3]); + //if ((gid == 0) && (lid == 0)) printf ("seed = %02x%02x%02x%02x%02x%02x%02x%02x\n", temp_ref_lo[0], temp_ref_lo[1], temp_ref_lo[2], temp_ref_lo[3], temp_ref_lo[4], temp_ref_lo[5], temp_ref_lo[6], temp_ref_lo[7]); + //if ((gid == 0) && (lid == 0)) printf ("seed = %02x%02x%02x%02x%02x%02x%02x%02x\n", temp_ref[0], temp_ref[1], temp_ref[2], temp_ref[3], temp_ref[4], temp_ref[5], temp_ref[6], temp_ref[7]); + + /** + * loop + */ + + //printf("Running a1 m90000_mxx\n"); + + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos++) + { + //const u32 tmp_buf = combs_buf[il_pos].i; + //if ((gid == 0) && (lid == 0)) printf ("combs_buf[il_pos].i = %08x\n", tmp_buf); + + u64x hash = MurmurHash64A_g (seed, pws[gid].i, pws[gid].pw_len, combs_buf[il_pos].i, combs_buf[il_pos].pw_len); + + const u32x r0 = l32_from_64(hash); + const u32x r1 = h32_from_64(hash); + const u32x z = 0; + + COMPARE_M_SCALAR (r0, r1, z, z); + } +} + +KERNEL_FQ void m90000_sxx (KERN_ATTR_BASIC ()) +{ + /** + * modifier + */ + + const u64 lid = get_local_id (0); + + /** + * base + */ + + const u64 gid = get_global_id (0); + + if (gid >= GID_CNT) return; + + /** + * salt + */ + + const u32 seed_lo = salt_bufs[SALT_POS_HOST].salt_buf[0]; + const u32 seed_hi = salt_bufs[SALT_POS_HOST].salt_buf[1]; + const u64 seed = ((u64) seed_hi << 32) | ((u64) seed_lo); + + /** + * digest + */ + + const u32 search[4] = + { + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R0], + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R1], + 0, + 0 + }; + + /** + * loop + */ + + printf("Running a1 m90000_sxx\n"); + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos++) + { + u64x hash = MurmurHash64A_g (seed, pws[gid].i, pws[gid].pw_len, combs_buf[il_pos].i, combs_buf[il_pos].pw_len); + + const u32 r0 = l32_from_64 (hash); + const u32 r1 = h32_from_64 (hash); + const u32x z = 0; + + COMPARE_S_SCALAR (r0, r1, z, z); + } +} From deaf984d231af5ab862adf6d6eae83a68d777d66 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Sat, 26 Oct 2024 17:15:58 +1100 Subject: [PATCH 17/61] Extract overflow and final parts to function --- OpenCL/m90000_a0-pure.cl | 129 ++++++++++++++++----------------------- 1 file changed, 54 insertions(+), 75 deletions(-) diff --git a/OpenCL/m90000_a0-pure.cl b/OpenCL/m90000_a0-pure.cl index 8f546c2b9..7c4034511 100644 --- a/OpenCL/m90000_a0-pure.cl +++ b/OpenCL/m90000_a0-pure.cl @@ -41,16 +41,61 @@ DECLSPEC u64 MurmurHash64A_round (PRIVATE_AS const u8 *data, u64 hash, const u32 return hash; } +DECLSPEC u64 MurmurHash64A_final (PRIVATE_AS const u8 *data, u64 hash, const u32 cur_pos, const u32 len) { + #define M 0xc6a4a7935bd1e995 + #define R 47 + + const u32 overflow = len & 7; + + if (overflow == 7) + { + hash ^= ((u64) data[cur_pos + 6] << 48); + } + if (overflow >= 6) + { + hash ^= ((u64) data[cur_pos + 5] << 40); + } + if (overflow >= 5) + { + hash ^= ((u64) data[cur_pos + 4] << 32); + } + if (overflow >= 4) + { + hash ^= ((u64) data[cur_pos + 3] << 24); + } + if (overflow >= 3) + { + hash ^= ((u64) data[cur_pos + 2] << 16); + } + if (overflow >= 2) + { + hash ^= ((u64) data[cur_pos + 1] << 8); + } + if (overflow >= 1) + { + hash ^= ((u64) data[cur_pos]); + } + if (overflow > 0) + { + hash *= M; + } + + hash ^= hash >> R; + hash *= M; + hash ^= hash >> R; + + #undef M + #undef R + + return hash; +} + DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u32 len) { #define M 0xc6a4a7935bd1e995 #define R 47 - //const char* tmp = (const char*) data; - //printf ("%.*s\n", (int) len, tmp); - - //printf ("data = %x\n", data); - + //Initialize hash u64 hash = seed ^ (len * M); const u64 INITIAL = hash; @@ -69,82 +114,16 @@ DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u3 i += 8; } - /* - - if (endpos >= 8) - { - for (i = 0; i < endpos; i += 8) - { - u64 k = data2[i] - | data2[i + 1] << 8 - | data2[i + 2] << 16 - | data2[i + 3] << 24 - | data2[i + 4] << 32 - | data2[i + 5] << 40 - | data2[i + 6] << 48 - | data2[i + 7] << 56; - - k *= M; - k ^= k >> R; - k *= M; - - hash ^= k; - hash *= M; - } - } - */ - - // Overflow - const u64 BEFORE_OVERFLOW = hash; + const u64 BEFORE_FINAL = hash; - const u32 overflow = len & 7; + hash = MurmurHash64A_final (data2, hash, i, len); - if (overflow == 7) - { - hash ^= ((u64) data2[i + 6] << 48); - //const u64 AFTER_OVERFLOW_7 = hash; - } - if (overflow >= 6) - { - hash ^= ((u64) data2[i + 5] << 40); - } - if (overflow >= 5) - { - hash ^= ((u64) data2[i + 4] << 32); - } - if (overflow >= 4) - { - hash ^= ((u64) data2[i + 3] << 24); - } - if (overflow >= 3) - { - hash ^= ((u64) data2[i + 2] << 16); - } - if (overflow >= 2) - { - hash ^= ((u64) data2[i + 1] << 8); - } - if (overflow >= 1) - { - hash ^= ((u64) data2[i]); - } - if (overflow > 0) - { - hash *= M; - } + const u64 AFTER_FINAL = hash; - const u64 AFTER_OVERFLOW = hash; - - hash ^= hash >> R; - hash *= M; - hash ^= hash >> R; - - - - //printf("debug: %016lx:%016lx:%c%c%c%c%c%c%c%c%c%c len: %d INITIAL: %016lx MIDDLE_O_BLK: %016lx B4OVERFLOW: %016lx overflow: %d AFTER_OVERFLOW: %016lx\n", hash, seed, data2[0], data2[1], data2[2], data2[3], data2[4], data2[5], data2[6], data2[7], data2[8], data2[9], len, INITIAL, MIDDLE_OF_BLOCK, BEFORE_OVERFLOW, overflow, AFTER_OVERFLOW); + //printf("debug: %016lx:%016lx:%c%c%c%c%c%c%c%c%c%c len: %d INITIAL: %016lx MIDDLE_O_BLK: %016lx B4FINAL: %016lx overflow: %d AFTER_FINAL: %016lx\n", hash, seed, data2[0], data2[1], data2[2], data2[3], data2[4], data2[5], data2[6], data2[7], data2[8], data2[9], len, INITIAL, MIDDLE_OF_BLOCK, BEFORE_FINAL, overflow, AFTER_FINAL); //printf("data2 = %.2s, len = %d\n", data2[0], len); #undef M From de90e37d76fbc1ac857e265f58a57121710c1b67 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Mon, 28 Oct 2024 12:34:39 +1100 Subject: [PATCH 18/61] Replace overflow if statements with switch statement --- OpenCL/m90000_a0-pure.cl | 48 +++++++++++----------------------------- 1 file changed, 13 insertions(+), 35 deletions(-) diff --git a/OpenCL/m90000_a0-pure.cl b/OpenCL/m90000_a0-pure.cl index 7c4034511..f689582e6 100644 --- a/OpenCL/m90000_a0-pure.cl +++ b/OpenCL/m90000_a0-pure.cl @@ -47,36 +47,14 @@ DECLSPEC u64 MurmurHash64A_final (PRIVATE_AS const u8 *data, u64 hash, const u32 const u32 overflow = len & 7; - if (overflow == 7) - { - hash ^= ((u64) data[cur_pos + 6] << 48); - } - if (overflow >= 6) - { - hash ^= ((u64) data[cur_pos + 5] << 40); - } - if (overflow >= 5) - { - hash ^= ((u64) data[cur_pos + 4] << 32); - } - if (overflow >= 4) - { - hash ^= ((u64) data[cur_pos + 3] << 24); - } - if (overflow >= 3) - { - hash ^= ((u64) data[cur_pos + 2] << 16); - } - if (overflow >= 2) - { - hash ^= ((u64) data[cur_pos + 1] << 8); - } - if (overflow >= 1) - { - hash ^= ((u64) data[cur_pos]); - } - if (overflow > 0) - { + switch (overflow) { + case 7: hash ^= ((u64) data[cur_pos + 6]) << 48; + case 6: hash ^= ((u64) data[cur_pos + 5]) << 40; + case 5: hash ^= ((u64) data[cur_pos + 4]) << 32; + case 4: hash ^= ((u64) data[cur_pos + 3]) << 24; + case 3: hash ^= ((u64) data[cur_pos + 2]) << 16; + case 2: hash ^= ((u64) data[cur_pos + 1]) << 8; + case 1: hash ^= ((u64) data[cur_pos]); hash *= M; } @@ -98,14 +76,14 @@ DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u3 //Initialize hash u64 hash = seed ^ (len * M); - const u64 INITIAL = hash; + //const u64 INITIAL = hash; const u32 endpos = len - (len & 7); - const u32 nBlocks = len >> 3; // number of 8 byte blocks + //const u32 nBlocks = len >> 3; // number of 8 byte blocks const u8 *data2 = (const u8*) data; - u64 MIDDLE_OF_BLOCK = 0; + //u64 MIDDLE_OF_BLOCK = 0; // Loop over blocks of 8 bytes u32 i = 0; @@ -117,11 +95,11 @@ DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u3 // Overflow - const u64 BEFORE_FINAL = hash; + //const u64 BEFORE_FINAL = hash; hash = MurmurHash64A_final (data2, hash, i, len); - const u64 AFTER_FINAL = hash; + //const u64 AFTER_FINAL = hash; //printf("debug: %016lx:%016lx:%c%c%c%c%c%c%c%c%c%c len: %d INITIAL: %016lx MIDDLE_O_BLK: %016lx B4FINAL: %016lx overflow: %d AFTER_FINAL: %016lx\n", hash, seed, data2[0], data2[1], data2[2], data2[3], data2[4], data2[5], data2[6], data2[7], data2[8], data2[9], len, INITIAL, MIDDLE_OF_BLOCK, BEFORE_FINAL, overflow, AFTER_FINAL); //printf("data2 = %.2s, len = %d\n", data2[0], len); From c1413e1f696154755583f3ea854bf2232bcb4efe Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Mon, 28 Oct 2024 12:35:03 +1100 Subject: [PATCH 19/61] a1-pure WIP --- OpenCL/m90000_a1-pure.cl | 114 ++++++++++++++++++++------------------- 1 file changed, 60 insertions(+), 54 deletions(-) diff --git a/OpenCL/m90000_a1-pure.cl b/OpenCL/m90000_a1-pure.cl index 0a0c85cbd..9f2387725 100644 --- a/OpenCL/m90000_a1-pure.cl +++ b/OpenCL/m90000_a1-pure.cl @@ -39,24 +39,69 @@ DECLSPEC u64 MurmurHash64A_round_g (GLOBAL_AS const u8 *data, u64 hash, const u3 return hash; } -DECLSPEC u64 MurmurHash64A_g (const u64 seed, GLOBAL_AS const u32 *data, const u32 len, GLOBAL_AS const u32 *comb_data, const u32 comb_len) +DECLSPEC u64 MurmurHash64A_final_g (GLOBAL_AS const u8 *data, u64 hash, const u32 cur_pos, const u32 len) { + #define M 0xc6a4a7935bd1e995 + #define R 47 + + const u32 overflow = len & 7; + + if (overflow == 7) + { + hash ^= ((u64) data[cur_pos + 6] << 48); + } + if (overflow >= 6) + { + hash ^= ((u64) data[cur_pos + 5] << 40); + } + if (overflow >= 5) + { + hash ^= ((u64) data[cur_pos + 4] << 32); + } + if (overflow >= 4) + { + hash ^= ((u64) data[cur_pos + 3] << 24); + } + if (overflow >= 3) + { + hash ^= ((u64) data[cur_pos + 2] << 16); + } + if (overflow >= 2) + { + hash ^= ((u64) data[cur_pos + 1] << 8); + } + if (overflow >= 1) + { + hash ^= ((u64) data[cur_pos]); + } + if (overflow > 0) + { + hash *= M; + } + + hash ^= hash >> R; + hash *= M; + hash ^= hash >> R; + + #undef M + #undef R + + return hash; +} + +DECLSPEC u64 MurmurHash64A_g (const u64 seed, GLOBAL_AS const u32 *data, const u32 len) { #define M 0xc6a4a7935bd1e995 #define R 47 - //const char* tmp = (const char*) data; - //printf ("%.*s\n", (int) len, tmp); - - //printf ("data = %x\n", data); - + //Initialize hash u64 hash = seed ^ (len * M); const u64 INITIAL = hash; const u32 endpos = len - (len & 7); - const u32 nBlocks = len >> 3; // number of 8 byte blocks - GLOBAL_AS u8 *data2 = (GLOBAL_AS u8*) data; + //const u32 nBlocks = len >> 3; // number of 8 byte blocks + GLOBAL_AS const u8 *data2 = (GLOBAL_AS const u8*) data; // Loop over blocks of 8 bytes u32 i = 0; @@ -68,53 +113,13 @@ DECLSPEC u64 MurmurHash64A_g (const u64 seed, GLOBAL_AS const u32 *data, const u // Overflow - const u64 BEFORE_OVERFLOW = hash; + const u64 BEFORE_FINAL = hash; - const u32 overflow = len & 7; + hash = MurmurHash64A_final_g (data2, hash, i, len); - if (overflow == 7) - { - hash ^= ((u64) data2[i + 6] << 48); - //const u64 AFTER_OVERFLOW_7 = hash; - } - if (overflow >= 6) - { - hash ^= ((u64) data2[i + 5] << 40); - } - if (overflow >= 5) - { - hash ^= ((u64) data2[i + 4] << 32); - } - if (overflow >= 4) - { - hash ^= ((u64) data2[i + 3] << 24); - } - if (overflow >= 3) - { - hash ^= ((u64) data2[i + 2] << 16); - } - if (overflow >= 2) - { - hash ^= ((u64) data2[i + 1] << 8); - } - if (overflow >= 1) - { - hash ^= ((u64) data2[i]); - } - if (overflow > 0) - { - hash *= M; - } + const u64 AFTER_FINAL = hash; - const u64 AFTER_OVERFLOW = hash; - - hash ^= hash >> R; - hash *= M; - hash ^= hash >> R; - - - - printf("d: %016lx:%016lx: %08x %08x %08x %08x %08x len: %d INITIAL: %016lx B4OVERFLOW: %016lx overflow: %d AFTER_OVERFLOW: %016lx\n", hash, seed, data[0], data[1], data[2], data[3], data[4], len, INITIAL, BEFORE_OVERFLOW, overflow, AFTER_OVERFLOW); + printf("debug: %016lx:%016lx:%c%c%c%c%c%c%c%c%c%c len: %d INITIAL: %016lx B4FINAL: %016lx AFTER_FINAL: %016lx\n", hash, seed, data2[0], data2[1], data2[2], data2[3], data2[4], data2[5], data2[6], data2[7], data2[8], data2[9], len, INITIAL, BEFORE_FINAL, AFTER_FINAL); //printf("data2 = %.2s, len = %d\n", data2[0], len); #undef M @@ -173,7 +178,8 @@ KERNEL_FQ void m90000_mxx (KERN_ATTR_BASIC ()) //const u32 tmp_buf = combs_buf[il_pos].i; //if ((gid == 0) && (lid == 0)) printf ("combs_buf[il_pos].i = %08x\n", tmp_buf); - u64x hash = MurmurHash64A_g (seed, pws[gid].i, pws[gid].pw_len, combs_buf[il_pos].i, combs_buf[il_pos].pw_len); + //u64x hash = MurmurHash64A_g (seed, pws[gid].i, pws[gid].pw_len, combs_buf[il_pos].i, combs_buf[il_pos].pw_len); + u64x hash = MurmurHash64A_g (seed, combs_buf[il_pos].i, combs_buf[il_pos].pw_len); const u32x r0 = l32_from_64(hash); const u32x r1 = h32_from_64(hash); @@ -227,7 +233,7 @@ KERNEL_FQ void m90000_sxx (KERN_ATTR_BASIC ()) for (u32 il_pos = 0; il_pos < IL_CNT; il_pos++) { - u64x hash = MurmurHash64A_g (seed, pws[gid].i, pws[gid].pw_len, combs_buf[il_pos].i, combs_buf[il_pos].pw_len); + u64x hash = MurmurHash64A_g (seed, combs_buf[il_pos].i, combs_buf[il_pos].pw_len); const u32 r0 = l32_from_64 (hash); const u32 r1 = h32_from_64 (hash); From 5a92c70b33c678aadd9c768c1b73887e5441bc89 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Mon, 28 Oct 2024 12:35:14 +1100 Subject: [PATCH 20/61] Update helper script --- scratch.py | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-) diff --git a/scratch.py b/scratch.py index a706b9539..4b22935ab 100644 --- a/scratch.py +++ b/scratch.py @@ -142,8 +142,8 @@ print(result_int) -data = "root_point" -seed = 0xfeebdaeddeadbeef +data = "bardin_complete_all_levels_desc" +seed = 0x0 # s = bytes.fromhex(data)[::-1].decode("utf-8") @@ -161,4 +161,15 @@ s = bytes.fromhex(data).decode("utf-8") print(s) """ -# print(f"{wrapping_mul(0xC6A4A7935BD1E995, 0x773e34d9d52c9ef8):016x}") \ No newline at end of file +# print(f"{wrapping_mul(0xC6A4A7935BD1E995, 0x773e34d9d52c9ef8):016x}") + +reverse = "69686361 6d657665 5f746e65 6c6c6f68 00005f79" +r_s = reverse.split(" ") +r_s = [bytearray.fromhex(s) for s in r_s] +for x in r_s: + x.reverse() +fnl = bytearray() +for x in r_s: + fnl += x + +print(fnl.decode("utf-8")) From 57e20fca6206c4946d107ec411d121b4ca463824 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Mon, 28 Oct 2024 13:18:05 +1100 Subject: [PATCH 21/61] Change u32x to u32 in _sxx --- OpenCL/m90000_a0-pure.cl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/OpenCL/m90000_a0-pure.cl b/OpenCL/m90000_a0-pure.cl index f689582e6..005a79f0a 100644 --- a/OpenCL/m90000_a0-pure.cl +++ b/OpenCL/m90000_a0-pure.cl @@ -235,7 +235,7 @@ KERNEL_FQ void m90000_sxx (KERN_ATTR_RULES ()) const u32 r0 = l32_from_64 (hash); const u32 r1 = h32_from_64 (hash); - const u32x z = 0; + const u32 z = 0; COMPARE_S_SCALAR (r0, r1, z, z); } From 23559a45c1c8e19a04db9b483cd581a61b23db51 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Mon, 28 Oct 2024 13:23:05 +1100 Subject: [PATCH 22/61] Copy left and right buffers into shared buffer (probably bad performance) --- OpenCL/m90000_a1-pure.cl | 50 +++++++++++++++++++++++++++++++++------- 1 file changed, 42 insertions(+), 8 deletions(-) diff --git a/OpenCL/m90000_a1-pure.cl b/OpenCL/m90000_a1-pure.cl index 9f2387725..d5210d52c 100644 --- a/OpenCL/m90000_a1-pure.cl +++ b/OpenCL/m90000_a1-pure.cl @@ -13,7 +13,7 @@ #include M2S(INCLUDE_PATH/inc_scalar.cl) #endif -DECLSPEC u64 MurmurHash64A_round_g (GLOBAL_AS const u8 *data, u64 hash, const u32 cur_pos) { +DECLSPEC u64 MurmurHash64A_round_g (const u8 *data, u64 hash, const u32 cur_pos) { #define M 0xc6a4a7935bd1e995 #define R 47 @@ -39,7 +39,7 @@ DECLSPEC u64 MurmurHash64A_round_g (GLOBAL_AS const u8 *data, u64 hash, const u3 return hash; } -DECLSPEC u64 MurmurHash64A_final_g (GLOBAL_AS const u8 *data, u64 hash, const u32 cur_pos, const u32 len) { +DECLSPEC u64 MurmurHash64A_final_g (const u8 *data, u64 hash, const u32 cur_pos, const u32 len) { #define M 0xc6a4a7935bd1e995 #define R 47 @@ -88,7 +88,7 @@ DECLSPEC u64 MurmurHash64A_final_g (GLOBAL_AS const u8 *data, u64 hash, const u3 return hash; } -DECLSPEC u64 MurmurHash64A_g (const u64 seed, GLOBAL_AS const u32 *data, const u32 len) +DECLSPEC u64 MurmurHash64A_g (const u64 seed, const u8 *data, const u32 len) { #define M 0xc6a4a7935bd1e995 #define R 47 @@ -101,7 +101,7 @@ DECLSPEC u64 MurmurHash64A_g (const u64 seed, GLOBAL_AS const u32 *data, const u const u32 endpos = len - (len & 7); //const u32 nBlocks = len >> 3; // number of 8 byte blocks - GLOBAL_AS const u8 *data2 = (GLOBAL_AS const u8*) data; + const u8 *data2 = (const u8*) data; // Loop over blocks of 8 bytes u32 i = 0; @@ -171,15 +171,32 @@ KERNEL_FQ void m90000_mxx (KERN_ATTR_BASIC ()) */ //printf("Running a1 m90000_mxx\n"); - + // probably really bad for performance. fix later + GLOBAL_AS const u8 *left = (GLOBAL_AS const u8*) pws[gid].i; + // create combined buffer + u8 combined_buf[256]; + + // copy left buffer + for (u32 i = 0; i < pws[gid].pw_len; i++) { + combined_buf[i] = left[i]; + } + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos++) { //const u32 tmp_buf = combs_buf[il_pos].i; //if ((gid == 0) && (lid == 0)) printf ("combs_buf[il_pos].i = %08x\n", tmp_buf); //u64x hash = MurmurHash64A_g (seed, pws[gid].i, pws[gid].pw_len, combs_buf[il_pos].i, combs_buf[il_pos].pw_len); - u64x hash = MurmurHash64A_g (seed, combs_buf[il_pos].i, combs_buf[il_pos].pw_len); + + GLOBAL_AS const u8 *right = (GLOBAL_AS const u8*) combs_buf[il_pos].i; + + // copy right buffer + for (u32 i = 0; i < combs_buf[il_pos].pw_len; i++) { + combined_buf[i + pws[gid].pw_len] = right[i]; + } + + u64x hash = MurmurHash64A_g (seed, combined_buf, pws[gid].pw_len + combs_buf[il_pos].pw_len); const u32x r0 = l32_from_64(hash); const u32x r1 = h32_from_64(hash); @@ -230,14 +247,31 @@ KERNEL_FQ void m90000_sxx (KERN_ATTR_BASIC ()) */ printf("Running a1 m90000_sxx\n"); + + + u8 combined_buf[256]; + + // copy left buffer + GLOBAL_AS const u8 *left = (GLOBAL_AS const u8*) pws[gid].i; + for (u32 i = 0; i < pws[gid].pw_len; i++) { + combined_buf[i] = left[i]; + } + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos++) { - u64x hash = MurmurHash64A_g (seed, combs_buf[il_pos].i, combs_buf[il_pos].pw_len); + + // copy right buffer + GLOBAL_AS const u8 *right = (GLOBAL_AS const u8*) combs_buf[il_pos].i; + for (u32 i = 0; i < combs_buf[il_pos].pw_len; i++) { + combined_buf[i + pws[gid].pw_len] = right[i]; + } + + u64 hash = MurmurHash64A_g (seed, combined_buf, pws[gid].pw_len + combs_buf[il_pos].pw_len); const u32 r0 = l32_from_64 (hash); const u32 r1 = h32_from_64 (hash); - const u32x z = 0; + const u32 z = 0; COMPARE_S_SCALAR (r0, r1, z, z); } From 5c876b4352a1c1085abc819824798d4d3aa8d7d3 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Mon, 28 Oct 2024 13:25:37 +1100 Subject: [PATCH 23/61] Use max of 256 for pure pw len --- tools/test_modules/m90000.pm | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/test_modules/m90000.pm b/tools/test_modules/m90000.pm index ffdafbcad..04d53ac18 100644 --- a/tools/test_modules/m90000.pm +++ b/tools/test_modules/m90000.pm @@ -9,7 +9,7 @@ use strict; use warnings; use Math::BigInt; -sub module_constraints { [[-1, -1], [16, 16], [0, 63], [16, 16], [-1, -1]] } +sub module_constraints { [[0, 256], [16, 16], [0, 63], [16, 16], [-1, -1]] } sub wrapping_mul { From 22f5e814fff7891838045aa1ba09e5f0a977d9c2 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Sat, 2 Nov 2024 11:21:30 +1100 Subject: [PATCH 24/61] Add a0-optimized --- OpenCL/m90000_a0-optimized.cl | 257 ++++++++++++++++++++++++++++++++++ 1 file changed, 257 insertions(+) create mode 100644 OpenCL/m90000_a0-optimized.cl diff --git a/OpenCL/m90000_a0-optimized.cl b/OpenCL/m90000_a0-optimized.cl new file mode 100644 index 000000000..651293602 --- /dev/null +++ b/OpenCL/m90000_a0-optimized.cl @@ -0,0 +1,257 @@ +/** + * Author......: See docs/credits.txt + * License.....: MIT + */ + +//#define NEW_SIMD_CODE + +#ifdef KERNEL_STATIC +#include M2S(INCLUDE_PATH/inc_vendor.h) +#include M2S(INCLUDE_PATH/inc_types.h) +#include M2S(INCLUDE_PATH/inc_platform.cl) +#include M2S(INCLUDE_PATH/inc_common.cl) +#include M2S(INCLUDE_PATH/inc_rp_optimized.h) +#include M2S(INCLUDE_PATH/inc_rp_optimized.cl) +#include M2S(INCLUDE_PATH/inc_simd.cl) +#endif + +DECLSPEC u64 MurmurHash64A_round (PRIVATE_AS const u8 *data, u64 hash, const u32 cur_pos) { + #define M 0xc6a4a7935bd1e995 + #define R 47 + + u64 k = ((u64) data[cur_pos]) + | ((u64) data[cur_pos + 1] << 8) + | ((u64) data[cur_pos + 2] << 16) + | ((u64) data[cur_pos + 3] << 24) + | ((u64) data[cur_pos + 4] << 32) + | ((u64) data[cur_pos + 5] << 40) + | ((u64) data[cur_pos + 6] << 48) + | ((u64) data[cur_pos + 7] << 56); + + k *= M; + k ^= k >> R; + k *= M; + + hash ^= k; + hash *= M; + + #undef M + #undef R + + return hash; +} + +DECLSPEC u64 MurmurHash64A_final (PRIVATE_AS const u8 *data, u64 hash, const u32 cur_pos, const u32 len) { + #define M 0xc6a4a7935bd1e995 + #define R 47 + + const u32 overflow = len & 7; + + switch (overflow) { + case 7: hash ^= ((u64) data[cur_pos + 6]) << 48; + case 6: hash ^= ((u64) data[cur_pos + 5]) << 40; + case 5: hash ^= ((u64) data[cur_pos + 4]) << 32; + case 4: hash ^= ((u64) data[cur_pos + 3]) << 24; + case 3: hash ^= ((u64) data[cur_pos + 2]) << 16; + case 2: hash ^= ((u64) data[cur_pos + 1]) << 8; + case 1: hash ^= ((u64) data[cur_pos]); + hash *= M; + } + + hash ^= hash >> R; + hash *= M; + hash ^= hash >> R; + + #undef M + #undef R + + return hash; +} + +DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u32 len) +{ + #define M 0xc6a4a7935bd1e995 + #define R 47 + + //Initialize hash + u64 hash = seed ^ (len * M); + + //const u64 INITIAL = hash; + + const u32 endpos = len - (len & 7); + + //const u32 nBlocks = len >> 3; // number of 8 byte blocks + const u8 *data2 = (const u8*) data; + + //u64 MIDDLE_OF_BLOCK = 0; + + // Loop over blocks of 8 bytes + u32 i = 0; + while (i != endpos) { + hash = MurmurHash64A_round(data2, hash, i); + + i += 8; + } + + // Overflow + + //const u64 BEFORE_FINAL = hash; + + hash = MurmurHash64A_final (data2, hash, i, len); + + //const u64 AFTER_FINAL = hash; + + //printf("debug: %016lx:%016lx:%c%c%c%c%c%c%c%c%c%c len: %d INITIAL: %016lx MIDDLE_O_BLK: %016lx B4FINAL: %016lx overflow: %d AFTER_FINAL: %016lx\n", hash, seed, data2[0], data2[1], data2[2], data2[3], data2[4], data2[5], data2[6], data2[7], data2[8], data2[9], len, INITIAL, MIDDLE_OF_BLOCK, BEFORE_FINAL, overflow, AFTER_FINAL); + //printf("data2 = %.2s, len = %d\n", data2[0], len); + + #undef M + #undef R + + return hash; +} + + + +KERNEL_FQ void m90000_m04 (KERN_ATTR_RULES ()) +{ + /** + * modifier + */ + + const u64 lid = get_local_id (0); + + /** + * base + */ + + const u64 gid = get_global_id (0); + + if (gid >= GID_CNT) return; + + u32 pw_buf0[4]; + u32 pw_buf1[4]; + + pw_buf0[0] = pws[gid].i[0]; + pw_buf0[1] = pws[gid].i[1]; + pw_buf0[2] = pws[gid].i[2]; + pw_buf0[3] = pws[gid].i[3]; + pw_buf1[0] = pws[gid].i[4]; + pw_buf1[1] = pws[gid].i[5]; + pw_buf1[2] = pws[gid].i[6]; + pw_buf1[3] = pws[gid].i[7]; + + const u32 pw_len = pws[gid].pw_len & 63; + + /** + * seed + */ + + const u32 seed_lo = salt_bufs[SALT_POS_HOST].salt_buf[0]; + const u32 seed_hi = salt_bufs[SALT_POS_HOST].salt_buf[1]; + const u64 seed = ((u64) seed_hi << 32) | ((u64) seed_lo); + + /** + * loop + */ + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) + { + u32x w[16] = { 0 }; + + const u32x out_len = apply_rules_vect_optimized (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w + 0, w + 4); + + u64x hash = MurmurHash64A (seed, w, out_len); + + const u32x r0 = l32_from_64(hash); + const u32x r1 = h32_from_64(hash); + const u32x z = 0; + + COMPARE_M_SIMD (r0, r1, z, z); + } +} + +KERNEL_FQ void m90000_m08 (KERN_ATTR_RULES ()) +{ +} + +KERNEL_FQ void m90000_m16 (KERN_ATTR_RULES ()) +{ +} + +KERNEL_FQ void m90000_s04 (KERN_ATTR_RULES ()) +{ + /** + * modifier + */ + + const u64 lid = get_local_id (0); + + /** + * base + */ + + const u64 gid = get_global_id (0); + + if (gid >= GID_CNT) return; + + u32 pw_buf0[4]; + u32 pw_buf1[4]; + + pw_buf0[0] = pws[gid].i[0]; + pw_buf0[1] = pws[gid].i[1]; + pw_buf0[2] = pws[gid].i[2]; + pw_buf0[3] = pws[gid].i[3]; + pw_buf1[0] = pws[gid].i[4]; + pw_buf1[1] = pws[gid].i[5]; + pw_buf1[2] = pws[gid].i[6]; + pw_buf1[3] = pws[gid].i[7]; + + const u32 pw_len = pws[gid].pw_len & 63; + + /** + * digest + */ + + const u32 search[4] = + { + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R0], + 0, + 0, + 0 + }; + + /** + * seed + */ + + const u32 seed_lo = salt_bufs[SALT_POS_HOST].salt_buf[0]; + const u32 seed_hi = salt_bufs[SALT_POS_HOST].salt_buf[1]; + const u64 seed = ((u64) seed_hi << 32) | ((u64) seed_lo); + + /** + * loop + */ + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) + { + u32x w[16] = { 0 }; + + const u32x out_len = apply_rules_vect_optimized (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w + 0, w + 4); + + u64x hash = MurmurHash64A (seed, w, out_len); + + const u32x r0 = l32_from_64(hash); + const u32x r1 = h32_from_64(hash); + const u32x z = 0; + + COMPARE_M_SIMD (r0, r1, z, z); + } +} + +KERNEL_FQ void m90000_s08 (KERN_ATTR_RULES ()) +{ +} + +KERNEL_FQ void m90000_s16 (KERN_ATTR_RULES ()) +{ +} From 8dd805fcbf3cf835658a73e15a3e68acec05e322 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Sat, 2 Nov 2024 11:25:32 +1100 Subject: [PATCH 25/61] Use COMPARE_S_SIMD instead of COMPARE_M_SIMD for m90000_s04 --- OpenCL/m90000_a0-optimized.cl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/OpenCL/m90000_a0-optimized.cl b/OpenCL/m90000_a0-optimized.cl index 651293602..8c957b8d9 100644 --- a/OpenCL/m90000_a0-optimized.cl +++ b/OpenCL/m90000_a0-optimized.cl @@ -244,7 +244,7 @@ KERNEL_FQ void m90000_s04 (KERN_ATTR_RULES ()) const u32x r1 = h32_from_64(hash); const u32x z = 0; - COMPARE_M_SIMD (r0, r1, z, z); + COMPARE_S_SIMD (r0, r1, z, z); } } From 92ca1af1e03cbf167665f4d2c3e28275f409e447 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Sat, 2 Nov 2024 13:04:45 +1100 Subject: [PATCH 26/61] Add a1-optimized --- OpenCL/m90000_a1-optimized.cl | 372 ++++++++++++++++++++++++++++++++++ 1 file changed, 372 insertions(+) create mode 100644 OpenCL/m90000_a1-optimized.cl diff --git a/OpenCL/m90000_a1-optimized.cl b/OpenCL/m90000_a1-optimized.cl new file mode 100644 index 000000000..556d3d8e6 --- /dev/null +++ b/OpenCL/m90000_a1-optimized.cl @@ -0,0 +1,372 @@ +/** + * Author......: See docs/credits.txt + * License.....: MIT + */ + +//too much register pressure +//#define NEW_SIMD_CODE + +#ifdef KERNEL_STATIC +#include M2S(INCLUDE_PATH/inc_vendor.h) +#include M2S(INCLUDE_PATH/inc_types.h) +#include M2S(INCLUDE_PATH/inc_platform.cl) +#include M2S(INCLUDE_PATH/inc_common.cl) +#include M2S(INCLUDE_PATH/inc_simd.cl) +#endif + +DECLSPEC u64 MurmurHash64A_round (PRIVATE_AS const u8 *data, u64 hash, const u32 cur_pos) { + #define M 0xc6a4a7935bd1e995 + #define R 47 + + u64 k = ((u64) data[cur_pos]) + | ((u64) data[cur_pos + 1] << 8) + | ((u64) data[cur_pos + 2] << 16) + | ((u64) data[cur_pos + 3] << 24) + | ((u64) data[cur_pos + 4] << 32) + | ((u64) data[cur_pos + 5] << 40) + | ((u64) data[cur_pos + 6] << 48) + | ((u64) data[cur_pos + 7] << 56); + + k *= M; + k ^= k >> R; + k *= M; + + hash ^= k; + hash *= M; + + #undef M + #undef R + + return hash; +} + +DECLSPEC u64 MurmurHash64A_final (PRIVATE_AS const u8 *data, u64 hash, const u32 cur_pos, const u32 len) { + #define M 0xc6a4a7935bd1e995 + #define R 47 + + const u32 overflow = len & 7; + + switch (overflow) { + case 7: hash ^= ((u64) data[cur_pos + 6]) << 48; + case 6: hash ^= ((u64) data[cur_pos + 5]) << 40; + case 5: hash ^= ((u64) data[cur_pos + 4]) << 32; + case 4: hash ^= ((u64) data[cur_pos + 3]) << 24; + case 3: hash ^= ((u64) data[cur_pos + 2]) << 16; + case 2: hash ^= ((u64) data[cur_pos + 1]) << 8; + case 1: hash ^= ((u64) data[cur_pos]); + hash *= M; + } + + hash ^= hash >> R; + hash *= M; + hash ^= hash >> R; + + #undef M + #undef R + + return hash; +} + +DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u32 len) +{ + #define M 0xc6a4a7935bd1e995 + #define R 47 + + //Initialize hash + u64 hash = seed ^ (len * M); + + //const u64 INITIAL = hash; + + const u32 endpos = len - (len & 7); + + //const u32 nBlocks = len >> 3; // number of 8 byte blocks + const u8 *data2 = (const u8*) data; + + //u64 MIDDLE_OF_BLOCK = 0; + + // Loop over blocks of 8 bytes + u32 i = 0; + while (i != endpos) { + hash = MurmurHash64A_round(data2, hash, i); + + i += 8; + } + + // Overflow + + //const u64 BEFORE_FINAL = hash; + + hash = MurmurHash64A_final (data2, hash, i, len); + + //const u64 AFTER_FINAL = hash; + + //printf("debug: %016lx:%016lx:%c%c%c%c%c%c%c%c%c%c len: %d INITIAL: %016lx MIDDLE_O_BLK: %016lx B4FINAL: %016lx overflow: %d AFTER_FINAL: %016lx\n", hash, seed, data2[0], data2[1], data2[2], data2[3], data2[4], data2[5], data2[6], data2[7], data2[8], data2[9], len, INITIAL, MIDDLE_OF_BLOCK, BEFORE_FINAL, overflow, AFTER_FINAL); + //printf("data2 = %.2s, len = %d\n", data2[0], len); + + #undef M + #undef R + + return hash; +} + +KERNEL_FQ void m90000_m04 (KERN_ATTR_BASIC ()) +{ + /** + * modifier + */ + + const u64 gid = get_global_id (0); + const u64 lid = get_local_id (0); + + if (gid >= GID_CNT) return; + + /** + * base + */ + + u32 pw_buf0[4]; + u32 pw_buf1[4]; + + pw_buf0[0] = pws[gid].i[0]; + pw_buf0[1] = pws[gid].i[1]; + pw_buf0[2] = pws[gid].i[2]; + pw_buf0[3] = pws[gid].i[3]; + pw_buf1[0] = pws[gid].i[4]; + pw_buf1[1] = pws[gid].i[5]; + pw_buf1[2] = pws[gid].i[6]; + pw_buf1[3] = pws[gid].i[7]; + + const u32 pw_l_len = pws[gid].pw_len & 63; + + /** + * seed + */ + + const u32 seed_lo = salt_bufs[SALT_POS_HOST].salt_buf[0]; + const u32 seed_hi = salt_bufs[SALT_POS_HOST].salt_buf[1]; + const u64 seed = ((u64) seed_hi << 32) | ((u64) seed_lo); + + /** + * loop + */ + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) + { + const u32 pw_r_len = pwlenx_create_combt (combs_buf, il_pos) & 63; + + const u32 pw_len = (pw_l_len + pw_r_len) & 63; + + /** + * concat password candidate + */ + + u32 wordl0[4] = { 0 }; + u32 wordl1[4] = { 0 }; + u32 wordl2[4] = { 0 }; + u32 wordl3[4] = { 0 }; + + wordl0[0] = pw_buf0[0]; + wordl0[1] = pw_buf0[1]; + wordl0[2] = pw_buf0[2]; + wordl0[3] = pw_buf0[3]; + wordl1[0] = pw_buf1[0]; + wordl1[1] = pw_buf1[1]; + wordl1[2] = pw_buf1[2]; + wordl1[3] = pw_buf1[3]; + + u32 wordr0[4] = { 0 }; + u32 wordr1[4] = { 0 }; + u32 wordr2[4] = { 0 }; + u32 wordr3[4] = { 0 }; + + wordr0[0] = ix_create_combt (combs_buf, il_pos, 0); + wordr0[1] = ix_create_combt (combs_buf, il_pos, 1); + wordr0[2] = ix_create_combt (combs_buf, il_pos, 2); + wordr0[3] = ix_create_combt (combs_buf, il_pos, 3); + wordr1[0] = ix_create_combt (combs_buf, il_pos, 4); + wordr1[1] = ix_create_combt (combs_buf, il_pos, 5); + wordr1[2] = ix_create_combt (combs_buf, il_pos, 6); + wordr1[3] = ix_create_combt (combs_buf, il_pos, 7); + + if (COMBS_MODE == COMBINATOR_MODE_BASE_LEFT) + { + switch_buffer_by_offset_le_VV (wordr0, wordr1, wordr2, wordr3, pw_l_len); + } + else + { + switch_buffer_by_offset_le_VV (wordl0, wordl1, wordl2, wordl3, pw_r_len); + } + + u32 w[16]; + + w[ 0] = wordl0[0] | wordr0[0]; + w[ 1] = wordl0[1] | wordr0[1]; + w[ 2] = wordl0[2] | wordr0[2]; + w[ 3] = wordl0[3] | wordr0[3]; + w[ 4] = wordl1[0] | wordr1[0]; + w[ 5] = wordl1[1] | wordr1[1]; + w[ 6] = wordl1[2] | wordr1[2]; + w[ 7] = wordl1[3] | wordr1[3]; + w[ 8] = wordl2[0] | wordr2[0]; + w[ 9] = wordl2[1] | wordr2[1]; + w[10] = wordl2[2] | wordr2[2]; + w[11] = wordl2[3] | wordr2[3]; + w[12] = wordl3[0] | wordr3[0]; + w[13] = wordl3[1] | wordr3[1]; + w[14] = wordl3[2] | wordr3[2]; + w[15] = wordl3[3] | wordr3[3]; + + u64x hash = MurmurHash64A (seed, w, pw_len); + + const u32x r0 = l32_from_64(hash); + const u32x r1 = h32_from_64(hash); + const u32x z = 0; + + COMPARE_M_SIMD (r0, r1, z, z); + } +} + +KERNEL_FQ void m90000_m08 (KERN_ATTR_BASIC ()) +{ +} + +KERNEL_FQ void m90000_m16 (KERN_ATTR_BASIC ()) +{ +} + +KERNEL_FQ void m90000_s04 (KERN_ATTR_BASIC ()) +{ + /** + * modifier + */ + + const u64 gid = get_global_id (0); + const u64 lid = get_local_id (0); + + if (gid >= GID_CNT) return; + + /** + * base + */ + + u32 pw_buf0[4]; + u32 pw_buf1[4]; + + pw_buf0[0] = pws[gid].i[0]; + pw_buf0[1] = pws[gid].i[1]; + pw_buf0[2] = pws[gid].i[2]; + pw_buf0[3] = pws[gid].i[3]; + pw_buf1[0] = pws[gid].i[4]; + pw_buf1[1] = pws[gid].i[5]; + pw_buf1[2] = pws[gid].i[6]; + pw_buf1[3] = pws[gid].i[7]; + + const u32 pw_l_len = pws[gid].pw_len & 63; + + /** + * seed + */ + + const u32 seed_lo = salt_bufs[SALT_POS_HOST].salt_buf[0]; + const u32 seed_hi = salt_bufs[SALT_POS_HOST].salt_buf[1]; + const u64 seed = ((u64) seed_hi << 32) | ((u64) seed_lo); + + /** + * digest + */ + + const u32 search[4] = + { + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R0], + 0, + 0, + 0 + }; + + /** + * loop + */ + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) + { + const u32 pw_r_len = pwlenx_create_combt (combs_buf, il_pos) & 63; + + const u32 pw_len = (pw_l_len + pw_r_len) & 63; + + /** + * concat password candidate + */ + + u32 wordl0[4] = { 0 }; + u32 wordl1[4] = { 0 }; + u32 wordl2[4] = { 0 }; + u32 wordl3[4] = { 0 }; + + wordl0[0] = pw_buf0[0]; + wordl0[1] = pw_buf0[1]; + wordl0[2] = pw_buf0[2]; + wordl0[3] = pw_buf0[3]; + wordl1[0] = pw_buf1[0]; + wordl1[1] = pw_buf1[1]; + wordl1[2] = pw_buf1[2]; + wordl1[3] = pw_buf1[3]; + + u32 wordr0[4] = { 0 }; + u32 wordr1[4] = { 0 }; + u32 wordr2[4] = { 0 }; + u32 wordr3[4] = { 0 }; + + wordr0[0] = ix_create_combt (combs_buf, il_pos, 0); + wordr0[1] = ix_create_combt (combs_buf, il_pos, 1); + wordr0[2] = ix_create_combt (combs_buf, il_pos, 2); + wordr0[3] = ix_create_combt (combs_buf, il_pos, 3); + wordr1[0] = ix_create_combt (combs_buf, il_pos, 4); + wordr1[1] = ix_create_combt (combs_buf, il_pos, 5); + wordr1[2] = ix_create_combt (combs_buf, il_pos, 6); + wordr1[3] = ix_create_combt (combs_buf, il_pos, 7); + + if (COMBS_MODE == COMBINATOR_MODE_BASE_LEFT) + { + switch_buffer_by_offset_le_VV (wordr0, wordr1, wordr2, wordr3, pw_l_len); + } + else + { + switch_buffer_by_offset_le_VV (wordl0, wordl1, wordl2, wordl3, pw_r_len); + } + + u32 w[16]; + + w[ 0] = wordl0[0] | wordr0[0]; + w[ 1] = wordl0[1] | wordr0[1]; + w[ 2] = wordl0[2] | wordr0[2]; + w[ 3] = wordl0[3] | wordr0[3]; + w[ 4] = wordl1[0] | wordr1[0]; + w[ 5] = wordl1[1] | wordr1[1]; + w[ 6] = wordl1[2] | wordr1[2]; + w[ 7] = wordl1[3] | wordr1[3]; + w[ 8] = wordl2[0] | wordr2[0]; + w[ 9] = wordl2[1] | wordr2[1]; + w[10] = wordl2[2] | wordr2[2]; + w[11] = wordl2[3] | wordr2[3]; + w[12] = wordl3[0] | wordr3[0]; + w[13] = wordl3[1] | wordr3[1]; + w[14] = wordl3[2] | wordr3[2]; + w[15] = wordl3[3] | wordr3[3]; + + u64 hash = MurmurHash64A (seed, w, pw_len); + + const u32 r0 = l32_from_64(hash); + const u32 r1 = h32_from_64(hash); + const u32 z = 0; + + COMPARE_S_SIMD (r0, r1, z, z); + } +} + +KERNEL_FQ void m90000_s08 (KERN_ATTR_BASIC ()) +{ +} + +KERNEL_FQ void m90000_s16 (KERN_ATTR_BASIC ()) +{ +} From a60c4317f08b4361b24f6a9f9da95f1bb10a500f Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Sat, 2 Nov 2024 13:16:44 +1100 Subject: [PATCH 27/61] Add a3-optimized (untested) --- OpenCL/m90000_a3-optimized.cl | 484 ++++++++++++++++++++++++++++++++++ 1 file changed, 484 insertions(+) create mode 100644 OpenCL/m90000_a3-optimized.cl diff --git a/OpenCL/m90000_a3-optimized.cl b/OpenCL/m90000_a3-optimized.cl new file mode 100644 index 000000000..cc246a4f5 --- /dev/null +++ b/OpenCL/m90000_a3-optimized.cl @@ -0,0 +1,484 @@ +/** + * Author......: See docs/credits.txt + * License.....: MIT + */ + +#define NEW_SIMD_CODE + +#ifdef KERNEL_STATIC +#include M2S(INCLUDE_PATH/inc_vendor.h) +#include M2S(INCLUDE_PATH/inc_types.h) +#include M2S(INCLUDE_PATH/inc_platform.cl) +#include M2S(INCLUDE_PATH/inc_common.cl) +#include M2S(INCLUDE_PATH/inc_simd.cl) +#include M2S(INCLUDE_PATH/inc_hash_md5.cl) +#endif + +DECLSPEC u64 MurmurHash64A_round (PRIVATE_AS const u8 *data, u64 hash, const u32 cur_pos) { + #define M 0xc6a4a7935bd1e995 + #define R 47 + + u64 k = ((u64) data[cur_pos]) + | ((u64) data[cur_pos + 1] << 8) + | ((u64) data[cur_pos + 2] << 16) + | ((u64) data[cur_pos + 3] << 24) + | ((u64) data[cur_pos + 4] << 32) + | ((u64) data[cur_pos + 5] << 40) + | ((u64) data[cur_pos + 6] << 48) + | ((u64) data[cur_pos + 7] << 56); + + k *= M; + k ^= k >> R; + k *= M; + + hash ^= k; + hash *= M; + + #undef M + #undef R + + return hash; +} + +DECLSPEC u64 MurmurHash64A_final (PRIVATE_AS const u8 *data, u64 hash, const u32 cur_pos, const u32 len) { + #define M 0xc6a4a7935bd1e995 + #define R 47 + + const u32 overflow = len & 7; + + switch (overflow) { + case 7: hash ^= ((u64) data[cur_pos + 6]) << 48; + case 6: hash ^= ((u64) data[cur_pos + 5]) << 40; + case 5: hash ^= ((u64) data[cur_pos + 4]) << 32; + case 4: hash ^= ((u64) data[cur_pos + 3]) << 24; + case 3: hash ^= ((u64) data[cur_pos + 2]) << 16; + case 2: hash ^= ((u64) data[cur_pos + 1]) << 8; + case 1: hash ^= ((u64) data[cur_pos]); + hash *= M; + } + + hash ^= hash >> R; + hash *= M; + hash ^= hash >> R; + + #undef M + #undef R + + return hash; +} + +DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u32 len) +{ + #define M 0xc6a4a7935bd1e995 + #define R 47 + + //Initialize hash + u64 hash = seed ^ (len * M); + + //const u64 INITIAL = hash; + + const u32 endpos = len - (len & 7); + + //const u32 nBlocks = len >> 3; // number of 8 byte blocks + const u8 *data2 = (const u8*) data; + + //u64 MIDDLE_OF_BLOCK = 0; + + // Loop over blocks of 8 bytes + u32 i = 0; + while (i != endpos) { + hash = MurmurHash64A_round(data2, hash, i); + + i += 8; + } + + // Overflow + + //const u64 BEFORE_FINAL = hash; + + hash = MurmurHash64A_final (data2, hash, i, len); + + //const u64 AFTER_FINAL = hash; + + //printf("debug: %016lx:%016lx:%c%c%c%c%c%c%c%c%c%c len: %d INITIAL: %016lx MIDDLE_O_BLK: %016lx B4FINAL: %016lx overflow: %d AFTER_FINAL: %016lx\n", hash, seed, data2[0], data2[1], data2[2], data2[3], data2[4], data2[5], data2[6], data2[7], data2[8], data2[9], len, INITIAL, MIDDLE_OF_BLOCK, BEFORE_FINAL, overflow, AFTER_FINAL); + //printf("data2 = %.2s, len = %d\n", data2[0], len); + + #undef M + #undef R + + return hash; +} + +DECLSPEC void m25700m (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_FUNC_VECTOR ()) +{ + /** + * modifiers are taken from args + */ + + /** + * seed + */ + + const u32x seed_lo = salt_bufs[SALT_POS_HOST].salt_buf[0]; + const u32x seed_hi = salt_bufs[SALT_POS_HOST].salt_buf[1]; + const u64x seed = ((u64) seed_hi << 32) | ((u64) seed_lo); + + /** + * base + */ + + u32x w[16]; + + w[ 0] = data[ 0]; + w[ 1] = data[ 1]; + w[ 2] = data[ 2]; + w[ 3] = data[ 3]; + w[ 4] = data[ 4]; + w[ 5] = data[ 5]; + w[ 6] = data[ 6]; + w[ 7] = data[ 7]; + w[ 8] = data[ 8]; + w[ 9] = data[ 9]; + w[10] = data[10]; + w[11] = data[11]; + w[12] = data[12]; + w[13] = data[13]; + w[14] = data[14]; + w[15] = data[15]; + + /** + * loop + */ + + u32x w0l = w[0]; + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) + { + const u32x w0r = words_buf_r[il_pos / VECT_SIZE]; + + const u32x w0 = w0l | w0r; + + w[0] = w0; + + const u64x hash = MurmurHash64A (seed, w, pw_len); + + const u32x r0 = l32_from_64(hash); + const u32x r1 = h32_from_64(hash); + const u32x z = 0; + + COMPARE_M_SIMD (r0, r1, z, z); + } +} + +DECLSPEC void m25700s (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_FUNC_VECTOR ()) +{ + /** + * modifiers are taken from args + */ + + /** + * digest + */ + + const u32 search[4] = + { + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R0], + 0, + 0, + 0 + }; + + /** + * seed + */ + + const u32x seed_lo = salt_bufs[SALT_POS_HOST].salt_buf[0]; + const u32x seed_hi = salt_bufs[SALT_POS_HOST].salt_buf[1]; + const u64x seed = ((u64) seed_hi << 32) | ((u64) seed_lo); + + /** + * base + */ + + u32x w[16]; + + w[ 0] = data[ 0]; + w[ 1] = data[ 1]; + w[ 2] = data[ 2]; + w[ 3] = data[ 3]; + w[ 4] = data[ 4]; + w[ 5] = data[ 5]; + w[ 6] = data[ 6]; + w[ 7] = data[ 7]; + w[ 8] = data[ 8]; + w[ 9] = data[ 9]; + w[10] = data[10]; + w[11] = data[11]; + w[12] = data[12]; + w[13] = data[13]; + w[14] = data[14]; + w[15] = data[15]; + + /** + * loop + */ + + u32x w0l = w[0]; + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) + { + const u32x w0r = words_buf_r[il_pos / VECT_SIZE]; + + const u32x w0 = w0l | w0r; + + w[0] = w0; + + const u64x hash = MurmurHash64A (seed, w, pw_len); + + const u32x r0 = l32_from_64(hash); + const u32x r1 = h32_from_64(hash); + const u32x z = 0; + + COMPARE_S_SIMD (r0, r1, z, z); + } +} + +KERNEL_FQ void m25700_m04 (KERN_ATTR_VECTOR ()) +{ + /** + * base + */ + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + const u64 lsz = get_local_size (0); + + if (gid >= GID_CNT) return; + + u32 w[16]; + + w[ 0] = pws[gid].i[ 0]; + w[ 1] = pws[gid].i[ 1]; + w[ 2] = pws[gid].i[ 2]; + w[ 3] = pws[gid].i[ 3]; + w[ 4] = 0; + w[ 5] = 0; + w[ 6] = 0; + w[ 7] = 0; + w[ 8] = 0; + w[ 9] = 0; + w[10] = 0; + w[11] = 0; + w[12] = 0; + w[13] = 0; + w[14] = 0; + w[15] = 0; + + const u32 pw_len = pws[gid].pw_len & 63; + + /** + * main + */ + + m25700m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); +} + +KERNEL_FQ void m25700_m08 (KERN_ATTR_VECTOR ()) +{ + /** + * base + */ + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + const u64 lsz = get_local_size (0); + + if (gid >= GID_CNT) return; + + u32 w[16]; + + w[ 0] = pws[gid].i[ 0]; + w[ 1] = pws[gid].i[ 1]; + w[ 2] = pws[gid].i[ 2]; + w[ 3] = pws[gid].i[ 3]; + w[ 4] = pws[gid].i[ 4]; + w[ 5] = pws[gid].i[ 5]; + w[ 6] = pws[gid].i[ 6]; + w[ 7] = pws[gid].i[ 7]; + w[ 8] = 0; + w[ 9] = 0; + w[10] = 0; + w[11] = 0; + w[12] = 0; + w[13] = 0; + w[14] = 0; + w[15] = 0; + + const u32 pw_len = pws[gid].pw_len & 63; + + /** + * main + */ + + m25700m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); +} + +KERNEL_FQ void m25700_m16 (KERN_ATTR_VECTOR ()) +{ + /** + * base + */ + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + const u64 lsz = get_local_size (0); + + if (gid >= GID_CNT) return; + + u32 w[16]; + + w[ 0] = pws[gid].i[ 0]; + w[ 1] = pws[gid].i[ 1]; + w[ 2] = pws[gid].i[ 2]; + w[ 3] = pws[gid].i[ 3]; + w[ 4] = pws[gid].i[ 4]; + w[ 5] = pws[gid].i[ 5]; + w[ 6] = pws[gid].i[ 6]; + w[ 7] = pws[gid].i[ 7]; + w[ 8] = pws[gid].i[ 8]; + w[ 9] = pws[gid].i[ 9]; + w[10] = pws[gid].i[10]; + w[11] = pws[gid].i[11]; + w[12] = pws[gid].i[12]; + w[13] = pws[gid].i[13]; + w[14] = pws[gid].i[14]; + w[15] = pws[gid].i[15]; + + const u32 pw_len = pws[gid].pw_len & 63; + + /** + * main + */ + + m25700m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); +} + +KERNEL_FQ void m25700_s04 (KERN_ATTR_VECTOR ()) +{ + /** + * base + */ + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + const u64 lsz = get_local_size (0); + + if (gid >= GID_CNT) return; + + u32 w[16]; + + w[ 0] = pws[gid].i[ 0]; + w[ 1] = pws[gid].i[ 1]; + w[ 2] = pws[gid].i[ 2]; + w[ 3] = pws[gid].i[ 3]; + w[ 4] = 0; + w[ 5] = 0; + w[ 6] = 0; + w[ 7] = 0; + w[ 8] = 0; + w[ 9] = 0; + w[10] = 0; + w[11] = 0; + w[12] = 0; + w[13] = 0; + w[14] = 0; + w[15] = 0; + + const u32 pw_len = pws[gid].pw_len & 63; + + /** + * main + */ + + m25700s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); +} + +KERNEL_FQ void m25700_s08 (KERN_ATTR_VECTOR ()) +{ + /** + * base + */ + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + const u64 lsz = get_local_size (0); + + if (gid >= GID_CNT) return; + + u32 w[16]; + + w[ 0] = pws[gid].i[ 0]; + w[ 1] = pws[gid].i[ 1]; + w[ 2] = pws[gid].i[ 2]; + w[ 3] = pws[gid].i[ 3]; + w[ 4] = pws[gid].i[ 4]; + w[ 5] = pws[gid].i[ 5]; + w[ 6] = pws[gid].i[ 6]; + w[ 7] = pws[gid].i[ 7]; + w[ 8] = 0; + w[ 9] = 0; + w[10] = 0; + w[11] = 0; + w[12] = 0; + w[13] = 0; + w[14] = 0; + w[15] = 0; + + const u32 pw_len = pws[gid].pw_len & 63; + + /** + * main + */ + + m25700s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); +} + +KERNEL_FQ void m25700_s16 (KERN_ATTR_VECTOR ()) +{ + /** + * base + */ + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + const u64 lsz = get_local_size (0); + + if (gid >= GID_CNT) return; + + u32 w[16]; + + w[ 0] = pws[gid].i[ 0]; + w[ 1] = pws[gid].i[ 1]; + w[ 2] = pws[gid].i[ 2]; + w[ 3] = pws[gid].i[ 3]; + w[ 4] = pws[gid].i[ 4]; + w[ 5] = pws[gid].i[ 5]; + w[ 6] = pws[gid].i[ 6]; + w[ 7] = pws[gid].i[ 7]; + w[ 8] = pws[gid].i[ 8]; + w[ 9] = pws[gid].i[ 9]; + w[10] = pws[gid].i[10]; + w[11] = pws[gid].i[11]; + w[12] = pws[gid].i[12]; + w[13] = pws[gid].i[13]; + w[14] = pws[gid].i[14]; + w[15] = pws[gid].i[15]; + + const u32 pw_len = pws[gid].pw_len & 63; + + /** + * main + */ + + m25700s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); +} From 1f4282d5510da3e94cb209fc6c89ead5bf98f7cc Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Thu, 7 Nov 2024 20:55:43 +1100 Subject: [PATCH 28/61] Specify LE and set digest[1] --- src/modules/module_90000.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/modules/module_90000.c b/src/modules/module_90000.c index 3d26c083e..a0ed045b2 100644 --- a/src/modules/module_90000.c +++ b/src/modules/module_90000.c @@ -22,6 +22,7 @@ static const u64 KERN_TYPE = 90000; static const u32 OPTI_TYPE = OPTI_TYPE_ZERO_BYTE | OPTI_TYPE_USES_BITS_64; static const u64 OPTS_TYPE = OPTS_TYPE_STOCK_MODULE + | OPTS_TYPE_PT_GENERATE_LE | OPTS_TYPE_ST_HEX | OPTS_TYPE_SUGGEST_KG; static const u32 SALT_TYPE = SALT_TYPE_EMBEDDED; @@ -94,6 +95,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE */ digest[0] = ((hex_to_u64 (&hash_pos[0]))); + digest[1] = 0; digest[0] = byte_swap_64 (digest[0]); From deeeff3113834f5808ecb09c8d30ca7d4afaeee5 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Thu, 7 Nov 2024 21:29:57 +1100 Subject: [PATCH 29/61] a3-optimized working? --- OpenCL/m90000_a3-optimized.cl | 158 +++++++++++++++++----------------- 1 file changed, 77 insertions(+), 81 deletions(-) diff --git a/OpenCL/m90000_a3-optimized.cl b/OpenCL/m90000_a3-optimized.cl index cc246a4f5..83681597c 100644 --- a/OpenCL/m90000_a3-optimized.cl +++ b/OpenCL/m90000_a3-optimized.cl @@ -3,7 +3,7 @@ * License.....: MIT */ -#define NEW_SIMD_CODE +//#define NEW_SIMD_CODE #ifdef KERNEL_STATIC #include M2S(INCLUDE_PATH/inc_vendor.h) @@ -11,105 +11,83 @@ #include M2S(INCLUDE_PATH/inc_platform.cl) #include M2S(INCLUDE_PATH/inc_common.cl) #include M2S(INCLUDE_PATH/inc_simd.cl) -#include M2S(INCLUDE_PATH/inc_hash_md5.cl) #endif -DECLSPEC u64 MurmurHash64A_round (PRIVATE_AS const u8 *data, u64 hash, const u32 cur_pos) { - #define M 0xc6a4a7935bd1e995 - #define R 47 - u64 k = ((u64) data[cur_pos]) - | ((u64) data[cur_pos + 1] << 8) - | ((u64) data[cur_pos + 2] << 16) - | ((u64) data[cur_pos + 3] << 24) - | ((u64) data[cur_pos + 4] << 32) - | ((u64) data[cur_pos + 5] << 40) - | ((u64) data[cur_pos + 6] << 48) - | ((u64) data[cur_pos + 7] << 56); - - k *= M; - k ^= k >> R; - k *= M; - - hash ^= k; - hash *= M; - - #undef M - #undef R - - return hash; -} - -DECLSPEC u64 MurmurHash64A_final (PRIVATE_AS const u8 *data, u64 hash, const u32 cur_pos, const u32 len) { - #define M 0xc6a4a7935bd1e995 - #define R 47 - - const u32 overflow = len & 7; - - switch (overflow) { - case 7: hash ^= ((u64) data[cur_pos + 6]) << 48; - case 6: hash ^= ((u64) data[cur_pos + 5]) << 40; - case 5: hash ^= ((u64) data[cur_pos + 4]) << 32; - case 4: hash ^= ((u64) data[cur_pos + 3]) << 24; - case 3: hash ^= ((u64) data[cur_pos + 2]) << 16; - case 2: hash ^= ((u64) data[cur_pos + 1]) << 8; - case 1: hash ^= ((u64) data[cur_pos]); - hash *= M; - } - - hash ^= hash >> R; - hash *= M; - hash ^= hash >> R; - - #undef M - #undef R - - return hash; -} - -DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u32 len) +DECLSPEC u64x MurmurHash64A (const u64x seed, PRIVATE_AS const u32x *data, const u32 len) { #define M 0xc6a4a7935bd1e995 #define R 47 //Initialize hash - u64 hash = seed ^ (len * M); + u64x hash = seed ^ (len * M); + + printf("INITIAL = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); - //const u64 INITIAL = hash; - const u32 endpos = len - (len & 7); - //const u32 nBlocks = len >> 3; // number of 8 byte blocks const u8 *data2 = (const u8*) data; - //u64 MIDDLE_OF_BLOCK = 0; + printf("seed = %08x%08x\n", h32_from_64(seed), l32_from_64(seed)); + printf("data2 = %c%c%c%c%c%c%c%c\n", data2[0], data2[1], data2[2], data2[3], data2[4], data2[5], data2[6], data2[7]); + printf("len = %d\n", len); + // Loop over blocks of 8 bytes u32 i = 0; while (i != endpos) { - hash = MurmurHash64A_round(data2, hash, i); + u64x k = ((u64) data2[i]) + | ((u64) data2[i + 1] << 8) + | ((u64) data2[i + 2] << 16) + | ((u64) data2[i + 3] << 24) + | ((u64) data2[i + 4] << 32) + | ((u64) data2[i + 5] << 40) + | ((u64) data2[i + 6] << 48) + | ((u64) data2[i + 7] << 56); + + k *= M; + k ^= k >> R; + k *= M; + + hash ^= k; + hash *= M; i += 8; } + printf("BEFORE_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); // Overflow - //const u64 BEFORE_FINAL = hash; + const u32 overflow = len & 7; - hash = MurmurHash64A_final (data2, hash, i, len); + printf("OVERFLOW = %d\n", overflow); - //const u64 AFTER_FINAL = hash; + switch (overflow) { + case 7: hash ^= ((u64) data2[i + 6]) << 48; + case 6: hash ^= ((u64) data2[i + 5]) << 40; + case 5: hash ^= ((u64) data2[i + 4]) << 32; + case 4: hash ^= ((u64) data2[i + 3]) << 24; + case 3: hash ^= ((u64) data2[i + 2]) << 16; + case 2: hash ^= ((u64) data2[i + 1]) << 8; + case 1: hash ^= ((u64) data2[i]); + hash *= M; + } - //printf("debug: %016lx:%016lx:%c%c%c%c%c%c%c%c%c%c len: %d INITIAL: %016lx MIDDLE_O_BLK: %016lx B4FINAL: %016lx overflow: %d AFTER_FINAL: %016lx\n", hash, seed, data2[0], data2[1], data2[2], data2[3], data2[4], data2[5], data2[6], data2[7], data2[8], data2[9], len, INITIAL, MIDDLE_OF_BLOCK, BEFORE_FINAL, overflow, AFTER_FINAL); - //printf("data2 = %.2s, len = %d\n", data2[0], len); + printf("AFTER_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + + hash ^= hash >> R; + hash *= M; + hash ^= hash >> R; #undef M #undef R + printf("hash = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + return hash; } -DECLSPEC void m25700m (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_FUNC_VECTOR ()) +DECLSPEC void m90000m (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_FUNC_VECTOR ()) { /** * modifiers are taken from args @@ -146,6 +124,9 @@ DECLSPEC void m25700m (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F w[14] = data[14]; w[15] = data[15]; + const u8 *data2 = (const u8*) data; + //printf("w = %c%c%c%c%c%c%c%c\n", data2[0], data2[1], data2[2], data2[3], data2[4], data2[5], data2[6], data2[7]); + /** * loop */ @@ -160,17 +141,21 @@ DECLSPEC void m25700m (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F w[0] = w0; + //printf("seed = %08x%08x\n", seed_hi, seed_lo); + const u64x hash = MurmurHash64A (seed, w, pw_len); const u32x r0 = l32_from_64(hash); const u32x r1 = h32_from_64(hash); const u32x z = 0; + printf("hash = %08x%08x\n", r1, r0); + COMPARE_M_SIMD (r0, r1, z, z); } } -DECLSPEC void m25700s (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_FUNC_VECTOR ()) +DECLSPEC void m90000s (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_FUNC_VECTOR ()) { /** * modifiers are taken from args @@ -179,11 +164,13 @@ DECLSPEC void m25700s (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F /** * digest */ + + printf("Hello world m90000s\n"); const u32 search[4] = { digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R0], - 0, + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R1], 0, 0 }; @@ -239,15 +226,21 @@ DECLSPEC void m25700s (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F const u32x r1 = h32_from_64(hash); const u32x z = 0; + //printf("r1 = %08x r0 = %08x\n", r1, r0); + printf("hash = %08x%08x\n", r1, r0); + COMPARE_S_SIMD (r0, r1, z, z); } } -KERNEL_FQ void m25700_m04 (KERN_ATTR_VECTOR ()) +KERNEL_FQ void m90000_m04 (KERN_ATTR_VECTOR ()) { /** * base */ + + //printf("Hello world m90000_m04\n"); + const u64 lid = get_local_id (0); const u64 gid = get_global_id (0); @@ -275,19 +268,22 @@ KERNEL_FQ void m25700_m04 (KERN_ATTR_VECTOR ()) w[15] = 0; const u32 pw_len = pws[gid].pw_len & 63; + //printf("pws[gid].pw_len = %d\n", pws[gid].pw_len); /** * main */ - m25700m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); + m90000m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ void m25700_m08 (KERN_ATTR_VECTOR ()) +KERNEL_FQ void m90000_m08 (KERN_ATTR_VECTOR ()) { /** * base */ + + printf("Hello world m90000_m08\n"); const u64 lid = get_local_id (0); const u64 gid = get_global_id (0); @@ -320,10 +316,10 @@ KERNEL_FQ void m25700_m08 (KERN_ATTR_VECTOR ()) * main */ - m25700m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); + m90000m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ void m25700_m16 (KERN_ATTR_VECTOR ()) +KERNEL_FQ void m90000_m16 (KERN_ATTR_VECTOR ()) { /** * base @@ -360,10 +356,10 @@ KERNEL_FQ void m25700_m16 (KERN_ATTR_VECTOR ()) * main */ - m25700m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); + m90000m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ void m25700_s04 (KERN_ATTR_VECTOR ()) +KERNEL_FQ void m90000_s04 (KERN_ATTR_VECTOR ()) { /** * base @@ -400,10 +396,10 @@ KERNEL_FQ void m25700_s04 (KERN_ATTR_VECTOR ()) * main */ - m25700s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); + m90000s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ void m25700_s08 (KERN_ATTR_VECTOR ()) +KERNEL_FQ void m90000_s08 (KERN_ATTR_VECTOR ()) { /** * base @@ -440,10 +436,10 @@ KERNEL_FQ void m25700_s08 (KERN_ATTR_VECTOR ()) * main */ - m25700s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); + m90000s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ void m25700_s16 (KERN_ATTR_VECTOR ()) +KERNEL_FQ void m90000_s16 (KERN_ATTR_VECTOR ()) { /** * base @@ -480,5 +476,5 @@ KERNEL_FQ void m25700_s16 (KERN_ATTR_VECTOR ()) * main */ - m25700s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); + m90000s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } From 4484280206f2aee5a89fbfe76a39323eac233950 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Thu, 7 Nov 2024 22:31:09 +1100 Subject: [PATCH 30/61] Fix a0-optimized single --- OpenCL/m90000_a0-optimized.cl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/OpenCL/m90000_a0-optimized.cl b/OpenCL/m90000_a0-optimized.cl index 8c957b8d9..07e878682 100644 --- a/OpenCL/m90000_a0-optimized.cl +++ b/OpenCL/m90000_a0-optimized.cl @@ -215,7 +215,7 @@ KERNEL_FQ void m90000_s04 (KERN_ATTR_RULES ()) const u32 search[4] = { digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R0], - 0, + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R1], 0, 0 }; From 564fb40818a669f5e823a8d7ee5d6226bdffa3d1 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Thu, 7 Nov 2024 22:36:22 +1100 Subject: [PATCH 31/61] Fix a1-optimized single --- OpenCL/m90000_a1-optimized.cl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/OpenCL/m90000_a1-optimized.cl b/OpenCL/m90000_a1-optimized.cl index 556d3d8e6..48d753b2d 100644 --- a/OpenCL/m90000_a1-optimized.cl +++ b/OpenCL/m90000_a1-optimized.cl @@ -278,7 +278,7 @@ KERNEL_FQ void m90000_s04 (KERN_ATTR_BASIC ()) const u32 search[4] = { digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R0], - 0, + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R1], 0, 0 }; From ad6a745ab2052ff1c7c49bfcd26802df9015586a Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Thu, 7 Nov 2024 23:45:39 +1100 Subject: [PATCH 32/61] No printf --- OpenCL/m90000_a3-optimized.cl | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/OpenCL/m90000_a3-optimized.cl b/OpenCL/m90000_a3-optimized.cl index 83681597c..51915057f 100644 --- a/OpenCL/m90000_a3-optimized.cl +++ b/OpenCL/m90000_a3-optimized.cl @@ -22,15 +22,15 @@ DECLSPEC u64x MurmurHash64A (const u64x seed, PRIVATE_AS const u32x *data, const //Initialize hash u64x hash = seed ^ (len * M); - printf("INITIAL = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + //printf("INITIAL = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); const u32 endpos = len - (len & 7); const u8 *data2 = (const u8*) data; - printf("seed = %08x%08x\n", h32_from_64(seed), l32_from_64(seed)); - printf("data2 = %c%c%c%c%c%c%c%c\n", data2[0], data2[1], data2[2], data2[3], data2[4], data2[5], data2[6], data2[7]); - printf("len = %d\n", len); + //printf("seed = %08x%08x\n", h32_from_64(seed), l32_from_64(seed)); + //printf("data2 = %c%c%c%c%c%c%c%c\n", data2[0], data2[1], data2[2], data2[3], data2[4], data2[5], data2[6], data2[7]); + //printf("len = %d\n", len); // Loop over blocks of 8 bytes @@ -54,13 +54,13 @@ DECLSPEC u64x MurmurHash64A (const u64x seed, PRIVATE_AS const u32x *data, const i += 8; } - printf("BEFORE_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + //printf("BEFORE_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); // Overflow const u32 overflow = len & 7; - printf("OVERFLOW = %d\n", overflow); + //printf("OVERFLOW = %d\n", overflow); switch (overflow) { case 7: hash ^= ((u64) data2[i + 6]) << 48; @@ -73,7 +73,7 @@ DECLSPEC u64x MurmurHash64A (const u64x seed, PRIVATE_AS const u32x *data, const hash *= M; } - printf("AFTER_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + //printf("AFTER_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); hash ^= hash >> R; hash *= M; @@ -82,7 +82,7 @@ DECLSPEC u64x MurmurHash64A (const u64x seed, PRIVATE_AS const u32x *data, const #undef M #undef R - printf("hash = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + //printf("hash = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); return hash; } @@ -124,7 +124,7 @@ DECLSPEC void m90000m (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F w[14] = data[14]; w[15] = data[15]; - const u8 *data2 = (const u8*) data; + //const u8 *data2 = (const u8*) data; //printf("w = %c%c%c%c%c%c%c%c\n", data2[0], data2[1], data2[2], data2[3], data2[4], data2[5], data2[6], data2[7]); /** @@ -149,7 +149,7 @@ DECLSPEC void m90000m (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F const u32x r1 = h32_from_64(hash); const u32x z = 0; - printf("hash = %08x%08x\n", r1, r0); + //printf("hash = %08x%08x\n", r1, r0); COMPARE_M_SIMD (r0, r1, z, z); } @@ -165,7 +165,7 @@ DECLSPEC void m90000s (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F * digest */ - printf("Hello world m90000s\n"); + //printf("Hello world m90000s\n"); const u32 search[4] = { @@ -227,7 +227,7 @@ DECLSPEC void m90000s (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F const u32x z = 0; //printf("r1 = %08x r0 = %08x\n", r1, r0); - printf("hash = %08x%08x\n", r1, r0); + //printf("hash = %08x%08x\n", r1, r0); COMPARE_S_SIMD (r0, r1, z, z); } @@ -283,7 +283,7 @@ KERNEL_FQ void m90000_m08 (KERN_ATTR_VECTOR ()) * base */ - printf("Hello world m90000_m08\n"); + //printf("Hello world m90000_m08\n"); const u64 lid = get_local_id (0); const u64 gid = get_global_id (0); From fff0b5ade274c1102e1c91b3ea8e4f2fff298efb Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Fri, 8 Nov 2024 10:15:33 +1100 Subject: [PATCH 33/61] Create mode for murmurhash64a with zero seed --- OpenCL/m90010_a0-optimized.cl | 249 ++++++++++++++++++ OpenCL/m90010_a1-optimized.cl | 364 ++++++++++++++++++++++++++ OpenCL/m90010_a3-optimized.cl | 472 ++++++++++++++++++++++++++++++++++ src/modules/module_90010.c | 174 +++++++++++++ tools/test_modules/m90010.pm | 152 +++++++++++ 5 files changed, 1411 insertions(+) create mode 100644 OpenCL/m90010_a0-optimized.cl create mode 100644 OpenCL/m90010_a1-optimized.cl create mode 100644 OpenCL/m90010_a3-optimized.cl create mode 100644 src/modules/module_90010.c create mode 100644 tools/test_modules/m90010.pm diff --git a/OpenCL/m90010_a0-optimized.cl b/OpenCL/m90010_a0-optimized.cl new file mode 100644 index 000000000..5b1768733 --- /dev/null +++ b/OpenCL/m90010_a0-optimized.cl @@ -0,0 +1,249 @@ +/** + * Author......: See docs/credits.txt + * License.....: MIT + */ + +//#define NEW_SIMD_CODE + +#ifdef KERNEL_STATIC +#include M2S(INCLUDE_PATH/inc_vendor.h) +#include M2S(INCLUDE_PATH/inc_types.h) +#include M2S(INCLUDE_PATH/inc_platform.cl) +#include M2S(INCLUDE_PATH/inc_common.cl) +#include M2S(INCLUDE_PATH/inc_rp_optimized.h) +#include M2S(INCLUDE_PATH/inc_rp_optimized.cl) +#include M2S(INCLUDE_PATH/inc_simd.cl) +#endif + +DECLSPEC u64 MurmurHash64A_round (PRIVATE_AS const u8 *data, u64 hash, const u32 cur_pos) { + #define M 0xc6a4a7935bd1e995 + #define R 47 + + u64 k = ((u64) data[cur_pos]) + | ((u64) data[cur_pos + 1] << 8) + | ((u64) data[cur_pos + 2] << 16) + | ((u64) data[cur_pos + 3] << 24) + | ((u64) data[cur_pos + 4] << 32) + | ((u64) data[cur_pos + 5] << 40) + | ((u64) data[cur_pos + 6] << 48) + | ((u64) data[cur_pos + 7] << 56); + + k *= M; + k ^= k >> R; + k *= M; + + hash ^= k; + hash *= M; + + #undef M + #undef R + + return hash; +} + +DECLSPEC u64 MurmurHash64A_final (PRIVATE_AS const u8 *data, u64 hash, const u32 cur_pos, const u32 len) { + #define M 0xc6a4a7935bd1e995 + #define R 47 + + const u32 overflow = len & 7; + + switch (overflow) { + case 7: hash ^= ((u64) data[cur_pos + 6]) << 48; + case 6: hash ^= ((u64) data[cur_pos + 5]) << 40; + case 5: hash ^= ((u64) data[cur_pos + 4]) << 32; + case 4: hash ^= ((u64) data[cur_pos + 3]) << 24; + case 3: hash ^= ((u64) data[cur_pos + 2]) << 16; + case 2: hash ^= ((u64) data[cur_pos + 1]) << 8; + case 1: hash ^= ((u64) data[cur_pos]); + hash *= M; + } + + hash ^= hash >> R; + hash *= M; + hash ^= hash >> R; + + #undef M + #undef R + + return hash; +} + +DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) +{ + #define M 0xc6a4a7935bd1e995 + #define R 47 + + //Initialize hash + u64 hash = 0 ^ (len * M); + + //const u64 INITIAL = hash; + + const u32 endpos = len - (len & 7); + + //const u32 nBlocks = len >> 3; // number of 8 byte blocks + const u8 *data2 = (const u8*) data; + + //u64 MIDDLE_OF_BLOCK = 0; + + // Loop over blocks of 8 bytes + u32 i = 0; + while (i != endpos) { + hash = MurmurHash64A_round(data2, hash, i); + + i += 8; + } + + // Overflow + + //const u64 BEFORE_FINAL = hash; + + hash = MurmurHash64A_final (data2, hash, i, len); + + //const u64 AFTER_FINAL = hash; + + //printf("debug: %016lx:%016lx:%c%c%c%c%c%c%c%c%c%c len: %d INITIAL: %016lx MIDDLE_O_BLK: %016lx B4FINAL: %016lx overflow: %d AFTER_FINAL: %016lx\n", hash, seed, data2[0], data2[1], data2[2], data2[3], data2[4], data2[5], data2[6], data2[7], data2[8], data2[9], len, INITIAL, MIDDLE_OF_BLOCK, BEFORE_FINAL, overflow, AFTER_FINAL); + //printf("data2 = %.2s, len = %d\n", data2[0], len); + + #undef M + #undef R + + return hash; +} + + + +KERNEL_FQ void m90000_m04 (KERN_ATTR_RULES ()) +{ + /** + * modifier + */ + + const u64 lid = get_local_id (0); + + /** + * base + */ + + const u64 gid = get_global_id (0); + + if (gid >= GID_CNT) return; + + u32 pw_buf0[4]; + u32 pw_buf1[4]; + + pw_buf0[0] = pws[gid].i[0]; + pw_buf0[1] = pws[gid].i[1]; + pw_buf0[2] = pws[gid].i[2]; + pw_buf0[3] = pws[gid].i[3]; + pw_buf1[0] = pws[gid].i[4]; + pw_buf1[1] = pws[gid].i[5]; + pw_buf1[2] = pws[gid].i[6]; + pw_buf1[3] = pws[gid].i[7]; + + const u32 pw_len = pws[gid].pw_len & 63; + + /** + * seed + */ + + /** + * loop + */ + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) + { + u32x w[16] = { 0 }; + + const u32x out_len = apply_rules_vect_optimized (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w + 0, w + 4); + + u64x hash = MurmurHash64A (w, out_len); + + const u32x r0 = l32_from_64(hash); + const u32x r1 = h32_from_64(hash); + const u32x z = 0; + + COMPARE_M_SIMD (r0, r1, z, z); + } +} + +KERNEL_FQ void m90000_m08 (KERN_ATTR_RULES ()) +{ +} + +KERNEL_FQ void m90000_m16 (KERN_ATTR_RULES ()) +{ +} + +KERNEL_FQ void m90000_s04 (KERN_ATTR_RULES ()) +{ + /** + * modifier + */ + + const u64 lid = get_local_id (0); + + /** + * base + */ + + const u64 gid = get_global_id (0); + + if (gid >= GID_CNT) return; + + u32 pw_buf0[4]; + u32 pw_buf1[4]; + + pw_buf0[0] = pws[gid].i[0]; + pw_buf0[1] = pws[gid].i[1]; + pw_buf0[2] = pws[gid].i[2]; + pw_buf0[3] = pws[gid].i[3]; + pw_buf1[0] = pws[gid].i[4]; + pw_buf1[1] = pws[gid].i[5]; + pw_buf1[2] = pws[gid].i[6]; + pw_buf1[3] = pws[gid].i[7]; + + const u32 pw_len = pws[gid].pw_len & 63; + + /** + * digest + */ + + const u32 search[4] = + { + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R0], + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R1], + 0, + 0 + }; + + /** + * seed + */ + + /** + * loop + */ + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) + { + u32x w[16] = { 0 }; + + const u32x out_len = apply_rules_vect_optimized (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w + 0, w + 4); + + u64x hash = MurmurHash64A (w, out_len); + + const u32x r0 = l32_from_64(hash); + const u32x r1 = h32_from_64(hash); + const u32x z = 0; + + COMPARE_S_SIMD (r0, r1, z, z); + } +} + +KERNEL_FQ void m90000_s08 (KERN_ATTR_RULES ()) +{ +} + +KERNEL_FQ void m90000_s16 (KERN_ATTR_RULES ()) +{ +} diff --git a/OpenCL/m90010_a1-optimized.cl b/OpenCL/m90010_a1-optimized.cl new file mode 100644 index 000000000..788145981 --- /dev/null +++ b/OpenCL/m90010_a1-optimized.cl @@ -0,0 +1,364 @@ +/** + * Author......: See docs/credits.txt + * License.....: MIT + */ + +//too much register pressure +//#define NEW_SIMD_CODE + +#ifdef KERNEL_STATIC +#include M2S(INCLUDE_PATH/inc_vendor.h) +#include M2S(INCLUDE_PATH/inc_types.h) +#include M2S(INCLUDE_PATH/inc_platform.cl) +#include M2S(INCLUDE_PATH/inc_common.cl) +#include M2S(INCLUDE_PATH/inc_simd.cl) +#endif + +DECLSPEC u64 MurmurHash64A_round (PRIVATE_AS const u8 *data, u64 hash, const u32 cur_pos) { + #define M 0xc6a4a7935bd1e995 + #define R 47 + + u64 k = ((u64) data[cur_pos]) + | ((u64) data[cur_pos + 1] << 8) + | ((u64) data[cur_pos + 2] << 16) + | ((u64) data[cur_pos + 3] << 24) + | ((u64) data[cur_pos + 4] << 32) + | ((u64) data[cur_pos + 5] << 40) + | ((u64) data[cur_pos + 6] << 48) + | ((u64) data[cur_pos + 7] << 56); + + k *= M; + k ^= k >> R; + k *= M; + + hash ^= k; + hash *= M; + + #undef M + #undef R + + return hash; +} + +DECLSPEC u64 MurmurHash64A_final (PRIVATE_AS const u8 *data, u64 hash, const u32 cur_pos, const u32 len) { + #define M 0xc6a4a7935bd1e995 + #define R 47 + + const u32 overflow = len & 7; + + switch (overflow) { + case 7: hash ^= ((u64) data[cur_pos + 6]) << 48; + case 6: hash ^= ((u64) data[cur_pos + 5]) << 40; + case 5: hash ^= ((u64) data[cur_pos + 4]) << 32; + case 4: hash ^= ((u64) data[cur_pos + 3]) << 24; + case 3: hash ^= ((u64) data[cur_pos + 2]) << 16; + case 2: hash ^= ((u64) data[cur_pos + 1]) << 8; + case 1: hash ^= ((u64) data[cur_pos]); + hash *= M; + } + + hash ^= hash >> R; + hash *= M; + hash ^= hash >> R; + + #undef M + #undef R + + return hash; +} + +DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) +{ + #define M 0xc6a4a7935bd1e995 + #define R 47 + + //Initialize hash + u64 hash = 0 ^ (len * M); + + //const u64 INITIAL = hash; + + const u32 endpos = len - (len & 7); + + //const u32 nBlocks = len >> 3; // number of 8 byte blocks + const u8 *data2 = (const u8*) data; + + //u64 MIDDLE_OF_BLOCK = 0; + + // Loop over blocks of 8 bytes + u32 i = 0; + while (i != endpos) { + hash = MurmurHash64A_round(data2, hash, i); + + i += 8; + } + + // Overflow + + //const u64 BEFORE_FINAL = hash; + + hash = MurmurHash64A_final (data2, hash, i, len); + + //const u64 AFTER_FINAL = hash; + + //printf("debug: %016lx:%016lx:%c%c%c%c%c%c%c%c%c%c len: %d INITIAL: %016lx MIDDLE_O_BLK: %016lx B4FINAL: %016lx overflow: %d AFTER_FINAL: %016lx\n", hash, seed, data2[0], data2[1], data2[2], data2[3], data2[4], data2[5], data2[6], data2[7], data2[8], data2[9], len, INITIAL, MIDDLE_OF_BLOCK, BEFORE_FINAL, overflow, AFTER_FINAL); + //printf("data2 = %.2s, len = %d\n", data2[0], len); + + #undef M + #undef R + + return hash; +} + +KERNEL_FQ void m90000_m04 (KERN_ATTR_BASIC ()) +{ + /** + * modifier + */ + + const u64 gid = get_global_id (0); + const u64 lid = get_local_id (0); + + if (gid >= GID_CNT) return; + + /** + * base + */ + + u32 pw_buf0[4]; + u32 pw_buf1[4]; + + pw_buf0[0] = pws[gid].i[0]; + pw_buf0[1] = pws[gid].i[1]; + pw_buf0[2] = pws[gid].i[2]; + pw_buf0[3] = pws[gid].i[3]; + pw_buf1[0] = pws[gid].i[4]; + pw_buf1[1] = pws[gid].i[5]; + pw_buf1[2] = pws[gid].i[6]; + pw_buf1[3] = pws[gid].i[7]; + + const u32 pw_l_len = pws[gid].pw_len & 63; + + /** + * seed + */ + + /** + * loop + */ + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) + { + const u32 pw_r_len = pwlenx_create_combt (combs_buf, il_pos) & 63; + + const u32 pw_len = (pw_l_len + pw_r_len) & 63; + + /** + * concat password candidate + */ + + u32 wordl0[4] = { 0 }; + u32 wordl1[4] = { 0 }; + u32 wordl2[4] = { 0 }; + u32 wordl3[4] = { 0 }; + + wordl0[0] = pw_buf0[0]; + wordl0[1] = pw_buf0[1]; + wordl0[2] = pw_buf0[2]; + wordl0[3] = pw_buf0[3]; + wordl1[0] = pw_buf1[0]; + wordl1[1] = pw_buf1[1]; + wordl1[2] = pw_buf1[2]; + wordl1[3] = pw_buf1[3]; + + u32 wordr0[4] = { 0 }; + u32 wordr1[4] = { 0 }; + u32 wordr2[4] = { 0 }; + u32 wordr3[4] = { 0 }; + + wordr0[0] = ix_create_combt (combs_buf, il_pos, 0); + wordr0[1] = ix_create_combt (combs_buf, il_pos, 1); + wordr0[2] = ix_create_combt (combs_buf, il_pos, 2); + wordr0[3] = ix_create_combt (combs_buf, il_pos, 3); + wordr1[0] = ix_create_combt (combs_buf, il_pos, 4); + wordr1[1] = ix_create_combt (combs_buf, il_pos, 5); + wordr1[2] = ix_create_combt (combs_buf, il_pos, 6); + wordr1[3] = ix_create_combt (combs_buf, il_pos, 7); + + if (COMBS_MODE == COMBINATOR_MODE_BASE_LEFT) + { + switch_buffer_by_offset_le_VV (wordr0, wordr1, wordr2, wordr3, pw_l_len); + } + else + { + switch_buffer_by_offset_le_VV (wordl0, wordl1, wordl2, wordl3, pw_r_len); + } + + u32 w[16]; + + w[ 0] = wordl0[0] | wordr0[0]; + w[ 1] = wordl0[1] | wordr0[1]; + w[ 2] = wordl0[2] | wordr0[2]; + w[ 3] = wordl0[3] | wordr0[3]; + w[ 4] = wordl1[0] | wordr1[0]; + w[ 5] = wordl1[1] | wordr1[1]; + w[ 6] = wordl1[2] | wordr1[2]; + w[ 7] = wordl1[3] | wordr1[3]; + w[ 8] = wordl2[0] | wordr2[0]; + w[ 9] = wordl2[1] | wordr2[1]; + w[10] = wordl2[2] | wordr2[2]; + w[11] = wordl2[3] | wordr2[3]; + w[12] = wordl3[0] | wordr3[0]; + w[13] = wordl3[1] | wordr3[1]; + w[14] = wordl3[2] | wordr3[2]; + w[15] = wordl3[3] | wordr3[3]; + + u64x hash = MurmurHash64A (w, pw_len); + + const u32x r0 = l32_from_64(hash); + const u32x r1 = h32_from_64(hash); + const u32x z = 0; + + COMPARE_M_SIMD (r0, r1, z, z); + } +} + +KERNEL_FQ void m90000_m08 (KERN_ATTR_BASIC ()) +{ +} + +KERNEL_FQ void m90000_m16 (KERN_ATTR_BASIC ()) +{ +} + +KERNEL_FQ void m90000_s04 (KERN_ATTR_BASIC ()) +{ + /** + * modifier + */ + + const u64 gid = get_global_id (0); + const u64 lid = get_local_id (0); + + if (gid >= GID_CNT) return; + + /** + * base + */ + + u32 pw_buf0[4]; + u32 pw_buf1[4]; + + pw_buf0[0] = pws[gid].i[0]; + pw_buf0[1] = pws[gid].i[1]; + pw_buf0[2] = pws[gid].i[2]; + pw_buf0[3] = pws[gid].i[3]; + pw_buf1[0] = pws[gid].i[4]; + pw_buf1[1] = pws[gid].i[5]; + pw_buf1[2] = pws[gid].i[6]; + pw_buf1[3] = pws[gid].i[7]; + + const u32 pw_l_len = pws[gid].pw_len & 63; + + /** + * seed + */ + + /** + * digest + */ + + const u32 search[4] = + { + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R0], + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R1], + 0, + 0 + }; + + /** + * loop + */ + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) + { + const u32 pw_r_len = pwlenx_create_combt (combs_buf, il_pos) & 63; + + const u32 pw_len = (pw_l_len + pw_r_len) & 63; + + /** + * concat password candidate + */ + + u32 wordl0[4] = { 0 }; + u32 wordl1[4] = { 0 }; + u32 wordl2[4] = { 0 }; + u32 wordl3[4] = { 0 }; + + wordl0[0] = pw_buf0[0]; + wordl0[1] = pw_buf0[1]; + wordl0[2] = pw_buf0[2]; + wordl0[3] = pw_buf0[3]; + wordl1[0] = pw_buf1[0]; + wordl1[1] = pw_buf1[1]; + wordl1[2] = pw_buf1[2]; + wordl1[3] = pw_buf1[3]; + + u32 wordr0[4] = { 0 }; + u32 wordr1[4] = { 0 }; + u32 wordr2[4] = { 0 }; + u32 wordr3[4] = { 0 }; + + wordr0[0] = ix_create_combt (combs_buf, il_pos, 0); + wordr0[1] = ix_create_combt (combs_buf, il_pos, 1); + wordr0[2] = ix_create_combt (combs_buf, il_pos, 2); + wordr0[3] = ix_create_combt (combs_buf, il_pos, 3); + wordr1[0] = ix_create_combt (combs_buf, il_pos, 4); + wordr1[1] = ix_create_combt (combs_buf, il_pos, 5); + wordr1[2] = ix_create_combt (combs_buf, il_pos, 6); + wordr1[3] = ix_create_combt (combs_buf, il_pos, 7); + + if (COMBS_MODE == COMBINATOR_MODE_BASE_LEFT) + { + switch_buffer_by_offset_le_VV (wordr0, wordr1, wordr2, wordr3, pw_l_len); + } + else + { + switch_buffer_by_offset_le_VV (wordl0, wordl1, wordl2, wordl3, pw_r_len); + } + + u32 w[16]; + + w[ 0] = wordl0[0] | wordr0[0]; + w[ 1] = wordl0[1] | wordr0[1]; + w[ 2] = wordl0[2] | wordr0[2]; + w[ 3] = wordl0[3] | wordr0[3]; + w[ 4] = wordl1[0] | wordr1[0]; + w[ 5] = wordl1[1] | wordr1[1]; + w[ 6] = wordl1[2] | wordr1[2]; + w[ 7] = wordl1[3] | wordr1[3]; + w[ 8] = wordl2[0] | wordr2[0]; + w[ 9] = wordl2[1] | wordr2[1]; + w[10] = wordl2[2] | wordr2[2]; + w[11] = wordl2[3] | wordr2[3]; + w[12] = wordl3[0] | wordr3[0]; + w[13] = wordl3[1] | wordr3[1]; + w[14] = wordl3[2] | wordr3[2]; + w[15] = wordl3[3] | wordr3[3]; + + u64 hash = MurmurHash64A (w, pw_len); + + const u32 r0 = l32_from_64(hash); + const u32 r1 = h32_from_64(hash); + const u32 z = 0; + + COMPARE_S_SIMD (r0, r1, z, z); + } +} + +KERNEL_FQ void m90000_s08 (KERN_ATTR_BASIC ()) +{ +} + +KERNEL_FQ void m90000_s16 (KERN_ATTR_BASIC ()) +{ +} diff --git a/OpenCL/m90010_a3-optimized.cl b/OpenCL/m90010_a3-optimized.cl new file mode 100644 index 000000000..92ff3edaa --- /dev/null +++ b/OpenCL/m90010_a3-optimized.cl @@ -0,0 +1,472 @@ +/** + * Author......: See docs/credits.txt + * License.....: MIT + */ + +//#define NEW_SIMD_CODE + +#ifdef KERNEL_STATIC +#include M2S(INCLUDE_PATH/inc_vendor.h) +#include M2S(INCLUDE_PATH/inc_types.h) +#include M2S(INCLUDE_PATH/inc_platform.cl) +#include M2S(INCLUDE_PATH/inc_common.cl) +#include M2S(INCLUDE_PATH/inc_simd.cl) +#endif + + +DECLSPEC u64x MurmurHash64A (PRIVATE_AS const u32x *data, const u32 len) +{ + #define M 0xc6a4a7935bd1e995 + #define R 47 + + //Initialize hash + u64x hash = 0 ^ (len * M); + + //printf("INITIAL = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + + const u32 endpos = len - (len & 7); + + const u8 *data2 = (const u8*) data; + + //printf("seed = %08x%08x\n", h32_from_64(seed), l32_from_64(seed)); + //printf("data2 = %c%c%c%c%c%c%c%c\n", data2[0], data2[1], data2[2], data2[3], data2[4], data2[5], data2[6], data2[7]); + //printf("len = %d\n", len); + + + // Loop over blocks of 8 bytes + u32 i = 0; + while (i != endpos) { + u64x k = ((u64) data2[i]) + | ((u64) data2[i + 1] << 8) + | ((u64) data2[i + 2] << 16) + | ((u64) data2[i + 3] << 24) + | ((u64) data2[i + 4] << 32) + | ((u64) data2[i + 5] << 40) + | ((u64) data2[i + 6] << 48) + | ((u64) data2[i + 7] << 56); + + k *= M; + k ^= k >> R; + k *= M; + + hash ^= k; + hash *= M; + + i += 8; + } + //printf("BEFORE_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + + // Overflow + + const u32 overflow = len & 7; + + //printf("OVERFLOW = %d\n", overflow); + + switch (overflow) { + case 7: hash ^= ((u64) data2[i + 6]) << 48; + case 6: hash ^= ((u64) data2[i + 5]) << 40; + case 5: hash ^= ((u64) data2[i + 4]) << 32; + case 4: hash ^= ((u64) data2[i + 3]) << 24; + case 3: hash ^= ((u64) data2[i + 2]) << 16; + case 2: hash ^= ((u64) data2[i + 1]) << 8; + case 1: hash ^= ((u64) data2[i]); + hash *= M; + } + + //printf("AFTER_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + + hash ^= hash >> R; + hash *= M; + hash ^= hash >> R; + + #undef M + #undef R + + //printf("hash = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + + return hash; +} + +DECLSPEC void m90000m (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_FUNC_VECTOR ()) +{ + /** + * modifiers are taken from args + */ + + /** + * seed + */ + + /** + * base + */ + + u32x w[16]; + + w[ 0] = data[ 0]; + w[ 1] = data[ 1]; + w[ 2] = data[ 2]; + w[ 3] = data[ 3]; + w[ 4] = data[ 4]; + w[ 5] = data[ 5]; + w[ 6] = data[ 6]; + w[ 7] = data[ 7]; + w[ 8] = data[ 8]; + w[ 9] = data[ 9]; + w[10] = data[10]; + w[11] = data[11]; + w[12] = data[12]; + w[13] = data[13]; + w[14] = data[14]; + w[15] = data[15]; + + //const u8 *data2 = (const u8*) data; + //printf("w = %c%c%c%c%c%c%c%c\n", data2[0], data2[1], data2[2], data2[3], data2[4], data2[5], data2[6], data2[7]); + + /** + * loop + */ + + u32x w0l = w[0]; + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) + { + const u32x w0r = words_buf_r[il_pos / VECT_SIZE]; + + const u32x w0 = w0l | w0r; + + w[0] = w0; + + //printf("seed = %08x%08x\n", seed_hi, seed_lo); + + const u64x hash = MurmurHash64A (w, pw_len); + + const u32x r0 = l32_from_64(hash); + const u32x r1 = h32_from_64(hash); + const u32x z = 0; + + //printf("hash = %08x%08x\n", r1, r0); + + COMPARE_M_SIMD (r0, r1, z, z); + } +} + +DECLSPEC void m90000s (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_FUNC_VECTOR ()) +{ + /** + * modifiers are taken from args + */ + + /** + * digest + */ + + //printf("Hello world m90000s\n"); + + const u32 search[4] = + { + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R0], + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R1], + 0, + 0 + }; + + /** + * seed + */ + + /** + * base + */ + + u32x w[16]; + + w[ 0] = data[ 0]; + w[ 1] = data[ 1]; + w[ 2] = data[ 2]; + w[ 3] = data[ 3]; + w[ 4] = data[ 4]; + w[ 5] = data[ 5]; + w[ 6] = data[ 6]; + w[ 7] = data[ 7]; + w[ 8] = data[ 8]; + w[ 9] = data[ 9]; + w[10] = data[10]; + w[11] = data[11]; + w[12] = data[12]; + w[13] = data[13]; + w[14] = data[14]; + w[15] = data[15]; + + /** + * loop + */ + + u32x w0l = w[0]; + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) + { + const u32x w0r = words_buf_r[il_pos / VECT_SIZE]; + + const u32x w0 = w0l | w0r; + + w[0] = w0; + + const u64x hash = MurmurHash64A (w, pw_len); + + const u32x r0 = l32_from_64(hash); + const u32x r1 = h32_from_64(hash); + const u32x z = 0; + + //printf("r1 = %08x r0 = %08x\n", r1, r0); + //printf("hash = %08x%08x\n", r1, r0); + + COMPARE_S_SIMD (r0, r1, z, z); + } +} + +KERNEL_FQ void m90000_m04 (KERN_ATTR_VECTOR ()) +{ + /** + * base + */ + + //printf("Hello world m90000_m04\n"); + + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + const u64 lsz = get_local_size (0); + + if (gid >= GID_CNT) return; + + u32 w[16]; + + w[ 0] = pws[gid].i[ 0]; + w[ 1] = pws[gid].i[ 1]; + w[ 2] = pws[gid].i[ 2]; + w[ 3] = pws[gid].i[ 3]; + w[ 4] = 0; + w[ 5] = 0; + w[ 6] = 0; + w[ 7] = 0; + w[ 8] = 0; + w[ 9] = 0; + w[10] = 0; + w[11] = 0; + w[12] = 0; + w[13] = 0; + w[14] = 0; + w[15] = 0; + + const u32 pw_len = pws[gid].pw_len & 63; + //printf("pws[gid].pw_len = %d\n", pws[gid].pw_len); + + /** + * main + */ + + m90000m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); +} + +KERNEL_FQ void m90000_m08 (KERN_ATTR_VECTOR ()) +{ + /** + * base + */ + + //printf("Hello world m90000_m08\n"); + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + const u64 lsz = get_local_size (0); + + if (gid >= GID_CNT) return; + + u32 w[16]; + + w[ 0] = pws[gid].i[ 0]; + w[ 1] = pws[gid].i[ 1]; + w[ 2] = pws[gid].i[ 2]; + w[ 3] = pws[gid].i[ 3]; + w[ 4] = pws[gid].i[ 4]; + w[ 5] = pws[gid].i[ 5]; + w[ 6] = pws[gid].i[ 6]; + w[ 7] = pws[gid].i[ 7]; + w[ 8] = 0; + w[ 9] = 0; + w[10] = 0; + w[11] = 0; + w[12] = 0; + w[13] = 0; + w[14] = 0; + w[15] = 0; + + const u32 pw_len = pws[gid].pw_len & 63; + + /** + * main + */ + + m90000m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); +} + +KERNEL_FQ void m90000_m16 (KERN_ATTR_VECTOR ()) +{ + /** + * base + */ + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + const u64 lsz = get_local_size (0); + + if (gid >= GID_CNT) return; + + u32 w[16]; + + w[ 0] = pws[gid].i[ 0]; + w[ 1] = pws[gid].i[ 1]; + w[ 2] = pws[gid].i[ 2]; + w[ 3] = pws[gid].i[ 3]; + w[ 4] = pws[gid].i[ 4]; + w[ 5] = pws[gid].i[ 5]; + w[ 6] = pws[gid].i[ 6]; + w[ 7] = pws[gid].i[ 7]; + w[ 8] = pws[gid].i[ 8]; + w[ 9] = pws[gid].i[ 9]; + w[10] = pws[gid].i[10]; + w[11] = pws[gid].i[11]; + w[12] = pws[gid].i[12]; + w[13] = pws[gid].i[13]; + w[14] = pws[gid].i[14]; + w[15] = pws[gid].i[15]; + + const u32 pw_len = pws[gid].pw_len & 63; + + /** + * main + */ + + m90000m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); +} + +KERNEL_FQ void m90000_s04 (KERN_ATTR_VECTOR ()) +{ + /** + * base + */ + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + const u64 lsz = get_local_size (0); + + if (gid >= GID_CNT) return; + + u32 w[16]; + + w[ 0] = pws[gid].i[ 0]; + w[ 1] = pws[gid].i[ 1]; + w[ 2] = pws[gid].i[ 2]; + w[ 3] = pws[gid].i[ 3]; + w[ 4] = 0; + w[ 5] = 0; + w[ 6] = 0; + w[ 7] = 0; + w[ 8] = 0; + w[ 9] = 0; + w[10] = 0; + w[11] = 0; + w[12] = 0; + w[13] = 0; + w[14] = 0; + w[15] = 0; + + const u32 pw_len = pws[gid].pw_len & 63; + + /** + * main + */ + + m90000s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); +} + +KERNEL_FQ void m90000_s08 (KERN_ATTR_VECTOR ()) +{ + /** + * base + */ + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + const u64 lsz = get_local_size (0); + + if (gid >= GID_CNT) return; + + u32 w[16]; + + w[ 0] = pws[gid].i[ 0]; + w[ 1] = pws[gid].i[ 1]; + w[ 2] = pws[gid].i[ 2]; + w[ 3] = pws[gid].i[ 3]; + w[ 4] = pws[gid].i[ 4]; + w[ 5] = pws[gid].i[ 5]; + w[ 6] = pws[gid].i[ 6]; + w[ 7] = pws[gid].i[ 7]; + w[ 8] = 0; + w[ 9] = 0; + w[10] = 0; + w[11] = 0; + w[12] = 0; + w[13] = 0; + w[14] = 0; + w[15] = 0; + + const u32 pw_len = pws[gid].pw_len & 63; + + /** + * main + */ + + m90000s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); +} + +KERNEL_FQ void m90000_s16 (KERN_ATTR_VECTOR ()) +{ + /** + * base + */ + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + const u64 lsz = get_local_size (0); + + if (gid >= GID_CNT) return; + + u32 w[16]; + + w[ 0] = pws[gid].i[ 0]; + w[ 1] = pws[gid].i[ 1]; + w[ 2] = pws[gid].i[ 2]; + w[ 3] = pws[gid].i[ 3]; + w[ 4] = pws[gid].i[ 4]; + w[ 5] = pws[gid].i[ 5]; + w[ 6] = pws[gid].i[ 6]; + w[ 7] = pws[gid].i[ 7]; + w[ 8] = pws[gid].i[ 8]; + w[ 9] = pws[gid].i[ 9]; + w[10] = pws[gid].i[10]; + w[11] = pws[gid].i[11]; + w[12] = pws[gid].i[12]; + w[13] = pws[gid].i[13]; + w[14] = pws[gid].i[14]; + w[15] = pws[gid].i[15]; + + const u32 pw_len = pws[gid].pw_len & 63; + + /** + * main + */ + + m90000s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); +} diff --git a/src/modules/module_90010.c b/src/modules/module_90010.c new file mode 100644 index 000000000..953a722e9 --- /dev/null +++ b/src/modules/module_90010.c @@ -0,0 +1,174 @@ +/** + * Author......: See docs/credits.txt + * License.....: MIT + */ + +#include "common.h" +#include "types.h" +#include "modules.h" +#include "bitops.h" +#include "convert.h" +#include "shared.h" + +static const u32 ATTACK_EXEC = ATTACK_EXEC_INSIDE_KERNEL; +static const u32 DGST_POS0 = 0; +static const u32 DGST_POS1 = 1; +static const u32 DGST_POS2 = 2; +static const u32 DGST_POS3 = 3; +static const u32 DGST_SIZE = DGST_SIZE_8_2; +static const u32 HASH_CATEGORY = HASH_CATEGORY_RAW_HASH; +static const char *HASH_NAME = "MurmurHash64A Zero Seed"; +static const u64 KERN_TYPE = 90010; +static const u32 OPTI_TYPE = OPTI_TYPE_ZERO_BYTE + | OPTI_TYPE_USES_BITS_64; +static const u64 OPTS_TYPE = OPTS_TYPE_STOCK_MODULE + | OPTS_TYPE_PT_GENERATE_LE + | OPTS_TYPE_SUGGEST_KG; +static const u32 SALT_TYPE = SALT_TYPE_NONE; +static const char *ST_PASS = "hashcat"; +static const char *ST_HASH = "73f8142b4326d36a"; + +u32 module_attack_exec (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return ATTACK_EXEC; } +u32 module_dgst_pos0 (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS0; } +u32 module_dgst_pos1 (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS1; } +u32 module_dgst_pos2 (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS2; } +u32 module_dgst_pos3 (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS3; } +u32 module_dgst_size (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_SIZE; } +u32 module_hash_category (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return HASH_CATEGORY; } +const char *module_hash_name (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return HASH_NAME; } +u64 module_kern_type (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return KERN_TYPE; } +u32 module_opti_type (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return OPTI_TYPE; } +u64 module_opts_type (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return OPTS_TYPE; } +u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return SALT_TYPE; } +const char *module_st_hash (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return ST_HASH; } +const char *module_st_pass (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return ST_PASS; } + +int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED void *digest_buf, MAYBE_UNUSED salt_t *salt, MAYBE_UNUSED void *esalt_buf, MAYBE_UNUSED void *hook_salt_buf, MAYBE_UNUSED hashinfo_t *hash_info, const char *line_buf, MAYBE_UNUSED const int line_len) +{ + u64 *digest = (u64 *) digest_buf; + + hc_token_t token; + + memset (&token, 0, sizeof (hc_token_t)); + + token.token_cnt = 1; + + token.len[0] = 16; + token.attr[0] = TOKEN_ATTR_FIXED_LENGTH + | TOKEN_ATTR_VERIFY_HEX; + + const int rc_tokenizer = input_tokenizer ((const u8 *) line_buf, line_len, &token); + + if (rc_tokenizer != PARSER_OK) return (rc_tokenizer); + + // digest + + const u8 *hash_pos = token.buf[0]; + // we have 16 chars (hash hex string, big endian) + + + digest[0] = ((hex_to_u64 (&hash_pos[0]))); + digest[1] = 0; + + digest[0] = byte_swap_64 (digest[0]); + + // now `digest` contains a proper little endian u64 + + return (PARSER_OK); +} + +int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const void *digest_buf, MAYBE_UNUSED const salt_t *salt, MAYBE_UNUSED const void *esalt_buf, MAYBE_UNUSED const void *hook_salt_buf, MAYBE_UNUSED const hashinfo_t *hash_info, char *line_buf, MAYBE_UNUSED const int line_size) +{ + const u64 *digest = (const u64 *) digest_buf; + + // we can not change anything in the original buffer, otherwise destroying sorting + // therefore create some local buffer + + u8 *out_buf = (u8 *) line_buf; + + const int out_len = 16; + + u64_to_hex (byte_swap_64 (digest[0]), out_buf); + + return out_len; +} + +void module_init (module_ctx_t *module_ctx) +{ + module_ctx->module_context_size = MODULE_CONTEXT_SIZE_CURRENT; + module_ctx->module_interface_version = MODULE_INTERFACE_VERSION_CURRENT; + + module_ctx->module_attack_exec = module_attack_exec; + module_ctx->module_benchmark_esalt = MODULE_DEFAULT; + module_ctx->module_benchmark_hook_salt = MODULE_DEFAULT; + module_ctx->module_benchmark_mask = MODULE_DEFAULT; + module_ctx->module_benchmark_charset = MODULE_DEFAULT; + module_ctx->module_benchmark_salt = MODULE_DEFAULT; + module_ctx->module_build_plain_postprocess = MODULE_DEFAULT; + module_ctx->module_deep_comp_kernel = MODULE_DEFAULT; + module_ctx->module_deprecated_notice = MODULE_DEFAULT; + module_ctx->module_dgst_pos0 = module_dgst_pos0; + module_ctx->module_dgst_pos1 = module_dgst_pos1; + module_ctx->module_dgst_pos2 = module_dgst_pos2; + module_ctx->module_dgst_pos3 = module_dgst_pos3; + module_ctx->module_dgst_size = module_dgst_size; + module_ctx->module_dictstat_disable = MODULE_DEFAULT; + module_ctx->module_esalt_size = MODULE_DEFAULT; + module_ctx->module_extra_buffer_size = MODULE_DEFAULT; + module_ctx->module_extra_tmp_size = MODULE_DEFAULT; + module_ctx->module_extra_tuningdb_block = MODULE_DEFAULT; + module_ctx->module_forced_outfile_format = MODULE_DEFAULT; + module_ctx->module_hash_binary_count = MODULE_DEFAULT; + module_ctx->module_hash_binary_parse = MODULE_DEFAULT; + module_ctx->module_hash_binary_save = MODULE_DEFAULT; + module_ctx->module_hash_decode_postprocess = MODULE_DEFAULT; + module_ctx->module_hash_decode_potfile = MODULE_DEFAULT; + module_ctx->module_hash_decode_zero_hash = MODULE_DEFAULT; + module_ctx->module_hash_decode = module_hash_decode; + module_ctx->module_hash_encode_status = MODULE_DEFAULT; + module_ctx->module_hash_encode_potfile = MODULE_DEFAULT; + module_ctx->module_hash_encode = module_hash_encode; + module_ctx->module_hash_init_selftest = MODULE_DEFAULT; + module_ctx->module_hash_mode = MODULE_DEFAULT; + module_ctx->module_hash_category = module_hash_category; + module_ctx->module_hash_name = module_hash_name; + module_ctx->module_hashes_count_min = MODULE_DEFAULT; + module_ctx->module_hashes_count_max = MODULE_DEFAULT; + module_ctx->module_hlfmt_disable = MODULE_DEFAULT; + module_ctx->module_hook_extra_param_size = MODULE_DEFAULT; + module_ctx->module_hook_extra_param_init = MODULE_DEFAULT; + module_ctx->module_hook_extra_param_term = MODULE_DEFAULT; + module_ctx->module_hook12 = MODULE_DEFAULT; + module_ctx->module_hook23 = MODULE_DEFAULT; + module_ctx->module_hook_salt_size = MODULE_DEFAULT; + module_ctx->module_hook_size = MODULE_DEFAULT; + module_ctx->module_jit_build_options = MODULE_DEFAULT; + module_ctx->module_jit_cache_disable = MODULE_DEFAULT; + module_ctx->module_kernel_accel_max = MODULE_DEFAULT; + module_ctx->module_kernel_accel_min = MODULE_DEFAULT; + module_ctx->module_kernel_loops_max = MODULE_DEFAULT; + module_ctx->module_kernel_loops_min = MODULE_DEFAULT; + module_ctx->module_kernel_threads_max = MODULE_DEFAULT; + module_ctx->module_kernel_threads_min = MODULE_DEFAULT; + module_ctx->module_kern_type = module_kern_type; + module_ctx->module_kern_type_dynamic = MODULE_DEFAULT; + module_ctx->module_opti_type = module_opti_type; + module_ctx->module_opts_type = module_opts_type; + module_ctx->module_outfile_check_disable = MODULE_DEFAULT; + module_ctx->module_outfile_check_nocomp = MODULE_DEFAULT; + module_ctx->module_potfile_custom_check = MODULE_DEFAULT; + module_ctx->module_potfile_disable = MODULE_DEFAULT; + module_ctx->module_potfile_keep_all_hashes = MODULE_DEFAULT; + module_ctx->module_pwdump_column = MODULE_DEFAULT; + module_ctx->module_pw_max = MODULE_DEFAULT; + module_ctx->module_pw_min = MODULE_DEFAULT; + module_ctx->module_salt_max = MODULE_DEFAULT; + module_ctx->module_salt_min = MODULE_DEFAULT; + module_ctx->module_salt_type = module_salt_type; + module_ctx->module_separator = MODULE_DEFAULT; + module_ctx->module_st_hash = module_st_hash; + module_ctx->module_st_pass = module_st_pass; + module_ctx->module_tmp_size = MODULE_DEFAULT; + module_ctx->module_unstable_warning = MODULE_DEFAULT; + module_ctx->module_warmup_disable = MODULE_DEFAULT; +} diff --git a/tools/test_modules/m90010.pm b/tools/test_modules/m90010.pm new file mode 100644 index 000000000..af5e2e581 --- /dev/null +++ b/tools/test_modules/m90010.pm @@ -0,0 +1,152 @@ +#!/usr/bin/env perl + +## +## Author......: See docs/credits.txt +## License.....: MIT +## + +use strict; +use warnings; +use Math::BigInt; + +sub module_constraints { [[0, 256], [-1, -1], [0, 63], [-1, -1], [0, 63]] } + +sub wrapping_mul +{ + my $a = shift; + my $b = shift; + + # 2**64 + my $width = Math::BigInt->new("0x10000000000000000"); + + return ($a * $b)->bmod($width); +} + +sub murmurhash64a +{ + use integer; + + my $word = shift; + my $seed = 0; + + # https://gitlab.com/lschwiderski/vt2_bundle_unpacker/-/blob/master/src/murmur/murmurhash64.rs + # 'm' and 'r' are mixing constants generated offline. + # They're not really 'magic', they just happen to work well. + + my $m = Math::BigInt->new("0xc6a4a7935bd1e995"); + #my $m = 0xc6a4a7935bd1e995; + my $r = 47; + + my @chars = unpack ("C*", $word); + my $len = length $word; + + my $hash = $seed ^ wrapping_mul ($len, $m); + + my $endpos = $len - ($len & 7); + my $i; + + for ($i = 0; $i < $endpos; $i += 8) + { + my $c0 = $chars[$i + 0]; + my $c1 = $chars[$i + 1]; + my $c2 = $chars[$i + 2]; + my $c3 = $chars[$i + 3]; + my $c4 = $chars[$i + 4]; + my $c5 = $chars[$i + 5]; + my $c6 = $chars[$i + 6]; + my $c7 = $chars[$i + 7]; + + my $k = ($c0 << 0) + | ($c1 << 8) + | ($c2 << 16) + | ($c3 << 24) + | ($c4 << 32) + | ($c5 << 40) + | ($c6 << 48) + | ($c7 << 56); + + $k = wrapping_mul ($k, $m); + $k ^= $k >> $r; + $k = wrapping_mul ($k, $m); + + $hash ^= $k; + $hash = wrapping_mul ($hash, $m); + } + + my $overflow = $len & 7; + + if ($overflow == 7) + { + $hash ^= $chars[$i + 6] << 48; + } + if ($overflow >= 6) + { + $hash ^= $chars[$i + 5] << 40; + } + if ($overflow >= 5) + { + $hash ^= $chars[$i + 4] << 32; + } + if ($overflow >= 4) + { + $hash ^= $chars[$i + 3] << 24; + } + if ($overflow >= 3) + { + $hash ^= $chars[$i + 2] << 16; + } + if ($overflow >= 2) + { + $hash ^= $chars[$i + 1] << 8; + } + if ($overflow >= 1) + { + $hash ^= $chars[$i + 0] << 0; + } + + if ($overflow > 0) + { + $hash = wrapping_mul ($hash, $m); + } + + $hash ^= $hash >> $r; + $hash = wrapping_mul ($hash, $m); + $hash ^= $hash >> $r; + + return $hash; +} + +sub module_generate_hash +{ + my $word = shift; + + my $digest = murmurhash64a ($word); + + $digest = unpack ("H*", pack ("Q>", $digest)); + + my $hash = sprintf ("%s", $digest); + + return $hash; +} + +sub module_verify_hash +{ + my $line = shift; + + my ($hash, $word) = split (':', $line, 2); + + return unless defined $hash; + return unless defined $word; + + return unless length $hash == 16; + + return unless ($hash =~ m/^[0-9a-fA-F]{16}$/); + + my $word_packed = pack_if_HEX_notation ($word); + + my $new_hash = module_generate_hash ($word_packed); + + return ($new_hash, $word); +} + +1; From b8255cd55583c09bf6a45e3ed09e5c19e647ad8d Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Fri, 8 Nov 2024 11:50:50 +1100 Subject: [PATCH 34/61] 90010 fixes --- OpenCL/m90010_a0-optimized.cl | 12 ++++++------ OpenCL/m90010_a1-optimized.cl | 12 ++++++------ OpenCL/m90010_a3-optimized.cl | 34 +++++++++++++++++----------------- 3 files changed, 29 insertions(+), 29 deletions(-) diff --git a/OpenCL/m90010_a0-optimized.cl b/OpenCL/m90010_a0-optimized.cl index 5b1768733..ba8af81ae 100644 --- a/OpenCL/m90010_a0-optimized.cl +++ b/OpenCL/m90010_a0-optimized.cl @@ -112,7 +112,7 @@ DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) -KERNEL_FQ void m90000_m04 (KERN_ATTR_RULES ()) +KERNEL_FQ void m90010_m04 (KERN_ATTR_RULES ()) { /** * modifier @@ -166,15 +166,15 @@ KERNEL_FQ void m90000_m04 (KERN_ATTR_RULES ()) } } -KERNEL_FQ void m90000_m08 (KERN_ATTR_RULES ()) +KERNEL_FQ void m90010_m08 (KERN_ATTR_RULES ()) { } -KERNEL_FQ void m90000_m16 (KERN_ATTR_RULES ()) +KERNEL_FQ void m90010_m16 (KERN_ATTR_RULES ()) { } -KERNEL_FQ void m90000_s04 (KERN_ATTR_RULES ()) +KERNEL_FQ void m90010_s04 (KERN_ATTR_RULES ()) { /** * modifier @@ -240,10 +240,10 @@ KERNEL_FQ void m90000_s04 (KERN_ATTR_RULES ()) } } -KERNEL_FQ void m90000_s08 (KERN_ATTR_RULES ()) +KERNEL_FQ void m90010_s08 (KERN_ATTR_RULES ()) { } -KERNEL_FQ void m90000_s16 (KERN_ATTR_RULES ()) +KERNEL_FQ void m90010_s16 (KERN_ATTR_RULES ()) { } diff --git a/OpenCL/m90010_a1-optimized.cl b/OpenCL/m90010_a1-optimized.cl index 788145981..1084b8f3c 100644 --- a/OpenCL/m90010_a1-optimized.cl +++ b/OpenCL/m90010_a1-optimized.cl @@ -109,7 +109,7 @@ DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) return hash; } -KERNEL_FQ void m90000_m04 (KERN_ATTR_BASIC ()) +KERNEL_FQ void m90010_m04 (KERN_ATTR_BASIC ()) { /** * modifier @@ -222,15 +222,15 @@ KERNEL_FQ void m90000_m04 (KERN_ATTR_BASIC ()) } } -KERNEL_FQ void m90000_m08 (KERN_ATTR_BASIC ()) +KERNEL_FQ void m90010_m08 (KERN_ATTR_BASIC ()) { } -KERNEL_FQ void m90000_m16 (KERN_ATTR_BASIC ()) +KERNEL_FQ void m90010_m16 (KERN_ATTR_BASIC ()) { } -KERNEL_FQ void m90000_s04 (KERN_ATTR_BASIC ()) +KERNEL_FQ void m90010_s04 (KERN_ATTR_BASIC ()) { /** * modifier @@ -355,10 +355,10 @@ KERNEL_FQ void m90000_s04 (KERN_ATTR_BASIC ()) } } -KERNEL_FQ void m90000_s08 (KERN_ATTR_BASIC ()) +KERNEL_FQ void m90010_s08 (KERN_ATTR_BASIC ()) { } -KERNEL_FQ void m90000_s16 (KERN_ATTR_BASIC ()) +KERNEL_FQ void m90010_s16 (KERN_ATTR_BASIC ()) { } diff --git a/OpenCL/m90010_a3-optimized.cl b/OpenCL/m90010_a3-optimized.cl index 92ff3edaa..1454db57f 100644 --- a/OpenCL/m90010_a3-optimized.cl +++ b/OpenCL/m90010_a3-optimized.cl @@ -87,7 +87,7 @@ DECLSPEC u64x MurmurHash64A (PRIVATE_AS const u32x *data, const u32 len) return hash; } -DECLSPEC void m90000m (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_FUNC_VECTOR ()) +DECLSPEC void m90010m (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_FUNC_VECTOR ()) { /** * modifiers are taken from args @@ -151,7 +151,7 @@ DECLSPEC void m90000m (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F } } -DECLSPEC void m90000s (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_FUNC_VECTOR ()) +DECLSPEC void m90010s (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_FUNC_VECTOR ()) { /** * modifiers are taken from args @@ -161,7 +161,7 @@ DECLSPEC void m90000s (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F * digest */ - //printf("Hello world m90000s\n"); + //printf("Hello world m90010s\n"); const u32 search[4] = { @@ -225,13 +225,13 @@ DECLSPEC void m90000s (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F } } -KERNEL_FQ void m90000_m04 (KERN_ATTR_VECTOR ()) +KERNEL_FQ void m90010_m04 (KERN_ATTR_VECTOR ()) { /** * base */ - //printf("Hello world m90000_m04\n"); + //printf("Hello world m90010_m04\n"); const u64 lid = get_local_id (0); @@ -266,16 +266,16 @@ KERNEL_FQ void m90000_m04 (KERN_ATTR_VECTOR ()) * main */ - m90000m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); + m90010m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ void m90000_m08 (KERN_ATTR_VECTOR ()) +KERNEL_FQ void m90010_m08 (KERN_ATTR_VECTOR ()) { /** * base */ - //printf("Hello world m90000_m08\n"); + //printf("Hello world m90010_m08\n"); const u64 lid = get_local_id (0); const u64 gid = get_global_id (0); @@ -308,10 +308,10 @@ KERNEL_FQ void m90000_m08 (KERN_ATTR_VECTOR ()) * main */ - m90000m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); + m90010m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ void m90000_m16 (KERN_ATTR_VECTOR ()) +KERNEL_FQ void m90010_m16 (KERN_ATTR_VECTOR ()) { /** * base @@ -348,10 +348,10 @@ KERNEL_FQ void m90000_m16 (KERN_ATTR_VECTOR ()) * main */ - m90000m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); + m90010m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ void m90000_s04 (KERN_ATTR_VECTOR ()) +KERNEL_FQ void m90010_s04 (KERN_ATTR_VECTOR ()) { /** * base @@ -388,10 +388,10 @@ KERNEL_FQ void m90000_s04 (KERN_ATTR_VECTOR ()) * main */ - m90000s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); + m90010s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ void m90000_s08 (KERN_ATTR_VECTOR ()) +KERNEL_FQ void m90010_s08 (KERN_ATTR_VECTOR ()) { /** * base @@ -428,10 +428,10 @@ KERNEL_FQ void m90000_s08 (KERN_ATTR_VECTOR ()) * main */ - m90000s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); + m90010s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ void m90000_s16 (KERN_ATTR_VECTOR ()) +KERNEL_FQ void m90010_s16 (KERN_ATTR_VECTOR ()) { /** * base @@ -468,5 +468,5 @@ KERNEL_FQ void m90000_s16 (KERN_ATTR_VECTOR ()) * main */ - m90000s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); + m90010s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } From efe491bf13e85dbb1d732c1b2521717aa4a149f8 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Fri, 8 Nov 2024 14:35:33 +1100 Subject: [PATCH 35/61] Define pw_max as 63 for optimized kernels --- src/modules/module_90010.c | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/src/modules/module_90010.c b/src/modules/module_90010.c index 953a722e9..d77421b73 100644 --- a/src/modules/module_90010.c +++ b/src/modules/module_90010.c @@ -20,7 +20,8 @@ static const u32 HASH_CATEGORY = HASH_CATEGORY_RAW_HASH; static const char *HASH_NAME = "MurmurHash64A Zero Seed"; static const u64 KERN_TYPE = 90010; static const u32 OPTI_TYPE = OPTI_TYPE_ZERO_BYTE - | OPTI_TYPE_USES_BITS_64; + | OPTI_TYPE_USES_BITS_64 + | OPTI_TYPE_NOT_SALTED; static const u64 OPTS_TYPE = OPTS_TYPE_STOCK_MODULE | OPTS_TYPE_PT_GENERATE_LE | OPTS_TYPE_SUGGEST_KG; @@ -43,6 +44,15 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig, const char *module_st_hash (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return ST_HASH; } const char *module_st_pass (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return ST_PASS; } +u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) +{ + const bool optimized_kernel = (hashconfig->opti_type & OPTI_TYPE_OPTIMIZED_KERNEL); + + const u32 pw_max = (optimized_kernel == true) ? 63 : PW_MAX; + + return pw_max; +} + int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED void *digest_buf, MAYBE_UNUSED salt_t *salt, MAYBE_UNUSED void *esalt_buf, MAYBE_UNUSED void *hook_salt_buf, MAYBE_UNUSED hashinfo_t *hash_info, const char *line_buf, MAYBE_UNUSED const int line_len) { u64 *digest = (u64 *) digest_buf; @@ -160,7 +170,7 @@ void module_init (module_ctx_t *module_ctx) module_ctx->module_potfile_disable = MODULE_DEFAULT; module_ctx->module_potfile_keep_all_hashes = MODULE_DEFAULT; module_ctx->module_pwdump_column = MODULE_DEFAULT; - module_ctx->module_pw_max = MODULE_DEFAULT; + module_ctx->module_pw_max = module_pw_max; module_ctx->module_pw_min = MODULE_DEFAULT; module_ctx->module_salt_max = MODULE_DEFAULT; module_ctx->module_salt_min = MODULE_DEFAULT; From eb23e846ebaa7bd16f7c9d83d344e57352bdc772 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Sat, 9 Nov 2024 15:03:53 +1100 Subject: [PATCH 36/61] Optimized kernels have max pw len of 32 --- OpenCL/m90010_a0-optimized.cl | 131 ++++++++++++++-------------------- OpenCL/m90010_a1-optimized.cl | 119 +++++++++++++----------------- OpenCL/m90010_a3-optimized.cl | 67 ++++++++--------- src/modules/module_90010.c | 2 +- 4 files changed, 140 insertions(+), 179 deletions(-) diff --git a/OpenCL/m90010_a0-optimized.cl b/OpenCL/m90010_a0-optimized.cl index ba8af81ae..ca8f99823 100644 --- a/OpenCL/m90010_a0-optimized.cl +++ b/OpenCL/m90010_a0-optimized.cl @@ -15,59 +15,6 @@ #include M2S(INCLUDE_PATH/inc_simd.cl) #endif -DECLSPEC u64 MurmurHash64A_round (PRIVATE_AS const u8 *data, u64 hash, const u32 cur_pos) { - #define M 0xc6a4a7935bd1e995 - #define R 47 - - u64 k = ((u64) data[cur_pos]) - | ((u64) data[cur_pos + 1] << 8) - | ((u64) data[cur_pos + 2] << 16) - | ((u64) data[cur_pos + 3] << 24) - | ((u64) data[cur_pos + 4] << 32) - | ((u64) data[cur_pos + 5] << 40) - | ((u64) data[cur_pos + 6] << 48) - | ((u64) data[cur_pos + 7] << 56); - - k *= M; - k ^= k >> R; - k *= M; - - hash ^= k; - hash *= M; - - #undef M - #undef R - - return hash; -} - -DECLSPEC u64 MurmurHash64A_final (PRIVATE_AS const u8 *data, u64 hash, const u32 cur_pos, const u32 len) { - #define M 0xc6a4a7935bd1e995 - #define R 47 - - const u32 overflow = len & 7; - - switch (overflow) { - case 7: hash ^= ((u64) data[cur_pos + 6]) << 48; - case 6: hash ^= ((u64) data[cur_pos + 5]) << 40; - case 5: hash ^= ((u64) data[cur_pos + 4]) << 32; - case 4: hash ^= ((u64) data[cur_pos + 3]) << 24; - case 3: hash ^= ((u64) data[cur_pos + 2]) << 16; - case 2: hash ^= ((u64) data[cur_pos + 1]) << 8; - case 1: hash ^= ((u64) data[cur_pos]); - hash *= M; - } - - hash ^= hash >> R; - hash *= M; - hash ^= hash >> R; - - #undef M - #undef R - - return hash; -} - DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) { #define M 0xc6a4a7935bd1e995 @@ -76,37 +23,71 @@ DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) //Initialize hash u64 hash = 0 ^ (len * M); - //const u64 INITIAL = hash; - - const u32 endpos = len - (len & 7); + //printf("len = %d\n", len); + //printf("INITIAL = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); - //const u32 nBlocks = len >> 3; // number of 8 byte blocks - const u8 *data2 = (const u8*) data; + // 2 for each u64 block + const u32 num_blocks = (len / 8) * 2; - //u64 MIDDLE_OF_BLOCK = 0; + //printf("num_blocks = %d\n", num_blocks); // Loop over blocks of 8 bytes u32 i = 0; - while (i != endpos) { - hash = MurmurHash64A_round(data2, hash, i); + while (i < num_blocks) { + u64 k = hl32_to_64 (data[i + 1], data[i]); - i += 8; + k *= M; + k ^= k >> R; + k *= M; + + hash ^= k; + hash *= M; + + i += 2; } + //printf("BEFORE_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + // Overflow - //const u64 BEFORE_FINAL = hash; + const u32 overflow = len & 7; - hash = MurmurHash64A_final (data2, hash, i, len); + //printf("OVERFLOW = %d\n", overflow); - //const u64 AFTER_FINAL = hash; + //printf("data = %08x%08x%08x%08x%08x%08x%08x%08x%08x%08x\n", data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9]); - //printf("debug: %016lx:%016lx:%c%c%c%c%c%c%c%c%c%c len: %d INITIAL: %016lx MIDDLE_O_BLK: %016lx B4FINAL: %016lx overflow: %d AFTER_FINAL: %016lx\n", hash, seed, data2[0], data2[1], data2[2], data2[3], data2[4], data2[5], data2[6], data2[7], data2[8], data2[9], len, INITIAL, MIDDLE_OF_BLOCK, BEFORE_FINAL, overflow, AFTER_FINAL); - //printf("data2 = %.2s, len = %d\n", data2[0], len); + //printf("i = %d\n", i); + //printf("data[i] data[i + 1] = %08x%08x\n", data[i], data[i + 1]); + + // can we turn this into a single xor + + if ((overflow > 0) && (overflow <= 4)) { + //printf("Overflow case 1\n"); + hash ^= hl32_to_64 (data[i + 1], data[i]); + hash *= M; + } + + else if (overflow > 4) { + //printf("Overflow case 2\n"); + //printf("tmp = %08x%08x\n", h32_from_64(tmp), l32_from_64(tmp)); + hash ^= hl32_to_64 (data[i + 1], data[i]); + hash *= M; + } + + //u64 test = hl32_to_64 (0x0a16869e, 0xcb107f54); + //printf("hl32_to_64 test = %08x%08x\n", h32_from_64(test), l32_from_64(test)); + + //printf("AFTER_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + + hash ^= hash >> R; + hash *= M; + hash ^= hash >> R; #undef M #undef R + //printf("hash = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + return hash; } @@ -114,6 +95,7 @@ DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) KERNEL_FQ void m90010_m04 (KERN_ATTR_RULES ()) { + //printf("Hello world m90010_m04\n"); /** * modifier */ @@ -140,11 +122,8 @@ KERNEL_FQ void m90010_m04 (KERN_ATTR_RULES ()) pw_buf1[2] = pws[gid].i[6]; pw_buf1[3] = pws[gid].i[7]; - const u32 pw_len = pws[gid].pw_len & 63; - - /** - * seed - */ + // max pw len of 32 + const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; /** * loop @@ -176,6 +155,7 @@ KERNEL_FQ void m90010_m16 (KERN_ATTR_RULES ()) KERNEL_FQ void m90010_s04 (KERN_ATTR_RULES ()) { + //printf("Hello world m90010_s04\n"); /** * modifier */ @@ -202,7 +182,8 @@ KERNEL_FQ void m90010_s04 (KERN_ATTR_RULES ()) pw_buf1[2] = pws[gid].i[6]; pw_buf1[3] = pws[gid].i[7]; - const u32 pw_len = pws[gid].pw_len & 63; + // max pw len of 32 + const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; /** * digest @@ -216,10 +197,6 @@ KERNEL_FQ void m90010_s04 (KERN_ATTR_RULES ()) 0 }; - /** - * seed - */ - /** * loop */ diff --git a/OpenCL/m90010_a1-optimized.cl b/OpenCL/m90010_a1-optimized.cl index 1084b8f3c..d5185fc9a 100644 --- a/OpenCL/m90010_a1-optimized.cl +++ b/OpenCL/m90010_a1-optimized.cl @@ -14,59 +14,6 @@ #include M2S(INCLUDE_PATH/inc_simd.cl) #endif -DECLSPEC u64 MurmurHash64A_round (PRIVATE_AS const u8 *data, u64 hash, const u32 cur_pos) { - #define M 0xc6a4a7935bd1e995 - #define R 47 - - u64 k = ((u64) data[cur_pos]) - | ((u64) data[cur_pos + 1] << 8) - | ((u64) data[cur_pos + 2] << 16) - | ((u64) data[cur_pos + 3] << 24) - | ((u64) data[cur_pos + 4] << 32) - | ((u64) data[cur_pos + 5] << 40) - | ((u64) data[cur_pos + 6] << 48) - | ((u64) data[cur_pos + 7] << 56); - - k *= M; - k ^= k >> R; - k *= M; - - hash ^= k; - hash *= M; - - #undef M - #undef R - - return hash; -} - -DECLSPEC u64 MurmurHash64A_final (PRIVATE_AS const u8 *data, u64 hash, const u32 cur_pos, const u32 len) { - #define M 0xc6a4a7935bd1e995 - #define R 47 - - const u32 overflow = len & 7; - - switch (overflow) { - case 7: hash ^= ((u64) data[cur_pos + 6]) << 48; - case 6: hash ^= ((u64) data[cur_pos + 5]) << 40; - case 5: hash ^= ((u64) data[cur_pos + 4]) << 32; - case 4: hash ^= ((u64) data[cur_pos + 3]) << 24; - case 3: hash ^= ((u64) data[cur_pos + 2]) << 16; - case 2: hash ^= ((u64) data[cur_pos + 1]) << 8; - case 1: hash ^= ((u64) data[cur_pos]); - hash *= M; - } - - hash ^= hash >> R; - hash *= M; - hash ^= hash >> R; - - #undef M - #undef R - - return hash; -} - DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) { #define M 0xc6a4a7935bd1e995 @@ -75,37 +22,71 @@ DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) //Initialize hash u64 hash = 0 ^ (len * M); - //const u64 INITIAL = hash; - - const u32 endpos = len - (len & 7); + //printf("len = %d\n", len); + //printf("INITIAL = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); - //const u32 nBlocks = len >> 3; // number of 8 byte blocks - const u8 *data2 = (const u8*) data; + // 2 for each u64 block + const u32 num_blocks = (len / 8) * 2; - //u64 MIDDLE_OF_BLOCK = 0; + //printf("num_blocks = %d\n", num_blocks); // Loop over blocks of 8 bytes u32 i = 0; - while (i != endpos) { - hash = MurmurHash64A_round(data2, hash, i); + while (i < num_blocks) { + u64 k = hl32_to_64 (data[i + 1], data[i]); - i += 8; + k *= M; + k ^= k >> R; + k *= M; + + hash ^= k; + hash *= M; + + i += 2; } + //printf("BEFORE_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + // Overflow - //const u64 BEFORE_FINAL = hash; + const u32 overflow = len & 7; - hash = MurmurHash64A_final (data2, hash, i, len); + //printf("OVERFLOW = %d\n", overflow); - //const u64 AFTER_FINAL = hash; + //printf("data = %08x%08x%08x%08x%08x%08x%08x%08x%08x%08x\n", data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9]); - //printf("debug: %016lx:%016lx:%c%c%c%c%c%c%c%c%c%c len: %d INITIAL: %016lx MIDDLE_O_BLK: %016lx B4FINAL: %016lx overflow: %d AFTER_FINAL: %016lx\n", hash, seed, data2[0], data2[1], data2[2], data2[3], data2[4], data2[5], data2[6], data2[7], data2[8], data2[9], len, INITIAL, MIDDLE_OF_BLOCK, BEFORE_FINAL, overflow, AFTER_FINAL); - //printf("data2 = %.2s, len = %d\n", data2[0], len); + //printf("i = %d\n", i); + //printf("data[i] data[i + 1] = %08x%08x\n", data[i], data[i + 1]); + + // can we turn this into a single xor + + if ((overflow > 0) && (overflow <= 4)) { + //printf("Overflow case 1\n"); + hash ^= hl32_to_64 (data[i + 1], data[i]); + hash *= M; + } + + else if (overflow > 4) { + //printf("Overflow case 2\n"); + //printf("tmp = %08x%08x\n", h32_from_64(tmp), l32_from_64(tmp)); + hash ^= hl32_to_64 (data[i + 1], data[i]); + hash *= M; + } + + //u64 test = hl32_to_64 (0x0a16869e, 0xcb107f54); + //printf("hl32_to_64 test = %08x%08x\n", h32_from_64(test), l32_from_64(test)); + + //printf("AFTER_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + + hash ^= hash >> R; + hash *= M; + hash ^= hash >> R; #undef M #undef R + //printf("hash = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + return hash; } @@ -136,7 +117,7 @@ KERNEL_FQ void m90010_m04 (KERN_ATTR_BASIC ()) pw_buf1[2] = pws[gid].i[6]; pw_buf1[3] = pws[gid].i[7]; - const u32 pw_l_len = pws[gid].pw_len & 63; + const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; /** * seed @@ -257,7 +238,7 @@ KERNEL_FQ void m90010_s04 (KERN_ATTR_BASIC ()) pw_buf1[2] = pws[gid].i[6]; pw_buf1[3] = pws[gid].i[7]; - const u32 pw_l_len = pws[gid].pw_len & 63; + const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; /** * seed diff --git a/OpenCL/m90010_a3-optimized.cl b/OpenCL/m90010_a3-optimized.cl index 1454db57f..7f5b8f83c 100644 --- a/OpenCL/m90010_a3-optimized.cl +++ b/OpenCL/m90010_a3-optimized.cl @@ -22,29 +22,19 @@ DECLSPEC u64x MurmurHash64A (PRIVATE_AS const u32x *data, const u32 len) //Initialize hash u64x hash = 0 ^ (len * M); + //printf("len = %d\n", len); //printf("INITIAL = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); - const u32 endpos = len - (len & 7); + // 2 for each u64 block + const u32 num_blocks = (len / 8) * 2; - const u8 *data2 = (const u8*) data; + //printf("num_blocks = %d\n", num_blocks); - //printf("seed = %08x%08x\n", h32_from_64(seed), l32_from_64(seed)); - //printf("data2 = %c%c%c%c%c%c%c%c\n", data2[0], data2[1], data2[2], data2[3], data2[4], data2[5], data2[6], data2[7]); - //printf("len = %d\n", len); - - // Loop over blocks of 8 bytes u32 i = 0; - while (i != endpos) { - u64x k = ((u64) data2[i]) - | ((u64) data2[i + 1] << 8) - | ((u64) data2[i + 2] << 16) - | ((u64) data2[i + 3] << 24) - | ((u64) data2[i + 4] << 32) - | ((u64) data2[i + 5] << 40) - | ((u64) data2[i + 6] << 48) - | ((u64) data2[i + 7] << 56); - + while (i < num_blocks) { + u64x k = hl32_to_64 (data[i + 1], data[i]); + k *= M; k ^= k >> R; k *= M; @@ -52,8 +42,9 @@ DECLSPEC u64x MurmurHash64A (PRIVATE_AS const u32x *data, const u32 len) hash ^= k; hash *= M; - i += 8; + i += 2; } + //printf("BEFORE_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); // Overflow @@ -62,17 +53,29 @@ DECLSPEC u64x MurmurHash64A (PRIVATE_AS const u32x *data, const u32 len) //printf("OVERFLOW = %d\n", overflow); - switch (overflow) { - case 7: hash ^= ((u64) data2[i + 6]) << 48; - case 6: hash ^= ((u64) data2[i + 5]) << 40; - case 5: hash ^= ((u64) data2[i + 4]) << 32; - case 4: hash ^= ((u64) data2[i + 3]) << 24; - case 3: hash ^= ((u64) data2[i + 2]) << 16; - case 2: hash ^= ((u64) data2[i + 1]) << 8; - case 1: hash ^= ((u64) data2[i]); + //printf("data = %08x%08x%08x%08x%08x%08x%08x%08x%08x%08x\n", data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9]); + + //printf("i = %d\n", i); + //printf("data[i] data[i + 1] = %08x%08x\n", data[i], data[i + 1]); + + // can we turn this into a single xor + + if ((overflow > 0) && (overflow <= 4)) { + //printf("Overflow case 1\n"); + hash ^= hl32_to_64 (data[i + 1], data[i]); hash *= M; } + else if (overflow > 4) { + //printf("Overflow case 2\n"); + //printf("tmp = %08x%08x\n", h32_from_64(tmp), l32_from_64(tmp)); + hash ^= hl32_to_64 (data[i + 1], data[i]); + hash *= M; + } + + //u64 test = hl32_to_64 (0x0a16869e, 0xcb107f54); + //printf("hl32_to_64 test = %08x%08x\n", h32_from_64(test), l32_from_64(test)); + //printf("AFTER_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); hash ^= hash >> R; @@ -259,7 +262,7 @@ KERNEL_FQ void m90010_m04 (KERN_ATTR_VECTOR ()) w[14] = 0; w[15] = 0; - const u32 pw_len = pws[gid].pw_len & 63; + const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; //printf("pws[gid].pw_len = %d\n", pws[gid].pw_len); /** @@ -302,7 +305,7 @@ KERNEL_FQ void m90010_m08 (KERN_ATTR_VECTOR ()) w[14] = 0; w[15] = 0; - const u32 pw_len = pws[gid].pw_len & 63; + const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; /** * main @@ -342,7 +345,7 @@ KERNEL_FQ void m90010_m16 (KERN_ATTR_VECTOR ()) w[14] = pws[gid].i[14]; w[15] = pws[gid].i[15]; - const u32 pw_len = pws[gid].pw_len & 63; + const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; /** * main @@ -382,7 +385,7 @@ KERNEL_FQ void m90010_s04 (KERN_ATTR_VECTOR ()) w[14] = 0; w[15] = 0; - const u32 pw_len = pws[gid].pw_len & 63; + const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; /** * main @@ -422,7 +425,7 @@ KERNEL_FQ void m90010_s08 (KERN_ATTR_VECTOR ()) w[14] = 0; w[15] = 0; - const u32 pw_len = pws[gid].pw_len & 63; + const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; /** * main @@ -462,7 +465,7 @@ KERNEL_FQ void m90010_s16 (KERN_ATTR_VECTOR ()) w[14] = pws[gid].i[14]; w[15] = pws[gid].i[15]; - const u32 pw_len = pws[gid].pw_len & 63; + const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; /** * main diff --git a/src/modules/module_90010.c b/src/modules/module_90010.c index d77421b73..5c52c5ce1 100644 --- a/src/modules/module_90010.c +++ b/src/modules/module_90010.c @@ -48,7 +48,7 @@ u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED con { const bool optimized_kernel = (hashconfig->opti_type & OPTI_TYPE_OPTIMIZED_KERNEL); - const u32 pw_max = (optimized_kernel == true) ? 63 : PW_MAX; + const u32 pw_max = (optimized_kernel == true) ? 32 : PW_MAX; return pw_max; } From 3fd27c12433d0a4468051fb32e40ed61279241f2 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Sat, 9 Nov 2024 15:12:48 +1100 Subject: [PATCH 37/61] m90010_a0-pure seems to work --- OpenCL/m90010_a0-pure.cl | 205 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 205 insertions(+) create mode 100644 OpenCL/m90010_a0-pure.cl diff --git a/OpenCL/m90010_a0-pure.cl b/OpenCL/m90010_a0-pure.cl new file mode 100644 index 000000000..6ffa08f80 --- /dev/null +++ b/OpenCL/m90010_a0-pure.cl @@ -0,0 +1,205 @@ +/** + * Author......: See docs/credits.txt + * License.....: MIT + */ + +//#define NEW_SIMD_CODE + +#ifdef KERNEL_STATIC +#include M2S(INCLUDE_PATH/inc_vendor.h) +#include M2S(INCLUDE_PATH/inc_types.h) +#include M2S(INCLUDE_PATH/inc_platform.cl) +#include M2S(INCLUDE_PATH/inc_common.cl) +#include M2S(INCLUDE_PATH/inc_rp.h) +#include M2S(INCLUDE_PATH/inc_rp.cl) +#include M2S(INCLUDE_PATH/inc_scalar.cl) +#endif + +DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) +{ + #define M 0xc6a4a7935bd1e995 + #define R 47 + + //Initialize hash + u64 hash = 0 ^ (len * M); + + //printf("len = %d\n", len); + //printf("INITIAL = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + + // 2 for each u64 block + const u32 num_blocks = (len / 8) * 2; + + //printf("num_blocks = %d\n", num_blocks); + + // Loop over blocks of 8 bytes + u32 i = 0; + while (i < num_blocks) { + u64 k = hl32_to_64 (data[i + 1], data[i]); + + k *= M; + k ^= k >> R; + k *= M; + + hash ^= k; + hash *= M; + + i += 2; + } + + //printf("BEFORE_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + + // Overflow + + const u32 overflow = len & 7; + + //printf("OVERFLOW = %d\n", overflow); + + //printf("data = %08x%08x%08x%08x%08x%08x%08x%08x%08x%08x\n", data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9]); + + //printf("i = %d\n", i); + //printf("data[i] data[i + 1] = %08x%08x\n", data[i], data[i + 1]); + + // can we turn this into a single xor + + if ((overflow > 0) && (overflow <= 4)) { + //printf("Overflow case 1\n"); + hash ^= hl32_to_64 (data[i + 1], data[i]); + hash *= M; + } + + else if (overflow > 4) { + //printf("Overflow case 2\n"); + //printf("tmp = %08x%08x\n", h32_from_64(tmp), l32_from_64(tmp)); + hash ^= hl32_to_64 (data[i + 1], data[i]); + hash *= M; + } + + //u64 test = hl32_to_64 (0x0a16869e, 0xcb107f54); + //printf("hl32_to_64 test = %08x%08x\n", h32_from_64(test), l32_from_64(test)); + + //printf("AFTER_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + + hash ^= hash >> R; + hash *= M; + hash ^= hash >> R; + + #undef M + #undef R + + //printf("hash = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + + return hash; +} + +KERNEL_FQ void m90010_mxx (KERN_ATTR_RULES ()) +{ + /** + * modifier + */ + + const u64 lid = get_local_id (0); + + /** + * base + */ + + const u64 gid = get_global_id (0); + + if (gid >= GID_CNT) return; + + COPY_PW (pws[gid]); + + //if ((gid == 0) && (lid == 0)) printf ("%016lx\n", pw_buf0); + //printf("Hello world\n"); + + /** + * salt + */ + + /** + * loop + */ + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos++) + { + pw_t tmp = PASTE_PW; + + tmp.pw_len = apply_rules (rules_buf[il_pos].cmds, tmp.i, tmp.pw_len); + + //if ((gid == 0) && (lid == 0) && (il_pos == 0)) printf ("tmp.i = %08x, tmp.pw_len = %x\n", *tmp.i, tmp.pw_len); + + u64 hash = MurmurHash64A (tmp.i, tmp.pw_len); + + //if ((gid == 0) && (lid == 0)) printf ("hash = %lu\n", hash); + + //if (il_pos == 0) printf("tmp.i = %lu, tmp.pw_len = %lu\n", tmp.i, tmp.pw_len); + //if (il_pos == 0) printf("seed = %llu\n", seed); + + const u32 r0 = l32_from_64(hash); + const u32 r1 = h32_from_64(hash); + const u32 z = 0; + + COMPARE_M_SCALAR (r0, r1, z, z); + } +} + +KERNEL_FQ void m90010_sxx (KERN_ATTR_RULES ()) +{ + /** + * modifier + */ + + const u64 lid = get_local_id (0); + + /** + * base + */ + + const u64 gid = get_global_id (0); + + if (gid >= GID_CNT) return; + + /** + * salt + */ + + /** + * digest + */ + + const u32 search[4] = + { + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R0], + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R1], + 0, + 0 + }; + + /** + * base + */ + + COPY_PW (pws[gid]); + + //printf ("%016lx\n", seed); + //printf("Hello world\n"); + + /** + * loop + */ + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos++) + { + pw_t tmp = PASTE_PW; + + tmp.pw_len = apply_rules (rules_buf[il_pos].cmds, tmp.i, tmp.pw_len); + + u64 hash = MurmurHash64A (tmp.i, tmp.pw_len); + + const u32 r0 = l32_from_64 (hash); + const u32 r1 = h32_from_64 (hash); + const u32 z = 0; + + COMPARE_S_SCALAR (r0, r1, z, z); + } +} From c87948c56efa2c4dec58263de18ce192bac33c39 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Sun, 10 Nov 2024 10:34:58 +1100 Subject: [PATCH 38/61] a1-pure seems to work --- OpenCL/m90010_a1-pure.cl | 220 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 220 insertions(+) create mode 100644 OpenCL/m90010_a1-pure.cl diff --git a/OpenCL/m90010_a1-pure.cl b/OpenCL/m90010_a1-pure.cl new file mode 100644 index 000000000..dc57edeb2 --- /dev/null +++ b/OpenCL/m90010_a1-pure.cl @@ -0,0 +1,220 @@ +/** + * Author......: See docs/credits.txt + * License.....: MIT + */ + +//too much register pressure +//#define NEW_SIMD_CODE + +#ifdef KERNEL_STATIC +#include M2S(INCLUDE_PATH/inc_vendor.h) +#include M2S(INCLUDE_PATH/inc_types.h) +#include M2S(INCLUDE_PATH/inc_platform.cl) +#include M2S(INCLUDE_PATH/inc_common.cl) +#include M2S(INCLUDE_PATH/inc_scalar.cl) +#endif + +DECLSPEC u64 MurmurHash64A (const u8 *data, const u32 len) +{ + #define M 0xc6a4a7935bd1e995 + #define R 47 + + //Initialize hash + u64 hash = 0 ^ (len * M); + + //printf("len = %d\n", len); + //printf("INITIAL = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + + // 2 for each u64 block + const u32 num_blocks = (len / 8) * 2; + + //printf("num_blocks = %d\n", num_blocks); + + const u32 endpos = len - (len & 7); + + //printf("endpos = %d\n", endpos); + + // Loop over blocks of 8 bytes + u32 i = 0; + while (i != endpos) { + u64x k = ((u64) data[i]) + | ((u64) data[i + 1] << 8) + | ((u64) data[i + 2] << 16) + | ((u64) data[i + 3] << 24) + | ((u64) data[i + 4] << 32) + | ((u64) data[i + 5] << 40) + | ((u64) data[i + 6] << 48) + | ((u64) data[i + 7] << 56); + + k *= M; + k ^= k >> R; + k *= M; + + hash ^= k; + hash *= M; + + i += 8; + } + + //printf("BEFORE_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + + // Overflow + + const u32 overflow = len & 7; + + //printf("OVERFLOW = %d\n", overflow); + + //printf("data = %c%c%c%c%c%c%c%c%c%c\n", data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9]); + + //printf("i = %d\n", i); + //printf("data[i] data[i + 1] = %08x%08x\n", data[i], data[i + 1]); + + switch (overflow) { + case 7: hash ^= ((u64) data[i + 6]) << 48; + case 6: hash ^= ((u64) data[i + 5]) << 40; + case 5: hash ^= ((u64) data[i + 4]) << 32; + case 4: hash ^= ((u64) data[i + 3]) << 24; + case 3: hash ^= ((u64) data[i + 2]) << 16; + case 2: hash ^= ((u64) data[i + 1]) << 8; + case 1: hash ^= ((u64) data[i]); + hash *= M; + } + + //u64 test = hl32_to_64 (0x0a16869e, 0xcb107f54); + //printf("hl32_to_64 test = %08x%08x\n", h32_from_64(test), l32_from_64(test)); + + //printf("AFTER_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + + hash ^= hash >> R; + hash *= M; + hash ^= hash >> R; + + #undef M + #undef R + + //printf("final hash = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + + return hash; +} + + + +KERNEL_FQ void m90010_mxx (KERN_ATTR_BASIC ()) +{ + /** + * modifier + */ + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + + if (gid >= GID_CNT) return; + + /** + * base + */ + + u8 combined_buf[256] = {0}; + const u8 *comb_ptr = combined_buf; + u32 offset = 0; + + // copy bytes from left buf + GLOBAL_AS u8 *l_buf = (GLOBAL_AS u8*) pws[gid].i; + + for (u32 i = 0; i < pws[gid].pw_len; i++) { + combined_buf[offset] = l_buf[i]; + offset++; + } + + //printf("offset = %d\n", offset); + + /** + * loop + */ + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos++) + { + // copy bytes from right buf + GLOBAL_AS u8 *r_buf = (GLOBAL_AS u8*) combs_buf[il_pos].i; + for (u32 i = 0; i < combs_buf[il_pos].pw_len; i++) { + combined_buf[offset + i] = r_buf[i]; + } + + const u32 total_len = pws[gid].pw_len + combs_buf[il_pos].pw_len; + + //const u32 *combined_ptr = (u32*) combined_buf; + const u64 hash = MurmurHash64A (comb_ptr, total_len); + + const u32 r0 = l32_from_64 (hash); + const u32 r1 = h32_from_64 (hash); + const u32 z = 0; + + COMPARE_M_SCALAR (r0, r1, z, z); + } +} + +KERNEL_FQ void m90010_sxx (KERN_ATTR_BASIC ()) +{ + /** + * modifier + */ + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + + if (gid >= GID_CNT) return; + + /** + * digest + */ + + const u32 search[4] = + { + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R0], + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R1], + 0, + 0 + }; + + /** + * base + */ + + u8 combined_buf[256] = {0}; + const u8 *comb_ptr = combined_buf; + u32 offset = 0; + + // copy bytes from left buf + GLOBAL_AS u8 *l_buf = (GLOBAL_AS u8*) pws[gid].i; + + for (u32 i = 0; i < pws[gid].pw_len; i++) { + combined_buf[offset] = l_buf[i]; + offset++; + } + + + + /** + * loop + */ + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos++) + { + // copy bytes from right buf + GLOBAL_AS u8 *r_buf = (GLOBAL_AS u8*) combs_buf[il_pos].i; + for (u32 i = 0; i < combs_buf[il_pos].pw_len; i++) { + combined_buf[offset + i] = r_buf[i]; + } + + const u32 total_len = pws[gid].pw_len + combs_buf[il_pos].pw_len; + + //const u32 *combined_ptr = (u32*) combined_buf; + const u64 hash = MurmurHash64A (comb_ptr, total_len); + + const u32 r0 = l32_from_64 (hash); + const u32 r1 = h32_from_64 (hash); + const u32 z = 0; + + COMPARE_S_SCALAR (r0, r1, z, z); + } +} From 468e96b49b24dd654700264a7945b8b2f86f70cf Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Sun, 10 Nov 2024 10:35:06 +1100 Subject: [PATCH 39/61] a3-pure seems to work --- OpenCL/m90010_a3-pure.cl | 198 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 198 insertions(+) create mode 100644 OpenCL/m90010_a3-pure.cl diff --git a/OpenCL/m90010_a3-pure.cl b/OpenCL/m90010_a3-pure.cl new file mode 100644 index 000000000..51421ab11 --- /dev/null +++ b/OpenCL/m90010_a3-pure.cl @@ -0,0 +1,198 @@ +/** + * Author......: See docs/credits.txt + * License.....: MIT + */ + +//#define NEW_SIMD_CODE + +#ifdef KERNEL_STATIC +#include M2S(INCLUDE_PATH/inc_vendor.h) +#include M2S(INCLUDE_PATH/inc_types.h) +#include M2S(INCLUDE_PATH/inc_platform.cl) +#include M2S(INCLUDE_PATH/inc_common.cl) +#include M2S(INCLUDE_PATH/inc_simd.cl) +#endif + +DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) +{ + #define M 0xc6a4a7935bd1e995 + #define R 47 + + //Initialize hash + u64 hash = 0 ^ (len * M); + + //printf("len = %d\n", len); + //printf("INITIAL = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + + // 2 for each u64 block + const u32 num_blocks = (len / 8) * 2; + + //printf("num_blocks = %d\n", num_blocks); + + // Loop over blocks of 8 bytes + u32 i = 0; + while (i < num_blocks) { + u64 k = hl32_to_64 (data[i + 1], data[i]); + + k *= M; + k ^= k >> R; + k *= M; + + hash ^= k; + hash *= M; + + i += 2; + } + + //printf("BEFORE_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + + // Overflow + + const u32 overflow = len & 7; + + //printf("OVERFLOW = %d\n", overflow); + + //printf("data = %08x%08x%08x%08x%08x%08x%08x%08x%08x%08x\n", data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9]); + + //printf("i = %d\n", i); + //printf("data[i] data[i + 1] = %08x%08x\n", data[i], data[i + 1]); + + // can we turn this into a single xor + + if ((overflow > 0) && (overflow <= 4)) { + //printf("Overflow case 1\n"); + hash ^= hl32_to_64 (data[i + 1], data[i]); + hash *= M; + } + + else if (overflow > 4) { + //printf("Overflow case 2\n"); + //printf("tmp = %08x%08x\n", h32_from_64(tmp), l32_from_64(tmp)); + hash ^= hl32_to_64 (data[i + 1], data[i]); + hash *= M; + } + + //u64 test = hl32_to_64 (0x0a16869e, 0xcb107f54); + //printf("hl32_to_64 test = %08x%08x\n", h32_from_64(test), l32_from_64(test)); + + //printf("AFTER_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + + hash ^= hash >> R; + hash *= M; + hash ^= hash >> R; + + #undef M + #undef R + + //printf("hash = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + + return hash; +} + +KERNEL_FQ void m90010_mxx (KERN_ATTR_VECTOR ()) +{ + /** + * modifier + */ + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + + if (gid >= GID_CNT) return; + + /** + * base + */ + + const u32 pw_len = pws[gid].pw_len; + + u32x w[64] = { 0 }; + + for (u32 i = 0, idx = 0; i < pw_len; i += 4, idx += 1) + { + w[idx] = pws[gid].i[idx]; + } + + /** + * loop + */ + + u32x w0l = w[0]; + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) + { + const u32x w0r = words_buf_r[il_pos / VECT_SIZE]; + + const u32x w0 = w0l | w0r; + + w[0] = w0; + + const u64x hash = MurmurHash64A (w, pw_len); + + const u32x r0 = l32_from_64(hash); + const u32x r1 = h32_from_64(hash); + const u32x z = 0; + + COMPARE_M_SIMD (r0, r1, z, z); + } +} + +KERNEL_FQ void m90010_sxx (KERN_ATTR_VECTOR ()) +{ + /** + * modifier + */ + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + + if (gid >= GID_CNT) return; + + /** + * digest + */ + + const u32 search[4] = + { + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R0], + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R1], + 0, + 0 + }; + + /** + * base + */ + + const u32 pw_len = pws[gid].pw_len; + + u32x w[64] = { 0 }; + + for (u32 i = 0, idx = 0; i < pw_len; i += 4, idx += 1) + { + w[idx] = pws[gid].i[idx]; + } + + /** + * loop + */ + + u32x w0l = w[0]; + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) + { + const u32x w0r = words_buf_r[il_pos / VECT_SIZE]; + + const u32x w0 = w0l | w0r; + + w[0] = w0; + + const u64x hash = MurmurHash64A (w, pw_len); + + const u32x r0 = l32_from_64(hash); + const u32x r1 = h32_from_64(hash); + const u32x z = 0; + + COMPARE_S_SIMD (r0, r1, z, z); + } +} From c3bd02ad6314dde841fe14edc227774a6a9326b3 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Sun, 10 Nov 2024 10:40:56 +1100 Subject: [PATCH 40/61] Fix a1-optimized --- OpenCL/m90010_a1-optimized.cl | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/OpenCL/m90010_a1-optimized.cl b/OpenCL/m90010_a1-optimized.cl index d5185fc9a..344157d42 100644 --- a/OpenCL/m90010_a1-optimized.cl +++ b/OpenCL/m90010_a1-optimized.cl @@ -117,7 +117,7 @@ KERNEL_FQ void m90010_m04 (KERN_ATTR_BASIC ()) pw_buf1[2] = pws[gid].i[6]; pw_buf1[3] = pws[gid].i[7]; - const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; + const u32 pw_l_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; /** * seed @@ -238,7 +238,7 @@ KERNEL_FQ void m90010_s04 (KERN_ATTR_BASIC ()) pw_buf1[2] = pws[gid].i[6]; pw_buf1[3] = pws[gid].i[7]; - const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; + const u32 pw_l_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; /** * seed From cbd5be48ca3b4221d7c7981681a1b7cfb0dfd75a Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Sun, 10 Nov 2024 10:41:27 +1100 Subject: [PATCH 41/61] Update helper python file --- scratch.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/scratch.py b/scratch.py index 4b22935ab..3279457f7 100644 --- a/scratch.py +++ b/scratch.py @@ -142,7 +142,7 @@ print(result_int) -data = "bardin_complete_all_levels_desc" +data = "hashcat" seed = 0x0 # s = bytes.fromhex(data)[::-1].decode("utf-8") @@ -151,7 +151,7 @@ seed = 0x0 h = get_hash(data, seed) -pretty = f"{h:016x}:{seed:016x}:{data} INITIAL: {INITIAL:016x} MIDDLE_OF_BLOCK: {MIDDLE_OF_BLOCK:016x} B4OVERFLOW: {BEFORE_OVERFLOW:016x} overflow: {OVERFLOW} AFTER_OVERFLOW = {AFTER_OVERFLOW:016x}" +pretty = f"{h:016x}:{seed:016x}:{data} INITIAL: {INITIAL:016x} B4OVERFLOW: {BEFORE_OVERFLOW:016x} overflow: {OVERFLOW} AFTER_OVERFLOW = {AFTER_OVERFLOW:016x}" print(pretty) From 9428f288e225c437cad2c7144142d110e3436dc5 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Tue, 12 Nov 2024 11:29:10 +1100 Subject: [PATCH 42/61] Create m90030 test module --- tools/test_modules/m90030.pm | 154 +++++++++++++++++++++++++++++++++++ 1 file changed, 154 insertions(+) create mode 100644 tools/test_modules/m90030.pm diff --git a/tools/test_modules/m90030.pm b/tools/test_modules/m90030.pm new file mode 100644 index 000000000..c0178a2c9 --- /dev/null +++ b/tools/test_modules/m90030.pm @@ -0,0 +1,154 @@ +#!/usr/bin/env perl + +## +## Author......: See docs/credits.txt +## License.....: MIT +## + +use strict; +use warnings; +use Math::BigInt; + +sub module_constraints { [[0, 256], [-1, -1], [0, 63], [-1, -1], [0, 63]] } + +sub wrapping_mul +{ + my $a = shift; + my $b = shift; + + # 2**64 + my $width = Math::BigInt->new("0x10000000000000000"); + + return ($a * $b)->bmod($width); +} + +sub murmurhash64a +{ + use integer; + + my $word = shift; + my $seed = 0; + + # https://gitlab.com/lschwiderski/vt2_bundle_unpacker/-/blob/master/src/murmur/murmurhash64.rs + # 'm' and 'r' are mixing constants generated offline. + # They're not really 'magic', they just happen to work well. + + my $m = Math::BigInt->new("0xc6a4a7935bd1e995"); + #my $m = 0xc6a4a7935bd1e995; + my $r = 47; + + my @chars = unpack ("C*", $word); + my $len = length $word; + + my $hash = $seed ^ wrapping_mul ($len, $m); + + my $endpos = $len - ($len & 7); + my $i; + + for ($i = 0; $i < $endpos; $i += 8) + { + my $c0 = $chars[$i + 0]; + my $c1 = $chars[$i + 1]; + my $c2 = $chars[$i + 2]; + my $c3 = $chars[$i + 3]; + my $c4 = $chars[$i + 4]; + my $c5 = $chars[$i + 5]; + my $c6 = $chars[$i + 6]; + my $c7 = $chars[$i + 7]; + + my $k = ($c0 << 0) + | ($c1 << 8) + | ($c2 << 16) + | ($c3 << 24) + | ($c4 << 32) + | ($c5 << 40) + | ($c6 << 48) + | ($c7 << 56); + + $k = wrapping_mul ($k, $m); + $k ^= $k >> $r; + $k = wrapping_mul ($k, $m); + + $hash ^= $k; + $hash = wrapping_mul ($hash, $m); + } + + my $overflow = $len & 7; + + if ($overflow == 7) + { + $hash ^= $chars[$i + 6] << 48; + } + if ($overflow >= 6) + { + $hash ^= $chars[$i + 5] << 40; + } + if ($overflow >= 5) + { + $hash ^= $chars[$i + 4] << 32; + } + if ($overflow >= 4) + { + $hash ^= $chars[$i + 3] << 24; + } + if ($overflow >= 3) + { + $hash ^= $chars[$i + 2] << 16; + } + if ($overflow >= 2) + { + $hash ^= $chars[$i + 1] << 8; + } + if ($overflow >= 1) + { + $hash ^= $chars[$i + 0] << 0; + } + + if ($overflow > 0) + { + $hash = wrapping_mul ($hash, $m); + } + + $hash ^= $hash >> $r; + $hash = wrapping_mul ($hash, $m); + $hash ^= $hash >> $r; + + $hash = $hash >> 32; + + return $hash; +} + +sub module_generate_hash +{ + my $word = shift; + + my $digest = murmurhash64a ($word); + + $digest = unpack ("H*", pack ("Q>", $digest)); + + my $hash = sprintf ("%s", $digest); + + return $hash; +} + +sub module_verify_hash +{ + my $line = shift; + + my ($hash, $word) = split (':', $line, 2); + + return unless defined $hash; + return unless defined $word; + + return unless length $hash == 16; + + return unless ($hash =~ m/^[0-9a-fA-F]{16}$/); + + my $word_packed = pack_if_HEX_notation ($word); + + my $new_hash = module_generate_hash ($word_packed); + + return ($new_hash, $word); +} + +1; From f4da726cecdca49b68b3dd8318a25b3647e142b9 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Tue, 12 Nov 2024 12:02:36 +1100 Subject: [PATCH 43/61] Fix m90030 test module --- tools/test_modules/m90030.pm | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/tools/test_modules/m90030.pm b/tools/test_modules/m90030.pm index c0178a2c9..d277c2ea5 100644 --- a/tools/test_modules/m90030.pm +++ b/tools/test_modules/m90030.pm @@ -9,7 +9,7 @@ use strict; use warnings; use Math::BigInt; -sub module_constraints { [[0, 256], [-1, -1], [0, 63], [-1, -1], [0, 63]] } +sub module_constraints { [[0, 256], [-1, -1], [0, 32], [-1, -1], [0, 32]] } sub wrapping_mul { @@ -22,7 +22,7 @@ sub wrapping_mul return ($a * $b)->bmod($width); } -sub murmurhash64a +sub murmurhash64a_32 { use integer; @@ -113,6 +113,7 @@ sub murmurhash64a $hash = wrapping_mul ($hash, $m); $hash ^= $hash >> $r; + # use only high 32 bits from hash $hash = $hash >> 32; return $hash; @@ -122,9 +123,9 @@ sub module_generate_hash { my $word = shift; - my $digest = murmurhash64a ($word); + my $digest = murmurhash64a_32 ($word); - $digest = unpack ("H*", pack ("Q>", $digest)); + $digest = unpack ("H*", pack ("L>", $digest)); my $hash = sprintf ("%s", $digest); @@ -140,9 +141,9 @@ sub module_verify_hash return unless defined $hash; return unless defined $word; - return unless length $hash == 16; + return unless length $hash == 8; - return unless ($hash =~ m/^[0-9a-fA-F]{16}$/); + return unless ($hash =~ m/^[0-9a-fA-F]{8}$/); my $word_packed = pack_if_HEX_notation ($word); From 58bc6ddb7d1a51e71fab1823974ad94a2b25461f Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Tue, 12 Nov 2024 12:03:48 +1100 Subject: [PATCH 44/61] Create m90030 C module --- src/modules/module_90030.c | 184 +++++++++++++++++++++++++++++++++++++ 1 file changed, 184 insertions(+) create mode 100644 src/modules/module_90030.c diff --git a/src/modules/module_90030.c b/src/modules/module_90030.c new file mode 100644 index 000000000..5c52c5ce1 --- /dev/null +++ b/src/modules/module_90030.c @@ -0,0 +1,184 @@ +/** + * Author......: See docs/credits.txt + * License.....: MIT + */ + +#include "common.h" +#include "types.h" +#include "modules.h" +#include "bitops.h" +#include "convert.h" +#include "shared.h" + +static const u32 ATTACK_EXEC = ATTACK_EXEC_INSIDE_KERNEL; +static const u32 DGST_POS0 = 0; +static const u32 DGST_POS1 = 1; +static const u32 DGST_POS2 = 2; +static const u32 DGST_POS3 = 3; +static const u32 DGST_SIZE = DGST_SIZE_8_2; +static const u32 HASH_CATEGORY = HASH_CATEGORY_RAW_HASH; +static const char *HASH_NAME = "MurmurHash64A Zero Seed"; +static const u64 KERN_TYPE = 90010; +static const u32 OPTI_TYPE = OPTI_TYPE_ZERO_BYTE + | OPTI_TYPE_USES_BITS_64 + | OPTI_TYPE_NOT_SALTED; +static const u64 OPTS_TYPE = OPTS_TYPE_STOCK_MODULE + | OPTS_TYPE_PT_GENERATE_LE + | OPTS_TYPE_SUGGEST_KG; +static const u32 SALT_TYPE = SALT_TYPE_NONE; +static const char *ST_PASS = "hashcat"; +static const char *ST_HASH = "73f8142b4326d36a"; + +u32 module_attack_exec (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return ATTACK_EXEC; } +u32 module_dgst_pos0 (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS0; } +u32 module_dgst_pos1 (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS1; } +u32 module_dgst_pos2 (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS2; } +u32 module_dgst_pos3 (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS3; } +u32 module_dgst_size (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_SIZE; } +u32 module_hash_category (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return HASH_CATEGORY; } +const char *module_hash_name (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return HASH_NAME; } +u64 module_kern_type (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return KERN_TYPE; } +u32 module_opti_type (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return OPTI_TYPE; } +u64 module_opts_type (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return OPTS_TYPE; } +u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return SALT_TYPE; } +const char *module_st_hash (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return ST_HASH; } +const char *module_st_pass (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return ST_PASS; } + +u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) +{ + const bool optimized_kernel = (hashconfig->opti_type & OPTI_TYPE_OPTIMIZED_KERNEL); + + const u32 pw_max = (optimized_kernel == true) ? 32 : PW_MAX; + + return pw_max; +} + +int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED void *digest_buf, MAYBE_UNUSED salt_t *salt, MAYBE_UNUSED void *esalt_buf, MAYBE_UNUSED void *hook_salt_buf, MAYBE_UNUSED hashinfo_t *hash_info, const char *line_buf, MAYBE_UNUSED const int line_len) +{ + u64 *digest = (u64 *) digest_buf; + + hc_token_t token; + + memset (&token, 0, sizeof (hc_token_t)); + + token.token_cnt = 1; + + token.len[0] = 16; + token.attr[0] = TOKEN_ATTR_FIXED_LENGTH + | TOKEN_ATTR_VERIFY_HEX; + + const int rc_tokenizer = input_tokenizer ((const u8 *) line_buf, line_len, &token); + + if (rc_tokenizer != PARSER_OK) return (rc_tokenizer); + + // digest + + const u8 *hash_pos = token.buf[0]; + // we have 16 chars (hash hex string, big endian) + + + digest[0] = ((hex_to_u64 (&hash_pos[0]))); + digest[1] = 0; + + digest[0] = byte_swap_64 (digest[0]); + + // now `digest` contains a proper little endian u64 + + return (PARSER_OK); +} + +int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const void *digest_buf, MAYBE_UNUSED const salt_t *salt, MAYBE_UNUSED const void *esalt_buf, MAYBE_UNUSED const void *hook_salt_buf, MAYBE_UNUSED const hashinfo_t *hash_info, char *line_buf, MAYBE_UNUSED const int line_size) +{ + const u64 *digest = (const u64 *) digest_buf; + + // we can not change anything in the original buffer, otherwise destroying sorting + // therefore create some local buffer + + u8 *out_buf = (u8 *) line_buf; + + const int out_len = 16; + + u64_to_hex (byte_swap_64 (digest[0]), out_buf); + + return out_len; +} + +void module_init (module_ctx_t *module_ctx) +{ + module_ctx->module_context_size = MODULE_CONTEXT_SIZE_CURRENT; + module_ctx->module_interface_version = MODULE_INTERFACE_VERSION_CURRENT; + + module_ctx->module_attack_exec = module_attack_exec; + module_ctx->module_benchmark_esalt = MODULE_DEFAULT; + module_ctx->module_benchmark_hook_salt = MODULE_DEFAULT; + module_ctx->module_benchmark_mask = MODULE_DEFAULT; + module_ctx->module_benchmark_charset = MODULE_DEFAULT; + module_ctx->module_benchmark_salt = MODULE_DEFAULT; + module_ctx->module_build_plain_postprocess = MODULE_DEFAULT; + module_ctx->module_deep_comp_kernel = MODULE_DEFAULT; + module_ctx->module_deprecated_notice = MODULE_DEFAULT; + module_ctx->module_dgst_pos0 = module_dgst_pos0; + module_ctx->module_dgst_pos1 = module_dgst_pos1; + module_ctx->module_dgst_pos2 = module_dgst_pos2; + module_ctx->module_dgst_pos3 = module_dgst_pos3; + module_ctx->module_dgst_size = module_dgst_size; + module_ctx->module_dictstat_disable = MODULE_DEFAULT; + module_ctx->module_esalt_size = MODULE_DEFAULT; + module_ctx->module_extra_buffer_size = MODULE_DEFAULT; + module_ctx->module_extra_tmp_size = MODULE_DEFAULT; + module_ctx->module_extra_tuningdb_block = MODULE_DEFAULT; + module_ctx->module_forced_outfile_format = MODULE_DEFAULT; + module_ctx->module_hash_binary_count = MODULE_DEFAULT; + module_ctx->module_hash_binary_parse = MODULE_DEFAULT; + module_ctx->module_hash_binary_save = MODULE_DEFAULT; + module_ctx->module_hash_decode_postprocess = MODULE_DEFAULT; + module_ctx->module_hash_decode_potfile = MODULE_DEFAULT; + module_ctx->module_hash_decode_zero_hash = MODULE_DEFAULT; + module_ctx->module_hash_decode = module_hash_decode; + module_ctx->module_hash_encode_status = MODULE_DEFAULT; + module_ctx->module_hash_encode_potfile = MODULE_DEFAULT; + module_ctx->module_hash_encode = module_hash_encode; + module_ctx->module_hash_init_selftest = MODULE_DEFAULT; + module_ctx->module_hash_mode = MODULE_DEFAULT; + module_ctx->module_hash_category = module_hash_category; + module_ctx->module_hash_name = module_hash_name; + module_ctx->module_hashes_count_min = MODULE_DEFAULT; + module_ctx->module_hashes_count_max = MODULE_DEFAULT; + module_ctx->module_hlfmt_disable = MODULE_DEFAULT; + module_ctx->module_hook_extra_param_size = MODULE_DEFAULT; + module_ctx->module_hook_extra_param_init = MODULE_DEFAULT; + module_ctx->module_hook_extra_param_term = MODULE_DEFAULT; + module_ctx->module_hook12 = MODULE_DEFAULT; + module_ctx->module_hook23 = MODULE_DEFAULT; + module_ctx->module_hook_salt_size = MODULE_DEFAULT; + module_ctx->module_hook_size = MODULE_DEFAULT; + module_ctx->module_jit_build_options = MODULE_DEFAULT; + module_ctx->module_jit_cache_disable = MODULE_DEFAULT; + module_ctx->module_kernel_accel_max = MODULE_DEFAULT; + module_ctx->module_kernel_accel_min = MODULE_DEFAULT; + module_ctx->module_kernel_loops_max = MODULE_DEFAULT; + module_ctx->module_kernel_loops_min = MODULE_DEFAULT; + module_ctx->module_kernel_threads_max = MODULE_DEFAULT; + module_ctx->module_kernel_threads_min = MODULE_DEFAULT; + module_ctx->module_kern_type = module_kern_type; + module_ctx->module_kern_type_dynamic = MODULE_DEFAULT; + module_ctx->module_opti_type = module_opti_type; + module_ctx->module_opts_type = module_opts_type; + module_ctx->module_outfile_check_disable = MODULE_DEFAULT; + module_ctx->module_outfile_check_nocomp = MODULE_DEFAULT; + module_ctx->module_potfile_custom_check = MODULE_DEFAULT; + module_ctx->module_potfile_disable = MODULE_DEFAULT; + module_ctx->module_potfile_keep_all_hashes = MODULE_DEFAULT; + module_ctx->module_pwdump_column = MODULE_DEFAULT; + module_ctx->module_pw_max = module_pw_max; + module_ctx->module_pw_min = MODULE_DEFAULT; + module_ctx->module_salt_max = MODULE_DEFAULT; + module_ctx->module_salt_min = MODULE_DEFAULT; + module_ctx->module_salt_type = module_salt_type; + module_ctx->module_separator = MODULE_DEFAULT; + module_ctx->module_st_hash = module_st_hash; + module_ctx->module_st_pass = module_st_pass; + module_ctx->module_tmp_size = MODULE_DEFAULT; + module_ctx->module_unstable_warning = MODULE_DEFAULT; + module_ctx->module_warmup_disable = MODULE_DEFAULT; +} From 9d7c3bda0cfb3fe1a68a793fda9c1680bf61634f Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Tue, 12 Nov 2024 12:07:26 +1100 Subject: [PATCH 45/61] Update m90030 C module --- src/modules/module_90030.c | 25 ++++++++++++------------- 1 file changed, 12 insertions(+), 13 deletions(-) diff --git a/src/modules/module_90030.c b/src/modules/module_90030.c index 5c52c5ce1..c8c9f6bd5 100644 --- a/src/modules/module_90030.c +++ b/src/modules/module_90030.c @@ -15,19 +15,18 @@ static const u32 DGST_POS0 = 0; static const u32 DGST_POS1 = 1; static const u32 DGST_POS2 = 2; static const u32 DGST_POS3 = 3; -static const u32 DGST_SIZE = DGST_SIZE_8_2; +static const u32 DGST_SIZE = DGST_SIZE_4_2; static const u32 HASH_CATEGORY = HASH_CATEGORY_RAW_HASH; -static const char *HASH_NAME = "MurmurHash64A Zero Seed"; -static const u64 KERN_TYPE = 90010; +static const char *HASH_NAME = "MurmurHash64A 32 Zero Seed"; +static const u64 KERN_TYPE = 90030; static const u32 OPTI_TYPE = OPTI_TYPE_ZERO_BYTE - | OPTI_TYPE_USES_BITS_64 | OPTI_TYPE_NOT_SALTED; static const u64 OPTS_TYPE = OPTS_TYPE_STOCK_MODULE | OPTS_TYPE_PT_GENERATE_LE | OPTS_TYPE_SUGGEST_KG; static const u32 SALT_TYPE = SALT_TYPE_NONE; static const char *ST_PASS = "hashcat"; -static const char *ST_HASH = "73f8142b4326d36a"; +static const char *ST_HASH = "73f8142b"; u32 module_attack_exec (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return ATTACK_EXEC; } u32 module_dgst_pos0 (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS0; } @@ -55,7 +54,7 @@ u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED con int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED void *digest_buf, MAYBE_UNUSED salt_t *salt, MAYBE_UNUSED void *esalt_buf, MAYBE_UNUSED void *hook_salt_buf, MAYBE_UNUSED hashinfo_t *hash_info, const char *line_buf, MAYBE_UNUSED const int line_len) { - u64 *digest = (u64 *) digest_buf; + u32 *digest = (u32 *) digest_buf; hc_token_t token; @@ -63,7 +62,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE token.token_cnt = 1; - token.len[0] = 16; + token.len[0] = 8; token.attr[0] = TOKEN_ATTR_FIXED_LENGTH | TOKEN_ATTR_VERIFY_HEX; @@ -74,13 +73,13 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE // digest const u8 *hash_pos = token.buf[0]; - // we have 16 chars (hash hex string, big endian) + // we have 8 chars (hash hex string, big endian) - digest[0] = ((hex_to_u64 (&hash_pos[0]))); + digest[0] = ((hex_to_u32 (&hash_pos[0]))); digest[1] = 0; - digest[0] = byte_swap_64 (digest[0]); + digest[0] = byte_swap_32 (digest[0]); // now `digest` contains a proper little endian u64 @@ -89,16 +88,16 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const void *digest_buf, MAYBE_UNUSED const salt_t *salt, MAYBE_UNUSED const void *esalt_buf, MAYBE_UNUSED const void *hook_salt_buf, MAYBE_UNUSED const hashinfo_t *hash_info, char *line_buf, MAYBE_UNUSED const int line_size) { - const u64 *digest = (const u64 *) digest_buf; + const u32 *digest = (const u32 *) digest_buf; // we can not change anything in the original buffer, otherwise destroying sorting // therefore create some local buffer u8 *out_buf = (u8 *) line_buf; - const int out_len = 16; + const int out_len = 8; - u64_to_hex (byte_swap_64 (digest[0]), out_buf); + u32_to_hex (byte_swap_32 (digest[0]), out_buf); return out_len; } From 117fe840bfed7fe44507354b82592359a9c6ac03 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Tue, 12 Nov 2024 12:09:02 +1100 Subject: [PATCH 46/61] Create m90030 optimized kernels --- OpenCL/m90030_a0-optimized.cl | 226 ++++++++++++++++ OpenCL/m90030_a1-optimized.cl | 345 ++++++++++++++++++++++++ OpenCL/m90030_a3-optimized.cl | 475 ++++++++++++++++++++++++++++++++++ 3 files changed, 1046 insertions(+) create mode 100644 OpenCL/m90030_a0-optimized.cl create mode 100644 OpenCL/m90030_a1-optimized.cl create mode 100644 OpenCL/m90030_a3-optimized.cl diff --git a/OpenCL/m90030_a0-optimized.cl b/OpenCL/m90030_a0-optimized.cl new file mode 100644 index 000000000..ca8f99823 --- /dev/null +++ b/OpenCL/m90030_a0-optimized.cl @@ -0,0 +1,226 @@ +/** + * Author......: See docs/credits.txt + * License.....: MIT + */ + +//#define NEW_SIMD_CODE + +#ifdef KERNEL_STATIC +#include M2S(INCLUDE_PATH/inc_vendor.h) +#include M2S(INCLUDE_PATH/inc_types.h) +#include M2S(INCLUDE_PATH/inc_platform.cl) +#include M2S(INCLUDE_PATH/inc_common.cl) +#include M2S(INCLUDE_PATH/inc_rp_optimized.h) +#include M2S(INCLUDE_PATH/inc_rp_optimized.cl) +#include M2S(INCLUDE_PATH/inc_simd.cl) +#endif + +DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) +{ + #define M 0xc6a4a7935bd1e995 + #define R 47 + + //Initialize hash + u64 hash = 0 ^ (len * M); + + //printf("len = %d\n", len); + //printf("INITIAL = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + + // 2 for each u64 block + const u32 num_blocks = (len / 8) * 2; + + //printf("num_blocks = %d\n", num_blocks); + + // Loop over blocks of 8 bytes + u32 i = 0; + while (i < num_blocks) { + u64 k = hl32_to_64 (data[i + 1], data[i]); + + k *= M; + k ^= k >> R; + k *= M; + + hash ^= k; + hash *= M; + + i += 2; + } + + //printf("BEFORE_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + + // Overflow + + const u32 overflow = len & 7; + + //printf("OVERFLOW = %d\n", overflow); + + //printf("data = %08x%08x%08x%08x%08x%08x%08x%08x%08x%08x\n", data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9]); + + //printf("i = %d\n", i); + //printf("data[i] data[i + 1] = %08x%08x\n", data[i], data[i + 1]); + + // can we turn this into a single xor + + if ((overflow > 0) && (overflow <= 4)) { + //printf("Overflow case 1\n"); + hash ^= hl32_to_64 (data[i + 1], data[i]); + hash *= M; + } + + else if (overflow > 4) { + //printf("Overflow case 2\n"); + //printf("tmp = %08x%08x\n", h32_from_64(tmp), l32_from_64(tmp)); + hash ^= hl32_to_64 (data[i + 1], data[i]); + hash *= M; + } + + //u64 test = hl32_to_64 (0x0a16869e, 0xcb107f54); + //printf("hl32_to_64 test = %08x%08x\n", h32_from_64(test), l32_from_64(test)); + + //printf("AFTER_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + + hash ^= hash >> R; + hash *= M; + hash ^= hash >> R; + + #undef M + #undef R + + //printf("hash = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + + return hash; +} + + + +KERNEL_FQ void m90010_m04 (KERN_ATTR_RULES ()) +{ + //printf("Hello world m90010_m04\n"); + /** + * modifier + */ + + const u64 lid = get_local_id (0); + + /** + * base + */ + + const u64 gid = get_global_id (0); + + if (gid >= GID_CNT) return; + + u32 pw_buf0[4]; + u32 pw_buf1[4]; + + pw_buf0[0] = pws[gid].i[0]; + pw_buf0[1] = pws[gid].i[1]; + pw_buf0[2] = pws[gid].i[2]; + pw_buf0[3] = pws[gid].i[3]; + pw_buf1[0] = pws[gid].i[4]; + pw_buf1[1] = pws[gid].i[5]; + pw_buf1[2] = pws[gid].i[6]; + pw_buf1[3] = pws[gid].i[7]; + + // max pw len of 32 + const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; + + /** + * loop + */ + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) + { + u32x w[16] = { 0 }; + + const u32x out_len = apply_rules_vect_optimized (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w + 0, w + 4); + + u64x hash = MurmurHash64A (w, out_len); + + const u32x r0 = l32_from_64(hash); + const u32x r1 = h32_from_64(hash); + const u32x z = 0; + + COMPARE_M_SIMD (r0, r1, z, z); + } +} + +KERNEL_FQ void m90010_m08 (KERN_ATTR_RULES ()) +{ +} + +KERNEL_FQ void m90010_m16 (KERN_ATTR_RULES ()) +{ +} + +KERNEL_FQ void m90010_s04 (KERN_ATTR_RULES ()) +{ + //printf("Hello world m90010_s04\n"); + /** + * modifier + */ + + const u64 lid = get_local_id (0); + + /** + * base + */ + + const u64 gid = get_global_id (0); + + if (gid >= GID_CNT) return; + + u32 pw_buf0[4]; + u32 pw_buf1[4]; + + pw_buf0[0] = pws[gid].i[0]; + pw_buf0[1] = pws[gid].i[1]; + pw_buf0[2] = pws[gid].i[2]; + pw_buf0[3] = pws[gid].i[3]; + pw_buf1[0] = pws[gid].i[4]; + pw_buf1[1] = pws[gid].i[5]; + pw_buf1[2] = pws[gid].i[6]; + pw_buf1[3] = pws[gid].i[7]; + + // max pw len of 32 + const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; + + /** + * digest + */ + + const u32 search[4] = + { + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R0], + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R1], + 0, + 0 + }; + + /** + * loop + */ + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) + { + u32x w[16] = { 0 }; + + const u32x out_len = apply_rules_vect_optimized (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w + 0, w + 4); + + u64x hash = MurmurHash64A (w, out_len); + + const u32x r0 = l32_from_64(hash); + const u32x r1 = h32_from_64(hash); + const u32x z = 0; + + COMPARE_S_SIMD (r0, r1, z, z); + } +} + +KERNEL_FQ void m90010_s08 (KERN_ATTR_RULES ()) +{ +} + +KERNEL_FQ void m90010_s16 (KERN_ATTR_RULES ()) +{ +} diff --git a/OpenCL/m90030_a1-optimized.cl b/OpenCL/m90030_a1-optimized.cl new file mode 100644 index 000000000..344157d42 --- /dev/null +++ b/OpenCL/m90030_a1-optimized.cl @@ -0,0 +1,345 @@ +/** + * Author......: See docs/credits.txt + * License.....: MIT + */ + +//too much register pressure +//#define NEW_SIMD_CODE + +#ifdef KERNEL_STATIC +#include M2S(INCLUDE_PATH/inc_vendor.h) +#include M2S(INCLUDE_PATH/inc_types.h) +#include M2S(INCLUDE_PATH/inc_platform.cl) +#include M2S(INCLUDE_PATH/inc_common.cl) +#include M2S(INCLUDE_PATH/inc_simd.cl) +#endif + +DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) +{ + #define M 0xc6a4a7935bd1e995 + #define R 47 + + //Initialize hash + u64 hash = 0 ^ (len * M); + + //printf("len = %d\n", len); + //printf("INITIAL = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + + // 2 for each u64 block + const u32 num_blocks = (len / 8) * 2; + + //printf("num_blocks = %d\n", num_blocks); + + // Loop over blocks of 8 bytes + u32 i = 0; + while (i < num_blocks) { + u64 k = hl32_to_64 (data[i + 1], data[i]); + + k *= M; + k ^= k >> R; + k *= M; + + hash ^= k; + hash *= M; + + i += 2; + } + + //printf("BEFORE_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + + // Overflow + + const u32 overflow = len & 7; + + //printf("OVERFLOW = %d\n", overflow); + + //printf("data = %08x%08x%08x%08x%08x%08x%08x%08x%08x%08x\n", data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9]); + + //printf("i = %d\n", i); + //printf("data[i] data[i + 1] = %08x%08x\n", data[i], data[i + 1]); + + // can we turn this into a single xor + + if ((overflow > 0) && (overflow <= 4)) { + //printf("Overflow case 1\n"); + hash ^= hl32_to_64 (data[i + 1], data[i]); + hash *= M; + } + + else if (overflow > 4) { + //printf("Overflow case 2\n"); + //printf("tmp = %08x%08x\n", h32_from_64(tmp), l32_from_64(tmp)); + hash ^= hl32_to_64 (data[i + 1], data[i]); + hash *= M; + } + + //u64 test = hl32_to_64 (0x0a16869e, 0xcb107f54); + //printf("hl32_to_64 test = %08x%08x\n", h32_from_64(test), l32_from_64(test)); + + //printf("AFTER_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + + hash ^= hash >> R; + hash *= M; + hash ^= hash >> R; + + #undef M + #undef R + + //printf("hash = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + + return hash; +} + +KERNEL_FQ void m90010_m04 (KERN_ATTR_BASIC ()) +{ + /** + * modifier + */ + + const u64 gid = get_global_id (0); + const u64 lid = get_local_id (0); + + if (gid >= GID_CNT) return; + + /** + * base + */ + + u32 pw_buf0[4]; + u32 pw_buf1[4]; + + pw_buf0[0] = pws[gid].i[0]; + pw_buf0[1] = pws[gid].i[1]; + pw_buf0[2] = pws[gid].i[2]; + pw_buf0[3] = pws[gid].i[3]; + pw_buf1[0] = pws[gid].i[4]; + pw_buf1[1] = pws[gid].i[5]; + pw_buf1[2] = pws[gid].i[6]; + pw_buf1[3] = pws[gid].i[7]; + + const u32 pw_l_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; + + /** + * seed + */ + + /** + * loop + */ + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) + { + const u32 pw_r_len = pwlenx_create_combt (combs_buf, il_pos) & 63; + + const u32 pw_len = (pw_l_len + pw_r_len) & 63; + + /** + * concat password candidate + */ + + u32 wordl0[4] = { 0 }; + u32 wordl1[4] = { 0 }; + u32 wordl2[4] = { 0 }; + u32 wordl3[4] = { 0 }; + + wordl0[0] = pw_buf0[0]; + wordl0[1] = pw_buf0[1]; + wordl0[2] = pw_buf0[2]; + wordl0[3] = pw_buf0[3]; + wordl1[0] = pw_buf1[0]; + wordl1[1] = pw_buf1[1]; + wordl1[2] = pw_buf1[2]; + wordl1[3] = pw_buf1[3]; + + u32 wordr0[4] = { 0 }; + u32 wordr1[4] = { 0 }; + u32 wordr2[4] = { 0 }; + u32 wordr3[4] = { 0 }; + + wordr0[0] = ix_create_combt (combs_buf, il_pos, 0); + wordr0[1] = ix_create_combt (combs_buf, il_pos, 1); + wordr0[2] = ix_create_combt (combs_buf, il_pos, 2); + wordr0[3] = ix_create_combt (combs_buf, il_pos, 3); + wordr1[0] = ix_create_combt (combs_buf, il_pos, 4); + wordr1[1] = ix_create_combt (combs_buf, il_pos, 5); + wordr1[2] = ix_create_combt (combs_buf, il_pos, 6); + wordr1[3] = ix_create_combt (combs_buf, il_pos, 7); + + if (COMBS_MODE == COMBINATOR_MODE_BASE_LEFT) + { + switch_buffer_by_offset_le_VV (wordr0, wordr1, wordr2, wordr3, pw_l_len); + } + else + { + switch_buffer_by_offset_le_VV (wordl0, wordl1, wordl2, wordl3, pw_r_len); + } + + u32 w[16]; + + w[ 0] = wordl0[0] | wordr0[0]; + w[ 1] = wordl0[1] | wordr0[1]; + w[ 2] = wordl0[2] | wordr0[2]; + w[ 3] = wordl0[3] | wordr0[3]; + w[ 4] = wordl1[0] | wordr1[0]; + w[ 5] = wordl1[1] | wordr1[1]; + w[ 6] = wordl1[2] | wordr1[2]; + w[ 7] = wordl1[3] | wordr1[3]; + w[ 8] = wordl2[0] | wordr2[0]; + w[ 9] = wordl2[1] | wordr2[1]; + w[10] = wordl2[2] | wordr2[2]; + w[11] = wordl2[3] | wordr2[3]; + w[12] = wordl3[0] | wordr3[0]; + w[13] = wordl3[1] | wordr3[1]; + w[14] = wordl3[2] | wordr3[2]; + w[15] = wordl3[3] | wordr3[3]; + + u64x hash = MurmurHash64A (w, pw_len); + + const u32x r0 = l32_from_64(hash); + const u32x r1 = h32_from_64(hash); + const u32x z = 0; + + COMPARE_M_SIMD (r0, r1, z, z); + } +} + +KERNEL_FQ void m90010_m08 (KERN_ATTR_BASIC ()) +{ +} + +KERNEL_FQ void m90010_m16 (KERN_ATTR_BASIC ()) +{ +} + +KERNEL_FQ void m90010_s04 (KERN_ATTR_BASIC ()) +{ + /** + * modifier + */ + + const u64 gid = get_global_id (0); + const u64 lid = get_local_id (0); + + if (gid >= GID_CNT) return; + + /** + * base + */ + + u32 pw_buf0[4]; + u32 pw_buf1[4]; + + pw_buf0[0] = pws[gid].i[0]; + pw_buf0[1] = pws[gid].i[1]; + pw_buf0[2] = pws[gid].i[2]; + pw_buf0[3] = pws[gid].i[3]; + pw_buf1[0] = pws[gid].i[4]; + pw_buf1[1] = pws[gid].i[5]; + pw_buf1[2] = pws[gid].i[6]; + pw_buf1[3] = pws[gid].i[7]; + + const u32 pw_l_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; + + /** + * seed + */ + + /** + * digest + */ + + const u32 search[4] = + { + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R0], + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R1], + 0, + 0 + }; + + /** + * loop + */ + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) + { + const u32 pw_r_len = pwlenx_create_combt (combs_buf, il_pos) & 63; + + const u32 pw_len = (pw_l_len + pw_r_len) & 63; + + /** + * concat password candidate + */ + + u32 wordl0[4] = { 0 }; + u32 wordl1[4] = { 0 }; + u32 wordl2[4] = { 0 }; + u32 wordl3[4] = { 0 }; + + wordl0[0] = pw_buf0[0]; + wordl0[1] = pw_buf0[1]; + wordl0[2] = pw_buf0[2]; + wordl0[3] = pw_buf0[3]; + wordl1[0] = pw_buf1[0]; + wordl1[1] = pw_buf1[1]; + wordl1[2] = pw_buf1[2]; + wordl1[3] = pw_buf1[3]; + + u32 wordr0[4] = { 0 }; + u32 wordr1[4] = { 0 }; + u32 wordr2[4] = { 0 }; + u32 wordr3[4] = { 0 }; + + wordr0[0] = ix_create_combt (combs_buf, il_pos, 0); + wordr0[1] = ix_create_combt (combs_buf, il_pos, 1); + wordr0[2] = ix_create_combt (combs_buf, il_pos, 2); + wordr0[3] = ix_create_combt (combs_buf, il_pos, 3); + wordr1[0] = ix_create_combt (combs_buf, il_pos, 4); + wordr1[1] = ix_create_combt (combs_buf, il_pos, 5); + wordr1[2] = ix_create_combt (combs_buf, il_pos, 6); + wordr1[3] = ix_create_combt (combs_buf, il_pos, 7); + + if (COMBS_MODE == COMBINATOR_MODE_BASE_LEFT) + { + switch_buffer_by_offset_le_VV (wordr0, wordr1, wordr2, wordr3, pw_l_len); + } + else + { + switch_buffer_by_offset_le_VV (wordl0, wordl1, wordl2, wordl3, pw_r_len); + } + + u32 w[16]; + + w[ 0] = wordl0[0] | wordr0[0]; + w[ 1] = wordl0[1] | wordr0[1]; + w[ 2] = wordl0[2] | wordr0[2]; + w[ 3] = wordl0[3] | wordr0[3]; + w[ 4] = wordl1[0] | wordr1[0]; + w[ 5] = wordl1[1] | wordr1[1]; + w[ 6] = wordl1[2] | wordr1[2]; + w[ 7] = wordl1[3] | wordr1[3]; + w[ 8] = wordl2[0] | wordr2[0]; + w[ 9] = wordl2[1] | wordr2[1]; + w[10] = wordl2[2] | wordr2[2]; + w[11] = wordl2[3] | wordr2[3]; + w[12] = wordl3[0] | wordr3[0]; + w[13] = wordl3[1] | wordr3[1]; + w[14] = wordl3[2] | wordr3[2]; + w[15] = wordl3[3] | wordr3[3]; + + u64 hash = MurmurHash64A (w, pw_len); + + const u32 r0 = l32_from_64(hash); + const u32 r1 = h32_from_64(hash); + const u32 z = 0; + + COMPARE_S_SIMD (r0, r1, z, z); + } +} + +KERNEL_FQ void m90010_s08 (KERN_ATTR_BASIC ()) +{ +} + +KERNEL_FQ void m90010_s16 (KERN_ATTR_BASIC ()) +{ +} diff --git a/OpenCL/m90030_a3-optimized.cl b/OpenCL/m90030_a3-optimized.cl new file mode 100644 index 000000000..7f5b8f83c --- /dev/null +++ b/OpenCL/m90030_a3-optimized.cl @@ -0,0 +1,475 @@ +/** + * Author......: See docs/credits.txt + * License.....: MIT + */ + +//#define NEW_SIMD_CODE + +#ifdef KERNEL_STATIC +#include M2S(INCLUDE_PATH/inc_vendor.h) +#include M2S(INCLUDE_PATH/inc_types.h) +#include M2S(INCLUDE_PATH/inc_platform.cl) +#include M2S(INCLUDE_PATH/inc_common.cl) +#include M2S(INCLUDE_PATH/inc_simd.cl) +#endif + + +DECLSPEC u64x MurmurHash64A (PRIVATE_AS const u32x *data, const u32 len) +{ + #define M 0xc6a4a7935bd1e995 + #define R 47 + + //Initialize hash + u64x hash = 0 ^ (len * M); + + //printf("len = %d\n", len); + //printf("INITIAL = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + + // 2 for each u64 block + const u32 num_blocks = (len / 8) * 2; + + //printf("num_blocks = %d\n", num_blocks); + + // Loop over blocks of 8 bytes + u32 i = 0; + while (i < num_blocks) { + u64x k = hl32_to_64 (data[i + 1], data[i]); + + k *= M; + k ^= k >> R; + k *= M; + + hash ^= k; + hash *= M; + + i += 2; + } + + //printf("BEFORE_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + + // Overflow + + const u32 overflow = len & 7; + + //printf("OVERFLOW = %d\n", overflow); + + //printf("data = %08x%08x%08x%08x%08x%08x%08x%08x%08x%08x\n", data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9]); + + //printf("i = %d\n", i); + //printf("data[i] data[i + 1] = %08x%08x\n", data[i], data[i + 1]); + + // can we turn this into a single xor + + if ((overflow > 0) && (overflow <= 4)) { + //printf("Overflow case 1\n"); + hash ^= hl32_to_64 (data[i + 1], data[i]); + hash *= M; + } + + else if (overflow > 4) { + //printf("Overflow case 2\n"); + //printf("tmp = %08x%08x\n", h32_from_64(tmp), l32_from_64(tmp)); + hash ^= hl32_to_64 (data[i + 1], data[i]); + hash *= M; + } + + //u64 test = hl32_to_64 (0x0a16869e, 0xcb107f54); + //printf("hl32_to_64 test = %08x%08x\n", h32_from_64(test), l32_from_64(test)); + + //printf("AFTER_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + + hash ^= hash >> R; + hash *= M; + hash ^= hash >> R; + + #undef M + #undef R + + //printf("hash = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + + return hash; +} + +DECLSPEC void m90010m (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_FUNC_VECTOR ()) +{ + /** + * modifiers are taken from args + */ + + /** + * seed + */ + + /** + * base + */ + + u32x w[16]; + + w[ 0] = data[ 0]; + w[ 1] = data[ 1]; + w[ 2] = data[ 2]; + w[ 3] = data[ 3]; + w[ 4] = data[ 4]; + w[ 5] = data[ 5]; + w[ 6] = data[ 6]; + w[ 7] = data[ 7]; + w[ 8] = data[ 8]; + w[ 9] = data[ 9]; + w[10] = data[10]; + w[11] = data[11]; + w[12] = data[12]; + w[13] = data[13]; + w[14] = data[14]; + w[15] = data[15]; + + //const u8 *data2 = (const u8*) data; + //printf("w = %c%c%c%c%c%c%c%c\n", data2[0], data2[1], data2[2], data2[3], data2[4], data2[5], data2[6], data2[7]); + + /** + * loop + */ + + u32x w0l = w[0]; + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) + { + const u32x w0r = words_buf_r[il_pos / VECT_SIZE]; + + const u32x w0 = w0l | w0r; + + w[0] = w0; + + //printf("seed = %08x%08x\n", seed_hi, seed_lo); + + const u64x hash = MurmurHash64A (w, pw_len); + + const u32x r0 = l32_from_64(hash); + const u32x r1 = h32_from_64(hash); + const u32x z = 0; + + //printf("hash = %08x%08x\n", r1, r0); + + COMPARE_M_SIMD (r0, r1, z, z); + } +} + +DECLSPEC void m90010s (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_FUNC_VECTOR ()) +{ + /** + * modifiers are taken from args + */ + + /** + * digest + */ + + //printf("Hello world m90010s\n"); + + const u32 search[4] = + { + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R0], + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R1], + 0, + 0 + }; + + /** + * seed + */ + + /** + * base + */ + + u32x w[16]; + + w[ 0] = data[ 0]; + w[ 1] = data[ 1]; + w[ 2] = data[ 2]; + w[ 3] = data[ 3]; + w[ 4] = data[ 4]; + w[ 5] = data[ 5]; + w[ 6] = data[ 6]; + w[ 7] = data[ 7]; + w[ 8] = data[ 8]; + w[ 9] = data[ 9]; + w[10] = data[10]; + w[11] = data[11]; + w[12] = data[12]; + w[13] = data[13]; + w[14] = data[14]; + w[15] = data[15]; + + /** + * loop + */ + + u32x w0l = w[0]; + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) + { + const u32x w0r = words_buf_r[il_pos / VECT_SIZE]; + + const u32x w0 = w0l | w0r; + + w[0] = w0; + + const u64x hash = MurmurHash64A (w, pw_len); + + const u32x r0 = l32_from_64(hash); + const u32x r1 = h32_from_64(hash); + const u32x z = 0; + + //printf("r1 = %08x r0 = %08x\n", r1, r0); + //printf("hash = %08x%08x\n", r1, r0); + + COMPARE_S_SIMD (r0, r1, z, z); + } +} + +KERNEL_FQ void m90010_m04 (KERN_ATTR_VECTOR ()) +{ + /** + * base + */ + + //printf("Hello world m90010_m04\n"); + + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + const u64 lsz = get_local_size (0); + + if (gid >= GID_CNT) return; + + u32 w[16]; + + w[ 0] = pws[gid].i[ 0]; + w[ 1] = pws[gid].i[ 1]; + w[ 2] = pws[gid].i[ 2]; + w[ 3] = pws[gid].i[ 3]; + w[ 4] = 0; + w[ 5] = 0; + w[ 6] = 0; + w[ 7] = 0; + w[ 8] = 0; + w[ 9] = 0; + w[10] = 0; + w[11] = 0; + w[12] = 0; + w[13] = 0; + w[14] = 0; + w[15] = 0; + + const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; + //printf("pws[gid].pw_len = %d\n", pws[gid].pw_len); + + /** + * main + */ + + m90010m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); +} + +KERNEL_FQ void m90010_m08 (KERN_ATTR_VECTOR ()) +{ + /** + * base + */ + + //printf("Hello world m90010_m08\n"); + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + const u64 lsz = get_local_size (0); + + if (gid >= GID_CNT) return; + + u32 w[16]; + + w[ 0] = pws[gid].i[ 0]; + w[ 1] = pws[gid].i[ 1]; + w[ 2] = pws[gid].i[ 2]; + w[ 3] = pws[gid].i[ 3]; + w[ 4] = pws[gid].i[ 4]; + w[ 5] = pws[gid].i[ 5]; + w[ 6] = pws[gid].i[ 6]; + w[ 7] = pws[gid].i[ 7]; + w[ 8] = 0; + w[ 9] = 0; + w[10] = 0; + w[11] = 0; + w[12] = 0; + w[13] = 0; + w[14] = 0; + w[15] = 0; + + const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; + + /** + * main + */ + + m90010m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); +} + +KERNEL_FQ void m90010_m16 (KERN_ATTR_VECTOR ()) +{ + /** + * base + */ + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + const u64 lsz = get_local_size (0); + + if (gid >= GID_CNT) return; + + u32 w[16]; + + w[ 0] = pws[gid].i[ 0]; + w[ 1] = pws[gid].i[ 1]; + w[ 2] = pws[gid].i[ 2]; + w[ 3] = pws[gid].i[ 3]; + w[ 4] = pws[gid].i[ 4]; + w[ 5] = pws[gid].i[ 5]; + w[ 6] = pws[gid].i[ 6]; + w[ 7] = pws[gid].i[ 7]; + w[ 8] = pws[gid].i[ 8]; + w[ 9] = pws[gid].i[ 9]; + w[10] = pws[gid].i[10]; + w[11] = pws[gid].i[11]; + w[12] = pws[gid].i[12]; + w[13] = pws[gid].i[13]; + w[14] = pws[gid].i[14]; + w[15] = pws[gid].i[15]; + + const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; + + /** + * main + */ + + m90010m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); +} + +KERNEL_FQ void m90010_s04 (KERN_ATTR_VECTOR ()) +{ + /** + * base + */ + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + const u64 lsz = get_local_size (0); + + if (gid >= GID_CNT) return; + + u32 w[16]; + + w[ 0] = pws[gid].i[ 0]; + w[ 1] = pws[gid].i[ 1]; + w[ 2] = pws[gid].i[ 2]; + w[ 3] = pws[gid].i[ 3]; + w[ 4] = 0; + w[ 5] = 0; + w[ 6] = 0; + w[ 7] = 0; + w[ 8] = 0; + w[ 9] = 0; + w[10] = 0; + w[11] = 0; + w[12] = 0; + w[13] = 0; + w[14] = 0; + w[15] = 0; + + const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; + + /** + * main + */ + + m90010s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); +} + +KERNEL_FQ void m90010_s08 (KERN_ATTR_VECTOR ()) +{ + /** + * base + */ + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + const u64 lsz = get_local_size (0); + + if (gid >= GID_CNT) return; + + u32 w[16]; + + w[ 0] = pws[gid].i[ 0]; + w[ 1] = pws[gid].i[ 1]; + w[ 2] = pws[gid].i[ 2]; + w[ 3] = pws[gid].i[ 3]; + w[ 4] = pws[gid].i[ 4]; + w[ 5] = pws[gid].i[ 5]; + w[ 6] = pws[gid].i[ 6]; + w[ 7] = pws[gid].i[ 7]; + w[ 8] = 0; + w[ 9] = 0; + w[10] = 0; + w[11] = 0; + w[12] = 0; + w[13] = 0; + w[14] = 0; + w[15] = 0; + + const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; + + /** + * main + */ + + m90010s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); +} + +KERNEL_FQ void m90010_s16 (KERN_ATTR_VECTOR ()) +{ + /** + * base + */ + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + const u64 lsz = get_local_size (0); + + if (gid >= GID_CNT) return; + + u32 w[16]; + + w[ 0] = pws[gid].i[ 0]; + w[ 1] = pws[gid].i[ 1]; + w[ 2] = pws[gid].i[ 2]; + w[ 3] = pws[gid].i[ 3]; + w[ 4] = pws[gid].i[ 4]; + w[ 5] = pws[gid].i[ 5]; + w[ 6] = pws[gid].i[ 6]; + w[ 7] = pws[gid].i[ 7]; + w[ 8] = pws[gid].i[ 8]; + w[ 9] = pws[gid].i[ 9]; + w[10] = pws[gid].i[10]; + w[11] = pws[gid].i[11]; + w[12] = pws[gid].i[12]; + w[13] = pws[gid].i[13]; + w[14] = pws[gid].i[14]; + w[15] = pws[gid].i[15]; + + const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; + + /** + * main + */ + + m90010s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); +} From 79e801583181d3a4336773d71507b3d0a6e9fc97 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Tue, 12 Nov 2024 14:16:27 +1100 Subject: [PATCH 47/61] Fix m90030 optimized kernels --- OpenCL/m90030_a0-optimized.cl | 39 ++++++++++++-------------- OpenCL/m90030_a1-optimized.cl | 30 +++++++++----------- OpenCL/m90030_a3-optimized.cl | 52 ++++++++++++++++------------------- 3 files changed, 54 insertions(+), 67 deletions(-) diff --git a/OpenCL/m90030_a0-optimized.cl b/OpenCL/m90030_a0-optimized.cl index ca8f99823..71c54129d 100644 --- a/OpenCL/m90030_a0-optimized.cl +++ b/OpenCL/m90030_a0-optimized.cl @@ -15,7 +15,7 @@ #include M2S(INCLUDE_PATH/inc_simd.cl) #endif -DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) +DECLSPEC u32 MurmurHash64A_32 (PRIVATE_AS const u32 *data, const u32 len) { #define M 0xc6a4a7935bd1e995 #define R 47 @@ -74,9 +74,6 @@ DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) hash *= M; } - //u64 test = hl32_to_64 (0x0a16869e, 0xcb107f54); - //printf("hl32_to_64 test = %08x%08x\n", h32_from_64(test), l32_from_64(test)); - //printf("AFTER_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); hash ^= hash >> R; @@ -88,14 +85,14 @@ DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) //printf("hash = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); - return hash; + return (u32) (hash >> 32); } -KERNEL_FQ void m90010_m04 (KERN_ATTR_RULES ()) +KERNEL_FQ void m90030_m04 (KERN_ATTR_RULES ()) { - //printf("Hello world m90010_m04\n"); + //printf("Hello world m90030_m04\n"); /** * modifier */ @@ -135,27 +132,27 @@ KERNEL_FQ void m90010_m04 (KERN_ATTR_RULES ()) const u32x out_len = apply_rules_vect_optimized (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w + 0, w + 4); - u64x hash = MurmurHash64A (w, out_len); + u32x hash = MurmurHash64A_32 (w, out_len); + + //printf("hash = %08x\n", hash); - const u32x r0 = l32_from_64(hash); - const u32x r1 = h32_from_64(hash); const u32x z = 0; - COMPARE_M_SIMD (r0, r1, z, z); + COMPARE_M_SIMD (hash, z, z, z); } } -KERNEL_FQ void m90010_m08 (KERN_ATTR_RULES ()) +KERNEL_FQ void m90030_m08 (KERN_ATTR_RULES ()) { } -KERNEL_FQ void m90010_m16 (KERN_ATTR_RULES ()) +KERNEL_FQ void m90030_m16 (KERN_ATTR_RULES ()) { } -KERNEL_FQ void m90010_s04 (KERN_ATTR_RULES ()) +KERNEL_FQ void m90030_s04 (KERN_ATTR_RULES ()) { - //printf("Hello world m90010_s04\n"); + //printf("Hello world m90030_s04\n"); /** * modifier */ @@ -192,7 +189,7 @@ KERNEL_FQ void m90010_s04 (KERN_ATTR_RULES ()) const u32 search[4] = { digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R0], - digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R1], + 0, 0, 0 }; @@ -207,20 +204,18 @@ KERNEL_FQ void m90010_s04 (KERN_ATTR_RULES ()) const u32x out_len = apply_rules_vect_optimized (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w + 0, w + 4); - u64x hash = MurmurHash64A (w, out_len); + u32x hash = MurmurHash64A_32 (w, out_len); - const u32x r0 = l32_from_64(hash); - const u32x r1 = h32_from_64(hash); const u32x z = 0; - COMPARE_S_SIMD (r0, r1, z, z); + COMPARE_S_SIMD (hash, z, z, z); } } -KERNEL_FQ void m90010_s08 (KERN_ATTR_RULES ()) +KERNEL_FQ void m90030_s08 (KERN_ATTR_RULES ()) { } -KERNEL_FQ void m90010_s16 (KERN_ATTR_RULES ()) +KERNEL_FQ void m90030_s16 (KERN_ATTR_RULES ()) { } diff --git a/OpenCL/m90030_a1-optimized.cl b/OpenCL/m90030_a1-optimized.cl index 344157d42..a5801e43b 100644 --- a/OpenCL/m90030_a1-optimized.cl +++ b/OpenCL/m90030_a1-optimized.cl @@ -14,7 +14,7 @@ #include M2S(INCLUDE_PATH/inc_simd.cl) #endif -DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) +DECLSPEC u32 MurmurHash64A_32 (PRIVATE_AS const u32 *data, const u32 len) { #define M 0xc6a4a7935bd1e995 #define R 47 @@ -87,10 +87,10 @@ DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) //printf("hash = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); - return hash; + return (u32) (hash >> 32); } -KERNEL_FQ void m90010_m04 (KERN_ATTR_BASIC ()) +KERNEL_FQ void m90030_m04 (KERN_ATTR_BASIC ()) { /** * modifier @@ -193,25 +193,23 @@ KERNEL_FQ void m90010_m04 (KERN_ATTR_BASIC ()) w[14] = wordl3[2] | wordr3[2]; w[15] = wordl3[3] | wordr3[3]; - u64x hash = MurmurHash64A (w, pw_len); + u32x hash = MurmurHash64A_32 (w, pw_len); - const u32x r0 = l32_from_64(hash); - const u32x r1 = h32_from_64(hash); const u32x z = 0; - COMPARE_M_SIMD (r0, r1, z, z); + COMPARE_M_SIMD (hash, z, z, z); } } -KERNEL_FQ void m90010_m08 (KERN_ATTR_BASIC ()) +KERNEL_FQ void m90030_m08 (KERN_ATTR_BASIC ()) { } -KERNEL_FQ void m90010_m16 (KERN_ATTR_BASIC ()) +KERNEL_FQ void m90030_m16 (KERN_ATTR_BASIC ()) { } -KERNEL_FQ void m90010_s04 (KERN_ATTR_BASIC ()) +KERNEL_FQ void m90030_s04 (KERN_ATTR_BASIC ()) { /** * modifier @@ -251,7 +249,7 @@ KERNEL_FQ void m90010_s04 (KERN_ATTR_BASIC ()) const u32 search[4] = { digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R0], - digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R1], + 0, 0, 0 }; @@ -326,20 +324,18 @@ KERNEL_FQ void m90010_s04 (KERN_ATTR_BASIC ()) w[14] = wordl3[2] | wordr3[2]; w[15] = wordl3[3] | wordr3[3]; - u64 hash = MurmurHash64A (w, pw_len); + u32 hash = MurmurHash64A_32 (w, pw_len); - const u32 r0 = l32_from_64(hash); - const u32 r1 = h32_from_64(hash); const u32 z = 0; - COMPARE_S_SIMD (r0, r1, z, z); + COMPARE_S_SIMD (hash, z, z, z); } } -KERNEL_FQ void m90010_s08 (KERN_ATTR_BASIC ()) +KERNEL_FQ void m90030_s08 (KERN_ATTR_BASIC ()) { } -KERNEL_FQ void m90010_s16 (KERN_ATTR_BASIC ()) +KERNEL_FQ void m90030_s16 (KERN_ATTR_BASIC ()) { } diff --git a/OpenCL/m90030_a3-optimized.cl b/OpenCL/m90030_a3-optimized.cl index 7f5b8f83c..61d6537ea 100644 --- a/OpenCL/m90030_a3-optimized.cl +++ b/OpenCL/m90030_a3-optimized.cl @@ -14,7 +14,7 @@ #endif -DECLSPEC u64x MurmurHash64A (PRIVATE_AS const u32x *data, const u32 len) +DECLSPEC u32x MurmurHash64A_32 (PRIVATE_AS const u32x *data, const u32 len) { #define M 0xc6a4a7935bd1e995 #define R 47 @@ -87,10 +87,10 @@ DECLSPEC u64x MurmurHash64A (PRIVATE_AS const u32x *data, const u32 len) //printf("hash = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); - return hash; + return (u32) (hash >> 32); } -DECLSPEC void m90010m (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_FUNC_VECTOR ()) +DECLSPEC void m90030m (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_FUNC_VECTOR ()) { /** * modifiers are taken from args @@ -142,19 +142,17 @@ DECLSPEC void m90010m (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F //printf("seed = %08x%08x\n", seed_hi, seed_lo); - const u64x hash = MurmurHash64A (w, pw_len); + const u32x hash = MurmurHash64A_32 (w, pw_len); - const u32x r0 = l32_from_64(hash); - const u32x r1 = h32_from_64(hash); const u32x z = 0; //printf("hash = %08x%08x\n", r1, r0); - COMPARE_M_SIMD (r0, r1, z, z); + COMPARE_M_SIMD (hash, z, z, z); } } -DECLSPEC void m90010s (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_FUNC_VECTOR ()) +DECLSPEC void m90030s (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_FUNC_VECTOR ()) { /** * modifiers are taken from args @@ -164,12 +162,12 @@ DECLSPEC void m90010s (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F * digest */ - //printf("Hello world m90010s\n"); + //printf("Hello world m90030s\n"); const u32 search[4] = { digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R0], - digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R1], + 0, 0, 0 }; @@ -215,26 +213,24 @@ DECLSPEC void m90010s (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F w[0] = w0; - const u64x hash = MurmurHash64A (w, pw_len); + const u32x hash = MurmurHash64A_32 (w, pw_len); - const u32x r0 = l32_from_64(hash); - const u32x r1 = h32_from_64(hash); const u32x z = 0; //printf("r1 = %08x r0 = %08x\n", r1, r0); //printf("hash = %08x%08x\n", r1, r0); - COMPARE_S_SIMD (r0, r1, z, z); + COMPARE_S_SIMD (hash, z, z, z); } } -KERNEL_FQ void m90010_m04 (KERN_ATTR_VECTOR ()) +KERNEL_FQ void m90030_m04 (KERN_ATTR_VECTOR ()) { /** * base */ - //printf("Hello world m90010_m04\n"); + //printf("Hello world m90030_m04\n"); const u64 lid = get_local_id (0); @@ -269,16 +265,16 @@ KERNEL_FQ void m90010_m04 (KERN_ATTR_VECTOR ()) * main */ - m90010m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); + m90030m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ void m90010_m08 (KERN_ATTR_VECTOR ()) +KERNEL_FQ void m90030_m08 (KERN_ATTR_VECTOR ()) { /** * base */ - //printf("Hello world m90010_m08\n"); + //printf("Hello world m90030_m08\n"); const u64 lid = get_local_id (0); const u64 gid = get_global_id (0); @@ -311,10 +307,10 @@ KERNEL_FQ void m90010_m08 (KERN_ATTR_VECTOR ()) * main */ - m90010m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); + m90030m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ void m90010_m16 (KERN_ATTR_VECTOR ()) +KERNEL_FQ void m90030_m16 (KERN_ATTR_VECTOR ()) { /** * base @@ -351,10 +347,10 @@ KERNEL_FQ void m90010_m16 (KERN_ATTR_VECTOR ()) * main */ - m90010m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); + m90030m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ void m90010_s04 (KERN_ATTR_VECTOR ()) +KERNEL_FQ void m90030_s04 (KERN_ATTR_VECTOR ()) { /** * base @@ -391,10 +387,10 @@ KERNEL_FQ void m90010_s04 (KERN_ATTR_VECTOR ()) * main */ - m90010s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); + m90030s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ void m90010_s08 (KERN_ATTR_VECTOR ()) +KERNEL_FQ void m90030_s08 (KERN_ATTR_VECTOR ()) { /** * base @@ -431,10 +427,10 @@ KERNEL_FQ void m90010_s08 (KERN_ATTR_VECTOR ()) * main */ - m90010s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); + m90030s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ void m90010_s16 (KERN_ATTR_VECTOR ()) +KERNEL_FQ void m90030_s16 (KERN_ATTR_VECTOR ()) { /** * base @@ -471,5 +467,5 @@ KERNEL_FQ void m90010_s16 (KERN_ATTR_VECTOR ()) * main */ - m90010s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); + m90030s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } From f6b262842b50781628e16eb319cbd29abc75d79a Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Tue, 12 Nov 2024 14:16:38 +1100 Subject: [PATCH 48/61] Fix m90030 C module --- src/modules/module_90030.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/modules/module_90030.c b/src/modules/module_90030.c index c8c9f6bd5..6bfca51b2 100644 --- a/src/modules/module_90030.c +++ b/src/modules/module_90030.c @@ -15,12 +15,13 @@ static const u32 DGST_POS0 = 0; static const u32 DGST_POS1 = 1; static const u32 DGST_POS2 = 2; static const u32 DGST_POS3 = 3; -static const u32 DGST_SIZE = DGST_SIZE_4_2; +static const u32 DGST_SIZE = DGST_SIZE_4_4; static const u32 HASH_CATEGORY = HASH_CATEGORY_RAW_HASH; static const char *HASH_NAME = "MurmurHash64A 32 Zero Seed"; static const u64 KERN_TYPE = 90030; static const u32 OPTI_TYPE = OPTI_TYPE_ZERO_BYTE - | OPTI_TYPE_NOT_SALTED; + | OPTI_TYPE_NOT_SALTED + | OPTI_TYPE_USES_BITS_64; static const u64 OPTS_TYPE = OPTS_TYPE_STOCK_MODULE | OPTS_TYPE_PT_GENERATE_LE | OPTS_TYPE_SUGGEST_KG; From 34022c303abdaebcb1ec76ff4fbc9bbe403fed49 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Tue, 12 Nov 2024 14:17:11 +1100 Subject: [PATCH 49/61] Update helper python file --- scratch.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/scratch.py b/scratch.py index 3279457f7..58fc2d64b 100644 --- a/scratch.py +++ b/scratch.py @@ -122,7 +122,9 @@ def get_hash(string: str, seed: int) -> int: key = [ord(char) for char in string] return hash64(key, seed) - +def get_short_hash(string: str, seed: int) -> int: + key = [ord(char) for char in string] + return hash32(key, seed) From e37800d9bbc785b067e8a2e8ee7824defa59375c Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Tue, 22 Jul 2025 19:38:28 +1000 Subject: [PATCH 50/61] Fix up modules for new hashcat updates --- OpenCL/m90000_a0-optimized.cl | 130 +++++++------------- OpenCL/m90000_a0-pure.cl | 138 ++++++--------------- OpenCL/m90000_a1-optimized.cl | 128 +++++++------------- OpenCL/m90000_a1-pure.cl | 222 +++++++++++----------------------- OpenCL/m90000_a3-optimized.cl | 106 ++++++---------- OpenCL/m90000_a3-pure.cl | 192 +++++++++++++++++++++++++++++ OpenCL/m90010_a0-optimized.cl | 83 +++++-------- OpenCL/m90010_a0-pure.cl | 79 +++--------- OpenCL/m90010_a1-optimized.cl | 79 ++++-------- OpenCL/m90010_a1-pure.cl | 206 +++++++++++++------------------ OpenCL/m90010_a3-optimized.cl | 101 ++++------------ OpenCL/m90010_a3-pure.cl | 68 ++++------- OpenCL/m90030_a0-optimized.cl | 74 ++++-------- OpenCL/m90030_a1-optimized.cl | 78 ++++-------- OpenCL/m90030_a3-optimized.cl | 98 ++++----------- scratch.py | 177 --------------------------- src/Makefile | 2 +- src/modules/module_90000.c | 2 + src/modules/module_90010.c | 7 +- src/modules/module_90030.c | 4 +- tools/test_modules/m90000.pm | 19 ++- tools/test_modules/m90010.pm | 21 ++-- tools/test_modules/m90030.pm | 23 ++-- 23 files changed, 718 insertions(+), 1319 deletions(-) mode change 100644 => 100755 OpenCL/m90000_a0-optimized.cl mode change 100644 => 100755 OpenCL/m90000_a0-pure.cl mode change 100644 => 100755 OpenCL/m90000_a1-optimized.cl mode change 100644 => 100755 OpenCL/m90000_a1-pure.cl mode change 100644 => 100755 OpenCL/m90000_a3-optimized.cl create mode 100755 OpenCL/m90000_a3-pure.cl mode change 100644 => 100755 OpenCL/m90010_a0-optimized.cl mode change 100644 => 100755 OpenCL/m90010_a0-pure.cl mode change 100644 => 100755 OpenCL/m90010_a1-optimized.cl mode change 100644 => 100755 OpenCL/m90010_a1-pure.cl mode change 100644 => 100755 OpenCL/m90010_a3-optimized.cl mode change 100644 => 100755 OpenCL/m90010_a3-pure.cl mode change 100644 => 100755 OpenCL/m90030_a0-optimized.cl mode change 100644 => 100755 OpenCL/m90030_a1-optimized.cl mode change 100644 => 100755 OpenCL/m90030_a3-optimized.cl delete mode 100644 scratch.py mode change 100644 => 100755 src/modules/module_90000.c mode change 100644 => 100755 src/modules/module_90010.c mode change 100644 => 100755 src/modules/module_90030.c mode change 100644 => 100755 tools/test_modules/m90000.pm mode change 100644 => 100755 tools/test_modules/m90010.pm mode change 100644 => 100755 tools/test_modules/m90030.pm diff --git a/OpenCL/m90000_a0-optimized.cl b/OpenCL/m90000_a0-optimized.cl old mode 100644 new mode 100755 index 07e878682..1842c60aa --- a/OpenCL/m90000_a0-optimized.cl +++ b/OpenCL/m90000_a0-optimized.cl @@ -15,46 +15,45 @@ #include M2S(INCLUDE_PATH/inc_simd.cl) #endif -DECLSPEC u64 MurmurHash64A_round (PRIVATE_AS const u8 *data, u64 hash, const u32 cur_pos) { +DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u32 len) +{ #define M 0xc6a4a7935bd1e995 #define R 47 - u64 k = ((u64) data[cur_pos]) - | ((u64) data[cur_pos + 1] << 8) - | ((u64) data[cur_pos + 2] << 16) - | ((u64) data[cur_pos + 3] << 24) - | ((u64) data[cur_pos + 4] << 32) - | ((u64) data[cur_pos + 5] << 40) - | ((u64) data[cur_pos + 6] << 48) - | ((u64) data[cur_pos + 7] << 56); - - k *= M; - k ^= k >> R; - k *= M; + //Initialize hash + u64 hash = seed ^ (len * M); - hash ^= k; - hash *= M; + // Twice the number of u64 blocks + const u32 num_u32_blocks = (len / 8) * 2; - #undef M - #undef R + // Loop over one u64 at a time + u32 i = 0; + while (i < num_u32_blocks) + { + // Reconstruct u64 from two u32s + u64 k = hl32_to_64 (data[i + 1], data[i]); - return hash; -} + k *= M; + k ^= k >> R; + k *= M; -DECLSPEC u64 MurmurHash64A_final (PRIVATE_AS const u8 *data, u64 hash, const u32 cur_pos, const u32 len) { - #define M 0xc6a4a7935bd1e995 - #define R 47 + hash ^= k; + hash *= M; + i += 2; + } + + // Up to 7 overflow bytes const u32 overflow = len & 7; - switch (overflow) { - case 7: hash ^= ((u64) data[cur_pos + 6]) << 48; - case 6: hash ^= ((u64) data[cur_pos + 5]) << 40; - case 5: hash ^= ((u64) data[cur_pos + 4]) << 32; - case 4: hash ^= ((u64) data[cur_pos + 3]) << 24; - case 3: hash ^= ((u64) data[cur_pos + 2]) << 16; - case 2: hash ^= ((u64) data[cur_pos + 1]) << 8; - case 1: hash ^= ((u64) data[cur_pos]); + if (overflow > 4) + { + hash ^= hl32_to_64 (data[i + 1], data[i]); + hash *= M; + } + else if (overflow > 0) + { + hash ^= hl32_to_64 (0, data[i]); hash *= M; } @@ -68,51 +67,7 @@ DECLSPEC u64 MurmurHash64A_final (PRIVATE_AS const u8 *data, u64 hash, const u32 return hash; } -DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u32 len) -{ - #define M 0xc6a4a7935bd1e995 - #define R 47 - - //Initialize hash - u64 hash = seed ^ (len * M); - - //const u64 INITIAL = hash; - - const u32 endpos = len - (len & 7); - - //const u32 nBlocks = len >> 3; // number of 8 byte blocks - const u8 *data2 = (const u8*) data; - - //u64 MIDDLE_OF_BLOCK = 0; - - // Loop over blocks of 8 bytes - u32 i = 0; - while (i != endpos) { - hash = MurmurHash64A_round(data2, hash, i); - - i += 8; - } - - // Overflow - - //const u64 BEFORE_FINAL = hash; - - hash = MurmurHash64A_final (data2, hash, i, len); - - //const u64 AFTER_FINAL = hash; - - //printf("debug: %016lx:%016lx:%c%c%c%c%c%c%c%c%c%c len: %d INITIAL: %016lx MIDDLE_O_BLK: %016lx B4FINAL: %016lx overflow: %d AFTER_FINAL: %016lx\n", hash, seed, data2[0], data2[1], data2[2], data2[3], data2[4], data2[5], data2[6], data2[7], data2[8], data2[9], len, INITIAL, MIDDLE_OF_BLOCK, BEFORE_FINAL, overflow, AFTER_FINAL); - //printf("data2 = %.2s, len = %d\n", data2[0], len); - - #undef M - #undef R - - return hash; -} - - - -KERNEL_FQ void m90000_m04 (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m90000_m04 (KERN_ATTR_RULES ()) { /** * modifier @@ -146,9 +101,10 @@ KERNEL_FQ void m90000_m04 (KERN_ATTR_RULES ()) * seed */ + // Reconstruct seed from two u32s const u32 seed_lo = salt_bufs[SALT_POS_HOST].salt_buf[0]; const u32 seed_hi = salt_bufs[SALT_POS_HOST].salt_buf[1]; - const u64 seed = ((u64) seed_hi << 32) | ((u64) seed_lo); + const u64 seed = hl32_to_64 (seed_hi, seed_lo); /** * loop @@ -162,23 +118,23 @@ KERNEL_FQ void m90000_m04 (KERN_ATTR_RULES ()) u64x hash = MurmurHash64A (seed, w, out_len); - const u32x r0 = l32_from_64(hash); - const u32x r1 = h32_from_64(hash); + const u32x r0 = l32_from_64 (hash); + const u32x r1 = h32_from_64 (hash); const u32x z = 0; COMPARE_M_SIMD (r0, r1, z, z); } } -KERNEL_FQ void m90000_m08 (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m90000_m08 (KERN_ATTR_RULES ()) { } -KERNEL_FQ void m90000_m16 (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m90000_m16 (KERN_ATTR_RULES ()) { } -KERNEL_FQ void m90000_s04 (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m90000_s04 (KERN_ATTR_RULES ()) { /** * modifier @@ -206,6 +162,7 @@ KERNEL_FQ void m90000_s04 (KERN_ATTR_RULES ()) pw_buf1[2] = pws[gid].i[6]; pw_buf1[3] = pws[gid].i[7]; + // Max pw len of 32 const u32 pw_len = pws[gid].pw_len & 63; /** @@ -224,9 +181,10 @@ KERNEL_FQ void m90000_s04 (KERN_ATTR_RULES ()) * seed */ + // Reconstruct seed from two u32s const u32 seed_lo = salt_bufs[SALT_POS_HOST].salt_buf[0]; const u32 seed_hi = salt_bufs[SALT_POS_HOST].salt_buf[1]; - const u64 seed = ((u64) seed_hi << 32) | ((u64) seed_lo); + const u64 seed = hl32_to_64 (seed_hi, seed_lo); /** * loop @@ -240,18 +198,18 @@ KERNEL_FQ void m90000_s04 (KERN_ATTR_RULES ()) u64x hash = MurmurHash64A (seed, w, out_len); - const u32x r0 = l32_from_64(hash); - const u32x r1 = h32_from_64(hash); + const u32x r0 = l32_from_64 (hash); + const u32x r1 = h32_from_64 (hash); const u32x z = 0; COMPARE_S_SIMD (r0, r1, z, z); } } -KERNEL_FQ void m90000_s08 (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m90000_s08 (KERN_ATTR_RULES ()) { } -KERNEL_FQ void m90000_s16 (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m90000_s16 (KERN_ATTR_RULES ()) { } diff --git a/OpenCL/m90000_a0-pure.cl b/OpenCL/m90000_a0-pure.cl old mode 100644 new mode 100755 index 005a79f0a..a130fb50d --- a/OpenCL/m90000_a0-pure.cl +++ b/OpenCL/m90000_a0-pure.cl @@ -15,46 +15,45 @@ #include M2S(INCLUDE_PATH/inc_scalar.cl) #endif -DECLSPEC u64 MurmurHash64A_round (PRIVATE_AS const u8 *data, u64 hash, const u32 cur_pos) { +DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u32 len) +{ #define M 0xc6a4a7935bd1e995 #define R 47 - u64 k = ((u64) data[cur_pos]) - | ((u64) data[cur_pos + 1] << 8) - | ((u64) data[cur_pos + 2] << 16) - | ((u64) data[cur_pos + 3] << 24) - | ((u64) data[cur_pos + 4] << 32) - | ((u64) data[cur_pos + 5] << 40) - | ((u64) data[cur_pos + 6] << 48) - | ((u64) data[cur_pos + 7] << 56); - - k *= M; - k ^= k >> R; - k *= M; + //Initialize hash + u64 hash = seed ^ (len * M); - hash ^= k; - hash *= M; + // Twice the number of u64 blocks + const u32 num_u32_blocks = (len / 8) * 2; - #undef M - #undef R + // Loop over one u64 at a time + u32 i = 0; + while (i < num_u32_blocks) + { + // Reconstruct u64 from two u32s + u64 k = hl32_to_64 (data[i + 1], data[i]); - return hash; -} + k *= M; + k ^= k >> R; + k *= M; -DECLSPEC u64 MurmurHash64A_final (PRIVATE_AS const u8 *data, u64 hash, const u32 cur_pos, const u32 len) { - #define M 0xc6a4a7935bd1e995 - #define R 47 + hash ^= k; + hash *= M; + i += 2; + } + + // Up to 7 overflow bytes const u32 overflow = len & 7; - switch (overflow) { - case 7: hash ^= ((u64) data[cur_pos + 6]) << 48; - case 6: hash ^= ((u64) data[cur_pos + 5]) << 40; - case 5: hash ^= ((u64) data[cur_pos + 4]) << 32; - case 4: hash ^= ((u64) data[cur_pos + 3]) << 24; - case 3: hash ^= ((u64) data[cur_pos + 2]) << 16; - case 2: hash ^= ((u64) data[cur_pos + 1]) << 8; - case 1: hash ^= ((u64) data[cur_pos]); + if (overflow > 4) + { + hash ^= hl32_to_64 (data[i + 1], data[i]); + hash *= M; + } + else if (overflow > 0) + { + hash ^= hl32_to_64 (0, data[i]); hash *= M; } @@ -68,49 +67,7 @@ DECLSPEC u64 MurmurHash64A_final (PRIVATE_AS const u8 *data, u64 hash, const u32 return hash; } -DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u32 len) -{ - #define M 0xc6a4a7935bd1e995 - #define R 47 - - //Initialize hash - u64 hash = seed ^ (len * M); - - //const u64 INITIAL = hash; - - const u32 endpos = len - (len & 7); - - //const u32 nBlocks = len >> 3; // number of 8 byte blocks - const u8 *data2 = (const u8*) data; - - //u64 MIDDLE_OF_BLOCK = 0; - - // Loop over blocks of 8 bytes - u32 i = 0; - while (i != endpos) { - hash = MurmurHash64A_round(data2, hash, i); - - i += 8; - } - - // Overflow - - //const u64 BEFORE_FINAL = hash; - - hash = MurmurHash64A_final (data2, hash, i, len); - - //const u64 AFTER_FINAL = hash; - - //printf("debug: %016lx:%016lx:%c%c%c%c%c%c%c%c%c%c len: %d INITIAL: %016lx MIDDLE_O_BLK: %016lx B4FINAL: %016lx overflow: %d AFTER_FINAL: %016lx\n", hash, seed, data2[0], data2[1], data2[2], data2[3], data2[4], data2[5], data2[6], data2[7], data2[8], data2[9], len, INITIAL, MIDDLE_OF_BLOCK, BEFORE_FINAL, overflow, AFTER_FINAL); - //printf("data2 = %.2s, len = %d\n", data2[0], len); - - #undef M - #undef R - - return hash; -} - -KERNEL_FQ void m90000_mxx (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m90000_mxx (KERN_ATTR_RULES ()) { /** * modifier @@ -128,26 +85,14 @@ KERNEL_FQ void m90000_mxx (KERN_ATTR_RULES ()) COPY_PW (pws[gid]); - //if ((gid == 0) && (lid == 0)) printf ("%016lx\n", pw_buf0); - //printf("Hello world\n"); - - // why is this here? - // const u32 pw_len = pws[gid].pw_len & 63; - /** * salt */ + // Reconstruct seed from two u32s const u32 seed_lo = salt_bufs[SALT_POS_HOST].salt_buf[0]; const u32 seed_hi = salt_bufs[SALT_POS_HOST].salt_buf[1]; - const u64 seed = ((u64) seed_hi << 32) | ((u64) seed_lo); // seems to work? - - //u8 *temp_ref_lo = (u8*) &seed_lo; - //u8 *temp_ref_hi = (u8*) &seed_hi; - //u8 *temp_ref = (u8*) &seed; - //if ((gid == 0) && (lid == 0)) printf ("seed = %02x%02x%02x%02x%02x%02x%02x%02x\n", temp_ref_lo[0], temp_ref_lo[1], temp_ref_lo[2], temp_ref_lo[3], temp_ref_hi[0], temp_ref_hi[1], temp_ref_hi[2], temp_ref_hi[3]); - //if ((gid == 0) && (lid == 0)) printf ("seed = %02x%02x%02x%02x%02x%02x%02x%02x\n", temp_ref_lo[0], temp_ref_lo[1], temp_ref_lo[2], temp_ref_lo[3], temp_ref_lo[4], temp_ref_lo[5], temp_ref_lo[6], temp_ref_lo[7]); - //if ((gid == 0) && (lid == 0)) printf ("seed = %02x%02x%02x%02x%02x%02x%02x%02x\n", temp_ref[0], temp_ref[1], temp_ref[2], temp_ref[3], temp_ref[4], temp_ref[5], temp_ref[6], temp_ref[7]); + const u64 seed = hl32_to_64 (seed_hi, seed_lo); /** * loop @@ -159,24 +104,17 @@ KERNEL_FQ void m90000_mxx (KERN_ATTR_RULES ()) tmp.pw_len = apply_rules (rules_buf[il_pos].cmds, tmp.i, tmp.pw_len); - //if ((gid == 0) && (lid == 0) && (il_pos == 0)) printf ("tmp.i = %08x, tmp.pw_len = %x\n", *tmp.i, tmp.pw_len); - u64x hash = MurmurHash64A (seed, tmp.i, tmp.pw_len); - //if ((gid == 0) && (lid == 0)) printf ("hash = %lu\n", hash); - - //if (il_pos == 0) printf("tmp.i = %lu, tmp.pw_len = %lu\n", tmp.i, tmp.pw_len); - //if (il_pos == 0) printf("seed = %llu\n", seed); - - const u32x r0 = l32_from_64(hash); - const u32x r1 = h32_from_64(hash); + const u32x r0 = l32_from_64 (hash); + const u32x r1 = h32_from_64 (hash); const u32x z = 0; COMPARE_M_SCALAR (r0, r1, z, z); } } -KERNEL_FQ void m90000_sxx (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m90000_sxx (KERN_ATTR_RULES ()) { /** * modifier @@ -196,9 +134,10 @@ KERNEL_FQ void m90000_sxx (KERN_ATTR_RULES ()) * salt */ + // Reconstruct seed from two u32s const u32 seed_lo = salt_bufs[SALT_POS_HOST].salt_buf[0]; const u32 seed_hi = salt_bufs[SALT_POS_HOST].salt_buf[1]; - const u64 seed = ((u64) seed_hi << 32) | ((u64) seed_lo); + const u64 seed = hl32_to_64 (seed_hi, seed_lo); /** * digest @@ -218,9 +157,6 @@ KERNEL_FQ void m90000_sxx (KERN_ATTR_RULES ()) COPY_PW (pws[gid]); - //printf ("%016lx\n", seed); - //printf("Hello world\n"); - /** * loop */ diff --git a/OpenCL/m90000_a1-optimized.cl b/OpenCL/m90000_a1-optimized.cl old mode 100644 new mode 100755 index 48d753b2d..405885110 --- a/OpenCL/m90000_a1-optimized.cl +++ b/OpenCL/m90000_a1-optimized.cl @@ -3,7 +3,6 @@ * License.....: MIT */ -//too much register pressure //#define NEW_SIMD_CODE #ifdef KERNEL_STATIC @@ -14,46 +13,45 @@ #include M2S(INCLUDE_PATH/inc_simd.cl) #endif -DECLSPEC u64 MurmurHash64A_round (PRIVATE_AS const u8 *data, u64 hash, const u32 cur_pos) { +DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u32 len) +{ #define M 0xc6a4a7935bd1e995 #define R 47 - u64 k = ((u64) data[cur_pos]) - | ((u64) data[cur_pos + 1] << 8) - | ((u64) data[cur_pos + 2] << 16) - | ((u64) data[cur_pos + 3] << 24) - | ((u64) data[cur_pos + 4] << 32) - | ((u64) data[cur_pos + 5] << 40) - | ((u64) data[cur_pos + 6] << 48) - | ((u64) data[cur_pos + 7] << 56); - - k *= M; - k ^= k >> R; - k *= M; + //Initialize hash + u64 hash = seed ^ (len * M); - hash ^= k; - hash *= M; + // Twice the number of u64 blocks + const u32 num_u32_blocks = (len / 8) * 2; - #undef M - #undef R + // Loop over one u64 at a time + u32 i = 0; + while (i < num_u32_blocks) + { + // Reconstruct u64 from two u32s + u64 k = hl32_to_64 (data[i + 1], data[i]); - return hash; -} + k *= M; + k ^= k >> R; + k *= M; -DECLSPEC u64 MurmurHash64A_final (PRIVATE_AS const u8 *data, u64 hash, const u32 cur_pos, const u32 len) { - #define M 0xc6a4a7935bd1e995 - #define R 47 + hash ^= k; + hash *= M; + i += 2; + } + + // Up to 7 overflow bytes const u32 overflow = len & 7; - switch (overflow) { - case 7: hash ^= ((u64) data[cur_pos + 6]) << 48; - case 6: hash ^= ((u64) data[cur_pos + 5]) << 40; - case 5: hash ^= ((u64) data[cur_pos + 4]) << 32; - case 4: hash ^= ((u64) data[cur_pos + 3]) << 24; - case 3: hash ^= ((u64) data[cur_pos + 2]) << 16; - case 2: hash ^= ((u64) data[cur_pos + 1]) << 8; - case 1: hash ^= ((u64) data[cur_pos]); + if (overflow > 4) + { + hash ^= hl32_to_64 (data[i + 1], data[i]); + hash *= M; + } + else if (overflow > 0) + { + hash ^= hl32_to_64 (0, data[i]); hash *= M; } @@ -67,49 +65,7 @@ DECLSPEC u64 MurmurHash64A_final (PRIVATE_AS const u8 *data, u64 hash, const u32 return hash; } -DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u32 len) -{ - #define M 0xc6a4a7935bd1e995 - #define R 47 - - //Initialize hash - u64 hash = seed ^ (len * M); - - //const u64 INITIAL = hash; - - const u32 endpos = len - (len & 7); - - //const u32 nBlocks = len >> 3; // number of 8 byte blocks - const u8 *data2 = (const u8*) data; - - //u64 MIDDLE_OF_BLOCK = 0; - - // Loop over blocks of 8 bytes - u32 i = 0; - while (i != endpos) { - hash = MurmurHash64A_round(data2, hash, i); - - i += 8; - } - - // Overflow - - //const u64 BEFORE_FINAL = hash; - - hash = MurmurHash64A_final (data2, hash, i, len); - - //const u64 AFTER_FINAL = hash; - - //printf("debug: %016lx:%016lx:%c%c%c%c%c%c%c%c%c%c len: %d INITIAL: %016lx MIDDLE_O_BLK: %016lx B4FINAL: %016lx overflow: %d AFTER_FINAL: %016lx\n", hash, seed, data2[0], data2[1], data2[2], data2[3], data2[4], data2[5], data2[6], data2[7], data2[8], data2[9], len, INITIAL, MIDDLE_OF_BLOCK, BEFORE_FINAL, overflow, AFTER_FINAL); - //printf("data2 = %.2s, len = %d\n", data2[0], len); - - #undef M - #undef R - - return hash; -} - -KERNEL_FQ void m90000_m04 (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m90000_m04 (KERN_ATTR_BASIC ()) { /** * modifier @@ -142,9 +98,10 @@ KERNEL_FQ void m90000_m04 (KERN_ATTR_BASIC ()) * seed */ + // Reconstruct seed from two u32s const u32 seed_lo = salt_bufs[SALT_POS_HOST].salt_buf[0]; const u32 seed_hi = salt_bufs[SALT_POS_HOST].salt_buf[1]; - const u64 seed = ((u64) seed_hi << 32) | ((u64) seed_lo); + const u64 seed = hl32_to_64 (seed_hi, seed_lo); /** * loop @@ -218,23 +175,23 @@ KERNEL_FQ void m90000_m04 (KERN_ATTR_BASIC ()) u64x hash = MurmurHash64A (seed, w, pw_len); - const u32x r0 = l32_from_64(hash); - const u32x r1 = h32_from_64(hash); + const u32x r0 = l32_from_64 (hash); + const u32x r1 = h32_from_64 (hash); const u32x z = 0; COMPARE_M_SIMD (r0, r1, z, z); } } -KERNEL_FQ void m90000_m08 (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m90000_m08 (KERN_ATTR_BASIC ()) { } -KERNEL_FQ void m90000_m16 (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m90000_m16 (KERN_ATTR_BASIC ()) { } -KERNEL_FQ void m90000_s04 (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m90000_s04 (KERN_ATTR_BASIC ()) { /** * modifier @@ -267,9 +224,10 @@ KERNEL_FQ void m90000_s04 (KERN_ATTR_BASIC ()) * seed */ + // Reconstruct seed from two u32s const u32 seed_lo = salt_bufs[SALT_POS_HOST].salt_buf[0]; const u32 seed_hi = salt_bufs[SALT_POS_HOST].salt_buf[1]; - const u64 seed = ((u64) seed_hi << 32) | ((u64) seed_lo); + const u64 seed = hl32_to_64 (seed_hi, seed_lo); /** * digest @@ -355,18 +313,18 @@ KERNEL_FQ void m90000_s04 (KERN_ATTR_BASIC ()) u64 hash = MurmurHash64A (seed, w, pw_len); - const u32 r0 = l32_from_64(hash); - const u32 r1 = h32_from_64(hash); + const u32 r0 = l32_from_64 (hash); + const u32 r1 = h32_from_64 (hash); const u32 z = 0; COMPARE_S_SIMD (r0, r1, z, z); } } -KERNEL_FQ void m90000_s08 (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m90000_s08 (KERN_ATTR_BASIC ()) { } -KERNEL_FQ void m90000_s16 (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m90000_s16 (KERN_ATTR_BASIC ()) { } diff --git a/OpenCL/m90000_a1-pure.cl b/OpenCL/m90000_a1-pure.cl old mode 100644 new mode 100755 index d5210d52c..7d5d3ed3a --- a/OpenCL/m90000_a1-pure.cl +++ b/OpenCL/m90000_a1-pure.cl @@ -13,68 +13,45 @@ #include M2S(INCLUDE_PATH/inc_scalar.cl) #endif -DECLSPEC u64 MurmurHash64A_round_g (const u8 *data, u64 hash, const u32 cur_pos) { +DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u32 len) +{ #define M 0xc6a4a7935bd1e995 #define R 47 - u64 k = ((u64) data[cur_pos]) - | ((u64) data[cur_pos + 1] << 8) - | ((u64) data[cur_pos + 2] << 16) - | ((u64) data[cur_pos + 3] << 24) - | ((u64) data[cur_pos + 4] << 32) - | ((u64) data[cur_pos + 5] << 40) - | ((u64) data[cur_pos + 6] << 48) - | ((u64) data[cur_pos + 7] << 56); - - k *= M; - k ^= k >> R; - k *= M; + //Initialize hash + u64 hash = seed ^ (len * M); - hash ^= k; - hash *= M; + // Twice the number of u64 blocks + const u32 num_u32_blocks = (len / 8) * 2; - #undef M - #undef R + // Loop over one u64 at a time + u32 i = 0; + while (i < num_u32_blocks) + { + // Reconstruct u64 from two u32s + u64 k = hl32_to_64 (data[i + 1], data[i]); - return hash; -} + k *= M; + k ^= k >> R; + k *= M; -DECLSPEC u64 MurmurHash64A_final_g (const u8 *data, u64 hash, const u32 cur_pos, const u32 len) { - #define M 0xc6a4a7935bd1e995 - #define R 47 + hash ^= k; + hash *= M; + i += 2; + } + + // Up to 7 overflow bytes const u32 overflow = len & 7; - if (overflow == 7) + if (overflow > 4) { - hash ^= ((u64) data[cur_pos + 6] << 48); + hash ^= hl32_to_64 (data[i + 1], data[i]); + hash *= M; } - if (overflow >= 6) - { - hash ^= ((u64) data[cur_pos + 5] << 40); - } - if (overflow >= 5) - { - hash ^= ((u64) data[cur_pos + 4] << 32); - } - if (overflow >= 4) - { - hash ^= ((u64) data[cur_pos + 3] << 24); - } - if (overflow >= 3) - { - hash ^= ((u64) data[cur_pos + 2] << 16); - } - if (overflow >= 2) - { - hash ^= ((u64) data[cur_pos + 1] << 8); - } - if (overflow >= 1) - { - hash ^= ((u64) data[cur_pos]); - } - if (overflow > 0) + else if (overflow > 0) { + hash ^= hl32_to_64 (0, data[i]); hash *= M; } @@ -88,147 +65,98 @@ DECLSPEC u64 MurmurHash64A_final_g (const u8 *data, u64 hash, const u32 cur_pos, return hash; } -DECLSPEC u64 MurmurHash64A_g (const u64 seed, const u8 *data, const u32 len) -{ - #define M 0xc6a4a7935bd1e995 - #define R 47 - - //Initialize hash - u64 hash = seed ^ (len * M); - - const u64 INITIAL = hash; - - const u32 endpos = len - (len & 7); - - //const u32 nBlocks = len >> 3; // number of 8 byte blocks - const u8 *data2 = (const u8*) data; - - // Loop over blocks of 8 bytes - u32 i = 0; - while (i != endpos) { - hash = MurmurHash64A_round_g(data2, hash, i); - - i += 8; - } - - // Overflow - - const u64 BEFORE_FINAL = hash; - - hash = MurmurHash64A_final_g (data2, hash, i, len); - - const u64 AFTER_FINAL = hash; - - printf("debug: %016lx:%016lx:%c%c%c%c%c%c%c%c%c%c len: %d INITIAL: %016lx B4FINAL: %016lx AFTER_FINAL: %016lx\n", hash, seed, data2[0], data2[1], data2[2], data2[3], data2[4], data2[5], data2[6], data2[7], data2[8], data2[9], len, INITIAL, BEFORE_FINAL, AFTER_FINAL); - //printf("data2 = %.2s, len = %d\n", data2[0], len); - - #undef M - #undef R - - return hash; -} - -KERNEL_FQ void m90000_mxx (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m90000_mxx (KERN_ATTR_BASIC ()) { /** * modifier */ const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + + if (gid >= GID_CNT) return; /** * base */ - const u64 gid = get_global_id (0); + PRIVATE_AS u8 combined_buf[256] = {0}; + const u32 *comb_ptr = (u32*) combined_buf; - if (gid >= GID_CNT) return; - - //if ((gid == 0) && (lid == 0)) printf ("%016lx\n", pw_buf0); - //printf("Hello world\n"); - - // why is this here? - // const u32 pw_len = pws[gid].pw_len & 63; + // copy left buffer + GLOBAL_AS const u8 *left = (GLOBAL_AS const u8*) pws[gid].i; + // probably really bad for performance. fix later + for (u32 i = 0; i < pws[gid].pw_len; i++) + { + combined_buf[i] = left[i]; + } /** * salt */ - + // Reconstruct seed from two u32s const u32 seed_lo = salt_bufs[SALT_POS_HOST].salt_buf[0]; const u32 seed_hi = salt_bufs[SALT_POS_HOST].salt_buf[1]; - const u64 seed = ((u64) seed_hi << 32) | ((u64) seed_lo); // seems to work? - - //u8 *temp_ref_lo = (u8*) &seed_lo; - //u8 *temp_ref_hi = (u8*) &seed_hi; - //u8 *temp_ref = (u8*) &seed; - //if ((gid == 0) && (lid == 0)) printf ("seed = %02x%02x%02x%02x%02x%02x%02x%02x\n", temp_ref_lo[0], temp_ref_lo[1], temp_ref_lo[2], temp_ref_lo[3], temp_ref_hi[0], temp_ref_hi[1], temp_ref_hi[2], temp_ref_hi[3]); - //if ((gid == 0) && (lid == 0)) printf ("seed = %02x%02x%02x%02x%02x%02x%02x%02x\n", temp_ref_lo[0], temp_ref_lo[1], temp_ref_lo[2], temp_ref_lo[3], temp_ref_lo[4], temp_ref_lo[5], temp_ref_lo[6], temp_ref_lo[7]); - //if ((gid == 0) && (lid == 0)) printf ("seed = %02x%02x%02x%02x%02x%02x%02x%02x\n", temp_ref[0], temp_ref[1], temp_ref[2], temp_ref[3], temp_ref[4], temp_ref[5], temp_ref[6], temp_ref[7]); - + const u64 seed = hl32_to_64 (seed_hi, seed_lo); + /** * loop */ - - //printf("Running a1 m90000_mxx\n"); - // probably really bad for performance. fix later - GLOBAL_AS const u8 *left = (GLOBAL_AS const u8*) pws[gid].i; - // create combined buffer - u8 combined_buf[256]; - - // copy left buffer - for (u32 i = 0; i < pws[gid].pw_len; i++) { - combined_buf[i] = left[i]; - } - for (u32 il_pos = 0; il_pos < IL_CNT; il_pos++) { - //const u32 tmp_buf = combs_buf[il_pos].i; - //if ((gid == 0) && (lid == 0)) printf ("combs_buf[il_pos].i = %08x\n", tmp_buf); - - //u64x hash = MurmurHash64A_g (seed, pws[gid].i, pws[gid].pw_len, combs_buf[il_pos].i, combs_buf[il_pos].pw_len); - - GLOBAL_AS const u8 *right = (GLOBAL_AS const u8*) combs_buf[il_pos].i; - // copy right buffer - for (u32 i = 0; i < combs_buf[il_pos].pw_len; i++) { + GLOBAL_AS const u8 *right = (GLOBAL_AS const u8*) combs_buf[il_pos].i; + for (u32 i = 0; i < combs_buf[il_pos].pw_len; i++) + { combined_buf[i + pws[gid].pw_len] = right[i]; } - u64x hash = MurmurHash64A_g (seed, combined_buf, pws[gid].pw_len + combs_buf[il_pos].pw_len); + u64x hash = MurmurHash64A (seed, comb_ptr, pws[gid].pw_len + combs_buf[il_pos].pw_len); - const u32x r0 = l32_from_64(hash); - const u32x r1 = h32_from_64(hash); + const u32x r0 = l32_from_64 (hash); + const u32x r1 = h32_from_64 (hash); const u32x z = 0; COMPARE_M_SCALAR (r0, r1, z, z); } } -KERNEL_FQ void m90000_sxx (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m90000_sxx (KERN_ATTR_BASIC ()) { /** * modifier */ const u64 lid = get_local_id (0); - - /** - * base - */ - const u64 gid = get_global_id (0); if (gid >= GID_CNT) return; + /** + * base + */ + + PRIVATE_AS u8 combined_buf[256] = {0}; + const u32 *comb_ptr = (u32*) combined_buf; + + // copy left buffer + GLOBAL_AS const u8 *left = (GLOBAL_AS const u8*) pws[gid].i; + // probably really bad for performance. fix later + for (u32 i = 0; i < pws[gid].pw_len; i++) + { + combined_buf[i] = left[i]; + } + /** * salt */ + // Reconstruct seed from two u32s const u32 seed_lo = salt_bufs[SALT_POS_HOST].salt_buf[0]; const u32 seed_hi = salt_bufs[SALT_POS_HOST].salt_buf[1]; - const u64 seed = ((u64) seed_hi << 32) | ((u64) seed_lo); + const u64 seed = hl32_to_64 (seed_hi, seed_lo); /** * digest @@ -246,28 +174,16 @@ KERNEL_FQ void m90000_sxx (KERN_ATTR_BASIC ()) * loop */ - printf("Running a1 m90000_sxx\n"); - - - u8 combined_buf[256]; - - // copy left buffer - GLOBAL_AS const u8 *left = (GLOBAL_AS const u8*) pws[gid].i; - for (u32 i = 0; i < pws[gid].pw_len; i++) { - combined_buf[i] = left[i]; - } - - for (u32 il_pos = 0; il_pos < IL_CNT; il_pos++) { - // copy right buffer GLOBAL_AS const u8 *right = (GLOBAL_AS const u8*) combs_buf[il_pos].i; - for (u32 i = 0; i < combs_buf[il_pos].pw_len; i++) { + for (u32 i = 0; i < combs_buf[il_pos].pw_len; i++) + { combined_buf[i + pws[gid].pw_len] = right[i]; } - u64 hash = MurmurHash64A_g (seed, combined_buf, pws[gid].pw_len + combs_buf[il_pos].pw_len); + u64 hash = MurmurHash64A (seed, comb_ptr, pws[gid].pw_len + combs_buf[il_pos].pw_len); const u32 r0 = l32_from_64 (hash); const u32 r1 = h32_from_64 (hash); diff --git a/OpenCL/m90000_a3-optimized.cl b/OpenCL/m90000_a3-optimized.cl old mode 100644 new mode 100755 index 51915057f..3edb18ef6 --- a/OpenCL/m90000_a3-optimized.cl +++ b/OpenCL/m90000_a3-optimized.cl @@ -13,38 +13,24 @@ #include M2S(INCLUDE_PATH/inc_simd.cl) #endif - -DECLSPEC u64x MurmurHash64A (const u64x seed, PRIVATE_AS const u32x *data, const u32 len) +DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u32 len) { #define M 0xc6a4a7935bd1e995 #define R 47 //Initialize hash - u64x hash = seed ^ (len * M); + u64 hash = seed ^ (len * M); - //printf("INITIAL = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + // Twice the number of u64 blocks + const u32 num_u32_blocks = (len / 8) * 2; - const u32 endpos = len - (len & 7); - - const u8 *data2 = (const u8*) data; - - //printf("seed = %08x%08x\n", h32_from_64(seed), l32_from_64(seed)); - //printf("data2 = %c%c%c%c%c%c%c%c\n", data2[0], data2[1], data2[2], data2[3], data2[4], data2[5], data2[6], data2[7]); - //printf("len = %d\n", len); - - - // Loop over blocks of 8 bytes + // Loop over one u64 at a time u32 i = 0; - while (i != endpos) { - u64x k = ((u64) data2[i]) - | ((u64) data2[i + 1] << 8) - | ((u64) data2[i + 2] << 16) - | ((u64) data2[i + 3] << 24) - | ((u64) data2[i + 4] << 32) - | ((u64) data2[i + 5] << 40) - | ((u64) data2[i + 6] << 48) - | ((u64) data2[i + 7] << 56); - + while (i < num_u32_blocks) + { + // Reconstruct u64 from two u32s + u64 k = hl32_to_64 (data[i + 1], data[i]); + k *= M; k ^= k >> R; k *= M; @@ -52,28 +38,22 @@ DECLSPEC u64x MurmurHash64A (const u64x seed, PRIVATE_AS const u32x *data, const hash ^= k; hash *= M; - i += 8; + i += 2; } - //printf("BEFORE_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); - - // Overflow + // Up to 7 overflow bytes const u32 overflow = len & 7; - //printf("OVERFLOW = %d\n", overflow); - - switch (overflow) { - case 7: hash ^= ((u64) data2[i + 6]) << 48; - case 6: hash ^= ((u64) data2[i + 5]) << 40; - case 5: hash ^= ((u64) data2[i + 4]) << 32; - case 4: hash ^= ((u64) data2[i + 3]) << 24; - case 3: hash ^= ((u64) data2[i + 2]) << 16; - case 2: hash ^= ((u64) data2[i + 1]) << 8; - case 1: hash ^= ((u64) data2[i]); + if (overflow > 4) + { + hash ^= hl32_to_64 (data[i + 1], data[i]); + hash *= M; + } + else if (overflow > 0) + { + hash ^= hl32_to_64 (0, data[i]); hash *= M; } - - //printf("AFTER_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); hash ^= hash >> R; hash *= M; @@ -82,8 +62,6 @@ DECLSPEC u64x MurmurHash64A (const u64x seed, PRIVATE_AS const u32x *data, const #undef M #undef R - //printf("hash = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); - return hash; } @@ -97,9 +75,10 @@ DECLSPEC void m90000m (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F * seed */ + // Reconstruct seed from two u32s const u32x seed_lo = salt_bufs[SALT_POS_HOST].salt_buf[0]; const u32x seed_hi = salt_bufs[SALT_POS_HOST].salt_buf[1]; - const u64x seed = ((u64) seed_hi << 32) | ((u64) seed_lo); + const u64x seed = hl32_to_64 (seed_hi, seed_lo); /** * base @@ -124,9 +103,6 @@ DECLSPEC void m90000m (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F w[14] = data[14]; w[15] = data[15]; - //const u8 *data2 = (const u8*) data; - //printf("w = %c%c%c%c%c%c%c%c\n", data2[0], data2[1], data2[2], data2[3], data2[4], data2[5], data2[6], data2[7]); - /** * loop */ @@ -141,16 +117,12 @@ DECLSPEC void m90000m (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F w[0] = w0; - //printf("seed = %08x%08x\n", seed_hi, seed_lo); - const u64x hash = MurmurHash64A (seed, w, pw_len); - const u32x r0 = l32_from_64(hash); - const u32x r1 = h32_from_64(hash); + const u32x r0 = l32_from_64 (hash); + const u32x r1 = h32_from_64 (hash); const u32x z = 0; - //printf("hash = %08x%08x\n", r1, r0); - COMPARE_M_SIMD (r0, r1, z, z); } } @@ -164,8 +136,6 @@ DECLSPEC void m90000s (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F /** * digest */ - - //printf("Hello world m90000s\n"); const u32 search[4] = { @@ -179,9 +149,10 @@ DECLSPEC void m90000s (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F * seed */ + // Reconstruct seed from two u32s const u32x seed_lo = salt_bufs[SALT_POS_HOST].salt_buf[0]; const u32x seed_hi = salt_bufs[SALT_POS_HOST].salt_buf[1]; - const u64x seed = ((u64) seed_hi << 32) | ((u64) seed_lo); + const u64x seed = hl32_to_64 (seed_hi, seed_lo); /** * base @@ -222,25 +193,19 @@ DECLSPEC void m90000s (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F const u64x hash = MurmurHash64A (seed, w, pw_len); - const u32x r0 = l32_from_64(hash); - const u32x r1 = h32_from_64(hash); + const u32x r0 = l32_from_64 (hash); + const u32x r1 = h32_from_64 (hash); const u32x z = 0; - //printf("r1 = %08x r0 = %08x\n", r1, r0); - //printf("hash = %08x%08x\n", r1, r0); - COMPARE_S_SIMD (r0, r1, z, z); } } -KERNEL_FQ void m90000_m04 (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m90000_m04 (KERN_ATTR_VECTOR ()) { /** * base */ - - //printf("Hello world m90000_m04\n"); - const u64 lid = get_local_id (0); const u64 gid = get_global_id (0); @@ -268,7 +233,6 @@ KERNEL_FQ void m90000_m04 (KERN_ATTR_VECTOR ()) w[15] = 0; const u32 pw_len = pws[gid].pw_len & 63; - //printf("pws[gid].pw_len = %d\n", pws[gid].pw_len); /** * main @@ -277,14 +241,12 @@ KERNEL_FQ void m90000_m04 (KERN_ATTR_VECTOR ()) m90000m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ void m90000_m08 (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m90000_m08 (KERN_ATTR_VECTOR ()) { /** * base */ - //printf("Hello world m90000_m08\n"); - const u64 lid = get_local_id (0); const u64 gid = get_global_id (0); const u64 lsz = get_local_size (0); @@ -319,7 +281,7 @@ KERNEL_FQ void m90000_m08 (KERN_ATTR_VECTOR ()) m90000m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ void m90000_m16 (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m90000_m16 (KERN_ATTR_VECTOR ()) { /** * base @@ -359,7 +321,7 @@ KERNEL_FQ void m90000_m16 (KERN_ATTR_VECTOR ()) m90000m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ void m90000_s04 (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m90000_s04 (KERN_ATTR_VECTOR ()) { /** * base @@ -399,7 +361,7 @@ KERNEL_FQ void m90000_s04 (KERN_ATTR_VECTOR ()) m90000s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ void m90000_s08 (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m90000_s08 (KERN_ATTR_VECTOR ()) { /** * base @@ -439,7 +401,7 @@ KERNEL_FQ void m90000_s08 (KERN_ATTR_VECTOR ()) m90000s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ void m90000_s16 (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m90000_s16 (KERN_ATTR_VECTOR ()) { /** * base diff --git a/OpenCL/m90000_a3-pure.cl b/OpenCL/m90000_a3-pure.cl new file mode 100755 index 000000000..6161762f6 --- /dev/null +++ b/OpenCL/m90000_a3-pure.cl @@ -0,0 +1,192 @@ +/** + * Author......: See docs/credits.txt + * License.....: MIT + */ + +//#define NEW_SIMD_CODE + +#ifdef KERNEL_STATIC +#include M2S(INCLUDE_PATH/inc_vendor.h) +#include M2S(INCLUDE_PATH/inc_types.h) +#include M2S(INCLUDE_PATH/inc_platform.cl) +#include M2S(INCLUDE_PATH/inc_common.cl) +#include M2S(INCLUDE_PATH/inc_scalar.cl) +#endif + +DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u32 len) +{ + #define M 0xc6a4a7935bd1e995 + #define R 47 + + //Initialize hash + u64 hash = seed ^ (len * M); + + // Twice the number of u64 blocks + const u32 num_u32_blocks = (len / 8) * 2; + + // Loop over one u64 at a time + u32 i = 0; + while (i < num_u32_blocks) + { + // Reconstruct u64 from two u32s + u64 k = hl32_to_64 (data[i + 1], data[i]); + + k *= M; + k ^= k >> R; + k *= M; + + hash ^= k; + hash *= M; + + i += 2; + } + + // Up to 7 overflow bytes + const u32 overflow = len & 7; + + if (overflow > 4) + { + hash ^= hl32_to_64 (data[i + 1], data[i]); + hash *= M; + } + else if (overflow > 0) + { + hash ^= hl32_to_64 (0, data[i]); + hash *= M; + } + + hash ^= hash >> R; + hash *= M; + hash ^= hash >> R; + + #undef M + #undef R + + return hash; +} + +KERNEL_FQ KERNEL_FA void m90000_mxx (KERN_ATTR_VECTOR ()) +{ + /** + * modifier + */ + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + + if (gid >= GID_CNT) return; + + /** + * seed + */ + + // Reconstruct seed from two u32s + const u32x seed_lo = salt_bufs[SALT_POS_HOST].salt_buf[0]; + const u32x seed_hi = salt_bufs[SALT_POS_HOST].salt_buf[1]; + const u64x seed = hl32_to_64 (seed_hi, seed_lo); + + /** + * base + */ + + const u32 pw_len = pws[gid].pw_len; + + u32x w[64] = { 0 }; + + for (u32 i = 0, idx = 0; i < pw_len; i += 4, idx += 1) + { + w[idx] = pws[gid].i[idx]; + } + + /** + * loop + */ + + u32x w0l = w[0]; + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) + { + const u32x w0r = words_buf_r[il_pos / VECT_SIZE]; + + const u32x w0 = w0l | w0r; + + w[0] = w0; + + const u64x hash = MurmurHash64A (seed, w, pw_len); + + const u32x r0 = l32_from_64 (hash); + const u32x r1 = h32_from_64 (hash); + const u32x z = 0; + + COMPARE_M_SCALAR (r0, r1, z, z); + } +} + +KERNEL_FQ KERNEL_FA void m90000_sxx (KERN_ATTR_VECTOR ()) +{ + /** + * modifier + */ + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + + if (gid >= GID_CNT) return; + + /** + * seed + */ + + // Reconstruct seed from two u32s + const u32x seed_lo = salt_bufs[SALT_POS_HOST].salt_buf[0]; + const u32x seed_hi = salt_bufs[SALT_POS_HOST].salt_buf[1]; + const u64x seed = hl32_to_64 (seed_hi, seed_lo); + + /** + * digest + */ + + const u32 search[4] = + { + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R0], + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R1], + 0, + 0 + }; + + /** + * base + */ + + const u32 pw_len = pws[gid].pw_len; + + u32x w[64] = { 0 }; + + for (u32 i = 0, idx = 0; i < pw_len; i += 4, idx += 1) + { + w[idx] = pws[gid].i[idx]; + } + + /** + * loop + */ + + u32x w0l = w[0]; + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) + { + const u32x w0r = words_buf_r[il_pos / VECT_SIZE]; + + const u32x w0 = w0l | w0r; + + w[0] = w0; + + const u64x hash = MurmurHash64A (seed, w, pw_len); + + const u32x r0 = l32_from_64 (hash); + const u32x r1 = h32_from_64 (hash); + const u32x z = 0; + + COMPARE_S_SCALAR (r0, r1, z, z); + } +} diff --git a/OpenCL/m90010_a0-optimized.cl b/OpenCL/m90010_a0-optimized.cl old mode 100644 new mode 100755 index ca8f99823..c24ff6446 --- a/OpenCL/m90010_a0-optimized.cl +++ b/OpenCL/m90010_a0-optimized.cl @@ -21,19 +21,16 @@ DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) #define R 47 //Initialize hash - u64 hash = 0 ^ (len * M); + u64 hash = len * M; - //printf("len = %d\n", len); - //printf("INITIAL = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + // Twice the number of u64 blocks + const u32 num_u32_blocks = (len / 8) * 2; - // 2 for each u64 block - const u32 num_blocks = (len / 8) * 2; - - //printf("num_blocks = %d\n", num_blocks); - - // Loop over blocks of 8 bytes + // Loop over one u64 at a time u32 i = 0; - while (i < num_blocks) { + while (i < num_u32_blocks) + { + // Reconstruct u64 from two u32s u64 k = hl32_to_64 (data[i + 1], data[i]); k *= M; @@ -46,39 +43,20 @@ DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) i += 2; } - //printf("BEFORE_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); - - // Overflow - + // Up to 7 overflow bytes const u32 overflow = len & 7; - //printf("OVERFLOW = %d\n", overflow); - - //printf("data = %08x%08x%08x%08x%08x%08x%08x%08x%08x%08x\n", data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9]); - - //printf("i = %d\n", i); - //printf("data[i] data[i + 1] = %08x%08x\n", data[i], data[i + 1]); - - // can we turn this into a single xor - - if ((overflow > 0) && (overflow <= 4)) { - //printf("Overflow case 1\n"); + if (overflow > 4) + { hash ^= hl32_to_64 (data[i + 1], data[i]); hash *= M; } - - else if (overflow > 4) { - //printf("Overflow case 2\n"); - //printf("tmp = %08x%08x\n", h32_from_64(tmp), l32_from_64(tmp)); - hash ^= hl32_to_64 (data[i + 1], data[i]); + else if (overflow > 0) + { + hash ^= hl32_to_64 (0, data[i]); hash *= M; } - //u64 test = hl32_to_64 (0x0a16869e, 0xcb107f54); - //printf("hl32_to_64 test = %08x%08x\n", h32_from_64(test), l32_from_64(test)); - - //printf("AFTER_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); - hash ^= hash >> R; hash *= M; hash ^= hash >> R; @@ -86,16 +64,11 @@ DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) #undef M #undef R - //printf("hash = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); - return hash; } - - -KERNEL_FQ void m90010_m04 (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m90010_m04 (KERN_ATTR_RULES ()) { - //printf("Hello world m90010_m04\n"); /** * modifier */ @@ -122,8 +95,7 @@ KERNEL_FQ void m90010_m04 (KERN_ATTR_RULES ()) pw_buf1[2] = pws[gid].i[6]; pw_buf1[3] = pws[gid].i[7]; - // max pw len of 32 - const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; + const u32 pw_len = pws[gid].pw_len & 63; /** * loop @@ -131,31 +103,30 @@ KERNEL_FQ void m90010_m04 (KERN_ATTR_RULES ()) for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) { - u32x w[16] = { 0 }; + u32x w[8] = { 0 }; const u32x out_len = apply_rules_vect_optimized (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w + 0, w + 4); u64x hash = MurmurHash64A (w, out_len); - const u32x r0 = l32_from_64(hash); - const u32x r1 = h32_from_64(hash); + const u32x r0 = l32_from_64 (hash); + const u32x r1 = h32_from_64 (hash); const u32x z = 0; COMPARE_M_SIMD (r0, r1, z, z); } } -KERNEL_FQ void m90010_m08 (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m90010_m08 (KERN_ATTR_RULES ()) { } -KERNEL_FQ void m90010_m16 (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m90010_m16 (KERN_ATTR_RULES ()) { } -KERNEL_FQ void m90010_s04 (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m90010_s04 (KERN_ATTR_RULES ()) { - //printf("Hello world m90010_s04\n"); /** * modifier */ @@ -182,8 +153,8 @@ KERNEL_FQ void m90010_s04 (KERN_ATTR_RULES ()) pw_buf1[2] = pws[gid].i[6]; pw_buf1[3] = pws[gid].i[7]; - // max pw len of 32 - const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; + // Max pw len of 32 + const u32 pw_len = pws[gid].pw_len & 63; /** * digest @@ -209,18 +180,18 @@ KERNEL_FQ void m90010_s04 (KERN_ATTR_RULES ()) u64x hash = MurmurHash64A (w, out_len); - const u32x r0 = l32_from_64(hash); - const u32x r1 = h32_from_64(hash); + const u32x r0 = l32_from_64 (hash); + const u32x r1 = h32_from_64 (hash); const u32x z = 0; COMPARE_S_SIMD (r0, r1, z, z); } } -KERNEL_FQ void m90010_s08 (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m90010_s08 (KERN_ATTR_RULES ()) { } -KERNEL_FQ void m90010_s16 (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m90010_s16 (KERN_ATTR_RULES ()) { } diff --git a/OpenCL/m90010_a0-pure.cl b/OpenCL/m90010_a0-pure.cl old mode 100644 new mode 100755 index 6ffa08f80..8259e740a --- a/OpenCL/m90010_a0-pure.cl +++ b/OpenCL/m90010_a0-pure.cl @@ -21,19 +21,16 @@ DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) #define R 47 //Initialize hash - u64 hash = 0 ^ (len * M); + u64 hash = len * M; - //printf("len = %d\n", len); - //printf("INITIAL = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + // Twice the number of u64 blocks + const u32 num_u32_blocks = (len / 8) * 2; - // 2 for each u64 block - const u32 num_blocks = (len / 8) * 2; - - //printf("num_blocks = %d\n", num_blocks); - - // Loop over blocks of 8 bytes + // Loop over one u64 at a time u32 i = 0; - while (i < num_blocks) { + while (i < num_u32_blocks) + { + // Reconstruct u64 from two u32s u64 k = hl32_to_64 (data[i + 1], data[i]); k *= M; @@ -46,39 +43,20 @@ DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) i += 2; } - //printf("BEFORE_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); - - // Overflow - + // Up to 7 overflow bytes const u32 overflow = len & 7; - //printf("OVERFLOW = %d\n", overflow); - - //printf("data = %08x%08x%08x%08x%08x%08x%08x%08x%08x%08x\n", data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9]); - - //printf("i = %d\n", i); - //printf("data[i] data[i + 1] = %08x%08x\n", data[i], data[i + 1]); - - // can we turn this into a single xor - - if ((overflow > 0) && (overflow <= 4)) { - //printf("Overflow case 1\n"); + if (overflow > 4) + { hash ^= hl32_to_64 (data[i + 1], data[i]); hash *= M; } - - else if (overflow > 4) { - //printf("Overflow case 2\n"); - //printf("tmp = %08x%08x\n", h32_from_64(tmp), l32_from_64(tmp)); - hash ^= hl32_to_64 (data[i + 1], data[i]); + else if (overflow > 0) + { + hash ^= hl32_to_64 (0, data[i]); hash *= M; } - //u64 test = hl32_to_64 (0x0a16869e, 0xcb107f54); - //printf("hl32_to_64 test = %08x%08x\n", h32_from_64(test), l32_from_64(test)); - - //printf("AFTER_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); - hash ^= hash >> R; hash *= M; hash ^= hash >> R; @@ -86,12 +64,10 @@ DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) #undef M #undef R - //printf("hash = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); - return hash; } -KERNEL_FQ void m90010_mxx (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m90010_mxx (KERN_ATTR_RULES ()) { /** * modifier @@ -109,13 +85,6 @@ KERNEL_FQ void m90010_mxx (KERN_ATTR_RULES ()) COPY_PW (pws[gid]); - //if ((gid == 0) && (lid == 0)) printf ("%016lx\n", pw_buf0); - //printf("Hello world\n"); - - /** - * salt - */ - /** * loop */ @@ -126,24 +95,17 @@ KERNEL_FQ void m90010_mxx (KERN_ATTR_RULES ()) tmp.pw_len = apply_rules (rules_buf[il_pos].cmds, tmp.i, tmp.pw_len); - //if ((gid == 0) && (lid == 0) && (il_pos == 0)) printf ("tmp.i = %08x, tmp.pw_len = %x\n", *tmp.i, tmp.pw_len); - u64 hash = MurmurHash64A (tmp.i, tmp.pw_len); - //if ((gid == 0) && (lid == 0)) printf ("hash = %lu\n", hash); - - //if (il_pos == 0) printf("tmp.i = %lu, tmp.pw_len = %lu\n", tmp.i, tmp.pw_len); - //if (il_pos == 0) printf("seed = %llu\n", seed); - - const u32 r0 = l32_from_64(hash); - const u32 r1 = h32_from_64(hash); + const u32 r0 = l32_from_64 (hash); + const u32 r1 = h32_from_64 (hash); const u32 z = 0; COMPARE_M_SCALAR (r0, r1, z, z); } } -KERNEL_FQ void m90010_sxx (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m90010_sxx (KERN_ATTR_RULES ()) { /** * modifier @@ -159,10 +121,6 @@ KERNEL_FQ void m90010_sxx (KERN_ATTR_RULES ()) if (gid >= GID_CNT) return; - /** - * salt - */ - /** * digest */ @@ -181,9 +139,6 @@ KERNEL_FQ void m90010_sxx (KERN_ATTR_RULES ()) COPY_PW (pws[gid]); - //printf ("%016lx\n", seed); - //printf("Hello world\n"); - /** * loop */ diff --git a/OpenCL/m90010_a1-optimized.cl b/OpenCL/m90010_a1-optimized.cl old mode 100644 new mode 100755 index 344157d42..0b22d2c10 --- a/OpenCL/m90010_a1-optimized.cl +++ b/OpenCL/m90010_a1-optimized.cl @@ -3,7 +3,6 @@ * License.....: MIT */ -//too much register pressure //#define NEW_SIMD_CODE #ifdef KERNEL_STATIC @@ -20,19 +19,16 @@ DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) #define R 47 //Initialize hash - u64 hash = 0 ^ (len * M); + u64 hash = len * M; - //printf("len = %d\n", len); - //printf("INITIAL = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + // Twice the number of u64 blocks + const u32 num_u32_blocks = (len / 8) * 2; - // 2 for each u64 block - const u32 num_blocks = (len / 8) * 2; - - //printf("num_blocks = %d\n", num_blocks); - - // Loop over blocks of 8 bytes + // Loop over one u64 at a time u32 i = 0; - while (i < num_blocks) { + while (i < num_u32_blocks) + { + // Reconstruct u64 from two u32s u64 k = hl32_to_64 (data[i + 1], data[i]); k *= M; @@ -45,39 +41,20 @@ DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) i += 2; } - //printf("BEFORE_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); - - // Overflow - + // Up to 7 overflow bytes const u32 overflow = len & 7; - //printf("OVERFLOW = %d\n", overflow); - - //printf("data = %08x%08x%08x%08x%08x%08x%08x%08x%08x%08x\n", data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9]); - - //printf("i = %d\n", i); - //printf("data[i] data[i + 1] = %08x%08x\n", data[i], data[i + 1]); - - // can we turn this into a single xor - - if ((overflow > 0) && (overflow <= 4)) { - //printf("Overflow case 1\n"); + if (overflow > 4) + { hash ^= hl32_to_64 (data[i + 1], data[i]); hash *= M; } - - else if (overflow > 4) { - //printf("Overflow case 2\n"); - //printf("tmp = %08x%08x\n", h32_from_64(tmp), l32_from_64(tmp)); - hash ^= hl32_to_64 (data[i + 1], data[i]); + else if (overflow > 0) + { + hash ^= hl32_to_64 (0, data[i]); hash *= M; } - //u64 test = hl32_to_64 (0x0a16869e, 0xcb107f54); - //printf("hl32_to_64 test = %08x%08x\n", h32_from_64(test), l32_from_64(test)); - - //printf("AFTER_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); - hash ^= hash >> R; hash *= M; hash ^= hash >> R; @@ -85,12 +62,10 @@ DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) #undef M #undef R - //printf("hash = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); - return hash; } -KERNEL_FQ void m90010_m04 (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m90010_m04 (KERN_ATTR_BASIC ()) { /** * modifier @@ -119,10 +94,6 @@ KERNEL_FQ void m90010_m04 (KERN_ATTR_BASIC ()) const u32 pw_l_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; - /** - * seed - */ - /** * loop */ @@ -195,23 +166,23 @@ KERNEL_FQ void m90010_m04 (KERN_ATTR_BASIC ()) u64x hash = MurmurHash64A (w, pw_len); - const u32x r0 = l32_from_64(hash); - const u32x r1 = h32_from_64(hash); + const u32x r0 = l32_from_64 (hash); + const u32x r1 = h32_from_64 (hash); const u32x z = 0; COMPARE_M_SIMD (r0, r1, z, z); } } -KERNEL_FQ void m90010_m08 (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m90010_m08 (KERN_ATTR_BASIC ()) { } -KERNEL_FQ void m90010_m16 (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m90010_m16 (KERN_ATTR_BASIC ()) { } -KERNEL_FQ void m90010_s04 (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m90010_s04 (KERN_ATTR_BASIC ()) { /** * modifier @@ -240,10 +211,6 @@ KERNEL_FQ void m90010_s04 (KERN_ATTR_BASIC ()) const u32 pw_l_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; - /** - * seed - */ - /** * digest */ @@ -328,18 +295,18 @@ KERNEL_FQ void m90010_s04 (KERN_ATTR_BASIC ()) u64 hash = MurmurHash64A (w, pw_len); - const u32 r0 = l32_from_64(hash); - const u32 r1 = h32_from_64(hash); + const u32 r0 = l32_from_64 (hash); + const u32 r1 = h32_from_64 (hash); const u32 z = 0; COMPARE_S_SIMD (r0, r1, z, z); } } -KERNEL_FQ void m90010_s08 (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m90010_s08 (KERN_ATTR_BASIC ()) { } -KERNEL_FQ void m90010_s16 (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m90010_s16 (KERN_ATTR_BASIC ()) { } diff --git a/OpenCL/m90010_a1-pure.cl b/OpenCL/m90010_a1-pure.cl old mode 100644 new mode 100755 index dc57edeb2..f0fd94428 --- a/OpenCL/m90010_a1-pure.cl +++ b/OpenCL/m90010_a1-pure.cl @@ -3,7 +3,6 @@ * License.....: MIT */ -//too much register pressure //#define NEW_SIMD_CODE #ifdef KERNEL_STATIC @@ -14,38 +13,24 @@ #include M2S(INCLUDE_PATH/inc_scalar.cl) #endif -DECLSPEC u64 MurmurHash64A (const u8 *data, const u32 len) +DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) { #define M 0xc6a4a7935bd1e995 #define R 47 //Initialize hash - u64 hash = 0 ^ (len * M); + u64 hash = len * M; - //printf("len = %d\n", len); - //printf("INITIAL = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + // Twice the number of u64 blocks + const u32 num_u32_blocks = (len / 8) * 2; - // 2 for each u64 block - const u32 num_blocks = (len / 8) * 2; - - //printf("num_blocks = %d\n", num_blocks); - - const u32 endpos = len - (len & 7); - - //printf("endpos = %d\n", endpos); - - // Loop over blocks of 8 bytes + // Loop over one u64 at a time u32 i = 0; - while (i != endpos) { - u64x k = ((u64) data[i]) - | ((u64) data[i + 1] << 8) - | ((u64) data[i + 2] << 16) - | ((u64) data[i + 3] << 24) - | ((u64) data[i + 4] << 32) - | ((u64) data[i + 5] << 40) - | ((u64) data[i + 6] << 48) - | ((u64) data[i + 7] << 56); - + while (i < num_u32_blocks) + { + // Reconstruct u64 from two u32s + u64 k = hl32_to_64 (data[i + 1], data[i]); + k *= M; k ^= k >> R; k *= M; @@ -53,37 +38,22 @@ DECLSPEC u64 MurmurHash64A (const u8 *data, const u32 len) hash ^= k; hash *= M; - i += 8; + i += 2; } - //printf("BEFORE_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); - - // Overflow - + // Up to 7 overflow bytes const u32 overflow = len & 7; - //printf("OVERFLOW = %d\n", overflow); - - //printf("data = %c%c%c%c%c%c%c%c%c%c\n", data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9]); - - //printf("i = %d\n", i); - //printf("data[i] data[i + 1] = %08x%08x\n", data[i], data[i + 1]); - - switch (overflow) { - case 7: hash ^= ((u64) data[i + 6]) << 48; - case 6: hash ^= ((u64) data[i + 5]) << 40; - case 5: hash ^= ((u64) data[i + 4]) << 32; - case 4: hash ^= ((u64) data[i + 3]) << 24; - case 3: hash ^= ((u64) data[i + 2]) << 16; - case 2: hash ^= ((u64) data[i + 1]) << 8; - case 1: hash ^= ((u64) data[i]); + if (overflow > 4) + { + hash ^= hl32_to_64 (data[i + 1], data[i]); + hash *= M; + } + else if (overflow > 0) + { + hash ^= hl32_to_64 (0, data[i]); hash *= M; } - - //u64 test = hl32_to_64 (0x0a16869e, 0xcb107f54); - //printf("hl32_to_64 test = %08x%08x\n", h32_from_64(test), l32_from_64(test)); - - //printf("AFTER_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); hash ^= hash >> R; hash *= M; @@ -92,14 +62,59 @@ DECLSPEC u64 MurmurHash64A (const u8 *data, const u32 len) #undef M #undef R - //printf("final hash = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); - return hash; } +KERNEL_FQ KERNEL_FA void m90010_mxx (KERN_ATTR_BASIC ()) +{ + /** + * modifier + */ + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); -KERNEL_FQ void m90010_mxx (KERN_ATTR_BASIC ()) + if (gid >= GID_CNT) return; + + /** + * base + */ + + PRIVATE_AS u8 combined_buf[256] = {0}; + const u32 *comb_ptr = (u32*) combined_buf; + + // copy left buffer + GLOBAL_AS const u8 *left = (GLOBAL_AS const u8*) pws[gid].i; + // probably really bad for performance. fix later + for (u32 i = 0; i < pws[gid].pw_len; i++) + { + combined_buf[i] = left[i]; + } + + /** + * loop + */ + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos++) + { + // copy right buffer + GLOBAL_AS const u8 *right = (GLOBAL_AS const u8*) combs_buf[il_pos].i; + for (u32 i = 0; i < combs_buf[il_pos].pw_len; i++) + { + combined_buf[i + pws[gid].pw_len] = right[i]; + } + + u64x hash = MurmurHash64A (comb_ptr, pws[gid].pw_len + combs_buf[il_pos].pw_len); + + const u32x r0 = l32_from_64 (hash); + const u32x r1 = h32_from_64 (hash); + const u32x z = 0; + + COMPARE_M_SCALAR (r0, r1, z, z); + } +} + +KERNEL_FQ KERNEL_FA void m90010_sxx (KERN_ATTR_BASIC ()) { /** * modifier @@ -113,56 +128,17 @@ KERNEL_FQ void m90010_mxx (KERN_ATTR_BASIC ()) /** * base */ - - u8 combined_buf[256] = {0}; - const u8 *comb_ptr = combined_buf; - u32 offset = 0; - - // copy bytes from left buf - GLOBAL_AS u8 *l_buf = (GLOBAL_AS u8*) pws[gid].i; - for (u32 i = 0; i < pws[gid].pw_len; i++) { - combined_buf[offset] = l_buf[i]; - offset++; - } + PRIVATE_AS u8 combined_buf[256] = {0}; + const u32 *comb_ptr = (u32*) combined_buf; - //printf("offset = %d\n", offset); - - /** - * loop - */ - - for (u32 il_pos = 0; il_pos < IL_CNT; il_pos++) + // copy left buffer + GLOBAL_AS const u8 *left = (GLOBAL_AS const u8*) pws[gid].i; + // probably really bad for performance. fix later + for (u32 i = 0; i < pws[gid].pw_len; i++) { - // copy bytes from right buf - GLOBAL_AS u8 *r_buf = (GLOBAL_AS u8*) combs_buf[il_pos].i; - for (u32 i = 0; i < combs_buf[il_pos].pw_len; i++) { - combined_buf[offset + i] = r_buf[i]; - } - - const u32 total_len = pws[gid].pw_len + combs_buf[il_pos].pw_len; - - //const u32 *combined_ptr = (u32*) combined_buf; - const u64 hash = MurmurHash64A (comb_ptr, total_len); - - const u32 r0 = l32_from_64 (hash); - const u32 r1 = h32_from_64 (hash); - const u32 z = 0; - - COMPARE_M_SCALAR (r0, r1, z, z); + combined_buf[i] = left[i]; } -} - -KERNEL_FQ void m90010_sxx (KERN_ATTR_BASIC ()) -{ - /** - * modifier - */ - - const u64 lid = get_local_id (0); - const u64 gid = get_global_id (0); - - if (gid >= GID_CNT) return; /** * digest @@ -176,40 +152,20 @@ KERNEL_FQ void m90010_sxx (KERN_ATTR_BASIC ()) 0 }; - /** - * base - */ - - u8 combined_buf[256] = {0}; - const u8 *comb_ptr = combined_buf; - u32 offset = 0; - - // copy bytes from left buf - GLOBAL_AS u8 *l_buf = (GLOBAL_AS u8*) pws[gid].i; - - for (u32 i = 0; i < pws[gid].pw_len; i++) { - combined_buf[offset] = l_buf[i]; - offset++; - } - - - /** * loop */ for (u32 il_pos = 0; il_pos < IL_CNT; il_pos++) { - // copy bytes from right buf - GLOBAL_AS u8 *r_buf = (GLOBAL_AS u8*) combs_buf[il_pos].i; - for (u32 i = 0; i < combs_buf[il_pos].pw_len; i++) { - combined_buf[offset + i] = r_buf[i]; + // copy right buffer + GLOBAL_AS const u8 *right = (GLOBAL_AS const u8*) combs_buf[il_pos].i; + for (u32 i = 0; i < combs_buf[il_pos].pw_len; i++) + { + combined_buf[i + pws[gid].pw_len] = right[i]; } - const u32 total_len = pws[gid].pw_len + combs_buf[il_pos].pw_len; - - //const u32 *combined_ptr = (u32*) combined_buf; - const u64 hash = MurmurHash64A (comb_ptr, total_len); + u64 hash = MurmurHash64A (comb_ptr, pws[gid].pw_len + combs_buf[il_pos].pw_len); const u32 r0 = l32_from_64 (hash); const u32 r1 = h32_from_64 (hash); diff --git a/OpenCL/m90010_a3-optimized.cl b/OpenCL/m90010_a3-optimized.cl old mode 100644 new mode 100755 index 7f5b8f83c..bf1e6e481 --- a/OpenCL/m90010_a3-optimized.cl +++ b/OpenCL/m90010_a3-optimized.cl @@ -13,27 +13,23 @@ #include M2S(INCLUDE_PATH/inc_simd.cl) #endif - -DECLSPEC u64x MurmurHash64A (PRIVATE_AS const u32x *data, const u32 len) +DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) { #define M 0xc6a4a7935bd1e995 #define R 47 //Initialize hash - u64x hash = 0 ^ (len * M); + u64 hash = len * M; - //printf("len = %d\n", len); - //printf("INITIAL = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + // Twice the number of u64 blocks + const u32 num_u32_blocks = (len / 8) * 2; - // 2 for each u64 block - const u32 num_blocks = (len / 8) * 2; - - //printf("num_blocks = %d\n", num_blocks); - - // Loop over blocks of 8 bytes + // Loop over one u64 at a time u32 i = 0; - while (i < num_blocks) { - u64x k = hl32_to_64 (data[i + 1], data[i]); + while (i < num_u32_blocks) + { + // Reconstruct u64 from two u32s + u64 k = hl32_to_64 (data[i + 1], data[i]); k *= M; k ^= k >> R; @@ -45,39 +41,20 @@ DECLSPEC u64x MurmurHash64A (PRIVATE_AS const u32x *data, const u32 len) i += 2; } - //printf("BEFORE_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); - - // Overflow - + // Up to 7 overflow bytes const u32 overflow = len & 7; - //printf("OVERFLOW = %d\n", overflow); - - //printf("data = %08x%08x%08x%08x%08x%08x%08x%08x%08x%08x\n", data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9]); - - //printf("i = %d\n", i); - //printf("data[i] data[i + 1] = %08x%08x\n", data[i], data[i + 1]); - - // can we turn this into a single xor - - if ((overflow > 0) && (overflow <= 4)) { - //printf("Overflow case 1\n"); + if (overflow > 4) + { hash ^= hl32_to_64 (data[i + 1], data[i]); hash *= M; } - - else if (overflow > 4) { - //printf("Overflow case 2\n"); - //printf("tmp = %08x%08x\n", h32_from_64(tmp), l32_from_64(tmp)); - hash ^= hl32_to_64 (data[i + 1], data[i]); + else if (overflow > 0) + { + hash ^= hl32_to_64 (0, data[i]); hash *= M; } - //u64 test = hl32_to_64 (0x0a16869e, 0xcb107f54); - //printf("hl32_to_64 test = %08x%08x\n", h32_from_64(test), l32_from_64(test)); - - //printf("AFTER_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); - hash ^= hash >> R; hash *= M; hash ^= hash >> R; @@ -85,8 +62,6 @@ DECLSPEC u64x MurmurHash64A (PRIVATE_AS const u32x *data, const u32 len) #undef M #undef R - //printf("hash = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); - return hash; } @@ -96,10 +71,6 @@ DECLSPEC void m90010m (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F * modifiers are taken from args */ - /** - * seed - */ - /** * base */ @@ -123,9 +94,6 @@ DECLSPEC void m90010m (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F w[14] = data[14]; w[15] = data[15]; - //const u8 *data2 = (const u8*) data; - //printf("w = %c%c%c%c%c%c%c%c\n", data2[0], data2[1], data2[2], data2[3], data2[4], data2[5], data2[6], data2[7]); - /** * loop */ @@ -140,16 +108,12 @@ DECLSPEC void m90010m (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F w[0] = w0; - //printf("seed = %08x%08x\n", seed_hi, seed_lo); - const u64x hash = MurmurHash64A (w, pw_len); - const u32x r0 = l32_from_64(hash); - const u32x r1 = h32_from_64(hash); + const u32x r0 = l32_from_64 (hash); + const u32x r1 = h32_from_64 (hash); const u32x z = 0; - //printf("hash = %08x%08x\n", r1, r0); - COMPARE_M_SIMD (r0, r1, z, z); } } @@ -163,8 +127,6 @@ DECLSPEC void m90010s (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F /** * digest */ - - //printf("Hello world m90010s\n"); const u32 search[4] = { @@ -174,10 +136,6 @@ DECLSPEC void m90010s (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F 0 }; - /** - * seed - */ - /** * base */ @@ -217,25 +175,19 @@ DECLSPEC void m90010s (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F const u64x hash = MurmurHash64A (w, pw_len); - const u32x r0 = l32_from_64(hash); - const u32x r1 = h32_from_64(hash); + const u32x r0 = l32_from_64 (hash); + const u32x r1 = h32_from_64 (hash); const u32x z = 0; - //printf("r1 = %08x r0 = %08x\n", r1, r0); - //printf("hash = %08x%08x\n", r1, r0); - COMPARE_S_SIMD (r0, r1, z, z); } } -KERNEL_FQ void m90010_m04 (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m90010_m04 (KERN_ATTR_VECTOR ()) { /** * base */ - - //printf("Hello world m90010_m04\n"); - const u64 lid = get_local_id (0); const u64 gid = get_global_id (0); @@ -263,7 +215,6 @@ KERNEL_FQ void m90010_m04 (KERN_ATTR_VECTOR ()) w[15] = 0; const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; - //printf("pws[gid].pw_len = %d\n", pws[gid].pw_len); /** * main @@ -272,13 +223,11 @@ KERNEL_FQ void m90010_m04 (KERN_ATTR_VECTOR ()) m90010m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ void m90010_m08 (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m90010_m08 (KERN_ATTR_VECTOR ()) { /** * base */ - - //printf("Hello world m90010_m08\n"); const u64 lid = get_local_id (0); const u64 gid = get_global_id (0); @@ -314,7 +263,7 @@ KERNEL_FQ void m90010_m08 (KERN_ATTR_VECTOR ()) m90010m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ void m90010_m16 (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m90010_m16 (KERN_ATTR_VECTOR ()) { /** * base @@ -354,7 +303,7 @@ KERNEL_FQ void m90010_m16 (KERN_ATTR_VECTOR ()) m90010m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ void m90010_s04 (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m90010_s04 (KERN_ATTR_VECTOR ()) { /** * base @@ -394,7 +343,7 @@ KERNEL_FQ void m90010_s04 (KERN_ATTR_VECTOR ()) m90010s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ void m90010_s08 (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m90010_s08 (KERN_ATTR_VECTOR ()) { /** * base @@ -434,7 +383,7 @@ KERNEL_FQ void m90010_s08 (KERN_ATTR_VECTOR ()) m90010s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ void m90010_s16 (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m90010_s16 (KERN_ATTR_VECTOR ()) { /** * base diff --git a/OpenCL/m90010_a3-pure.cl b/OpenCL/m90010_a3-pure.cl old mode 100644 new mode 100755 index 51421ab11..6db8db29b --- a/OpenCL/m90010_a3-pure.cl +++ b/OpenCL/m90010_a3-pure.cl @@ -10,7 +10,7 @@ #include M2S(INCLUDE_PATH/inc_types.h) #include M2S(INCLUDE_PATH/inc_platform.cl) #include M2S(INCLUDE_PATH/inc_common.cl) -#include M2S(INCLUDE_PATH/inc_simd.cl) +#include M2S(INCLUDE_PATH/inc_scalar.cl) #endif DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) @@ -19,19 +19,16 @@ DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) #define R 47 //Initialize hash - u64 hash = 0 ^ (len * M); + u64 hash = len * M; - //printf("len = %d\n", len); - //printf("INITIAL = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + // Twice the number of u64 blocks + const u32 num_u32_blocks = (len / 8) * 2; - // 2 for each u64 block - const u32 num_blocks = (len / 8) * 2; - - //printf("num_blocks = %d\n", num_blocks); - - // Loop over blocks of 8 bytes + // Loop over one u64 at a time u32 i = 0; - while (i < num_blocks) { + while (i < num_u32_blocks) + { + // Reconstruct u64 from two u32s u64 k = hl32_to_64 (data[i + 1], data[i]); k *= M; @@ -44,39 +41,20 @@ DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) i += 2; } - //printf("BEFORE_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); - - // Overflow - + // Up to 7 overflow bytes const u32 overflow = len & 7; - //printf("OVERFLOW = %d\n", overflow); - - //printf("data = %08x%08x%08x%08x%08x%08x%08x%08x%08x%08x\n", data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9]); - - //printf("i = %d\n", i); - //printf("data[i] data[i + 1] = %08x%08x\n", data[i], data[i + 1]); - - // can we turn this into a single xor - - if ((overflow > 0) && (overflow <= 4)) { - //printf("Overflow case 1\n"); + if (overflow > 4) + { hash ^= hl32_to_64 (data[i + 1], data[i]); hash *= M; } - - else if (overflow > 4) { - //printf("Overflow case 2\n"); - //printf("tmp = %08x%08x\n", h32_from_64(tmp), l32_from_64(tmp)); - hash ^= hl32_to_64 (data[i + 1], data[i]); + else if (overflow > 0) + { + hash ^= hl32_to_64 (0, data[i]); hash *= M; } - //u64 test = hl32_to_64 (0x0a16869e, 0xcb107f54); - //printf("hl32_to_64 test = %08x%08x\n", h32_from_64(test), l32_from_64(test)); - - //printf("AFTER_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); - hash ^= hash >> R; hash *= M; hash ^= hash >> R; @@ -84,12 +62,10 @@ DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) #undef M #undef R - //printf("hash = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); - return hash; } -KERNEL_FQ void m90010_mxx (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m90010_mxx (KERN_ATTR_VECTOR ()) { /** * modifier @@ -129,15 +105,15 @@ KERNEL_FQ void m90010_mxx (KERN_ATTR_VECTOR ()) const u64x hash = MurmurHash64A (w, pw_len); - const u32x r0 = l32_from_64(hash); - const u32x r1 = h32_from_64(hash); + const u32x r0 = l32_from_64 (hash); + const u32x r1 = h32_from_64 (hash); const u32x z = 0; - COMPARE_M_SIMD (r0, r1, z, z); + COMPARE_M_SCALAR (r0, r1, z, z); } } -KERNEL_FQ void m90010_sxx (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m90010_sxx (KERN_ATTR_VECTOR ()) { /** * modifier @@ -189,10 +165,10 @@ KERNEL_FQ void m90010_sxx (KERN_ATTR_VECTOR ()) const u64x hash = MurmurHash64A (w, pw_len); - const u32x r0 = l32_from_64(hash); - const u32x r1 = h32_from_64(hash); + const u32x r0 = l32_from_64 (hash); + const u32x r1 = h32_from_64 (hash); const u32x z = 0; - COMPARE_S_SIMD (r0, r1, z, z); + COMPARE_S_SCALAR (r0, r1, z, z); } } diff --git a/OpenCL/m90030_a0-optimized.cl b/OpenCL/m90030_a0-optimized.cl old mode 100644 new mode 100755 index 71c54129d..9ce1ae104 --- a/OpenCL/m90030_a0-optimized.cl +++ b/OpenCL/m90030_a0-optimized.cl @@ -15,25 +15,22 @@ #include M2S(INCLUDE_PATH/inc_simd.cl) #endif -DECLSPEC u32 MurmurHash64A_32 (PRIVATE_AS const u32 *data, const u32 len) +DECLSPEC u32 MurmurHash64A_truncated (PRIVATE_AS const u32 *data, const u32 len) { #define M 0xc6a4a7935bd1e995 #define R 47 //Initialize hash - u64 hash = 0 ^ (len * M); + u64 hash = len * M; - //printf("len = %d\n", len); - //printf("INITIAL = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + // Twice the number of u64 blocks + const u32 num_u32_blocks = (len / 8) * 2; - // 2 for each u64 block - const u32 num_blocks = (len / 8) * 2; - - //printf("num_blocks = %d\n", num_blocks); - - // Loop over blocks of 8 bytes + // Loop over one u64 at a time u32 i = 0; - while (i < num_blocks) { + while (i < num_u32_blocks) + { + // Reconstruct u64 from two u32s u64 k = hl32_to_64 (data[i + 1], data[i]); k *= M; @@ -46,36 +43,20 @@ DECLSPEC u32 MurmurHash64A_32 (PRIVATE_AS const u32 *data, const u32 len) i += 2; } - //printf("BEFORE_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); - - // Overflow - + // Up to 7 overflow bytes const u32 overflow = len & 7; - //printf("OVERFLOW = %d\n", overflow); - - //printf("data = %08x%08x%08x%08x%08x%08x%08x%08x%08x%08x\n", data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9]); - - //printf("i = %d\n", i); - //printf("data[i] data[i + 1] = %08x%08x\n", data[i], data[i + 1]); - - // can we turn this into a single xor - - if ((overflow > 0) && (overflow <= 4)) { - //printf("Overflow case 1\n"); + if (overflow > 4) + { hash ^= hl32_to_64 (data[i + 1], data[i]); hash *= M; } - - else if (overflow > 4) { - //printf("Overflow case 2\n"); - //printf("tmp = %08x%08x\n", h32_from_64(tmp), l32_from_64(tmp)); - hash ^= hl32_to_64 (data[i + 1], data[i]); + else if (overflow > 0) + { + hash ^= hl32_to_64 (0, data[i]); hash *= M; } - //printf("AFTER_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); - hash ^= hash >> R; hash *= M; hash ^= hash >> R; @@ -83,16 +64,12 @@ DECLSPEC u32 MurmurHash64A_32 (PRIVATE_AS const u32 *data, const u32 len) #undef M #undef R - //printf("hash = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); - + // Truncate to high 4 bytes return (u32) (hash >> 32); } - - -KERNEL_FQ void m90030_m04 (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m90030_m04 (KERN_ATTR_RULES ()) { - //printf("Hello world m90030_m04\n"); /** * modifier */ @@ -119,7 +96,6 @@ KERNEL_FQ void m90030_m04 (KERN_ATTR_RULES ()) pw_buf1[2] = pws[gid].i[6]; pw_buf1[3] = pws[gid].i[7]; - // max pw len of 32 const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; /** @@ -132,9 +108,7 @@ KERNEL_FQ void m90030_m04 (KERN_ATTR_RULES ()) const u32x out_len = apply_rules_vect_optimized (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w + 0, w + 4); - u32x hash = MurmurHash64A_32 (w, out_len); - - //printf("hash = %08x\n", hash); + u32x hash = MurmurHash64A_truncated (w, out_len); const u32x z = 0; @@ -142,17 +116,16 @@ KERNEL_FQ void m90030_m04 (KERN_ATTR_RULES ()) } } -KERNEL_FQ void m90030_m08 (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m90030_m08 (KERN_ATTR_RULES ()) { } -KERNEL_FQ void m90030_m16 (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m90030_m16 (KERN_ATTR_RULES ()) { } -KERNEL_FQ void m90030_s04 (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m90030_s04 (KERN_ATTR_RULES ()) { - //printf("Hello world m90030_s04\n"); /** * modifier */ @@ -179,7 +152,6 @@ KERNEL_FQ void m90030_s04 (KERN_ATTR_RULES ()) pw_buf1[2] = pws[gid].i[6]; pw_buf1[3] = pws[gid].i[7]; - // max pw len of 32 const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; /** @@ -204,7 +176,7 @@ KERNEL_FQ void m90030_s04 (KERN_ATTR_RULES ()) const u32x out_len = apply_rules_vect_optimized (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w + 0, w + 4); - u32x hash = MurmurHash64A_32 (w, out_len); + u32x hash = MurmurHash64A_truncated (w, out_len); const u32x z = 0; @@ -212,10 +184,10 @@ KERNEL_FQ void m90030_s04 (KERN_ATTR_RULES ()) } } -KERNEL_FQ void m90030_s08 (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m90030_s08 (KERN_ATTR_RULES ()) { } -KERNEL_FQ void m90030_s16 (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m90030_s16 (KERN_ATTR_RULES ()) { } diff --git a/OpenCL/m90030_a1-optimized.cl b/OpenCL/m90030_a1-optimized.cl old mode 100644 new mode 100755 index a5801e43b..0f743c3ef --- a/OpenCL/m90030_a1-optimized.cl +++ b/OpenCL/m90030_a1-optimized.cl @@ -3,7 +3,6 @@ * License.....: MIT */ -//too much register pressure //#define NEW_SIMD_CODE #ifdef KERNEL_STATIC @@ -14,25 +13,22 @@ #include M2S(INCLUDE_PATH/inc_simd.cl) #endif -DECLSPEC u32 MurmurHash64A_32 (PRIVATE_AS const u32 *data, const u32 len) +DECLSPEC u32 MurmurHash64A_truncated (PRIVATE_AS const u32 *data, const u32 len) { #define M 0xc6a4a7935bd1e995 #define R 47 //Initialize hash - u64 hash = 0 ^ (len * M); + u64 hash = len * M; - //printf("len = %d\n", len); - //printf("INITIAL = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + // Twice the number of u64 blocks + const u32 num_u32_blocks = (len / 8) * 2; - // 2 for each u64 block - const u32 num_blocks = (len / 8) * 2; - - //printf("num_blocks = %d\n", num_blocks); - - // Loop over blocks of 8 bytes + // Loop over one u64 at a time u32 i = 0; - while (i < num_blocks) { + while (i < num_u32_blocks) + { + // Reconstruct u64 from two u32s u64 k = hl32_to_64 (data[i + 1], data[i]); k *= M; @@ -45,39 +41,20 @@ DECLSPEC u32 MurmurHash64A_32 (PRIVATE_AS const u32 *data, const u32 len) i += 2; } - //printf("BEFORE_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); - - // Overflow - + // Up to 7 overflow bytes const u32 overflow = len & 7; - //printf("OVERFLOW = %d\n", overflow); - - //printf("data = %08x%08x%08x%08x%08x%08x%08x%08x%08x%08x\n", data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9]); - - //printf("i = %d\n", i); - //printf("data[i] data[i + 1] = %08x%08x\n", data[i], data[i + 1]); - - // can we turn this into a single xor - - if ((overflow > 0) && (overflow <= 4)) { - //printf("Overflow case 1\n"); + if (overflow > 4) + { hash ^= hl32_to_64 (data[i + 1], data[i]); hash *= M; } - - else if (overflow > 4) { - //printf("Overflow case 2\n"); - //printf("tmp = %08x%08x\n", h32_from_64(tmp), l32_from_64(tmp)); - hash ^= hl32_to_64 (data[i + 1], data[i]); + else if (overflow > 0) + { + hash ^= hl32_to_64 (0, data[i]); hash *= M; } - //u64 test = hl32_to_64 (0x0a16869e, 0xcb107f54); - //printf("hl32_to_64 test = %08x%08x\n", h32_from_64(test), l32_from_64(test)); - - //printf("AFTER_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); - hash ^= hash >> R; hash *= M; hash ^= hash >> R; @@ -85,12 +62,11 @@ DECLSPEC u32 MurmurHash64A_32 (PRIVATE_AS const u32 *data, const u32 len) #undef M #undef R - //printf("hash = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); - + // Truncate to high 4 bytes return (u32) (hash >> 32); } -KERNEL_FQ void m90030_m04 (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m90030_m04 (KERN_ATTR_BASIC ()) { /** * modifier @@ -119,10 +95,6 @@ KERNEL_FQ void m90030_m04 (KERN_ATTR_BASIC ()) const u32 pw_l_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; - /** - * seed - */ - /** * loop */ @@ -193,7 +165,7 @@ KERNEL_FQ void m90030_m04 (KERN_ATTR_BASIC ()) w[14] = wordl3[2] | wordr3[2]; w[15] = wordl3[3] | wordr3[3]; - u32x hash = MurmurHash64A_32 (w, pw_len); + u32x hash = MurmurHash64A_truncated (w, pw_len); const u32x z = 0; @@ -201,15 +173,15 @@ KERNEL_FQ void m90030_m04 (KERN_ATTR_BASIC ()) } } -KERNEL_FQ void m90030_m08 (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m90030_m08 (KERN_ATTR_BASIC ()) { } -KERNEL_FQ void m90030_m16 (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m90030_m16 (KERN_ATTR_BASIC ()) { } -KERNEL_FQ void m90030_s04 (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m90030_s04 (KERN_ATTR_BASIC ()) { /** * modifier @@ -238,10 +210,6 @@ KERNEL_FQ void m90030_s04 (KERN_ATTR_BASIC ()) const u32 pw_l_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; - /** - * seed - */ - /** * digest */ @@ -324,7 +292,7 @@ KERNEL_FQ void m90030_s04 (KERN_ATTR_BASIC ()) w[14] = wordl3[2] | wordr3[2]; w[15] = wordl3[3] | wordr3[3]; - u32 hash = MurmurHash64A_32 (w, pw_len); + u32 hash = MurmurHash64A_truncated (w, pw_len); const u32 z = 0; @@ -332,10 +300,10 @@ KERNEL_FQ void m90030_s04 (KERN_ATTR_BASIC ()) } } -KERNEL_FQ void m90030_s08 (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m90030_s08 (KERN_ATTR_BASIC ()) { } -KERNEL_FQ void m90030_s16 (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m90030_s16 (KERN_ATTR_BASIC ()) { } diff --git a/OpenCL/m90030_a3-optimized.cl b/OpenCL/m90030_a3-optimized.cl old mode 100644 new mode 100755 index 61d6537ea..443fdd838 --- a/OpenCL/m90030_a3-optimized.cl +++ b/OpenCL/m90030_a3-optimized.cl @@ -13,27 +13,23 @@ #include M2S(INCLUDE_PATH/inc_simd.cl) #endif - -DECLSPEC u32x MurmurHash64A_32 (PRIVATE_AS const u32x *data, const u32 len) +DECLSPEC u32 MurmurHash64A_truncated (PRIVATE_AS const u32 *data, const u32 len) { #define M 0xc6a4a7935bd1e995 #define R 47 //Initialize hash - u64x hash = 0 ^ (len * M); + u64 hash = len * M; - //printf("len = %d\n", len); - //printf("INITIAL = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); + // Twice the number of u64 blocks + const u32 num_u32_blocks = (len / 8) * 2; - // 2 for each u64 block - const u32 num_blocks = (len / 8) * 2; - - //printf("num_blocks = %d\n", num_blocks); - - // Loop over blocks of 8 bytes + // Loop over one u64 at a time u32 i = 0; - while (i < num_blocks) { - u64x k = hl32_to_64 (data[i + 1], data[i]); + while (i < num_u32_blocks) + { + // Reconstruct u64 from two u32s + u64 k = hl32_to_64 (data[i + 1], data[i]); k *= M; k ^= k >> R; @@ -45,39 +41,20 @@ DECLSPEC u32x MurmurHash64A_32 (PRIVATE_AS const u32x *data, const u32 len) i += 2; } - //printf("BEFORE_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); - - // Overflow - + // Up to 7 overflow bytes const u32 overflow = len & 7; - //printf("OVERFLOW = %d\n", overflow); - - //printf("data = %08x%08x%08x%08x%08x%08x%08x%08x%08x%08x\n", data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9]); - - //printf("i = %d\n", i); - //printf("data[i] data[i + 1] = %08x%08x\n", data[i], data[i + 1]); - - // can we turn this into a single xor - - if ((overflow > 0) && (overflow <= 4)) { - //printf("Overflow case 1\n"); + if (overflow > 4) + { hash ^= hl32_to_64 (data[i + 1], data[i]); hash *= M; } - - else if (overflow > 4) { - //printf("Overflow case 2\n"); - //printf("tmp = %08x%08x\n", h32_from_64(tmp), l32_from_64(tmp)); - hash ^= hl32_to_64 (data[i + 1], data[i]); + else if (overflow > 0) + { + hash ^= hl32_to_64 (0, data[i]); hash *= M; } - //u64 test = hl32_to_64 (0x0a16869e, 0xcb107f54); - //printf("hl32_to_64 test = %08x%08x\n", h32_from_64(test), l32_from_64(test)); - - //printf("AFTER_OVERFLOW = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); - hash ^= hash >> R; hash *= M; hash ^= hash >> R; @@ -85,8 +62,7 @@ DECLSPEC u32x MurmurHash64A_32 (PRIVATE_AS const u32x *data, const u32 len) #undef M #undef R - //printf("hash = %08x%08x\n", h32_from_64(hash), l32_from_64(hash)); - + // Truncate to high 4 bytes return (u32) (hash >> 32); } @@ -96,10 +72,6 @@ DECLSPEC void m90030m (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F * modifiers are taken from args */ - /** - * seed - */ - /** * base */ @@ -123,9 +95,6 @@ DECLSPEC void m90030m (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F w[14] = data[14]; w[15] = data[15]; - //const u8 *data2 = (const u8*) data; - //printf("w = %c%c%c%c%c%c%c%c\n", data2[0], data2[1], data2[2], data2[3], data2[4], data2[5], data2[6], data2[7]); - /** * loop */ @@ -140,14 +109,10 @@ DECLSPEC void m90030m (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F w[0] = w0; - //printf("seed = %08x%08x\n", seed_hi, seed_lo); - - const u32x hash = MurmurHash64A_32 (w, pw_len); + const u32x hash = MurmurHash64A_truncated (w, pw_len); const u32x z = 0; - //printf("hash = %08x%08x\n", r1, r0); - COMPARE_M_SIMD (hash, z, z, z); } } @@ -161,8 +126,6 @@ DECLSPEC void m90030s (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F /** * digest */ - - //printf("Hello world m90030s\n"); const u32 search[4] = { @@ -172,10 +135,6 @@ DECLSPEC void m90030s (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F 0 }; - /** - * seed - */ - /** * base */ @@ -213,25 +172,19 @@ DECLSPEC void m90030s (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F w[0] = w0; - const u32x hash = MurmurHash64A_32 (w, pw_len); + const u32x hash = MurmurHash64A_truncated (w, pw_len); const u32x z = 0; - //printf("r1 = %08x r0 = %08x\n", r1, r0); - //printf("hash = %08x%08x\n", r1, r0); - COMPARE_S_SIMD (hash, z, z, z); } } -KERNEL_FQ void m90030_m04 (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m90030_m04 (KERN_ATTR_VECTOR ()) { /** * base */ - - //printf("Hello world m90030_m04\n"); - const u64 lid = get_local_id (0); const u64 gid = get_global_id (0); @@ -259,7 +212,6 @@ KERNEL_FQ void m90030_m04 (KERN_ATTR_VECTOR ()) w[15] = 0; const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; - //printf("pws[gid].pw_len = %d\n", pws[gid].pw_len); /** * main @@ -268,13 +220,11 @@ KERNEL_FQ void m90030_m04 (KERN_ATTR_VECTOR ()) m90030m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ void m90030_m08 (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m90030_m08 (KERN_ATTR_VECTOR ()) { /** * base */ - - //printf("Hello world m90030_m08\n"); const u64 lid = get_local_id (0); const u64 gid = get_global_id (0); @@ -310,7 +260,7 @@ KERNEL_FQ void m90030_m08 (KERN_ATTR_VECTOR ()) m90030m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ void m90030_m16 (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m90030_m16 (KERN_ATTR_VECTOR ()) { /** * base @@ -350,7 +300,7 @@ KERNEL_FQ void m90030_m16 (KERN_ATTR_VECTOR ()) m90030m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ void m90030_s04 (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m90030_s04 (KERN_ATTR_VECTOR ()) { /** * base @@ -390,7 +340,7 @@ KERNEL_FQ void m90030_s04 (KERN_ATTR_VECTOR ()) m90030s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ void m90030_s08 (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m90030_s08 (KERN_ATTR_VECTOR ()) { /** * base @@ -430,7 +380,7 @@ KERNEL_FQ void m90030_s08 (KERN_ATTR_VECTOR ()) m90030s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ void m90030_s16 (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m90030_s16 (KERN_ATTR_VECTOR ()) { /** * base diff --git a/scratch.py b/scratch.py deleted file mode 100644 index 58fc2d64b..000000000 --- a/scratch.py +++ /dev/null @@ -1,177 +0,0 @@ -""" -Adapted from https://gitlab.com/lschwiderski/vt2_bundle_unpacker -murmur/murmurhash64.rs -https://bitsquid.blogspot.com/2011/08/code-snippet-murmur-hash-inverse-pre.html -This appears to be MurmurHash2 (specifically MurmurHash64A) -""" -global INITIAL -global MIDDLE_OF_BLOCK -global BEFORE_OVERFLOW -global OVERFLOW -global AFTER_OVERFLOW_7 -global AFTER_OVERFLOW - -INITIAL = None -MIDDLE_OF_BLOCK = None -BEFORE_OVERFLOW = None -OVERFLOW = None -AFTER_OVERFLOW_7 = None -AFTER_OVERFLOW = None - - - -# 'M' and 'R' are mixing constants generated offline. -# They're not really 'magic', they just happen to work well. -M: int = 0xC6A4A7935BD1E995 # u64 -# Multiplicative inverse of `M` under % 2^64 -M_INVERSE: int = 0x5F7A0EA7E59B19BD # u64 -R: int = 47 # 47 - - -def wrapping_mul(a, b): - # Returns (a * b) mod 2**N, where N is the width of a and b in bits. - # we're only dealing in u64, so N is always 64? - return (a * b) % 2**64 - - -def hash64(key: list[int], seed: int) -> int: - global INITIAL - global MIDDLE_OF_BLOCK - global BEFORE_OVERFLOW - global OVERFLOW - global AFTER_OVERFLOW_7 - global AFTER_OVERFLOW - length = len(key) - h: int = seed ^ wrapping_mul(length, M) - - INITIAL = h - - endpos = length - (length & 7) - - i = 0 - while i != endpos: - k = key[i] - k |= key[i + 1] << 8 - k |= key[i + 2] << 16 - k |= key[i + 3] << 24 - k |= key[i + 4] << 32 - k |= key[i + 5] << 40 - k |= key[i + 6] << 48 - k |= key[i + 7] << 56 - - if i == 0: - MIDDLE_OF_BLOCK = k - - k = wrapping_mul(k, M) - k ^= k >> R - k = wrapping_mul(k, M) - - h ^= k - h = wrapping_mul(h, M) - - i += 8 - - - BEFORE_OVERFLOW = h - overflow = length & 7 - OVERFLOW = overflow - if overflow == 7: - h ^= key[i + 6] << 48 - AFTER_OVERFLOW_7 = h - if overflow >= 6: - h ^= key[i + 5] << 40 - if overflow >= 5: - h ^= key[i + 4] << 32 - if overflow >= 4: - h ^= key[i + 3] << 24 - if overflow >= 3: - h ^= key[i + 2] << 16 - if overflow >= 2: - h ^= key[i + 1] << 8 - if overflow >= 1: - h ^= key[i] - if overflow > 0: - h = wrapping_mul(h, M) - - AFTER_OVERFLOW = h - - h ^= h >> R - h = wrapping_mul(h, M) - h ^= h >> R - return h - - -# don't need hash_inverse? - - -def hash32(key: list[int], seed: int) -> int: - h = hash64(key, seed) - return h >> 32 - - -def test_hash(): - assert 0 == hash64(bytes("", "UTF-8"), 0) - assert 0xC26E8BC196329B0F == hash64(bytes("", "UTF-8"), 10) - assert 0xA14E8DFA2CD117E2 == hash64(bytes("lua", "UTF-8"), 0) - assert 0x069A33456AAD3042 == hash64(bytes("twitch_intervention", "UTF-8"), 0) - - -# test_hash() - -def get_hash(string: str, seed: int) -> int: - key = [ord(char) for char in string] - return hash64(key, seed) - -def get_short_hash(string: str, seed: int) -> int: - key = [ord(char) for char in string] - return hash32(key, seed) - - - - -""" -s = "deadbeef" -s_int = int(s, 16) - -expected_bytes = struct.pack("module_benchmark_mask = MODULE_DEFAULT; module_ctx->module_benchmark_charset = MODULE_DEFAULT; module_ctx->module_benchmark_salt = MODULE_DEFAULT; + module_ctx->module_bridge_name = MODULE_DEFAULT; + module_ctx->module_bridge_type = MODULE_DEFAULT; module_ctx->module_build_plain_postprocess = MODULE_DEFAULT; module_ctx->module_deep_comp_kernel = MODULE_DEFAULT; module_ctx->module_deprecated_notice = MODULE_DEFAULT; diff --git a/src/modules/module_90010.c b/src/modules/module_90010.c old mode 100644 new mode 100755 index 5c52c5ce1..817dc9447 --- a/src/modules/module_90010.c +++ b/src/modules/module_90010.c @@ -17,7 +17,7 @@ static const u32 DGST_POS2 = 2; static const u32 DGST_POS3 = 3; static const u32 DGST_SIZE = DGST_SIZE_8_2; static const u32 HASH_CATEGORY = HASH_CATEGORY_RAW_HASH; -static const char *HASH_NAME = "MurmurHash64A Zero Seed"; +static const char *HASH_NAME = "MurmurHash64A (zero seed)"; static const u64 KERN_TYPE = 90010; static const u32 OPTI_TYPE = OPTI_TYPE_ZERO_BYTE | OPTI_TYPE_USES_BITS_64 @@ -74,9 +74,8 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE // digest const u8 *hash_pos = token.buf[0]; - // we have 16 chars (hash hex string, big endian) - + // 16 chars (hash hex string, big endian) digest[0] = ((hex_to_u64 (&hash_pos[0]))); digest[1] = 0; @@ -114,6 +113,8 @@ void module_init (module_ctx_t *module_ctx) module_ctx->module_benchmark_mask = MODULE_DEFAULT; module_ctx->module_benchmark_charset = MODULE_DEFAULT; module_ctx->module_benchmark_salt = MODULE_DEFAULT; + module_ctx->module_bridge_name = MODULE_DEFAULT; + module_ctx->module_bridge_type = MODULE_DEFAULT; module_ctx->module_build_plain_postprocess = MODULE_DEFAULT; module_ctx->module_deep_comp_kernel = MODULE_DEFAULT; module_ctx->module_deprecated_notice = MODULE_DEFAULT; diff --git a/src/modules/module_90030.c b/src/modules/module_90030.c old mode 100644 new mode 100755 index 6bfca51b2..bb116a726 --- a/src/modules/module_90030.c +++ b/src/modules/module_90030.c @@ -17,7 +17,7 @@ static const u32 DGST_POS2 = 2; static const u32 DGST_POS3 = 3; static const u32 DGST_SIZE = DGST_SIZE_4_4; static const u32 HASH_CATEGORY = HASH_CATEGORY_RAW_HASH; -static const char *HASH_NAME = "MurmurHash64A 32 Zero Seed"; +static const char *HASH_NAME = "MurmurHash64A truncated (zero seed)"; static const u64 KERN_TYPE = 90030; static const u32 OPTI_TYPE = OPTI_TYPE_ZERO_BYTE | OPTI_TYPE_NOT_SALTED @@ -114,6 +114,8 @@ void module_init (module_ctx_t *module_ctx) module_ctx->module_benchmark_mask = MODULE_DEFAULT; module_ctx->module_benchmark_charset = MODULE_DEFAULT; module_ctx->module_benchmark_salt = MODULE_DEFAULT; + module_ctx->module_bridge_name = MODULE_DEFAULT; + module_ctx->module_bridge_type = MODULE_DEFAULT; module_ctx->module_build_plain_postprocess = MODULE_DEFAULT; module_ctx->module_deep_comp_kernel = MODULE_DEFAULT; module_ctx->module_deprecated_notice = MODULE_DEFAULT; diff --git a/tools/test_modules/m90000.pm b/tools/test_modules/m90000.pm old mode 100644 new mode 100755 index 04d53ac18..e9759d155 --- a/tools/test_modules/m90000.pm +++ b/tools/test_modules/m90000.pm @@ -11,17 +11,20 @@ use Math::BigInt; sub module_constraints { [[0, 256], [16, 16], [0, 63], [16, 16], [-1, -1]] } +my $u64_width = Math::BigInt->new("0x10000000000000000"); # 2**64 + +# Ensure that uint64 integer overflow is replicated correctly sub wrapping_mul { my $a = shift; my $b = shift; - # 2**64 - my $width = Math::BigInt->new("0x10000000000000000"); - - return ($a * $b)->bmod($width); + return ($a * $b)->bmod($u64_width); } +my $m = Math::BigInt->new("0xc6a4a7935bd1e995"); +my $r = 47; + sub murmurhash64a { use integer; @@ -29,14 +32,6 @@ sub murmurhash64a my $word = shift; my $seed = shift; - # https://gitlab.com/lschwiderski/vt2_bundle_unpacker/-/blob/master/src/murmur/murmurhash64.rs - # 'm' and 'r' are mixing constants generated offline. - # They're not really 'magic', they just happen to work well. - - my $m = Math::BigInt->new("0xc6a4a7935bd1e995"); - #my $m = 0xc6a4a7935bd1e995; - my $r = 47; - my @chars = unpack ("C*", $word); my $len = length $word; diff --git a/tools/test_modules/m90010.pm b/tools/test_modules/m90010.pm old mode 100644 new mode 100755 index af5e2e581..b093a4efd --- a/tools/test_modules/m90010.pm +++ b/tools/test_modules/m90010.pm @@ -11,31 +11,26 @@ use Math::BigInt; sub module_constraints { [[0, 256], [-1, -1], [0, 63], [-1, -1], [0, 63]] } +my $u64_width = Math::BigInt->new("0x10000000000000000"); # 2**64 + +# Ensure that uint64 integer overflow is replicated correctly sub wrapping_mul { my $a = shift; my $b = shift; - # 2**64 - my $width = Math::BigInt->new("0x10000000000000000"); - - return ($a * $b)->bmod($width); + return ($a * $b)->bmod($u64_width); } +my $m = Math::BigInt->new("0xc6a4a7935bd1e995"); +my $r = 47; + sub murmurhash64a { use integer; my $word = shift; - my $seed = 0; - - # https://gitlab.com/lschwiderski/vt2_bundle_unpacker/-/blob/master/src/murmur/murmurhash64.rs - # 'm' and 'r' are mixing constants generated offline. - # They're not really 'magic', they just happen to work well. - - my $m = Math::BigInt->new("0xc6a4a7935bd1e995"); - #my $m = 0xc6a4a7935bd1e995; - my $r = 47; + my $seed = shift; my @chars = unpack ("C*", $word); my $len = length $word; diff --git a/tools/test_modules/m90030.pm b/tools/test_modules/m90030.pm old mode 100644 new mode 100755 index d277c2ea5..e14d2401d --- a/tools/test_modules/m90030.pm +++ b/tools/test_modules/m90030.pm @@ -11,31 +11,26 @@ use Math::BigInt; sub module_constraints { [[0, 256], [-1, -1], [0, 32], [-1, -1], [0, 32]] } +my $u64_width = Math::BigInt->new("0x10000000000000000"); # 2**64 + +# Ensure that uint64 integer overflow is replicated correctly sub wrapping_mul { my $a = shift; my $b = shift; - # 2**64 - my $width = Math::BigInt->new("0x10000000000000000"); - - return ($a * $b)->bmod($width); + return ($a * $b)->bmod($u64_width); } +my $m = Math::BigInt->new("0xc6a4a7935bd1e995"); +my $r = 47; + sub murmurhash64a_32 { use integer; my $word = shift; - my $seed = 0; - - # https://gitlab.com/lschwiderski/vt2_bundle_unpacker/-/blob/master/src/murmur/murmurhash64.rs - # 'm' and 'r' are mixing constants generated offline. - # They're not really 'magic', they just happen to work well. - - my $m = Math::BigInt->new("0xc6a4a7935bd1e995"); - #my $m = 0xc6a4a7935bd1e995; - my $r = 47; + my $seed = shift; my @chars = unpack ("C*", $word); my $len = length $word; @@ -113,7 +108,7 @@ sub murmurhash64a_32 $hash = wrapping_mul ($hash, $m); $hash ^= $hash >> $r; - # use only high 32 bits from hash + # Use only high 32 bits from final hash $hash = $hash >> 32; return $hash; From 8d38c6f808c8f87246dab2a4e5e44ae640e910b9 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Wed, 23 Jul 2025 12:36:17 +1000 Subject: [PATCH 51/61] Fix up c modules --- src/modules/module_90000.c | 79 ++++++++++++-------------------------- src/modules/module_90010.c | 11 +++--- src/modules/module_90030.c | 16 ++++---- 3 files changed, 39 insertions(+), 67 deletions(-) diff --git a/src/modules/module_90000.c b/src/modules/module_90000.c index 124adbc3c..db20ffc15 100755 --- a/src/modules/module_90000.c +++ b/src/modules/module_90000.c @@ -20,11 +20,12 @@ static const u32 HASH_CATEGORY = HASH_CATEGORY_RAW_CHECKSUM; static const char *HASH_NAME = "MurmurHash64A"; static const u64 KERN_TYPE = 90000; static const u32 OPTI_TYPE = OPTI_TYPE_ZERO_BYTE - | OPTI_TYPE_USES_BITS_64; + | OPTI_TYPE_USES_BITS_64 + | OPTI_TYPE_NOT_ITERATED; static const u64 OPTS_TYPE = OPTS_TYPE_STOCK_MODULE | OPTS_TYPE_PT_GENERATE_LE - | OPTS_TYPE_ST_HEX - | OPTS_TYPE_SUGGEST_KG; + | OPTS_TYPE_SUGGEST_KG + | OPTS_TYPE_ST_HEX; static const u32 SALT_TYPE = SALT_TYPE_EMBEDDED; static const char *ST_PASS = "hashcat"; static const char *ST_HASH = "ef3014941bf1102d:837163b2348dfae1"; @@ -44,6 +45,15 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig, const char *module_st_hash (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return ST_HASH; } const char *module_st_pass (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return ST_PASS; } +u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) +{ + const bool optimized_kernel = (hashconfig->opti_type & OPTI_TYPE_OPTIMIZED_KERNEL); + + const u32 pw_max = (optimized_kernel == true) ? 32 : PW_MAX; + + return pw_max; +} + u32 module_salt_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { const u32 salt_max = 8; @@ -82,65 +92,30 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE if (rc_tokenizer != PARSER_OK) return (rc_tokenizer); - // digest + // Digest + // 16 chars (hash hex string, big endian) const u8 *hash_pos = token.buf[0]; - // we have 16 chars (hash hex string, big endian) - /* - printf("hash_pos = "); - for (size_t i = 0; i < 16; ++i) { - printf("%c", hash_pos[i]); - } - printf("\n"); - */ + // Convert to little endian u64 digest[0] = ((hex_to_u64 (&hash_pos[0]))); digest[1] = 0; digest[0] = byte_swap_64 (digest[0]); - // now `digest` contains a proper little endian u64 - /* - u8 *temp_ref = (u8*) &digest[0]; - printf("digest[0] = "); - for (size_t i = 0; i < 8; ++i) { - printf("%02x", temp_ref[i]); - } - printf("\n"); - */ - - // seed + // Seed + // 16 chars (salt hex string, big endian) const u8 *salt_pos = token.buf[1]; - // const int salt_len = token.len[1]; - // `salt_pos` is an array of 16 chars (salt hex string, big endian) - /* - printf("salt_pos = "); - for (size_t i = 0; i < 16; ++i) { - printf("%c", salt_pos[i]); - } - printf("\n"); - */ - - u64 temp_salt = hex_to_u64 (&salt_pos[0]); // convert hex to u64 - temp_salt = byte_swap_64 (temp_salt); // byte swap + u64 temp_salt = hex_to_u64 (&salt_pos[0]); // Convert hex to u64 + temp_salt = byte_swap_64 (temp_salt); // Byte swap to little endian + // Split into two u32s for salt_buf salt->salt_buf[0] = (u32) (temp_salt & 0xffffffff); // lo 32 bits salt->salt_buf[1] = (u32) (temp_salt >> 32); // hi 32 bits salt->salt_len = 8; - // now salt->salt_buf[0] has the first half of a u64 - // and salt->salt_buf[1] has the other half - - /* - u8 *temp_ref = (u8*) salt->salt_buf; - printf("salt->salt_buf[0] = "); - for (size_t i = 0; i < 8; ++i) { - printf("%02x", temp_ref[i]); - } - printf("\n"); - */ return (PARSER_OK); } @@ -158,22 +133,16 @@ int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE int out_len = 0; + // Write hash as big endian hex u64_to_hex (byte_swap_64 (digest[0]), out_buf + out_len); out_len += 16; out_buf[out_len] = (u8) hashconfig->separator; out_len += 1; + // Write salt as big endian hex u64_to_hex (byte_swap_64 (salt_b[0]), out_buf + out_len); out_len += 16; - /* - printf("out_buf = "); - for (int i = 0; i < out_len; ++i) { - printf("%c", out_buf[i]); - } - printf("\n"); - */ - // len should be 33 (16 + 1 + 16) return out_len; } @@ -247,7 +216,7 @@ void module_init (module_ctx_t *module_ctx) module_ctx->module_potfile_disable = MODULE_DEFAULT; module_ctx->module_potfile_keep_all_hashes = MODULE_DEFAULT; module_ctx->module_pwdump_column = MODULE_DEFAULT; - module_ctx->module_pw_max = MODULE_DEFAULT; + module_ctx->module_pw_max = module_pw_max; module_ctx->module_pw_min = MODULE_DEFAULT; module_ctx->module_salt_max = module_salt_max; module_ctx->module_salt_min = module_salt_min; diff --git a/src/modules/module_90010.c b/src/modules/module_90010.c index 817dc9447..9bce40591 100755 --- a/src/modules/module_90010.c +++ b/src/modules/module_90010.c @@ -21,6 +21,7 @@ static const char *HASH_NAME = "MurmurHash64A (zero seed)"; static const u64 KERN_TYPE = 90010; static const u32 OPTI_TYPE = OPTI_TYPE_ZERO_BYTE | OPTI_TYPE_USES_BITS_64 + | OPTI_TYPE_NOT_ITERATED | OPTI_TYPE_NOT_SALTED; static const u64 OPTS_TYPE = OPTS_TYPE_STOCK_MODULE | OPTS_TYPE_PT_GENERATE_LE @@ -71,18 +72,17 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE if (rc_tokenizer != PARSER_OK) return (rc_tokenizer); - // digest - - const u8 *hash_pos = token.buf[0]; + // Digest // 16 chars (hash hex string, big endian) + const u8 *hash_pos = token.buf[0]; + + // Convert to little endian u64 digest[0] = ((hex_to_u64 (&hash_pos[0]))); digest[1] = 0; digest[0] = byte_swap_64 (digest[0]); - // now `digest` contains a proper little endian u64 - return (PARSER_OK); } @@ -97,6 +97,7 @@ int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE const int out_len = 16; + // Write hash as big endian hex u64_to_hex (byte_swap_64 (digest[0]), out_buf); return out_len; diff --git a/src/modules/module_90030.c b/src/modules/module_90030.c index bb116a726..c6ef5646c 100755 --- a/src/modules/module_90030.c +++ b/src/modules/module_90030.c @@ -20,8 +20,9 @@ static const u32 HASH_CATEGORY = HASH_CATEGORY_RAW_HASH; static const char *HASH_NAME = "MurmurHash64A truncated (zero seed)"; static const u64 KERN_TYPE = 90030; static const u32 OPTI_TYPE = OPTI_TYPE_ZERO_BYTE - | OPTI_TYPE_NOT_SALTED - | OPTI_TYPE_USES_BITS_64; + | OPTI_TYPE_USES_BITS_64 + | OPTI_TYPE_NOT_ITERATED + | OPTI_TYPE_NOT_SALTED; static const u64 OPTS_TYPE = OPTS_TYPE_STOCK_MODULE | OPTS_TYPE_PT_GENERATE_LE | OPTS_TYPE_SUGGEST_KG; @@ -71,19 +72,19 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE if (rc_tokenizer != PARSER_OK) return (rc_tokenizer); - // digest + // Digest + // 8 chars (hash hex string, big endian) const u8 *hash_pos = token.buf[0]; - // we have 8 chars (hash hex string, big endian) - + // Convert to little endian u32 digest[0] = ((hex_to_u32 (&hash_pos[0]))); digest[1] = 0; + digest[2] = 0; + digest[3] = 0; digest[0] = byte_swap_32 (digest[0]); - // now `digest` contains a proper little endian u64 - return (PARSER_OK); } @@ -98,6 +99,7 @@ int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE const int out_len = 8; + // Write hash as big endian hex u32_to_hex (byte_swap_32 (digest[0]), out_buf); return out_len; From 4b1a8f2623870c9b6bb19833273ccefc5bb05faa Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Wed, 23 Jul 2025 13:07:58 +1000 Subject: [PATCH 52/61] More fixes --- OpenCL/m90000_a0-optimized.cl | 1 - OpenCL/m90000_a1-pure.cl | 4 ++-- OpenCL/m90010_a0-optimized.cl | 1 - OpenCL/m90010_a1-optimized.cl | 4 ++-- OpenCL/m90010_a1-pure.cl | 4 ++-- OpenCL/m90010_a3-optimized.cl | 14 +++++++------- OpenCL/m90030_a0-optimized.cl | 4 ++-- OpenCL/m90030_a1-optimized.cl | 4 ++-- OpenCL/m90030_a3-optimized.cl | 12 ++++++------ 9 files changed, 23 insertions(+), 25 deletions(-) diff --git a/OpenCL/m90000_a0-optimized.cl b/OpenCL/m90000_a0-optimized.cl index 1842c60aa..f61422fe8 100755 --- a/OpenCL/m90000_a0-optimized.cl +++ b/OpenCL/m90000_a0-optimized.cl @@ -162,7 +162,6 @@ KERNEL_FQ KERNEL_FA void m90000_s04 (KERN_ATTR_RULES ()) pw_buf1[2] = pws[gid].i[6]; pw_buf1[3] = pws[gid].i[7]; - // Max pw len of 32 const u32 pw_len = pws[gid].pw_len & 63; /** diff --git a/OpenCL/m90000_a1-pure.cl b/OpenCL/m90000_a1-pure.cl index 7d5d3ed3a..1c86763fd 100755 --- a/OpenCL/m90000_a1-pure.cl +++ b/OpenCL/m90000_a1-pure.cl @@ -85,7 +85,7 @@ KERNEL_FQ KERNEL_FA void m90000_mxx (KERN_ATTR_BASIC ()) // copy left buffer GLOBAL_AS const u8 *left = (GLOBAL_AS const u8*) pws[gid].i; - // probably really bad for performance. fix later + // probably bad for performance for (u32 i = 0; i < pws[gid].pw_len; i++) { combined_buf[i] = left[i]; @@ -143,7 +143,7 @@ KERNEL_FQ KERNEL_FA void m90000_sxx (KERN_ATTR_BASIC ()) // copy left buffer GLOBAL_AS const u8 *left = (GLOBAL_AS const u8*) pws[gid].i; - // probably really bad for performance. fix later + // probably bad for performance for (u32 i = 0; i < pws[gid].pw_len; i++) { combined_buf[i] = left[i]; diff --git a/OpenCL/m90010_a0-optimized.cl b/OpenCL/m90010_a0-optimized.cl index c24ff6446..61585984d 100755 --- a/OpenCL/m90010_a0-optimized.cl +++ b/OpenCL/m90010_a0-optimized.cl @@ -153,7 +153,6 @@ KERNEL_FQ KERNEL_FA void m90010_s04 (KERN_ATTR_RULES ()) pw_buf1[2] = pws[gid].i[6]; pw_buf1[3] = pws[gid].i[7]; - // Max pw len of 32 const u32 pw_len = pws[gid].pw_len & 63; /** diff --git a/OpenCL/m90010_a1-optimized.cl b/OpenCL/m90010_a1-optimized.cl index 0b22d2c10..1eba4d2dd 100755 --- a/OpenCL/m90010_a1-optimized.cl +++ b/OpenCL/m90010_a1-optimized.cl @@ -92,7 +92,7 @@ KERNEL_FQ KERNEL_FA void m90010_m04 (KERN_ATTR_BASIC ()) pw_buf1[2] = pws[gid].i[6]; pw_buf1[3] = pws[gid].i[7]; - const u32 pw_l_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; + const u32 pw_len = pws[gid].pw_len & 63; /** * loop @@ -209,7 +209,7 @@ KERNEL_FQ KERNEL_FA void m90010_s04 (KERN_ATTR_BASIC ()) pw_buf1[2] = pws[gid].i[6]; pw_buf1[3] = pws[gid].i[7]; - const u32 pw_l_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; + const u32 pw_len = pws[gid].pw_len & 63; /** * digest diff --git a/OpenCL/m90010_a1-pure.cl b/OpenCL/m90010_a1-pure.cl index f0fd94428..33ee4f66a 100755 --- a/OpenCL/m90010_a1-pure.cl +++ b/OpenCL/m90010_a1-pure.cl @@ -85,7 +85,7 @@ KERNEL_FQ KERNEL_FA void m90010_mxx (KERN_ATTR_BASIC ()) // copy left buffer GLOBAL_AS const u8 *left = (GLOBAL_AS const u8*) pws[gid].i; - // probably really bad for performance. fix later + // probably bad for performance for (u32 i = 0; i < pws[gid].pw_len; i++) { combined_buf[i] = left[i]; @@ -134,7 +134,7 @@ KERNEL_FQ KERNEL_FA void m90010_sxx (KERN_ATTR_BASIC ()) // copy left buffer GLOBAL_AS const u8 *left = (GLOBAL_AS const u8*) pws[gid].i; - // probably really bad for performance. fix later + // probably bad for performance for (u32 i = 0; i < pws[gid].pw_len; i++) { combined_buf[i] = left[i]; diff --git a/OpenCL/m90010_a3-optimized.cl b/OpenCL/m90010_a3-optimized.cl index bf1e6e481..ed54415d6 100755 --- a/OpenCL/m90010_a3-optimized.cl +++ b/OpenCL/m90010_a3-optimized.cl @@ -214,7 +214,7 @@ KERNEL_FQ KERNEL_FA void m90010_m04 (KERN_ATTR_VECTOR ()) w[14] = 0; w[15] = 0; - const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; + const u32 pw_len = pws[gid].pw_len & 63; /** * main @@ -254,7 +254,7 @@ KERNEL_FQ KERNEL_FA void m90010_m08 (KERN_ATTR_VECTOR ()) w[14] = 0; w[15] = 0; - const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; + const u32 pw_len = pws[gid].pw_len & 63; /** * main @@ -294,7 +294,7 @@ KERNEL_FQ KERNEL_FA void m90010_m16 (KERN_ATTR_VECTOR ()) w[14] = pws[gid].i[14]; w[15] = pws[gid].i[15]; - const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; + const u32 pw_len = pws[gid].pw_len & 63; /** * main @@ -334,7 +334,7 @@ KERNEL_FQ KERNEL_FA void m90010_s04 (KERN_ATTR_VECTOR ()) w[14] = 0; w[15] = 0; - const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; + const u32 pw_len = pws[gid].pw_len & 63; /** * main @@ -374,7 +374,7 @@ KERNEL_FQ KERNEL_FA void m90010_s08 (KERN_ATTR_VECTOR ()) w[14] = 0; w[15] = 0; - const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; + const u32 pw_len = pws[gid].pw_len & 63; /** * main @@ -413,8 +413,8 @@ KERNEL_FQ KERNEL_FA void m90010_s16 (KERN_ATTR_VECTOR ()) w[13] = pws[gid].i[13]; w[14] = pws[gid].i[14]; w[15] = pws[gid].i[15]; - - const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; + + const u32 pw_len = pws[gid].pw_len & 63; /** * main diff --git a/OpenCL/m90030_a0-optimized.cl b/OpenCL/m90030_a0-optimized.cl index 9ce1ae104..bfe1a3b7e 100755 --- a/OpenCL/m90030_a0-optimized.cl +++ b/OpenCL/m90030_a0-optimized.cl @@ -96,7 +96,7 @@ KERNEL_FQ KERNEL_FA void m90030_m04 (KERN_ATTR_RULES ()) pw_buf1[2] = pws[gid].i[6]; pw_buf1[3] = pws[gid].i[7]; - const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; + const u32 pw_len = pws[gid].pw_len & 63; /** * loop @@ -152,7 +152,7 @@ KERNEL_FQ KERNEL_FA void m90030_s04 (KERN_ATTR_RULES ()) pw_buf1[2] = pws[gid].i[6]; pw_buf1[3] = pws[gid].i[7]; - const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; + const u32 pw_len = pws[gid].pw_len & 63; /** * digest diff --git a/OpenCL/m90030_a1-optimized.cl b/OpenCL/m90030_a1-optimized.cl index 0f743c3ef..d1ea374c0 100755 --- a/OpenCL/m90030_a1-optimized.cl +++ b/OpenCL/m90030_a1-optimized.cl @@ -93,7 +93,7 @@ KERNEL_FQ KERNEL_FA void m90030_m04 (KERN_ATTR_BASIC ()) pw_buf1[2] = pws[gid].i[6]; pw_buf1[3] = pws[gid].i[7]; - const u32 pw_l_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; + const u32 pw_len = pws[gid].pw_len & 63; /** * loop @@ -208,7 +208,7 @@ KERNEL_FQ KERNEL_FA void m90030_s04 (KERN_ATTR_BASIC ()) pw_buf1[2] = pws[gid].i[6]; pw_buf1[3] = pws[gid].i[7]; - const u32 pw_l_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; + const u32 pw_len = pws[gid].pw_len & 63; /** * digest diff --git a/OpenCL/m90030_a3-optimized.cl b/OpenCL/m90030_a3-optimized.cl index 443fdd838..d36ad3c93 100755 --- a/OpenCL/m90030_a3-optimized.cl +++ b/OpenCL/m90030_a3-optimized.cl @@ -211,7 +211,7 @@ KERNEL_FQ KERNEL_FA void m90030_m04 (KERN_ATTR_VECTOR ()) w[14] = 0; w[15] = 0; - const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; + const u32 pw_len = pws[gid].pw_len & 63; /** * main @@ -251,7 +251,7 @@ KERNEL_FQ KERNEL_FA void m90030_m08 (KERN_ATTR_VECTOR ()) w[14] = 0; w[15] = 0; - const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; + const u32 pw_len = pws[gid].pw_len & 63; /** * main @@ -291,7 +291,7 @@ KERNEL_FQ KERNEL_FA void m90030_m16 (KERN_ATTR_VECTOR ()) w[14] = pws[gid].i[14]; w[15] = pws[gid].i[15]; - const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; + const u32 pw_len = pws[gid].pw_len & 63; /** * main @@ -331,7 +331,7 @@ KERNEL_FQ KERNEL_FA void m90030_s04 (KERN_ATTR_VECTOR ()) w[14] = 0; w[15] = 0; - const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; + const u32 pw_len = pws[gid].pw_len & 63; /** * main @@ -371,7 +371,7 @@ KERNEL_FQ KERNEL_FA void m90030_s08 (KERN_ATTR_VECTOR ()) w[14] = 0; w[15] = 0; - const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; + const u32 pw_len = pws[gid].pw_len & 63; /** * main @@ -411,7 +411,7 @@ KERNEL_FQ KERNEL_FA void m90030_s16 (KERN_ATTR_VECTOR ()) w[14] = pws[gid].i[14]; w[15] = pws[gid].i[15]; - const u32 pw_len = (pws[gid].pw_len > 32) ? 32 : pws[gid].pw_len; + const u32 pw_len = pws[gid].pw_len & 63; /** * main From 5b2a95800ed6f5a3ea7e6cdbe5a22dba9a93a6d4 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Wed, 23 Jul 2025 13:42:44 +1000 Subject: [PATCH 53/61] Rename modes to 34200 --- ...a0-optimized.cl => m34200_a0-optimized.cl} | 12 ++++---- .../{m90000_a0-pure.cl => m34200_a0-pure.cl} | 4 +-- ...a1-optimized.cl => m34200_a1-optimized.cl} | 12 ++++---- .../{m90000_a1-pure.cl => m34200_a1-pure.cl} | 4 +-- ...a3-optimized.cl => m34200_a3-optimized.cl} | 28 +++++++++---------- .../{m90000_a3-pure.cl => m34200_a3-pure.cl} | 4 +-- ...a0-optimized.cl => m34201_a0-optimized.cl} | 12 ++++---- .../{m90010_a0-pure.cl => m34201_a0-pure.cl} | 4 +-- ...a1-optimized.cl => m34201_a1-optimized.cl} | 12 ++++---- .../{m90010_a1-pure.cl => m34201_a1-pure.cl} | 4 +-- ...a3-optimized.cl => m34201_a3-optimized.cl} | 28 +++++++++---------- .../{m90010_a3-pure.cl => m34201_a3-pure.cl} | 4 +-- ...a0-optimized.cl => m34211_a0-optimized.cl} | 12 ++++---- ...a1-optimized.cl => m34211_a1-optimized.cl} | 12 ++++---- ...a3-optimized.cl => m34211_a3-optimized.cl} | 28 +++++++++---------- .../{module_90000.c => module_34200.c} | 2 +- .../{module_90010.c => module_34201.c} | 2 +- .../{module_90030.c => module_34211.c} | 2 +- tools/test_modules/{m90000.pm => m34200.pm} | 0 tools/test_modules/{m90010.pm => m34201.pm} | 6 ++-- tools/test_modules/{m90030.pm => m34211.pm} | 6 ++-- 21 files changed, 99 insertions(+), 99 deletions(-) rename OpenCL/{m90000_a0-optimized.cl => m34200_a0-optimized.cl} (91%) rename OpenCL/{m90000_a0-pure.cl => m34200_a0-pure.cl} (96%) rename OpenCL/{m90000_a1-optimized.cl => m34200_a1-optimized.cl} (95%) rename OpenCL/{m90000_a1-pure.cl => m34200_a1-pure.cl} (97%) rename OpenCL/{m90000_a3-optimized.cl => m34200_a3-optimized.cl} (91%) rename OpenCL/{m90000_a3-pure.cl => m34200_a3-pure.cl} (96%) rename OpenCL/{m90010_a0-optimized.cl => m34201_a0-optimized.cl} (90%) rename OpenCL/{m90010_a0-pure.cl => m34201_a0-pure.cl} (95%) rename OpenCL/{m90010_a1-optimized.cl => m34201_a1-optimized.cl} (95%) rename OpenCL/{m90010_a1-pure.cl => m34201_a1-pure.cl} (96%) rename OpenCL/{m90010_a3-optimized.cl => m34201_a3-optimized.cl} (90%) rename OpenCL/{m90010_a3-pure.cl => m34201_a3-pure.cl} (96%) rename OpenCL/{m90030_a0-optimized.cl => m34211_a0-optimized.cl} (90%) rename OpenCL/{m90030_a1-optimized.cl => m34211_a1-optimized.cl} (95%) rename OpenCL/{m90030_a3-optimized.cl => m34211_a3-optimized.cl} (90%) rename src/modules/{module_90000.c => module_34200.c} (99%) rename src/modules/{module_90010.c => module_34201.c} (99%) rename src/modules/{module_90030.c => module_34211.c} (99%) rename tools/test_modules/{m90000.pm => m34200.pm} (100%) rename tools/test_modules/{m90010.pm => m34201.pm} (96%) rename tools/test_modules/{m90030.pm => m34211.pm} (95%) diff --git a/OpenCL/m90000_a0-optimized.cl b/OpenCL/m34200_a0-optimized.cl similarity index 91% rename from OpenCL/m90000_a0-optimized.cl rename to OpenCL/m34200_a0-optimized.cl index f61422fe8..82448631c 100755 --- a/OpenCL/m90000_a0-optimized.cl +++ b/OpenCL/m34200_a0-optimized.cl @@ -67,7 +67,7 @@ DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u3 return hash; } -KERNEL_FQ KERNEL_FA void m90000_m04 (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m34200_m04 (KERN_ATTR_RULES ()) { /** * modifier @@ -126,15 +126,15 @@ KERNEL_FQ KERNEL_FA void m90000_m04 (KERN_ATTR_RULES ()) } } -KERNEL_FQ KERNEL_FA void m90000_m08 (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m34200_m08 (KERN_ATTR_RULES ()) { } -KERNEL_FQ KERNEL_FA void m90000_m16 (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m34200_m16 (KERN_ATTR_RULES ()) { } -KERNEL_FQ KERNEL_FA void m90000_s04 (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m34200_s04 (KERN_ATTR_RULES ()) { /** * modifier @@ -205,10 +205,10 @@ KERNEL_FQ KERNEL_FA void m90000_s04 (KERN_ATTR_RULES ()) } } -KERNEL_FQ KERNEL_FA void m90000_s08 (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m34200_s08 (KERN_ATTR_RULES ()) { } -KERNEL_FQ KERNEL_FA void m90000_s16 (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m34200_s16 (KERN_ATTR_RULES ()) { } diff --git a/OpenCL/m90000_a0-pure.cl b/OpenCL/m34200_a0-pure.cl similarity index 96% rename from OpenCL/m90000_a0-pure.cl rename to OpenCL/m34200_a0-pure.cl index a130fb50d..7a820464d 100755 --- a/OpenCL/m90000_a0-pure.cl +++ b/OpenCL/m34200_a0-pure.cl @@ -67,7 +67,7 @@ DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u3 return hash; } -KERNEL_FQ KERNEL_FA void m90000_mxx (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m34200_mxx (KERN_ATTR_RULES ()) { /** * modifier @@ -114,7 +114,7 @@ KERNEL_FQ KERNEL_FA void m90000_mxx (KERN_ATTR_RULES ()) } } -KERNEL_FQ KERNEL_FA void m90000_sxx (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m34200_sxx (KERN_ATTR_RULES ()) { /** * modifier diff --git a/OpenCL/m90000_a1-optimized.cl b/OpenCL/m34200_a1-optimized.cl similarity index 95% rename from OpenCL/m90000_a1-optimized.cl rename to OpenCL/m34200_a1-optimized.cl index 405885110..46b9d4e3c 100755 --- a/OpenCL/m90000_a1-optimized.cl +++ b/OpenCL/m34200_a1-optimized.cl @@ -65,7 +65,7 @@ DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u3 return hash; } -KERNEL_FQ KERNEL_FA void m90000_m04 (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m34200_m04 (KERN_ATTR_BASIC ()) { /** * modifier @@ -183,15 +183,15 @@ KERNEL_FQ KERNEL_FA void m90000_m04 (KERN_ATTR_BASIC ()) } } -KERNEL_FQ KERNEL_FA void m90000_m08 (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m34200_m08 (KERN_ATTR_BASIC ()) { } -KERNEL_FQ KERNEL_FA void m90000_m16 (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m34200_m16 (KERN_ATTR_BASIC ()) { } -KERNEL_FQ KERNEL_FA void m90000_s04 (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m34200_s04 (KERN_ATTR_BASIC ()) { /** * modifier @@ -321,10 +321,10 @@ KERNEL_FQ KERNEL_FA void m90000_s04 (KERN_ATTR_BASIC ()) } } -KERNEL_FQ KERNEL_FA void m90000_s08 (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m34200_s08 (KERN_ATTR_BASIC ()) { } -KERNEL_FQ KERNEL_FA void m90000_s16 (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m34200_s16 (KERN_ATTR_BASIC ()) { } diff --git a/OpenCL/m90000_a1-pure.cl b/OpenCL/m34200_a1-pure.cl similarity index 97% rename from OpenCL/m90000_a1-pure.cl rename to OpenCL/m34200_a1-pure.cl index 1c86763fd..9a75e24da 100755 --- a/OpenCL/m90000_a1-pure.cl +++ b/OpenCL/m34200_a1-pure.cl @@ -65,7 +65,7 @@ DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u3 return hash; } -KERNEL_FQ KERNEL_FA void m90000_mxx (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m34200_mxx (KERN_ATTR_BASIC ()) { /** * modifier @@ -123,7 +123,7 @@ KERNEL_FQ KERNEL_FA void m90000_mxx (KERN_ATTR_BASIC ()) } } -KERNEL_FQ KERNEL_FA void m90000_sxx (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m34200_sxx (KERN_ATTR_BASIC ()) { /** * modifier diff --git a/OpenCL/m90000_a3-optimized.cl b/OpenCL/m34200_a3-optimized.cl similarity index 91% rename from OpenCL/m90000_a3-optimized.cl rename to OpenCL/m34200_a3-optimized.cl index 3edb18ef6..e90809b16 100755 --- a/OpenCL/m90000_a3-optimized.cl +++ b/OpenCL/m34200_a3-optimized.cl @@ -65,7 +65,7 @@ DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u3 return hash; } -DECLSPEC void m90000m (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_FUNC_VECTOR ()) +DECLSPEC void m34200m (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_FUNC_VECTOR ()) { /** * modifiers are taken from args @@ -127,7 +127,7 @@ DECLSPEC void m90000m (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F } } -DECLSPEC void m90000s (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_FUNC_VECTOR ()) +DECLSPEC void m34200s (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_FUNC_VECTOR ()) { /** * modifiers are taken from args @@ -201,7 +201,7 @@ DECLSPEC void m90000s (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F } } -KERNEL_FQ KERNEL_FA void m90000_m04 (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m34200_m04 (KERN_ATTR_VECTOR ()) { /** * base @@ -238,10 +238,10 @@ KERNEL_FQ KERNEL_FA void m90000_m04 (KERN_ATTR_VECTOR ()) * main */ - m90000m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); + m34200m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ KERNEL_FA void m90000_m08 (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m34200_m08 (KERN_ATTR_VECTOR ()) { /** * base @@ -278,10 +278,10 @@ KERNEL_FQ KERNEL_FA void m90000_m08 (KERN_ATTR_VECTOR ()) * main */ - m90000m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); + m34200m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ KERNEL_FA void m90000_m16 (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m34200_m16 (KERN_ATTR_VECTOR ()) { /** * base @@ -318,10 +318,10 @@ KERNEL_FQ KERNEL_FA void m90000_m16 (KERN_ATTR_VECTOR ()) * main */ - m90000m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); + m34200m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ KERNEL_FA void m90000_s04 (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m34200_s04 (KERN_ATTR_VECTOR ()) { /** * base @@ -358,10 +358,10 @@ KERNEL_FQ KERNEL_FA void m90000_s04 (KERN_ATTR_VECTOR ()) * main */ - m90000s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); + m34200s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ KERNEL_FA void m90000_s08 (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m34200_s08 (KERN_ATTR_VECTOR ()) { /** * base @@ -398,10 +398,10 @@ KERNEL_FQ KERNEL_FA void m90000_s08 (KERN_ATTR_VECTOR ()) * main */ - m90000s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); + m34200s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ KERNEL_FA void m90000_s16 (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m34200_s16 (KERN_ATTR_VECTOR ()) { /** * base @@ -438,5 +438,5 @@ KERNEL_FQ KERNEL_FA void m90000_s16 (KERN_ATTR_VECTOR ()) * main */ - m90000s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); + m34200s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } diff --git a/OpenCL/m90000_a3-pure.cl b/OpenCL/m34200_a3-pure.cl similarity index 96% rename from OpenCL/m90000_a3-pure.cl rename to OpenCL/m34200_a3-pure.cl index 6161762f6..4cc2400df 100755 --- a/OpenCL/m90000_a3-pure.cl +++ b/OpenCL/m34200_a3-pure.cl @@ -65,7 +65,7 @@ DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u3 return hash; } -KERNEL_FQ KERNEL_FA void m90000_mxx (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m34200_mxx (KERN_ATTR_VECTOR ()) { /** * modifier @@ -122,7 +122,7 @@ KERNEL_FQ KERNEL_FA void m90000_mxx (KERN_ATTR_VECTOR ()) } } -KERNEL_FQ KERNEL_FA void m90000_sxx (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m34200_sxx (KERN_ATTR_VECTOR ()) { /** * modifier diff --git a/OpenCL/m90010_a0-optimized.cl b/OpenCL/m34201_a0-optimized.cl similarity index 90% rename from OpenCL/m90010_a0-optimized.cl rename to OpenCL/m34201_a0-optimized.cl index 61585984d..74245f6b1 100755 --- a/OpenCL/m90010_a0-optimized.cl +++ b/OpenCL/m34201_a0-optimized.cl @@ -67,7 +67,7 @@ DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) return hash; } -KERNEL_FQ KERNEL_FA void m90010_m04 (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m34201_m04 (KERN_ATTR_RULES ()) { /** * modifier @@ -117,15 +117,15 @@ KERNEL_FQ KERNEL_FA void m90010_m04 (KERN_ATTR_RULES ()) } } -KERNEL_FQ KERNEL_FA void m90010_m08 (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m34201_m08 (KERN_ATTR_RULES ()) { } -KERNEL_FQ KERNEL_FA void m90010_m16 (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m34201_m16 (KERN_ATTR_RULES ()) { } -KERNEL_FQ KERNEL_FA void m90010_s04 (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m34201_s04 (KERN_ATTR_RULES ()) { /** * modifier @@ -187,10 +187,10 @@ KERNEL_FQ KERNEL_FA void m90010_s04 (KERN_ATTR_RULES ()) } } -KERNEL_FQ KERNEL_FA void m90010_s08 (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m34201_s08 (KERN_ATTR_RULES ()) { } -KERNEL_FQ KERNEL_FA void m90010_s16 (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m34201_s16 (KERN_ATTR_RULES ()) { } diff --git a/OpenCL/m90010_a0-pure.cl b/OpenCL/m34201_a0-pure.cl similarity index 95% rename from OpenCL/m90010_a0-pure.cl rename to OpenCL/m34201_a0-pure.cl index 8259e740a..805f22198 100755 --- a/OpenCL/m90010_a0-pure.cl +++ b/OpenCL/m34201_a0-pure.cl @@ -67,7 +67,7 @@ DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) return hash; } -KERNEL_FQ KERNEL_FA void m90010_mxx (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m34201_mxx (KERN_ATTR_RULES ()) { /** * modifier @@ -105,7 +105,7 @@ KERNEL_FQ KERNEL_FA void m90010_mxx (KERN_ATTR_RULES ()) } } -KERNEL_FQ KERNEL_FA void m90010_sxx (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m34201_sxx (KERN_ATTR_RULES ()) { /** * modifier diff --git a/OpenCL/m90010_a1-optimized.cl b/OpenCL/m34201_a1-optimized.cl similarity index 95% rename from OpenCL/m90010_a1-optimized.cl rename to OpenCL/m34201_a1-optimized.cl index 1eba4d2dd..c3337c057 100755 --- a/OpenCL/m90010_a1-optimized.cl +++ b/OpenCL/m34201_a1-optimized.cl @@ -65,7 +65,7 @@ DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) return hash; } -KERNEL_FQ KERNEL_FA void m90010_m04 (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m34201_m04 (KERN_ATTR_BASIC ()) { /** * modifier @@ -174,15 +174,15 @@ KERNEL_FQ KERNEL_FA void m90010_m04 (KERN_ATTR_BASIC ()) } } -KERNEL_FQ KERNEL_FA void m90010_m08 (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m34201_m08 (KERN_ATTR_BASIC ()) { } -KERNEL_FQ KERNEL_FA void m90010_m16 (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m34201_m16 (KERN_ATTR_BASIC ()) { } -KERNEL_FQ KERNEL_FA void m90010_s04 (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m34201_s04 (KERN_ATTR_BASIC ()) { /** * modifier @@ -303,10 +303,10 @@ KERNEL_FQ KERNEL_FA void m90010_s04 (KERN_ATTR_BASIC ()) } } -KERNEL_FQ KERNEL_FA void m90010_s08 (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m34201_s08 (KERN_ATTR_BASIC ()) { } -KERNEL_FQ KERNEL_FA void m90010_s16 (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m34201_s16 (KERN_ATTR_BASIC ()) { } diff --git a/OpenCL/m90010_a1-pure.cl b/OpenCL/m34201_a1-pure.cl similarity index 96% rename from OpenCL/m90010_a1-pure.cl rename to OpenCL/m34201_a1-pure.cl index 33ee4f66a..0daf17ec8 100755 --- a/OpenCL/m90010_a1-pure.cl +++ b/OpenCL/m34201_a1-pure.cl @@ -65,7 +65,7 @@ DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) return hash; } -KERNEL_FQ KERNEL_FA void m90010_mxx (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m34201_mxx (KERN_ATTR_BASIC ()) { /** * modifier @@ -114,7 +114,7 @@ KERNEL_FQ KERNEL_FA void m90010_mxx (KERN_ATTR_BASIC ()) } } -KERNEL_FQ KERNEL_FA void m90010_sxx (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m34201_sxx (KERN_ATTR_BASIC ()) { /** * modifier diff --git a/OpenCL/m90010_a3-optimized.cl b/OpenCL/m34201_a3-optimized.cl similarity index 90% rename from OpenCL/m90010_a3-optimized.cl rename to OpenCL/m34201_a3-optimized.cl index ed54415d6..b20404cdc 100755 --- a/OpenCL/m90010_a3-optimized.cl +++ b/OpenCL/m34201_a3-optimized.cl @@ -65,7 +65,7 @@ DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) return hash; } -DECLSPEC void m90010m (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_FUNC_VECTOR ()) +DECLSPEC void m34201m (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_FUNC_VECTOR ()) { /** * modifiers are taken from args @@ -118,7 +118,7 @@ DECLSPEC void m90010m (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F } } -DECLSPEC void m90010s (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_FUNC_VECTOR ()) +DECLSPEC void m34201s (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_FUNC_VECTOR ()) { /** * modifiers are taken from args @@ -183,7 +183,7 @@ DECLSPEC void m90010s (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F } } -KERNEL_FQ KERNEL_FA void m90010_m04 (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m34201_m04 (KERN_ATTR_VECTOR ()) { /** * base @@ -220,10 +220,10 @@ KERNEL_FQ KERNEL_FA void m90010_m04 (KERN_ATTR_VECTOR ()) * main */ - m90010m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); + m34201m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ KERNEL_FA void m90010_m08 (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m34201_m08 (KERN_ATTR_VECTOR ()) { /** * base @@ -260,10 +260,10 @@ KERNEL_FQ KERNEL_FA void m90010_m08 (KERN_ATTR_VECTOR ()) * main */ - m90010m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); + m34201m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ KERNEL_FA void m90010_m16 (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m34201_m16 (KERN_ATTR_VECTOR ()) { /** * base @@ -300,10 +300,10 @@ KERNEL_FQ KERNEL_FA void m90010_m16 (KERN_ATTR_VECTOR ()) * main */ - m90010m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); + m34201m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ KERNEL_FA void m90010_s04 (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m34201_s04 (KERN_ATTR_VECTOR ()) { /** * base @@ -340,10 +340,10 @@ KERNEL_FQ KERNEL_FA void m90010_s04 (KERN_ATTR_VECTOR ()) * main */ - m90010s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); + m34201s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ KERNEL_FA void m90010_s08 (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m34201_s08 (KERN_ATTR_VECTOR ()) { /** * base @@ -380,10 +380,10 @@ KERNEL_FQ KERNEL_FA void m90010_s08 (KERN_ATTR_VECTOR ()) * main */ - m90010s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); + m34201s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ KERNEL_FA void m90010_s16 (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m34201_s16 (KERN_ATTR_VECTOR ()) { /** * base @@ -420,5 +420,5 @@ KERNEL_FQ KERNEL_FA void m90010_s16 (KERN_ATTR_VECTOR ()) * main */ - m90010s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); + m34201s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } diff --git a/OpenCL/m90010_a3-pure.cl b/OpenCL/m34201_a3-pure.cl similarity index 96% rename from OpenCL/m90010_a3-pure.cl rename to OpenCL/m34201_a3-pure.cl index 6db8db29b..f08ec0cdb 100755 --- a/OpenCL/m90010_a3-pure.cl +++ b/OpenCL/m34201_a3-pure.cl @@ -65,7 +65,7 @@ DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) return hash; } -KERNEL_FQ KERNEL_FA void m90010_mxx (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m34201_mxx (KERN_ATTR_VECTOR ()) { /** * modifier @@ -113,7 +113,7 @@ KERNEL_FQ KERNEL_FA void m90010_mxx (KERN_ATTR_VECTOR ()) } } -KERNEL_FQ KERNEL_FA void m90010_sxx (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m34201_sxx (KERN_ATTR_VECTOR ()) { /** * modifier diff --git a/OpenCL/m90030_a0-optimized.cl b/OpenCL/m34211_a0-optimized.cl similarity index 90% rename from OpenCL/m90030_a0-optimized.cl rename to OpenCL/m34211_a0-optimized.cl index bfe1a3b7e..18342ac79 100755 --- a/OpenCL/m90030_a0-optimized.cl +++ b/OpenCL/m34211_a0-optimized.cl @@ -68,7 +68,7 @@ DECLSPEC u32 MurmurHash64A_truncated (PRIVATE_AS const u32 *data, const u32 len) return (u32) (hash >> 32); } -KERNEL_FQ KERNEL_FA void m90030_m04 (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m34211_m04 (KERN_ATTR_RULES ()) { /** * modifier @@ -116,15 +116,15 @@ KERNEL_FQ KERNEL_FA void m90030_m04 (KERN_ATTR_RULES ()) } } -KERNEL_FQ KERNEL_FA void m90030_m08 (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m34211_m08 (KERN_ATTR_RULES ()) { } -KERNEL_FQ KERNEL_FA void m90030_m16 (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m34211_m16 (KERN_ATTR_RULES ()) { } -KERNEL_FQ KERNEL_FA void m90030_s04 (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m34211_s04 (KERN_ATTR_RULES ()) { /** * modifier @@ -184,10 +184,10 @@ KERNEL_FQ KERNEL_FA void m90030_s04 (KERN_ATTR_RULES ()) } } -KERNEL_FQ KERNEL_FA void m90030_s08 (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m34211_s08 (KERN_ATTR_RULES ()) { } -KERNEL_FQ KERNEL_FA void m90030_s16 (KERN_ATTR_RULES ()) +KERNEL_FQ KERNEL_FA void m34211_s16 (KERN_ATTR_RULES ()) { } diff --git a/OpenCL/m90030_a1-optimized.cl b/OpenCL/m34211_a1-optimized.cl similarity index 95% rename from OpenCL/m90030_a1-optimized.cl rename to OpenCL/m34211_a1-optimized.cl index d1ea374c0..c1cf3f301 100755 --- a/OpenCL/m90030_a1-optimized.cl +++ b/OpenCL/m34211_a1-optimized.cl @@ -66,7 +66,7 @@ DECLSPEC u32 MurmurHash64A_truncated (PRIVATE_AS const u32 *data, const u32 len) return (u32) (hash >> 32); } -KERNEL_FQ KERNEL_FA void m90030_m04 (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m34211_m04 (KERN_ATTR_BASIC ()) { /** * modifier @@ -173,15 +173,15 @@ KERNEL_FQ KERNEL_FA void m90030_m04 (KERN_ATTR_BASIC ()) } } -KERNEL_FQ KERNEL_FA void m90030_m08 (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m34211_m08 (KERN_ATTR_BASIC ()) { } -KERNEL_FQ KERNEL_FA void m90030_m16 (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m34211_m16 (KERN_ATTR_BASIC ()) { } -KERNEL_FQ KERNEL_FA void m90030_s04 (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m34211_s04 (KERN_ATTR_BASIC ()) { /** * modifier @@ -300,10 +300,10 @@ KERNEL_FQ KERNEL_FA void m90030_s04 (KERN_ATTR_BASIC ()) } } -KERNEL_FQ KERNEL_FA void m90030_s08 (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m34211_s08 (KERN_ATTR_BASIC ()) { } -KERNEL_FQ KERNEL_FA void m90030_s16 (KERN_ATTR_BASIC ()) +KERNEL_FQ KERNEL_FA void m34211_s16 (KERN_ATTR_BASIC ()) { } diff --git a/OpenCL/m90030_a3-optimized.cl b/OpenCL/m34211_a3-optimized.cl similarity index 90% rename from OpenCL/m90030_a3-optimized.cl rename to OpenCL/m34211_a3-optimized.cl index d36ad3c93..44531d8c7 100755 --- a/OpenCL/m90030_a3-optimized.cl +++ b/OpenCL/m34211_a3-optimized.cl @@ -66,7 +66,7 @@ DECLSPEC u32 MurmurHash64A_truncated (PRIVATE_AS const u32 *data, const u32 len) return (u32) (hash >> 32); } -DECLSPEC void m90030m (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_FUNC_VECTOR ()) +DECLSPEC void m34211m (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_FUNC_VECTOR ()) { /** * modifiers are taken from args @@ -117,7 +117,7 @@ DECLSPEC void m90030m (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F } } -DECLSPEC void m90030s (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_FUNC_VECTOR ()) +DECLSPEC void m34211s (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_FUNC_VECTOR ()) { /** * modifiers are taken from args @@ -180,7 +180,7 @@ DECLSPEC void m90030s (PRIVATE_AS const u32 *data, const u32 pw_len, KERN_ATTR_F } } -KERNEL_FQ KERNEL_FA void m90030_m04 (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m34211_m04 (KERN_ATTR_VECTOR ()) { /** * base @@ -217,10 +217,10 @@ KERNEL_FQ KERNEL_FA void m90030_m04 (KERN_ATTR_VECTOR ()) * main */ - m90030m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); + m34211m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ KERNEL_FA void m90030_m08 (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m34211_m08 (KERN_ATTR_VECTOR ()) { /** * base @@ -257,10 +257,10 @@ KERNEL_FQ KERNEL_FA void m90030_m08 (KERN_ATTR_VECTOR ()) * main */ - m90030m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); + m34211m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ KERNEL_FA void m90030_m16 (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m34211_m16 (KERN_ATTR_VECTOR ()) { /** * base @@ -297,10 +297,10 @@ KERNEL_FQ KERNEL_FA void m90030_m16 (KERN_ATTR_VECTOR ()) * main */ - m90030m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); + m34211m (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ KERNEL_FA void m90030_s04 (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m34211_s04 (KERN_ATTR_VECTOR ()) { /** * base @@ -337,10 +337,10 @@ KERNEL_FQ KERNEL_FA void m90030_s04 (KERN_ATTR_VECTOR ()) * main */ - m90030s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); + m34211s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ KERNEL_FA void m90030_s08 (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m34211_s08 (KERN_ATTR_VECTOR ()) { /** * base @@ -377,10 +377,10 @@ KERNEL_FQ KERNEL_FA void m90030_s08 (KERN_ATTR_VECTOR ()) * main */ - m90030s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); + m34211s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } -KERNEL_FQ KERNEL_FA void m90030_s16 (KERN_ATTR_VECTOR ()) +KERNEL_FQ KERNEL_FA void m34211_s16 (KERN_ATTR_VECTOR ()) { /** * base @@ -417,5 +417,5 @@ KERNEL_FQ KERNEL_FA void m90030_s16 (KERN_ATTR_VECTOR ()) * main */ - m90030s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); + m34211s (w, pw_len, pws, rules_buf, combs_buf, words_buf_r, tmps, hooks, bitmaps_buf_s1_a, bitmaps_buf_s1_b, bitmaps_buf_s1_c, bitmaps_buf_s1_d, bitmaps_buf_s2_a, bitmaps_buf_s2_b, bitmaps_buf_s2_c, bitmaps_buf_s2_d, plains_buf, digests_buf, hashes_shown, salt_bufs, esalt_bufs, d_return_buf, d_extra0_buf, d_extra1_buf, d_extra2_buf, d_extra3_buf, kernel_param, gid, lid, lsz); } diff --git a/src/modules/module_90000.c b/src/modules/module_34200.c similarity index 99% rename from src/modules/module_90000.c rename to src/modules/module_34200.c index db20ffc15..a9883e8ae 100755 --- a/src/modules/module_90000.c +++ b/src/modules/module_34200.c @@ -18,7 +18,7 @@ static const u32 DGST_POS3 = 3; static const u32 DGST_SIZE = DGST_SIZE_8_2; static const u32 HASH_CATEGORY = HASH_CATEGORY_RAW_CHECKSUM; static const char *HASH_NAME = "MurmurHash64A"; -static const u64 KERN_TYPE = 90000; +static const u64 KERN_TYPE = 34200; static const u32 OPTI_TYPE = OPTI_TYPE_ZERO_BYTE | OPTI_TYPE_USES_BITS_64 | OPTI_TYPE_NOT_ITERATED; diff --git a/src/modules/module_90010.c b/src/modules/module_34201.c similarity index 99% rename from src/modules/module_90010.c rename to src/modules/module_34201.c index 9bce40591..bd6dcb24a 100755 --- a/src/modules/module_90010.c +++ b/src/modules/module_34201.c @@ -18,7 +18,7 @@ static const u32 DGST_POS3 = 3; static const u32 DGST_SIZE = DGST_SIZE_8_2; static const u32 HASH_CATEGORY = HASH_CATEGORY_RAW_HASH; static const char *HASH_NAME = "MurmurHash64A (zero seed)"; -static const u64 KERN_TYPE = 90010; +static const u64 KERN_TYPE = 34201; static const u32 OPTI_TYPE = OPTI_TYPE_ZERO_BYTE | OPTI_TYPE_USES_BITS_64 | OPTI_TYPE_NOT_ITERATED diff --git a/src/modules/module_90030.c b/src/modules/module_34211.c similarity index 99% rename from src/modules/module_90030.c rename to src/modules/module_34211.c index c6ef5646c..e3bc94a54 100755 --- a/src/modules/module_90030.c +++ b/src/modules/module_34211.c @@ -18,7 +18,7 @@ static const u32 DGST_POS3 = 3; static const u32 DGST_SIZE = DGST_SIZE_4_4; static const u32 HASH_CATEGORY = HASH_CATEGORY_RAW_HASH; static const char *HASH_NAME = "MurmurHash64A truncated (zero seed)"; -static const u64 KERN_TYPE = 90030; +static const u64 KERN_TYPE = 34211; static const u32 OPTI_TYPE = OPTI_TYPE_ZERO_BYTE | OPTI_TYPE_USES_BITS_64 | OPTI_TYPE_NOT_ITERATED diff --git a/tools/test_modules/m90000.pm b/tools/test_modules/m34200.pm similarity index 100% rename from tools/test_modules/m90000.pm rename to tools/test_modules/m34200.pm diff --git a/tools/test_modules/m90010.pm b/tools/test_modules/m34201.pm similarity index 96% rename from tools/test_modules/m90010.pm rename to tools/test_modules/m34201.pm index b093a4efd..218466450 100755 --- a/tools/test_modules/m90010.pm +++ b/tools/test_modules/m34201.pm @@ -25,12 +25,12 @@ sub wrapping_mul my $m = Math::BigInt->new("0xc6a4a7935bd1e995"); my $r = 47; -sub murmurhash64a +sub murmurhash64a_zero_seed { use integer; my $word = shift; - my $seed = shift; + my $seed = 0; my @chars = unpack ("C*", $word); my $len = length $word; @@ -115,7 +115,7 @@ sub module_generate_hash { my $word = shift; - my $digest = murmurhash64a ($word); + my $digest = murmurhash64a_zero_seed ($word); $digest = unpack ("H*", pack ("Q>", $digest)); diff --git a/tools/test_modules/m90030.pm b/tools/test_modules/m34211.pm similarity index 95% rename from tools/test_modules/m90030.pm rename to tools/test_modules/m34211.pm index e14d2401d..78bbec496 100755 --- a/tools/test_modules/m90030.pm +++ b/tools/test_modules/m34211.pm @@ -25,12 +25,12 @@ sub wrapping_mul my $m = Math::BigInt->new("0xc6a4a7935bd1e995"); my $r = 47; -sub murmurhash64a_32 +sub murmurhash64a_truncated_zero_seed { use integer; my $word = shift; - my $seed = shift; + my $seed = 0; my @chars = unpack ("C*", $word); my $len = length $word; @@ -118,7 +118,7 @@ sub module_generate_hash { my $word = shift; - my $digest = murmurhash64a_32 ($word); + my $digest = murmurhash64a_truncated_zero_seed ($word); $digest = unpack ("H*", pack ("L>", $digest)); From 1bd68a5a80dbe745f42660d876d4db11b5841da0 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Wed, 23 Jul 2025 14:57:34 +1000 Subject: [PATCH 54/61] Styling changes --- OpenCL/m34200_a0-optimized.cl | 10 +++++----- OpenCL/m34200_a0-pure.cl | 10 +++++----- OpenCL/m34200_a1-optimized.cl | 10 +++++----- OpenCL/m34200_a1-pure.cl | 18 +++++++++--------- OpenCL/m34200_a3-optimized.cl | 12 ++++++------ OpenCL/m34200_a3-pure.cl | 10 +++++----- OpenCL/m34201_a0-optimized.cl | 10 +++++----- OpenCL/m34201_a0-pure.cl | 10 +++++----- OpenCL/m34201_a1-optimized.cl | 2 +- OpenCL/m34201_a1-pure.cl | 14 +++++++------- OpenCL/m34201_a3-optimized.cl | 12 ++++++------ OpenCL/m34201_a3-pure.cl | 10 +++++----- OpenCL/m34211_a0-optimized.cl | 10 +++++----- OpenCL/m34211_a1-optimized.cl | 10 +++++----- OpenCL/m34211_a3-optimized.cl | 10 +++++----- tools/test_modules/m34200.pm | 6 +++--- tools/test_modules/m34201.pm | 6 +++--- tools/test_modules/m34211.pm | 6 +++--- 18 files changed, 88 insertions(+), 88 deletions(-) diff --git a/OpenCL/m34200_a0-optimized.cl b/OpenCL/m34200_a0-optimized.cl index 82448631c..4e9486a03 100755 --- a/OpenCL/m34200_a0-optimized.cl +++ b/OpenCL/m34200_a0-optimized.cl @@ -17,10 +17,10 @@ DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u32 len) { - #define M 0xc6a4a7935bd1e995 - #define R 47 +#define M 0xc6a4a7935bd1e995 +#define R 47 - //Initialize hash + // Initialize hash u64 hash = seed ^ (len * M); // Twice the number of u64 blocks @@ -61,8 +61,8 @@ DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u3 hash *= M; hash ^= hash >> R; - #undef M - #undef R +#undef M +#undef R return hash; } diff --git a/OpenCL/m34200_a0-pure.cl b/OpenCL/m34200_a0-pure.cl index 7a820464d..67976dfad 100755 --- a/OpenCL/m34200_a0-pure.cl +++ b/OpenCL/m34200_a0-pure.cl @@ -17,10 +17,10 @@ DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u32 len) { - #define M 0xc6a4a7935bd1e995 - #define R 47 +#define M 0xc6a4a7935bd1e995 +#define R 47 - //Initialize hash + // Initialize hash u64 hash = seed ^ (len * M); // Twice the number of u64 blocks @@ -61,8 +61,8 @@ DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u3 hash *= M; hash ^= hash >> R; - #undef M - #undef R +#undef M +#undef R return hash; } diff --git a/OpenCL/m34200_a1-optimized.cl b/OpenCL/m34200_a1-optimized.cl index 46b9d4e3c..bc262f8b1 100755 --- a/OpenCL/m34200_a1-optimized.cl +++ b/OpenCL/m34200_a1-optimized.cl @@ -15,10 +15,10 @@ DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u32 len) { - #define M 0xc6a4a7935bd1e995 - #define R 47 +#define M 0xc6a4a7935bd1e995 +#define R 47 - //Initialize hash + // Initialize hash u64 hash = seed ^ (len * M); // Twice the number of u64 blocks @@ -59,8 +59,8 @@ DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u3 hash *= M; hash ^= hash >> R; - #undef M - #undef R +#undef M +#undef R return hash; } diff --git a/OpenCL/m34200_a1-pure.cl b/OpenCL/m34200_a1-pure.cl index 9a75e24da..5dff43865 100755 --- a/OpenCL/m34200_a1-pure.cl +++ b/OpenCL/m34200_a1-pure.cl @@ -15,10 +15,10 @@ DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u32 len) { - #define M 0xc6a4a7935bd1e995 - #define R 47 +#define M 0xc6a4a7935bd1e995 +#define R 47 - //Initialize hash + // Initialize hash u64 hash = seed ^ (len * M); // Twice the number of u64 blocks @@ -59,8 +59,8 @@ DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u3 hash *= M; hash ^= hash >> R; - #undef M - #undef R +#undef M +#undef R return hash; } @@ -75,7 +75,7 @@ KERNEL_FQ KERNEL_FA void m34200_mxx (KERN_ATTR_BASIC ()) const u64 gid = get_global_id (0); if (gid >= GID_CNT) return; - + /** * base */ @@ -99,7 +99,7 @@ KERNEL_FQ KERNEL_FA void m34200_mxx (KERN_ATTR_BASIC ()) const u32 seed_lo = salt_bufs[SALT_POS_HOST].salt_buf[0]; const u32 seed_hi = salt_bufs[SALT_POS_HOST].salt_buf[1]; const u64 seed = hl32_to_64 (seed_hi, seed_lo); - + /** * loop */ @@ -137,7 +137,7 @@ KERNEL_FQ KERNEL_FA void m34200_sxx (KERN_ATTR_BASIC ()) /** * base */ - + PRIVATE_AS u8 combined_buf[256] = {0}; const u32 *comb_ptr = (u32*) combined_buf; @@ -148,7 +148,7 @@ KERNEL_FQ KERNEL_FA void m34200_sxx (KERN_ATTR_BASIC ()) { combined_buf[i] = left[i]; } - + /** * salt */ diff --git a/OpenCL/m34200_a3-optimized.cl b/OpenCL/m34200_a3-optimized.cl index e90809b16..8b311bc3c 100755 --- a/OpenCL/m34200_a3-optimized.cl +++ b/OpenCL/m34200_a3-optimized.cl @@ -15,10 +15,10 @@ DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u32 len) { - #define M 0xc6a4a7935bd1e995 - #define R 47 +#define M 0xc6a4a7935bd1e995 +#define R 47 - //Initialize hash + // Initialize hash u64 hash = seed ^ (len * M); // Twice the number of u64 blocks @@ -59,8 +59,8 @@ DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u3 hash *= M; hash ^= hash >> R; - #undef M - #undef R +#undef M +#undef R return hash; } @@ -246,7 +246,7 @@ KERNEL_FQ KERNEL_FA void m34200_m08 (KERN_ATTR_VECTOR ()) /** * base */ - + const u64 lid = get_local_id (0); const u64 gid = get_global_id (0); const u64 lsz = get_local_size (0); diff --git a/OpenCL/m34200_a3-pure.cl b/OpenCL/m34200_a3-pure.cl index 4cc2400df..a8b71adba 100755 --- a/OpenCL/m34200_a3-pure.cl +++ b/OpenCL/m34200_a3-pure.cl @@ -15,10 +15,10 @@ DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u32 len) { - #define M 0xc6a4a7935bd1e995 - #define R 47 +#define M 0xc6a4a7935bd1e995 +#define R 47 - //Initialize hash + // Initialize hash u64 hash = seed ^ (len * M); // Twice the number of u64 blocks @@ -59,8 +59,8 @@ DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u3 hash *= M; hash ^= hash >> R; - #undef M - #undef R +#undef M +#undef R return hash; } diff --git a/OpenCL/m34201_a0-optimized.cl b/OpenCL/m34201_a0-optimized.cl index 74245f6b1..a587ab308 100755 --- a/OpenCL/m34201_a0-optimized.cl +++ b/OpenCL/m34201_a0-optimized.cl @@ -17,10 +17,10 @@ DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) { - #define M 0xc6a4a7935bd1e995 - #define R 47 +#define M 0xc6a4a7935bd1e995 +#define R 47 - //Initialize hash + // Initialize hash u64 hash = len * M; // Twice the number of u64 blocks @@ -61,8 +61,8 @@ DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) hash *= M; hash ^= hash >> R; - #undef M - #undef R +#undef M +#undef R return hash; } diff --git a/OpenCL/m34201_a0-pure.cl b/OpenCL/m34201_a0-pure.cl index 805f22198..4ebec52d5 100755 --- a/OpenCL/m34201_a0-pure.cl +++ b/OpenCL/m34201_a0-pure.cl @@ -17,10 +17,10 @@ DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) { - #define M 0xc6a4a7935bd1e995 - #define R 47 +#define M 0xc6a4a7935bd1e995 +#define R 47 - //Initialize hash + // Initialize hash u64 hash = len * M; // Twice the number of u64 blocks @@ -61,8 +61,8 @@ DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) hash *= M; hash ^= hash >> R; - #undef M - #undef R +#undef M +#undef R return hash; } diff --git a/OpenCL/m34201_a1-optimized.cl b/OpenCL/m34201_a1-optimized.cl index c3337c057..20c2ab7b9 100755 --- a/OpenCL/m34201_a1-optimized.cl +++ b/OpenCL/m34201_a1-optimized.cl @@ -18,7 +18,7 @@ DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) #define M 0xc6a4a7935bd1e995 #define R 47 - //Initialize hash + // Initialize hash u64 hash = len * M; // Twice the number of u64 blocks diff --git a/OpenCL/m34201_a1-pure.cl b/OpenCL/m34201_a1-pure.cl index 0daf17ec8..53260346e 100755 --- a/OpenCL/m34201_a1-pure.cl +++ b/OpenCL/m34201_a1-pure.cl @@ -15,10 +15,10 @@ DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) { - #define M 0xc6a4a7935bd1e995 - #define R 47 +#define M 0xc6a4a7935bd1e995 +#define R 47 - //Initialize hash + // Initialize hash u64 hash = len * M; // Twice the number of u64 blocks @@ -59,8 +59,8 @@ DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) hash *= M; hash ^= hash >> R; - #undef M - #undef R +#undef M +#undef R return hash; } @@ -75,7 +75,7 @@ KERNEL_FQ KERNEL_FA void m34201_mxx (KERN_ATTR_BASIC ()) const u64 gid = get_global_id (0); if (gid >= GID_CNT) return; - + /** * base */ @@ -128,7 +128,7 @@ KERNEL_FQ KERNEL_FA void m34201_sxx (KERN_ATTR_BASIC ()) /** * base */ - + PRIVATE_AS u8 combined_buf[256] = {0}; const u32 *comb_ptr = (u32*) combined_buf; diff --git a/OpenCL/m34201_a3-optimized.cl b/OpenCL/m34201_a3-optimized.cl index b20404cdc..ab844377f 100755 --- a/OpenCL/m34201_a3-optimized.cl +++ b/OpenCL/m34201_a3-optimized.cl @@ -15,10 +15,10 @@ DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) { - #define M 0xc6a4a7935bd1e995 - #define R 47 +#define M 0xc6a4a7935bd1e995 +#define R 47 - //Initialize hash + // Initialize hash u64 hash = len * M; // Twice the number of u64 blocks @@ -59,8 +59,8 @@ DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) hash *= M; hash ^= hash >> R; - #undef M - #undef R +#undef M +#undef R return hash; } @@ -413,7 +413,7 @@ KERNEL_FQ KERNEL_FA void m34201_s16 (KERN_ATTR_VECTOR ()) w[13] = pws[gid].i[13]; w[14] = pws[gid].i[14]; w[15] = pws[gid].i[15]; - + const u32 pw_len = pws[gid].pw_len & 63; /** diff --git a/OpenCL/m34201_a3-pure.cl b/OpenCL/m34201_a3-pure.cl index f08ec0cdb..35281b8c4 100755 --- a/OpenCL/m34201_a3-pure.cl +++ b/OpenCL/m34201_a3-pure.cl @@ -15,10 +15,10 @@ DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) { - #define M 0xc6a4a7935bd1e995 - #define R 47 +#define M 0xc6a4a7935bd1e995 +#define R 47 - //Initialize hash + // Initialize hash u64 hash = len * M; // Twice the number of u64 blocks @@ -59,8 +59,8 @@ DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) hash *= M; hash ^= hash >> R; - #undef M - #undef R +#undef M +#undef R return hash; } diff --git a/OpenCL/m34211_a0-optimized.cl b/OpenCL/m34211_a0-optimized.cl index 18342ac79..ec3aa0c6c 100755 --- a/OpenCL/m34211_a0-optimized.cl +++ b/OpenCL/m34211_a0-optimized.cl @@ -17,10 +17,10 @@ DECLSPEC u32 MurmurHash64A_truncated (PRIVATE_AS const u32 *data, const u32 len) { - #define M 0xc6a4a7935bd1e995 - #define R 47 +#define M 0xc6a4a7935bd1e995 +#define R 47 - //Initialize hash + // Initialize hash u64 hash = len * M; // Twice the number of u64 blocks @@ -61,8 +61,8 @@ DECLSPEC u32 MurmurHash64A_truncated (PRIVATE_AS const u32 *data, const u32 len) hash *= M; hash ^= hash >> R; - #undef M - #undef R +#undef M +#undef R // Truncate to high 4 bytes return (u32) (hash >> 32); diff --git a/OpenCL/m34211_a1-optimized.cl b/OpenCL/m34211_a1-optimized.cl index c1cf3f301..b8c34d4c7 100755 --- a/OpenCL/m34211_a1-optimized.cl +++ b/OpenCL/m34211_a1-optimized.cl @@ -15,10 +15,10 @@ DECLSPEC u32 MurmurHash64A_truncated (PRIVATE_AS const u32 *data, const u32 len) { - #define M 0xc6a4a7935bd1e995 - #define R 47 +#define M 0xc6a4a7935bd1e995 +#define R 47 - //Initialize hash + // Initialize hash u64 hash = len * M; // Twice the number of u64 blocks @@ -59,8 +59,8 @@ DECLSPEC u32 MurmurHash64A_truncated (PRIVATE_AS const u32 *data, const u32 len) hash *= M; hash ^= hash >> R; - #undef M - #undef R +#undef M +#undef R // Truncate to high 4 bytes return (u32) (hash >> 32); diff --git a/OpenCL/m34211_a3-optimized.cl b/OpenCL/m34211_a3-optimized.cl index 44531d8c7..273596113 100755 --- a/OpenCL/m34211_a3-optimized.cl +++ b/OpenCL/m34211_a3-optimized.cl @@ -15,10 +15,10 @@ DECLSPEC u32 MurmurHash64A_truncated (PRIVATE_AS const u32 *data, const u32 len) { - #define M 0xc6a4a7935bd1e995 - #define R 47 +#define M 0xc6a4a7935bd1e995 +#define R 47 - //Initialize hash + // Initialize hash u64 hash = len * M; // Twice the number of u64 blocks @@ -59,8 +59,8 @@ DECLSPEC u32 MurmurHash64A_truncated (PRIVATE_AS const u32 *data, const u32 len) hash *= M; hash ^= hash >> R; - #undef M - #undef R +#undef M +#undef R // Truncate to high 4 bytes return (u32) (hash >> 32); diff --git a/tools/test_modules/m34200.pm b/tools/test_modules/m34200.pm index e9759d155..0415ee33c 100755 --- a/tools/test_modules/m34200.pm +++ b/tools/test_modules/m34200.pm @@ -11,7 +11,7 @@ use Math::BigInt; sub module_constraints { [[0, 256], [16, 16], [0, 63], [16, 16], [-1, -1]] } -my $u64_width = Math::BigInt->new("0x10000000000000000"); # 2**64 +my $u64_width = Math::BigInt->new ("0x10000000000000000"); # 2**64 # Ensure that uint64 integer overflow is replicated correctly sub wrapping_mul @@ -19,10 +19,10 @@ sub wrapping_mul my $a = shift; my $b = shift; - return ($a * $b)->bmod($u64_width); + return ($a * $b)->bmod ($u64_width); } -my $m = Math::BigInt->new("0xc6a4a7935bd1e995"); +my $m = Math::BigInt->new ("0xc6a4a7935bd1e995"); my $r = 47; sub murmurhash64a diff --git a/tools/test_modules/m34201.pm b/tools/test_modules/m34201.pm index 218466450..5ef460557 100755 --- a/tools/test_modules/m34201.pm +++ b/tools/test_modules/m34201.pm @@ -11,7 +11,7 @@ use Math::BigInt; sub module_constraints { [[0, 256], [-1, -1], [0, 63], [-1, -1], [0, 63]] } -my $u64_width = Math::BigInt->new("0x10000000000000000"); # 2**64 +my $u64_width = Math::BigInt->new ("0x10000000000000000"); # 2**64 # Ensure that uint64 integer overflow is replicated correctly sub wrapping_mul @@ -19,10 +19,10 @@ sub wrapping_mul my $a = shift; my $b = shift; - return ($a * $b)->bmod($u64_width); + return ($a * $b)->bmod ($u64_width); } -my $m = Math::BigInt->new("0xc6a4a7935bd1e995"); +my $m = Math::BigInt->new ("0xc6a4a7935bd1e995"); my $r = 47; sub murmurhash64a_zero_seed diff --git a/tools/test_modules/m34211.pm b/tools/test_modules/m34211.pm index 78bbec496..4cbea3090 100755 --- a/tools/test_modules/m34211.pm +++ b/tools/test_modules/m34211.pm @@ -11,7 +11,7 @@ use Math::BigInt; sub module_constraints { [[0, 256], [-1, -1], [0, 32], [-1, -1], [0, 32]] } -my $u64_width = Math::BigInt->new("0x10000000000000000"); # 2**64 +my $u64_width = Math::BigInt->new ("0x10000000000000000"); # 2**64 # Ensure that uint64 integer overflow is replicated correctly sub wrapping_mul @@ -19,10 +19,10 @@ sub wrapping_mul my $a = shift; my $b = shift; - return ($a * $b)->bmod($u64_width); + return ($a * $b)->bmod ($u64_width); } -my $m = Math::BigInt->new("0xc6a4a7935bd1e995"); +my $m = Math::BigInt->new ("0xc6a4a7935bd1e995"); my $r = 47; sub murmurhash64a_truncated_zero_seed From f583bbf5747f802882cd0f03d986f817e0337a06 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Wed, 23 Jul 2025 19:32:26 +1000 Subject: [PATCH 55/61] Fix pw len variable names --- OpenCL/m34201_a1-optimized.cl | 4 ++-- OpenCL/m34211_a1-optimized.cl | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/OpenCL/m34201_a1-optimized.cl b/OpenCL/m34201_a1-optimized.cl index 20c2ab7b9..04c140deb 100755 --- a/OpenCL/m34201_a1-optimized.cl +++ b/OpenCL/m34201_a1-optimized.cl @@ -92,7 +92,7 @@ KERNEL_FQ KERNEL_FA void m34201_m04 (KERN_ATTR_BASIC ()) pw_buf1[2] = pws[gid].i[6]; pw_buf1[3] = pws[gid].i[7]; - const u32 pw_len = pws[gid].pw_len & 63; + const u32 pw_l_len = pws[gid].pw_len & 63; /** * loop @@ -209,7 +209,7 @@ KERNEL_FQ KERNEL_FA void m34201_s04 (KERN_ATTR_BASIC ()) pw_buf1[2] = pws[gid].i[6]; pw_buf1[3] = pws[gid].i[7]; - const u32 pw_len = pws[gid].pw_len & 63; + const u32 pw_l_len = pws[gid].pw_len & 63; /** * digest diff --git a/OpenCL/m34211_a1-optimized.cl b/OpenCL/m34211_a1-optimized.cl index b8c34d4c7..2a309ca19 100755 --- a/OpenCL/m34211_a1-optimized.cl +++ b/OpenCL/m34211_a1-optimized.cl @@ -93,7 +93,7 @@ KERNEL_FQ KERNEL_FA void m34211_m04 (KERN_ATTR_BASIC ()) pw_buf1[2] = pws[gid].i[6]; pw_buf1[3] = pws[gid].i[7]; - const u32 pw_len = pws[gid].pw_len & 63; + const u32 pw_l_len = pws[gid].pw_len & 63; /** * loop @@ -208,7 +208,7 @@ KERNEL_FQ KERNEL_FA void m34211_s04 (KERN_ATTR_BASIC ()) pw_buf1[2] = pws[gid].i[6]; pw_buf1[3] = pws[gid].i[7]; - const u32 pw_len = pws[gid].pw_len & 63; + const u32 pw_l_len = pws[gid].pw_len & 63; /** * digest From 4d27a0a6d8deadb6c36f2e7e89ed306c374abece Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Fri, 25 Jul 2025 14:01:55 +1000 Subject: [PATCH 56/61] Add pure kernels for 34211 --- OpenCL/m34211_a0-pure.cl | 157 +++++++++++++++++++++++++++++++++++ OpenCL/m34211_a1-pure.cl | 173 +++++++++++++++++++++++++++++++++++++++ OpenCL/m34211_a3-pure.cl | 171 ++++++++++++++++++++++++++++++++++++++ 3 files changed, 501 insertions(+) create mode 100755 OpenCL/m34211_a0-pure.cl create mode 100755 OpenCL/m34211_a1-pure.cl create mode 100755 OpenCL/m34211_a3-pure.cl diff --git a/OpenCL/m34211_a0-pure.cl b/OpenCL/m34211_a0-pure.cl new file mode 100755 index 000000000..f36d8e393 --- /dev/null +++ b/OpenCL/m34211_a0-pure.cl @@ -0,0 +1,157 @@ +/** + * Author......: See docs/credits.txt + * License.....: MIT + */ + +//#define NEW_SIMD_CODE + +#ifdef KERNEL_STATIC +#include M2S(INCLUDE_PATH/inc_vendor.h) +#include M2S(INCLUDE_PATH/inc_types.h) +#include M2S(INCLUDE_PATH/inc_platform.cl) +#include M2S(INCLUDE_PATH/inc_common.cl) +#include M2S(INCLUDE_PATH/inc_rp.h) +#include M2S(INCLUDE_PATH/inc_rp.cl) +#include M2S(INCLUDE_PATH/inc_scalar.cl) +#endif + +DECLSPEC u32 MurmurHash64A_truncated (PRIVATE_AS const u32 *data, const u32 len) +{ +#define M 0xc6a4a7935bd1e995 +#define R 47 + + // Initialize hash + u64 hash = len * M; + + // Twice the number of u64 blocks + const u32 num_u32_blocks = (len / 8) * 2; + + // Loop over one u64 at a time + u32 i = 0; + while (i < num_u32_blocks) + { + // Reconstruct u64 from two u32s + u64 k = hl32_to_64 (data[i + 1], data[i]); + + k *= M; + k ^= k >> R; + k *= M; + + hash ^= k; + hash *= M; + + i += 2; + } + + // Up to 7 overflow bytes + const u32 overflow = len & 7; + + if (overflow > 4) + { + hash ^= hl32_to_64 (data[i + 1], data[i]); + hash *= M; + } + else if (overflow > 0) + { + hash ^= hl32_to_64 (0, data[i]); + hash *= M; + } + + hash ^= hash >> R; + hash *= M; + hash ^= hash >> R; + +#undef M +#undef R + + // Truncate to high 4 bytes + return (u32) (hash >> 32); +} + +KERNEL_FQ KERNEL_FA void m34211_mxx (KERN_ATTR_RULES ()) +{ + /** + * modifier + */ + + const u64 lid = get_local_id (0); + + /** + * base + */ + + const u64 gid = get_global_id (0); + + if (gid >= GID_CNT) return; + + COPY_PW (pws[gid]); + + /** + * loop + */ + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos++) + { + pw_t tmp = PASTE_PW; + + tmp.pw_len = apply_rules (rules_buf[il_pos].cmds, tmp.i, tmp.pw_len); + + u32 hash = MurmurHash64A_truncated (tmp.i, tmp.pw_len); + + const u32 z = 0; + + COMPARE_M_SCALAR (hash, z, z, z); + } +} + +KERNEL_FQ KERNEL_FA void m34211_sxx (KERN_ATTR_RULES ()) +{ + /** + * modifier + */ + + const u64 lid = get_local_id (0); + + /** + * base + */ + + const u64 gid = get_global_id (0); + + if (gid >= GID_CNT) return; + + /** + * digest + */ + + const u32 search[4] = + { + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R0], + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R1], + 0, + 0 + }; + + /** + * base + */ + + COPY_PW (pws[gid]); + + /** + * loop + */ + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos++) + { + pw_t tmp = PASTE_PW; + + tmp.pw_len = apply_rules (rules_buf[il_pos].cmds, tmp.i, tmp.pw_len); + + u32 hash = MurmurHash64A_truncated (tmp.i, tmp.pw_len); + + const u32 z = 0; + + COMPARE_S_SCALAR (hash, z, z, z); + } +} diff --git a/OpenCL/m34211_a1-pure.cl b/OpenCL/m34211_a1-pure.cl new file mode 100755 index 000000000..bd53d64ee --- /dev/null +++ b/OpenCL/m34211_a1-pure.cl @@ -0,0 +1,173 @@ +/** + * Author......: See docs/credits.txt + * License.....: MIT + */ + +//#define NEW_SIMD_CODE + +#ifdef KERNEL_STATIC +#include M2S(INCLUDE_PATH/inc_vendor.h) +#include M2S(INCLUDE_PATH/inc_types.h) +#include M2S(INCLUDE_PATH/inc_platform.cl) +#include M2S(INCLUDE_PATH/inc_common.cl) +#include M2S(INCLUDE_PATH/inc_scalar.cl) +#endif + +DECLSPEC u32 MurmurHash64A_truncated (PRIVATE_AS const u32 *data, const u32 len) +{ +#define M 0xc6a4a7935bd1e995 +#define R 47 + + // Initialize hash + u64 hash = len * M; + + // Twice the number of u64 blocks + const u32 num_u32_blocks = (len / 8) * 2; + + // Loop over one u64 at a time + u32 i = 0; + while (i < num_u32_blocks) + { + // Reconstruct u64 from two u32s + u64 k = hl32_to_64 (data[i + 1], data[i]); + + k *= M; + k ^= k >> R; + k *= M; + + hash ^= k; + hash *= M; + + i += 2; + } + + // Up to 7 overflow bytes + const u32 overflow = len & 7; + + if (overflow > 4) + { + hash ^= hl32_to_64 (data[i + 1], data[i]); + hash *= M; + } + else if (overflow > 0) + { + hash ^= hl32_to_64 (0, data[i]); + hash *= M; + } + + hash ^= hash >> R; + hash *= M; + hash ^= hash >> R; + +#undef M +#undef R + + // Truncate to high 4 bytes + return (u32) (hash >> 32); +} + +KERNEL_FQ KERNEL_FA void m34211_mxx (KERN_ATTR_BASIC ()) +{ + /** + * modifier + */ + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + + if (gid >= GID_CNT) return; + + /** + * base + */ + + PRIVATE_AS u8 combined_buf[256] = {0}; + const u32 *comb_ptr = (u32*) combined_buf; + + // copy left buffer + GLOBAL_AS const u8 *left = (GLOBAL_AS const u8*) pws[gid].i; + // probably bad for performance + for (u32 i = 0; i < pws[gid].pw_len; i++) + { + combined_buf[i] = left[i]; + } + + /** + * loop + */ + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos++) + { + // copy right buffer + GLOBAL_AS const u8 *right = (GLOBAL_AS const u8*) combs_buf[il_pos].i; + for (u32 i = 0; i < combs_buf[il_pos].pw_len; i++) + { + combined_buf[i + pws[gid].pw_len] = right[i]; + } + + u32 hash = MurmurHash64A_truncated (comb_ptr, pws[gid].pw_len + combs_buf[il_pos].pw_len); + + const u32 z = 0; + + COMPARE_M_SCALAR (hash, z, z, z); + } +} + +KERNEL_FQ KERNEL_FA void m34211_sxx (KERN_ATTR_BASIC ()) +{ + /** + * modifier + */ + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + + if (gid >= GID_CNT) return; + + /** + * base + */ + + PRIVATE_AS u8 combined_buf[256] = {0}; + const u32 *comb_ptr = (u32*) combined_buf; + + // copy left buffer + GLOBAL_AS const u8 *left = (GLOBAL_AS const u8*) pws[gid].i; + // probably bad for performance + for (u32 i = 0; i < pws[gid].pw_len; i++) + { + combined_buf[i] = left[i]; + } + + /** + * digest + */ + + const u32 search[4] = + { + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R0], + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R1], + 0, + 0 + }; + + /** + * loop + */ + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos++) + { + // copy right buffer + GLOBAL_AS const u8 *right = (GLOBAL_AS const u8*) combs_buf[il_pos].i; + for (u32 i = 0; i < combs_buf[il_pos].pw_len; i++) + { + combined_buf[i + pws[gid].pw_len] = right[i]; + } + + u32 hash = MurmurHash64A_truncated (comb_ptr, pws[gid].pw_len + combs_buf[il_pos].pw_len); + + const u32 z = 0; + + COMPARE_S_SCALAR (hash, z, z, z); + } +} diff --git a/OpenCL/m34211_a3-pure.cl b/OpenCL/m34211_a3-pure.cl new file mode 100755 index 000000000..bb846f189 --- /dev/null +++ b/OpenCL/m34211_a3-pure.cl @@ -0,0 +1,171 @@ +/** + * Author......: See docs/credits.txt + * License.....: MIT + */ + +#define NEW_SIMD_CODE + +#ifdef KERNEL_STATIC +#include M2S(INCLUDE_PATH/inc_vendor.h) +#include M2S(INCLUDE_PATH/inc_types.h) +#include M2S(INCLUDE_PATH/inc_platform.cl) +#include M2S(INCLUDE_PATH/inc_common.cl) +#include M2S(INCLUDE_PATH/inc_simd.cl) +#endif + +DECLSPEC u32 MurmurHash64A_truncated (PRIVATE_AS const u32 *data, const u32 len) +{ +#define M 0xc6a4a7935bd1e995 +#define R 47 + + // Initialize hash + u64 hash = len * M; + + // Twice the number of u64 blocks + const u32 num_u32_blocks = (len / 8) * 2; + + // Loop over one u64 at a time + u32 i = 0; + while (i < num_u32_blocks) + { + // Reconstruct u64 from two u32s + u64 k = hl32_to_64 (data[i + 1], data[i]); + + k *= M; + k ^= k >> R; + k *= M; + + hash ^= k; + hash *= M; + + i += 2; + } + + // Up to 7 overflow bytes + const u32 overflow = len & 7; + + if (overflow > 4) + { + hash ^= hl32_to_64 (data[i + 1], data[i]); + hash *= M; + } + else if (overflow > 0) + { + hash ^= hl32_to_64 (0, data[i]); + hash *= M; + } + + hash ^= hash >> R; + hash *= M; + hash ^= hash >> R; + +#undef M +#undef R + + // Truncate to high 4 bytes + return (u32) (hash >> 32); +} + +KERNEL_FQ KERNEL_FA void m34211_mxx (KERN_ATTR_VECTOR ()) +{ + /** + * modifier + */ + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + + if (gid >= GID_CNT) return; + + /** + * base + */ + + const u32 pw_len = pws[gid].pw_len; + + u32x w[64] = { 0 }; + + for (u32 i = 0, idx = 0; i < pw_len; i += 4, idx += 1) + { + w[idx] = pws[gid].i[idx]; + } + + /** + * loop + */ + + u32x w0l = w[0]; + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) + { + const u32x w0r = words_buf_r[il_pos / VECT_SIZE]; + + const u32x w0 = w0l | w0r; + + w[0] = w0; + + const u32x hash = MurmurHash64A_truncated (w, pw_len); + + const u32x z = 0; + + COMPARE_M_SIMD (hash, z, z, z); + } +} + +KERNEL_FQ KERNEL_FA void m34211_sxx (KERN_ATTR_VECTOR ()) +{ + /** + * modifier + */ + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + + if (gid >= GID_CNT) return; + + /** + * digest + */ + + const u32 search[4] = + { + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R0], + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R1], + 0, + 0 + }; + + /** + * base + */ + + const u32 pw_len = pws[gid].pw_len; + + u32x w[64] = { 0 }; + + for (u32 i = 0, idx = 0; i < pw_len; i += 4, idx += 1) + { + w[idx] = pws[gid].i[idx]; + } + + /** + * loop + */ + + u32x w0l = w[0]; + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) + { + const u32x w0r = words_buf_r[il_pos / VECT_SIZE]; + + const u32x w0 = w0l | w0r; + + w[0] = w0; + + const u32x hash = MurmurHash64A_truncated (w, pw_len); + + const u32x z = 0; + + COMPARE_S_SIMD (hash, z, z, z); + } +} From 35ff3047e401a5cb1af4ff0ab5172e38e444a2e3 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Fri, 25 Jul 2025 14:11:01 +1000 Subject: [PATCH 57/61] Fix SIMD for 34200, 34201 a3 pure kernels --- OpenCL/m34200_a3-pure.cl | 8 ++++---- OpenCL/m34201_a3-pure.cl | 8 ++++---- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/OpenCL/m34200_a3-pure.cl b/OpenCL/m34200_a3-pure.cl index a8b71adba..5b5491a8e 100755 --- a/OpenCL/m34200_a3-pure.cl +++ b/OpenCL/m34200_a3-pure.cl @@ -3,14 +3,14 @@ * License.....: MIT */ -//#define NEW_SIMD_CODE +#define NEW_SIMD_CODE #ifdef KERNEL_STATIC #include M2S(INCLUDE_PATH/inc_vendor.h) #include M2S(INCLUDE_PATH/inc_types.h) #include M2S(INCLUDE_PATH/inc_platform.cl) #include M2S(INCLUDE_PATH/inc_common.cl) -#include M2S(INCLUDE_PATH/inc_scalar.cl) +#include M2S(INCLUDE_PATH/inc_simd.cl) #endif DECLSPEC u64 MurmurHash64A (const u64 seed, PRIVATE_AS const u32 *data, const u32 len) @@ -118,7 +118,7 @@ KERNEL_FQ KERNEL_FA void m34200_mxx (KERN_ATTR_VECTOR ()) const u32x r1 = h32_from_64 (hash); const u32x z = 0; - COMPARE_M_SCALAR (r0, r1, z, z); + COMPARE_M_SIMD (r0, r1, z, z); } } @@ -187,6 +187,6 @@ KERNEL_FQ KERNEL_FA void m34200_sxx (KERN_ATTR_VECTOR ()) const u32x r1 = h32_from_64 (hash); const u32x z = 0; - COMPARE_S_SCALAR (r0, r1, z, z); + COMPARE_S_SIMD (r0, r1, z, z); } } diff --git a/OpenCL/m34201_a3-pure.cl b/OpenCL/m34201_a3-pure.cl index 35281b8c4..fc6544a49 100755 --- a/OpenCL/m34201_a3-pure.cl +++ b/OpenCL/m34201_a3-pure.cl @@ -3,14 +3,14 @@ * License.....: MIT */ -//#define NEW_SIMD_CODE +#define NEW_SIMD_CODE #ifdef KERNEL_STATIC #include M2S(INCLUDE_PATH/inc_vendor.h) #include M2S(INCLUDE_PATH/inc_types.h) #include M2S(INCLUDE_PATH/inc_platform.cl) #include M2S(INCLUDE_PATH/inc_common.cl) -#include M2S(INCLUDE_PATH/inc_scalar.cl) +#include M2S(INCLUDE_PATH/inc_simd.cl) #endif DECLSPEC u64 MurmurHash64A (PRIVATE_AS const u32 *data, const u32 len) @@ -109,7 +109,7 @@ KERNEL_FQ KERNEL_FA void m34201_mxx (KERN_ATTR_VECTOR ()) const u32x r1 = h32_from_64 (hash); const u32x z = 0; - COMPARE_M_SCALAR (r0, r1, z, z); + COMPARE_M_SIMD (r0, r1, z, z); } } @@ -169,6 +169,6 @@ KERNEL_FQ KERNEL_FA void m34201_sxx (KERN_ATTR_VECTOR ()) const u32x r1 = h32_from_64 (hash); const u32x z = 0; - COMPARE_S_SCALAR (r0, r1, z, z); + COMPARE_S_SIMD (r0, r1, z, z); } } From a0f669094582114512576f0ef12ed6b7120877d4 Mon Sep 17 00:00:00 2001 From: qasikfwn <51647241+qasikfwn@users.noreply.github.com> Date: Sun, 27 Jul 2025 14:52:31 +1000 Subject: [PATCH 58/61] Update modules, unit tests, optimized kernels to accept pw len up to 64 --- OpenCL/m34200_a0-optimized.cl | 4 ++-- OpenCL/m34200_a1-optimized.cl | 12 ++++++------ OpenCL/m34200_a3-optimized.cl | 12 ++++++------ OpenCL/m34201_a0-optimized.cl | 4 ++-- OpenCL/m34201_a1-optimized.cl | 12 ++++++------ OpenCL/m34201_a3-optimized.cl | 12 ++++++------ OpenCL/m34211_a0-optimized.cl | 4 ++-- OpenCL/m34211_a1-optimized.cl | 12 ++++++------ OpenCL/m34211_a3-optimized.cl | 12 ++++++------ src/modules/module_34200.c | 2 +- src/modules/module_34201.c | 2 +- src/modules/module_34211.c | 2 +- tools/test_modules/m34200.pm | 2 +- tools/test_modules/m34201.pm | 2 +- tools/test_modules/m34211.pm | 2 +- 15 files changed, 48 insertions(+), 48 deletions(-) diff --git a/OpenCL/m34200_a0-optimized.cl b/OpenCL/m34200_a0-optimized.cl index 4e9486a03..c927cb950 100755 --- a/OpenCL/m34200_a0-optimized.cl +++ b/OpenCL/m34200_a0-optimized.cl @@ -95,7 +95,7 @@ KERNEL_FQ KERNEL_FA void m34200_m04 (KERN_ATTR_RULES ()) pw_buf1[2] = pws[gid].i[6]; pw_buf1[3] = pws[gid].i[7]; - const u32 pw_len = pws[gid].pw_len & 63; + const u32 pw_len = pws[gid].pw_len; /** * seed @@ -162,7 +162,7 @@ KERNEL_FQ KERNEL_FA void m34200_s04 (KERN_ATTR_RULES ()) pw_buf1[2] = pws[gid].i[6]; pw_buf1[3] = pws[gid].i[7]; - const u32 pw_len = pws[gid].pw_len & 63; + const u32 pw_len = pws[gid].pw_len; /** * digest diff --git a/OpenCL/m34200_a1-optimized.cl b/OpenCL/m34200_a1-optimized.cl index bc262f8b1..57d9a776c 100755 --- a/OpenCL/m34200_a1-optimized.cl +++ b/OpenCL/m34200_a1-optimized.cl @@ -92,7 +92,7 @@ KERNEL_FQ KERNEL_FA void m34200_m04 (KERN_ATTR_BASIC ()) pw_buf1[2] = pws[gid].i[6]; pw_buf1[3] = pws[gid].i[7]; - const u32 pw_l_len = pws[gid].pw_len & 63; + const u32 pw_l_len = pws[gid].pw_len; /** * seed @@ -109,9 +109,9 @@ KERNEL_FQ KERNEL_FA void m34200_m04 (KERN_ATTR_BASIC ()) for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) { - const u32 pw_r_len = pwlenx_create_combt (combs_buf, il_pos) & 63; + const u32 pw_r_len = pwlenx_create_combt (combs_buf, il_pos); - const u32 pw_len = (pw_l_len + pw_r_len) & 63; + const u32 pw_len = pw_l_len + pw_r_len; /** * concat password candidate @@ -218,7 +218,7 @@ KERNEL_FQ KERNEL_FA void m34200_s04 (KERN_ATTR_BASIC ()) pw_buf1[2] = pws[gid].i[6]; pw_buf1[3] = pws[gid].i[7]; - const u32 pw_l_len = pws[gid].pw_len & 63; + const u32 pw_l_len = pws[gid].pw_len; /** * seed @@ -247,9 +247,9 @@ KERNEL_FQ KERNEL_FA void m34200_s04 (KERN_ATTR_BASIC ()) for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) { - const u32 pw_r_len = pwlenx_create_combt (combs_buf, il_pos) & 63; + const u32 pw_r_len = pwlenx_create_combt (combs_buf, il_pos); - const u32 pw_len = (pw_l_len + pw_r_len) & 63; + const u32 pw_len = pw_l_len + pw_r_len; /** * concat password candidate diff --git a/OpenCL/m34200_a3-optimized.cl b/OpenCL/m34200_a3-optimized.cl index 8b311bc3c..82937b2a3 100755 --- a/OpenCL/m34200_a3-optimized.cl +++ b/OpenCL/m34200_a3-optimized.cl @@ -232,7 +232,7 @@ KERNEL_FQ KERNEL_FA void m34200_m04 (KERN_ATTR_VECTOR ()) w[14] = 0; w[15] = 0; - const u32 pw_len = pws[gid].pw_len & 63; + const u32 pw_len = pws[gid].pw_len; /** * main @@ -272,7 +272,7 @@ KERNEL_FQ KERNEL_FA void m34200_m08 (KERN_ATTR_VECTOR ()) w[14] = 0; w[15] = 0; - const u32 pw_len = pws[gid].pw_len & 63; + const u32 pw_len = pws[gid].pw_len; /** * main @@ -312,7 +312,7 @@ KERNEL_FQ KERNEL_FA void m34200_m16 (KERN_ATTR_VECTOR ()) w[14] = pws[gid].i[14]; w[15] = pws[gid].i[15]; - const u32 pw_len = pws[gid].pw_len & 63; + const u32 pw_len = pws[gid].pw_len; /** * main @@ -352,7 +352,7 @@ KERNEL_FQ KERNEL_FA void m34200_s04 (KERN_ATTR_VECTOR ()) w[14] = 0; w[15] = 0; - const u32 pw_len = pws[gid].pw_len & 63; + const u32 pw_len = pws[gid].pw_len; /** * main @@ -392,7 +392,7 @@ KERNEL_FQ KERNEL_FA void m34200_s08 (KERN_ATTR_VECTOR ()) w[14] = 0; w[15] = 0; - const u32 pw_len = pws[gid].pw_len & 63; + const u32 pw_len = pws[gid].pw_len; /** * main @@ -432,7 +432,7 @@ KERNEL_FQ KERNEL_FA void m34200_s16 (KERN_ATTR_VECTOR ()) w[14] = pws[gid].i[14]; w[15] = pws[gid].i[15]; - const u32 pw_len = pws[gid].pw_len & 63; + const u32 pw_len = pws[gid].pw_len; /** * main diff --git a/OpenCL/m34201_a0-optimized.cl b/OpenCL/m34201_a0-optimized.cl index a587ab308..0057ae586 100755 --- a/OpenCL/m34201_a0-optimized.cl +++ b/OpenCL/m34201_a0-optimized.cl @@ -95,7 +95,7 @@ KERNEL_FQ KERNEL_FA void m34201_m04 (KERN_ATTR_RULES ()) pw_buf1[2] = pws[gid].i[6]; pw_buf1[3] = pws[gid].i[7]; - const u32 pw_len = pws[gid].pw_len & 63; + const u32 pw_len = pws[gid].pw_len; /** * loop @@ -153,7 +153,7 @@ KERNEL_FQ KERNEL_FA void m34201_s04 (KERN_ATTR_RULES ()) pw_buf1[2] = pws[gid].i[6]; pw_buf1[3] = pws[gid].i[7]; - const u32 pw_len = pws[gid].pw_len & 63; + const u32 pw_len = pws[gid].pw_len; /** * digest diff --git a/OpenCL/m34201_a1-optimized.cl b/OpenCL/m34201_a1-optimized.cl index 04c140deb..556204201 100755 --- a/OpenCL/m34201_a1-optimized.cl +++ b/OpenCL/m34201_a1-optimized.cl @@ -92,7 +92,7 @@ KERNEL_FQ KERNEL_FA void m34201_m04 (KERN_ATTR_BASIC ()) pw_buf1[2] = pws[gid].i[6]; pw_buf1[3] = pws[gid].i[7]; - const u32 pw_l_len = pws[gid].pw_len & 63; + const u32 pw_l_len = pws[gid].pw_len; /** * loop @@ -100,9 +100,9 @@ KERNEL_FQ KERNEL_FA void m34201_m04 (KERN_ATTR_BASIC ()) for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) { - const u32 pw_r_len = pwlenx_create_combt (combs_buf, il_pos) & 63; + const u32 pw_r_len = pwlenx_create_combt (combs_buf, il_pos); - const u32 pw_len = (pw_l_len + pw_r_len) & 63; + const u32 pw_len = pw_l_len + pw_r_len; /** * concat password candidate @@ -209,7 +209,7 @@ KERNEL_FQ KERNEL_FA void m34201_s04 (KERN_ATTR_BASIC ()) pw_buf1[2] = pws[gid].i[6]; pw_buf1[3] = pws[gid].i[7]; - const u32 pw_l_len = pws[gid].pw_len & 63; + const u32 pw_l_len = pws[gid].pw_len; /** * digest @@ -229,9 +229,9 @@ KERNEL_FQ KERNEL_FA void m34201_s04 (KERN_ATTR_BASIC ()) for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) { - const u32 pw_r_len = pwlenx_create_combt (combs_buf, il_pos) & 63; + const u32 pw_r_len = pwlenx_create_combt (combs_buf, il_pos); - const u32 pw_len = (pw_l_len + pw_r_len) & 63; + const u32 pw_len = pw_l_len + pw_r_len; /** * concat password candidate diff --git a/OpenCL/m34201_a3-optimized.cl b/OpenCL/m34201_a3-optimized.cl index ab844377f..62cf032a5 100755 --- a/OpenCL/m34201_a3-optimized.cl +++ b/OpenCL/m34201_a3-optimized.cl @@ -214,7 +214,7 @@ KERNEL_FQ KERNEL_FA void m34201_m04 (KERN_ATTR_VECTOR ()) w[14] = 0; w[15] = 0; - const u32 pw_len = pws[gid].pw_len & 63; + const u32 pw_len = pws[gid].pw_len; /** * main @@ -254,7 +254,7 @@ KERNEL_FQ KERNEL_FA void m34201_m08 (KERN_ATTR_VECTOR ()) w[14] = 0; w[15] = 0; - const u32 pw_len = pws[gid].pw_len & 63; + const u32 pw_len = pws[gid].pw_len; /** * main @@ -294,7 +294,7 @@ KERNEL_FQ KERNEL_FA void m34201_m16 (KERN_ATTR_VECTOR ()) w[14] = pws[gid].i[14]; w[15] = pws[gid].i[15]; - const u32 pw_len = pws[gid].pw_len & 63; + const u32 pw_len = pws[gid].pw_len; /** * main @@ -334,7 +334,7 @@ KERNEL_FQ KERNEL_FA void m34201_s04 (KERN_ATTR_VECTOR ()) w[14] = 0; w[15] = 0; - const u32 pw_len = pws[gid].pw_len & 63; + const u32 pw_len = pws[gid].pw_len; /** * main @@ -374,7 +374,7 @@ KERNEL_FQ KERNEL_FA void m34201_s08 (KERN_ATTR_VECTOR ()) w[14] = 0; w[15] = 0; - const u32 pw_len = pws[gid].pw_len & 63; + const u32 pw_len = pws[gid].pw_len; /** * main @@ -414,7 +414,7 @@ KERNEL_FQ KERNEL_FA void m34201_s16 (KERN_ATTR_VECTOR ()) w[14] = pws[gid].i[14]; w[15] = pws[gid].i[15]; - const u32 pw_len = pws[gid].pw_len & 63; + const u32 pw_len = pws[gid].pw_len; /** * main diff --git a/OpenCL/m34211_a0-optimized.cl b/OpenCL/m34211_a0-optimized.cl index ec3aa0c6c..c2b2efc72 100755 --- a/OpenCL/m34211_a0-optimized.cl +++ b/OpenCL/m34211_a0-optimized.cl @@ -96,7 +96,7 @@ KERNEL_FQ KERNEL_FA void m34211_m04 (KERN_ATTR_RULES ()) pw_buf1[2] = pws[gid].i[6]; pw_buf1[3] = pws[gid].i[7]; - const u32 pw_len = pws[gid].pw_len & 63; + const u32 pw_len = pws[gid].pw_len; /** * loop @@ -152,7 +152,7 @@ KERNEL_FQ KERNEL_FA void m34211_s04 (KERN_ATTR_RULES ()) pw_buf1[2] = pws[gid].i[6]; pw_buf1[3] = pws[gid].i[7]; - const u32 pw_len = pws[gid].pw_len & 63; + const u32 pw_len = pws[gid].pw_len; /** * digest diff --git a/OpenCL/m34211_a1-optimized.cl b/OpenCL/m34211_a1-optimized.cl index 2a309ca19..9f4593cf4 100755 --- a/OpenCL/m34211_a1-optimized.cl +++ b/OpenCL/m34211_a1-optimized.cl @@ -93,7 +93,7 @@ KERNEL_FQ KERNEL_FA void m34211_m04 (KERN_ATTR_BASIC ()) pw_buf1[2] = pws[gid].i[6]; pw_buf1[3] = pws[gid].i[7]; - const u32 pw_l_len = pws[gid].pw_len & 63; + const u32 pw_l_len = pws[gid].pw_len; /** * loop @@ -101,9 +101,9 @@ KERNEL_FQ KERNEL_FA void m34211_m04 (KERN_ATTR_BASIC ()) for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) { - const u32 pw_r_len = pwlenx_create_combt (combs_buf, il_pos) & 63; + const u32 pw_r_len = pwlenx_create_combt (combs_buf, il_pos); - const u32 pw_len = (pw_l_len + pw_r_len) & 63; + const u32 pw_len = pw_l_len + pw_r_len; /** * concat password candidate @@ -208,7 +208,7 @@ KERNEL_FQ KERNEL_FA void m34211_s04 (KERN_ATTR_BASIC ()) pw_buf1[2] = pws[gid].i[6]; pw_buf1[3] = pws[gid].i[7]; - const u32 pw_l_len = pws[gid].pw_len & 63; + const u32 pw_l_len = pws[gid].pw_len; /** * digest @@ -228,9 +228,9 @@ KERNEL_FQ KERNEL_FA void m34211_s04 (KERN_ATTR_BASIC ()) for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) { - const u32 pw_r_len = pwlenx_create_combt (combs_buf, il_pos) & 63; + const u32 pw_r_len = pwlenx_create_combt (combs_buf, il_pos); - const u32 pw_len = (pw_l_len + pw_r_len) & 63; + const u32 pw_len = pw_l_len + pw_r_len; /** * concat password candidate diff --git a/OpenCL/m34211_a3-optimized.cl b/OpenCL/m34211_a3-optimized.cl index 273596113..da3e14af1 100755 --- a/OpenCL/m34211_a3-optimized.cl +++ b/OpenCL/m34211_a3-optimized.cl @@ -211,7 +211,7 @@ KERNEL_FQ KERNEL_FA void m34211_m04 (KERN_ATTR_VECTOR ()) w[14] = 0; w[15] = 0; - const u32 pw_len = pws[gid].pw_len & 63; + const u32 pw_len = pws[gid].pw_len; /** * main @@ -251,7 +251,7 @@ KERNEL_FQ KERNEL_FA void m34211_m08 (KERN_ATTR_VECTOR ()) w[14] = 0; w[15] = 0; - const u32 pw_len = pws[gid].pw_len & 63; + const u32 pw_len = pws[gid].pw_len; /** * main @@ -291,7 +291,7 @@ KERNEL_FQ KERNEL_FA void m34211_m16 (KERN_ATTR_VECTOR ()) w[14] = pws[gid].i[14]; w[15] = pws[gid].i[15]; - const u32 pw_len = pws[gid].pw_len & 63; + const u32 pw_len = pws[gid].pw_len; /** * main @@ -331,7 +331,7 @@ KERNEL_FQ KERNEL_FA void m34211_s04 (KERN_ATTR_VECTOR ()) w[14] = 0; w[15] = 0; - const u32 pw_len = pws[gid].pw_len & 63; + const u32 pw_len = pws[gid].pw_len; /** * main @@ -371,7 +371,7 @@ KERNEL_FQ KERNEL_FA void m34211_s08 (KERN_ATTR_VECTOR ()) w[14] = 0; w[15] = 0; - const u32 pw_len = pws[gid].pw_len & 63; + const u32 pw_len = pws[gid].pw_len; /** * main @@ -411,7 +411,7 @@ KERNEL_FQ KERNEL_FA void m34211_s16 (KERN_ATTR_VECTOR ()) w[14] = pws[gid].i[14]; w[15] = pws[gid].i[15]; - const u32 pw_len = pws[gid].pw_len & 63; + const u32 pw_len = pws[gid].pw_len; /** * main diff --git a/src/modules/module_34200.c b/src/modules/module_34200.c index a9883e8ae..6908d6d1d 100755 --- a/src/modules/module_34200.c +++ b/src/modules/module_34200.c @@ -49,7 +49,7 @@ u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED con { const bool optimized_kernel = (hashconfig->opti_type & OPTI_TYPE_OPTIMIZED_KERNEL); - const u32 pw_max = (optimized_kernel == true) ? 32 : PW_MAX; + const u32 pw_max = (optimized_kernel == true) ? 64 : PW_MAX; return pw_max; } diff --git a/src/modules/module_34201.c b/src/modules/module_34201.c index bd6dcb24a..fa5e6d3b5 100755 --- a/src/modules/module_34201.c +++ b/src/modules/module_34201.c @@ -49,7 +49,7 @@ u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED con { const bool optimized_kernel = (hashconfig->opti_type & OPTI_TYPE_OPTIMIZED_KERNEL); - const u32 pw_max = (optimized_kernel == true) ? 32 : PW_MAX; + const u32 pw_max = (optimized_kernel == true) ? 64 : PW_MAX; return pw_max; } diff --git a/src/modules/module_34211.c b/src/modules/module_34211.c index e3bc94a54..04ec7c188 100755 --- a/src/modules/module_34211.c +++ b/src/modules/module_34211.c @@ -49,7 +49,7 @@ u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED con { const bool optimized_kernel = (hashconfig->opti_type & OPTI_TYPE_OPTIMIZED_KERNEL); - const u32 pw_max = (optimized_kernel == true) ? 32 : PW_MAX; + const u32 pw_max = (optimized_kernel == true) ? 64 : PW_MAX; return pw_max; } diff --git a/tools/test_modules/m34200.pm b/tools/test_modules/m34200.pm index 0415ee33c..168b4c839 100755 --- a/tools/test_modules/m34200.pm +++ b/tools/test_modules/m34200.pm @@ -9,7 +9,7 @@ use strict; use warnings; use Math::BigInt; -sub module_constraints { [[0, 256], [16, 16], [0, 63], [16, 16], [-1, -1]] } +sub module_constraints { [[0, 256], [16, 16], [0, 64], [16, 16], [-1, -1]] } my $u64_width = Math::BigInt->new ("0x10000000000000000"); # 2**64 diff --git a/tools/test_modules/m34201.pm b/tools/test_modules/m34201.pm index 5ef460557..0d7a2eec5 100755 --- a/tools/test_modules/m34201.pm +++ b/tools/test_modules/m34201.pm @@ -9,7 +9,7 @@ use strict; use warnings; use Math::BigInt; -sub module_constraints { [[0, 256], [-1, -1], [0, 63], [-1, -1], [0, 63]] } +sub module_constraints { [[0, 256], [-1, -1], [0, 64], [-1, -1], [-1, -1]] } my $u64_width = Math::BigInt->new ("0x10000000000000000"); # 2**64 diff --git a/tools/test_modules/m34211.pm b/tools/test_modules/m34211.pm index 4cbea3090..9394e0414 100755 --- a/tools/test_modules/m34211.pm +++ b/tools/test_modules/m34211.pm @@ -9,7 +9,7 @@ use strict; use warnings; use Math::BigInt; -sub module_constraints { [[0, 256], [-1, -1], [0, 32], [-1, -1], [0, 32]] } +sub module_constraints { [[0, 256], [-1, -1], [0, 64], [-1, -1], [-1, -1]] } my $u64_width = Math::BigInt->new ("0x10000000000000000"); # 2**64 From 1e622b1655b222b0e0bcc63b7bc6035ba01de90a Mon Sep 17 00:00:00 2001 From: Gabriele Gristina Date: Sun, 27 Jul 2025 11:29:52 +0200 Subject: [PATCH 59/61] Updated benchmark_deep.pl - Added OS detection to allow conditional execution of platform-specific initialization steps - Implemented macOS-specific cache cleaning to ensure consistent benchmark results - Updated script logic to align with other test suites, including improved handling of workdir setup and execution timing measurements --- docs/changes.txt | 1 + tools/benchmark_deep.pl | 88 ++++++++++++++++++++++++++++++----------- 2 files changed, 67 insertions(+), 22 deletions(-) diff --git a/docs/changes.txt b/docs/changes.txt index 4a4ce784b..2be2a9874 100644 --- a/docs/changes.txt +++ b/docs/changes.txt @@ -185,6 +185,7 @@ - Backend: Splitting backend_ctx_devices_init into smaller runtime-specific functions - Backend: Updated OpenCL/CUDA/HIP/Metal API's - Backend: Updated filename chksum format to prevent invalid cache on Apple Silicon when switching arch +- Benchmark: Updated benchmark_deep.pl with OS detection, Apple cache cleaning way and other minor changes - Brain: Added sanity check and corresponding error message for invalid --brain-port values - Building: Support building windows binaries on macOS using MinGW - Debug: Added -g to build_options if DEBUG >= 1 (only with HIP and OpenCL) diff --git a/tools/benchmark_deep.pl b/tools/benchmark_deep.pl index f6369e995..03831c818 100755 --- a/tools/benchmark_deep.pl +++ b/tools/benchmark_deep.pl @@ -8,6 +8,11 @@ use strict; use warnings; +use File::Path qw(make_path); + +my $startTime = time(); +my $workdir = "test_benchmarkDeep_$startTime"; + my $nvidia_cache = "~/.nv"; my $amd_cache = "~/.AMD"; my $hashcat_path = "."; @@ -18,34 +23,61 @@ my $workload_profile = 3; my $runtime = 11; my $sleep_sec = 13; my $default_mask = "?a?a?a?a?a?a?a"; -my $result = "result.txt"; +my $result = "$workdir/result.txt"; my $old_hashcat = 0; # requires to have ran with new hashcat before to create the hashfiles my $repeats = 0; my $cpu_benchmark = 0; -print "\nHardware preparations... You may need to adjust some settings and probably can ignore some of the error\n\n"; - -system ("echo performance | sudo tee /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor"); - -if ($cpu_benchmark == 1) +unless (-d $workdir) { - system ("sudo echo 1 > /sys/devices/system/cpu/intel_pstate/no_turbo"); ## for CPU benchmark Intel - system ("sudo echo 0 > /sys/devices/system/cpu/cpufreq/boost"); ## for CPU benchmark AMD -} -else -{ - #system ("rocm-smi --resetprofile --resetclocks --resetfans"); - #system ("rocm-smi --setfan 100% --setperflevel high"); - - system ("nvidia-settings -a GPUPowerMizerMode=1 -a GPUFanControlState=1 -a GPUTargetFanSpeed=100"); + make_path($workdir) or die "Unable to create '$workdir': $!"; } -print "\n\nStarting...\n\n"; +print "\n[$workdir] > Hardware preparations... You may need to adjust some settings and probably can ignore some of the error\n\n"; + +if ($^O eq 'linux') +{ + system ("echo performance | sudo tee /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor"); + + if ($cpu_benchmark == 1) + { + system ("sudo echo 1 > /sys/devices/system/cpu/intel_pstate/no_turbo"); ## for CPU benchmark Intel + system ("sudo echo 0 > /sys/devices/system/cpu/cpufreq/boost"); ## for CPU benchmark AMD + } + else + { + #system ("rocm-smi --resetprofile --resetclocks --resetfans"); + #system ("rocm-smi --setfan 100% --setperflevel high"); + + system ("nvidia-settings -a GPUPowerMizerMode=1 -a GPUFanControlState=1 -a GPUTargetFanSpeed=100"); + } + + system ("rm -rf $nvidia_cache"); + system ("rm -rf $amd_cache"); +} +elsif ($^O eq 'darwin') +{ + open(my $stderr_orig, '>&', STDERR) or die "Can't dup STDERR: $!"; + + open(STDERR, '>', '/dev/null') or die "Can't redirect STDERR: $!"; + + chomp(my $temp_dir = `getconf DARWIN_USER_TEMP_DIR`); + chomp(my $cache_dir = `getconf DARWIN_USER_CACHE_DIR`); + + # cleanup OpenCL cache + system("find \"$temp_dir\" -mindepth 1 -exec rm -rf {} +"); + # cleanup OpenCL/Metal cache + system("rm -rf \"$cache_dir/com.apple.metalfe/*\""); + # cleanup Metal cache + system("rm -rf \"$cache_dir/com.apple.metal/*\""); + + open(STDERR, '>&', $stderr_orig) or die "Can't restore STDERR: $!"; +} -system ("rm -rf $nvidia_cache"); -system ("rm -rf $amd_cache"); system ("rm -rf $kernels_cache"); +print "\n\n[$workdir] > Starting...\n\n"; + my @hash_types_selection = ( 0, @@ -379,6 +411,8 @@ for my $hash_type (@hash_types) my $mask = $default_mask; + my $filepath = "$workdir/tmp.hash.$hash_type"; + if ($old_hashcat == 0) { my $module = get_module ($hash_type); @@ -386,7 +420,7 @@ for my $hash_type (@hash_types) my $st_hash = $module->{"st_hash"}; my $is_binary = $module->{"is_binary"}; - open (OUT, ">", "tmp.hash.$hash_type") or die; + open (OUT, ">", $filepath) or die; if ($is_binary) { @@ -406,7 +440,7 @@ for my $hash_type (@hash_types) ( $hashcat_bin, "-D2", "--quiet", - "tmp.hash.$hash_type", + $filepath, "--keep-guessing", "--self-test-disable", "--markov-disable", @@ -435,13 +469,13 @@ for my $hash_type (@hash_types) push (@command, "--backend-devices", $device); } - print "Executing command: ", join (" ", @command), "\n"; + print "[$workdir] > Executing command: ", join (" ", @command), "\n"; my $final_speed = 0; for (my $i = 0; $i <= $repeats; $i++) { - printf ("Run #%d\n", $i); + printf ("[$workdir] > Run #%d\n", $i); open (IN, "-|", @command, "--runtime", 1); close (IN); @@ -493,6 +527,16 @@ for my $hash_type (@hash_types) open (OUT, ">>", $result) or die; print OUT $final_speed, "\n"; close (OUT); + + my $endTime = time(); + my $elapsed = $endTime - $startTime; + + my $days = int($elapsed / 86400); + my $hours = int(($elapsed % 86400) / 3600); + my $minutes = int(($elapsed % 3600) / 60); + my $seconds = $elapsed % 60; + + printf("\n\n[$workdir] > All tests done in: %d days, %02d hours, %02d minutes, %02d seconds\n", $days, $hours, $minutes, $seconds); } sub get_module From 3151e1dcbb962994938d618af33d5b8006fb79fa Mon Sep 17 00:00:00 2001 From: Gabriele Gristina Date: Sun, 27 Jul 2025 21:54:30 +0200 Subject: [PATCH 60/61] Allow also a list of vectors widths in test_edge.sh --- tools/test_edge.sh | 34 +++++++++++++++++++++++++--------- 1 file changed, 25 insertions(+), 9 deletions(-) diff --git a/tools/test_edge.sh b/tools/test_edge.sh index 2bcf65a8d..4c866dae7 100755 --- a/tools/test_edge.sh +++ b/tools/test_edge.sh @@ -27,7 +27,8 @@ function usage() echo "" echo "-t / --target-type : set Target Type (default: all. supported: single, multi)" echo "" - echo "-V / --vector-width : set Vector Width (default: all. supported: 1, 2, 4, 8, 16)" + echo "-V / --vector-width : set Vector Width or a list of comma-separated Vector Widths" + echo " (default: all. supported: 1, 2, 4, 8, 16)" echo " --vector-width-min : set min vector-width (default: 1)" echo " --vector-width-max : set max vector-width (default: 16)" echo "" @@ -290,11 +291,21 @@ while [[ $# -gt 0 ]]; do if [[ "$optarg" == "all" ]]; then : - elif [[ "$optarg" =~ ^(1|2|4|8|16)$ ]]; then - VECTOR_WIDTH="$optarg" else - echo "Invalid vector width: $optarg" - usage + VECTOR_WIDTH="" + VECTOR_WIDTHS="" + + IFS=',' read -ra INPUT_VECTOR_WIDTHS <<< "$optarg" + for vec in "${INPUT_VECTOR_WIDTHS[@]}"; do + if [[ "$vec" =~ ^(1|2|4|8|16)$ ]]; then + VECTOR_WIDTHS+=" $vec" + else + echo "Invalid Vector width: $vec" + usage + fi + done + + VECTOR_WIDTHS="$(echo "$VECTOR_WIDTHS" | xargs)" # Trim leading/trailing spaces fi [[ "$shift_inline" -eq 0 ]] && shift @@ -513,7 +524,14 @@ if [ ${FORCE} -eq 1 ]; then fi if [ $METAL_BACKEND -eq 1 ]; then - VECTOR_WIDTHS="1 2 4" + VECTOR_WIDTHS_FILTER="" + for v in $VECTOR_WIDTHS; do + if [ "$v" -le 4 ]; then + VECTOR_WIDTHS_FILTER="$VECTOR_WIDTHS_FILTER$v " + fi + done + + VECTOR_WIDTHS="$(echo "$VECTOR_WIDTHS_FILTER" | xargs)" if [ $VECTOR_WIDTH_MAX -gt 4 ]; then VECTOR_WIDTH_MAX=4 @@ -668,9 +686,7 @@ for hash_type in $(ls tools/test_modules/*.pm | cut -d'm' -f3 | cut -d'.' -f1 | for vector_width in ${VECTOR_WIDTHS}; do - if [ $VECTOR_WIDTH != "all" ]; then - if [ $VECTOR_WIDTH -ne $vector_width ]; then continue; fi - else + if [ "$VECTOR_WIDTH" == "all" ]; then if [ ${vector_width} -lt ${VECTOR_WIDTH_MIN} ]; then continue; fi if [ ${vector_width} -gt ${VECTOR_WIDTH_MAX} ]; then continue; fi fi From e9bc14b6397724406f7b88f02f937913385e6504 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Sun, 27 Jul 2025 21:15:14 +0000 Subject: [PATCH 61/61] Automatically updated docs/hashcat-help.md or docs/hashcat-example_hashes.md (by Github Action) --- docs/hashcat-example_hashes.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/docs/hashcat-example_hashes.md b/docs/hashcat-example_hashes.md index 913745815..bca271eff 100644 --- a/docs/hashcat-example_hashes.md +++ b/docs/hashcat-example_hashes.md @@ -556,6 +556,9 @@ All manual changes will be overwritten! | `33800` | `WBB4 (Woltlab Burning Board) Plugin [bcrypt(bcrypt($pass))]` | `$2a$08$hashcatohohohohohohohegk6PN.SFkoXxDIkacAGKFN9AF8nx.Hi` | | `33900` | `Citrix NetScaler (PBKDF2-HMAC-SHA256)` | `5567243c55099b6b10a714a350db53beea8be6ac9c247fd40fea7e96d206a9f11fd1c45735556ac2004138640de206d0e1522607ab3c3f92816156d2d7845068e` | | `34000` | `Argon2` | `$argon2id$v=19$m=65536,t=3,p=1$FBMjI4RJBhIykCgol1KEJA$2ky5GAdhT1kH4kIgPN/oERE3Taiy43vNN70a3HpiKQU` | +| `34200` | `MurmurHash64A` | `ef3014941bf1102d:837163b2348dfae1` | +| `34201` | `MurmurHash64A (zero seed)` | `73f8142b4326d36a` | +| `34211` | `MurmurHash64A truncated (zero seed)` | `73f8142b` | | `70000` | `argon2id [Bridged: reference implementation + tunings]` | `$argon2id$v=19$m=65536,t=3,p=1$FBMjI4RJBhIykCgol1KEJA$2ky5GAdhT1kH4kIgPN/oERE3Taiy43vNN70a3HpiKQU` | | `70100` | `scrypt [Bridged: Scrypt-Jane ROMix]` | `SCRYPT:16384:8:1:OTEyNzU0ODg=:Cc8SPjRH1hFQhuIPCdF51uNGtJ2aOY/isuoMlMUsJ8c=` | | `70200` | `scrypt [Bridged: Scrypt-Yescrypt]` | `SCRYPT:16384:8:1:OTEyNzU0ODg=:Cc8SPjRH1hFQhuIPCdF51uNGtJ2aOY/isuoMlMUsJ8c=` |