arno/hashcat
1
0
Fork 0
mirror of https://github.com/hashcat/hashcat.git synced 2025-02-02 10:51:16 +00:00
Code Issues Releases Wiki Activity

-m 28600 code style and formatting fixes

Browse Source
This commit is contained in:
philsmd 2022-02-20 11:52:02 +01:00 committed by GitHub
parent 912c46d958
commit 9a96501a69
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 199 additions and 190 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;