snprintf (cached_file, 255, "%s/kernels/amp_a%d.%s.kernel", profile_dir, attack_kern, device_name_chksum);
}
+static char *filename_from_filepath (char *filepath)
+{
+ char *ptr = NULL;
+
+ if ((ptr = strrchr (filepath, '/')) != NULL)
+ {
+ ptr++;
+ }
+ else if ((ptr = strrchr (filepath, '\\')) != NULL)
+ {
+ ptr++;
+ }
+ else
+ {
+ ptr = filepath;
+ }
+
+ return ptr;
+}
+
static uint convert_from_hex (char *line_buf, const uint line_len)
{
if (line_len & 1) return (line_len); // not in hex
}
}
+// stolen from princeprocessor ;)
+
+typedef struct
+{
+ FILE *fp;
+
+ char buf[BUFSIZ];
+ int len;
+
+} out_t;
+
+static void out_flush (out_t *out)
+{
+ fwrite (out->buf, 1, out->len, out->fp);
+
+ out->len = 0;
+}
+
+static void out_push (out_t *out, const u8 *pw_buf, const int pw_len)
+{
+ char *ptr = out->buf + out->len;
+
+ memcpy (ptr, pw_buf, pw_len);
+
+ ptr[pw_len] = '\n';
+
+ out->len += pw_len + 1;
+
+ if (out->len >= BUFSIZ - 100)
+ {
+ out_flush (out);
+ }
+}
+
static void process_stdout (hc_device_param_t *device_param, const uint pws_cnt)
{
- char out_buf[HCBUFSIZ] = { 0 };
+ out_t out;
+
+ out.fp = stdout;
+ out.len = 0;
uint plain_buf[16] = { 0 };
if (plain_len > data.pw_max) plain_len = data.pw_max;
- format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
+ out_push (&out, plain_ptr, plain_len);
}
}
}
if (plain_len > data.pw_max) plain_len = data.pw_max;
}
- format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
+ out_push (&out, plain_ptr, plain_len);
}
}
}
plain_len = data.css_cnt;
- format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
+ out_push (&out, plain_ptr, plain_len);
}
}
}
plain_len += start + stop;
- format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
+ out_push (&out, plain_ptr, plain_len);
}
}
}
plain_len += start + stop;
- format_output (stdout, out_buf, plain_ptr, plain_len, 0, NULL, 0);
+ out_push (&out, plain_ptr, plain_len);
}
}
}
+
+ out_flush (&out);
}
static void save_hash ()
{
clear_prompt ();
- log_info ("Device #%u: autotuned kernel-accel to %u\n"
- "Device #%u: autotuned kernel-loops to %u\n",
+ log_info ("- Device #%u: autotuned kernel-accel to %u\n"
+ "- Device #%u: autotuned kernel-loops to %u\n",
device_param->device_id + 1, kernel_accel,
device_param->device_id + 1, kernel_loops);
{
if (outfile_format > 1)
{
- log_error ("ERROR: Mixing outfile-format > 1 is not allowed together with left parameter");
+ log_error ("ERROR: Mixing outfile-format > 1 with left parameter is not allowed");
return (-1);
}
{
if ((outfile_format > 7) && (outfile_format < 16))
{
- log_error ("ERROR: Mixing outfile-format > 7 is not allowed together with show parameter");
+ log_error ("ERROR: Mixing outfile-format > 7 with show parameter is not allowed");
return (-1);
}
if ((increment == 1) && (attack_mode == ATTACK_MODE_STRAIGHT))
{
- log_error ("ERROR: increment is not allowed in attack-mode 0");
+ log_error ("ERROR: Increment is not allowed in attack-mode 0");
return (-1);
}
if ((increment == 0) && (increment_min_chgd == 1))
{
- log_error ("ERROR: increment-min is only supported together with increment switch");
+ log_error ("ERROR: Increment-min is only supported combined with increment switch");
return (-1);
}
if ((increment == 0) && (increment_max_chgd == 1))
{
- log_error ("ERROR: increment-max is only supported together with increment switch");
+ log_error ("ERROR: Increment-max is only supported combined with increment switch");
return (-1);
}
{
if (show == 1)
{
- log_error ("ERROR: Mixing show parameter not supported with keyspace parameter");
+ log_error ("ERROR: Combining show parameter with keyspace parameter is not allowed");
return (-1);
}
else if (left == 1)
{
- log_error ("ERROR: Mixing left parameter not supported wiht keyspace parameter");
+ log_error ("ERROR: Combining left parameter with keyspace parameter is not allowed");
return (-1);
}
kernel_loops = 1024;
force = 1;
outfile_check_timer = 0;
+ session = "stdout";
+ opencl_vector_width = 1;
}
if (remove_timer_chgd == 1)
salt_type = SALT_TYPE_NONE;
attack_exec = ATTACK_EXEC_INSIDE_KERNEL;
opts_type = OPTS_TYPE_PT_GENERATE_LE;
- kern_type = 0;
+ kern_type = KERN_TYPE_STDOUT;
dgst_size = DGST_SIZE_4_4;
parse_func = NULL;
sort_by_digest = NULL;
if (hash_fmt_error)
{
- log_info ("WARNING: failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
+ log_info ("WARNING: Failed to parse hashes using the '%s' format", strhlfmt (hashlist_format));
}
else
{
if (parser_status < PARSER_GLOBAL_ZERO)
{
- log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
+ log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
continue;
}
if (parser_status < PARSER_GLOBAL_ZERO)
{
- log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
+ log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
continue;
}
if (parser_status < PARSER_GLOBAL_ZERO)
{
- log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
+ log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
continue;
}
if (parser_status < PARSER_GLOBAL_ZERO)
{
- log_info ("WARNING: Hashfile '%s' in line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
+ log_info ("WARNING: Hashfile '%s' on line %u (%s): %s", data.hashfile, line_num, line_buf, strparser (parser_status));
continue;
}
if (result == -1)
{
- log_info ("WARNING: Skipping invalid or unsupported rule in file %s in line %u: %s", rp_file, rule_line, rule_buf);
+ log_info ("WARNING: Skipping invalid or unsupported rule in file %s on line %u: %s", rp_file, rule_line, rule_buf);
continue;
}
if (cpu_rule_to_kernel_rule (rule_buf, rule_len, &kernel_rules_buf[kernel_rules_cnt]) == -1)
{
- log_info ("WARNING: Cannot convert rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf);
+ log_info ("WARNING: Cannot convert rule for use on device in file %s on line %u: %s", rp_file, rule_line, rule_buf);
memset (&kernel_rules_buf[kernel_rules_cnt], 0, sizeof (kernel_rule_t)); // needs to be cleared otherwise we could have some remaining data
}
}
- /**
- * OpenCL device types:
- * In case the user did not specify --opencl-device-types and the user runs hashcat in a system with only a CPU only he probably want to use that CPU.
- * In such a case, automatically enable CPU device type support, since it's disabled by default.
- */
-
if (opencl_device_types == NULL)
{
+ /**
+ * OpenCL device types:
+ * In case the user did not specify --opencl-device-types and the user runs hashcat in a system with only a CPU only he probably want to use that CPU.
+ */
+
cl_device_type device_types_all = 0;
for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
}
}
+ // In such a case, automatically enable CPU device type support, since it's disabled by default.
+
if ((device_types_all & (CL_DEVICE_TYPE_GPU | CL_DEVICE_TYPE_ACCELERATOR)) == 0)
{
device_types_filter |= CL_DEVICE_TYPE_CPU;
}
+
+ // In another case, when the user uses --stdout, using CPU devices is much faster to setup
+ // If we have a CPU device, force it to be used
+
+ if (stdout_flag == 1)
+ {
+ if (device_types_all & CL_DEVICE_TYPE_CPU)
+ {
+ device_types_filter = CL_DEVICE_TYPE_CPU;
+ }
+ }
}
/**
for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++)
{
- if ((opencl_platforms_filter & (1 << platform_id)) == 0) continue;
-
cl_platform_id platform = platforms[platform_id];
hc_clGetDeviceIDs (data.ocl, platform, CL_DEVICE_TYPE_ALL, DEVICES_MAX, platform_devices, &platform_devices_cnt);
platform_vendor_id = VENDOR_ID_GENERIC;
}
+ const uint platform_skipped = ((opencl_platforms_filter & (1 << platform_id)) == 0);
+
+ if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
+ {
+ if (machine_readable == 0)
+ {
+ if (platform_skipped == 0)
+ {
+ const int len = log_info ("OpenCL Platform #%u: %s", platform_id + 1, platform_vendor);
+
+ char line[256] = { 0 };
+
+ for (int i = 0; i < len; i++) line[i] = '=';
+
+ log_info (line);
+ }
+ else
+ {
+ log_info ("OpenCL Platform #%u: %s, skipped", platform_id + 1, platform_vendor);
+ log_info ("");
+ }
+ }
+ }
+
+ if (platform_skipped == 1) continue;
+
for (uint platform_devices_id = 0; platform_devices_id < platform_devices_cnt; platform_devices_id++)
{
size_t param_value_size = 0;
if (device_endian_little == CL_FALSE)
{
- log_info ("Device #%u: WARNING: not little endian device", device_id + 1);
+ log_info ("- Device #%u: WARNING: Not a little endian device", device_id + 1);
device_param->skipped = 1;
}
if (device_available == CL_FALSE)
{
- log_info ("Device #%u: WARNING: device not available", device_id + 1);
+ log_info ("- Device #%u: WARNING: Device not available", device_id + 1);
device_param->skipped = 1;
}
if (device_compiler_available == CL_FALSE)
{
- log_info ("Device #%u: WARNING: device no compiler available", device_id + 1);
+ log_info ("- Device #%u: WARNING: No compiler available for device", device_id + 1);
device_param->skipped = 1;
}
if ((device_execution_capabilities & CL_EXEC_KERNEL) == 0)
{
- log_info ("Device #%u: WARNING: device does not support executing kernels", device_id + 1);
+ log_info ("- Device #%u: WARNING: Device does not support executing kernels", device_id + 1);
device_param->skipped = 1;
}
if (strstr (device_extensions, "base_atomics") == 0)
{
- log_info ("Device #%u: WARNING: device does not support base atomics", device_id + 1);
+ log_info ("- Device #%u: WARNING: Device does not support base atomics", device_id + 1);
device_param->skipped = 1;
}
if (strstr (device_extensions, "byte_addressable_store") == 0)
{
- log_info ("Device #%u: WARNING: device does not support byte addressable store", device_id + 1);
+ log_info ("- Device #%u: WARNING: Device does not support byte addressable store", device_id + 1);
device_param->skipped = 1;
}
if (device_local_mem_size < 32768)
{
- log_info ("Device #%u: WARNING: device local mem size is too small", device_id + 1);
+ log_info ("- Device #%u: WARNING: Device local mem size is too small", device_id + 1);
device_param->skipped = 1;
}
{
if (algorithm_pos == 0)
{
- log_info ("Device #%u: WARNING: not native intel opencl runtime, expect massive speed loss", device_id + 1);
- log_info (" You can use --force to override this but do not post error reports if you do so");
+ log_info ("- Device #%u: WARNING: Not a native intel opencl runtime, expect massive speed loss", device_id + 1);
+ log_info (" You can use --force to override this but do not post error reports if you do so");
}
device_param->skipped = 1;
{
if (device_param->skipped == 0)
{
- log_info ("Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
+ log_info ("- Device #%u: %s, %lu/%lu MB allocatable, %uMCU",
device_id + 1,
device_name,
(unsigned int) (device_maxmem_alloc / 1024 / 1024),
}
else
{
- log_info ("Device #%u: %s, skipped",
+ log_info ("- Device #%u: %s, skipped",
device_id + 1,
device_name);
}
if (catalyst_broken == 1)
{
log_info ("");
- log_info ("ATTENTION! The installed catalyst driver in your system is known to be broken!");
- log_info ("It will pass over cracked hashes and does not report them as cracked");
+ log_info ("ATTENTION! The Catalyst driver installed on your system is known to be broken!");
+ log_info ("It passes over cracked hashes and will not report them as cracked");
log_info ("You are STRONGLY encouraged not to use it");
log_info ("You can use --force to override this but do not post error reports if you do so");
log_info ("");
if (catalyst_warn == 1)
{
log_info ("");
- log_info ("ATTENTION! Unsupported or incorrect installed catalyst driver detected!");
- log_info ("You are STRONGLY encouraged to use the official supported catalyst driver for good reasons");
+ log_info ("ATTENTION! Unsupported or incorrectly installed Catalyst driver detected!");
+ log_info ("You are STRONGLY encouraged to use the official supported catalyst driver");
log_info ("See hashcat's homepage for official supported catalyst drivers");
#ifdef _WIN
log_info ("Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
{
if (device_param->kernel_exec_timeout != 0)
{
- if (data.quiet == 0) log_info ("Device #%u: WARNING! Kernel exec timeout is not disabled, it might cause you errors of code 702", device_id + 1);
- if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
+ if (data.quiet == 0) log_info ("- Device #%u: WARNING! Kernel exec timeout is not disabled, it might cause you errors of code 702", device_id + 1);
+ if (data.quiet == 0) log_info (" See the wiki on how to disable it: https://hashcat.net/wiki/doku.php?id=timeout_patch");
}
}
}
devices_cnt++;
}
+
+ if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
+ {
+ if (machine_readable == 0)
+ {
+ log_info ("");
+ }
+ }
}
if (keyspace == 0 && devices_active == 0)
data.devices_active = devices_active;
- if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0))
- {
- if (machine_readable == 0)
- {
- log_info ("");
- }
- }
-
/**
* HM devices: init
*/
{
if (gpu_temp_abort < gpu_temp_retain)
{
- log_error ("ERROR: invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
+ log_error ("ERROR: Invalid values for gpu-temp-abort. Parameter gpu-temp-abort is less than gpu-temp-retain.");
return (-1);
}
if ((engine_clock_max - engine_clock_profile_max) > warning_trigger_engine)
{
- log_info ("WARN: the custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
+ log_info ("WARN: The custom profile seems to have too low maximum engine clock values. You therefore may not reach full performance");
}
if ((memory_clock_max - memory_clock_profile_max) > warning_trigger_memory)
{
- log_info ("WARN: the custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
+ log_info ("WARN: The custom profile seems to have too low maximum memory clock values. You therefore may not reach full performance");
}
ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel));
if (size_scryptV > device_param->device_maxmem_alloc)
{
- if (quiet == 0) log_info ("WARNING: not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
+ if (quiet == 0) log_info ("WARNING: Not enough device memory allocatable to use --scrypt-tmto %d, increasing...", tmto);
continue;
}
if (data.salts_buf[0].scrypt_phy == 0)
{
- log_error ("ERROR: can't allocate enough device memory");
+ log_error ("ERROR: Can't allocate enough device memory");
return -1;
}
/*
if (kernel_accel_max == 0)
{
- log_error ("Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
+ log_error ("- Device #%u: Device does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
return -1;
}
/*
if (kernel_accel_max < kernel_accel)
{
- if (quiet == 0) log_info ("Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
+ if (quiet == 0) log_info ("- Device #%u: Reduced maximum kernel-accel to %u", device_id + 1, kernel_accel_max);
device_param->kernel_accel = kernel_accel_max;
}
*/
#ifdef DEBUG
- log_info ("Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
+ log_info ("- Device #%u: build_opts '%s'\n", device_id + 1, build_opts);
#endif
/**
{
if (cached == 0)
{
- if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
+ if (quiet == 0) log_info ("- Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, filename_from_filepath (cached_file));
load_kernel (source_file, 1, kernel_lengths, kernel_sources);
{
device_param->skipped = true;
- log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
+ log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
continue;
}
else
{
#ifdef DEBUG
- log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
+ log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
#endif
load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
else
{
#ifdef DEBUG
- log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
+ log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, source_file, sst.st_size);
#endif
load_kernel (source_file, 1, kernel_lengths, kernel_sources);
{
device_param->skipped = true;
- log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
+ log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
}
}
if (cached == 0)
{
- if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
+ if (quiet == 0) log_info ("- Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, filename_from_filepath (cached_file));
if (quiet == 0) log_info ("");
load_kernel (source_file, 1, kernel_lengths, kernel_sources);
{
device_param->skipped = true;
- log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
+ log_info ("- Device #%u: Kernel %s build failure. Proceeding without this device.", device_id + 1, source_file);
continue;
}
else
{
#ifdef DEBUG
- log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
+ log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
#endif
load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
if (cached == 0)
{
- if (quiet == 0) log_info ("Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, cached_file);
+ if (quiet == 0) log_info ("- Device #%u: Kernel %s not found in cache! Building may take a while...", device_id + 1, filename_from_filepath (cached_file));
if (quiet == 0) log_info ("");
load_kernel (source_file, 1, kernel_lengths, kernel_sources);
{
device_param->skipped = true;
- log_info ("Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
+ log_info ("- Device #%u: Kernel %s build failure. Proceed without this device.", device_id + 1, source_file);
continue;
}
else
{
#ifdef DEBUG
- if (quiet == 0) log_info ("Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
+ if (quiet == 0) log_info ("- Device #%u: Kernel %s (%ld bytes)", device_id + 1, cached_file, cst.st_size);
#endif
load_kernel (cached_file, 1, kernel_lengths, kernel_sources);
if (keyspace == 1)
{
- log_error ("ERROR: keyspace parameter is not allowed together with a directory");
+ log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
return (-1);
}
if (keyspace == 1)
{
- log_error ("ERROR: keyspace parameter is not allowed together with a directory");
+ log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
return (-1);
}
if (keyspace == 1)
{
- log_error ("ERROR: keyspace parameter is not allowed together with a directory");
+ log_error ("ERROR: Keyspace parameter is not allowed together with a directory");
return (-1);
}
{
if (potfile_remove_cracks > 0)
{
- if (potfile_remove_cracks == 1) log_info ("INFO: removed 1 hash found in pot file\n");
- else log_info ("INFO: removed %u hashes found in pot file\n", potfile_remove_cracks);
+ if (potfile_remove_cracks == 1) log_info ("INFO: Removed 1 hash found in pot file\n");
+ else log_info ("INFO: Removed %u hashes found in pot file\n", potfile_remove_cracks);
}
}
{
if (css_cnt < mask_min)
{
- log_info ("WARNING: skipping mask '%s' because it is smaller than the minimum password length", mask);
+ log_info ("WARNING: Skipping mask '%s' because it is smaller than the minimum password length", mask);
}
if (css_cnt > mask_max)
{
- log_info ("WARNING: skipping mask '%s' because it is larger than the maximum password length", mask);
+ log_info ("WARNING: Skipping mask '%s' because it is larger than the maximum password length", mask);
}
// skip to next mask
if (data.words_cur > data.words_base)
{
- log_error ("ERROR: restore value greater keyspace");
+ log_error ("ERROR: Restore value greater keyspace");
return (-1);
}