arno
/
hashcat
mirror of https://github.com/hashcat/hashcat.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Add TOKEN_ATTR_TERMINATE_STRING feature to input_tokenizer()

Browse Source 
The following parser functions have been rewritten to make use of input_tokenizer():
bitcoin_wallet_parse_hash
sip_auth_parse_hash
crc32_parse_hash
oraclet_parse_hash
seven_zip_parse_hash
pull/1619/head
jsteube 6 years ago
parent 39418571db
commit 230ec5e004
3 changed files with 359 additions and 401 deletions
Show Stats Download Patch File Download Diff File

10
include/interface.h
Unescape View File

@ -1020,18 +1020,8 @@ typedef struct hccapx hccapx_t;
typedef enum display_len
{
DISPLAY_LEN_MIN_11300 = 1 + 7 + 1 + 2 + 1 + 96 + 1 + 2 + 1 + 16 + 1 + 1 + 1 + 2 + 1 + 96 + 1 + 1 + 1 + 2,
DISPLAY_LEN_MAX_11300 = 1 + 7 + 1 + 2 + 1 + 96 + 1 + 2 + 1 + 16 + 1 + 6 + 1 + 2 + 1 + 96 + 1 + 3 + 1 + 512,
DISPLAY_LEN_MIN_11400 = 6 + 0 + 1 + 0 + 1 + 0 + 1 + 0 + 1 + 0 + 1 + 0 + 1 + 1 + 1 + 0 + 1 + 1 + 1 + 0 + 1 + 0 + 1 + 0 + 1 + 3 + 1 + 32,
DISPLAY_LEN_MAX_11400 = 6 + 512 + 1 + 512 + 1 + 116 + 1 + 116 + 1 + 246 + 1 + 245 + 1 + 246 + 1 + 245 + 1 + 50 + 1 + 50 + 1 + 50 + 1 + 50 + 1 + 3 + 1 + 32,
DISPLAY_LEN_MIN_11500 = 8 + 1 + 8,
DISPLAY_LEN_MAX_11500 = 8 + 1 + 8,
DISPLAY_LEN_MIN_11600 = 1 + 2 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 0 + 1 + 1 + 1 + 32 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 2 + 0 + 0 + 0 + 0,
DISPLAY_LEN_MAX_11600 = 1 + 2 + 1 + 1 + 1 + 2 + 1 + 1 + 1 + 64 + 1 + 1 + 1 + 32 + 1 + 10 + 1 + 4 + 1 + 4 + 1 + 655056 + 1 + 4 + 1 + 10,
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_12300 = 160,
DISPLAY_LEN_MAX_12300 = 160,
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,

1
include/types.h
Unescape View File

@ -694,6 +694,7 @@ typedef enum token_attr
TOKEN_ATTR_VERIFY_HEX = 1 << 5,
TOKEN_ATTR_VERIFY_BASE64A = 1 << 6,
TOKEN_ATTR_VERIFY_BASE64B = 1 << 7,
TOKEN_ATTR_TERMINATE_STRING = 1 << 8,
} token_attr_t;

749
src/interface.c
Unescape View File

