arno/hashcat
1
0
Fork 0
mirror of https://github.com/hashcat/hashcat.git synced 2025-07-18 20:49:19 +00:00
Code Issues Releases Wiki Activity

VeraCrypt modules code cleanup

Browse Source
This commit is contained in:
Konrad Goławski 2024-02-08 15:38:07 +01:00
parent c1a10518fd
commit d1b1a64a8c
63 changed files with 623 additions and 1143 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
OpenCL/m13711-pure.cl
View File

@ -19,9 +19,11 @@
#include M2S(INCLUDE_PATH/inc_cipher_kuznyechik.cl)
#endif
#define VC_DATA_LEN (448)
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -43,6 +45,8 @@ typedef struct vc
#include M2S(INCLUDE_PATH/inc_veracrypt_keyfile.cl)
#endif
#define VC_DATA_LEN (448)
typedef struct vc_tmp
{
u32 ipad[16];

4
OpenCL/m13712-pure.cl
View File

@ -19,9 +19,11 @@
#include M2S(INCLUDE_PATH/inc_cipher_kuznyechik.cl)
#endif
#define VC_DATA_LEN (448)
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;

4
OpenCL/m13713-pure.cl
View File

@ -19,9 +19,11 @@
#include M2S(INCLUDE_PATH/inc_cipher_kuznyechik.cl)
#endif
#define VC_DATA_LEN (448)
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;

4
OpenCL/m13721-pure.cl
View File

@ -19,9 +19,11 @@
#include M2S(INCLUDE_PATH/inc_cipher_kuznyechik.cl)
#endif
#define VC_DATA_LEN (448)
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;

4
OpenCL/m13722-pure.cl
View File

@ -19,9 +19,11 @@
#include M2S(INCLUDE_PATH/inc_cipher_kuznyechik.cl)
#endif
#define VC_DATA_LEN (448)
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;

4
OpenCL/m13723-pure.cl
View File

@ -19,9 +19,11 @@
#include M2S(INCLUDE_PATH/inc_cipher_kuznyechik.cl)
#endif
#define VC_DATA_LEN (448)
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;

4
OpenCL/m13731-pure.cl
View File

@ -19,9 +19,11 @@
#include M2S(INCLUDE_PATH/inc_cipher_kuznyechik.cl)
#endif
#define VC_DATA_LEN (448)
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;

4
OpenCL/m13732-pure.cl
View File

@ -19,9 +19,11 @@
#include M2S(INCLUDE_PATH/inc_cipher_kuznyechik.cl)
#endif
#define VC_DATA_LEN (448)
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;

4
OpenCL/m13733-pure.cl
View File

@ -19,9 +19,11 @@
#include M2S(INCLUDE_PATH/inc_cipher_kuznyechik.cl)
#endif
#define VC_DATA_LEN (448)
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;

4
OpenCL/m13751-pure.cl
View File

@ -19,9 +19,11 @@
#include M2S(INCLUDE_PATH/inc_cipher_kuznyechik.cl)
#endif
#define VC_DATA_LEN (448)
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;

4
OpenCL/m13752-pure.cl
View File

@ -19,9 +19,11 @@
#include M2S(INCLUDE_PATH/inc_cipher_kuznyechik.cl)
#endif
#define VC_DATA_LEN (448)
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;

4
OpenCL/m13753-pure.cl
View File

@ -19,9 +19,11 @@
#include M2S(INCLUDE_PATH/inc_cipher_kuznyechik.cl)
#endif
#define VC_DATA_LEN (448)
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;

4
OpenCL/m13771-pure.cl
View File

@ -19,9 +19,11 @@
#include M2S(INCLUDE_PATH/inc_cipher_kuznyechik.cl)
#endif
#define VC_DATA_LEN (448)
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;

4
OpenCL/m13772-pure.cl
View File

@ -19,9 +19,11 @@
#include M2S(INCLUDE_PATH/inc_cipher_kuznyechik.cl)
#endif
#define VC_DATA_LEN (448)
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;

4
OpenCL/m13773-pure.cl
View File

@ -19,9 +19,11 @@
#include M2S(INCLUDE_PATH/inc_cipher_kuznyechik.cl)
#endif
#define VC_DATA_LEN (448)
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;

26
src/modules/module_13711.c
View File

@ -49,9 +49,10 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_HEADER_LEN 512
#define VC_SALT_LEN ( 64)
#define VC_DATA_LEN ( 448)
#define VC_HEADER_LEN ( 512)
#define VC_HEADER_HEX_LEN (VC_HEADER_LEN * 2)
typedef struct vc_tmp
{
@ -69,7 +70,7 @@ typedef struct vc_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -148,20 +149,11 @@ u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED con
int module_hash_init_selftest (MAYBE_UNUSED const hashconfig_t *hashconfig, hash_t *hash)
{
const size_t st_hash_len = strlen (hashconfig->st_hash);
char header[VC_HEADER_LEN + 1] = { 0 };
char *tmpdata = (char *) hcmalloc (st_hash_len / 2);
hex_decode ((const u8 *) hashconfig->st_hash, VC_HEADER_HEX_LEN, (u8 *) header);
for (size_t i = 0, j = 0; j < st_hash_len; i += 1, j += 2)
{
const u8 c = hex_to_u8 ((const u8 *) hashconfig->st_hash + j);
tmpdata[i] = c;
}
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, tmpdata, st_hash_len / 2);
hcfree (tmpdata);
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, header, VC_HEADER_LEN);
return parser_status;
}
@ -283,7 +275,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}

26
src/modules/module_13712.c
View File

@ -49,9 +49,10 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_HEADER_LEN 512
#define VC_SALT_LEN ( 64)
#define VC_DATA_LEN ( 448)
#define VC_HEADER_LEN ( 512)
#define VC_HEADER_HEX_LEN (VC_HEADER_LEN * 2)
typedef struct vc_tmp
{
@ -69,7 +70,7 @@ typedef struct vc_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -148,20 +149,11 @@ u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED con
int module_hash_init_selftest (MAYBE_UNUSED const hashconfig_t *hashconfig, hash_t *hash)
{
const size_t st_hash_len = strlen (hashconfig->st_hash);
char header[VC_HEADER_LEN + 1] = { 0 };
char *tmpdata = (char *) hcmalloc (st_hash_len / 2);
hex_decode ((const u8 *) hashconfig->st_hash, VC_HEADER_HEX_LEN, (u8 *) header);
for (size_t i = 0, j = 0; j < st_hash_len; i += 1, j += 2)
{
const u8 c = hex_to_u8 ((const u8 *) hashconfig->st_hash + j);
tmpdata[i] = c;
}
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, tmpdata, st_hash_len / 2);
hcfree (tmpdata);
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, header, VC_HEADER_LEN);
return parser_status;
}
@ -283,7 +275,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}

26
src/modules/module_13713.c
View File

@ -49,9 +49,10 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_HEADER_LEN 512
#define VC_SALT_LEN ( 64)
#define VC_DATA_LEN ( 448)
#define VC_HEADER_LEN ( 512)
#define VC_HEADER_HEX_LEN (VC_HEADER_LEN * 2)
typedef struct vc_tmp
{
@ -69,7 +70,7 @@ typedef struct vc_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -148,20 +149,11 @@ u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED con
int module_hash_init_selftest (MAYBE_UNUSED const hashconfig_t *hashconfig, hash_t *hash)
{
const size_t st_hash_len = strlen (hashconfig->st_hash);
char header[VC_HEADER_LEN + 1] = { 0 };
char *tmpdata = (char *) hcmalloc (st_hash_len / 2);
hex_decode ((const u8 *) hashconfig->st_hash, VC_HEADER_HEX_LEN, (u8 *) header);
for (size_t i = 0, j = 0; j < st_hash_len; i += 1, j += 2)
{
const u8 c = hex_to_u8 ((const u8 *) hashconfig->st_hash + j);
tmpdata[i] = c;
}
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, tmpdata, st_hash_len / 2);
hcfree (tmpdata);
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, header, VC_HEADER_LEN);
return parser_status;
}
@ -283,7 +275,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}

26
src/modules/module_13721.c
View File

@ -51,9 +51,10 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_HEADER_LEN 512
#define VC_SALT_LEN ( 64)
#define VC_DATA_LEN ( 448)
#define VC_HEADER_LEN ( 512)
#define VC_HEADER_HEX_LEN (VC_HEADER_LEN * 2)
typedef struct vc64_tmp
{
@ -71,7 +72,7 @@ typedef struct vc64_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -161,20 +162,11 @@ u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED con
int module_hash_init_selftest (MAYBE_UNUSED const hashconfig_t *hashconfig, hash_t *hash)
{
const size_t st_hash_len = strlen (hashconfig->st_hash);
char header[VC_HEADER_LEN + 1] = { 0 };
char *tmpdata = (char *) hcmalloc (st_hash_len / 2);
hex_decode ((const u8 *) hashconfig->st_hash, VC_HEADER_HEX_LEN, (u8 *) header);
for (size_t i = 0, j = 0; j < st_hash_len; i += 1, j += 2)
{
const u8 c = hex_to_u8 ((const u8 *) hashconfig->st_hash + j);
tmpdata[i] = c;
}
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, tmpdata, st_hash_len / 2);
hcfree (tmpdata);
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, header, VC_HEADER_LEN);
return parser_status;
}
@ -296,7 +288,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}

26
src/modules/module_13722.c
View File

@ -51,9 +51,10 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_HEADER_LEN 512
#define VC_SALT_LEN ( 64)
#define VC_DATA_LEN ( 448)
#define VC_HEADER_LEN ( 512)
#define VC_HEADER_HEX_LEN (VC_HEADER_LEN * 2)
typedef struct vc64_tmp
{
@ -71,7 +72,7 @@ typedef struct vc64_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -161,20 +162,11 @@ u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED con
int module_hash_init_selftest (MAYBE_UNUSED const hashconfig_t *hashconfig, hash_t *hash)
{
const size_t st_hash_len = strlen (hashconfig->st_hash);
char header[VC_HEADER_LEN + 1] = { 0 };
char *tmpdata = (char *) hcmalloc (st_hash_len / 2);
hex_decode ((const u8 *) hashconfig->st_hash, VC_HEADER_HEX_LEN, (u8 *) header);
for (size_t i = 0, j = 0; j < st_hash_len; i += 1, j += 2)
{
const u8 c = hex_to_u8 ((const u8 *) hashconfig->st_hash + j);
tmpdata[i] = c;
}
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, tmpdata, st_hash_len / 2);
hcfree (tmpdata);
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, header, VC_HEADER_LEN);
return parser_status;
}
@ -296,7 +288,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}

26
src/modules/module_13723.c
View File

@ -51,9 +51,10 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_HEADER_LEN 512
#define VC_SALT_LEN ( 64)
#define VC_DATA_LEN ( 448)
#define VC_HEADER_LEN ( 512)
#define VC_HEADER_HEX_LEN (VC_HEADER_LEN * 2)
typedef struct vc64_tmp
{
@ -71,7 +72,7 @@ typedef struct vc64_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -161,20 +162,11 @@ u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED con
int module_hash_init_selftest (MAYBE_UNUSED const hashconfig_t *hashconfig, hash_t *hash)
{
const size_t st_hash_len = strlen (hashconfig->st_hash);
char header[VC_HEADER_LEN + 1] = { 0 };
char *tmpdata = (char *) hcmalloc (st_hash_len / 2);
hex_decode ((const u8 *) hashconfig->st_hash, VC_HEADER_HEX_LEN, (u8 *) header);
for (size_t i = 0, j = 0; j < st_hash_len; i += 1, j += 2)
{
const u8 c = hex_to_u8 ((const u8 *) hashconfig->st_hash + j);
tmpdata[i] = c;
}
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, tmpdata, st_hash_len / 2);
hcfree (tmpdata);
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, header, VC_HEADER_LEN);
return parser_status;
}
@ -296,7 +288,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}

