case 12900: return ((char *) HT_12900); break;
case 13000: return ((char *) HT_13000); break;
case 13100: return ((char *) HT_13100); break;
+ case 13200: return ((char *) HT_13200); break;
+ case 13300: return ((char *) HT_13300); break;
}
return ((char *) "Unknown");
data,
data + 33);
}
+ else if (hash_mode == 13200)
+ {
+ snprintf (out_buf, len-1, "%s*%d*%08x%08x%08x%08x*%08x%08x%08x%08x%08x%08x",
+ SIGNATURE_AXCRYPT,
+ salt.salt_iter,
+ salt.salt_buf[0],
+ salt.salt_buf[1],
+ salt.salt_buf[2],
+ salt.salt_buf[3],
+ salt.salt_buf[4],
+ salt.salt_buf[5],
+ salt.salt_buf[6],
+ salt.salt_buf[7],
+ salt.salt_buf[8],
+ salt.salt_buf[9]);
+ }
+ else if (hash_mode == 13300)
+ {
+ snprintf (out_buf, len-1, "%s$%08x%08x%08x%08x",
+ SIGNATURE_AXCRYPT_SHA1,
+ digest_buf[0],
+ digest_buf[1],
+ digest_buf[2],
+ digest_buf[3]);
+ }
else
{
if (hash_type == HASH_TYPE_MD4)
salt_len = parse_and_store_salt (salt_buf_ptr, salt_buf, salt_len);
- // max. salt length: salt_buf[32] => 32 - 22 (":Administration Tools:") = 10
- if (salt_len > 10) return (PARSER_SALT_LENGTH);
+ // max. salt length: 55 (max for MD5) - 22 (":Administration Tools:") - 1 (0x80) = 32
+ // 32 - 4 bytes (to fit w0lr for all attack modes) = 28
+
+ if (salt_len > 28) return (PARSER_SALT_LENGTH);
salt->salt_len = salt_len;
uint salt_len = strlen (in.essid);
+ if (salt_len > 36)
+ {
+ log_info ("WARNING: the length of the ESSID is too long. The hccap file may be invalid or corrupted");
+
+ return (PARSER_SALT_LENGTH);
+ }
+
memcpy (salt->salt_buf, in.essid, salt_len);
salt->salt_len = salt_len;
int md5crypt_parse_hash (char *input_buf, uint input_len, hash_t *hash_buf)
{
+ if (input_len < DISPLAY_LEN_MIN_500) return (PARSER_GLOBAL_LENGTH);
+
if (memcmp (SIGNATURE_MD5CRYPT, input_buf, 3)) return (PARSER_SIGNATURE_UNMATCHED);
u32 *digest = (u32 *) hash_buf->digest;
salt->salt_iter = ROUNDS_MD5CRYPT;
}
- if ((input_len < DISPLAY_LEN_MIN_500) || (input_len > (DISPLAY_LEN_MAX_500 + iterations_len))) return (PARSER_GLOBAL_LENGTH);
+ if (input_len > (DISPLAY_LEN_MAX_500 + iterations_len)) return (PARSER_GLOBAL_LENGTH);
char *hash_pos = strchr (salt_pos, '$');
char *hash_pos = strchr (srvchall_pos, ':');
- if (srvchall_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
+ if (hash_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
uint srvchall_len = hash_pos - srvchall_pos;
char *hash_pos = strchr (srvchall_pos, ':');
- if (srvchall_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
+ if (hash_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
uint srvchall_len = hash_pos - srvchall_pos;
return (PARSER_OK);
}
+int sha1axcrypt_parse_hash (char *input_buf, uint input_len, hash_t *hash_buf)
+{
+ if ((input_len < DISPLAY_LEN_MIN_13300) || (input_len > DISPLAY_LEN_MAX_13300)) return (PARSER_GLOBAL_LENGTH);
+
+ if (memcmp (SIGNATURE_AXCRYPT_SHA1, input_buf, 13)) return (PARSER_SIGNATURE_UNMATCHED);
+
+ u32 *digest = (u32 *) hash_buf->digest;
+
+ input_buf +=14;
+
+ digest[0] = hex_to_u32 ((const u8 *) &input_buf[ 0]);
+ digest[1] = hex_to_u32 ((const u8 *) &input_buf[ 8]);
+ digest[2] = hex_to_u32 ((const u8 *) &input_buf[16]);
+ digest[3] = hex_to_u32 ((const u8 *) &input_buf[24]);
+ digest[4] = 0x00000000;
+
+ return (PARSER_OK);
+}
+
int sha1s_parse_hash (char *input_buf, uint input_len, hash_t *hash_buf)
{
if (data.opts_type & OPTS_TYPE_ST_HEX)
int tmp_len = base64_decode (base64_to_int, (const u8 *) input_buf + 6, input_len - 6, tmp_buf);
+ if (tmp_len < 20) return (PARSER_HASH_LENGTH);
+
memcpy (digest, tmp_buf, 20);
- salt->salt_len = tmp_len - 20;
+ int salt_len = tmp_len - 20;
+
+ if (salt_len < 0) return (PARSER_SALT_LENGTH);
+
+ salt->salt_len = salt_len;
memcpy (salt->salt_buf, tmp_buf + 20, salt->salt_len);
in_off[0] = strtok (input_buf, ":");
+ if (in_off[0] == NULL) return (PARSER_SEPARATOR_UNMATCHED);
+
in_len[0] = strlen (in_off[0]);
size_t i;
in_off[0] = strtok (input_buf, ":");
+ if (in_off[0] == NULL) return (PARSER_SEPARATOR_UNMATCHED);
+
in_len[0] = strlen (in_off[0]);
size_t i;
int tmp_len = base64_decode (base64_to_int, (const u8 *) input_buf + 9, input_len - 9, tmp_buf);
+ if (tmp_len < 64) return (PARSER_HASH_LENGTH);
+
memcpy (digest, tmp_buf, 64);
digest[0] = byte_swap_64 (digest[0]);
digest[6] -= SHA512M_G;
digest[7] -= SHA512M_H;
- salt->salt_len = tmp_len - 64;
+ int salt_len = tmp_len - 64;
+
+ if (salt_len < 0) return (PARSER_SALT_LENGTH);
+
+ salt->salt_len = salt_len;
memcpy (salt->salt_buf, tmp_buf + 64, salt->salt_len);
u32 *digest = (u32 *) hash_buf->digest;
+ salt_t *salt = hash_buf->salt;
+
u8 tmp_buf[100] = { 0 };
base64_decode (base64_to_int, (const u8 *) input_buf, input_len, tmp_buf);
digest[3] -= SHA1M_D;
digest[4] -= SHA1M_E;
+ salt->salt_buf[0] = 0x80;
+
+ salt->salt_len = 0;
+
return (PARSER_OK);
}
char *edata_ptr = (char *) krb5tgs->edata2;
+ krb5tgs->edata2_len = (data_len - 32) / 2 ;
+
/* skip '$' */
- for (uint i = 16 * 2 + 1; i < input_len; i += 2)
+ for (uint i = 16 * 2 + 1; i < (krb5tgs->edata2_len * 2) + (16 * 2 + 1); i += 2)
{
const char p0 = data_pos[i + 0];
const char p1 = data_pos[i + 1];
/* this is needed for hmac_md5 */
*edata_ptr++ = 0x80;
- krb5tgs->edata2_len = (data_len - 32) / 2 ;
-
salt->salt_buf[0] = krb5tgs->checksum[0];
salt->salt_buf[1] = krb5tgs->checksum[1];
salt->salt_buf[2] = krb5tgs->checksum[2];
return (PARSER_OK);
}
+int axcrypt_parse_hash (char *input_buf, uint input_len, hash_t *hash_buf)
+{
+ if ((input_len < DISPLAY_LEN_MIN_13200) || (input_len > DISPLAY_LEN_MAX_13200)) return (PARSER_GLOBAL_LENGTH);
+
+ if (memcmp (SIGNATURE_AXCRYPT, input_buf, 11)) return (PARSER_SIGNATURE_UNMATCHED);
+
+ u32 *digest = (u32 *) hash_buf->digest;
+
+ salt_t *salt = hash_buf->salt;
+
+ /**
+ * parse line
+ */
+
+ /* Skip '*' */
+ char *wrapping_rounds_pos = input_buf + 11 + 1;
+
+ char *salt_pos;
+
+ char *wrapped_key_pos;
+
+ char *data_pos;
+
+ salt->salt_iter = atoi (wrapping_rounds_pos);
+
+ salt_pos = strchr (wrapping_rounds_pos, '*');
+
+ if (salt_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
+
+ uint wrapping_rounds_len = salt_pos - wrapping_rounds_pos;
+
+ /* Skip '*' */
+ salt_pos++;
+
+ data_pos = salt_pos;
+
+ wrapped_key_pos = strchr (salt_pos, '*');
+
+ if (wrapped_key_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
+
+ uint salt_len = wrapped_key_pos - salt_pos;
+
+ if (salt_len != 32) return (PARSER_SALT_LENGTH);
+
+ /* Skip '*' */
+ wrapped_key_pos++;
+
+ uint wrapped_key_len = input_len - 11 - 1 - wrapping_rounds_len - 1 - salt_len - 1;
+
+ if (wrapped_key_len != 48) return (PARSER_SALT_LENGTH);
+
+ 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]);
+
+ data_pos += 33;
+
+ salt->salt_buf[4] = hex_to_u32 ((const u8 *) &data_pos[ 0]);
+ salt->salt_buf[5] = hex_to_u32 ((const u8 *) &data_pos[ 8]);
+ salt->salt_buf[6] = hex_to_u32 ((const u8 *) &data_pos[16]);
+ salt->salt_buf[7] = hex_to_u32 ((const u8 *) &data_pos[24]);
+ salt->salt_buf[8] = hex_to_u32 ((const u8 *) &data_pos[32]);
+ salt->salt_buf[9] = hex_to_u32 ((const u8 *) &data_pos[40]);
+
+ salt->salt_len = 40;
+
+ digest[0] = salt->salt_buf[0];
+ digest[1] = salt->salt_buf[1];
+ digest[2] = salt->salt_buf[2];
+ digest[3] = salt->salt_buf[3];
+
+ return (PARSER_OK);
+}
+
int cf10_parse_hash (char *input_buf, uint input_len, hash_t *hash_buf)
{
if ((input_len < DISPLAY_LEN_MIN_12600) || (input_len > DISPLAY_LEN_MAX_12600)) return (PARSER_GLOBAL_LENGTH);
projects / hashcat.git / blobdiff