From 50aeaa299dd14bdf5c14a2111c9ffd5ccb7342e9 Mon Sep 17 00:00:00 2001 From: Gabriele Gristina Date: Wed, 14 Jul 2021 19:31:21 +0200 Subject: [PATCH 1/6] Added hash-mode: VMware VMX (PBKDF2-HMAC-SHA1 + AES-256-CBC) --- OpenCL/m26700-pure.cl | 351 +++++++++++++++++++++++++++++++++++ docs/changes.txt | 1 + docs/readme.txt | 1 + src/modules/module_26700.c | 270 +++++++++++++++++++++++++++ tools/test_modules/m26700.pm | 104 +++++++++++ tools/vmwarevmx2hashcat.py | 79 ++++++++ 6 files changed, 806 insertions(+) create mode 100644 OpenCL/m26700-pure.cl create mode 100644 src/modules/module_26700.c create mode 100644 tools/test_modules/m26700.pm create mode 100644 tools/vmwarevmx2hashcat.py diff --git a/OpenCL/m26700-pure.cl b/OpenCL/m26700-pure.cl new file mode 100644 index 000000000..ff7722961 --- /dev/null +++ b/OpenCL/m26700-pure.cl @@ -0,0 +1,351 @@ +/** + * Author......: See docs/credits.txt + * License.....: MIT + */ + +#define NEW_SIMD_CODE + +#ifdef KERNEL_STATIC +#include "inc_vendor.h" +#include "inc_types.h" +#include "inc_platform.cl" +#include "inc_common.cl" +#include "inc_simd.cl" +#include "inc_hash_sha1.cl" +#include "inc_cipher_aes.cl" +#endif + +#define COMPARE_S "inc_comp_single.cl" +#define COMPARE_M "inc_comp_multi.cl" + +typedef struct pbkdf2_sha1_tmp +{ + u32 ipad[5]; + u32 opad[5]; + + u32 dgst[32]; + u32 out[32]; + +} pbkdf2_sha1_tmp_t; + +typedef struct pbkdf2_sha1 +{ + u32 salt_buf[64]; + u32 iv_buf[4]; + u32 ct_buf[4]; + +} pbkdf2_sha1_t; + +DECLSPEC void hmac_sha1_run_V (u32x *w0, u32x *w1, u32x *w2, u32x *w3, u32x *ipad, u32x *opad, u32x *digest) +{ + digest[0] = ipad[0]; + digest[1] = ipad[1]; + digest[2] = ipad[2]; + digest[3] = ipad[3]; + digest[4] = ipad[4]; + + sha1_transform_vector (w0, w1, w2, w3, digest); + + w0[0] = digest[0]; + w0[1] = digest[1]; + w0[2] = digest[2]; + w0[3] = digest[3]; + w1[0] = digest[4]; + w1[1] = 0x80000000; + w1[2] = 0; + w1[3] = 0; + w2[0] = 0; + w2[1] = 0; + w2[2] = 0; + w2[3] = 0; + w3[0] = 0; + w3[1] = 0; + w3[2] = 0; + w3[3] = (64 + 20) * 8; + + digest[0] = opad[0]; + digest[1] = opad[1]; + digest[2] = opad[2]; + digest[3] = opad[3]; + digest[4] = opad[4]; + + sha1_transform_vector (w0, w1, w2, w3, digest); +} + +KERNEL_FQ void m26700_init (KERN_ATTR_TMPS_ESALT (pbkdf2_sha1_tmp_t, pbkdf2_sha1_t)) +{ + /** + * base + */ + + const u64 gid = get_global_id (0); + + if (gid >= gid_max) return; + + sha1_hmac_ctx_t sha1_hmac_ctx; + + sha1_hmac_init_global_swap (&sha1_hmac_ctx, pws[gid].i, pws[gid].pw_len); + + tmps[gid].ipad[0] = sha1_hmac_ctx.ipad.h[0]; + tmps[gid].ipad[1] = sha1_hmac_ctx.ipad.h[1]; + tmps[gid].ipad[2] = sha1_hmac_ctx.ipad.h[2]; + tmps[gid].ipad[3] = sha1_hmac_ctx.ipad.h[3]; + tmps[gid].ipad[4] = sha1_hmac_ctx.ipad.h[4]; + + tmps[gid].opad[0] = sha1_hmac_ctx.opad.h[0]; + tmps[gid].opad[1] = sha1_hmac_ctx.opad.h[1]; + tmps[gid].opad[2] = sha1_hmac_ctx.opad.h[2]; + tmps[gid].opad[3] = sha1_hmac_ctx.opad.h[3]; + tmps[gid].opad[4] = sha1_hmac_ctx.opad.h[4]; + + sha1_hmac_update_global_swap (&sha1_hmac_ctx, esalt_bufs[DIGESTS_OFFSET].salt_buf, salt_bufs[SALT_POS].salt_len); + + for (u32 i = 0, j = 1; i < 8; i += 5, j += 1) + { + sha1_hmac_ctx_t sha1_hmac_ctx2 = sha1_hmac_ctx; + + u32 w0[4]; + u32 w1[4]; + u32 w2[4]; + u32 w3[4]; + + w0[0] = j; + w0[1] = 0; + w0[2] = 0; + w0[3] = 0; + w1[0] = 0; + w1[1] = 0; + w1[2] = 0; + w1[3] = 0; + w2[0] = 0; + w2[1] = 0; + w2[2] = 0; + w2[3] = 0; + w3[0] = 0; + w3[1] = 0; + w3[2] = 0; + w3[3] = 0; + + sha1_hmac_update_64 (&sha1_hmac_ctx2, w0, w1, w2, w3, 4); + + sha1_hmac_final (&sha1_hmac_ctx2); + + tmps[gid].dgst[i + 0] = sha1_hmac_ctx2.opad.h[0]; + tmps[gid].dgst[i + 1] = sha1_hmac_ctx2.opad.h[1]; + tmps[gid].dgst[i + 2] = sha1_hmac_ctx2.opad.h[2]; + tmps[gid].dgst[i + 3] = sha1_hmac_ctx2.opad.h[3]; + tmps[gid].dgst[i + 4] = sha1_hmac_ctx2.opad.h[4]; + + tmps[gid].out[i + 0] = tmps[gid].dgst[i + 0]; + tmps[gid].out[i + 1] = tmps[gid].dgst[i + 1]; + tmps[gid].out[i + 2] = tmps[gid].dgst[i + 2]; + tmps[gid].out[i + 3] = tmps[gid].dgst[i + 3]; + tmps[gid].out[i + 4] = tmps[gid].dgst[i + 4]; + } +} + +KERNEL_FQ void m26700_loop (KERN_ATTR_TMPS_ESALT (pbkdf2_sha1_tmp_t, pbkdf2_sha1_t)) +{ + const u64 gid = get_global_id (0); + + if ((gid * VECT_SIZE) >= gid_max) return; + + u32x ipad[5]; + u32x opad[5]; + + ipad[0] = packv (tmps, ipad, gid, 0); + ipad[1] = packv (tmps, ipad, gid, 1); + ipad[2] = packv (tmps, ipad, gid, 2); + ipad[3] = packv (tmps, ipad, gid, 3); + ipad[4] = packv (tmps, ipad, gid, 4); + + opad[0] = packv (tmps, opad, gid, 0); + opad[1] = packv (tmps, opad, gid, 1); + opad[2] = packv (tmps, opad, gid, 2); + opad[3] = packv (tmps, opad, gid, 3); + opad[4] = packv (tmps, opad, gid, 4); + + for (u32 i = 0; i < 8; i += 5) + { + u32x dgst[5]; + u32x out[5]; + + dgst[0] = packv (tmps, dgst, gid, i + 0); + dgst[1] = packv (tmps, dgst, gid, i + 1); + dgst[2] = packv (tmps, dgst, gid, i + 2); + dgst[3] = packv (tmps, dgst, gid, i + 3); + dgst[4] = packv (tmps, dgst, gid, i + 4); + + out[0] = packv (tmps, out, gid, i + 0); + out[1] = packv (tmps, out, gid, i + 1); + out[2] = packv (tmps, out, gid, i + 2); + out[3] = packv (tmps, out, gid, i + 3); + out[4] = packv (tmps, out, gid, i + 4); + + for (u32 j = 0; j < loop_cnt; j++) + { + u32x w0[4]; + u32x w1[4]; + u32x w2[4]; + u32x w3[4]; + + w0[0] = dgst[0]; + w0[1] = dgst[1]; + w0[2] = dgst[2]; + w0[3] = dgst[3]; + w1[0] = dgst[4]; + w1[1] = 0x80000000; + w1[2] = 0; + w1[3] = 0; + w2[0] = 0; + w2[1] = 0; + w2[2] = 0; + w2[3] = 0; + w3[0] = 0; + w3[1] = 0; + w3[2] = 0; + w3[3] = (64 + 20) * 8; + + hmac_sha1_run_V (w0, w1, w2, w3, ipad, opad, dgst); + + out[0] ^= dgst[0]; + out[1] ^= dgst[1]; + out[2] ^= dgst[2]; + out[3] ^= dgst[3]; + out[4] ^= dgst[4]; + } + + unpackv (tmps, dgst, gid, i + 0, dgst[0]); + unpackv (tmps, dgst, gid, i + 1, dgst[1]); + unpackv (tmps, dgst, gid, i + 2, dgst[2]); + unpackv (tmps, dgst, gid, i + 3, dgst[3]); + unpackv (tmps, dgst, gid, i + 4, dgst[4]); + + unpackv (tmps, out, gid, i + 0, out[0]); + unpackv (tmps, out, gid, i + 1, out[1]); + unpackv (tmps, out, gid, i + 2, out[2]); + unpackv (tmps, out, gid, i + 3, out[3]); + unpackv (tmps, out, gid, i + 4, out[4]); + } +} + +KERNEL_FQ void m26700_comp (KERN_ATTR_TMPS_ESALT (pbkdf2_sha1_tmp_t, pbkdf2_sha1_t)) +{ + /** + * base + */ + + const u64 gid = get_global_id (0); + const u64 lid = get_local_id(0); + const u64 lsz = get_local_size(0); + + /** + * aes shared + */ + + #ifdef REAL_SHM + + LOCAL_VK u32 s_td0[256]; + LOCAL_VK u32 s_td1[256]; + LOCAL_VK u32 s_td2[256]; + LOCAL_VK u32 s_td3[256]; + LOCAL_VK u32 s_td4[256]; + + 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_td0[i] = td0[i]; + s_td1[i] = td1[i]; + s_td2[i] = td2[i]; + s_td3[i] = td3[i]; + s_td4[i] = td4[i]; + + 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_td0 = td0; + CONSTANT_AS u32a* s_td1 = td1; + CONSTANT_AS u32a* s_td2 = td2; + CONSTANT_AS u32a* s_td3 = td3; + CONSTANT_AS u32a* s_td4 = td4; + + 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_max) return; + + u32 ukey[8]; + + ukey[0] = tmps[gid].out[0]; + ukey[1] = tmps[gid].out[1]; + ukey[2] = tmps[gid].out[2]; + ukey[3] = tmps[gid].out[3]; + ukey[4] = tmps[gid].out[4]; + ukey[5] = tmps[gid].out[5]; + ukey[6] = tmps[gid].out[6]; + ukey[7] = tmps[gid].out[7]; + + u32 ks[60]; + + AES256_set_decrypt_key (ks, ukey, s_te0, s_te1, s_te2, s_te3, s_td0, s_td1, s_td2, s_td3); + + // iv + + u32 iv_buf[4]; + + iv_buf[0] = esalt_bufs[DIGESTS_OFFSET].iv_buf[0]; + iv_buf[1] = esalt_bufs[DIGESTS_OFFSET].iv_buf[1]; + iv_buf[2] = esalt_bufs[DIGESTS_OFFSET].iv_buf[2]; + iv_buf[3] = esalt_bufs[DIGESTS_OFFSET].iv_buf[3]; + + // ct + + u32 ct_buf[4]; + + ct_buf[0] = esalt_bufs[DIGESTS_OFFSET].ct_buf[0]; + ct_buf[1] = esalt_bufs[DIGESTS_OFFSET].ct_buf[1]; + ct_buf[2] = esalt_bufs[DIGESTS_OFFSET].ct_buf[2]; + ct_buf[3] = esalt_bufs[DIGESTS_OFFSET].ct_buf[3]; + + // decrypt first block + + u32 pt_buf[4]; + + AES256_decrypt (ks, ct_buf, pt_buf, s_td0, s_td1, s_td2, s_td3, s_td4); + + pt_buf[0] ^= iv_buf[0]; + pt_buf[1] ^= iv_buf[1]; + pt_buf[2] ^= iv_buf[2]; + pt_buf[3] ^= iv_buf[3]; + + // check + + const u32 r0 = pt_buf[0]; + const u32 r1 = pt_buf[1]; + const u32 r2 = pt_buf[2]; + const u32 r3 = pt_buf[3]; + + #define il_pos 0 + + #ifdef KERNEL_STATIC + #include COMPARE_M + #endif +} diff --git a/docs/changes.txt b/docs/changes.txt index d9e895e53..89033e686 100644 --- a/docs/changes.txt +++ b/docs/changes.txt @@ -12,6 +12,7 @@ - Added hash-mode: AES-256-ECB NOKDF (PT = $salt, key = $pass) - Added hash-mode: iPhone passcode (UID key + System Keybag) - Added hash-mode: MetaMask Wallet +- Added hash-mode: VMware VMX (PBKDF2-HMAC-SHA1 + AES-256-CBC) ## ## Features diff --git a/docs/readme.txt b/docs/readme.txt index 07605c0cc..d15a33faa 100644 --- a/docs/readme.txt +++ b/docs/readme.txt @@ -389,6 +389,7 @@ NVIDIA GPUs require "NVIDIA Driver" (440.64 or later) and "CUDA Toolkit" (9.0 or - MetaMask Wallet - MultiBit Classic .key (MD5) - MultiBit HD (scrypt) +- VMware VMX (PBKDF2-HMAC-SHA1 + AES-256-CBC) ## ## Attack-Modes diff --git a/src/modules/module_26700.c b/src/modules/module_26700.c new file mode 100644 index 000000000..d38395a89 --- /dev/null +++ b/src/modules/module_26700.c @@ -0,0 +1,270 @@ +/** + * 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_OUTSIDE_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_4; +static const u32 HASH_CATEGORY = HASH_CATEGORY_RAW_CIPHER_KPA; +static const char *HASH_NAME = "VMware VMX (PBKDF2-HMAC-SHA1 + AES-256-CBC)"; +static const u64 KERN_TYPE = 26700; +static const u32 OPTI_TYPE = OPTI_TYPE_ZERO_BYTE + | OPTI_TYPE_SLOW_HASH_SIMD_LOOP; +static const u64 OPTS_TYPE = OPTS_TYPE_PT_GENERATE_LE + | OPTS_TYPE_ST_HEX + | OPTS_TYPE_HASH_COPY; +static const u32 SALT_TYPE = SALT_TYPE_EMBEDDED; +static const char *ST_PASS = "hashcat"; +static const char *ST_HASH = "$vmx$0$10000$264bbab02fdf7c1a793651120bec3723$cbb368564d8dfb99f509d4922f4693413f3816af713f0e76bc2409ff9336935d069b1c0763c06ec30bd340d87849da7db5c946f6c2bbcc2cf47fcd01d704e4711310f2e09189e2b87ada80573cafade6f83c7a27a3ceca9c5722ba7c083b358151247bb9b13fb01ad5a98ec893d8a40cfb8db06c"; + +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 pbkdf2_sha1_tmp +{ + u32 ipad[5]; + u32 opad[5]; + + u32 dgst[32]; + u32 out[32]; + +} pbkdf2_sha1_tmp_t; + +typedef struct pbkdf2_sha1 +{ + u32 salt_buf[64]; + u32 iv_buf[4]; + u32 ct_buf[4]; + +} pbkdf2_sha1_t; + +static const char *SIGNATURE_VMX = "$vmx$0$"; + +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 (pbkdf2_sha1_t); + + return esalt_size; +} + +u64 module_tmp_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 tmp_size = (const u64) sizeof (pbkdf2_sha1_tmp_t); + + return tmp_size; +} + +u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const user_options_t *user_options, MAYBE_UNUSED const user_options_extra_t *user_options_extra) +{ + // this overrides the reductions of PW_MAX in case optimized kernel is selected + // IOW, even in optimized kernel mode it support length 256 + + const u32 pw_max = PW_MAX; + + return pw_max; +} + +int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED void *digest_buf, MAYBE_UNUSED salt_t *salt, MAYBE_UNUSED void *esalt_buf, MAYBE_UNUSED void *hook_salt_buf, MAYBE_UNUSED hashinfo_t *hash_info, const char *line_buf, MAYBE_UNUSED const int line_len) +{ + u32 *digest = (u32 *) digest_buf; + + pbkdf2_sha1_t *pbkdf2_sha1 = (pbkdf2_sha1_t *) esalt_buf; + + token_t token; + + token.token_cnt = 4; + + token.signatures_cnt = 1; + token.signatures_buf[0] = SIGNATURE_VMX; + + token.sep[0] = '$'; + token.len[0] = 7; + token.attr[0] = TOKEN_ATTR_FIXED_LENGTH + | TOKEN_ATTR_VERIFY_SIGNATURE; + + token.sep[1] = '$'; + token.len_min[1] = 1; + token.len_max[1] = 9; + token.attr[1] = TOKEN_ATTR_VERIFY_LENGTH + | TOKEN_ATTR_VERIFY_DIGIT; + + token.sep[2] = '$'; + token.len_min[2] = 32; + token.len_max[2] = 32; + token.attr[2] = TOKEN_ATTR_VERIFY_LENGTH + | TOKEN_ATTR_VERIFY_HEX; + + token.sep[3] = '$'; + token.len_min[3] = 32; + token.len_max[3] = 512; + token.attr[3] = 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); + + // iter + + const u8 *iter_pos = token.buf[1]; + + const u32 iter = hc_strtoul ((const char *) iter_pos, NULL, 10); + + salt->salt_iter = iter - 1; + + // salt + + u8 *salt_pos = (u8 *) token.buf[2]; + int salt_len = token.len[2]; + + salt->salt_buf[0] = hex_to_u32 (salt_pos + 0); + salt->salt_buf[1] = hex_to_u32 (salt_pos + 8); + salt->salt_buf[2] = hex_to_u32 (salt_pos + 16); + salt->salt_buf[3] = hex_to_u32 (salt_pos + 24); + + salt->salt_len = salt_len / 2; + + pbkdf2_sha1->salt_buf[0] = salt->salt_buf[0]; + pbkdf2_sha1->salt_buf[1] = salt->salt_buf[1]; + pbkdf2_sha1->salt_buf[2] = salt->salt_buf[2]; + pbkdf2_sha1->salt_buf[3] = salt->salt_buf[3]; + + const u8 *hash_pos = token.buf[3]; + + // iv + + pbkdf2_sha1->iv_buf[0] = hex_to_u32 (hash_pos + 0); + pbkdf2_sha1->iv_buf[1] = hex_to_u32 (hash_pos + 8); + pbkdf2_sha1->iv_buf[2] = hex_to_u32 (hash_pos + 16); + pbkdf2_sha1->iv_buf[3] = hex_to_u32 (hash_pos + 24); + + pbkdf2_sha1->iv_buf[0] = byte_swap_32 (pbkdf2_sha1->iv_buf[0]); + pbkdf2_sha1->iv_buf[1] = byte_swap_32 (pbkdf2_sha1->iv_buf[1]); + pbkdf2_sha1->iv_buf[2] = byte_swap_32 (pbkdf2_sha1->iv_buf[2]); + pbkdf2_sha1->iv_buf[3] = byte_swap_32 (pbkdf2_sha1->iv_buf[3]); + + // ct + + pbkdf2_sha1->ct_buf[0] = hex_to_u32 (hash_pos + 32); + pbkdf2_sha1->ct_buf[1] = hex_to_u32 (hash_pos + 40); + pbkdf2_sha1->ct_buf[2] = hex_to_u32 (hash_pos + 48); + pbkdf2_sha1->ct_buf[3] = hex_to_u32 (hash_pos + 56); + + pbkdf2_sha1->ct_buf[0] = byte_swap_32 (pbkdf2_sha1->ct_buf[0]); + pbkdf2_sha1->ct_buf[1] = byte_swap_32 (pbkdf2_sha1->ct_buf[1]); + pbkdf2_sha1->ct_buf[2] = byte_swap_32 (pbkdf2_sha1->ct_buf[2]); + pbkdf2_sha1->ct_buf[3] = byte_swap_32 (pbkdf2_sha1->ct_buf[3]); + + // known pt => 'type=key:cipher=' + + digest[0] = 0x74797065; + digest[1] = 0x3d6b6579; + digest[2] = 0x3a636970; + digest[3] = 0x6865723d; + + 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) +{ + return snprintf (line_buf, line_size, "%s", hash_info->orighash); +} + +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_salt = MODULE_DEFAULT; + module_ctx->module_build_plain_postprocess = MODULE_DEFAULT; + module_ctx->module_deep_comp_kernel = 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_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_potfile = MODULE_DEFAULT; + module_ctx->module_hash_decode_zero_hash = MODULE_DEFAULT; + module_ctx->module_hash_decode = module_hash_decode; + module_ctx->module_hash_encode_status = MODULE_DEFAULT; + module_ctx->module_hash_encode_potfile = MODULE_DEFAULT; + module_ctx->module_hash_encode = module_hash_encode; + module_ctx->module_hash_init_selftest = MODULE_DEFAULT; + module_ctx->module_hash_mode = MODULE_DEFAULT; + module_ctx->module_hash_category = module_hash_category; + module_ctx->module_hash_name = module_hash_name; + module_ctx->module_hashes_count_min = MODULE_DEFAULT; + module_ctx->module_hashes_count_max = MODULE_DEFAULT; + module_ctx->module_hlfmt_disable = MODULE_DEFAULT; + module_ctx->module_hook_extra_param_size = MODULE_DEFAULT; + module_ctx->module_hook_extra_param_init = MODULE_DEFAULT; + module_ctx->module_hook_extra_param_term = MODULE_DEFAULT; + module_ctx->module_hook12 = MODULE_DEFAULT; + module_ctx->module_hook23 = MODULE_DEFAULT; + module_ctx->module_hook_salt_size = MODULE_DEFAULT; + module_ctx->module_hook_size = MODULE_DEFAULT; + module_ctx->module_jit_build_options = MODULE_DEFAULT; + module_ctx->module_jit_cache_disable = MODULE_DEFAULT; + module_ctx->module_kernel_accel_max = MODULE_DEFAULT; + module_ctx->module_kernel_accel_min = MODULE_DEFAULT; + module_ctx->module_kernel_loops_max = MODULE_DEFAULT; + module_ctx->module_kernel_loops_min = MODULE_DEFAULT; + module_ctx->module_kernel_threads_max = MODULE_DEFAULT; + module_ctx->module_kernel_threads_min = MODULE_DEFAULT; + module_ctx->module_kern_type = module_kern_type; + module_ctx->module_kern_type_dynamic = MODULE_DEFAULT; + module_ctx->module_opti_type = module_opti_type; + module_ctx->module_opts_type = module_opts_type; + module_ctx->module_outfile_check_disable = MODULE_DEFAULT; + module_ctx->module_outfile_check_nocomp = MODULE_DEFAULT; + module_ctx->module_potfile_custom_check = MODULE_DEFAULT; + module_ctx->module_potfile_disable = MODULE_DEFAULT; + module_ctx->module_potfile_keep_all_hashes = MODULE_DEFAULT; + module_ctx->module_pwdump_column = MODULE_DEFAULT; + module_ctx->module_pw_max = module_pw_max; + module_ctx->module_pw_min = MODULE_DEFAULT; + module_ctx->module_salt_max = MODULE_DEFAULT; + module_ctx->module_salt_min = MODULE_DEFAULT; + module_ctx->module_salt_type = module_salt_type; + module_ctx->module_separator = MODULE_DEFAULT; + module_ctx->module_st_hash = module_st_hash; + module_ctx->module_st_pass = module_st_pass; + module_ctx->module_tmp_size = module_tmp_size; + module_ctx->module_unstable_warning = MODULE_DEFAULT; + module_ctx->module_warmup_disable = MODULE_DEFAULT; +} diff --git a/tools/test_modules/m26700.pm b/tools/test_modules/m26700.pm new file mode 100644 index 000000000..908b47243 --- /dev/null +++ b/tools/test_modules/m26700.pm @@ -0,0 +1,104 @@ +#!/usr/bin/env perl + +## +## Author......: See docs/credits.txt +## License.....: MIT +## + +use strict; +use warnings; + +use Crypt::PBKDF2; +use Crypt::CBC; +use Crypt::Mode::CBC; + +sub module_constraints { [[0, 256], [32, 32], [-1, -1], [-1, -1], [-1, -1]] } + +sub module_generate_hash +{ + my $word = shift; + my $salt_str = shift // random_hex_string (32); + my $ct_str = shift; + + my $iv_str = ""; + + if (defined $ct_str) + { + $iv_str = substr($ct_str, 0, 32); + } + else + { + $iv_str = random_hex_string (32); + } + + my $salt = pack ("H*", $salt_str); + + my $iv = pack ("H*", $iv_str); + + my $iterations = 10000; + + my $hasher = Crypt::PBKDF2->hasher_from_algorithm ('HMACSHA1'); + + my $pbkdf2 = Crypt::PBKDF2->new ( + hasher => $hasher, + iterations => $iterations, + output_len => 32 + ); + + my $key = $pbkdf2->PBKDF2 ($salt, $word); + + my $cipher = Crypt::CBC->new ({ + key => $key, + cipher => "Crypt::Rijndael", + iv => $iv, + literal_key => 1, + header => "none", + keysize => 32 + }); + + my $hash = ""; + + if (defined $ct_str) + { + my $ct_bin = pack ("H*", $ct_str); + my $iv_bin = substr ($ct_bin, 0, 16); + my $encrypted = substr ($ct_bin, 16); + + $hash = sprintf ("\$vmx\$0\$%s\$%s\$%s%s", $iterations, unpack ("H*", $salt), unpack ("H*", $iv_bin), unpack ("H*", $encrypted)); + } + else + { + my $data = 'type=key:cipher='; + + my $encrypted = unpack ("H*", $cipher->encrypt ($data)); + + $hash = sprintf ("\$vmx\$0\$%s\$%s\$%s%s", $iterations, unpack ("H*", $salt), unpack ("H*", $iv), $encrypted); + } + + return $hash; +} + +sub module_verify_hash +{ + my $line = shift; + + my ($hash, $word) = split (':', $line); + + return unless defined $hash; + return unless defined $word; + + my (undef, $signature, $version, $rounds, $salt, $ct) = split '\$', $hash; + + return unless ($signature eq "vmx"); + return unless ($version eq 0); + return unless ($rounds eq 10000); + return unless (length $ct lt 32); + + my $word_packed = pack_if_HEX_notation ($word); + + my $new_hash = module_generate_hash ($word_packed, $salt, $ct); + + return ($new_hash, $word); +} + +1; diff --git a/tools/vmwarevmx2hashcat.py b/tools/vmwarevmx2hashcat.py new file mode 100644 index 000000000..388007fc2 --- /dev/null +++ b/tools/vmwarevmx2hashcat.py @@ -0,0 +1,79 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# Based on "pyvmx-cracker" (https://github.com/axcheron/pyvmx-cracker) (MIT license) + +# Author: Gabriele 'matrix' Gristina +# Version: 1.0 +# Date: Tue 13 Jul 2021 01:29:23 PM CEST +# License: MIT + +import argparse +from urllib.parse import unquote +from binascii import hexlify +import re +import base64 + +ks_re = '.+phrase/(.*?)/pass2key=(.*?):cipher=(.*?):rounds=(.*?):salt=(.*?),(.*?),(.*?)\)' + +ks_struct = { + 'password_hash': None, + 'password_cipher': None, + 'hash_round': None, + 'salt': None, + 'dict': None +} + +def parse_keysafe(file): + try: + with open(file, 'r') as data: + lines = data.readlines() + except (OSError, IOError): + sys.exit('[-] Cannot read from file ' + data) + + for line in lines: + if 'encryption.keySafe' in line: + keysafe = line + + keysafe = unquote(keysafe) + + match = re.match(ks_re, keysafe) + if not match: + msg = 'Unsupported format of the encryption.keySafe line:\n' + keysafe + raise ValueError(msg) + + vmx_ks = ks_struct + +# vmx_ks['id'] = hexlify(base64.b64decode(match.group(1))).decode() + vmx_ks['password_hash'] = match.group(2) + if vmx_ks['password_hash'] != 'PBKDF2-HMAC-SHA-1': + msg = 'Unsupported password hash format: ' + vmx_ks['password_hash'] + raise ValueError(msg) + + vmx_ks['password_cipher'] = match.group(3) + if vmx_ks['password_cipher'] != 'AES-256': + msg = 'Unsupported cypher format: ' + vmx_ks['password_cypher'] + raise ValueError(msg) + + + vmx_ks['hash_round'] = int(match.group(4)) + vmx_ks['salt'] = base64.b64decode(unquote(match.group(5))) +# vmx_ks['config_hash'] = match.group(6) + vmx_ks['dict'] = base64.b64decode(match.group(7)) + + return vmx_ks + +def pyvmx(vmx): + keysafe = parse_keysafe(vmx) + print("$vmx$0$" + str(keysafe['hash_round']) + "$" + hexlify(keysafe['salt']).decode() + "$" + hexlify(keysafe['dict']).decode()) + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description="vmwarevmx2hashcat extraction tool") + parser.add_argument('--vmx', required=True, help='set vmware vmx file from path', type=str) + + args = parser.parse_args() + if args.vmx: + pyvmx(args.vmx) + else: + parser.print_help() + exit(1) From eaedfb3f8a24b02680726b063d1f98767b4f5e56 Mon Sep 17 00:00:00 2001 From: Gabriele Gristina Date: Thu, 15 Jul 2021 19:58:11 +0200 Subject: [PATCH 2/6] fix 26700 --- docs/readme.txt | 2 +- src/modules/module_26700.c | 101 +++++++++++++++++++++++------------ tools/test_modules/m26700.pm | 7 ++- tools/vmwarevmx2hashcat.py | 5 +- 4 files changed, 73 insertions(+), 42 deletions(-) diff --git a/docs/readme.txt b/docs/readme.txt index d15a33faa..36314135a 100644 --- a/docs/readme.txt +++ b/docs/readme.txt @@ -265,6 +265,7 @@ NVIDIA GPUs require "NVIDIA Driver" (440.64 or later) and "CUDA Toolkit" (9.0 or - Huawei sha1(md5($pass).$salt) - AuthMe sha256 - AES Crypt (SHA256) +- VMware VMX (PBKDF2-HMAC-SHA1 + AES-256-CBC) - LUKS - VeraCrypt - BestCrypt v3 Volume Encryption @@ -389,7 +390,6 @@ NVIDIA GPUs require "NVIDIA Driver" (440.64 or later) and "CUDA Toolkit" (9.0 or - MetaMask Wallet - MultiBit Classic .key (MD5) - MultiBit HD (scrypt) -- VMware VMX (PBKDF2-HMAC-SHA1 + AES-256-CBC) ## ## Attack-Modes diff --git a/src/modules/module_26700.c b/src/modules/module_26700.c index d38395a89..86779625f 100644 --- a/src/modules/module_26700.c +++ b/src/modules/module_26700.c @@ -16,17 +16,16 @@ static const u32 DGST_POS1 = 1; static const u32 DGST_POS2 = 2; static const u32 DGST_POS3 = 3; static const u32 DGST_SIZE = DGST_SIZE_4_4; -static const u32 HASH_CATEGORY = HASH_CATEGORY_RAW_CIPHER_KPA; +static const u32 HASH_CATEGORY = HASH_CATEGORY_FDE; static const char *HASH_NAME = "VMware VMX (PBKDF2-HMAC-SHA1 + AES-256-CBC)"; static const u64 KERN_TYPE = 26700; static const u32 OPTI_TYPE = OPTI_TYPE_ZERO_BYTE | OPTI_TYPE_SLOW_HASH_SIMD_LOOP; static const u64 OPTS_TYPE = OPTS_TYPE_PT_GENERATE_LE - | OPTS_TYPE_ST_HEX - | OPTS_TYPE_HASH_COPY; + | OPTS_TYPE_ST_HEX; static const u32 SALT_TYPE = SALT_TYPE_EMBEDDED; static const char *ST_PASS = "hashcat"; -static const char *ST_HASH = "$vmx$0$10000$264bbab02fdf7c1a793651120bec3723$cbb368564d8dfb99f509d4922f4693413f3816af713f0e76bc2409ff9336935d069b1c0763c06ec30bd340d87849da7db5c946f6c2bbcc2cf47fcd01d704e4711310f2e09189e2b87ada80573cafade6f83c7a27a3ceca9c5722ba7c083b358151247bb9b13fb01ad5a98ec893d8a40cfb8db06c"; +static const char *ST_HASH = "$vmx$0$10000$264bbab02fdf7c1a793651120bec3723$cbb368564d8dfb99f509d4922f4693413f3816af713f0e76bc2409ff9336935d"; 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; } @@ -53,19 +52,19 @@ typedef struct pbkdf2_sha1_tmp } pbkdf2_sha1_tmp_t; -typedef struct pbkdf2_sha1 +typedef struct vmware_vmx { u32 salt_buf[64]; u32 iv_buf[4]; u32 ct_buf[4]; -} pbkdf2_sha1_t; +} vmware_vmx_t; -static const char *SIGNATURE_VMX = "$vmx$0$"; +static const char *SIGNATURE_VMWARE_VMX = "$vmx$0$"; 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 (pbkdf2_sha1_t); + const u64 esalt_size = (const u64) sizeof (vmware_vmx_t); return esalt_size; } @@ -91,14 +90,14 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE { u32 *digest = (u32 *) digest_buf; - pbkdf2_sha1_t *pbkdf2_sha1 = (pbkdf2_sha1_t *) esalt_buf; + vmware_vmx_t *vmware_vmx = (vmware_vmx_t *) esalt_buf; token_t token; token.token_cnt = 4; token.signatures_cnt = 1; - token.signatures_buf[0] = SIGNATURE_VMX; + token.signatures_buf[0] = SIGNATURE_VMWARE_VMX; token.sep[0] = '$'; token.len[0] = 7; @@ -118,8 +117,8 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE | TOKEN_ATTR_VERIFY_HEX; token.sep[3] = '$'; - token.len_min[3] = 32; - token.len_max[3] = 512; + token.len_min[3] = 64; + token.len_max[3] = 64; token.attr[3] = TOKEN_ATTR_VERIFY_LENGTH | TOKEN_ATTR_VERIFY_HEX; @@ -147,36 +146,36 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE salt->salt_len = salt_len / 2; - pbkdf2_sha1->salt_buf[0] = salt->salt_buf[0]; - pbkdf2_sha1->salt_buf[1] = salt->salt_buf[1]; - pbkdf2_sha1->salt_buf[2] = salt->salt_buf[2]; - pbkdf2_sha1->salt_buf[3] = salt->salt_buf[3]; + vmware_vmx->salt_buf[0] = salt->salt_buf[0]; + vmware_vmx->salt_buf[1] = salt->salt_buf[1]; + vmware_vmx->salt_buf[2] = salt->salt_buf[2]; + vmware_vmx->salt_buf[3] = salt->salt_buf[3]; const u8 *hash_pos = token.buf[3]; // iv - pbkdf2_sha1->iv_buf[0] = hex_to_u32 (hash_pos + 0); - pbkdf2_sha1->iv_buf[1] = hex_to_u32 (hash_pos + 8); - pbkdf2_sha1->iv_buf[2] = hex_to_u32 (hash_pos + 16); - pbkdf2_sha1->iv_buf[3] = hex_to_u32 (hash_pos + 24); + vmware_vmx->iv_buf[0] = hex_to_u32 (hash_pos + 0); + vmware_vmx->iv_buf[1] = hex_to_u32 (hash_pos + 8); + vmware_vmx->iv_buf[2] = hex_to_u32 (hash_pos + 16); + vmware_vmx->iv_buf[3] = hex_to_u32 (hash_pos + 24); - pbkdf2_sha1->iv_buf[0] = byte_swap_32 (pbkdf2_sha1->iv_buf[0]); - pbkdf2_sha1->iv_buf[1] = byte_swap_32 (pbkdf2_sha1->iv_buf[1]); - pbkdf2_sha1->iv_buf[2] = byte_swap_32 (pbkdf2_sha1->iv_buf[2]); - pbkdf2_sha1->iv_buf[3] = byte_swap_32 (pbkdf2_sha1->iv_buf[3]); + vmware_vmx->iv_buf[0] = byte_swap_32 (vmware_vmx->iv_buf[0]); + vmware_vmx->iv_buf[1] = byte_swap_32 (vmware_vmx->iv_buf[1]); + vmware_vmx->iv_buf[2] = byte_swap_32 (vmware_vmx->iv_buf[2]); + vmware_vmx->iv_buf[3] = byte_swap_32 (vmware_vmx->iv_buf[3]); // ct - pbkdf2_sha1->ct_buf[0] = hex_to_u32 (hash_pos + 32); - pbkdf2_sha1->ct_buf[1] = hex_to_u32 (hash_pos + 40); - pbkdf2_sha1->ct_buf[2] = hex_to_u32 (hash_pos + 48); - pbkdf2_sha1->ct_buf[3] = hex_to_u32 (hash_pos + 56); + vmware_vmx->ct_buf[0] = hex_to_u32 (hash_pos + 32); + vmware_vmx->ct_buf[1] = hex_to_u32 (hash_pos + 40); + vmware_vmx->ct_buf[2] = hex_to_u32 (hash_pos + 48); + vmware_vmx->ct_buf[3] = hex_to_u32 (hash_pos + 56); - pbkdf2_sha1->ct_buf[0] = byte_swap_32 (pbkdf2_sha1->ct_buf[0]); - pbkdf2_sha1->ct_buf[1] = byte_swap_32 (pbkdf2_sha1->ct_buf[1]); - pbkdf2_sha1->ct_buf[2] = byte_swap_32 (pbkdf2_sha1->ct_buf[2]); - pbkdf2_sha1->ct_buf[3] = byte_swap_32 (pbkdf2_sha1->ct_buf[3]); + vmware_vmx->ct_buf[0] = byte_swap_32 (vmware_vmx->ct_buf[0]); + vmware_vmx->ct_buf[1] = byte_swap_32 (vmware_vmx->ct_buf[1]); + vmware_vmx->ct_buf[2] = byte_swap_32 (vmware_vmx->ct_buf[2]); + vmware_vmx->ct_buf[3] = byte_swap_32 (vmware_vmx->ct_buf[3]); // known pt => 'type=key:cipher=' @@ -190,7 +189,43 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const void *digest_buf, MAYBE_UNUSED const salt_t *salt, MAYBE_UNUSED const void *esalt_buf, MAYBE_UNUSED const void *hook_salt_buf, MAYBE_UNUSED const hashinfo_t *hash_info, char *line_buf, MAYBE_UNUSED const int line_size) { - return snprintf (line_buf, line_size, "%s", hash_info->orighash); + vmware_vmx_t *vmware_vmx = (vmware_vmx_t *) esalt_buf; + + // salt + + u8 salt_buf[32+1] = { 0 }; + + u32_to_hex (vmware_vmx->salt_buf[0], salt_buf + 0); + u32_to_hex (vmware_vmx->salt_buf[1], salt_buf + 8); + u32_to_hex (vmware_vmx->salt_buf[2], salt_buf + 16); + u32_to_hex (vmware_vmx->salt_buf[3], salt_buf + 24); + + // iv + + u8 iv_buf[32+1] = { 0 }; + + u32_to_hex (byte_swap_32 (vmware_vmx->iv_buf[0]), iv_buf + 0); + u32_to_hex (byte_swap_32 (vmware_vmx->iv_buf[1]), iv_buf + 8); + u32_to_hex (byte_swap_32 (vmware_vmx->iv_buf[2]), iv_buf + 16); + u32_to_hex (byte_swap_32 (vmware_vmx->iv_buf[3]), iv_buf + 24); + + // ct + + u8 ct_buf[32+1] = { 0 }; + + u32_to_hex (byte_swap_32 (vmware_vmx->ct_buf[0]), ct_buf + 0); + u32_to_hex (byte_swap_32 (vmware_vmx->ct_buf[1]), ct_buf + 8); + u32_to_hex (byte_swap_32 (vmware_vmx->ct_buf[2]), ct_buf + 16); + u32_to_hex (byte_swap_32 (vmware_vmx->ct_buf[3]), ct_buf + 24); + + const int line_len = snprintf (line_buf, line_size, "%s%u$%s$%s%s", + SIGNATURE_VMWARE_VMX, + salt->salt_iter + 1, + salt_buf, + iv_buf, + ct_buf); + + return line_len; } void module_init (module_ctx_t *module_ctx) diff --git a/tools/test_modules/m26700.pm b/tools/test_modules/m26700.pm index 908b47243..50f26576e 100644 --- a/tools/test_modules/m26700.pm +++ b/tools/test_modules/m26700.pm @@ -10,14 +10,13 @@ use warnings; use Crypt::PBKDF2; use Crypt::CBC; -use Crypt::Mode::CBC; sub module_constraints { [[0, 256], [32, 32], [-1, -1], [-1, -1], [-1, -1]] } sub module_generate_hash { my $word = shift; - my $salt_str = shift // random_hex_string (32); + my $salt_str = shift; my $ct_str = shift; my $iv_str = ""; @@ -72,7 +71,7 @@ sub module_generate_hash my $encrypted = unpack ("H*", $cipher->encrypt ($data)); - $hash = sprintf ("\$vmx\$0\$%s\$%s\$%s%s", $iterations, unpack ("H*", $salt), unpack ("H*", $iv), $encrypted); + $hash = sprintf ("\$vmx\$0\$%s\$%s\$%s%s", $iterations, unpack ("H*", $salt), unpack ("H*", $iv), substr ($encrypted, 0, 32)); } return $hash; @@ -92,7 +91,7 @@ sub module_verify_hash return unless ($signature eq "vmx"); return unless ($version eq 0); return unless ($rounds eq 10000); - return unless (length $ct lt 32); + return unless (length $ct eq 64); my $word_packed = pack_if_HEX_notation ($word); diff --git a/tools/vmwarevmx2hashcat.py b/tools/vmwarevmx2hashcat.py index 388007fc2..015b2a614 100644 --- a/tools/vmwarevmx2hashcat.py +++ b/tools/vmwarevmx2hashcat.py @@ -44,7 +44,6 @@ def parse_keysafe(file): vmx_ks = ks_struct -# vmx_ks['id'] = hexlify(base64.b64decode(match.group(1))).decode() vmx_ks['password_hash'] = match.group(2) if vmx_ks['password_hash'] != 'PBKDF2-HMAC-SHA-1': msg = 'Unsupported password hash format: ' + vmx_ks['password_hash'] @@ -55,11 +54,9 @@ def parse_keysafe(file): msg = 'Unsupported cypher format: ' + vmx_ks['password_cypher'] raise ValueError(msg) - vmx_ks['hash_round'] = int(match.group(4)) vmx_ks['salt'] = base64.b64decode(unquote(match.group(5))) -# vmx_ks['config_hash'] = match.group(6) - vmx_ks['dict'] = base64.b64decode(match.group(7)) + vmx_ks['dict'] = base64.b64decode(match.group(7))[0:32] return vmx_ks From 0f055d93ba025ff0d4631c1b971f76247bd2b5e6 Mon Sep 17 00:00:00 2001 From: Gabriele Gristina Date: Thu, 15 Jul 2021 20:59:54 +0200 Subject: [PATCH 3/6] fix 26700 struct name --- OpenCL/m26700-pure.cl | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/OpenCL/m26700-pure.cl b/OpenCL/m26700-pure.cl index ff7722961..23b69597d 100644 --- a/OpenCL/m26700-pure.cl +++ b/OpenCL/m26700-pure.cl @@ -28,13 +28,13 @@ typedef struct pbkdf2_sha1_tmp } pbkdf2_sha1_tmp_t; -typedef struct pbkdf2_sha1 +typedef struct vmware_vmx { u32 salt_buf[64]; u32 iv_buf[4]; u32 ct_buf[4]; -} pbkdf2_sha1_t; +} vmware_vmx_t; DECLSPEC void hmac_sha1_run_V (u32x *w0, u32x *w1, u32x *w2, u32x *w3, u32x *ipad, u32x *opad, u32x *digest) { @@ -72,7 +72,7 @@ DECLSPEC void hmac_sha1_run_V (u32x *w0, u32x *w1, u32x *w2, u32x *w3, u32x *ipa sha1_transform_vector (w0, w1, w2, w3, digest); } -KERNEL_FQ void m26700_init (KERN_ATTR_TMPS_ESALT (pbkdf2_sha1_tmp_t, pbkdf2_sha1_t)) +KERNEL_FQ void m26700_init (KERN_ATTR_TMPS_ESALT (pbkdf2_sha1_tmp_t, vmware_vmx_t)) { /** * base @@ -144,7 +144,7 @@ KERNEL_FQ void m26700_init (KERN_ATTR_TMPS_ESALT (pbkdf2_sha1_tmp_t, pbkdf2_sha1 } } -KERNEL_FQ void m26700_loop (KERN_ATTR_TMPS_ESALT (pbkdf2_sha1_tmp_t, pbkdf2_sha1_t)) +KERNEL_FQ void m26700_loop (KERN_ATTR_TMPS_ESALT (pbkdf2_sha1_tmp_t, vmware_vmx_t)) { const u64 gid = get_global_id (0); From 0b19c4a688795af4c712538c7dc87137be302fcd Mon Sep 17 00:00:00 2001 From: Gabriele Gristina Date: Sat, 17 Jul 2021 14:44:36 +0200 Subject: [PATCH 4/6] fix m26700_comp, cleanup changes.txt --- OpenCL/m26700-pure.cl | 2 +- docs/changes.txt | 1 - 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/OpenCL/m26700-pure.cl b/OpenCL/m26700-pure.cl index 23b69597d..9983cb3d2 100644 --- a/OpenCL/m26700-pure.cl +++ b/OpenCL/m26700-pure.cl @@ -229,7 +229,7 @@ KERNEL_FQ void m26700_loop (KERN_ATTR_TMPS_ESALT (pbkdf2_sha1_tmp_t, vmware_vmx_ } } -KERNEL_FQ void m26700_comp (KERN_ATTR_TMPS_ESALT (pbkdf2_sha1_tmp_t, pbkdf2_sha1_t)) +KERNEL_FQ void m26700_comp (KERN_ATTR_TMPS_ESALT (pbkdf2_sha1_tmp_t, vmware_vmx_t)) { /** * base diff --git a/docs/changes.txt b/docs/changes.txt index 89033e686..d9e895e53 100644 --- a/docs/changes.txt +++ b/docs/changes.txt @@ -12,7 +12,6 @@ - Added hash-mode: AES-256-ECB NOKDF (PT = $salt, key = $pass) - Added hash-mode: iPhone passcode (UID key + System Keybag) - Added hash-mode: MetaMask Wallet -- Added hash-mode: VMware VMX (PBKDF2-HMAC-SHA1 + AES-256-CBC) ## ## Features From a43e239db81045ab50fd91ad05664ce71ad292a5 Mon Sep 17 00:00:00 2001 From: Gabriele Gristina Date: Tue, 10 Aug 2021 16:35:15 +0200 Subject: [PATCH 5/6] move to 27400, fix unit test --- OpenCL/{m26700-pure.cl => m27400-pure.cl} | 6 +++--- src/modules/{module_26700.c => module_27400.c} | 2 +- tools/test_modules/{m26700.pm => m27400.pm} | 11 +++++------ 3 files changed, 9 insertions(+), 10 deletions(-) rename OpenCL/{m26700-pure.cl => m27400-pure.cl} (97%) rename src/modules/{module_26700.c => module_27400.c} (99%) rename tools/test_modules/{m26700.pm => m27400.pm} (90%) diff --git a/OpenCL/m26700-pure.cl b/OpenCL/m27400-pure.cl similarity index 97% rename from OpenCL/m26700-pure.cl rename to OpenCL/m27400-pure.cl index 9983cb3d2..9373d2b68 100644 --- a/OpenCL/m26700-pure.cl +++ b/OpenCL/m27400-pure.cl @@ -72,7 +72,7 @@ DECLSPEC void hmac_sha1_run_V (u32x *w0, u32x *w1, u32x *w2, u32x *w3, u32x *ipa sha1_transform_vector (w0, w1, w2, w3, digest); } -KERNEL_FQ void m26700_init (KERN_ATTR_TMPS_ESALT (pbkdf2_sha1_tmp_t, vmware_vmx_t)) +KERNEL_FQ void m27400_init (KERN_ATTR_TMPS_ESALT (pbkdf2_sha1_tmp_t, vmware_vmx_t)) { /** * base @@ -144,7 +144,7 @@ KERNEL_FQ void m26700_init (KERN_ATTR_TMPS_ESALT (pbkdf2_sha1_tmp_t, vmware_vmx_ } } -KERNEL_FQ void m26700_loop (KERN_ATTR_TMPS_ESALT (pbkdf2_sha1_tmp_t, vmware_vmx_t)) +KERNEL_FQ void m27400_loop (KERN_ATTR_TMPS_ESALT (pbkdf2_sha1_tmp_t, vmware_vmx_t)) { const u64 gid = get_global_id (0); @@ -229,7 +229,7 @@ KERNEL_FQ void m26700_loop (KERN_ATTR_TMPS_ESALT (pbkdf2_sha1_tmp_t, vmware_vmx_ } } -KERNEL_FQ void m26700_comp (KERN_ATTR_TMPS_ESALT (pbkdf2_sha1_tmp_t, vmware_vmx_t)) +KERNEL_FQ void m27400_comp (KERN_ATTR_TMPS_ESALT (pbkdf2_sha1_tmp_t, vmware_vmx_t)) { /** * base diff --git a/src/modules/module_26700.c b/src/modules/module_27400.c similarity index 99% rename from src/modules/module_26700.c rename to src/modules/module_27400.c index 86779625f..9eff16f22 100644 --- a/src/modules/module_26700.c +++ b/src/modules/module_27400.c @@ -18,7 +18,7 @@ static const u32 DGST_POS3 = 3; static const u32 DGST_SIZE = DGST_SIZE_4_4; static const u32 HASH_CATEGORY = HASH_CATEGORY_FDE; static const char *HASH_NAME = "VMware VMX (PBKDF2-HMAC-SHA1 + AES-256-CBC)"; -static const u64 KERN_TYPE = 26700; +static const u64 KERN_TYPE = 27400; static const u32 OPTI_TYPE = OPTI_TYPE_ZERO_BYTE | OPTI_TYPE_SLOW_HASH_SIMD_LOOP; static const u64 OPTS_TYPE = OPTS_TYPE_PT_GENERATE_LE diff --git a/tools/test_modules/m26700.pm b/tools/test_modules/m27400.pm similarity index 90% rename from tools/test_modules/m26700.pm rename to tools/test_modules/m27400.pm index 50f26576e..ad5941104 100644 --- a/tools/test_modules/m26700.pm +++ b/tools/test_modules/m27400.pm @@ -57,20 +57,19 @@ sub module_generate_hash my $hash = ""; + my $data = 'type=key:cipher='; + + my $encrypted = unpack ("H*", $cipher->encrypt ($data)); + if (defined $ct_str) { my $ct_bin = pack ("H*", $ct_str); my $iv_bin = substr ($ct_bin, 0, 16); - my $encrypted = substr ($ct_bin, 16); - $hash = sprintf ("\$vmx\$0\$%s\$%s\$%s%s", $iterations, unpack ("H*", $salt), unpack ("H*", $iv_bin), unpack ("H*", $encrypted)); + $hash = sprintf ("\$vmx\$0\$%s\$%s\$%s%s", $iterations, unpack ("H*", $salt), unpack ("H*", $iv_bin), substr ($encrypted, 0, 32)); } else { - my $data = 'type=key:cipher='; - - my $encrypted = unpack ("H*", $cipher->encrypt ($data)); - $hash = sprintf ("\$vmx\$0\$%s\$%s\$%s%s", $iterations, unpack ("H*", $salt), unpack ("H*", $iv), substr ($encrypted, 0, 32)); } From 9e9ed433e4e416fa60af15700935f2928163e38c Mon Sep 17 00:00:00 2001 From: Jens Steube Date: Thu, 12 Aug 2021 08:24:38 +0200 Subject: [PATCH 6/6] Update with newly added module functions --- src/modules/module_27400.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/modules/module_27400.c b/src/modules/module_27400.c index 9eff16f22..86efb742e 100644 --- a/src/modules/module_27400.c +++ b/src/modules/module_27400.c @@ -240,6 +240,7 @@ void module_init (module_ctx_t *module_ctx) 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; @@ -249,6 +250,7 @@ void module_init (module_ctx_t *module_ctx) 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;