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

Added the current first and last password candidate test queued for execution per device on status view

Browse Source
pull/533/head
jsteube 8 years ago
parent 0b2c568ba6
commit eeb8210951
10 changed files with 360 additions and 248 deletions
Show Stats Download Patch File Download Diff File

1
docs/changes.txt
Unescape View File

@ -4,6 +4,7 @@
## Improvements
##
- Added the current first and last password candidate test queued for execution per device on status view
- Use .gitmodules to handle OpenCL headers depency
- Allow loading of bcrypt hashes with signature $2b$ (February 2014)
- Replaced some uint macros with enums types

3
include/convert.h
Unescape View File

@ -8,6 +8,9 @@
#include <ctype.h>
bool need_hexify (const u8 *buf, const int len);
void exec_hexify (const u8 *buf, const int len, u8 *out);
bool is_valid_hex_char (const u8 c);
u8 hex_convert (const u8 c);

4
include/hashes.h
Unescape View File

@ -11,10 +11,6 @@ int sort_by_salt (const void *v1, const void *v2);
int sort_by_hash (const void *v1, const void *v2, void *v3);
int sort_by_hash_no_salt (const void *v1, const void *v2, void *v3);
void build_plain (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, plain_t *plain, u32 *plain_buf, int *out_len);
void build_crackpos (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, plain_t *plain, u64 *out_pos);
void build_debugdata (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, plain_t *plain, u8 *debug_rule_buf, int *debug_rule_len, u8 *debug_plain_ptr, int *debug_plain_len);
void save_hash (const user_options_t *user_options, const hashconfig_t *hashconfig, const hashes_t *hashes);
void check_hash (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, plain_t *plain);

4
include/outfile.h
Unescape View File

@ -10,6 +10,10 @@
#include <time.h>
#include <inttypes.h>
void build_plain (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, plain_t *plain, u32 *plain_buf, int *out_len);
void build_crackpos (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, plain_t *plain, u64 *out_pos);
void build_debugdata (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, plain_t *plain, u8 *debug_rule_buf, int *debug_rule_len, u8 *debug_plain_ptr, int *debug_plain_len);
void outfile_init (outfile_ctx_t *outfile_ctx, const user_options_t *user_options);
void outfile_destroy (outfile_ctx_t *outfile_ctx);
void outfile_format_plain (outfile_ctx_t *outfile_ctx, const unsigned char *plain_ptr, const u32 plain_len);

32
src/convert.c
Unescape View File

