arno/hashcat
1
0
Fork 0
mirror of https://github.com/hashcat/hashcat.git synced 2025-03-06 10:06:06 +00:00
Code Issues Releases Wiki Activity

Update OpenCL runtime- and driver-requirements

Browse Source 
Update changes.txt
This commit is contained in:
jsteube 2016-11-11 13:10:24 +01:00
parent 4d9cb462a9
commit 80a4f234f5
3 changed files with 161 additions and 85 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
docs/changes.txt
View File

@ -1,35 +1,47 @@
* changes v3.00 -> v3.xx: * changes v3.10 -> v3.xx:
## ##
## Improvements ## Features
## ##
- Added support for --speed-only: quickly shows expected speed per device based on the users hash(es) and option selected - New option --speed-only: quickly shows expected speed per device based on the users hash(es) and option selected
- Added the current first and last password candidate test queued for execution per device on status view - New option --keep-guessing to continue cracking hashes even after they have been cracked (to find collisions)
- Use .gitmodules to handle OpenCL headers depency - Status view: Show the current first and last password candidate test queued for execution per device
- Allow loading of bcrypt hashes with signature $2b$ (February 2014) - Status view: Show the current position of the queue in use
- Replaced some uint macros with enums types - Status view: Show the base and modifier keyspace currently in use
- Abort session after NUM seconds of --runtime but do not count time in pause mode - Status view: Show core-clock and memory-clock in benchmark-mode in case --machine-readable is set
- Added docs/credits.txt - Hardware management: Support temperature, clock and fanspeed readings for AMDGPU-Pro Driver
- Added docs/team.txt - Hardware management: Support --gpu-temp-retain for AMDGPU-Pro Driver
- Allow words of length > 32 in wordlists for -a 0 for slow hashes if no rules are in use or a : rule is in the rulefile - Hardware management: Support --powertune-enable for AMDGPU-Pro Driver
- Reduce max. number of allowed function calls per rule from 256 to 32 to save GPU memory
- Status display shows what's the base and modifier keyspace currently in use ##
- Added a workaround for some OpenCL kernel to compile with amd-gpu-pro ## Bugs
- Added hardware management support (temperature, clocks, fans) for AMD-GPU-PRO driver ##
- Added support for --powertune-enable for AMD-GPU-PRO driver
- Added option --keep-guessing to continue cracking hashes even after they have been cracked (to find collisions) - Fixed a bug when cracking a large salted hashlist status view showed 0H/s but progress counter increased
- Fixed a bug when cracking a large salted hashlist: If a word is rejected this produces so high CPU load that cracking process doesn't start
- Added core-clock and memory-clock to output in benchmark mode with --machine-readable enabled
## ##
## Algorithms ## Algorithms
## ##
- Reduce maximum number of allowed function calls per rule from 256 to 32 to save device memory
- Workaround for some OpenCL kernels to compile with AMDGPU-Pro Driver
- Allow words of length > 32 in wordlists for -a 0 for some slow hashes if no rules are in use
- Allow loading of bcrypt hashes with signature $2b$ (February 2014)
- Added new hash-mode 14000 = DES (PT = $salt, key = $pass) - Added new hash-mode 14000 = DES (PT = $salt, key = $pass)
- Added new hash-mode 14100 = 3DES (PT = $salt, key = $pass) - Added new hash-mode 14100 = 3DES (PT = $salt, key = $pass)
- Added new hash-mode 99999 = Plaintext - Added new hash-mode 99999 = Plaintext
##
## Technical
##
- Use .gitmodules to handle OpenCL headers depency
- Abort session after NUM seconds of --runtime but do not count time in pause mode
- Added docs/credits.txt
- Added docs/team.txt
- Replaced some uint macros with enums types
* changes v3.00 -> v3.10: * changes v3.00 -> v3.10:
## ##

9
docs/readme.txt
View File

@ -1,9 +1,12 @@
hashcat v3.10 hashcat v3.10
============= =============
AMD users require AMD drivers 14.9 or later (recommended 15.12) AMD users on Windows require "AMD Radeon Software Crimson Edition" (15.12 or later)
Intel users require Intel OpenCL Runtime 14.2 or later (recommended 16.1 or later) AMD users on Linux require "AMDGPU-Pro Driver" (16.40 or later)
NVidia users require NVidia drivers 346.59 or later (recommended 367.27 or later) Intel CPU users require "OpenCL Runtime for Intel Core and Intel Xeon Processors" (16.1.1 or later)
Intel GPU on Windows users require "OpenCL Driver for Intel Iris and Intel HD Graphics"
Intel GPU on Linux users require "OpenCL 2.0 GPU Driver Package for Linux" (2.0 or later)
NVidia users require "NVIDIA Driver" (367.x or later)
## ##
## Features ## Features