26
src/modules/module_13731.c
View File

@ -50,9 +50,10 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_HEADER_LEN 512
#define VC_SALT_LEN ( 64)
#define VC_DATA_LEN ( 448)
#define VC_HEADER_LEN ( 512)
#define VC_HEADER_HEX_LEN (VC_HEADER_LEN * 2)
typedef struct vc_tmp
{
@ -70,7 +71,7 @@ typedef struct vc_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -167,20 +168,11 @@ u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED con
int module_hash_init_selftest (MAYBE_UNUSED const hashconfig_t *hashconfig, hash_t *hash)
{
const size_t st_hash_len = strlen (hashconfig->st_hash);
char header[VC_HEADER_LEN + 1] = { 0 };
char *tmpdata = (char *) hcmalloc (st_hash_len / 2);
hex_decode ((const u8 *) hashconfig->st_hash, VC_HEADER_HEX_LEN, (u8 *) header);
for (size_t i = 0, j = 0; j < st_hash_len; i += 1, j += 2)
{
const u8 c = hex_to_u8 ((const u8 *) hashconfig->st_hash + j);
tmpdata[i] = c;
}
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, tmpdata, st_hash_len / 2);
hcfree (tmpdata);
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, header, VC_HEADER_LEN);
return parser_status;
}
@ -302,7 +294,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}

26
src/modules/module_13732.c
View File

@ -50,9 +50,10 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_HEADER_LEN 512
#define VC_SALT_LEN ( 64)
#define VC_DATA_LEN ( 448)
#define VC_HEADER_LEN ( 512)
#define VC_HEADER_HEX_LEN (VC_HEADER_LEN * 2)
typedef struct vc_tmp
{
@ -70,7 +71,7 @@ typedef struct vc_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -167,20 +168,11 @@ u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED con
int module_hash_init_selftest (MAYBE_UNUSED const hashconfig_t *hashconfig, hash_t *hash)
{
const size_t st_hash_len = strlen (hashconfig->st_hash);
char header[VC_HEADER_LEN + 1] = { 0 };
char *tmpdata = (char *) hcmalloc (st_hash_len / 2);
hex_decode ((const u8 *) hashconfig->st_hash, VC_HEADER_HEX_LEN, (u8 *) header);
for (size_t i = 0, j = 0; j < st_hash_len; i += 1, j += 2)
{
const u8 c = hex_to_u8 ((const u8 *) hashconfig->st_hash + j);
tmpdata[i] = c;
}
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, tmpdata, st_hash_len / 2);
hcfree (tmpdata);
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, header, VC_HEADER_LEN);
return parser_status;
}
@ -302,7 +294,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}

26
src/modules/module_13733.c
View File

@ -50,9 +50,10 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_HEADER_LEN 512
#define VC_SALT_LEN ( 64)
#define VC_DATA_LEN ( 448)
#define VC_HEADER_LEN ( 512)
#define VC_HEADER_HEX_LEN (VC_HEADER_LEN * 2)
typedef struct vc_tmp
{
@ -70,7 +71,7 @@ typedef struct vc_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -167,20 +168,11 @@ u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED con
int module_hash_init_selftest (MAYBE_UNUSED const hashconfig_t *hashconfig, hash_t *hash)
{
const size_t st_hash_len = strlen (hashconfig->st_hash);
char header[VC_HEADER_LEN + 1] = { 0 };
char *tmpdata = (char *) hcmalloc (st_hash_len / 2);
hex_decode ((const u8 *) hashconfig->st_hash, VC_HEADER_HEX_LEN, (u8 *) header);
for (size_t i = 0, j = 0; j < st_hash_len; i += 1, j += 2)
{
const u8 c = hex_to_u8 ((const u8 *) hashconfig->st_hash + j);
tmpdata[i] = c;
}
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, tmpdata, st_hash_len / 2);
hcfree (tmpdata);
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, header, VC_HEADER_LEN);
return parser_status;
}
@ -302,7 +294,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}

26
src/modules/module_13741.c
View File

@ -50,9 +50,10 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_HEADER_LEN 512
#define VC_SALT_LEN ( 64)
#define VC_DATA_LEN ( 448)
#define VC_HEADER_LEN ( 512)
#define VC_HEADER_HEX_LEN (VC_HEADER_LEN * 2)
typedef struct vc_tmp
{
@ -70,7 +71,7 @@ typedef struct vc_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -150,20 +151,11 @@ u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED con
int module_hash_init_selftest (MAYBE_UNUSED const hashconfig_t *hashconfig, hash_t *hash)
{
const size_t st_hash_len = strlen (hashconfig->st_hash);
char header[VC_HEADER_LEN + 1] = { 0 };
char *tmpdata = (char *) hcmalloc (st_hash_len / 2);
hex_decode ((const u8 *) hashconfig->st_hash, VC_HEADER_HEX_LEN, (u8 *) header);
for (size_t i = 0, j = 0; j < st_hash_len; i += 1, j += 2)
{
const u8 c = hex_to_u8 ((const u8 *) hashconfig->st_hash + j);
tmpdata[i] = c;
}
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, tmpdata, st_hash_len / 2);
hcfree (tmpdata);
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, header, VC_HEADER_LEN);
return parser_status;
}
@ -285,7 +277,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}

26
src/modules/module_13742.c
View File

@ -50,9 +50,10 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_HEADER_LEN 512
#define VC_SALT_LEN ( 64)
#define VC_DATA_LEN ( 448)
#define VC_HEADER_LEN ( 512)
#define VC_HEADER_HEX_LEN (VC_HEADER_LEN * 2)
typedef struct vc_tmp
{
@ -70,7 +71,7 @@ typedef struct vc_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -150,20 +151,11 @@ u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED con
int module_hash_init_selftest (MAYBE_UNUSED const hashconfig_t *hashconfig, hash_t *hash)
{
const size_t st_hash_len = strlen (hashconfig->st_hash);
char header[VC_HEADER_LEN + 1] = { 0 };
char *tmpdata = (char *) hcmalloc (st_hash_len / 2);
hex_decode ((const u8 *) hashconfig->st_hash, VC_HEADER_HEX_LEN, (u8 *) header);
for (size_t i = 0, j = 0; j < st_hash_len; i += 1, j += 2)
{
const u8 c = hex_to_u8 ((const u8 *) hashconfig->st_hash + j);
tmpdata[i] = c;
}
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, tmpdata, st_hash_len / 2);
hcfree (tmpdata);
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, header, VC_HEADER_LEN);
return parser_status;
}
@ -285,7 +277,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}

26
src/modules/module_13743.c
View File

@ -50,9 +50,10 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_HEADER_LEN 512
#define VC_SALT_LEN ( 64)
#define VC_DATA_LEN ( 448)
#define VC_HEADER_LEN ( 512)
#define VC_HEADER_HEX_LEN (VC_HEADER_LEN * 2)
typedef struct vc_tmp
{
@ -70,7 +71,7 @@ typedef struct vc_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -150,20 +151,11 @@ u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED con
int module_hash_init_selftest (MAYBE_UNUSED const hashconfig_t *hashconfig, hash_t *hash)
{
const size_t st_hash_len = strlen (hashconfig->st_hash);
char header[VC_HEADER_LEN + 1] = { 0 };
char *tmpdata = (char *) hcmalloc (st_hash_len / 2);
hex_decode ((const u8 *) hashconfig->st_hash, VC_HEADER_HEX_LEN, (u8 *) header);
for (size_t i = 0, j = 0; j < st_hash_len; i += 1, j += 2)
{
const u8 c = hex_to_u8 ((const u8 *) hashconfig->st_hash + j);
tmpdata[i] = c;
}
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, tmpdata, st_hash_len / 2);
hcfree (tmpdata);
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, header, VC_HEADER_LEN);
return parser_status;
}
@ -285,7 +277,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}

26
src/modules/module_13751.c
View File

@ -49,9 +49,10 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_HEADER_LEN 512
#define VC_SALT_LEN ( 64)
#define VC_DATA_LEN ( 448)
#define VC_HEADER_LEN ( 512)
#define VC_HEADER_HEX_LEN (VC_HEADER_LEN * 2)
typedef struct vc_tmp
{
@ -69,7 +70,7 @@ typedef struct vc_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -167,20 +168,11 @@ u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED con
int module_hash_init_selftest (MAYBE_UNUSED const hashconfig_t *hashconfig, hash_t *hash)
{
const size_t st_hash_len = strlen (hashconfig->st_hash);
char header[VC_HEADER_LEN + 1] = { 0 };
char *tmpdata = (char *) hcmalloc (st_hash_len / 2);
hex_decode ((const u8 *) hashconfig->st_hash, VC_HEADER_HEX_LEN, (u8 *) header);
for (size_t i = 0, j = 0; j < st_hash_len; i += 1, j += 2)
{
const u8 c = hex_to_u8 ((const u8 *) hashconfig->st_hash + j);
tmpdata[i] = c;
}
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, tmpdata, st_hash_len / 2);
hcfree (tmpdata);
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, header, VC_HEADER_LEN);
return parser_status;
}
@ -302,7 +294,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}

26
src/modules/module_13752.c
View File

@ -49,9 +49,10 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_HEADER_LEN 512
#define VC_SALT_LEN ( 64)
#define VC_DATA_LEN ( 448)
#define VC_HEADER_LEN ( 512)
#define VC_HEADER_HEX_LEN (VC_HEADER_LEN * 2)
typedef struct vc_tmp
{
@ -69,7 +70,7 @@ typedef struct vc_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -167,20 +168,11 @@ u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED con
int module_hash_init_selftest (MAYBE_UNUSED const hashconfig_t *hashconfig, hash_t *hash)
{
const size_t st_hash_len = strlen (hashconfig->st_hash);
char header[VC_HEADER_LEN + 1] = { 0 };
char *tmpdata = (char *) hcmalloc (st_hash_len / 2);
hex_decode ((const u8 *) hashconfig->st_hash, VC_HEADER_HEX_LEN, (u8 *) header);
for (size_t i = 0, j = 0; j < st_hash_len; i += 1, j += 2)
{
const u8 c = hex_to_u8 ((const u8 *) hashconfig->st_hash + j);
tmpdata[i] = c;
}
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, tmpdata, st_hash_len / 2);
hcfree (tmpdata);
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, header, VC_HEADER_LEN);
return parser_status;
}
@ -302,7 +294,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}

26
src/modules/module_13753.c
View File

@ -49,9 +49,10 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_HEADER_LEN 512
#define VC_SALT_LEN ( 64)
#define VC_DATA_LEN ( 448)
#define VC_HEADER_LEN ( 512)
#define VC_HEADER_HEX_LEN (VC_HEADER_LEN * 2)
typedef struct vc_tmp
{
@ -69,7 +70,7 @@ typedef struct vc_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -167,20 +168,11 @@ u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED con
int module_hash_init_selftest (MAYBE_UNUSED const hashconfig_t *hashconfig, hash_t *hash)
{
const size_t st_hash_len = strlen (hashconfig->st_hash);
char header[VC_HEADER_LEN + 1] = { 0 };
char *tmpdata = (char *) hcmalloc (st_hash_len / 2);
hex_decode ((const u8 *) hashconfig->st_hash, VC_HEADER_HEX_LEN, (u8 *) header);
for (size_t i = 0, j = 0; j < st_hash_len; i += 1, j += 2)
{
const u8 c = hex_to_u8 ((const u8 *) hashconfig->st_hash + j);
tmpdata[i] = c;
}
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, tmpdata, st_hash_len / 2);
hcfree (tmpdata);
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, header, VC_HEADER_LEN);
return parser_status;
}
@ -302,7 +294,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}

