arno/hashcat
1
0
Fork 0
mirror of https://github.com/hashcat/hashcat.git synced 2024-11-26 01:50:10 +00:00
Code Issues Releases Wiki Activity

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

Browse Source 
ms_drsr_parse_hash
androidfde_samsung_parse_hash
rar5_parse_hash
krb5tgs_parse_hash
axcrypt_parse_hash
This commit is contained in:
jsteube 2018-07-17 16:13:55 +02:00
parent a6b52d6faf
commit 558c2c4aa5
2 changed files with 291 additions and 270 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
include/interface.h
View File

@ -1020,18 +1020,6 @@ typedef struct hccapx hccapx_t;
typedef enum display_len typedef enum display_len
{ {
DISPLAY_LEN_MIN_12700 = 1 + 10 + 1 + 1 + 1 + 64,
DISPLAY_LEN_MAX_12700 = 1 + 10 + 1 + 5 + 1 + 20000,
DISPLAY_LEN_MIN_12800 = 11 + 1 + 20 + 1 + 1 + 1 + 64,
DISPLAY_LEN_MAX_12800 = 11 + 1 + 20 + 1 + 5 + 1 + 64,
DISPLAY_LEN_MIN_12900 = 64 + 64 + 32,
DISPLAY_LEN_MAX_12900 = 64 + 64 + 32,
DISPLAY_LEN_MIN_13000 = 1 + 4 + 1 + 2 + 1 + 32 + 1 + 2 + 1 + 32 + 1 + 1 + 1 + 16,
DISPLAY_LEN_MAX_13000 = 1 + 4 + 1 + 2 + 1 + 32 + 1 + 2 + 1 + 32 + 1 + 1 + 1 + 16,
DISPLAY_LEN_MIN_13100 = 1 + 7 + 1 + 2 + 1 + 0 + 0 + 32 + 1 + 64,
DISPLAY_LEN_MAX_13100 = 1 + 7 + 1 + 2 + 1 + 2 + 512 + 1 + 32 + 1 + 20480,
DISPLAY_LEN_MIN_13200 = 1 + 7 + 1 + 1 + 1 + 1 + 1 + 1 + 32 + 1 + 48,
DISPLAY_LEN_MAX_13200 = 1 + 7 + 1 + 1 + 1 + 1 + 50 + 1 + 32 + 1 + 48 + 1 + 20480,
DISPLAY_LEN_MIN_13400 = 1 + 7 + 1 + 1 + 1 + 1 + 1 + 1 + 32 + 1 + 64 + 1 + 32 + 1 + 64 + 1 + 1 + 1 + 1, DISPLAY_LEN_MIN_13400 = 1 + 7 + 1 + 1 + 1 + 1 + 1 + 1 + 32 + 1 + 64 + 1 + 32 + 1 + 64 + 1 + 1 + 1 + 1,
DISPLAY_LEN_MAX_13400 = 1 + 7 + 1 + 1 + 10 + 1 + 3 + 1 + 64 + 1 + 64 + 1 + 32 + 1 + 64 + 1 + 4 + 1 + 600000 + 1 + 2 + 1 + 64, DISPLAY_LEN_MAX_13400 = 1 + 7 + 1 + 1 + 10 + 1 + 3 + 1 + 64 + 1 + 64 + 1 + 32 + 1 + 64 + 1 + 4 + 1 + 600000 + 1 + 2 + 1 + 64,
DISPLAY_LEN_MIN_13600 = 6 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 16 + 1 + 1 + 1 + 1 + 1 + 0 + 1 + 20 + 1 + 7, DISPLAY_LEN_MIN_13600 = 6 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 16 + 1 + 1 + 1 + 1 + 1 + 0 + 1 + 20 + 1 + 7,

547
src/interface.c
View File

@ -584,7 +584,7 @@ static const char *HT_13763 = "VeraCrypt PBKDF2-HMAC-SHA256 + XTS 1536 bit + boo
static const char *HT_12001 = "Atlassian (PBKDF2-HMAC-SHA1)"; static const char *HT_12001 = "Atlassian (PBKDF2-HMAC-SHA1)";
static const char *SIGNATURE_ANDROIDFDE = "$fde$"; static const char *SIGNATURE_ANDROIDFDE = "$fde$";
static const char *SIGNATURE_AXCRYPT = "$axcrypt$*1"; static const char *SIGNATURE_AXCRYPT = "$axcrypt$";
static const char *SIGNATURE_AXCRYPT_SHA1 = "$axcrypt_sha1$"; static const char *SIGNATURE_AXCRYPT_SHA1 = "$axcrypt_sha1$";
static const char *SIGNATURE_BCRYPT1 = "$2a$"; static const char *SIGNATURE_BCRYPT1 = "$2a$";
static const char *SIGNATURE_BCRYPT2 = "$2b$"; static const char *SIGNATURE_BCRYPT2 = "$2b$";
@ -605,7 +605,7 @@ static const char *SIGNATURE_ECRYPTFS = "$ecryptfs$";
static const char *SIGNATURE_EPISERVER = "$episerver$"; static const char *SIGNATURE_EPISERVER = "$episerver$";
static const char *SIGNATURE_KEEPASS = "$keepass$"; static const char *SIGNATURE_KEEPASS = "$keepass$";
static const char *SIGNATURE_KRB5PA = "$krb5pa$23$"; static const char *SIGNATURE_KRB5PA = "$krb5pa$23$";
static const char *SIGNATURE_KRB5TGS = "$krb5tgs$23"; static const char *SIGNATURE_KRB5TGS = "$krb5tgs$23$";
static const char *SIGNATURE_MD5AIX = "{smd5}"; static const char *SIGNATURE_MD5AIX = "{smd5}";
static const char *SIGNATURE_MD5APR1 = "$apr1$"; static const char *SIGNATURE_MD5APR1 = "$apr1$";
static const char *SIGNATURE_MD5CRYPT = "$1$"; static const char *SIGNATURE_MD5CRYPT = "$1$";
@ -13803,106 +13803,97 @@ int rar3hp_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNU
int rar5_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNUSED hashconfig_t *hashconfig) int rar5_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNUSED hashconfig_t *hashconfig)
{ {
if ((input_len < DISPLAY_LEN_MIN_13000) || (input_len > DISPLAY_LEN_MAX_13000)) return (PARSER_GLOBAL_LENGTH);
if (memcmp (SIGNATURE_RAR5, input_buf, 1 + 4 + 1) != 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;
rar5_t *rar5 = (rar5_t *) hash_buf->esalt; rar5_t *rar5 = (rar5_t *) hash_buf->esalt;
/** token_t token;
* parse line
*/
u8 *param0_pos = input_buf + 1 + 4 + 1; token.token_cnt = 7;
u8 *param1_pos = (u8 *) strchr ((const char *) param0_pos, '$'); token.signatures_cnt = 1;
token.signatures_buf[0] = SIGNATURE_RAR5;
if (param1_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED); token.len[0] = 6;
token.attr[0] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_SIGNATURE;
u32 param0_len = param1_pos - param0_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;
param1_pos++; token.sep[2] = '$';
token.len_min[2] = 32;
token.len_max[2] = 32;
token.attr[2] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
u8 *param2_pos = (u8 *) strchr ((const char *) param1_pos, '$'); token.sep[3] = '$';
token.len_min[3] = 2;
token.len_max[3] = 2;
token.attr[3] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_DIGIT;
if (param2_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED); token.sep[4] = '$';
token.len_min[4] = 32;
token.len_max[4] = 32;
token.attr[4] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
u32 param1_len = param2_pos - param1_pos; token.sep[5] = '$';
token.len_min[5] = 1;
token.len_max[5] = 1;
token.attr[5] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_DIGIT;
param2_pos++; token.sep[6] = '$';
token.len_min[6] = 16;
token.len_max[6] = 16;
token.attr[6] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
u8 *param3_pos = (u8 *) strchr ((const char *) param2_pos, '$'); const int rc_tokenizer = input_tokenizer (input_buf, input_len, &token);
if (param3_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED); if (rc_tokenizer != PARSER_OK) return (rc_tokenizer);
u32 param2_len = param3_pos - param2_pos; // iter
param3_pos++; u8 *iter_pos = token.buf[3];
u8 *param4_pos = (u8 *) strchr ((const char *) param3_pos, '$'); const u32 iterations = hc_strtoul ((const char *) iter_pos, NULL, 10);
if (param4_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED); salt->salt_iter = ((1u << iterations) + 32) - 1;
u32 param3_len = param4_pos - param3_pos;
param4_pos++;
u8 *param5_pos = (u8 *) strchr ((const char *) param4_pos, '$');
if (param5_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
u32 param4_len = param5_pos - param4_pos;
param5_pos++;
u32 param5_len = input_len - 1 - 4 - 1 - param0_len - 1 - param1_len - 1 - param2_len - 1 - param3_len - 1 - param4_len - 1;
u8 *salt_buf = param1_pos;
u8 *iv = param3_pos;
u8 *pswcheck = param5_pos;
const u32 salt_len = hc_strtoul ((const char *) param0_pos, NULL, 10);
const u32 iterations = hc_strtoul ((const char *) param2_pos, NULL, 10);
const u32 pswcheck_len = hc_strtoul ((const char *) param4_pos, NULL, 10);
/**
* verify some data
*/
if (param1_len != 32) return (PARSER_SALT_VALUE);
if (param3_len != 32) return (PARSER_SALT_VALUE);
if (param5_len != 16) return (PARSER_SALT_VALUE);
if (salt_len != 16) return (PARSER_SALT_VALUE);
if (iterations == 0) return (PARSER_SALT_VALUE); if (iterations == 0) return (PARSER_SALT_VALUE);
if (pswcheck_len != 8) return (PARSER_SALT_VALUE);
/** salt->salt_sign[0] = iterations;
* store data
*/
if (is_valid_hex_string (salt_buf, 32) == false) return (PARSER_SALT_ENCODING); // salt
salt->salt_buf[0] = hex_to_u32 ((const u8 *) &salt_buf[ 0]); u8 *salt_buf = token.buf[2];
salt->salt_buf[1] = hex_to_u32 ((const u8 *) &salt_buf[ 8]);
salt->salt_buf[2] = hex_to_u32 ((const u8 *) &salt_buf[16]); salt->salt_buf[0] = hex_to_u32 (salt_buf + 0);
salt->salt_buf[3] = hex_to_u32 ((const u8 *) &salt_buf[24]); salt->salt_buf[1] = hex_to_u32 (salt_buf + 8);
salt->salt_buf[2] = hex_to_u32 (salt_buf + 16);
salt->salt_buf[3] = hex_to_u32 (salt_buf + 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]);
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]);
if (is_valid_hex_string (iv, 32) == false) return (PARSER_SALT_ENCODING); // iv
rar5->iv[0] = hex_to_u32 ((const u8 *) &iv[ 0]); u8 *iv = token.buf[4];
rar5->iv[1] = hex_to_u32 ((const u8 *) &iv[ 8]);
rar5->iv[2] = hex_to_u32 ((const u8 *) &iv[16]); rar5->iv[0] = hex_to_u32 (iv + 0);
rar5->iv[3] = hex_to_u32 ((const u8 *) &iv[24]); rar5->iv[1] = hex_to_u32 (iv + 8);
rar5->iv[2] = hex_to_u32 (iv + 16);
rar5->iv[3] = hex_to_u32 (iv + 24);
rar5->iv[0] = byte_swap_32 (rar5->iv[0]); rar5->iv[0] = byte_swap_32 (rar5->iv[0]);
rar5->iv[1] = byte_swap_32 (rar5->iv[1]); rar5->iv[1] = byte_swap_32 (rar5->iv[1]);
@ -13911,18 +13902,12 @@ int rar5_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNUSE
salt->salt_len = 16; salt->salt_len = 16;
salt->salt_sign[0] = iterations; // hash
salt->salt_iter = ((1u << iterations) + 32) - 1; u8 *pswcheck = token.buf[6];
/** digest[0] = hex_to_u32 (pswcheck + 0);
* digest buf digest[1] = hex_to_u32 (pswcheck + 8);
*/
if (is_valid_hex_string (pswcheck, 16) == false) return (PARSER_SALT_ENCODING);
digest[0] = hex_to_u32 ((const u8 *) &pswcheck[ 0]);
digest[1] = hex_to_u32 ((const u8 *) &pswcheck[ 8]);
digest[2] = 0; digest[2] = 0;
digest[3] = 0; digest[3] = 0;
@ -13936,78 +13921,110 @@ int rar5_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNUSE
int krb5tgs_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNUSED hashconfig_t *hashconfig) int krb5tgs_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNUSED hashconfig_t *hashconfig)
{ {
if ((input_len < DISPLAY_LEN_MIN_13100) || (input_len > DISPLAY_LEN_MAX_13100)) return (PARSER_GLOBAL_LENGTH);
if (memcmp (SIGNATURE_KRB5TGS, input_buf, 11) != 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;
krb5tgs_t *krb5tgs = (krb5tgs_t *) hash_buf->esalt; krb5tgs_t *krb5tgs = (krb5tgs_t *) hash_buf->esalt;
token_t token;
token.signatures_cnt = 1;
token.signatures_buf[0] = SIGNATURE_KRB5TGS;
token.len[0] = 12;
token.attr[0] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_SIGNATURE;
/** /**
* parse line * $krb5tgs$23$checksum$edata2
* $krb5tgs$23$*user*realm*spn*$checksum$edata2
*/ */
/* Skip '$' */ if (input_len < 16) return (PARSER_SALT_LENGTH);
u8 *account_pos = input_buf + 11 + 1;
u8 *data_pos; if (input_buf[12] == '*')
u32 data_len;
if (account_pos[0] == '*')
{ {
account_pos++; char *account_info_start = input_buf + 12; // we want the * char included
char *account_info_stop = strchr ((const char *) account_info_start + 1, '*');
data_pos = (u8 *) strchr ((const char *) account_pos, '*'); if (account_info_stop == NULL) return (PARSER_SEPARATOR_UNMATCHED);
if (data_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED); account_info_stop++; // we want the * char included
account_info_stop++; // we want the $ char included
/* Skip '*' */ const int account_info_len = account_info_stop - account_info_start;
data_pos++;
u32 account_len = data_pos - account_pos + 1; token.token_cnt = 4;
if (account_len >= 512) return (PARSER_SALT_LENGTH); token.len[1] = account_info_len;
token.attr[1] = TOKEN_ATTR_FIXED_LENGTH;
/* Skip '$' */ token.sep[2] = '$';
data_pos++; token.len_min[2] = 32;
token.len_max[2] = 32;
token.attr[2] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
data_len = input_len - 11 - 1 - account_len - 2; token.sep[3] = '$';
token.len_min[3] = 64;
memcpy (krb5tgs->account_info, account_pos - 1, account_len); token.len_max[3] = 20480;
token.attr[3] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
} }
else else
{ {
/* assume $krb5tgs$23$checksum$edata2 */ token.token_cnt = 3;
data_pos = account_pos;
memcpy (krb5tgs->account_info, "**", 3); token.sep[1] = '$';
token.len_min[1] = 32;
token.len_max[1] = 32;
token.attr[1] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
data_len = input_len - 11 - 1 - 1; token.sep[2] = '$';
token.len_min[2] = 64;
token.len_max[2] = 20480;
token.attr[2] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
} }
if (data_len < ((16 + 32) * 2)) return (PARSER_SALT_LENGTH); const int rc_tokenizer = input_tokenizer (input_buf, input_len, &token);
u8 *checksum_ptr = (u8 *) krb5tgs->checksum; if (rc_tokenizer != PARSER_OK) return (rc_tokenizer);
for (u32 i = 0; i < 16 * 2; i += 2) u8 *checksum_pos;
u8 *data_pos;
int data_len;
if (input_buf[12] == '*')
{ {
const u8 p0 = data_pos[i + 0]; checksum_pos = token.buf[2];
const u8 p1 = data_pos[i + 1];
*checksum_ptr++ = hex_convert (p1) << 0 data_pos = token.buf[3];
| hex_convert (p0) << 4; data_len = token.len[3];
memcpy (krb5tgs->account_info, token.buf[1], token.len[1]);
} }
else
{
checksum_pos = token.buf[1];
data_pos = token.buf[2];
data_len = token.len[2];
krb5tgs->account_info[0] = 0;
}
krb5tgs->checksum[0] = hex_to_u32 (checksum_pos + 0);
krb5tgs->checksum[1] = hex_to_u32 (checksum_pos + 8);
krb5tgs->checksum[2] = hex_to_u32 (checksum_pos + 16);
krb5tgs->checksum[3] = hex_to_u32 (checksum_pos + 24);
u8 *edata_ptr = (u8 *) krb5tgs->edata2; u8 *edata_ptr = (u8 *) krb5tgs->edata2;
krb5tgs->edata2_len = (data_len - 32) / 2; for (int i = 0; i < data_len; i += 2)
/* skip '$' */
for (u32 i = 16 * 2 + 1; i < (krb5tgs->edata2_len * 2) + (16 * 2 + 1); i += 2)
{ {
const u8 p0 = data_pos[i + 0]; const u8 p0 = data_pos[i + 0];
const u8 p1 = data_pos[i + 1]; const u8 p1 = data_pos[i + 1];
@ -14016,6 +14033,8 @@ int krb5tgs_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UN
| hex_convert (p0) << 4; | hex_convert (p0) << 4;
} }
krb5tgs->edata2_len = data_len / 2;
/* this is needed for hmac_md5 */ /* this is needed for hmac_md5 */
*edata_ptr++ = 0x80; *edata_ptr++ = 0x80;
@ -14024,7 +14043,7 @@ int krb5tgs_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UN
salt->salt_buf[2] = krb5tgs->checksum[2]; salt->salt_buf[2] = krb5tgs->checksum[2];
salt->salt_buf[3] = krb5tgs->checksum[3]; salt->salt_buf[3] = krb5tgs->checksum[3];
salt->salt_len = 32; salt->salt_len = 16;
digest[0] = krb5tgs->checksum[0]; digest[0] = krb5tgs->checksum[0];
digest[1] = krb5tgs->checksum[1]; digest[1] = krb5tgs->checksum[1];
@ -14036,74 +14055,81 @@ int krb5tgs_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UN
int axcrypt_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNUSED hashconfig_t *hashconfig) int axcrypt_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNUSED hashconfig_t *hashconfig)
{ {
if ((input_len < DISPLAY_LEN_MIN_13200) || (input_len > DISPLAY_LEN_MAX_13200)) return (PARSER_GLOBAL_LENGTH);
if (memcmp (SIGNATURE_AXCRYPT, input_buf, 11) != 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
*/
/* Skip '*' */ token.token_cnt = 5;
u8 *wrapping_rounds_pos = input_buf + 11 + 1;
u8 *salt_pos; token.signatures_cnt = 1;
token.signatures_buf[0] = SIGNATURE_AXCRYPT;
u8 *wrapped_key_pos; token.sep[0] = '*';
token.len_min[0] = 9;
token.len_max[0] = 9;
token.attr[0] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_SIGNATURE;
u8 *data_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;
token.sep[2] = '*';
token.len_min[2] = 1;
token.len_max[2] = 6;
token.attr[2] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_DIGIT;
token.sep[3] = '*';
token.len_min[3] = 32;
token.len_max[3] = 32;
token.attr[3] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[4] = '*';
token.len_min[4] = 48;
token.len_max[4] = 48;
token.attr[4] = 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);
// iter
u8 *wrapping_rounds_pos = token.buf[2];
salt->salt_iter = hc_strtoul ((const char *) wrapping_rounds_pos, NULL, 10); salt->salt_iter = hc_strtoul ((const char *) wrapping_rounds_pos, NULL, 10);
salt_pos = (u8 *) strchr ((const char *) wrapping_rounds_pos, '*'); // salt
if (salt_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED); u8 *wrapped_key_pos = token.buf[3];
u32 wrapping_rounds_len = salt_pos - wrapping_rounds_pos; salt->salt_buf[0] = hex_to_u32 (wrapped_key_pos + 0);
salt->salt_buf[1] = hex_to_u32 (wrapped_key_pos + 8);
/* Skip '*' */ salt->salt_buf[2] = hex_to_u32 (wrapped_key_pos + 16);
salt_pos++; salt->salt_buf[3] = hex_to_u32 (wrapped_key_pos + 24);
data_pos = salt_pos;
wrapped_key_pos = (u8 *) strchr ((const char *) salt_pos, '*');
if (wrapped_key_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
u32 salt_len = wrapped_key_pos - salt_pos;
if (salt_len != 32) return (PARSER_SALT_LENGTH);
u32 wrapped_key_len = input_len - 11 - 1 - wrapping_rounds_len - 1 - salt_len - 1;
if (wrapped_key_len != 48) return (PARSER_SALT_LENGTH);
if (is_valid_hex_string (data_pos, 32) == false) return (PARSER_SALT_ENCODING);
salt->salt_buf[0] = hex_to_u32 ((const u8 *) &data_pos[ 0]);
salt->salt_buf[1] = hex_to_u32 ((const u8 *) &data_pos[ 8]);
salt->salt_buf[2] = hex_to_u32 ((const u8 *) &data_pos[16]);
salt->salt_buf[3] = hex_to_u32 ((const u8 *) &data_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]);
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]);
data_pos += 33; // data
if (is_valid_hex_string (data_pos, 48) == false) return (PARSER_SALT_ENCODING); u8 *data_pos = token.buf[4];
salt->salt_buf[4] = hex_to_u32 ((const u8 *) &data_pos[ 0]); salt->salt_buf[4] = hex_to_u32 (data_pos + 0);
salt->salt_buf[5] = hex_to_u32 ((const u8 *) &data_pos[ 8]); salt->salt_buf[5] = hex_to_u32 (data_pos + 8);
salt->salt_buf[6] = hex_to_u32 ((const u8 *) &data_pos[16]); salt->salt_buf[6] = hex_to_u32 (data_pos + 16);
salt->salt_buf[7] = hex_to_u32 ((const u8 *) &data_pos[24]); salt->salt_buf[7] = hex_to_u32 (data_pos + 24);
salt->salt_buf[8] = hex_to_u32 ((const u8 *) &data_pos[32]); salt->salt_buf[8] = hex_to_u32 (data_pos + 32);
salt->salt_buf[9] = hex_to_u32 ((const u8 *) &data_pos[40]); salt->salt_buf[9] = hex_to_u32 (data_pos + 40);
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]);
@ -14797,73 +14823,74 @@ int mywalletv2_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE
int ms_drsr_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNUSED hashconfig_t *hashconfig) int ms_drsr_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNUSED hashconfig_t *hashconfig)
{ {
if ((input_len < DISPLAY_LEN_MIN_12800) || (input_len > DISPLAY_LEN_MAX_12800)) return (PARSER_GLOBAL_LENGTH);
if (memcmp (SIGNATURE_MS_DRSR, input_buf, 11) != 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 + 11 + 1; token.token_cnt = 4;
u8 *iter_pos = (u8 *) strchr ((const char *) salt_pos, ','); token.signatures_cnt = 1;
token.signatures_buf[0] = SIGNATURE_MS_DRSR;
if (iter_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED); token.len_min[0] = 11;
token.len_max[0] = 11;
token.sep[0] = ',';
token.attr[0] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_SIGNATURE;
u32 salt_len = iter_pos - salt_pos; token.len_min[1] = 20;
token.len_max[1] = 20;
token.sep[1] = ',';
token.attr[1] = TOKEN_ATTR_VERIFY_LENGTH;
if (salt_len != 20) return (PARSER_SALT_LENGTH); token.len_min[2] = 1;
token.len_max[2] = 6;
token.sep[2] = ',';
token.attr[2] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_DIGIT;
iter_pos++; token.len_min[3] = 64;
token.len_max[3] = 64;
token.sep[3] = ',';
token.attr[3] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
u8 *hash_pos = (u8 *) strchr ((const char *) iter_pos, ','); const int rc_tokenizer = input_tokenizer (input_buf, input_len, &token);
if (hash_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED); if (rc_tokenizer != PARSER_OK) return (rc_tokenizer);
u32 iter_len = hash_pos - iter_pos; // salt
if (iter_len > 5) return (PARSER_SALT_LENGTH); u8 *salt_pos = token.buf[1];
int salt_len = token.len[1];
hash_pos++; salt->salt_buf[0] = hex_to_u32 (salt_pos + 0);
salt->salt_buf[1] = hex_to_u32 (salt_pos + 8);
u32 hash_len = input_len - 11 - 1 - salt_len - 1 - iter_len - 1; salt->salt_buf[2] = hex_to_u32 (salt_pos + 16) & 0x0000ffff;
if (hash_len != 64) return (PARSER_HASH_LENGTH);
/**
* salt
*/
if (is_valid_hex_string (salt_pos, 20) == false) return (PARSER_SALT_ENCODING);
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]) & 0x0000ffff;
salt->salt_buf[3] = 0; salt->salt_buf[3] = 0;
salt->salt_len = salt_len / 2; salt->salt_len = salt_len / 2;
// iter
u8 *iter_pos = token.buf[2];
salt->salt_iter = hc_strtoul ((const char *) iter_pos, NULL, 10) - 1ul; salt->salt_iter = hc_strtoul ((const char *) iter_pos, NULL, 10) - 1ul;
/** // hash
* digest buf
*/
if (is_valid_hex_string (hash_pos, 64) == false) return (PARSER_HASH_ENCODING); u8 *hash_pos = token.buf[3];
digest[0] = hex_to_u32 ((const u8 *) &hash_pos[ 0]); digest[0] = hex_to_u32 (hash_pos + 0);
digest[1] = hex_to_u32 ((const u8 *) &hash_pos[ 8]); digest[1] = hex_to_u32 (hash_pos + 8);
digest[2] = hex_to_u32 ((const u8 *) &hash_pos[16]); digest[2] = hex_to_u32 (hash_pos + 16);
digest[3] = hex_to_u32 ((const u8 *) &hash_pos[24]); digest[3] = hex_to_u32 (hash_pos + 24);
digest[4] = hex_to_u32 ((const u8 *) &hash_pos[32]); digest[4] = hex_to_u32 (hash_pos + 32);
digest[5] = hex_to_u32 ((const u8 *) &hash_pos[40]); digest[5] = hex_to_u32 (hash_pos + 40);
digest[6] = hex_to_u32 ((const u8 *) &hash_pos[48]); digest[6] = hex_to_u32 (hash_pos + 48);
digest[7] = hex_to_u32 ((const u8 *) &hash_pos[56]); 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]);
@ -14879,39 +14906,49 @@ int ms_drsr_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UN
int androidfde_samsung_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNUSED hashconfig_t *hashconfig) int androidfde_samsung_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNUSED hashconfig_t *hashconfig)
{ {
if ((input_len < DISPLAY_LEN_MIN_12900) || (input_len > DISPLAY_LEN_MAX_12900)) 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;
/** token_t token;
* parse line
*/
u8 *hash_pos = input_buf + 64; token.token_cnt = 3;
u8 *salt1_pos = input_buf + 128;
u8 *salt2_pos = input_buf; token.len[0] = 64;
token.attr[0] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.len[1] = 64;
token.attr[1] = TOKEN_ATTR_FIXED_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.len[2] = 32;
token.attr[2] = 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);
/** /**
* salt * salt
*/ */
if (is_valid_hex_string (salt1_pos, 32) == false) return (PARSER_SALT_ENCODING); u8 *salt1_pos = token.buf[2];
if (is_valid_hex_string (salt2_pos, 64) == false) return (PARSER_SALT_ENCODING); u8 *salt2_pos = token.buf[0];
salt->salt_buf[ 0] = hex_to_u32 ((const u8 *) &salt1_pos[ 0]); salt->salt_buf[ 0] = hex_to_u32 (salt1_pos + 0);
salt->salt_buf[ 1] = hex_to_u32 ((const u8 *) &salt1_pos[ 8]); salt->salt_buf[ 1] = hex_to_u32 (salt1_pos + 8);
salt->salt_buf[ 2] = hex_to_u32 ((const u8 *) &salt1_pos[16]); salt->salt_buf[ 2] = hex_to_u32 (salt1_pos + 16);
salt->salt_buf[ 3] = hex_to_u32 ((const u8 *) &salt1_pos[24]); salt->salt_buf[ 3] = hex_to_u32 (salt1_pos + 24);
salt->salt_buf[ 4] = hex_to_u32 ((const u8 *) &salt2_pos[ 0]); salt->salt_buf[ 4] = hex_to_u32 (salt2_pos + 0);
salt->salt_buf[ 5] = hex_to_u32 ((const u8 *) &salt2_pos[ 8]); salt->salt_buf[ 5] = hex_to_u32 (salt2_pos + 8);
salt->salt_buf[ 6] = hex_to_u32 ((const u8 *) &salt2_pos[16]); salt->salt_buf[ 6] = hex_to_u32 (salt2_pos + 16);
salt->salt_buf[ 7] = hex_to_u32 ((const u8 *) &salt2_pos[24]); salt->salt_buf[ 7] = hex_to_u32 (salt2_pos + 24);
salt->salt_buf[ 8] = hex_to_u32 ((const u8 *) &salt2_pos[32]); salt->salt_buf[ 8] = hex_to_u32 (salt2_pos + 32);
salt->salt_buf[ 9] = hex_to_u32 ((const u8 *) &salt2_pos[40]); salt->salt_buf[ 9] = hex_to_u32 (salt2_pos + 40);
salt->salt_buf[10] = hex_to_u32 ((const u8 *) &salt2_pos[48]); salt->salt_buf[10] = hex_to_u32 (salt2_pos + 48);
salt->salt_buf[11] = hex_to_u32 ((const u8 *) &salt2_pos[56]); salt->salt_buf[11] = hex_to_u32 (salt2_pos + 56);
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]);
@ -14934,16 +14971,16 @@ int androidfde_samsung_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_bu
* digest buf * digest buf
*/ */
if (is_valid_hex_string (hash_pos, 64) == false) return (PARSER_HASH_ENCODING); u8 *hash_pos = token.buf[1];
digest[0] = hex_to_u32 ((const u8 *) &hash_pos[ 0]); digest[0] = hex_to_u32 (hash_pos + 0);
digest[1] = hex_to_u32 ((const u8 *) &hash_pos[ 8]); digest[1] = hex_to_u32 (hash_pos + 8);
digest[2] = hex_to_u32 ((const u8 *) &hash_pos[16]); digest[2] = hex_to_u32 (hash_pos + 16);
digest[3] = hex_to_u32 ((const u8 *) &hash_pos[24]); digest[3] = hex_to_u32 (hash_pos + 24);
digest[4] = hex_to_u32 ((const u8 *) &hash_pos[32]); digest[4] = hex_to_u32 (hash_pos + 32);
digest[5] = hex_to_u32 ((const u8 *) &hash_pos[40]); digest[5] = hex_to_u32 (hash_pos + 40);
digest[6] = hex_to_u32 ((const u8 *) &hash_pos[48]); digest[6] = hex_to_u32 (hash_pos + 48);
digest[7] = hex_to_u32 ((const u8 *) &hash_pos[56]); 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]);
@ -20660,31 +20697,27 @@ int ascii_digest (hashcat_ctx_t *hashcat_ctx, char *out_buf, const size_t out_le
krb5tgs_t *krb5tgs = &krb5tgss[digest_cur]; krb5tgs_t *krb5tgs = &krb5tgss[digest_cur];
u8 *ptr_checksum = (u8 *) krb5tgs->checksum;
u8 *ptr_edata2 = (u8 *) krb5tgs->edata2;
char data[2560 * 4 * 2] = { 0 }; char data[2560 * 4 * 2] = { 0 };
char *ptr_data = data; for (u32 i = 0, j = 0; i < krb5tgs->edata2_len; i += 1, j += 2)
{
u8 *ptr_edata2 = (u8 *) krb5tgs->edata2;
for (u32 i = 0; i < 16; i++, ptr_data += 2) sprintf (data + j, "%02x", ptr_edata2[i]);
sprintf (ptr_data, "%02x", ptr_checksum[i]); }
/* skip '$' */ snprintf (out_buf, out_len - 1, "%s%s%08x%08x%08x%08x$%s",
ptr_data++;
for (u32 i = 0; i < krb5tgs->edata2_len; i++, ptr_data += 2)
sprintf (ptr_data, "%02x", ptr_edata2[i]);
snprintf (out_buf, out_len - 1, "%s$%s$%s$%s",
SIGNATURE_KRB5TGS, SIGNATURE_KRB5TGS,
(char *) krb5tgs->account_info, (char *) krb5tgs->account_info,
data, byte_swap_32 (krb5tgs->checksum[0]),
data + 33); byte_swap_32 (krb5tgs->checksum[1]),
byte_swap_32 (krb5tgs->checksum[2]),
byte_swap_32 (krb5tgs->checksum[3]),
data);
} }
else if (hash_mode == 13200) else if (hash_mode == 13200)
{ {
snprintf (out_buf, out_len - 1, "%s*%u*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x", snprintf (out_buf, out_len - 1, "%s*1*%u*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
SIGNATURE_AXCRYPT, SIGNATURE_AXCRYPT,
salt.salt_iter, salt.salt_iter,
salt.salt_buf[0], salt.salt_buf[0],