From 6b28169c66dadbd884f5fc4a4dc62d8b734e02a1 Mon Sep 17 00:00:00 2001 From: Yaakov Saxon Date: Wed, 15 Mar 2023 16:22:10 -0400 Subject: [PATCH 01/11] 31400 securecrt module --- OpenCL/m31400_a0-pure.cl | 311 ++++++++++++++++++++++++++++++ OpenCL/m31400_a1-pure.cl | 318 ++++++++++++++++++++++++++++++ OpenCL/m31400_a3-pure.cl | 364 +++++++++++++++++++++++++++++++++++ src/modules/module_31400.c | 178 +++++++++++++++++ tools/test_modules/m31400.pm | 101 ++++++++++ 5 files changed, 1272 insertions(+) create mode 100644 OpenCL/m31400_a0-pure.cl create mode 100644 OpenCL/m31400_a1-pure.cl create mode 100644 OpenCL/m31400_a3-pure.cl create mode 100644 src/modules/module_31400.c create mode 100644 tools/test_modules/m31400.pm diff --git a/OpenCL/m31400_a0-pure.cl b/OpenCL/m31400_a0-pure.cl new file mode 100644 index 000000000..47752622e --- /dev/null +++ b/OpenCL/m31400_a0-pure.cl @@ -0,0 +1,311 @@ +/** + * 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.h) +#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_simd.cl) +#include M2S(INCLUDE_PATH/inc_scalar.cl) +#include M2S(INCLUDE_PATH/inc_hash_sha256.cl) +#include M2S(INCLUDE_PATH/inc_cipher_aes.h) +#include M2S(INCLUDE_PATH/inc_cipher_aes.cl) +#endif + +DECLSPEC void shift_buffer_by_offset (PRIVATE_AS u32 *w0, const u32 offset) +{ +const int offset_switch = offset / 4; + + #if ((defined IS_AMD || defined IS_HIP) && HAS_VPERM == 0) || defined IS_GENERIC + switch (offset_switch) + { + case 0: + w0[3] = hc_bytealign_be_S (w0[2], w0[3], offset); + w0[2] = hc_bytealign_be_S (w0[1], w0[2], offset); + w0[1] = hc_bytealign_be_S (w0[0], w0[1], offset); + w0[0] = hc_bytealign_be_S ( 0, w0[0], offset); + break; + + case 1: + w0[3] = hc_bytealign_be_S (w0[1], w0[2], offset); + w0[2] = hc_bytealign_be_S (w0[0], w0[1], offset); + w0[1] = hc_bytealign_be_S ( 0, w0[0], offset); + w0[0] = 0; + break; + + case 2: + w0[3] = hc_bytealign_be_S (w0[0], w0[1], offset); + w0[2] = hc_bytealign_be_S ( 0, w0[0], offset); + w0[1] = 0; + w0[0] = 0; + break; + + case 3: + w0[3] = hc_bytealign_be_S ( 0, w0[0], offset); + w0[2] = 0; + w0[1] = 0; + w0[0] = 0; + break; + + default: + w0[3] = 0; + w0[2] = 0; + w0[1] = 0; + w0[0] = 0; + break; + } + #endif + + #if ((defined IS_AMD || defined IS_HIP) && HAS_VPERM == 1) || defined IS_NV + + #if defined IS_NV + const int selector = (0x76543210 >> ((offset & 3) * 4)) & 0xffff; + #endif + + #if (defined IS_AMD || defined IS_HIP) + const int selector = l32_from_64_S (0x0706050403020100UL >> ((offset & 3) * 8)); + #endif + + switch (offset_switch) + { + case 0: + w0[3] = hc_byte_perm_S (w0[3], w0[2], selector); + w0[2] = hc_byte_perm_S (w0[2], w0[1], selector); + w0[1] = hc_byte_perm_S (w0[1], w0[0], selector); + w0[0] = hc_byte_perm_S (w0[0], 0, selector); + break; + + case 1: + w0[3] = hc_byte_perm_S (w0[2], w0[1], selector); + w0[2] = hc_byte_perm_S (w0[1], w0[0], selector); + w0[1] = hc_byte_perm_S (w0[0], 0, selector); + w0[0] = 0; + break; + + case 2: + w0[3] = hc_byte_perm_S (w0[1], w0[0], selector); + w0[2] = hc_byte_perm_S (w0[0], 0, selector); + w0[1] = 0; + w0[0] = 0; + break; + + case 3: + w0[3] = hc_byte_perm_S (w0[0], 0, selector); + w0[2] = 0; + w0[1] = 0; + w0[0] = 0; + break; + + default: + w0[3] = 0; + w0[2] = 0; + w0[1] = 0; + w0[0] = 0; + break; + } + #endif +} + + +DECLSPEC void aes256_scrt_format (PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32 *pw, const int pw_len, PRIVATE_AS u32 *hash, PRIVATE_AS u32 *out, SHM_TYPE u32 *s_te0, SHM_TYPE u32 *s_te1, SHM_TYPE u32 *s_te2, SHM_TYPE u32 *s_te3, SHM_TYPE u32 *s_te4) +{ + AES256_set_encrypt_key(aes_ks, hash, s_te0, s_te1, s_te2, s_te3); + + shift_buffer_by_offset(hash,pw_len+4); + + hash[0] = hc_swap32(pw_len); + hash[1] |= hc_swap32(pw[0]); + hash[2] |= hc_swap32(pw[1]); + hash[3] |= hc_swap32(pw[2]); + + AES256_encrypt (aes_ks, hash, out, s_te0, s_te1, s_te2, s_te3, s_te4); +} + +KERNEL_FQ void m31400_mxx (KERN_ATTR_RULES ()) +{ + /** + * modifier + */ + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + const u64 lsz = get_local_size (0); + + /** + * aes shared + */ + +#ifdef REAL_SHM + + LOCAL_VK u32 s_te0[256]; + LOCAL_VK u32 s_te1[256]; + LOCAL_VK u32 s_te2[256]; + LOCAL_VK u32 s_te3[256]; + LOCAL_VK u32 s_te4[256]; + + for (u32 i = lid; i < 256; i += lsz) + { + s_te0[i] = te0[i]; + s_te1[i] = te1[i]; + s_te2[i] = te2[i]; + s_te3[i] = te3[i]; + s_te4[i] = te4[i]; + } + + SYNC_THREADS(); + +#else + + CONSTANT_AS u32a *s_te0 = te0; + CONSTANT_AS u32a *s_te1 = te1; + CONSTANT_AS u32a *s_te2 = te2; + CONSTANT_AS u32a *s_te3 = te3; + CONSTANT_AS u32a *s_te4 = te4; + +#endif + + if (gid >= GID_CNT) return; + + /** + * base + */ + + COPY_PW (pws[gid]); + + /** + * loop + */ + + u32 ks[60]; + + 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); + + sha256_ctx_t ctx; + + sha256_init (&ctx); + + sha256_update_swap (&ctx, tmp.i, tmp.pw_len); + + sha256_final (&ctx); + + u32 out[4]={0}; + + aes256_scrt_format(ks,tmp.i,tmp.pw_len,ctx.h,out,s_te0, s_te1, s_te2, s_te3, s_te4); + + const u32 r0 = out[DGST_R0]; + const u32 r1 = out[DGST_R1]; + const u32 r2 = out[DGST_R2]; + const u32 r3 = out[DGST_R3]; + + COMPARE_M_SCALAR (r0, r1, r2, r3); + } +} + +KERNEL_FQ void m31400_sxx (KERN_ATTR_RULES ()) +{ + + /** + * modifier + */ + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + const u64 lsz = get_local_size (0); + + /** + * aes shared + */ + + #ifdef REAL_SHM + + LOCAL_VK u32 s_te0[256]; + LOCAL_VK u32 s_te1[256]; + LOCAL_VK u32 s_te2[256]; + LOCAL_VK u32 s_te3[256]; + LOCAL_VK u32 s_te4[256]; + + for (u32 i = lid; i < 256; i += lsz) + { + s_te0[i] = te0[i]; + s_te1[i] = te1[i]; + s_te2[i] = te2[i]; + s_te3[i] = te3[i]; + s_te4[i] = te4[i]; + } + + SYNC_THREADS (); + + #else + + CONSTANT_AS u32a *s_te0 = te0; + CONSTANT_AS u32a *s_te1 = te1; + CONSTANT_AS u32a *s_te2 = te2; + CONSTANT_AS u32a *s_te3 = te3; + CONSTANT_AS u32a *s_te4 = te4; + + #endif + + 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]); + + u32 ks[60]; + + /** + * 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); + + sha256_ctx_t ctx; + + sha256_init (&ctx); + + sha256_update_swap (&ctx, tmp.i, tmp.pw_len); + + sha256_final (&ctx); + + u32 out[4]={0}; + + aes256_scrt_format(ks,tmp.i,tmp.pw_len,ctx.h,out,s_te0, s_te1, s_te2, s_te3, s_te4); + + const u32 r0 = out[DGST_R0]; + const u32 r1 = out[DGST_R1]; + const u32 r2 = out[DGST_R2]; + const u32 r3 = out[DGST_R3]; + + COMPARE_S_SCALAR (r0, r1, r2, r3); + } +} diff --git a/OpenCL/m31400_a1-pure.cl b/OpenCL/m31400_a1-pure.cl new file mode 100644 index 000000000..a8c2ca286 --- /dev/null +++ b/OpenCL/m31400_a1-pure.cl @@ -0,0 +1,318 @@ +/** + * 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.h) +#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_simd.cl) +#include M2S(INCLUDE_PATH/inc_scalar.cl) +#include M2S(INCLUDE_PATH/inc_hash_sha256.cl) +#include M2S(INCLUDE_PATH/inc_cipher_aes.h) +#include M2S(INCLUDE_PATH/inc_cipher_aes.cl) +#endif + +DECLSPEC void shift_buffer_by_offset (PRIVATE_AS u32 *w0, const u32 offset) +{ +const int offset_switch = offset / 4; + + #if ((defined IS_AMD || defined IS_HIP) && HAS_VPERM == 0) || defined IS_GENERIC + switch (offset_switch) + { + case 0: + w0[3] = hc_bytealign_be_S (w0[2], w0[3], offset); + w0[2] = hc_bytealign_be_S (w0[1], w0[2], offset); + w0[1] = hc_bytealign_be_S (w0[0], w0[1], offset); + w0[0] = hc_bytealign_be_S ( 0, w0[0], offset); + break; + + case 1: + w0[3] = hc_bytealign_be_S (w0[1], w0[2], offset); + w0[2] = hc_bytealign_be_S (w0[0], w0[1], offset); + w0[1] = hc_bytealign_be_S ( 0, w0[0], offset); + w0[0] = 0; + break; + + case 2: + w0[3] = hc_bytealign_be_S (w0[0], w0[1], offset); + w0[2] = hc_bytealign_be_S ( 0, w0[0], offset); + w0[1] = 0; + w0[0] = 0; + break; + + case 3: + w0[3] = hc_bytealign_be_S ( 0, w0[0], offset); + w0[2] = 0; + w0[1] = 0; + w0[0] = 0; + break; + + default: + w0[3] = 0; + w0[2] = 0; + w0[1] = 0; + w0[0] = 0; + break; + } + #endif + + #if ((defined IS_AMD || defined IS_HIP) && HAS_VPERM == 1) || defined IS_NV + + #if defined IS_NV + const int selector = (0x76543210 >> ((offset & 3) * 4)) & 0xffff; + #endif + + #if (defined IS_AMD || defined IS_HIP) + const int selector = l32_from_64_S (0x0706050403020100UL >> ((offset & 3) * 8)); + #endif + + switch (offset_switch) + { + case 0: + w0[3] = hc_byte_perm_S (w0[3], w0[2], selector); + w0[2] = hc_byte_perm_S (w0[2], w0[1], selector); + w0[1] = hc_byte_perm_S (w0[1], w0[0], selector); + w0[0] = hc_byte_perm_S (w0[0], 0, selector); + break; + + case 1: + w0[3] = hc_byte_perm_S (w0[2], w0[1], selector); + w0[2] = hc_byte_perm_S (w0[1], w0[0], selector); + w0[1] = hc_byte_perm_S (w0[0], 0, selector); + w0[0] = 0; + break; + + case 2: + w0[3] = hc_byte_perm_S (w0[1], w0[0], selector); + w0[2] = hc_byte_perm_S (w0[0], 0, selector); + w0[1] = 0; + w0[0] = 0; + break; + + case 3: + w0[3] = hc_byte_perm_S (w0[0], 0, selector); + w0[2] = 0; + w0[1] = 0; + w0[0] = 0; + break; + + default: + w0[3] = 0; + w0[2] = 0; + w0[1] = 0; + w0[0] = 0; + break; + } + #endif +} + + +DECLSPEC void aes256_scrt_format (PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32 *pw, const int pw_len, PRIVATE_AS u32 *hash, PRIVATE_AS u32 *out, SHM_TYPE u32 *s_te0, SHM_TYPE u32 *s_te1, SHM_TYPE u32 *s_te2, SHM_TYPE u32 *s_te3, SHM_TYPE u32 *s_te4) +{ + AES256_set_encrypt_key(aes_ks, hash, s_te0, s_te1, s_te2, s_te3); + + shift_buffer_by_offset(hash,pw_len+4); + + hash[0] = hc_swap32(pw_len); + hash[1] |= hc_swap32(pw[0]); + hash[2] |= hc_swap32(pw[1]); + hash[3] |= hc_swap32(pw[2]); + + AES256_encrypt (aes_ks, hash, out, s_te0, s_te1, s_te2, s_te3, s_te4); +} + +KERNEL_FQ void m31400_mxx (KERN_ATTR_BASIC ()) +{ + /** + * modifier + */ + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + const u64 lsz = get_local_size (0); + + /** + * aes shared + */ + +#ifdef REAL_SHM + + LOCAL_VK u32 s_te0[256]; + LOCAL_VK u32 s_te1[256]; + LOCAL_VK u32 s_te2[256]; + LOCAL_VK u32 s_te3[256]; + LOCAL_VK u32 s_te4[256]; + + for (u32 i = lid; i < 256; i += lsz) + { + s_te0[i] = te0[i]; + s_te1[i] = te1[i]; + s_te2[i] = te2[i]; + s_te3[i] = te3[i]; + s_te4[i] = te4[i]; + } + + SYNC_THREADS(); + +#else + + CONSTANT_AS u32a *s_te0 = te0; + CONSTANT_AS u32a *s_te1 = te1; + CONSTANT_AS u32a *s_te2 = te2; + CONSTANT_AS u32a *s_te3 = te3; + CONSTANT_AS u32a *s_te4 = te4; + +#endif + + if (gid >= GID_CNT) return; + + /** + * base + */ + + sha256_ctx_t ctx0; + + sha256_init (&ctx0); + + sha256_update_global_swap (&ctx0, pws[gid].i, pws[gid].pw_len); + + /** + * loop + */ + + u32 ks[60]; + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos++) + { + sha256_ctx_t ctx = ctx0; + + sha256_update_global_swap (&ctx, combs_buf[il_pos].i, combs_buf[il_pos].pw_len); + + u32 pw_candidate[3]; + pw_candidate[0]= hc_swap32(ctx.w0[0]); + pw_candidate[1]= hc_swap32(ctx.w0[1]); + pw_candidate[2]= hc_swap32(ctx.w0[2]); + u32 pw_len=ctx.len; + + sha256_final (&ctx); + + u32 out[4]={0}; + + aes256_scrt_format(ks,pw_candidate,pw_len,ctx.h,out,s_te0, s_te1, s_te2, s_te3, s_te4); + + const u32 r0 = out[DGST_R0]; + const u32 r1 = out[DGST_R1]; + const u32 r2 = out[DGST_R2]; + const u32 r3 = out[DGST_R3]; + + COMPARE_M_SCALAR (r0, r1, r2, r3); + } +} + +KERNEL_FQ void m31400_sxx (KERN_ATTR_BASIC ()) +{ + /** + * modifier + */ + + const u64 lid = get_local_id (0); + const u64 gid = get_global_id (0); + const u64 lsz = get_local_size (0); + + /** + * aes shared + */ + + #ifdef REAL_SHM + + LOCAL_VK u32 s_te0[256]; + LOCAL_VK u32 s_te1[256]; + LOCAL_VK u32 s_te2[256]; + LOCAL_VK u32 s_te3[256]; + LOCAL_VK u32 s_te4[256]; + + for (u32 i = lid; i < 256; i += lsz) + { + s_te0[i] = te0[i]; + s_te1[i] = te1[i]; + s_te2[i] = te2[i]; + s_te3[i] = te3[i]; + s_te4[i] = te4[i]; + } + + SYNC_THREADS (); + + #else + + CONSTANT_AS u32a *s_te0 = te0; + CONSTANT_AS u32a *s_te1 = te1; + CONSTANT_AS u32a *s_te2 = te2; + CONSTANT_AS u32a *s_te3 = te3; + CONSTANT_AS u32a *s_te4 = te4; + + #endif + + 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 + */ + + sha256_ctx_t ctx0; + + sha256_init (&ctx0); + + sha256_update_global_swap (&ctx0, pws[gid].i, pws[gid].pw_len); + + u32 ks[60]; + + /** + * loop + */ + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos++) + { + sha256_ctx_t ctx = ctx0; + + sha256_update_global_swap (&ctx, combs_buf[il_pos].i, combs_buf[il_pos].pw_len); + + u32 pw_candidate[3]; + pw_candidate[0]=hc_swap32(ctx.w0[0]); + pw_candidate[1]=hc_swap32(ctx.w0[1]); + pw_candidate[2]=hc_swap32(ctx.w0[2]); + u32 pw_len=ctx.len; + + sha256_final (&ctx); + + u32 out[4]={0}; + + aes256_scrt_format(ks,pw_candidate,pw_len,ctx.h,out,s_te0, s_te1, s_te2, s_te3, s_te4); + + const u32 r0 = out[DGST_R0]; + const u32 r1 = out[DGST_R1]; + const u32 r2 = out[DGST_R2]; + const u32 r3 = out[DGST_R3]; + + COMPARE_S_SCALAR (r0, r1, r2, r3); + } +} diff --git a/OpenCL/m31400_a3-pure.cl b/OpenCL/m31400_a3-pure.cl new file mode 100644 index 000000000..8a7fe6724 --- /dev/null +++ b/OpenCL/m31400_a3-pure.cl @@ -0,0 +1,364 @@ +/** + * 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.h) +#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_simd.cl) +#include M2S(INCLUDE_PATH/inc_scalar.cl) +#include M2S(INCLUDE_PATH/inc_hash_sha256.cl) +#include M2S(INCLUDE_PATH/inc_cipher_aes.h) +#include M2S(INCLUDE_PATH/inc_cipher_aes.cl) +#endif + +DECLSPEC void shift_buffer_by_offset(PRIVATE_AS u32 *w0, const u32 offset) +{ + const int offset_switch = offset / 4; + +#if ((defined IS_AMD || defined IS_HIP) && HAS_VPERM == 0) || defined IS_GENERIC + switch (offset_switch) + { + case 0: + w0[3] = hc_bytealign_be_S(w0[2], w0[3], offset); + w0[2] = hc_bytealign_be_S(w0[1], w0[2], offset); + w0[1] = hc_bytealign_be_S(w0[0], w0[1], offset); + w0[0] = hc_bytealign_be_S(0, w0[0], offset); + break; + + case 1: + w0[3] = hc_bytealign_be_S(w0[1], w0[2], offset); + w0[2] = hc_bytealign_be_S(w0[0], w0[1], offset); + w0[1] = hc_bytealign_be_S(0, w0[0], offset); + w0[0] = 0; + break; + + case 2: + w0[3] = hc_bytealign_be_S(w0[0], w0[1], offset); + w0[2] = hc_bytealign_be_S(0, w0[0], offset); + w0[1] = 0; + w0[0] = 0; + break; + + case 3: + w0[3] = hc_bytealign_be_S(0, w0[0], offset); + w0[2] = 0; + w0[1] = 0; + w0[0] = 0; + break; + + default: + w0[3] = 0; + w0[2] = 0; + w0[1] = 0; + w0[0] = 0; + break; + } +#endif + +#if ((defined IS_AMD || defined IS_HIP) && HAS_VPERM == 1) || defined IS_NV + +#if defined IS_NV + const int selector = (0x76543210 >> ((offset & 3) * 4)) & 0xffff; +#endif + +#if (defined IS_AMD || defined IS_HIP) + const int selector = l32_from_64_S(0x0706050403020100UL >> ((offset & 3) * 8)); +#endif + + switch (offset_switch) + { + case 0: + w0[3] = hc_byte_perm_S(w0[3], w0[2], selector); + w0[2] = hc_byte_perm_S(w0[2], w0[1], selector); + w0[1] = hc_byte_perm_S(w0[1], w0[0], selector); + w0[0] = hc_byte_perm_S(w0[0], 0, selector); + break; + + case 1: + w0[3] = hc_byte_perm_S(w0[2], w0[1], selector); + w0[2] = hc_byte_perm_S(w0[1], w0[0], selector); + w0[1] = hc_byte_perm_S(w0[0], 0, selector); + w0[0] = 0; + break; + + case 2: + w0[3] = hc_byte_perm_S(w0[1], w0[0], selector); + w0[2] = hc_byte_perm_S(w0[0], 0, selector); + w0[1] = 0; + w0[0] = 0; + break; + + case 3: + w0[3] = hc_byte_perm_S(w0[0], 0, selector); + w0[2] = 0; + w0[1] = 0; + w0[0] = 0; + break; + + default: + w0[3] = 0; + w0[2] = 0; + w0[1] = 0; + w0[0] = 0; + break; + } +#endif +} + +DECLSPEC void aes256_scrt_format(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32 *pw, const int pw_len, PRIVATE_AS u32 *hash, PRIVATE_AS u32 *out, SHM_TYPE u32 *s_te0, SHM_TYPE u32 *s_te1, SHM_TYPE u32 *s_te2, SHM_TYPE u32 *s_te3, SHM_TYPE u32 *s_te4) +{ + AES256_set_encrypt_key(aes_ks, hash, s_te0, s_te1, s_te2, s_te3); + + shift_buffer_by_offset(hash, pw_len + 4); + + hash[0] = hc_swap32(pw_len); + hash[1] |= hc_swap32(pw[0]); + hash[2] |= hc_swap32(pw[1]); + hash[3] |= hc_swap32(pw[2]); + + AES256_encrypt(aes_ks, hash, out, s_te0, s_te1, s_te2, s_te3, s_te4); +} +DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, const int pw_len, PRIVATE_AS u32x *hash, PRIVATE_AS u32x *out, SHM_TYPE u32 *s_te0, SHM_TYPE u32 *s_te1, SHM_TYPE u32 *s_te2, SHM_TYPE u32 *s_te3, SHM_TYPE u32 *s_te4) +{ +#if VECT_SIZE == 1 + aes256_scrt_format(aes_ks, w, pw_len, hash, out, s_te0, s_te1, s_te2, s_te3, s_te4); +#endif + +#if VECT_SIZE >= 2 + aes256_scrt_format(aes_ks, w.s0, pw_len.s0, hash.s0, out.s0, s_te0, s_te1, s_te2, s_te3, s_te4); + aes256_scrt_format(aes_ks, w.s1, pw_len.s1, hash.s1, out.s1, s_te0, s_te1, s_te2, s_te3, s_te4); +#endif + +#if VECT_SIZE >= 4 + aes256_scrt_format(aes_ks, w.s2, pw_len.s2, hash.s2, out.s2, s_te0, s_te1, s_te2, s_te3, s_te4); + aes256_scrt_format(aes_ks, w.s3, pw_len.s3, hash.s3, out.s3, s_te0, s_te1, s_te2, s_te3, s_te4); +#endif + +#if VECT_SIZE >= 8 + aes256_scrt_format(aes_ks, w.s5, pw_len.s5, hash.s5, out.s5, s_te0, s_te1, s_te2, s_te3, s_te4); + aes256_scrt_format(aes_ks, w.s6, pw_len.s6, hash.s6, out.s6, s_te0, s_te1, s_te2, s_te3, s_te4); + aes256_scrt_format(aes_ks, w.s7, pw_len.s7, hash.s7, out.s7, s_te0, s_te1, s_te2, s_te3, s_te4); + aes256_scrt_format(aes_ks, w.s8, pw_len.s8, hash.s8, out.s8, s_te0, s_te1, s_te2, s_te3, s_te4); +#endif + +#if VECT_SIZE >= 16 + aes256_scrt_format(aes_ks, w.s9, pw_len.s9, hash.s9, out.s9, s_te0, s_te1, s_te2, s_te3, s_te4); + aes256_scrt_format(aes_ks, w.s10, pw_len.s10, hash.s10, out.s10, s_te0, s_te1, s_te2, s_te3, s_te4); + aes256_scrt_format(aes_ks, w.s11, pw_len.s11, hash.s11, out.s11, s_te0, s_te1, s_te2, s_te3, s_te4); + aes256_scrt_format(aes_ks, w.s12, pw_len.s12, hash.s12, out.s12, s_te0, s_te1, s_te2, s_te3, s_te4); + aes256_scrt_format(aes_ks, w.s13, pw_len.s13, hash.s13, out.s13, s_te0, s_te1, s_te2, s_te3, s_te4); + aes256_scrt_format(aes_ks, w.s15, pw_len.s15, hash.s15, out.s15, s_te0, s_te1, s_te2, s_te3, s_te4); + aes256_scrt_format(aes_ks, w.s16, pw_len.s16, hash.s16, out.s16, s_te0, s_te1, s_te2, s_te3, s_te4); + aes256_scrt_format(aes_ks, w.s17, pw_len.s17, hash.s17, out.s17, s_te0, s_te1, s_te2, s_te3, s_te4); +#endif +} + +KERNEL_FQ void m31400_mxx(KERN_ATTR_VECTOR()) +{ + /** + * modifier + */ + + const u64 lid = get_local_id(0); + const u64 gid = get_global_id(0); + const u64 lsz = get_local_size(0); + + /** + * aes shared + */ + +#ifdef REAL_SHM + + LOCAL_VK u32 s_te0[256]; + LOCAL_VK u32 s_te1[256]; + LOCAL_VK u32 s_te2[256]; + LOCAL_VK u32 s_te3[256]; + LOCAL_VK u32 s_te4[256]; + + for (u32 i = lid; i < 256; i += lsz) + { + s_te0[i] = te0[i]; + s_te1[i] = te1[i]; + s_te2[i] = te2[i]; + s_te3[i] = te3[i]; + s_te4[i] = te4[i]; + } + + SYNC_THREADS(); + +#else + + CONSTANT_AS u32a *s_te0 = te0; + CONSTANT_AS u32a *s_te1 = te1; + CONSTANT_AS u32a *s_te2 = te2; + CONSTANT_AS u32a *s_te3 = te3; + CONSTANT_AS u32a *s_te4 = te4; + +#endif + + 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]; + } + + u32 aes_ks[60]; + + /** + * loop + */ + + u32x w0l = w[0]; + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) + { + const u32x w0r = words_buf_r[il_pos / VECT_SIZE]; + + const u32x w0 = w0l | w0r; + + w[0] = w0; + + sha256_ctx_vector_t ctx; + + sha256_init_vector(&ctx); + + sha256_update_vector_swap(&ctx, w, pw_len); + + sha256_final_vector(&ctx); + + u32x out[4] = {0}; + + aes256_scrt_format_VV(aes_ks, w, pw_len, ctx.h, out, s_te0, s_te1, s_te2, s_te3, s_te4); + + const u32x r0 = out[DGST_R0]; + const u32x r1 = out[DGST_R1]; + const u32x r2 = out[DGST_R2]; + const u32x r3 = out[DGST_R3]; + + COMPARE_M_SIMD(r0, r1, r2, r3); + } +} + +KERNEL_FQ void m31400_sxx(KERN_ATTR_VECTOR()) +{ + /** + * modifier + */ + + const u64 lid = get_local_id(0); + const u64 gid = get_global_id(0); + const u64 lsz = get_local_size(0); + + /** + * aes shared + */ + +#ifdef REAL_SHM + + LOCAL_VK u32 s_te0[256]; + LOCAL_VK u32 s_te1[256]; + LOCAL_VK u32 s_te2[256]; + LOCAL_VK u32 s_te3[256]; + LOCAL_VK u32 s_te4[256]; + + for (u32 i = lid; i < 256; i += lsz) + { + s_te0[i] = te0[i]; + s_te1[i] = te1[i]; + s_te2[i] = te2[i]; + s_te3[i] = te3[i]; + s_te4[i] = te4[i]; + } + + SYNC_THREADS(); + +#else + + CONSTANT_AS u32a *s_te0 = te0; + CONSTANT_AS u32a *s_te1 = te1; + CONSTANT_AS u32a *s_te2 = te2; + CONSTANT_AS u32a *s_te3 = te3; + CONSTANT_AS u32a *s_te4 = te4; + +#endif + + 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]; + } + + /** + * loop + */ + + u32 aes_ks[60]; + u32x w0l = w[0]; + + for (u32 il_pos = 0; il_pos < IL_CNT; il_pos += VECT_SIZE) + { + const u32x w0r = words_buf_r[il_pos / VECT_SIZE]; + + const u32x w0 = w0l | w0r; + + w[0] = w0; + + sha256_ctx_vector_t ctx; + + sha256_init_vector(&ctx); + + sha256_update_vector_swap(&ctx, w, pw_len); + + sha256_final_vector(&ctx); + + u32x out[4] = {0}; + + aes256_scrt_format_VV(aes_ks, w, pw_len, ctx.h, out, s_te0, s_te1, s_te2, s_te3, s_te4); + + const u32x r0 = out[DGST_R0]; + const u32x r1 = out[DGST_R1]; + const u32x r2 = out[DGST_R2]; + const u32x r3 = out[DGST_R3]; + + COMPARE_S_SIMD(r0, r1, r2, r3); + } +} diff --git a/src/modules/module_31400.c b/src/modules/module_31400.c new file mode 100644 index 000000000..232b48109 --- /dev/null +++ b/src/modules/module_31400.c @@ -0,0 +1,178 @@ +/** + * Author......: See docs/credits.txt + * License.....: MIT + */ + +#include "common.h" +#include "types.h" +#include "modules.h" +#include "bitops.h" +#include "convert.h" +#include "shared.h" + +static const u32 ATTACK_EXEC = ATTACK_EXEC_INSIDE_KERNEL; +static const u32 DGST_POS0 = 0; +static const u32 DGST_POS1 = 1; +static const u32 DGST_POS2 = 2; +static const u32 DGST_POS3 = 3; +static const u32 DGST_SIZE = DGST_SIZE_4_8; +static const u32 HASH_CATEGORY = HASH_CATEGORY_RAW_HASH; +static const char *HASH_NAME = "SecureCRT"; +static const u64 KERN_TYPE = 31400; +static const u32 OPTI_TYPE = OPTI_TYPE_ZERO_BYTE + | OPTI_TYPE_PRECOMPUTE_INIT + | OPTI_TYPE_EARLY_SKIP + | OPTI_TYPE_NOT_ITERATED + | OPTI_TYPE_NOT_SALTED + | OPTI_TYPE_RAW_HASH; +static const u64 OPTS_TYPE = OPTS_TYPE_STOCK_MODULE + | OPTS_TYPE_HASH_COPY + | OPTS_TYPE_PT_ADD80 + | OPTS_TYPE_PT_ADDBITS15; +static const u32 SALT_TYPE = SALT_TYPE_NONE; +static const char *ST_PASS = "hashcat"; +static const char *ST_HASH = "S:\"Config Passphrase\"=02:ded7137400e0a1004a12f1708453968ccc270908ba02ab0345c83690d1de3d9937587be66ad2a7fe8cc6cb16ecff02e61ac05e09d4f49f284efd24f6b16d6ae3"; + +u32 module_attack_exec (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return ATTACK_EXEC; } +u32 module_dgst_pos0 (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS0; } +u32 module_dgst_pos1 (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS1; } +u32 module_dgst_pos2 (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS2; } +u32 module_dgst_pos3 (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_POS3; } +u32 module_dgst_size (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return DGST_SIZE; } +u32 module_hash_category (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return HASH_CATEGORY; } +const char *module_hash_name (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return HASH_NAME; } +u64 module_kern_type (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return KERN_TYPE; } +u32 module_opti_type (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return OPTI_TYPE; } +u64 module_opts_type (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return OPTS_TYPE; } +u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return SALT_TYPE; } +const char *module_st_hash (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return ST_HASH; } +const char *module_st_pass (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) { return ST_PASS; } + +int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED void *digest_buf, MAYBE_UNUSED salt_t *salt, MAYBE_UNUSED void *esalt_buf, MAYBE_UNUSED void *hook_salt_buf, MAYBE_UNUSED hashinfo_t *hash_info, const char *line_buf, MAYBE_UNUSED const int line_len) +{ + static const char *CONFIGPASSPHRASEV2_SIGNATURE = "S:\"Config Passphrase\"=02:"; //The whole line is part of the format to prevent confusion with other similiar tokens also prefixed with 02: in the config files + static const char *CONFIGPASSPHRASEV2_SIGNATURE_UNDERSCORE = "S:_Config_Passphrase_=02:"; //double quotes char messes up testing so we're also allowing underscore instead + + u32 *digest = (u32 *) digest_buf; + + hc_token_t token; + + token.token_cnt = 2; + + token.signatures_cnt = 2; + token.signatures_buf[0] = CONFIGPASSPHRASEV2_SIGNATURE; + token.signatures_buf[1] = CONFIGPASSPHRASEV2_SIGNATURE_UNDERSCORE; + + token.len[0] = 25; + token.attr[0] = TOKEN_ATTR_FIXED_LENGTH + | TOKEN_ATTR_VERIFY_SIGNATURE; + + token.len_min[1] = 96; + token.len_max[1] = 160; + token.attr[1] = TOKEN_ATTR_VERIFY_LENGTH + | TOKEN_ATTR_VERIFY_HEX; + + const int rc_tokenizer = input_tokenizer ((const u8 *) line_buf, line_len, &token); + + if (rc_tokenizer != PARSER_OK) return (rc_tokenizer); + + const u8 *hash_pos = token.buf[1]; + + 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); + + digest[0] = byte_swap_32 (digest[0]); + digest[1] = byte_swap_32 (digest[1]); + digest[2] = byte_swap_32 (digest[2]); + digest[3] = byte_swap_32 (digest[3]); + + 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 int line_len = snprintf (line_buf, line_size, "%s", hash_info->orighash); + return line_len; +} + +void module_init (module_ctx_t *module_ctx) +{ + module_ctx->module_context_size = MODULE_CONTEXT_SIZE_CURRENT; + module_ctx->module_interface_version = MODULE_INTERFACE_VERSION_CURRENT; + + module_ctx->module_attack_exec = module_attack_exec; + module_ctx->module_benchmark_esalt = MODULE_DEFAULT; + module_ctx->module_benchmark_hook_salt = MODULE_DEFAULT; + module_ctx->module_benchmark_mask = MODULE_DEFAULT; + module_ctx->module_benchmark_charset = MODULE_DEFAULT; + module_ctx->module_benchmark_salt = MODULE_DEFAULT; + module_ctx->module_build_plain_postprocess = MODULE_DEFAULT; + module_ctx->module_deep_comp_kernel = MODULE_DEFAULT; + module_ctx->module_deprecated_notice = MODULE_DEFAULT; + module_ctx->module_dgst_pos0 = module_dgst_pos0; + module_ctx->module_dgst_pos1 = module_dgst_pos1; + module_ctx->module_dgst_pos2 = module_dgst_pos2; + module_ctx->module_dgst_pos3 = module_dgst_pos3; + module_ctx->module_dgst_size = module_dgst_size; + module_ctx->module_dictstat_disable = MODULE_DEFAULT; + module_ctx->module_esalt_size = MODULE_DEFAULT; + module_ctx->module_extra_buffer_size = MODULE_DEFAULT; + module_ctx->module_extra_tmp_size = MODULE_DEFAULT; + module_ctx->module_extra_tuningdb_block = MODULE_DEFAULT; + module_ctx->module_forced_outfile_format = MODULE_DEFAULT; + module_ctx->module_hash_binary_count = MODULE_DEFAULT; + module_ctx->module_hash_binary_parse = MODULE_DEFAULT; + module_ctx->module_hash_binary_save = MODULE_DEFAULT; + module_ctx->module_hash_decode_postprocess = MODULE_DEFAULT; + module_ctx->module_hash_decode_potfile = MODULE_DEFAULT; + module_ctx->module_hash_decode_zero_hash = MODULE_DEFAULT; + module_ctx->module_hash_decode = module_hash_decode; + module_ctx->module_hash_encode_status = MODULE_DEFAULT; + module_ctx->module_hash_encode_potfile = MODULE_DEFAULT; + module_ctx->module_hash_encode = module_hash_encode; + module_ctx->module_hash_init_selftest = MODULE_DEFAULT; + module_ctx->module_hash_mode = MODULE_DEFAULT; + module_ctx->module_hash_category = module_hash_category; + module_ctx->module_hash_name = module_hash_name; + module_ctx->module_hashes_count_min = MODULE_DEFAULT; + module_ctx->module_hashes_count_max = MODULE_DEFAULT; + module_ctx->module_hlfmt_disable = MODULE_DEFAULT; + module_ctx->module_hook_extra_param_size = MODULE_DEFAULT; + module_ctx->module_hook_extra_param_init = MODULE_DEFAULT; + module_ctx->module_hook_extra_param_term = MODULE_DEFAULT; + module_ctx->module_hook12 = MODULE_DEFAULT; + module_ctx->module_hook23 = MODULE_DEFAULT; + module_ctx->module_hook_salt_size = MODULE_DEFAULT; + module_ctx->module_hook_size = MODULE_DEFAULT; + module_ctx->module_jit_build_options = MODULE_DEFAULT; + module_ctx->module_jit_cache_disable = MODULE_DEFAULT; + module_ctx->module_kernel_accel_max = MODULE_DEFAULT; + module_ctx->module_kernel_accel_min = MODULE_DEFAULT; + module_ctx->module_kernel_loops_max = MODULE_DEFAULT; + module_ctx->module_kernel_loops_min = MODULE_DEFAULT; + module_ctx->module_kernel_threads_max = MODULE_DEFAULT; + module_ctx->module_kernel_threads_min = MODULE_DEFAULT; + module_ctx->module_kern_type = module_kern_type; + module_ctx->module_kern_type_dynamic = MODULE_DEFAULT; + module_ctx->module_opti_type = module_opti_type; + module_ctx->module_opts_type = module_opts_type; + module_ctx->module_outfile_check_disable = MODULE_DEFAULT; + module_ctx->module_outfile_check_nocomp = MODULE_DEFAULT; + module_ctx->module_potfile_custom_check = MODULE_DEFAULT; + module_ctx->module_potfile_disable = MODULE_DEFAULT; + module_ctx->module_potfile_keep_all_hashes = MODULE_DEFAULT; + module_ctx->module_pwdump_column = MODULE_DEFAULT; + module_ctx->module_pw_max = MODULE_DEFAULT; + module_ctx->module_pw_min = MODULE_DEFAULT; + module_ctx->module_salt_max = MODULE_DEFAULT; + module_ctx->module_salt_min = MODULE_DEFAULT; + module_ctx->module_salt_type = module_salt_type; + module_ctx->module_separator = MODULE_DEFAULT; + module_ctx->module_st_hash = module_st_hash; + module_ctx->module_st_pass = module_st_pass; + module_ctx->module_tmp_size = MODULE_DEFAULT; + module_ctx->module_unstable_warning = MODULE_DEFAULT; + module_ctx->module_warmup_disable = MODULE_DEFAULT; +} diff --git a/tools/test_modules/m31400.pm b/tools/test_modules/m31400.pm new file mode 100644 index 000000000..b9b423078 --- /dev/null +++ b/tools/test_modules/m31400.pm @@ -0,0 +1,101 @@ +#!/usr/bin/env perl + +## +## Author......: See docs/credits.txt +## License.....: MIT +## + +use strict; +use warnings; + +use Digest::SHA qw (sha256_hex); +use Crypt::CBC; + +sub module_constraints { [[0, 256], [-1, -1], [0, 55], [-1, -1], [-1, -1]] } + +sub calculate_padding +{ + my $length = shift; + my $blocksize = shift // 32; + my $minpadding = shift // 16; + + my $padded_len=$length+$minpadding; + my $finalpadded=( ( $padded_len - 1 ) | ( $blocksize - 1 ) ) + 1; + + return $finalpadded - $length; + +} + +sub module_generate_hash +{ + my $word = shift; + my $total_len = (length($word)*2) + 8 + 64; + my $padding = shift // random_hex_string (calculate_padding($total_len)); + + if (length $padding == 0){ + $padding=random_hex_string (calculate_padding($total_len)); + } + + + my $digest = sha256_hex ($word); + my $len = sprintf("%02d",length($word)); + my $paddedlen = sprintf("%02x000000", $len); + my $hexofword=unpack "H*",$word; + my $plaintext = $paddedlen . $hexofword . $digest . $padding; + + + my $aes = Crypt::CBC->new ({ + key => pack ("H*", $digest), + cipher => "Crypt::Rijndael", + iv => => "\x00" x 16, + literal_key => 1, + header => "none", + keysize => 32, + padding => "none", + }); + + my $ciphertext=$aes->encrypt(pack("H*",$plaintext)); + my $hash = sprintf("S:_Config_Passphrase_=02:%s",unpack ("H*",$ciphertext)); + + return $hash +} + +sub get_aes +{ + my $word_packed=shift; + my $key = sha256_hex ($word_packed); + + my $aes = Crypt::CBC->new ({ + key => pack ("H*", $key), + cipher => "Crypt::Rijndael", + iv => => "\x00" x 16, + literal_key => 1, + header => "none", + keysize => 32, + padding => "none", + }); + return $aes +} + +sub module_verify_hash +{ + my $line = shift; + + my ($hash, $word) = $line=~ /S:.Config.Passphrase.=02:(.*):(.*)/; + + return unless defined $hash; + return unless defined $word; + + my $word_packed = pack_if_HEX_notation ($word); + my $decrypted = get_aes($word_packed)->decrypt(pack"H*", $hash); + my $plaintext_hex=unpack "H*",$decrypted; + my $passlen=hex(substr($plaintext_hex,0,2)); + my $padding = substr($plaintext_hex,8+2*$passlen+64); + + + my $new_hash = module_generate_hash ($word_packed,$padding); + + return ($new_hash, $word); +} + +1; From 06b07d06e21b26ad1fdac54089e0e6ea760d9b85 Mon Sep 17 00:00:00 2001 From: Yaakov Saxon Date: Wed, 15 Mar 2023 16:33:19 -0400 Subject: [PATCH 02/11] clarify purpose and applicable versions --- src/modules/module_31400.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/modules/module_31400.c b/src/modules/module_31400.c index 232b48109..93ee01c7a 100644 --- a/src/modules/module_31400.c +++ b/src/modules/module_31400.c @@ -1,6 +1,9 @@ /** * Author......: See docs/credits.txt * License.....: MIT + * + * Note that this module is intended to crack only the master passphrase of a SecureCRT config stored in the 2: format (versions < 9.3) + * See https://github.com/HyperSine/how-does-SecureCRT-encrypt-password for decrypting passwords after you've cracked the master passphrase (or if there is no master passphrase) */ #include "common.h" @@ -17,7 +20,7 @@ static const u32 DGST_POS2 = 2; static const u32 DGST_POS3 = 3; static const u32 DGST_SIZE = DGST_SIZE_4_8; static const u32 HASH_CATEGORY = HASH_CATEGORY_RAW_HASH; -static const char *HASH_NAME = "SecureCRT"; +static const char *HASH_NAME = "SecureCRT MasterPassphrase v2"; static const u64 KERN_TYPE = 31400; static const u32 OPTI_TYPE = OPTI_TYPE_ZERO_BYTE | OPTI_TYPE_PRECOMPUTE_INIT From d8eb42883804ae1bd68862b14158a2db21d08d3c Mon Sep 17 00:00:00 2001 From: Yaakov Saxon Date: Thu, 16 Mar 2023 14:08:57 -0400 Subject: [PATCH 03/11] unwrap vectors in a3 --- OpenCL/m31400_a3-pure.cl | 277 ++++++++++++++++++++++++++++++++++++--- 1 file changed, 261 insertions(+), 16 deletions(-) diff --git a/OpenCL/m31400_a3-pure.cl b/OpenCL/m31400_a3-pure.cl index 8a7fe6724..6c093a02d 100644 --- a/OpenCL/m31400_a3-pure.cl +++ b/OpenCL/m31400_a3-pure.cl @@ -134,31 +134,276 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, #endif #if VECT_SIZE >= 2 - aes256_scrt_format(aes_ks, w.s0, pw_len.s0, hash.s0, out.s0, s_te0, s_te1, s_te2, s_te3, s_te4); - aes256_scrt_format(aes_ks, w.s1, pw_len.s1, hash.s1, out.s1, s_te0, s_te1, s_te2, s_te3, s_te4); + + u32 tmp_w[4]; + u32 tmp_out[4]; + u32 tmp_pw_len; + + //s0 + tmp_w[0] = w[0].s0; + tmp_w[1] = w[1].s0; + tmp_w[2] = w[2].s0; + tmp_w[3] = w[3].s0; + + tmp_pw_len = pw_len.s0; + + aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, hash.s0, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + + out[0].s0 = tmp_out[0]; + out[1].s0 = tmp_out[1]; + out[2].s0 = tmp_out[2]; + out[3].s0 = tmp_out[3]; + + + //s1 + tmp_w[0] = w[0].s1; + tmp_w[1] = w[1].s1; + tmp_w[2] = w[2].s1; + tmp_w[3] = w[3].s1; + + tmp_pw_len = pw_len.s1; + + aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, hash.s1, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + + out[0].s1 = tmp_out[0]; + out[1].s1 = tmp_out[1]; + out[2].s1 = tmp_out[2]; + out[3].s1 = tmp_out[3]; + + #endif #if VECT_SIZE >= 4 - aes256_scrt_format(aes_ks, w.s2, pw_len.s2, hash.s2, out.s2, s_te0, s_te1, s_te2, s_te3, s_te4); - aes256_scrt_format(aes_ks, w.s3, pw_len.s3, hash.s3, out.s3, s_te0, s_te1, s_te2, s_te3, s_te4); + //s2 + tmp_w[0] = w[0].s2; + tmp_w[1] = w[1].s2; + tmp_w[2] = w[2].s2; + tmp_w[3] = w[3].s2; + + tmp_pw_len = pw_len.s2; + + aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, hash.s2, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + + out[0].s2 = tmp_out[0]; + out[1].s2 = tmp_out[1]; + out[2].s2 = tmp_out[2]; + out[3].s2 = tmp_out[3]; + + + //s3 + tmp_w[0] = w[0].s3; + tmp_w[1] = w[1].s3; + tmp_w[2] = w[2].s3; + tmp_w[3] = w[3].s3; + + tmp_pw_len = pw_len.s3; + + aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, hash.s3, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + + out[0].s3 = tmp_out[0]; + out[1].s3 = tmp_out[1]; + out[2].s3 = tmp_out[2]; + out[3].s3 = tmp_out[3]; + + #endif #if VECT_SIZE >= 8 - aes256_scrt_format(aes_ks, w.s5, pw_len.s5, hash.s5, out.s5, s_te0, s_te1, s_te2, s_te3, s_te4); - aes256_scrt_format(aes_ks, w.s6, pw_len.s6, hash.s6, out.s6, s_te0, s_te1, s_te2, s_te3, s_te4); - aes256_scrt_format(aes_ks, w.s7, pw_len.s7, hash.s7, out.s7, s_te0, s_te1, s_te2, s_te3, s_te4); - aes256_scrt_format(aes_ks, w.s8, pw_len.s8, hash.s8, out.s8, s_te0, s_te1, s_te2, s_te3, s_te4); + //s5 + tmp_w[0] = w[0].s5; + tmp_w[1] = w[1].s5; + tmp_w[2] = w[2].s5; + tmp_w[3] = w[3].s5; + + tmp_pw_len = pw_len.s5; + + aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, hash.s5, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + + out[0].s5 = tmp_out[0]; + out[1].s5 = tmp_out[1]; + out[2].s5 = tmp_out[2]; + out[3].s5 = tmp_out[3]; + + + //s6 + tmp_w[0] = w[0].s6; + tmp_w[1] = w[1].s6; + tmp_w[2] = w[2].s6; + tmp_w[3] = w[3].s6; + + tmp_pw_len = pw_len.s6; + + aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, hash.s6, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + + out[0].s6 = tmp_out[0]; + out[1].s6 = tmp_out[1]; + out[2].s6 = tmp_out[2]; + out[3].s6 = tmp_out[3]; + + + //s7 + tmp_w[0] = w[0].s7; + tmp_w[1] = w[1].s7; + tmp_w[2] = w[2].s7; + tmp_w[3] = w[3].s7; + + tmp_pw_len = pw_len.s7; + + aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, hash.s7, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + + out[0].s7 = tmp_out[0]; + out[1].s7 = tmp_out[1]; + out[2].s7 = tmp_out[2]; + out[3].s7 = tmp_out[3]; + + + //s8 + tmp_w[0] = w[0].s8; + tmp_w[1] = w[1].s8; + tmp_w[2] = w[2].s8; + tmp_w[3] = w[3].s8; + + tmp_pw_len = pw_len.s8; + + aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, hash.s8, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + + out[0].s8 = tmp_out[0]; + out[1].s8 = tmp_out[1]; + out[2].s8 = tmp_out[2]; + out[3].s8 = tmp_out[3]; + + #endif #if VECT_SIZE >= 16 - aes256_scrt_format(aes_ks, w.s9, pw_len.s9, hash.s9, out.s9, s_te0, s_te1, s_te2, s_te3, s_te4); - aes256_scrt_format(aes_ks, w.s10, pw_len.s10, hash.s10, out.s10, s_te0, s_te1, s_te2, s_te3, s_te4); - aes256_scrt_format(aes_ks, w.s11, pw_len.s11, hash.s11, out.s11, s_te0, s_te1, s_te2, s_te3, s_te4); - aes256_scrt_format(aes_ks, w.s12, pw_len.s12, hash.s12, out.s12, s_te0, s_te1, s_te2, s_te3, s_te4); - aes256_scrt_format(aes_ks, w.s13, pw_len.s13, hash.s13, out.s13, s_te0, s_te1, s_te2, s_te3, s_te4); - aes256_scrt_format(aes_ks, w.s15, pw_len.s15, hash.s15, out.s15, s_te0, s_te1, s_te2, s_te3, s_te4); - aes256_scrt_format(aes_ks, w.s16, pw_len.s16, hash.s16, out.s16, s_te0, s_te1, s_te2, s_te3, s_te4); - aes256_scrt_format(aes_ks, w.s17, pw_len.s17, hash.s17, out.s17, s_te0, s_te1, s_te2, s_te3, s_te4); + //s9 + tmp_w[0] = w[0].s9; + tmp_w[1] = w[1].s9; + tmp_w[2] = w[2].s9; + tmp_w[3] = w[3].s9; + + tmp_pw_len = pw_len.s9; + + aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, hash.s9, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + + out[0].s9 = tmp_out[0]; + out[1].s9 = tmp_out[1]; + out[2].s9 = tmp_out[2]; + out[3].s9 = tmp_out[3]; + + + //s10 + tmp_w[0] = w[0].s10; + tmp_w[1] = w[1].s10; + tmp_w[2] = w[2].s10; + tmp_w[3] = w[3].s10; + + tmp_pw_len = pw_len.s10; + + aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, hash.s10, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + + out[0].s10 = tmp_out[0]; + out[1].s10 = tmp_out[1]; + out[2].s10 = tmp_out[2]; + out[3].s10 = tmp_out[3]; + + + //s11 + tmp_w[0] = w[0].s11; + tmp_w[1] = w[1].s11; + tmp_w[2] = w[2].s11; + tmp_w[3] = w[3].s11; + + tmp_pw_len = pw_len.s11; + + aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, hash.s11, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + + out[0].s11 = tmp_out[0]; + out[1].s11 = tmp_out[1]; + out[2].s11 = tmp_out[2]; + out[3].s11 = tmp_out[3]; + + + //s12 + tmp_w[0] = w[0].s12; + tmp_w[1] = w[1].s12; + tmp_w[2] = w[2].s12; + tmp_w[3] = w[3].s12; + + tmp_pw_len = pw_len.s12; + + aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, hash.s12, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + + out[0].s12 = tmp_out[0]; + out[1].s12 = tmp_out[1]; + out[2].s12 = tmp_out[2]; + out[3].s12 = tmp_out[3]; + + + //s13 + tmp_w[0] = w[0].s13; + tmp_w[1] = w[1].s13; + tmp_w[2] = w[2].s13; + tmp_w[3] = w[3].s13; + + tmp_pw_len = pw_len.s13; + + aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, hash.s13, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + + out[0].s13 = tmp_out[0]; + out[1].s13 = tmp_out[1]; + out[2].s13 = tmp_out[2]; + out[3].s13 = tmp_out[3]; + + + //s15 + tmp_w[0] = w[0].s15; + tmp_w[1] = w[1].s15; + tmp_w[2] = w[2].s15; + tmp_w[3] = w[3].s15; + + tmp_pw_len = pw_len.s15; + + aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, hash.s15, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + + out[0].s15 = tmp_out[0]; + out[1].s15 = tmp_out[1]; + out[2].s15 = tmp_out[2]; + out[3].s15 = tmp_out[3]; + + + //s16 + tmp_w[0] = w[0].s16; + tmp_w[1] = w[1].s16; + tmp_w[2] = w[2].s16; + tmp_w[3] = w[3].s16; + + tmp_pw_len = pw_len.s16; + + aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, hash.s16, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + + out[0].s16 = tmp_out[0]; + out[1].s16 = tmp_out[1]; + out[2].s16 = tmp_out[2]; + out[3].s16 = tmp_out[3]; + + + //s17 + tmp_w[0] = w[0].s17; + tmp_w[1] = w[1].s17; + tmp_w[2] = w[2].s17; + tmp_w[3] = w[3].s17; + + tmp_pw_len = pw_len.s17; + + aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, hash.s17, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + + out[0].s17 = tmp_out[0]; + out[1].s17 = tmp_out[1]; + out[2].s17 = tmp_out[2]; + out[3].s17 = tmp_out[3]; + + #endif } From f4b96e1faac16d4ba26ff8c85019f7d56f3d2a49 Mon Sep 17 00:00:00 2001 From: Yaakov Saxon Date: Thu, 16 Mar 2023 23:04:10 -0400 Subject: [PATCH 04/11] still not working but maybe closer --- OpenCL/m31400_a3-pure.cl | 194 ++++++++++++++++++++++++++++----------- 1 file changed, 141 insertions(+), 53 deletions(-) diff --git a/OpenCL/m31400_a3-pure.cl b/OpenCL/m31400_a3-pure.cl index 6c093a02d..588c7dfeb 100644 --- a/OpenCL/m31400_a3-pure.cl +++ b/OpenCL/m31400_a3-pure.cl @@ -114,20 +114,20 @@ DECLSPEC void shift_buffer_by_offset(PRIVATE_AS u32 *w0, const u32 offset) #endif } -DECLSPEC void aes256_scrt_format(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32 *pw, const int pw_len, PRIVATE_AS u32 *hash, PRIVATE_AS u32 *out, SHM_TYPE u32 *s_te0, SHM_TYPE u32 *s_te1, SHM_TYPE u32 *s_te2, SHM_TYPE u32 *s_te3, SHM_TYPE u32 *s_te4) +DECLSPEC void aes256_scrt_format(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32 *pw, PRIVATE_AS u32 pw_len, PRIVATE_AS u32 *hash, PRIVATE_AS u32 *out, SHM_TYPE u32 *s_te0, SHM_TYPE u32 *s_te1, SHM_TYPE u32 *s_te2, SHM_TYPE u32 *s_te3, SHM_TYPE u32 *s_te4) { AES256_set_encrypt_key(aes_ks, hash, s_te0, s_te1, s_te2, s_te3); shift_buffer_by_offset(hash, pw_len + 4); - hash[0] = hc_swap32(pw_len); - hash[1] |= hc_swap32(pw[0]); - hash[2] |= hc_swap32(pw[1]); - hash[3] |= hc_swap32(pw[2]); + hash[0] = hc_swap32_S(pw_len); + hash[1] |= hc_swap32_S(pw[0]); + hash[2] |= hc_swap32_S(pw[1]); + hash[3] |= hc_swap32_S(pw[2]); AES256_encrypt(aes_ks, hash, out, s_te0, s_te1, s_te2, s_te3, s_te4); } -DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, const int pw_len, PRIVATE_AS u32x *hash, PRIVATE_AS u32x *out, SHM_TYPE u32 *s_te0, SHM_TYPE u32 *s_te1, SHM_TYPE u32 *s_te2, SHM_TYPE u32 *s_te3, SHM_TYPE u32 *s_te4) +DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, PRIVATE_AS u32x pw_len, PRIVATE_AS u32x *hash, PRIVATE_AS u32x *out, SHM_TYPE u32 *s_te0, SHM_TYPE u32 *s_te1, SHM_TYPE u32 *s_te2, SHM_TYPE u32 *s_te3, SHM_TYPE u32 *s_te4) { #if VECT_SIZE == 1 aes256_scrt_format(aes_ks, w, pw_len, hash, out, s_te0, s_te1, s_te2, s_te3, s_te4); @@ -136,6 +136,7 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, #if VECT_SIZE >= 2 u32 tmp_w[4]; + u32 tmp_hash[4]; u32 tmp_out[4]; u32 tmp_pw_len; @@ -145,6 +146,11 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_w[2] = w[2].s0; tmp_w[3] = w[3].s0; + tmp_hash[0] = hash[0].s0; + tmp_hash[1] = hash[1].s0; + tmp_hash[2] = hash[2].s0; + tmp_hash[3] = hash[3].s0; + tmp_pw_len = pw_len.s0; aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, hash.s0, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); @@ -161,6 +167,11 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_w[2] = w[2].s1; tmp_w[3] = w[3].s1; + tmp_hash[0] = hash[0].s1; + tmp_hash[1] = hash[1].s1; + tmp_hash[2] = hash[2].s1; + tmp_hash[3] = hash[3].s1; + tmp_pw_len = pw_len.s1; aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, hash.s1, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); @@ -180,9 +191,14 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_w[2] = w[2].s2; tmp_w[3] = w[3].s2; + tmp_hash[0] = hash[0].s2; + tmp_hash[1] = hash[1].s2; + tmp_hash[2] = hash[2].s2; + tmp_hash[3] = hash[3].s2; + tmp_pw_len = pw_len.s2; - aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, hash.s2, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].s2 = tmp_out[0]; out[1].s2 = tmp_out[1]; @@ -196,9 +212,14 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_w[2] = w[2].s3; tmp_w[3] = w[3].s3; + tmp_hash[0] = hash[0].s3; + tmp_hash[1] = hash[1].s3; + tmp_hash[2] = hash[2].s3; + tmp_hash[3] = hash[3].s3; + tmp_pw_len = pw_len.s3; - aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, hash.s3, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].s3 = tmp_out[0]; out[1].s3 = tmp_out[1]; @@ -209,15 +230,41 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, #endif #if VECT_SIZE >= 8 + //s4 + tmp_w[0] = w[0].s4; + tmp_w[1] = w[1].s4; + tmp_w[2] = w[2].s4; + tmp_w[3] = w[3].s4; + + tmp_hash[0] = hash[0].s4; + tmp_hash[1] = hash[1].s4; + tmp_hash[2] = hash[2].s4; + tmp_hash[3] = hash[3].s4; + + tmp_pw_len = pw_len.s4; + + aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + + out[0].s4 = tmp_out[0]; + out[1].s4 = tmp_out[1]; + out[2].s4 = tmp_out[2]; + out[3].s4 = tmp_out[3]; + + //s5 tmp_w[0] = w[0].s5; tmp_w[1] = w[1].s5; tmp_w[2] = w[2].s5; tmp_w[3] = w[3].s5; + tmp_hash[0] = hash[0].s5; + tmp_hash[1] = hash[1].s5; + tmp_hash[2] = hash[2].s5; + tmp_hash[3] = hash[3].s5; + tmp_pw_len = pw_len.s5; - aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, hash.s5, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].s5 = tmp_out[0]; out[1].s5 = tmp_out[1]; @@ -231,9 +278,14 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_w[2] = w[2].s6; tmp_w[3] = w[3].s6; + tmp_hash[0] = hash[0].s6; + tmp_hash[1] = hash[1].s6; + tmp_hash[2] = hash[2].s6; + tmp_hash[3] = hash[3].s6; + tmp_pw_len = pw_len.s6; - aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, hash.s6, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].s6 = tmp_out[0]; out[1].s6 = tmp_out[1]; @@ -247,15 +299,23 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_w[2] = w[2].s7; tmp_w[3] = w[3].s7; + tmp_hash[0] = hash[0].s7; + tmp_hash[1] = hash[1].s7; + tmp_hash[2] = hash[2].s7; + tmp_hash[3] = hash[3].s7; + tmp_pw_len = pw_len.s7; - aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, hash.s7, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].s7 = tmp_out[0]; out[1].s7 = tmp_out[1]; out[2].s7 = tmp_out[2]; out[3].s7 = tmp_out[3]; +#endif + +#if VECT_SIZE >= 16 //s8 tmp_w[0] = w[0].s8; @@ -263,9 +323,14 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_w[2] = w[2].s8; tmp_w[3] = w[3].s8; + tmp_hash[0] = hash[0].s8; + tmp_hash[1] = hash[1].s8; + tmp_hash[2] = hash[2].s8; + tmp_hash[3] = hash[3].s8; + tmp_pw_len = pw_len.s8; - aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, hash.s8, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].s8 = tmp_out[0]; out[1].s8 = tmp_out[1]; @@ -273,18 +338,21 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, out[3].s8 = tmp_out[3]; -#endif - -#if VECT_SIZE >= 16 //s9 tmp_w[0] = w[0].s9; tmp_w[1] = w[1].s9; tmp_w[2] = w[2].s9; tmp_w[3] = w[3].s9; + + tmp_hash[0] = hash[0].s9; + tmp_hash[1] = hash[1].s9; + tmp_hash[2] = hash[2].s9; + tmp_hash[3] = hash[3].s9; + tmp_pw_len = pw_len.s9; - aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, hash.s9, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].s9 = tmp_out[0]; out[1].s9 = tmp_out[1]; @@ -298,9 +366,15 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_w[2] = w[2].s10; tmp_w[3] = w[3].s10; + + tmp_hash[0] = hash[0].s10; + tmp_hash[1] = hash[1].s10; + tmp_hash[2] = hash[2].s10; + tmp_hash[3] = hash[3].s10; + tmp_pw_len = pw_len.s10; - aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, hash.s10, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].s10 = tmp_out[0]; out[1].s10 = tmp_out[1]; @@ -314,9 +388,15 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_w[2] = w[2].s11; tmp_w[3] = w[3].s11; + + tmp_hash[0] = hash[0].s11; + tmp_hash[1] = hash[1].s11; + tmp_hash[2] = hash[2].s11; + tmp_hash[3] = hash[3].s11; + tmp_pw_len = pw_len.s11; - aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, hash.s11, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].s11 = tmp_out[0]; out[1].s11 = tmp_out[1]; @@ -330,9 +410,15 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_w[2] = w[2].s12; tmp_w[3] = w[3].s12; + + tmp_hash[0] = hash[0].s12; + tmp_hash[1] = hash[1].s12; + tmp_hash[2] = hash[2].s12; + tmp_hash[3] = hash[3].s12; + tmp_pw_len = pw_len.s12; - aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, hash.s12, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].s12 = tmp_out[0]; out[1].s12 = tmp_out[1]; @@ -346,15 +432,42 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_w[2] = w[2].s13; tmp_w[3] = w[3].s13; + + tmp_hash[0] = hash[0].s13; + tmp_hash[1] = hash[1].s13; + tmp_hash[2] = hash[2].s13; + tmp_hash[3] = hash[3].s13; + tmp_pw_len = pw_len.s13; - aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, hash.s13, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].s13 = tmp_out[0]; out[1].s13 = tmp_out[1]; out[2].s13 = tmp_out[2]; out[3].s13 = tmp_out[3]; + //s14 + tmp_w[0] = w[0].s14; + tmp_w[1] = w[1].s14; + tmp_w[2] = w[2].s14; + tmp_w[3] = w[3].s14; + + tmp_hash[0] = hash[0].s14; + tmp_hash[1] = hash[1].s14; + tmp_hash[2] = hash[2].s14; + tmp_hash[3] = hash[3].s14; + + + tmp_pw_len = pw_len.s14; + + aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + + out[0].s14 = tmp_out[0]; + out[1].s14 = tmp_out[1]; + out[2].s14 = tmp_out[2]; + out[3].s14 = tmp_out[3]; + //s15 tmp_w[0] = w[0].s15; @@ -362,9 +475,15 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_w[2] = w[2].s15; tmp_w[3] = w[3].s15; + + tmp_hash[0] = hash[0].s15; + tmp_hash[1] = hash[1].s15; + tmp_hash[2] = hash[2].s15; + tmp_hash[3] = hash[3].s15; + tmp_pw_len = pw_len.s15; - aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, hash.s15, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].s15 = tmp_out[0]; out[1].s15 = tmp_out[1]; @@ -372,39 +491,8 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, out[3].s15 = tmp_out[3]; - //s16 - tmp_w[0] = w[0].s16; - tmp_w[1] = w[1].s16; - tmp_w[2] = w[2].s16; - tmp_w[3] = w[3].s16; - - tmp_pw_len = pw_len.s16; - - aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, hash.s16, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); - - out[0].s16 = tmp_out[0]; - out[1].s16 = tmp_out[1]; - out[2].s16 = tmp_out[2]; - out[3].s16 = tmp_out[3]; - - - //s17 - tmp_w[0] = w[0].s17; - tmp_w[1] = w[1].s17; - tmp_w[2] = w[2].s17; - tmp_w[3] = w[3].s17; - - tmp_pw_len = pw_len.s17; - - aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, hash.s17, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); - - out[0].s17 = tmp_out[0]; - out[1].s17 = tmp_out[1]; - out[2].s17 = tmp_out[2]; - out[3].s17 = tmp_out[3]; - - #endif + } KERNEL_FQ void m31400_mxx(KERN_ATTR_VECTOR()) From aa80cc45470288ebed3f2f4611a4b2dd15dfe6f4 Mon Sep 17 00:00:00 2001 From: Yaakov Saxon Date: Thu, 16 Mar 2023 23:13:32 -0400 Subject: [PATCH 05/11] change s10-15 to sa-sf --- OpenCL/m31400_a3-pure.cl | 156 +++++++++++++++++++-------------------- 1 file changed, 78 insertions(+), 78 deletions(-) diff --git a/OpenCL/m31400_a3-pure.cl b/OpenCL/m31400_a3-pure.cl index 588c7dfeb..c5a145da0 100644 --- a/OpenCL/m31400_a3-pure.cl +++ b/OpenCL/m31400_a3-pure.cl @@ -361,134 +361,134 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, //s10 - tmp_w[0] = w[0].s10; - tmp_w[1] = w[1].s10; - tmp_w[2] = w[2].s10; - tmp_w[3] = w[3].s10; + tmp_w[0] = w[0].sa; + tmp_w[1] = w[1].sa; + tmp_w[2] = w[2].sa; + tmp_w[3] = w[3].sa; - tmp_hash[0] = hash[0].s10; - tmp_hash[1] = hash[1].s10; - tmp_hash[2] = hash[2].s10; - tmp_hash[3] = hash[3].s10; + tmp_hash[0] = hash[0].sa; + tmp_hash[1] = hash[1].sa; + tmp_hash[2] = hash[2].sa; + tmp_hash[3] = hash[3].sa; - tmp_pw_len = pw_len.s10; + tmp_pw_len = pw_len.sa; aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); - out[0].s10 = tmp_out[0]; - out[1].s10 = tmp_out[1]; - out[2].s10 = tmp_out[2]; - out[3].s10 = tmp_out[3]; + out[0].sa = tmp_out[0]; + out[1].sa = tmp_out[1]; + out[2].sa = tmp_out[2]; + out[3].sa = tmp_out[3]; //s11 - tmp_w[0] = w[0].s11; - tmp_w[1] = w[1].s11; - tmp_w[2] = w[2].s11; - tmp_w[3] = w[3].s11; + tmp_w[0] = w[0].sb; + tmp_w[1] = w[1].sb; + tmp_w[2] = w[2].sb; + tmp_w[3] = w[3].sb; - tmp_hash[0] = hash[0].s11; - tmp_hash[1] = hash[1].s11; - tmp_hash[2] = hash[2].s11; - tmp_hash[3] = hash[3].s11; + tmp_hash[0] = hash[0].sb; + tmp_hash[1] = hash[1].sb; + tmp_hash[2] = hash[2].sb; + tmp_hash[3] = hash[3].sb; - tmp_pw_len = pw_len.s11; + tmp_pw_len = pw_len.sb; aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); - out[0].s11 = tmp_out[0]; - out[1].s11 = tmp_out[1]; - out[2].s11 = tmp_out[2]; - out[3].s11 = tmp_out[3]; + out[0].sb = tmp_out[0]; + out[1].sb = tmp_out[1]; + out[2].sb = tmp_out[2]; + out[3].sb = tmp_out[3]; //s12 - tmp_w[0] = w[0].s12; - tmp_w[1] = w[1].s12; - tmp_w[2] = w[2].s12; - tmp_w[3] = w[3].s12; + tmp_w[0] = w[0].sc; + tmp_w[1] = w[1].sc; + tmp_w[2] = w[2].sc; + tmp_w[3] = w[3].sc; - tmp_hash[0] = hash[0].s12; - tmp_hash[1] = hash[1].s12; - tmp_hash[2] = hash[2].s12; - tmp_hash[3] = hash[3].s12; + tmp_hash[0] = hash[0].sc; + tmp_hash[1] = hash[1].sc; + tmp_hash[2] = hash[2].sc; + tmp_hash[3] = hash[3].sc; - tmp_pw_len = pw_len.s12; + tmp_pw_len = pw_len.sc; aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); - out[0].s12 = tmp_out[0]; - out[1].s12 = tmp_out[1]; - out[2].s12 = tmp_out[2]; - out[3].s12 = tmp_out[3]; + out[0].sc = tmp_out[0]; + out[1].sc = tmp_out[1]; + out[2].sc = tmp_out[2]; + out[3].sc = tmp_out[3]; //s13 - tmp_w[0] = w[0].s13; - tmp_w[1] = w[1].s13; - tmp_w[2] = w[2].s13; - tmp_w[3] = w[3].s13; + tmp_w[0] = w[0].sd; + tmp_w[1] = w[1].sd; + tmp_w[2] = w[2].sd; + tmp_w[3] = w[3].sd; - tmp_hash[0] = hash[0].s13; - tmp_hash[1] = hash[1].s13; - tmp_hash[2] = hash[2].s13; - tmp_hash[3] = hash[3].s13; + tmp_hash[0] = hash[0].sd; + tmp_hash[1] = hash[1].sd; + tmp_hash[2] = hash[2].sd; + tmp_hash[3] = hash[3].sd; - tmp_pw_len = pw_len.s13; + tmp_pw_len = pw_len.sd; aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); - out[0].s13 = tmp_out[0]; - out[1].s13 = tmp_out[1]; - out[2].s13 = tmp_out[2]; - out[3].s13 = tmp_out[3]; + out[0].sd = tmp_out[0]; + out[1].sd = tmp_out[1]; + out[2].sd = tmp_out[2]; + out[3].sd = tmp_out[3]; //s14 - tmp_w[0] = w[0].s14; - tmp_w[1] = w[1].s14; - tmp_w[2] = w[2].s14; - tmp_w[3] = w[3].s14; + tmp_w[0] = w[0].se; + tmp_w[1] = w[1].se; + tmp_w[2] = w[2].se; + tmp_w[3] = w[3].se; - tmp_hash[0] = hash[0].s14; - tmp_hash[1] = hash[1].s14; - tmp_hash[2] = hash[2].s14; - tmp_hash[3] = hash[3].s14; + tmp_hash[0] = hash[0].se; + tmp_hash[1] = hash[1].se; + tmp_hash[2] = hash[2].se; + tmp_hash[3] = hash[3].se; - tmp_pw_len = pw_len.s14; + tmp_pw_len = pw_len.se; aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); - out[0].s14 = tmp_out[0]; - out[1].s14 = tmp_out[1]; - out[2].s14 = tmp_out[2]; - out[3].s14 = tmp_out[3]; + out[0].se = tmp_out[0]; + out[1].se = tmp_out[1]; + out[2].se = tmp_out[2]; + out[3].se = tmp_out[3]; //s15 - tmp_w[0] = w[0].s15; - tmp_w[1] = w[1].s15; - tmp_w[2] = w[2].s15; - tmp_w[3] = w[3].s15; + tmp_w[0] = w[0].sf; + tmp_w[1] = w[1].sf; + tmp_w[2] = w[2].sf; + tmp_w[3] = w[3].sf; - tmp_hash[0] = hash[0].s15; - tmp_hash[1] = hash[1].s15; - tmp_hash[2] = hash[2].s15; - tmp_hash[3] = hash[3].s15; + tmp_hash[0] = hash[0].sf; + tmp_hash[1] = hash[1].sf; + tmp_hash[2] = hash[2].sf; + tmp_hash[3] = hash[3].sf; - tmp_pw_len = pw_len.s15; + tmp_pw_len = pw_len.sf; aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); - out[0].s15 = tmp_out[0]; - out[1].s15 = tmp_out[1]; - out[2].s15 = tmp_out[2]; - out[3].s15 = tmp_out[3]; + out[0].sf = tmp_out[0]; + out[1].sf = tmp_out[1]; + out[2].sf = tmp_out[2]; + out[3].sf = tmp_out[3]; #endif From 9262056b0ea9dd4147fcdb64d65e8e54b06bf933 Mon Sep 17 00:00:00 2001 From: Yaakov Saxon Date: Thu, 16 Mar 2023 23:17:20 -0400 Subject: [PATCH 06/11] fix accidental revert --- OpenCL/m31400_a3-pure.cl | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/OpenCL/m31400_a3-pure.cl b/OpenCL/m31400_a3-pure.cl index c5a145da0..7f2908556 100644 --- a/OpenCL/m31400_a3-pure.cl +++ b/OpenCL/m31400_a3-pure.cl @@ -153,7 +153,7 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_pw_len = pw_len.s0; - aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, hash.s0, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].s0 = tmp_out[0]; out[1].s0 = tmp_out[1]; @@ -174,7 +174,7 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_pw_len = pw_len.s1; - aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, hash.s1, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].s1 = tmp_out[0]; out[1].s1 = tmp_out[1]; From ec3a940785ef203d726814bf7e193395d782e3c4 Mon Sep 17 00:00:00 2001 From: Yaakov Saxon Date: Fri, 17 Mar 2023 11:27:07 -0400 Subject: [PATCH 07/11] add _S to hc_swap32 in a0,a1 --- OpenCL/m31400_a0-pure.cl | 8 ++++---- OpenCL/m31400_a1-pure.cl | 20 ++++++++++---------- 2 files changed, 14 insertions(+), 14 deletions(-) diff --git a/OpenCL/m31400_a0-pure.cl b/OpenCL/m31400_a0-pure.cl index 47752622e..cd11beb97 100644 --- a/OpenCL/m31400_a0-pure.cl +++ b/OpenCL/m31400_a0-pure.cl @@ -121,10 +121,10 @@ DECLSPEC void aes256_scrt_format (PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32 *pw, co shift_buffer_by_offset(hash,pw_len+4); - hash[0] = hc_swap32(pw_len); - hash[1] |= hc_swap32(pw[0]); - hash[2] |= hc_swap32(pw[1]); - hash[3] |= hc_swap32(pw[2]); + hash[0] = hc_swap32_S(pw_len); + hash[1] |= hc_swap32_S(pw[0]); + hash[2] |= hc_swap32_S(pw[1]); + hash[3] |= hc_swap32_S(pw[2]); AES256_encrypt (aes_ks, hash, out, s_te0, s_te1, s_te2, s_te3, s_te4); } diff --git a/OpenCL/m31400_a1-pure.cl b/OpenCL/m31400_a1-pure.cl index a8c2ca286..04cef3256 100644 --- a/OpenCL/m31400_a1-pure.cl +++ b/OpenCL/m31400_a1-pure.cl @@ -121,10 +121,10 @@ DECLSPEC void aes256_scrt_format (PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32 *pw, co shift_buffer_by_offset(hash,pw_len+4); - hash[0] = hc_swap32(pw_len); - hash[1] |= hc_swap32(pw[0]); - hash[2] |= hc_swap32(pw[1]); - hash[3] |= hc_swap32(pw[2]); + hash[0] = hc_swap32_S(pw_len); + hash[1] |= hc_swap32_S(pw[0]); + hash[2] |= hc_swap32_S(pw[1]); + hash[3] |= hc_swap32_S(pw[2]); AES256_encrypt (aes_ks, hash, out, s_te0, s_te1, s_te2, s_te3, s_te4); } @@ -197,9 +197,9 @@ KERNEL_FQ void m31400_mxx (KERN_ATTR_BASIC ()) sha256_update_global_swap (&ctx, combs_buf[il_pos].i, combs_buf[il_pos].pw_len); u32 pw_candidate[3]; - pw_candidate[0]= hc_swap32(ctx.w0[0]); - pw_candidate[1]= hc_swap32(ctx.w0[1]); - pw_candidate[2]= hc_swap32(ctx.w0[2]); + pw_candidate[0]= hc_swap32_S(ctx.w0[0]); + pw_candidate[1]= hc_swap32_S(ctx.w0[1]); + pw_candidate[2]= hc_swap32_S(ctx.w0[2]); u32 pw_len=ctx.len; sha256_final (&ctx); @@ -297,9 +297,9 @@ KERNEL_FQ void m31400_sxx (KERN_ATTR_BASIC ()) sha256_update_global_swap (&ctx, combs_buf[il_pos].i, combs_buf[il_pos].pw_len); u32 pw_candidate[3]; - pw_candidate[0]=hc_swap32(ctx.w0[0]); - pw_candidate[1]=hc_swap32(ctx.w0[1]); - pw_candidate[2]=hc_swap32(ctx.w0[2]); + pw_candidate[0]=hc_swap32_S(ctx.w0[0]); + pw_candidate[1]=hc_swap32_S(ctx.w0[1]); + pw_candidate[2]=hc_swap32_S(ctx.w0[2]); u32 pw_len=ctx.len; sha256_final (&ctx); From 4805680616da5e9037155b57fb77772bd5d9e032 Mon Sep 17 00:00:00 2001 From: Yaakov Saxon Date: Fri, 17 Mar 2023 11:36:37 -0400 Subject: [PATCH 08/11] remove tmp_pw --- OpenCL/m31400_a3-pure.cl | 82 +++++++++++++++------------------------- 1 file changed, 31 insertions(+), 51 deletions(-) diff --git a/OpenCL/m31400_a3-pure.cl b/OpenCL/m31400_a3-pure.cl index 7f2908556..21afa2aa5 100644 --- a/OpenCL/m31400_a3-pure.cl +++ b/OpenCL/m31400_a3-pure.cl @@ -116,15 +116,15 @@ DECLSPEC void shift_buffer_by_offset(PRIVATE_AS u32 *w0, const u32 offset) DECLSPEC void aes256_scrt_format(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32 *pw, PRIVATE_AS u32 pw_len, PRIVATE_AS u32 *hash, PRIVATE_AS u32 *out, SHM_TYPE u32 *s_te0, SHM_TYPE u32 *s_te1, SHM_TYPE u32 *s_te2, SHM_TYPE u32 *s_te3, SHM_TYPE u32 *s_te4) { - AES256_set_encrypt_key(aes_ks, hash, s_te0, s_te1, s_te2, s_te3); + AES256_set_encrypt_key(aes_ks, hash, s_te0, s_te1, s_te2, s_te3); shift_buffer_by_offset(hash, pw_len + 4); - hash[0] = hc_swap32_S(pw_len); - hash[1] |= hc_swap32_S(pw[0]); - hash[2] |= hc_swap32_S(pw[1]); - hash[3] |= hc_swap32_S(pw[2]); - + hash[0] = hc_swap32_S(pw_len); + hash[1] |= hc_swap32_S(pw[0]); + hash[2] |= hc_swap32_S(pw[1]); + hash[3] |= hc_swap32_S(pw[2]); + AES256_encrypt(aes_ks, hash, out, s_te0, s_te1, s_te2, s_te3, s_te4); } DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, PRIVATE_AS u32x pw_len, PRIVATE_AS u32x *hash, PRIVATE_AS u32x *out, SHM_TYPE u32 *s_te0, SHM_TYPE u32 *s_te1, SHM_TYPE u32 *s_te2, SHM_TYPE u32 *s_te3, SHM_TYPE u32 *s_te4) @@ -138,7 +138,6 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, u32 tmp_w[4]; u32 tmp_hash[4]; u32 tmp_out[4]; - u32 tmp_pw_len; //s0 tmp_w[0] = w[0].s0; @@ -151,9 +150,8 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_hash[2] = hash[2].s0; tmp_hash[3] = hash[3].s0; - tmp_pw_len = pw_len.s0; - - aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + + aes256_scrt_format(aes_ks, tmp_w, pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].s0 = tmp_out[0]; out[1].s0 = tmp_out[1]; @@ -172,9 +170,8 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_hash[2] = hash[2].s1; tmp_hash[3] = hash[3].s1; - tmp_pw_len = pw_len.s1; - - aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + + aes256_scrt_format(aes_ks, tmp_w, pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].s1 = tmp_out[0]; out[1].s1 = tmp_out[1]; @@ -196,9 +193,8 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_hash[2] = hash[2].s2; tmp_hash[3] = hash[3].s2; - tmp_pw_len = pw_len.s2; - aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + aes256_scrt_format(aes_ks, tmp_w, pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].s2 = tmp_out[0]; out[1].s2 = tmp_out[1]; @@ -217,9 +213,7 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_hash[2] = hash[2].s3; tmp_hash[3] = hash[3].s3; - tmp_pw_len = pw_len.s3; - - aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + aes256_scrt_format(aes_ks, tmp_w, pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].s3 = tmp_out[0]; out[1].s3 = tmp_out[1]; @@ -241,9 +235,8 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_hash[2] = hash[2].s4; tmp_hash[3] = hash[3].s4; - tmp_pw_len = pw_len.s4; - - aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + + aes256_scrt_format(aes_ks, tmp_w, pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].s4 = tmp_out[0]; out[1].s4 = tmp_out[1]; @@ -262,9 +255,7 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_hash[2] = hash[2].s5; tmp_hash[3] = hash[3].s5; - tmp_pw_len = pw_len.s5; - - aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + aes256_scrt_format(aes_ks, tmp_w, pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].s5 = tmp_out[0]; out[1].s5 = tmp_out[1]; @@ -283,9 +274,8 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_hash[2] = hash[2].s6; tmp_hash[3] = hash[3].s6; - tmp_pw_len = pw_len.s6; - - aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + + aes256_scrt_format(aes_ks, tmp_w, pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].s6 = tmp_out[0]; out[1].s6 = tmp_out[1]; @@ -304,9 +294,7 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_hash[2] = hash[2].s7; tmp_hash[3] = hash[3].s7; - tmp_pw_len = pw_len.s7; - - aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + aes256_scrt_format(aes_ks, tmp_w, pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].s7 = tmp_out[0]; out[1].s7 = tmp_out[1]; @@ -328,9 +316,8 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_hash[2] = hash[2].s8; tmp_hash[3] = hash[3].s8; - tmp_pw_len = pw_len.s8; - - aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + + aes256_scrt_format(aes_ks, tmp_w, pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].s8 = tmp_out[0]; out[1].s8 = tmp_out[1]; @@ -350,9 +337,8 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_hash[2] = hash[2].s9; tmp_hash[3] = hash[3].s9; - tmp_pw_len = pw_len.s9; - - aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + + aes256_scrt_format(aes_ks, tmp_w, pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].s9 = tmp_out[0]; out[1].s9 = tmp_out[1]; @@ -372,9 +358,8 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_hash[2] = hash[2].sa; tmp_hash[3] = hash[3].sa; - tmp_pw_len = pw_len.sa; - - aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + + aes256_scrt_format(aes_ks, tmp_w, pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].sa = tmp_out[0]; out[1].sa = tmp_out[1]; @@ -394,9 +379,8 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_hash[2] = hash[2].sb; tmp_hash[3] = hash[3].sb; - tmp_pw_len = pw_len.sb; - - aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + + aes256_scrt_format(aes_ks, tmp_w, pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].sb = tmp_out[0]; out[1].sb = tmp_out[1]; @@ -416,9 +400,8 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_hash[2] = hash[2].sc; tmp_hash[3] = hash[3].sc; - tmp_pw_len = pw_len.sc; - - aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + + aes256_scrt_format(aes_ks, tmp_w, pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].sc = tmp_out[0]; out[1].sc = tmp_out[1]; @@ -438,9 +421,8 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_hash[2] = hash[2].sd; tmp_hash[3] = hash[3].sd; - tmp_pw_len = pw_len.sd; - aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + aes256_scrt_format(aes_ks, tmp_w, pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].sd = tmp_out[0]; out[1].sd = tmp_out[1]; @@ -459,9 +441,8 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_hash[3] = hash[3].se; - tmp_pw_len = pw_len.se; - aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + aes256_scrt_format(aes_ks, tmp_w, pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].se = tmp_out[0]; out[1].se = tmp_out[1]; @@ -481,9 +462,8 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_hash[2] = hash[2].sf; tmp_hash[3] = hash[3].sf; - tmp_pw_len = pw_len.sf; - aes256_scrt_format(aes_ks, tmp_w, tmp_pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); + aes256_scrt_format(aes_ks, tmp_w, pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].sf = tmp_out[0]; out[1].sf = tmp_out[1]; From e33e6b0ac0db7fb93797dc4f03fe6b10cafd7b72 Mon Sep 17 00:00:00 2001 From: Yaakov Saxon Date: Fri, 17 Mar 2023 11:37:51 -0400 Subject: [PATCH 09/11] make pw_len a const u32 --- OpenCL/m31400_a3-pure.cl | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/OpenCL/m31400_a3-pure.cl b/OpenCL/m31400_a3-pure.cl index 21afa2aa5..e4fe07dd0 100644 --- a/OpenCL/m31400_a3-pure.cl +++ b/OpenCL/m31400_a3-pure.cl @@ -114,7 +114,7 @@ DECLSPEC void shift_buffer_by_offset(PRIVATE_AS u32 *w0, const u32 offset) #endif } -DECLSPEC void aes256_scrt_format(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32 *pw, PRIVATE_AS u32 pw_len, PRIVATE_AS u32 *hash, PRIVATE_AS u32 *out, SHM_TYPE u32 *s_te0, SHM_TYPE u32 *s_te1, SHM_TYPE u32 *s_te2, SHM_TYPE u32 *s_te3, SHM_TYPE u32 *s_te4) +DECLSPEC void aes256_scrt_format (PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32 *pw, const u32 pw_len, PRIVATE_AS u32 *hash, PRIVATE_AS u32 *out, SHM_TYPE u32 *s_te0, SHM_TYPE u32 *s_te1, SHM_TYPE u32 *s_te2, SHM_TYPE u32 *s_te3, SHM_TYPE u32 *s_te4) { AES256_set_encrypt_key(aes_ks, hash, s_te0, s_te1, s_te2, s_te3); @@ -127,7 +127,7 @@ DECLSPEC void aes256_scrt_format(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32 *pw, PRI AES256_encrypt(aes_ks, hash, out, s_te0, s_te1, s_te2, s_te3, s_te4); } -DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, PRIVATE_AS u32x pw_len, PRIVATE_AS u32x *hash, PRIVATE_AS u32x *out, SHM_TYPE u32 *s_te0, SHM_TYPE u32 *s_te1, SHM_TYPE u32 *s_te2, SHM_TYPE u32 *s_te3, SHM_TYPE u32 *s_te4) +DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, const u32 pw_len, PRIVATE_AS u32x *hash, PRIVATE_AS u32x *out, SHM_TYPE u32 *s_te0, SHM_TYPE u32 *s_te1, SHM_TYPE u32 *s_te2, SHM_TYPE u32 *s_te3, SHM_TYPE u32 *s_te4) { #if VECT_SIZE == 1 aes256_scrt_format(aes_ks, w, pw_len, hash, out, s_te0, s_te1, s_te2, s_te3, s_te4); From 507bba4554795299bd3828c10d3bb6e1021abc66 Mon Sep 17 00:00:00 2001 From: Yaakov Saxon Date: Fri, 17 Mar 2023 11:38:48 -0400 Subject: [PATCH 10/11] (minor) improve line spacing --- OpenCL/m31400_a3-pure.cl | 24 ++++-------------------- 1 file changed, 4 insertions(+), 20 deletions(-) diff --git a/OpenCL/m31400_a3-pure.cl b/OpenCL/m31400_a3-pure.cl index e4fe07dd0..477473766 100644 --- a/OpenCL/m31400_a3-pure.cl +++ b/OpenCL/m31400_a3-pure.cl @@ -127,6 +127,7 @@ DECLSPEC void aes256_scrt_format (PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32 *pw, co AES256_encrypt(aes_ks, hash, out, s_te0, s_te1, s_te2, s_te3, s_te4); } + DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, const u32 pw_len, PRIVATE_AS u32x *hash, PRIVATE_AS u32x *out, SHM_TYPE u32 *s_te0, SHM_TYPE u32 *s_te1, SHM_TYPE u32 *s_te2, SHM_TYPE u32 *s_te3, SHM_TYPE u32 *s_te4) { #if VECT_SIZE == 1 @@ -193,7 +194,6 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_hash[2] = hash[2].s2; tmp_hash[3] = hash[3].s2; - aes256_scrt_format(aes_ks, tmp_w, pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].s2 = tmp_out[0]; @@ -212,7 +212,7 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_hash[1] = hash[1].s3; tmp_hash[2] = hash[2].s3; tmp_hash[3] = hash[3].s3; - + aes256_scrt_format(aes_ks, tmp_w, pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].s3 = tmp_out[0]; @@ -243,7 +243,6 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, out[2].s4 = tmp_out[2]; out[3].s4 = tmp_out[3]; - //s5 tmp_w[0] = w[0].s5; tmp_w[1] = w[1].s5; @@ -254,7 +253,7 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_hash[1] = hash[1].s5; tmp_hash[2] = hash[2].s5; tmp_hash[3] = hash[3].s5; - + aes256_scrt_format(aes_ks, tmp_w, pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].s5 = tmp_out[0]; @@ -273,7 +272,6 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_hash[1] = hash[1].s6; tmp_hash[2] = hash[2].s6; tmp_hash[3] = hash[3].s6; - aes256_scrt_format(aes_ks, tmp_w, pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); @@ -293,7 +291,7 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_hash[1] = hash[1].s7; tmp_hash[2] = hash[2].s7; tmp_hash[3] = hash[3].s7; - + aes256_scrt_format(aes_ks, tmp_w, pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].s7 = tmp_out[0]; @@ -316,7 +314,6 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_hash[2] = hash[2].s8; tmp_hash[3] = hash[3].s8; - aes256_scrt_format(aes_ks, tmp_w, pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].s8 = tmp_out[0]; @@ -331,12 +328,10 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_w[2] = w[2].s9; tmp_w[3] = w[3].s9; - tmp_hash[0] = hash[0].s9; tmp_hash[1] = hash[1].s9; tmp_hash[2] = hash[2].s9; tmp_hash[3] = hash[3].s9; - aes256_scrt_format(aes_ks, tmp_w, pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); @@ -352,7 +347,6 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_w[2] = w[2].sa; tmp_w[3] = w[3].sa; - tmp_hash[0] = hash[0].sa; tmp_hash[1] = hash[1].sa; tmp_hash[2] = hash[2].sa; @@ -373,13 +367,11 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_w[2] = w[2].sb; tmp_w[3] = w[3].sb; - tmp_hash[0] = hash[0].sb; tmp_hash[1] = hash[1].sb; tmp_hash[2] = hash[2].sb; tmp_hash[3] = hash[3].sb; - aes256_scrt_format(aes_ks, tmp_w, pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].sb = tmp_out[0]; @@ -394,13 +386,11 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_w[2] = w[2].sc; tmp_w[3] = w[3].sc; - tmp_hash[0] = hash[0].sc; tmp_hash[1] = hash[1].sc; tmp_hash[2] = hash[2].sc; tmp_hash[3] = hash[3].sc; - aes256_scrt_format(aes_ks, tmp_w, pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].sc = tmp_out[0]; @@ -415,13 +405,11 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_w[2] = w[2].sd; tmp_w[3] = w[3].sd; - tmp_hash[0] = hash[0].sd; tmp_hash[1] = hash[1].sd; tmp_hash[2] = hash[2].sd; tmp_hash[3] = hash[3].sd; - aes256_scrt_format(aes_ks, tmp_w, pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].sd = tmp_out[0]; @@ -440,8 +428,6 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_hash[2] = hash[2].se; tmp_hash[3] = hash[3].se; - - aes256_scrt_format(aes_ks, tmp_w, pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].se = tmp_out[0]; @@ -456,13 +442,11 @@ DECLSPEC void aes256_scrt_format_VV(PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32x *w, tmp_w[2] = w[2].sf; tmp_w[3] = w[3].sf; - tmp_hash[0] = hash[0].sf; tmp_hash[1] = hash[1].sf; tmp_hash[2] = hash[2].sf; tmp_hash[3] = hash[3].sf; - aes256_scrt_format(aes_ks, tmp_w, pw_len, tmp_hash, tmp_out, s_te0, s_te1, s_te2, s_te3, s_te4); out[0].sf = tmp_out[0]; From d92acb20cfe21e67d6c48d6233a2e30b4881471b Mon Sep 17 00:00:00 2001 From: Yaakov Saxon Date: Fri, 17 Mar 2023 11:42:08 -0400 Subject: [PATCH 11/11] more minor formatting --- OpenCL/m31400_a3-pure.cl | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/OpenCL/m31400_a3-pure.cl b/OpenCL/m31400_a3-pure.cl index 477473766..ce35acda2 100644 --- a/OpenCL/m31400_a3-pure.cl +++ b/OpenCL/m31400_a3-pure.cl @@ -116,14 +116,14 @@ DECLSPEC void shift_buffer_by_offset(PRIVATE_AS u32 *w0, const u32 offset) DECLSPEC void aes256_scrt_format (PRIVATE_AS u32 *aes_ks, PRIVATE_AS u32 *pw, const u32 pw_len, PRIVATE_AS u32 *hash, PRIVATE_AS u32 *out, SHM_TYPE u32 *s_te0, SHM_TYPE u32 *s_te1, SHM_TYPE u32 *s_te2, SHM_TYPE u32 *s_te3, SHM_TYPE u32 *s_te4) { - AES256_set_encrypt_key(aes_ks, hash, s_te0, s_te1, s_te2, s_te3); + AES256_set_encrypt_key(aes_ks, hash, s_te0, s_te1, s_te2, s_te3); shift_buffer_by_offset(hash, pw_len + 4); - hash[0] = hc_swap32_S(pw_len); - hash[1] |= hc_swap32_S(pw[0]); - hash[2] |= hc_swap32_S(pw[1]); - hash[3] |= hc_swap32_S(pw[2]); + hash[0] = hc_swap32_S(pw_len); + hash[1] |= hc_swap32_S(pw[0]); + hash[2] |= hc_swap32_S(pw[1]); + hash[3] |= hc_swap32_S(pw[2]); AES256_encrypt(aes_ks, hash, out, s_te0, s_te1, s_te2, s_te3, s_te4); }