@ -7,6 +7,38 @@
#include "types.h"
#include "convert.h"
bool need_hexify (const u8 *buf, const int len)
{
for (int i = 0; i < len; i++)
{
const u8 c = buf[i];
if (c < 0x20) return true;
if (c > 0x7f) return true;
}
return false;
}
void exec_hexify (const u8 *buf, const int len, u8 *out)
{
for (int i = len - 1, j = i * 2; i >= 0; i -= 1, j -= 2)
{
const u8 v = buf[i];
u8 h0 = v >> 4 & 15;
u8 h1 = v >> 0 & 15;
u8 add;
h0 += 6; add = ((h0 & 0x10) >> 4) * 39; h0 += 42 + add;
h1 += 6; add = ((h1 & 0x10) >> 4) * 39; h1 += 42 + add;
out[j + 0] = h0;
out[j + 1] = h1;
}
}
bool is_valid_hex_char (const u8 c)
{
if ((c >= '0') && (c <= '9')) return true;

243
src/hashes.c
Unescape View File

@ -117,249 +117,6 @@ int sort_by_hash_no_salt (const void *v1, const void *v2, void *v3)
return sort_by_digest_p0p1 (d1, d2, v3);
}
void build_plain (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, plain_t *plain, u32 *plain_buf, int *out_len)
{
combinator_ctx_t *combinator_ctx = hashcat_ctx->combinator_ctx;
hashconfig_t *hashconfig = hashcat_ctx->hashconfig;
hashes_t *hashes = hashcat_ctx->hashes;
mask_ctx_t *mask_ctx = hashcat_ctx->mask_ctx;
opencl_ctx_t *opencl_ctx = hashcat_ctx->opencl_ctx;
straight_ctx_t *straight_ctx = hashcat_ctx->straight_ctx;
user_options_t *user_options = hashcat_ctx->user_options;
const u32 gidvid = plain->gidvid;
const u32 il_pos = plain->il_pos;
int plain_len = 0;
u8 *plain_ptr = (u8 *) plain_buf;
if (user_options->attack_mode == ATTACK_MODE_STRAIGHT)
{
pw_t pw;
gidd_to_pw_t (opencl_ctx, device_param, gidvid, &pw);
for (int i = 0; i < 16; i++)
{
plain_buf[i] = pw.i[i];
}
plain_len = (int) pw.pw_len;
const u32 off = device_param->innerloop_pos + il_pos;
plain_len = (int) apply_rules (straight_ctx->kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], (u32) plain_len);
if (plain_len > (int) hashconfig->pw_max) plain_len = (int) hashconfig->pw_max;
}
else if (user_options->attack_mode == ATTACK_MODE_COMBI)
{
pw_t pw;
gidd_to_pw_t (opencl_ctx, device_param, gidvid, &pw);
for (int i = 0; i < 16; i++)
{
plain_buf[i] = pw.i[i];
}
plain_len = (int) pw.pw_len;
char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
u32 comb_len = device_param->combs_buf[il_pos].pw_len;
if (combinator_ctx->combs_mode == COMBINATOR_MODE_BASE_LEFT)
{
memcpy (plain_ptr + plain_len, comb_buf, (size_t) comb_len);
}
else
{
memmove (plain_ptr + comb_len, plain_ptr, (size_t) plain_len);
memcpy (plain_ptr, comb_buf, comb_len);
}
plain_len += comb_len;
if (hashconfig->pw_max != PW_DICTMAX1)
{
if (plain_len > (int) hashconfig->pw_max) plain_len = (int) hashconfig->pw_max;
}
}
else if (user_options->attack_mode == ATTACK_MODE_BF)
{
u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
u32 l_start = device_param->kernel_params_mp_l_buf32[5];
u32 r_start = device_param->kernel_params_mp_r_buf32[5];
u32 l_stop = device_param->kernel_params_mp_l_buf32[4];
u32 r_stop = device_param->kernel_params_mp_r_buf32[4];
sp_exec (l_off, (char *) plain_ptr + l_start, mask_ctx->root_css_buf, mask_ctx->markov_css_buf, l_start, l_start + l_stop);
sp_exec (r_off, (char *) plain_ptr + r_start, mask_ctx->root_css_buf, mask_ctx->markov_css_buf, r_start, r_start + r_stop);
plain_len = (int) mask_ctx->css_cnt;
}
else if (user_options->attack_mode == ATTACK_MODE_HYBRID1)
{
pw_t pw;
gidd_to_pw_t (opencl_ctx, device_param, gidvid, &pw);
for (int i = 0; i < 16; i++)
{
plain_buf[i] = pw.i[i];
}
plain_len = (int) pw.pw_len;
u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
u32 start = 0;
u32 stop = device_param->kernel_params_mp_buf32[4];
sp_exec (off, (char *) plain_ptr + plain_len, mask_ctx->root_css_buf, mask_ctx->markov_css_buf, start, start + stop);
plain_len += start + stop;
if (hashconfig->pw_max != PW_DICTMAX1)
{
if (plain_len > (int) hashconfig->pw_max) plain_len = (int) hashconfig->pw_max;
}
}
else if (user_options->attack_mode == ATTACK_MODE_HYBRID2)
{
pw_t pw;
gidd_to_pw_t (opencl_ctx, device_param, gidvid, &pw);
for (int i = 0; i < 16; i++)
{
plain_buf[i] = pw.i[i];
}
plain_len = (int) pw.pw_len;
u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
u32 start = 0;
u32 stop = device_param->kernel_params_mp_buf32[4];
memmove (plain_ptr + stop, plain_ptr, plain_len);
sp_exec (off, (char *) plain_ptr, mask_ctx->root_css_buf, mask_ctx->markov_css_buf, start, start + stop);
plain_len += start + stop;
if (hashconfig->pw_max != PW_DICTMAX1)
{
if (plain_len > (int) hashconfig->pw_max) plain_len = (int) hashconfig->pw_max;
}
}
if (user_options->attack_mode == ATTACK_MODE_BF)
{
if (hashconfig->opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
{
if (hashconfig->opti_type & OPTI_TYPE_SINGLE_HASH)
{
if (hashconfig->opti_type & OPTI_TYPE_APPENDED_SALT)
{
plain_len = plain_len - hashes->salts_buf[0].salt_len;
}
}
if (hashconfig->opts_type & OPTS_TYPE_PT_UNICODE)
{
for (int i = 0, j = 0; i < plain_len; i += 2, j += 1)
{
plain_ptr[j] = plain_ptr[i];
}
plain_len = plain_len / 2;
}
}
}
*out_len = plain_len;
}
void build_crackpos (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, plain_t *plain, u64 *out_pos)
{
combinator_ctx_t *combinator_ctx = hashcat_ctx->combinator_ctx;
mask_ctx_t *mask_ctx = hashcat_ctx->mask_ctx;
straight_ctx_t *straight_ctx = hashcat_ctx->straight_ctx;
user_options_extra_t *user_options_extra = hashcat_ctx->user_options_extra;
const u32 gidvid = plain->gidvid;
const u32 il_pos = plain->il_pos;
u64 crackpos = device_param->words_off;
if (user_options_extra->attack_kern == ATTACK_KERN_STRAIGHT)
{
crackpos += gidvid;
crackpos *= straight_ctx->kernel_rules_cnt;
crackpos += device_param->innerloop_pos + il_pos;
}
else if (user_options_extra->attack_kern == ATTACK_KERN_COMBI)
{
crackpos += gidvid;
crackpos *= combinator_ctx->combs_cnt;
crackpos += device_param->innerloop_pos + il_pos;
}
else if (user_options_extra->attack_kern == ATTACK_MODE_BF)
{
crackpos += gidvid;
crackpos *= mask_ctx->bfs_cnt;
crackpos += device_param->innerloop_pos + il_pos;
}
*out_pos = crackpos;
}
void build_debugdata (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, plain_t *plain, u8 *debug_rule_buf, int *debug_rule_len, u8 *debug_plain_ptr, int *debug_plain_len)
{
debugfile_ctx_t *debugfile_ctx = hashcat_ctx->debugfile_ctx;
opencl_ctx_t *opencl_ctx = hashcat_ctx->opencl_ctx;
straight_ctx_t *straight_ctx = hashcat_ctx->straight_ctx;
user_options_t *user_options = hashcat_ctx->user_options;
const u32 gidvid = plain->gidvid;
const u32 il_pos = plain->il_pos;
if (user_options->attack_mode != ATTACK_MODE_STRAIGHT) return;
const u32 debug_mode = debugfile_ctx->mode;
if (debug_mode == 0) return;
pw_t pw;
gidd_to_pw_t (opencl_ctx, device_param, gidvid, &pw);
int plain_len = (int) pw.pw_len;
const u32 off = device_param->innerloop_pos + il_pos;
// save rule
if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
{
*debug_rule_len = kernel_rule_to_cpu_rule ((char *) debug_rule_buf, &straight_ctx->kernel_rules_buf[off]);
}
// save plain
if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
{
memcpy (debug_plain_ptr, (char *) pw.i, (size_t) plain_len);
*debug_plain_len = plain_len;
}
}
void save_hash (const user_options_t *user_options, const hashconfig_t *hashconfig, const hashes_t *hashes)
{
char *hashfile = hashes->hashfile;

4
src/opencl.c
Unescape View File

@ -1034,6 +1034,10 @@ int run_cracker (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, co
+ device_param->kernel_params_mp_l_buf32[5];
}
// we make use of this in status view
device_param->outerloop_left = pws_cnt;
// loop start: most outer loop = salt iteration, then innerloops (if multi)
for (u32 salt_pos = 0; salt_pos < hashes->salts_cnt; salt_pos++)

247
src/outfile.c
Unescape View File

@ -9,8 +9,255 @@
#include "logging.h"
#include "interface.h"
#include "hashes.h"
#include "mpsp.h"
#include "rp.h"
#include "rp_kernel_on_cpu.h"
#include "opencl.h"
#include "outfile.h"
void build_plain (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, plain_t *plain, u32 *plain_buf, int *out_len)
{
combinator_ctx_t *combinator_ctx = hashcat_ctx->combinator_ctx;
hashconfig_t *hashconfig = hashcat_ctx->hashconfig;
hashes_t *hashes = hashcat_ctx->hashes;
mask_ctx_t *mask_ctx = hashcat_ctx->mask_ctx;
opencl_ctx_t *opencl_ctx = hashcat_ctx->opencl_ctx;
straight_ctx_t *straight_ctx = hashcat_ctx->straight_ctx;
user_options_t *user_options = hashcat_ctx->user_options;
const u32 gidvid = plain->gidvid;
const u32 il_pos = plain->il_pos;
int plain_len = 0;
u8 *plain_ptr = (u8 *) plain_buf;
if (user_options->attack_mode == ATTACK_MODE_STRAIGHT)
{
pw_t pw;
gidd_to_pw_t (opencl_ctx, device_param, gidvid, &pw);
for (int i = 0; i < 16; i++)
{
plain_buf[i] = pw.i[i];
}
plain_len = (int) pw.pw_len;
const u32 off = device_param->innerloop_pos + il_pos;
plain_len = (int) apply_rules (straight_ctx->kernel_rules_buf[off].cmds, &plain_buf[0], &plain_buf[4], (u32) plain_len);
if (plain_len > (int) hashconfig->pw_max) plain_len = (int) hashconfig->pw_max;
}
else if (user_options->attack_mode == ATTACK_MODE_COMBI)
{
pw_t pw;
gidd_to_pw_t (opencl_ctx, device_param, gidvid, &pw);
for (int i = 0; i < 16; i++)
{
plain_buf[i] = pw.i[i];
}
plain_len = (int) pw.pw_len;
char *comb_buf = (char *) device_param->combs_buf[il_pos].i;
u32 comb_len = device_param->combs_buf[il_pos].pw_len;
if (combinator_ctx->combs_mode == COMBINATOR_MODE_BASE_LEFT)
{
memcpy (plain_ptr + plain_len, comb_buf, (size_t) comb_len);
}
else
{
memmove (plain_ptr + comb_len, plain_ptr, (size_t) plain_len);
memcpy (plain_ptr, comb_buf, comb_len);
}
plain_len += comb_len;
if (hashconfig->pw_max != PW_DICTMAX1)
{
if (plain_len > (int) hashconfig->pw_max) plain_len = (int) hashconfig->pw_max;
}
}
else if (user_options->attack_mode == ATTACK_MODE_BF)
{
u64 l_off = device_param->kernel_params_mp_l_buf64[3] + gidvid;
u64 r_off = device_param->kernel_params_mp_r_buf64[3] + il_pos;
u32 l_start = device_param->kernel_params_mp_l_buf32[5];
u32 r_start = device_param->kernel_params_mp_r_buf32[5];
u32 l_stop = device_param->kernel_params_mp_l_buf32[4];
u32 r_stop = device_param->kernel_params_mp_r_buf32[4];
sp_exec (l_off, (char *) plain_ptr + l_start, mask_ctx->root_css_buf, mask_ctx->markov_css_buf, l_start, l_start + l_stop);
sp_exec (r_off, (char *) plain_ptr + r_start, mask_ctx->root_css_buf, mask_ctx->markov_css_buf, r_start, r_start + r_stop);
plain_len = (int) mask_ctx->css_cnt;
}
else if (user_options->attack_mode == ATTACK_MODE_HYBRID1)
{
pw_t pw;
gidd_to_pw_t (opencl_ctx, device_param, gidvid, &pw);
for (int i = 0; i < 16; i++)
{
plain_buf[i] = pw.i[i];
}
plain_len = (int) pw.pw_len;
u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
u32 start = 0;
u32 stop = device_param->kernel_params_mp_buf32[4];
sp_exec (off, (char *) plain_ptr + plain_len, mask_ctx->root_css_buf, mask_ctx->markov_css_buf, start, start + stop);
plain_len += start + stop;
if (hashconfig->pw_max != PW_DICTMAX1)
{
if (plain_len > (int) hashconfig->pw_max) plain_len = (int) hashconfig->pw_max;
}
}
else if (user_options->attack_mode == ATTACK_MODE_HYBRID2)
{
pw_t pw;
gidd_to_pw_t (opencl_ctx, device_param, gidvid, &pw);
for (int i = 0; i < 16; i++)
{
plain_buf[i] = pw.i[i];
}
plain_len = (int) pw.pw_len;
u64 off = device_param->kernel_params_mp_buf64[3] + il_pos;
u32 start = 0;
u32 stop = device_param->kernel_params_mp_buf32[4];
memmove (plain_ptr + stop, plain_ptr, plain_len);
sp_exec (off, (char *) plain_ptr, mask_ctx->root_css_buf, mask_ctx->markov_css_buf, start, start + stop);
plain_len += start + stop;
if (hashconfig->pw_max != PW_DICTMAX1)
{
if (plain_len > (int) hashconfig->pw_max) plain_len = (int) hashconfig->pw_max;
}
}
if (user_options->attack_mode == ATTACK_MODE_BF)
{
if (hashconfig->opti_type & OPTI_TYPE_BRUTE_FORCE) // lots of optimizations can happen here
{
if (hashconfig->opti_type & OPTI_TYPE_SINGLE_HASH)
{
if (hashconfig->opti_type & OPTI_TYPE_APPENDED_SALT)
{
plain_len = plain_len - hashes->salts_buf[0].salt_len;
}
}
if (hashconfig->opts_type & OPTS_TYPE_PT_UNICODE)
{
for (int i = 0, j = 0; i < plain_len; i += 2, j += 1)
{
plain_ptr[j] = plain_ptr[i];
}
plain_len = plain_len / 2;
}
}
}
*out_len = plain_len;
}
void build_crackpos (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, plain_t *plain, u64 *out_pos)
{
combinator_ctx_t *combinator_ctx = hashcat_ctx->combinator_ctx;
mask_ctx_t *mask_ctx = hashcat_ctx->mask_ctx;
straight_ctx_t *straight_ctx = hashcat_ctx->straight_ctx;
user_options_extra_t *user_options_extra = hashcat_ctx->user_options_extra;
const u32 gidvid = plain->gidvid;
const u32 il_pos = plain->il_pos;
u64 crackpos = device_param->words_off;
if (user_options_extra->attack_kern == ATTACK_KERN_STRAIGHT)
{
crackpos += gidvid;
crackpos *= straight_ctx->kernel_rules_cnt;
crackpos += device_param->innerloop_pos + il_pos;
}
else if (user_options_extra->attack_kern == ATTACK_KERN_COMBI)
{
crackpos += gidvid;
crackpos *= combinator_ctx->combs_cnt;
crackpos += device_param->innerloop_pos + il_pos;
}
else if (user_options_extra->attack_kern == ATTACK_MODE_BF)
{
crackpos += gidvid;
crackpos *= mask_ctx->bfs_cnt;
crackpos += device_param->innerloop_pos + il_pos;
}
*out_pos = crackpos;
}
void build_debugdata (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, plain_t *plain, u8 *debug_rule_buf, int *debug_rule_len, u8 *debug_plain_ptr, int *debug_plain_len)
{
debugfile_ctx_t *debugfile_ctx = hashcat_ctx->debugfile_ctx;
opencl_ctx_t *opencl_ctx = hashcat_ctx->opencl_ctx;
straight_ctx_t *straight_ctx = hashcat_ctx->straight_ctx;
user_options_t *user_options = hashcat_ctx->user_options;
const u32 gidvid = plain->gidvid;
const u32 il_pos = plain->il_pos;
if (user_options->attack_mode != ATTACK_MODE_STRAIGHT) return;
const u32 debug_mode = debugfile_ctx->mode;
if (debug_mode == 0) return;
pw_t pw;
gidd_to_pw_t (opencl_ctx, device_param, gidvid, &pw);
int plain_len = (int) pw.pw_len;
const u32 off = device_param->innerloop_pos + il_pos;
// save rule
if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))
{
*debug_rule_len = kernel_rule_to_cpu_rule ((char *) debug_rule_buf, &straight_ctx->kernel_rules_buf[off]);
}
// save plain
if ((debug_mode == 2) || (debug_mode == 3) || (debug_mode == 4))
{
memcpy (debug_plain_ptr, (char *) pw.i, (size_t) plain_len);
*debug_plain_len = plain_len;
}
}
void outfile_init (outfile_ctx_t *outfile_ctx, const user_options_t *user_options)
{
if (user_options->outfile == NULL)

1
src/rp_kernel_on_cpu.c
Unescape View File

@ -9,6 +9,7 @@
#include "common.h"
#include "types.h"
#include "bitops.h"
#include "rp.h"
#include "rp_kernel_on_cpu.h"
u32 swap_workaround (const u32 n)

69
src/status.c
Unescape View File

@ -7,11 +7,13 @@
#include "types.h"
#include "memory.h"
#include "logging.h"
#include "convert.h"
#include "restore.h"
#include "thread.h"
#include "timer.h"
#include "interface.h"
#include "hwmon.h"
#include "outfile.h"
#include "status.h"
static const char ST_0000[] = "Initializing";
@ -164,6 +166,13 @@ void status_display_machine_readable (hashcat_ctx_t *hashcat_ctx)
return;
}
if (status_ctx->devices_status == STATUS_AUTOTUNE)
{
log_error ("ERROR: status view is not available during autotune phase");
return;
}
FILE *out = stdout;
fprintf (out, "STATUS\t%u\t", status_ctx->devices_status);
@ -326,6 +335,13 @@ void status_display (hashcat_ctx_t *hashcat_ctx)
return;
}
if (status_ctx->devices_status == STATUS_AUTOTUNE)
{
log_error ("ERROR: status view is not available during autotune phase");
return;
}
// in this case some required buffers are free'd, ascii_digest() would run into segfault
if (status_ctx->shutdown_inner == 1) return;
@ -859,7 +875,44 @@ void status_display (hashcat_ctx_t *hashcat_ctx)
if (device_param->skipped) continue;
// log_info ("Plain.Txt.#%d...: xxx", device_id + 1);
const u32 outerloop_first = 0;
const u32 outerloop_last = (device_param->outerloop_left) ? device_param->outerloop_left - 1 : 0;
const u32 innerloop_first = 0;
const u32 innerloop_last = (device_param->innerloop_left) ? device_param->innerloop_left - 1 : 0;
plain_t plain1 = { 0, 0, 0, outerloop_first, innerloop_first };
plain_t plain2 = { 0, 0, 0, outerloop_last, innerloop_last };
u32 plain_buf1[16] = { 0 };
u32 plain_buf2[16] = { 0 };
u8 *plain_ptr1 = (u8 *) plain_buf1;
u8 *plain_ptr2 = (u8 *) plain_buf2;
int plain_len1 = 0;
int plain_len2 = 0;
build_plain (hashcat_ctx, device_param, &plain1, plain_buf1, &plain_len1);
build_plain (hashcat_ctx, device_param, &plain2, plain_buf2, &plain_len2);
bool need_hex1 = need_hexify (plain_ptr1, plain_len1);
bool need_hex2 = need_hexify (plain_ptr2, plain_len2);
if ((need_hex1 == true) || (need_hex2 == true))
{
exec_hexify (plain_ptr1, plain_len1, plain_ptr1);
exec_hexify (plain_ptr2, plain_len2, plain_ptr2);
plain_ptr1[plain_len1 * 2] = 0;
plain_ptr2[plain_len2 * 2] = 0;
log_info ("Guess.Pass.#%d..: $HEX[%s] -> $HEX[%s]", device_id + 1, plain_ptr1, plain_ptr2);
}
else
{
log_info ("Guess.Pass.#%d..: %s -> %s", device_id + 1, plain_ptr1, plain_ptr2);
}
}
for (u32 device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++)
@ -1123,6 +1176,13 @@ void status_benchmark_automate (hashcat_ctx_t *hashcat_ctx)
return;
}
if (status_ctx->devices_status == STATUS_AUTOTUNE)
{
log_error ("ERROR: status view is not available during autotune phase");
return;
}
u64 speed_cnt[DEVICES_MAX] = { 0 };
double speed_ms[DEVICES_MAX] = { 0 };
@ -1175,6 +1235,13 @@ void status_benchmark (hashcat_ctx_t *hashcat_ctx)
return;
}
if (status_ctx->devices_status == STATUS_AUTOTUNE)
{
log_error ("ERROR: status view is not available during autotune phase");
return;
}
if (status_ctx->shutdown_inner == 1) return;
if (user_options->machine_readable == true)

Write Preview
Loading…
Cancel
Save