26
src/modules/module_13761.c
View File

@ -50,9 +50,10 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_HEADER_LEN 512
#define VC_SALT_LEN ( 64)
#define VC_DATA_LEN ( 448)
#define VC_HEADER_LEN ( 512)
#define VC_HEADER_HEX_LEN (VC_HEADER_LEN * 2)
typedef struct vc_tmp
{
@ -70,7 +71,7 @@ typedef struct vc_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -169,20 +170,11 @@ u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED con
int module_hash_init_selftest (MAYBE_UNUSED const hashconfig_t *hashconfig, hash_t *hash)
{
const size_t st_hash_len = strlen (hashconfig->st_hash);
char header[VC_HEADER_LEN + 1] = { 0 };
char *tmpdata = (char *) hcmalloc (st_hash_len / 2);
hex_decode ((const u8 *) hashconfig->st_hash, VC_HEADER_HEX_LEN, (u8 *) header);
for (size_t i = 0, j = 0; j < st_hash_len; i += 1, j += 2)
{
const u8 c = hex_to_u8 ((const u8 *) hashconfig->st_hash + j);
tmpdata[i] = c;
}
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, tmpdata, st_hash_len / 2);
hcfree (tmpdata);
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, header, VC_HEADER_LEN);
return parser_status;
}
@ -304,7 +296,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}

26
src/modules/module_13762.c
View File

@ -50,9 +50,10 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_HEADER_LEN 512
#define VC_SALT_LEN ( 64)
#define VC_DATA_LEN ( 448)
#define VC_HEADER_LEN ( 512)
#define VC_HEADER_HEX_LEN (VC_HEADER_LEN * 2)
typedef struct vc_tmp
{
@ -70,7 +71,7 @@ typedef struct vc_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -169,20 +170,11 @@ u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED con
int module_hash_init_selftest (MAYBE_UNUSED const hashconfig_t *hashconfig, hash_t *hash)
{
const size_t st_hash_len = strlen (hashconfig->st_hash);
char header[VC_HEADER_LEN + 1] = { 0 };
char *tmpdata = (char *) hcmalloc (st_hash_len / 2);
hex_decode ((const u8 *) hashconfig->st_hash, VC_HEADER_HEX_LEN, (u8 *) header);
for (size_t i = 0, j = 0; j < st_hash_len; i += 1, j += 2)
{
const u8 c = hex_to_u8 ((const u8 *) hashconfig->st_hash + j);
tmpdata[i] = c;
}
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, tmpdata, st_hash_len / 2);
hcfree (tmpdata);
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, header, VC_HEADER_LEN);
return parser_status;
}
@ -304,7 +296,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}

26
src/modules/module_13763.c
View File

@ -50,9 +50,10 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_HEADER_LEN 512
#define VC_SALT_LEN ( 64)
#define VC_DATA_LEN ( 448)
#define VC_HEADER_LEN ( 512)
#define VC_HEADER_HEX_LEN (VC_HEADER_LEN * 2)
typedef struct vc_tmp
{
@ -70,7 +71,7 @@ typedef struct vc_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -169,20 +170,11 @@ u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED con
int module_hash_init_selftest (MAYBE_UNUSED const hashconfig_t *hashconfig, hash_t *hash)
{
const size_t st_hash_len = strlen (hashconfig->st_hash);
char header[VC_HEADER_LEN + 1] = { 0 };
char *tmpdata = (char *) hcmalloc (st_hash_len / 2);
hex_decode ((const u8 *) hashconfig->st_hash, VC_HEADER_HEX_LEN, (u8 *) header);
for (size_t i = 0, j = 0; j < st_hash_len; i += 1, j += 2)
{
const u8 c = hex_to_u8 ((const u8 *) hashconfig->st_hash + j);
tmpdata[i] = c;
}
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, tmpdata, st_hash_len / 2);
hcfree (tmpdata);
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, header, VC_HEADER_LEN);
return parser_status;
}
@ -304,7 +296,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}

26
src/modules/module_13771.c
View File

@ -51,9 +51,10 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_HEADER_LEN 512
#define VC_SALT_LEN ( 64)
#define VC_DATA_LEN ( 448)
#define VC_HEADER_LEN ( 512)
#define VC_HEADER_HEX_LEN (VC_HEADER_LEN * 2)
typedef struct vc64_sbog_tmp
{
@ -74,7 +75,7 @@ typedef struct vc64_sbog_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -153,20 +154,11 @@ u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED con
int module_hash_init_selftest (MAYBE_UNUSED const hashconfig_t *hashconfig, hash_t *hash)
{
const size_t st_hash_len = strlen (hashconfig->st_hash);
char header[VC_HEADER_LEN + 1] = { 0 };
char *tmpdata = (char *) hcmalloc (st_hash_len / 2);
hex_decode ((const u8 *) hashconfig->st_hash, VC_HEADER_HEX_LEN, (u8 *) header);
for (size_t i = 0, j = 0; j < st_hash_len; i += 1, j += 2)
{
const u8 c = hex_to_u8 ((const u8 *) hashconfig->st_hash + j);
tmpdata[i] = c;
}
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, tmpdata, st_hash_len / 2);
hcfree (tmpdata);
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, header, VC_HEADER_LEN);
return parser_status;
}
@ -288,7 +280,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}

26
src/modules/module_13772.c
View File

@ -51,9 +51,10 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_HEADER_LEN 512
#define VC_SALT_LEN ( 64)
#define VC_DATA_LEN ( 448)
#define VC_HEADER_LEN ( 512)
#define VC_HEADER_HEX_LEN (VC_HEADER_LEN * 2)
typedef struct vc64_sbog_tmp
{
@ -74,7 +75,7 @@ typedef struct vc64_sbog_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -153,20 +154,11 @@ u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED con
int module_hash_init_selftest (MAYBE_UNUSED const hashconfig_t *hashconfig, hash_t *hash)
{
const size_t st_hash_len = strlen (hashconfig->st_hash);
char header[VC_HEADER_LEN + 1] = { 0 };
char *tmpdata = (char *) hcmalloc (st_hash_len / 2);
hex_decode ((const u8 *) hashconfig->st_hash, VC_HEADER_HEX_LEN, (u8 *) header);
for (size_t i = 0, j = 0; j < st_hash_len; i += 1, j += 2)
{
const u8 c = hex_to_u8 ((const u8 *) hashconfig->st_hash + j);
tmpdata[i] = c;
}
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, tmpdata, st_hash_len / 2);
hcfree (tmpdata);
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, header, VC_HEADER_LEN);
return parser_status;
}
@ -288,7 +280,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}

26
src/modules/module_13773.c
View File

@ -51,9 +51,10 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_HEADER_LEN 512
#define VC_SALT_LEN ( 64)
#define VC_DATA_LEN ( 448)
#define VC_HEADER_LEN ( 512)
#define VC_HEADER_HEX_LEN (VC_HEADER_LEN * 2)
typedef struct vc64_sbog_tmp
{
@ -74,7 +75,7 @@ typedef struct vc64_sbog_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -153,20 +154,11 @@ u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED con
int module_hash_init_selftest (MAYBE_UNUSED const hashconfig_t *hashconfig, hash_t *hash)
{
const size_t st_hash_len = strlen (hashconfig->st_hash);
char header[VC_HEADER_LEN + 1] = { 0 };
char *tmpdata = (char *) hcmalloc (st_hash_len / 2);
hex_decode ((const u8 *) hashconfig->st_hash, VC_HEADER_HEX_LEN, (u8 *) header);
for (size_t i = 0, j = 0; j < st_hash_len; i += 1, j += 2)
{
const u8 c = hex_to_u8 ((const u8 *) hashconfig->st_hash + j);
tmpdata[i] = c;
}
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, tmpdata, st_hash_len / 2);
hcfree (tmpdata);
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, header, VC_HEADER_LEN);
return parser_status;
}
@ -288,7 +280,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}

26
src/modules/module_13781.c
View File

@ -52,9 +52,10 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_HEADER_LEN 512
#define VC_SALT_LEN ( 64)
#define VC_DATA_LEN ( 448)
#define VC_HEADER_LEN ( 512)
#define VC_HEADER_HEX_LEN (VC_HEADER_LEN * 2)
typedef struct vc64_sbog_tmp
{
@ -75,7 +76,7 @@ typedef struct vc64_sbog_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -155,20 +156,11 @@ u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED con
int module_hash_init_selftest (MAYBE_UNUSED const hashconfig_t *hashconfig, hash_t *hash)
{
const size_t st_hash_len = strlen (hashconfig->st_hash);
char header[VC_HEADER_LEN + 1] = { 0 };
char *tmpdata = (char *) hcmalloc (st_hash_len / 2);
hex_decode ((const u8 *) hashconfig->st_hash, VC_HEADER_HEX_LEN, (u8 *) header);
for (size_t i = 0, j = 0; j < st_hash_len; i += 1, j += 2)
{
const u8 c = hex_to_u8 ((const u8 *) hashconfig->st_hash + j);
tmpdata[i] = c;
}
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, tmpdata, st_hash_len / 2);
hcfree (tmpdata);
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, header, VC_HEADER_LEN);
return parser_status;
}
@ -290,7 +282,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}

26
src/modules/module_13782.c
View File

@ -52,9 +52,10 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_HEADER_LEN 512
#define VC_SALT_LEN ( 64)
#define VC_DATA_LEN ( 448)
#define VC_HEADER_LEN ( 512)
#define VC_HEADER_HEX_LEN (VC_HEADER_LEN * 2)
typedef struct vc64_sbog_tmp
{
@ -75,7 +76,7 @@ typedef struct vc64_sbog_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -155,20 +156,11 @@ u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED con
int module_hash_init_selftest (MAYBE_UNUSED const hashconfig_t *hashconfig, hash_t *hash)
{
const size_t st_hash_len = strlen (hashconfig->st_hash);
char header[VC_HEADER_LEN + 1] = { 0 };
char *tmpdata = (char *) hcmalloc (st_hash_len / 2);
hex_decode ((const u8 *) hashconfig->st_hash, VC_HEADER_HEX_LEN, (u8 *) header);
for (size_t i = 0, j = 0; j < st_hash_len; i += 1, j += 2)
{
const u8 c = hex_to_u8 ((const u8 *) hashconfig->st_hash + j);
tmpdata[i] = c;
}
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, tmpdata, st_hash_len / 2);
hcfree (tmpdata);
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, header, VC_HEADER_LEN);
return parser_status;
}
@ -290,7 +282,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}

26
src/modules/module_13783.c
View File

