arno/hashcat
1
0
Fork 0
mirror of https://github.com/hashcat/hashcat.git synced 2024-12-01 12:28:24 +00:00
Code Issues Releases Wiki Activity

The following parser functions have been rewritten to make use of input_tokenizer():

Browse Source 
ecryptfs_parse_hash
bsdicrypt_parse_hash
rar3hp_parse_hash
cf10_parse_hash
mywallet_parse_hash
This commit is contained in:
jsteube 2018-07-16 18:22:58 +02:00
parent e1fd84255b
commit a6b52d6faf
2 changed files with 189 additions and 137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
include/interface.h
View File

@ -1020,14 +1020,6 @@ typedef struct hccapx hccapx_t;
typedef enum display_len typedef enum display_len
{ {
DISPLAY_LEN_MIN_12200 = 1 + 8 + 1 + 1 + 1 + 1 + 1 + 16 + 1 + 16,
DISPLAY_LEN_MAX_12200 = 1 + 8 + 1 + 1 + 1 + 1 + 1 + 16 + 1 + 16,
DISPLAY_LEN_MIN_12400 = 1 + 4 + 4 + 11,
DISPLAY_LEN_MAX_12400 = 1 + 4 + 4 + 11,
DISPLAY_LEN_MIN_12500 = 6 + 1 + 1 + 1 + 16 + 1 + 32,
DISPLAY_LEN_MAX_12500 = 6 + 1 + 1 + 1 + 16 + 1 + 32,
DISPLAY_LEN_MIN_12600 = 64 + 1 + 64,
DISPLAY_LEN_MAX_12600 = 64 + 1 + 64,
DISPLAY_LEN_MIN_12700 = 1 + 10 + 1 + 1 + 1 + 64, DISPLAY_LEN_MIN_12700 = 1 + 10 + 1 + 1 + 1 + 64,
DISPLAY_LEN_MAX_12700 = 1 + 10 + 1 + 5 + 1 + 20000, DISPLAY_LEN_MAX_12700 = 1 + 10 + 1 + 5 + 1 + 20000,
DISPLAY_LEN_MIN_12800 = 11 + 1 + 20 + 1 + 1 + 1 + 64, DISPLAY_LEN_MIN_12800 = 11 + 1 + 20 + 1 + 1 + 1 + 64,

318
src/interface.c
View File

@ -12614,7 +12614,7 @@ int sip_auth_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_U
| TOKEN_ATTR_TERMINATE_STRING; | TOKEN_ATTR_TERMINATE_STRING;
token.sep[7] = '*'; token.sep[7] = '*';
token.len_min[7] = 0; token.len_min[7] = 1;
token.len_max[7] = 246; token.len_max[7] = 246;
token.attr[7] = TOKEN_ATTR_VERIFY_LENGTH token.attr[7] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_TERMINATE_STRING; | TOKEN_ATTR_TERMINATE_STRING;
@ -12626,7 +12626,7 @@ int sip_auth_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_U
| TOKEN_ATTR_TERMINATE_STRING; | TOKEN_ATTR_TERMINATE_STRING;
token.sep[9] = '*'; token.sep[9] = '*';
token.len_min[9] = 0; token.len_min[9] = 1;
token.len_max[9] = 50; token.len_max[9] = 50;
token.attr[9] = TOKEN_ATTR_VERIFY_LENGTH token.attr[9] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_TERMINATE_STRING; | TOKEN_ATTR_TERMINATE_STRING;
@ -13561,39 +13561,55 @@ int pbkdf2_sha512_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MA
int ecryptfs_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNUSED hashconfig_t *hashconfig) int ecryptfs_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNUSED hashconfig_t *hashconfig)
{ {
if ((input_len < DISPLAY_LEN_MIN_12200) || (input_len > DISPLAY_LEN_MAX_12200)) return (PARSER_GLOBAL_LENGTH);
if (memcmp (SIGNATURE_ECRYPTFS, input_buf, 10) != 0) return (PARSER_SIGNATURE_UNMATCHED);
u32 *digest = (u32 *) hash_buf->digest; u32 *digest = (u32 *) hash_buf->digest;
salt_t *salt = hash_buf->salt; salt_t *salt = hash_buf->salt;
/** token_t token;
* parse line
*/
u8 *salt_pos = input_buf + 10 + 2 + 2; // skip over "0$" and "1$" token.token_cnt = 5;
u8 *hash_pos = (u8 *) strchr ((const char *) salt_pos, '$'); token.signatures_cnt = 1;
token.signatures_buf[0] = SIGNATURE_ECRYPTFS;
if (hash_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED); token.len[0] = 10;
token.attr[0] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_SIGNATURE;
u32 salt_len = hash_pos - salt_pos; token.sep[1] = '$';
token.len_min[1] = 1;
token.len_max[1] = 1;
token.attr[1] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_DIGIT;
hash_pos++; token.sep[2] = '$';
token.len_min[2] = 1;
token.len_max[2] = 1;
token.attr[2] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_DIGIT;
u32 hash_len = input_len - 10 - 2 - 2 - salt_len - 1; token.sep[3] = '$';
token.len_min[3] = 16;
token.len_max[3] = 16;
token.attr[3] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
if (hash_len != 16) return (PARSER_HASH_LENGTH); token.sep[4] = '$';
if (salt_len != 16) return (PARSER_SALT_LENGTH); token.len_min[4] = 16;
token.len_max[4] = 16;
token.attr[4] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
// decode hash const int rc_tokenizer = input_tokenizer (input_buf, input_len, &token);
if (is_valid_hex_string (hash_pos, 16) == false) return (PARSER_HASH_ENCODING); if (rc_tokenizer != PARSER_OK) return (rc_tokenizer);
digest[ 0] = hex_to_u32 ((const u8 *) &hash_pos[0]); // hash
digest[ 1] = hex_to_u32 ((const u8 *) &hash_pos[8]);
u8 *hash_pos = token.buf[4];
digest[ 0] = hex_to_u32 (hash_pos + 0);
digest[ 1] = hex_to_u32 (hash_pos + 8);
digest[ 2] = 0; digest[ 2] = 0;
digest[ 3] = 0; digest[ 3] = 0;
digest[ 4] = 0; digest[ 4] = 0;
@ -13612,12 +13628,12 @@ int ecryptfs_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_U
digest[0] = byte_swap_32 (digest[0]); digest[0] = byte_swap_32 (digest[0]);
digest[1] = byte_swap_32 (digest[1]); digest[1] = byte_swap_32 (digest[1]);
// decode salt // salt
if (is_valid_hex_string (salt_pos, 16) == false) return (PARSER_SALT_ENCODING); u8 *salt_pos = token.buf[3];
salt->salt_buf[0] = hex_to_u32 ((const u8 *) &salt_pos[0]); salt->salt_buf[0] = hex_to_u32 (salt_pos + 0);
salt->salt_buf[1] = hex_to_u32 ((const u8 *) &salt_pos[8]); salt->salt_buf[1] = hex_to_u32 (salt_pos + 8);
salt->salt_buf[0] = byte_swap_32 (salt->salt_buf[0]); salt->salt_buf[0] = byte_swap_32 (salt->salt_buf[0]);
salt->salt_buf[1] = byte_swap_32 (salt->salt_buf[1]); salt->salt_buf[1] = byte_swap_32 (salt->salt_buf[1]);
@ -13630,37 +13646,69 @@ int ecryptfs_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_U
int bsdicrypt_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNUSED hashconfig_t *hashconfig) int bsdicrypt_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNUSED hashconfig_t *hashconfig)
{ {
if ((input_len < DISPLAY_LEN_MIN_12400) || (input_len > DISPLAY_LEN_MAX_12400)) return (PARSER_GLOBAL_LENGTH);
if (memcmp (SIGNATURE_BSDICRYPT, input_buf, 1) != 0) return (PARSER_SIGNATURE_UNMATCHED);
unsigned char c19 = itoa64_to_int (input_buf[19]);
if (c19 & 3) return (PARSER_HASH_VALUE);
salt_t *salt = hash_buf->salt; salt_t *salt = hash_buf->salt;
u32 *digest = (u32 *) hash_buf->digest; u32 *digest = (u32 *) hash_buf->digest;
token_t token;
token.token_cnt = 4;
token.signatures_cnt = 1;
token.signatures_buf[0] = SIGNATURE_BSDICRYPT;
token.len[0] = 1;
token.attr[0] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_SIGNATURE;
token.len[1] = 4;
token.attr[1] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_BASE64B;
token.len[2] = 4;
token.attr[2] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_BASE64B;
token.len[3] = 11;
token.attr[3] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_BASE64B;
const int rc_tokenizer = input_tokenizer (input_buf, input_len, &token);
if (rc_tokenizer != PARSER_OK) return (rc_tokenizer);
// iteration count // iteration count
salt->salt_iter = itoa64_to_int (input_buf[1]) u8 *iter_pos = token.buf[1];
| itoa64_to_int (input_buf[2]) << 6
| itoa64_to_int (input_buf[3]) << 12 salt->salt_iter = itoa64_to_int (iter_pos[0])
| itoa64_to_int (input_buf[4]) << 18; | itoa64_to_int (iter_pos[1]) << 6
| itoa64_to_int (iter_pos[2]) << 12
| itoa64_to_int (iter_pos[3]) << 18;
// set salt // set salt
salt->salt_buf[0] = itoa64_to_int (input_buf[5]) u8 *salt_pos = token.buf[2];
| itoa64_to_int (input_buf[6]) << 6
| itoa64_to_int (input_buf[7]) << 12 salt->salt_buf[0] = itoa64_to_int (salt_pos[0])
| itoa64_to_int (input_buf[8]) << 18; | itoa64_to_int (salt_pos[1]) << 6
| itoa64_to_int (salt_pos[2]) << 12
| itoa64_to_int (salt_pos[3]) << 18;
salt->salt_len = 4; salt->salt_len = 4;
// hash
u8 *hash_pos = token.buf[3];
int hash_len = token.len[3];
unsigned char c19 = itoa64_to_int (hash_pos[10]);
if (c19 & 3) return (PARSER_HASH_VALUE);
u8 tmp_buf[100] = { 0 }; u8 tmp_buf[100] = { 0 };
base64_decode (itoa64_to_int, (const u8 *) input_buf + 9, 11, tmp_buf); base64_decode (itoa64_to_int, hash_pos, hash_len, tmp_buf);
memcpy (digest, tmp_buf, 8); memcpy (digest, tmp_buf, 8);
@ -13678,57 +13726,61 @@ int bsdicrypt_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_
int rar3hp_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNUSED hashconfig_t *hashconfig) int rar3hp_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNUSED hashconfig_t *hashconfig)
{ {
if ((input_len < DISPLAY_LEN_MIN_12500) || (input_len > DISPLAY_LEN_MAX_12500)) return (PARSER_GLOBAL_LENGTH);
if (memcmp (SIGNATURE_RAR3, input_buf, 6) != 0) return (PARSER_SIGNATURE_UNMATCHED);
u32 *digest = (u32 *) hash_buf->digest; u32 *digest = (u32 *) hash_buf->digest;
salt_t *salt = hash_buf->salt; salt_t *salt = hash_buf->salt;
/** token_t token;
* parse line
*/
u8 *type_pos = input_buf + 6 + 1; token.token_cnt = 4;
u8 *salt_pos = (u8 *) strchr ((const char *) type_pos, '*'); token.signatures_cnt = 1;
token.signatures_buf[0] = SIGNATURE_RAR3;
if (salt_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED); token.sep[0] = '*';
token.len_min[0] = 6;
token.len_max[0] = 6;
token.attr[0] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_SIGNATURE;
u32 type_len = salt_pos - type_pos; token.sep[1] = '*';
token.len_min[1] = 1;
token.len_max[1] = 1;
token.attr[1] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_DIGIT;
salt_pos++; token.sep[2] = '*';
token.len_min[2] = 16;
token.len_max[2] = 16;
token.attr[2] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
u8 *crypted_pos = (u8 *) strchr ((const char *) salt_pos, '*'); token.sep[3] = '*';
token.len_min[3] = 32;
token.len_max[3] = 32;
token.attr[3] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
if (crypted_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED); const int rc_tokenizer = input_tokenizer (input_buf, input_len, &token);
u32 salt_len = crypted_pos - salt_pos; if (rc_tokenizer != PARSER_OK) return (rc_tokenizer);
crypted_pos++; u8 *type_pos = token.buf[1];
u8 *salt_pos = token.buf[2];
u8 *crypted_pos = token.buf[3];
u32 crypted_len = input_len - 6 - 1 - type_len - 1 - salt_len - 1; if (type_pos[0] != '0') return (PARSER_SIGNATURE_UNMATCHED);
if (crypted_len != 32) return (PARSER_SALT_LENGTH);
if (type_len != 1) return (PARSER_SALT_LENGTH);
if (salt_len != 16) return (PARSER_SALT_LENGTH);
/** /**
* copy data * copy data
*/ */
if (is_valid_hex_string (salt_pos, 16) == false) return (PARSER_SALT_ENCODING); salt->salt_buf[0] = hex_to_u32 (salt_pos + 0);
salt->salt_buf[1] = hex_to_u32 (salt_pos + 8);
salt->salt_buf[0] = hex_to_u32 ((const u8 *) &salt_pos[0]); salt->salt_buf[2] = hex_to_u32 (crypted_pos + 0);
salt->salt_buf[1] = hex_to_u32 ((const u8 *) &salt_pos[8]); salt->salt_buf[3] = hex_to_u32 (crypted_pos + 8);
salt->salt_buf[4] = hex_to_u32 (crypted_pos + 16);
if (is_valid_hex_string (crypted_pos, 32) == false) return (PARSER_SALT_ENCODING); salt->salt_buf[5] = hex_to_u32 (crypted_pos + 24);
salt->salt_buf[2] = hex_to_u32 ((const u8 *) &crypted_pos[ 0]);
salt->salt_buf[3] = hex_to_u32 ((const u8 *) &crypted_pos[ 8]);
salt->salt_buf[4] = hex_to_u32 ((const u8 *) &crypted_pos[16]);
salt->salt_buf[5] = hex_to_u32 ((const u8 *) &crypted_pos[24]);
salt->salt_buf[2] = byte_swap_32 (salt->salt_buf[2]); salt->salt_buf[2] = byte_swap_32 (salt->salt_buf[2]);
salt->salt_buf[3] = byte_swap_32 (salt->salt_buf[3]); salt->salt_buf[3] = byte_swap_32 (salt->salt_buf[3]);
@ -14468,22 +14520,41 @@ int keepass_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UN
int cf10_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNUSED hashconfig_t *hashconfig) int cf10_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNUSED hashconfig_t *hashconfig)
{ {
if ((input_len < DISPLAY_LEN_MIN_12600) || (input_len > DISPLAY_LEN_MAX_12600)) return (PARSER_GLOBAL_LENGTH);
u32 *digest = (u32 *) hash_buf->digest; u32 *digest = (u32 *) hash_buf->digest;
salt_t *salt = hash_buf->salt; salt_t *salt = hash_buf->salt;
if (is_valid_hex_string (input_buf, 64) == false) return (PARSER_HASH_ENCODING); token_t token;
digest[0] = hex_to_u32 ((const u8 *) &input_buf[ 0]); token.token_cnt = 2;
digest[1] = hex_to_u32 ((const u8 *) &input_buf[ 8]);
digest[2] = hex_to_u32 ((const u8 *) &input_buf[16]); token.sep[0] = hashconfig->separator;
digest[3] = hex_to_u32 ((const u8 *) &input_buf[24]); token.len_min[0] = 64;
digest[4] = hex_to_u32 ((const u8 *) &input_buf[32]); token.len_max[0] = 64;
digest[5] = hex_to_u32 ((const u8 *) &input_buf[40]); token.attr[0] = TOKEN_ATTR_VERIFY_LENGTH
digest[6] = hex_to_u32 ((const u8 *) &input_buf[48]); | TOKEN_ATTR_VERIFY_HEX;
digest[7] = hex_to_u32 ((const u8 *) &input_buf[56]);
token.len_min[1] = 64;
token.len_max[1] = 64;
token.attr[1] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
const int rc_tokenizer = input_tokenizer (input_buf, input_len, &token);
if (rc_tokenizer != PARSER_OK) return (rc_tokenizer);
// hash
u8 *hash_pos = token.buf[0];
digest[0] = hex_to_u32 (hash_pos + 0);
digest[1] = hex_to_u32 (hash_pos + 8);
digest[2] = hex_to_u32 (hash_pos + 16);
digest[3] = hex_to_u32 (hash_pos + 24);
digest[4] = hex_to_u32 (hash_pos + 32);
digest[5] = hex_to_u32 (hash_pos + 40);
digest[6] = hex_to_u32 (hash_pos + 48);
digest[7] = hex_to_u32 (hash_pos + 56);
digest[0] = byte_swap_32 (digest[0]); digest[0] = byte_swap_32 (digest[0]);
digest[1] = byte_swap_32 (digest[1]); digest[1] = byte_swap_32 (digest[1]);
@ -14494,19 +14565,14 @@ int cf10_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNUSE
digest[6] = byte_swap_32 (digest[6]); digest[6] = byte_swap_32 (digest[6]);
digest[7] = byte_swap_32 (digest[7]); digest[7] = byte_swap_32 (digest[7]);
if (input_buf[64] != hashconfig->separator) return (PARSER_SEPARATOR_UNMATCHED); // salt
u32 salt_len = input_len - 64 - 1; u8 *salt_pos = token.buf[1];
int salt_len = token.len[1];
u8 *salt_buf = input_buf + 64 + 1; const bool parse_rc = parse_and_store_generic_salt ((u8 *) salt->salt_buf, (int *) &salt->salt_len, salt_pos, salt_len, hashconfig);
u8 *salt_buf_ptr = (u8 *) salt->salt_buf; if (parse_rc == false) return (PARSER_SALT_LENGTH);
salt_len = parse_and_store_salt_legacy (salt_buf_ptr, salt_buf, salt_len, hashconfig);
if (salt_len == UINT_MAX) return (PARSER_SALT_LENGTH);
salt->salt_len = salt_len;
/** /**
* we can precompute the first sha256 transform * we can precompute the first sha256 transform
@ -14558,53 +14624,47 @@ int cf10_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNUSE
int mywallet_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNUSED hashconfig_t *hashconfig) int mywallet_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNUSED hashconfig_t *hashconfig)
{ {
if ((input_len < DISPLAY_LEN_MIN_12700) || (input_len > DISPLAY_LEN_MAX_12700)) return (PARSER_GLOBAL_LENGTH);
if (memcmp (SIGNATURE_MYWALLET, input_buf, 12) != 0) return (PARSER_SIGNATURE_UNMATCHED);
u32 *digest = (u32 *) hash_buf->digest; u32 *digest = (u32 *) hash_buf->digest;
salt_t *salt = hash_buf->salt; salt_t *salt = hash_buf->salt;
/** token_t token;
* parse line
*/
u8 *data_len_pos = input_buf + 1 + 10 + 1; token.token_cnt = 3;
u8 *data_buf_pos = (u8 *) strchr ((const char *) data_len_pos, '$'); token.signatures_cnt = 1;
token.signatures_buf[0] = SIGNATURE_MYWALLET;
if (data_buf_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED); token.len[0] = 12;
token.attr[0] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_SIGNATURE;
u32 data_len_len = data_buf_pos - data_len_pos; token.len_min[1] = 1;
token.len_max[1] = 6;
token.sep[1] = '$';
token.attr[1] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_DIGIT;
if (data_len_len < 1) return (PARSER_SALT_LENGTH); token.len_min[2] = 64;
if (data_len_len > 5) return (PARSER_SALT_LENGTH); token.len_max[2] = 65536;
token.sep[2] = '$';
token.attr[2] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
data_buf_pos++; const int rc_tokenizer = input_tokenizer (input_buf, input_len, &token);
u32 data_buf_len = input_len - 1 - 10 - 1 - data_len_len - 1; if (rc_tokenizer != PARSER_OK) return (rc_tokenizer);
if (data_buf_len < 64) return (PARSER_HASH_LENGTH);
if (data_buf_len % 16) return (PARSER_HASH_LENGTH);
u32 data_len = hc_strtoul ((const char *) data_len_pos, NULL, 10);
if ((data_len * 2) != data_buf_len) return (PARSER_HASH_LENGTH);
/** /**
* salt * salt
*/ */
u8 *salt_pos = data_buf_pos; u8 *salt_pos = token.buf[2];
if (is_valid_hex_string (salt_pos, 64) == false) return (PARSER_SALT_ENCODING); salt->salt_buf[0] = hex_to_u32 (salt_pos + 0);
salt->salt_buf[1] = hex_to_u32 (salt_pos + 8);
salt->salt_buf[0] = hex_to_u32 ((const u8 *) &salt_pos[ 0]); salt->salt_buf[2] = hex_to_u32 (salt_pos + 16);
salt->salt_buf[1] = hex_to_u32 ((const u8 *) &salt_pos[ 8]); salt->salt_buf[3] = hex_to_u32 (salt_pos + 24);
salt->salt_buf[2] = hex_to_u32 ((const u8 *) &salt_pos[16]);
salt->salt_buf[3] = hex_to_u32 ((const u8 *) &salt_pos[24]);
salt->salt_buf[0] = byte_swap_32 (salt->salt_buf[0]); salt->salt_buf[0] = byte_swap_32 (salt->salt_buf[0]);
salt->salt_buf[1] = byte_swap_32 (salt->salt_buf[1]); salt->salt_buf[1] = byte_swap_32 (salt->salt_buf[1]);
@ -14613,10 +14673,10 @@ int mywallet_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_U
// this is actually the CT, which is also the hash later (if matched) // this is actually the CT, which is also the hash later (if matched)
salt->salt_buf[4] = hex_to_u32 ((const u8 *) &salt_pos[32]); salt->salt_buf[4] = hex_to_u32 (salt_pos + 32);
salt->salt_buf[5] = hex_to_u32 ((const u8 *) &salt_pos[40]); salt->salt_buf[5] = hex_to_u32 (salt_pos + 40);
salt->salt_buf[6] = hex_to_u32 ((const u8 *) &salt_pos[48]); salt->salt_buf[6] = hex_to_u32 (salt_pos + 48);
salt->salt_buf[7] = hex_to_u32 ((const u8 *) &salt_pos[56]); salt->salt_buf[7] = hex_to_u32 (salt_pos + 56);
salt->salt_buf[4] = byte_swap_32 (salt->salt_buf[4]); salt->salt_buf[4] = byte_swap_32 (salt->salt_buf[4]);
salt->salt_buf[5] = byte_swap_32 (salt->salt_buf[5]); salt->salt_buf[5] = byte_swap_32 (salt->salt_buf[5]);