161
src/opencl.c
View File

@ -300,20 +300,27 @@ int ocl_init (hashcat_ctx_t *hashcat_ctx)
if (ocl->lib == NULL) if (ocl->lib == NULL)
{ {
event_log_error (hashcat_ctx, "Can't find an OpenCL ICD loader library"); event_log_error (hashcat_ctx, "Can not find an OpenCL ICD loader library");
event_log_error (hashcat_ctx, ""); event_log_error (hashcat_ctx, "");
event_log_error (hashcat_ctx, "You're probably missing the OpenCL runtime and driver installation");
#if defined (__linux__) #if defined (__linux__)
event_log_error (hashcat_ctx, "You're probably missing the \"ocl-icd-libopencl1\" package (Debian/Ubuntu)"); event_log_error (hashcat_ctx, "* AMD users on Linux require \"AMDGPU-Pro Driver\" (16.40 or later)");
event_log_error (hashcat_ctx, "Run: sudo apt-get install ocl-icd-libopencl1");
event_log_error (hashcat_ctx, "");
#elif defined (_WIN) #elif defined (_WIN)
event_log_error (hashcat_ctx, "You're probably missing the OpenCL runtime installation"); event_log_error (hashcat_ctx, "* AMD users on Windows require \"AMD Radeon Software Crimson Edition\" (15.12 or later)");
event_log_error (hashcat_ctx, "* AMD users require AMD drivers 14.9 or later (recommended 15.12 exact)");
event_log_error (hashcat_ctx, "* Intel users require Intel OpenCL Runtime 14.2 or later (recommended 16.1 or later)");
event_log_error (hashcat_ctx, "* NVidia users require NVidia drivers 346.59 or later (recommended 367.27 or later)");
event_log_error (hashcat_ctx, "");
#endif #endif
event_log_error (hashcat_ctx, "* Intel CPU users require \"OpenCL Runtime for Intel Core and Intel Xeon Processors\" (16.1.1 or later)");
#if defined (__linux__)
event_log_error (hashcat_ctx, "* Intel GPU on Linux users require \"OpenCL 2.0 GPU Driver Package for Linux\" (2.0 or later)");
#elif defined (_WIN)
event_log_error (hashcat_ctx, "* Intel GPU on Windows users require \"OpenCL Driver for Intel Iris and Intel HD Graphics\"");
#endif
event_log_error (hashcat_ctx, "* NVidia users require \"NVIDIA Driver\" (367.x or later)");
event_log_error (hashcat_ctx, "");
return -1; return -1;
} }
@ -2434,7 +2441,7 @@ int opencl_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
{ {
event_log_error (hashcat_ctx, "* Device #%u: Not a little endian device", device_id + 1); event_log_error (hashcat_ctx, "* Device #%u: Not a little endian device", device_id + 1);
device_param->skipped = 1; device_param->skipped = true;
} }
// device_available // device_available
@ -2449,7 +2456,7 @@ int opencl_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
{ {
event_log_error (hashcat_ctx, "* Device #%u: Device not available", device_id + 1); event_log_error (hashcat_ctx, "* Device #%u: Device not available", device_id + 1);
device_param->skipped = 1; device_param->skipped = true;
} }
// device_compiler_available // device_compiler_available
@ -2464,7 +2471,7 @@ int opencl_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
{ {
event_log_error (hashcat_ctx, "* Device #%u: No compiler available for device", device_id + 1); event_log_error (hashcat_ctx, "* Device #%u: No compiler available for device", device_id + 1);
device_param->skipped = 1; device_param->skipped = true;
} }
// device_execution_capabilities // device_execution_capabilities
@ -2479,7 +2486,7 @@ int opencl_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
{ {
event_log_error (hashcat_ctx, "* Device #%u: Device does not support executing kernels", device_id + 1); event_log_error (hashcat_ctx, "* Device #%u: Device does not support executing kernels", device_id + 1);
device_param->skipped = 1; device_param->skipped = true;
} }
// device_extensions // device_extensions
@ -2500,14 +2507,14 @@ int opencl_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
{ {
event_log_error (hashcat_ctx, "* Device #%u: Device does not support base atomics", device_id + 1); event_log_error (hashcat_ctx, "* Device #%u: Device does not support base atomics", device_id + 1);
device_param->skipped = 1; device_param->skipped = true;
} }
if (strstr (device_extensions, "byte_addressable_store") == 0) if (strstr (device_extensions, "byte_addressable_store") == 0)
{ {
event_log_error (hashcat_ctx, "* Device #%u: Device does not support byte addressable store", device_id + 1); event_log_error (hashcat_ctx, "* Device #%u: Device does not support byte addressable store", device_id + 1);
device_param->skipped = 1; device_param->skipped = true;
} }
hcfree (device_extensions); hcfree (device_extensions);
@ -2524,7 +2531,7 @@ int opencl_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
{ {
event_log_error (hashcat_ctx, "* Device #%u: Device local mem size is too small", device_id + 1); event_log_error (hashcat_ctx, "* Device #%u: Device local mem size is too small", device_id + 1);
device_param->skipped = 1; device_param->skipped = true;
} }
// If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation // If there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation
@ -2542,7 +2549,7 @@ int opencl_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
if (user_options->quiet == false) event_log_warning (hashcat_ctx, "* Device #%u: Not a native Intel OpenCL runtime, expect massive speed loss", device_id + 1); if (user_options->quiet == false) event_log_warning (hashcat_ctx, "* Device #%u: Not a native Intel OpenCL runtime, expect massive speed loss", device_id + 1);
if (user_options->quiet == false) event_log_warning (hashcat_ctx, " You can use --force to override this but do not post error reports if you do so"); if (user_options->quiet == false) event_log_warning (hashcat_ctx, " You can use --force to override this but do not post error reports if you do so");
device_param->skipped = 1; device_param->skipped = true;
} }
} }
} }
@ -2692,60 +2699,113 @@ int opencl_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
// common driver check // common driver check
if (device_param->skipped == 0) if (device_param->skipped == false)
{ {
if (device_type & CL_DEVICE_TYPE_GPU) if ((user_options->force == false) && (user_options->opencl_info == false))
{ {
if (platform_vendor_id == VENDOR_ID_AMD) if (device_type & CL_DEVICE_TYPE_CPU)
{ {
int catalyst_check = (user_options->force == 1) ? 0 : 1; if (device_vendor_id == VENDOR_ID_INTEL_SDK)
{
bool intel_warn = false;
int catalyst_warn = 0; int v0 = 0;
int v1 = 0;
int v2 = 0;
int v3 = 0;
int catalyst_broken = 0; int res = sscanf (device_param->driver_version, "%d.%d.%d.%d", &v0, &v1, &v2, &v3);
if (catalyst_check == 1) if (res == 4)
{ {
catalyst_warn = 1; int version = 0;
// v14.9 and higher version += v0 * 1000 * 1000 * 1000;
if (atoi (device_param->driver_version) >= 1573) version += v1 * 1000 * 1000;
{ version += v2 * 1000;
catalyst_warn = 0; version += v3;
// Intel OpenCL runtime 16.1.1
if (version < 1002000025) intel_warn = true;
} }
catalyst_check = 0; if (intel_warn == true)
}
if (catalyst_broken == 1)
{ {
event_log_error (hashcat_ctx, "* Device #%u: The Catalyst driver installed on your system is known to be broken!", device_id + 1); event_log_error_nn (hashcat_ctx, "* Device #%u: Outdated or incorrectly installed NVIDIA driver detected!", device_id + 1);
event_log_error (hashcat_ctx, ""); event_log_error_nn (hashcat_ctx, "%s", EOL);
event_log_error (hashcat_ctx, "It passes over cracked hashes and will not report them as cracked"); event_log_error_nn (hashcat_ctx, "%s", EOL);
event_log_error (hashcat_ctx, "You are STRONGLY encouraged not to use it"); event_log_error_nn (hashcat_ctx, "You are STRONGLY encouraged to use the official supported NVIDIA driver");
event_log_error (hashcat_ctx, "You can use --force to override this but do not post error reports if you do so"); event_log_error_nn (hashcat_ctx, "%s", EOL);
event_log_error (hashcat_ctx, ""); event_log_error_nn (hashcat_ctx, "See hashcat's homepage for official supported NVIDIA drivers");
event_log_error_nn (hashcat_ctx, "%s", EOL);
event_log_error_nn (hashcat_ctx, "You can use --force to override this but do not post error reports if you do so");
event_log_error_nn (hashcat_ctx, "%s", EOL);
event_log_error_nn (hashcat_ctx, "%s", EOL);
return -1; return -1;
} }
}
if (catalyst_warn == 1) }
else if (device_type & CL_DEVICE_TYPE_GPU)
{ {
event_log_error (hashcat_ctx, "* Device #%u: Unsupported or incorrectly installed Catalyst driver detected!", device_id + 1); if (device_vendor_id == VENDOR_ID_AMD)
event_log_error (hashcat_ctx, ""); {
event_log_error (hashcat_ctx, "You are STRONGLY encouraged to use the official supported catalyst driver"); bool amd_warn = true;
event_log_error (hashcat_ctx, "See hashcat's homepage for official supported catalyst drivers");
#if defined (_WIN) #if defined (__linux__)
event_log_error (hashcat_ctx, "Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to"); // AMDGPU-Pro Driver 16.40 and higher
if (atoi (device_param->driver_version) >= 2117) amd_warn = false;
#elif defined (_WIN)
// AMD Radeon Software 14.9 and higher, should be updated to 15.12
if (atoi (device_param->driver_version) >= 1573) amd_warn = false;
#else
// we have no information about other os
amd_warn = false;
#endif #endif
event_log_error (hashcat_ctx, "You can use --force to override this but do not post error reports if you do so");
event_log_error (hashcat_ctx, ""); if (amd_warn == true)
{
event_log_error_nn (hashcat_ctx, "* Device #%u: Outdated or incorrectly installed AMD driver detected!", device_id + 1);
event_log_error_nn (hashcat_ctx, "%s", EOL);
event_log_error_nn (hashcat_ctx, "%s", EOL);
event_log_error_nn (hashcat_ctx, "You are STRONGLY encouraged to use the official supported AMD driver");
event_log_error_nn (hashcat_ctx, "%s", EOL);
event_log_error_nn (hashcat_ctx, "See hashcat's homepage for official supported AMD drivers");
event_log_error_nn (hashcat_ctx, "%s", EOL);
#if defined (_WIN)
event_log_error_nn (hashcat_ctx, "Also see: http://hashcat.net/wiki/doku.php?id=upgrading_amd_drivers_how_to");
event_log_error_nn (hashcat_ctx, "%s", EOL);
#endif
event_log_error_nn (hashcat_ctx, "You can use --force to override this but do not post error reports if you do so");
event_log_error_nn (hashcat_ctx, "%s", EOL);
event_log_error_nn (hashcat_ctx, "%s", EOL);
return -1; return -1;
} }
} }
else if (platform_vendor_id == VENDOR_ID_NV) else if (device_vendor_id == VENDOR_ID_NV)
{ {
int nv_warn = true;
// nvidia driver 367.x and higher
if (atoi (device_param->driver_version) >= 367) nv_warn = false;
if (nv_warn == true)
{
event_log_error_nn (hashcat_ctx, "* Device #%u: Outdated or incorrectly installed NVIDIA driver detected!", device_id + 1);
event_log_error_nn (hashcat_ctx, "%s", EOL);
event_log_error_nn (hashcat_ctx, "%s", EOL);
event_log_error_nn (hashcat_ctx, "You are STRONGLY encouraged to use the official supported NVIDIA driver");
event_log_error_nn (hashcat_ctx, "%s", EOL);
event_log_error_nn (hashcat_ctx, "See hashcat's homepage for official supported NVIDIA drivers");
event_log_error_nn (hashcat_ctx, "%s", EOL);
event_log_error_nn (hashcat_ctx, "You can use --force to override this but do not post error reports if you do so");
event_log_error_nn (hashcat_ctx, "%s", EOL);
event_log_error_nn (hashcat_ctx, "%s", EOL);
return -1;
}
if (device_param->kernel_exec_timeout != 0) if (device_param->kernel_exec_timeout != 0)
{ {
if (user_options->quiet == false) event_log_warning (hashcat_ctx, "* Device #%u: Kernel exec timeout is not disabled, it might cause you errors of code 702", device_id + 1); if (user_options->quiet == false) event_log_warning (hashcat_ctx, "* Device #%u: Kernel exec timeout is not disabled, it might cause you errors of code 702", device_id + 1);
@ -2753,6 +2813,7 @@ int opencl_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
} }
} }
} }
}
/** /**
* activate device * activate device