@ -52,9 +52,10 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_HEADER_LEN 512
#define VC_SALT_LEN ( 64)
#define VC_DATA_LEN ( 448)
#define VC_HEADER_LEN ( 512)
#define VC_HEADER_HEX_LEN (VC_HEADER_LEN * 2)
typedef struct vc64_sbog_tmp
{
@ -75,7 +76,7 @@ typedef struct vc64_sbog_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -155,20 +156,11 @@ u32 module_pw_max (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED con
int module_hash_init_selftest (MAYBE_UNUSED const hashconfig_t *hashconfig, hash_t *hash)
{
const size_t st_hash_len = strlen (hashconfig->st_hash);
char header[VC_HEADER_LEN + 1] = { 0 };
char *tmpdata = (char *) hcmalloc (st_hash_len / 2);
hex_decode ((const u8 *) hashconfig->st_hash, VC_HEADER_HEX_LEN, (u8 *) header);
for (size_t i = 0, j = 0; j < st_hash_len; i += 1, j += 2)
{
const u8 c = hex_to_u8 ((const u8 *) hashconfig->st_hash + j);
tmpdata[i] = c;
}
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, tmpdata, st_hash_len / 2);
hcfree (tmpdata);
const int parser_status = module_hash_decode (hashconfig, hash->digest, hash->salt, hash->esalt, hash->hook_salt, hash->hash_info, header, VC_HEADER_LEN);
return parser_status;
}
@ -290,7 +282,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}

45
src/modules/module_29411.c
View File

@ -48,8 +48,11 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_SALT_LEN ( 64)
#define VC_SALT_HEX_LEN (VC_SALT_LEN * 2)
#define VC_DATA_LEN ( 448)
#define VC_DATA_HEX_LEN (VC_DATA_LEN * 2)
typedef struct vc_tmp
{
@ -67,7 +70,7 @@ typedef struct vc_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -165,12 +168,12 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
| TOKEN_ATTR_VERIFY_SIGNATURE;
token.sep[1] = '$';
token.len[1] = 128;
token.len[1] = VC_SALT_HEX_LEN;
token.attr[1] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[2] = '$';
token.len[2] = 896;
token.len[2] = VC_DATA_HEX_LEN;
token.attr[2] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
@ -182,12 +185,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *salt_pos = token.buf[1];
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
salt->salt_buf[i] = hex_to_u32 (salt_pos + j);
}
salt->salt_len = VC_SALT_LEN;
salt->salt_len = hex_decode (salt_pos, VC_SALT_HEX_LEN, (u8 *) salt->salt_buf);
// iter
@ -197,10 +195,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *data_pos = token.buf[2];
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
vc->data_buf[i] = hex_to_u32 (data_pos + j);
}
hex_decode (data_pos, VC_DATA_HEX_LEN, (u8 *) vc->data_buf);
// entropy
@ -220,7 +215,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}
@ -284,25 +279,15 @@ int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// salt
#define SALT_HEX_LEN VC_SALT_LEN * 2 + 1
char salt_buf[VC_SALT_HEX_LEN + 1] = { 0 };
char salt_buf[SALT_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
snprintf (salt_buf + j, SALT_HEX_LEN - j, "%08x", byte_swap_32 (salt->salt_buf[i]));
}
hex_encode ((const u8 *) salt->salt_buf, VC_SALT_LEN, (u8 *) salt_buf);
// data
#define DATA_HEX_LEN VC_DATA_LEN * 2 + 1
char data_buf[VC_DATA_HEX_LEN + 1] = { 0 };
char data_buf[DATA_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
snprintf (data_buf + j, DATA_HEX_LEN - j, "%08x", byte_swap_32 (vc->data_buf[i]));
}
hex_encode ((const u8 *) vc->data_buf, VC_DATA_LEN, (u8 *) data_buf);
// output

45
src/modules/module_29412.c
View File

@ -48,8 +48,11 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_SALT_LEN ( 64)
#define VC_SALT_HEX_LEN (VC_SALT_LEN * 2)
#define VC_DATA_LEN ( 448)
#define VC_DATA_HEX_LEN (VC_DATA_LEN * 2)
typedef struct vc_tmp
{
@ -67,7 +70,7 @@ typedef struct vc_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -165,12 +168,12 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
| TOKEN_ATTR_VERIFY_SIGNATURE;
token.sep[1] = '$';
token.len[1] = 128;
token.len[1] = VC_SALT_HEX_LEN;
token.attr[1] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[2] = '$';
token.len[2] = 896;
token.len[2] = VC_DATA_HEX_LEN;
token.attr[2] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
@ -182,12 +185,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *salt_pos = token.buf[1];
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
salt->salt_buf[i] = hex_to_u32 (salt_pos + j);
}
salt->salt_len = VC_SALT_LEN;
salt->salt_len = hex_decode (salt_pos, VC_SALT_HEX_LEN, (u8 *) salt->salt_buf);
// iter
@ -197,10 +195,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *data_pos = token.buf[2];
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
vc->data_buf[i] = hex_to_u32 (data_pos + j);
}
hex_decode (data_pos, VC_DATA_HEX_LEN, (u8 *) vc->data_buf);
// entropy
@ -220,7 +215,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}
@ -284,25 +279,15 @@ int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// salt
#define SALT_HEX_LEN VC_SALT_LEN * 2 + 1
char salt_buf[VC_SALT_HEX_LEN + 1] = { 0 };
char salt_buf[SALT_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
snprintf (salt_buf + j, SALT_HEX_LEN - j, "%08x", byte_swap_32 (salt->salt_buf[i]));
}
hex_encode ((const u8 *) salt->salt_buf, VC_SALT_LEN, (u8 *) salt_buf);
// data
#define DATA_HEX_LEN VC_DATA_LEN * 2 + 1
char data_buf[VC_DATA_HEX_LEN + 1] = { 0 };
char data_buf[DATA_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
snprintf (data_buf + j, DATA_HEX_LEN - j, "%08x", byte_swap_32 (vc->data_buf[i]));
}
hex_encode ((const u8 *) vc->data_buf, VC_DATA_LEN, (u8 *) data_buf);
// output

45
src/modules/module_29413.c
View File

@ -48,8 +48,11 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_SALT_LEN ( 64)
#define VC_SALT_HEX_LEN (VC_SALT_LEN * 2)
#define VC_DATA_LEN ( 448)
#define VC_DATA_HEX_LEN (VC_DATA_LEN * 2)
typedef struct vc_tmp
{
@ -67,7 +70,7 @@ typedef struct vc_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -165,12 +168,12 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
| TOKEN_ATTR_VERIFY_SIGNATURE;
token.sep[1] = '$';
token.len[1] = 128;
token.len[1] = VC_SALT_HEX_LEN;
token.attr[1] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[2] = '$';
token.len[2] = 896;
token.len[2] = VC_DATA_HEX_LEN;
token.attr[2] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
@ -182,12 +185,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *salt_pos = token.buf[1];
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
salt->salt_buf[i] = hex_to_u32 (salt_pos + j);
}
salt->salt_len = VC_SALT_LEN;
salt->salt_len = hex_decode (salt_pos, VC_SALT_HEX_LEN, (u8 *) salt->salt_buf);
// iter
@ -197,10 +195,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *data_pos = token.buf[2];
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
vc->data_buf[i] = hex_to_u32 (data_pos + j);
}
hex_decode (data_pos, VC_DATA_HEX_LEN, (u8 *) vc->data_buf);
// entropy
@ -220,7 +215,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}
@ -284,25 +279,15 @@ int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// salt
#define SALT_HEX_LEN VC_SALT_LEN * 2 + 1
char salt_buf[VC_SALT_HEX_LEN + 1] = { 0 };
char salt_buf[SALT_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
snprintf (salt_buf + j, SALT_HEX_LEN - j, "%08x", byte_swap_32 (salt->salt_buf[i]));
}
hex_encode ((const u8 *) salt->salt_buf, VC_SALT_LEN, (u8 *) salt_buf);
// data
#define DATA_HEX_LEN VC_DATA_LEN * 2 + 1
char data_buf[VC_DATA_HEX_LEN + 1] = { 0 };
char data_buf[DATA_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
snprintf (data_buf + j, DATA_HEX_LEN - j, "%08x", byte_swap_32 (vc->data_buf[i]));
}
hex_encode ((const u8 *) vc->data_buf, VC_DATA_LEN, (u8 *) data_buf);
// output

45
src/modules/module_29421.c
View File

@ -50,8 +50,11 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_SALT_LEN ( 64)
#define VC_SALT_HEX_LEN (VC_SALT_LEN * 2)
#define VC_DATA_LEN ( 448)
#define VC_DATA_HEX_LEN (VC_DATA_LEN * 2)
typedef struct vc64_tmp
{
@ -69,7 +72,7 @@ typedef struct vc64_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -176,12 +179,12 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
| TOKEN_ATTR_VERIFY_SIGNATURE;
token.sep[1] = '$';
token.len[1] = 128;
token.len[1] = VC_SALT_HEX_LEN;
token.attr[1] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[2] = '$';
token.len[2] = 896;
token.len[2] = VC_DATA_HEX_LEN;
token.attr[2] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
@ -193,12 +196,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *salt_pos = token.buf[1];
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
salt->salt_buf[i] = hex_to_u32 (salt_pos + j);
}
salt->salt_len = VC_SALT_LEN;
salt->salt_len = hex_decode (salt_pos, VC_SALT_HEX_LEN, (u8 *) salt->salt_buf);
// iter
@ -208,10 +206,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *data_pos = token.buf[2];
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
vc->data_buf[i] = hex_to_u32 (data_pos + j);
}
hex_decode (data_pos, VC_DATA_HEX_LEN, (u8 *) vc->data_buf);
// entropy
@ -231,7 +226,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}
@ -295,25 +290,15 @@ int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// salt
#define SALT_HEX_LEN VC_SALT_LEN * 2 + 1
char salt_buf[VC_SALT_HEX_LEN + 1] = { 0 };
char salt_buf[SALT_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
snprintf (salt_buf + j, SALT_HEX_LEN - j, "%08x", byte_swap_32 (salt->salt_buf[i]));
}
hex_encode ((const u8 *) salt->salt_buf, VC_SALT_LEN, (u8 *) salt_buf);
// data
#define DATA_HEX_LEN VC_DATA_LEN * 2 + 1
char data_buf[VC_DATA_HEX_LEN + 1] = { 0 };
char data_buf[DATA_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
snprintf (data_buf + j, DATA_HEX_LEN - j, "%08x", byte_swap_32 (vc->data_buf[i]));
}
hex_encode ((const u8 *) vc->data_buf, VC_DATA_LEN, (u8 *) data_buf);
// output

45
src/modules/module_29422.c
View File

