u8 GDBDebugServer::read_hexbyte()
{
std::string s = "";
s += read_char();
s += read_char();
return hex_to_u8(s);
}
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 *tmpdata = (char *) hcmalloc (st_hash_len / 2);
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);
return parser_status;
}
int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED void *digest_buf, MAYBE_UNUSED salt_t *salt, MAYBE_UNUSED void *esalt_buf, MAYBE_UNUSED void *hook_salt_buf, MAYBE_UNUSED hashinfo_t *hash_info, const char *line_buf, MAYBE_UNUSED const int line_len)
{
u32 *digest = (u32 *) digest_buf;
jks_sha1_t *jks_sha1 = (jks_sha1_t *) esalt_buf;
token_t token;
token.token_cnt = 7;
token.signatures_cnt = 1;
token.signatures_buf[0] = SIGNATURE_JKS_SHA1;
token.sep[0] = '*';
token.len_min[0] = 10;
token.len_max[0] = 10;
token.attr[0] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_SIGNATURE;
token.sep[1] = '*';
token.len_min[1] = 40;
token.len_max[1] = 40;
token.attr[1] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[2] = '*';
token.len_min[2] = 40;
token.len_max[2] = 40;
token.attr[2] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[3] = '*';
token.len_min[3] = 2;
token.len_max[3] = 16384;
token.attr[3] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[4] = '*';
token.len_min[4] = 2;
token.len_max[4] = 2;
token.attr[4] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_DIGIT;
token.sep[5] = '*';
token.len_min[5] = 28;
token.len_max[5] = 28;
token.attr[5] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[6] = '*';
token.len_min[6] = 0;
token.len_max[6] = 64;
token.attr[6] = TOKEN_ATTR_VERIFY_LENGTH;
const int rc_tokenizer = input_tokenizer ((const u8 *) line_buf, line_len, &token);
if (rc_tokenizer != PARSER_OK) return (rc_tokenizer);
// checksum
const u8 *checksum_pos = token.buf[1];
jks_sha1->checksum[0] = hex_to_u32 ((const u8 *) &checksum_pos[ 0]);
jks_sha1->checksum[1] = hex_to_u32 ((const u8 *) &checksum_pos[ 8]);
jks_sha1->checksum[2] = hex_to_u32 ((const u8 *) &checksum_pos[16]);
jks_sha1->checksum[3] = hex_to_u32 ((const u8 *) &checksum_pos[24]);
jks_sha1->checksum[4] = hex_to_u32 ((const u8 *) &checksum_pos[32]);
// iv
const u8 *iv_pos = token.buf[2];
jks_sha1->iv[0] = hex_to_u32 ((const u8 *) &iv_pos[ 0]);
jks_sha1->iv[1] = hex_to_u32 ((const u8 *) &iv_pos[ 8]);
jks_sha1->iv[2] = hex_to_u32 ((const u8 *) &iv_pos[16]);
jks_sha1->iv[3] = hex_to_u32 ((const u8 *) &iv_pos[24]);
jks_sha1->iv[4] = hex_to_u32 ((const u8 *) &iv_pos[32]);
// enc_key
const u8 *enc_key_pos = token.buf[3];
const int enc_key_len = token.len[3];
u8 *enc_key_buf = (u8 *) jks_sha1->enc_key_buf;
for (int i = 0, j = 0; j < enc_key_len; i += 1, j += 2)
{
enc_key_buf[i] = hex_to_u8 ((const u8 *) &enc_key_pos[j]);
jks_sha1->enc_key_len++;
}
// der1
const u8 *der1_pos = token.buf[4];
u8 *der = (u8 *) jks_sha1->der;
der[0] = hex_to_u8 ((const u8 *) &der1_pos[0]);
// der2
const u8 *der2_pos = token.buf[5];
for (int i = 6, j = 0; j < 28; i += 1, j += 2)
{
der[i] = hex_to_u8 ((const u8 *) &der2_pos[j]);
}
der[1] = 0;
der[2] = 0;
der[3] = 0;
der[4] = 0;
der[5] = 0;
// alias
const u8 *alias_pos = token.buf[6];
strncpy ((char *) jks_sha1->alias, (const char *) alias_pos, 64);
// fake salt
salt->salt_buf[0] = jks_sha1->iv[0];
salt->salt_buf[1] = jks_sha1->iv[1];
salt->salt_buf[2] = jks_sha1->iv[2];
salt->salt_buf[3] = jks_sha1->iv[3];
salt->salt_buf[4] = jks_sha1->iv[4];
salt->salt_len = 20;
// fake digest
digest[0] = byte_swap_32 (jks_sha1->der[0]);
digest[1] = byte_swap_32 (jks_sha1->der[1]);
digest[2] = byte_swap_32 (jks_sha1->der[2]);
digest[3] = byte_swap_32 (jks_sha1->der[3]);
digest[4] = byte_swap_32 (jks_sha1->der[4]);
return (PARSER_OK);
}
int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED void *digest_buf, MAYBE_UNUSED salt_t *salt, MAYBE_UNUSED void *esalt_buf, MAYBE_UNUSED void *hook_salt_buf, MAYBE_UNUSED hashinfo_t *hash_info, const char *line_buf, MAYBE_UNUSED const int line_len)
{
u32 *digest = (u32 *) digest_buf;
wpa_pmkid_t *wpa_pmkid = (wpa_pmkid_t *) esalt_buf;
token_t token;
// real 16801 pmkid hash-lines
token.token_cnt = 3;
token.sep[0] = ':';
token.len_min[0] = 32;
token.len_max[0] = 32;
token.attr[0] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[1] = ':';
token.len_min[1] = 12;
token.len_max[1] = 12;
token.attr[1] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[2] = ':';
token.len_min[2] = 12;
token.len_max[2] = 12;
token.attr[2] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
const int rc_tokenizer = input_tokenizer ((const u8 *) line_buf, line_len, &token);
if (rc_tokenizer != PARSER_OK)
{
// we'll accept normal 16800 pmkid hash-lines, too
token.token_cnt = 4;
token.sep[0] = ':';
token.len_min[0] = 32;
token.len_max[0] = 32;
token.attr[0] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[1] = ':';
token.len_min[1] = 12;
token.len_max[1] = 12;
token.attr[1] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[2] = ':';
token.len_min[2] = 12;
token.len_max[2] = 12;
token.attr[2] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[3] = ':';
token.len_min[3] = 0;
token.len_max[3] = 64;
token.attr[3] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
const int rc_tokenizer2 = input_tokenizer ((const u8 *) line_buf, line_len, &token);
if (rc_tokenizer2 != PARSER_OK) return (rc_tokenizer);
// essid
const u8 *essid_buf = token.buf[3];
const int essid_len = token.len[3];
if (essid_len & 1) return (PARSER_SALT_VALUE);
wpa_pmkid->essid_len = hex_decode (essid_buf, essid_len, (u8 *) wpa_pmkid->essid_buf);
}
// pmkid
const u8 *pmkid_buf = token.buf[0];
wpa_pmkid->pmkid[0] = hex_to_u32 (pmkid_buf + 0);
wpa_pmkid->pmkid[1] = hex_to_u32 (pmkid_buf + 8);
wpa_pmkid->pmkid[2] = hex_to_u32 (pmkid_buf + 16);
wpa_pmkid->pmkid[3] = hex_to_u32 (pmkid_buf + 24);
// mac_ap
const u8 *macap_buf = token.buf[1];
wpa_pmkid->orig_mac_ap[0] = hex_to_u8 (macap_buf + 0);
wpa_pmkid->orig_mac_ap[1] = hex_to_u8 (macap_buf + 2);
wpa_pmkid->orig_mac_ap[2] = hex_to_u8 (macap_buf + 4);
wpa_pmkid->orig_mac_ap[3] = hex_to_u8 (macap_buf + 6);
wpa_pmkid->orig_mac_ap[4] = hex_to_u8 (macap_buf + 8);
wpa_pmkid->orig_mac_ap[5] = hex_to_u8 (macap_buf + 10);
// mac_sta
const u8 *macsta_buf = token.buf[2];
wpa_pmkid->orig_mac_sta[0] = hex_to_u8 (macsta_buf + 0);
wpa_pmkid->orig_mac_sta[1] = hex_to_u8 (macsta_buf + 2);
wpa_pmkid->orig_mac_sta[2] = hex_to_u8 (macsta_buf + 4);
wpa_pmkid->orig_mac_sta[3] = hex_to_u8 (macsta_buf + 6);
wpa_pmkid->orig_mac_sta[4] = hex_to_u8 (macsta_buf + 8);
wpa_pmkid->orig_mac_sta[5] = hex_to_u8 (macsta_buf + 10);
// pmkid_data
wpa_pmkid->pmkid_data[0] = 0x204b4d50; // "PMK "
wpa_pmkid->pmkid_data[1] = 0x656d614e; // "Name"
wpa_pmkid->pmkid_data[2] = (wpa_pmkid->orig_mac_ap[0] << 0)
| (wpa_pmkid->orig_mac_ap[1] << 8)
| (wpa_pmkid->orig_mac_ap[2] << 16)
| (wpa_pmkid->orig_mac_ap[3] << 24);
wpa_pmkid->pmkid_data[3] = (wpa_pmkid->orig_mac_ap[4] << 0)
| (wpa_pmkid->orig_mac_ap[5] << 8)
| (wpa_pmkid->orig_mac_sta[0] << 16)
| (wpa_pmkid->orig_mac_sta[1] << 24);
wpa_pmkid->pmkid_data[4] = (wpa_pmkid->orig_mac_sta[2] << 0)
| (wpa_pmkid->orig_mac_sta[3] << 8)
| (wpa_pmkid->orig_mac_sta[4] << 16)
| (wpa_pmkid->orig_mac_sta[5] << 24);
// salt
salt->salt_buf[0] = wpa_pmkid->pmkid_data[0];
salt->salt_buf[1] = wpa_pmkid->pmkid_data[1];
salt->salt_buf[2] = wpa_pmkid->pmkid_data[2];
salt->salt_buf[3] = wpa_pmkid->pmkid_data[3];
salt->salt_buf[4] = wpa_pmkid->pmkid_data[4];
salt->salt_buf[5] = wpa_pmkid->pmkid_data[5];
salt->salt_buf[6] = wpa_pmkid->pmkid_data[6];
salt->salt_buf[7] = wpa_pmkid->pmkid_data[7];
salt->salt_len = 32;
salt->salt_iter = ROUNDS_WPA_PMK - 1;
// hash
digest[0] = wpa_pmkid->pmkid[0];
digest[1] = wpa_pmkid->pmkid[1];
digest[2] = wpa_pmkid->pmkid[2];
digest[3] = wpa_pmkid->pmkid[3];
digest[0] = byte_swap_32 (digest[0]);
digest[1] = byte_swap_32 (digest[1]);
digest[2] = byte_swap_32 (digest[2]);
digest[3] = byte_swap_32 (digest[3]);
return (PARSER_OK);
}
int module_hash_encode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED const void *digest_buf, MAYBE_UNUSED const salt_t *salt, MAYBE_UNUSED const void *esalt_buf, MAYBE_UNUSED const void *hook_salt_buf, MAYBE_UNUSED const hashinfo_t *hash_info, char *line_buf, MAYBE_UNUSED const int line_size)
{
const dpapimk_t *dpapimk = (const dpapimk_t *) esalt_buf;
u32 version = 2;
u32 context = dpapimk->context;
u32 rounds = salt->salt_iter + 1;
u32 contents_len = dpapimk->contents_len;
u32 SID_len = dpapimk->SID_len;
u32 iv_len = 32;
u8 cipher_algorithm[8] = { 0 };
u8 hash_algorithm[8] = { 0 };
u8 SID[512] = { 0 };
u8* SID_tmp;
u32 *ptr_SID = (u32 *) dpapimk->SID;
u32 *ptr_iv = (u32 *) dpapimk->iv;
u32 *ptr_contents = (u32 *) dpapimk->contents;
u32 u32_iv[4];
u8 iv[32 + 1];
// convert back SID
SID_tmp = (u8 *) hcmalloc ((SID_len + 1) * sizeof(u8));
for (u32 i = 0; i < (SID_len / 4) + 1; i++)
{
u8 hex[8] = { 0 };
u32_to_hex (byte_swap_32 (ptr_SID[i]), hex);
for (u32 j = 0, k = 0; j < 8; j += 2, k++)
{
SID_tmp[i * 4 + k] = hex_to_u8 (&hex[j]);
}
}
// overwrite trailing 0x80
SID_tmp[SID_len] = 0;
for (u32 i = 0, j = 0 ; j < SID_len ; i++, j += 2)
{
SID[i] = SID_tmp[j];
}
hcfree (SID_tmp);
for (u32 i = 0; i < iv_len / 8; i++)
{
u32_iv[i] = byte_swap_32 (ptr_iv[i]);
u32_to_hex (u32_iv[i], iv + i * 8);
}
iv[32] = 0;
u32 u32_contents[36];
u8 contents[288 + 1];
for (u32 i = 0; i < contents_len / 8; i++)
{
u32_contents[i] = byte_swap_32 (ptr_contents[i]);
u32_to_hex (u32_contents[i], contents + i * 8);
}
contents[288] = 0;
if (contents_len == 288)
{
memcpy (cipher_algorithm, "aes256", strlen ("aes256"));
memcpy (hash_algorithm, "sha512", strlen ("sha512"));
}
const int line_len = snprintf (line_buf, line_size, "%s%d*%d*%s*%s*%s*%d*%s*%d*%s",
SIGNATURE_DPAPIMK,
version,
context,
SID,
cipher_algorithm,
hash_algorithm,
rounds,
iv,
contents_len,
contents);
return line_len;
}
int hashes_init_selftest (hashcat_ctx_t *hashcat_ctx)
{
folder_config_t *folder_config = hashcat_ctx->folder_config;
hashconfig_t *hashconfig = hashcat_ctx->hashconfig;
hashes_t *hashes = hashcat_ctx->hashes;
user_options_t *user_options = hashcat_ctx->user_options;
if (hashconfig->st_hash == NULL) return 0;
void *st_digests_buf = NULL;
salt_t *st_salts_buf = NULL;
void *st_esalts_buf = NULL;
void *st_hook_salts_buf = NULL;
st_digests_buf = hccalloc (1, hashconfig->dgst_size);
st_salts_buf = (salt_t *) hccalloc (1, sizeof (salt_t));
if (hashconfig->esalt_size > 0)
{
st_esalts_buf = hccalloc (1, hashconfig->esalt_size);
}
if (hashconfig->hook_salt_size > 0)
{
st_hook_salts_buf = hccalloc (1, hashconfig->hook_salt_size);
}
hash_t hash;
hash.digest = st_digests_buf;
hash.salt = st_salts_buf;
hash.esalt = st_esalts_buf;
hash.hook_salt = st_hook_salts_buf;
hash.cracked = 0;
hash.hash_info = NULL;
hash.pw_buf = NULL;
hash.pw_len = 0;
int parser_status;
if ((hashconfig->hash_mode == 2500) || (hashconfig->hash_mode == 2501))
{
char *tmpdata = (char *) hcmalloc (sizeof (hccapx_t));
const size_t st_hash_len = strlen (hashconfig->st_hash);
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;
}
parser_status = hashconfig->parse_func ((u8 *) tmpdata, sizeof (hccapx_t), &hash, hashconfig);
hcfree (tmpdata);
wpa_t *wpa = (wpa_t *) st_esalts_buf;
wpa->nonce_error_corrections = 3;
}
else if (hashconfig->opts_type & OPTS_TYPE_BINARY_HASHFILE)
{
char *tmpfile_bin;
hc_asprintf (&tmpfile_bin, "%s/selftest.hash", folder_config->session_dir);
FILE *fp = fopen (tmpfile_bin, "wb");
const size_t st_hash_len = strlen (hashconfig->st_hash);
for (size_t i = 0; i < st_hash_len; i += 2)
{
const u8 c = hex_to_u8 ((const u8 *) hashconfig->st_hash + i);
fputc (c, fp);
}
fclose (fp);
parser_status = hashconfig->parse_func ((u8 *) tmpfile_bin, (u32) strlen (tmpfile_bin), &hash, hashconfig);
unlink (tmpfile_bin);
hcfree (tmpfile_bin);
}
else
{
hashconfig_t *hashconfig_st = (hashconfig_t *) hcmalloc (sizeof (hashconfig_t));
memcpy (hashconfig_st, hashconfig, sizeof (hashconfig_t));
hashconfig_st->separator = SEPARATOR;
if (user_options->hex_salt)
{
if (hashconfig->salt_type == SALT_TYPE_GENERIC)
{
// this is save as there's no hash mode that has both SALT_TYPE_GENERIC and OPTS_TYPE_ST_HEX by default
hashconfig_st->opts_type &= ~OPTS_TYPE_ST_HEX;
}
}
// Make sure that we do not modify constant data. Make a copy of the constant self-test hash
// Note: sometimes parse_func () modifies the data internally. We always need to use a copy of the original data
char *tmpdata = hcstrdup (hashconfig->st_hash);
parser_status = hashconfig->parse_func ((u8 *) tmpdata, (u32) strlen (hashconfig->st_hash), &hash, hashconfig_st);
hcfree (tmpdata);
hcfree (hashconfig_st);
}
if (parser_status == PARSER_OK)
{
// nothing to do
}
else
{
event_log_error (hashcat_ctx, "Self-test hash parsing error: %s", strparser (parser_status));
return -1;
}
hashes->st_digests_buf = st_digests_buf;
hashes->st_salts_buf = st_salts_buf;
hashes->st_esalts_buf = st_esalts_buf;
hashes->st_hook_salts_buf = st_hook_salts_buf;
return 0;
}
static int outfile_remove (hashcat_ctx_t *hashcat_ctx)
{
// some hash-dependent constants
hashconfig_t *hashconfig = hashcat_ctx->hashconfig;
hashes_t *hashes = hashcat_ctx->hashes;
outcheck_ctx_t *outcheck_ctx = hashcat_ctx->outcheck_ctx;
status_ctx_t *status_ctx = hashcat_ctx->status_ctx;
user_options_t *user_options = hashcat_ctx->user_options;
u32 dgst_size = hashconfig->dgst_size;
u32 is_salted = hashconfig->is_salted;
u32 esalt_size = hashconfig->esalt_size;
u32 hash_mode = hashconfig->hash_mode;
char separator = hashconfig->separator;
char *root_directory = outcheck_ctx->root_directory;
u32 outfile_check_timer = user_options->outfile_check_timer;
// buffers
hash_t hash_buf = { 0, 0, 0, 0, 0, NULL, 0 };
hash_buf.digest = hcmalloc (dgst_size);
if (is_salted) hash_buf.salt = (salt_t *) hcmalloc (sizeof (salt_t));
if (esalt_size) hash_buf.esalt = (void *) hcmalloc (esalt_size);
u32 digest_buf[64] = { 0 };
outfile_data_t *out_info = NULL;
char **out_files = NULL;
time_t folder_mtime = 0;
int out_cnt = 0;
u32 check_left = outfile_check_timer; // or 1 if we want to check it at startup
while (status_ctx->shutdown_inner == false)
{
hc_sleep (1);
if (status_ctx->devices_status != STATUS_RUNNING) continue;
check_left--;
if (check_left == 0)
{
hc_stat_t outfile_check_stat;
if (hc_stat (root_directory, &outfile_check_stat) == 0)
{
u32 is_dir = S_ISDIR (outfile_check_stat.st_mode);
if (is_dir == 1)
{
if (outfile_check_stat.st_mtime > folder_mtime)
{
char **out_files_new = scan_directory (root_directory);
int out_cnt_new = count_dictionaries (out_files_new);
outfile_data_t *out_info_new = NULL;
if (out_cnt_new > 0)
{
out_info_new = (outfile_data_t *) hccalloc (out_cnt_new, sizeof (outfile_data_t));
for (int i = 0; i < out_cnt_new; i++)
{
out_info_new[i].file_name = out_files_new[i];
// check if there are files that we have seen/checked before (and not changed)
for (int j = 0; j < out_cnt; j++)
{
if (strcmp (out_info[j].file_name, out_info_new[i].file_name) == 0)
{
hc_stat_t outfile_stat;
if (hc_stat (out_info_new[i].file_name, &outfile_stat) == 0)
{
if (outfile_stat.st_ctime == out_info[j].ctime)
{
out_info_new[i].ctime = out_info[j].ctime;
out_info_new[i].seek = out_info[j].seek;
}
}
}
}
}
}
hcfree (out_info);
hcfree (out_files);
out_files = out_files_new;
out_cnt = out_cnt_new;
out_info = out_info_new;
folder_mtime = outfile_check_stat.st_mtime;
}
for (int j = 0; j < out_cnt; j++)
{
FILE *fp = fopen (out_info[j].file_name, "rb");
if (fp != NULL)
{
//hc_thread_mutex_lock (status_ctx->mux_display);
hc_stat_t outfile_stat;
hc_fstat (fileno (fp), &outfile_stat);
if (outfile_stat.st_ctime > out_info[j].ctime)
{
out_info[j].ctime = outfile_stat.st_ctime;
out_info[j].seek = 0;
}
fseeko (fp, out_info[j].seek, SEEK_SET);
char *line_buf = (char *) hcmalloc (HCBUFSIZ_LARGE);
while (!feof (fp))
{
char *ptr = fgets (line_buf, HCBUFSIZ_LARGE - 1, fp);
if (ptr == NULL) break;
size_t line_len = strlen (line_buf);
if (line_len == 0) continue;
size_t iter = MAX_CUT_TRIES;
for (size_t i = line_len - 1; i && iter; i--, line_len--)
{
if (line_buf[i] != separator) continue;
iter--;
int parser_status = PARSER_OK;
if ((hash_mode != 2500) && (hash_mode != 6800))
{
parser_status = hashconfig->parse_func ((u8 *) line_buf, line_len - 1, &hash_buf, hashconfig);
}
u32 found = 0;
if (parser_status == PARSER_OK)
{
for (u32 salt_pos = 0; (found == 0) && (salt_pos < hashes->salts_cnt); salt_pos++)
{
if (hashes->salts_shown[salt_pos] == 1) continue;
salt_t *salt_buf = &hashes->salts_buf[salt_pos];
for (u32 digest_pos = 0; (found == 0) && (digest_pos < salt_buf->digests_cnt); digest_pos++)
{
u32 idx = salt_buf->digests_offset + digest_pos;
if (hashes->digests_shown[idx] == 1) continue;
u32 cracked = 0;
if (hash_mode == 6800)
{
if (i == salt_buf->salt_len)
{
cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
}
}
else if (hash_mode == 2500)
{
// BSSID : MAC1 : MAC2 (:plain)
if (i == (salt_buf->salt_len + 1 + 12 + 1 + 12))
{
cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0);
if (!cracked) continue;
// now compare MAC1 and MAC2 too, since we have this additional info
char *mac1_pos = line_buf + salt_buf->salt_len + 1;
char *mac2_pos = mac1_pos + 12 + 1;
wpa_t *wpas = (wpa_t *) hashes->esalts_buf;
wpa_t *wpa = &wpas[salt_pos];
// compare hex string(s) vs binary MAC address(es)
for (u32 mac_idx = 0, orig_mac_idx = 0; mac_idx < 6; mac_idx++, orig_mac_idx += 2)
{
if (wpa->orig_mac1[mac_idx] != hex_to_u8 ((const u8 *) &mac1_pos[orig_mac_idx]))
{
cracked = 0;
break;
}
}
// early skip ;)
if (!cracked) continue;
for (u32 mac_idx = 0, orig_mac_idx = 0; mac_idx < 6; mac_idx++, orig_mac_idx += 2)
{
if (wpa->orig_mac2[mac_idx] != hex_to_u8 ((const u8 *) &mac2_pos[orig_mac_idx]))
{
cracked = 0;
break;
}
}
}
}
else
{
char *digests_buf_ptr = (char *) hashes->digests_buf;
memcpy (digest_buf, digests_buf_ptr + (hashes->salts_buf[salt_pos].digests_offset * dgst_size) + (digest_pos * dgst_size), dgst_size);
cracked = (sort_by_digest_p0p1 (digest_buf, hash_buf.digest, hashconfig) == 0);
}
if (cracked == 1)
{
found = 1;
hashes->digests_shown[idx] = 1;
hashes->digests_done++;
salt_buf->digests_done++;
if (salt_buf->digests_done == salt_buf->digests_cnt)
{
hashes->salts_shown[salt_pos] = 1;
hashes->salts_done++;
if (hashes->salts_done == hashes->salts_cnt) mycracked (hashcat_ctx);
}
}
}
if (status_ctx->devices_status == STATUS_CRACKED) break;
}
}
if (found) break;
if (status_ctx->devices_status == STATUS_CRACKED) break;
}
if (status_ctx->devices_status == STATUS_CRACKED) break;
}
hcfree (line_buf);
out_info[j].seek = ftello (fp);
//hc_thread_mutex_unlock (status_ctx->mux_display);
fclose (fp);
}
}
}
}
check_left = outfile_check_timer;
}
}
hcfree (hash_buf.esalt);
hcfree (hash_buf.salt);
hcfree (hash_buf.digest);
hcfree (out_info);
hcfree (out_files);
return 0;
}
int _old_apply_rule (const char *rule, int rule_len, char in[RP_PASSWORD_SIZE], int in_len, char out[RP_PASSWORD_SIZE])
{
char mem[RP_PASSWORD_SIZE] = { 0 };
int pos_mem = -1;
if (in == NULL) return (RULE_RC_REJECT_ERROR);
if (out == NULL) return (RULE_RC_REJECT_ERROR);
if (in_len < 0 || in_len > RP_PASSWORD_SIZE) return (RULE_RC_REJECT_ERROR);
if (rule_len < 1) return (RULE_RC_REJECT_ERROR);
int out_len = in_len;
int mem_len = in_len;
memcpy (out, in, out_len);
char *rule_new = (char *) hcmalloc (rule_len);
int rule_len_new = 0;
int rule_pos;
for (rule_pos = 0; rule_pos < rule_len; rule_pos++)
{
if (is_hex_notation (rule, rule_len, rule_pos))
{
const u8 c = hex_to_u8 (&rule[rule_pos + 2]);
rule_pos += 3;
rule_new[rule_len_new] = c;
rule_len_new++;
}
else
{
rule_new[rule_len_new] = rule[rule_pos];
rule_len_new++;
}
}
for (rule_pos = 0; rule_pos < rule_len_new; rule_pos++)
{
int upos, upos2;
int ulen;
switch (rule_new[rule_pos])
{
case ' ':
break;
case RULE_OP_MANGLE_NOOP:
break;
case RULE_OP_MANGLE_LREST:
out_len = mangle_lrest (out, out_len);
break;
case RULE_OP_MANGLE_UREST:
out_len = mangle_urest (out, out_len);
break;
case RULE_OP_MANGLE_LREST_UFIRST:
out_len = mangle_lrest (out, out_len);
if (out_len) MANGLE_UPPER_AT (out, 0);
break;
case RULE_OP_MANGLE_UREST_LFIRST:
out_len = mangle_urest (out, out_len);
if (out_len) MANGLE_LOWER_AT (out, 0);
break;
case RULE_OP_MANGLE_TREST:
out_len = mangle_trest (out, out_len);
break;
case RULE_OP_MANGLE_TOGGLE_AT:
NEXT_RULEPOS (rule_pos);
NEXT_RPTOI (rule, rule_pos, upos);
if (upos < out_len) MANGLE_TOGGLE_AT (out, upos);
break;
case RULE_OP_MANGLE_REVERSE:
out_len = mangle_reverse (out, out_len);
break;
case RULE_OP_MANGLE_DUPEWORD:
out_len = mangle_double (out, out_len);
break;
case RULE_OP_MANGLE_DUPEWORD_TIMES:
NEXT_RULEPOS (rule_pos);
NEXT_RPTOI (rule, rule_pos, ulen);
out_len = mangle_double_times (out, out_len, ulen);
break;
case RULE_OP_MANGLE_REFLECT:
out_len = mangle_reflect (out, out_len);
break;
case RULE_OP_MANGLE_ROTATE_LEFT:
mangle_rotate_left (out, out_len);
break;
case RULE_OP_MANGLE_ROTATE_RIGHT:
mangle_rotate_right (out, out_len);
break;
case RULE_OP_MANGLE_APPEND:
NEXT_RULEPOS (rule_pos);
out_len = mangle_append (out, out_len, rule_new[rule_pos]);
break;
case RULE_OP_MANGLE_PREPEND:
NEXT_RULEPOS (rule_pos);
out_len = mangle_prepend (out, out_len, rule_new[rule_pos]);
break;
case RULE_OP_MANGLE_DELETE_FIRST:
out_len = mangle_delete_at (out, out_len, 0);
break;
case RULE_OP_MANGLE_DELETE_LAST:
out_len = mangle_delete_at (out, out_len, (out_len) ? out_len - 1 : 0);
break;
case RULE_OP_MANGLE_DELETE_AT:
NEXT_RULEPOS (rule_pos);
NEXT_RPTOI (rule, rule_pos, upos);
out_len = mangle_delete_at (out, out_len, upos);
break;
case RULE_OP_MANGLE_EXTRACT:
NEXT_RULEPOS (rule_pos);
NEXT_RPTOI (rule, rule_pos, upos);
NEXT_RULEPOS (rule_pos);
NEXT_RPTOI (rule, rule_pos, ulen);
out_len = mangle_extract (out, out_len, upos, ulen);
break;
case RULE_OP_MANGLE_OMIT:
NEXT_RULEPOS (rule_pos);
NEXT_RPTOI (rule, rule_pos, upos);
NEXT_RULEPOS (rule_pos);
NEXT_RPTOI (rule, rule_pos, ulen);
out_len = mangle_omit (out, out_len, upos, ulen);
break;
case RULE_OP_MANGLE_INSERT:
NEXT_RULEPOS (rule_pos);
NEXT_RPTOI (rule, rule_pos, upos);
NEXT_RULEPOS (rule_pos);
out_len = mangle_insert (out, out_len, upos, rule_new[rule_pos]);
break;
case RULE_OP_MANGLE_OVERSTRIKE:
NEXT_RULEPOS (rule_pos);
NEXT_RPTOI (rule, rule_pos, upos);
NEXT_RULEPOS (rule_pos);
out_len = mangle_overstrike (out, out_len, upos, rule_new[rule_pos]);
break;
case RULE_OP_MANGLE_TRUNCATE_AT:
NEXT_RULEPOS (rule_pos);
NEXT_RPTOI (rule, rule_pos, upos);
out_len = mangle_truncate_at (out, out_len, upos);
break;
case RULE_OP_MANGLE_REPLACE:
NEXT_RULEPOS (rule_pos);
NEXT_RULEPOS (rule_pos);
out_len = mangle_replace (out, out_len, rule_new[rule_pos - 1], rule_new[rule_pos]);
break;
case RULE_OP_MANGLE_PURGECHAR:
NEXT_RULEPOS (rule_pos);
out_len = mangle_purgechar (out, out_len, rule_new[rule_pos]);
break;
case RULE_OP_MANGLE_TOGGLECASE_REC:
/* todo */
break;
case RULE_OP_MANGLE_DUPECHAR_FIRST:
NEXT_RULEPOS (rule_pos);
NEXT_RPTOI (rule, rule_pos, ulen);
out_len = mangle_dupechar_at (out, out_len, 0, ulen);
break;
case RULE_OP_MANGLE_DUPECHAR_LAST:
NEXT_RULEPOS (rule_pos);
NEXT_RPTOI (rule, rule_pos, ulen);
out_len = mangle_dupechar_at (out, out_len, out_len - 1, ulen);
break;
case RULE_OP_MANGLE_DUPECHAR_ALL:
out_len = mangle_dupechar (out, out_len);
break;
case RULE_OP_MANGLE_DUPEBLOCK_FIRST:
NEXT_RULEPOS (rule_pos);
NEXT_RPTOI (rule, rule_pos, ulen);
out_len = mangle_dupeblock_prepend (out, out_len, ulen);
break;
case RULE_OP_MANGLE_DUPEBLOCK_LAST:
NEXT_RULEPOS (rule_pos);
NEXT_RPTOI (rule, rule_pos, ulen);
out_len = mangle_dupeblock_append (out, out_len, ulen);
break;
case RULE_OP_MANGLE_SWITCH_FIRST:
if (out_len >= 2) mangle_switch_at (out, out_len, 0, 1);
break;
case RULE_OP_MANGLE_SWITCH_LAST:
if (out_len >= 2) mangle_switch_at (out, out_len, out_len - 1, out_len - 2);
break;
case RULE_OP_MANGLE_SWITCH_AT:
NEXT_RULEPOS (rule_pos);
NEXT_RPTOI (rule, rule_pos, upos);
NEXT_RULEPOS (rule_pos);
NEXT_RPTOI (rule, rule_pos, upos2);
out_len = mangle_switch_at_check (out, out_len, upos, upos2);
break;
case RULE_OP_MANGLE_CHR_SHIFTL:
NEXT_RULEPOS (rule_pos);
NEXT_RPTOI (rule, rule_pos, upos);
mangle_chr_shiftl (out, out_len, upos);
break;
case RULE_OP_MANGLE_CHR_SHIFTR:
NEXT_RULEPOS (rule_pos);
NEXT_RPTOI (rule, rule_pos, upos);
mangle_chr_shiftr (out, out_len, upos);
break;
case RULE_OP_MANGLE_CHR_INCR:
NEXT_RULEPOS (rule_pos);
NEXT_RPTOI (rule, rule_pos, upos);
mangle_chr_incr (out, out_len, upos);
break;
case RULE_OP_MANGLE_CHR_DECR:
NEXT_RULEPOS (rule_pos);
NEXT_RPTOI (rule, rule_pos, upos);
mangle_chr_decr (out, out_len, upos);
break;
case RULE_OP_MANGLE_REPLACE_NP1:
NEXT_RULEPOS (rule_pos);
NEXT_RPTOI (rule, rule_pos, upos);
if ((upos >= 0) && ((upos + 1) < out_len)) mangle_overstrike (out, out_len, upos, out[upos + 1]);
break;
case RULE_OP_MANGLE_REPLACE_NM1:
NEXT_RULEPOS (rule_pos);
NEXT_RPTOI (rule, rule_pos, upos);
if ((upos >= 1) && ((upos + 0) < out_len)) mangle_overstrike (out, out_len, upos, out[upos - 1]);
break;
case RULE_OP_MANGLE_TITLE_SEP:
NEXT_RULEPOS (rule_pos);
out_len = mangle_title_sep (out, out_len, rule_new[rule_pos]);
break;
case RULE_OP_MANGLE_TITLE:
out_len = mangle_title_sep (out, out_len, ' ');
break;
case RULE_OP_MANGLE_EXTRACT_MEMORY:
if (mem_len < 1) return (RULE_RC_REJECT_ERROR);
NEXT_RULEPOS (rule_pos);
NEXT_RPTOI (rule, rule_pos, upos);
NEXT_RULEPOS (rule_pos);
NEXT_RPTOI (rule, rule_pos, ulen);
NEXT_RULEPOS (rule_pos);
NEXT_RPTOI (rule, rule_pos, upos2);
if ((out_len = mangle_insert_multi (out, out_len, upos2, mem, mem_len, upos, ulen)) < 1) return (out_len);
break;
case RULE_OP_MANGLE_APPEND_MEMORY:
if (mem_len < 1) return (RULE_RC_REJECT_ERROR);
if ((out_len + mem_len) >= RP_PASSWORD_SIZE) return (RULE_RC_REJECT_ERROR);
memcpy (out + out_len, mem, mem_len);
out_len += mem_len;
break;
case RULE_OP_MANGLE_PREPEND_MEMORY:
if (mem_len < 1) return (RULE_RC_REJECT_ERROR);
if ((mem_len + out_len) >= RP_PASSWORD_SIZE) return (RULE_RC_REJECT_ERROR);
memcpy (mem + mem_len, out, out_len);
out_len += mem_len;
memcpy (out, mem, out_len);
break;
case RULE_OP_MEMORIZE_WORD:
memcpy (mem, out, out_len);
mem_len = out_len;
break;
case RULE_OP_REJECT_LESS:
NEXT_RULEPOS (rule_pos);
NEXT_RPTOI (rule, rule_pos, upos);
if (out_len > upos) return (RULE_RC_REJECT_ERROR);
break;
case RULE_OP_REJECT_GREATER:
NEXT_RULEPOS (rule_pos);
NEXT_RPTOI (rule, rule_pos, upos);
if (out_len < upos) return (RULE_RC_REJECT_ERROR);
break;
case RULE_OP_REJECT_EQUAL:
NEXT_RULEPOS (rule_pos);
NEXT_RPTOI (rule, rule_pos, upos);
if (out_len != upos) return (RULE_RC_REJECT_ERROR);
break;
case RULE_OP_REJECT_CONTAIN:
NEXT_RULEPOS (rule_pos);
if (strchr (out, rule_new[rule_pos]) != NULL) return (RULE_RC_REJECT_ERROR);
break;
case RULE_OP_REJECT_NOT_CONTAIN:
NEXT_RULEPOS (rule_pos);
char *match = strchr (out, rule_new[rule_pos]);
if (match != NULL)
{
pos_mem = (int)(match - out);
}
else
{
return (RULE_RC_REJECT_ERROR);
}
break;
case RULE_OP_REJECT_EQUAL_FIRST:
NEXT_RULEPOS (rule_pos);
if (out[0] != rule_new[rule_pos]) return (RULE_RC_REJECT_ERROR);
break;
case RULE_OP_REJECT_EQUAL_LAST:
NEXT_RULEPOS (rule_pos);
if (out[out_len - 1] != rule_new[rule_pos]) return (RULE_RC_REJECT_ERROR);
break;
case RULE_OP_REJECT_EQUAL_AT:
NEXT_RULEPOS (rule_pos);
NEXT_RPTOI (rule, rule_pos, upos);
if ((upos + 1) > out_len) return (RULE_RC_REJECT_ERROR);
NEXT_RULEPOS (rule_pos);
if (out[upos] != rule_new[rule_pos]) return (RULE_RC_REJECT_ERROR);
break;
case RULE_OP_REJECT_CONTAINS:
NEXT_RULEPOS (rule_pos);
NEXT_RPTOI (rule, rule_pos, upos);
if ((upos + 1) > out_len) return (RULE_RC_REJECT_ERROR);
NEXT_RULEPOS (rule_pos);
int c; int cnt;
for (c = 0, cnt = 0; c < out_len && cnt < upos; c++)
{
if (out[c] == rule_new[rule_pos])
{
cnt++;
pos_mem = c;
}
}
if (cnt < upos) return (RULE_RC_REJECT_ERROR);
break;
case RULE_OP_REJECT_MEMORY:
if ((out_len == mem_len) && (memcmp (out, mem, out_len) == 0)) return (RULE_RC_REJECT_ERROR);
break;
default:
return (RULE_RC_SYNTAX_ERROR);
}
}
memset (out + out_len, 0, RP_PASSWORD_SIZE - out_len);
hcfree (rule_new);
return (out_len);
}
int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSED void *digest_buf, MAYBE_UNUSED salt_t *salt, MAYBE_UNUSED void *esalt_buf, MAYBE_UNUSED void *hook_salt_buf, MAYBE_UNUSED hashinfo_t *hash_info, const char *line_buf, MAYBE_UNUSED const int line_len)
{
u32 *digest = (u32 *) digest_buf;
ikepsk_t *ikepsk = (ikepsk_t *) esalt_buf;
token_t token;
token.token_cnt = 9;
token.sep[0] = ':';
token.len_min[0] = 0;
token.len_max[0] = 1024;
token.attr[0] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[1] = ':';
token.len_min[1] = 0;
token.len_max[1] = 1024;
token.attr[1] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[2] = ':';
token.len_min[2] = 0;
token.len_max[2] = 1024;
token.attr[2] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[3] = ':';
token.len_min[3] = 0;
token.len_max[3] = 1024;
token.attr[3] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[4] = ':';
token.len_min[4] = 0;
token.len_max[4] = 1024;
token.attr[4] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[5] = ':';
token.len_min[5] = 0;
token.len_max[5] = 1024;
token.attr[5] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[6] = ':';
token.len_min[6] = 0;
token.len_max[6] = 128;
token.attr[6] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[7] = ':';
token.len_min[7] = 0;
token.len_max[7] = 128;
token.attr[7] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
token.sep[8] = ':';
token.len_min[8] = 32;
token.len_max[8] = 32;
token.attr[8] = TOKEN_ATTR_VERIFY_LENGTH
| TOKEN_ATTR_VERIFY_HEX;
const int rc_tokenizer = input_tokenizer ((const u8 *) line_buf, line_len, &token);
if (rc_tokenizer != PARSER_OK) return (rc_tokenizer);
ikepsk->msg_len[0] = token.len[0] / 2;
ikepsk->msg_len[1] = ikepsk->msg_len[0] + token.len[1] / 2;
ikepsk->msg_len[2] = ikepsk->msg_len[1] + token.len[2] / 2;
ikepsk->msg_len[3] = ikepsk->msg_len[2] + token.len[3] / 2;
ikepsk->msg_len[4] = ikepsk->msg_len[3] + token.len[4] / 2;
ikepsk->msg_len[5] = ikepsk->msg_len[4] + token.len[5] / 2;
ikepsk->nr_len = (token.len[6] + token.len[7]) / 2;
if (ikepsk->msg_len[5] > 512) return (PARSER_SALT_LENGTH);
if (ikepsk->nr_len > 64) return (PARSER_SALT_LENGTH);
u8 *ptr1 = (u8 *) ikepsk->msg_buf;
u8 *ptr2 = (u8 *) ikepsk->nr_buf;
for (int i = 0; i < token.len[0]; i += 2) *ptr1++ = hex_to_u8 (token.buf[0] + i);
for (int i = 0; i < token.len[1]; i += 2) *ptr1++ = hex_to_u8 (token.buf[1] + i);
for (int i = 0; i < token.len[2]; i += 2) *ptr1++ = hex_to_u8 (token.buf[2] + i);
for (int i = 0; i < token.len[3]; i += 2) *ptr1++ = hex_to_u8 (token.buf[3] + i);
for (int i = 0; i < token.len[4]; i += 2) *ptr1++ = hex_to_u8 (token.buf[4] + i);
for (int i = 0; i < token.len[5]; i += 2) *ptr1++ = hex_to_u8 (token.buf[5] + i);
for (int i = 0; i < token.len[6]; i += 2) *ptr2++ = hex_to_u8 (token.buf[6] + i);
for (int i = 0; i < token.len[7]; i += 2) *ptr2++ = hex_to_u8 (token.buf[7] + i);
*ptr1++ = 0x80;
*ptr2++ = 0x80;
/**
* Store to database
*/
const u8 *hash_pos = token.buf[8];
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);
salt->salt_len = 32;
salt->salt_buf[0] = ikepsk->nr_buf[0];
salt->salt_buf[1] = ikepsk->nr_buf[1];
salt->salt_buf[2] = ikepsk->nr_buf[2];
salt->salt_buf[3] = ikepsk->nr_buf[3];
salt->salt_buf[4] = ikepsk->nr_buf[4];
salt->salt_buf[5] = ikepsk->nr_buf[5];
salt->salt_buf[6] = ikepsk->nr_buf[6];
salt->salt_buf[7] = ikepsk->nr_buf[7];
return (PARSER_OK);
}
