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); }
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; bool is_salted = hashconfig->is_salted; u32 esalt_size = hashconfig->esalt_size; u32 hook_salt_size = hashconfig->hook_salt_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, 0, NULL, 0 }; hash_buf.digest = hcmalloc (dgst_size); if (is_salted == true) hash_buf.salt = (salt_t *) hcmalloc (sizeof (salt_t)); if (esalt_size > 0) hash_buf.esalt = hcmalloc (esalt_size); if (hook_salt_size > 0) hash_buf.hook_salt = hcmalloc (hook_salt_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) { sleep (1); if (status_ctx->devices_status != STATUS_RUNNING) continue; check_left--; if (check_left == 0) { if (hc_path_exist (root_directory) == true) { const bool is_dir = hc_path_is_directory (root_directory); if (is_dir == true) { struct stat outfile_check_stat; if (stat (root_directory, &outfile_check_stat) == -1) { event_log_error (hashcat_ctx, "%s: %s", root_directory, strerror (errno)); hcfree (out_files); hcfree (out_info); return -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) { struct stat outfile_stat; if (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); struct stat outfile_stat; if (fstat (fileno (fp), &outfile_stat)) { fclose (fp); continue; } 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 = 1; 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 != 2501) && (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) || (hash_mode == 2501)) { // this comparison is a bit inaccurate as we compare only ESSID // call it a bug, but it's good enough for a special case used in a special case // in this case all essid will be marked as cracked that match the essid if (i == salt_buf->salt_len) { cracked = (memcmp (line_buf, salt_buf->salt_buf, salt_buf->salt_len) == 0); } } 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.hook_salt); hcfree (hash_buf.salt); hcfree (hash_buf.digest); hcfree (out_info); hcfree (out_files); return 0; }
void status_display (hashcat_ctx_t *hashcat_ctx) { const hashconfig_t *hashconfig = hashcat_ctx->hashconfig; const user_options_t *user_options = hashcat_ctx->user_options; if (user_options->machine_readable == true) { status_display_machine_readable (hashcat_ctx); return; } hashcat_status_t *hashcat_status = (hashcat_status_t *) hcmalloc (sizeof (hashcat_status_t)); const int rc_status = hashcat_get_status (hashcat_ctx, hashcat_status); if (rc_status == -1) { hcfree (hashcat_status); return; } /** * show something */ event_log_info (hashcat_ctx, "Session..........: %s", hashcat_status->session); event_log_info (hashcat_ctx, "Status...........: %s", hashcat_status->status_string); event_log_info (hashcat_ctx, "Hash.Type........: %s", hashcat_status->hash_type); event_log_info (hashcat_ctx, "Hash.Target......: %s", hashcat_status->hash_target); event_log_info (hashcat_ctx, "Time.Started.....: %s (%s)", hashcat_status->time_started_absolute, hashcat_status->time_started_relative); event_log_info (hashcat_ctx, "Time.Estimated...: %s (%s)", hashcat_status->time_estimated_absolute, hashcat_status->time_estimated_relative); switch (hashcat_status->guess_mode) { case GUESS_MODE_STRAIGHT_FILE: event_log_info (hashcat_ctx, "Guess.Base.......: File (%s)", hashcat_status->guess_base); break; case GUESS_MODE_STRAIGHT_FILE_RULES_FILE: event_log_info (hashcat_ctx, "Guess.Base.......: File (%s)", hashcat_status->guess_base); event_log_info (hashcat_ctx, "Guess.Mod........: Rules (%s)", hashcat_status->guess_mod); break; case GUESS_MODE_STRAIGHT_FILE_RULES_GEN: event_log_info (hashcat_ctx, "Guess.Base.......: File (%s)", hashcat_status->guess_base); event_log_info (hashcat_ctx, "Guess.Mod........: Rules (Generated)"); break; case GUESS_MODE_STRAIGHT_STDIN: event_log_info (hashcat_ctx, "Guess.Base.......: Pipe"); break; case GUESS_MODE_STRAIGHT_STDIN_RULES_FILE: event_log_info (hashcat_ctx, "Guess.Base.......: Pipe"); event_log_info (hashcat_ctx, "Guess.Mod........: Rules (%s)", hashcat_status->guess_mod); break; case GUESS_MODE_STRAIGHT_STDIN_RULES_GEN: event_log_info (hashcat_ctx, "Guess.Base.......: Pipe"); event_log_info (hashcat_ctx, "Guess.Mod........: Rules (Generated)"); break; case GUESS_MODE_COMBINATOR_BASE_LEFT: event_log_info (hashcat_ctx, "Guess.Base.......: File (%s), Left Side", hashcat_status->guess_base); event_log_info (hashcat_ctx, "Guess.Mod........: File (%s), Right Side", hashcat_status->guess_mod); break; case GUESS_MODE_COMBINATOR_BASE_RIGHT: event_log_info (hashcat_ctx, "Guess.Base.......: File (%s), Right Side", hashcat_status->guess_base); event_log_info (hashcat_ctx, "Guess.Mod........: File (%s), Left Side", hashcat_status->guess_mod); break; case GUESS_MODE_MASK: event_log_info (hashcat_ctx, "Guess.Mask.......: %s [%d]", hashcat_status->guess_base, hashcat_status->guess_mask_length); break; case GUESS_MODE_MASK_CS: event_log_info (hashcat_ctx, "Guess.Mask.......: %s [%d]", hashcat_status->guess_base, hashcat_status->guess_mask_length); event_log_info (hashcat_ctx, "Guess.Charset....: %s ", hashcat_status->guess_charset); break; case GUESS_MODE_HYBRID1: event_log_info (hashcat_ctx, "Guess.Base.......: File (%s), Left Side", hashcat_status->guess_base); event_log_info (hashcat_ctx, "Guess.Mod........: Mask (%s) [%d], Right Side", hashcat_status->guess_mod, hashcat_status->guess_mask_length); break; case GUESS_MODE_HYBRID1_CS: event_log_info (hashcat_ctx, "Guess.Base.......: File (%s), Left Side", hashcat_status->guess_base); event_log_info (hashcat_ctx, "Guess.Mod........: Mask (%s) [%d], Right Side", hashcat_status->guess_mod, hashcat_status->guess_mask_length); event_log_info (hashcat_ctx, "Guess.Charset....: %s", hashcat_status->guess_charset); break; case GUESS_MODE_HYBRID2: if (hashconfig->opti_type & OPTI_TYPE_OPTIMIZED_KERNEL) { event_log_info (hashcat_ctx, "Guess.Base.......: Mask (%s) [%d], Left Side", hashcat_status->guess_base, hashcat_status->guess_mask_length); event_log_info (hashcat_ctx, "Guess.Mod........: File (%s), Right Side", hashcat_status->guess_mod); } else { event_log_info (hashcat_ctx, "Guess.Base.......: File (%s), Right Side", hashcat_status->guess_base); event_log_info (hashcat_ctx, "Guess.Mod........: Mask (%s) [%d], Left Side", hashcat_status->guess_mod, hashcat_status->guess_mask_length); } break; case GUESS_MODE_HYBRID2_CS: if (hashconfig->opti_type & OPTI_TYPE_OPTIMIZED_KERNEL) { event_log_info (hashcat_ctx, "Guess.Base.......: Mask (%s) [%d], Left Side", hashcat_status->guess_base, hashcat_status->guess_mask_length); event_log_info (hashcat_ctx, "Guess.Mod........: File (%s), Right Side", hashcat_status->guess_mod); event_log_info (hashcat_ctx, "Guess.Charset....: %s", hashcat_status->guess_charset); } else { event_log_info (hashcat_ctx, "Guess.Base.......: File (%s), Right Side", hashcat_status->guess_base); event_log_info (hashcat_ctx, "Guess.Mod........: Mask (%s) [%d], Left Side", hashcat_status->guess_mod, hashcat_status->guess_mask_length); event_log_info (hashcat_ctx, "Guess.Charset....: %s", hashcat_status->guess_charset); } break; } switch (hashcat_status->guess_mode) { case GUESS_MODE_STRAIGHT_FILE: event_log_info (hashcat_ctx, "Guess.Queue......: %d/%d (%.02f%%)", hashcat_status->guess_base_offset, hashcat_status->guess_base_count, hashcat_status->guess_base_percent); break; case GUESS_MODE_STRAIGHT_FILE_RULES_FILE: event_log_info (hashcat_ctx, "Guess.Queue......: %d/%d (%.02f%%)", hashcat_status->guess_base_offset, hashcat_status->guess_base_count, hashcat_status->guess_base_percent); break; case GUESS_MODE_STRAIGHT_FILE_RULES_GEN: event_log_info (hashcat_ctx, "Guess.Queue......: %d/%d (%.02f%%)", hashcat_status->guess_base_offset, hashcat_status->guess_base_count, hashcat_status->guess_base_percent); break; case GUESS_MODE_MASK: event_log_info (hashcat_ctx, "Guess.Queue......: %d/%d (%.02f%%)", hashcat_status->guess_base_offset, hashcat_status->guess_base_count, hashcat_status->guess_base_percent); break; case GUESS_MODE_MASK_CS: event_log_info (hashcat_ctx, "Guess.Queue......: %d/%d (%.02f%%)", hashcat_status->guess_base_offset, hashcat_status->guess_base_count, hashcat_status->guess_base_percent); break; case GUESS_MODE_HYBRID1: event_log_info (hashcat_ctx, "Guess.Queue.Base.: %d/%d (%.02f%%)", hashcat_status->guess_base_offset, hashcat_status->guess_base_count, hashcat_status->guess_base_percent); event_log_info (hashcat_ctx, "Guess.Queue.Mod..: %d/%d (%.02f%%)", hashcat_status->guess_mod_offset, hashcat_status->guess_mod_count, hashcat_status->guess_mod_percent); break; case GUESS_MODE_HYBRID2: event_log_info (hashcat_ctx, "Guess.Queue.Base.: %d/%d (%.02f%%)", hashcat_status->guess_base_offset, hashcat_status->guess_base_count, hashcat_status->guess_base_percent); event_log_info (hashcat_ctx, "Guess.Queue.Mod..: %d/%d (%.02f%%)", hashcat_status->guess_mod_offset, hashcat_status->guess_mod_count, hashcat_status->guess_mod_percent); break; } for (int device_id = 0; device_id < hashcat_status->device_info_cnt; device_id++) { const device_info_t *device_info = hashcat_status->device_info_buf + device_id; if (device_info->skipped_dev == true) continue; event_log_info (hashcat_ctx, "Speed.Dev.#%d.....: %9sH/s (%0.2fms) @ Accel:%d Loops:%d Thr:%d Vec:%d", device_id + 1, device_info->speed_sec_dev, device_info->exec_msec_dev, device_info->kernel_accel_dev, device_info->kernel_loops_dev, device_info->kernel_threads_dev, device_info->vector_width_dev); } if (hashcat_status->device_info_active > 1) { event_log_info (hashcat_ctx, "Speed.Dev.#*.....: %9sH/s", hashcat_status->speed_sec_all); } event_log_info (hashcat_ctx, "Recovered........: %d/%d (%.2f%%) Digests, %d/%d (%.2f%%) Salts", hashcat_status->digests_done, hashcat_status->digests_cnt, hashcat_status->digests_percent, hashcat_status->salts_done, hashcat_status->salts_cnt, hashcat_status->salts_percent); if (hashcat_status->digests_cnt > 1000) { event_log_info (hashcat_ctx, "Recovered/Time...: %s", hashcat_status->cpt); } switch (hashcat_status->progress_mode) { case PROGRESS_MODE_KEYSPACE_KNOWN: event_log_info (hashcat_ctx, "Progress.........: %" PRIu64 "/%" PRIu64 " (%.02f%%)", hashcat_status->progress_cur_relative_skip, hashcat_status->progress_end_relative_skip, hashcat_status->progress_finished_percent); event_log_info (hashcat_ctx, "Rejected.........: %" PRIu64 "/%" PRIu64 " (%.02f%%)", hashcat_status->progress_rejected, hashcat_status->progress_cur_relative_skip, hashcat_status->progress_rejected_percent); event_log_info (hashcat_ctx, "Restore.Point....: %" PRIu64 "/%" PRIu64 " (%.02f%%)", hashcat_status->restore_point, hashcat_status->restore_total, hashcat_status->restore_percent); break; case PROGRESS_MODE_KEYSPACE_UNKNOWN: event_log_info (hashcat_ctx, "Progress.........: %" PRIu64, hashcat_status->progress_cur_relative_skip); event_log_info (hashcat_ctx, "Rejected.........: %" PRIu64, hashcat_status->progress_rejected); event_log_info (hashcat_ctx, "Restore.Point....: %" PRIu64, hashcat_status->restore_point); break; } for (int device_id = 0; device_id < hashcat_status->device_info_cnt; device_id++) { const device_info_t *device_info = hashcat_status->device_info_buf + device_id; if (device_info->skipped_dev == true) continue; if (device_info->guess_candidates_dev == NULL) continue; event_log_info (hashcat_ctx, "Candidates.#%d....: %s", device_id + 1, device_info->guess_candidates_dev); } if (user_options->gpu_temp_disable == false) { for (int device_id = 0; device_id < hashcat_status->device_info_cnt; device_id++) { const device_info_t *device_info = hashcat_status->device_info_buf + device_id; if (device_info->skipped_dev == true) continue; if (device_info->hwmon_dev == NULL) continue; event_log_info (hashcat_ctx, "HWMon.Dev.#%d.....: %s", device_id + 1, device_info->hwmon_dev); } } status_status_destroy (hashcat_ctx, hashcat_status); hcfree (hashcat_status); }
int mask_ctx_init (hashcat_ctx_t *hashcat_ctx) { mask_ctx_t *mask_ctx = hashcat_ctx->mask_ctx; user_options_extra_t *user_options_extra = hashcat_ctx->user_options_extra; user_options_t *user_options = hashcat_ctx->user_options; mask_ctx->enabled = false; if (user_options->left == true) return 0; if (user_options->opencl_info == true) return 0; if (user_options->show == true) return 0; if (user_options->usage == true) return 0; if (user_options->version == true) return 0; if (user_options->attack_mode == ATTACK_MODE_STRAIGHT) return 0; if (user_options->attack_mode == ATTACK_MODE_COMBI) return 0; mask_ctx->enabled = true; mask_ctx->root_table_buf = (hcstat_table_t *) hccalloc (SP_ROOT_CNT, sizeof (hcstat_table_t)); mask_ctx->markov_table_buf = (hcstat_table_t *) hccalloc (SP_MARKOV_CNT, sizeof (hcstat_table_t)); sp_setup_tbl (hashcat_ctx); mask_ctx->root_css_buf = (cs_t *) hccalloc (SP_PW_MAX, sizeof (cs_t)); mask_ctx->markov_css_buf = (cs_t *) hccalloc (SP_PW_MAX * CHARSIZ, sizeof (cs_t)); mask_ctx->css_cnt = 0; mask_ctx->css_buf = NULL; mask_ctx->mask_from_file = false; mask_ctx->masks = NULL; mask_ctx->masks_pos = 0; mask_ctx->masks_cnt = 0; mask_ctx->mfs = (mf_t *) hccalloc (MAX_MFS, sizeof (mf_t)); mp_setup_sys (mask_ctx->mp_sys); if (user_options->custom_charset_1) { const int rc = mp_setup_usr (hashcat_ctx, mask_ctx->mp_sys, mask_ctx->mp_usr, user_options->custom_charset_1, 0); if (rc == -1) return -1; } if (user_options->custom_charset_2) { const int rc = mp_setup_usr (hashcat_ctx, mask_ctx->mp_sys, mask_ctx->mp_usr, user_options->custom_charset_2, 1); if (rc == -1) return -1; } if (user_options->custom_charset_3) { const int rc = mp_setup_usr (hashcat_ctx, mask_ctx->mp_sys, mask_ctx->mp_usr, user_options->custom_charset_3, 2); if (rc == -1) return -1; } if (user_options->custom_charset_4) { const int rc = mp_setup_usr (hashcat_ctx, mask_ctx->mp_sys, mask_ctx->mp_usr, user_options->custom_charset_4, 3); if (rc == -1) return -1; } if (user_options->attack_mode == ATTACK_MODE_BF) { if (user_options->benchmark == false) { if (user_options_extra->hc_workc) { char *arg = user_options_extra->hc_workv[0]; hc_stat_t file_stat; if (hc_stat (arg, &file_stat) == -1) { const int rc = mask_append (hashcat_ctx, arg, NULL); if (rc == -1) return -1; } else { mask_ctx->mask_from_file = true; for (int i = 0; i < user_options_extra->hc_workc; i++) { arg = user_options_extra->hc_workv[i]; if (hc_stat (arg, &file_stat) == -1) { event_log_error (hashcat_ctx, "%s: %m", arg); return -1; } if (S_ISREG (file_stat.st_mode)) { FILE *mask_fp = fopen (arg, "r"); if (mask_fp == NULL) { event_log_error (hashcat_ctx, "%s: %m", arg); return -1; } char *line_buf = (char *) hcmalloc (HCBUFSIZ_LARGE); while (!feof (mask_fp)) { const int line_len = fgetl (mask_fp, line_buf); if (line_len == 0) continue; if (line_buf[0] == '#') continue; char *mask_buf = mask_ctx_parse_maskfile_find_mask (line_buf, line_len); char *prepend_buf = NULL; if (line_buf != mask_buf) { // if we have custom charsets prepend_buf = line_buf; mask_buf[-1] = 0; } const int rc = mask_append (hashcat_ctx, mask_buf, prepend_buf); if (rc == -1) { fclose (mask_fp); return -1; } } hcfree (line_buf); fclose (mask_fp); } else { event_log_error (hashcat_ctx, "%s: unsupported file-type", arg); return -1; } } } } else { const char *mask = DEF_MASK; const int rc = mask_append (hashcat_ctx, mask, NULL); if (rc == -1) return -1; } } else { const char *mask = hashconfig_benchmark_mask (hashcat_ctx); const int rc = mask_append (hashcat_ctx, mask, NULL); if (rc == -1) return -1; } } else if (user_options->attack_mode == ATTACK_MODE_HYBRID1) { // display char *arg = user_options_extra->hc_workv[user_options_extra->hc_workc - 1]; // mod hc_stat_t file_stat; if (hc_stat (arg, &file_stat) == -1) { const int rc = mask_append (hashcat_ctx, arg, NULL); if (rc == -1) return -1; } else { if (S_ISREG (file_stat.st_mode)) { mask_ctx->mask_from_file = true; FILE *mask_fp = fopen (arg, "r"); if (mask_fp == NULL) { event_log_error (hashcat_ctx, "%s: %m", arg); return -1; } char *line_buf = (char *) hcmalloc (HCBUFSIZ_LARGE); while (!feof (mask_fp)) { const int line_len = fgetl (mask_fp, line_buf); if (line_len == 0) continue; if (line_buf[0] == '#') continue; char *mask_buf = mask_ctx_parse_maskfile_find_mask (line_buf, line_len); char *prepend_buf = NULL; if (line_buf != mask_buf) { // if we have custom charsets prepend_buf = line_buf; mask_buf[-1] = 0; } const int rc = mask_append (hashcat_ctx, mask_buf, prepend_buf); if (rc == -1) { fclose (mask_fp); return -1; } } hcfree (line_buf); fclose (mask_fp); } else { event_log_error (hashcat_ctx, "%s: unsupported file-type", arg); return -1; } } } else if (user_options->attack_mode == ATTACK_MODE_HYBRID2) { // display char *arg = user_options_extra->hc_workv[0]; // mod hc_stat_t file_stat; if (hc_stat (arg, &file_stat) == -1) { const int rc = mask_append (hashcat_ctx, arg, NULL); if (rc == -1) return -1; } else { if (S_ISREG (file_stat.st_mode)) { mask_ctx->mask_from_file = true; FILE *mask_fp = fopen (arg, "r"); if (mask_fp == NULL) { event_log_error (hashcat_ctx, "%s: %m", arg); return -1; } char *line_buf = (char *) hcmalloc (HCBUFSIZ_LARGE); while (!feof (mask_fp)) { const int line_len = fgetl (mask_fp, line_buf); if (line_len == 0) continue; if (line_buf[0] == '#') continue; char *mask_buf = mask_ctx_parse_maskfile_find_mask (line_buf, line_len); char *prepend_buf = NULL; if (line_buf != mask_buf) { // if we have custom charsets prepend_buf = line_buf; mask_buf[-1] = 0; } const int rc = mask_append (hashcat_ctx, mask_buf, prepend_buf); if (rc == -1) { fclose (mask_fp); return -1; } } hcfree (line_buf); fclose (mask_fp); } else { event_log_error (hashcat_ctx, "%s: unsupported file-type", arg); return -1; } } } if (mask_ctx->masks_cnt == 0) { event_log_error (hashcat_ctx, "Invalid mask"); return -1; } mask_ctx->mask = mask_ctx->masks[0]; return 0; }
int tuning_db_init (hashcat_ctx_t *hashcat_ctx) { folder_config_t *folder_config = hashcat_ctx->folder_config; tuning_db_t *tuning_db = hashcat_ctx->tuning_db; user_options_t *user_options = hashcat_ctx->user_options; user_options_extra_t *user_options_extra = hashcat_ctx->user_options_extra; tuning_db->enabled = false; if (user_options->example_hashes == true) return 0; if (user_options->keyspace == true) return 0; if (user_options->left == true) return 0; if (user_options->opencl_info == true) return 0; if (user_options->show == true) return 0; if (user_options->usage == true) return 0; if (user_options->version == true) return 0; tuning_db->enabled = true; char *tuning_db_file; hc_asprintf (&tuning_db_file, "%s/%s", folder_config->shared_dir, TUNING_DB_FILE); FILE *fp = fopen (tuning_db_file, "rb"); if (fp == NULL) { event_log_error (hashcat_ctx, "%s: %s", tuning_db_file, strerror (errno)); return -1; } hcfree (tuning_db_file); int num_lines = count_lines (fp); // a bit over-allocated tuning_db->alias_buf = (tuning_db_alias_t *) hccalloc (num_lines + 1, sizeof (tuning_db_alias_t)); tuning_db->alias_cnt = 0; tuning_db->entry_buf = (tuning_db_entry_t *) hccalloc (num_lines + 1, sizeof (tuning_db_entry_t)); tuning_db->entry_cnt = 0; rewind (fp); int line_num = 0; char *buf = (char *) hcmalloc (HCBUFSIZ_LARGE); while (!feof (fp)) { char *line_buf = fgets (buf, HCBUFSIZ_LARGE - 1, fp); if (line_buf == NULL) break; line_num++; const int line_len = in_superchop (line_buf); if (line_len == 0) continue; if (line_buf[0] == '#') continue; // start processing char *token_ptr[7] = { NULL }; int token_cnt = 0; char *saveptr = NULL; char *next = strtok_r (line_buf, "\t ", &saveptr); token_ptr[token_cnt] = next; token_cnt++; while ((next = strtok_r ((char *) NULL, "\t ", &saveptr)) != NULL) { token_ptr[token_cnt] = next; token_cnt++; } if (token_cnt == 2) { char *device_name = token_ptr[0]; char *alias_name = token_ptr[1]; tuning_db_alias_t *alias = &tuning_db->alias_buf[tuning_db->alias_cnt]; alias->device_name = hcstrdup (device_name); alias->alias_name = hcstrdup (alias_name); tuning_db->alias_cnt++; } else if (token_cnt == 6) { if ((token_ptr[1][0] != '0') && (token_ptr[1][0] != '1') && (token_ptr[1][0] != '3') && (token_ptr[1][0] != '*')) { event_log_warning (hashcat_ctx, "Tuning-db: Invalid attack_mode '%c' in Line '%d'", token_ptr[1][0], line_num); continue; } if ((token_ptr[3][0] != '1') && (token_ptr[3][0] != '2') && (token_ptr[3][0] != '4') && (token_ptr[3][0] != '8') && (token_ptr[3][0] != 'N')) { event_log_warning (hashcat_ctx, "Tuning-db: Invalid vector_width '%c' in Line '%d'", token_ptr[3][0], line_num); continue; } char *device_name = token_ptr[0]; int attack_mode = -1; int hash_type = -1; int vector_width = -1; int kernel_accel = -1; int kernel_loops = -1; if (token_ptr[1][0] != '*') attack_mode = strtol (token_ptr[1], NULL, 10); if (token_ptr[2][0] != '*') hash_type = strtol (token_ptr[2], NULL, 10); if (token_ptr[3][0] != 'N') vector_width = strtol (token_ptr[3], NULL, 10); if (token_ptr[4][0] == 'A') { kernel_accel = 0; } else if (token_ptr[4][0] == 'M') { kernel_accel = 1024; } else { kernel_accel = strtol (token_ptr[4], NULL, 10); if ((kernel_accel < 1) || (kernel_accel > 1024)) { event_log_warning (hashcat_ctx, "Tuning-db: Invalid kernel_accel '%d' in Line '%d'", kernel_accel, line_num); continue; } } if (token_ptr[5][0] == 'A') { kernel_loops = 0; } else if (token_ptr[5][0] == 'M') { if (user_options_extra->attack_kern == ATTACK_KERN_STRAIGHT) { kernel_loops = KERNEL_RULES; } else if (user_options_extra->attack_kern == ATTACK_KERN_COMBI) { kernel_loops = KERNEL_COMBS; } else if (user_options_extra->attack_kern == ATTACK_KERN_BF) { kernel_loops = KERNEL_BFS; } } else { kernel_loops = strtol (token_ptr[5], NULL, 10); if (kernel_loops < 1) { event_log_warning (hashcat_ctx, "Tuning-db: Invalid kernel_loops '%d' in Line '%d'", kernel_loops, line_num); continue; } if ((user_options_extra->attack_kern == ATTACK_KERN_STRAIGHT) && (kernel_loops > KERNEL_RULES)) { event_log_warning (hashcat_ctx, "Tuning-db: Invalid kernel_loops '%d' in Line '%d'", kernel_loops, line_num); continue; } if ((user_options_extra->attack_kern == ATTACK_KERN_COMBI) && (kernel_loops > KERNEL_COMBS)) { event_log_warning (hashcat_ctx, "Tuning-db: Invalid kernel_loops '%d' in Line '%d'", kernel_loops, line_num); continue; } if ((user_options_extra->attack_kern == ATTACK_KERN_BF) && (kernel_loops > KERNEL_BFS)) { event_log_warning (hashcat_ctx, "Tuning-db: Invalid kernel_loops '%d' in Line '%d'", kernel_loops, line_num); continue; } } tuning_db_entry_t *entry = &tuning_db->entry_buf[tuning_db->entry_cnt]; entry->device_name = hcstrdup (device_name); entry->attack_mode = attack_mode; entry->hash_type = hash_type; entry->vector_width = vector_width; entry->kernel_accel = kernel_accel; entry->kernel_loops = kernel_loops; tuning_db->entry_cnt++; } else { event_log_warning (hashcat_ctx, "Tuning-db: Invalid number of token in Line '%d'", line_num); continue; } } hcfree (buf); fclose (fp); // todo: print loaded 'cnt' message // sort the database qsort (tuning_db->alias_buf, tuning_db->alias_cnt, sizeof (tuning_db_alias_t), sort_by_tuning_db_alias); qsort (tuning_db->entry_buf, tuning_db->entry_cnt, sizeof (tuning_db_entry_t), sort_by_tuning_db_entry); return 0; }
void status_display_machine_readable (hashcat_ctx_t *hashcat_ctx) { const user_options_t *user_options = hashcat_ctx->user_options; hashcat_status_t *hashcat_status = (hashcat_status_t *) hcmalloc (sizeof (hashcat_status_t)); const int rc_status = hashcat_get_status (hashcat_ctx, hashcat_status); if (rc_status == -1) { hcfree (hashcat_status); return; } printf ("STATUS\t%d\t", hashcat_status->status_number); printf ("SPEED\t"); for (int device_id = 0; device_id < hashcat_status->device_info_cnt; device_id++) { const device_info_t *device_info = hashcat_status->device_info_buf + device_id; if (device_info->skipped_dev == true) continue; printf ("%" PRIu64 "\t", (u64) (device_info->hashes_msec_dev * 1000)); // that 1\t is for backward compatibility printf ("1000\t"); } printf ("EXEC_RUNTIME\t"); for (int device_id = 0; device_id < hashcat_status->device_info_cnt; device_id++) { const device_info_t *device_info = hashcat_status->device_info_buf + device_id; if (device_info->skipped_dev == true) continue; printf ("%f\t", device_info->exec_msec_dev); } printf ("CURKU\t%" PRIu64 "\t", hashcat_status->restore_point); printf ("PROGRESS\t%" PRIu64 "\t%" PRIu64 "\t", hashcat_status->progress_cur_relative_skip, hashcat_status->progress_end_relative_skip); printf ("RECHASH\t%d\t%d\t", hashcat_status->digests_done, hashcat_status->digests_cnt); printf ("RECSALT\t%d\t%d\t", hashcat_status->salts_done, hashcat_status->salts_cnt); if (user_options->gpu_temp_disable == false) { printf ("TEMP\t"); for (int device_id = 0; device_id < hashcat_status->device_info_cnt; device_id++) { const device_info_t *device_info = hashcat_status->device_info_buf + device_id; if (device_info->skipped_dev == true) continue; // ok, little cheat here... const int temp = hm_get_temperature_with_device_id (hashcat_ctx, device_id); printf ("%d\t", temp); } } printf ("REJECTED\t%" PRIu64 "\t", hashcat_status->progress_rejected); printf ("UTIL\t"); for (int device_id = 0; device_id < hashcat_status->device_info_cnt; device_id++) { const device_info_t *device_info = hashcat_status->device_info_buf + device_id; if (device_info->skipped_dev == true) continue; // ok, little cheat here again... const int util = hm_get_utilization_with_device_id (hashcat_ctx, device_id); printf ("%d\t", util); } hc_fwrite (EOL, strlen (EOL), 1, stdout); fflush (stdout); status_status_destroy (hashcat_ctx, hashcat_status); hcfree (hashcat_status); }
int hashcat_init (hashcat_ctx_t *hashcat_ctx, void (*event) (const u32, struct hashcat_ctx *, const void *, const size_t)) { if (event == NULL) { fprintf (stderr, "Event callback function is mandatory\n"); return -1; } hashcat_ctx->event = event; hashcat_ctx->bitmap_ctx = (bitmap_ctx_t *) hcmalloc (sizeof (bitmap_ctx_t)); hashcat_ctx->combinator_ctx = (combinator_ctx_t *) hcmalloc (sizeof (combinator_ctx_t)); hashcat_ctx->cpt_ctx = (cpt_ctx_t *) hcmalloc (sizeof (cpt_ctx_t)); hashcat_ctx->debugfile_ctx = (debugfile_ctx_t *) hcmalloc (sizeof (debugfile_ctx_t)); hashcat_ctx->dictstat_ctx = (dictstat_ctx_t *) hcmalloc (sizeof (dictstat_ctx_t)); hashcat_ctx->event_ctx = (event_ctx_t *) hcmalloc (sizeof (event_ctx_t)); hashcat_ctx->folder_config = (folder_config_t *) hcmalloc (sizeof (folder_config_t)); hashcat_ctx->hashcat_user = (hashcat_user_t *) hcmalloc (sizeof (hashcat_user_t)); hashcat_ctx->hashconfig = (hashconfig_t *) hcmalloc (sizeof (hashconfig_t)); hashcat_ctx->hashes = (hashes_t *) hcmalloc (sizeof (hashes_t)); hashcat_ctx->hwmon_ctx = (hwmon_ctx_t *) hcmalloc (sizeof (hwmon_ctx_t)); hashcat_ctx->induct_ctx = (induct_ctx_t *) hcmalloc (sizeof (induct_ctx_t)); hashcat_ctx->logfile_ctx = (logfile_ctx_t *) hcmalloc (sizeof (logfile_ctx_t)); hashcat_ctx->loopback_ctx = (loopback_ctx_t *) hcmalloc (sizeof (loopback_ctx_t)); hashcat_ctx->mask_ctx = (mask_ctx_t *) hcmalloc (sizeof (mask_ctx_t)); hashcat_ctx->opencl_ctx = (opencl_ctx_t *) hcmalloc (sizeof (opencl_ctx_t)); hashcat_ctx->outcheck_ctx = (outcheck_ctx_t *) hcmalloc (sizeof (outcheck_ctx_t)); hashcat_ctx->outfile_ctx = (outfile_ctx_t *) hcmalloc (sizeof (outfile_ctx_t)); hashcat_ctx->pidfile_ctx = (pidfile_ctx_t *) hcmalloc (sizeof (pidfile_ctx_t)); hashcat_ctx->potfile_ctx = (potfile_ctx_t *) hcmalloc (sizeof (potfile_ctx_t)); hashcat_ctx->restore_ctx = (restore_ctx_t *) hcmalloc (sizeof (restore_ctx_t)); hashcat_ctx->status_ctx = (status_ctx_t *) hcmalloc (sizeof (status_ctx_t)); hashcat_ctx->straight_ctx = (straight_ctx_t *) hcmalloc (sizeof (straight_ctx_t)); hashcat_ctx->tuning_db = (tuning_db_t *) hcmalloc (sizeof (tuning_db_t)); hashcat_ctx->user_options_extra = (user_options_extra_t *) hcmalloc (sizeof (user_options_extra_t)); hashcat_ctx->user_options = (user_options_t *) hcmalloc (sizeof (user_options_t)); hashcat_ctx->wl_data = (wl_data_t *) hcmalloc (sizeof (wl_data_t)); return 0; }
void *hc_lzma_alloc (MAYBE_UNUSED ISzAllocPtr p, size_t size) { return hcmalloc (size); }
static int sp_setup_tbl (hashcat_ctx_t *hashcat_ctx) { folder_config_t *folder_config = hashcat_ctx->folder_config; mask_ctx_t *mask_ctx = hashcat_ctx->mask_ctx; user_options_t *user_options = hashcat_ctx->user_options; char *shared_dir = folder_config->shared_dir; char *hcstat = user_options->markov_hcstat2; u32 disable = user_options->markov_disable; u32 classic = user_options->markov_classic; hcstat_table_t *root_table_buf = mask_ctx->root_table_buf; hcstat_table_t *markov_table_buf = mask_ctx->markov_table_buf; /** * Initialize hcstats */ u64 *root_stats_buf = (u64 *) hccalloc (SP_ROOT_CNT, sizeof (u64)); u64 *root_stats_ptr = root_stats_buf; u64 *root_stats_buf_by_pos[SP_PW_MAX]; for (int i = 0; i < SP_PW_MAX; i++) { root_stats_buf_by_pos[i] = root_stats_ptr; root_stats_ptr += CHARSIZ; } u64 *markov_stats_buf = (u64 *) hccalloc (SP_MARKOV_CNT, sizeof (u64)); u64 *markov_stats_ptr = markov_stats_buf; u64 *markov_stats_buf_by_key[SP_PW_MAX][CHARSIZ]; for (int i = 0; i < SP_PW_MAX; i++) { for (int j = 0; j < CHARSIZ; j++) { markov_stats_buf_by_key[i][j] = markov_stats_ptr; markov_stats_ptr += CHARSIZ; } } /** * Load hcstats File */ char hcstat_tmp[256]; if (hcstat == NULL) { snprintf (hcstat_tmp, sizeof (hcstat_tmp), "%s/%s", shared_dir, SP_HCSTAT); hcstat = hcstat_tmp; } struct stat s; if (stat (hcstat, &s) == -1) { event_log_error (hashcat_ctx, "%s: %s", hcstat, strerror (errno)); return -1; } FILE *fd = fopen (hcstat, "rb"); if (fd == NULL) { event_log_error (hashcat_ctx, "%s: %s", hcstat, strerror (errno)); return -1; } u8 *inbuf = (u8 *) hcmalloc (s.st_size); SizeT inlen = (SizeT) hc_fread (inbuf, 1, s.st_size, fd); if (inlen != (SizeT) s.st_size) { event_log_error (hashcat_ctx, "%s: Could not read data.", hcstat); fclose (fd); hcfree (inbuf); return -1; } fclose (fd); u8 *outbuf = (u8 *) hcmalloc (SP_FILESZ); SizeT outlen = SP_FILESZ; const char props = 0x1c; // lzma properties constant, retrieved with 7z2hashcat const SRes res = hc_lzma2_decompress (inbuf, &inlen, outbuf, &outlen, &props); if (res != SZ_OK) { event_log_error (hashcat_ctx, "%s: Could not uncompress data.", hcstat); hcfree (inbuf); hcfree (outbuf); return -1; } if (outlen != SP_FILESZ) { event_log_error (hashcat_ctx, "%s: Could not uncompress data.", hcstat); hcfree (inbuf); hcfree (outbuf); return -1; } u64 *ptr = (u64 *) outbuf; u64 v = *ptr++; u64 z = *ptr++; memcpy (root_stats_buf, ptr, sizeof (u64) * SP_ROOT_CNT); ptr += SP_ROOT_CNT; memcpy (markov_stats_buf, ptr, sizeof (u64) * SP_MARKOV_CNT); // ptr += SP_MARKOV_CNT; hcfree (inbuf); hcfree (outbuf); /** * switch endianess */ v = byte_swap_64 (v); z = byte_swap_64 (z); for (int i = 0; i < SP_ROOT_CNT; i++) root_stats_buf[i] = byte_swap_64 (root_stats_buf[i]); for (int i = 0; i < SP_MARKOV_CNT; i++) markov_stats_buf[i] = byte_swap_64 (markov_stats_buf[i]); /** * verify header */ if (v != SP_VERSION) { event_log_error (hashcat_ctx, "%s: Invalid header", hcstat); return -1; } if (z != 0) { event_log_error (hashcat_ctx, "%s: Invalid header", hcstat); return -1; } /** * Markov modifier of hcstat_table on user request */ if (disable) { memset (root_stats_buf, 0, SP_ROOT_CNT * sizeof (u64)); memset (markov_stats_buf, 0, SP_MARKOV_CNT * sizeof (u64)); } if (classic) { /* Add all stats to first position */ for (int i = 1; i < SP_PW_MAX; i++) { u64 *out = root_stats_buf_by_pos[0]; u64 *in = root_stats_buf_by_pos[i]; for (int j = 0; j < CHARSIZ; j++) { *out++ += *in++; } } for (int i = 1; i < SP_PW_MAX; i++) { u64 *out = markov_stats_buf_by_key[0][0]; u64 *in = markov_stats_buf_by_key[i][0]; for (int j = 0; j < CHARSIZ; j++) { for (int k = 0; k < CHARSIZ; k++) { *out++ += *in++; } } } /* copy them to all pw_positions */ for (int i = 1; i < SP_PW_MAX; i++) { memcpy (root_stats_buf_by_pos[i], root_stats_buf_by_pos[0], CHARSIZ * sizeof (u64)); } for (int i = 1; i < SP_PW_MAX; i++) { memcpy (markov_stats_buf_by_key[i][0], markov_stats_buf_by_key[0][0], CHARSIZ * CHARSIZ * sizeof (u64)); } } /** * Initialize tables */ hcstat_table_t *root_table_ptr = root_table_buf; hcstat_table_t *root_table_buf_by_pos[SP_PW_MAX]; for (int i = 0; i < SP_PW_MAX; i++) { root_table_buf_by_pos[i] = root_table_ptr; root_table_ptr += CHARSIZ; } hcstat_table_t *markov_table_ptr = markov_table_buf; hcstat_table_t *markov_table_buf_by_key[SP_PW_MAX][CHARSIZ]; for (int i = 0; i < SP_PW_MAX; i++) { for (int j = 0; j < CHARSIZ; j++) { markov_table_buf_by_key[i][j] = markov_table_ptr; markov_table_ptr += CHARSIZ; } } /** * Convert hcstat to tables */ for (int i = 0; i < SP_ROOT_CNT; i++) { u32 key = i % CHARSIZ; root_table_buf[i].key = key; root_table_buf[i].val = root_stats_buf[i]; } for (int i = 0; i < SP_MARKOV_CNT; i++) { u32 key = i % CHARSIZ; markov_table_buf[i].key = key; markov_table_buf[i].val = markov_stats_buf[i]; } hcfree (root_stats_buf); hcfree (markov_stats_buf); /** * Finally sort them */ for (int i = 0; i < SP_PW_MAX; i++) { qsort (root_table_buf_by_pos[i], CHARSIZ, sizeof (hcstat_table_t), sp_comp_val); } for (int i = 0; i < SP_PW_MAX; i++) { for (int j = 0; j < CHARSIZ; j++) { qsort (markov_table_buf_by_key[i][j], CHARSIZ, sizeof (hcstat_table_t), sp_comp_val); } } return 0; }
static int mask_append (hashcat_ctx_t *hashcat_ctx, const char *mask, const char *prepend) { hashconfig_t *hashconfig = hashcat_ctx->hashconfig; user_options_t *user_options = hashcat_ctx->user_options; if (user_options->increment == true) { const u32 mask_length = mp_get_length (mask); u32 increment_min = user_options->increment_min; u32 increment_max = user_options->increment_max; increment_max = MIN (increment_max, mask_length); if (user_options->attack_mode == ATTACK_MODE_BF) { const u32 pw_min = hashconfig->pw_min; const u32 pw_max = hashconfig->pw_max; increment_min = MAX (increment_min, pw_min); increment_max = MIN (increment_max, pw_max); } for (u32 increment_len = increment_min; increment_len <= increment_max; increment_len++) { char *mask_truncated = (char *) hcmalloc (256); char *mask_truncated_next = mask_truncated; if (prepend) { // this happens with maskfiles only mask_truncated_next += snprintf (mask_truncated, 256, "%s,", prepend); } const int rc_truncated_mask = mp_get_truncated_mask (hashcat_ctx, mask, strlen (mask), increment_len, mask_truncated_next); if (rc_truncated_mask == -1) { hcfree (mask_truncated); break; } const int rc = mask_append_final (hashcat_ctx, mask_truncated); hcfree (mask_truncated); if (rc == -1) return -1; } } else { if (prepend) { // this happens with maskfiles only char *prepend_mask; hc_asprintf (&prepend_mask, "%s,%s", prepend, mask); const int rc = mask_append_final (hashcat_ctx, prepend_mask); hcfree (prepend_mask); if (rc == -1) return -1; } else { const int rc = mask_append_final (hashcat_ctx, mask); if (rc == -1) return -1; } } return 0; }
int potfile_init (hashcat_ctx_t *hashcat_ctx) { folder_config_t *folder_config = hashcat_ctx->folder_config; potfile_ctx_t *potfile_ctx = hashcat_ctx->potfile_ctx; user_options_t *user_options = hashcat_ctx->user_options; potfile_ctx->enabled = false; if (user_options->benchmark == true) return 0; if (user_options->example_hashes == true) return 0; if (user_options->keyspace == true) return 0; if (user_options->opencl_info == true) return 0; if (user_options->stdout_flag == true) return 0; if (user_options->speed_only == true) return 0; if (user_options->progress_only == true) return 0; if (user_options->usage == true) return 0; if (user_options->version == true) return 0; if (user_options->potfile_disable == true) return 0; potfile_ctx->enabled = true; if (user_options->potfile_path == NULL) { potfile_ctx->fp = NULL; hc_asprintf (&potfile_ctx->filename, "%s/hashcat.potfile", folder_config->profile_dir); } else { potfile_ctx->filename = hcstrdup (user_options->potfile_path); potfile_ctx->fp = NULL; } // keep all hashes if --username was combined with --left or --show potfile_ctx->keep_all_hashes = false; if (user_options->username == true) { if ((user_options->show == true) || (user_options->left == true)) { potfile_ctx->keep_all_hashes = true; } } // keep all hashes if -m 3000 was combined with --left or --show if (user_options->hash_mode == 3000) { if ((user_options->show == true) || (user_options->left == true)) { potfile_ctx->keep_all_hashes = true; } } // starting from here, we should allocate some scratch buffer for later use u8 *out_buf = (u8 *) hcmalloc (HCBUFSIZ_LARGE); potfile_ctx->out_buf = out_buf; // we need two buffers in parallel u8 *tmp_buf = (u8 *) hcmalloc (HCBUFSIZ_LARGE); potfile_ctx->tmp_buf = tmp_buf; // old potfile detection if (user_options->potfile_path == NULL) { char *potfile_old; hc_asprintf (&potfile_old, "%s/hashcat.pot", folder_config->profile_dir); if (hc_path_exist (potfile_old) == true) { event_log_warning (hashcat_ctx, "Old potfile detected: %s", potfile_old); event_log_warning (hashcat_ctx, "New potfile is: %s ", potfile_ctx->filename); event_log_warning (hashcat_ctx, NULL); } hcfree (potfile_old); } return 0; }
int potfile_remove_parse (hashcat_ctx_t *hashcat_ctx) { hashconfig_t *hashconfig = hashcat_ctx->hashconfig; const hashes_t *hashes = hashcat_ctx->hashes; const potfile_ctx_t *potfile_ctx = hashcat_ctx->potfile_ctx; if (potfile_ctx->enabled == false) return 0; // if no potfile exists yet we don't need to do anything here if (hc_path_exist (potfile_ctx->filename) == false) return 0; hash_t *hashes_buf = hashes->hashes_buf; u32 hashes_cnt = hashes->hashes_cnt; // no solution for these special hash types (for instane because they use hashfile in output etc) if (hashconfig->hash_mode == 5200) return 0; if ((hashconfig->hash_mode >= 6200) && (hashconfig->hash_mode <= 6299)) return 0; if (hashconfig->hash_mode == 9000) return 0; if ((hashconfig->hash_mode >= 13700) && (hashconfig->hash_mode <= 13799)) return 0; if (hashconfig->hash_mode == 14600) return 0; hash_t hash_buf; hash_buf.digest = hcmalloc (hashconfig->dgst_size); hash_buf.salt = NULL; hash_buf.esalt = NULL; hash_buf.hook_salt = NULL; hash_buf.hash_info = NULL; hash_buf.cracked = 0; if (hashconfig->is_salted == true) { hash_buf.salt = (salt_t *) hcmalloc (sizeof (salt_t)); } if (hashconfig->esalt_size > 0) { hash_buf.esalt = hcmalloc (hashconfig->esalt_size); } if (hashconfig->hook_salt_size > 0) { hash_buf.hook_salt = hcmalloc (hashconfig->hook_salt_size); } // we only need this variable in a very specific situation: // whenever we use --username and --show together we want to keep all hashes sorted within a nice structure pot_tree_entry_t *all_hashes_tree = NULL; pot_tree_entry_t *tree_entry_cache = NULL; pot_hash_node_t *tree_nodes_cache = NULL; if (potfile_ctx->keep_all_hashes == true) { // we need *at most* one entry for every hash // (if there are no hashes with the same keys (hash + salt), a counter example would be: same hash but different user name) tree_entry_cache = (pot_tree_entry_t *) hccalloc (hashes_cnt, sizeof (pot_tree_entry_t)); // we need *always exactly* one linked list for every hash tree_nodes_cache = (pot_hash_node_t *) hccalloc (hashes_cnt, sizeof (pot_hash_node_t)); for (u32 hash_pos = 0; hash_pos < hashes_cnt; hash_pos++) { // initialize the linked list node: // we always need to create a new one and add it, because we want to keep and later update all hashes: pot_hash_node_t *new_node = &tree_nodes_cache[hash_pos]; new_node->hash_buf = &hashes_buf[hash_pos]; new_node->next = NULL; // initialize the entry: pot_tree_entry_t *new_entry = &tree_entry_cache[hash_pos]; // note: the "key" (hash + salt) is indirectly accessible via the first nodes "hash_buf" new_entry->nodes = new_node; // the hashconfig is needed here because we need to be able to check within the sort function if we also need // to sort by salt and we also need to have the correct order of dgst_pos0...dgst_pos3: new_entry->hashconfig = (hashconfig_t *) hashconfig; // "const hashconfig_t" gives a warning // the following function searches if the "key" is already present and if not inserts the new entry: void **found = tsearch (new_entry, (void **) &all_hashes_tree, sort_pot_tree_by_hash); pot_tree_entry_t *found_entry = (pot_tree_entry_t *) *found; // we now need to check these cases; tsearch () could return: // 1. NULL : if we have a memory allocation problem (not enough memory for the tree structure) // 2. found_entry == new_entry: if we successfully insert a new key (which was not present yet) // 3. found_entry != new_entry: if the key was already present // case 1: memory allocation error if (found_entry == NULL) { fprintf (stderr, "Error while allocating memory for the potfile search: %s\n", MSG_ENOMEM); return -1; } // case 2: this means it was a new insert (and the insert was successful) if (found_entry == new_entry) { // no updates to the linked list required (since it is the first one!) } // case 3: if we have found an already existing entry else { new_node->next = found_entry->nodes; } // we always insert the new node at the very beginning // (or in other words: the head of the linked list always points to *this* new inserted node) found_entry->nodes = new_node; } } // special case for a split hash if (hashconfig->hash_mode == 3000) { int parser_status = hashconfig->parse_func ((u8 *) LM_ZERO_HASH, 16, &hash_buf, hashconfig); if (parser_status == PARSER_OK) { if (potfile_ctx->keep_all_hashes == true) { potfile_update_hashes (hashcat_ctx, &hash_buf, NULL, 0, all_hashes_tree); } else { hash_t *found = (hash_t *) hc_bsearch_r (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_no_salt, (void *) hashconfig); potfile_update_hash (hashcat_ctx, found, NULL, 0); } } } const int rc = potfile_read_open (hashcat_ctx); if (rc == -1) return -1; char *line_buf = (char *) hcmalloc (HCBUFSIZ_LARGE); while (!feof (potfile_ctx->fp)) { size_t line_len = fgetl (potfile_ctx->fp, line_buf); if (line_len == 0) continue; char *last_separator = strrchr (line_buf, hashconfig->separator); if (last_separator == NULL) continue; // ?? char *line_pw_buf = last_separator + 1; size_t line_pw_len = line_buf + line_len - line_pw_buf; char *line_hash_buf = line_buf; size_t line_hash_len = last_separator - line_buf; line_hash_buf[line_hash_len] = 0; if (line_hash_len == 0) continue; if (hashconfig->is_salted == true) { memset (hash_buf.salt, 0, sizeof (salt_t)); } if (hashconfig->esalt_size > 0) { memset (hash_buf.esalt, 0, hashconfig->esalt_size); } if (hashconfig->hook_salt_size > 0) { memset (hash_buf.hook_salt, 0, hashconfig->hook_salt_size); } hash_t *found = NULL; if (hashconfig->hash_mode == 6800) { if (line_hash_len < 256) // 64 = 64 * u32 in salt_buf[] { // manipulate salt_buf memcpy (hash_buf.salt->salt_buf, line_hash_buf, line_hash_len); hash_buf.salt->salt_len = (u32) line_hash_len; found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt); } } else if ((hashconfig->hash_mode == 2500) || (hashconfig->hash_mode == 2501)) { // here we have in line_hash_buf: hash:macap:macsta:essid:password char *sep_pos = strrchr (line_hash_buf, ':'); if (sep_pos == NULL) continue; sep_pos[0] = 0; char *hash_pos = line_hash_buf; const size_t hash_len = strlen (hash_pos); if (hash_len != 32 + 1 + 12 + 1 + 12) continue; char *essid_pos = sep_pos + 1; size_t essid_len = strlen (essid_pos); if (is_hexify ((const u8 *) essid_pos, essid_len) == true) { essid_len = exec_unhexify ((const u8 *) essid_pos, essid_len, (u8 *) essid_pos, essid_len); } if (essid_len > 32) continue; if (hashconfig->is_salted == true) { // this should be always true, but we need it to make scan-build happy memcpy (hash_buf.salt->salt_buf, essid_pos, essid_len); hash_buf.salt->salt_len = (u32) essid_len; hash_buf.salt->salt_iter = ROUNDS_WPA_PBKDF2 - 1; u32 hash[4]; hash[0] = hex_to_u32 ((const u8 *) &hash_pos[ 0]); hash[1] = hex_to_u32 ((const u8 *) &hash_pos[ 8]); hash[2] = hex_to_u32 ((const u8 *) &hash_pos[16]); hash[3] = hex_to_u32 ((const u8 *) &hash_pos[24]); hash[0] = byte_swap_32 (hash[0]); hash[1] = byte_swap_32 (hash[1]); hash[2] = byte_swap_32 (hash[2]); hash[3] = byte_swap_32 (hash[3]); u32 *digest = (u32 *) hash_buf.digest; digest[0] = hash[0]; digest[1] = hash[1]; digest[2] = hash[2]; digest[3] = hash[3]; } found = (hash_t *) hc_bsearch_r (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash, (void *) hashconfig); } else { int parser_status = hashconfig->parse_func ((u8 *) line_hash_buf, (u32) line_hash_len, &hash_buf, hashconfig); if (parser_status != PARSER_OK) continue; if (potfile_ctx->keep_all_hashes == true) { potfile_update_hashes (hashcat_ctx, &hash_buf, line_pw_buf, (u32) line_pw_len, all_hashes_tree); continue; } found = (hash_t *) hc_bsearch_r (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash, (void *) hashconfig); } potfile_update_hash (hashcat_ctx, found, line_pw_buf, (u32) line_pw_len); } hcfree (line_buf); potfile_read_close (hashcat_ctx); if (potfile_ctx->keep_all_hashes == true) { pot_tree_destroy (all_hashes_tree); // this could be slow (should we just skip it?) hcfree (tree_nodes_cache); hcfree (tree_entry_cache); } if (hashconfig->esalt_size > 0) { hcfree (hash_buf.esalt); } if (hashconfig->hook_salt_size > 0) { hcfree (hash_buf.hook_salt); } if (hashconfig->is_salted == true) { hcfree (hash_buf.salt); } hcfree (hash_buf.digest); return 0; }
int straight_ctx_init (hashcat_ctx_t *hashcat_ctx) { straight_ctx_t *straight_ctx = hashcat_ctx->straight_ctx; user_options_extra_t *user_options_extra = hashcat_ctx->user_options_extra; user_options_t *user_options = hashcat_ctx->user_options; straight_ctx->enabled = false; if (user_options->example_hashes == true) return 0; if (user_options->left == true) return 0; if (user_options->opencl_info == true) return 0; if (user_options->show == true) return 0; if (user_options->usage == true) return 0; if (user_options->version == true) return 0; if (user_options->attack_mode == ATTACK_MODE_BF) return 0; straight_ctx->enabled = true; /** * generate NOP rules */ if ((user_options->rp_files_cnt == 0) && (user_options->rp_gen == 0)) { straight_ctx->kernel_rules_buf = (kernel_rule_t *) hcmalloc (sizeof (kernel_rule_t)); straight_ctx->kernel_rules_buf[0].cmds[0] = RULE_OP_MANGLE_NOOP; straight_ctx->kernel_rules_cnt = 1; } else { if (user_options->rp_files_cnt) { const int rc_kernel_load = kernel_rules_load (hashcat_ctx, &straight_ctx->kernel_rules_buf, &straight_ctx->kernel_rules_cnt); if (rc_kernel_load == -1) return -1; } else if (user_options->rp_gen) { const int rc_kernel_generate = kernel_rules_generate (hashcat_ctx, &straight_ctx->kernel_rules_buf, &straight_ctx->kernel_rules_cnt); if (rc_kernel_generate == -1) return -1; } } /** * wordlist based work */ if (user_options->attack_mode == ATTACK_MODE_STRAIGHT) { if (user_options_extra->wordlist_mode == WL_MODE_FILE) { for (int i = 0; i < user_options_extra->hc_workc; i++) { char *l0_filename = user_options_extra->hc_workv[i]; // at this point we already verified the path actually exist and is readable if (hc_path_is_directory (l0_filename) == true) { char **dictionary_files; dictionary_files = scan_directory (l0_filename); if (dictionary_files != NULL) { qsort (dictionary_files, (size_t) count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr); for (int d = 0; dictionary_files[d] != NULL; d++) { char *l1_filename = dictionary_files[d]; if (hc_path_read (l1_filename) == false) { event_log_error (hashcat_ctx, "%s: %s", l1_filename, strerror (errno)); hcfree (dictionary_files); return -1; } if (hc_path_is_file (l1_filename) == true) { const int rc = straight_ctx_add_wl (hashcat_ctx, l1_filename); if (rc == -1) { hcfree (dictionary_files); return -1; } } } } hcfree (dictionary_files); } else { const int rc = straight_ctx_add_wl (hashcat_ctx, l0_filename); if (rc == -1) return -1; } } if (straight_ctx->dicts_cnt == 0) { event_log_error (hashcat_ctx, "No usable dictionary file found."); return -1; } } } else if (user_options->attack_mode == ATTACK_MODE_COMBI) { } else if (user_options->attack_mode == ATTACK_MODE_BF) { } else if (user_options->attack_mode == ATTACK_MODE_HYBRID1) { for (int i = 0; i < user_options_extra->hc_workc - 1; i++) { char *l0_filename = user_options_extra->hc_workv[i]; // at this point we already verified the path actually exist and is readable if (hc_path_is_directory (l0_filename) == true) { char **dictionary_files; dictionary_files = scan_directory (l0_filename); if (dictionary_files != NULL) { qsort (dictionary_files, (size_t) count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr); for (int d = 0; dictionary_files[d] != NULL; d++) { char *l1_filename = dictionary_files[d]; if (hc_path_read (l1_filename) == false) { event_log_error (hashcat_ctx, "%s: %s", l1_filename, strerror (errno)); hcfree (dictionary_files); return -1; } if (hc_path_is_file (l1_filename) == true) { const int rc = straight_ctx_add_wl (hashcat_ctx, l1_filename); if (rc == -1) { hcfree (dictionary_files); return -1; } } } } hcfree (dictionary_files); } else { const int rc = straight_ctx_add_wl (hashcat_ctx, l0_filename); if (rc == -1) return -1; } } if (straight_ctx->dicts_cnt == 0) { event_log_error (hashcat_ctx, "No usable dictionary file found."); return -1; } } else if (user_options->attack_mode == ATTACK_MODE_HYBRID2) { for (int i = 1; i < user_options_extra->hc_workc; i++) { char *l0_filename = user_options_extra->hc_workv[i]; // at this point we already verified the path actually exist and is readable if (hc_path_is_directory (l0_filename) == true) { char **dictionary_files; dictionary_files = scan_directory (l0_filename); if (dictionary_files != NULL) { qsort (dictionary_files, (size_t) count_dictionaries (dictionary_files), sizeof (char *), sort_by_stringptr); for (int d = 0; dictionary_files[d] != NULL; d++) { char *l1_filename = dictionary_files[d]; if (hc_path_read (l1_filename) == false) { event_log_error (hashcat_ctx, "%s: %s", l1_filename, strerror (errno)); hcfree (dictionary_files); return -1; } if (hc_path_is_file (l1_filename) == true) { const int rc = straight_ctx_add_wl (hashcat_ctx, l1_filename); if (rc == -1) { hcfree (dictionary_files); return -1; } } } } hcfree (dictionary_files); } else { const int rc = straight_ctx_add_wl (hashcat_ctx, l0_filename); if (rc == -1) return -1; } } if (straight_ctx->dicts_cnt == 0) { event_log_error (hashcat_ctx, "No usable dictionary file found."); return -1; } } return 0; }