@ -50,8 +50,11 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_SALT_LEN ( 64)
#define VC_SALT_HEX_LEN (VC_SALT_LEN * 2)
#define VC_DATA_LEN ( 448)
#define VC_DATA_HEX_LEN (VC_DATA_LEN * 2)
typedef struct vc64_tmp
{
@ -69,7 +72,7 @@ typedef struct vc64_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -176,12 +179,12 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
| TOKEN_ATTR_VERIFY_SIGNATURE;
token.sep[1] = '$';
token.len[1] = 128;
token.len[1] = VC_SALT_HEX_LEN;
token.attr[1] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[2] = '$';
token.len[2] = 896;
token.len[2] = VC_DATA_HEX_LEN;
token.attr[2] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
@ -193,12 +196,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *salt_pos = token.buf[1];
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
salt->salt_buf[i] = hex_to_u32 (salt_pos + j);
}
salt->salt_len = VC_SALT_LEN;
salt->salt_len = hex_decode (salt_pos, VC_SALT_HEX_LEN, (u8 *) salt->salt_buf);
// iter
@ -208,10 +206,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *data_pos = token.buf[2];
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
vc->data_buf[i] = hex_to_u32 (data_pos + j);
}
hex_decode (data_pos, VC_DATA_HEX_LEN, (u8 *) vc->data_buf);
// entropy
@ -231,7 +226,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}
@ -295,25 +290,15 @@ int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// salt
#define SALT_HEX_LEN VC_SALT_LEN * 2 + 1
char salt_buf[VC_SALT_HEX_LEN + 1] = { 0 };
char salt_buf[SALT_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
snprintf (salt_buf + j, SALT_HEX_LEN - j, "%08x", byte_swap_32 (salt->salt_buf[i]));
}
hex_encode ((const u8 *) salt->salt_buf, VC_SALT_LEN, (u8 *) salt_buf);
// data
#define DATA_HEX_LEN VC_DATA_LEN * 2 + 1
char data_buf[VC_DATA_HEX_LEN + 1] = { 0 };
char data_buf[DATA_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
snprintf (data_buf + j, DATA_HEX_LEN - j, "%08x", byte_swap_32 (vc->data_buf[i]));
}
hex_encode ((const u8 *) vc->data_buf, VC_DATA_LEN, (u8 *) data_buf);
// output

45
src/modules/module_29423.c
View File

@ -50,8 +50,11 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_SALT_LEN ( 64)
#define VC_SALT_HEX_LEN (VC_SALT_LEN * 2)
#define VC_DATA_LEN ( 448)
#define VC_DATA_HEX_LEN (VC_DATA_LEN * 2)
typedef struct vc64_tmp
{
@ -69,7 +72,7 @@ typedef struct vc64_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -176,12 +179,12 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
| TOKEN_ATTR_VERIFY_SIGNATURE;
token.sep[1] = '$';
token.len[1] = 128;
token.len[1] = VC_SALT_HEX_LEN;
token.attr[1] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[2] = '$';
token.len[2] = 896;
token.len[2] = VC_DATA_HEX_LEN;
token.attr[2] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
@ -193,12 +196,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *salt_pos = token.buf[1];
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
salt->salt_buf[i] = hex_to_u32 (salt_pos + j);
}
salt->salt_len = VC_SALT_LEN;
salt->salt_len = hex_decode (salt_pos, VC_SALT_HEX_LEN, (u8 *) salt->salt_buf);
// iter
@ -208,10 +206,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *data_pos = token.buf[2];
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
vc->data_buf[i] = hex_to_u32 (data_pos + j);
}
hex_decode (data_pos, VC_DATA_HEX_LEN, (u8 *) vc->data_buf);
// entropy
@ -231,7 +226,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}
@ -295,25 +290,15 @@ int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// salt
#define SALT_HEX_LEN VC_SALT_LEN * 2 + 1
char salt_buf[VC_SALT_HEX_LEN + 1] = { 0 };
char salt_buf[SALT_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
snprintf (salt_buf + j, SALT_HEX_LEN - j, "%08x", byte_swap_32 (salt->salt_buf[i]));
}
hex_encode ((const u8 *) salt->salt_buf, VC_SALT_LEN, (u8 *) salt_buf);
// data
#define DATA_HEX_LEN VC_DATA_LEN * 2 + 1
char data_buf[VC_DATA_HEX_LEN + 1] = { 0 };
char data_buf[DATA_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
snprintf (data_buf + j, DATA_HEX_LEN - j, "%08x", byte_swap_32 (vc->data_buf[i]));
}
hex_encode ((const u8 *) vc->data_buf, VC_DATA_LEN, (u8 *) data_buf);
// output

45
src/modules/module_29431.c
View File

@ -49,8 +49,11 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_SALT_LEN ( 64)
#define VC_SALT_HEX_LEN (VC_SALT_LEN * 2)
#define VC_DATA_LEN ( 448)
#define VC_DATA_HEX_LEN (VC_DATA_LEN * 2)
typedef struct vc_tmp
{
@ -68,7 +71,7 @@ typedef struct vc_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -152,12 +155,12 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
| TOKEN_ATTR_VERIFY_SIGNATURE;
token.sep[1] = '$';
token.len[1] = 128;
token.len[1] = VC_SALT_HEX_LEN;
token.attr[1] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[2] = '$';
token.len[2] = 896;
token.len[2] = VC_DATA_HEX_LEN;
token.attr[2] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
@ -169,12 +172,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *salt_pos = token.buf[1];
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
salt->salt_buf[i] = hex_to_u32 (salt_pos + j);
}
salt->salt_len = VC_SALT_LEN;
salt->salt_len = hex_decode (salt_pos, VC_SALT_HEX_LEN, (u8 *) salt->salt_buf);
// iter
@ -184,10 +182,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *data_pos = token.buf[2];
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
vc->data_buf[i] = hex_to_u32 (data_pos + j);
}
hex_decode (data_pos, VC_DATA_HEX_LEN, (u8 *) vc->data_buf);
// entropy
@ -207,7 +202,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}
@ -271,25 +266,15 @@ int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// salt
#define SALT_HEX_LEN VC_SALT_LEN * 2 + 1
char salt_buf[VC_SALT_HEX_LEN + 1] = { 0 };
char salt_buf[SALT_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
snprintf (salt_buf + j, SALT_HEX_LEN - j, "%08x", byte_swap_32 (salt->salt_buf[i]));
}
hex_encode ((const u8 *) salt->salt_buf, VC_SALT_LEN, (u8 *) salt_buf);
// data
#define DATA_HEX_LEN VC_DATA_LEN * 2 + 1
char data_buf[VC_DATA_HEX_LEN + 1] = { 0 };
char data_buf[DATA_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
snprintf (data_buf + j, DATA_HEX_LEN - j, "%08x", byte_swap_32 (vc->data_buf[i]));
}
hex_encode ((const u8 *) vc->data_buf, VC_DATA_LEN, (u8 *) data_buf);
// output

45
src/modules/module_29432.c
View File

@ -49,8 +49,11 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_SALT_LEN ( 64)
#define VC_SALT_HEX_LEN (VC_SALT_LEN * 2)
#define VC_DATA_LEN ( 448)
#define VC_DATA_HEX_LEN (VC_DATA_LEN * 2)
typedef struct vc_tmp
{
@ -68,7 +71,7 @@ typedef struct vc_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -152,12 +155,12 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
| TOKEN_ATTR_VERIFY_SIGNATURE;
token.sep[1] = '$';
token.len[1] = 128;
token.len[1] = VC_SALT_HEX_LEN;
token.attr[1] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[2] = '$';
token.len[2] = 896;
token.len[2] = VC_DATA_HEX_LEN;
token.attr[2] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
@ -169,12 +172,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *salt_pos = token.buf[1];
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
salt->salt_buf[i] = hex_to_u32 (salt_pos + j);
}
salt->salt_len = VC_SALT_LEN;
salt->salt_len = hex_decode (salt_pos, VC_SALT_HEX_LEN, (u8 *) salt->salt_buf);
// iter
@ -184,10 +182,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *data_pos = token.buf[2];
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
vc->data_buf[i] = hex_to_u32 (data_pos + j);
}
hex_decode (data_pos, VC_DATA_HEX_LEN, (u8 *) vc->data_buf);
// entropy
@ -207,7 +202,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}
@ -271,25 +266,15 @@ int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// salt
#define SALT_HEX_LEN VC_SALT_LEN * 2 + 1
char salt_buf[VC_SALT_HEX_LEN + 1] = { 0 };
char salt_buf[SALT_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
snprintf (salt_buf + j, SALT_HEX_LEN - j, "%08x", byte_swap_32 (salt->salt_buf[i]));
}
hex_encode ((const u8 *) salt->salt_buf, VC_SALT_LEN, (u8 *) salt_buf);
// data
#define DATA_HEX_LEN VC_DATA_LEN * 2 + 1
char data_buf[VC_DATA_HEX_LEN + 1] = { 0 };
char data_buf[DATA_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
snprintf (data_buf + j, DATA_HEX_LEN - j, "%08x", byte_swap_32 (vc->data_buf[i]));
}
hex_encode ((const u8 *) vc->data_buf, VC_DATA_LEN, (u8 *) data_buf);
// output

45
src/modules/module_29433.c
View File

@ -49,8 +49,11 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_SALT_LEN ( 64)
#define VC_SALT_HEX_LEN (VC_SALT_LEN * 2)
#define VC_DATA_LEN ( 448)
#define VC_DATA_HEX_LEN (VC_DATA_LEN * 2)
typedef struct vc_tmp
{
@ -68,7 +71,7 @@ typedef struct vc_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -166,12 +169,12 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
| TOKEN_ATTR_VERIFY_SIGNATURE;
token.sep[1] = '$';
token.len[1] = 128;
token.len[1] = VC_SALT_HEX_LEN;
token.attr[1] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[2] = '$';
token.len[2] = 896;
token.len[2] = VC_DATA_HEX_LEN;
token.attr[2] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
@ -183,12 +186,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *salt_pos = token.buf[1];
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
salt->salt_buf[i] = hex_to_u32 (salt_pos + j);
}
salt->salt_len = VC_SALT_LEN;
salt->salt_len = hex_decode (salt_pos, VC_SALT_HEX_LEN, (u8 *) salt->salt_buf);
// iter
@ -198,10 +196,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *data_pos = token.buf[2];
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
vc->data_buf[i] = hex_to_u32 (data_pos + j);
}
hex_decode (data_pos, VC_DATA_HEX_LEN, (u8 *) vc->data_buf);
// entropy
@ -221,7 +216,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}
@ -285,25 +280,15 @@ int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// salt
#define SALT_HEX_LEN VC_SALT_LEN * 2 + 1
char salt_buf[VC_SALT_HEX_LEN + 1] = { 0 };
char salt_buf[SALT_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
snprintf (salt_buf + j, SALT_HEX_LEN - j, "%08x", byte_swap_32 (salt->salt_buf[i]));
}
hex_encode ((const u8 *) salt->salt_buf, VC_SALT_LEN, (u8 *) salt_buf);
// data
#define DATA_HEX_LEN VC_DATA_LEN * 2 + 1
char data_buf[VC_DATA_HEX_LEN + 1] = { 0 };
char data_buf[DATA_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
snprintf (data_buf + j, DATA_HEX_LEN - j, "%08x", byte_swap_32 (vc->data_buf[i]));
}
hex_encode ((const u8 *) vc->data_buf, VC_DATA_LEN, (u8 *) data_buf);
// output

45
src/modules/module_29441.c
View File