@ -651,7 +651,7 @@ static const char *SIGNATURE_SHA512B64S = "{SSHA512}";
static const char *SIGNATURE_SHA512CRYPT = "$6$";
static const char *SIGNATURE_SHA512GRUB = "grub.pbkdf2.sha512.";
static const char *SIGNATURE_SHA512MACOS = "$ml$";
static const char *SIGNATURE_SIP_AUTH = "$sip$*";
static const char *SIGNATURE_SIP_AUTH = "$sip$";
static const char *SIGNATURE_SSHA1B64_lower = "{ssha}";
static const char *SIGNATURE_SSHA1B64_upper = "{SSHA}";
static const char *SIGNATURE_SYBASEASE = "0xc007";
@ -2563,6 +2563,11 @@ static int input_tokenizer (u8 *input_buf, int input_len, token_t *token)
{
if (is_valid_base64b_string (token->buf[token_idx], token->len[token_idx]) == false) return (PARSER_TOKEN_ENCODING);
}
if (token->attr[token_idx] & TOKEN_ATTR_TERMINATE_STRING)
{
token->buf[token_idx][token->len[token_idx]] = 0;
}
}
return PARSER_OK;
@ -5793,32 +5798,44 @@ int oracles_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UN
int oraclet_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNUSED hashconfig_t *hashconfig)
{
if ((input_len < DISPLAY_LEN_MIN_12300) || (input_len > DISPLAY_LEN_MAX_12300)) return (PARSER_GLOBAL_LENGTH);
u32 *digest = (u32 *) hash_buf->digest;
salt_t *salt = hash_buf->salt;
u8 *hash_pos = input_buf;
token_t token;
token.token_cnt = 2;
token.len[0] = 128;
token.attr[0] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.len[1] = 32;
token.attr[1] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
const int rc_tokenizer = input_tokenizer (input_buf, input_len, &token);
if (rc_tokenizer != PARSER_OK) return (rc_tokenizer);
u8 *hash_pos = token.buf[0];
if (is_valid_hex_string (hash_pos, 128) == false) return (PARSER_HASH_ENCODING);
digest[ 0] = hex_to_u32 ((const u8 *) &hash_pos[ 0]);
digest[ 1] = hex_to_u32 ((const u8 *) &hash_pos[ 8]);
digest[ 2] = hex_to_u32 ((const u8 *) &hash_pos[ 16]);
digest[ 3] = hex_to_u32 ((const u8 *) &hash_pos[ 24]);
digest[ 4] = hex_to_u32 ((const u8 *) &hash_pos[ 32]);
digest[ 5] = hex_to_u32 ((const u8 *) &hash_pos[ 40]);
digest[ 6] = hex_to_u32 ((const u8 *) &hash_pos[ 48]);
digest[ 7] = hex_to_u32 ((const u8 *) &hash_pos[ 56]);
digest[ 8] = hex_to_u32 ((const u8 *) &hash_pos[ 64]);
digest[ 9] = hex_to_u32 ((const u8 *) &hash_pos[ 72]);
digest[10] = hex_to_u32 ((const u8 *) &hash_pos[ 80]);
digest[11] = hex_to_u32 ((const u8 *) &hash_pos[ 88]);
digest[12] = hex_to_u32 ((const u8 *) &hash_pos[ 96]);
digest[13] = hex_to_u32 ((const u8 *) &hash_pos[104]);
digest[14] = hex_to_u32 ((const u8 *) &hash_pos[112]);
digest[15] = hex_to_u32 ((const u8 *) &hash_pos[120]);
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[ 8] = hex_to_u32 (hash_pos + 64);
digest[ 9] = hex_to_u32 (hash_pos + 72);
digest[10] = hex_to_u32 (hash_pos + 80);
digest[11] = hex_to_u32 (hash_pos + 88);
digest[12] = hex_to_u32 (hash_pos + 96);
digest[13] = hex_to_u32 (hash_pos + 104);
digest[14] = hex_to_u32 (hash_pos + 112);
digest[15] = hex_to_u32 (hash_pos + 120);
digest[ 0] = byte_swap_32 (digest[ 0]);
digest[ 1] = byte_swap_32 (digest[ 1]);
@ -5837,14 +5854,12 @@ int oraclet_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UN
digest[14] = byte_swap_32 (digest[14]);
digest[15] = byte_swap_32 (digest[15]);
u8 *salt_pos = input_buf + 128;
if (is_valid_hex_string (salt_pos, 32) == false) return (PARSER_SALT_ENCODING);
u8 *salt_pos = token.buf[1];
salt->salt_buf[0] = hex_to_u32 ((const u8 *) &salt_pos[ 0]);
salt->salt_buf[1] = hex_to_u32 ((const u8 *) &salt_pos[ 8]);
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] = hex_to_u32 (salt_pos + 0);
salt->salt_buf[1] = hex_to_u32 (salt_pos + 8);
salt->salt_buf[2] = hex_to_u32 (salt_pos + 16);
salt->salt_buf[3] = hex_to_u32 (salt_pos + 24);
salt->salt_buf[0] = byte_swap_32 (salt->salt_buf[0]);
salt->salt_buf[1] = byte_swap_32 (salt->salt_buf[1]);
@ -12396,115 +12411,121 @@ int mysql_auth_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE
int bitcoin_wallet_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNUSED hashconfig_t *hashconfig)
{
if ((input_len < DISPLAY_LEN_MIN_11300) || (input_len > DISPLAY_LEN_MAX_11300)) return (PARSER_GLOBAL_LENGTH);
if (memcmp (SIGNATURE_BITCOIN_WALLET, input_buf, 9) != 0) return (PARSER_SIGNATURE_UNMATCHED);
u32 *digest = (u32 *) hash_buf->digest;
salt_t *salt = hash_buf->salt;
bitcoin_wallet_t *bitcoin_wallet = (bitcoin_wallet_t *) hash_buf->esalt;
/**
* parse line
*/
u8 *cry_master_len_pos = input_buf + 9;
u8 *cry_master_buf_pos = (u8 *) strchr ((const char *) cry_master_len_pos, '$');
if (cry_master_buf_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
u32 cry_master_len_len = cry_master_buf_pos - cry_master_len_pos;
cry_master_buf_pos++;
u8 *cry_salt_len_pos = (u8 *) strchr ((const char *) cry_master_buf_pos, '$');
if (cry_salt_len_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
u32 cry_master_buf_len = cry_salt_len_pos - cry_master_buf_pos;
cry_salt_len_pos++;
u8 *cry_salt_buf_pos = (u8 *) strchr ((const char *) cry_salt_len_pos, '$');
if (cry_salt_buf_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
u32 cry_salt_len_len = cry_salt_buf_pos - cry_salt_len_pos;
cry_salt_buf_pos++;
u8 *cry_rounds_pos = (u8 *) strchr ((const char *) cry_salt_buf_pos, '$');
if (cry_rounds_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
u32 cry_salt_buf_len = cry_rounds_pos - cry_salt_buf_pos;
cry_rounds_pos++;
token_t token;
u8 *ckey_len_pos = (u8 *) strchr ((const char *) cry_rounds_pos, '$');
token.token_cnt = 10;
if (ckey_len_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
token.signatures_cnt = 1;
token.signatures_buf[0] = SIGNATURE_BITCOIN_WALLET;
u32 cry_rounds_len = ckey_len_pos - cry_rounds_pos;
token.len[0] = 9;
token.attr[0] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_SIGNATURE;
ckey_len_pos++;
token.sep[1] = '$';
token.len_min[1] = 2;
token.len_max[1] = 2;
token.attr[1] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_DIGIT;
u8 *ckey_buf_pos = (u8 *) strchr ((const char *) ckey_len_pos, '$');
token.sep[2] = '$';
token.len_min[2] = 96;
token.len_max[2] = 96;
token.attr[2] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
if (ckey_buf_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
token.sep[3] = '$';
token.len_min[3] = 2;
token.len_max[3] = 2;
token.attr[3] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_DIGIT;
u32 ckey_len_len = ckey_buf_pos - ckey_len_pos;
token.sep[4] = '$';
token.len_min[4] = 16;
token.len_max[4] = 16;
token.attr[4] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
ckey_buf_pos++;
token.sep[5] = '$';
token.len_min[5] = 1;
token.len_max[5] = 6;
token.attr[5] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_DIGIT;
u8 *public_key_len_pos = (u8 *) strchr ((const char *) ckey_buf_pos, '$');
token.sep[6] = '$';
token.len_min[6] = 2;
token.len_max[6] = 2;
token.attr[6] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_DIGIT;
if (public_key_len_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
token.sep[7] = '$';
token.len_min[7] = 96;
token.len_max[7] = 96;
token.attr[7] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
u32 ckey_buf_len = public_key_len_pos - ckey_buf_pos;
token.sep[8] = '$';
token.len_min[8] = 1;
token.len_max[8] = 3;
token.attr[8] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_DIGIT;
public_key_len_pos++;
token.sep[9] = '$';
token.len_min[9] = 2;
token.len_max[9] = 512;
token.attr[9] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
u8 *public_key_buf_pos = (u8 *) strchr ((const char *) public_key_len_pos, '$');
const int rc_tokenizer = input_tokenizer (input_buf, input_len, &token);
if (public_key_buf_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
if (rc_tokenizer != PARSER_OK) return (rc_tokenizer);
u32 public_key_len_len = public_key_buf_pos - public_key_len_pos;
u8 *cry_master_len_pos = token.buf[1];
u8 *cry_master_buf_pos = token.buf[2];
u8 *cry_salt_len_pos = token.buf[3];
u8 *cry_salt_buf_pos = token.buf[4];
u8 *cry_rounds_pos = token.buf[5];
u8 *ckey_len_pos = token.buf[6];
u8 *ckey_buf_pos = token.buf[7];
u8 *public_key_len_pos = token.buf[8];
u8 *public_key_buf_pos = token.buf[9];
public_key_buf_pos++;
int cry_master_buf_len = token.len[2];
int cry_salt_buf_len = token.len[4];
int ckey_buf_len = token.len[7];
int public_key_buf_len = token.len[9];
u32 public_key_buf_len = input_len - 1 - 7 - 1 - cry_master_len_len - 1 - cry_master_buf_len - 1 - cry_salt_len_len - 1 - cry_salt_buf_len - 1 - cry_rounds_len - 1 - ckey_len_len - 1 - ckey_buf_len - 1 - public_key_len_len - 1;
// verify
const u32 cry_master_len = hc_strtoul ((const char *) cry_master_len_pos, NULL, 10);
const u32 cry_salt_len = hc_strtoul ((const char *) cry_salt_len_pos, NULL, 10);
const u32 ckey_len = hc_strtoul ((const char *) ckey_len_pos, NULL, 10);
const u32 public_key_len = hc_strtoul ((const char *) public_key_len_pos, NULL, 10);
const int cry_master_len = hc_strtoul ((const char *) cry_master_len_pos, NULL, 10);
const int cry_salt_len = hc_strtoul ((const char *) cry_salt_len_pos, NULL, 10);
const int ckey_len = hc_strtoul ((const char *) ckey_len_pos, NULL, 10);
const int public_key_len = hc_strtoul ((const char *) public_key_len_pos, NULL, 10);
if (cry_master_buf_len != cry_master_len) return (PARSER_SALT_VALUE);
if (cry_salt_buf_len != cry_salt_len) return (PARSER_SALT_VALUE);
if (ckey_buf_len != ckey_len) return (PARSER_SALT_VALUE);
if (public_key_buf_len != public_key_len) return (PARSER_SALT_VALUE);
if (is_valid_hex_string (cry_master_buf_pos, cry_master_len) == false) return (PARSER_SALT_ENCODING);
// esalt
for (u32 i = 0, j = 0; j < cry_master_len; i += 1, j += 8)
for (int i = 0, j = 0; j < cry_master_len; i += 1, j += 8)
{
bitcoin_wallet->cry_master_buf[i] = hex_to_u32 ((const u8 *) &cry_master_buf_pos[j]);
}
if (is_valid_hex_string (ckey_buf_pos, ckey_len) == false) return (PARSER_SALT_ENCODING);
for (u32 i = 0, j = 0; j < ckey_len; i += 1, j += 8)
for (int i = 0, j = 0; j < ckey_len; i += 1, j += 8)
{
bitcoin_wallet->ckey_buf[i] = hex_to_u32 ((const u8 *) &ckey_buf_pos[j]);
}
if (is_valid_hex_string (public_key_buf_pos, public_key_len) == false) return (PARSER_SALT_ENCODING);
for (u32 i = 0, j = 0; j < public_key_len; i += 1, j += 8)
for (int i = 0, j = 0; j < public_key_len; i += 1, j += 8)
{
bitcoin_wallet->public_key_buf[i] = hex_to_u32 ((const u8 *) &public_key_buf_pos[j]);
}
@ -12513,223 +12534,162 @@ int bitcoin_wallet_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, M
bitcoin_wallet->ckey_len = ckey_len / 2;
bitcoin_wallet->public_key_len = public_key_len / 2;
/*
* store digest (should be unique enought, hopefully)
*/
// hash
digest[0] = bitcoin_wallet->cry_master_buf[0];
digest[1] = bitcoin_wallet->cry_master_buf[1];
digest[2] = bitcoin_wallet->cry_master_buf[2];
digest[3] = bitcoin_wallet->cry_master_buf[3];
/*
* store salt
*/
if (cry_rounds_len >= 7) return (PARSER_SALT_VALUE);
// iter
const u32 cry_rounds = hc_strtoul ((const char *) cry_rounds_pos, NULL, 10);
const int cry_rounds = hc_strtoul ((const char *) cry_rounds_pos, NULL, 10);
salt->salt_iter = cry_rounds - 1;
u8 *salt_buf_ptr = (u8 *) salt->salt_buf;
// salt
const u32 salt_len = parse_and_store_salt_legacy (salt_buf_ptr, cry_salt_buf_pos, cry_salt_buf_len, hashconfig);
const bool parse_rc = parse_and_store_generic_salt ((u8 *) salt->salt_buf, (int *) &salt->salt_len, cry_salt_buf_pos, cry_salt_buf_len, hashconfig);
if (salt_len == UINT_MAX) return (PARSER_SALT_LENGTH);
salt->salt_len = salt_len;
if (parse_rc == false) return (PARSER_SALT_LENGTH);
return (PARSER_OK);
}
int sip_auth_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNUSED hashconfig_t *hashconfig)
{
if ((input_len < DISPLAY_LEN_MIN_11400) || (input_len > DISPLAY_LEN_MAX_11400)) return (PARSER_GLOBAL_LENGTH);
if (memcmp (SIGNATURE_SIP_AUTH, input_buf, 6) != 0) return (PARSER_SIGNATURE_UNMATCHED);
u32 *digest = (u32 *) hash_buf->digest;
salt_t *salt = hash_buf->salt;
sip_t *sip = (sip_t *) hash_buf->esalt;
// work with a temporary copy of input_buf (s.t. we can manipulate it directly)
// why? should be fine to use original buffer
//u8 *temp_input_buf = (u8 *) hcmalloc (input_len + 1);
//memcpy (temp_input_buf, input_buf, input_len);
// URI_server:
u8 *URI_server_pos = input_buf + 6;
u8 *URI_client_pos = (u8 *) strchr ((const char *) URI_server_pos, '*');
if (URI_client_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
URI_client_pos[0] = 0;
URI_client_pos++;
size_t URI_server_len = strlen ((const char *) URI_server_pos);
if (URI_server_len > 512) return (PARSER_SALT_LENGTH);
// URI_client:
u8 *user_pos = (u8 *) strchr ((const char *) URI_client_pos, '*');
if (user_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
user_pos[0] = 0;
user_pos++;
size_t URI_client_len = strlen ((const char *) URI_client_pos);
if (URI_client_len > 512) return (PARSER_SALT_LENGTH);
// user:
u8 *realm_pos = (u8 *) strchr ((const char *) user_pos, '*');
if (realm_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
realm_pos[0] = 0;
realm_pos++;
size_t user_len = strlen ((const char *) user_pos);
if (user_len > 116) return (PARSER_SALT_LENGTH);
// realm:
u8 *method_pos = (u8 *) strchr ((const char *) realm_pos, '*');
if (method_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
method_pos[0] = 0;
method_pos++;
size_t realm_len = strlen ((const char *) realm_pos);
if (realm_len > 116) return (PARSER_SALT_LENGTH);
// method:
u8 *URI_prefix_pos = (u8 *) strchr ((const char *) method_pos, '*');
if (URI_prefix_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
URI_prefix_pos[0] = 0;
URI_prefix_pos++;
size_t method_len = strlen ((const char *) method_pos);
if (method_len > 246) return (PARSER_SALT_LENGTH);
// URI_prefix:
u8 *URI_resource_pos = (u8 *) strchr ((const char *) URI_prefix_pos, '*');
if (URI_resource_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
URI_resource_pos[0] = 0;
URI_resource_pos++;
size_t URI_prefix_len = strlen ((const char *) URI_prefix_pos);
if (URI_prefix_len > 245) return (PARSER_SALT_LENGTH);
// URI_resource:
u8 *URI_suffix_pos = (u8 *) strchr ((const char *) URI_resource_pos, '*');
if (URI_suffix_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
URI_suffix_pos[0] = 0;
URI_suffix_pos++;
size_t URI_resource_len = strlen ((const char *) URI_resource_pos);
if (URI_resource_len < 1 || URI_resource_len > 246) return (PARSER_SALT_LENGTH);
// URI_suffix:
u8 *nonce_pos = (u8 *) strchr ((const char *) URI_suffix_pos, '*');
if (nonce_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
nonce_pos[0] = 0;
nonce_pos++;
size_t URI_suffix_len = strlen ((const char *) URI_suffix_pos);
if (URI_suffix_len > 245) return (PARSER_SALT_LENGTH);
// nonce:
u8 *nonce_client_pos = (u8 *) strchr ((const char *) nonce_pos, '*');
if (nonce_client_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
nonce_client_pos[0] = 0;
nonce_client_pos++;
size_t nonce_len = strlen ((const char *) nonce_pos);
if (nonce_len < 1 || nonce_len > 50) return (PARSER_SALT_LENGTH);
// nonce_client:
u8 *nonce_count_pos = (u8 *) strchr ((const char *) nonce_client_pos, '*');
if (nonce_count_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
nonce_count_pos[0] = 0;
nonce_count_pos++;
size_t nonce_client_len = strlen ((const char *) nonce_client_pos);
if (nonce_client_len > 50) return (PARSER_SALT_LENGTH);
// nonce_count:
u8 *qop_pos = (u8 *) strchr ((const char *) nonce_count_pos, '*');
if (qop_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
qop_pos[0] = 0;
qop_pos++;
size_t nonce_count_len = strlen ((const char *) nonce_count_pos);
if (nonce_count_len > 50) return (PARSER_SALT_LENGTH);
token_t token;
// qop:
token.token_cnt = 15;
u8 *directive_pos = (u8 *) strchr ((const char *) qop_pos, '*');
token.signatures_cnt = 1;
token.signatures_buf[0] = SIGNATURE_SIP_AUTH;
if (directive_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
token.sep[0] = '*';
token.len_min[0] = 5;
token.len_max[0] = 5;
token.attr[0] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_SIGNATURE;
directive_pos[0] = 0;
directive_pos++;
token.sep[1] = '*';
token.len_min[1] = 0;
token.len_max[1] = 512;
token.attr[1] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_TERMINATE_STRING;
token.sep[2] = '*';
token.len_min[2] = 0;
token.len_max[2] = 512;
token.attr[2] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_TERMINATE_STRING;
token.sep[3] = '*';
token.len_min[3] = 0;
token.len_max[3] = 116;
token.attr[3] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_TERMINATE_STRING;
token.sep[4] = '*';
token.len_min[4] = 0;
token.len_max[4] = 116;
token.attr[4] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_TERMINATE_STRING;
token.sep[5] = '*';
token.len_min[5] = 0;
token.len_max[5] = 246;
token.attr[5] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_TERMINATE_STRING;
token.sep[6] = '*';
token.len_min[6] = 0;
token.len_max[6] = 245;
token.attr[6] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_TERMINATE_STRING;
token.sep[7] = '*';
token.len_min[7] = 0;
token.len_max[7] = 246;
token.attr[7] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_TERMINATE_STRING;
token.sep[8] = '*';
token.len_min[8] = 0;
token.len_max[8] = 245;
token.attr[8] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_TERMINATE_STRING;
token.sep[9] = '*';
token.len_min[9] = 0;
token.len_max[9] = 50;
token.attr[9] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_TERMINATE_STRING;
size_t qop_len = strlen ((const char *) qop_pos);
token.sep[10] = '*';
token.len_min[10] = 0;
token.len_max[10] = 50;
token.attr[10] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_TERMINATE_STRING;
if (qop_len > 50) return (PARSER_SALT_LENGTH);
token.sep[11] = '*';
token.len_min[11] = 0;
token.len_max[11] = 50;
token.attr[11] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_TERMINATE_STRING;
// directive
token.sep[12] = '*';
token.len_min[12] = 0;
token.len_max[12] = 50;
token.attr[12] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_TERMINATE_STRING;
u8 *digest_pos = (u8 *) strchr ((const char *) directive_pos, '*');
token.sep[13] = '*';
token.len_min[13] = 3;
token.len_max[13] = 3;
token.attr[13] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_TERMINATE_STRING;
if (digest_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
token.sep[14] = '*';
token.len_min[14] = 32;
token.len_max[14] = 32;
token.attr[14] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
digest_pos[0] = 0;
digest_pos++;
const int rc_tokenizer = input_tokenizer (input_buf, input_len, &token);
size_t directive_len = strlen ((const char *) directive_pos);
if (rc_tokenizer != PARSER_OK) return (rc_tokenizer);
if (directive_len != 3) return (PARSER_SALT_LENGTH);
u8 *user_pos = token.buf[ 3];
u8 *realm_pos = token.buf[ 4];
u8 *method_pos = token.buf[ 5];
u8 *URI_prefix_pos = token.buf[ 6];
u8 *URI_resource_pos = token.buf[ 7];
u8 *URI_suffix_pos = token.buf[ 8];
u8 *nonce_pos = token.buf[ 9];
u8 *nonce_client_pos = token.buf[10];
u8 *nonce_count_pos = token.buf[11];
u8 *qop_pos = token.buf[12];
u8 *directive_pos = token.buf[13];
u8 *digest_pos = token.buf[14];
int user_len = token.len[ 3];
int realm_len = token.len[ 4];
int method_len = token.len[ 5];
int URI_prefix_len = token.len[ 6];
int URI_resource_len = token.len[ 7];
int URI_suffix_len = token.len[ 8];
int nonce_len = token.len[ 9];
int nonce_client_len = token.len[10];
int nonce_count_len = token.len[11];
int qop_len = token.len[12];
// verify
if (memcmp (directive_pos, "MD5", 3) != 0) return (PARSER_SIP_AUTH_DIRECTIVE);
@ -12901,8 +12861,6 @@ int sip_auth_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_U
* digest
*/
if (is_valid_hex_string (digest_pos, 32) == false) return (PARSER_HASH_ENCODING);
digest[0] = hex_to_u32 ((const u8 *) &digest_pos[ 0]);
digest[1] = hex_to_u32 ((const u8 *) &digest_pos[ 8]);
digest[2] = hex_to_u32 ((const u8 *) &digest_pos[16]);
@ -12913,21 +12871,33 @@ int sip_auth_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_U
int crc32_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNUSED hashconfig_t *hashconfig)
{
if ((input_len < DISPLAY_LEN_MIN_11500) || (input_len > DISPLAY_LEN_MAX_11500)) return (PARSER_GLOBAL_LENGTH);
if (input_buf[8] != hashconfig->separator) return (PARSER_SEPARATOR_UNMATCHED);
u32 *digest = (u32 *) hash_buf->digest;
salt_t *salt = hash_buf->salt;
// digest
token_t token;
u8 *digest_pos = input_buf;
token.token_cnt = 2;
token.sep[0] = hashconfig->separator;
token.len_min[0] = 8;
token.len_max[0] = 8;
token.attr[0] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[1] = hashconfig->separator;
token.len_min[1] = 8;
token.len_max[1] = 8;
token.attr[1] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
const int rc_tokenizer = input_tokenizer (input_buf, input_len, &token);
if (is_valid_hex_string (digest_pos, 8) == false) return (PARSER_HASH_ENCODING);
if (rc_tokenizer != PARSER_OK) return (rc_tokenizer);
u8 *hash_pos = token.buf[0];
digest[0] = hex_to_u32 ((const u8 *) &digest_pos[0]);
digest[0] = hex_to_u32 (hash_pos + 0);
digest[1] = 0;
digest[2] = 0;
digest[3] = 0;
@ -12937,112 +12907,119 @@ int crc32_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNUS
digest[2] = 0;
digest[3] = 0;
// salt
u8 *salt_buf = input_buf + 8 + 1;
u32 salt_len = 8;
u8 *salt_buf_ptr = (u8 *) salt->salt_buf;
salt_len = parse_and_store_salt_legacy (salt_buf_ptr, salt_buf, salt_len, hashconfig);
u8 *salt_pos = token.buf[1];
int salt_len = token.len[1];
if (salt_len == UINT_MAX) return (PARSER_SALT_LENGTH);
const bool parse_rc = parse_and_store_generic_salt ((u8 *) salt->salt_buf, (int *) &salt->salt_len, salt_pos, salt_len, hashconfig);
salt->salt_len = salt_len;
if (parse_rc == false) return (PARSER_SALT_LENGTH);
return (PARSER_OK);
}
int seven_zip_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNUSED hashconfig_t *hashconfig)
{
if ((input_len < DISPLAY_LEN_MIN_11600) || (input_len > DISPLAY_LEN_MAX_11600)) return (PARSER_GLOBAL_LENGTH);
if (memcmp (SIGNATURE_SEVEN_ZIP, input_buf, 4) != 0) return (PARSER_SIGNATURE_UNMATCHED);
u32 *digest = (u32 *) hash_buf->digest;
salt_t *salt = hash_buf->salt;
seven_zip_hook_salt_t *seven_zip = (seven_zip_hook_salt_t *) hash_buf->hook_salt;
/**
* parse line
*/
u8 *data_type_pos = input_buf + 4;
u8 *NumCyclesPower_pos = (u8 *) strchr ((const char *) data_type_pos, '$');
if (NumCyclesPower_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
u32 data_type_len = NumCyclesPower_pos - data_type_pos;
NumCyclesPower_pos++;
u8 *salt_len_pos = (u8 *) strchr ((const char *) NumCyclesPower_pos, '$');
if (salt_len_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
u32 NumCyclesPower_len = salt_len_pos - NumCyclesPower_pos;
salt_len_pos++;
u8 *salt_buf_pos = (u8 *) strchr ((const char *) salt_len_pos, '$');
if (salt_buf_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
u32 salt_len_len = salt_buf_pos - salt_len_pos;
salt_buf_pos++;
u8 *iv_len_pos = (u8 *) strchr ((const char *) salt_buf_pos, '$');
if (iv_len_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
u32 salt_buf_len = iv_len_pos - salt_buf_pos;
iv_len_pos++;
u8 *iv_buf_pos = (u8 *) strchr ((const char *) iv_len_pos, '$');
if (iv_buf_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
u32 iv_len_len = iv_buf_pos - iv_len_pos;
iv_buf_pos++;
token_t token;
u8 *crc_buf_pos = (u8 *) strchr ((const char *) iv_buf_pos, '$');
token.token_cnt = 11;
if (crc_buf_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
token.signatures_cnt = 1;
token.signatures_buf[0] = SIGNATURE_SEVEN_ZIP;
u32 iv_buf_len = crc_buf_pos - iv_buf_pos;
token.len[0] = 4;
token.attr[0] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_SIGNATURE;
crc_buf_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;
u8 *data_len_pos = (u8 *) strchr ((const char *) crc_buf_pos, '$');
token.sep[2] = '$';
token.len_min[2] = 1;
token.len_max[2] = 2;
token.attr[2] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_DIGIT;
if (data_len_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
token.sep[3] = '$';
token.len_min[3] = 1;
token.len_max[3] = 2;
token.attr[3] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_DIGIT;
u32 crc_buf_len = data_len_pos - crc_buf_pos;
token.sep[4] = '$';
token.len_min[4] = 0;
token.len_max[4] = 64;
token.attr[4] = TOKEN_ATTR_VERIFY_LENGTH;
data_len_pos++;
token.sep[5] = '$';
token.len_min[5] = 2;
token.len_max[5] = 2;
token.attr[5] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_DIGIT;
u8 *unpack_size_pos = (u8 *) strchr ((const char *) data_len_pos, '$');
token.sep[6] = '$';
token.len_min[6] = 32;
token.len_max[6] = 32;
token.attr[6] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
if (unpack_size_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
token.sep[7] = '$';
token.len_min[7] = 10;
token.len_max[7] = 10;
token.attr[7] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_DIGIT;
u32 data_len_len = unpack_size_pos - data_len_pos;
token.sep[8] = '$';
token.len_min[8] = 1;
token.len_max[8] = 4;
token.attr[8] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_DIGIT;
unpack_size_pos++;
token.sep[9] = '$';
token.len_min[9] = 1;
token.len_max[9] = 4;
token.attr[9] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_DIGIT;
u8 *data_buf_pos = (u8 *) strchr ((const char *) unpack_size_pos, '$');
token.sep[10] = '$';
token.len_min[10] = 2;
token.len_max[10] = 655056;
token.attr[10] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
if (data_buf_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
const int rc_tokenizer = input_tokenizer (input_buf, input_len, &token);
u32 unpack_size_len = data_buf_pos - unpack_size_pos;
if (rc_tokenizer != PARSER_OK) return (rc_tokenizer);
data_buf_pos++;
u8 *data_type_pos = token.buf[ 1];
u8 *NumCyclesPower_pos = token.buf[ 2];
u8 *salt_len_pos = token.buf[ 3];
u8 *salt_buf_pos = token.buf[ 4];
u8 *iv_len_pos = token.buf[ 5];
u8 *iv_buf_pos = token.buf[ 6];
u8 *crc_buf_pos = token.buf[ 7];
u8 *data_len_pos = token.buf[ 8];
u8 *unpack_size_pos = token.buf[ 9];
u8 *data_buf_pos = token.buf[10];
int data_type_len = token.len[ 1];
int NumCyclesPower_len = token.len[ 2];
int salt_len_len = token.len[ 3];
int salt_buf_len = token.len[ 4];
int iv_len_len = token.len[ 5];
int iv_buf_len = token.len[ 6];
int crc_buf_len = token.len[ 7];
int data_len_len = token.len[ 8];
int unpack_size_len = token.len[ 9];
int data_buf_len = token.len[10];
// fields only used when data was compressed:
@ -13052,8 +13029,6 @@ int seven_zip_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_
u8 *coder_attributes_pos = 0;
u32 coder_attributes_len = 0;
u32 data_buf_len = 0;
if (crc_len_pos != NULL)
{
data_buf_len = crc_len_pos - data_buf_pos;
@ -13068,22 +13043,18 @@ int seven_zip_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_
coder_attributes_pos++;
}
else
{
data_buf_len = input_len - 1 - 2 - 1 - data_type_len - 1 - NumCyclesPower_len - 1 - salt_len_len - 1 - salt_buf_len - 1 - iv_len_len - 1 - iv_buf_len - 1 - crc_buf_len - 1 - data_len_len - 1 - unpack_size_len - 1;
}
const u32 iter = hc_strtoul ((const char *) NumCyclesPower_pos, NULL, 10);
const u32 crc = hc_strtoul ((const char *) crc_buf_pos, NULL, 10);
const u32 data_type = hc_strtoul ((const char *) data_type_pos, NULL, 10);
const u32 salt_len = hc_strtoul ((const char *) salt_len_pos, NULL, 10);
const u32 iv_len = hc_strtoul ((const char *) iv_len_pos, NULL, 10);
const u32 unpack_size = hc_strtoul ((const char *) unpack_size_pos, NULL, 10);
const u32 data_len = hc_strtoul ((const char *) data_len_pos, NULL, 10);
const int iter = hc_strtoul ((const char *) NumCyclesPower_pos, NULL, 10);
const int crc = hc_strtoul ((const char *) crc_buf_pos, NULL, 10);
const int data_type = hc_strtoul ((const char *) data_type_pos, NULL, 10);
const int salt_len = hc_strtoul ((const char *) salt_len_pos, NULL, 10);
const int iv_len = hc_strtoul ((const char *) iv_len_pos, NULL, 10);
const int unpack_size = hc_strtoul ((const char *) unpack_size_pos, NULL, 10);
const int data_len = hc_strtoul ((const char *) data_len_pos, NULL, 10);
// if neither uncompressed nor truncated, then we need the length for crc and coder attributes
u32 crc_len = 0;
int crc_len = 0;
bool is_compressed = ((data_type != 0) && (data_type != 0x80));
@ -13139,12 +13110,10 @@ int seven_zip_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_
seven_zip->data_type = data_type;
if (is_valid_hex_string (iv_buf_pos, 32) == false) return (PARSER_SALT_ENCODING);
seven_zip->iv_buf[0] = hex_to_u32 ((const u8 *) &iv_buf_pos[ 0]);
seven_zip->iv_buf[1] = hex_to_u32 ((const u8 *) &iv_buf_pos[ 8]);
seven_zip->iv_buf[2] = hex_to_u32 ((const u8 *) &iv_buf_pos[16]);
seven_zip->iv_buf[3] = hex_to_u32 ((const u8 *) &iv_buf_pos[24]);
seven_zip->iv_buf[0] = hex_to_u32 (iv_buf_pos + 0);
seven_zip->iv_buf[1] = hex_to_u32 (iv_buf_pos + 8);
seven_zip->iv_buf[2] = hex_to_u32 (iv_buf_pos + 16);
seven_zip->iv_buf[3] = hex_to_u32 (iv_buf_pos + 24);
seven_zip->iv_len = iv_len;
@ -13154,11 +13123,9 @@ int seven_zip_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_
seven_zip->crc = crc;
if (is_valid_hex_string (data_buf_pos, data_buf_len) == false) return (PARSER_SALT_ENCODING);
for (u32 i = 0, j = 0; j < data_buf_len; i += 1, j += 8)
for (int i = 0, j = 0; j < data_buf_len; i += 1, j += 8)
{
seven_zip->data_buf[i] = hex_to_u32 ((const u8 *) &data_buf_pos[j]);
seven_zip->data_buf[i] = hex_to_u32 (data_buf_pos + j);
}
seven_zip->data_len = data_len;
@ -13185,7 +13152,7 @@ int seven_zip_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_
// normally: crc_len <= unpacksize <= packsize (== data_len)
u32 aes_len = data_len;
int aes_len = data_len;
if (crc_len != 0) // it is 0 only in case of uncompressed data or truncated data
{

Write Preview
Loading…
Cancel
Save