From 9944e964d6c17870423da4c523259fc886df1144 Mon Sep 17 00:00:00 2001 From: Pikachu Date: Thu, 20 Oct 2022 12:57:48 +0300 Subject: [PATCH 1/9] Add hash-mode 3730 - Dahua NVR/DVR - md5($salt1.strtoupper(md5($salt2.$pass))) Pure kernel on attack mode 0 doesn't crack when only a single hash is present in the hashfile (otherwise ok) - self-test fails as well. --- OpenCL/inc_common.h | 5 + OpenCL/m03730_a0-optimized.cl | 790 +++++++++++++++++++++++ OpenCL/m03730_a0-pure.cl | 309 +++++++++ OpenCL/m03730_a1-optimized.cl | 906 ++++++++++++++++++++++++++ OpenCL/m03730_a1-pure.cl | 299 +++++++++ OpenCL/m03730_a3-optimized.cl | 1138 +++++++++++++++++++++++++++++++++ OpenCL/m03730_a3-pure.cl | 328 ++++++++++ src/modules/module_03730.c | 278 ++++++++ 8 files changed, 4053 insertions(+) create mode 100644 OpenCL/m03730_a0-optimized.cl create mode 100644 OpenCL/m03730_a0-pure.cl create mode 100644 OpenCL/m03730_a1-optimized.cl create mode 100644 OpenCL/m03730_a1-pure.cl create mode 100644 OpenCL/m03730_a3-optimized.cl create mode 100644 OpenCL/m03730_a3-pure.cl create mode 100644 src/modules/module_03730.c diff --git a/OpenCL/inc_common.h b/OpenCL/inc_common.h index 016d6240a..97762a80f 100644 --- a/OpenCL/inc_common.h +++ b/OpenCL/inc_common.h @@ -92,6 +92,7 @@ #if defined IS_CUDA || defined IS_HIP #define _KERN_ATTR_BASIC() KERN_ATTR (GLOBAL_AS, GLOBAL_AS const bf_t *g_bfs_buf, void, void, void) +#define _KERN_ATTR_BASIC_ESALT(e) KERN_ATTR (GLOBAL_AS, GLOBAL_AS const bf_t *g_bfs_buf, void, void, e) #define _KERN_ATTR_BITSLICE() KERN_ATTR (GLOBAL_AS, GLOBAL_AS const bs_word_t *g_words_buf_s, void, void, void) #define _KERN_ATTR_ESALT(e) KERN_ATTR (GLOBAL_AS, GLOBAL_AS const bf_t *g_bfs_buf, void, void, e) #define _KERN_ATTR_RULES() KERN_ATTR (GLOBAL_AS, GLOBAL_AS const bf_t *g_bfs_buf, void, void, void) @@ -104,6 +105,7 @@ #define _KERN_ATTR_VECTOR_ESALT(e) KERN_ATTR (GLOBAL_AS, GLOBAL_AS const u32x *g_words_buf_r, void, void, e) #else #define _KERN_ATTR_BASIC() KERN_ATTR (GLOBAL_AS, CONSTANT_AS const bf_t *bfs_buf, void, void, void) +#define _KERN_ATTR_BASIC_ESALT(e) KERN_ATTR (GLOBAL_AS, CONSTANT_AS const bf_t *bfs_buf, void, void, e) #define _KERN_ATTR_BITSLICE() KERN_ATTR (GLOBAL_AS, CONSTANT_AS const bs_word_t *words_buf_s, void, void, void) #define _KERN_ATTR_ESALT(e) KERN_ATTR (GLOBAL_AS, CONSTANT_AS const bf_t *bfs_buf, void, void, e) #define _KERN_ATTR_RULES() KERN_ATTR (CONSTANT_AS, GLOBAL_AS const bf_t *bfs_buf, void, void, void) @@ -145,6 +147,7 @@ #if defined IS_METAL #define KERN_ATTR_BASIC() _KERN_ATTR_BASIC(), KERN_ATTR_MAIN_PARAMS +#define KERN_ATTR_BASIC_ESALT(e) _KERN_ATTR_BASIC_ESALT(e), KERN_ATTR_MAIN_PARAMS #define KERN_ATTR_BITSLICE() _KERN_ATTR_BITSLICE(), KERN_ATTR_MAIN_PARAMS #define KERN_ATTR_ESALT(e) _KERN_ATTR_ESALT(e), KERN_ATTR_MAIN_PARAMS #define KERN_ATTR_RULES() _KERN_ATTR_RULES(), KERN_ATTR_MAIN_PARAMS @@ -158,6 +161,7 @@ #define KERN_ATTR_TM _KERN_ATTR_TM, KERN_ATTR_MAIN_PARAMS #else // CUDA, HIP and OpenCL #define KERN_ATTR_BASIC() _KERN_ATTR_BASIC() +#define KERN_ATTR_BASIC_ESALT(e) _KERN_ATTR_BASIC_ESALT(e) #define KERN_ATTR_BITSLICE() _KERN_ATTR_BITSLICE() #define KERN_ATTR_ESALT(e) _KERN_ATTR_ESALT(e) #define KERN_ATTR_RULES() _KERN_ATTR_RULES() @@ -184,6 +188,7 @@ MAYBE_UNUSED const u64 lsz #define KERN_ATTR_FUNC_BASIC() _KERN_ATTR_BASIC(), KERN_ATTR_FUNC_PARAMS +#define KERN_ATTR_FUNC_BASIC_ESALT(e) _KERN_ATTR_BASIC_ESALT(e), KERN_ATTR_FUNC_PARAMS #define KERN_ATTR_FUNC_BITSLICE() _KERN_ATTR_BITSLICE(), KERN_ATTR_FUNC_PARAMS #define KERN_ATTR_FUNC_ESALT(e) _KERN_ATTR_ESALT(e), KERN_ATTR_FUNC_PARAMS #define KERN_ATTR_FUNC_RULES() _KERN_ATTR_RULES(), KERN_ATTR_FUNC_PARAMS diff --git a/OpenCL/m03730_a0-optimized.cl b/OpenCL/m03730_a0-optimized.cl new file mode 100644 index 000000000..df1e6252f --- /dev/null +++ b/OpenCL/m03730_a0-optimized.cl @@ -0,0 +1,790 @@ +/** + * 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) +#include M2S(INCLUDE_PATH/inc_hash_md5.cl) +#endif + +#if VECT_SIZE == 1 +#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i)]) +#elif VECT_SIZE == 2 +#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i).s0], u_bin2asc[(i).s1]) +#elif VECT_SIZE == 4 +#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i).s0], u_bin2asc[(i).s1], u_bin2asc[(i).s2], u_bin2asc[(i).s3]) +#elif VECT_SIZE == 8 +#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i).s0], u_bin2asc[(i).s1], u_bin2asc[(i).s2], u_bin2asc[(i).s3], u_bin2asc[(i).s4], u_bin2asc[(i).s5], u_bin2asc[(i).s6], u_bin2asc[(i).s7]) +#elif VECT_SIZE == 16 +#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i).s0], u_bin2asc[(i).s1], u_bin2asc[(i).s2], u_bin2asc[(i).s3], u_bin2asc[(i).s4], u_bin2asc[(i).s5], u_bin2asc[(i).s6], u_bin2asc[(i).s7], u_bin2asc[(i).s8], u_bin2asc[(i).s9], u_bin2asc[(i).sa], u_bin2asc[(i).sb], u_bin2asc[(i).sc], u_bin2asc[(i).sd], u_bin2asc[(i).se], u_bin2asc[(i).sf]) +#endif + +typedef struct md5_double_salt +{ + u32 salt1_buf[64]; + int salt1_len; + + u32 salt2_buf[64]; + int salt2_len; + +} md5_double_salt_t; + +KERNEL_FQ void m03730_m04 (KERN_ATTR_RULES_ESALT (md5_double_salt_t)) +{ + /** + * modifier + */ + + const u64 gid = get_global_id (0); + const u64 lid = get_local_id (0); + const u64 lsz = get_local_size (0); + + /** + * bin2asc uppercase array + */ + LOCAL_VK u32 u_bin2asc[256]; + + for (u32 j = lid; j < 256; j += lsz) + { + const u32 i0 = (j >> 0) & 15; + const u32 i1 = (j >> 4) & 15; + + u_bin2asc[j] = ((i0 < 10) ? '0' + i0 : 'A' - 10 + i0) << 8 + | ((i1 < 10) ? '0' + i1 : 'A' - 10 + i1) << 0; + } + + SYNC_THREADS (); + + 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_len = pws[gid].pw_len & 63; + + /** + * salt1 + */ + + u32 salt1_buf0[4]; + u32 salt1_buf1[4]; + u32 salt1_buf2[4]; + u32 salt1_buf3[4]; + + salt1_buf0[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 0]; + salt1_buf0[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 1]; + salt1_buf0[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 2]; + salt1_buf0[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 3]; + salt1_buf1[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 4]; + salt1_buf1[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 5]; + salt1_buf1[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 6]; + salt1_buf1[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 7]; + salt1_buf2[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 8]; + salt1_buf2[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 9]; + salt1_buf2[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[10]; + salt1_buf2[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[11]; + salt1_buf3[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[12]; + salt1_buf3[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[13]; + salt1_buf3[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[14]; + salt1_buf3[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[15]; + + const u32 salt1_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_len; + + /** + * salt2 + */ + + u32 salt2_buf0[4]; + u32 salt2_buf1[4]; + u32 salt2_buf2[4]; + u32 salt2_buf3[4]; + + salt2_buf0[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 0]; + salt2_buf0[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 1]; + salt2_buf0[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 2]; + salt2_buf0[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 3]; + salt2_buf1[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 4]; + salt2_buf1[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 5]; + salt2_buf1[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 6]; + salt2_buf1[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 7]; + salt2_buf2[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 8]; + salt2_buf2[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 9]; + salt2_buf2[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[10]; + salt2_buf2[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[11]; + salt2_buf3[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[12]; + salt2_buf3[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[13]; + salt2_buf3[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[14]; + salt2_buf3[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[15]; + + const u32 salt2_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_len; + + const u32 pw_salt_len = 32 + salt2_len; + + /** + * loop + */ + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) + { + u32x w0[4] = { 0 }; + u32x w1[4] = { 0 }; + u32x w2[4] = { 0 }; + u32x w3[4] = { 0 }; + + const u32x out_len = apply_rules_vect_optimized (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w0, w1); + + /** + * prepend salt2 + */ + + const u32x out_salt_len = salt2_len + out_len; + + switch_buffer_by_offset_le (w0, w1, w2, w3, salt2_len); + + w0[0] |= salt2_buf0[0]; + w0[1] |= salt2_buf0[1]; + w0[2] |= salt2_buf0[2]; + w0[3] |= salt2_buf0[3]; + w1[0] |= salt2_buf1[0]; + w1[1] |= salt2_buf1[1]; + w1[2] |= salt2_buf1[2]; + w1[3] |= salt2_buf1[3]; + w2[0] |= salt2_buf2[0]; + w2[1] |= salt2_buf2[1]; + w2[2] |= salt2_buf2[2]; + w2[3] |= salt2_buf2[3]; + w3[0] |= salt2_buf3[0]; + w3[1] |= salt2_buf3[1]; + w3[2] = out_salt_len * 8; + w3[3] = 0; + + append_0x80_4x4_VV (w0, w1, w2, w3, out_salt_len); + + /** + * md5 + */ + + u32x a = MD5M_A; + u32x b = MD5M_B; + u32x c = MD5M_C; + u32x d = MD5M_D; + + MD5_STEP (MD5_Fo, a, b, c, d, w0[0], MD5C00, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w0[1], MD5C01, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w0[2], MD5C02, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w0[3], MD5C03, MD5S03); + MD5_STEP (MD5_Fo, a, b, c, d, w1[0], MD5C04, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w1[1], MD5C05, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w1[2], MD5C06, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w1[3], MD5C07, MD5S03); + MD5_STEP (MD5_Fo, a, b, c, d, w2[0], MD5C08, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w2[1], MD5C09, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w2[2], MD5C0a, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w2[3], MD5C0b, MD5S03); + MD5_STEP (MD5_Fo, a, b, c, d, w3[0], MD5C0c, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w3[1], MD5C0d, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w3[2], MD5C0e, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w3[3], MD5C0f, MD5S03); + + MD5_STEP (MD5_Go, a, b, c, d, w0[1], MD5C10, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w1[2], MD5C11, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w2[3], MD5C12, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w0[0], MD5C13, MD5S13); + MD5_STEP (MD5_Go, a, b, c, d, w1[1], MD5C14, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w2[2], MD5C15, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w3[3], MD5C16, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w1[0], MD5C17, MD5S13); + MD5_STEP (MD5_Go, a, b, c, d, w2[1], MD5C18, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w3[2], MD5C19, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w0[3], MD5C1a, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w2[0], MD5C1b, MD5S13); + MD5_STEP (MD5_Go, a, b, c, d, w3[1], MD5C1c, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w0[2], MD5C1d, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w1[3], MD5C1e, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w3[0], MD5C1f, MD5S13); + + u32x t; + + MD5_STEP (MD5_H1, a, b, c, d, w1[1], MD5C20, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w2[0], MD5C21, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w2[3], MD5C22, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w3[2], MD5C23, MD5S23); + MD5_STEP (MD5_H1, a, b, c, d, w0[1], MD5C24, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w1[0], MD5C25, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w1[3], MD5C26, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w2[2], MD5C27, MD5S23); + MD5_STEP (MD5_H1, a, b, c, d, w3[1], MD5C28, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w0[0], MD5C29, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w0[3], MD5C2a, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w1[2], MD5C2b, MD5S23); + MD5_STEP (MD5_H1, a, b, c, d, w2[1], MD5C2c, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w3[0], MD5C2d, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w3[3], MD5C2e, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w0[2], MD5C2f, MD5S23); + + MD5_STEP (MD5_I , a, b, c, d, w0[0], MD5C30, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w1[3], MD5C31, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w3[2], MD5C32, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w1[1], MD5C33, MD5S33); + MD5_STEP (MD5_I , a, b, c, d, w3[0], MD5C34, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w0[3], MD5C35, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w2[2], MD5C36, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w0[1], MD5C37, MD5S33); + MD5_STEP (MD5_I , a, b, c, d, w2[0], MD5C38, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w3[3], MD5C39, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w1[2], MD5C3a, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w3[1], MD5C3b, MD5S33); + MD5_STEP (MD5_I , a, b, c, d, w1[0], MD5C3c, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w2[3], MD5C3d, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w0[2], MD5C3e, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w2[1], MD5C3f, MD5S33); + + a += make_u32x (MD5M_A); + b += make_u32x (MD5M_B); + c += make_u32x (MD5M_C); + d += make_u32x (MD5M_D); + + w0[0] = uint_to_hex_upper8 ((a >> 0) & 255) << 0 + | uint_to_hex_upper8 ((a >> 8) & 255) << 16; + w0[1] = uint_to_hex_upper8 ((a >> 16) & 255) << 0 + | uint_to_hex_upper8 ((a >> 24) & 255) << 16; + w0[2] = uint_to_hex_upper8 ((b >> 0) & 255) << 0 + | uint_to_hex_upper8 ((b >> 8) & 255) << 16; + w0[3] = uint_to_hex_upper8 ((b >> 16) & 255) << 0 + | uint_to_hex_upper8 ((b >> 24) & 255) << 16; + w1[0] = uint_to_hex_upper8 ((c >> 0) & 255) << 0 + | uint_to_hex_upper8 ((c >> 8) & 255) << 16; + w1[1] = uint_to_hex_upper8 ((c >> 16) & 255) << 0 + | uint_to_hex_upper8 ((c >> 24) & 255) << 16; + w1[2] = uint_to_hex_upper8 ((d >> 0) & 255) << 0 + | uint_to_hex_upper8 ((d >> 8) & 255) << 16; + w1[3] = uint_to_hex_upper8 ((d >> 16) & 255) << 0 + | uint_to_hex_upper8 ((d >> 24) & 255) << 16; + w2[0] = 0x80; + w2[1] = 0; + w2[2] = 0; + w2[3] = 0; + w3[0] = 0; + w3[1] = 0; + w3[2] = 0; + w3[3] = 0; + + /** + * prepend salt1 + */ + + switch_buffer_by_offset_le (w0, w1, w2, w3, salt1_len); + + w3[2] = pw_salt_len * 8; + w3[3] = 0; + + w0[0] |= salt1_buf0[0]; + w0[1] |= salt1_buf0[1]; + w0[2] |= salt1_buf0[2]; + w0[3] |= salt1_buf0[3]; + w1[0] |= salt1_buf1[0]; + w1[1] |= salt1_buf1[1]; + w1[2] |= salt1_buf1[2]; + w1[3] |= salt1_buf1[3]; + w2[0] |= salt1_buf2[0]; + w2[1] |= salt1_buf2[1]; + w2[2] |= salt1_buf2[2]; + w2[3] |= salt1_buf2[3]; + w3[0] |= salt1_buf3[0]; + w3[1] |= salt1_buf3[1]; + w3[2] |= salt1_buf3[2]; + w3[3] |= salt1_buf3[3]; + + /** + * md5 + */ + + a = MD5M_A; + b = MD5M_B; + c = MD5M_C; + d = MD5M_D; + + MD5_STEP (MD5_Fo, a, b, c, d, w0[0], MD5C00, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w0[1], MD5C01, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w0[2], MD5C02, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w0[3], MD5C03, MD5S03); + MD5_STEP (MD5_Fo, a, b, c, d, w1[0], MD5C04, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w1[1], MD5C05, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w1[2], MD5C06, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w1[3], MD5C07, MD5S03); + MD5_STEP (MD5_Fo, a, b, c, d, w2[0], MD5C08, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w2[1], MD5C09, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w2[2], MD5C0a, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w2[3], MD5C0b, MD5S03); + MD5_STEP (MD5_Fo, a, b, c, d, w3[0], MD5C0c, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w3[1], MD5C0d, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w3[2], MD5C0e, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w3[3], MD5C0f, MD5S03); + + MD5_STEP (MD5_Go, a, b, c, d, w0[1], MD5C10, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w1[2], MD5C11, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w2[3], MD5C12, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w0[0], MD5C13, MD5S13); + MD5_STEP (MD5_Go, a, b, c, d, w1[1], MD5C14, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w2[2], MD5C15, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w3[3], MD5C16, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w1[0], MD5C17, MD5S13); + MD5_STEP (MD5_Go, a, b, c, d, w2[1], MD5C18, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w3[2], MD5C19, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w0[3], MD5C1a, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w2[0], MD5C1b, MD5S13); + MD5_STEP (MD5_Go, a, b, c, d, w3[1], MD5C1c, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w0[2], MD5C1d, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w1[3], MD5C1e, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w3[0], MD5C1f, MD5S13); + + MD5_STEP (MD5_H1, a, b, c, d, w1[1], MD5C20, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w2[0], MD5C21, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w2[3], MD5C22, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w3[2], MD5C23, MD5S23); + MD5_STEP (MD5_H1, a, b, c, d, w0[1], MD5C24, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w1[0], MD5C25, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w1[3], MD5C26, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w2[2], MD5C27, MD5S23); + MD5_STEP (MD5_H1, a, b, c, d, w3[1], MD5C28, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w0[0], MD5C29, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w0[3], MD5C2a, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w1[2], MD5C2b, MD5S23); + MD5_STEP (MD5_H1, a, b, c, d, w2[1], MD5C2c, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w3[0], MD5C2d, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w3[3], MD5C2e, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w0[2], MD5C2f, MD5S23); + + MD5_STEP (MD5_I , a, b, c, d, w0[0], MD5C30, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w1[3], MD5C31, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w3[2], MD5C32, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w1[1], MD5C33, MD5S33); + MD5_STEP (MD5_I , a, b, c, d, w3[0], MD5C34, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w0[3], MD5C35, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w2[2], MD5C36, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w0[1], MD5C37, MD5S33); + MD5_STEP (MD5_I , a, b, c, d, w2[0], MD5C38, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w3[3], MD5C39, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w1[2], MD5C3a, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w3[1], MD5C3b, MD5S33); + MD5_STEP (MD5_I , a, b, c, d, w1[0], MD5C3c, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w2[3], MD5C3d, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w0[2], MD5C3e, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w2[1], MD5C3f, MD5S33); + + COMPARE_M_SIMD (a, d, c, b); + } +} + +KERNEL_FQ void m03730_m08 (KERN_ATTR_RULES_ESALT (md5_double_salt_t)) +{ +} + +KERNEL_FQ void m03730_m16 (KERN_ATTR_RULES_ESALT (md5_double_salt_t)) +{ +} + +KERNEL_FQ void m03730_s04 (KERN_ATTR_RULES_ESALT (md5_double_salt_t)) +{ + /** + * modifier + */ + + const u64 gid = get_global_id (0); + const u64 lid = get_local_id (0); + const u64 lsz = get_local_size (0); + + /** + * bin2asc uppercase array + */ + LOCAL_VK u32 u_bin2asc[256]; + + for (u32 j = lid; j < 256; j += lsz) + { + const u32 i0 = (j >> 0) & 15; + const u32 i1 = (j >> 4) & 15; + + u_bin2asc[j] = ((i0 < 10) ? '0' + i0 : 'A' - 10 + i0) << 8 + | ((i1 < 10) ? '0' + i1 : 'A' - 10 + i1) << 0; + } + + SYNC_THREADS (); + + 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_len = pws[gid].pw_len & 63; + + /** + * salt1 + */ + + u32 salt1_buf0[4]; + u32 salt1_buf1[4]; + u32 salt1_buf2[4]; + u32 salt1_buf3[4]; + + salt1_buf0[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 0]; + salt1_buf0[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 1]; + salt1_buf0[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 2]; + salt1_buf0[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 3]; + salt1_buf1[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 4]; + salt1_buf1[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 5]; + salt1_buf1[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 6]; + salt1_buf1[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 7]; + salt1_buf2[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 8]; + salt1_buf2[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 9]; + salt1_buf2[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[10]; + salt1_buf2[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[11]; + salt1_buf3[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[12]; + salt1_buf3[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[13]; + salt1_buf3[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[14]; + salt1_buf3[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[15]; + + const u32 salt1_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_len; + + /** + * salt2 + */ + + u32 salt2_buf0[4]; + u32 salt2_buf1[4]; + u32 salt2_buf2[4]; + u32 salt2_buf3[4]; + + salt2_buf0[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 0]; + salt2_buf0[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 1]; + salt2_buf0[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 2]; + salt2_buf0[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 3]; + salt2_buf1[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 4]; + salt2_buf1[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 5]; + salt2_buf1[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 6]; + salt2_buf1[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 7]; + salt2_buf2[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 8]; + salt2_buf2[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 9]; + salt2_buf2[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[10]; + salt2_buf2[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[11]; + salt2_buf3[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[12]; + salt2_buf3[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[13]; + salt2_buf3[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[14]; + salt2_buf3[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[15]; + + const u32 salt2_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_len; + + const u32 pw_salt_len = 32 + salt2_len; + + /** + * 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] + }; + + /** + * loop + */ + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) + { + u32x w0[4] = { 0 }; + u32x w1[4] = { 0 }; + u32x w2[4] = { 0 }; + u32x w3[4] = { 0 }; + + const u32x out_len = apply_rules_vect_optimized (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w0, w1); + + /** + * prepend salt2 + */ + + const u32x out_salt_len = salt2_len + out_len; + + switch_buffer_by_offset_le (w0, w1, w2, w3, salt2_len); + + w0[0] |= salt2_buf0[0]; + w0[1] |= salt2_buf0[1]; + w0[2] |= salt2_buf0[2]; + w0[3] |= salt2_buf0[3]; + w1[0] |= salt2_buf1[0]; + w1[1] |= salt2_buf1[1]; + w1[2] |= salt2_buf1[2]; + w1[3] |= salt2_buf1[3]; + w2[0] |= salt2_buf2[0]; + w2[1] |= salt2_buf2[1]; + w2[2] |= salt2_buf2[2]; + w2[3] |= salt2_buf2[3]; + w3[0] |= salt2_buf3[0]; + w3[1] |= salt2_buf3[1]; + w3[2] = out_salt_len * 8; + w3[3] = 0; + + append_0x80_4x4_VV (w0, w1, w2, w3, out_salt_len); + + /** + * md5 + */ + + u32x a = MD5M_A; + u32x b = MD5M_B; + u32x c = MD5M_C; + u32x d = MD5M_D; + + MD5_STEP (MD5_Fo, a, b, c, d, w0[0], MD5C00, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w0[1], MD5C01, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w0[2], MD5C02, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w0[3], MD5C03, MD5S03); + MD5_STEP (MD5_Fo, a, b, c, d, w1[0], MD5C04, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w1[1], MD5C05, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w1[2], MD5C06, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w1[3], MD5C07, MD5S03); + MD5_STEP (MD5_Fo, a, b, c, d, w2[0], MD5C08, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w2[1], MD5C09, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w2[2], MD5C0a, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w2[3], MD5C0b, MD5S03); + MD5_STEP (MD5_Fo, a, b, c, d, w3[0], MD5C0c, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w3[1], MD5C0d, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w3[2], MD5C0e, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w3[3], MD5C0f, MD5S03); + + MD5_STEP (MD5_Go, a, b, c, d, w0[1], MD5C10, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w1[2], MD5C11, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w2[3], MD5C12, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w0[0], MD5C13, MD5S13); + MD5_STEP (MD5_Go, a, b, c, d, w1[1], MD5C14, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w2[2], MD5C15, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w3[3], MD5C16, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w1[0], MD5C17, MD5S13); + MD5_STEP (MD5_Go, a, b, c, d, w2[1], MD5C18, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w3[2], MD5C19, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w0[3], MD5C1a, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w2[0], MD5C1b, MD5S13); + MD5_STEP (MD5_Go, a, b, c, d, w3[1], MD5C1c, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w0[2], MD5C1d, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w1[3], MD5C1e, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w3[0], MD5C1f, MD5S13); + + u32x t; + + MD5_STEP (MD5_H1, a, b, c, d, w1[1], MD5C20, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w2[0], MD5C21, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w2[3], MD5C22, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w3[2], MD5C23, MD5S23); + MD5_STEP (MD5_H1, a, b, c, d, w0[1], MD5C24, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w1[0], MD5C25, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w1[3], MD5C26, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w2[2], MD5C27, MD5S23); + MD5_STEP (MD5_H1, a, b, c, d, w3[1], MD5C28, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w0[0], MD5C29, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w0[3], MD5C2a, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w1[2], MD5C2b, MD5S23); + MD5_STEP (MD5_H1, a, b, c, d, w2[1], MD5C2c, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w3[0], MD5C2d, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w3[3], MD5C2e, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w0[2], MD5C2f, MD5S23); + + MD5_STEP (MD5_I , a, b, c, d, w0[0], MD5C30, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w1[3], MD5C31, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w3[2], MD5C32, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w1[1], MD5C33, MD5S33); + MD5_STEP (MD5_I , a, b, c, d, w3[0], MD5C34, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w0[3], MD5C35, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w2[2], MD5C36, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w0[1], MD5C37, MD5S33); + MD5_STEP (MD5_I , a, b, c, d, w2[0], MD5C38, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w3[3], MD5C39, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w1[2], MD5C3a, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w3[1], MD5C3b, MD5S33); + MD5_STEP (MD5_I , a, b, c, d, w1[0], MD5C3c, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w2[3], MD5C3d, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w0[2], MD5C3e, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w2[1], MD5C3f, MD5S33); + + a += make_u32x (MD5M_A); + b += make_u32x (MD5M_B); + c += make_u32x (MD5M_C); + d += make_u32x (MD5M_D); + + w0[0] = uint_to_hex_upper8 ((a >> 0) & 255) << 0 + | uint_to_hex_upper8 ((a >> 8) & 255) << 16; + w0[1] = uint_to_hex_upper8 ((a >> 16) & 255) << 0 + | uint_to_hex_upper8 ((a >> 24) & 255) << 16; + w0[2] = uint_to_hex_upper8 ((b >> 0) & 255) << 0 + | uint_to_hex_upper8 ((b >> 8) & 255) << 16; + w0[3] = uint_to_hex_upper8 ((b >> 16) & 255) << 0 + | uint_to_hex_upper8 ((b >> 24) & 255) << 16; + w1[0] = uint_to_hex_upper8 ((c >> 0) & 255) << 0 + | uint_to_hex_upper8 ((c >> 8) & 255) << 16; + w1[1] = uint_to_hex_upper8 ((c >> 16) & 255) << 0 + | uint_to_hex_upper8 ((c >> 24) & 255) << 16; + w1[2] = uint_to_hex_upper8 ((d >> 0) & 255) << 0 + | uint_to_hex_upper8 ((d >> 8) & 255) << 16; + w1[3] = uint_to_hex_upper8 ((d >> 16) & 255) << 0 + | uint_to_hex_upper8 ((d >> 24) & 255) << 16; + w2[0] = 0x80; + w2[1] = 0; + w2[2] = 0; + w2[3] = 0; + w3[0] = 0; + w3[1] = 0; + w3[2] = 0; + w3[3] = 0; + + /** + * prepend salt1 + */ + + switch_buffer_by_offset_le (w0, w1, w2, w3, salt1_len); + + w3[2] = pw_salt_len * 8; + w3[3] = 0; + + w0[0] |= salt1_buf0[0]; + w0[1] |= salt1_buf0[1]; + w0[2] |= salt1_buf0[2]; + w0[3] |= salt1_buf0[3]; + w1[0] |= salt1_buf1[0]; + w1[1] |= salt1_buf1[1]; + w1[2] |= salt1_buf1[2]; + w1[3] |= salt1_buf1[3]; + w2[0] |= salt1_buf2[0]; + w2[1] |= salt1_buf2[1]; + w2[2] |= salt1_buf2[2]; + w2[3] |= salt1_buf2[3]; + w3[0] |= salt1_buf3[0]; + w3[1] |= salt1_buf3[1]; + w3[2] |= salt1_buf3[2]; + w3[3] |= salt1_buf3[3]; + + /** + * md5 + */ + + a = MD5M_A; + b = MD5M_B; + c = MD5M_C; + d = MD5M_D; + + MD5_STEP (MD5_Fo, a, b, c, d, w0[0], MD5C00, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w0[1], MD5C01, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w0[2], MD5C02, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w0[3], MD5C03, MD5S03); + MD5_STEP (MD5_Fo, a, b, c, d, w1[0], MD5C04, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w1[1], MD5C05, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w1[2], MD5C06, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w1[3], MD5C07, MD5S03); + MD5_STEP (MD5_Fo, a, b, c, d, w2[0], MD5C08, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w2[1], MD5C09, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w2[2], MD5C0a, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w2[3], MD5C0b, MD5S03); + MD5_STEP (MD5_Fo, a, b, c, d, w3[0], MD5C0c, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w3[1], MD5C0d, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w3[2], MD5C0e, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w3[3], MD5C0f, MD5S03); + + MD5_STEP (MD5_Go, a, b, c, d, w0[1], MD5C10, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w1[2], MD5C11, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w2[3], MD5C12, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w0[0], MD5C13, MD5S13); + MD5_STEP (MD5_Go, a, b, c, d, w1[1], MD5C14, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w2[2], MD5C15, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w3[3], MD5C16, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w1[0], MD5C17, MD5S13); + MD5_STEP (MD5_Go, a, b, c, d, w2[1], MD5C18, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w3[2], MD5C19, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w0[3], MD5C1a, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w2[0], MD5C1b, MD5S13); + MD5_STEP (MD5_Go, a, b, c, d, w3[1], MD5C1c, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w0[2], MD5C1d, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w1[3], MD5C1e, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w3[0], MD5C1f, MD5S13); + + MD5_STEP (MD5_H1, a, b, c, d, w1[1], MD5C20, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w2[0], MD5C21, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w2[3], MD5C22, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w3[2], MD5C23, MD5S23); + MD5_STEP (MD5_H1, a, b, c, d, w0[1], MD5C24, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w1[0], MD5C25, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w1[3], MD5C26, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w2[2], MD5C27, MD5S23); + MD5_STEP (MD5_H1, a, b, c, d, w3[1], MD5C28, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w0[0], MD5C29, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w0[3], MD5C2a, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w1[2], MD5C2b, MD5S23); + MD5_STEP (MD5_H1, a, b, c, d, w2[1], MD5C2c, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w3[0], MD5C2d, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w3[3], MD5C2e, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w0[2], MD5C2f, MD5S23); + + MD5_STEP (MD5_I , a, b, c, d, w0[0], MD5C30, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w1[3], MD5C31, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w3[2], MD5C32, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w1[1], MD5C33, MD5S33); + MD5_STEP (MD5_I , a, b, c, d, w3[0], MD5C34, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w0[3], MD5C35, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w2[2], MD5C36, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w0[1], MD5C37, MD5S33); + MD5_STEP (MD5_I , a, b, c, d, w2[0], MD5C38, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w3[3], MD5C39, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w1[2], MD5C3a, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w3[1], MD5C3b, MD5S33); + MD5_STEP (MD5_I , a, b, c, d, w1[0], MD5C3c, MD5S30); + + if (MATCHES_NONE_VS (a, search[0])) continue; + + MD5_STEP (MD5_I , d, a, b, c, w2[3], MD5C3d, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w0[2], MD5C3e, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w2[1], MD5C3f, MD5S33); + + COMPARE_S_SIMD (a, d, c, b); + } +} + +KERNEL_FQ void m03730_s08 (KERN_ATTR_RULES_ESALT (md5_double_salt_t)) +{ +} + +KERNEL_FQ void m03730_s16 (KERN_ATTR_RULES_ESALT (md5_double_salt_t)) +{ +} diff --git a/OpenCL/m03730_a0-pure.cl b/OpenCL/m03730_a0-pure.cl new file mode 100644 index 000000000..322120f00 --- /dev/null +++ b/OpenCL/m03730_a0-pure.cl @@ -0,0 +1,309 @@ +/** + * 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) +#include M2S(INCLUDE_PATH/inc_hash_md5.cl) +#endif + +#if VECT_SIZE == 1 +#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i)]) +#elif VECT_SIZE == 2 +#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i).s0], u_bin2asc[(i).s1]) +#elif VECT_SIZE == 4 +#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i).s0], u_bin2asc[(i).s1], u_bin2asc[(i).s2], u_bin2asc[(i).s3]) +#elif VECT_SIZE == 8 +#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i).s0], u_bin2asc[(i).s1], u_bin2asc[(i).s2], u_bin2asc[(i).s3], u_bin2asc[(i).s4], u_bin2asc[(i).s5], u_bin2asc[(i).s6], u_bin2asc[(i).s7]) +#elif VECT_SIZE == 16 +#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i).s0], u_bin2asc[(i).s1], u_bin2asc[(i).s2], u_bin2asc[(i).s3], u_bin2asc[(i).s4], u_bin2asc[(i).s5], u_bin2asc[(i).s6], u_bin2asc[(i).s7], u_bin2asc[(i).s8], u_bin2asc[(i).s9], u_bin2asc[(i).sa], u_bin2asc[(i).sb], u_bin2asc[(i).sc], u_bin2asc[(i).sd], u_bin2asc[(i).se], u_bin2asc[(i).sf]) +#endif + +typedef struct md5_double_salt +{ + u32 salt1_buf[64]; + int salt1_len; + + u32 salt2_buf[64]; + int salt2_len; + +} md5_double_salt_t; + + +KERNEL_FQ void m03730_mxx (KERN_ATTR_RULES_ESALT (md5_double_salt_t)) +{ + /** + * modifier + */ + + const u64 gid = get_global_id (0); + const u64 lid = get_local_id (0); + const u64 lsz = get_local_size (0); + + /** + * bin2asc uppercase table + */ + + LOCAL_VK u32 u_bin2asc[256]; + + for (u32 j = lid; j < 256; j += lsz) + { + const u32 i0 = (j >> 0) & 15; + const u32 i1 = (j >> 4) & 15; + + u_bin2asc[j] = ((i0 < 10) ? '0' + i0 : 'A' - 10 + i0) << 8 + | ((i1 < 10) ? '0' + i1 : 'A' - 10 + i1) << 0; + } + + SYNC_THREADS (); + + if (gid >= GID_CNT) return; + + /** + * base + */ + + COPY_PW (pws[gid]); + + const u32 salt_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_len; + + u32 s[64] = { 0 }; + + for (u32 i = 0, idx = 0; i < salt_len; i += 4, idx += 1) + { + s[idx] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[idx]; + } + + const int salt2_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_len; + + u32 s2[64] = { 0 }; + + for (int i = 0, idx = 0; i < salt2_len; i += 4, idx += 1) + { + s2[idx] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[idx]; + } + + md5_ctx_t ctx0; + + md5_init (&ctx0); + + md5_update_global (&ctx0, esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf, esalt_bufs[DIGESTS_OFFSET_HOST].salt2_len); + /** + * 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); + + md5_ctx_t ctx1 = ctx0; + + md5_update (&ctx1, tmp.i, tmp.pw_len); + + md5_final (&ctx1); + + const u32 a = ctx1.h[0]; + const u32 b = ctx1.h[1]; + const u32 c = ctx1.h[2]; + const u32 d = ctx1.h[3]; + + md5_ctx_t ctx; + + md5_init (&ctx); + + md5_update (&ctx, s, salt_len); + + u32 w0[4]; + u32 w1[4]; + u32 w2[4]; + u32 w3[4]; + + w0[0] = uint_to_hex_upper8 ((a >> 0) & 255) << 0 + | uint_to_hex_upper8 ((a >> 8) & 255) << 16; + w0[1] = uint_to_hex_upper8 ((a >> 16) & 255) << 0 + | uint_to_hex_upper8 ((a >> 24) & 255) << 16; + w0[2] = uint_to_hex_upper8 ((b >> 0) & 255) << 0 + | uint_to_hex_upper8 ((b >> 8) & 255) << 16; + w0[3] = uint_to_hex_upper8 ((b >> 16) & 255) << 0 + | uint_to_hex_upper8 ((b >> 24) & 255) << 16; + w1[0] = uint_to_hex_upper8 ((c >> 0) & 255) << 0 + | uint_to_hex_upper8 ((c >> 8) & 255) << 16; + w1[1] = uint_to_hex_upper8 ((c >> 16) & 255) << 0 + | uint_to_hex_upper8 ((c >> 24) & 255) << 16; + w1[2] = uint_to_hex_upper8 ((d >> 0) & 255) << 0 + | uint_to_hex_upper8 ((d >> 8) & 255) << 16; + w1[3] = uint_to_hex_upper8 ((d >> 16) & 255) << 0 + | uint_to_hex_upper8 ((d >> 24) & 255) << 16; + w2[0] = 0; + w2[1] = 0; + w2[2] = 0; + w2[3] = 0; + w3[0] = 0; + w3[1] = 0; + w3[2] = 0; + w3[3] = 0; + + md5_update_64 (&ctx, w0, w1, w2, w3, 32); + + md5_final (&ctx); + + const u32 r0 = ctx.h[DGST_R0]; + const u32 r1 = ctx.h[DGST_R1]; + const u32 r2 = ctx.h[DGST_R2]; + const u32 r3 = ctx.h[DGST_R3]; + + COMPARE_M_SCALAR (r0, r1, r2, r3); + } +} + +KERNEL_FQ void m03730_sxx (KERN_ATTR_RULES_ESALT (md5_double_salt_t)) +{ + /** + * modifier + */ + + const u64 gid = get_global_id (0); + const u64 lid = get_local_id (0); + const u64 lsz = get_local_size (0); + + /** + * bin2asc uppercase table + */ + LOCAL_VK u32 u_bin2asc[256]; + + for (u32 j = lid; j < 256; j += lsz) + { + const u32 i0 = (j >> 0) & 15; + const u32 i1 = (j >> 4) & 15; + + u_bin2asc[j] = ((i0 < 10) ? '0' + i0 : 'A' - 10 + i0) << 8 + | ((i1 < 10) ? '0' + i1 : 'A' - 10 + i1) << 0; + } + + SYNC_THREADS (); + + 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], + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R2], + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R3] + }; + + /** + * base + */ + + COPY_PW (pws[gid]); + + const u32 salt_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_len; + + u32 s[64] = { 0 }; + + for (u32 i = 0, idx = 0; i < salt_len; i += 4, idx += 1) + { + s[idx] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[idx]; + } + + const int salt2_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_len; + + u32 s2[64] = { 0 }; + + for (u32 i = 0, idx = 0; i < salt2_len; i += 4, idx += 1) + { + s2[idx] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[idx]; + } + + md5_ctx_t ctx0; + + md5_init (&ctx0); + + md5_update_global (&ctx0, esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf, esalt_bufs[DIGESTS_OFFSET_HOST].salt1_len); + + /** + * 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); + + md5_ctx_t ctx1 = ctx0; + + md5_update (&ctx1, tmp.i, tmp.pw_len); + + md5_final (&ctx1); + + const u32 a = ctx1.h[0]; + const u32 b = ctx1.h[1]; + const u32 c = ctx1.h[2]; + const u32 d = ctx1.h[3]; + + md5_ctx_t ctx; + + md5_init (&ctx); + + md5_update (&ctx, s, salt_len); + + u32 w0[4]; + u32 w1[4]; + u32 w2[4]; + u32 w3[4]; + + w0[0] = uint_to_hex_upper8 ((a >> 0) & 255) << 0 + | uint_to_hex_upper8 ((a >> 8) & 255) << 16; + w0[1] = uint_to_hex_upper8 ((a >> 16) & 255) << 0 + | uint_to_hex_upper8 ((a >> 24) & 255) << 16; + w0[2] = uint_to_hex_upper8 ((b >> 0) & 255) << 0 + | uint_to_hex_upper8 ((b >> 8) & 255) << 16; + w0[3] = uint_to_hex_upper8 ((b >> 16) & 255) << 0 + | uint_to_hex_upper8 ((b >> 24) & 255) << 16; + w1[0] = uint_to_hex_upper8 ((c >> 0) & 255) << 0 + | uint_to_hex_upper8 ((c >> 8) & 255) << 16; + w1[1] = uint_to_hex_upper8 ((c >> 16) & 255) << 0 + | uint_to_hex_upper8 ((c >> 24) & 255) << 16; + w1[2] = uint_to_hex_upper8 ((d >> 0) & 255) << 0 + | uint_to_hex_upper8 ((d >> 8) & 255) << 16; + w1[3] = uint_to_hex_upper8 ((d >> 16) & 255) << 0 + | uint_to_hex_upper8 ((d >> 24) & 255) << 16; + w2[0] = 0; + w2[1] = 0; + w2[2] = 0; + w2[3] = 0; + w3[0] = 0; + w3[1] = 0; + w3[2] = 0; + w3[3] = 0; + + md5_update_64 (&ctx, w0, w1, w2, w3, 32); + + md5_final (&ctx); + + const u32 r0 = ctx.h[DGST_R0]; + const u32 r1 = ctx.h[DGST_R1]; + const u32 r2 = ctx.h[DGST_R2]; + const u32 r3 = ctx.h[DGST_R3]; + + COMPARE_S_SCALAR (r0, r1, r2, r3); + } +} diff --git a/OpenCL/m03730_a1-optimized.cl b/OpenCL/m03730_a1-optimized.cl new file mode 100644 index 000000000..69a6b1736 --- /dev/null +++ b/OpenCL/m03730_a1-optimized.cl @@ -0,0 +1,906 @@ +/** + * 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 + +#if VECT_SIZE == 1 +#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i)]) +#elif VECT_SIZE == 2 +#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i).s0], u_bin2asc[(i).s1]) +#elif VECT_SIZE == 4 +#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i).s0], u_bin2asc[(i).s1], u_bin2asc[(i).s2], u_bin2asc[(i).s3]) +#elif VECT_SIZE == 8 +#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i).s0], u_bin2asc[(i).s1], u_bin2asc[(i).s2], u_bin2asc[(i).s3], u_bin2asc[(i).s4], u_bin2asc[(i).s5], u_bin2asc[(i).s6], u_bin2asc[(i).s7]) +#elif VECT_SIZE == 16 +#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i).s0], u_bin2asc[(i).s1], u_bin2asc[(i).s2], u_bin2asc[(i).s3], u_bin2asc[(i).s4], u_bin2asc[(i).s5], u_bin2asc[(i).s6], u_bin2asc[(i).s7], u_bin2asc[(i).s8], u_bin2asc[(i).s9], u_bin2asc[(i).sa], u_bin2asc[(i).sb], u_bin2asc[(i).sc], u_bin2asc[(i).sd], u_bin2asc[(i).se], u_bin2asc[(i).sf]) +#endif + +typedef struct md5_double_salt +{ + u32 salt1_buf[64]; + int salt1_len; + + u32 salt2_buf[64]; + int salt2_len; + +} md5_double_salt_t; + +KERNEL_FQ void m03730_m04 (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) +{ + /** + * modifier + */ + + const u64 gid = get_global_id (0); + const u64 lid = get_local_id (0); + const u64 lsz = get_local_size (0); + + /** + * bin2asc uppercase table + */ + + LOCAL_VK u32 u_bin2asc[256]; + + for (u32 j = lid; j < 256; j += lsz) + { + const u32 i0 = (j >> 0) & 15; + const u32 i1 = (j >> 4) & 15; + + u_bin2asc[j] = ((i0 < 10) ? '0' + i0 : 'A' - 10 + i0) << 8 + | ((i1 < 10) ? '0' + i1 : 'A' - 10 + i1) << 0; + } + + SYNC_THREADS (); + + 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; + + /** + * salt1 + */ + + u32 salt1_buf0[4]; + u32 salt1_buf1[4]; + u32 salt1_buf2[4]; + u32 salt1_buf3[4]; + + salt1_buf0[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 0]; + salt1_buf0[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 1]; + salt1_buf0[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 2]; + salt1_buf0[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 3]; + salt1_buf1[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 4]; + salt1_buf1[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 5]; + salt1_buf1[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 6]; + salt1_buf1[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 7]; + salt1_buf2[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 8]; + salt1_buf2[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 9]; + salt1_buf2[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[10]; + salt1_buf2[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[11]; + salt1_buf3[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[12]; + salt1_buf3[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[13]; + salt1_buf3[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[14]; + salt1_buf3[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[15]; + + const u32 salt1_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_len; + + /** + * salt2 + */ + + u32 salt2_buf0[4]; + u32 salt2_buf1[4]; + u32 salt2_buf2[4]; + u32 salt2_buf3[4]; + + salt2_buf0[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 0]; + salt2_buf0[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 1]; + salt2_buf0[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 2]; + salt2_buf0[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 3]; + salt2_buf1[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 4]; + salt2_buf1[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 5]; + salt2_buf1[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 6]; + salt2_buf1[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 7]; + salt2_buf2[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 8]; + salt2_buf2[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 9]; + salt2_buf2[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[10]; + salt2_buf2[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[11]; + salt2_buf3[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[12]; + salt2_buf3[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[13]; + salt2_buf3[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[14]; + salt2_buf3[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[15]; + + const u32 salt2_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_len; + + const u32 final_len = salt1_len + 32; + + /** + * loop + */ + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) + { + const u32x pw_r_len = pwlenx_create_combt (combs_buf, il_pos) & 63; + + const u32x pw_len = (pw_l_len + pw_r_len) & 63; + + /** + * concat password candidate + */ + + u32x wordl0[4] = { 0 }; + u32x wordl1[4] = { 0 }; + u32x wordl2[4] = { 0 }; + u32x 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]; + + u32x wordr0[4] = { 0 }; + u32x wordr1[4] = { 0 }; + u32x wordr2[4] = { 0 }; + u32x 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); + } + + u32x w0[4]; + u32x w1[4]; + u32x w2[4]; + u32x w3[4]; + + w0[0] = wordl0[0] | wordr0[0]; + w0[1] = wordl0[1] | wordr0[1]; + w0[2] = wordl0[2] | wordr0[2]; + w0[3] = wordl0[3] | wordr0[3]; + w1[0] = wordl1[0] | wordr1[0]; + w1[1] = wordl1[1] | wordr1[1]; + w1[2] = wordl1[2] | wordr1[2]; + w1[3] = wordl1[3] | wordr1[3]; + w2[0] = wordl2[0] | wordr2[0]; + w2[1] = wordl2[1] | wordr2[1]; + w2[2] = wordl2[2] | wordr2[2]; + w2[3] = wordl2[3] | wordr2[3]; + w3[0] = wordl3[0] | wordr3[0]; + w3[1] = wordl3[1] | wordr3[1]; + w3[2] = pw_len * 8; + w3[3] = 0; + + /** + * prepend salt2 + */ + + switch_buffer_by_offset_le (w0, w1, w2, w3, salt2_len); + + const u32x pw_salt_len = pw_len + salt2_len; + + w0[0] |= salt2_buf0[0]; + w0[1] |= salt2_buf0[1]; + w0[2] |= salt2_buf0[2]; + w0[3] |= salt2_buf0[3]; + w1[0] |= salt2_buf1[0]; + w1[1] |= salt2_buf1[1]; + w1[2] |= salt2_buf1[2]; + w1[3] |= salt2_buf1[3]; + w2[0] |= salt2_buf2[0]; + w2[1] |= salt2_buf2[1]; + w2[2] |= salt2_buf2[2]; + w2[3] |= salt2_buf2[3]; + w3[0] |= salt2_buf3[0]; + w3[1] |= salt2_buf3[1]; + w3[2] = pw_salt_len * 8; + w3[3] = 0; + + /** + * md5 + */ + + u32x a = MD5M_A; + u32x b = MD5M_B; + u32x c = MD5M_C; + u32x d = MD5M_D; + + MD5_STEP (MD5_Fo, a, b, c, d, w0[0], MD5C00, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w0[1], MD5C01, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w0[2], MD5C02, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w0[3], MD5C03, MD5S03); + MD5_STEP (MD5_Fo, a, b, c, d, w1[0], MD5C04, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w1[1], MD5C05, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w1[2], MD5C06, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w1[3], MD5C07, MD5S03); + MD5_STEP (MD5_Fo, a, b, c, d, w2[0], MD5C08, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w2[1], MD5C09, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w2[2], MD5C0a, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w2[3], MD5C0b, MD5S03); + MD5_STEP (MD5_Fo, a, b, c, d, w3[0], MD5C0c, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w3[1], MD5C0d, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w3[2], MD5C0e, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w3[3], MD5C0f, MD5S03); + + MD5_STEP (MD5_Go, a, b, c, d, w0[1], MD5C10, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w1[2], MD5C11, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w2[3], MD5C12, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w0[0], MD5C13, MD5S13); + MD5_STEP (MD5_Go, a, b, c, d, w1[1], MD5C14, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w2[2], MD5C15, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w3[3], MD5C16, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w1[0], MD5C17, MD5S13); + MD5_STEP (MD5_Go, a, b, c, d, w2[1], MD5C18, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w3[2], MD5C19, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w0[3], MD5C1a, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w2[0], MD5C1b, MD5S13); + MD5_STEP (MD5_Go, a, b, c, d, w3[1], MD5C1c, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w0[2], MD5C1d, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w1[3], MD5C1e, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w3[0], MD5C1f, MD5S13); + + u32x t; + + MD5_STEP (MD5_H1, a, b, c, d, w1[1], MD5C20, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w2[0], MD5C21, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w2[3], MD5C22, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w3[2], MD5C23, MD5S23); + MD5_STEP (MD5_H1, a, b, c, d, w0[1], MD5C24, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w1[0], MD5C25, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w1[3], MD5C26, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w2[2], MD5C27, MD5S23); + MD5_STEP (MD5_H1, a, b, c, d, w3[1], MD5C28, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w0[0], MD5C29, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w0[3], MD5C2a, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w1[2], MD5C2b, MD5S23); + MD5_STEP (MD5_H1, a, b, c, d, w2[1], MD5C2c, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w3[0], MD5C2d, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w3[3], MD5C2e, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w0[2], MD5C2f, MD5S23); + + MD5_STEP (MD5_I , a, b, c, d, w0[0], MD5C30, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w1[3], MD5C31, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w3[2], MD5C32, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w1[1], MD5C33, MD5S33); + MD5_STEP (MD5_I , a, b, c, d, w3[0], MD5C34, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w0[3], MD5C35, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w2[2], MD5C36, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w0[1], MD5C37, MD5S33); + MD5_STEP (MD5_I , a, b, c, d, w2[0], MD5C38, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w3[3], MD5C39, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w1[2], MD5C3a, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w3[1], MD5C3b, MD5S33); + MD5_STEP (MD5_I , a, b, c, d, w1[0], MD5C3c, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w2[3], MD5C3d, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w0[2], MD5C3e, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w2[1], MD5C3f, MD5S33); + + a += make_u32x (MD5M_A); + b += make_u32x (MD5M_B); + c += make_u32x (MD5M_C); + d += make_u32x (MD5M_D); + + w0[0] = uint_to_hex_upper8 ((a >> 0) & 255) << 0 + | uint_to_hex_upper8 ((a >> 8) & 255) << 16; + w0[1] = uint_to_hex_upper8 ((a >> 16) & 255) << 0 + | uint_to_hex_upper8 ((a >> 24) & 255) << 16; + w0[2] = uint_to_hex_upper8 ((b >> 0) & 255) << 0 + | uint_to_hex_upper8 ((b >> 8) & 255) << 16; + w0[3] = uint_to_hex_upper8 ((b >> 16) & 255) << 0 + | uint_to_hex_upper8 ((b >> 24) & 255) << 16; + w1[0] = uint_to_hex_upper8 ((c >> 0) & 255) << 0 + | uint_to_hex_upper8 ((c >> 8) & 255) << 16; + w1[1] = uint_to_hex_upper8 ((c >> 16) & 255) << 0 + | uint_to_hex_upper8 ((c >> 24) & 255) << 16; + w1[2] = uint_to_hex_upper8 ((d >> 0) & 255) << 0 + | uint_to_hex_upper8 ((d >> 8) & 255) << 16; + w1[3] = uint_to_hex_upper8 ((d >> 16) & 255) << 0 + | uint_to_hex_upper8 ((d >> 24) & 255) << 16; + w2[0] = 0x80; + w2[1] = 0; + w2[2] = 0; + w2[3] = 0; + w3[0] = 0; + w3[1] = 0; + w3[2] = 0; + w3[3] = 0; + + /** + * prepend salt1 + */ + + switch_buffer_by_offset_le (w0, w1, w2, w3, salt1_len); + + w3[2] = final_len * 8; + w3[3] = 0; + + w0[0] |= salt1_buf0[0]; + w0[1] |= salt1_buf0[1]; + w0[2] |= salt1_buf0[2]; + w0[3] |= salt1_buf0[3]; + w1[0] |= salt1_buf1[0]; + w1[1] |= salt1_buf1[1]; + w1[2] |= salt1_buf1[2]; + w1[3] |= salt1_buf1[3]; + w2[0] |= salt1_buf2[0]; + w2[1] |= salt1_buf2[1]; + w2[2] |= salt1_buf2[2]; + w2[3] |= salt1_buf2[3]; + w3[0] |= salt1_buf3[0]; + w3[1] |= salt1_buf3[1]; + w3[2] |= salt1_buf3[2]; + w3[3] |= salt1_buf3[3]; + + /** + * md5 + */ + + a = MD5M_A; + b = MD5M_B; + c = MD5M_C; + d = MD5M_D; + + MD5_STEP (MD5_Fo, a, b, c, d, w0[0], MD5C00, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w0[1], MD5C01, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w0[2], MD5C02, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w0[3], MD5C03, MD5S03); + MD5_STEP (MD5_Fo, a, b, c, d, w1[0], MD5C04, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w1[1], MD5C05, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w1[2], MD5C06, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w1[3], MD5C07, MD5S03); + MD5_STEP (MD5_Fo, a, b, c, d, w2[0], MD5C08, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w2[1], MD5C09, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w2[2], MD5C0a, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w2[3], MD5C0b, MD5S03); + MD5_STEP (MD5_Fo, a, b, c, d, w3[0], MD5C0c, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w3[1], MD5C0d, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w3[2], MD5C0e, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w3[3], MD5C0f, MD5S03); + + MD5_STEP (MD5_Go, a, b, c, d, w0[1], MD5C10, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w1[2], MD5C11, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w2[3], MD5C12, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w0[0], MD5C13, MD5S13); + MD5_STEP (MD5_Go, a, b, c, d, w1[1], MD5C14, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w2[2], MD5C15, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w3[3], MD5C16, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w1[0], MD5C17, MD5S13); + MD5_STEP (MD5_Go, a, b, c, d, w2[1], MD5C18, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w3[2], MD5C19, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w0[3], MD5C1a, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w2[0], MD5C1b, MD5S13); + MD5_STEP (MD5_Go, a, b, c, d, w3[1], MD5C1c, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w0[2], MD5C1d, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w1[3], MD5C1e, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w3[0], MD5C1f, MD5S13); + + MD5_STEP (MD5_H1, a, b, c, d, w1[1], MD5C20, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w2[0], MD5C21, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w2[3], MD5C22, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w3[2], MD5C23, MD5S23); + MD5_STEP (MD5_H1, a, b, c, d, w0[1], MD5C24, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w1[0], MD5C25, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w1[3], MD5C26, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w2[2], MD5C27, MD5S23); + MD5_STEP (MD5_H1, a, b, c, d, w3[1], MD5C28, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w0[0], MD5C29, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w0[3], MD5C2a, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w1[2], MD5C2b, MD5S23); + MD5_STEP (MD5_H1, a, b, c, d, w2[1], MD5C2c, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w3[0], MD5C2d, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w3[3], MD5C2e, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w0[2], MD5C2f, MD5S23); + + MD5_STEP (MD5_I , a, b, c, d, w0[0], MD5C30, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w1[3], MD5C31, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w3[2], MD5C32, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w1[1], MD5C33, MD5S33); + MD5_STEP (MD5_I , a, b, c, d, w3[0], MD5C34, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w0[3], MD5C35, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w2[2], MD5C36, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w0[1], MD5C37, MD5S33); + MD5_STEP (MD5_I , a, b, c, d, w2[0], MD5C38, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w3[3], MD5C39, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w1[2], MD5C3a, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w3[1], MD5C3b, MD5S33); + MD5_STEP (MD5_I , a, b, c, d, w1[0], MD5C3c, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w2[3], MD5C3d, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w0[2], MD5C3e, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w2[1], MD5C3f, MD5S33); + + COMPARE_M_SIMD (a, d, c, b); + } +} + +KERNEL_FQ void m03730_m08 (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) +{ +} + +KERNEL_FQ void m03730_m16 (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) +{ +} + +KERNEL_FQ void m03730_s04 (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) +{ + /** + * modifier + */ + + const u64 gid = get_global_id (0); + const u64 lid = get_local_id (0); + const u64 lsz = get_local_size (0); + + /** + * bin2asc uppercase table + */ + + LOCAL_VK u32 u_bin2asc[256]; + + for (u32 j = lid; j < 256; j += lsz) + { + const u32 i0 = (j >> 0) & 15; + const u32 i1 = (j >> 4) & 15; + + u_bin2asc[j] = ((i0 < 10) ? '0' + i0 : 'A' - 10 + i0) << 8 + | ((i1 < 10) ? '0' + i1 : 'A' - 10 + i1) << 0; + } + + SYNC_THREADS (); + + 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; + + /** + * salt1 + */ + + u32 salt1_buf0[4]; + u32 salt1_buf1[4]; + u32 salt1_buf2[4]; + u32 salt1_buf3[4]; + + salt1_buf0[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 0]; + salt1_buf0[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 1]; + salt1_buf0[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 2]; + salt1_buf0[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 3]; + salt1_buf1[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 4]; + salt1_buf1[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 5]; + salt1_buf1[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 6]; + salt1_buf1[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 7]; + salt1_buf2[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 8]; + salt1_buf2[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 9]; + salt1_buf2[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[10]; + salt1_buf2[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[11]; + salt1_buf3[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[12]; + salt1_buf3[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[13]; + salt1_buf3[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[14]; + salt1_buf3[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[15]; + + const u32 salt1_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_len; + + /** + * salt2 + */ + + u32 salt2_buf0[4]; + u32 salt2_buf1[4]; + u32 salt2_buf2[4]; + u32 salt2_buf3[4]; + + salt2_buf0[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 0]; + salt2_buf0[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 1]; + salt2_buf0[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 2]; + salt2_buf0[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 3]; + salt2_buf1[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 4]; + salt2_buf1[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 5]; + salt2_buf1[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 6]; + salt2_buf1[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 7]; + salt2_buf2[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 8]; + salt2_buf2[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 9]; + salt2_buf2[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[10]; + salt2_buf2[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[11]; + salt2_buf3[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[12]; + salt2_buf3[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[13]; + salt2_buf3[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[14]; + salt2_buf3[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[15]; + + const u32 salt2_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_len; + + const u32 final_len = salt1_len + 32; + + /** + * 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] + }; + + /** + * loop + */ + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) + { + const u32x pw_r_len = pwlenx_create_combt (combs_buf, il_pos) & 63; + + const u32x pw_len = (pw_l_len + pw_r_len) & 63; + + /** + * concat password candidate + */ + + u32x wordl0[4] = { 0 }; + u32x wordl1[4] = { 0 }; + u32x wordl2[4] = { 0 }; + u32x 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]; + + u32x wordr0[4] = { 0 }; + u32x wordr1[4] = { 0 }; + u32x wordr2[4] = { 0 }; + u32x 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); + } + + u32x w0[4]; + u32x w1[4]; + u32x w2[4]; + u32x w3[4]; + + w0[0] = wordl0[0] | wordr0[0]; + w0[1] = wordl0[1] | wordr0[1]; + w0[2] = wordl0[2] | wordr0[2]; + w0[3] = wordl0[3] | wordr0[3]; + w1[0] = wordl1[0] | wordr1[0]; + w1[1] = wordl1[1] | wordr1[1]; + w1[2] = wordl1[2] | wordr1[2]; + w1[3] = wordl1[3] | wordr1[3]; + w2[0] = wordl2[0] | wordr2[0]; + w2[1] = wordl2[1] | wordr2[1]; + w2[2] = wordl2[2] | wordr2[2]; + w2[3] = wordl2[3] | wordr2[3]; + w3[0] = wordl3[0] | wordr3[0]; + w3[1] = wordl3[1] | wordr3[1]; + w3[2] = pw_len * 8; + w3[3] = 0; + + /** + * prepend salt2 + */ + + switch_buffer_by_offset_le (w0, w1, w2, w3, salt2_len); + + const u32x pw_salt_len = pw_len + salt2_len; + + w0[0] |= salt2_buf0[0]; + w0[1] |= salt2_buf0[1]; + w0[2] |= salt2_buf0[2]; + w0[3] |= salt2_buf0[3]; + w1[0] |= salt2_buf1[0]; + w1[1] |= salt2_buf1[1]; + w1[2] |= salt2_buf1[2]; + w1[3] |= salt2_buf1[3]; + w2[0] |= salt2_buf2[0]; + w2[1] |= salt2_buf2[1]; + w2[2] |= salt2_buf2[2]; + w2[3] |= salt2_buf2[3]; + w3[0] |= salt2_buf3[0]; + w3[1] |= salt2_buf3[1]; + w3[2] = pw_salt_len * 8; + w3[3] = 0; + + /** + * md5 + */ + + u32x a = MD5M_A; + u32x b = MD5M_B; + u32x c = MD5M_C; + u32x d = MD5M_D; + + MD5_STEP (MD5_Fo, a, b, c, d, w0[0], MD5C00, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w0[1], MD5C01, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w0[2], MD5C02, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w0[3], MD5C03, MD5S03); + MD5_STEP (MD5_Fo, a, b, c, d, w1[0], MD5C04, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w1[1], MD5C05, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w1[2], MD5C06, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w1[3], MD5C07, MD5S03); + MD5_STEP (MD5_Fo, a, b, c, d, w2[0], MD5C08, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w2[1], MD5C09, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w2[2], MD5C0a, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w2[3], MD5C0b, MD5S03); + MD5_STEP (MD5_Fo, a, b, c, d, w3[0], MD5C0c, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w3[1], MD5C0d, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w3[2], MD5C0e, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w3[3], MD5C0f, MD5S03); + + MD5_STEP (MD5_Go, a, b, c, d, w0[1], MD5C10, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w1[2], MD5C11, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w2[3], MD5C12, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w0[0], MD5C13, MD5S13); + MD5_STEP (MD5_Go, a, b, c, d, w1[1], MD5C14, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w2[2], MD5C15, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w3[3], MD5C16, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w1[0], MD5C17, MD5S13); + MD5_STEP (MD5_Go, a, b, c, d, w2[1], MD5C18, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w3[2], MD5C19, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w0[3], MD5C1a, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w2[0], MD5C1b, MD5S13); + MD5_STEP (MD5_Go, a, b, c, d, w3[1], MD5C1c, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w0[2], MD5C1d, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w1[3], MD5C1e, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w3[0], MD5C1f, MD5S13); + + u32x t; + + MD5_STEP (MD5_H1, a, b, c, d, w1[1], MD5C20, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w2[0], MD5C21, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w2[3], MD5C22, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w3[2], MD5C23, MD5S23); + MD5_STEP (MD5_H1, a, b, c, d, w0[1], MD5C24, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w1[0], MD5C25, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w1[3], MD5C26, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w2[2], MD5C27, MD5S23); + MD5_STEP (MD5_H1, a, b, c, d, w3[1], MD5C28, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w0[0], MD5C29, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w0[3], MD5C2a, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w1[2], MD5C2b, MD5S23); + MD5_STEP (MD5_H1, a, b, c, d, w2[1], MD5C2c, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w3[0], MD5C2d, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w3[3], MD5C2e, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w0[2], MD5C2f, MD5S23); + + MD5_STEP (MD5_I , a, b, c, d, w0[0], MD5C30, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w1[3], MD5C31, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w3[2], MD5C32, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w1[1], MD5C33, MD5S33); + MD5_STEP (MD5_I , a, b, c, d, w3[0], MD5C34, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w0[3], MD5C35, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w2[2], MD5C36, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w0[1], MD5C37, MD5S33); + MD5_STEP (MD5_I , a, b, c, d, w2[0], MD5C38, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w3[3], MD5C39, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w1[2], MD5C3a, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w3[1], MD5C3b, MD5S33); + MD5_STEP (MD5_I , a, b, c, d, w1[0], MD5C3c, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w2[3], MD5C3d, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w0[2], MD5C3e, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w2[1], MD5C3f, MD5S33); + + a += make_u32x (MD5M_A); + b += make_u32x (MD5M_B); + c += make_u32x (MD5M_C); + d += make_u32x (MD5M_D); + + w0[0] = uint_to_hex_upper8 ((a >> 0) & 255) << 0 + | uint_to_hex_upper8 ((a >> 8) & 255) << 16; + w0[1] = uint_to_hex_upper8 ((a >> 16) & 255) << 0 + | uint_to_hex_upper8 ((a >> 24) & 255) << 16; + w0[2] = uint_to_hex_upper8 ((b >> 0) & 255) << 0 + | uint_to_hex_upper8 ((b >> 8) & 255) << 16; + w0[3] = uint_to_hex_upper8 ((b >> 16) & 255) << 0 + | uint_to_hex_upper8 ((b >> 24) & 255) << 16; + w1[0] = uint_to_hex_upper8 ((c >> 0) & 255) << 0 + | uint_to_hex_upper8 ((c >> 8) & 255) << 16; + w1[1] = uint_to_hex_upper8 ((c >> 16) & 255) << 0 + | uint_to_hex_upper8 ((c >> 24) & 255) << 16; + w1[2] = uint_to_hex_upper8 ((d >> 0) & 255) << 0 + | uint_to_hex_upper8 ((d >> 8) & 255) << 16; + w1[3] = uint_to_hex_upper8 ((d >> 16) & 255) << 0 + | uint_to_hex_upper8 ((d >> 24) & 255) << 16; + w2[0] = 0x80; + w2[1] = 0; + w2[2] = 0; + w2[3] = 0; + w3[0] = 0; + w3[1] = 0; + w3[2] = 0; + w3[3] = 0; + + /** + * prepend salt1 + */ + + switch_buffer_by_offset_le (w0, w1, w2, w3, salt1_len); + + w3[2] = final_len * 8; + w3[3] = 0; + + w0[0] |= salt1_buf0[0]; + w0[1] |= salt1_buf0[1]; + w0[2] |= salt1_buf0[2]; + w0[3] |= salt1_buf0[3]; + w1[0] |= salt1_buf1[0]; + w1[1] |= salt1_buf1[1]; + w1[2] |= salt1_buf1[2]; + w1[3] |= salt1_buf1[3]; + w2[0] |= salt1_buf2[0]; + w2[1] |= salt1_buf2[1]; + w2[2] |= salt1_buf2[2]; + w2[3] |= salt1_buf2[3]; + w3[0] |= salt1_buf3[0]; + w3[1] |= salt1_buf3[1]; + w3[2] |= salt1_buf3[2]; + w3[3] |= salt1_buf3[3]; + + /** + * md5 + */ + + a = MD5M_A; + b = MD5M_B; + c = MD5M_C; + d = MD5M_D; + + MD5_STEP (MD5_Fo, a, b, c, d, w0[0], MD5C00, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w0[1], MD5C01, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w0[2], MD5C02, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w0[3], MD5C03, MD5S03); + MD5_STEP (MD5_Fo, a, b, c, d, w1[0], MD5C04, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w1[1], MD5C05, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w1[2], MD5C06, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w1[3], MD5C07, MD5S03); + MD5_STEP (MD5_Fo, a, b, c, d, w2[0], MD5C08, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w2[1], MD5C09, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w2[2], MD5C0a, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w2[3], MD5C0b, MD5S03); + MD5_STEP (MD5_Fo, a, b, c, d, w3[0], MD5C0c, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w3[1], MD5C0d, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w3[2], MD5C0e, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w3[3], MD5C0f, MD5S03); + + MD5_STEP (MD5_Go, a, b, c, d, w0[1], MD5C10, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w1[2], MD5C11, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w2[3], MD5C12, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w0[0], MD5C13, MD5S13); + MD5_STEP (MD5_Go, a, b, c, d, w1[1], MD5C14, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w2[2], MD5C15, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w3[3], MD5C16, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w1[0], MD5C17, MD5S13); + MD5_STEP (MD5_Go, a, b, c, d, w2[1], MD5C18, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w3[2], MD5C19, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w0[3], MD5C1a, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w2[0], MD5C1b, MD5S13); + MD5_STEP (MD5_Go, a, b, c, d, w3[1], MD5C1c, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w0[2], MD5C1d, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w1[3], MD5C1e, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w3[0], MD5C1f, MD5S13); + + MD5_STEP (MD5_H1, a, b, c, d, w1[1], MD5C20, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w2[0], MD5C21, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w2[3], MD5C22, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w3[2], MD5C23, MD5S23); + MD5_STEP (MD5_H1, a, b, c, d, w0[1], MD5C24, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w1[0], MD5C25, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w1[3], MD5C26, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w2[2], MD5C27, MD5S23); + MD5_STEP (MD5_H1, a, b, c, d, w3[1], MD5C28, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w0[0], MD5C29, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w0[3], MD5C2a, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w1[2], MD5C2b, MD5S23); + MD5_STEP (MD5_H1, a, b, c, d, w2[1], MD5C2c, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w3[0], MD5C2d, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w3[3], MD5C2e, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w0[2], MD5C2f, MD5S23); + + MD5_STEP (MD5_I , a, b, c, d, w0[0], MD5C30, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w1[3], MD5C31, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w3[2], MD5C32, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w1[1], MD5C33, MD5S33); + MD5_STEP (MD5_I , a, b, c, d, w3[0], MD5C34, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w0[3], MD5C35, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w2[2], MD5C36, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w0[1], MD5C37, MD5S33); + MD5_STEP (MD5_I , a, b, c, d, w2[0], MD5C38, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w3[3], MD5C39, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w1[2], MD5C3a, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w3[1], MD5C3b, MD5S33); + MD5_STEP (MD5_I , a, b, c, d, w1[0], MD5C3c, MD5S30); + + if (MATCHES_NONE_VS (a, search[0])) continue; + + MD5_STEP (MD5_I , d, a, b, c, w2[3], MD5C3d, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w0[2], MD5C3e, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w2[1], MD5C3f, MD5S33); + + COMPARE_S_SIMD (a, d, c, b); + } +} + +KERNEL_FQ void m03730_s08 (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) +{ +} + +KERNEL_FQ void m03730_s16 (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) +{ +} diff --git a/OpenCL/m03730_a1-pure.cl b/OpenCL/m03730_a1-pure.cl new file mode 100644 index 000000000..b51734cb8 --- /dev/null +++ b/OpenCL/m03730_a1-pure.cl @@ -0,0 +1,299 @@ +/** + * 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) +#include M2S(INCLUDE_PATH/inc_hash_md5.cl) +#endif + +#if VECT_SIZE == 1 +#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i)]) +#elif VECT_SIZE == 2 +#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i).s0], u_bin2asc[(i).s1]) +#elif VECT_SIZE == 4 +#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i).s0], u_bin2asc[(i).s1], u_bin2asc[(i).s2], u_bin2asc[(i).s3]) +#elif VECT_SIZE == 8 +#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i).s0], u_bin2asc[(i).s1], u_bin2asc[(i).s2], u_bin2asc[(i).s3], u_bin2asc[(i).s4], u_bin2asc[(i).s5], u_bin2asc[(i).s6], u_bin2asc[(i).s7]) +#elif VECT_SIZE == 16 +#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i).s0], u_bin2asc[(i).s1], u_bin2asc[(i).s2], u_bin2asc[(i).s3], u_bin2asc[(i).s4], u_bin2asc[(i).s5], u_bin2asc[(i).s6], u_bin2asc[(i).s7], u_bin2asc[(i).s8], u_bin2asc[(i).s9], u_bin2asc[(i).sa], u_bin2asc[(i).sb], u_bin2asc[(i).sc], u_bin2asc[(i).sd], u_bin2asc[(i).se], u_bin2asc[(i).sf]) +#endif + +typedef struct md5_double_salt +{ + u32 salt1_buf[64]; + int salt1_len; + + u32 salt2_buf[64]; + int salt2_len; + +} md5_double_salt_t; + +KERNEL_FQ void m03730_mxx (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) +{ + /** + * modifier + */ + + const u64 gid = get_global_id (0); + const u64 lid = get_local_id (0); + const u64 lsz = get_local_size (0); + + /** + * bin2asc uppercase array + */ + + LOCAL_VK u32 u_bin2asc[256]; + + for (u32 j = lid; j < 256; j += lsz) + { + const u32 i0 = (j >> 0) & 15; + const u32 i1 = (j >> 4) & 15; + + u_bin2asc[j] = ((i0 < 10) ? '0' + i0 : 'A' - 10 + i0) << 8 + | ((i1 < 10) ? '0' + i1 : 'A' - 10 + i1) << 0; + } + + SYNC_THREADS (); + + if (gid >= GID_CNT) return; + + /** + * base + */ + + const u32 salt_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_len; + + u32 s[64] = { 0 }; + + for (u32 i = 0, idx = 0; i < salt_len; i += 4, idx += 1) + { + s[idx] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[idx]; + } + + const int salt2_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_len; + + u32 s2[64] = { 0 }; + + for (int i = 0, idx = 0; i < salt2_len; i += 4, idx += 1) + { + s2[idx] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[idx]; + } + + md5_ctx_t ctx0; + + md5_init (&ctx0); + + md5_update_global (&ctx0, esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf, esalt_bufs[DIGESTS_OFFSET_HOST].salt2_len); + + md5_update_global (&ctx0, pws[gid].i, pws[gid].pw_len); + + /** + * loop + */ + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos++) + { + md5_ctx_t ctx1 = ctx0; + + md5_update_global (&ctx1, combs_buf[il_pos].i, combs_buf[il_pos].pw_len); + + md5_final (&ctx1); + + const u32 a = ctx1.h[0]; + const u32 b = ctx1.h[1]; + const u32 c = ctx1.h[2]; + const u32 d = ctx1.h[3]; + + u32 w0[4]; + u32 w1[4]; + u32 w2[4]; + u32 w3[4]; + + w0[0] = uint_to_hex_upper8 ((a >> 0) & 255) << 0 + | uint_to_hex_upper8 ((a >> 8) & 255) << 16; + w0[1] = uint_to_hex_upper8 ((a >> 16) & 255) << 0 + | uint_to_hex_upper8 ((a >> 24) & 255) << 16; + w0[2] = uint_to_hex_upper8 ((b >> 0) & 255) << 0 + | uint_to_hex_upper8 ((b >> 8) & 255) << 16; + w0[3] = uint_to_hex_upper8 ((b >> 16) & 255) << 0 + | uint_to_hex_upper8 ((b >> 24) & 255) << 16; + w1[0] = uint_to_hex_upper8 ((c >> 0) & 255) << 0 + | uint_to_hex_upper8 ((c >> 8) & 255) << 16; + w1[1] = uint_to_hex_upper8 ((c >> 16) & 255) << 0 + | uint_to_hex_upper8 ((c >> 24) & 255) << 16; + w1[2] = uint_to_hex_upper8 ((d >> 0) & 255) << 0 + | uint_to_hex_upper8 ((d >> 8) & 255) << 16; + w1[3] = uint_to_hex_upper8 ((d >> 16) & 255) << 0 + | uint_to_hex_upper8 ((d >> 24) & 255) << 16; + w2[0] = 0; + w2[1] = 0; + w2[2] = 0; + w2[3] = 0; + w3[0] = 0; + w3[1] = 0; + w3[2] = 0; + w3[3] = 0; + + md5_ctx_t ctx; + + md5_init (&ctx); + + md5_update (&ctx, s, salt_len); + + md5_update_64 (&ctx, w0, w1, w2, w3, 32); + + md5_final (&ctx); + + const u32 r0 = ctx.h[DGST_R0]; + const u32 r1 = ctx.h[DGST_R1]; + const u32 r2 = ctx.h[DGST_R2]; + const u32 r3 = ctx.h[DGST_R3]; + + COMPARE_M_SCALAR (r0, r1, r2, r3); + } +} + +KERNEL_FQ void m03730_sxx (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) +{ + /** + * modifier + */ + + const u64 gid = get_global_id (0); + const u64 lid = get_local_id (0); + const u64 lsz = get_local_size (0); + + /** + * bin2asc uppercase array + */ + + LOCAL_VK u32 u_bin2asc[256]; + + for (u32 j = lid; j < 256; j += lsz) + { + const u32 i0 = (j >> 0) & 15; + const u32 i1 = (j >> 4) & 15; + + u_bin2asc[j] = ((i0 < 10) ? '0' + i0 : 'A' - 10 + i0) << 8 + | ((i1 < 10) ? '0' + i1 : 'A' - 10 + i1) << 0; + } + + SYNC_THREADS (); + + 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], + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R2], + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R3] + }; + + const u32 salt_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_len; + + u32 s[64] = { 0 }; + + for (u32 i = 0, idx = 0; i < salt_len; i += 4, idx += 1) + { + s[idx] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[idx]; + } + + const u32 salt2_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_len; + + u32 s2[64] = { 0 }; + + for (u32 i = 0, idx = 0; i < salt2_len; i += 4, idx += 1) + { + s2[idx] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[idx]; + } + + /** + * base + */ + + md5_ctx_t ctx0; + + md5_init (&ctx0); + + md5_update_global (&ctx0, esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf, esalt_bufs[DIGESTS_OFFSET_HOST].salt2_len); + + md5_update_global (&ctx0, pws[gid].i, pws[gid].pw_len); + + /** + * loop + */ + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos++) + { + md5_ctx_t ctx1 = ctx0; + + md5_update_global (&ctx1, combs_buf[il_pos].i, combs_buf[il_pos].pw_len); + + md5_final (&ctx1); + + const u32 a = ctx1.h[0]; + const u32 b = ctx1.h[1]; + const u32 c = ctx1.h[2]; + const u32 d = ctx1.h[3]; + + u32 w0[4]; + u32 w1[4]; + u32 w2[4]; + u32 w3[4]; + + w0[0] = uint_to_hex_upper8 ((a >> 0) & 255) << 0 + | uint_to_hex_upper8 ((a >> 8) & 255) << 16; + w0[1] = uint_to_hex_upper8 ((a >> 16) & 255) << 0 + | uint_to_hex_upper8 ((a >> 24) & 255) << 16; + w0[2] = uint_to_hex_upper8 ((b >> 0) & 255) << 0 + | uint_to_hex_upper8 ((b >> 8) & 255) << 16; + w0[3] = uint_to_hex_upper8 ((b >> 16) & 255) << 0 + | uint_to_hex_upper8 ((b >> 24) & 255) << 16; + w1[0] = uint_to_hex_upper8 ((c >> 0) & 255) << 0 + | uint_to_hex_upper8 ((c >> 8) & 255) << 16; + w1[1] = uint_to_hex_upper8 ((c >> 16) & 255) << 0 + | uint_to_hex_upper8 ((c >> 24) & 255) << 16; + w1[2] = uint_to_hex_upper8 ((d >> 0) & 255) << 0 + | uint_to_hex_upper8 ((d >> 8) & 255) << 16; + w1[3] = uint_to_hex_upper8 ((d >> 16) & 255) << 0 + | uint_to_hex_upper8 ((d >> 24) & 255) << 16; + w2[0] = 0; + w2[1] = 0; + w2[2] = 0; + w2[3] = 0; + w3[0] = 0; + w3[1] = 0; + w3[2] = 0; + w3[3] = 0; + + md5_ctx_t ctx; + + md5_init (&ctx); + + md5_update (&ctx, s, salt_len); + + md5_update_64 (&ctx, w0, w1, w2, w3, 32); + + md5_final (&ctx); + + const u32 r0 = ctx.h[DGST_R0]; + const u32 r1 = ctx.h[DGST_R1]; + const u32 r2 = ctx.h[DGST_R2]; + const u32 r3 = ctx.h[DGST_R3]; + + COMPARE_S_SCALAR (r0, r1, r2, r3); + } +} diff --git a/OpenCL/m03730_a3-optimized.cl b/OpenCL/m03730_a3-optimized.cl new file mode 100644 index 000000000..85044932d --- /dev/null +++ b/OpenCL/m03730_a3-optimized.cl @@ -0,0 +1,1138 @@ +/** + * 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 + +#if VECT_SIZE == 1 +#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i)]) +#elif VECT_SIZE == 2 +#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i).s0], u_bin2asc[(i).s1]) +#elif VECT_SIZE == 4 +#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i).s0], u_bin2asc[(i).s1], u_bin2asc[(i).s2], u_bin2asc[(i).s3]) +#elif VECT_SIZE == 8 +#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i).s0], u_bin2asc[(i).s1], u_bin2asc[(i).s2], u_bin2asc[(i).s3], u_bin2asc[(i).s4], u_bin2asc[(i).s5], u_bin2asc[(i).s6], u_bin2asc[(i).s7]) +#elif VECT_SIZE == 16 +#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i).s0], u_bin2asc[(i).s1], u_bin2asc[(i).s2], u_bin2asc[(i).s3], u_bin2asc[(i).s4], u_bin2asc[(i).s5], u_bin2asc[(i).s6], u_bin2asc[(i).s7], u_bin2asc[(i).s8], u_bin2asc[(i).s9], u_bin2asc[(i).sa], u_bin2asc[(i).sb], u_bin2asc[(i).sc], u_bin2asc[(i).sd], u_bin2asc[(i).se], u_bin2asc[(i).sf]) +#endif + +typedef struct md5_double_salt +{ + u32 salt1_buf[64]; + int salt1_len; + + u32 salt2_buf[64]; + int salt2_len; + +} md5_double_salt_t; + +DECLSPEC void m03730m (PRIVATE_AS u32 *w0, PRIVATE_AS u32 *w1, PRIVATE_AS u32 *w2, PRIVATE_AS u32 *w3, const u32 pw_len, KERN_ATTR_FUNC_BASIC_ESALT (md5_double_salt_t), LOCAL_AS u32 *u_bin2asc) +{ + /** + * modifiers are taken from args + */ + + /** + * salt1 + */ + + u32 salt1_buf0[4]; + u32 salt1_buf1[4]; + u32 salt1_buf2[4]; + u32 salt1_buf3[4]; + + salt1_buf0[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 0]; + salt1_buf0[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 1]; + salt1_buf0[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 2]; + salt1_buf0[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 3]; + salt1_buf1[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 4]; + salt1_buf1[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 5]; + salt1_buf1[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 6]; + salt1_buf1[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 7]; + salt1_buf2[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 8]; + salt1_buf2[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 9]; + salt1_buf2[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[10]; + salt1_buf2[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[11]; + salt1_buf3[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[12]; + salt1_buf3[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[13]; + salt1_buf3[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[14]; + salt1_buf3[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[15]; + + const u32 salt1_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_len; + + /** + * salt2 + */ + + u32 salt2_buf0[4]; + u32 salt2_buf1[4]; + u32 salt2_buf2[4]; + u32 salt2_buf3[4]; + + salt2_buf0[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 0]; + salt2_buf0[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 1]; + salt2_buf0[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 2]; + salt2_buf0[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 3]; + salt2_buf1[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 4]; + salt2_buf1[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 5]; + salt2_buf1[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 6]; + salt2_buf1[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 7]; + salt2_buf2[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 8]; + salt2_buf2[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 9]; + salt2_buf2[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[10]; + salt2_buf2[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[11]; + salt2_buf3[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[12]; + salt2_buf3[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[13]; + salt2_buf3[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[14]; + salt2_buf3[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[15]; + + const u32 salt2_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_len; + + const u32 pw_salt_len = pw_len + salt2_len; + const u32 final_len = salt1_len + 32; + + /** + * loop + */ + + const u32 w0l = w0[0]; + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) + { + const u32x w0r = ix_create_bft (bfs_buf, il_pos); + + const u32x w0lr = w0l | w0r; + + u32x w0_t[4]; + u32x w1_t[4]; + u32x w2_t[4]; + u32x w3_t[4]; + + w0_t[0] = w0lr; + w0_t[1] = w0[1]; + w0_t[2] = w0[2]; + w0_t[3] = w0[3]; + w1_t[0] = w1[0]; + w1_t[1] = w1[1]; + w1_t[2] = w1[2]; + w1_t[3] = w1[3]; + w2_t[0] = w2[0]; + w2_t[1] = w2[1]; + w2_t[2] = w2[2]; + w2_t[3] = w2[3]; + w3_t[0] = w3[0]; + w3_t[1] = w3[1]; + w3_t[2] = w3[2]; + w3_t[3] = w3[3]; + + switch_buffer_by_offset_le (w0_t, w1_t, w2_t, w3_t, salt2_len); + + w0_t[0] |= salt2_buf0[0]; + w0_t[1] |= salt2_buf0[1]; + w0_t[2] |= salt2_buf0[2]; + w0_t[3] |= salt2_buf0[3]; + w1_t[0] |= salt2_buf1[0]; + w1_t[1] |= salt2_buf1[1]; + w1_t[2] |= salt2_buf1[2]; + w1_t[3] |= salt2_buf1[3]; + w2_t[0] |= salt2_buf2[0]; + w2_t[1] |= salt2_buf2[1]; + w2_t[2] |= salt2_buf2[2]; + w2_t[3] |= salt2_buf2[3]; + w3_t[0] |= salt2_buf3[0]; + w3_t[1] |= salt2_buf3[1]; + w3_t[2] = pw_salt_len * 8; + w3_t[3] = 0; + + /** + * md5 + */ + + u32x a = MD5M_A; + u32x b = MD5M_B; + u32x c = MD5M_C; + u32x d = MD5M_D; + + MD5_STEP (MD5_Fo, a, b, c, d, w0_t[0], MD5C00, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w0_t[1], MD5C01, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w0_t[2], MD5C02, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w0_t[3], MD5C03, MD5S03); + MD5_STEP (MD5_Fo, a, b, c, d, w1_t[0], MD5C04, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w1_t[1], MD5C05, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w1_t[2], MD5C06, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w1_t[3], MD5C07, MD5S03); + MD5_STEP (MD5_Fo, a, b, c, d, w2_t[0], MD5C08, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w2_t[1], MD5C09, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w2_t[2], MD5C0a, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w2_t[3], MD5C0b, MD5S03); + MD5_STEP (MD5_Fo, a, b, c, d, w3_t[0], MD5C0c, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w3_t[1], MD5C0d, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w3_t[2], MD5C0e, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w3_t[3], MD5C0f, MD5S03); + + MD5_STEP (MD5_Go, a, b, c, d, w0_t[1], MD5C10, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w1_t[2], MD5C11, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w2_t[3], MD5C12, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w0_t[0], MD5C13, MD5S13); + MD5_STEP (MD5_Go, a, b, c, d, w1_t[1], MD5C14, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w2_t[2], MD5C15, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w3_t[3], MD5C16, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w1_t[0], MD5C17, MD5S13); + MD5_STEP (MD5_Go, a, b, c, d, w2_t[1], MD5C18, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w3_t[2], MD5C19, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w0_t[3], MD5C1a, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w2_t[0], MD5C1b, MD5S13); + MD5_STEP (MD5_Go, a, b, c, d, w3_t[1], MD5C1c, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w0_t[2], MD5C1d, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w1_t[3], MD5C1e, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w3_t[0], MD5C1f, MD5S13); + + u32x t; + + MD5_STEP (MD5_H1, a, b, c, d, w1_t[1], MD5C20, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w2_t[0], MD5C21, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w2_t[3], MD5C22, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w3_t[2], MD5C23, MD5S23); + MD5_STEP (MD5_H1, a, b, c, d, w0_t[1], MD5C24, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w1_t[0], MD5C25, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w1_t[3], MD5C26, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w2_t[2], MD5C27, MD5S23); + MD5_STEP (MD5_H1, a, b, c, d, w3_t[1], MD5C28, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w0_t[0], MD5C29, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w0_t[3], MD5C2a, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w1_t[2], MD5C2b, MD5S23); + MD5_STEP (MD5_H1, a, b, c, d, w2_t[1], MD5C2c, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w3_t[0], MD5C2d, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w3_t[3], MD5C2e, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w0_t[2], MD5C2f, MD5S23); + + MD5_STEP (MD5_I , a, b, c, d, w0_t[0], MD5C30, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w1_t[3], MD5C31, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w3_t[2], MD5C32, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w1_t[1], MD5C33, MD5S33); + MD5_STEP (MD5_I , a, b, c, d, w3_t[0], MD5C34, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w0_t[3], MD5C35, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w2_t[2], MD5C36, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w0_t[1], MD5C37, MD5S33); + MD5_STEP (MD5_I , a, b, c, d, w2_t[0], MD5C38, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w3_t[3], MD5C39, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w1_t[2], MD5C3a, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w3_t[1], MD5C3b, MD5S33); + MD5_STEP (MD5_I , a, b, c, d, w1_t[0], MD5C3c, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w2_t[3], MD5C3d, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w0_t[2], MD5C3e, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w2_t[1], MD5C3f, MD5S33); + + a += make_u32x (MD5M_A); + b += make_u32x (MD5M_B); + c += make_u32x (MD5M_C); + d += make_u32x (MD5M_D); + + w0_t[0] = uint_to_hex_upper8 ((a >> 0) & 255) << 0 + | uint_to_hex_upper8 ((a >> 8) & 255) << 16; + w0_t[1] = uint_to_hex_upper8 ((a >> 16) & 255) << 0 + | uint_to_hex_upper8 ((a >> 24) & 255) << 16; + w0_t[2] = uint_to_hex_upper8 ((b >> 0) & 255) << 0 + | uint_to_hex_upper8 ((b >> 8) & 255) << 16; + w0_t[3] = uint_to_hex_upper8 ((b >> 16) & 255) << 0 + | uint_to_hex_upper8 ((b >> 24) & 255) << 16; + w1_t[0] = uint_to_hex_upper8 ((c >> 0) & 255) << 0 + | uint_to_hex_upper8 ((c >> 8) & 255) << 16; + w1_t[1] = uint_to_hex_upper8 ((c >> 16) & 255) << 0 + | uint_to_hex_upper8 ((c >> 24) & 255) << 16; + w1_t[2] = uint_to_hex_upper8 ((d >> 0) & 255) << 0 + | uint_to_hex_upper8 ((d >> 8) & 255) << 16; + w1_t[3] = uint_to_hex_upper8 ((d >> 16) & 255) << 0 + | uint_to_hex_upper8 ((d >> 24) & 255) << 16; + w2_t[0] = 0x80; + w2_t[1] = 0; + w2_t[2] = 0; + w2_t[3] = 0; + w3_t[0] = 0; + w3_t[1] = 0; + w3_t[2] = 0; + w3_t[3] = 0; + + /** + * prepend salt1 + */ + + switch_buffer_by_offset_le (w0_t, w1_t, w2_t, w3_t, salt1_len); + + w3_t[2] = final_len * 8; + w3_t[3] = 0; + + w0_t[0] |= salt1_buf0[0]; + w0_t[1] |= salt1_buf0[1]; + w0_t[2] |= salt1_buf0[2]; + w0_t[3] |= salt1_buf0[3]; + w1_t[0] |= salt1_buf1[0]; + w1_t[1] |= salt1_buf1[1]; + w1_t[2] |= salt1_buf1[2]; + w1_t[3] |= salt1_buf1[3]; + w2_t[0] |= salt1_buf2[0]; + w2_t[1] |= salt1_buf2[1]; + w2_t[2] |= salt1_buf2[2]; + w2_t[3] |= salt1_buf2[3]; + w3_t[0] |= salt1_buf3[0]; + w3_t[1] |= salt1_buf3[1]; + w3_t[2] |= salt1_buf3[2]; + w3_t[3] |= salt1_buf3[3]; + + /** + * md5 + */ + + a = MD5M_A; + b = MD5M_B; + c = MD5M_C; + d = MD5M_D; + + MD5_STEP (MD5_Fo, a, b, c, d, w0_t[0], MD5C00, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w0_t[1], MD5C01, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w0_t[2], MD5C02, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w0_t[3], MD5C03, MD5S03); + MD5_STEP (MD5_Fo, a, b, c, d, w1_t[0], MD5C04, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w1_t[1], MD5C05, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w1_t[2], MD5C06, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w1_t[3], MD5C07, MD5S03); + MD5_STEP (MD5_Fo, a, b, c, d, w2_t[0], MD5C08, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w2_t[1], MD5C09, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w2_t[2], MD5C0a, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w2_t[3], MD5C0b, MD5S03); + MD5_STEP (MD5_Fo, a, b, c, d, w3_t[0], MD5C0c, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w3_t[1], MD5C0d, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w3_t[2], MD5C0e, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w3_t[3], MD5C0f, MD5S03); + + MD5_STEP (MD5_Go, a, b, c, d, w0_t[1], MD5C10, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w1_t[2], MD5C11, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w2_t[3], MD5C12, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w0_t[0], MD5C13, MD5S13); + MD5_STEP (MD5_Go, a, b, c, d, w1_t[1], MD5C14, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w2_t[2], MD5C15, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w3_t[3], MD5C16, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w1_t[0], MD5C17, MD5S13); + MD5_STEP (MD5_Go, a, b, c, d, w2_t[1], MD5C18, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w3_t[2], MD5C19, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w0_t[3], MD5C1a, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w2_t[0], MD5C1b, MD5S13); + MD5_STEP (MD5_Go, a, b, c, d, w3_t[1], MD5C1c, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w0_t[2], MD5C1d, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w1_t[3], MD5C1e, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w3_t[0], MD5C1f, MD5S13); + + MD5_STEP (MD5_H1, a, b, c, d, w1_t[1], MD5C20, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w2_t[0], MD5C21, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w2_t[3], MD5C22, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w3_t[2], MD5C23, MD5S23); + MD5_STEP (MD5_H1, a, b, c, d, w0_t[1], MD5C24, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w1_t[0], MD5C25, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w1_t[3], MD5C26, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w2_t[2], MD5C27, MD5S23); + MD5_STEP (MD5_H1, a, b, c, d, w3_t[1], MD5C28, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w0_t[0], MD5C29, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w0_t[3], MD5C2a, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w1_t[2], MD5C2b, MD5S23); + MD5_STEP (MD5_H1, a, b, c, d, w2_t[1], MD5C2c, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w3_t[0], MD5C2d, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w3_t[3], MD5C2e, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w0_t[2], MD5C2f, MD5S23); + + MD5_STEP (MD5_I , a, b, c, d, w0_t[0], MD5C30, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w1_t[3], MD5C31, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w3_t[2], MD5C32, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w1_t[1], MD5C33, MD5S33); + MD5_STEP (MD5_I , a, b, c, d, w3_t[0], MD5C34, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w0_t[3], MD5C35, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w2_t[2], MD5C36, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w0_t[1], MD5C37, MD5S33); + MD5_STEP (MD5_I , a, b, c, d, w2_t[0], MD5C38, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w3_t[3], MD5C39, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w1_t[2], MD5C3a, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w3_t[1], MD5C3b, MD5S33); + MD5_STEP (MD5_I , a, b, c, d, w1_t[0], MD5C3c, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w2_t[3], MD5C3d, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w0_t[2], MD5C3e, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w2_t[1], MD5C3f, MD5S33); + + COMPARE_M_SIMD (a, d, c, b); + } +} + +DECLSPEC void m03730s (PRIVATE_AS u32 *w0, PRIVATE_AS u32 *w1, PRIVATE_AS u32 *w2, PRIVATE_AS u32 *w3, const u32 pw_len, KERN_ATTR_FUNC_BASIC_ESALT (md5_double_salt_t), LOCAL_AS u32 *u_bin2asc) +{ + /** + * modifiers are taken from args + */ + + /** + * 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] + }; + + /** + * salt1 + */ + + u32 salt1_buf0[4]; + u32 salt1_buf1[4]; + u32 salt1_buf2[4]; + u32 salt1_buf3[4]; + + salt1_buf0[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 0]; + salt1_buf0[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 1]; + salt1_buf0[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 2]; + salt1_buf0[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 3]; + salt1_buf1[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 4]; + salt1_buf1[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 5]; + salt1_buf1[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 6]; + salt1_buf1[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 7]; + salt1_buf2[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 8]; + salt1_buf2[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 9]; + salt1_buf2[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[10]; + salt1_buf2[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[11]; + salt1_buf3[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[12]; + salt1_buf3[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[13]; + salt1_buf3[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[14]; + salt1_buf3[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[15]; + + const u32 salt1_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_len; + + /** + * salt2 + */ + + u32 salt2_buf0[4]; + u32 salt2_buf1[4]; + u32 salt2_buf2[4]; + u32 salt2_buf3[4]; + + salt2_buf0[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 0]; + salt2_buf0[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 1]; + salt2_buf0[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 2]; + salt2_buf0[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 3]; + salt2_buf1[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 4]; + salt2_buf1[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 5]; + salt2_buf1[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 6]; + salt2_buf1[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 7]; + salt2_buf2[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 8]; + salt2_buf2[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 9]; + salt2_buf2[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[10]; + salt2_buf2[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[11]; + salt2_buf3[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[12]; + salt2_buf3[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[13]; + salt2_buf3[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[14]; + salt2_buf3[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[15]; + + const u32 salt2_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_len; + + const u32 pw_salt_len = pw_len + salt2_len; + const u32 final_len = salt1_len + 32; + + /** + * loop + */ + + const u32 w0l = w0[0]; + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) + { + const u32x w0r = ix_create_bft (bfs_buf, il_pos); + + const u32x w0lr = w0l | w0r; + + u32x w0_t[4]; + u32x w1_t[4]; + u32x w2_t[4]; + u32x w3_t[4]; + + w0_t[0] = w0lr; + w0_t[1] = w0[1]; + w0_t[2] = w0[2]; + w0_t[3] = w0[3]; + w1_t[0] = w1[0]; + w1_t[1] = w1[1]; + w1_t[2] = w1[2]; + w1_t[3] = w1[3]; + w2_t[0] = w2[0]; + w2_t[1] = w2[1]; + w2_t[2] = w2[2]; + w2_t[3] = w2[3]; + w3_t[0] = w3[0]; + w3_t[1] = w3[1]; + w3_t[2] = w3[2]; + w3_t[3] = w3[3]; + + switch_buffer_by_offset_le (w0_t, w1_t, w2_t, w3_t, salt2_len); + + w0_t[0] |= salt2_buf0[0]; + w0_t[1] |= salt2_buf0[1]; + w0_t[2] |= salt2_buf0[2]; + w0_t[3] |= salt2_buf0[3]; + w1_t[0] |= salt2_buf1[0]; + w1_t[1] |= salt2_buf1[1]; + w1_t[2] |= salt2_buf1[2]; + w1_t[3] |= salt2_buf1[3]; + w2_t[0] |= salt2_buf2[0]; + w2_t[1] |= salt2_buf2[1]; + w2_t[2] |= salt2_buf2[2]; + w2_t[3] |= salt2_buf2[3]; + w3_t[0] |= salt2_buf3[0]; + w3_t[1] |= salt2_buf3[1]; + w3_t[2] = pw_salt_len * 8; + w3_t[3] = 0; + + /** + * md5 + */ + + u32x a = MD5M_A; + u32x b = MD5M_B; + u32x c = MD5M_C; + u32x d = MD5M_D; + + MD5_STEP (MD5_Fo, a, b, c, d, w0_t[0], MD5C00, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w0_t[1], MD5C01, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w0_t[2], MD5C02, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w0_t[3], MD5C03, MD5S03); + MD5_STEP (MD5_Fo, a, b, c, d, w1_t[0], MD5C04, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w1_t[1], MD5C05, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w1_t[2], MD5C06, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w1_t[3], MD5C07, MD5S03); + MD5_STEP (MD5_Fo, a, b, c, d, w2_t[0], MD5C08, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w2_t[1], MD5C09, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w2_t[2], MD5C0a, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w2_t[3], MD5C0b, MD5S03); + MD5_STEP (MD5_Fo, a, b, c, d, w3_t[0], MD5C0c, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w3_t[1], MD5C0d, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w3_t[2], MD5C0e, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w3_t[3], MD5C0f, MD5S03); + + MD5_STEP (MD5_Go, a, b, c, d, w0_t[1], MD5C10, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w1_t[2], MD5C11, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w2_t[3], MD5C12, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w0_t[0], MD5C13, MD5S13); + MD5_STEP (MD5_Go, a, b, c, d, w1_t[1], MD5C14, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w2_t[2], MD5C15, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w3_t[3], MD5C16, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w1_t[0], MD5C17, MD5S13); + MD5_STEP (MD5_Go, a, b, c, d, w2_t[1], MD5C18, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w3_t[2], MD5C19, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w0_t[3], MD5C1a, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w2_t[0], MD5C1b, MD5S13); + MD5_STEP (MD5_Go, a, b, c, d, w3_t[1], MD5C1c, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w0_t[2], MD5C1d, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w1_t[3], MD5C1e, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w3_t[0], MD5C1f, MD5S13); + + u32x t; + + MD5_STEP (MD5_H1, a, b, c, d, w1_t[1], MD5C20, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w2_t[0], MD5C21, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w2_t[3], MD5C22, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w3_t[2], MD5C23, MD5S23); + MD5_STEP (MD5_H1, a, b, c, d, w0_t[1], MD5C24, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w1_t[0], MD5C25, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w1_t[3], MD5C26, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w2_t[2], MD5C27, MD5S23); + MD5_STEP (MD5_H1, a, b, c, d, w3_t[1], MD5C28, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w0_t[0], MD5C29, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w0_t[3], MD5C2a, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w1_t[2], MD5C2b, MD5S23); + MD5_STEP (MD5_H1, a, b, c, d, w2_t[1], MD5C2c, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w3_t[0], MD5C2d, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w3_t[3], MD5C2e, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w0_t[2], MD5C2f, MD5S23); + + MD5_STEP (MD5_I , a, b, c, d, w0_t[0], MD5C30, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w1_t[3], MD5C31, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w3_t[2], MD5C32, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w1_t[1], MD5C33, MD5S33); + MD5_STEP (MD5_I , a, b, c, d, w3_t[0], MD5C34, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w0_t[3], MD5C35, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w2_t[2], MD5C36, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w0_t[1], MD5C37, MD5S33); + MD5_STEP (MD5_I , a, b, c, d, w2_t[0], MD5C38, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w3_t[3], MD5C39, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w1_t[2], MD5C3a, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w3_t[1], MD5C3b, MD5S33); + MD5_STEP (MD5_I , a, b, c, d, w1_t[0], MD5C3c, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w2_t[3], MD5C3d, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w0_t[2], MD5C3e, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w2_t[1], MD5C3f, MD5S33); + + a += make_u32x (MD5M_A); + b += make_u32x (MD5M_B); + c += make_u32x (MD5M_C); + d += make_u32x (MD5M_D); + + w0_t[0] = uint_to_hex_upper8 ((a >> 0) & 255) << 0 + | uint_to_hex_upper8 ((a >> 8) & 255) << 16; + w0_t[1] = uint_to_hex_upper8 ((a >> 16) & 255) << 0 + | uint_to_hex_upper8 ((a >> 24) & 255) << 16; + w0_t[2] = uint_to_hex_upper8 ((b >> 0) & 255) << 0 + | uint_to_hex_upper8 ((b >> 8) & 255) << 16; + w0_t[3] = uint_to_hex_upper8 ((b >> 16) & 255) << 0 + | uint_to_hex_upper8 ((b >> 24) & 255) << 16; + w1_t[0] = uint_to_hex_upper8 ((c >> 0) & 255) << 0 + | uint_to_hex_upper8 ((c >> 8) & 255) << 16; + w1_t[1] = uint_to_hex_upper8 ((c >> 16) & 255) << 0 + | uint_to_hex_upper8 ((c >> 24) & 255) << 16; + w1_t[2] = uint_to_hex_upper8 ((d >> 0) & 255) << 0 + | uint_to_hex_upper8 ((d >> 8) & 255) << 16; + w1_t[3] = uint_to_hex_upper8 ((d >> 16) & 255) << 0 + | uint_to_hex_upper8 ((d >> 24) & 255) << 16; + w2_t[0] = 0x80; + w2_t[1] = 0; + w2_t[2] = 0; + w2_t[3] = 0; + w3_t[0] = 0; + w3_t[1] = 0; + w3_t[2] = 0; + w3_t[3] = 0; + + /** + * prepend salt1 + */ + + switch_buffer_by_offset_le (w0_t, w1_t, w2_t, w3_t, salt1_len); + + w3_t[2] = final_len * 8; + w3_t[3] = 0; + + w0_t[0] |= salt1_buf0[0]; + w0_t[1] |= salt1_buf0[1]; + w0_t[2] |= salt1_buf0[2]; + w0_t[3] |= salt1_buf0[3]; + w1_t[0] |= salt1_buf1[0]; + w1_t[1] |= salt1_buf1[1]; + w1_t[2] |= salt1_buf1[2]; + w1_t[3] |= salt1_buf1[3]; + w2_t[0] |= salt1_buf2[0]; + w2_t[1] |= salt1_buf2[1]; + w2_t[2] |= salt1_buf2[2]; + w2_t[3] |= salt1_buf2[3]; + w3_t[0] |= salt1_buf3[0]; + w3_t[1] |= salt1_buf3[1]; + w3_t[2] |= salt1_buf3[2]; + w3_t[3] |= salt1_buf3[3]; + + /** + * md5 + */ + + a = MD5M_A; + b = MD5M_B; + c = MD5M_C; + d = MD5M_D; + + MD5_STEP (MD5_Fo, a, b, c, d, w0_t[0], MD5C00, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w0_t[1], MD5C01, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w0_t[2], MD5C02, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w0_t[3], MD5C03, MD5S03); + MD5_STEP (MD5_Fo, a, b, c, d, w1_t[0], MD5C04, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w1_t[1], MD5C05, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w1_t[2], MD5C06, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w1_t[3], MD5C07, MD5S03); + MD5_STEP (MD5_Fo, a, b, c, d, w2_t[0], MD5C08, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w2_t[1], MD5C09, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w2_t[2], MD5C0a, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w2_t[3], MD5C0b, MD5S03); + MD5_STEP (MD5_Fo, a, b, c, d, w3_t[0], MD5C0c, MD5S00); + MD5_STEP (MD5_Fo, d, a, b, c, w3_t[1], MD5C0d, MD5S01); + MD5_STEP (MD5_Fo, c, d, a, b, w3_t[2], MD5C0e, MD5S02); + MD5_STEP (MD5_Fo, b, c, d, a, w3_t[3], MD5C0f, MD5S03); + + MD5_STEP (MD5_Go, a, b, c, d, w0_t[1], MD5C10, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w1_t[2], MD5C11, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w2_t[3], MD5C12, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w0_t[0], MD5C13, MD5S13); + MD5_STEP (MD5_Go, a, b, c, d, w1_t[1], MD5C14, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w2_t[2], MD5C15, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w3_t[3], MD5C16, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w1_t[0], MD5C17, MD5S13); + MD5_STEP (MD5_Go, a, b, c, d, w2_t[1], MD5C18, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w3_t[2], MD5C19, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w0_t[3], MD5C1a, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w2_t[0], MD5C1b, MD5S13); + MD5_STEP (MD5_Go, a, b, c, d, w3_t[1], MD5C1c, MD5S10); + MD5_STEP (MD5_Go, d, a, b, c, w0_t[2], MD5C1d, MD5S11); + MD5_STEP (MD5_Go, c, d, a, b, w1_t[3], MD5C1e, MD5S12); + MD5_STEP (MD5_Go, b, c, d, a, w3_t[0], MD5C1f, MD5S13); + + MD5_STEP (MD5_H1, a, b, c, d, w1_t[1], MD5C20, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w2_t[0], MD5C21, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w2_t[3], MD5C22, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w3_t[2], MD5C23, MD5S23); + MD5_STEP (MD5_H1, a, b, c, d, w0_t[1], MD5C24, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w1_t[0], MD5C25, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w1_t[3], MD5C26, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w2_t[2], MD5C27, MD5S23); + MD5_STEP (MD5_H1, a, b, c, d, w3_t[1], MD5C28, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w0_t[0], MD5C29, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w0_t[3], MD5C2a, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w1_t[2], MD5C2b, MD5S23); + MD5_STEP (MD5_H1, a, b, c, d, w2_t[1], MD5C2c, MD5S20); + MD5_STEP (MD5_H2, d, a, b, c, w3_t[0], MD5C2d, MD5S21); + MD5_STEP (MD5_H1, c, d, a, b, w3_t[3], MD5C2e, MD5S22); + MD5_STEP (MD5_H2, b, c, d, a, w0_t[2], MD5C2f, MD5S23); + + MD5_STEP (MD5_I , a, b, c, d, w0_t[0], MD5C30, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w1_t[3], MD5C31, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w3_t[2], MD5C32, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w1_t[1], MD5C33, MD5S33); + MD5_STEP (MD5_I , a, b, c, d, w3_t[0], MD5C34, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w0_t[3], MD5C35, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w2_t[2], MD5C36, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w0_t[1], MD5C37, MD5S33); + MD5_STEP (MD5_I , a, b, c, d, w2_t[0], MD5C38, MD5S30); + MD5_STEP (MD5_I , d, a, b, c, w3_t[3], MD5C39, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w1_t[2], MD5C3a, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w3_t[1], MD5C3b, MD5S33); + MD5_STEP (MD5_I , a, b, c, d, w1_t[0], MD5C3c, MD5S30); + + if (MATCHES_NONE_VS (a, search[0])) continue; + + MD5_STEP (MD5_I , d, a, b, c, w2_t[3], MD5C3d, MD5S31); + MD5_STEP (MD5_I , c, d, a, b, w0_t[2], MD5C3e, MD5S32); + MD5_STEP (MD5_I , b, c, d, a, w2_t[1], MD5C3f, MD5S33); + + COMPARE_S_SIMD (a, d, c, b); + } +} + +KERNEL_FQ void m03730_m04 (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) +{ + /** + * base + */ + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + const u64 lsz = get_local_size (0); + + /** + * bin2asc uppercase array + */ + LOCAL_VK u32 u_bin2asc[256]; + + for (u32 j = lid; j < 256; j += lsz) + { + const u32 i0 = (j >> 0) & 15; + const u32 i1 = (j >> 4) & 15; + + u_bin2asc[j] = ((i0 < 10) ? '0' + i0 : 'A' - 10 + i0) << 8 + | ((i1 < 10) ? '0' + i1 : 'A' - 10 + i1) << 0; + } + + SYNC_THREADS (); + + if (gid >= GID_CNT) return; + + /** + * modifier + */ + + u32 w0[4]; + + w0[0] = pws[gid].i[ 0]; + w0[1] = pws[gid].i[ 1]; + w0[2] = pws[gid].i[ 2]; + w0[3] = pws[gid].i[ 3]; + + u32 w1[4]; + + w1[0] = 0; + w1[1] = 0; + w1[2] = 0; + w1[3] = 0; + + u32 w2[4]; + + w2[0] = 0; + w2[1] = 0; + w2[2] = 0; + w2[3] = 0; + + u32 w3[4]; + + w3[0] = 0; + w3[1] = 0; + w3[2] = pws[gid].i[14]; + w3[3] = 0; + + const u32 pw_len = pws[gid].pw_len & 63; + + /** + * main + */ + + m03730m (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, 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, u_bin2asc); +} + +KERNEL_FQ void m03730_m08 (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) +{ + /** + * base + */ + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + const u64 lsz = get_local_size (0); + + /** + * modifier + */ + + u32 w0[4]; + + w0[0] = pws[gid].i[ 0]; + w0[1] = pws[gid].i[ 1]; + w0[2] = pws[gid].i[ 2]; + w0[3] = pws[gid].i[ 3]; + + u32 w1[4]; + + w1[0] = pws[gid].i[ 4]; + w1[1] = pws[gid].i[ 5]; + w1[2] = pws[gid].i[ 6]; + w1[3] = pws[gid].i[ 7]; + + u32 w2[4]; + + w2[0] = 0; + w2[1] = 0; + w2[2] = 0; + w2[3] = 0; + + u32 w3[4]; + + w3[0] = 0; + w3[1] = 0; + w3[2] = pws[gid].i[14]; + w3[3] = 0; + + const u32 pw_len = pws[gid].pw_len & 63; + + /** + * bin2asc uppercase array + */ + LOCAL_VK u32 u_bin2asc[256]; + + for (u32 j = lid; j < 256; j += lsz) + { + const u32 i0 = (j >> 0) & 15; + const u32 i1 = (j >> 4) & 15; + + u_bin2asc[j] = ((i0 < 10) ? '0' + i0 : 'A' - 10 + i0) << 8 + | ((i1 < 10) ? '0' + i1 : 'A' - 10 + i1) << 0; + } + + SYNC_THREADS (); + + if (gid >= GID_CNT) return; + + /** + * main + */ + + m03730m (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, 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, u_bin2asc); +} + +KERNEL_FQ void m03730_m16 (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) +{ + /** + * base + */ + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + const u64 lsz = get_local_size (0); + + /** + * modifier + */ + + u32 w0[4]; + + w0[0] = pws[gid].i[ 0]; + w0[1] = pws[gid].i[ 1]; + w0[2] = pws[gid].i[ 2]; + w0[3] = pws[gid].i[ 3]; + + u32 w1[4]; + + w1[0] = pws[gid].i[ 4]; + w1[1] = pws[gid].i[ 5]; + w1[2] = pws[gid].i[ 6]; + w1[3] = pws[gid].i[ 7]; + + u32 w2[4]; + + w2[0] = pws[gid].i[ 8]; + w2[1] = pws[gid].i[ 9]; + w2[2] = pws[gid].i[10]; + w2[3] = pws[gid].i[11]; + + u32 w3[4]; + + w3[0] = pws[gid].i[12]; + w3[1] = pws[gid].i[13]; + w3[2] = pws[gid].i[14]; + w3[3] = pws[gid].i[15]; + + const u32 pw_len = pws[gid].pw_len & 63; + + /** + * bin2asc uppercase array + */ + + LOCAL_VK u32 u_bin2asc[256]; + + for (u32 j = lid; j < 256; j += lsz) + { + const u32 i0 = (j >> 0) & 15; + const u32 i1 = (j >> 4) & 15; + + u_bin2asc[j] = ((i0 < 10) ? '0' + i0 : 'A' - 10 + i0) << 8 + | ((i1 < 10) ? '0' + i1 : 'A' - 10 + i1) << 0; + } + + SYNC_THREADS (); + + if (gid >= GID_CNT) return; + + /** + * main + */ + + m03730m (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, 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, u_bin2asc); +} + +KERNEL_FQ void m03730_s04 (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) +{ + /** + * base + */ + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + const u64 lsz = get_local_size (0); + + /** + * modifier + */ + + u32 w0[4]; + + w0[0] = pws[gid].i[ 0]; + w0[1] = pws[gid].i[ 1]; + w0[2] = pws[gid].i[ 2]; + w0[3] = pws[gid].i[ 3]; + + u32 w1[4]; + + w1[0] = 0; + w1[1] = 0; + w1[2] = 0; + w1[3] = 0; + + u32 w2[4]; + + w2[0] = 0; + w2[1] = 0; + w2[2] = 0; + w2[3] = 0; + + u32 w3[4]; + + w3[0] = 0; + w3[1] = 0; + w3[2] = pws[gid].i[14]; + w3[3] = 0; + + const u32 pw_len = pws[gid].pw_len & 63; + + /** + * bin2asc uppercase array + */ + + LOCAL_VK u32 u_bin2asc[256]; + + for (u32 j = lid; j < 256; j += lsz) + { + const u32 i0 = (j >> 0) & 15; + const u32 i1 = (j >> 4) & 15; + + u_bin2asc[j] = ((i0 < 10) ? '0' + i0 : 'A' - 10 + i0) << 8 + | ((i1 < 10) ? '0' + i1 : 'A' - 10 + i1) << 0; + } + + SYNC_THREADS (); + + if (gid >= GID_CNT) return; + + /** + * main + */ + + m03730s (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, 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, u_bin2asc); +} + +KERNEL_FQ void m03730_s08 (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) +{ + /** + * base + */ + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + const u64 lsz = get_local_size (0); + + /** + * modifier + */ + + u32 w0[4]; + + w0[0] = pws[gid].i[ 0]; + w0[1] = pws[gid].i[ 1]; + w0[2] = pws[gid].i[ 2]; + w0[3] = pws[gid].i[ 3]; + + u32 w1[4]; + + w1[0] = pws[gid].i[ 4]; + w1[1] = pws[gid].i[ 5]; + w1[2] = pws[gid].i[ 6]; + w1[3] = pws[gid].i[ 7]; + + u32 w2[4]; + + w2[0] = 0; + w2[1] = 0; + w2[2] = 0; + w2[3] = 0; + + u32 w3[4]; + + w3[0] = 0; + w3[1] = 0; + w3[2] = pws[gid].i[14]; + w3[3] = 0; + + const u32 pw_len = pws[gid].pw_len & 63; + + /** + * bin2asc uppercase array + */ + + LOCAL_VK u32 u_bin2asc[256]; + + for (u32 j = lid; j < 256; j += lsz) + { + const u32 i0 = (j >> 0) & 15; + const u32 i1 = (j >> 4) & 15; + + u_bin2asc[j] = ((i0 < 10) ? '0' + i0 : 'A' - 10 + i0) << 8 + | ((i1 < 10) ? '0' + i1 : 'A' - 10 + i1) << 0; + } + + SYNC_THREADS (); + + if (gid >= GID_CNT) return; + + /** + * main + */ + + m03730s (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, 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, u_bin2asc); +} + +KERNEL_FQ void m03730_s16 (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) +{ + /** + * base + */ + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + const u64 lsz = get_local_size (0); + + /** + * bin2asc uppercase array + */ + + LOCAL_VK u32 u_bin2asc[256]; + + for (u32 j = lid; j < 256; j += lsz) + { + const u32 i0 = (j >> 0) & 15; + const u32 i1 = (j >> 4) & 15; + + u_bin2asc[j] = ((i0 < 10) ? '0' + i0 : 'A' - 10 + i0) << 8 + | ((i1 < 10) ? '0' + i1 : 'A' - 10 + i1) << 0; + } + + SYNC_THREADS (); + + if (gid >= GID_CNT) return; + + /** + * modifier + */ + + u32 w0[4]; + + w0[0] = pws[gid].i[ 0]; + w0[1] = pws[gid].i[ 1]; + w0[2] = pws[gid].i[ 2]; + w0[3] = pws[gid].i[ 3]; + + u32 w1[4]; + + w1[0] = pws[gid].i[ 4]; + w1[1] = pws[gid].i[ 5]; + w1[2] = pws[gid].i[ 6]; + w1[3] = pws[gid].i[ 7]; + + u32 w2[4]; + + w2[0] = pws[gid].i[ 8]; + w2[1] = pws[gid].i[ 9]; + w2[2] = pws[gid].i[10]; + w2[3] = pws[gid].i[11]; + + u32 w3[4]; + + w3[0] = pws[gid].i[12]; + w3[1] = pws[gid].i[13]; + w3[2] = pws[gid].i[14]; + w3[3] = pws[gid].i[15]; + + const u32 pw_len = pws[gid].pw_len & 63; + + /** + * main + */ + + m03730s (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, 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, u_bin2asc); +} diff --git a/OpenCL/m03730_a3-pure.cl b/OpenCL/m03730_a3-pure.cl new file mode 100644 index 000000000..114d5f6dc --- /dev/null +++ b/OpenCL/m03730_a3-pure.cl @@ -0,0 +1,328 @@ +/** + * 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 + +#if VECT_SIZE == 1 +#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i)]) +#elif VECT_SIZE == 2 +#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i).s0], u_bin2asc[(i).s1]) +#elif VECT_SIZE == 4 +#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i).s0], u_bin2asc[(i).s1], u_bin2asc[(i).s2], u_bin2asc[(i).s3]) +#elif VECT_SIZE == 8 +#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i).s0], u_bin2asc[(i).s1], u_bin2asc[(i).s2], u_bin2asc[(i).s3], u_bin2asc[(i).s4], u_bin2asc[(i).s5], u_bin2asc[(i).s6], u_bin2asc[(i).s7]) +#elif VECT_SIZE == 16 +#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i).s0], u_bin2asc[(i).s1], u_bin2asc[(i).s2], u_bin2asc[(i).s3], u_bin2asc[(i).s4], u_bin2asc[(i).s5], u_bin2asc[(i).s6], u_bin2asc[(i).s7], u_bin2asc[(i).s8], u_bin2asc[(i).s9], u_bin2asc[(i).sa], u_bin2asc[(i).sb], u_bin2asc[(i).sc], u_bin2asc[(i).sd], u_bin2asc[(i).se], u_bin2asc[(i).sf]) +#endif + +typedef struct md5_double_salt +{ + u32 salt1_buf[64]; + int salt1_len; + + u32 salt2_buf[64]; + int salt2_len; + +} md5_double_salt_t; + +KERNEL_FQ void m03730_mxx (KERN_ATTR_VECTOR_ESALT (md5_double_salt_t)) +{ + /** + * modifier + */ + + const u64 gid = get_global_id (0); + const u64 lid = get_local_id (0); + const u64 lsz = get_local_size (0); + + /** + * bin2asc uppercase array + */ + LOCAL_VK u32 u_bin2asc[256]; + + for (u32 j = lid; j < 256; j += lsz) + { + const u32 i0 = (j >> 0) & 15; + const u32 i1 = (j >> 4) & 15; + + u_bin2asc[j] = ((i0 < 10) ? '0' + i0 : 'A' - 10 + i0) << 8 + | ((i1 < 10) ? '0' + i1 : 'A' - 10 + i1) << 0; + } + + SYNC_THREADS (); + + 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]; + } + + const u32 salt_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_len; + + u32 s[64] = { 0 }; + + for (u32 i = 0, idx = 0; i < salt_len; i += 4, idx += 1) + { + s[idx] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[idx]; + } + + const int salt2_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_len; + + u32 s2[64] = { 0 }; + + for (int i = 0, idx = 0; i < salt2_len; i += 4, idx += 1) + { + s2[idx] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[idx]; + } + + md5_ctx_vector_t ctx0; + + md5_init_vector (&ctx0); + + md5_update_vector (&ctx0, esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf, esalt_bufs[DIGESTS_OFFSET_HOST].salt2_len); + + /** + * 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 w0lr = w0l | w0r; + + w[0] = w0lr; + + md5_ctx_vector_t ctx1 = ctx0; + + md5_update_vector (&ctx1, w, pw_len); + + md5_final_vector (&ctx1); + + const u32x a = ctx1.h[0]; + const u32x b = ctx1.h[1]; + const u32x c = ctx1.h[2]; + const u32x d = ctx1.h[3]; + + md5_ctx_vector_t ctx; + + md5_init_vector (&ctx); + + md5_update_vector (&ctx, s, salt_len); + + u32x w0[4]; + u32x w1[4]; + u32x w2[4]; + u32x w3[4]; + + w0[0] = uint_to_hex_upper8 ((a >> 0) & 255) << 0 + | uint_to_hex_upper8 ((a >> 8) & 255) << 16; + w0[1] = uint_to_hex_upper8 ((a >> 16) & 255) << 0 + | uint_to_hex_upper8 ((a >> 24) & 255) << 16; + w0[2] = uint_to_hex_upper8 ((b >> 0) & 255) << 0 + | uint_to_hex_upper8 ((b >> 8) & 255) << 16; + w0[3] = uint_to_hex_upper8 ((b >> 16) & 255) << 0 + | uint_to_hex_upper8 ((b >> 24) & 255) << 16; + w1[0] = uint_to_hex_upper8 ((c >> 0) & 255) << 0 + | uint_to_hex_upper8 ((c >> 8) & 255) << 16; + w1[1] = uint_to_hex_upper8 ((c >> 16) & 255) << 0 + | uint_to_hex_upper8 ((c >> 24) & 255) << 16; + w1[2] = uint_to_hex_upper8 ((d >> 0) & 255) << 0 + | uint_to_hex_upper8 ((d >> 8) & 255) << 16; + w1[3] = uint_to_hex_upper8 ((d >> 16) & 255) << 0 + | uint_to_hex_upper8 ((d >> 24) & 255) << 16; + w2[0] = 0; + w2[1] = 0; + w2[2] = 0; + w2[3] = 0; + w3[0] = 0; + w3[1] = 0; + w3[2] = 0; + w3[3] = 0; + + md5_update_vector_64 (&ctx, w0, w1, w2, w3, 32); + + md5_final_vector (&ctx); + + const u32x r0 = ctx.h[DGST_R0]; + const u32x r1 = ctx.h[DGST_R1]; + const u32x r2 = ctx.h[DGST_R2]; + const u32x r3 = ctx.h[DGST_R3]; + + COMPARE_M_SIMD (r0, r1, r2, r3); + } +} + +KERNEL_FQ void m03730_sxx (KERN_ATTR_VECTOR_ESALT (md5_double_salt_t)) +{ + /** + * modifier + */ + + const u64 gid = get_global_id (0); + const u64 lid = get_local_id (0); + const u64 lsz = get_local_size (0); + + /* + * bin2asc uppercase table + */ + + LOCAL_VK u32 u_bin2asc[256]; + + for (u32 j = lid; j < 256; j += lsz) + { + const u32 i0 = (j >> 0) & 15; + const u32 i1 = (j >> 4) & 15; + + u_bin2asc[j] = ((i0 < 10) ? '0' + i0 : 'A' - 10 + i0) << 8 + | ((i1 < 10) ? '0' + i1 : 'A' - 10 + i1) << 0; + } + + SYNC_THREADS (); + + 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], + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R2], + digests_buf[DIGESTS_OFFSET_HOST].digest_buf[DGST_R3] + }; + + /** + * 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]; + } + + const u32 salt_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_len; + + u32 s[64] = { 0 }; + + for (u32 i = 0, idx = 0; i < salt_len; i += 4, idx += 1) + { + s[idx] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[idx]; + } + + const u32 salt2_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_len; + + u32 s2[64] = { 0 }; + + for (u32 i = 0, idx = 0; i < salt2_len; i += 4, idx += 1) + { + s2[idx] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[idx]; + } + + md5_ctx_vector_t ctx0; + + md5_init_vector (&ctx0); + + md5_update_vector (&ctx0, esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf, esalt_bufs[DIGESTS_OFFSET_HOST].salt2_len); + + /** + * 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 w0lr = w0l | w0r; + + w[0] = w0lr; + + md5_ctx_vector_t ctx1 = ctx0; + + md5_update_vector (&ctx1, w, pw_len); + + md5_final_vector (&ctx1); + + const u32x a = ctx1.h[0]; + const u32x b = ctx1.h[1]; + const u32x c = ctx1.h[2]; + const u32x d = ctx1.h[3]; + + md5_ctx_vector_t ctx; + + md5_init_vector (&ctx); + + md5_update_vector (&ctx, s, salt_len); + + u32x w0[4]; + u32x w1[4]; + u32x w2[4]; + u32x w3[4]; + + w0[0] = uint_to_hex_upper8 ((a >> 0) & 255) << 0 + | uint_to_hex_upper8 ((a >> 8) & 255) << 16; + w0[1] = uint_to_hex_upper8 ((a >> 16) & 255) << 0 + | uint_to_hex_upper8 ((a >> 24) & 255) << 16; + w0[2] = uint_to_hex_upper8 ((b >> 0) & 255) << 0 + | uint_to_hex_upper8 ((b >> 8) & 255) << 16; + w0[3] = uint_to_hex_upper8 ((b >> 16) & 255) << 0 + | uint_to_hex_upper8 ((b >> 24) & 255) << 16; + w1[0] = uint_to_hex_upper8 ((c >> 0) & 255) << 0 + | uint_to_hex_upper8 ((c >> 8) & 255) << 16; + w1[1] = uint_to_hex_upper8 ((c >> 16) & 255) << 0 + | uint_to_hex_upper8 ((c >> 24) & 255) << 16; + w1[2] = uint_to_hex_upper8 ((d >> 0) & 255) << 0 + | uint_to_hex_upper8 ((d >> 8) & 255) << 16; + w1[3] = uint_to_hex_upper8 ((d >> 16) & 255) << 0 + | uint_to_hex_upper8 ((d >> 24) & 255) << 16; + w2[0] = 0; + w2[1] = 0; + w2[2] = 0; + w2[3] = 0; + w3[0] = 0; + w3[1] = 0; + w3[2] = 0; + w3[3] = 0; + + md5_update_vector_64 (&ctx, w0, w1, w2, w3, 32); + + md5_final_vector (&ctx); + + const u32x r0 = ctx.h[DGST_R0]; + const u32x r1 = ctx.h[DGST_R1]; + const u32x r2 = ctx.h[DGST_R2]; + const u32x r3 = ctx.h[DGST_R3]; + + COMPARE_S_SIMD (r0, r1, r2, r3); + } +} diff --git a/src/modules/module_03730.c b/src/modules/module_03730.c new file mode 100644 index 000000000..1b4197506 --- /dev/null +++ b/src/modules/module_03730.c @@ -0,0 +1,278 @@ +/** + * 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" +#include "emu_inc_hash_md5.h" + +static const u32 ATTACK_EXEC = ATTACK_EXEC_INSIDE_KERNEL; +static const u32 DGST_POS0 = 0; +static const u32 DGST_POS1 = 3; +static const u32 DGST_POS2 = 2; +static const u32 DGST_POS3 = 1; +static const u32 DGST_SIZE = DGST_SIZE_4_4; +static const u32 HASH_CATEGORY = HASH_CATEGORY_RAW_HASH_SALTED; +static const char *HASH_NAME = "md5($salt1.strtoupper(md5($salt2.$pass)))"; +static const u64 KERN_TYPE = 3730; +static const u32 OPTI_TYPE = OPTI_TYPE_ZERO_BYTE + | OPTI_TYPE_PRECOMPUTE_INIT + | OPTI_TYPE_EARLY_SKIP; +static const u64 OPTS_TYPE = OPTS_TYPE_STOCK_MODULE + | OPTS_TYPE_PT_GENERATE_LE + | OPTS_TYPE_PT_ADD80 + | OPTS_TYPE_PT_ADDBITS14; +static const u32 SALT_TYPE = SALT_TYPE_GENERIC; +static const char *ST_PASS = "hashcat"; +static const char *ST_HASH = "0e1484eb061b8e9cfd81868bba1dc4a0:229381927:182719643"; + +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; } + +typedef struct md5_double_salt +{ + u32 salt1_buf[64]; + int salt1_len; + + u32 salt2_buf[64]; + int salt2_len; + +} md5_double_salt_t; + +u64 module_esalt_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) +{ + const u64 esalt_size = (const u64) sizeof (md5_double_salt_t); + + return esalt_size; +} + +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; + + md5_double_salt_t *md5_double_salt = (md5_double_salt_t *) esalt_buf; + + hc_token_t token; + + token.token_cnt = 3; + + token.sep[0] = hashconfig->separator; + token.len_min[0] = 32; + token.len_max[0] = 32; + token.attr[0] = TOKEN_ATTR_VERIFY_LENGTH + | TOKEN_ATTR_VERIFY_HEX; + + token.sep[1] = hashconfig->separator; + token.len_min[1] = SALT_MIN; + token.len_max[1] = SALT_MAX; + token.attr[1] = TOKEN_ATTR_VERIFY_LENGTH; + + token.sep[2] = hashconfig->separator; + token.len_min[2] = SALT_MIN; + token.len_max[2] = SALT_MAX; + token.attr[2] = TOKEN_ATTR_VERIFY_LENGTH; + + if (hashconfig->opts_type & OPTS_TYPE_ST_HEX) + { + token.len_min[1] *= 2; + token.len_max[1] *= 2; + + token.attr[1] |= TOKEN_ATTR_VERIFY_HEX; + + token.len_min[2] *= 2; + token.len_max[2] *= 2; + + token.attr[2] |= 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); + + 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] = hex_to_u32 (hash_pos + 16); + digest[3] = hex_to_u32 (hash_pos + 24); + + if (hashconfig->opti_type & OPTI_TYPE_OPTIMIZED_KERNEL) + { + digest[0] -= MD5M_A; + digest[1] -= MD5M_B; + digest[2] -= MD5M_C; + digest[3] -= MD5M_D; + } + + const bool parse_rc1 = generic_salt_decode (hashconfig, token.buf[1], token.len[1], (u8 *) md5_double_salt->salt1_buf, (int *) &md5_double_salt->salt1_len); + + if (parse_rc1 == false) return (PARSER_SALT_LENGTH); + + const bool parse_rc2 = generic_salt_decode (hashconfig, token.buf[2], token.len[2], (u8 *) md5_double_salt->salt2_buf, (int *) &md5_double_salt->salt2_len); + + if (parse_rc2 == false) return (PARSER_SALT_LENGTH); + + // make salt sorter happy + + md5_ctx_t md5_ctx; + + md5_init (&md5_ctx); + md5_update (&md5_ctx, md5_double_salt->salt1_buf, md5_double_salt->salt1_len); + md5_update (&md5_ctx, md5_double_salt->salt2_buf, md5_double_salt->salt2_len); + md5_final (&md5_ctx); + + salt->salt_buf[0] = md5_ctx.h[0]; + salt->salt_buf[1] = md5_ctx.h[1]; + salt->salt_buf[2] = md5_ctx.h[2]; + salt->salt_buf[3] = md5_ctx.h[3]; + + salt->salt_len = 16; + + 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 md5_double_salt_t *md5_double_salt = (const md5_double_salt_t *) esalt_buf; + + // we can not change anything in the original buffer, otherwise destroying sorting + // therefore create some local buffer + + u32 tmp[4]; + + tmp[0] = digest[0]; + tmp[1] = digest[1]; + tmp[2] = digest[2]; + tmp[3] = digest[3]; + + if (hashconfig->opti_type & OPTI_TYPE_OPTIMIZED_KERNEL) + { + tmp[0] += MD5M_A; + tmp[1] += MD5M_B; + tmp[2] += MD5M_C; + tmp[3] += MD5M_D; + } + + u8 *out_buf = (u8 *) line_buf; + + int out_len = 0; + + u32_to_hex (tmp[0], out_buf + out_len); out_len += 8; + u32_to_hex (tmp[1], out_buf + out_len); out_len += 8; + u32_to_hex (tmp[2], out_buf + out_len); out_len += 8; + u32_to_hex (tmp[3], out_buf + out_len); out_len += 8; + + out_buf[out_len] = hashconfig->separator; + + out_len += 1; + + out_len += generic_salt_encode (hashconfig, (const u8 *) md5_double_salt->salt1_buf, (const int) md5_double_salt->salt1_len, out_buf + out_len); + + out_buf[out_len] = hashconfig->separator; + + out_len += 1; + + out_len += generic_salt_encode (hashconfig, (const u8 *) md5_double_salt->salt2_buf, (const int) md5_double_salt->salt2_len, out_buf + out_len); + + 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_esalt_size; + 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; +} From b5420b40bd146adc7e656e703a250eca9699ba0f Mon Sep 17 00:00:00 2001 From: Pikachu Date: Thu, 20 Oct 2022 16:29:20 +0300 Subject: [PATCH 2/9] Fixed pure kernel on attack mode 0 for hash 3730 Concatenated $salt1 instead of $salt2 to $pass, rendering single hashes uncrackable. --- OpenCL/m03730_a0-pure.cl | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/OpenCL/m03730_a0-pure.cl b/OpenCL/m03730_a0-pure.cl index 322120f00..8fb097640 100644 --- a/OpenCL/m03730_a0-pure.cl +++ b/OpenCL/m03730_a0-pure.cl @@ -97,6 +97,7 @@ KERNEL_FQ void m03730_mxx (KERN_ATTR_RULES_ESALT (md5_double_salt_t)) md5_init (&ctx0); md5_update_global (&ctx0, esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf, esalt_bufs[DIGESTS_OFFSET_HOST].salt2_len); + /** * loop */ @@ -235,7 +236,7 @@ KERNEL_FQ void m03730_sxx (KERN_ATTR_RULES_ESALT (md5_double_salt_t)) md5_init (&ctx0); - md5_update_global (&ctx0, esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf, esalt_bufs[DIGESTS_OFFSET_HOST].salt1_len); + md5_update_global (&ctx0, esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf, esalt_bufs[DIGESTS_OFFSET_HOST].salt2_len); /** * loop From 76b6569b84f24f0d7a55341ccfaa152f31dc320b Mon Sep 17 00:00:00 2001 From: Pikachu Date: Thu, 20 Oct 2022 16:51:10 +0300 Subject: [PATCH 3/9] Update inc_common.h Fixed indentation. --- OpenCL/inc_common.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/OpenCL/inc_common.h b/OpenCL/inc_common.h index 97762a80f..cb04a398a 100644 --- a/OpenCL/inc_common.h +++ b/OpenCL/inc_common.h @@ -147,7 +147,7 @@ #if defined IS_METAL #define KERN_ATTR_BASIC() _KERN_ATTR_BASIC(), KERN_ATTR_MAIN_PARAMS -#define KERN_ATTR_BASIC_ESALT(e) _KERN_ATTR_BASIC_ESALT(e), KERN_ATTR_MAIN_PARAMS +#define KERN_ATTR_BASIC_ESALT(e) _KERN_ATTR_BASIC_ESALT(e), KERN_ATTR_MAIN_PARAMS #define KERN_ATTR_BITSLICE() _KERN_ATTR_BITSLICE(), KERN_ATTR_MAIN_PARAMS #define KERN_ATTR_ESALT(e) _KERN_ATTR_ESALT(e), KERN_ATTR_MAIN_PARAMS #define KERN_ATTR_RULES() _KERN_ATTR_RULES(), KERN_ATTR_MAIN_PARAMS @@ -161,7 +161,7 @@ #define KERN_ATTR_TM _KERN_ATTR_TM, KERN_ATTR_MAIN_PARAMS #else // CUDA, HIP and OpenCL #define KERN_ATTR_BASIC() _KERN_ATTR_BASIC() -#define KERN_ATTR_BASIC_ESALT(e) _KERN_ATTR_BASIC_ESALT(e) +#define KERN_ATTR_BASIC_ESALT(e) _KERN_ATTR_BASIC_ESALT(e) #define KERN_ATTR_BITSLICE() _KERN_ATTR_BITSLICE() #define KERN_ATTR_ESALT(e) _KERN_ATTR_ESALT(e) #define KERN_ATTR_RULES() _KERN_ATTR_RULES() From 1a1baf45acaa9ffed43df01415ef8c8c2ed69e7a Mon Sep 17 00:00:00 2001 From: Pikachu Date: Thu, 20 Oct 2022 16:52:34 +0300 Subject: [PATCH 4/9] Update inc_common.h Fixed indentation. --- OpenCL/inc_common.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/OpenCL/inc_common.h b/OpenCL/inc_common.h index cb04a398a..0eba6b8d7 100644 --- a/OpenCL/inc_common.h +++ b/OpenCL/inc_common.h @@ -147,7 +147,7 @@ #if defined IS_METAL #define KERN_ATTR_BASIC() _KERN_ATTR_BASIC(), KERN_ATTR_MAIN_PARAMS -#define KERN_ATTR_BASIC_ESALT(e) _KERN_ATTR_BASIC_ESALT(e), KERN_ATTR_MAIN_PARAMS +#define KERN_ATTR_BASIC_ESALT(e) _KERN_ATTR_BASIC_ESALT(e), KERN_ATTR_MAIN_PARAMS #define KERN_ATTR_BITSLICE() _KERN_ATTR_BITSLICE(), KERN_ATTR_MAIN_PARAMS #define KERN_ATTR_ESALT(e) _KERN_ATTR_ESALT(e), KERN_ATTR_MAIN_PARAMS #define KERN_ATTR_RULES() _KERN_ATTR_RULES(), KERN_ATTR_MAIN_PARAMS @@ -161,7 +161,7 @@ #define KERN_ATTR_TM _KERN_ATTR_TM, KERN_ATTR_MAIN_PARAMS #else // CUDA, HIP and OpenCL #define KERN_ATTR_BASIC() _KERN_ATTR_BASIC() -#define KERN_ATTR_BASIC_ESALT(e) _KERN_ATTR_BASIC_ESALT(e) +#define KERN_ATTR_BASIC_ESALT(e) _KERN_ATTR_BASIC_ESALT(e) #define KERN_ATTR_BITSLICE() _KERN_ATTR_BITSLICE() #define KERN_ATTR_ESALT(e) _KERN_ATTR_ESALT(e) #define KERN_ATTR_RULES() _KERN_ATTR_RULES() From 2a19e0c0bd7945253b2f26ca92312af6e017085e Mon Sep 17 00:00:00 2001 From: Pikachu Date: Sun, 23 Oct 2022 08:08:33 +0300 Subject: [PATCH 5/9] Removed unnecessary parsing of salt2 in pure kernels --- OpenCL/m03730_a0-optimized.cl | 2 ++ OpenCL/m03730_a0-pure.cl | 23 ++--------------------- OpenCL/m03730_a1-pure.cl | 20 +------------------- OpenCL/m03730_a3-pure.cl | 19 +------------------ docs/changes.txt | 1 + src/modules/module_03730.c | 13 ++++++------- 6 files changed, 13 insertions(+), 65 deletions(-) diff --git a/OpenCL/m03730_a0-optimized.cl b/OpenCL/m03730_a0-optimized.cl index df1e6252f..c0c24eb1c 100644 --- a/OpenCL/m03730_a0-optimized.cl +++ b/OpenCL/m03730_a0-optimized.cl @@ -51,6 +51,7 @@ KERNEL_FQ void m03730_m04 (KERN_ATTR_RULES_ESALT (md5_double_salt_t)) /** * bin2asc uppercase array */ + LOCAL_VK u32 u_bin2asc[256]; for (u32 j = lid; j < 256; j += lsz) @@ -419,6 +420,7 @@ KERNEL_FQ void m03730_s04 (KERN_ATTR_RULES_ESALT (md5_double_salt_t)) /** * bin2asc uppercase array */ + LOCAL_VK u32 u_bin2asc[256]; for (u32 j = lid; j < 256; j += lsz) diff --git a/OpenCL/m03730_a0-pure.cl b/OpenCL/m03730_a0-pure.cl index 8fb097640..2e0669ba2 100644 --- a/OpenCL/m03730_a0-pure.cl +++ b/OpenCL/m03730_a0-pure.cl @@ -38,7 +38,6 @@ typedef struct md5_double_salt } md5_double_salt_t; - KERNEL_FQ void m03730_mxx (KERN_ATTR_RULES_ESALT (md5_double_salt_t)) { /** @@ -82,15 +81,6 @@ KERNEL_FQ void m03730_mxx (KERN_ATTR_RULES_ESALT (md5_double_salt_t)) { s[idx] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[idx]; } - - const int salt2_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_len; - - u32 s2[64] = { 0 }; - - for (int i = 0, idx = 0; i < salt2_len; i += 4, idx += 1) - { - s2[idx] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[idx]; - } md5_ctx_t ctx0; @@ -181,6 +171,7 @@ KERNEL_FQ void m03730_sxx (KERN_ATTR_RULES_ESALT (md5_double_salt_t)) /** * bin2asc uppercase table */ + LOCAL_VK u32 u_bin2asc[256]; for (u32 j = lid; j < 256; j += lsz) @@ -222,15 +213,6 @@ KERNEL_FQ void m03730_sxx (KERN_ATTR_RULES_ESALT (md5_double_salt_t)) { s[idx] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[idx]; } - - const int salt2_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_len; - - u32 s2[64] = { 0 }; - - for (u32 i = 0, idx = 0; i < salt2_len; i += 4, idx += 1) - { - s2[idx] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[idx]; - } md5_ctx_t ctx0; @@ -244,7 +226,6 @@ KERNEL_FQ void m03730_sxx (KERN_ATTR_RULES_ESALT (md5_double_salt_t)) 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); @@ -307,4 +288,4 @@ KERNEL_FQ void m03730_sxx (KERN_ATTR_RULES_ESALT (md5_double_salt_t)) COMPARE_S_SCALAR (r0, r1, r2, r3); } -} +} \ No newline at end of file diff --git a/OpenCL/m03730_a1-pure.cl b/OpenCL/m03730_a1-pure.cl index b51734cb8..e32f5f210 100644 --- a/OpenCL/m03730_a1-pure.cl +++ b/OpenCL/m03730_a1-pure.cl @@ -78,15 +78,6 @@ KERNEL_FQ void m03730_mxx (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) s[idx] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[idx]; } - const int salt2_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_len; - - u32 s2[64] = { 0 }; - - for (int i = 0, idx = 0; i < salt2_len; i += 4, idx += 1) - { - s2[idx] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[idx]; - } - md5_ctx_t ctx0; md5_init (&ctx0); @@ -210,16 +201,7 @@ KERNEL_FQ void m03730_sxx (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) { s[idx] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[idx]; } - - const u32 salt2_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_len; - - u32 s2[64] = { 0 }; - - for (u32 i = 0, idx = 0; i < salt2_len; i += 4, idx += 1) - { - s2[idx] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[idx]; - } - + /** * base */ diff --git a/OpenCL/m03730_a3-pure.cl b/OpenCL/m03730_a3-pure.cl index 114d5f6dc..899fe648d 100644 --- a/OpenCL/m03730_a3-pure.cl +++ b/OpenCL/m03730_a3-pure.cl @@ -49,6 +49,7 @@ KERNEL_FQ void m03730_mxx (KERN_ATTR_VECTOR_ESALT (md5_double_salt_t)) /** * bin2asc uppercase array */ + LOCAL_VK u32 u_bin2asc[256]; for (u32 j = lid; j < 256; j += lsz) @@ -85,15 +86,6 @@ KERNEL_FQ void m03730_mxx (KERN_ATTR_VECTOR_ESALT (md5_double_salt_t)) { s[idx] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[idx]; } - - const int salt2_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_len; - - u32 s2[64] = { 0 }; - - for (int i = 0, idx = 0; i < salt2_len; i += 4, idx += 1) - { - s2[idx] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[idx]; - } md5_ctx_vector_t ctx0; @@ -238,15 +230,6 @@ KERNEL_FQ void m03730_sxx (KERN_ATTR_VECTOR_ESALT (md5_double_salt_t)) s[idx] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[idx]; } - const u32 salt2_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_len; - - u32 s2[64] = { 0 }; - - for (u32 i = 0, idx = 0; i < salt2_len; i += 4, idx += 1) - { - s2[idx] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[idx]; - } - md5_ctx_vector_t ctx0; md5_init_vector (&ctx0); diff --git a/docs/changes.txt b/docs/changes.txt index 01aef0566..2befcafdc 100644 --- a/docs/changes.txt +++ b/docs/changes.txt @@ -5,6 +5,7 @@ ## - Added hash-mode: Bisq .wallet (scrypt) +- Added hash-mode: Dahua NVR/DVR/HVR (md5($salt1.strtoupper(md5($salt2.$pass)))) ## ## Technical diff --git a/src/modules/module_03730.c b/src/modules/module_03730.c index 1b4197506..482f54ba6 100644 --- a/src/modules/module_03730.c +++ b/src/modules/module_03730.c @@ -95,11 +95,11 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE token.len_max[1] *= 2; token.attr[1] |= TOKEN_ATTR_VERIFY_HEX; - - token.len_min[2] *= 2; - token.len_max[2] *= 2; - - token.attr[2] |= TOKEN_ATTR_VERIFY_HEX; + + token.len_min[2] *= 2; + token.len_max[2] *= 2; + + token.attr[2] |= TOKEN_ATTR_VERIFY_HEX; } const int rc_tokenizer = input_tokenizer ((const u8 *) line_buf, line_len, &token); @@ -194,7 +194,6 @@ int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE out_len += generic_salt_encode (hashconfig, (const u8 *) md5_double_salt->salt2_buf, (const int) md5_double_salt->salt2_len, out_buf + out_len); return out_len; - } void module_init (module_ctx_t *module_ctx) @@ -275,4 +274,4 @@ void module_init (module_ctx_t *module_ctx) module_ctx->module_tmp_size = MODULE_DEFAULT; module_ctx->module_unstable_warning = MODULE_DEFAULT; module_ctx->module_warmup_disable = MODULE_DEFAULT; -} +} \ No newline at end of file From 2abe5126342942a35c52b36fac75d8247361f3ce Mon Sep 17 00:00:00 2001 From: Pikachu Date: Sun, 23 Oct 2022 14:58:15 +0300 Subject: [PATCH 6/9] Removed unnecessary changes made to inc_common.h and made the proper adjustments in the OpenCL kernels to inflict the changes --- OpenCL/inc_common.h | 5 ----- OpenCL/m03730_a0-pure.cl | 16 ++++++---------- OpenCL/m03730_a1-optimized.cl | 12 ++++++------ OpenCL/m03730_a1-pure.cl | 4 ++-- OpenCL/m03730_a3-optimized.cl | 16 ++++++++-------- src/modules/module_03730.c | 1 - 6 files changed, 22 insertions(+), 32 deletions(-) diff --git a/OpenCL/inc_common.h b/OpenCL/inc_common.h index 0eba6b8d7..016d6240a 100644 --- a/OpenCL/inc_common.h +++ b/OpenCL/inc_common.h @@ -92,7 +92,6 @@ #if defined IS_CUDA || defined IS_HIP #define _KERN_ATTR_BASIC() KERN_ATTR (GLOBAL_AS, GLOBAL_AS const bf_t *g_bfs_buf, void, void, void) -#define _KERN_ATTR_BASIC_ESALT(e) KERN_ATTR (GLOBAL_AS, GLOBAL_AS const bf_t *g_bfs_buf, void, void, e) #define _KERN_ATTR_BITSLICE() KERN_ATTR (GLOBAL_AS, GLOBAL_AS const bs_word_t *g_words_buf_s, void, void, void) #define _KERN_ATTR_ESALT(e) KERN_ATTR (GLOBAL_AS, GLOBAL_AS const bf_t *g_bfs_buf, void, void, e) #define _KERN_ATTR_RULES() KERN_ATTR (GLOBAL_AS, GLOBAL_AS const bf_t *g_bfs_buf, void, void, void) @@ -105,7 +104,6 @@ #define _KERN_ATTR_VECTOR_ESALT(e) KERN_ATTR (GLOBAL_AS, GLOBAL_AS const u32x *g_words_buf_r, void, void, e) #else #define _KERN_ATTR_BASIC() KERN_ATTR (GLOBAL_AS, CONSTANT_AS const bf_t *bfs_buf, void, void, void) -#define _KERN_ATTR_BASIC_ESALT(e) KERN_ATTR (GLOBAL_AS, CONSTANT_AS const bf_t *bfs_buf, void, void, e) #define _KERN_ATTR_BITSLICE() KERN_ATTR (GLOBAL_AS, CONSTANT_AS const bs_word_t *words_buf_s, void, void, void) #define _KERN_ATTR_ESALT(e) KERN_ATTR (GLOBAL_AS, CONSTANT_AS const bf_t *bfs_buf, void, void, e) #define _KERN_ATTR_RULES() KERN_ATTR (CONSTANT_AS, GLOBAL_AS const bf_t *bfs_buf, void, void, void) @@ -147,7 +145,6 @@ #if defined IS_METAL #define KERN_ATTR_BASIC() _KERN_ATTR_BASIC(), KERN_ATTR_MAIN_PARAMS -#define KERN_ATTR_BASIC_ESALT(e) _KERN_ATTR_BASIC_ESALT(e), KERN_ATTR_MAIN_PARAMS #define KERN_ATTR_BITSLICE() _KERN_ATTR_BITSLICE(), KERN_ATTR_MAIN_PARAMS #define KERN_ATTR_ESALT(e) _KERN_ATTR_ESALT(e), KERN_ATTR_MAIN_PARAMS #define KERN_ATTR_RULES() _KERN_ATTR_RULES(), KERN_ATTR_MAIN_PARAMS @@ -161,7 +158,6 @@ #define KERN_ATTR_TM _KERN_ATTR_TM, KERN_ATTR_MAIN_PARAMS #else // CUDA, HIP and OpenCL #define KERN_ATTR_BASIC() _KERN_ATTR_BASIC() -#define KERN_ATTR_BASIC_ESALT(e) _KERN_ATTR_BASIC_ESALT(e) #define KERN_ATTR_BITSLICE() _KERN_ATTR_BITSLICE() #define KERN_ATTR_ESALT(e) _KERN_ATTR_ESALT(e) #define KERN_ATTR_RULES() _KERN_ATTR_RULES() @@ -188,7 +184,6 @@ MAYBE_UNUSED const u64 lsz #define KERN_ATTR_FUNC_BASIC() _KERN_ATTR_BASIC(), KERN_ATTR_FUNC_PARAMS -#define KERN_ATTR_FUNC_BASIC_ESALT(e) _KERN_ATTR_BASIC_ESALT(e), KERN_ATTR_FUNC_PARAMS #define KERN_ATTR_FUNC_BITSLICE() _KERN_ATTR_BITSLICE(), KERN_ATTR_FUNC_PARAMS #define KERN_ATTR_FUNC_ESALT(e) _KERN_ATTR_ESALT(e), KERN_ATTR_FUNC_PARAMS #define KERN_ATTR_FUNC_RULES() _KERN_ATTR_RULES(), KERN_ATTR_FUNC_PARAMS diff --git a/OpenCL/m03730_a0-pure.cl b/OpenCL/m03730_a0-pure.cl index 2e0669ba2..03c901054 100644 --- a/OpenCL/m03730_a0-pure.cl +++ b/OpenCL/m03730_a0-pure.cl @@ -38,7 +38,7 @@ typedef struct md5_double_salt } md5_double_salt_t; -KERNEL_FQ void m03730_mxx (KERN_ATTR_RULES_ESALT (md5_double_salt_t)) +KERNEL_FQ void m03730_mxx (KERN_ATTR_ESALT (md5_double_salt_t)) { /** * modifier @@ -96,12 +96,10 @@ KERNEL_FQ void m03730_mxx (KERN_ATTR_RULES_ESALT (md5_double_salt_t)) { pw_t tmp = PASTE_PW; - tmp.pw_len = apply_rules (rules_buf[il_pos].cmds, tmp.i, tmp.pw_len); - md5_ctx_t ctx1 = ctx0; - md5_update (&ctx1, tmp.i, tmp.pw_len); - + md5_update(&ctx1, pws[gid].i, pws[gid].pw_len); + md5_final (&ctx1); const u32 a = ctx1.h[0]; @@ -158,7 +156,7 @@ KERNEL_FQ void m03730_mxx (KERN_ATTR_RULES_ESALT (md5_double_salt_t)) } } -KERNEL_FQ void m03730_sxx (KERN_ATTR_RULES_ESALT (md5_double_salt_t)) +KERNEL_FQ void m03730_sxx (KERN_ATTR_ESALT (md5_double_salt_t)) { /** * modifier @@ -228,11 +226,9 @@ KERNEL_FQ void m03730_sxx (KERN_ATTR_RULES_ESALT (md5_double_salt_t)) { pw_t tmp = PASTE_PW; - tmp.pw_len = apply_rules (rules_buf[il_pos].cmds, tmp.i, tmp.pw_len); - md5_ctx_t ctx1 = ctx0; - md5_update (&ctx1, tmp.i, tmp.pw_len); + md5_update (&ctx1, pws[gid].i, pws[gid].pw_len); md5_final (&ctx1); @@ -288,4 +284,4 @@ KERNEL_FQ void m03730_sxx (KERN_ATTR_RULES_ESALT (md5_double_salt_t)) COMPARE_S_SCALAR (r0, r1, r2, r3); } -} \ No newline at end of file +} diff --git a/OpenCL/m03730_a1-optimized.cl b/OpenCL/m03730_a1-optimized.cl index 69a6b1736..64173bdd7 100644 --- a/OpenCL/m03730_a1-optimized.cl +++ b/OpenCL/m03730_a1-optimized.cl @@ -36,7 +36,7 @@ typedef struct md5_double_salt } md5_double_salt_t; -KERNEL_FQ void m03730_m04 (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) +KERNEL_FQ void m03730_m04 (KERN_ATTR_ESALT (md5_double_salt_t)) { /** * modifier @@ -455,15 +455,15 @@ KERNEL_FQ void m03730_m04 (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) } } -KERNEL_FQ void m03730_m08 (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) +KERNEL_FQ void m03730_m08 (KERN_ATTR_ESALT (md5_double_salt_t)) { } -KERNEL_FQ void m03730_m16 (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) +KERNEL_FQ void m03730_m16 (KERN_ATTR_ESALT (md5_double_salt_t)) { } -KERNEL_FQ void m03730_s04 (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) +KERNEL_FQ void m03730_s04 (KERN_ATTR_ESALT (md5_double_salt_t)) { /** * modifier @@ -897,10 +897,10 @@ KERNEL_FQ void m03730_s04 (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) } } -KERNEL_FQ void m03730_s08 (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) +KERNEL_FQ void m03730_s08 (KERN_ATTR_ESALT (md5_double_salt_t)) { } -KERNEL_FQ void m03730_s16 (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) +KERNEL_FQ void m03730_s16 (KERN_ATTR_ESALT (md5_double_salt_t)) { } diff --git a/OpenCL/m03730_a1-pure.cl b/OpenCL/m03730_a1-pure.cl index e32f5f210..df60a8b32 100644 --- a/OpenCL/m03730_a1-pure.cl +++ b/OpenCL/m03730_a1-pure.cl @@ -36,7 +36,7 @@ typedef struct md5_double_salt } md5_double_salt_t; -KERNEL_FQ void m03730_mxx (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) +KERNEL_FQ void m03730_mxx (KERN_ATTR_ESALT (md5_double_salt_t)) { /** * modifier @@ -152,7 +152,7 @@ KERNEL_FQ void m03730_mxx (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) } } -KERNEL_FQ void m03730_sxx (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) +KERNEL_FQ void m03730_sxx (KERN_ATTR_ESALT (md5_double_salt_t)) { /** * modifier diff --git a/OpenCL/m03730_a3-optimized.cl b/OpenCL/m03730_a3-optimized.cl index 85044932d..261a679d3 100644 --- a/OpenCL/m03730_a3-optimized.cl +++ b/OpenCL/m03730_a3-optimized.cl @@ -36,7 +36,7 @@ typedef struct md5_double_salt } md5_double_salt_t; -DECLSPEC void m03730m (PRIVATE_AS u32 *w0, PRIVATE_AS u32 *w1, PRIVATE_AS u32 *w2, PRIVATE_AS u32 *w3, const u32 pw_len, KERN_ATTR_FUNC_BASIC_ESALT (md5_double_salt_t), LOCAL_AS u32 *u_bin2asc) +DECLSPEC void m03730m (PRIVATE_AS u32 *w0, PRIVATE_AS u32 *w1, PRIVATE_AS u32 *w2, PRIVATE_AS u32 *w3, const u32 pw_len, KERN_ATTR_FUNC_ESALT (md5_double_salt_t), LOCAL_AS u32 *u_bin2asc) { /** * modifiers are taken from args @@ -370,7 +370,7 @@ DECLSPEC void m03730m (PRIVATE_AS u32 *w0, PRIVATE_AS u32 *w1, PRIVATE_AS u32 *w } } -DECLSPEC void m03730s (PRIVATE_AS u32 *w0, PRIVATE_AS u32 *w1, PRIVATE_AS u32 *w2, PRIVATE_AS u32 *w3, const u32 pw_len, KERN_ATTR_FUNC_BASIC_ESALT (md5_double_salt_t), LOCAL_AS u32 *u_bin2asc) +DECLSPEC void m03730s (PRIVATE_AS u32 *w0, PRIVATE_AS u32 *w1, PRIVATE_AS u32 *w2, PRIVATE_AS u32 *w3, const u32 pw_len, KERN_ATTR_FUNC_ESALT (md5_double_salt_t), LOCAL_AS u32 *u_bin2asc) { /** * modifiers are taken from args @@ -719,7 +719,7 @@ DECLSPEC void m03730s (PRIVATE_AS u32 *w0, PRIVATE_AS u32 *w1, PRIVATE_AS u32 *w } } -KERNEL_FQ void m03730_m04 (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) +KERNEL_FQ void m03730_m04 (KERN_ATTR_ESALT (md5_double_salt_t)) { /** * base @@ -788,7 +788,7 @@ KERNEL_FQ void m03730_m04 (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) m03730m (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, 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, u_bin2asc); } -KERNEL_FQ void m03730_m08 (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) +KERNEL_FQ void m03730_m08 (KERN_ATTR_ESALT (md5_double_salt_t)) { /** * base @@ -857,7 +857,7 @@ KERNEL_FQ void m03730_m08 (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) m03730m (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, 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, u_bin2asc); } -KERNEL_FQ void m03730_m16 (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) +KERNEL_FQ void m03730_m16 (KERN_ATTR_ESALT (md5_double_salt_t)) { /** * base @@ -927,7 +927,7 @@ KERNEL_FQ void m03730_m16 (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) m03730m (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, 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, u_bin2asc); } -KERNEL_FQ void m03730_s04 (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) +KERNEL_FQ void m03730_s04 (KERN_ATTR_ESALT (md5_double_salt_t)) { /** * base @@ -997,7 +997,7 @@ KERNEL_FQ void m03730_s04 (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) m03730s (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, 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, u_bin2asc); } -KERNEL_FQ void m03730_s08 (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) +KERNEL_FQ void m03730_s08 (KERN_ATTR_ESALT (md5_double_salt_t)) { /** * base @@ -1067,7 +1067,7 @@ KERNEL_FQ void m03730_s08 (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) m03730s (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, 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, u_bin2asc); } -KERNEL_FQ void m03730_s16 (KERN_ATTR_BASIC_ESALT (md5_double_salt_t)) +KERNEL_FQ void m03730_s16 (KERN_ATTR_ESALT (md5_double_salt_t)) { /** * base diff --git a/src/modules/module_03730.c b/src/modules/module_03730.c index 482f54ba6..a8a9e084f 100644 --- a/src/modules/module_03730.c +++ b/src/modules/module_03730.c @@ -200,7 +200,6 @@ 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; From a23080a5cc1c520dd50a0880f2460a541c7568a5 Mon Sep 17 00:00:00 2001 From: Pikachu Date: Sun, 23 Oct 2022 15:13:24 +0300 Subject: [PATCH 7/9] Added a unit-test in tools/test_modules for hash-mode 3730 --- tools/test_modules/m03730.pm | 46 ++++++++++++++++++++++++++++++++++++ 1 file changed, 46 insertions(+) create mode 100644 tools/test_modules/m03730.pm diff --git a/tools/test_modules/m03730.pm b/tools/test_modules/m03730.pm new file mode 100644 index 000000000..73fb116a8 --- /dev/null +++ b/tools/test_modules/m03730.pm @@ -0,0 +1,46 @@ +#!/usr/bin/env perl + +## +## Author......: See docs/credits.txt +## License.....: MIT +## + +use strict; +use warnings; + +use Digest::MD5 qw (md5_hex); + +sub module_constraints { [[0, 256], [0, 256], [0, 55], [0, 23], [0, 55]] } + +sub module_generate_hash +{ + my $word = shift; + my $salt1 = shift; + my $salt2 = shift || random_numeric_string (128); + + my $digest = md5_hex ($salt1 . uc(md5_hex ($salt2 . $word))); + + my $hash = sprintf ("%s:%s:%s", $digest, $salt1, $salt2); + + return $hash; +} + +sub module_verify_hash +{ + my $line = shift; + + my ($hash, $salt1, $salt2, $word) = split (':', $line); + + return unless defined $hash; + return unless defined $salt1; + return unless defined $salt2; + return unless defined $word; + + $word = pack_if_HEX_notation ($word); + + my $new_hash = module_generate_hash ($word, $salt1, $salt2); + + return ($new_hash, $word); +} + +1; From 760eba95fbf0cb77c98882209a74820220733265 Mon Sep 17 00:00:00 2001 From: Pikachu Date: Sun, 23 Oct 2022 18:17:42 +0300 Subject: [PATCH 8/9] Updated hash-mode 3730 unit-test to work with two salts --- tools/test_modules/m03730.pm | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/tools/test_modules/m03730.pm b/tools/test_modules/m03730.pm index 73fb116a8..11547fd83 100644 --- a/tools/test_modules/m03730.pm +++ b/tools/test_modules/m03730.pm @@ -10,14 +10,14 @@ use warnings; use Digest::MD5 qw (md5_hex); -sub module_constraints { [[0, 256], [0, 256], [0, 55], [0, 23], [0, 55]] } +sub module_constraints { [[0, 64], [0, 128], [0, 55], [0, 128], [0, 55]] } sub module_generate_hash { my $word = shift; my $salt1 = shift; - my $salt2 = shift || random_numeric_string (128); - + my $salt2 = shift || random_numeric_string (32); + my $digest = md5_hex ($salt1 . uc(md5_hex ($salt2 . $word))); my $hash = sprintf ("%s:%s:%s", $digest, $salt1, $salt2); @@ -29,18 +29,17 @@ sub module_verify_hash { my $line = shift; - my ($hash, $salt1, $salt2, $word) = split (':', $line); + my ($hash, $salt, $word) = split (':', $line); return unless defined $hash; - return unless defined $salt1; - return unless defined $salt2; + return unless defined $salt; return unless defined $word; - $word = pack_if_HEX_notation ($word); + my $word_packed = pack_if_HEX_notation ($word); - my $new_hash = module_generate_hash ($word, $salt1, $salt2); + my $new_hash = module_generate_hash ($word_packed, $salt); return ($new_hash, $word); } -1; +1; \ No newline at end of file From c81596511cf2b98e6a1f7342380c2e9698af513c Mon Sep 17 00:00:00 2001 From: Pikachu Date: Wed, 26 Oct 2022 19:58:00 +0300 Subject: [PATCH 9/9] Removed hash-mode 3730 optimized kernel support Optimized kernels requires handling on data larger than the block size of the underlaying primitive, thus more work is to be done to support optimized kernels. --- OpenCL/m03730_a0-optimized.cl | 792 ----------------------- OpenCL/m03730_a1-optimized.cl | 906 -------------------------- OpenCL/m03730_a3-optimized.cl | 1138 --------------------------------- tools/test_modules/m03730.pm | 4 +- 4 files changed, 2 insertions(+), 2838 deletions(-) delete mode 100644 OpenCL/m03730_a0-optimized.cl delete mode 100644 OpenCL/m03730_a1-optimized.cl delete mode 100644 OpenCL/m03730_a3-optimized.cl diff --git a/OpenCL/m03730_a0-optimized.cl b/OpenCL/m03730_a0-optimized.cl deleted file mode 100644 index c0c24eb1c..000000000 --- a/OpenCL/m03730_a0-optimized.cl +++ /dev/null @@ -1,792 +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) -#include M2S(INCLUDE_PATH/inc_hash_md5.cl) -#endif - -#if VECT_SIZE == 1 -#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i)]) -#elif VECT_SIZE == 2 -#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i).s0], u_bin2asc[(i).s1]) -#elif VECT_SIZE == 4 -#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i).s0], u_bin2asc[(i).s1], u_bin2asc[(i).s2], u_bin2asc[(i).s3]) -#elif VECT_SIZE == 8 -#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i).s0], u_bin2asc[(i).s1], u_bin2asc[(i).s2], u_bin2asc[(i).s3], u_bin2asc[(i).s4], u_bin2asc[(i).s5], u_bin2asc[(i).s6], u_bin2asc[(i).s7]) -#elif VECT_SIZE == 16 -#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i).s0], u_bin2asc[(i).s1], u_bin2asc[(i).s2], u_bin2asc[(i).s3], u_bin2asc[(i).s4], u_bin2asc[(i).s5], u_bin2asc[(i).s6], u_bin2asc[(i).s7], u_bin2asc[(i).s8], u_bin2asc[(i).s9], u_bin2asc[(i).sa], u_bin2asc[(i).sb], u_bin2asc[(i).sc], u_bin2asc[(i).sd], u_bin2asc[(i).se], u_bin2asc[(i).sf]) -#endif - -typedef struct md5_double_salt -{ - u32 salt1_buf[64]; - int salt1_len; - - u32 salt2_buf[64]; - int salt2_len; - -} md5_double_salt_t; - -KERNEL_FQ void m03730_m04 (KERN_ATTR_RULES_ESALT (md5_double_salt_t)) -{ - /** - * modifier - */ - - const u64 gid = get_global_id (0); - const u64 lid = get_local_id (0); - const u64 lsz = get_local_size (0); - - /** - * bin2asc uppercase array - */ - - LOCAL_VK u32 u_bin2asc[256]; - - for (u32 j = lid; j < 256; j += lsz) - { - const u32 i0 = (j >> 0) & 15; - const u32 i1 = (j >> 4) & 15; - - u_bin2asc[j] = ((i0 < 10) ? '0' + i0 : 'A' - 10 + i0) << 8 - | ((i1 < 10) ? '0' + i1 : 'A' - 10 + i1) << 0; - } - - SYNC_THREADS (); - - 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_len = pws[gid].pw_len & 63; - - /** - * salt1 - */ - - u32 salt1_buf0[4]; - u32 salt1_buf1[4]; - u32 salt1_buf2[4]; - u32 salt1_buf3[4]; - - salt1_buf0[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 0]; - salt1_buf0[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 1]; - salt1_buf0[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 2]; - salt1_buf0[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 3]; - salt1_buf1[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 4]; - salt1_buf1[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 5]; - salt1_buf1[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 6]; - salt1_buf1[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 7]; - salt1_buf2[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 8]; - salt1_buf2[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 9]; - salt1_buf2[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[10]; - salt1_buf2[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[11]; - salt1_buf3[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[12]; - salt1_buf3[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[13]; - salt1_buf3[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[14]; - salt1_buf3[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[15]; - - const u32 salt1_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_len; - - /** - * salt2 - */ - - u32 salt2_buf0[4]; - u32 salt2_buf1[4]; - u32 salt2_buf2[4]; - u32 salt2_buf3[4]; - - salt2_buf0[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 0]; - salt2_buf0[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 1]; - salt2_buf0[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 2]; - salt2_buf0[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 3]; - salt2_buf1[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 4]; - salt2_buf1[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 5]; - salt2_buf1[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 6]; - salt2_buf1[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 7]; - salt2_buf2[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 8]; - salt2_buf2[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 9]; - salt2_buf2[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[10]; - salt2_buf2[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[11]; - salt2_buf3[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[12]; - salt2_buf3[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[13]; - salt2_buf3[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[14]; - salt2_buf3[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[15]; - - const u32 salt2_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_len; - - const u32 pw_salt_len = 32 + salt2_len; - - /** - * loop - */ - - for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) - { - u32x w0[4] = { 0 }; - u32x w1[4] = { 0 }; - u32x w2[4] = { 0 }; - u32x w3[4] = { 0 }; - - const u32x out_len = apply_rules_vect_optimized (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w0, w1); - - /** - * prepend salt2 - */ - - const u32x out_salt_len = salt2_len + out_len; - - switch_buffer_by_offset_le (w0, w1, w2, w3, salt2_len); - - w0[0] |= salt2_buf0[0]; - w0[1] |= salt2_buf0[1]; - w0[2] |= salt2_buf0[2]; - w0[3] |= salt2_buf0[3]; - w1[0] |= salt2_buf1[0]; - w1[1] |= salt2_buf1[1]; - w1[2] |= salt2_buf1[2]; - w1[3] |= salt2_buf1[3]; - w2[0] |= salt2_buf2[0]; - w2[1] |= salt2_buf2[1]; - w2[2] |= salt2_buf2[2]; - w2[3] |= salt2_buf2[3]; - w3[0] |= salt2_buf3[0]; - w3[1] |= salt2_buf3[1]; - w3[2] = out_salt_len * 8; - w3[3] = 0; - - append_0x80_4x4_VV (w0, w1, w2, w3, out_salt_len); - - /** - * md5 - */ - - u32x a = MD5M_A; - u32x b = MD5M_B; - u32x c = MD5M_C; - u32x d = MD5M_D; - - MD5_STEP (MD5_Fo, a, b, c, d, w0[0], MD5C00, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w0[1], MD5C01, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w0[2], MD5C02, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w0[3], MD5C03, MD5S03); - MD5_STEP (MD5_Fo, a, b, c, d, w1[0], MD5C04, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w1[1], MD5C05, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w1[2], MD5C06, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w1[3], MD5C07, MD5S03); - MD5_STEP (MD5_Fo, a, b, c, d, w2[0], MD5C08, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w2[1], MD5C09, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w2[2], MD5C0a, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w2[3], MD5C0b, MD5S03); - MD5_STEP (MD5_Fo, a, b, c, d, w3[0], MD5C0c, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w3[1], MD5C0d, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w3[2], MD5C0e, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w3[3], MD5C0f, MD5S03); - - MD5_STEP (MD5_Go, a, b, c, d, w0[1], MD5C10, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w1[2], MD5C11, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w2[3], MD5C12, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w0[0], MD5C13, MD5S13); - MD5_STEP (MD5_Go, a, b, c, d, w1[1], MD5C14, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w2[2], MD5C15, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w3[3], MD5C16, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w1[0], MD5C17, MD5S13); - MD5_STEP (MD5_Go, a, b, c, d, w2[1], MD5C18, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w3[2], MD5C19, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w0[3], MD5C1a, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w2[0], MD5C1b, MD5S13); - MD5_STEP (MD5_Go, a, b, c, d, w3[1], MD5C1c, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w0[2], MD5C1d, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w1[3], MD5C1e, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w3[0], MD5C1f, MD5S13); - - u32x t; - - MD5_STEP (MD5_H1, a, b, c, d, w1[1], MD5C20, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w2[0], MD5C21, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w2[3], MD5C22, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w3[2], MD5C23, MD5S23); - MD5_STEP (MD5_H1, a, b, c, d, w0[1], MD5C24, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w1[0], MD5C25, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w1[3], MD5C26, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w2[2], MD5C27, MD5S23); - MD5_STEP (MD5_H1, a, b, c, d, w3[1], MD5C28, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w0[0], MD5C29, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w0[3], MD5C2a, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w1[2], MD5C2b, MD5S23); - MD5_STEP (MD5_H1, a, b, c, d, w2[1], MD5C2c, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w3[0], MD5C2d, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w3[3], MD5C2e, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w0[2], MD5C2f, MD5S23); - - MD5_STEP (MD5_I , a, b, c, d, w0[0], MD5C30, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w1[3], MD5C31, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w3[2], MD5C32, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w1[1], MD5C33, MD5S33); - MD5_STEP (MD5_I , a, b, c, d, w3[0], MD5C34, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w0[3], MD5C35, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w2[2], MD5C36, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w0[1], MD5C37, MD5S33); - MD5_STEP (MD5_I , a, b, c, d, w2[0], MD5C38, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w3[3], MD5C39, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w1[2], MD5C3a, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w3[1], MD5C3b, MD5S33); - MD5_STEP (MD5_I , a, b, c, d, w1[0], MD5C3c, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w2[3], MD5C3d, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w0[2], MD5C3e, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w2[1], MD5C3f, MD5S33); - - a += make_u32x (MD5M_A); - b += make_u32x (MD5M_B); - c += make_u32x (MD5M_C); - d += make_u32x (MD5M_D); - - w0[0] = uint_to_hex_upper8 ((a >> 0) & 255) << 0 - | uint_to_hex_upper8 ((a >> 8) & 255) << 16; - w0[1] = uint_to_hex_upper8 ((a >> 16) & 255) << 0 - | uint_to_hex_upper8 ((a >> 24) & 255) << 16; - w0[2] = uint_to_hex_upper8 ((b >> 0) & 255) << 0 - | uint_to_hex_upper8 ((b >> 8) & 255) << 16; - w0[3] = uint_to_hex_upper8 ((b >> 16) & 255) << 0 - | uint_to_hex_upper8 ((b >> 24) & 255) << 16; - w1[0] = uint_to_hex_upper8 ((c >> 0) & 255) << 0 - | uint_to_hex_upper8 ((c >> 8) & 255) << 16; - w1[1] = uint_to_hex_upper8 ((c >> 16) & 255) << 0 - | uint_to_hex_upper8 ((c >> 24) & 255) << 16; - w1[2] = uint_to_hex_upper8 ((d >> 0) & 255) << 0 - | uint_to_hex_upper8 ((d >> 8) & 255) << 16; - w1[3] = uint_to_hex_upper8 ((d >> 16) & 255) << 0 - | uint_to_hex_upper8 ((d >> 24) & 255) << 16; - w2[0] = 0x80; - w2[1] = 0; - w2[2] = 0; - w2[3] = 0; - w3[0] = 0; - w3[1] = 0; - w3[2] = 0; - w3[3] = 0; - - /** - * prepend salt1 - */ - - switch_buffer_by_offset_le (w0, w1, w2, w3, salt1_len); - - w3[2] = pw_salt_len * 8; - w3[3] = 0; - - w0[0] |= salt1_buf0[0]; - w0[1] |= salt1_buf0[1]; - w0[2] |= salt1_buf0[2]; - w0[3] |= salt1_buf0[3]; - w1[0] |= salt1_buf1[0]; - w1[1] |= salt1_buf1[1]; - w1[2] |= salt1_buf1[2]; - w1[3] |= salt1_buf1[3]; - w2[0] |= salt1_buf2[0]; - w2[1] |= salt1_buf2[1]; - w2[2] |= salt1_buf2[2]; - w2[3] |= salt1_buf2[3]; - w3[0] |= salt1_buf3[0]; - w3[1] |= salt1_buf3[1]; - w3[2] |= salt1_buf3[2]; - w3[3] |= salt1_buf3[3]; - - /** - * md5 - */ - - a = MD5M_A; - b = MD5M_B; - c = MD5M_C; - d = MD5M_D; - - MD5_STEP (MD5_Fo, a, b, c, d, w0[0], MD5C00, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w0[1], MD5C01, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w0[2], MD5C02, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w0[3], MD5C03, MD5S03); - MD5_STEP (MD5_Fo, a, b, c, d, w1[0], MD5C04, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w1[1], MD5C05, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w1[2], MD5C06, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w1[3], MD5C07, MD5S03); - MD5_STEP (MD5_Fo, a, b, c, d, w2[0], MD5C08, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w2[1], MD5C09, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w2[2], MD5C0a, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w2[3], MD5C0b, MD5S03); - MD5_STEP (MD5_Fo, a, b, c, d, w3[0], MD5C0c, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w3[1], MD5C0d, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w3[2], MD5C0e, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w3[3], MD5C0f, MD5S03); - - MD5_STEP (MD5_Go, a, b, c, d, w0[1], MD5C10, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w1[2], MD5C11, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w2[3], MD5C12, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w0[0], MD5C13, MD5S13); - MD5_STEP (MD5_Go, a, b, c, d, w1[1], MD5C14, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w2[2], MD5C15, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w3[3], MD5C16, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w1[0], MD5C17, MD5S13); - MD5_STEP (MD5_Go, a, b, c, d, w2[1], MD5C18, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w3[2], MD5C19, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w0[3], MD5C1a, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w2[0], MD5C1b, MD5S13); - MD5_STEP (MD5_Go, a, b, c, d, w3[1], MD5C1c, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w0[2], MD5C1d, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w1[3], MD5C1e, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w3[0], MD5C1f, MD5S13); - - MD5_STEP (MD5_H1, a, b, c, d, w1[1], MD5C20, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w2[0], MD5C21, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w2[3], MD5C22, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w3[2], MD5C23, MD5S23); - MD5_STEP (MD5_H1, a, b, c, d, w0[1], MD5C24, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w1[0], MD5C25, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w1[3], MD5C26, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w2[2], MD5C27, MD5S23); - MD5_STEP (MD5_H1, a, b, c, d, w3[1], MD5C28, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w0[0], MD5C29, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w0[3], MD5C2a, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w1[2], MD5C2b, MD5S23); - MD5_STEP (MD5_H1, a, b, c, d, w2[1], MD5C2c, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w3[0], MD5C2d, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w3[3], MD5C2e, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w0[2], MD5C2f, MD5S23); - - MD5_STEP (MD5_I , a, b, c, d, w0[0], MD5C30, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w1[3], MD5C31, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w3[2], MD5C32, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w1[1], MD5C33, MD5S33); - MD5_STEP (MD5_I , a, b, c, d, w3[0], MD5C34, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w0[3], MD5C35, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w2[2], MD5C36, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w0[1], MD5C37, MD5S33); - MD5_STEP (MD5_I , a, b, c, d, w2[0], MD5C38, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w3[3], MD5C39, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w1[2], MD5C3a, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w3[1], MD5C3b, MD5S33); - MD5_STEP (MD5_I , a, b, c, d, w1[0], MD5C3c, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w2[3], MD5C3d, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w0[2], MD5C3e, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w2[1], MD5C3f, MD5S33); - - COMPARE_M_SIMD (a, d, c, b); - } -} - -KERNEL_FQ void m03730_m08 (KERN_ATTR_RULES_ESALT (md5_double_salt_t)) -{ -} - -KERNEL_FQ void m03730_m16 (KERN_ATTR_RULES_ESALT (md5_double_salt_t)) -{ -} - -KERNEL_FQ void m03730_s04 (KERN_ATTR_RULES_ESALT (md5_double_salt_t)) -{ - /** - * modifier - */ - - const u64 gid = get_global_id (0); - const u64 lid = get_local_id (0); - const u64 lsz = get_local_size (0); - - /** - * bin2asc uppercase array - */ - - LOCAL_VK u32 u_bin2asc[256]; - - for (u32 j = lid; j < 256; j += lsz) - { - const u32 i0 = (j >> 0) & 15; - const u32 i1 = (j >> 4) & 15; - - u_bin2asc[j] = ((i0 < 10) ? '0' + i0 : 'A' - 10 + i0) << 8 - | ((i1 < 10) ? '0' + i1 : 'A' - 10 + i1) << 0; - } - - SYNC_THREADS (); - - 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_len = pws[gid].pw_len & 63; - - /** - * salt1 - */ - - u32 salt1_buf0[4]; - u32 salt1_buf1[4]; - u32 salt1_buf2[4]; - u32 salt1_buf3[4]; - - salt1_buf0[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 0]; - salt1_buf0[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 1]; - salt1_buf0[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 2]; - salt1_buf0[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 3]; - salt1_buf1[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 4]; - salt1_buf1[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 5]; - salt1_buf1[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 6]; - salt1_buf1[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 7]; - salt1_buf2[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 8]; - salt1_buf2[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 9]; - salt1_buf2[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[10]; - salt1_buf2[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[11]; - salt1_buf3[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[12]; - salt1_buf3[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[13]; - salt1_buf3[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[14]; - salt1_buf3[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[15]; - - const u32 salt1_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_len; - - /** - * salt2 - */ - - u32 salt2_buf0[4]; - u32 salt2_buf1[4]; - u32 salt2_buf2[4]; - u32 salt2_buf3[4]; - - salt2_buf0[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 0]; - salt2_buf0[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 1]; - salt2_buf0[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 2]; - salt2_buf0[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 3]; - salt2_buf1[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 4]; - salt2_buf1[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 5]; - salt2_buf1[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 6]; - salt2_buf1[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 7]; - salt2_buf2[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 8]; - salt2_buf2[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 9]; - salt2_buf2[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[10]; - salt2_buf2[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[11]; - salt2_buf3[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[12]; - salt2_buf3[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[13]; - salt2_buf3[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[14]; - salt2_buf3[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[15]; - - const u32 salt2_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_len; - - const u32 pw_salt_len = 32 + salt2_len; - - /** - * 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] - }; - - /** - * loop - */ - - for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) - { - u32x w0[4] = { 0 }; - u32x w1[4] = { 0 }; - u32x w2[4] = { 0 }; - u32x w3[4] = { 0 }; - - const u32x out_len = apply_rules_vect_optimized (pw_buf0, pw_buf1, pw_len, rules_buf, il_pos, w0, w1); - - /** - * prepend salt2 - */ - - const u32x out_salt_len = salt2_len + out_len; - - switch_buffer_by_offset_le (w0, w1, w2, w3, salt2_len); - - w0[0] |= salt2_buf0[0]; - w0[1] |= salt2_buf0[1]; - w0[2] |= salt2_buf0[2]; - w0[3] |= salt2_buf0[3]; - w1[0] |= salt2_buf1[0]; - w1[1] |= salt2_buf1[1]; - w1[2] |= salt2_buf1[2]; - w1[3] |= salt2_buf1[3]; - w2[0] |= salt2_buf2[0]; - w2[1] |= salt2_buf2[1]; - w2[2] |= salt2_buf2[2]; - w2[3] |= salt2_buf2[3]; - w3[0] |= salt2_buf3[0]; - w3[1] |= salt2_buf3[1]; - w3[2] = out_salt_len * 8; - w3[3] = 0; - - append_0x80_4x4_VV (w0, w1, w2, w3, out_salt_len); - - /** - * md5 - */ - - u32x a = MD5M_A; - u32x b = MD5M_B; - u32x c = MD5M_C; - u32x d = MD5M_D; - - MD5_STEP (MD5_Fo, a, b, c, d, w0[0], MD5C00, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w0[1], MD5C01, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w0[2], MD5C02, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w0[3], MD5C03, MD5S03); - MD5_STEP (MD5_Fo, a, b, c, d, w1[0], MD5C04, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w1[1], MD5C05, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w1[2], MD5C06, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w1[3], MD5C07, MD5S03); - MD5_STEP (MD5_Fo, a, b, c, d, w2[0], MD5C08, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w2[1], MD5C09, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w2[2], MD5C0a, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w2[3], MD5C0b, MD5S03); - MD5_STEP (MD5_Fo, a, b, c, d, w3[0], MD5C0c, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w3[1], MD5C0d, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w3[2], MD5C0e, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w3[3], MD5C0f, MD5S03); - - MD5_STEP (MD5_Go, a, b, c, d, w0[1], MD5C10, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w1[2], MD5C11, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w2[3], MD5C12, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w0[0], MD5C13, MD5S13); - MD5_STEP (MD5_Go, a, b, c, d, w1[1], MD5C14, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w2[2], MD5C15, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w3[3], MD5C16, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w1[0], MD5C17, MD5S13); - MD5_STEP (MD5_Go, a, b, c, d, w2[1], MD5C18, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w3[2], MD5C19, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w0[3], MD5C1a, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w2[0], MD5C1b, MD5S13); - MD5_STEP (MD5_Go, a, b, c, d, w3[1], MD5C1c, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w0[2], MD5C1d, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w1[3], MD5C1e, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w3[0], MD5C1f, MD5S13); - - u32x t; - - MD5_STEP (MD5_H1, a, b, c, d, w1[1], MD5C20, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w2[0], MD5C21, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w2[3], MD5C22, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w3[2], MD5C23, MD5S23); - MD5_STEP (MD5_H1, a, b, c, d, w0[1], MD5C24, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w1[0], MD5C25, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w1[3], MD5C26, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w2[2], MD5C27, MD5S23); - MD5_STEP (MD5_H1, a, b, c, d, w3[1], MD5C28, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w0[0], MD5C29, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w0[3], MD5C2a, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w1[2], MD5C2b, MD5S23); - MD5_STEP (MD5_H1, a, b, c, d, w2[1], MD5C2c, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w3[0], MD5C2d, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w3[3], MD5C2e, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w0[2], MD5C2f, MD5S23); - - MD5_STEP (MD5_I , a, b, c, d, w0[0], MD5C30, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w1[3], MD5C31, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w3[2], MD5C32, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w1[1], MD5C33, MD5S33); - MD5_STEP (MD5_I , a, b, c, d, w3[0], MD5C34, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w0[3], MD5C35, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w2[2], MD5C36, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w0[1], MD5C37, MD5S33); - MD5_STEP (MD5_I , a, b, c, d, w2[0], MD5C38, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w3[3], MD5C39, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w1[2], MD5C3a, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w3[1], MD5C3b, MD5S33); - MD5_STEP (MD5_I , a, b, c, d, w1[0], MD5C3c, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w2[3], MD5C3d, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w0[2], MD5C3e, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w2[1], MD5C3f, MD5S33); - - a += make_u32x (MD5M_A); - b += make_u32x (MD5M_B); - c += make_u32x (MD5M_C); - d += make_u32x (MD5M_D); - - w0[0] = uint_to_hex_upper8 ((a >> 0) & 255) << 0 - | uint_to_hex_upper8 ((a >> 8) & 255) << 16; - w0[1] = uint_to_hex_upper8 ((a >> 16) & 255) << 0 - | uint_to_hex_upper8 ((a >> 24) & 255) << 16; - w0[2] = uint_to_hex_upper8 ((b >> 0) & 255) << 0 - | uint_to_hex_upper8 ((b >> 8) & 255) << 16; - w0[3] = uint_to_hex_upper8 ((b >> 16) & 255) << 0 - | uint_to_hex_upper8 ((b >> 24) & 255) << 16; - w1[0] = uint_to_hex_upper8 ((c >> 0) & 255) << 0 - | uint_to_hex_upper8 ((c >> 8) & 255) << 16; - w1[1] = uint_to_hex_upper8 ((c >> 16) & 255) << 0 - | uint_to_hex_upper8 ((c >> 24) & 255) << 16; - w1[2] = uint_to_hex_upper8 ((d >> 0) & 255) << 0 - | uint_to_hex_upper8 ((d >> 8) & 255) << 16; - w1[3] = uint_to_hex_upper8 ((d >> 16) & 255) << 0 - | uint_to_hex_upper8 ((d >> 24) & 255) << 16; - w2[0] = 0x80; - w2[1] = 0; - w2[2] = 0; - w2[3] = 0; - w3[0] = 0; - w3[1] = 0; - w3[2] = 0; - w3[3] = 0; - - /** - * prepend salt1 - */ - - switch_buffer_by_offset_le (w0, w1, w2, w3, salt1_len); - - w3[2] = pw_salt_len * 8; - w3[3] = 0; - - w0[0] |= salt1_buf0[0]; - w0[1] |= salt1_buf0[1]; - w0[2] |= salt1_buf0[2]; - w0[3] |= salt1_buf0[3]; - w1[0] |= salt1_buf1[0]; - w1[1] |= salt1_buf1[1]; - w1[2] |= salt1_buf1[2]; - w1[3] |= salt1_buf1[3]; - w2[0] |= salt1_buf2[0]; - w2[1] |= salt1_buf2[1]; - w2[2] |= salt1_buf2[2]; - w2[3] |= salt1_buf2[3]; - w3[0] |= salt1_buf3[0]; - w3[1] |= salt1_buf3[1]; - w3[2] |= salt1_buf3[2]; - w3[3] |= salt1_buf3[3]; - - /** - * md5 - */ - - a = MD5M_A; - b = MD5M_B; - c = MD5M_C; - d = MD5M_D; - - MD5_STEP (MD5_Fo, a, b, c, d, w0[0], MD5C00, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w0[1], MD5C01, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w0[2], MD5C02, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w0[3], MD5C03, MD5S03); - MD5_STEP (MD5_Fo, a, b, c, d, w1[0], MD5C04, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w1[1], MD5C05, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w1[2], MD5C06, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w1[3], MD5C07, MD5S03); - MD5_STEP (MD5_Fo, a, b, c, d, w2[0], MD5C08, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w2[1], MD5C09, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w2[2], MD5C0a, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w2[3], MD5C0b, MD5S03); - MD5_STEP (MD5_Fo, a, b, c, d, w3[0], MD5C0c, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w3[1], MD5C0d, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w3[2], MD5C0e, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w3[3], MD5C0f, MD5S03); - - MD5_STEP (MD5_Go, a, b, c, d, w0[1], MD5C10, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w1[2], MD5C11, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w2[3], MD5C12, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w0[0], MD5C13, MD5S13); - MD5_STEP (MD5_Go, a, b, c, d, w1[1], MD5C14, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w2[2], MD5C15, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w3[3], MD5C16, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w1[0], MD5C17, MD5S13); - MD5_STEP (MD5_Go, a, b, c, d, w2[1], MD5C18, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w3[2], MD5C19, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w0[3], MD5C1a, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w2[0], MD5C1b, MD5S13); - MD5_STEP (MD5_Go, a, b, c, d, w3[1], MD5C1c, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w0[2], MD5C1d, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w1[3], MD5C1e, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w3[0], MD5C1f, MD5S13); - - MD5_STEP (MD5_H1, a, b, c, d, w1[1], MD5C20, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w2[0], MD5C21, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w2[3], MD5C22, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w3[2], MD5C23, MD5S23); - MD5_STEP (MD5_H1, a, b, c, d, w0[1], MD5C24, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w1[0], MD5C25, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w1[3], MD5C26, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w2[2], MD5C27, MD5S23); - MD5_STEP (MD5_H1, a, b, c, d, w3[1], MD5C28, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w0[0], MD5C29, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w0[3], MD5C2a, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w1[2], MD5C2b, MD5S23); - MD5_STEP (MD5_H1, a, b, c, d, w2[1], MD5C2c, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w3[0], MD5C2d, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w3[3], MD5C2e, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w0[2], MD5C2f, MD5S23); - - MD5_STEP (MD5_I , a, b, c, d, w0[0], MD5C30, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w1[3], MD5C31, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w3[2], MD5C32, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w1[1], MD5C33, MD5S33); - MD5_STEP (MD5_I , a, b, c, d, w3[0], MD5C34, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w0[3], MD5C35, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w2[2], MD5C36, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w0[1], MD5C37, MD5S33); - MD5_STEP (MD5_I , a, b, c, d, w2[0], MD5C38, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w3[3], MD5C39, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w1[2], MD5C3a, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w3[1], MD5C3b, MD5S33); - MD5_STEP (MD5_I , a, b, c, d, w1[0], MD5C3c, MD5S30); - - if (MATCHES_NONE_VS (a, search[0])) continue; - - MD5_STEP (MD5_I , d, a, b, c, w2[3], MD5C3d, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w0[2], MD5C3e, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w2[1], MD5C3f, MD5S33); - - COMPARE_S_SIMD (a, d, c, b); - } -} - -KERNEL_FQ void m03730_s08 (KERN_ATTR_RULES_ESALT (md5_double_salt_t)) -{ -} - -KERNEL_FQ void m03730_s16 (KERN_ATTR_RULES_ESALT (md5_double_salt_t)) -{ -} diff --git a/OpenCL/m03730_a1-optimized.cl b/OpenCL/m03730_a1-optimized.cl deleted file mode 100644 index 64173bdd7..000000000 --- a/OpenCL/m03730_a1-optimized.cl +++ /dev/null @@ -1,906 +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_simd.cl) -#include M2S(INCLUDE_PATH/inc_hash_md5.cl) -#endif - -#if VECT_SIZE == 1 -#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i)]) -#elif VECT_SIZE == 2 -#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i).s0], u_bin2asc[(i).s1]) -#elif VECT_SIZE == 4 -#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i).s0], u_bin2asc[(i).s1], u_bin2asc[(i).s2], u_bin2asc[(i).s3]) -#elif VECT_SIZE == 8 -#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i).s0], u_bin2asc[(i).s1], u_bin2asc[(i).s2], u_bin2asc[(i).s3], u_bin2asc[(i).s4], u_bin2asc[(i).s5], u_bin2asc[(i).s6], u_bin2asc[(i).s7]) -#elif VECT_SIZE == 16 -#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i).s0], u_bin2asc[(i).s1], u_bin2asc[(i).s2], u_bin2asc[(i).s3], u_bin2asc[(i).s4], u_bin2asc[(i).s5], u_bin2asc[(i).s6], u_bin2asc[(i).s7], u_bin2asc[(i).s8], u_bin2asc[(i).s9], u_bin2asc[(i).sa], u_bin2asc[(i).sb], u_bin2asc[(i).sc], u_bin2asc[(i).sd], u_bin2asc[(i).se], u_bin2asc[(i).sf]) -#endif - -typedef struct md5_double_salt -{ - u32 salt1_buf[64]; - int salt1_len; - - u32 salt2_buf[64]; - int salt2_len; - -} md5_double_salt_t; - -KERNEL_FQ void m03730_m04 (KERN_ATTR_ESALT (md5_double_salt_t)) -{ - /** - * modifier - */ - - const u64 gid = get_global_id (0); - const u64 lid = get_local_id (0); - const u64 lsz = get_local_size (0); - - /** - * bin2asc uppercase table - */ - - LOCAL_VK u32 u_bin2asc[256]; - - for (u32 j = lid; j < 256; j += lsz) - { - const u32 i0 = (j >> 0) & 15; - const u32 i1 = (j >> 4) & 15; - - u_bin2asc[j] = ((i0 < 10) ? '0' + i0 : 'A' - 10 + i0) << 8 - | ((i1 < 10) ? '0' + i1 : 'A' - 10 + i1) << 0; - } - - SYNC_THREADS (); - - 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; - - /** - * salt1 - */ - - u32 salt1_buf0[4]; - u32 salt1_buf1[4]; - u32 salt1_buf2[4]; - u32 salt1_buf3[4]; - - salt1_buf0[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 0]; - salt1_buf0[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 1]; - salt1_buf0[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 2]; - salt1_buf0[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 3]; - salt1_buf1[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 4]; - salt1_buf1[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 5]; - salt1_buf1[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 6]; - salt1_buf1[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 7]; - salt1_buf2[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 8]; - salt1_buf2[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 9]; - salt1_buf2[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[10]; - salt1_buf2[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[11]; - salt1_buf3[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[12]; - salt1_buf3[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[13]; - salt1_buf3[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[14]; - salt1_buf3[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[15]; - - const u32 salt1_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_len; - - /** - * salt2 - */ - - u32 salt2_buf0[4]; - u32 salt2_buf1[4]; - u32 salt2_buf2[4]; - u32 salt2_buf3[4]; - - salt2_buf0[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 0]; - salt2_buf0[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 1]; - salt2_buf0[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 2]; - salt2_buf0[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 3]; - salt2_buf1[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 4]; - salt2_buf1[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 5]; - salt2_buf1[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 6]; - salt2_buf1[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 7]; - salt2_buf2[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 8]; - salt2_buf2[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 9]; - salt2_buf2[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[10]; - salt2_buf2[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[11]; - salt2_buf3[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[12]; - salt2_buf3[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[13]; - salt2_buf3[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[14]; - salt2_buf3[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[15]; - - const u32 salt2_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_len; - - const u32 final_len = salt1_len + 32; - - /** - * loop - */ - - for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) - { - const u32x pw_r_len = pwlenx_create_combt (combs_buf, il_pos) & 63; - - const u32x pw_len = (pw_l_len + pw_r_len) & 63; - - /** - * concat password candidate - */ - - u32x wordl0[4] = { 0 }; - u32x wordl1[4] = { 0 }; - u32x wordl2[4] = { 0 }; - u32x 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]; - - u32x wordr0[4] = { 0 }; - u32x wordr1[4] = { 0 }; - u32x wordr2[4] = { 0 }; - u32x 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); - } - - u32x w0[4]; - u32x w1[4]; - u32x w2[4]; - u32x w3[4]; - - w0[0] = wordl0[0] | wordr0[0]; - w0[1] = wordl0[1] | wordr0[1]; - w0[2] = wordl0[2] | wordr0[2]; - w0[3] = wordl0[3] | wordr0[3]; - w1[0] = wordl1[0] | wordr1[0]; - w1[1] = wordl1[1] | wordr1[1]; - w1[2] = wordl1[2] | wordr1[2]; - w1[3] = wordl1[3] | wordr1[3]; - w2[0] = wordl2[0] | wordr2[0]; - w2[1] = wordl2[1] | wordr2[1]; - w2[2] = wordl2[2] | wordr2[2]; - w2[3] = wordl2[3] | wordr2[3]; - w3[0] = wordl3[0] | wordr3[0]; - w3[1] = wordl3[1] | wordr3[1]; - w3[2] = pw_len * 8; - w3[3] = 0; - - /** - * prepend salt2 - */ - - switch_buffer_by_offset_le (w0, w1, w2, w3, salt2_len); - - const u32x pw_salt_len = pw_len + salt2_len; - - w0[0] |= salt2_buf0[0]; - w0[1] |= salt2_buf0[1]; - w0[2] |= salt2_buf0[2]; - w0[3] |= salt2_buf0[3]; - w1[0] |= salt2_buf1[0]; - w1[1] |= salt2_buf1[1]; - w1[2] |= salt2_buf1[2]; - w1[3] |= salt2_buf1[3]; - w2[0] |= salt2_buf2[0]; - w2[1] |= salt2_buf2[1]; - w2[2] |= salt2_buf2[2]; - w2[3] |= salt2_buf2[3]; - w3[0] |= salt2_buf3[0]; - w3[1] |= salt2_buf3[1]; - w3[2] = pw_salt_len * 8; - w3[3] = 0; - - /** - * md5 - */ - - u32x a = MD5M_A; - u32x b = MD5M_B; - u32x c = MD5M_C; - u32x d = MD5M_D; - - MD5_STEP (MD5_Fo, a, b, c, d, w0[0], MD5C00, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w0[1], MD5C01, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w0[2], MD5C02, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w0[3], MD5C03, MD5S03); - MD5_STEP (MD5_Fo, a, b, c, d, w1[0], MD5C04, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w1[1], MD5C05, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w1[2], MD5C06, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w1[3], MD5C07, MD5S03); - MD5_STEP (MD5_Fo, a, b, c, d, w2[0], MD5C08, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w2[1], MD5C09, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w2[2], MD5C0a, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w2[3], MD5C0b, MD5S03); - MD5_STEP (MD5_Fo, a, b, c, d, w3[0], MD5C0c, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w3[1], MD5C0d, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w3[2], MD5C0e, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w3[3], MD5C0f, MD5S03); - - MD5_STEP (MD5_Go, a, b, c, d, w0[1], MD5C10, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w1[2], MD5C11, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w2[3], MD5C12, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w0[0], MD5C13, MD5S13); - MD5_STEP (MD5_Go, a, b, c, d, w1[1], MD5C14, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w2[2], MD5C15, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w3[3], MD5C16, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w1[0], MD5C17, MD5S13); - MD5_STEP (MD5_Go, a, b, c, d, w2[1], MD5C18, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w3[2], MD5C19, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w0[3], MD5C1a, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w2[0], MD5C1b, MD5S13); - MD5_STEP (MD5_Go, a, b, c, d, w3[1], MD5C1c, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w0[2], MD5C1d, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w1[3], MD5C1e, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w3[0], MD5C1f, MD5S13); - - u32x t; - - MD5_STEP (MD5_H1, a, b, c, d, w1[1], MD5C20, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w2[0], MD5C21, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w2[3], MD5C22, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w3[2], MD5C23, MD5S23); - MD5_STEP (MD5_H1, a, b, c, d, w0[1], MD5C24, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w1[0], MD5C25, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w1[3], MD5C26, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w2[2], MD5C27, MD5S23); - MD5_STEP (MD5_H1, a, b, c, d, w3[1], MD5C28, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w0[0], MD5C29, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w0[3], MD5C2a, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w1[2], MD5C2b, MD5S23); - MD5_STEP (MD5_H1, a, b, c, d, w2[1], MD5C2c, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w3[0], MD5C2d, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w3[3], MD5C2e, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w0[2], MD5C2f, MD5S23); - - MD5_STEP (MD5_I , a, b, c, d, w0[0], MD5C30, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w1[3], MD5C31, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w3[2], MD5C32, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w1[1], MD5C33, MD5S33); - MD5_STEP (MD5_I , a, b, c, d, w3[0], MD5C34, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w0[3], MD5C35, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w2[2], MD5C36, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w0[1], MD5C37, MD5S33); - MD5_STEP (MD5_I , a, b, c, d, w2[0], MD5C38, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w3[3], MD5C39, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w1[2], MD5C3a, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w3[1], MD5C3b, MD5S33); - MD5_STEP (MD5_I , a, b, c, d, w1[0], MD5C3c, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w2[3], MD5C3d, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w0[2], MD5C3e, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w2[1], MD5C3f, MD5S33); - - a += make_u32x (MD5M_A); - b += make_u32x (MD5M_B); - c += make_u32x (MD5M_C); - d += make_u32x (MD5M_D); - - w0[0] = uint_to_hex_upper8 ((a >> 0) & 255) << 0 - | uint_to_hex_upper8 ((a >> 8) & 255) << 16; - w0[1] = uint_to_hex_upper8 ((a >> 16) & 255) << 0 - | uint_to_hex_upper8 ((a >> 24) & 255) << 16; - w0[2] = uint_to_hex_upper8 ((b >> 0) & 255) << 0 - | uint_to_hex_upper8 ((b >> 8) & 255) << 16; - w0[3] = uint_to_hex_upper8 ((b >> 16) & 255) << 0 - | uint_to_hex_upper8 ((b >> 24) & 255) << 16; - w1[0] = uint_to_hex_upper8 ((c >> 0) & 255) << 0 - | uint_to_hex_upper8 ((c >> 8) & 255) << 16; - w1[1] = uint_to_hex_upper8 ((c >> 16) & 255) << 0 - | uint_to_hex_upper8 ((c >> 24) & 255) << 16; - w1[2] = uint_to_hex_upper8 ((d >> 0) & 255) << 0 - | uint_to_hex_upper8 ((d >> 8) & 255) << 16; - w1[3] = uint_to_hex_upper8 ((d >> 16) & 255) << 0 - | uint_to_hex_upper8 ((d >> 24) & 255) << 16; - w2[0] = 0x80; - w2[1] = 0; - w2[2] = 0; - w2[3] = 0; - w3[0] = 0; - w3[1] = 0; - w3[2] = 0; - w3[3] = 0; - - /** - * prepend salt1 - */ - - switch_buffer_by_offset_le (w0, w1, w2, w3, salt1_len); - - w3[2] = final_len * 8; - w3[3] = 0; - - w0[0] |= salt1_buf0[0]; - w0[1] |= salt1_buf0[1]; - w0[2] |= salt1_buf0[2]; - w0[3] |= salt1_buf0[3]; - w1[0] |= salt1_buf1[0]; - w1[1] |= salt1_buf1[1]; - w1[2] |= salt1_buf1[2]; - w1[3] |= salt1_buf1[3]; - w2[0] |= salt1_buf2[0]; - w2[1] |= salt1_buf2[1]; - w2[2] |= salt1_buf2[2]; - w2[3] |= salt1_buf2[3]; - w3[0] |= salt1_buf3[0]; - w3[1] |= salt1_buf3[1]; - w3[2] |= salt1_buf3[2]; - w3[3] |= salt1_buf3[3]; - - /** - * md5 - */ - - a = MD5M_A; - b = MD5M_B; - c = MD5M_C; - d = MD5M_D; - - MD5_STEP (MD5_Fo, a, b, c, d, w0[0], MD5C00, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w0[1], MD5C01, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w0[2], MD5C02, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w0[3], MD5C03, MD5S03); - MD5_STEP (MD5_Fo, a, b, c, d, w1[0], MD5C04, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w1[1], MD5C05, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w1[2], MD5C06, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w1[3], MD5C07, MD5S03); - MD5_STEP (MD5_Fo, a, b, c, d, w2[0], MD5C08, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w2[1], MD5C09, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w2[2], MD5C0a, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w2[3], MD5C0b, MD5S03); - MD5_STEP (MD5_Fo, a, b, c, d, w3[0], MD5C0c, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w3[1], MD5C0d, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w3[2], MD5C0e, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w3[3], MD5C0f, MD5S03); - - MD5_STEP (MD5_Go, a, b, c, d, w0[1], MD5C10, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w1[2], MD5C11, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w2[3], MD5C12, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w0[0], MD5C13, MD5S13); - MD5_STEP (MD5_Go, a, b, c, d, w1[1], MD5C14, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w2[2], MD5C15, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w3[3], MD5C16, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w1[0], MD5C17, MD5S13); - MD5_STEP (MD5_Go, a, b, c, d, w2[1], MD5C18, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w3[2], MD5C19, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w0[3], MD5C1a, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w2[0], MD5C1b, MD5S13); - MD5_STEP (MD5_Go, a, b, c, d, w3[1], MD5C1c, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w0[2], MD5C1d, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w1[3], MD5C1e, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w3[0], MD5C1f, MD5S13); - - MD5_STEP (MD5_H1, a, b, c, d, w1[1], MD5C20, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w2[0], MD5C21, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w2[3], MD5C22, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w3[2], MD5C23, MD5S23); - MD5_STEP (MD5_H1, a, b, c, d, w0[1], MD5C24, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w1[0], MD5C25, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w1[3], MD5C26, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w2[2], MD5C27, MD5S23); - MD5_STEP (MD5_H1, a, b, c, d, w3[1], MD5C28, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w0[0], MD5C29, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w0[3], MD5C2a, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w1[2], MD5C2b, MD5S23); - MD5_STEP (MD5_H1, a, b, c, d, w2[1], MD5C2c, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w3[0], MD5C2d, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w3[3], MD5C2e, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w0[2], MD5C2f, MD5S23); - - MD5_STEP (MD5_I , a, b, c, d, w0[0], MD5C30, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w1[3], MD5C31, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w3[2], MD5C32, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w1[1], MD5C33, MD5S33); - MD5_STEP (MD5_I , a, b, c, d, w3[0], MD5C34, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w0[3], MD5C35, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w2[2], MD5C36, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w0[1], MD5C37, MD5S33); - MD5_STEP (MD5_I , a, b, c, d, w2[0], MD5C38, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w3[3], MD5C39, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w1[2], MD5C3a, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w3[1], MD5C3b, MD5S33); - MD5_STEP (MD5_I , a, b, c, d, w1[0], MD5C3c, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w2[3], MD5C3d, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w0[2], MD5C3e, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w2[1], MD5C3f, MD5S33); - - COMPARE_M_SIMD (a, d, c, b); - } -} - -KERNEL_FQ void m03730_m08 (KERN_ATTR_ESALT (md5_double_salt_t)) -{ -} - -KERNEL_FQ void m03730_m16 (KERN_ATTR_ESALT (md5_double_salt_t)) -{ -} - -KERNEL_FQ void m03730_s04 (KERN_ATTR_ESALT (md5_double_salt_t)) -{ - /** - * modifier - */ - - const u64 gid = get_global_id (0); - const u64 lid = get_local_id (0); - const u64 lsz = get_local_size (0); - - /** - * bin2asc uppercase table - */ - - LOCAL_VK u32 u_bin2asc[256]; - - for (u32 j = lid; j < 256; j += lsz) - { - const u32 i0 = (j >> 0) & 15; - const u32 i1 = (j >> 4) & 15; - - u_bin2asc[j] = ((i0 < 10) ? '0' + i0 : 'A' - 10 + i0) << 8 - | ((i1 < 10) ? '0' + i1 : 'A' - 10 + i1) << 0; - } - - SYNC_THREADS (); - - 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; - - /** - * salt1 - */ - - u32 salt1_buf0[4]; - u32 salt1_buf1[4]; - u32 salt1_buf2[4]; - u32 salt1_buf3[4]; - - salt1_buf0[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 0]; - salt1_buf0[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 1]; - salt1_buf0[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 2]; - salt1_buf0[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 3]; - salt1_buf1[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 4]; - salt1_buf1[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 5]; - salt1_buf1[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 6]; - salt1_buf1[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 7]; - salt1_buf2[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 8]; - salt1_buf2[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 9]; - salt1_buf2[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[10]; - salt1_buf2[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[11]; - salt1_buf3[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[12]; - salt1_buf3[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[13]; - salt1_buf3[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[14]; - salt1_buf3[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[15]; - - const u32 salt1_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_len; - - /** - * salt2 - */ - - u32 salt2_buf0[4]; - u32 salt2_buf1[4]; - u32 salt2_buf2[4]; - u32 salt2_buf3[4]; - - salt2_buf0[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 0]; - salt2_buf0[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 1]; - salt2_buf0[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 2]; - salt2_buf0[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 3]; - salt2_buf1[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 4]; - salt2_buf1[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 5]; - salt2_buf1[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 6]; - salt2_buf1[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 7]; - salt2_buf2[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 8]; - salt2_buf2[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 9]; - salt2_buf2[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[10]; - salt2_buf2[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[11]; - salt2_buf3[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[12]; - salt2_buf3[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[13]; - salt2_buf3[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[14]; - salt2_buf3[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[15]; - - const u32 salt2_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_len; - - const u32 final_len = salt1_len + 32; - - /** - * 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] - }; - - /** - * loop - */ - - for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) - { - const u32x pw_r_len = pwlenx_create_combt (combs_buf, il_pos) & 63; - - const u32x pw_len = (pw_l_len + pw_r_len) & 63; - - /** - * concat password candidate - */ - - u32x wordl0[4] = { 0 }; - u32x wordl1[4] = { 0 }; - u32x wordl2[4] = { 0 }; - u32x 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]; - - u32x wordr0[4] = { 0 }; - u32x wordr1[4] = { 0 }; - u32x wordr2[4] = { 0 }; - u32x 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); - } - - u32x w0[4]; - u32x w1[4]; - u32x w2[4]; - u32x w3[4]; - - w0[0] = wordl0[0] | wordr0[0]; - w0[1] = wordl0[1] | wordr0[1]; - w0[2] = wordl0[2] | wordr0[2]; - w0[3] = wordl0[3] | wordr0[3]; - w1[0] = wordl1[0] | wordr1[0]; - w1[1] = wordl1[1] | wordr1[1]; - w1[2] = wordl1[2] | wordr1[2]; - w1[3] = wordl1[3] | wordr1[3]; - w2[0] = wordl2[0] | wordr2[0]; - w2[1] = wordl2[1] | wordr2[1]; - w2[2] = wordl2[2] | wordr2[2]; - w2[3] = wordl2[3] | wordr2[3]; - w3[0] = wordl3[0] | wordr3[0]; - w3[1] = wordl3[1] | wordr3[1]; - w3[2] = pw_len * 8; - w3[3] = 0; - - /** - * prepend salt2 - */ - - switch_buffer_by_offset_le (w0, w1, w2, w3, salt2_len); - - const u32x pw_salt_len = pw_len + salt2_len; - - w0[0] |= salt2_buf0[0]; - w0[1] |= salt2_buf0[1]; - w0[2] |= salt2_buf0[2]; - w0[3] |= salt2_buf0[3]; - w1[0] |= salt2_buf1[0]; - w1[1] |= salt2_buf1[1]; - w1[2] |= salt2_buf1[2]; - w1[3] |= salt2_buf1[3]; - w2[0] |= salt2_buf2[0]; - w2[1] |= salt2_buf2[1]; - w2[2] |= salt2_buf2[2]; - w2[3] |= salt2_buf2[3]; - w3[0] |= salt2_buf3[0]; - w3[1] |= salt2_buf3[1]; - w3[2] = pw_salt_len * 8; - w3[3] = 0; - - /** - * md5 - */ - - u32x a = MD5M_A; - u32x b = MD5M_B; - u32x c = MD5M_C; - u32x d = MD5M_D; - - MD5_STEP (MD5_Fo, a, b, c, d, w0[0], MD5C00, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w0[1], MD5C01, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w0[2], MD5C02, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w0[3], MD5C03, MD5S03); - MD5_STEP (MD5_Fo, a, b, c, d, w1[0], MD5C04, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w1[1], MD5C05, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w1[2], MD5C06, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w1[3], MD5C07, MD5S03); - MD5_STEP (MD5_Fo, a, b, c, d, w2[0], MD5C08, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w2[1], MD5C09, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w2[2], MD5C0a, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w2[3], MD5C0b, MD5S03); - MD5_STEP (MD5_Fo, a, b, c, d, w3[0], MD5C0c, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w3[1], MD5C0d, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w3[2], MD5C0e, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w3[3], MD5C0f, MD5S03); - - MD5_STEP (MD5_Go, a, b, c, d, w0[1], MD5C10, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w1[2], MD5C11, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w2[3], MD5C12, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w0[0], MD5C13, MD5S13); - MD5_STEP (MD5_Go, a, b, c, d, w1[1], MD5C14, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w2[2], MD5C15, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w3[3], MD5C16, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w1[0], MD5C17, MD5S13); - MD5_STEP (MD5_Go, a, b, c, d, w2[1], MD5C18, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w3[2], MD5C19, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w0[3], MD5C1a, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w2[0], MD5C1b, MD5S13); - MD5_STEP (MD5_Go, a, b, c, d, w3[1], MD5C1c, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w0[2], MD5C1d, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w1[3], MD5C1e, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w3[0], MD5C1f, MD5S13); - - u32x t; - - MD5_STEP (MD5_H1, a, b, c, d, w1[1], MD5C20, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w2[0], MD5C21, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w2[3], MD5C22, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w3[2], MD5C23, MD5S23); - MD5_STEP (MD5_H1, a, b, c, d, w0[1], MD5C24, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w1[0], MD5C25, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w1[3], MD5C26, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w2[2], MD5C27, MD5S23); - MD5_STEP (MD5_H1, a, b, c, d, w3[1], MD5C28, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w0[0], MD5C29, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w0[3], MD5C2a, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w1[2], MD5C2b, MD5S23); - MD5_STEP (MD5_H1, a, b, c, d, w2[1], MD5C2c, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w3[0], MD5C2d, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w3[3], MD5C2e, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w0[2], MD5C2f, MD5S23); - - MD5_STEP (MD5_I , a, b, c, d, w0[0], MD5C30, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w1[3], MD5C31, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w3[2], MD5C32, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w1[1], MD5C33, MD5S33); - MD5_STEP (MD5_I , a, b, c, d, w3[0], MD5C34, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w0[3], MD5C35, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w2[2], MD5C36, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w0[1], MD5C37, MD5S33); - MD5_STEP (MD5_I , a, b, c, d, w2[0], MD5C38, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w3[3], MD5C39, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w1[2], MD5C3a, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w3[1], MD5C3b, MD5S33); - MD5_STEP (MD5_I , a, b, c, d, w1[0], MD5C3c, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w2[3], MD5C3d, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w0[2], MD5C3e, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w2[1], MD5C3f, MD5S33); - - a += make_u32x (MD5M_A); - b += make_u32x (MD5M_B); - c += make_u32x (MD5M_C); - d += make_u32x (MD5M_D); - - w0[0] = uint_to_hex_upper8 ((a >> 0) & 255) << 0 - | uint_to_hex_upper8 ((a >> 8) & 255) << 16; - w0[1] = uint_to_hex_upper8 ((a >> 16) & 255) << 0 - | uint_to_hex_upper8 ((a >> 24) & 255) << 16; - w0[2] = uint_to_hex_upper8 ((b >> 0) & 255) << 0 - | uint_to_hex_upper8 ((b >> 8) & 255) << 16; - w0[3] = uint_to_hex_upper8 ((b >> 16) & 255) << 0 - | uint_to_hex_upper8 ((b >> 24) & 255) << 16; - w1[0] = uint_to_hex_upper8 ((c >> 0) & 255) << 0 - | uint_to_hex_upper8 ((c >> 8) & 255) << 16; - w1[1] = uint_to_hex_upper8 ((c >> 16) & 255) << 0 - | uint_to_hex_upper8 ((c >> 24) & 255) << 16; - w1[2] = uint_to_hex_upper8 ((d >> 0) & 255) << 0 - | uint_to_hex_upper8 ((d >> 8) & 255) << 16; - w1[3] = uint_to_hex_upper8 ((d >> 16) & 255) << 0 - | uint_to_hex_upper8 ((d >> 24) & 255) << 16; - w2[0] = 0x80; - w2[1] = 0; - w2[2] = 0; - w2[3] = 0; - w3[0] = 0; - w3[1] = 0; - w3[2] = 0; - w3[3] = 0; - - /** - * prepend salt1 - */ - - switch_buffer_by_offset_le (w0, w1, w2, w3, salt1_len); - - w3[2] = final_len * 8; - w3[3] = 0; - - w0[0] |= salt1_buf0[0]; - w0[1] |= salt1_buf0[1]; - w0[2] |= salt1_buf0[2]; - w0[3] |= salt1_buf0[3]; - w1[0] |= salt1_buf1[0]; - w1[1] |= salt1_buf1[1]; - w1[2] |= salt1_buf1[2]; - w1[3] |= salt1_buf1[3]; - w2[0] |= salt1_buf2[0]; - w2[1] |= salt1_buf2[1]; - w2[2] |= salt1_buf2[2]; - w2[3] |= salt1_buf2[3]; - w3[0] |= salt1_buf3[0]; - w3[1] |= salt1_buf3[1]; - w3[2] |= salt1_buf3[2]; - w3[3] |= salt1_buf3[3]; - - /** - * md5 - */ - - a = MD5M_A; - b = MD5M_B; - c = MD5M_C; - d = MD5M_D; - - MD5_STEP (MD5_Fo, a, b, c, d, w0[0], MD5C00, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w0[1], MD5C01, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w0[2], MD5C02, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w0[3], MD5C03, MD5S03); - MD5_STEP (MD5_Fo, a, b, c, d, w1[0], MD5C04, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w1[1], MD5C05, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w1[2], MD5C06, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w1[3], MD5C07, MD5S03); - MD5_STEP (MD5_Fo, a, b, c, d, w2[0], MD5C08, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w2[1], MD5C09, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w2[2], MD5C0a, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w2[3], MD5C0b, MD5S03); - MD5_STEP (MD5_Fo, a, b, c, d, w3[0], MD5C0c, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w3[1], MD5C0d, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w3[2], MD5C0e, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w3[3], MD5C0f, MD5S03); - - MD5_STEP (MD5_Go, a, b, c, d, w0[1], MD5C10, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w1[2], MD5C11, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w2[3], MD5C12, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w0[0], MD5C13, MD5S13); - MD5_STEP (MD5_Go, a, b, c, d, w1[1], MD5C14, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w2[2], MD5C15, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w3[3], MD5C16, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w1[0], MD5C17, MD5S13); - MD5_STEP (MD5_Go, a, b, c, d, w2[1], MD5C18, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w3[2], MD5C19, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w0[3], MD5C1a, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w2[0], MD5C1b, MD5S13); - MD5_STEP (MD5_Go, a, b, c, d, w3[1], MD5C1c, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w0[2], MD5C1d, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w1[3], MD5C1e, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w3[0], MD5C1f, MD5S13); - - MD5_STEP (MD5_H1, a, b, c, d, w1[1], MD5C20, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w2[0], MD5C21, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w2[3], MD5C22, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w3[2], MD5C23, MD5S23); - MD5_STEP (MD5_H1, a, b, c, d, w0[1], MD5C24, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w1[0], MD5C25, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w1[3], MD5C26, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w2[2], MD5C27, MD5S23); - MD5_STEP (MD5_H1, a, b, c, d, w3[1], MD5C28, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w0[0], MD5C29, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w0[3], MD5C2a, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w1[2], MD5C2b, MD5S23); - MD5_STEP (MD5_H1, a, b, c, d, w2[1], MD5C2c, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w3[0], MD5C2d, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w3[3], MD5C2e, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w0[2], MD5C2f, MD5S23); - - MD5_STEP (MD5_I , a, b, c, d, w0[0], MD5C30, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w1[3], MD5C31, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w3[2], MD5C32, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w1[1], MD5C33, MD5S33); - MD5_STEP (MD5_I , a, b, c, d, w3[0], MD5C34, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w0[3], MD5C35, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w2[2], MD5C36, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w0[1], MD5C37, MD5S33); - MD5_STEP (MD5_I , a, b, c, d, w2[0], MD5C38, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w3[3], MD5C39, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w1[2], MD5C3a, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w3[1], MD5C3b, MD5S33); - MD5_STEP (MD5_I , a, b, c, d, w1[0], MD5C3c, MD5S30); - - if (MATCHES_NONE_VS (a, search[0])) continue; - - MD5_STEP (MD5_I , d, a, b, c, w2[3], MD5C3d, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w0[2], MD5C3e, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w2[1], MD5C3f, MD5S33); - - COMPARE_S_SIMD (a, d, c, b); - } -} - -KERNEL_FQ void m03730_s08 (KERN_ATTR_ESALT (md5_double_salt_t)) -{ -} - -KERNEL_FQ void m03730_s16 (KERN_ATTR_ESALT (md5_double_salt_t)) -{ -} diff --git a/OpenCL/m03730_a3-optimized.cl b/OpenCL/m03730_a3-optimized.cl deleted file mode 100644 index 261a679d3..000000000 --- a/OpenCL/m03730_a3-optimized.cl +++ /dev/null @@ -1,1138 +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_simd.cl) -#include M2S(INCLUDE_PATH/inc_hash_md5.cl) -#endif - -#if VECT_SIZE == 1 -#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i)]) -#elif VECT_SIZE == 2 -#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i).s0], u_bin2asc[(i).s1]) -#elif VECT_SIZE == 4 -#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i).s0], u_bin2asc[(i).s1], u_bin2asc[(i).s2], u_bin2asc[(i).s3]) -#elif VECT_SIZE == 8 -#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i).s0], u_bin2asc[(i).s1], u_bin2asc[(i).s2], u_bin2asc[(i).s3], u_bin2asc[(i).s4], u_bin2asc[(i).s5], u_bin2asc[(i).s6], u_bin2asc[(i).s7]) -#elif VECT_SIZE == 16 -#define uint_to_hex_upper8(i) make_u32x (u_bin2asc[(i).s0], u_bin2asc[(i).s1], u_bin2asc[(i).s2], u_bin2asc[(i).s3], u_bin2asc[(i).s4], u_bin2asc[(i).s5], u_bin2asc[(i).s6], u_bin2asc[(i).s7], u_bin2asc[(i).s8], u_bin2asc[(i).s9], u_bin2asc[(i).sa], u_bin2asc[(i).sb], u_bin2asc[(i).sc], u_bin2asc[(i).sd], u_bin2asc[(i).se], u_bin2asc[(i).sf]) -#endif - -typedef struct md5_double_salt -{ - u32 salt1_buf[64]; - int salt1_len; - - u32 salt2_buf[64]; - int salt2_len; - -} md5_double_salt_t; - -DECLSPEC void m03730m (PRIVATE_AS u32 *w0, PRIVATE_AS u32 *w1, PRIVATE_AS u32 *w2, PRIVATE_AS u32 *w3, const u32 pw_len, KERN_ATTR_FUNC_ESALT (md5_double_salt_t), LOCAL_AS u32 *u_bin2asc) -{ - /** - * modifiers are taken from args - */ - - /** - * salt1 - */ - - u32 salt1_buf0[4]; - u32 salt1_buf1[4]; - u32 salt1_buf2[4]; - u32 salt1_buf3[4]; - - salt1_buf0[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 0]; - salt1_buf0[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 1]; - salt1_buf0[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 2]; - salt1_buf0[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 3]; - salt1_buf1[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 4]; - salt1_buf1[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 5]; - salt1_buf1[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 6]; - salt1_buf1[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 7]; - salt1_buf2[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 8]; - salt1_buf2[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 9]; - salt1_buf2[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[10]; - salt1_buf2[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[11]; - salt1_buf3[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[12]; - salt1_buf3[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[13]; - salt1_buf3[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[14]; - salt1_buf3[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[15]; - - const u32 salt1_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_len; - - /** - * salt2 - */ - - u32 salt2_buf0[4]; - u32 salt2_buf1[4]; - u32 salt2_buf2[4]; - u32 salt2_buf3[4]; - - salt2_buf0[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 0]; - salt2_buf0[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 1]; - salt2_buf0[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 2]; - salt2_buf0[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 3]; - salt2_buf1[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 4]; - salt2_buf1[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 5]; - salt2_buf1[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 6]; - salt2_buf1[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 7]; - salt2_buf2[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 8]; - salt2_buf2[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 9]; - salt2_buf2[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[10]; - salt2_buf2[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[11]; - salt2_buf3[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[12]; - salt2_buf3[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[13]; - salt2_buf3[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[14]; - salt2_buf3[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[15]; - - const u32 salt2_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_len; - - const u32 pw_salt_len = pw_len + salt2_len; - const u32 final_len = salt1_len + 32; - - /** - * loop - */ - - const u32 w0l = w0[0]; - - for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) - { - const u32x w0r = ix_create_bft (bfs_buf, il_pos); - - const u32x w0lr = w0l | w0r; - - u32x w0_t[4]; - u32x w1_t[4]; - u32x w2_t[4]; - u32x w3_t[4]; - - w0_t[0] = w0lr; - w0_t[1] = w0[1]; - w0_t[2] = w0[2]; - w0_t[3] = w0[3]; - w1_t[0] = w1[0]; - w1_t[1] = w1[1]; - w1_t[2] = w1[2]; - w1_t[3] = w1[3]; - w2_t[0] = w2[0]; - w2_t[1] = w2[1]; - w2_t[2] = w2[2]; - w2_t[3] = w2[3]; - w3_t[0] = w3[0]; - w3_t[1] = w3[1]; - w3_t[2] = w3[2]; - w3_t[3] = w3[3]; - - switch_buffer_by_offset_le (w0_t, w1_t, w2_t, w3_t, salt2_len); - - w0_t[0] |= salt2_buf0[0]; - w0_t[1] |= salt2_buf0[1]; - w0_t[2] |= salt2_buf0[2]; - w0_t[3] |= salt2_buf0[3]; - w1_t[0] |= salt2_buf1[0]; - w1_t[1] |= salt2_buf1[1]; - w1_t[2] |= salt2_buf1[2]; - w1_t[3] |= salt2_buf1[3]; - w2_t[0] |= salt2_buf2[0]; - w2_t[1] |= salt2_buf2[1]; - w2_t[2] |= salt2_buf2[2]; - w2_t[3] |= salt2_buf2[3]; - w3_t[0] |= salt2_buf3[0]; - w3_t[1] |= salt2_buf3[1]; - w3_t[2] = pw_salt_len * 8; - w3_t[3] = 0; - - /** - * md5 - */ - - u32x a = MD5M_A; - u32x b = MD5M_B; - u32x c = MD5M_C; - u32x d = MD5M_D; - - MD5_STEP (MD5_Fo, a, b, c, d, w0_t[0], MD5C00, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w0_t[1], MD5C01, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w0_t[2], MD5C02, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w0_t[3], MD5C03, MD5S03); - MD5_STEP (MD5_Fo, a, b, c, d, w1_t[0], MD5C04, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w1_t[1], MD5C05, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w1_t[2], MD5C06, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w1_t[3], MD5C07, MD5S03); - MD5_STEP (MD5_Fo, a, b, c, d, w2_t[0], MD5C08, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w2_t[1], MD5C09, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w2_t[2], MD5C0a, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w2_t[3], MD5C0b, MD5S03); - MD5_STEP (MD5_Fo, a, b, c, d, w3_t[0], MD5C0c, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w3_t[1], MD5C0d, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w3_t[2], MD5C0e, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w3_t[3], MD5C0f, MD5S03); - - MD5_STEP (MD5_Go, a, b, c, d, w0_t[1], MD5C10, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w1_t[2], MD5C11, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w2_t[3], MD5C12, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w0_t[0], MD5C13, MD5S13); - MD5_STEP (MD5_Go, a, b, c, d, w1_t[1], MD5C14, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w2_t[2], MD5C15, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w3_t[3], MD5C16, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w1_t[0], MD5C17, MD5S13); - MD5_STEP (MD5_Go, a, b, c, d, w2_t[1], MD5C18, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w3_t[2], MD5C19, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w0_t[3], MD5C1a, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w2_t[0], MD5C1b, MD5S13); - MD5_STEP (MD5_Go, a, b, c, d, w3_t[1], MD5C1c, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w0_t[2], MD5C1d, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w1_t[3], MD5C1e, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w3_t[0], MD5C1f, MD5S13); - - u32x t; - - MD5_STEP (MD5_H1, a, b, c, d, w1_t[1], MD5C20, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w2_t[0], MD5C21, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w2_t[3], MD5C22, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w3_t[2], MD5C23, MD5S23); - MD5_STEP (MD5_H1, a, b, c, d, w0_t[1], MD5C24, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w1_t[0], MD5C25, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w1_t[3], MD5C26, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w2_t[2], MD5C27, MD5S23); - MD5_STEP (MD5_H1, a, b, c, d, w3_t[1], MD5C28, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w0_t[0], MD5C29, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w0_t[3], MD5C2a, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w1_t[2], MD5C2b, MD5S23); - MD5_STEP (MD5_H1, a, b, c, d, w2_t[1], MD5C2c, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w3_t[0], MD5C2d, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w3_t[3], MD5C2e, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w0_t[2], MD5C2f, MD5S23); - - MD5_STEP (MD5_I , a, b, c, d, w0_t[0], MD5C30, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w1_t[3], MD5C31, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w3_t[2], MD5C32, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w1_t[1], MD5C33, MD5S33); - MD5_STEP (MD5_I , a, b, c, d, w3_t[0], MD5C34, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w0_t[3], MD5C35, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w2_t[2], MD5C36, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w0_t[1], MD5C37, MD5S33); - MD5_STEP (MD5_I , a, b, c, d, w2_t[0], MD5C38, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w3_t[3], MD5C39, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w1_t[2], MD5C3a, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w3_t[1], MD5C3b, MD5S33); - MD5_STEP (MD5_I , a, b, c, d, w1_t[0], MD5C3c, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w2_t[3], MD5C3d, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w0_t[2], MD5C3e, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w2_t[1], MD5C3f, MD5S33); - - a += make_u32x (MD5M_A); - b += make_u32x (MD5M_B); - c += make_u32x (MD5M_C); - d += make_u32x (MD5M_D); - - w0_t[0] = uint_to_hex_upper8 ((a >> 0) & 255) << 0 - | uint_to_hex_upper8 ((a >> 8) & 255) << 16; - w0_t[1] = uint_to_hex_upper8 ((a >> 16) & 255) << 0 - | uint_to_hex_upper8 ((a >> 24) & 255) << 16; - w0_t[2] = uint_to_hex_upper8 ((b >> 0) & 255) << 0 - | uint_to_hex_upper8 ((b >> 8) & 255) << 16; - w0_t[3] = uint_to_hex_upper8 ((b >> 16) & 255) << 0 - | uint_to_hex_upper8 ((b >> 24) & 255) << 16; - w1_t[0] = uint_to_hex_upper8 ((c >> 0) & 255) << 0 - | uint_to_hex_upper8 ((c >> 8) & 255) << 16; - w1_t[1] = uint_to_hex_upper8 ((c >> 16) & 255) << 0 - | uint_to_hex_upper8 ((c >> 24) & 255) << 16; - w1_t[2] = uint_to_hex_upper8 ((d >> 0) & 255) << 0 - | uint_to_hex_upper8 ((d >> 8) & 255) << 16; - w1_t[3] = uint_to_hex_upper8 ((d >> 16) & 255) << 0 - | uint_to_hex_upper8 ((d >> 24) & 255) << 16; - w2_t[0] = 0x80; - w2_t[1] = 0; - w2_t[2] = 0; - w2_t[3] = 0; - w3_t[0] = 0; - w3_t[1] = 0; - w3_t[2] = 0; - w3_t[3] = 0; - - /** - * prepend salt1 - */ - - switch_buffer_by_offset_le (w0_t, w1_t, w2_t, w3_t, salt1_len); - - w3_t[2] = final_len * 8; - w3_t[3] = 0; - - w0_t[0] |= salt1_buf0[0]; - w0_t[1] |= salt1_buf0[1]; - w0_t[2] |= salt1_buf0[2]; - w0_t[3] |= salt1_buf0[3]; - w1_t[0] |= salt1_buf1[0]; - w1_t[1] |= salt1_buf1[1]; - w1_t[2] |= salt1_buf1[2]; - w1_t[3] |= salt1_buf1[3]; - w2_t[0] |= salt1_buf2[0]; - w2_t[1] |= salt1_buf2[1]; - w2_t[2] |= salt1_buf2[2]; - w2_t[3] |= salt1_buf2[3]; - w3_t[0] |= salt1_buf3[0]; - w3_t[1] |= salt1_buf3[1]; - w3_t[2] |= salt1_buf3[2]; - w3_t[3] |= salt1_buf3[3]; - - /** - * md5 - */ - - a = MD5M_A; - b = MD5M_B; - c = MD5M_C; - d = MD5M_D; - - MD5_STEP (MD5_Fo, a, b, c, d, w0_t[0], MD5C00, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w0_t[1], MD5C01, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w0_t[2], MD5C02, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w0_t[3], MD5C03, MD5S03); - MD5_STEP (MD5_Fo, a, b, c, d, w1_t[0], MD5C04, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w1_t[1], MD5C05, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w1_t[2], MD5C06, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w1_t[3], MD5C07, MD5S03); - MD5_STEP (MD5_Fo, a, b, c, d, w2_t[0], MD5C08, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w2_t[1], MD5C09, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w2_t[2], MD5C0a, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w2_t[3], MD5C0b, MD5S03); - MD5_STEP (MD5_Fo, a, b, c, d, w3_t[0], MD5C0c, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w3_t[1], MD5C0d, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w3_t[2], MD5C0e, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w3_t[3], MD5C0f, MD5S03); - - MD5_STEP (MD5_Go, a, b, c, d, w0_t[1], MD5C10, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w1_t[2], MD5C11, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w2_t[3], MD5C12, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w0_t[0], MD5C13, MD5S13); - MD5_STEP (MD5_Go, a, b, c, d, w1_t[1], MD5C14, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w2_t[2], MD5C15, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w3_t[3], MD5C16, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w1_t[0], MD5C17, MD5S13); - MD5_STEP (MD5_Go, a, b, c, d, w2_t[1], MD5C18, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w3_t[2], MD5C19, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w0_t[3], MD5C1a, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w2_t[0], MD5C1b, MD5S13); - MD5_STEP (MD5_Go, a, b, c, d, w3_t[1], MD5C1c, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w0_t[2], MD5C1d, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w1_t[3], MD5C1e, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w3_t[0], MD5C1f, MD5S13); - - MD5_STEP (MD5_H1, a, b, c, d, w1_t[1], MD5C20, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w2_t[0], MD5C21, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w2_t[3], MD5C22, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w3_t[2], MD5C23, MD5S23); - MD5_STEP (MD5_H1, a, b, c, d, w0_t[1], MD5C24, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w1_t[0], MD5C25, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w1_t[3], MD5C26, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w2_t[2], MD5C27, MD5S23); - MD5_STEP (MD5_H1, a, b, c, d, w3_t[1], MD5C28, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w0_t[0], MD5C29, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w0_t[3], MD5C2a, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w1_t[2], MD5C2b, MD5S23); - MD5_STEP (MD5_H1, a, b, c, d, w2_t[1], MD5C2c, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w3_t[0], MD5C2d, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w3_t[3], MD5C2e, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w0_t[2], MD5C2f, MD5S23); - - MD5_STEP (MD5_I , a, b, c, d, w0_t[0], MD5C30, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w1_t[3], MD5C31, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w3_t[2], MD5C32, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w1_t[1], MD5C33, MD5S33); - MD5_STEP (MD5_I , a, b, c, d, w3_t[0], MD5C34, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w0_t[3], MD5C35, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w2_t[2], MD5C36, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w0_t[1], MD5C37, MD5S33); - MD5_STEP (MD5_I , a, b, c, d, w2_t[0], MD5C38, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w3_t[3], MD5C39, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w1_t[2], MD5C3a, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w3_t[1], MD5C3b, MD5S33); - MD5_STEP (MD5_I , a, b, c, d, w1_t[0], MD5C3c, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w2_t[3], MD5C3d, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w0_t[2], MD5C3e, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w2_t[1], MD5C3f, MD5S33); - - COMPARE_M_SIMD (a, d, c, b); - } -} - -DECLSPEC void m03730s (PRIVATE_AS u32 *w0, PRIVATE_AS u32 *w1, PRIVATE_AS u32 *w2, PRIVATE_AS u32 *w3, const u32 pw_len, KERN_ATTR_FUNC_ESALT (md5_double_salt_t), LOCAL_AS u32 *u_bin2asc) -{ - /** - * modifiers are taken from args - */ - - /** - * 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] - }; - - /** - * salt1 - */ - - u32 salt1_buf0[4]; - u32 salt1_buf1[4]; - u32 salt1_buf2[4]; - u32 salt1_buf3[4]; - - salt1_buf0[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 0]; - salt1_buf0[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 1]; - salt1_buf0[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 2]; - salt1_buf0[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 3]; - salt1_buf1[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 4]; - salt1_buf1[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 5]; - salt1_buf1[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 6]; - salt1_buf1[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 7]; - salt1_buf2[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 8]; - salt1_buf2[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[ 9]; - salt1_buf2[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[10]; - salt1_buf2[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[11]; - salt1_buf3[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[12]; - salt1_buf3[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[13]; - salt1_buf3[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[14]; - salt1_buf3[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_buf[15]; - - const u32 salt1_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt1_len; - - /** - * salt2 - */ - - u32 salt2_buf0[4]; - u32 salt2_buf1[4]; - u32 salt2_buf2[4]; - u32 salt2_buf3[4]; - - salt2_buf0[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 0]; - salt2_buf0[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 1]; - salt2_buf0[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 2]; - salt2_buf0[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 3]; - salt2_buf1[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 4]; - salt2_buf1[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 5]; - salt2_buf1[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 6]; - salt2_buf1[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 7]; - salt2_buf2[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 8]; - salt2_buf2[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[ 9]; - salt2_buf2[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[10]; - salt2_buf2[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[11]; - salt2_buf3[0] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[12]; - salt2_buf3[1] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[13]; - salt2_buf3[2] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[14]; - salt2_buf3[3] = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_buf[15]; - - const u32 salt2_len = esalt_bufs[DIGESTS_OFFSET_HOST].salt2_len; - - const u32 pw_salt_len = pw_len + salt2_len; - const u32 final_len = salt1_len + 32; - - /** - * loop - */ - - const u32 w0l = w0[0]; - - for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) - { - const u32x w0r = ix_create_bft (bfs_buf, il_pos); - - const u32x w0lr = w0l | w0r; - - u32x w0_t[4]; - u32x w1_t[4]; - u32x w2_t[4]; - u32x w3_t[4]; - - w0_t[0] = w0lr; - w0_t[1] = w0[1]; - w0_t[2] = w0[2]; - w0_t[3] = w0[3]; - w1_t[0] = w1[0]; - w1_t[1] = w1[1]; - w1_t[2] = w1[2]; - w1_t[3] = w1[3]; - w2_t[0] = w2[0]; - w2_t[1] = w2[1]; - w2_t[2] = w2[2]; - w2_t[3] = w2[3]; - w3_t[0] = w3[0]; - w3_t[1] = w3[1]; - w3_t[2] = w3[2]; - w3_t[3] = w3[3]; - - switch_buffer_by_offset_le (w0_t, w1_t, w2_t, w3_t, salt2_len); - - w0_t[0] |= salt2_buf0[0]; - w0_t[1] |= salt2_buf0[1]; - w0_t[2] |= salt2_buf0[2]; - w0_t[3] |= salt2_buf0[3]; - w1_t[0] |= salt2_buf1[0]; - w1_t[1] |= salt2_buf1[1]; - w1_t[2] |= salt2_buf1[2]; - w1_t[3] |= salt2_buf1[3]; - w2_t[0] |= salt2_buf2[0]; - w2_t[1] |= salt2_buf2[1]; - w2_t[2] |= salt2_buf2[2]; - w2_t[3] |= salt2_buf2[3]; - w3_t[0] |= salt2_buf3[0]; - w3_t[1] |= salt2_buf3[1]; - w3_t[2] = pw_salt_len * 8; - w3_t[3] = 0; - - /** - * md5 - */ - - u32x a = MD5M_A; - u32x b = MD5M_B; - u32x c = MD5M_C; - u32x d = MD5M_D; - - MD5_STEP (MD5_Fo, a, b, c, d, w0_t[0], MD5C00, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w0_t[1], MD5C01, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w0_t[2], MD5C02, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w0_t[3], MD5C03, MD5S03); - MD5_STEP (MD5_Fo, a, b, c, d, w1_t[0], MD5C04, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w1_t[1], MD5C05, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w1_t[2], MD5C06, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w1_t[3], MD5C07, MD5S03); - MD5_STEP (MD5_Fo, a, b, c, d, w2_t[0], MD5C08, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w2_t[1], MD5C09, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w2_t[2], MD5C0a, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w2_t[3], MD5C0b, MD5S03); - MD5_STEP (MD5_Fo, a, b, c, d, w3_t[0], MD5C0c, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w3_t[1], MD5C0d, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w3_t[2], MD5C0e, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w3_t[3], MD5C0f, MD5S03); - - MD5_STEP (MD5_Go, a, b, c, d, w0_t[1], MD5C10, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w1_t[2], MD5C11, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w2_t[3], MD5C12, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w0_t[0], MD5C13, MD5S13); - MD5_STEP (MD5_Go, a, b, c, d, w1_t[1], MD5C14, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w2_t[2], MD5C15, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w3_t[3], MD5C16, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w1_t[0], MD5C17, MD5S13); - MD5_STEP (MD5_Go, a, b, c, d, w2_t[1], MD5C18, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w3_t[2], MD5C19, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w0_t[3], MD5C1a, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w2_t[0], MD5C1b, MD5S13); - MD5_STEP (MD5_Go, a, b, c, d, w3_t[1], MD5C1c, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w0_t[2], MD5C1d, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w1_t[3], MD5C1e, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w3_t[0], MD5C1f, MD5S13); - - u32x t; - - MD5_STEP (MD5_H1, a, b, c, d, w1_t[1], MD5C20, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w2_t[0], MD5C21, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w2_t[3], MD5C22, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w3_t[2], MD5C23, MD5S23); - MD5_STEP (MD5_H1, a, b, c, d, w0_t[1], MD5C24, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w1_t[0], MD5C25, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w1_t[3], MD5C26, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w2_t[2], MD5C27, MD5S23); - MD5_STEP (MD5_H1, a, b, c, d, w3_t[1], MD5C28, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w0_t[0], MD5C29, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w0_t[3], MD5C2a, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w1_t[2], MD5C2b, MD5S23); - MD5_STEP (MD5_H1, a, b, c, d, w2_t[1], MD5C2c, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w3_t[0], MD5C2d, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w3_t[3], MD5C2e, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w0_t[2], MD5C2f, MD5S23); - - MD5_STEP (MD5_I , a, b, c, d, w0_t[0], MD5C30, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w1_t[3], MD5C31, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w3_t[2], MD5C32, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w1_t[1], MD5C33, MD5S33); - MD5_STEP (MD5_I , a, b, c, d, w3_t[0], MD5C34, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w0_t[3], MD5C35, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w2_t[2], MD5C36, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w0_t[1], MD5C37, MD5S33); - MD5_STEP (MD5_I , a, b, c, d, w2_t[0], MD5C38, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w3_t[3], MD5C39, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w1_t[2], MD5C3a, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w3_t[1], MD5C3b, MD5S33); - MD5_STEP (MD5_I , a, b, c, d, w1_t[0], MD5C3c, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w2_t[3], MD5C3d, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w0_t[2], MD5C3e, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w2_t[1], MD5C3f, MD5S33); - - a += make_u32x (MD5M_A); - b += make_u32x (MD5M_B); - c += make_u32x (MD5M_C); - d += make_u32x (MD5M_D); - - w0_t[0] = uint_to_hex_upper8 ((a >> 0) & 255) << 0 - | uint_to_hex_upper8 ((a >> 8) & 255) << 16; - w0_t[1] = uint_to_hex_upper8 ((a >> 16) & 255) << 0 - | uint_to_hex_upper8 ((a >> 24) & 255) << 16; - w0_t[2] = uint_to_hex_upper8 ((b >> 0) & 255) << 0 - | uint_to_hex_upper8 ((b >> 8) & 255) << 16; - w0_t[3] = uint_to_hex_upper8 ((b >> 16) & 255) << 0 - | uint_to_hex_upper8 ((b >> 24) & 255) << 16; - w1_t[0] = uint_to_hex_upper8 ((c >> 0) & 255) << 0 - | uint_to_hex_upper8 ((c >> 8) & 255) << 16; - w1_t[1] = uint_to_hex_upper8 ((c >> 16) & 255) << 0 - | uint_to_hex_upper8 ((c >> 24) & 255) << 16; - w1_t[2] = uint_to_hex_upper8 ((d >> 0) & 255) << 0 - | uint_to_hex_upper8 ((d >> 8) & 255) << 16; - w1_t[3] = uint_to_hex_upper8 ((d >> 16) & 255) << 0 - | uint_to_hex_upper8 ((d >> 24) & 255) << 16; - w2_t[0] = 0x80; - w2_t[1] = 0; - w2_t[2] = 0; - w2_t[3] = 0; - w3_t[0] = 0; - w3_t[1] = 0; - w3_t[2] = 0; - w3_t[3] = 0; - - /** - * prepend salt1 - */ - - switch_buffer_by_offset_le (w0_t, w1_t, w2_t, w3_t, salt1_len); - - w3_t[2] = final_len * 8; - w3_t[3] = 0; - - w0_t[0] |= salt1_buf0[0]; - w0_t[1] |= salt1_buf0[1]; - w0_t[2] |= salt1_buf0[2]; - w0_t[3] |= salt1_buf0[3]; - w1_t[0] |= salt1_buf1[0]; - w1_t[1] |= salt1_buf1[1]; - w1_t[2] |= salt1_buf1[2]; - w1_t[3] |= salt1_buf1[3]; - w2_t[0] |= salt1_buf2[0]; - w2_t[1] |= salt1_buf2[1]; - w2_t[2] |= salt1_buf2[2]; - w2_t[3] |= salt1_buf2[3]; - w3_t[0] |= salt1_buf3[0]; - w3_t[1] |= salt1_buf3[1]; - w3_t[2] |= salt1_buf3[2]; - w3_t[3] |= salt1_buf3[3]; - - /** - * md5 - */ - - a = MD5M_A; - b = MD5M_B; - c = MD5M_C; - d = MD5M_D; - - MD5_STEP (MD5_Fo, a, b, c, d, w0_t[0], MD5C00, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w0_t[1], MD5C01, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w0_t[2], MD5C02, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w0_t[3], MD5C03, MD5S03); - MD5_STEP (MD5_Fo, a, b, c, d, w1_t[0], MD5C04, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w1_t[1], MD5C05, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w1_t[2], MD5C06, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w1_t[3], MD5C07, MD5S03); - MD5_STEP (MD5_Fo, a, b, c, d, w2_t[0], MD5C08, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w2_t[1], MD5C09, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w2_t[2], MD5C0a, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w2_t[3], MD5C0b, MD5S03); - MD5_STEP (MD5_Fo, a, b, c, d, w3_t[0], MD5C0c, MD5S00); - MD5_STEP (MD5_Fo, d, a, b, c, w3_t[1], MD5C0d, MD5S01); - MD5_STEP (MD5_Fo, c, d, a, b, w3_t[2], MD5C0e, MD5S02); - MD5_STEP (MD5_Fo, b, c, d, a, w3_t[3], MD5C0f, MD5S03); - - MD5_STEP (MD5_Go, a, b, c, d, w0_t[1], MD5C10, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w1_t[2], MD5C11, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w2_t[3], MD5C12, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w0_t[0], MD5C13, MD5S13); - MD5_STEP (MD5_Go, a, b, c, d, w1_t[1], MD5C14, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w2_t[2], MD5C15, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w3_t[3], MD5C16, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w1_t[0], MD5C17, MD5S13); - MD5_STEP (MD5_Go, a, b, c, d, w2_t[1], MD5C18, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w3_t[2], MD5C19, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w0_t[3], MD5C1a, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w2_t[0], MD5C1b, MD5S13); - MD5_STEP (MD5_Go, a, b, c, d, w3_t[1], MD5C1c, MD5S10); - MD5_STEP (MD5_Go, d, a, b, c, w0_t[2], MD5C1d, MD5S11); - MD5_STEP (MD5_Go, c, d, a, b, w1_t[3], MD5C1e, MD5S12); - MD5_STEP (MD5_Go, b, c, d, a, w3_t[0], MD5C1f, MD5S13); - - MD5_STEP (MD5_H1, a, b, c, d, w1_t[1], MD5C20, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w2_t[0], MD5C21, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w2_t[3], MD5C22, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w3_t[2], MD5C23, MD5S23); - MD5_STEP (MD5_H1, a, b, c, d, w0_t[1], MD5C24, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w1_t[0], MD5C25, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w1_t[3], MD5C26, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w2_t[2], MD5C27, MD5S23); - MD5_STEP (MD5_H1, a, b, c, d, w3_t[1], MD5C28, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w0_t[0], MD5C29, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w0_t[3], MD5C2a, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w1_t[2], MD5C2b, MD5S23); - MD5_STEP (MD5_H1, a, b, c, d, w2_t[1], MD5C2c, MD5S20); - MD5_STEP (MD5_H2, d, a, b, c, w3_t[0], MD5C2d, MD5S21); - MD5_STEP (MD5_H1, c, d, a, b, w3_t[3], MD5C2e, MD5S22); - MD5_STEP (MD5_H2, b, c, d, a, w0_t[2], MD5C2f, MD5S23); - - MD5_STEP (MD5_I , a, b, c, d, w0_t[0], MD5C30, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w1_t[3], MD5C31, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w3_t[2], MD5C32, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w1_t[1], MD5C33, MD5S33); - MD5_STEP (MD5_I , a, b, c, d, w3_t[0], MD5C34, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w0_t[3], MD5C35, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w2_t[2], MD5C36, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w0_t[1], MD5C37, MD5S33); - MD5_STEP (MD5_I , a, b, c, d, w2_t[0], MD5C38, MD5S30); - MD5_STEP (MD5_I , d, a, b, c, w3_t[3], MD5C39, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w1_t[2], MD5C3a, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w3_t[1], MD5C3b, MD5S33); - MD5_STEP (MD5_I , a, b, c, d, w1_t[0], MD5C3c, MD5S30); - - if (MATCHES_NONE_VS (a, search[0])) continue; - - MD5_STEP (MD5_I , d, a, b, c, w2_t[3], MD5C3d, MD5S31); - MD5_STEP (MD5_I , c, d, a, b, w0_t[2], MD5C3e, MD5S32); - MD5_STEP (MD5_I , b, c, d, a, w2_t[1], MD5C3f, MD5S33); - - COMPARE_S_SIMD (a, d, c, b); - } -} - -KERNEL_FQ void m03730_m04 (KERN_ATTR_ESALT (md5_double_salt_t)) -{ - /** - * base - */ - - const u64 lid = get_local_id (0); - const u64 gid = get_global_id (0); - const u64 lsz = get_local_size (0); - - /** - * bin2asc uppercase array - */ - LOCAL_VK u32 u_bin2asc[256]; - - for (u32 j = lid; j < 256; j += lsz) - { - const u32 i0 = (j >> 0) & 15; - const u32 i1 = (j >> 4) & 15; - - u_bin2asc[j] = ((i0 < 10) ? '0' + i0 : 'A' - 10 + i0) << 8 - | ((i1 < 10) ? '0' + i1 : 'A' - 10 + i1) << 0; - } - - SYNC_THREADS (); - - if (gid >= GID_CNT) return; - - /** - * modifier - */ - - u32 w0[4]; - - w0[0] = pws[gid].i[ 0]; - w0[1] = pws[gid].i[ 1]; - w0[2] = pws[gid].i[ 2]; - w0[3] = pws[gid].i[ 3]; - - u32 w1[4]; - - w1[0] = 0; - w1[1] = 0; - w1[2] = 0; - w1[3] = 0; - - u32 w2[4]; - - w2[0] = 0; - w2[1] = 0; - w2[2] = 0; - w2[3] = 0; - - u32 w3[4]; - - w3[0] = 0; - w3[1] = 0; - w3[2] = pws[gid].i[14]; - w3[3] = 0; - - const u32 pw_len = pws[gid].pw_len & 63; - - /** - * main - */ - - m03730m (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, 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, u_bin2asc); -} - -KERNEL_FQ void m03730_m08 (KERN_ATTR_ESALT (md5_double_salt_t)) -{ - /** - * base - */ - - const u64 lid = get_local_id (0); - const u64 gid = get_global_id (0); - const u64 lsz = get_local_size (0); - - /** - * modifier - */ - - u32 w0[4]; - - w0[0] = pws[gid].i[ 0]; - w0[1] = pws[gid].i[ 1]; - w0[2] = pws[gid].i[ 2]; - w0[3] = pws[gid].i[ 3]; - - u32 w1[4]; - - w1[0] = pws[gid].i[ 4]; - w1[1] = pws[gid].i[ 5]; - w1[2] = pws[gid].i[ 6]; - w1[3] = pws[gid].i[ 7]; - - u32 w2[4]; - - w2[0] = 0; - w2[1] = 0; - w2[2] = 0; - w2[3] = 0; - - u32 w3[4]; - - w3[0] = 0; - w3[1] = 0; - w3[2] = pws[gid].i[14]; - w3[3] = 0; - - const u32 pw_len = pws[gid].pw_len & 63; - - /** - * bin2asc uppercase array - */ - LOCAL_VK u32 u_bin2asc[256]; - - for (u32 j = lid; j < 256; j += lsz) - { - const u32 i0 = (j >> 0) & 15; - const u32 i1 = (j >> 4) & 15; - - u_bin2asc[j] = ((i0 < 10) ? '0' + i0 : 'A' - 10 + i0) << 8 - | ((i1 < 10) ? '0' + i1 : 'A' - 10 + i1) << 0; - } - - SYNC_THREADS (); - - if (gid >= GID_CNT) return; - - /** - * main - */ - - m03730m (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, 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, u_bin2asc); -} - -KERNEL_FQ void m03730_m16 (KERN_ATTR_ESALT (md5_double_salt_t)) -{ - /** - * base - */ - - const u64 lid = get_local_id (0); - const u64 gid = get_global_id (0); - const u64 lsz = get_local_size (0); - - /** - * modifier - */ - - u32 w0[4]; - - w0[0] = pws[gid].i[ 0]; - w0[1] = pws[gid].i[ 1]; - w0[2] = pws[gid].i[ 2]; - w0[3] = pws[gid].i[ 3]; - - u32 w1[4]; - - w1[0] = pws[gid].i[ 4]; - w1[1] = pws[gid].i[ 5]; - w1[2] = pws[gid].i[ 6]; - w1[3] = pws[gid].i[ 7]; - - u32 w2[4]; - - w2[0] = pws[gid].i[ 8]; - w2[1] = pws[gid].i[ 9]; - w2[2] = pws[gid].i[10]; - w2[3] = pws[gid].i[11]; - - u32 w3[4]; - - w3[0] = pws[gid].i[12]; - w3[1] = pws[gid].i[13]; - w3[2] = pws[gid].i[14]; - w3[3] = pws[gid].i[15]; - - const u32 pw_len = pws[gid].pw_len & 63; - - /** - * bin2asc uppercase array - */ - - LOCAL_VK u32 u_bin2asc[256]; - - for (u32 j = lid; j < 256; j += lsz) - { - const u32 i0 = (j >> 0) & 15; - const u32 i1 = (j >> 4) & 15; - - u_bin2asc[j] = ((i0 < 10) ? '0' + i0 : 'A' - 10 + i0) << 8 - | ((i1 < 10) ? '0' + i1 : 'A' - 10 + i1) << 0; - } - - SYNC_THREADS (); - - if (gid >= GID_CNT) return; - - /** - * main - */ - - m03730m (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, 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, u_bin2asc); -} - -KERNEL_FQ void m03730_s04 (KERN_ATTR_ESALT (md5_double_salt_t)) -{ - /** - * base - */ - - const u64 lid = get_local_id (0); - const u64 gid = get_global_id (0); - const u64 lsz = get_local_size (0); - - /** - * modifier - */ - - u32 w0[4]; - - w0[0] = pws[gid].i[ 0]; - w0[1] = pws[gid].i[ 1]; - w0[2] = pws[gid].i[ 2]; - w0[3] = pws[gid].i[ 3]; - - u32 w1[4]; - - w1[0] = 0; - w1[1] = 0; - w1[2] = 0; - w1[3] = 0; - - u32 w2[4]; - - w2[0] = 0; - w2[1] = 0; - w2[2] = 0; - w2[3] = 0; - - u32 w3[4]; - - w3[0] = 0; - w3[1] = 0; - w3[2] = pws[gid].i[14]; - w3[3] = 0; - - const u32 pw_len = pws[gid].pw_len & 63; - - /** - * bin2asc uppercase array - */ - - LOCAL_VK u32 u_bin2asc[256]; - - for (u32 j = lid; j < 256; j += lsz) - { - const u32 i0 = (j >> 0) & 15; - const u32 i1 = (j >> 4) & 15; - - u_bin2asc[j] = ((i0 < 10) ? '0' + i0 : 'A' - 10 + i0) << 8 - | ((i1 < 10) ? '0' + i1 : 'A' - 10 + i1) << 0; - } - - SYNC_THREADS (); - - if (gid >= GID_CNT) return; - - /** - * main - */ - - m03730s (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, 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, u_bin2asc); -} - -KERNEL_FQ void m03730_s08 (KERN_ATTR_ESALT (md5_double_salt_t)) -{ - /** - * base - */ - - const u64 lid = get_local_id (0); - const u64 gid = get_global_id (0); - const u64 lsz = get_local_size (0); - - /** - * modifier - */ - - u32 w0[4]; - - w0[0] = pws[gid].i[ 0]; - w0[1] = pws[gid].i[ 1]; - w0[2] = pws[gid].i[ 2]; - w0[3] = pws[gid].i[ 3]; - - u32 w1[4]; - - w1[0] = pws[gid].i[ 4]; - w1[1] = pws[gid].i[ 5]; - w1[2] = pws[gid].i[ 6]; - w1[3] = pws[gid].i[ 7]; - - u32 w2[4]; - - w2[0] = 0; - w2[1] = 0; - w2[2] = 0; - w2[3] = 0; - - u32 w3[4]; - - w3[0] = 0; - w3[1] = 0; - w3[2] = pws[gid].i[14]; - w3[3] = 0; - - const u32 pw_len = pws[gid].pw_len & 63; - - /** - * bin2asc uppercase array - */ - - LOCAL_VK u32 u_bin2asc[256]; - - for (u32 j = lid; j < 256; j += lsz) - { - const u32 i0 = (j >> 0) & 15; - const u32 i1 = (j >> 4) & 15; - - u_bin2asc[j] = ((i0 < 10) ? '0' + i0 : 'A' - 10 + i0) << 8 - | ((i1 < 10) ? '0' + i1 : 'A' - 10 + i1) << 0; - } - - SYNC_THREADS (); - - if (gid >= GID_CNT) return; - - /** - * main - */ - - m03730s (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, 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, u_bin2asc); -} - -KERNEL_FQ void m03730_s16 (KERN_ATTR_ESALT (md5_double_salt_t)) -{ - /** - * base - */ - - const u64 lid = get_local_id (0); - const u64 gid = get_global_id (0); - const u64 lsz = get_local_size (0); - - /** - * bin2asc uppercase array - */ - - LOCAL_VK u32 u_bin2asc[256]; - - for (u32 j = lid; j < 256; j += lsz) - { - const u32 i0 = (j >> 0) & 15; - const u32 i1 = (j >> 4) & 15; - - u_bin2asc[j] = ((i0 < 10) ? '0' + i0 : 'A' - 10 + i0) << 8 - | ((i1 < 10) ? '0' + i1 : 'A' - 10 + i1) << 0; - } - - SYNC_THREADS (); - - if (gid >= GID_CNT) return; - - /** - * modifier - */ - - u32 w0[4]; - - w0[0] = pws[gid].i[ 0]; - w0[1] = pws[gid].i[ 1]; - w0[2] = pws[gid].i[ 2]; - w0[3] = pws[gid].i[ 3]; - - u32 w1[4]; - - w1[0] = pws[gid].i[ 4]; - w1[1] = pws[gid].i[ 5]; - w1[2] = pws[gid].i[ 6]; - w1[3] = pws[gid].i[ 7]; - - u32 w2[4]; - - w2[0] = pws[gid].i[ 8]; - w2[1] = pws[gid].i[ 9]; - w2[2] = pws[gid].i[10]; - w2[3] = pws[gid].i[11]; - - u32 w3[4]; - - w3[0] = pws[gid].i[12]; - w3[1] = pws[gid].i[13]; - w3[2] = pws[gid].i[14]; - w3[3] = pws[gid].i[15]; - - const u32 pw_len = pws[gid].pw_len & 63; - - /** - * main - */ - - m03730s (w0, w1, w2, w3, pw_len, pws, rules_buf, combs_buf, bfs_buf, 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, u_bin2asc); -} diff --git a/tools/test_modules/m03730.pm b/tools/test_modules/m03730.pm index 11547fd83..e50da02c8 100644 --- a/tools/test_modules/m03730.pm +++ b/tools/test_modules/m03730.pm @@ -10,13 +10,13 @@ use warnings; use Digest::MD5 qw (md5_hex); -sub module_constraints { [[0, 64], [0, 128], [0, 55], [0, 128], [0, 55]] } +sub module_constraints { [[0, 255], [0, 255], [-1, -1], [-1, -1], [-1, -1]] } sub module_generate_hash { my $word = shift; my $salt1 = shift; - my $salt2 = shift || random_numeric_string (32); + my $salt2 = shift || random_numeric_string (128); my $digest = md5_hex ($salt1 . uc(md5_hex ($salt2 . $word)));