@ -49,8 +49,11 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_SALT_LEN ( 64)
#define VC_SALT_HEX_LEN (VC_SALT_LEN * 2)
#define VC_DATA_LEN ( 448)
#define VC_DATA_HEX_LEN (VC_DATA_LEN * 2)
typedef struct vc_tmp
{
@ -68,7 +71,7 @@ typedef struct vc_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -167,12 +170,12 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
| TOKEN_ATTR_VERIFY_SIGNATURE;
token.sep[1] = '$';
token.len[1] = 128;
token.len[1] = VC_SALT_HEX_LEN;
token.attr[1] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[2] = '$';
token.len[2] = 896;
token.len[2] = VC_DATA_HEX_LEN;
token.attr[2] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
@ -184,12 +187,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *salt_pos = token.buf[1];
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
salt->salt_buf[i] = hex_to_u32 (salt_pos + j);
}
salt->salt_len = VC_SALT_LEN;
salt->salt_len = hex_decode (salt_pos, VC_SALT_HEX_LEN, (u8 *) salt->salt_buf);
// iter
@ -199,10 +197,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *data_pos = token.buf[2];
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
vc->data_buf[i] = hex_to_u32 (data_pos + j);
}
hex_decode (data_pos, VC_DATA_HEX_LEN, (u8 *) vc->data_buf);
// entropy
@ -222,7 +217,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}
@ -286,25 +281,15 @@ int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// salt
#define SALT_HEX_LEN VC_SALT_LEN * 2 + 1
char salt_buf[VC_SALT_HEX_LEN + 1] = { 0 };
char salt_buf[SALT_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
snprintf (salt_buf + j, SALT_HEX_LEN - j, "%08x", byte_swap_32 (salt->salt_buf[i]));
}
hex_encode ((const u8 *) salt->salt_buf, VC_SALT_LEN, (u8 *) salt_buf);
// data
#define DATA_HEX_LEN VC_DATA_LEN * 2 + 1
char data_buf[VC_DATA_HEX_LEN + 1] = { 0 };
char data_buf[DATA_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
snprintf (data_buf + j, DATA_HEX_LEN - j, "%08x", byte_swap_32 (vc->data_buf[i]));
}
hex_encode ((const u8 *) vc->data_buf, VC_DATA_LEN, (u8 *) data_buf);
// output

45
src/modules/module_29442.c
View File

@ -49,8 +49,11 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_SALT_LEN ( 64)
#define VC_SALT_HEX_LEN (VC_SALT_LEN * 2)
#define VC_DATA_LEN ( 448)
#define VC_DATA_HEX_LEN (VC_DATA_LEN * 2)
typedef struct vc_tmp
{
@ -68,7 +71,7 @@ typedef struct vc_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -167,12 +170,12 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
| TOKEN_ATTR_VERIFY_SIGNATURE;
token.sep[1] = '$';
token.len[1] = 128;
token.len[1] = VC_SALT_HEX_LEN;
token.attr[1] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[2] = '$';
token.len[2] = 896;
token.len[2] = VC_DATA_HEX_LEN;
token.attr[2] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
@ -184,12 +187,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *salt_pos = token.buf[1];
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
salt->salt_buf[i] = hex_to_u32 (salt_pos + j);
}
salt->salt_len = VC_SALT_LEN;
salt->salt_len = hex_decode (salt_pos, VC_SALT_HEX_LEN, (u8 *) salt->salt_buf);
// iter
@ -199,10 +197,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *data_pos = token.buf[2];
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
vc->data_buf[i] = hex_to_u32 (data_pos + j);
}
hex_decode (data_pos, VC_DATA_HEX_LEN, (u8 *) vc->data_buf);
// entropy
@ -222,7 +217,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}
@ -286,25 +281,15 @@ int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// salt
#define SALT_HEX_LEN VC_SALT_LEN * 2 + 1
char salt_buf[VC_SALT_HEX_LEN + 1] = { 0 };
char salt_buf[SALT_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
snprintf (salt_buf + j, SALT_HEX_LEN - j, "%08x", byte_swap_32 (salt->salt_buf[i]));
}
hex_encode ((const u8 *) salt->salt_buf, VC_SALT_LEN, (u8 *) salt_buf);
// data
#define DATA_HEX_LEN VC_DATA_LEN * 2 + 1
char data_buf[VC_DATA_HEX_LEN + 1] = { 0 };
char data_buf[DATA_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
snprintf (data_buf + j, DATA_HEX_LEN - j, "%08x", byte_swap_32 (vc->data_buf[i]));
}
hex_encode ((const u8 *) vc->data_buf, VC_DATA_LEN, (u8 *) data_buf);
// output

45
src/modules/module_29443.c
View File

@ -49,8 +49,11 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_SALT_LEN ( 64)
#define VC_SALT_HEX_LEN (VC_SALT_LEN * 2)
#define VC_DATA_LEN ( 448)
#define VC_DATA_HEX_LEN (VC_DATA_LEN * 2)
typedef struct vc_tmp
{
@ -68,7 +71,7 @@ typedef struct vc_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -167,12 +170,12 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
| TOKEN_ATTR_VERIFY_SIGNATURE;
token.sep[1] = '$';
token.len[1] = 128;
token.len[1] = VC_SALT_HEX_LEN;
token.attr[1] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[2] = '$';
token.len[2] = 896;
token.len[2] = VC_DATA_HEX_LEN;
token.attr[2] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
@ -184,12 +187,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *salt_pos = token.buf[1];
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
salt->salt_buf[i] = hex_to_u32 (salt_pos + j);
}
salt->salt_len = VC_SALT_LEN;
salt->salt_len = hex_decode (salt_pos, VC_SALT_HEX_LEN, (u8 *) salt->salt_buf);
// iter
@ -199,10 +197,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *data_pos = token.buf[2];
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
vc->data_buf[i] = hex_to_u32 (data_pos + j);
}
hex_decode (data_pos, VC_DATA_HEX_LEN, (u8 *) vc->data_buf);
// entropy
@ -222,7 +217,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}
@ -286,25 +281,15 @@ int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// salt
#define SALT_HEX_LEN VC_SALT_LEN * 2 + 1
char salt_buf[VC_SALT_HEX_LEN + 1] = { 0 };
char salt_buf[SALT_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
snprintf (salt_buf + j, SALT_HEX_LEN - j, "%08x", byte_swap_32 (salt->salt_buf[i]));
}
hex_encode ((const u8 *) salt->salt_buf, VC_SALT_LEN, (u8 *) salt_buf);
// data
#define DATA_HEX_LEN VC_DATA_LEN * 2 + 1
char data_buf[VC_DATA_HEX_LEN + 1] = { 0 };
char data_buf[DATA_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
snprintf (data_buf + j, DATA_HEX_LEN - j, "%08x", byte_swap_32 (vc->data_buf[i]));
}
hex_encode ((const u8 *) vc->data_buf, VC_DATA_LEN, (u8 *) data_buf);
// output

45
src/modules/module_29451.c
View File

@ -48,8 +48,11 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_SALT_LEN ( 64)
#define VC_SALT_HEX_LEN (VC_SALT_LEN * 2)
#define VC_DATA_LEN ( 448)
#define VC_DATA_HEX_LEN (VC_DATA_LEN * 2)
typedef struct vc_tmp
{
@ -67,7 +70,7 @@ typedef struct vc_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -184,12 +187,12 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
| TOKEN_ATTR_VERIFY_SIGNATURE;
token.sep[1] = '$';
token.len[1] = 128;
token.len[1] = VC_SALT_HEX_LEN;
token.attr[1] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[2] = '$';
token.len[2] = 896;
token.len[2] = VC_DATA_HEX_LEN;
token.attr[2] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
@ -201,12 +204,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *salt_pos = token.buf[1];
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
salt->salt_buf[i] = hex_to_u32 (salt_pos + j);
}
salt->salt_len = VC_SALT_LEN;
salt->salt_len = hex_decode (salt_pos, VC_SALT_HEX_LEN, (u8 *) salt->salt_buf);
// iter
@ -216,10 +214,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *data_pos = token.buf[2];
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
vc->data_buf[i] = hex_to_u32 (data_pos + j);
}
hex_decode (data_pos, VC_DATA_HEX_LEN, (u8 *) vc->data_buf);
// entropy
@ -239,7 +234,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}
@ -303,25 +298,15 @@ int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// salt
#define SALT_HEX_LEN VC_SALT_LEN * 2 + 1
char salt_buf[VC_SALT_HEX_LEN + 1] = { 0 };
char salt_buf[SALT_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
snprintf (salt_buf + j, SALT_HEX_LEN - j, "%08x", byte_swap_32 (salt->salt_buf[i]));
}
hex_encode ((const u8 *) salt->salt_buf, VC_SALT_LEN, (u8 *) salt_buf);
// data
#define DATA_HEX_LEN VC_DATA_LEN * 2 + 1
char data_buf[VC_DATA_HEX_LEN + 1] = { 0 };
char data_buf[DATA_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
snprintf (data_buf + j, DATA_HEX_LEN - j, "%08x", byte_swap_32 (vc->data_buf[i]));
}
hex_encode ((const u8 *) vc->data_buf, VC_DATA_LEN, (u8 *) data_buf);
// output

45
src/modules/module_29452.c
View File

@ -48,8 +48,11 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_SALT_LEN ( 64)
#define VC_SALT_HEX_LEN (VC_SALT_LEN * 2)
#define VC_DATA_LEN ( 448)
#define VC_DATA_HEX_LEN (VC_DATA_LEN * 2)
typedef struct vc_tmp
{
@ -67,7 +70,7 @@ typedef struct vc_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -184,12 +187,12 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
| TOKEN_ATTR_VERIFY_SIGNATURE;
token.sep[1] = '$';
token.len[1] = 128;
token.len[1] = VC_SALT_HEX_LEN;
token.attr[1] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[2] = '$';
token.len[2] = 896;
token.len[2] = VC_DATA_HEX_LEN;
token.attr[2] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
@ -201,12 +204,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *salt_pos = token.buf[1];
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
salt->salt_buf[i] = hex_to_u32 (salt_pos + j);
}
salt->salt_len = VC_SALT_LEN;
salt->salt_len = hex_decode (salt_pos, VC_SALT_HEX_LEN, (u8 *) salt->salt_buf);
// iter
@ -216,10 +214,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *data_pos = token.buf[2];
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
vc->data_buf[i] = hex_to_u32 (data_pos + j);
}
hex_decode (data_pos, VC_DATA_HEX_LEN, (u8 *) vc->data_buf);
// entropy
@ -239,7 +234,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}
@ -303,25 +298,15 @@ int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// salt
#define SALT_HEX_LEN VC_SALT_LEN * 2 + 1
char salt_buf[VC_SALT_HEX_LEN + 1] = { 0 };
char salt_buf[SALT_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
snprintf (salt_buf + j, SALT_HEX_LEN - j, "%08x", byte_swap_32 (salt->salt_buf[i]));
}
hex_encode ((const u8 *) salt->salt_buf, VC_SALT_LEN, (u8 *) salt_buf);
// data
#define DATA_HEX_LEN VC_DATA_LEN * 2 + 1
char data_buf[VC_DATA_HEX_LEN + 1] = { 0 };
char data_buf[DATA_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
snprintf (data_buf + j, DATA_HEX_LEN - j, "%08x", byte_swap_32 (vc->data_buf[i]));
}
hex_encode ((const u8 *) vc->data_buf, VC_DATA_LEN, (u8 *) data_buf);
// output

45
src/modules/module_29453.c
View File

