arno/hashcat
1
0
Fork 0
mirror of https://github.com/hashcat/hashcat.git synced 2025-02-23 04:52:03 +00:00
Code Issues Releases Wiki Activity

Merge pull request #3193 from philsmd/philsmd-cleanup-code-style

Browse Source 
cleanup and code style fixes
This commit is contained in:
Jens Steube 2022-02-20 12:33:54 +01:00 committed by GitHub
commit e5d441320d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 249 additions and 225 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

203
src/modules/module_28600.c
View File

@ -20,9 +20,10 @@ static const u32 DGST_SIZE = DGST_SIZE_4_8;
static const u32 HASH_CATEGORY = HASH_CATEGORY_DATABASE_SERVER; static const u32 HASH_CATEGORY = HASH_CATEGORY_DATABASE_SERVER;
static const char *HASH_NAME = "PostgreSQL SCRAM-SHA-256"; static const char *HASH_NAME = "PostgreSQL SCRAM-SHA-256";
static const u64 KERN_TYPE = 28600; static const u64 KERN_TYPE = 28600;
static const u32 OPTI_TYPE = static const u32 OPTI_TYPE = OPTI_TYPE_ZERO_BYTE
OPTI_TYPE_ZERO_BYTE | OPTI_TYPE_SLOW_HASH_SIMD_LOOP; | OPTI_TYPE_SLOW_HASH_SIMD_LOOP;
static const u64 OPTS_TYPE = OPTS_TYPE_PT_GENERATE_LE | OPTS_TYPE_ST_BASE64; static const u64 OPTS_TYPE = OPTS_TYPE_PT_GENERATE_LE
| OPTS_TYPE_ST_BASE64;
static const u32 SALT_TYPE = SALT_TYPE_EMBEDDED; static const u32 SALT_TYPE = SALT_TYPE_EMBEDDED;
static const char *ST_PASS = "hashcat"; static const char *ST_PASS = "hashcat";
static const char *ST_HASH = "SCRAM-SHA-256$4096:IKfxzJ8Nq4PkLJCfgKcPmA==$" static const char *ST_HASH = "SCRAM-SHA-256$4096:IKfxzJ8Nq4PkLJCfgKcPmA==$"
@ -45,7 +46,8 @@ const char *module_st_hash (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; } 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 postgres_sha256_tmp { typedef struct postgres_sha256_tmp
{
u32 ipad[8]; u32 ipad[8];
u32 opad[8]; u32 opad[8];
@ -54,7 +56,8 @@ typedef struct postgres_sha256_tmp {
} postgres_sha256_tmp_t; } postgres_sha256_tmp_t;
typedef struct postgres_sha256 { typedef struct postgres_sha256
{
u32 salt[16]; u32 salt[16];
u32 storedKey[16]; u32 storedKey[16];
@ -70,23 +73,27 @@ char *module_jit_build_options (MAYBE_UNUSED const hashconfig_t *hashconfig, MAY
char *jit_build_options = NULL; char *jit_build_options = NULL;
// Extra treatment for Apple systems // Extra treatment for Apple systems
if (device_param->opencl_platform_vendor_id == VENDOR_ID_APPLE) { if (device_param->opencl_platform_vendor_id == VENDOR_ID_APPLE)
{
return jit_build_options; return jit_build_options;
} }
// NVIDIA GPU // NVIDIA GPU
if (device_param->opencl_device_vendor_id == VENDOR_ID_NV) { if (device_param->opencl_device_vendor_id == VENDOR_ID_NV)
{
hc_asprintf(&jit_build_options, "-D _unroll"); hc_asprintf(&jit_build_options, "-D _unroll");
} }
// HIP // HIP
if (device_param->opencl_device_vendor_id == VENDOR_ID_AMD_USE_HIP) { if (device_param->opencl_device_vendor_id == VENDOR_ID_AMD_USE_HIP)
{
hc_asprintf(&jit_build_options, "-D _unroll"); hc_asprintf(&jit_build_options, "-D _unroll");
} }
// ROCM // ROCM
if ((device_param->opencl_device_vendor_id == VENDOR_ID_AMD) && if ((device_param->opencl_device_vendor_id == VENDOR_ID_AMD) &&
(device_param->has_vperm == true)) { (device_param->has_vperm == true))
{
hc_asprintf(&jit_build_options, "-D _unroll"); hc_asprintf(&jit_build_options, "-D _unroll");
} }
@ -95,14 +102,14 @@ char *module_jit_build_options (MAYBE_UNUSED const hashconfig_t *hashconfig, MAY
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) 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(postgres_sha256_t); const u64 esalt_size = (const u64) sizeof (postgres_sha256_t);
return esalt_size; 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) 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(postgres_sha256_tmp_t); const u64 tmp_size = (const u64) sizeof (postgres_sha256_tmp_t);
return tmp_size; return tmp_size;
} }
@ -119,9 +126,9 @@ u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED con
int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED void *digest_buf, MAYBE_UNUSED salt_t *salt, MAYBE_UNUSED void *esalt_buf, MAYBE_UNUSED void *hook_salt_buf, MAYBE_UNUSED hashinfo_t *hash_info, const char *line_buf, MAYBE_UNUSED const int line_len) 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; u32 *digest = (u32 *) digest_buf;
postgres_sha256_t *postgres_sha256 = (postgres_sha256_t *)esalt_buf; postgres_sha256_t *postgres_sha256 = (postgres_sha256_t *) esalt_buf;
hc_token_t token; hc_token_t token;
@ -133,66 +140,67 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
token.sep[0] = '$'; token.sep[0] = '$';
token.len_min[0] = 13; token.len_min[0] = 13;
token.len_max[0] = 13; token.len_max[0] = 13;
token.attr[0] = TOKEN_ATTR_VERIFY_LENGTH | TOKEN_ATTR_VERIFY_SIGNATURE; token.attr[0] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_SIGNATURE;
token.sep[1] = ':'; token.sep[1] = ':';
token.len_min[1] = 1; token.len_min[1] = 1;
token.len_max[1] = 7; token.len_max[1] = 7;
token.attr[1] = TOKEN_ATTR_VERIFY_LENGTH | TOKEN_ATTR_VERIFY_DIGIT; token.attr[1] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_DIGIT;
token.sep[2] = '$'; token.sep[2] = '$';
token.len_min[2] = 0; token.len_min[2] = 0;
token.len_max[2] = 88; token.len_max[2] = 88;
token.attr[2] = TOKEN_ATTR_VERIFY_LENGTH | TOKEN_ATTR_VERIFY_BASE64A; token.attr[2] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_BASE64A;
token.sep[3] = ':'; token.sep[3] = ':';
token.len_min[3] = 44; token.len_min[3] = 44;
token.len_max[3] = 44; token.len_max[3] = 44;
token.attr[3] = TOKEN_ATTR_VERIFY_LENGTH | TOKEN_ATTR_VERIFY_BASE64A; token.attr[3] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_BASE64A;
token.len[4] = 44; token.len[4] = 44;
token.attr[4] = TOKEN_ATTR_FIXED_LENGTH | TOKEN_ATTR_VERIFY_BASE64A; token.attr[4] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_BASE64A;
const int rc_tokenizer = const int rc_tokenizer = input_tokenizer ((const u8 *) line_buf, line_len, &token);
input_tokenizer((const u8 *)line_buf, line_len, &token);
if (rc_tokenizer != PARSER_OK) if (rc_tokenizer != PARSER_OK) return (rc_tokenizer);
return (rc_tokenizer);
// iter // iter
const u8 *iter_pos = token.buf[1]; const u8 *iter_pos = token.buf[1];
const u32 iter = hc_strtoul((const char *)iter_pos, NULL, 10); const u32 iter = hc_strtoul ((const char *) iter_pos, NULL, 10);
if (iter < 1) if (iter < 1) return (PARSER_SALT_ITERATION);
return (PARSER_SALT_ITERATION);
salt->salt_iter = iter - 1; salt->salt_iter = iter - 1;
// salt // salt
u8 tmp_buf[100] = {0}; u8 tmp_buf[100] = { 0 };
const u8 *salt_pos = token.buf[2]; const u8 *salt_pos = token.buf[2];
const int salt_len = token.len[2]; const int salt_len = token.len[2];
int tmp_len = base64_decode(base64_to_int, salt_pos, salt_len, tmp_buf); int tmp_len = base64_decode (base64_to_int, salt_pos, salt_len, tmp_buf);
if (tmp_len > 64) if (tmp_len > 64) return (PARSER_SALT_LENGTH);
return (PARSER_SALT_LENGTH);
memcpy(postgres_sha256->salt, tmp_buf, tmp_len); memcpy (postgres_sha256->salt, tmp_buf, tmp_len);
postgres_sha256->salt[0] = byte_swap_32(postgres_sha256->salt[0]); postgres_sha256->salt[ 0] = byte_swap_32(postgres_sha256->salt[ 0]);
postgres_sha256->salt[1] = byte_swap_32(postgres_sha256->salt[1]); postgres_sha256->salt[ 1] = byte_swap_32(postgres_sha256->salt[ 1]);
postgres_sha256->salt[2] = byte_swap_32(postgres_sha256->salt[2]); postgres_sha256->salt[ 2] = byte_swap_32(postgres_sha256->salt[ 2]);
postgres_sha256->salt[3] = byte_swap_32(postgres_sha256->salt[3]); postgres_sha256->salt[ 3] = byte_swap_32(postgres_sha256->salt[ 3]);
postgres_sha256->salt[4] = byte_swap_32(postgres_sha256->salt[4]); postgres_sha256->salt[ 4] = byte_swap_32(postgres_sha256->salt[ 4]);
postgres_sha256->salt[5] = byte_swap_32(postgres_sha256->salt[5]); postgres_sha256->salt[ 5] = byte_swap_32(postgres_sha256->salt[ 5]);
postgres_sha256->salt[6] = byte_swap_32(postgres_sha256->salt[6]); postgres_sha256->salt[ 6] = byte_swap_32(postgres_sha256->salt[ 6]);
postgres_sha256->salt[7] = byte_swap_32(postgres_sha256->salt[7]); postgres_sha256->salt[ 7] = byte_swap_32(postgres_sha256->salt[ 7]);
postgres_sha256->salt[8] = byte_swap_32(postgres_sha256->salt[8]); postgres_sha256->salt[ 8] = byte_swap_32(postgres_sha256->salt[ 8]);
postgres_sha256->salt[9] = byte_swap_32(postgres_sha256->salt[9]); postgres_sha256->salt[ 9] = byte_swap_32(postgres_sha256->salt[ 9]);
postgres_sha256->salt[10] = byte_swap_32(postgres_sha256->salt[10]); postgres_sha256->salt[10] = byte_swap_32(postgres_sha256->salt[10]);
postgres_sha256->salt[11] = byte_swap_32(postgres_sha256->salt[11]); postgres_sha256->salt[11] = byte_swap_32(postgres_sha256->salt[11]);
postgres_sha256->salt[12] = byte_swap_32(postgres_sha256->salt[12]); postgres_sha256->salt[12] = byte_swap_32(postgres_sha256->salt[12]);
@ -203,16 +211,16 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
postgres_sha256->salt_len = tmp_len; postgres_sha256->salt_len = tmp_len;
salt->salt_len = tmp_len; salt->salt_len = tmp_len;
salt->salt_buf[0] = postgres_sha256->salt[0]; salt->salt_buf[ 0] = postgres_sha256->salt[ 0];
salt->salt_buf[1] = postgres_sha256->salt[1]; salt->salt_buf[ 1] = postgres_sha256->salt[ 1];
salt->salt_buf[2] = postgres_sha256->salt[2]; salt->salt_buf[ 2] = postgres_sha256->salt[ 2];
salt->salt_buf[3] = postgres_sha256->salt[3]; salt->salt_buf[ 3] = postgres_sha256->salt[ 3];
salt->salt_buf[4] = postgres_sha256->salt[4]; salt->salt_buf[ 4] = postgres_sha256->salt[ 4];
salt->salt_buf[5] = postgres_sha256->salt[5]; salt->salt_buf[ 5] = postgres_sha256->salt[ 5];
salt->salt_buf[6] = postgres_sha256->salt[6]; salt->salt_buf[ 6] = postgres_sha256->salt[ 6];
salt->salt_buf[7] = postgres_sha256->salt[7]; salt->salt_buf[ 7] = postgres_sha256->salt[ 7];
salt->salt_buf[8] = postgres_sha256->salt[8]; salt->salt_buf[ 8] = postgres_sha256->salt[ 8];
salt->salt_buf[9] = postgres_sha256->salt[9]; salt->salt_buf[ 9] = postgres_sha256->salt[ 9];
salt->salt_buf[10] = postgres_sha256->salt[10]; salt->salt_buf[10] = postgres_sha256->salt[10];
salt->salt_buf[11] = postgres_sha256->salt[11]; salt->salt_buf[11] = postgres_sha256->salt[11];
salt->salt_buf[12] = postgres_sha256->salt[12]; salt->salt_buf[12] = postgres_sha256->salt[12];
@ -224,11 +232,11 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *stored_key_pos = token.buf[3]; const u8 *stored_key_pos = token.buf[3];
const int stored_key_len = token.len[3]; const int stored_key_len = token.len[3];
memset(tmp_buf, 0, sizeof(tmp_buf)); memset (tmp_buf, 0, sizeof (tmp_buf));
tmp_len = base64_decode(base64_to_int, stored_key_pos, stored_key_len, tmp_buf); tmp_len = base64_decode (base64_to_int, stored_key_pos, stored_key_len, tmp_buf);
memcpy(postgres_sha256->storedKey, tmp_buf, tmp_len); memcpy (postgres_sha256->storedKey, tmp_buf, tmp_len);
postgres_sha256->storedKey_len = tmp_len; postgres_sha256->storedKey_len = tmp_len;
@ -237,67 +245,65 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *hash_pos = token.buf[4]; const u8 *hash_pos = token.buf[4];
const int hash_len = token.len[4]; const int hash_len = token.len[4];
memset(tmp_buf, 0, sizeof(tmp_buf)); memset (tmp_buf, 0, sizeof(tmp_buf));
tmp_len = base64_decode(base64_to_int, hash_pos, hash_len, tmp_buf); tmp_len = base64_decode (base64_to_int, hash_pos, hash_len, tmp_buf);
if (tmp_len != 32) if (tmp_len != 32) return (PARSER_HASH_LENGTH);
return (PARSER_HASH_LENGTH);
memcpy(digest, tmp_buf, 32); memcpy (digest, tmp_buf, 32);
digest[0] = byte_swap_32(digest[0]); digest[0] = byte_swap_32 (digest[0]);
digest[1] = byte_swap_32(digest[1]); digest[1] = byte_swap_32 (digest[1]);
digest[2] = byte_swap_32(digest[2]); digest[2] = byte_swap_32 (digest[2]);
digest[3] = byte_swap_32(digest[3]); digest[3] = byte_swap_32 (digest[3]);
digest[4] = byte_swap_32(digest[4]); digest[4] = byte_swap_32 (digest[4]);
digest[5] = byte_swap_32(digest[5]); digest[5] = byte_swap_32 (digest[5]);
digest[6] = byte_swap_32(digest[6]); digest[6] = byte_swap_32 (digest[6]);
digest[7] = byte_swap_32(digest[7]); digest[7] = byte_swap_32 (digest[7]);
return (PARSER_OK); 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) 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)
{ {
u32 *digest = (u32 *)digest_buf; u32 *digest = (u32 *) digest_buf;
postgres_sha256_t *postgres_sha256 = (postgres_sha256_t *)esalt_buf; postgres_sha256_t *postgres_sha256 = (postgres_sha256_t *) esalt_buf;
// salt // salt
u32 salt_buf[8] = {0}; // make the buffer large enough for base64_encode () u32 salt_buf[8] = { 0 }; // make the buffer large enough for base64_encode ()
salt_buf[0] = byte_swap_32(postgres_sha256->salt[0]); salt_buf[0] = byte_swap_32 (postgres_sha256->salt[0]);
salt_buf[1] = byte_swap_32(postgres_sha256->salt[1]); salt_buf[1] = byte_swap_32 (postgres_sha256->salt[1]);
salt_buf[2] = byte_swap_32(postgres_sha256->salt[2]); salt_buf[2] = byte_swap_32 (postgres_sha256->salt[2]);
salt_buf[3] = byte_swap_32(postgres_sha256->salt[3]); salt_buf[3] = byte_swap_32 (postgres_sha256->salt[3]);
salt_buf[4] = byte_swap_32(postgres_sha256->salt[4]); salt_buf[4] = byte_swap_32 (postgres_sha256->salt[4]);
salt_buf[5] = byte_swap_32(postgres_sha256->salt[5]); salt_buf[5] = byte_swap_32 (postgres_sha256->salt[5]);
salt_buf[6] = byte_swap_32(postgres_sha256->salt[6]); salt_buf[6] = byte_swap_32 (postgres_sha256->salt[6]);
salt_buf[7] = byte_swap_32(postgres_sha256->salt[7]); salt_buf[7] = byte_swap_32 (postgres_sha256->salt[7]);
u8 salt_base64[64] = {0}; u8 salt_base64[64] = { 0 };
base64_encode(int_to_base64, (const u8 *)salt_buf, salt->salt_len, base64_encode (int_to_base64, (const u8 *) salt_buf, salt->salt_len, salt_base64);
salt_base64);
// server key // server key
u32 hash[8] = {0}; // make the buffer large enough for base64_encode () u32 hash[8] = { 0 }; // make the buffer large enough for base64_encode ()
hash[0] = byte_swap_32(digest[0]); hash[0] = byte_swap_32 (digest[0]);
hash[1] = byte_swap_32(digest[1]); hash[1] = byte_swap_32 (digest[1]);
hash[2] = byte_swap_32(digest[2]); hash[2] = byte_swap_32 (digest[2]);
hash[3] = byte_swap_32(digest[3]); hash[3] = byte_swap_32 (digest[3]);
hash[4] = byte_swap_32(digest[4]); hash[4] = byte_swap_32 (digest[4]);
hash[5] = byte_swap_32(digest[5]); hash[5] = byte_swap_32 (digest[5]);
hash[6] = byte_swap_32(digest[6]); hash[6] = byte_swap_32 (digest[6]);
hash[7] = byte_swap_32(digest[7]); hash[7] = byte_swap_32 (digest[7]);
u8 server_key_base64[64] = {0}; u8 server_key_base64[64] = { 0 };
base64_encode(int_to_base64, (const u8 *)hash, 32, server_key_base64); base64_encode (int_to_base64, (const u8 *) hash, 32, server_key_base64);
// stored key // stored key
@ -305,19 +311,22 @@ int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
memcpy (stored_key_bin, (char *) postgres_sha256->storedKey, postgres_sha256->storedKey_len); memcpy (stored_key_bin, (char *) postgres_sha256->storedKey, postgres_sha256->storedKey_len);
u8 stored_key_base64[64] = {0}; u8 stored_key_base64[64] = { 0 };
base64_encode(int_to_base64, stored_key_bin, postgres_sha256->storedKey_len, stored_key_base64); base64_encode (int_to_base64, stored_key_bin, postgres_sha256->storedKey_len, stored_key_base64);
// print final line // print final line
const int line_len = const int line_len = snprintf (line_buf, line_size, "%s$%u:%s$%s:%s",
snprintf(line_buf, line_size, "%s$%u:%s$%s:%s", SIGNATURE_POSTGRES_SHA256, SIGNATURE_POSTGRES_SHA256,
salt->salt_iter + 1, salt_base64, stored_key_base64, server_key_base64); salt->salt_iter + 1,
salt_base64,
stored_key_base64,
server_key_base64);
return line_len; return line_len;
} }
void module_init(module_ctx_t *module_ctx) void module_init (module_ctx_t *module_ctx)
{ {
module_ctx->module_context_size = MODULE_CONTEXT_SIZE_CURRENT; module_ctx->module_context_size = MODULE_CONTEXT_SIZE_CURRENT;
module_ctx->module_interface_version = MODULE_INTERFACE_VERSION_CURRENT; module_ctx->module_interface_version = MODULE_INTERFACE_VERSION_CURRENT;

55
src/wordlist.c
View File

@ -107,8 +107,10 @@ void get_next_word_lm_gen (char *buf, u64 sz, u64 *len, u64 *off, u64 cutlen)
if (i == cutlen) if (i == cutlen)
{ {
if (cutlen == 20) buf[i-1]=']'; // add ] in $HEX[] format if (cutlen == 20) buf[i - 1]= ']'; // add ] in $HEX[] format
*len = i; *len = i;
// but continue a loop to skip rest of the line // but continue a loop to skip rest of the line
} }
@ -124,20 +126,22 @@ void get_next_word_lm_gen (char *buf, u64 sz, u64 *len, u64 *off, u64 cutlen)
} }
*off = sz; *off = sz;
if (sz<cutlen) *len = sz;
if (sz < cutlen) *len = sz;
} }
void get_next_word_lm_hex (char *buf, u64 sz, u64 *len, u64 *off) void get_next_word_lm_hex (char *buf, u64 sz, u64 *len, u64 *off)
{ {
// this one is called if --hex-wordlist is uesed // this one is called if --hex-wordlist is used
// we need 14 hex-digits to get 7 characters // we need 14 hex-digits to get 7 characters
// but first convert 7 chars to upper case if thay are a-z // but first convert 7 chars to upper case if they are a-z
for (u64 i = 5; i < sz; i++) for (u64 i = 5; i < sz; i++)
{ {
if ((i & 1) == 0) if ((i & 1) == 0)
{ {
if (is_valid_hex_char(buf[i])) if (is_valid_hex_char (buf[i]))
if (is_valid_hex_char(buf[i+1])) if (is_valid_hex_char (buf[i + 1]))
{ {
if (buf[i] == '6') if (buf[i] == '6')
if (buf[i+1] > '0') if (buf[i+1] > '0')
@ -147,34 +151,42 @@ void get_next_word_lm_hex (char *buf, u64 sz, u64 *len, u64 *off)
buf[i] = '5'; buf[i] = '5';
} }
} }
if (i == 12) break; // stop when 7 chars are converted if (i == 12) break; // stop when 7 chars are converted
} }
// call generic next_word // call generic next_word
get_next_word_lm_gen(buf, sz, len, off, 14);
get_next_word_lm_gen (buf, sz, len, off, 14);
} }
void get_next_word_lm_hex_or_text (char *buf, u64 sz, u64 *len, u64 *off) void get_next_word_lm_hex_or_text (char *buf, u64 sz, u64 *len, u64 *off)
{ {
// check if not $HEX[..] format // check if not $HEX[..] format
bool hex = true; bool hex = true;
if (sz<8) hex=false;
if (sz < 8) hex = false;
if (hex && (buf[0] != '$')) hex = false; if (hex && (buf[0] != '$')) hex = false;
if (hex && (buf[1] != 'H')) hex = false; if (hex && (buf[1] != 'H')) hex = false;
if (hex && (buf[2] != 'E')) hex = false; if (hex && (buf[2] != 'E')) hex = false;
if (hex && (buf[3] != 'X')) hex = false; if (hex && (buf[3] != 'X')) hex = false;
if (hex && (buf[4] != '[')) hex = false; if (hex && (buf[4] != '[')) hex = false;
if (hex){
char *ptr = buf+5; // starting after '[' if (hex)
{
char *ptr = buf + 5; // starting after '['
for (u64 i = 5; i < sz; i++, ptr++) for (u64 i = 5; i < sz; i++, ptr++)
{ {
if (*ptr == ']') if (*ptr == ']')
{ {
if ((i & 1) == 0) hex=false; // not even number of characters if ((i & 1) == 0) hex = false; // not even number of characters
break; break;
} }
else else
{ {
if (is_valid_hex_char(*ptr) == false) if (is_valid_hex_char (*ptr) == false)
{ {
hex = false; hex = false;
break; break;
@ -182,13 +194,13 @@ void get_next_word_lm_hex_or_text (char *buf, u64 sz, u64 *len, u64 *off)
// upcase character if it is a letter 'a-z' // upcase character if it is a letter 'a-z'
if ((i & 1) == 1) // if first hex-char if ((i & 1) == 1) // if first hex-char
{ {
if (is_valid_hex_char(buf[i+1])) if (is_valid_hex_char (buf[i + 1]))
{ {
if (buf[i] == '6') if (buf[i] == '6')
if (buf[i+1] > '0') if (buf[i + 1] > '0')
buf[i] = '4'; buf[i] = '4';
if (buf[i] == '7') if (buf[i] == '7')
if (buf[i+1] < 'B') if (buf[i + 1] < 'B')
buf[i] = '5'; buf[i] = '5';
} }
} }
@ -198,18 +210,18 @@ void get_next_word_lm_hex_or_text (char *buf, u64 sz, u64 *len, u64 *off)
if (hex) if (hex)
{ {
//$HEX[] format so we need max 14 hex-digits + 6 chars '$HEX[]' //$HEX[] format so we need max 14 hex-digits + 6 chars '$HEX[]'
get_next_word_lm_gen(buf, sz, len, off, 20); get_next_word_lm_gen (buf, sz, len, off, 20);
} }
else else
{ {
// threat it as normal string // threat it as normal string
get_next_word_lm_gen(buf, sz, len, off, 7); get_next_word_lm_gen (buf, sz, len, off, 7);
} }
} }
void get_next_word_lm_text (char *buf, u64 sz, u64 *len, u64 *off) void get_next_word_lm_text (char *buf, u64 sz, u64 *len, u64 *off)
{ {
get_next_word_lm_gen(buf, sz, len, off, 7); get_next_word_lm_gen (buf, sz, len, off, 7);
} }
void get_next_word_uc (char *buf, u64 sz, u64 *len, u64 *off) void get_next_word_uc (char *buf, u64 sz, u64 *len, u64 *off)
@ -699,7 +711,8 @@ int wl_data_init (hashcat_ctx_t *hashcat_ctx)
if (hashconfig->opts_type & OPTS_TYPE_PT_LM) if (hashconfig->opts_type & OPTS_TYPE_PT_LM)
{ {
if (hashconfig->opts_type & OPTS_TYPE_PT_HEX){ if (hashconfig->opts_type & OPTS_TYPE_PT_HEX)
{
wl_data->func = get_next_word_lm_hex; // all hex in file wl_data->func = get_next_word_lm_hex; // all hex in file
} }
else else
@ -707,7 +720,9 @@ int wl_data_init (hashcat_ctx_t *hashcat_ctx)
if (user_options->wordlist_autohex_disable == false) if (user_options->wordlist_autohex_disable == false)
{ {
wl_data->func = get_next_word_lm_hex_or_text; // might be $HEX[] notation wl_data->func = get_next_word_lm_hex_or_text; // might be $HEX[] notation
}else{ }
else
{
wl_data->func = get_next_word_lm_text; // treat as nromal text wl_data->func = get_next_word_lm_text; // treat as nromal text
} }
} }