@ -48,8 +48,11 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_SALT_LEN ( 64)
#define VC_SALT_HEX_LEN (VC_SALT_LEN * 2)
#define VC_DATA_LEN ( 448)
#define VC_DATA_HEX_LEN (VC_DATA_LEN * 2)
typedef struct vc_tmp
{
@ -67,7 +70,7 @@ typedef struct vc_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -184,12 +187,12 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
| TOKEN_ATTR_VERIFY_SIGNATURE;
token.sep[1] = '$';
token.len[1] = 128;
token.len[1] = VC_SALT_HEX_LEN;
token.attr[1] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[2] = '$';
token.len[2] = 896;
token.len[2] = VC_DATA_HEX_LEN;
token.attr[2] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
@ -201,12 +204,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *salt_pos = token.buf[1];
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
salt->salt_buf[i] = hex_to_u32 (salt_pos + j);
}
salt->salt_len = VC_SALT_LEN;
salt->salt_len = hex_decode (salt_pos, VC_SALT_HEX_LEN, (u8 *) salt->salt_buf);
// iter
@ -216,10 +214,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *data_pos = token.buf[2];
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
vc->data_buf[i] = hex_to_u32 (data_pos + j);
}
hex_decode (data_pos, VC_DATA_HEX_LEN, (u8 *) vc->data_buf);
// entropy
@ -239,7 +234,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}
@ -303,25 +298,15 @@ int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// salt
#define SALT_HEX_LEN VC_SALT_LEN * 2 + 1
char salt_buf[VC_SALT_HEX_LEN + 1] = { 0 };
char salt_buf[SALT_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
snprintf (salt_buf + j, SALT_HEX_LEN - j, "%08x", byte_swap_32 (salt->salt_buf[i]));
}
hex_encode ((const u8 *) salt->salt_buf, VC_SALT_LEN, (u8 *) salt_buf);
// data
#define DATA_HEX_LEN VC_DATA_LEN * 2 + 1
char data_buf[VC_DATA_HEX_LEN + 1] = { 0 };
char data_buf[DATA_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
snprintf (data_buf + j, DATA_HEX_LEN - j, "%08x", byte_swap_32 (vc->data_buf[i]));
}
hex_encode ((const u8 *) vc->data_buf, VC_DATA_LEN, (u8 *) data_buf);
// output

45
src/modules/module_29461.c
View File

@ -49,8 +49,11 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_SALT_LEN ( 64)
#define VC_SALT_HEX_LEN (VC_SALT_LEN * 2)
#define VC_DATA_LEN ( 448)
#define VC_DATA_HEX_LEN (VC_DATA_LEN * 2)
typedef struct vc_tmp
{
@ -68,7 +71,7 @@ typedef struct vc_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -186,12 +189,12 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
| TOKEN_ATTR_VERIFY_SIGNATURE;
token.sep[1] = '$';
token.len[1] = 128;
token.len[1] = VC_SALT_HEX_LEN;
token.attr[1] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[2] = '$';
token.len[2] = 896;
token.len[2] = VC_DATA_HEX_LEN;
token.attr[2] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
@ -203,12 +206,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *salt_pos = token.buf[1];
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
salt->salt_buf[i] = hex_to_u32 (salt_pos + j);
}
salt->salt_len = VC_SALT_LEN;
salt->salt_len = hex_decode (salt_pos, VC_SALT_HEX_LEN, (u8 *) salt->salt_buf);
// iter
@ -218,10 +216,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *data_pos = token.buf[2];
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
vc->data_buf[i] = hex_to_u32 (data_pos + j);
}
hex_decode (data_pos, VC_DATA_HEX_LEN, (u8 *) vc->data_buf);
// entropy
@ -241,7 +236,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}
@ -305,25 +300,15 @@ int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// salt
#define SALT_HEX_LEN VC_SALT_LEN * 2 + 1
char salt_buf[VC_SALT_HEX_LEN + 1] = { 0 };
char salt_buf[SALT_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
snprintf (salt_buf + j, SALT_HEX_LEN - j, "%08x", byte_swap_32 (salt->salt_buf[i]));
}
hex_encode ((const u8 *) salt->salt_buf, VC_SALT_LEN, (u8 *) salt_buf);
// data
#define DATA_HEX_LEN VC_DATA_LEN * 2 + 1
char data_buf[VC_DATA_HEX_LEN + 1] = { 0 };
char data_buf[DATA_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
snprintf (data_buf + j, DATA_HEX_LEN - j, "%08x", byte_swap_32 (vc->data_buf[i]));
}
hex_encode ((const u8 *) vc->data_buf, VC_DATA_LEN, (u8 *) data_buf);
// output

45
src/modules/module_29462.c
View File

@ -49,8 +49,11 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_SALT_LEN ( 64)
#define VC_SALT_HEX_LEN (VC_SALT_LEN * 2)
#define VC_DATA_LEN ( 448)
#define VC_DATA_HEX_LEN (VC_DATA_LEN * 2)
typedef struct vc_tmp
{
@ -68,7 +71,7 @@ typedef struct vc_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -186,12 +189,12 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
| TOKEN_ATTR_VERIFY_SIGNATURE;
token.sep[1] = '$';
token.len[1] = 128;
token.len[1] = VC_SALT_HEX_LEN;
token.attr[1] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[2] = '$';
token.len[2] = 896;
token.len[2] = VC_DATA_HEX_LEN;
token.attr[2] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
@ -203,12 +206,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *salt_pos = token.buf[1];
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
salt->salt_buf[i] = hex_to_u32 (salt_pos + j);
}
salt->salt_len = VC_SALT_LEN;
salt->salt_len = hex_decode (salt_pos, VC_SALT_HEX_LEN, (u8 *) salt->salt_buf);
// iter
@ -218,10 +216,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *data_pos = token.buf[2];
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
vc->data_buf[i] = hex_to_u32 (data_pos + j);
}
hex_decode (data_pos, VC_DATA_HEX_LEN, (u8 *) vc->data_buf);
// entropy
@ -241,7 +236,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}
@ -305,25 +300,15 @@ int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// salt
#define SALT_HEX_LEN VC_SALT_LEN * 2 + 1
char salt_buf[VC_SALT_HEX_LEN + 1] = { 0 };
char salt_buf[SALT_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
snprintf (salt_buf + j, SALT_HEX_LEN - j, "%08x", byte_swap_32 (salt->salt_buf[i]));
}
hex_encode ((const u8 *) salt->salt_buf, VC_SALT_LEN, (u8 *) salt_buf);
// data
#define DATA_HEX_LEN VC_DATA_LEN * 2 + 1
char data_buf[VC_DATA_HEX_LEN + 1] = { 0 };
char data_buf[DATA_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
snprintf (data_buf + j, DATA_HEX_LEN - j, "%08x", byte_swap_32 (vc->data_buf[i]));
}
hex_encode ((const u8 *) vc->data_buf, VC_DATA_LEN, (u8 *) data_buf);
// output

45
src/modules/module_29463.c
View File

@ -49,8 +49,11 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_SALT_LEN ( 64)
#define VC_SALT_HEX_LEN (VC_SALT_LEN * 2)
#define VC_DATA_LEN ( 448)
#define VC_DATA_HEX_LEN (VC_DATA_LEN * 2)
typedef struct vc_tmp
{
@ -68,7 +71,7 @@ typedef struct vc_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -186,12 +189,12 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
| TOKEN_ATTR_VERIFY_SIGNATURE;
token.sep[1] = '$';
token.len[1] = 128;
token.len[1] = VC_SALT_HEX_LEN;
token.attr[1] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[2] = '$';
token.len[2] = 896;
token.len[2] = VC_DATA_HEX_LEN;
token.attr[2] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
@ -203,12 +206,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *salt_pos = token.buf[1];
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
salt->salt_buf[i] = hex_to_u32 (salt_pos + j);
}
salt->salt_len = VC_SALT_LEN;
salt->salt_len = hex_decode (salt_pos, VC_SALT_HEX_LEN, (u8 *) salt->salt_buf);
// iter
@ -218,10 +216,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *data_pos = token.buf[2];
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
vc->data_buf[i] = hex_to_u32 (data_pos + j);
}
hex_decode (data_pos, VC_DATA_HEX_LEN, (u8 *) vc->data_buf);
// entropy
@ -241,7 +236,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}
@ -305,25 +300,15 @@ int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// salt
#define SALT_HEX_LEN VC_SALT_LEN * 2 + 1
char salt_buf[VC_SALT_HEX_LEN + 1] = { 0 };
char salt_buf[SALT_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
snprintf (salt_buf + j, SALT_HEX_LEN - j, "%08x", byte_swap_32 (salt->salt_buf[i]));
}
hex_encode ((const u8 *) salt->salt_buf, VC_SALT_LEN, (u8 *) salt_buf);
// data
#define DATA_HEX_LEN VC_DATA_LEN * 2 + 1
char data_buf[VC_DATA_HEX_LEN + 1] = { 0 };
char data_buf[DATA_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
snprintf (data_buf + j, DATA_HEX_LEN - j, "%08x", byte_swap_32 (vc->data_buf[i]));
}
hex_encode ((const u8 *) vc->data_buf, VC_DATA_LEN, (u8 *) data_buf);
// output

45
src/modules/module_29471.c
View File

@ -49,8 +49,11 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_SALT_LEN ( 64)
#define VC_SALT_HEX_LEN (VC_SALT_LEN * 2)
#define VC_DATA_LEN ( 448)
#define VC_DATA_HEX_LEN (VC_DATA_LEN * 2)
typedef struct vc64_sbog_tmp
{
@ -71,7 +74,7 @@ typedef struct vc64_sbog_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -175,12 +178,12 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
| TOKEN_ATTR_VERIFY_SIGNATURE;
token.sep[1] = '$';
token.len[1] = 128;
token.len[1] = VC_SALT_HEX_LEN;
token.attr[1] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[2] = '$';
token.len[2] = 896;
token.len[2] = VC_DATA_HEX_LEN;
token.attr[2] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
@ -192,12 +195,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *salt_pos = token.buf[1];
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
salt->salt_buf[i] = hex_to_u32 (salt_pos + j);
}
salt->salt_len = VC_SALT_LEN;
salt->salt_len = hex_decode (salt_pos, VC_SALT_HEX_LEN, (u8 *) salt->salt_buf);
// iter
@ -207,10 +205,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *data_pos = token.buf[2];
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
vc->data_buf[i] = hex_to_u32 (data_pos + j);
}
hex_decode (data_pos, VC_DATA_HEX_LEN, (u8 *) vc->data_buf);
// entropy
@ -230,7 +225,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}
@ -294,25 +289,15 @@ int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// salt
#define SALT_HEX_LEN VC_SALT_LEN * 2 + 1
char salt_buf[VC_SALT_HEX_LEN + 1] = { 0 };
char salt_buf[SALT_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
snprintf (salt_buf + j, SALT_HEX_LEN - j, "%08x", byte_swap_32 (salt->salt_buf[i]));
}
hex_encode ((const u8 *) salt->salt_buf, VC_SALT_LEN, (u8 *) salt_buf);
// data
#define DATA_HEX_LEN VC_DATA_LEN * 2 + 1
char data_buf[VC_DATA_HEX_LEN + 1] = { 0 };
char data_buf[DATA_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
snprintf (data_buf + j, DATA_HEX_LEN - j, "%08x", byte_swap_32 (vc->data_buf[i]));
}
hex_encode ((const u8 *) vc->data_buf, VC_DATA_LEN, (u8 *) data_buf);
// output

45
src/modules/module_29472.c
View File

@ -49,8 +49,11 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_SALT_LEN ( 64)
#define VC_SALT_HEX_LEN (VC_SALT_LEN * 2)
#define VC_DATA_LEN ( 448)
#define VC_DATA_HEX_LEN (VC_DATA_LEN * 2)
typedef struct vc64_sbog_tmp
{
@ -71,7 +74,7 @@ typedef struct vc64_sbog_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -175,12 +178,12 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
| TOKEN_ATTR_VERIFY_SIGNATURE;
token.sep[1] = '$';
token.len[1] = 128;
token.len[1] = VC_SALT_HEX_LEN;
token.attr[1] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[2] = '$';
token.len[2] = 896;
token.len[2] = VC_DATA_HEX_LEN;
token.attr[2] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
@ -192,12 +195,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *salt_pos = token.buf[1];
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
salt->salt_buf[i] = hex_to_u32 (salt_pos + j);
}
salt->salt_len = VC_SALT_LEN;
salt->salt_len = hex_decode (salt_pos, VC_SALT_HEX_LEN, (u8 *) salt->salt_buf);
// iter
@ -207,10 +205,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *data_pos = token.buf[2];
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
vc->data_buf[i] = hex_to_u32 (data_pos + j);
}
hex_decode (data_pos, VC_DATA_HEX_LEN, (u8 *) vc->data_buf);
// entropy
@ -230,7 +225,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}
@ -294,25 +289,15 @@ int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// salt
#define SALT_HEX_LEN VC_SALT_LEN * 2 + 1
char salt_buf[VC_SALT_HEX_LEN + 1] = { 0 };
char salt_buf[SALT_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
snprintf (salt_buf + j, SALT_HEX_LEN - j, "%08x", byte_swap_32 (salt->salt_buf[i]));
}
hex_encode ((const u8 *) salt->salt_buf, VC_SALT_LEN, (u8 *) salt_buf);
// data
#define DATA_HEX_LEN VC_DATA_LEN * 2 + 1
char data_buf[VC_DATA_HEX_LEN + 1] = { 0 };
char data_buf[DATA_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
snprintf (data_buf + j, DATA_HEX_LEN - j, "%08x", byte_swap_32 (vc->data_buf[i]));
}
hex_encode ((const u8 *) vc->data_buf, VC_DATA_LEN, (u8 *) data_buf);
// output

45
src/modules/module_29473.c
View File

@ -49,8 +49,11 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_SALT_LEN ( 64)
#define VC_SALT_HEX_LEN (VC_SALT_LEN * 2)
#define VC_DATA_LEN ( 448)
#define VC_DATA_HEX_LEN (VC_DATA_LEN * 2)
typedef struct vc64_sbog_tmp
{
@ -71,7 +74,7 @@ typedef struct vc64_sbog_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -181,12 +184,12 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
| TOKEN_ATTR_VERIFY_SIGNATURE;
token.sep[1] = '$';
token.len[1] = 128;
token.len[1] = VC_SALT_HEX_LEN;
token.attr[1] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[2] = '$';
token.len[2] = 896;
token.len[2] = VC_DATA_HEX_LEN;
token.attr[2] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
@ -198,12 +201,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *salt_pos = token.buf[1];
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
salt->salt_buf[i] = hex_to_u32 (salt_pos + j);
}
salt->salt_len = VC_SALT_LEN;
salt->salt_len = hex_decode (salt_pos, VC_SALT_HEX_LEN, (u8 *) salt->salt_buf);
// iter
@ -213,10 +211,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *data_pos = token.buf[2];
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
vc->data_buf[i] = hex_to_u32 (data_pos + j);
}
hex_decode (data_pos, VC_DATA_HEX_LEN, (u8 *) vc->data_buf);
// entropy
@ -236,7 +231,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}
@ -300,25 +295,15 @@ int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// salt
#define SALT_HEX_LEN VC_SALT_LEN * 2 + 1
char salt_buf[VC_SALT_HEX_LEN + 1] = { 0 };
char salt_buf[SALT_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
snprintf (salt_buf + j, SALT_HEX_LEN - j, "%08x", byte_swap_32 (salt->salt_buf[i]));
}
hex_encode ((const u8 *) salt->salt_buf, VC_SALT_LEN, (u8 *) salt_buf);
// data
#define DATA_HEX_LEN VC_DATA_LEN * 2 + 1
char data_buf[VC_DATA_HEX_LEN + 1] = { 0 };
char data_buf[DATA_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
snprintf (data_buf + j, DATA_HEX_LEN - j, "%08x", byte_swap_32 (vc->data_buf[i]));
}
hex_encode ((const u8 *) vc->data_buf, VC_DATA_LEN, (u8 *) data_buf);
// output

45
src/modules/module_29481.c
View File

@ -50,8 +50,11 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_SALT_LEN ( 64)
#define VC_SALT_HEX_LEN (VC_SALT_LEN * 2)
#define VC_DATA_LEN ( 448)
#define VC_DATA_HEX_LEN (VC_DATA_LEN * 2)
typedef struct vc64_sbog_tmp
{
@ -72,7 +75,7 @@ typedef struct vc64_sbog_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -177,12 +180,12 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
| TOKEN_ATTR_VERIFY_SIGNATURE;
token.sep[1] = '$';
token.len[1] = 128;
token.len[1] = VC_SALT_HEX_LEN;
token.attr[1] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[2] = '$';
token.len[2] = 896;
token.len[2] = VC_DATA_HEX_LEN;
token.attr[2] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
@ -194,12 +197,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *salt_pos = token.buf[1];
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
salt->salt_buf[i] = hex_to_u32 (salt_pos + j);
}
salt->salt_len = VC_SALT_LEN;
salt->salt_len = hex_decode (salt_pos, VC_SALT_HEX_LEN, (u8 *) salt->salt_buf);
// iter
@ -209,10 +207,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *data_pos = token.buf[2];
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
vc->data_buf[i] = hex_to_u32 (data_pos + j);
}
hex_decode (data_pos, VC_DATA_HEX_LEN, (u8 *) vc->data_buf);
// entropy
@ -232,7 +227,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}
@ -296,25 +291,15 @@ int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// salt
#define SALT_HEX_LEN VC_SALT_LEN * 2 + 1
char salt_buf[VC_SALT_HEX_LEN + 1] = { 0 };
char salt_buf[SALT_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
snprintf (salt_buf + j, SALT_HEX_LEN - j, "%08x", byte_swap_32 (salt->salt_buf[i]));
}
hex_encode ((const u8 *) salt->salt_buf, VC_SALT_LEN, (u8 *) salt_buf);
// data
#define DATA_HEX_LEN VC_DATA_LEN * 2 + 1
char data_buf[VC_DATA_HEX_LEN + 1] = { 0 };
char data_buf[DATA_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
snprintf (data_buf + j, DATA_HEX_LEN - j, "%08x", byte_swap_32 (vc->data_buf[i]));
}
hex_encode ((const u8 *) vc->data_buf, VC_DATA_LEN, (u8 *) data_buf);
// output

45
src/modules/module_29482.c
View File

@ -50,8 +50,11 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_SALT_LEN ( 64)
#define VC_SALT_HEX_LEN (VC_SALT_LEN * 2)
#define VC_DATA_LEN ( 448)
#define VC_DATA_HEX_LEN (VC_DATA_LEN * 2)
typedef struct vc64_sbog_tmp
{
@ -72,7 +75,7 @@ typedef struct vc64_sbog_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -177,12 +180,12 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
| TOKEN_ATTR_VERIFY_SIGNATURE;
token.sep[1] = '$';
token.len[1] = 128;
token.len[1] = VC_SALT_HEX_LEN;
token.attr[1] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[2] = '$';
token.len[2] = 896;
token.len[2] = VC_DATA_HEX_LEN;
token.attr[2] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
@ -194,12 +197,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *salt_pos = token.buf[1];
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
salt->salt_buf[i] = hex_to_u32 (salt_pos + j);
}
salt->salt_len = VC_SALT_LEN;
salt->salt_len = hex_decode (salt_pos, VC_SALT_HEX_LEN, (u8 *) salt->salt_buf);
// iter
@ -209,10 +207,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *data_pos = token.buf[2];
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
vc->data_buf[i] = hex_to_u32 (data_pos + j);
}
hex_decode (data_pos, VC_DATA_HEX_LEN, (u8 *) vc->data_buf);
// entropy
@ -232,7 +227,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}
@ -296,25 +291,15 @@ int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// salt
#define SALT_HEX_LEN VC_SALT_LEN * 2 + 1
char salt_buf[VC_SALT_HEX_LEN + 1] = { 0 };
char salt_buf[SALT_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
snprintf (salt_buf + j, SALT_HEX_LEN - j, "%08x", byte_swap_32 (salt->salt_buf[i]));
}
hex_encode ((const u8 *) salt->salt_buf, VC_SALT_LEN, (u8 *) salt_buf);
// data
#define DATA_HEX_LEN VC_DATA_LEN * 2 + 1
char data_buf[VC_DATA_HEX_LEN + 1] = { 0 };
char data_buf[DATA_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
snprintf (data_buf + j, DATA_HEX_LEN - j, "%08x", byte_swap_32 (vc->data_buf[i]));
}
hex_encode ((const u8 *) vc->data_buf, VC_DATA_LEN, (u8 *) data_buf);
// output

45
src/modules/module_29483.c
View File

@ -50,8 +50,11 @@ u32 module_salt_type (MAYBE_UNUSED const hashconfig_t *hashconfig,
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; }
#define VC_SALT_LEN 64
#define VC_DATA_LEN 448
#define VC_SALT_LEN ( 64)
#define VC_SALT_HEX_LEN (VC_SALT_LEN * 2)
#define VC_DATA_LEN ( 448)
#define VC_DATA_HEX_LEN (VC_DATA_LEN * 2)
typedef struct vc64_sbog_tmp
{
@ -72,7 +75,7 @@ typedef struct vc64_sbog_tmp
typedef struct vc
{
u32 data_buf[112];
u32 data_buf[VC_DATA_LEN / 4];
u32 keyfile_buf16[16];
u32 keyfile_buf32[32];
u32 keyfile_enabled;
@ -177,12 +180,12 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
| TOKEN_ATTR_VERIFY_SIGNATURE;
token.sep[1] = '$';
token.len[1] = 128;
token.len[1] = VC_SALT_HEX_LEN;
token.attr[1] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[2] = '$';
token.len[2] = 896;
token.len[2] = VC_DATA_HEX_LEN;
token.attr[2] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
@ -194,12 +197,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *salt_pos = token.buf[1];
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
salt->salt_buf[i] = hex_to_u32 (salt_pos + j);
}
salt->salt_len = VC_SALT_LEN;
salt->salt_len = hex_decode (salt_pos, VC_SALT_HEX_LEN, (u8 *) salt->salt_buf);
// iter
@ -209,10 +207,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
const u8 *data_pos = token.buf[2];
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
vc->data_buf[i] = hex_to_u32 (data_pos + j);
}
hex_decode (data_pos, VC_DATA_HEX_LEN, (u8 *) vc->data_buf);
// entropy
@ -232,7 +227,7 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// fake digest
memcpy (digest, vc->data_buf, 112);
memcpy (digest, vc->data_buf, VC_DATA_LEN / 4);
return (PARSER_OK);
}
@ -296,25 +291,15 @@ int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
// salt
#define SALT_HEX_LEN VC_SALT_LEN * 2 + 1
char salt_buf[VC_SALT_HEX_LEN + 1] = { 0 };
char salt_buf[SALT_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_SALT_LEN / 4; i += 1, j += 8)
{
snprintf (salt_buf + j, SALT_HEX_LEN - j, "%08x", byte_swap_32 (salt->salt_buf[i]));
}
hex_encode ((const u8 *) salt->salt_buf, VC_SALT_LEN, (u8 *) salt_buf);
// data
#define DATA_HEX_LEN VC_DATA_LEN * 2 + 1
char data_buf[VC_DATA_HEX_LEN + 1] = { 0 };
char data_buf[DATA_HEX_LEN] = { 0 };
for (u32 i = 0, j = 0; i < VC_DATA_LEN / 4; i += 1, j += 8)
{
snprintf (data_buf + j, DATA_HEX_LEN - j, "%08x", byte_swap_32 (vc->data_buf[i]));
}
hex_encode ((const u8 *) vc->data_buf, VC_DATA_LEN, (u8 *) data_buf);
// output