X-Git-Url: https://www.flypig.org.uk/git/?a=blobdiff_plain;f=src%2Fhashcat.c;h=b7fbb2568bc0e4edb061359427ebc200afa2e3d7;hb=6be99f523c1f5b86818825923d04bc22080f43fb;hp=c311e1c313106feed27d708331ecd0c81fc406b7;hpb=19afd5c13588d844137f79740075b71ff4be3c8a;p=hashcat.git diff --git a/src/hashcat.c b/src/hashcat.c index c311e1c..41b6144 100644 --- a/src/hashcat.c +++ b/src/hashcat.c @@ -6,7 +6,7 @@ * License.....: MIT */ -#ifdef OSX +#ifdef DARWIN #include #endif @@ -19,7 +19,7 @@ const char *PROGNAME = "hashcat"; const uint VERSION_BIN = 300; const uint RESTORE_MIN = 300; -double TARGET_MS_PROFILE[3] = { 8, 16, 96 }; +double TARGET_MS_PROFILE[4] = { 2, 12, 96, 480 }; #define INCR_RULES 10000 #define INCR_SALTS 100000 @@ -33,12 +33,13 @@ double TARGET_MS_PROFILE[3] = { 8, 16, 96 }; #define MARKOV_DISABLE 0 #define MARKOV_CLASSIC 0 #define BENCHMARK 0 +#define STDOUT_FLAG 0 #define RESTORE 0 #define RESTORE_TIMER 60 #define RESTORE_DISABLE 0 #define STATUS 0 #define STATUS_TIMER 10 -#define STATUS_AUTOMAT 0 +#define MACHINE_READABLE 0 #define LOOPBACK 0 #define WEAK_HASH_THRESHOLD 100 #define SHOW 0 @@ -74,9 +75,10 @@ double TARGET_MS_PROFILE[3] = { 8, 16, 96 }; #define SEPARATOR ':' #define BITMAP_MIN 16 #define BITMAP_MAX 24 +#define NVIDIA_SPIN_DAMP 100 #define GPU_TEMP_DISABLE 0 #define GPU_TEMP_ABORT 90 -#define GPU_TEMP_RETAIN 80 +#define GPU_TEMP_RETAIN 75 #define WORKLOAD_PROFILE 2 #define KERNEL_ACCEL 0 #define KERNEL_LOOPS 0 @@ -148,7 +150,9 @@ double TARGET_MS_PROFILE[3] = { 8, 16, 96 }; #define MAX_DICTSTAT 10000 -#define NUM_DEFAULT_BENCHMARK_ALGORITHMS 137 +#define NUM_DEFAULT_BENCHMARK_ALGORITHMS 143 + +#define NVIDIA_100PERCENTCPU_WORKAROUND 100 #define global_free(attr) \ { \ @@ -164,6 +168,12 @@ double TARGET_MS_PROFILE[3] = { 8, 16, 96 }; attr = NULL; \ } +#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +#define HC_API_CALL __stdcall +#else +#define HC_API_CALL +#endif + static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] = { 900, @@ -279,6 +289,12 @@ static uint default_benchmark_algorithms[NUM_DEFAULT_BENCHMARK_ALGORITHMS] = 6221, 6231, 6241, + 13711, + 13721, + 13731, + 13741, + 13751, + 13761, 8800, 12900, 12200, @@ -343,415 +359,389 @@ const char *USAGE_BIG[] = "", "Usage: %s [options]... hash|hashfile|hccapfile [dictionary|mask|directory]...", "", - "=======", - "Options", - "=======", - "", - "* General:", - "", - " -m, --hash-type=NUM Hash-type, see references below", - " -a, --attack-mode=NUM Attack-mode, see references below", - " -V, --version Print version", - " -h, --help Print help", - " --quiet Suppress output", - "", - "* Misc:", - "", - " --hex-charset Assume charset is given in hex", - " --hex-salt Assume salt is given in hex", - " --hex-wordlist Assume words in wordlist is given in hex", - " --force Ignore warnings", - " --status Enable automatic update of the status-screen", - " --status-timer=NUM Seconds between status-screen update", - " --status-automat Display the status view in a machine readable format", - " --loopback Add new plains to induct directory", - " --weak-hash-threshold=NUM Threshold when to stop checking for weak hashes, default is 100 salts", - "", - "* Markov:", + "- [ Options ] -", "", - " --markov-hcstat=FILE Specify hcstat file to use, default is hashcat.hcstat", - " --markov-disable Disables markov-chains, emulates classic brute-force", - " --markov-classic Enables classic markov-chains, no per-position enhancement", - " -t, --markov-threshold=NUM Threshold when to stop accepting new markov-chains", - "", - "* Session:", - "", - " --runtime=NUM Abort session after NUM seconds of runtime", - " --session=STR Define specific session name", - " --restore Restore session from --session", - " --restore-disable Do not write restore file", - "", - "* Files:", - "", - " -o, --outfile=FILE Define outfile for recovered hash", - " --outfile-format=NUM Define outfile-format for recovered hash, see references below", - " --outfile-autohex-disable Disable the use of $HEX[] in output plains", - " --outfile-check-timer=NUM Seconds between outfile checks", - " -p, --separator=CHAR Separator char for hashlists and outfile", - " --show Show cracked passwords only", - " --left Show un-cracked passwords only", - " --username Enable ignoring of usernames in hashfile (recommended: also use --show)", - " --remove Enable remove of hash once it is cracked", - " --remove-timer=NUM Update input hash file each NUM seconds", - " --potfile-disable Do not write potfile", - " --potfile-path Specific path to potfile", - " --debug-mode=NUM Defines the debug mode (hybrid only by using rules), see references below", - " --debug-file=FILE Output file for debugging rules (see also --debug-mode)", - " --induction-dir=FOLDER Specify induction directory to use, default is $session.induct", - " --outfile-check-dir=FOLDER Specify the outfile directory which should be monitored, default is $session.outfiles", - " --logfile-disable Disable the logfile", - " --truecrypt-keyfiles=FILE Keyfiles used, separate with comma", - "", - "* Resources:", - "", - " -b, --benchmark Run benchmark", - " --benchmark-repeats=NUM Repeat the kernel on the device NUM times to increase benchmark accuracy", - " -c, --segment-size=NUM Size in MB to cache from the wordfile", - " --bitmap-min=NUM Minimum number of bits allowed for bitmaps", - " --bitmap-max=NUM Maximum number of bits allowed for bitmaps", - " --cpu-affinity=STR Locks to CPU devices, separate with comma", - " --opencl-platforms=STR OpenCL platforms to use, separate with comma", - " -d, --opencl-devices=STR OpenCL devices to use, separate with comma", - " --opencl-device-types=STR OpenCL device-types to use, separate with comma, see references below", - " --opencl-vector-width=NUM OpenCL vector-width (either 1, 2, 4, 8 or 16), overrides value from device query", - " -w, --workload-profile=NUM Enable a specific workload profile, see references below", - " -n, --kernel-accel=NUM Workload tuning, increase the outer-loop step size", - " -u, --kernel-loops=NUM Workload tuning, increase the inner-loop step size", - " --gpu-temp-disable Disable temperature and fanspeed readings and triggers", + " Options Short / Long | Type | Description | Example", + "===============================+======+======================================================+=======================", + " -m, --hash-type | Num | Hash-type, see references below | -m 1000", + " -a, --attack-mode | Num | Attack-mode, see references below | -a 3", + " -V, --version | | Print version |", + " -h, --help | | Print help |", + " --quiet | | Suppress output |", + " --hex-charset | | Assume charset is given in hex |", + " --hex-salt | | Assume salt is given in hex |", + " --hex-wordlist | | Assume words in wordlist is given in hex |", + " --force | | Ignore warnings |", + " --status | | Enable automatic update of the status-screen |", + " --status-timer | Num | Sets seconds between status-screen update to X | --status-timer=1", + " --machine-readable | | Display the status view in a machine readable format |", + " --loopback | | Add new plains to induct directory |", + " --weak-hash-threshold | Num | Threshold X when to stop checking for weak hashes | --weak=0", + " --markov-hcstat | File | Specify hcstat file to use | --markov-hc=my.hcstat", + " --markov-disable | | Disables markov-chains, emulates classic brute-force |", + " --markov-classic | | Enables classic markov-chains, no per-position |", + " -t, --markov-threshold | Num | Threshold X when to stop accepting new markov-chains | -t 50", + " --runtime | Num | Abort session after X seconds of runtime | --runtime=10", + " --session | Str | Define specific session name | --session=mysession", + " --restore | | Restore session from --session |", + " --restore-disable | | Do not write restore file |", + " -o, --outfile | File | Define outfile for recovered hash | -o outfile.txt", + " --outfile-format | Num | Define outfile-format X for recovered hash | --outfile-format=7", + " --outfile-autohex-disable | | Disable the use of $HEX[] in output plains |", + " --outfile-check-timer | Num | Sets seconds between outfile checks to X | --outfile-check=30", + " -p, --separator | Char | Separator char for hashlists and outfile | -p :", + " --stdout | | Do not crack a hash, instead print candidates only |", + " --show | | Compare hashlist with potfile; Show cracked hashes |", + " --left | | Compare hashlist with potfile; Show uncracked hashes |", + " --username | | Enable ignoring of usernames in hashfile |", + " --remove | | Enable remove of hash once it is cracked |", + " --remove-timer | Num | Update input hash file each X seconds | --remove-timer=30", + " --potfile-disable | | Do not write potfile |", + " --potfile-path | Dir | Specific path to potfile | --potfile-path=my.pot", + " --debug-mode | Num | Defines the debug mode (hybrid only by using rules) | --debug-mode=4", + " --debug-file | File | Output file for debugging rules | --debug-file=good.log", + " --induction-dir | Dir | Specify the induction directory to use for loopback | --induction=inducts", + " --outfile-check-dir | Dir | Specify the outfile directory to monitor for plains | --outfile-check-dir=x", + " --logfile-disable | | Disable the logfile |", + " --truecrypt-keyfiles | File | Keyfiles used, separate with comma | --truecrypt-key=x.png", + " --veracrypt-keyfiles | File | Keyfiles used, separate with comma | --veracrypt-key=x.txt", + " --veracrypt-pim | Num | VeraCrypt personal iterations multiplier | --veracrypt-pim=1000", + " -b, --benchmark | | Run benchmark |", + " -c, --segment-size | Num | Sets size in MB to cache from the wordfile to X | -c 32", + " --bitmap-min | Num | Sets minimum bits allowed for bitmaps to X | --bitmap-min=24", + " --bitmap-max | Num | Sets maximum bits allowed for bitmaps to X | --bitmap-min=24", + " --cpu-affinity | Str | Locks to CPU devices, separate with comma | --cpu-affinity=1,2,3", + " --opencl-platforms | Str | OpenCL platforms to use, separate with comma | --opencl-platforms=2", + " -d, --opencl-devices | Str | OpenCL devices to use, separate with comma | -d 1", + " -D, --opencl-device-types | Str | OpenCL device-types to use, separate with comma | -D 1", + " --opencl-vector-width | Num | Manual override OpenCL vector-width to X | --opencl-vector=4", + " -w, --workload-profile | Num | Enable a specific workload profile, see pool below | -w 3", + " -n, --kernel-accel | Num | Manual workload tuning, set outerloop step size to X | -n 64", + " -u, --kernel-loops | Num | Manual workload tuning, set innerloop step size to X | -u 256", + " --nvidia-spin-damp | Num | Workaround NVidias CPU burning loop bug, in percent | --nvidia-spin-damp=50", + " --gpu-temp-disable | | Disable temperature and fanspeed reads and triggers |", #ifdef HAVE_HWMON - " --gpu-temp-abort=NUM Abort session if GPU temperature reaches NUM degrees celsius", - " --gpu-temp-retain=NUM Try to retain GPU temperature at NUM degrees celsius (AMD only)", - #ifdef HAVE_ADL - " --powertune-enable Enable automatic power tuning option (AMD OverDrive 6 only)", + " --gpu-temp-abort | Num | Abort if GPU temperature reaches X degrees celsius | --gpu-temp-abort=100", + " --gpu-temp-retain | Num | Try to retain GPU temperature at X degrees celsius | --gpu-temp-retain=95", + " --powertune-enable | | Enable power tuning, restores settings when finished |", #endif - #endif - " --scrypt-tmto=NUM Manually override automatically calculated TMTO value for scrypt", - "", - "* Distributed:", - "", - " -s, --skip=NUM Skip number of words", - " -l, --limit=NUM Limit number of words", - " --keyspace Show keyspace base:mod values and quit", - "", - "* Rules:", - "", - " -j, --rule-left=RULE Single rule applied to each word from left dict", - " -k, --rule-right=RULE Single rule applied to each word from right dict", - " -r, --rules-file=FILE Rules-file, multi use: -r 1.rule -r 2.rule", - " -g, --generate-rules=NUM Generate NUM random rules", - " --generate-rules-func-min=NUM Force NUM functions per random rule min", - " --generate-rules-func-max=NUM Force NUM functions per random rule max", - " --generate-rules-seed=NUM Force RNG seed to NUM", - "", - "* Custom charsets:", - "", - " -1, --custom-charset1=CS User-defined charsets", - " -2, --custom-charset2=CS Example:", - " -3, --custom-charset3=CS --custom-charset1=?dabcdef : sets charset ?1 to 0123456789abcdef", - " -4, --custom-charset4=CS -2 mycharset.hcchr : sets charset ?2 to chars contained in file", - "", - "* Increment:", - "", - " -i, --increment Enable increment mode", - " --increment-min=NUM Start incrementing at NUM", - " --increment-max=NUM Stop incrementing at NUM", - "", - "==========", - "References", - "==========", - "", - "* Workload Profile:", - "", - " 1 = Interactive performance profile, kernel execution runtime to 8ms, lower latency desktop, lower speed", - " 2 = Default performance profile, kernel execution runtime to 16ms, economic setting", - " 3 = Headless performance profile, kernel execution runtime to 96ms, higher latency desktop, higher speed", - "", - "* OpenCL device-types:", - "", - " 1 = CPU devices", - " 2 = GPU devices", - " 3 = Accelerator devices (FPGA, CELL Blade, etc.)", - "", - "* Outfile Formats:", - "", - " 1 = hash[:salt]", - " 2 = plain", - " 3 = hash[:salt]:plain", - " 4 = hex_plain", - " 5 = hash[:salt]:hex_plain", - " 6 = plain:hex_plain", - " 7 = hash[:salt]:plain:hex_plain", - " 8 = crackpos", - " 9 = hash[:salt]:crackpos", - " 10 = plain:crackpos", - " 11 = hash[:salt]:plain:crackpos", - " 12 = hex_plain:crackpos", - " 13 = hash[:salt]:hex_plain:crackpos", - " 14 = plain:hex_plain:crackpos", - " 15 = hash[:salt]:plain:hex_plain:crackpos", - "", - "* Debug mode output formats (for hybrid mode only, by using rules):", - "", - " 1 = save finding rule", - " 2 = save original word", - " 3 = save original word and finding rule", - " 4 = save original word, finding rule and modified plain", + " --scrypt-tmto | Num | Manually override TMTO value for scrypt to X | --scrypt-tmto=3", + " -s, --skip | Num | Skip X words from the start | -s 1000000", + " -l, --limit | Num | Limit X words from the start + skipped words | -l 1000000", + " --keyspace | | Show keyspace base:mod values and quit |", + " -j, --rule-left | Rule | Single rule applied to each word from left wordlist | -j 'c'", + " -k, --rule-right | Rule | Single rule applied to each word from right wordlist | -k '^-'", + " -r, --rules-file | File | Multiple rules applied to each word from wordlists | -r rules/best64.rule", + " -g, --generate-rules | Num | Generate X random rules | -g 10000", + " --generate-rules-func-min | Num | Force min X funcs per rule |", + " --generate-rules-func-max | Num | Force max X funcs per rule |", + " --generate-rules-seed | Num | Force RNG seed set to X |", + " -1, --custom-charset1 | CS | User-defined charset ?1 | -1 ?l?d?u", + " -2, --custom-charset2 | CS | User-defined charset ?2 | -2 ?l?d?s", + " -3, --custom-charset3 | CS | User-defined charset ?3 |", + " -4, --custom-charset4 | CS | User-defined charset ?4 |", + " -i, --increment | | Enable mask increment mode |", + " --increment-min | Num | Start mask incrementing at X | --increment-min=4", + " --increment-max | Num | Stop mask incrementing at X | --increment-max=8", "", - "* Built-in charsets:", + "- [ Hash modes ] -", "", - " ?l = abcdefghijklmnopqrstuvwxyz", - " ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ", - " ?d = 0123456789", - " ?s = !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~", - " ?a = ?l?u?d?s", - " ?b = 0x00 - 0xff", + " # | Name | Category", + " ======+==================================================+======================================", + " 900 | MD4 | Raw Hash", + " 0 | MD5 | Raw Hash", + " 5100 | Half MD5 | Raw Hash", + " 100 | SHA1 | Raw Hash", + " 10800 | SHA-384 | Raw Hash", + " 1400 | SHA-256 | Raw Hash", + " 1700 | SHA-512 | Raw Hash", + " 5000 | SHA-3(Keccak) | Raw Hash", + " 10100 | SipHash | Raw Hash", + " 6000 | RipeMD160 | Raw Hash", + " 6100 | Whirlpool | Raw Hash", + " 6900 | GOST R 34.11-94 | Raw Hash", + " 11700 | GOST R 34.11-2012 (Streebog) 256-bit | Raw Hash", + " 11800 | GOST R 34.11-2012 (Streebog) 512-bit | Raw Hash", + " 10 | md5($pass.$salt) | Raw Hash, Salted and / or Iterated", + " 20 | md5($salt.$pass) | Raw Hash, Salted and / or Iterated", + " 30 | md5(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated", + " 40 | md5($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated", + " 3800 | md5($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated", + " 3710 | md5($salt.md5($pass)) | Raw Hash, Salted and / or Iterated", + " 2600 | md5(md5($pass) | Raw Hash, Salted and / or Iterated", + " 4300 | md5(strtoupper(md5($pass))) | Raw Hash, Salted and / or Iterated", + " 4400 | md5(sha1($pass)) | Raw Hash, Salted and / or Iterated", + " 110 | sha1($pass.$salt) | Raw Hash, Salted and / or Iterated", + " 120 | sha1($salt.$pass) | Raw Hash, Salted and / or Iterated", + " 130 | sha1(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated", + " 140 | sha1($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated", + " 4500 | sha1(sha1($pass) | Raw Hash, Salted and / or Iterated", + " 4700 | sha1(md5($pass)) | Raw Hash, Salted and / or Iterated", + " 4900 | sha1($salt.$pass.$salt) | Raw Hash, Salted and / or Iterated", + " 1410 | sha256($pass.$salt) | Raw Hash, Salted and / or Iterated", + " 1420 | sha256($salt.$pass) | Raw Hash, Salted and / or Iterated", + " 1430 | sha256(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated", + " 1440 | sha256($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated", + " 1710 | sha512($pass.$salt) | Raw Hash, Salted and / or Iterated", + " 1720 | sha512($salt.$pass) | Raw Hash, Salted and / or Iterated", + " 1730 | sha512(unicode($pass).$salt) | Raw Hash, Salted and / or Iterated", + " 1740 | sha512($salt.unicode($pass)) | Raw Hash, Salted and / or Iterated", + " 50 | HMAC-MD5 (key = $pass) | Raw Hash, Authenticated", + " 60 | HMAC-MD5 (key = $salt) | Raw Hash, Authenticated", + " 150 | HMAC-SHA1 (key = $pass) | Raw Hash, Authenticated", + " 160 | HMAC-SHA1 (key = $salt) | Raw Hash, Authenticated", + " 1450 | HMAC-SHA256 (key = $pass) | Raw Hash, Authenticated", + " 1460 | HMAC-SHA256 (key = $salt) | Raw Hash, Authenticated", + " 1750 | HMAC-SHA512 (key = $pass) | Raw Hash, Authenticated", + " 1760 | HMAC-SHA512 (key = $salt) | Raw Hash, Authenticated", + " 400 | phpass | Generic KDF", + " 8900 | scrypt | Generic KDF", + " 11900 | PBKDF2-HMAC-MD5 | Generic KDF", + " 12000 | PBKDF2-HMAC-SHA1 | Generic KDF", + " 10900 | PBKDF2-HMAC-SHA256 | Generic KDF", + " 12100 | PBKDF2-HMAC-SHA512 | Generic KDF", + " 23 | Skype | Network protocols", + " 2500 | WPA/WPA2 | Network protocols", + " 4800 | iSCSI CHAP authentication, MD5(Chap) | Network protocols", + " 5300 | IKE-PSK MD5 | Network protocols", + " 5400 | IKE-PSK SHA1 | Network protocols", + " 5500 | NetNTLMv1 | Network protocols", + " 5500 | NetNTLMv1 + ESS | Network protocols", + " 5600 | NetNTLMv2 | Network protocols", + " 7300 | IPMI2 RAKP HMAC-SHA1 | Network protocols", + " 7500 | Kerberos 5 AS-REQ Pre-Auth etype 23 | Network protocols", + " 8300 | DNSSEC (NSEC3) | Network protocols", + " 10200 | Cram MD5 | Network protocols", + " 11100 | PostgreSQL CRAM (MD5) | Network protocols", + " 11200 | MySQL CRAM (SHA1) | Network protocols", + " 11400 | SIP digest authentication (MD5) | Network protocols", + " 13100 | Kerberos 5 TGS-REP etype 23 | Network protocols", + " 121 | SMF (Simple Machines Forum) | Forums, CMS, E-Commerce, Frameworks", + " 400 | phpBB3 | Forums, CMS, E-Commerce, Frameworks", + " 2611 | vBulletin < v3.8.5 | Forums, CMS, E-Commerce, Frameworks", + " 2711 | vBulletin > v3.8.5 | Forums, CMS, E-Commerce, Frameworks", + " 2811 | MyBB | Forums, CMS, E-Commerce, Frameworks", + " 2811 | IPB (Invison Power Board) | Forums, CMS, E-Commerce, Frameworks", + " 8400 | WBB3 (Woltlab Burning Board) | Forums, CMS, E-Commerce, Frameworks", + " 11 | Joomla < 2.5.18 | Forums, CMS, E-Commerce, Frameworks", + " 400 | Joomla > 2.5.18 | Forums, CMS, E-Commerce, Frameworks", + " 400 | Wordpress | Forums, CMS, E-Commerce, Frameworks", + " 2612 | PHPS | Forums, CMS, E-Commerce, Frameworks", + " 7900 | Drupal7 | Forums, CMS, E-Commerce, Frameworks", + " 21 | osCommerce | Forums, CMS, E-Commerce, Frameworks", + " 21 | xt:Commerce | Forums, CMS, E-Commerce, Frameworks", + " 11000 | PrestaShop | Forums, CMS, E-Commerce, Frameworks", + " 124 | Django (SHA-1) | Forums, CMS, E-Commerce, Frameworks", + " 10000 | Django (PBKDF2-SHA256) | Forums, CMS, E-Commerce, Frameworks", + " 3711 | Mediawiki B type | Forums, CMS, E-Commerce, Frameworks", + " 7600 | Redmine | Forums, CMS, E-Commerce, Frameworks", + " 12 | PostgreSQL | Database Server", + " 131 | MSSQL(2000) | Database Server", + " 132 | MSSQL(2005) | Database Server", + " 1731 | MSSQL(2012) | Database Server", + " 1731 | MSSQL(2014) | Database Server", + " 200 | MySQL323 | Database Server", + " 300 | MySQL4.1/MySQL5 | Database Server", + " 3100 | Oracle H: Type (Oracle 7+) | Database Server", + " 112 | Oracle S: Type (Oracle 11+) | Database Server", + " 12300 | Oracle T: Type (Oracle 12+) | Database Server", + " 8000 | Sybase ASE | Database Server", + " 141 | EPiServer 6.x < v4 | HTTP, SMTP, LDAP Server", + " 1441 | EPiServer 6.x > v4 | HTTP, SMTP, LDAP Server", + " 1600 | Apache $apr1$ | HTTP, SMTP, LDAP Server", + " 12600 | ColdFusion 10+ | HTTP, SMTP, LDAP Server", + " 1421 | hMailServer | HTTP, SMTP, LDAP Server", + " 101 | nsldap, SHA-1(Base64), Netscape LDAP SHA | HTTP, SMTP, LDAP Server", + " 111 | nsldaps, SSHA-1(Base64), Netscape LDAP SSHA | HTTP, SMTP, LDAP Server", + " 1711 | SSHA-512(Base64), LDAP {SSHA512} | HTTP, SMTP, LDAP Server", + " 11500 | CRC32 | Checksums", + " 3000 | LM | Operating-Systems", + " 1000 | NTLM | Operating-Systems", + " 1100 | Domain Cached Credentials (DCC), MS Cache | Operating-Systems", + " 2100 | Domain Cached Credentials 2 (DCC2), MS Cache 2 | Operating-Systems", + " 12800 | MS-AzureSync PBKDF2-HMAC-SHA256 | Operating-Systems", + " 1500 | descrypt, DES(Unix), Traditional DES | Operating-Systems", + " 12400 | BSDiCrypt, Extended DES | Operating-Systems", + " 500 | md5crypt $1$, MD5(Unix) | Operating-Systems", + " 3200 | bcrypt $2*$, Blowfish(Unix) | Operating-Systems", + " 7400 | sha256crypt $5$, SHA256(Unix) | Operating-Systems", + " 1800 | sha512crypt $6$, SHA512(Unix) | Operating-Systems", + " 122 | OSX v10.4, OSX v10.5, OSX v10.6 | Operating-Systems", + " 1722 | OSX v10.7 | Operating-Systems", + " 7100 | OSX v10.8, OSX v10.9, OSX v10.10 | Operating-Systems", + " 6300 | AIX {smd5} | Operating-Systems", + " 6700 | AIX {ssha1} | Operating-Systems", + " 6400 | AIX {ssha256} | Operating-Systems", + " 6500 | AIX {ssha512} | Operating-Systems", + " 2400 | Cisco-PIX | Operating-Systems", + " 2410 | Cisco-ASA | Operating-Systems", + " 500 | Cisco-IOS $1$ | Operating-Systems", + " 5700 | Cisco-IOS $4$ | Operating-Systems", + " 9200 | Cisco-IOS $8$ | Operating-Systems", + " 9300 | Cisco-IOS $9$ | Operating-Systems", + " 22 | Juniper Netscreen/SSG (ScreenOS) | Operating-Systems", + " 501 | Juniper IVE | Operating-Systems", + " 5800 | Android PIN | Operating-Systems", + " 13800 | Windows 8+ phone PIN/Password | Operating-Systems", + " 8100 | Citrix Netscaler | Operating-Systems", + " 8500 | RACF | Operating-Systems", + " 7200 | GRUB 2 | Operating-Systems", + " 9900 | Radmin2 | Operating-Systems", + " 125 | ArubaOS | Operating-Systems", + " 7700 | SAP CODVN B (BCODE) | Enterprise Application Software (EAS)", + " 7800 | SAP CODVN F/G (PASSCODE) | Enterprise Application Software (EAS)", + " 10300 | SAP CODVN H (PWDSALTEDHASH) iSSHA-1 | Enterprise Application Software (EAS)", + " 8600 | Lotus Notes/Domino 5 | Enterprise Application Software (EAS)", + " 8700 | Lotus Notes/Domino 6 | Enterprise Application Software (EAS)", + " 9100 | Lotus Notes/Domino 8 | Enterprise Application Software (EAS)", + " 133 | PeopleSoft | Enterprise Application Software (EAS)", + " 13500 | PeopleSoft Token | Enterprise Application Software (EAS)", + " 11600 | 7-Zip | Archives", + " 12500 | RAR3-hp | Archives", + " 13000 | RAR5 | Archives", + " 13200 | AxCrypt | Archives", + " 13300 | AxCrypt in memory SHA1 | Archives", + " 13600 | WinZip | Archives", + " 62XY | TrueCrypt | Full-Disk encryptions (FDE)", + " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)", + " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)", + " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)", + " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)", + " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)", + " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)", + " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)", + " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)", + " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)", + " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)", + " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)", + " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)", + " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)", + " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)", + " 8800 | Android FDE < v4.3 | Full-Disk encryptions (FDE)", + " 12900 | Android FDE (Samsung DEK) | Full-Disk encryptions (FDE)", + " 12200 | eCryptfs | Full-Disk encryptions (FDE)", + " 137XY | VeraCrypt | Full-Disk encryptions (FDE)", + " X | 1 = PBKDF2-HMAC-RipeMD160 | Full-Disk encryptions (FDE)", + " X | 2 = PBKDF2-HMAC-SHA512 | Full-Disk encryptions (FDE)", + " X | 3 = PBKDF2-HMAC-Whirlpool | Full-Disk encryptions (FDE)", + " X | 4 = PBKDF2-HMAC-RipeMD160 + boot-mode | Full-Disk encryptions (FDE)", + " X | 5 = PBKDF2-HMAC-SHA256 | Full-Disk encryptions (FDE)", + " X | 6 = PBKDF2-HMAC-SHA256 + boot-mode | Full-Disk encryptions (FDE)", + " Y | 1 = XTS 512 bit pure AES | Full-Disk encryptions (FDE)", + " Y | 1 = XTS 512 bit pure Serpent | Full-Disk encryptions (FDE)", + " Y | 1 = XTS 512 bit pure Twofish | Full-Disk encryptions (FDE)", + " Y | 2 = XTS 1024 bit pure AES | Full-Disk encryptions (FDE)", + " Y | 2 = XTS 1024 bit pure Serpent | Full-Disk encryptions (FDE)", + " Y | 2 = XTS 1024 bit pure Twofish | Full-Disk encryptions (FDE)", + " Y | 2 = XTS 1024 bit cascaded AES-Twofish | Full-Disk encryptions (FDE)", + " Y | 2 = XTS 1024 bit cascaded Serpent-AES | Full-Disk encryptions (FDE)", + " Y | 2 = XTS 1024 bit cascaded Twofish-Serpent | Full-Disk encryptions (FDE)", + " Y | 3 = XTS 1536 bit all | Full-Disk encryptions (FDE)", + " 9700 | MS Office <= 2003 $0|$1, MD5 + RC4 | Documents", + " 9710 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #1 | Documents", + " 9720 | MS Office <= 2003 $0|$1, MD5 + RC4, collider #2 | Documents", + " 9800 | MS Office <= 2003 $3|$4, SHA1 + RC4 | Documents", + " 9810 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #1 | Documents", + " 9820 | MS Office <= 2003 $3|$4, SHA1 + RC4, collider #2 | Documents", + " 9400 | MS Office 2007 | Documents", + " 9500 | MS Office 2010 | Documents", + " 9600 | MS Office 2013 | Documents", + " 10400 | PDF 1.1 - 1.3 (Acrobat 2 - 4) | Documents", + " 10410 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #1 | Documents", + " 10420 | PDF 1.1 - 1.3 (Acrobat 2 - 4), collider #2 | Documents", + " 10500 | PDF 1.4 - 1.6 (Acrobat 5 - 8) | Documents", + " 10600 | PDF 1.7 Level 3 (Acrobat 9) | Documents", + " 10700 | PDF 1.7 Level 8 (Acrobat 10 - 11) | Documents", + " 9000 | Password Safe v2 | Password Managers", + " 5200 | Password Safe v3 | Password Managers", + " 6800 | Lastpass + Lastpass sniffed | Password Managers", + " 6600 | 1Password, agilekeychain | Password Managers", + " 8200 | 1Password, cloudkeychain | Password Managers", + " 11300 | Bitcoin/Litecoin wallet.dat | Password Managers", + " 12700 | Blockchain, My Wallet | Password Managers", + " 13400 | Keepass 1 (AES/Twofish) and Keepass 2 (AES) | Password Managers", "", - "* Attack modes:", + "- [ Outfile Formats ] -", "", - " 0 = Straight", - " 1 = Combination", - " 3 = Brute-force", - " 6 = Hybrid dict + mask", - " 7 = Hybrid mask + dict", + " # | Format", + " ===+========", + " 1 | hash[:salt]", + " 2 | plain", + " 3 | hash[:salt]:plain", + " 4 | hex_plain", + " 5 | hash[:salt]:hex_plain", + " 6 | plain:hex_plain", + " 7 | hash[:salt]:plain:hex_plain", + " 8 | crackpos", + " 9 | hash[:salt]:crack_pos", + " 10 | plain:crack_pos", + " 11 | hash[:salt]:plain:crack_pos", + " 12 | hex_plain:crack_pos", + " 13 | hash[:salt]:hex_plain:crack_pos", + " 14 | plain:hex_plain:crack_pos", + " 15 | hash[:salt]:plain:hex_plain:crack_pos", "", - "* Hash types:", + "- [ Rule Debugging Modes ] -", "", - "[[ Roll-your-own: Raw Hashes ]]", + " # | Format", + " ===+========", + " 1 | Finding-Rule", + " 2 | Original-Word", + " 3 | Original-Word:Finding-Rule", + " 4 | Original-Word:Finding-Rule:Processed-Word", "", - " 900 = MD4", - " 0 = MD5", - " 5100 = Half MD5", - " 100 = SHA1", - " 10800 = SHA-384", - " 1400 = SHA-256", - " 1700 = SHA-512", - " 5000 = SHA-3(Keccak)", - " 10100 = SipHash", - " 6000 = RipeMD160", - " 6100 = Whirlpool", - " 6900 = GOST R 34.11-94", - " 11700 = GOST R 34.11-2012 (Streebog) 256-bit", - " 11800 = GOST R 34.11-2012 (Streebog) 512-bit", + "- [ Attack Modes ] -", "", - "[[ Roll-your-own: Iterated and / or Salted Hashes ]]", + " # | Mode", + " ===+======", + " 0 | Straight", + " 1 | Combination", + " 3 | Brute-force", + " 6 | Hybrid Wordlist + Mask", + " 7 | Hybrid Mask + Wordlist", "", - " 10 = md5($pass.$salt)", - " 20 = md5($salt.$pass)", - " 30 = md5(unicode($pass).$salt)", - " 40 = md5($salt.unicode($pass))", - " 3800 = md5($salt.$pass.$salt)", - " 3710 = md5($salt.md5($pass))", - " 2600 = md5(md5($pass)", - " 4300 = md5(strtoupper(md5($pass)))", - " 4400 = md5(sha1($pass))", - " 110 = sha1($pass.$salt)", - " 120 = sha1($salt.$pass)", - " 130 = sha1(unicode($pass).$salt)", - " 140 = sha1($salt.unicode($pass))", - " 4500 = sha1(sha1($pass)", - " 4700 = sha1(md5($pass))", - " 4900 = sha1($salt.$pass.$salt)", - " 1410 = sha256($pass.$salt)", - " 1420 = sha256($salt.$pass)", - " 1430 = sha256(unicode($pass).$salt)", - " 1440 = sha256($salt.unicode($pass))", - " 1710 = sha512($pass.$salt)", - " 1720 = sha512($salt.$pass)", - " 1730 = sha512(unicode($pass).$salt)", - " 1740 = sha512($salt.unicode($pass))", + "- [ Built-in Charsets ] -", "", - "[[ Roll-your-own: Authenticated Hashes ]]", + " ? | Charset", + " ===+=========", + " l | abcdefghijklmnopqrstuvwxyz", + " u | ABCDEFGHIJKLMNOPQRSTUVWXYZ", + " d | 0123456789", + " s | !\"#$%%&'()*+,-./:;<=>?@[\\]^_`{|}~", + " a | ?l?u?d?s", + " b | 0x00 - 0xff", "", - " 50 = HMAC-MD5 (key = $pass)", - " 60 = HMAC-MD5 (key = $salt)", - " 150 = HMAC-SHA1 (key = $pass)", - " 160 = HMAC-SHA1 (key = $salt)", - " 1450 = HMAC-SHA256 (key = $pass)", - " 1460 = HMAC-SHA256 (key = $salt)", - " 1750 = HMAC-SHA512 (key = $pass)", - " 1760 = HMAC-SHA512 (key = $salt)", + "- [ OpenCL Device Types ] -", "", - "[[ Generic KDF ]]", + " # | Device Type", + " ===+=============", + " 1 | CPU", + " 2 | GPU", + " 3 | FPGA, DSP, Co-Processor", "", - " 400 = phpass", - " 8900 = scrypt", - " 11900 = PBKDF2-HMAC-MD5", - " 12000 = PBKDF2-HMAC-SHA1", - " 10900 = PBKDF2-HMAC-SHA256", - " 12100 = PBKDF2-HMAC-SHA512", + "- [ Workload Profiles ] -", "", - "[[ Network protocols, Challenge-Response ]]", + " # | Performance | Runtime | Power Consumption | Desktop Impact", + " ===+=============+=========+===================+=================", + " 1 | Low | 2 ms | Low | Minimal", + " 2 | Default | 12 ms | Economic | Noticeable", + " 3 | High | 96 ms | High | Unresponsive", + " 4 | Nightmare | 480 ms | Insane | Headless", "", - " 23 = Skype", - " 2500 = WPA/WPA2", - " 4800 = iSCSI CHAP authentication, MD5(Chap)", - " 5300 = IKE-PSK MD5", - " 5400 = IKE-PSK SHA1", - " 5500 = NetNTLMv1", - " 5500 = NetNTLMv1 + ESS", - " 5600 = NetNTLMv2", - " 7300 = IPMI2 RAKP HMAC-SHA1", - " 7500 = Kerberos 5 AS-REQ Pre-Auth etype 23", - " 8300 = DNSSEC (NSEC3)", - " 10200 = Cram MD5", - " 11100 = PostgreSQL Challenge-Response Authentication (MD5)", - " 11200 = MySQL Challenge-Response Authentication (SHA1)", - " 11400 = SIP digest authentication (MD5)", - " 13100 = Kerberos 5 TGS-REP etype 23", + "- [ Basic Examples ] -", "", - "[[ Forums, CMS, E-Commerce, Frameworks, Middleware, Wiki, Management ]]", + " Attack- | Hash- |", + " Mode | Type | Example command", + " ==================+=======+==================================================================", + " Wordlist | $P$ | %s -a 0 -m 400 example400.hash example.dict", + " Wordlist + Rules | MD5 | %s -a 0 -m 0 example0.hash example.dict -r rules/best64.rule", + " Brute-Force | MD5 | %s -a 3 -m 0 example0.hash ?a?a?a?a?a?a", + " Combinator | MD5 | %s -a 1 -m 0 example0.hash example.dict example.dict", "", - " 121 = SMF (Simple Machines Forum)", - " 400 = phpBB3", - " 2611 = vBulletin < v3.8.5", - " 2711 = vBulletin > v3.8.5", - " 2811 = MyBB", - " 2811 = IPB (Invison Power Board)", - " 8400 = WBB3 (Woltlab Burning Board)", - " 11 = Joomla < 2.5.18", - " 400 = Joomla > 2.5.18", - " 400 = Wordpress", - " 2612 = PHPS", - " 7900 = Drupal7", - " 21 = osCommerce", - " 21 = xt:Commerce", - " 11000 = PrestaShop", - " 124 = Django (SHA-1)", - " 10000 = Django (PBKDF2-SHA256)", - " 3711 = Mediawiki B type", - " 7600 = Redmine", - "", - "[[ Database Server ]]", - "", - " 12 = PostgreSQL", - " 131 = MSSQL(2000)", - " 132 = MSSQL(2005)", - " 1731 = MSSQL(2012)", - " 1731 = MSSQL(2014)", - " 200 = MySQL323", - " 300 = MySQL4.1/MySQL5", - " 3100 = Oracle H: Type (Oracle 7+)", - " 112 = Oracle S: Type (Oracle 11+)", - " 12300 = Oracle T: Type (Oracle 12+)", - " 8000 = Sybase ASE", - "", - "[[ HTTP, SMTP, LDAP Server ]]", - "", - " 141 = EPiServer 6.x < v4", - " 1441 = EPiServer 6.x > v4", - " 1600 = Apache $apr1$", - " 12600 = ColdFusion 10+", - " 1421 = hMailServer", - " 101 = nsldap, SHA-1(Base64), Netscape LDAP SHA", - " 111 = nsldaps, SSHA-1(Base64), Netscape LDAP SSHA", - " 1711 = SSHA-512(Base64), LDAP {SSHA512}", - "", - "[[ Checksums ]]", - "", - " 11500 = CRC32", - "", - "[[ Operating-Systems ]]", - "", - " 3000 = LM", - " 1000 = NTLM", - " 1100 = Domain Cached Credentials (DCC), MS Cache", - " 2100 = Domain Cached Credentials 2 (DCC2), MS Cache 2", - " 12800 = MS-AzureSync PBKDF2-HMAC-SHA256", - " 1500 = descrypt, DES(Unix), Traditional DES", - " 12400 = BSDiCrypt, Extended DES", - " 500 = md5crypt $1$, MD5(Unix)", - " 3200 = bcrypt $2*$, Blowfish(Unix)", - " 7400 = sha256crypt $5$, SHA256(Unix)", - " 1800 = sha512crypt $6$, SHA512(Unix)", - " 122 = OSX v10.4", - " 122 = OSX v10.5", - " 122 = OSX v10.6", - " 1722 = OSX v10.7", - " 7100 = OSX v10.8", - " 7100 = OSX v10.9", - " 7100 = OSX v10.10", - " 6300 = AIX {smd5}", - " 6700 = AIX {ssha1}", - " 6400 = AIX {ssha256}", - " 6500 = AIX {ssha512}", - " 2400 = Cisco-PIX", - " 2410 = Cisco-ASA", - " 500 = Cisco-IOS $1$", - " 5700 = Cisco-IOS $4$", - " 9200 = Cisco-IOS $8$", - " 9300 = Cisco-IOS $9$", - " 22 = Juniper Netscreen/SSG (ScreenOS)", - " 501 = Juniper IVE", - " 5800 = Android PIN", - " 8100 = Citrix Netscaler", - " 8500 = RACF", - " 7200 = GRUB 2", - " 9900 = Radmin2", - " 125 = ArubaOS", - "", - "[[ Enterprise Application Software (EAS) ]]", - "", - " 7700 = SAP CODVN B (BCODE)", - " 7800 = SAP CODVN F/G (PASSCODE)", - " 10300 = SAP CODVN H (PWDSALTEDHASH) iSSHA-1", - " 8600 = Lotus Notes/Domino 5", - " 8700 = Lotus Notes/Domino 6", - " 9100 = Lotus Notes/Domino 8", - " 133 = PeopleSoft", - " 13500 = PeopleSoft Token", - "", - "[[ Archives ]]", - "", - " 11600 = 7-Zip", - " 12500 = RAR3-hp", - " 13000 = RAR5", - " 13200 = AxCrypt", - " 13300 = AxCrypt in memory SHA1", - " 13600 = WinZip", - "", - "[[ Full-Disk encryptions (FDE) ]]", - "", - " 62XY = TrueCrypt 5.0+", - " X = 1 = PBKDF2-HMAC-RipeMD160", - " X = 2 = PBKDF2-HMAC-SHA512", - " X = 3 = PBKDF2-HMAC-Whirlpool", - " X = 4 = PBKDF2-HMAC-RipeMD160 + boot-mode", - " Y = 1 = XTS 512 bit (Ciphers: AES or Serpent or Twofish)", - " Y = 2 = XTS 1024 bit (Ciphers: AES or Serpent or Twofish or AES-Twofish or Serpent-AES or Twofish-Serpent)", - " Y = 3 = XTS 1536 bit (Ciphers: All)", - " 8800 = Android FDE < v4.3", - " 12900 = Android FDE (Samsung DEK)", - " 12200 = eCryptfs", - "", - "[[ Documents ]]", - "", - " 9700 = MS Office <= 2003 MD5 + RC4, oldoffice$0, oldoffice$1", - " 9710 = MS Office <= 2003 MD5 + RC4, collider-mode #1", - " 9720 = MS Office <= 2003 MD5 + RC4, collider-mode #2", - " 9800 = MS Office <= 2003 SHA1 + RC4, oldoffice$3, oldoffice$4", - " 9810 = MS Office <= 2003 SHA1 + RC4, collider-mode #1", - " 9820 = MS Office <= 2003 SHA1 + RC4, collider-mode #2", - " 9400 = MS Office 2007", - " 9500 = MS Office 2010", - " 9600 = MS Office 2013", - " 10400 = PDF 1.1 - 1.3 (Acrobat 2 - 4)", - " 10410 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #1", - " 10420 = PDF 1.1 - 1.3 (Acrobat 2 - 4) + collider-mode #2", - " 10500 = PDF 1.4 - 1.6 (Acrobat 5 - 8)", - " 10600 = PDF 1.7 Level 3 (Acrobat 9)", - " 10700 = PDF 1.7 Level 8 (Acrobat 10 - 11)", - "", - "[[ Password Managers ]]", - "", - " 9000 = Password Safe v2", - " 5200 = Password Safe v3", - " 6800 = Lastpass", - " 6600 = 1Password, agilekeychain", - " 8200 = 1Password, cloudkeychain", - " 11300 = Bitcoin/Litecoin wallet.dat", - " 12700 = Blockchain, My Wallet", - " 13400 = Keepass 1 (AES/Twofish) and Keepass 2 (AES)", + "If you still have no idea what just happened try following pages:", "", + "* https://hashcat.net/wiki/#howtos_videos_papers_articles_etc_in_the_wild", + "* https://hashcat.net/wiki/#frequently_asked_questions", NULL }; @@ -786,7 +776,7 @@ static double get_avg_exec_time (hc_device_param_t *device_param, const int last return exec_ms_sum / exec_ms_cnt; } -void status_display_automat () +void status_display_machine_readable () { FILE *out = stdout; @@ -926,15 +916,7 @@ void status_display_automat () * flush */ - #ifdef _WIN - fputc ('\r', out); - fputc ('\n', out); - #endif - - #ifdef _POSIX - fputc ('\n', out); - #endif - + fputs (EOL, out); fflush (out); } @@ -942,11 +924,10 @@ void status_display () { if (data.devices_status == STATUS_INIT) return; if (data.devices_status == STATUS_STARTING) return; - if (data.devices_status == STATUS_BYPASS) return; - if (data.status_automat == 1) + if (data.machine_readable == 1) { - status_display_automat (); + status_display_machine_readable (); return; } @@ -1096,6 +1077,10 @@ void status_display () { log_info ("Hash.Target....: File (%s)", data.hashfile); } + else if ((data.hash_mode >= 13700) && (data.hash_mode <= 13799)) + { + log_info ("Hash.Target....: File (%s)", data.hashfile); + } else { char out_buf[HCBUFSIZ] = { 0 }; @@ -1559,6 +1544,12 @@ void status_display () } #ifdef HAVE_HWMON + + if (data.devices_status == STATUS_EXHAUSTED) return; + if (data.devices_status == STATUS_CRACKED) return; + if (data.devices_status == STATUS_ABORTED) return; + if (data.devices_status == STATUS_QUIT) return; + if (data.gpu_temp_disable == 0) { hc_thread_mutex_lock (mux_adl); @@ -1569,46 +1560,84 @@ void status_display () if (device_param->skipped) continue; - #define HM_STR_BUF_SIZE 255 + const int num_temperature = hm_get_temperature_with_device_id (device_id); + const int num_fanspeed = hm_get_fanspeed_with_device_id (device_id); + const int num_utilization = hm_get_utilization_with_device_id (device_id); + const int num_corespeed = hm_get_corespeed_with_device_id (device_id); + const int num_memoryspeed = hm_get_memoryspeed_with_device_id (device_id); + const int num_buslanes = hm_get_buslanes_with_device_id (device_id); + const int num_throttle = hm_get_throttle_with_device_id (device_id); + + char output_buf[256] = { 0 }; + + int output_len = 0; + + if (num_temperature >= 0) + { + snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Temp:%3uc", num_temperature); + + output_len = strlen (output_buf); + } - if (data.hm_device[device_id].fan_supported == 1) + if (num_fanspeed >= 0) { - char utilization[HM_STR_BUF_SIZE] = { 0 }; - char temperature[HM_STR_BUF_SIZE] = { 0 }; - char fanspeed[HM_STR_BUF_SIZE] = { 0 }; + snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Fan:%3u%%", num_fanspeed); - hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id)); - hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id)); + output_len = strlen (output_buf); + } - if (device_param->vendor_id == VENDOR_ID_AMD) - { - hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id)); - } - else if (device_param->vendor_id == VENDOR_ID_NV) - { - hm_device_val_to_str ((char *) fanspeed, HM_STR_BUF_SIZE, "%", hm_get_fanspeed_with_device_id (device_id)); - } + if (num_utilization >= 0) + { + snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Util:%3u%%", num_utilization); - log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, %s Fan", device_id + 1, utilization, temperature, fanspeed); + output_len = strlen (output_buf); } - else + + if (num_corespeed >= 0) + { + snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Core:%4uMhz", num_corespeed); + + output_len = strlen (output_buf); + } + + if (num_memoryspeed >= 0) + { + snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Mem:%4uMhz", num_memoryspeed); + + output_len = strlen (output_buf); + } + + if (num_buslanes >= 0) + { + snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " Lanes:%u", num_buslanes); + + output_len = strlen (output_buf); + } + + if (num_throttle == 1) { - char utilization[HM_STR_BUF_SIZE] = { 0 }; - char temperature[HM_STR_BUF_SIZE] = { 0 }; + snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " *Throttled*"); + + output_len = strlen (output_buf); + } - hm_device_val_to_str ((char *) utilization, HM_STR_BUF_SIZE, "%", hm_get_utilization_with_device_id (device_id)); - hm_device_val_to_str ((char *) temperature, HM_STR_BUF_SIZE, "c", hm_get_temperature_with_device_id (device_id)); + if (output_len == 0) + { + snprintf (output_buf + output_len, sizeof (output_buf) - output_len, " N/A"); - log_info ("HWMon.GPU.#%d...: %s Util, %s Temp, N/A Fan", device_id + 1, utilization, temperature); + output_len = strlen (output_buf); } + + log_info ("HWMon.Dev.#%d...:%s", device_id + 1, output_buf); } hc_thread_mutex_unlock (mux_adl); } + #endif // HAVE_HWMON } -static void status_benchmark_automat () +static void status_benchmark_automate () { u64 speed_cnt[DEVICES_MAX] = { 0 }; double speed_ms[DEVICES_MAX] = { 0 }; @@ -1653,11 +1682,10 @@ static void status_benchmark () { if (data.devices_status == STATUS_INIT) return; if (data.devices_status == STATUS_STARTING) return; - if (data.devices_status == STATUS_BYPASS) return; - if (data.status_automat == 1) + if (data.machine_readable == 1) { - status_benchmark_automat (); + status_benchmark_automate (); return; } @@ -1724,7 +1752,14 @@ static void status_benchmark () format_speed_display (hashes_dev_ms[device_id] * 1000, display_dev_cur, sizeof (display_dev_cur)); - log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]); + if (data.devices_active >= 10) + { + log_info ("Speed.Dev.#%d: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]); + } + else + { + log_info ("Speed.Dev.#%d.: %9sH/s (%0.2fms)", device_id + 1, display_dev_cur, exec_all_ms[device_id]); + } } char display_all_cur[16] = { 0 }; @@ -1806,6 +1841,26 @@ static void generate_cached_kernel_amp_filename (const uint attack_kern, char *p 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 @@ -1868,7 +1923,7 @@ static void gidd_to_pw_t (hc_device_param_t *device_param, const u64 gidd, pw_t hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, gidd * sizeof (pw_t), sizeof (pw_t), pw, 0, NULL, NULL); } -static void check_hash (hc_device_param_t *device_param, const uint salt_pos, const uint digest_pos) +static void check_hash (hc_device_param_t *device_param, plain_t *plain) { char *outfile = data.outfile; uint quiet = data.quiet; @@ -1887,38 +1942,32 @@ static void check_hash (hc_device_param_t *device_param, const uint salt_pos, co char out_buf[HCBUFSIZ] = { 0 }; - ascii_digest (out_buf, salt_pos, digest_pos); + const u32 salt_pos = plain->salt_pos; + const u32 digest_pos = plain->digest_pos; // relative + const u32 gidvid = plain->gidvid; + const u32 il_pos = plain->il_pos; - uint idx = data.salts_buf[salt_pos].digests_offset + digest_pos; + ascii_digest (out_buf, salt_pos, digest_pos); // plain - plain_t plain; - - hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, idx * sizeof (plain_t), sizeof (plain_t), &plain, 0, NULL, NULL); - - uint gidvid = plain.gidvid; - uint il_pos = plain.il_pos; - u64 crackpos = device_param->words_off; uint plain_buf[16] = { 0 }; u8 *plain_ptr = (u8 *) plain_buf; + unsigned int plain_len = 0; if (data.attack_mode == ATTACK_MODE_STRAIGHT) { - u64 gidd = gidvid; - u64 gidm = 0; - pw_t pw; - gidd_to_pw_t (device_param, gidd, &pw); + gidd_to_pw_t (device_param, gidvid, &pw); - for (int i = 0, j = gidm; i < 16; i++, j++) + for (int i = 0; i < 16; i++) { - plain_buf[i] = pw.i[j]; + plain_buf[i] = pw.i[i]; } plain_len = pw.pw_len; @@ -1958,16 +2007,13 @@ static void check_hash (hc_device_param_t *device_param, const uint salt_pos, co } else if (data.attack_mode == ATTACK_MODE_COMBI) { - u64 gidd = gidvid; - u64 gidm = 0; - pw_t pw; - gidd_to_pw_t (device_param, gidd, &pw); + gidd_to_pw_t (device_param, gidvid, &pw); - for (int i = 0, j = gidm; i < 16; i++, j++) + for (int i = 0; i < 16; i++) { - plain_buf[i] = pw.i[j]; + plain_buf[i] = pw.i[i]; } plain_len = pw.pw_len; @@ -2019,16 +2065,13 @@ static void check_hash (hc_device_param_t *device_param, const uint salt_pos, co } else if (data.attack_mode == ATTACK_MODE_HYBRID1) { - u64 gidd = gidvid; - u64 gidm = 0; - pw_t pw; - gidd_to_pw_t (device_param, gidd, &pw); + gidd_to_pw_t (device_param, gidvid, &pw); - for (int i = 0, j = gidm; i < 16; i++, j++) + for (int i = 0; i < 16; i++) { - plain_buf[i] = pw.i[j]; + plain_buf[i] = pw.i[i]; } plain_len = pw.pw_len; @@ -2053,16 +2096,13 @@ static void check_hash (hc_device_param_t *device_param, const uint salt_pos, co } else if (data.attack_mode == ATTACK_MODE_HYBRID2) { - u64 gidd = gidvid; - u64 gidm = 0; - pw_t pw; - gidd_to_pw_t (device_param, gidd, &pw); + gidd_to_pw_t (device_param, gidvid, &pw); - for (int i = 0, j = gidm; i < 16; i++, j++) + for (int i = 0; i < 16; i++) { - plain_buf[i] = pw.i[j]; + plain_buf[i] = pw.i[i]; } plain_len = pw.pw_len; @@ -2141,6 +2181,7 @@ static void check_hash (hc_device_param_t *device_param, const uint salt_pos, co out_fp = stdout; } + lock_file (out_fp); } else @@ -2218,33 +2259,33 @@ static void check_cracked (hc_device_param_t *device_param, const uint salt_pos) { salt_t *salt_buf = &data.salts_buf[salt_pos]; - int found = 0; + u32 num_cracked; - hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL); + hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL); - for (uint i = 0; i < device_param->kernel_threads; i++) if (device_param->result[i] == 1) found = 1; - - if (found == 1) + if (num_cracked) { // display hack (for weak hashes etc, it could be that there is still something to clear on the current line) log_info_nn (""); - hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL); + plain_t *cracked = (plain_t *) mycalloc (num_cracked, sizeof (plain_t)); + + hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_plain_bufs, CL_TRUE, 0, num_cracked * sizeof (plain_t), cracked, 0, NULL, NULL); uint cpt_cracked = 0; - for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++) - { - uint idx = salt_buf->digests_offset + digest_pos; + hc_thread_mutex_lock (mux_display); - if (data.digests_shown_tmp[idx] == 0) continue; + for (uint i = 0; i < num_cracked; i++) + { + const uint hash_pos = cracked[i].hash_pos; - if (data.digests_shown[idx] == 1) continue; + if (data.digests_shown[hash_pos] == 1) continue; if ((data.opts_type & OPTS_TYPE_PT_NEVERCRACK) == 0) { - data.digests_shown[idx] = 1; + data.digests_shown[hash_pos] = 1; data.digests_done++; @@ -2262,11 +2303,17 @@ static void check_cracked (hc_device_param_t *device_param, const uint salt_pos) if (data.salts_done == data.salts_cnt) data.devices_status = STATUS_CRACKED; - check_hash (device_param, salt_pos, digest_pos); + check_hash (device_param, &cracked[i]); } + hc_thread_mutex_unlock (mux_display); + + myfree (cracked); + if (cpt_cracked > 0) { + hc_thread_mutex_lock (mux_display); + data.cpt_buf[data.cpt_pos].timestamp = time (NULL); data.cpt_buf[data.cpt_pos].cracked = cpt_cracked; @@ -2275,6 +2322,8 @@ static void check_cracked (hc_device_param_t *device_param, const uint salt_pos) data.cpt_total += cpt_cracked; if (data.cpt_pos == CPT_BUF) data.cpt_pos = 0; + + hc_thread_mutex_unlock (mux_display); } if (data.opts_type & OPTS_TYPE_PT_NEVERCRACK) @@ -2288,146 +2337,320 @@ static void check_cracked (hc_device_param_t *device_param, const uint salt_pos) hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, salt_buf->digests_offset * sizeof (uint), salt_buf->digests_cnt * sizeof (uint), &data.digests_shown_tmp[salt_buf->digests_offset], 0, NULL, NULL); } - memset (device_param->result, 0, device_param->size_results); + num_cracked = 0; - hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, device_param->size_results, device_param->result, 0, NULL, NULL); + hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_result, CL_TRUE, 0, sizeof (u32), &num_cracked, 0, NULL, NULL); } } -static void save_hash () +// stolen from princeprocessor ;) + +typedef struct { - char *hashfile = data.hashfile; + FILE *fp; - char new_hashfile[256] = { 0 }; - char old_hashfile[256] = { 0 }; + char buf[BUFSIZ]; + int len; - snprintf (new_hashfile, 255, "%s.new", hashfile); - snprintf (old_hashfile, 255, "%s.old", hashfile); +} out_t; - unlink (new_hashfile); +static void out_flush (out_t *out) +{ + fwrite (out->buf, 1, out->len, out->fp); - char separator = data.separator; + out->len = 0; +} - FILE *fp = fopen (new_hashfile, "wb"); +static void out_push (out_t *out, const u8 *pw_buf, const int pw_len) +{ + char *ptr = out->buf + out->len; - if (fp == NULL) - { - log_error ("ERROR: %s: %s", new_hashfile, strerror (errno)); + memcpy (ptr, pw_buf, pw_len); - exit (-1); - } + ptr[pw_len] = '\n'; - for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++) + out->len += pw_len + 1; + + if (out->len >= BUFSIZ - 100) { - if (data.salts_shown[salt_pos] == 1) continue; + out_flush (out); + } +} - salt_t *salt_buf = &data.salts_buf[salt_pos]; +static void process_stdout (hc_device_param_t *device_param, const uint pws_cnt) +{ + out_t out; - for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++) - { - uint idx = salt_buf->digests_offset + digest_pos; + out.fp = stdout; + out.len = 0; - if (data.digests_shown[idx] == 1) continue; + uint plain_buf[16] = { 0 }; - if (data.hash_mode != 2500) - { - char out_buf[HCBUFSIZ] = { 0 }; + u8 *plain_ptr = (u8 *) plain_buf; - if (data.username == 1) - { - user_t *user = data.hash_info[idx]->user; + uint plain_len = 0; - uint i; + const uint il_cnt = device_param->kernel_params_buf32[30]; // ugly, i know - for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp); + if (data.attack_mode == ATTACK_MODE_STRAIGHT) + { + pw_t pw; - fputc (separator, fp); + for (uint gidvid = 0; gidvid < pws_cnt; gidvid++) + { + gidd_to_pw_t (device_param, gidvid, &pw); + + const uint pos = device_param->innerloop_pos; + + for (uint il_pos = 0; il_pos < il_cnt; il_pos++) + { + for (int i = 0; i < 8; i++) + { + plain_buf[i] = pw.i[i]; } - ascii_digest (out_buf, salt_pos, digest_pos); + plain_len = pw.pw_len; - fputs (out_buf, fp); + plain_len = apply_rules (data.kernel_rules_buf[pos + il_pos].cmds, &plain_buf[0], &plain_buf[4], plain_len); - log_out (fp, ""); + if (plain_len > data.pw_max) plain_len = data.pw_max; + + out_push (&out, plain_ptr, plain_len); } - else + } + } + else if (data.attack_mode == ATTACK_MODE_COMBI) + { + pw_t pw; + + for (uint gidvid = 0; gidvid < pws_cnt; gidvid++) + { + gidd_to_pw_t (device_param, gidvid, &pw); + + for (uint il_pos = 0; il_pos < il_cnt; il_pos++) { - hccap_t hccap; + for (int i = 0; i < 8; i++) + { + plain_buf[i] = pw.i[i]; + } - to_hccap_t (&hccap, salt_pos, digest_pos); + plain_len = pw.pw_len; - fwrite (&hccap, sizeof (hccap_t), 1, fp); + char *comb_buf = (char *) device_param->combs_buf[il_pos].i; + uint comb_len = device_param->combs_buf[il_pos].pw_len; + + if (data.combs_mode == COMBINATOR_MODE_BASE_LEFT) + { + memcpy (plain_ptr + plain_len, comb_buf, comb_len); + } + else + { + memmove (plain_ptr + comb_len, plain_ptr, plain_len); + + memcpy (plain_ptr, comb_buf, comb_len); + } + + plain_len += comb_len; + + if (data.pw_max != PW_DICTMAX1) + { + if (plain_len > data.pw_max) plain_len = data.pw_max; + } + + out_push (&out, plain_ptr, plain_len); } } } + else if (data.attack_mode == ATTACK_MODE_BF) + { + for (uint gidvid = 0; gidvid < pws_cnt; gidvid++) + { + for (uint il_pos = 0; il_pos < il_cnt; il_pos++) + { + 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; - fflush (fp); + uint l_start = device_param->kernel_params_mp_l_buf32[5]; + uint r_start = device_param->kernel_params_mp_r_buf32[5]; - fclose (fp); + uint l_stop = device_param->kernel_params_mp_l_buf32[4]; + uint r_stop = device_param->kernel_params_mp_r_buf32[4]; - unlink (old_hashfile); + sp_exec (l_off, (char *) plain_ptr + l_start, data.root_css_buf, data.markov_css_buf, l_start, l_start + l_stop); + sp_exec (r_off, (char *) plain_ptr + r_start, data.root_css_buf, data.markov_css_buf, r_start, r_start + r_stop); - if (rename (hashfile, old_hashfile) != 0) - { - log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno)); + plain_len = data.css_cnt; - exit (-1); + out_push (&out, plain_ptr, plain_len); + } + } } - - unlink (hashfile); - - if (rename (new_hashfile, hashfile) != 0) + else if (data.attack_mode == ATTACK_MODE_HYBRID1) { - log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno)); + pw_t pw; - exit (-1); - } + for (uint gidvid = 0; gidvid < pws_cnt; gidvid++) + { + gidd_to_pw_t (device_param, gidvid, &pw); - unlink (old_hashfile); -} + for (uint il_pos = 0; il_pos < il_cnt; il_pos++) + { + for (int i = 0; i < 8; i++) + { + plain_buf[i] = pw.i[i]; + } -static float find_kernel_power_div (const u64 total_left, const uint kernel_power_all) -{ - // function called only in case kernel_power_all > words_left + plain_len = pw.pw_len; - float kernel_power_div = (float) (total_left) / kernel_power_all; + u64 off = device_param->kernel_params_mp_buf64[3] + il_pos; - kernel_power_div += kernel_power_div / 100; + uint start = 0; + uint stop = device_param->kernel_params_mp_buf32[4]; - u32 kernel_power_new = (u32) (kernel_power_all * kernel_power_div); + sp_exec (off, (char *) plain_ptr + plain_len, data.root_css_buf, data.markov_css_buf, start, start + stop); - while (kernel_power_new < total_left) - { - kernel_power_div += kernel_power_div / 100; + plain_len += start + stop; - kernel_power_new = (u32) (kernel_power_all * kernel_power_div); + out_push (&out, plain_ptr, plain_len); + } + } } - - if (data.quiet == 0) + else if (data.attack_mode == ATTACK_MODE_HYBRID2) { - clear_prompt (); + pw_t pw; - //log_info (""); + for (uint gidvid = 0; gidvid < pws_cnt; gidvid++) + { + gidd_to_pw_t (device_param, gidvid, &pw); - log_info ("INFO: approaching final keyspace, workload adjusted"); - log_info (""); + for (uint il_pos = 0; il_pos < il_cnt; il_pos++) + { + for (int i = 0; i < 8; i++) + { + plain_buf[i] = pw.i[i]; + } - fprintf (stdout, "%s", PROMPT); + plain_len = pw.pw_len; - fflush (stdout); - } + u64 off = device_param->kernel_params_mp_buf64[3] + il_pos; - if ((kernel_power_all * kernel_power_div) < 8) return 1; + uint start = 0; + uint stop = device_param->kernel_params_mp_buf32[4]; - return kernel_power_div; + memmove (plain_ptr + stop, plain_ptr, plain_len); + + sp_exec (off, (char *) plain_ptr, data.root_css_buf, data.markov_css_buf, start, start + stop); + + plain_len += start + stop; + + out_push (&out, plain_ptr, plain_len); + } + } + } + + out_flush (&out); +} + +static void save_hash () +{ + char *hashfile = data.hashfile; + + char new_hashfile[256] = { 0 }; + char old_hashfile[256] = { 0 }; + + snprintf (new_hashfile, 255, "%s.new", hashfile); + snprintf (old_hashfile, 255, "%s.old", hashfile); + + unlink (new_hashfile); + + char separator = data.separator; + + FILE *fp = fopen (new_hashfile, "wb"); + + if (fp == NULL) + { + log_error ("ERROR: %s: %s", new_hashfile, strerror (errno)); + + exit (-1); + } + + for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++) + { + if (data.salts_shown[salt_pos] == 1) continue; + + salt_t *salt_buf = &data.salts_buf[salt_pos]; + + for (uint digest_pos = 0; digest_pos < salt_buf->digests_cnt; digest_pos++) + { + uint idx = salt_buf->digests_offset + digest_pos; + + if (data.digests_shown[idx] == 1) continue; + + if (data.hash_mode != 2500) + { + if (data.username == 1) + { + user_t *user = data.hash_info[idx]->user; + + uint i; + + for (i = 0; i < user->user_len; i++) fputc (user->user_name[i], fp); + + fputc (separator, fp); + } + + char out_buf[HCBUFSIZ]; // scratch buffer + + out_buf[0] = 0; + + ascii_digest (out_buf, salt_pos, digest_pos); + + fputs (out_buf, fp); + + fputc ('\n', fp); + } + else + { + hccap_t hccap; + + to_hccap_t (&hccap, salt_pos, digest_pos); + + fwrite (&hccap, sizeof (hccap_t), 1, fp); + } + } + } + + fflush (fp); + + fclose (fp); + + unlink (old_hashfile); + + if (rename (hashfile, old_hashfile) != 0) + { + log_error ("ERROR: Rename file '%s' to '%s': %s", hashfile, old_hashfile, strerror (errno)); + + exit (-1); + } + + unlink (hashfile); + + if (rename (new_hashfile, hashfile) != 0) + { + log_error ("ERROR: Rename file '%s' to '%s': %s", new_hashfile, hashfile, strerror (errno)); + + exit (-1); + } + + unlink (old_hashfile); } -static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update) +static void run_kernel (const uint kern_run, hc_device_param_t *device_param, const uint num, const uint event_update, const uint iteration) { uint num_elements = num; - device_param->kernel_params_buf32[30] = data.combs_mode; - device_param->kernel_params_buf32[31] = num; + device_param->kernel_params_buf32[33] = data.combs_mode; + device_param->kernel_params_buf32[34] = num; uint kernel_threads = device_param->kernel_threads; @@ -2444,9 +2667,6 @@ static void run_kernel (const uint kern_run, hc_device_param_t *device_param, co case KERN_RUN_3: kernel = device_param->kernel3; break; } - hc_clSetKernelArg (data.ocl, kernel, 21, sizeof (cl_uint), device_param->kernel_params[21]); - hc_clSetKernelArg (data.ocl, kernel, 22, sizeof (cl_uint), device_param->kernel_params[22]); - hc_clSetKernelArg (data.ocl, kernel, 23, sizeof (cl_uint), device_param->kernel_params[23]); hc_clSetKernelArg (data.ocl, kernel, 24, sizeof (cl_uint), device_param->kernel_params[24]); hc_clSetKernelArg (data.ocl, kernel, 25, sizeof (cl_uint), device_param->kernel_params[25]); hc_clSetKernelArg (data.ocl, kernel, 26, sizeof (cl_uint), device_param->kernel_params[26]); @@ -2455,6 +2675,9 @@ static void run_kernel (const uint kern_run, hc_device_param_t *device_param, co hc_clSetKernelArg (data.ocl, kernel, 29, sizeof (cl_uint), device_param->kernel_params[29]); hc_clSetKernelArg (data.ocl, kernel, 30, sizeof (cl_uint), device_param->kernel_params[30]); hc_clSetKernelArg (data.ocl, kernel, 31, sizeof (cl_uint), device_param->kernel_params[31]); + hc_clSetKernelArg (data.ocl, kernel, 32, sizeof (cl_uint), device_param->kernel_params[32]); + hc_clSetKernelArg (data.ocl, kernel, 33, sizeof (cl_uint), device_param->kernel_params[33]); + hc_clSetKernelArg (data.ocl, kernel, 34, sizeof (cl_uint), device_param->kernel_params[34]); cl_event event; @@ -2485,21 +2708,50 @@ static void run_kernel (const uint kern_run, hc_device_param_t *device_param, co hc_clFlush (data.ocl, device_param->command_queue); + if (device_param->nvidia_spin_damp) + { + if (data.devices_status == STATUS_RUNNING) + { + if (iteration < EXPECTED_ITERATIONS) + { + switch (kern_run) + { + case KERN_RUN_1: if (device_param->exec_us_prev1[iteration]) usleep (device_param->exec_us_prev1[iteration] * device_param->nvidia_spin_damp); break; + case KERN_RUN_2: if (device_param->exec_us_prev2[iteration]) usleep (device_param->exec_us_prev2[iteration] * device_param->nvidia_spin_damp); break; + case KERN_RUN_3: if (device_param->exec_us_prev3[iteration]) usleep (device_param->exec_us_prev3[iteration] * device_param->nvidia_spin_damp); break; + } + } + } + } + hc_clWaitForEvents (data.ocl, 1, &event); - if (event_update) - { - cl_ulong time_start; - cl_ulong time_end; + cl_ulong time_start; + cl_ulong time_end; + + hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL); + hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL); - hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_START, sizeof (time_start), &time_start, NULL); - hc_clGetEventProfilingInfo (data.ocl, event, CL_PROFILING_COMMAND_END, sizeof (time_end), &time_end, NULL); + const double exec_us = (double) (time_end - time_start) / 1000; - const double exec_time = (double) (time_end - time_start) / 1000000.0; + if (data.devices_status == STATUS_RUNNING) + { + if (iteration < EXPECTED_ITERATIONS) + { + switch (kern_run) + { + case KERN_RUN_1: device_param->exec_us_prev1[iteration] = exec_us; break; + case KERN_RUN_2: device_param->exec_us_prev2[iteration] = exec_us; break; + case KERN_RUN_3: device_param->exec_us_prev3[iteration] = exec_us; break; + } + } + } + if (event_update) + { uint exec_pos = device_param->exec_pos; - device_param->exec_ms[exec_pos] = exec_time; + device_param->exec_ms[exec_pos] = exec_us / 1000; exec_pos++; @@ -2626,11 +2878,59 @@ static void run_kernel_amp (hc_device_param_t *device_param, const uint num) hc_clFinish (data.ocl, device_param->command_queue); } +static void run_kernel_memset (hc_device_param_t *device_param, cl_mem buf, const uint value, const uint num) +{ + const u32 num16d = num / 16; + const u32 num16m = num % 16; + + if (num16d) + { + device_param->kernel_params_memset_buf32[1] = value; + device_param->kernel_params_memset_buf32[2] = num16d; + + uint kernel_threads = device_param->kernel_threads; + + uint num_elements = num16d; + + while (num_elements % kernel_threads) num_elements++; + + cl_kernel kernel = device_param->kernel_memset; + + hc_clSetKernelArg (data.ocl, kernel, 0, sizeof (cl_mem), (void *) &buf); + hc_clSetKernelArg (data.ocl, kernel, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]); + hc_clSetKernelArg (data.ocl, kernel, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]); + + const size_t global_work_size[3] = { num_elements, 1, 1 }; + const size_t local_work_size[3] = { kernel_threads, 1, 1 }; + + hc_clEnqueueNDRangeKernel (data.ocl, device_param->command_queue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL); + + hc_clFlush (data.ocl, device_param->command_queue); + + hc_clFinish (data.ocl, device_param->command_queue); + } + + if (num16m) + { + u32 tmp[4]; + + tmp[0] = value; + tmp[1] = value; + tmp[2] = value; + tmp[3] = value; + + hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, buf, CL_TRUE, num16d * 16, num16m, tmp, 0, NULL, NULL); + } +} + static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const size_t size) { + run_kernel_memset (device_param, buf, 0, size); + + /* int rc = -1; - if (device_param->opencl_v12 && device_param->vendor_id == VENDOR_ID_AMD) + if (device_param->opencl_v12 && device_param->platform_vendor_id == VENDOR_ID_AMD) { // So far tested, amd is the only supporting this OpenCL 1.2 function without segfaulting @@ -2661,10 +2961,18 @@ static void run_kernel_bzero (hc_device_param_t *device_param, cl_mem buf, const myfree (tmp); } + */ } -static void choose_kernel (hc_device_param_t *device_param, const uint attack_exec, const uint attack_mode, const uint opts_type, const salt_t *salt_buf, const uint highest_pw_len, const uint pws_cnt) +static void choose_kernel (hc_device_param_t *device_param, const uint attack_exec, const uint attack_mode, const uint opts_type, const salt_t *salt_buf, const uint highest_pw_len, const uint pws_cnt, const uint fast_iteration) { + if (data.hash_mode == 2000) + { + process_stdout (device_param, pws_cnt); + + return; + } + if (attack_exec == ATTACK_EXEC_INSIDE_KERNEL) { if (attack_mode == ATTACK_MODE_BF) @@ -2683,46 +2991,53 @@ static void choose_kernel (hc_device_param_t *device_param, const uint attack_ex if (highest_pw_len < 16) { - run_kernel (KERN_RUN_1, device_param, pws_cnt, true); + run_kernel (KERN_RUN_1, device_param, pws_cnt, true, fast_iteration); } else if (highest_pw_len < 32) { - run_kernel (KERN_RUN_2, device_param, pws_cnt, true); + run_kernel (KERN_RUN_2, device_param, pws_cnt, true, fast_iteration); } else { - run_kernel (KERN_RUN_3, device_param, pws_cnt, true); + run_kernel (KERN_RUN_3, device_param, pws_cnt, true, fast_iteration); } } else { run_kernel_amp (device_param, pws_cnt); - run_kernel (KERN_RUN_1, device_param, pws_cnt, false); + run_kernel (KERN_RUN_1, device_param, pws_cnt, false, 0); if (opts_type & OPTS_TYPE_HOOK12) { - run_kernel (KERN_RUN_12, device_param, pws_cnt, false); + run_kernel (KERN_RUN_12, device_param, pws_cnt, false, 0); + + hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL); + + // do something with data + + hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL); } uint iter = salt_buf->salt_iter; uint loop_step = device_param->kernel_loops; - for (uint loop_pos = 0; loop_pos < iter; loop_pos += loop_step) + for (uint loop_pos = 0, slow_iteration = 0; loop_pos < iter; loop_pos += loop_step, slow_iteration++) { uint loop_left = iter - loop_pos; loop_left = MIN (loop_left, loop_step); - device_param->kernel_params_buf32[25] = loop_pos; - device_param->kernel_params_buf32[26] = loop_left; + device_param->kernel_params_buf32[28] = loop_pos; + device_param->kernel_params_buf32[29] = loop_left; - run_kernel (KERN_RUN_2, device_param, pws_cnt, true); + run_kernel (KERN_RUN_2, device_param, pws_cnt, true, slow_iteration); if (data.devices_status == STATUS_CRACKED) break; if (data.devices_status == STATUS_ABORTED) break; if (data.devices_status == STATUS_QUIT) break; + if (data.devices_status == STATUS_BYPASS) break; /** * speed @@ -2750,7 +3065,7 @@ static void choose_kernel (hc_device_param_t *device_param, const uint attack_ex if (opts_type & OPTS_TYPE_HOOK23) { - run_kernel (KERN_RUN_23, device_param, pws_cnt, false); + run_kernel (KERN_RUN_23, device_param, pws_cnt, false, 0); hc_clEnqueueReadBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL); @@ -2759,7 +3074,7 @@ static void choose_kernel (hc_device_param_t *device_param, const uint attack_ex hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_hooks, CL_TRUE, 0, device_param->size_hooks, device_param->hooks_buf, 0, NULL, NULL); } - run_kernel (KERN_RUN_3, device_param, pws_cnt, false); + run_kernel (KERN_RUN_3, device_param, pws_cnt, false, 0); } } @@ -2785,7 +3100,35 @@ static void run_copy (hc_device_param_t *device_param, const uint pws_cnt) } else if (data.attack_kern == ATTACK_KERN_COMBI) { - if (data.attack_mode == ATTACK_MODE_HYBRID2) + if (data.attack_mode == ATTACK_MODE_COMBI) + { + if (data.combs_mode == COMBINATOR_MODE_BASE_RIGHT) + { + if (data.opts_type & OPTS_TYPE_PT_ADD01) + { + for (u32 i = 0; i < pws_cnt; i++) + { + const u32 pw_len = device_param->pws_buf[i].pw_len; + + u8 *ptr = (u8 *) device_param->pws_buf[i].i; + + ptr[pw_len] = 0x01; + } + } + else if (data.opts_type & OPTS_TYPE_PT_ADD80) + { + for (u32 i = 0; i < pws_cnt; i++) + { + const u32 pw_len = device_param->pws_buf[i].pw_len; + + u8 *ptr = (u8 *) device_param->pws_buf[i].i; + + ptr[pw_len] = 0x80; + } + } + } + } + else if (data.attack_mode == ATTACK_MODE_HYBRID2) { if (data.opts_type & OPTS_TYPE_PT_ADD01) { @@ -2825,19 +3168,19 @@ static void run_copy (hc_device_param_t *device_param, const uint pws_cnt) static double try_run (hc_device_param_t *device_param, const u32 kernel_accel, const u32 kernel_loops) { - const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * kernel_accel; + const u32 kernel_power_try = device_param->device_processors * device_param->kernel_threads * kernel_accel; - device_param->kernel_params_buf32[25] = 0; - device_param->kernel_params_buf32[26] = kernel_loops; // not a bug, both need to be set - device_param->kernel_params_buf32[27] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes + device_param->kernel_params_buf32[28] = 0; + device_param->kernel_params_buf32[29] = kernel_loops; // not a bug, both need to be set + device_param->kernel_params_buf32[30] = kernel_loops; // because there's two variables for inner iters for slow and fast hashes if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) { - run_kernel (KERN_RUN_1, device_param, kernel_power, true); + run_kernel (KERN_RUN_1, device_param, kernel_power_try, true, 0); } else { - run_kernel (KERN_RUN_2, device_param, kernel_power, true); + run_kernel (KERN_RUN_2, device_param, kernel_power_try, true, 0); } const double exec_ms_prev = get_avg_exec_time (device_param, 1); @@ -2858,53 +3201,88 @@ static void autotune (hc_device_param_t *device_param) u32 kernel_accel = kernel_accel_min; u32 kernel_loops = kernel_loops_min; - // init some fake words + // in this case the user specified a fixed -u and -n on the commandline + // no way to tune anything + // but we need to run a few caching rounds + + if ((kernel_loops_min == kernel_loops_max) && (kernel_accel_min == kernel_accel_max)) + { + if (data.hash_mode != 2000) + { + try_run (device_param, kernel_accel, kernel_loops); + try_run (device_param, kernel_accel, kernel_loops); + try_run (device_param, kernel_accel, kernel_loops); + try_run (device_param, kernel_accel, kernel_loops); + } + + device_param->kernel_accel = kernel_accel; + device_param->kernel_loops = kernel_loops; + + const u32 kernel_power = device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel; + + device_param->kernel_power = kernel_power; + + return; + } + + // from here it's clear we are allowed to autotune + // so let's init some fake words const u32 kernel_power_max = device_param->device_processors * device_param->kernel_threads * kernel_accel_max; - for (u32 i = 0; i < kernel_power_max; i++) + if (data.attack_kern == ATTACK_KERN_BF) { - device_param->pws_buf[i].i[0] = i; - device_param->pws_buf[i].i[1] = 0x01234567; - device_param->pws_buf[i].pw_len = 7; + run_kernel_memset (device_param, device_param->d_pws_buf, 7, kernel_power_max * sizeof (pw_t)); } + else + { + for (u32 i = 0; i < kernel_power_max; i++) + { + device_param->pws_buf[i].i[0] = i; + device_param->pws_buf[i].i[1] = 0x01234567; + device_param->pws_buf[i].pw_len = 7 + (i & 7); + } - hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL); + hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL); + } - if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL) + if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) + { + if (data.kernel_rules_cnt > 1) + { + hc_clEnqueueCopyBuffer (data.ocl, device_param->command_queue, device_param->d_rules, device_param->d_rules_c, 0, 0, MIN (kernel_loops_max, KERNEL_RULES) * sizeof (kernel_rule_t), 0, NULL, NULL); + } + } + else { run_kernel_amp (device_param, kernel_power_max); } - // begin actual testing + #define VERIFIER_CNT 1 - double exec_ms_final = try_run (device_param, kernel_accel, kernel_loops); + // first find out highest kernel-loops that stays below target_ms - if ((kernel_loops_min == kernel_loops_max) || (kernel_accel_min == kernel_accel_max)) + if (kernel_loops_min < kernel_loops_max) { - // we do this in case the user specified a fixed -u and -n on the commandline - // so we have a cached kernel for benchmark - - try_run (device_param, kernel_accel, kernel_loops); - try_run (device_param, kernel_accel, kernel_loops); - try_run (device_param, kernel_accel, kernel_loops); - try_run (device_param, kernel_accel, kernel_loops); - try_run (device_param, kernel_accel, kernel_loops); - } - - // first find out highest kernel-loops that stays below target_ms + for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1) + { + double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops); - #define STEPS_CNT 10 + for (int i = 0; i < VERIFIER_CNT; i++) + { + double exec_ms_v = try_run (device_param, kernel_accel_min, kernel_loops); - for (kernel_loops = kernel_loops_max; kernel_loops > kernel_loops_min; kernel_loops >>= 1) - { - double exec_ms = try_run (device_param, kernel_accel_min, kernel_loops); + exec_ms = MIN (exec_ms, exec_ms_v); + } - if (exec_ms < target_ms) break; + if (exec_ms < target_ms) break; + } } // now the same for kernel-accel but with the new kernel-loops from previous loop set + #define STEPS_CNT 10 + if (kernel_accel_min < kernel_accel_max) { for (int i = 0; i < STEPS_CNT; i++) @@ -2916,64 +3294,104 @@ static void autotune (hc_device_param_t *device_param) double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops); - if (exec_ms > target_ms) break; + for (int i = 0; i < VERIFIER_CNT; i++) + { + double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops); + + exec_ms = MIN (exec_ms, exec_ms_v); + } - exec_ms_final = exec_ms; + if (exec_ms > target_ms) break; kernel_accel = kernel_accel_try; } } - // there's a chance that we have a fixed kernel_loops but not a fixed kernel_accel - // in such a case the above function would not create any change - // we'll use the runtime to find out if we're allow to do last improvement + // at this point we want to know the actual runtime for the following reason: + // we need a reference for the balancing loop following up, and this + // the balancing loop can have an effect that the creates a new opportunity, for example: + // if the target is 95 ms and the current runtime is 48ms the above loop + // stopped the execution because the previous exec_ms was > 95ms + // due to the rebalance it's possible that the runtime reduces from 48ms to 47ms + // and this creates the possibility to double the workload -> 47 * 2 = 95ms, which is < 96ms + + double exec_ms_pre_final = try_run (device_param, kernel_accel, kernel_loops); + + for (int i = 0; i < VERIFIER_CNT; i++) + { + double exec_ms_pre_final_v = try_run (device_param, kernel_accel, kernel_loops); + + exec_ms_pre_final = MIN (exec_ms_pre_final, exec_ms_pre_final_v); + } + + u32 diff = kernel_loops - kernel_accel; - if (exec_ms_final > 0) + if ((kernel_loops_min < kernel_loops_max) && (kernel_accel_min < kernel_accel_max)) { - if ((exec_ms_final * 2) <= target_ms) + u32 kernel_accel_orig = kernel_accel; + u32 kernel_loops_orig = kernel_loops; + + for (u32 f = 1; f < 1024; f++) { - const double exec_left = target_ms / exec_ms_final; + const u32 kernel_accel_try = (float) kernel_accel_orig * f; + const u32 kernel_loops_try = (float) kernel_loops_orig / f; + + if (kernel_accel_try > kernel_accel_max) break; + if (kernel_loops_try < kernel_loops_min) break; + + u32 diff_new = kernel_loops_try - kernel_accel_try; - const double accel_left = kernel_accel_max / kernel_accel; + if (diff_new > diff) break; - const int exec_accel_min = MIN (exec_left, accel_left); // we want that to be int + diff_new = diff; - if (exec_accel_min >= 2) + double exec_ms = try_run (device_param, kernel_accel_try, kernel_loops_try); + + for (int i = 0; i < VERIFIER_CNT; i++) + { + double exec_ms_v = try_run (device_param, kernel_accel_try, kernel_loops_try); + + exec_ms = MIN (exec_ms, exec_ms_v); + } + + if (exec_ms < exec_ms_pre_final) { - kernel_accel *= exec_accel_min; + exec_ms_pre_final = exec_ms; + + kernel_accel = kernel_accel_try; + kernel_loops = kernel_loops_try; } } } - // balancing the workload turns out to be very efficient - - if (kernel_loops_min != kernel_loops_max) - { - const u32 kernel_power_balance = kernel_accel * kernel_loops; + const double exec_left = target_ms / exec_ms_pre_final; - u32 sqrtv; + const double accel_left = kernel_accel_max / kernel_accel; - for (sqrtv = 1; sqrtv < 0x100000; sqrtv++) - { - if ((sqrtv * sqrtv) >= kernel_power_balance) break; - } + const double exec_accel_min = MIN (exec_left, accel_left); // we want that to be int - const u32 kernel_accel_try = sqrtv; - const u32 kernel_loops_try = sqrtv; + if (exec_accel_min >= 1.0) + { + // this is safe to not overflow kernel_accel_max because of accel_left - if ((kernel_accel_try <= kernel_accel_max) && (kernel_loops_try >= kernel_loops_min)) - { - kernel_accel = kernel_accel_try; - kernel_loops = kernel_loops_try; - } + kernel_accel = (double) kernel_accel * exec_accel_min; } - // reset fake words + // reset them fake words + /* memset (device_param->pws_buf, 0, kernel_power_max * sizeof (pw_t)); hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL); hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_pws_amp_buf, CL_TRUE, 0, kernel_power_max * sizeof (pw_t), device_param->pws_buf, 0, NULL, NULL); + */ + + run_kernel_memset (device_param, device_param->d_pws_buf, 0, kernel_power_max * sizeof (pw_t)); + + if (data.attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL) + { + run_kernel_memset (device_param, device_param->d_pws_amp_buf, 0, kernel_power_max * sizeof (pw_t)); + } // reset timer @@ -2981,6 +3399,10 @@ static void autotune (hc_device_param_t *device_param) memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double)); + memset (device_param->exec_us_prev1, 0, EXPECTED_ITERATIONS * sizeof (double)); + memset (device_param->exec_us_prev2, 0, EXPECTED_ITERATIONS * sizeof (double)); + memset (device_param->exec_us_prev3, 0, EXPECTED_ITERATIONS * sizeof (double)); + // store device_param->kernel_accel = kernel_accel; @@ -2996,8 +3418,8 @@ static void autotune (hc_device_param_t *device_param) { 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); @@ -3074,9 +3496,9 @@ static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt) salt_t *salt_buf = &data.salts_buf[salt_pos]; - device_param->kernel_params_buf32[24] = salt_pos; - device_param->kernel_params_buf32[28] = salt_buf->digests_cnt; - device_param->kernel_params_buf32[29] = salt_buf->digests_offset; + device_param->kernel_params_buf32[27] = salt_pos; + device_param->kernel_params_buf32[31] = salt_buf->digests_cnt; + device_param->kernel_params_buf32[32] = salt_buf->digests_offset; FILE *combs_fp = device_param->combs_fp; @@ -3098,14 +3520,21 @@ static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt) if (data.devices_status == STATUS_QUIT) break; if (data.devices_status == STATUS_BYPASS) break; + uint fast_iteration = 0; + uint innerloop_left = innerloop_cnt - innerloop_pos; - if (innerloop_left > innerloop_step) innerloop_left = innerloop_step; + if (innerloop_left > innerloop_step) + { + innerloop_left = innerloop_step; + + fast_iteration = 1; + } device_param->innerloop_pos = innerloop_pos; device_param->innerloop_left = innerloop_left; - device_param->kernel_params_buf32[27] = innerloop_left; + device_param->kernel_params_buf32[30] = innerloop_left; // i think we can get rid of this if (innerloop_left == 0) @@ -3258,23 +3687,23 @@ static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt) hc_timer_set (&device_param->timer_speed); } - choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt); + choose_kernel (device_param, data.attack_exec, data.attack_mode, data.opts_type, salt_buf, highest_pw_len, pws_cnt, fast_iteration); if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint (); if (data.devices_status == STATUS_CRACKED) break; if (data.devices_status == STATUS_ABORTED) break; if (data.devices_status == STATUS_QUIT) break; + if (data.devices_status == STATUS_BYPASS) break; /** * result */ - hc_thread_mutex_lock (mux_display); - - check_cracked (device_param, salt_pos); - - hc_thread_mutex_unlock (mux_display); + if (data.benchmark == 0) + { + check_cracked (device_param, salt_pos); + } /** * progress @@ -3298,15 +3727,15 @@ static void run_cracker (hc_device_param_t *device_param, const uint pws_cnt) hc_timer_set (&device_param->timer_speed); - hc_thread_mutex_lock (mux_display); - // current speed + //hc_thread_mutex_lock (mux_display); + device_param->speed_cnt[speed_pos] = perf_sum_all; device_param->speed_ms[speed_pos] = speed_ms; - hc_thread_mutex_unlock (mux_display); + //hc_thread_mutex_unlock (mux_display); speed_pos++; @@ -3668,9 +4097,11 @@ static void *thread_monitor (void *p) uint status_left = data.status_timer; #ifdef HAVE_HWMON - uint hwmon_check = 0; + uint hwmon_check = 0; + + int slowdown_warnings = 0; - // these variables are mainly used for fan control (AMD only) + // these variables are mainly used for fan control int *fan_speed_chgd = (int *) mycalloc (data.devices_cnt, sizeof (int)); @@ -3679,12 +4110,10 @@ static void *thread_monitor (void *p) int *temp_diff_old = (int *) mycalloc (data.devices_cnt, sizeof (int)); int *temp_diff_sum = (int *) mycalloc (data.devices_cnt, sizeof (int)); - #ifdef HAVE_ADL int temp_threshold = 1; // degrees celcius int fan_speed_min = 15; // in percentage int fan_speed_max = 100; - #endif // HAVE_ADL time_t last_temp_check_time; #endif // HAVE_HWMON @@ -3728,13 +4157,70 @@ static void *thread_monitor (void *p) return (p); } - while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT)) + while (data.shutdown_inner == 0) { hc_sleep (sleep_time); if (data.devices_status != STATUS_RUNNING) continue; #ifdef HAVE_HWMON + + if (hwmon_check == 1) + { + hc_thread_mutex_lock (mux_adl); + + for (uint device_id = 0; device_id < data.devices_cnt; device_id++) + { + hc_device_param_t *device_param = &data.devices_param[device_id]; + + if (device_param->skipped) continue; + + if (device_param->device_vendor_id == VENDOR_ID_NV) + { + if (data.hm_nvapi) + { + NV_GPU_PERF_POLICIES_INFO_PARAMS_V1 perfPolicies_info = { 0 }; + NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1 perfPolicies_status = { 0 }; + + perfPolicies_info.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_INFO_PARAMS_V1, 1); + perfPolicies_status.version = MAKE_NVAPI_VERSION (NV_GPU_PERF_POLICIES_STATUS_PARAMS_V1, 1); + + hm_NvAPI_GPU_GetPerfPoliciesInfo (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_info); + + perfPolicies_status.info_value = perfPolicies_info.info_value; + + hm_NvAPI_GPU_GetPerfPoliciesStatus (data.hm_nvapi, data.hm_device[device_id].nvapi, &perfPolicies_status); + + if (perfPolicies_status.throttle & 2) + { + if (slowdown_warnings < 3) + { + if (data.quiet == 0) clear_prompt (); + + log_info ("WARNING: Drivers temperature threshold hit on GPU #%d, expect performance to drop...", device_id + 1); + + if (slowdown_warnings == 2) + { + log_info (""); + } + + if (data.quiet == 0) fprintf (stdout, "%s", PROMPT); + if (data.quiet == 0) fflush (stdout); + + slowdown_warnings++; + } + } + else + { + slowdown_warnings = 0; + } + } + } + } + + hc_thread_mutex_unlock (mux_adl); + } + if (hwmon_check == 1) { hc_thread_mutex_lock (mux_adl); @@ -3766,12 +4252,11 @@ static void *thread_monitor (void *p) break; } - #ifdef HAVE_ADL const int gpu_temp_retain = data.gpu_temp_retain; - if (gpu_temp_retain) // VENDOR_ID_AMD implied + if (gpu_temp_retain) { - if (data.hm_device[device_id].fan_supported == 1) + if (data.hm_device[device_id].fan_set_supported == 1) { int temp_cur = temperature; @@ -3811,7 +4296,20 @@ static void *thread_monitor (void *p) if ((freely_change_fan_speed == 1) || (fan_speed_must_change == 1)) { - hm_set_fanspeed_with_device_id_amd (device_id, fan_speed_new); + if (device_param->device_vendor_id == VENDOR_ID_AMD) + { + hm_set_fanspeed_with_device_id_adl (device_id, fan_speed_new, 1); + } + else if (device_param->device_vendor_id == VENDOR_ID_NV) + { + #ifdef WIN + hm_set_fanspeed_with_device_id_nvapi (device_id, fan_speed_new, 1); + #endif + + #ifdef LINUX + hm_set_fanspeed_with_device_id_xnvctrl (device_id, fan_speed_new); + #endif + } fan_speed_chgd[device_id] = 1; } @@ -3821,7 +4319,6 @@ static void *thread_monitor (void *p) } } } - #endif // HAVE_ADL } hc_thread_mutex_unlock (mux_adl); @@ -3846,7 +4343,7 @@ static void *thread_monitor (void *p) time (&runtime_cur); - int runtime_left = data.runtime_start + data.runtime - runtime_cur; + int runtime_left = data.proc_start + data.runtime - runtime_cur; if (runtime_left <= 0) { @@ -3949,7 +4446,7 @@ static void *thread_outfile_remove (void *p) uint check_left = outfile_check_timer; // or 1 if we want to check it at startup - while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT)) + while (data.shutdown_inner == 0) { hc_sleep (1); @@ -4211,8 +4708,8 @@ static void *thread_outfile_remove (void *p) static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len) { - if (device_param->pws_cnt < device_param->kernel_power) - { + //if (device_param->pws_cnt < device_param->kernel_power) + //{ pw_t *pw = (pw_t *) device_param->pws_buf + device_param->pws_cnt; u8 *ptr = (u8 *) pw->i; @@ -4224,51 +4721,76 @@ static void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw->pw_len = pw_len; device_param->pws_cnt++; + //} + //else + //{ + // fprintf (stderr, "BUG pw_add()!!\n"); + // + // return; + //} +} + +static void set_kernel_power_final (const u64 kernel_power_final) +{ + if (data.quiet == 0) + { + clear_prompt (); + + //log_info (""); + + log_info ("INFO: approaching final keyspace, workload adjusted"); + log_info (""); + + fprintf (stdout, "%s", PROMPT); + + fflush (stdout); } - else + + data.kernel_power_final = kernel_power_final; +} + +static u32 get_power (hc_device_param_t *device_param) +{ + const u64 kernel_power_final = data.kernel_power_final; + + if (kernel_power_final) { - fprintf (stderr, "BUG pw_add()!!\n"); + const double device_factor = (double) device_param->hardware_power / data.hardware_power_all; - return; + const u64 words_left_device = CEIL ((double) kernel_power_final * device_factor); + + // work should be at least the hardware power available without any accelerator + + const u64 work = MAX (words_left_device, device_param->hardware_power); + + return work; } + + return device_param->kernel_power; } -static uint get_work (hc_device_param_t *device_param, const u64 max, const bool allow_div) +static uint get_work (hc_device_param_t *device_param, const u64 max) { hc_thread_mutex_lock (mux_dispatcher); const u64 words_cur = data.words_cur; - const u64 words_base = (data.limit == 0) ? data.words_base : data.limit; + const u64 words_base = (data.limit == 0) ? data.words_base : MIN (data.limit, data.words_base); device_param->words_off = words_cur; + const u64 kernel_power_all = data.kernel_power_all; + const u64 words_left = words_base - words_cur; - if (allow_div) + if (words_left < kernel_power_all) { - if (data.kernel_power_all > words_left) - { - if (data.kernel_power_div == 0) - { - data.kernel_power_div = find_kernel_power_div (words_left, data.kernel_power_all); - } - } - - if (data.kernel_power_div) + if (data.kernel_power_final == 0) { - if (device_param->kernel_power == device_param->kernel_power_user) - { - const u32 kernel_power_new = (float) device_param->kernel_power * data.kernel_power_div; - - if (kernel_power_new < device_param->kernel_power) - { - device_param->kernel_power = kernel_power_new; - } - } + set_kernel_power_final (words_left); } } - const uint kernel_power = device_param->kernel_power; + const u32 kernel_power = get_power (device_param); uint work = MIN (words_left, kernel_power); @@ -4281,7 +4803,7 @@ static uint get_work (hc_device_param_t *device_param, const u64 max, const bool return work; } -static void *thread_calc_stdin (void *p) +static void *thread_autotune (void *p) { hc_device_param_t *device_param = (hc_device_param_t *) p; @@ -4289,13 +4811,20 @@ static void *thread_calc_stdin (void *p) autotune (device_param); + return NULL; +} + +static void *thread_calc_stdin (void *p) +{ + hc_device_param_t *device_param = (hc_device_param_t *) p; + + if (device_param->skipped) return NULL; + char *buf = (char *) mymalloc (HCBUFSIZ); const uint attack_kern = data.attack_kern; - const uint kernel_power = device_param->kernel_power; - - while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT)) + while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT)) { hc_thread_mutex_lock (mux_dispatcher); @@ -4308,7 +4837,7 @@ static void *thread_calc_stdin (void *p) uint words_cur = 0; - while (words_cur < kernel_power) + while (words_cur < device_param->kernel_power) { char *line_buf = fgets (buf, HCBUFSIZ - 1, stdin); @@ -4342,6 +4871,8 @@ static void *thread_calc_stdin (void *p) continue; } + // hmm that's always the case, or? + if (attack_kern == ATTACK_KERN_STRAIGHT) { if ((line_len < data.pw_min) || (line_len > data.pw_max)) @@ -4358,25 +4889,6 @@ static void *thread_calc_stdin (void *p) continue; } } - else if (attack_kern == ATTACK_KERN_COMBI) - { - // do not check if minimum restriction is satisfied (line_len >= data.pw_min) here - // since we still need to combine the plains - - if (line_len > data.pw_max) - { - hc_thread_mutex_lock (mux_counter); - - for (uint salt_pos = 0; salt_pos < data.salts_cnt; salt_pos++) - { - data.words_progress_rejected[salt_pos] += data.combs_cnt; - } - - hc_thread_mutex_unlock (mux_counter); - - continue; - } - } pw_add (device_param, (u8 *) line_buf, line_len); @@ -4407,6 +4919,8 @@ static void *thread_calc_stdin (void *p) device_param->pws_cnt = 0; + /* + still required? if (attack_kern == ATTACK_KERN_STRAIGHT) { run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c); @@ -4415,6 +4929,7 @@ static void *thread_calc_stdin (void *p) { run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs); } + */ } } @@ -4432,16 +4947,14 @@ static void *thread_calc (void *p) if (device_param->skipped) return NULL; - autotune (device_param); - const uint attack_mode = data.attack_mode; const uint attack_kern = data.attack_kern; if (attack_mode == ATTACK_MODE_BF) { - while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT)) + while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT)) { - const uint work = get_work (device_param, -1, true); + const uint work = get_work (device_param, -1); if (work == 0) break; @@ -4460,7 +4973,10 @@ static void *thread_calc (void *p) device_param->pws_cnt = 0; + /* + still required? run_kernel_bzero (device_param, device_param->d_bfs_c, device_param->size_bfs); + */ } if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint (); @@ -4548,23 +5064,21 @@ static void *thread_calc (void *p) u64 words_cur = 0; - while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT)) + while ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT)) { u64 words_off = 0; u64 words_fin = 0; - bool allow_div = true; - u64 max = -1; while (max) { - const uint work = get_work (device_param, max, allow_div); - - allow_div = false; + const uint work = get_work (device_param, max); if (work == 0) break; + max = 0; + words_off = device_param->words_off; words_fin = words_off + work; @@ -4573,8 +5087,6 @@ static void *thread_calc (void *p) for ( ; words_cur < words_off; words_cur++) get_next_word (wl_data, fd, &line_buf, &line_len); - max = 0; - for ( ; words_cur < words_fin; words_cur++) { get_next_word (wl_data, fd, &line_buf, &line_len); @@ -4679,6 +5191,8 @@ static void *thread_calc (void *p) device_param->pws_cnt = 0; + /* + still required? if (attack_kern == ATTACK_KERN_STRAIGHT) { run_kernel_bzero (device_param, device_param->d_rules_c, device_param->size_rules_c); @@ -4687,6 +5201,7 @@ static void *thread_calc (void *p) { run_kernel_bzero (device_param, device_param->d_combs_c, device_param->size_combs); } + */ } if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint (); @@ -4729,12 +5244,12 @@ static void weak_hash_check (hc_device_param_t *device_param, const uint salt_po salt_t *salt_buf = &data.salts_buf[salt_pos]; - device_param->kernel_params_buf32[24] = salt_pos; - device_param->kernel_params_buf32[27] = 1; - device_param->kernel_params_buf32[28] = salt_buf->digests_cnt; - device_param->kernel_params_buf32[29] = salt_buf->digests_offset; - device_param->kernel_params_buf32[30] = 0; - device_param->kernel_params_buf32[31] = 1; + device_param->kernel_params_buf32[27] = salt_pos; + device_param->kernel_params_buf32[30] = 1; + device_param->kernel_params_buf32[31] = salt_buf->digests_cnt; + device_param->kernel_params_buf32[32] = salt_buf->digests_offset; + device_param->kernel_params_buf32[33] = 0; + device_param->kernel_params_buf32[34] = 1; char *dictfile_old = data.dictfile; @@ -4752,11 +5267,11 @@ static void weak_hash_check (hc_device_param_t *device_param, const uint salt_po if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) { - run_kernel (KERN_RUN_1, device_param, 1, false); + run_kernel (KERN_RUN_1, device_param, 1, false, 0); } else { - run_kernel (KERN_RUN_1, device_param, 1, false); + run_kernel (KERN_RUN_1, device_param, 1, false, 0); uint loop_step = 16; @@ -4768,13 +5283,13 @@ static void weak_hash_check (hc_device_param_t *device_param, const uint salt_po loop_left = MIN (loop_left, loop_step); - device_param->kernel_params_buf32[25] = loop_pos; - device_param->kernel_params_buf32[26] = loop_left; + device_param->kernel_params_buf32[28] = loop_pos; + device_param->kernel_params_buf32[29] = loop_left; - run_kernel (KERN_RUN_2, device_param, 1, false); + run_kernel (KERN_RUN_2, device_param, 1, false, 0); } - run_kernel (KERN_RUN_3, device_param, 1, false); + run_kernel (KERN_RUN_3, device_param, 1, false, 0); } /** @@ -4787,14 +5302,14 @@ static void weak_hash_check (hc_device_param_t *device_param, const uint salt_po * cleanup */ - device_param->kernel_params_buf32[24] = 0; - device_param->kernel_params_buf32[25] = 0; - device_param->kernel_params_buf32[26] = 0; device_param->kernel_params_buf32[27] = 0; device_param->kernel_params_buf32[28] = 0; device_param->kernel_params_buf32[29] = 0; device_param->kernel_params_buf32[30] = 0; device_param->kernel_params_buf32[31] = 0; + device_param->kernel_params_buf32[32] = 0; + device_param->kernel_params_buf32[33] = 0; + device_param->kernel_params_buf32[34] = 0; data.dictfile = dictfile_old; @@ -5157,8 +5672,8 @@ static uint hlfmt_detect (FILE *fp, uint max_check) // wrapper around mymalloc for ADL -#if defined(HAVE_HWMON) && defined(HAVE_ADL) -void *__stdcall ADL_Main_Memory_Alloc (const int iSize) +#if defined(HAVE_HWMON) +void *HC_API_CALL ADL_Main_Memory_Alloc (const int iSize) { return mymalloc (iSize); } @@ -5214,8 +5729,38 @@ static uint generate_bitmaps (const uint digests_cnt, const uint dgst_size, cons * main */ +#ifdef WIN +void SetConsoleWindowSize (const int x) +{ + HANDLE h = GetStdHandle (STD_OUTPUT_HANDLE); + + if (h == INVALID_HANDLE_VALUE) return; + + CONSOLE_SCREEN_BUFFER_INFO bufferInfo; + + if (!GetConsoleScreenBufferInfo (h, &bufferInfo)) return; + + SMALL_RECT *sr = &bufferInfo.srWindow; + + sr->Right = MAX (sr->Right, x - 1); + + COORD co; + + co.X = sr->Right + 1; + co.Y = 9999; + + if (!SetConsoleScreenBufferSize (h, co)) return; + + if (!SetConsoleWindowInfo (h, TRUE, sr)) return; +} +#endif + int main (int argc, char **argv) { + #ifdef WIN + SetConsoleWindowSize (132); + #endif + /** * To help users a bit */ @@ -5251,6 +5796,8 @@ int main (int argc, char **argv) if (getenv ("POCL_KERNEL_CACHE") == NULL) putenv ((char *) "POCL_KERNEL_CACHE=0"); + umask (077); + /** * Real init */ @@ -5275,253 +5822,253 @@ int main (int argc, char **argv) * commandline parameters */ - uint usage = USAGE; - uint version = VERSION; - uint quiet = QUIET; - uint benchmark = BENCHMARK; - uint show = SHOW; - uint left = LEFT; - uint username = USERNAME; - uint remove = REMOVE; - uint remove_timer = REMOVE_TIMER; - u64 skip = SKIP; - u64 limit = LIMIT; - uint keyspace = KEYSPACE; - uint potfile_disable = POTFILE_DISABLE; - char *potfile_path = NULL; - uint debug_mode = DEBUG_MODE; - char *debug_file = NULL; - char *induction_dir = NULL; - char *outfile_check_dir = NULL; - uint force = FORCE; - uint runtime = RUNTIME; - uint hash_mode = HASH_MODE; - uint attack_mode = ATTACK_MODE; - uint markov_disable = MARKOV_DISABLE; - uint markov_classic = MARKOV_CLASSIC; - uint markov_threshold = MARKOV_THRESHOLD; - char *markov_hcstat = NULL; - char *outfile = NULL; - uint outfile_format = OUTFILE_FORMAT; - uint outfile_autohex = OUTFILE_AUTOHEX; - uint outfile_check_timer = OUTFILE_CHECK_TIMER; - uint restore = RESTORE; - uint restore_timer = RESTORE_TIMER; - uint restore_disable = RESTORE_DISABLE; - uint status = STATUS; - uint status_timer = STATUS_TIMER; - uint status_automat = STATUS_AUTOMAT; - uint loopback = LOOPBACK; - uint weak_hash_threshold = WEAK_HASH_THRESHOLD; - char *session = NULL; - uint hex_charset = HEX_CHARSET; - uint hex_salt = HEX_SALT; - uint hex_wordlist = HEX_WORDLIST; - uint rp_gen = RP_GEN; - uint rp_gen_func_min = RP_GEN_FUNC_MIN; - uint rp_gen_func_max = RP_GEN_FUNC_MAX; - uint rp_gen_seed = RP_GEN_SEED; - char *rule_buf_l = (char *) RULE_BUF_L; - char *rule_buf_r = (char *) RULE_BUF_R; - uint increment = INCREMENT; - uint increment_min = INCREMENT_MIN; - uint increment_max = INCREMENT_MAX; - char *cpu_affinity = NULL; - OCL_PTR *ocl = NULL; - char *opencl_devices = NULL; - char *opencl_platforms = NULL; - char *opencl_device_types = NULL; - uint opencl_vector_width = OPENCL_VECTOR_WIDTH; - char *truecrypt_keyfiles = NULL; - uint workload_profile = WORKLOAD_PROFILE; - uint kernel_accel = KERNEL_ACCEL; - uint kernel_loops = KERNEL_LOOPS; - uint gpu_temp_disable = GPU_TEMP_DISABLE; + uint usage = USAGE; + uint version = VERSION; + uint quiet = QUIET; + uint benchmark = BENCHMARK; + uint stdout_flag = STDOUT_FLAG; + uint show = SHOW; + uint left = LEFT; + uint username = USERNAME; + uint remove = REMOVE; + uint remove_timer = REMOVE_TIMER; + u64 skip = SKIP; + u64 limit = LIMIT; + uint keyspace = KEYSPACE; + uint potfile_disable = POTFILE_DISABLE; + char *potfile_path = NULL; + uint debug_mode = DEBUG_MODE; + char *debug_file = NULL; + char *induction_dir = NULL; + char *outfile_check_dir = NULL; + uint force = FORCE; + uint runtime = RUNTIME; + uint hash_mode = HASH_MODE; + uint attack_mode = ATTACK_MODE; + uint markov_disable = MARKOV_DISABLE; + uint markov_classic = MARKOV_CLASSIC; + uint markov_threshold = MARKOV_THRESHOLD; + char *markov_hcstat = NULL; + char *outfile = NULL; + uint outfile_format = OUTFILE_FORMAT; + uint outfile_autohex = OUTFILE_AUTOHEX; + uint outfile_check_timer = OUTFILE_CHECK_TIMER; + uint restore = RESTORE; + uint restore_timer = RESTORE_TIMER; + uint restore_disable = RESTORE_DISABLE; + uint status = STATUS; + uint status_timer = STATUS_TIMER; + uint machine_readable = MACHINE_READABLE; + uint loopback = LOOPBACK; + uint weak_hash_threshold = WEAK_HASH_THRESHOLD; + char *session = NULL; + uint hex_charset = HEX_CHARSET; + uint hex_salt = HEX_SALT; + uint hex_wordlist = HEX_WORDLIST; + uint rp_gen = RP_GEN; + uint rp_gen_func_min = RP_GEN_FUNC_MIN; + uint rp_gen_func_max = RP_GEN_FUNC_MAX; + uint rp_gen_seed = RP_GEN_SEED; + char *rule_buf_l = (char *) RULE_BUF_L; + char *rule_buf_r = (char *) RULE_BUF_R; + uint increment = INCREMENT; + uint increment_min = INCREMENT_MIN; + uint increment_max = INCREMENT_MAX; + char *cpu_affinity = NULL; + OCL_PTR *ocl = NULL; + char *opencl_devices = NULL; + char *opencl_platforms = NULL; + char *opencl_device_types = NULL; + uint opencl_vector_width = OPENCL_VECTOR_WIDTH; + char *truecrypt_keyfiles = NULL; + char *veracrypt_keyfiles = NULL; + uint veracrypt_pim = 0; + uint workload_profile = WORKLOAD_PROFILE; + uint kernel_accel = KERNEL_ACCEL; + uint kernel_loops = KERNEL_LOOPS; + uint nvidia_spin_damp = NVIDIA_SPIN_DAMP; + uint gpu_temp_disable = GPU_TEMP_DISABLE; #ifdef HAVE_HWMON - uint gpu_temp_abort = GPU_TEMP_ABORT; - uint gpu_temp_retain = GPU_TEMP_RETAIN; - #ifdef HAVE_ADL - uint powertune_enable = POWERTUNE_ENABLE; + uint gpu_temp_abort = GPU_TEMP_ABORT; + uint gpu_temp_retain = GPU_TEMP_RETAIN; + uint powertune_enable = POWERTUNE_ENABLE; #endif - #endif - uint logfile_disable = LOGFILE_DISABLE; - uint segment_size = SEGMENT_SIZE; - uint scrypt_tmto = SCRYPT_TMTO; - char separator = SEPARATOR; - uint bitmap_min = BITMAP_MIN; - uint bitmap_max = BITMAP_MAX; - char *custom_charset_1 = NULL; - char *custom_charset_2 = NULL; - char *custom_charset_3 = NULL; - char *custom_charset_4 = NULL; - - #define IDX_HELP 'h' - #define IDX_VERSION 'V' - #define IDX_VERSION_LOWER 'v' - #define IDX_QUIET 0xff02 - #define IDX_SHOW 0xff03 - #define IDX_LEFT 0xff04 - #define IDX_REMOVE 0xff05 - #define IDX_REMOVE_TIMER 0xff37 - #define IDX_SKIP 's' - #define IDX_LIMIT 'l' - #define IDX_KEYSPACE 0xff35 - #define IDX_POTFILE_DISABLE 0xff06 - #define IDX_POTFILE_PATH 0xffe0 - #define IDX_DEBUG_MODE 0xff43 - #define IDX_DEBUG_FILE 0xff44 - #define IDX_INDUCTION_DIR 0xff46 - #define IDX_OUTFILE_CHECK_DIR 0xff47 - #define IDX_USERNAME 0xff07 - #define IDX_FORCE 0xff08 - #define IDX_RUNTIME 0xff09 - #define IDX_BENCHMARK 'b' - #define IDX_HASH_MODE 'm' - #define IDX_ATTACK_MODE 'a' - #define IDX_RP_FILE 'r' - #define IDX_RP_GEN 'g' - #define IDX_RP_GEN_FUNC_MIN 0xff10 - #define IDX_RP_GEN_FUNC_MAX 0xff11 - #define IDX_RP_GEN_SEED 0xff34 - #define IDX_RULE_BUF_L 'j' - #define IDX_RULE_BUF_R 'k' - #define IDX_INCREMENT 'i' - #define IDX_INCREMENT_MIN 0xff12 - #define IDX_INCREMENT_MAX 0xff13 - #define IDX_OUTFILE 'o' - #define IDX_OUTFILE_FORMAT 0xff14 - #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39 - #define IDX_OUTFILE_CHECK_TIMER 0xff45 - #define IDX_RESTORE 0xff15 - #define IDX_RESTORE_DISABLE 0xff27 - #define IDX_STATUS 0xff17 - #define IDX_STATUS_TIMER 0xff18 - #define IDX_STATUS_AUTOMAT 0xff50 - #define IDX_LOOPBACK 0xff38 - #define IDX_WEAK_HASH_THRESHOLD 0xff42 - #define IDX_SESSION 0xff19 - #define IDX_HEX_CHARSET 0xff20 - #define IDX_HEX_SALT 0xff21 - #define IDX_HEX_WORDLIST 0xff40 - #define IDX_MARKOV_DISABLE 0xff22 - #define IDX_MARKOV_CLASSIC 0xff23 - #define IDX_MARKOV_THRESHOLD 't' - #define IDX_MARKOV_HCSTAT 0xff24 - #define IDX_CPU_AFFINITY 0xff25 - #define IDX_OPENCL_DEVICES 'd' - #define IDX_OPENCL_PLATFORMS 0xff72 - #define IDX_OPENCL_DEVICE_TYPES 0xff73 - #define IDX_OPENCL_VECTOR_WIDTH 0xff74 - #define IDX_WORKLOAD_PROFILE 'w' - #define IDX_KERNEL_ACCEL 'n' - #define IDX_KERNEL_LOOPS 'u' - #define IDX_GPU_TEMP_DISABLE 0xff29 - #define IDX_GPU_TEMP_ABORT 0xff30 - #define IDX_GPU_TEMP_RETAIN 0xff31 - #define IDX_POWERTUNE_ENABLE 0xff41 - #define IDX_LOGFILE_DISABLE 0xff51 - #define IDX_TRUECRYPT_KEYFILES 0xff52 - #define IDX_SCRYPT_TMTO 0xff61 - #define IDX_SEGMENT_SIZE 'c' - #define IDX_SEPARATOR 'p' - #define IDX_BITMAP_MIN 0xff70 - #define IDX_BITMAP_MAX 0xff71 - #define IDX_CUSTOM_CHARSET_1 '1' - #define IDX_CUSTOM_CHARSET_2 '2' - #define IDX_CUSTOM_CHARSET_3 '3' - #define IDX_CUSTOM_CHARSET_4 '4' - - char short_options[] = "hVvm:a:r:j:k:g:o:t:d:n:u:c:p:s:l:1:2:3:4:ibw:"; + uint logfile_disable = LOGFILE_DISABLE; + uint segment_size = SEGMENT_SIZE; + uint scrypt_tmto = SCRYPT_TMTO; + char separator = SEPARATOR; + uint bitmap_min = BITMAP_MIN; + uint bitmap_max = BITMAP_MAX; + char *custom_charset_1 = NULL; + char *custom_charset_2 = NULL; + char *custom_charset_3 = NULL; + char *custom_charset_4 = NULL; + + #define IDX_HELP 'h' + #define IDX_VERSION 'V' + #define IDX_VERSION_LOWER 'v' + #define IDX_QUIET 0xff02 + #define IDX_SHOW 0xff03 + #define IDX_LEFT 0xff04 + #define IDX_REMOVE 0xff05 + #define IDX_REMOVE_TIMER 0xff37 + #define IDX_SKIP 's' + #define IDX_LIMIT 'l' + #define IDX_KEYSPACE 0xff35 + #define IDX_POTFILE_DISABLE 0xff06 + #define IDX_POTFILE_PATH 0xffe0 + #define IDX_DEBUG_MODE 0xff43 + #define IDX_DEBUG_FILE 0xff44 + #define IDX_INDUCTION_DIR 0xff46 + #define IDX_OUTFILE_CHECK_DIR 0xff47 + #define IDX_USERNAME 0xff07 + #define IDX_FORCE 0xff08 + #define IDX_RUNTIME 0xff09 + #define IDX_BENCHMARK 'b' + #define IDX_STDOUT_FLAG 0xff77 + #define IDX_HASH_MODE 'm' + #define IDX_ATTACK_MODE 'a' + #define IDX_RP_FILE 'r' + #define IDX_RP_GEN 'g' + #define IDX_RP_GEN_FUNC_MIN 0xff10 + #define IDX_RP_GEN_FUNC_MAX 0xff11 + #define IDX_RP_GEN_SEED 0xff34 + #define IDX_RULE_BUF_L 'j' + #define IDX_RULE_BUF_R 'k' + #define IDX_INCREMENT 'i' + #define IDX_INCREMENT_MIN 0xff12 + #define IDX_INCREMENT_MAX 0xff13 + #define IDX_OUTFILE 'o' + #define IDX_OUTFILE_FORMAT 0xff14 + #define IDX_OUTFILE_AUTOHEX_DISABLE 0xff39 + #define IDX_OUTFILE_CHECK_TIMER 0xff45 + #define IDX_RESTORE 0xff15 + #define IDX_RESTORE_DISABLE 0xff27 + #define IDX_STATUS 0xff17 + #define IDX_STATUS_TIMER 0xff18 + #define IDX_MACHINE_READABLE 0xff50 + #define IDX_LOOPBACK 0xff38 + #define IDX_WEAK_HASH_THRESHOLD 0xff42 + #define IDX_SESSION 0xff19 + #define IDX_HEX_CHARSET 0xff20 + #define IDX_HEX_SALT 0xff21 + #define IDX_HEX_WORDLIST 0xff40 + #define IDX_MARKOV_DISABLE 0xff22 + #define IDX_MARKOV_CLASSIC 0xff23 + #define IDX_MARKOV_THRESHOLD 't' + #define IDX_MARKOV_HCSTAT 0xff24 + #define IDX_CPU_AFFINITY 0xff25 + #define IDX_OPENCL_DEVICES 'd' + #define IDX_OPENCL_PLATFORMS 0xff72 + #define IDX_OPENCL_DEVICE_TYPES 'D' + #define IDX_OPENCL_VECTOR_WIDTH 0xff74 + #define IDX_WORKLOAD_PROFILE 'w' + #define IDX_KERNEL_ACCEL 'n' + #define IDX_KERNEL_LOOPS 'u' + #define IDX_NVIDIA_SPIN_DAMP 0xff79 + #define IDX_GPU_TEMP_DISABLE 0xff29 + #define IDX_GPU_TEMP_ABORT 0xff30 + #define IDX_GPU_TEMP_RETAIN 0xff31 + #define IDX_POWERTUNE_ENABLE 0xff41 + #define IDX_LOGFILE_DISABLE 0xff51 + #define IDX_TRUECRYPT_KEYFILES 0xff52 + #define IDX_VERACRYPT_KEYFILES 0xff53 + #define IDX_VERACRYPT_PIM 0xff54 + #define IDX_SCRYPT_TMTO 0xff61 + #define IDX_SEGMENT_SIZE 'c' + #define IDX_SEPARATOR 'p' + #define IDX_BITMAP_MIN 0xff70 + #define IDX_BITMAP_MAX 0xff71 + #define IDX_CUSTOM_CHARSET_1 '1' + #define IDX_CUSTOM_CHARSET_2 '2' + #define IDX_CUSTOM_CHARSET_3 '3' + #define IDX_CUSTOM_CHARSET_4 '4' + + char short_options[] = "hVvm:a:r:j:k:g:o:t:d:D:n:u:c:p:s:l:1:2:3:4:ibw:"; struct option long_options[] = { - {"help", no_argument, 0, IDX_HELP}, - {"version", no_argument, 0, IDX_VERSION}, - {"quiet", no_argument, 0, IDX_QUIET}, - {"show", no_argument, 0, IDX_SHOW}, - {"left", no_argument, 0, IDX_LEFT}, - {"username", no_argument, 0, IDX_USERNAME}, - {"remove", no_argument, 0, IDX_REMOVE}, - {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER}, - {"skip", required_argument, 0, IDX_SKIP}, - {"limit", required_argument, 0, IDX_LIMIT}, - {"keyspace", no_argument, 0, IDX_KEYSPACE}, - {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE}, - {"potfile-path", required_argument, 0, IDX_POTFILE_PATH}, - {"debug-mode", required_argument, 0, IDX_DEBUG_MODE}, - {"debug-file", required_argument, 0, IDX_DEBUG_FILE}, - {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR}, - {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR}, - {"force", no_argument, 0, IDX_FORCE}, - {"benchmark", no_argument, 0, IDX_BENCHMARK}, - {"restore", no_argument, 0, IDX_RESTORE}, - {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE}, - {"status", no_argument, 0, IDX_STATUS}, - {"status-timer", required_argument, 0, IDX_STATUS_TIMER}, - {"status-automat", no_argument, 0, IDX_STATUS_AUTOMAT}, - {"loopback", no_argument, 0, IDX_LOOPBACK}, - {"weak-hash-threshold", - required_argument, 0, IDX_WEAK_HASH_THRESHOLD}, - {"session", required_argument, 0, IDX_SESSION}, - {"runtime", required_argument, 0, IDX_RUNTIME}, - {"generate-rules", required_argument, 0, IDX_RP_GEN}, - {"generate-rules-func-min", - required_argument, 0, IDX_RP_GEN_FUNC_MIN}, - {"generate-rules-func-max", - required_argument, 0, IDX_RP_GEN_FUNC_MAX}, - {"generate-rules-seed", - required_argument, 0, IDX_RP_GEN_SEED}, - {"rule-left", required_argument, 0, IDX_RULE_BUF_L}, - {"rule-right", required_argument, 0, IDX_RULE_BUF_R}, - {"hash-type", required_argument, 0, IDX_HASH_MODE}, - {"attack-mode", required_argument, 0, IDX_ATTACK_MODE}, - {"rules-file", required_argument, 0, IDX_RP_FILE}, - {"outfile", required_argument, 0, IDX_OUTFILE}, - {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT}, - {"outfile-autohex-disable", - no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE}, - {"outfile-check-timer", - required_argument, 0, IDX_OUTFILE_CHECK_TIMER}, - {"hex-charset", no_argument, 0, IDX_HEX_CHARSET}, - {"hex-salt", no_argument, 0, IDX_HEX_SALT}, - {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST}, - {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE}, - {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC}, - {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD}, - {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT}, - {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY}, - {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES}, - {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS}, - {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES}, - {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH}, - {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE}, - {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL}, - {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS}, - {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE}, + {"help", no_argument, 0, IDX_HELP}, + {"version", no_argument, 0, IDX_VERSION}, + {"quiet", no_argument, 0, IDX_QUIET}, + {"show", no_argument, 0, IDX_SHOW}, + {"left", no_argument, 0, IDX_LEFT}, + {"username", no_argument, 0, IDX_USERNAME}, + {"remove", no_argument, 0, IDX_REMOVE}, + {"remove-timer", required_argument, 0, IDX_REMOVE_TIMER}, + {"skip", required_argument, 0, IDX_SKIP}, + {"limit", required_argument, 0, IDX_LIMIT}, + {"keyspace", no_argument, 0, IDX_KEYSPACE}, + {"potfile-disable", no_argument, 0, IDX_POTFILE_DISABLE}, + {"potfile-path", required_argument, 0, IDX_POTFILE_PATH}, + {"debug-mode", required_argument, 0, IDX_DEBUG_MODE}, + {"debug-file", required_argument, 0, IDX_DEBUG_FILE}, + {"induction-dir", required_argument, 0, IDX_INDUCTION_DIR}, + {"outfile-check-dir", required_argument, 0, IDX_OUTFILE_CHECK_DIR}, + {"force", no_argument, 0, IDX_FORCE}, + {"benchmark", no_argument, 0, IDX_BENCHMARK}, + {"stdout", no_argument, 0, IDX_STDOUT_FLAG}, + {"restore", no_argument, 0, IDX_RESTORE}, + {"restore-disable", no_argument, 0, IDX_RESTORE_DISABLE}, + {"status", no_argument, 0, IDX_STATUS}, + {"status-timer", required_argument, 0, IDX_STATUS_TIMER}, + {"machine-readable", no_argument, 0, IDX_MACHINE_READABLE}, + {"loopback", no_argument, 0, IDX_LOOPBACK}, + {"weak-hash-threshold", required_argument, 0, IDX_WEAK_HASH_THRESHOLD}, + {"session", required_argument, 0, IDX_SESSION}, + {"runtime", required_argument, 0, IDX_RUNTIME}, + {"generate-rules", required_argument, 0, IDX_RP_GEN}, + {"generate-rules-func-min", required_argument, 0, IDX_RP_GEN_FUNC_MIN}, + {"generate-rules-func-max", required_argument, 0, IDX_RP_GEN_FUNC_MAX}, + {"generate-rules-seed", required_argument, 0, IDX_RP_GEN_SEED}, + {"rule-left", required_argument, 0, IDX_RULE_BUF_L}, + {"rule-right", required_argument, 0, IDX_RULE_BUF_R}, + {"hash-type", required_argument, 0, IDX_HASH_MODE}, + {"attack-mode", required_argument, 0, IDX_ATTACK_MODE}, + {"rules-file", required_argument, 0, IDX_RP_FILE}, + {"outfile", required_argument, 0, IDX_OUTFILE}, + {"outfile-format", required_argument, 0, IDX_OUTFILE_FORMAT}, + {"outfile-autohex-disable", no_argument, 0, IDX_OUTFILE_AUTOHEX_DISABLE}, + {"outfile-check-timer", required_argument, 0, IDX_OUTFILE_CHECK_TIMER}, + {"hex-charset", no_argument, 0, IDX_HEX_CHARSET}, + {"hex-salt", no_argument, 0, IDX_HEX_SALT}, + {"hex-wordlist", no_argument, 0, IDX_HEX_WORDLIST}, + {"markov-disable", no_argument, 0, IDX_MARKOV_DISABLE}, + {"markov-classic", no_argument, 0, IDX_MARKOV_CLASSIC}, + {"markov-threshold", required_argument, 0, IDX_MARKOV_THRESHOLD}, + {"markov-hcstat", required_argument, 0, IDX_MARKOV_HCSTAT}, + {"cpu-affinity", required_argument, 0, IDX_CPU_AFFINITY}, + {"opencl-devices", required_argument, 0, IDX_OPENCL_DEVICES}, + {"opencl-platforms", required_argument, 0, IDX_OPENCL_PLATFORMS}, + {"opencl-device-types", required_argument, 0, IDX_OPENCL_DEVICE_TYPES}, + {"opencl-vector-width", required_argument, 0, IDX_OPENCL_VECTOR_WIDTH}, + {"workload-profile", required_argument, 0, IDX_WORKLOAD_PROFILE}, + {"kernel-accel", required_argument, 0, IDX_KERNEL_ACCEL}, + {"kernel-loops", required_argument, 0, IDX_KERNEL_LOOPS}, + {"nvidia-spin-damp", required_argument, 0, IDX_NVIDIA_SPIN_DAMP}, + {"gpu-temp-disable", no_argument, 0, IDX_GPU_TEMP_DISABLE}, #ifdef HAVE_HWMON - {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT}, - {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN}, - #ifdef HAVE_ADL - {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE}, - #endif + {"gpu-temp-abort", required_argument, 0, IDX_GPU_TEMP_ABORT}, + {"gpu-temp-retain", required_argument, 0, IDX_GPU_TEMP_RETAIN}, + {"powertune-enable", no_argument, 0, IDX_POWERTUNE_ENABLE}, #endif // HAVE_HWMON - {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE}, - {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES}, - {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE}, - {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO}, - // deprecated - {"seperator", required_argument, 0, IDX_SEPARATOR}, - {"separator", required_argument, 0, IDX_SEPARATOR}, - {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN}, - {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX}, - {"increment", no_argument, 0, IDX_INCREMENT}, - {"increment-min", required_argument, 0, IDX_INCREMENT_MIN}, - {"increment-max", required_argument, 0, IDX_INCREMENT_MAX}, - {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1}, - {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2}, - {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3}, - {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4}, - + {"logfile-disable", no_argument, 0, IDX_LOGFILE_DISABLE}, + {"truecrypt-keyfiles", required_argument, 0, IDX_TRUECRYPT_KEYFILES}, + {"veracrypt-keyfiles", required_argument, 0, IDX_VERACRYPT_KEYFILES}, + {"veracrypt-pim", required_argument, 0, IDX_VERACRYPT_PIM}, + {"segment-size", required_argument, 0, IDX_SEGMENT_SIZE}, + {"scrypt-tmto", required_argument, 0, IDX_SCRYPT_TMTO}, + {"seperator", required_argument, 0, IDX_SEPARATOR}, + {"separator", required_argument, 0, IDX_SEPARATOR}, + {"bitmap-min", required_argument, 0, IDX_BITMAP_MIN}, + {"bitmap-max", required_argument, 0, IDX_BITMAP_MAX}, + {"increment", no_argument, 0, IDX_INCREMENT}, + {"increment-min", required_argument, 0, IDX_INCREMENT_MIN}, + {"increment-max", required_argument, 0, IDX_INCREMENT_MAX}, + {"custom-charset1", required_argument, 0, IDX_CUSTOM_CHARSET_1}, + {"custom-charset2", required_argument, 0, IDX_CUSTOM_CHARSET_2}, + {"custom-charset3", required_argument, 0, IDX_CUSTOM_CHARSET_3}, + {"custom-charset4", required_argument, 0, IDX_CUSTOM_CHARSET_4}, {0, 0, 0, 0} }; @@ -5718,6 +6265,7 @@ int main (int argc, char **argv) uint runtime_chgd = 0; uint kernel_loops_chgd = 0; uint kernel_accel_chgd = 0; + uint nvidia_spin_damp_chgd = 0; uint attack_mode_chgd = 0; uint outfile_format_chgd = 0; uint rp_gen_seed_chgd = 0; @@ -5727,11 +6275,6 @@ int main (int argc, char **argv) uint workload_profile_chgd = 0; uint opencl_vector_width_chgd = 0; - #if defined(HAVE_HWMON) && defined(HAVE_ADL) - uint gpu_temp_retain_chgd = 0; - uint gpu_temp_abort_chgd = 0; - #endif - optind = 1; optopt = 0; option_index = 0; @@ -5740,113 +6283,103 @@ int main (int argc, char **argv) { switch (c) { - //case IDX_HELP: usage = 1; break; - //case IDX_VERSION: version = 1; break; - //case IDX_RESTORE: restore = 1; break; - case IDX_QUIET: quiet = 1; break; - //case IDX_SHOW: show = 1; break; - case IDX_SHOW: break; - //case IDX_LEFT: left = 1; break; - case IDX_LEFT: break; - case IDX_USERNAME: username = 1; break; - case IDX_REMOVE: remove = 1; break; - case IDX_REMOVE_TIMER: remove_timer = atoi (optarg); - remove_timer_chgd = 1; break; - case IDX_POTFILE_DISABLE: potfile_disable = 1; break; - case IDX_POTFILE_PATH: potfile_path = optarg; break; - case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break; - case IDX_DEBUG_FILE: debug_file = optarg; break; - case IDX_INDUCTION_DIR: induction_dir = optarg; break; - case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break; - case IDX_FORCE: force = 1; break; - case IDX_SKIP: skip = atoll (optarg); break; - case IDX_LIMIT: limit = atoll (optarg); break; - case IDX_KEYSPACE: keyspace = 1; break; - case IDX_BENCHMARK: benchmark = 1; break; - case IDX_RESTORE: break; - case IDX_RESTORE_DISABLE: restore_disable = 1; break; - case IDX_STATUS: status = 1; break; - case IDX_STATUS_TIMER: status_timer = atoi (optarg); break; - case IDX_STATUS_AUTOMAT: status_automat = 1; break; - case IDX_LOOPBACK: loopback = 1; break; - case IDX_WEAK_HASH_THRESHOLD: - weak_hash_threshold = atoi (optarg); break; - //case IDX_SESSION: session = optarg; break; - case IDX_SESSION: break; - case IDX_HASH_MODE: hash_mode = atoi (optarg); - hash_mode_chgd = 1; break; - case IDX_RUNTIME: runtime = atoi (optarg); - runtime_chgd = 1; break; - case IDX_ATTACK_MODE: attack_mode = atoi (optarg); - attack_mode_chgd = 1; break; - case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break; - case IDX_RP_GEN: rp_gen = atoi (optarg); break; - case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break; - case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break; - case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg); - rp_gen_seed_chgd = 1; break; - case IDX_RULE_BUF_L: rule_buf_l = optarg; break; - case IDX_RULE_BUF_R: rule_buf_r = optarg; break; - case IDX_MARKOV_DISABLE: markov_disable = 1; break; - case IDX_MARKOV_CLASSIC: markov_classic = 1; break; - case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break; - case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break; - case IDX_OUTFILE: outfile = optarg; break; - case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg); - outfile_format_chgd = 1; break; - case IDX_OUTFILE_AUTOHEX_DISABLE: - outfile_autohex = 0; break; - case IDX_OUTFILE_CHECK_TIMER: - outfile_check_timer = atoi (optarg); break; - case IDX_HEX_CHARSET: hex_charset = 1; break; - case IDX_HEX_SALT: hex_salt = 1; break; - case IDX_HEX_WORDLIST: hex_wordlist = 1; break; - case IDX_CPU_AFFINITY: cpu_affinity = optarg; break; - case IDX_OPENCL_DEVICES: opencl_devices = optarg; break; - case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break; - case IDX_OPENCL_DEVICE_TYPES: - opencl_device_types = optarg; break; - case IDX_OPENCL_VECTOR_WIDTH: - opencl_vector_width = atoi (optarg); - opencl_vector_width_chgd = 1; break; - case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); - workload_profile_chgd = 1; break; - case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg); - kernel_accel_chgd = 1; break; - case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg); - kernel_loops_chgd = 1; break; - case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break; + //case IDX_HELP: usage = 1; break; + //case IDX_VERSION: version = 1; break; + //case IDX_RESTORE: restore = 1; break; + case IDX_QUIET: quiet = 1; break; + //case IDX_SHOW: show = 1; break; + case IDX_SHOW: break; + //case IDX_LEFT: left = 1; break; + case IDX_LEFT: break; + case IDX_USERNAME: username = 1; break; + case IDX_REMOVE: remove = 1; break; + case IDX_REMOVE_TIMER: remove_timer = atoi (optarg); + remove_timer_chgd = 1; break; + case IDX_POTFILE_DISABLE: potfile_disable = 1; break; + case IDX_POTFILE_PATH: potfile_path = optarg; break; + case IDX_DEBUG_MODE: debug_mode = atoi (optarg); break; + case IDX_DEBUG_FILE: debug_file = optarg; break; + case IDX_INDUCTION_DIR: induction_dir = optarg; break; + case IDX_OUTFILE_CHECK_DIR: outfile_check_dir = optarg; break; + case IDX_FORCE: force = 1; break; + case IDX_SKIP: skip = atoll (optarg); break; + case IDX_LIMIT: limit = atoll (optarg); break; + case IDX_KEYSPACE: keyspace = 1; break; + case IDX_BENCHMARK: benchmark = 1; break; + case IDX_STDOUT_FLAG: stdout_flag = 1; break; + case IDX_RESTORE: break; + case IDX_RESTORE_DISABLE: restore_disable = 1; break; + case IDX_STATUS: status = 1; break; + case IDX_STATUS_TIMER: status_timer = atoi (optarg); break; + case IDX_MACHINE_READABLE: machine_readable = 1; break; + case IDX_LOOPBACK: loopback = 1; break; + case IDX_WEAK_HASH_THRESHOLD: weak_hash_threshold = atoi (optarg); break; + //case IDX_SESSION: session = optarg; break; + case IDX_SESSION: break; + case IDX_HASH_MODE: hash_mode = atoi (optarg); + hash_mode_chgd = 1; break; + case IDX_RUNTIME: runtime = atoi (optarg); + runtime_chgd = 1; break; + case IDX_ATTACK_MODE: attack_mode = atoi (optarg); + attack_mode_chgd = 1; break; + case IDX_RP_FILE: rp_files[rp_files_cnt++] = optarg; break; + case IDX_RP_GEN: rp_gen = atoi (optarg); break; + case IDX_RP_GEN_FUNC_MIN: rp_gen_func_min = atoi (optarg); break; + case IDX_RP_GEN_FUNC_MAX: rp_gen_func_max = atoi (optarg); break; + case IDX_RP_GEN_SEED: rp_gen_seed = atoi (optarg); + rp_gen_seed_chgd = 1; break; + case IDX_RULE_BUF_L: rule_buf_l = optarg; break; + case IDX_RULE_BUF_R: rule_buf_r = optarg; break; + case IDX_MARKOV_DISABLE: markov_disable = 1; break; + case IDX_MARKOV_CLASSIC: markov_classic = 1; break; + case IDX_MARKOV_THRESHOLD: markov_threshold = atoi (optarg); break; + case IDX_MARKOV_HCSTAT: markov_hcstat = optarg; break; + case IDX_OUTFILE: outfile = optarg; break; + case IDX_OUTFILE_FORMAT: outfile_format = atoi (optarg); + outfile_format_chgd = 1; break; + case IDX_OUTFILE_AUTOHEX_DISABLE: outfile_autohex = 0; break; + case IDX_OUTFILE_CHECK_TIMER: outfile_check_timer = atoi (optarg); break; + case IDX_HEX_CHARSET: hex_charset = 1; break; + case IDX_HEX_SALT: hex_salt = 1; break; + case IDX_HEX_WORDLIST: hex_wordlist = 1; break; + case IDX_CPU_AFFINITY: cpu_affinity = optarg; break; + case IDX_OPENCL_DEVICES: opencl_devices = optarg; break; + case IDX_OPENCL_PLATFORMS: opencl_platforms = optarg; break; + case IDX_OPENCL_DEVICE_TYPES: opencl_device_types = optarg; break; + case IDX_OPENCL_VECTOR_WIDTH: opencl_vector_width = atoi (optarg); + opencl_vector_width_chgd = 1; break; + case IDX_WORKLOAD_PROFILE: workload_profile = atoi (optarg); + workload_profile_chgd = 1; break; + case IDX_KERNEL_ACCEL: kernel_accel = atoi (optarg); + kernel_accel_chgd = 1; break; + case IDX_KERNEL_LOOPS: kernel_loops = atoi (optarg); + kernel_loops_chgd = 1; break; + case IDX_NVIDIA_SPIN_DAMP: nvidia_spin_damp = atoi (optarg); + nvidia_spin_damp_chgd = 1; break; + case IDX_GPU_TEMP_DISABLE: gpu_temp_disable = 1; break; #ifdef HAVE_HWMON - case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); - #ifdef HAVE_ADL - gpu_temp_abort_chgd = 1; - #endif - break; - case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); - #ifdef HAVE_ADL - gpu_temp_retain_chgd = 1; - #endif - break; - #ifdef HAVE_ADL - case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break; - #endif + case IDX_GPU_TEMP_ABORT: gpu_temp_abort = atoi (optarg); break; + case IDX_GPU_TEMP_RETAIN: gpu_temp_retain = atoi (optarg); break; + case IDX_POWERTUNE_ENABLE: powertune_enable = 1; break; #endif // HAVE_HWMON - case IDX_LOGFILE_DISABLE: logfile_disable = 1; break; - case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break; - case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break; - case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break; - case IDX_SEPARATOR: separator = optarg[0]; break; - case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break; - case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break; - case IDX_INCREMENT: increment = 1; break; - case IDX_INCREMENT_MIN: increment_min = atoi (optarg); - increment_min_chgd = 1; break; - case IDX_INCREMENT_MAX: increment_max = atoi (optarg); - increment_max_chgd = 1; break; - case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break; - case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break; - case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break; - case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break; + case IDX_LOGFILE_DISABLE: logfile_disable = 1; break; + case IDX_TRUECRYPT_KEYFILES: truecrypt_keyfiles = optarg; break; + case IDX_VERACRYPT_KEYFILES: veracrypt_keyfiles = optarg; break; + case IDX_VERACRYPT_PIM: veracrypt_pim = atoi (optarg); break; + case IDX_SEGMENT_SIZE: segment_size = atoi (optarg); break; + case IDX_SCRYPT_TMTO: scrypt_tmto = atoi (optarg); break; + case IDX_SEPARATOR: separator = optarg[0]; break; + case IDX_BITMAP_MIN: bitmap_min = atoi (optarg); break; + case IDX_BITMAP_MAX: bitmap_max = atoi (optarg); break; + case IDX_INCREMENT: increment = 1; break; + case IDX_INCREMENT_MIN: increment_min = atoi (optarg); + increment_min_chgd = 1; break; + case IDX_INCREMENT_MAX: increment_max = atoi (optarg); + increment_max_chgd = 1; break; + case IDX_CUSTOM_CHARSET_1: custom_charset_1 = optarg; break; + case IDX_CUSTOM_CHARSET_2: custom_charset_2 = optarg; break; + case IDX_CUSTOM_CHARSET_3: custom_charset_3 = optarg; break; + case IDX_CUSTOM_CHARSET_4: custom_charset_4 = optarg; break; default: log_error ("ERROR: Invalid argument specified"); @@ -5871,7 +6404,7 @@ int main (int argc, char **argv) { if (benchmark == 1) { - if (status_automat == 0) + if (machine_readable == 0) { log_info ("%s (%s) starting in benchmark-mode...", PROGNAME, VERSION_TAG); log_info (""); @@ -5886,6 +6419,14 @@ int main (int argc, char **argv) log_info ("%s (%s) starting in restore-mode...", PROGNAME, VERSION_TAG); log_info (""); } + else if (stdout_flag == 1) + { + // do nothing + } + else if (keyspace == 1) + { + // do nothing + } else { log_info ("%s (%s) starting...", PROGNAME, VERSION_TAG); @@ -5911,7 +6452,7 @@ int main (int argc, char **argv) return (-1); } - if (hash_mode_chgd && hash_mode > 13600) // just added to remove compiler warnings for hash_mode_chgd + if (hash_mode_chgd && hash_mode > 13800) // just added to remove compiler warnings for hash_mode_chgd { log_error ("ERROR: Invalid hash-type specified"); @@ -5940,7 +6481,7 @@ int main (int argc, char **argv) if (username == 1) { - if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299))) + if ((hash_mode == 2500) || (hash_mode == 5200) || ((hash_mode >= 6200) && (hash_mode <= 6299)) || ((hash_mode >= 13700) && (hash_mode <= 13799))) { log_error ("ERROR: Mixing support for user names and hashes of type %s is not supported", strhashtype (hash_mode)); @@ -5961,7 +6502,7 @@ int main (int argc, char **argv) { 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); } @@ -5978,7 +6519,7 @@ int main (int argc, char **argv) { 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); } @@ -6008,21 +6549,21 @@ int main (int argc, char **argv) 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); } @@ -6053,6 +6594,16 @@ int main (int argc, char **argv) if (kernel_accel_chgd == 1) { + if (force == 0) + { + log_info ("The manual use of the -n option (or --kernel-accel) is outdated"); + log_info ("Please consider using the -w option instead"); + log_info ("You can use --force to override this but do not post error reports if you do so"); + log_info (""); + + return (-1); + } + if (kernel_accel < 1) { log_error ("ERROR: Invalid kernel-accel specified"); @@ -6070,6 +6621,16 @@ int main (int argc, char **argv) if (kernel_loops_chgd == 1) { + if (force == 0) + { + log_info ("The manual use of the -u option (or --kernel-loops) is outdated"); + log_info ("Please consider using the -w option instead"); + log_info ("You can use --force to override this but do not post error reports if you do so"); + log_info (""); + + return (-1); + } + if (kernel_loops < 1) { log_error ("ERROR: Invalid kernel-loops specified"); @@ -6085,7 +6646,7 @@ int main (int argc, char **argv) } } - if ((workload_profile < 1) || (workload_profile > 3)) + if ((workload_profile < 1) || (workload_profile > 4)) { log_error ("ERROR: workload-profile %i not available", workload_profile); @@ -6129,8 +6690,32 @@ int main (int argc, char **argv) case ATTACK_MODE_HYBRID2: attack_kern = ATTACK_KERN_COMBI; break; } - if (benchmark == 0) + if (benchmark == 1) + { + if (myargv[optind] != 0) + { + log_error ("ERROR: Invalid argument for benchmark mode specified"); + + return (-1); + } + + if (attack_mode_chgd == 1) + { + if (attack_mode != ATTACK_MODE_BF) + { + log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode"); + + return (-1); + } + } + } + else { + if (stdout_flag == 1) // no hash here + { + optind--; + } + if (keyspace == 1) { int num_additional_params = 1; @@ -6188,25 +6773,6 @@ int main (int argc, char **argv) return (-1); } } - else - { - if (myargv[optind] != 0) - { - log_error ("ERROR: Invalid argument for benchmark mode specified"); - - return (-1); - } - - if (attack_mode_chgd == 1) - { - if (attack_mode != ATTACK_MODE_BF) - { - log_error ("ERROR: Only attack-mode 3 allowed in benchmark mode"); - - return (-1); - } - } - } if (skip != 0 && limit != 0) { @@ -6217,13 +6783,13 @@ int main (int argc, char **argv) { 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); } @@ -6239,6 +6805,26 @@ int main (int argc, char **argv) quiet = 1; } + if (stdout_flag == 1) + { + status_timer = 0; + restore_timer = 0; + restore_disable = 1; + restore = 0; + potfile_disable = 1; + weak_hash_threshold = 0; + gpu_temp_disable = 1; + hash_mode = 2000; + quiet = 1; + outfile_format = OUTFILE_FMT_PLAIN; + kernel_accel = 1024; + kernel_loops = 1024; + force = 1; + outfile_check_timer = 0; + session = "stdout"; + opencl_vector_width = 1; + } + if (remove_timer_chgd == 1) { if (remove == 0) @@ -6331,6 +6917,14 @@ int main (int argc, char **argv) weak_hash_threshold = 0; } + if (nvidia_spin_damp > 100) + { + log_error ("ERROR: setting --nvidia-spin-damp must be between 0 and 100 (inclusive)"); + + return (-1); + } + + /** * induction directory */ @@ -6481,43 +7075,45 @@ int main (int argc, char **argv) * store stuff */ - data.hash_mode = hash_mode; - data.restore = restore; - data.restore_timer = restore_timer; - data.restore_disable = restore_disable; - data.status = status; - data.status_timer = status_timer; - data.status_automat = status_automat; - data.loopback = loopback; - data.runtime = runtime; - data.remove = remove; - data.remove_timer = remove_timer; - data.debug_mode = debug_mode; - data.debug_file = debug_file; - data.username = username; - data.quiet = quiet; - data.outfile = outfile; - data.outfile_format = outfile_format; - data.outfile_autohex = outfile_autohex; - data.hex_charset = hex_charset; - data.hex_salt = hex_salt; - data.hex_wordlist = hex_wordlist; - data.separator = separator; - data.rp_files = rp_files; - data.rp_files_cnt = rp_files_cnt; - data.rp_gen = rp_gen; - data.rp_gen_seed = rp_gen_seed; - data.force = force; - data.benchmark = benchmark; - data.skip = skip; - data.limit = limit; - #if defined(HAVE_HWMON) && defined(HAVE_ADL) - data.powertune_enable = powertune_enable; + data.hash_mode = hash_mode; + data.restore = restore; + data.restore_timer = restore_timer; + data.restore_disable = restore_disable; + data.status = status; + data.status_timer = status_timer; + data.machine_readable = machine_readable; + data.loopback = loopback; + data.runtime = runtime; + data.remove = remove; + data.remove_timer = remove_timer; + data.debug_mode = debug_mode; + data.debug_file = debug_file; + data.username = username; + data.quiet = quiet; + data.outfile = outfile; + data.outfile_format = outfile_format; + data.outfile_autohex = outfile_autohex; + data.hex_charset = hex_charset; + data.hex_salt = hex_salt; + data.hex_wordlist = hex_wordlist; + data.separator = separator; + data.rp_files = rp_files; + data.rp_files_cnt = rp_files_cnt; + data.rp_gen = rp_gen; + data.rp_gen_seed = rp_gen_seed; + data.force = force; + data.benchmark = benchmark; + data.skip = skip; + data.limit = limit; + #ifdef HAVE_HWMON + data.powertune_enable = powertune_enable; #endif - data.logfile_disable = logfile_disable; - data.truecrypt_keyfiles = truecrypt_keyfiles; - data.scrypt_tmto = scrypt_tmto; - data.workload_profile = workload_profile; + data.logfile_disable = logfile_disable; + data.truecrypt_keyfiles = truecrypt_keyfiles; + data.veracrypt_keyfiles = veracrypt_keyfiles; + data.veracrypt_pim = veracrypt_pim; + data.scrypt_tmto = scrypt_tmto; + data.workload_profile = workload_profile; /** * cpu affinity @@ -6583,12 +7179,14 @@ int main (int argc, char **argv) logfile_top_uint (attack_mode); logfile_top_uint (attack_kern); logfile_top_uint (benchmark); + logfile_top_uint (stdout_flag); logfile_top_uint (bitmap_min); logfile_top_uint (bitmap_max); logfile_top_uint (debug_mode); logfile_top_uint (force); logfile_top_uint (kernel_accel); logfile_top_uint (kernel_loops); + logfile_top_uint (nvidia_spin_damp); logfile_top_uint (gpu_temp_disable); #ifdef HAVE_HWMON logfile_top_uint (gpu_temp_abort); @@ -6613,7 +7211,7 @@ int main (int argc, char **argv) logfile_top_uint (outfile_format); logfile_top_uint (potfile_disable); logfile_top_string (potfile_path); - #if defined(HAVE_HWMON) && defined(HAVE_ADL) + #if defined(HAVE_HWMON) logfile_top_uint (powertune_enable); #endif logfile_top_uint (scrypt_tmto); @@ -6631,7 +7229,7 @@ int main (int argc, char **argv) logfile_top_uint (segment_size); logfile_top_uint (show); logfile_top_uint (status); - logfile_top_uint (status_automat); + logfile_top_uint (machine_readable); logfile_top_uint (status_timer); logfile_top_uint (usage); logfile_top_uint (username); @@ -6659,6 +7257,8 @@ int main (int argc, char **argv) logfile_top_string (rule_buf_r); logfile_top_string (session); logfile_top_string (truecrypt_keyfiles); + logfile_top_string (veracrypt_keyfiles); + logfile_top_uint (veracrypt_pim); /** * Init OpenCL library loader @@ -6706,11 +7306,21 @@ int main (int argc, char **argv) restore_disable = 1; potfile_disable = 1; weak_hash_threshold = 0; + nvidia_spin_damp = 0; gpu_temp_disable = 1; + outfile_check_timer = 0; - data.status_timer = status_timer; - data.restore_timer = restore_timer; - data.restore_disable = restore_disable; + #ifdef HAVE_HWMON + if (powertune_enable == 1) + { + gpu_temp_disable = 0; + } + #endif + + data.status_timer = status_timer; + data.restore_timer = restore_timer; + data.restore_disable = restore_disable; + data.outfile_check_timer = outfile_check_timer; /** * force attack mode to be bruteforce @@ -6727,6 +7337,37 @@ int main (int argc, char **argv) } } + /** + * status, monitor and outfile remove threads + */ + + uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN; + + data.wordlist_mode = wordlist_mode; + + if (wordlist_mode == WL_MODE_STDIN) + { + status = 1; + + data.status = status; + } + + uint outer_threads_cnt = 0; + + hc_thread_t *outer_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t)); + + data.shutdown_outer = 0; + + if (keyspace == 0 && benchmark == 0 && stdout_flag == 0) + { + if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK)) + { + hc_thread_create (outer_threads[outer_threads_cnt], thread_keypress, NULL); + + outer_threads_cnt++; + } + } + /** * config */ @@ -7481,28 +8122,7 @@ int main (int argc, char **argv) dgst_pos3 = 1; break; - case 190: hash_type = HASH_TYPE_SHA1; - salt_type = SALT_TYPE_NONE; - attack_exec = ATTACK_EXEC_INSIDE_KERNEL; - opts_type = OPTS_TYPE_PT_GENERATE_BE - | OPTS_TYPE_PT_ADD80 - | OPTS_TYPE_PT_ADDBITS15; - kern_type = KERN_TYPE_SHA1_LINKEDIN; - dgst_size = DGST_SIZE_4_5; - parse_func = sha1linkedin_parse_hash; - sort_by_digest = sort_by_digest_4_5; - opti_type = OPTI_TYPE_ZERO_BYTE - | OPTI_TYPE_PRECOMPUTE_INIT - | OPTI_TYPE_EARLY_SKIP - | OPTI_TYPE_NOT_ITERATED - | OPTI_TYPE_NOT_SALTED; - dgst_pos0 = 0; - dgst_pos1 = 4; - dgst_pos2 = 3; - dgst_pos3 = 2; - break; - - case 200: hash_type = HASH_TYPE_MYSQL; + case 200: hash_type = HASH_TYPE_MYSQL; salt_type = SALT_TYPE_NONE; attack_exec = ATTACK_EXEC_INSIDE_KERNEL; opts_type = 0; @@ -8142,6 +8762,21 @@ int main (int argc, char **argv) dgst_pos3 = 3; break; + case 2000: hash_type = HASH_TYPE_STDOUT; + salt_type = SALT_TYPE_NONE; + attack_exec = ATTACK_EXEC_INSIDE_KERNEL; + opts_type = OPTS_TYPE_PT_GENERATE_LE; + kern_type = KERN_TYPE_STDOUT; + dgst_size = DGST_SIZE_4_4; + parse_func = NULL; + sort_by_digest = NULL; + opti_type = 0; + dgst_pos0 = 0; + dgst_pos1 = 0; + dgst_pos2 = 0; + dgst_pos3 = 0; + break; + case 2100: hash_type = HASH_TYPE_DCC2; salt_type = SALT_TYPE_EMBEDDED; attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL; @@ -10283,118 +10918,430 @@ int main (int argc, char **argv) dgst_pos3 = 3; break; - default: usage_mini_print (PROGNAME); return (-1); - } - - /** - * parser - */ + case 13711: hash_type = HASH_TYPE_RIPEMD160; + salt_type = SALT_TYPE_EMBEDDED; + attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL; + opts_type = OPTS_TYPE_PT_GENERATE_LE; + kern_type = KERN_TYPE_TCRIPEMD160_XTS512; + dgst_size = DGST_SIZE_4_5; + parse_func = veracrypt_parse_hash_655331; + sort_by_digest = sort_by_digest_4_5; + opti_type = OPTI_TYPE_ZERO_BYTE; + dgst_pos0 = 0; + dgst_pos1 = 1; + dgst_pos2 = 2; + dgst_pos3 = 3; + break; - data.parse_func = parse_func; + case 13712: hash_type = HASH_TYPE_RIPEMD160; + salt_type = SALT_TYPE_EMBEDDED; + attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL; + opts_type = OPTS_TYPE_PT_GENERATE_LE; + kern_type = KERN_TYPE_TCRIPEMD160_XTS1024; + dgst_size = DGST_SIZE_4_5; + parse_func = veracrypt_parse_hash_655331; + sort_by_digest = sort_by_digest_4_5; + opti_type = OPTI_TYPE_ZERO_BYTE; + dgst_pos0 = 0; + dgst_pos1 = 1; + dgst_pos2 = 2; + dgst_pos3 = 3; + break; - /** - * misc stuff - */ + case 13713: hash_type = HASH_TYPE_RIPEMD160; + salt_type = SALT_TYPE_EMBEDDED; + attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL; + opts_type = OPTS_TYPE_PT_GENERATE_LE; + kern_type = KERN_TYPE_TCRIPEMD160_XTS1536; + dgst_size = DGST_SIZE_4_5; + parse_func = veracrypt_parse_hash_655331; + sort_by_digest = sort_by_digest_4_5; + opti_type = OPTI_TYPE_ZERO_BYTE; + dgst_pos0 = 0; + dgst_pos1 = 1; + dgst_pos2 = 2; + dgst_pos3 = 3; + break; - if (hex_salt) - { - if (salt_type == SALT_TYPE_INTERN) - { - opts_type |= OPTS_TYPE_ST_HEX; - } - else - { - log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode); + case 13721: hash_type = HASH_TYPE_SHA512; + salt_type = SALT_TYPE_EMBEDDED; + attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL; + opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE + kern_type = KERN_TYPE_TCSHA512_XTS512; + dgst_size = DGST_SIZE_8_8; + parse_func = veracrypt_parse_hash_500000; + sort_by_digest = sort_by_digest_8_8; + opti_type = OPTI_TYPE_ZERO_BYTE + | OPTI_TYPE_USES_BITS_64; + dgst_pos0 = 0; + dgst_pos1 = 1; + dgst_pos2 = 2; + dgst_pos3 = 3; + break; - return (-1); - } - } + case 13722: hash_type = HASH_TYPE_SHA512; + salt_type = SALT_TYPE_EMBEDDED; + attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL; + opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE + kern_type = KERN_TYPE_TCSHA512_XTS1024; + dgst_size = DGST_SIZE_8_8; + parse_func = veracrypt_parse_hash_500000; + sort_by_digest = sort_by_digest_8_8; + opti_type = OPTI_TYPE_ZERO_BYTE + | OPTI_TYPE_USES_BITS_64; + dgst_pos0 = 0; + dgst_pos1 = 1; + dgst_pos2 = 2; + dgst_pos3 = 3; + break; - uint isSalted = ((salt_type == SALT_TYPE_INTERN) - | (salt_type == SALT_TYPE_EXTERN) - | (salt_type == SALT_TYPE_EMBEDDED) - | (salt_type == SALT_TYPE_VIRTUAL)); + case 13723: hash_type = HASH_TYPE_SHA512; + salt_type = SALT_TYPE_EMBEDDED; + attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL; + opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE + kern_type = KERN_TYPE_TCSHA512_XTS1536; + dgst_size = DGST_SIZE_8_8; + parse_func = veracrypt_parse_hash_500000; + sort_by_digest = sort_by_digest_8_8; + opti_type = OPTI_TYPE_ZERO_BYTE + | OPTI_TYPE_USES_BITS_64; + dgst_pos0 = 0; + dgst_pos1 = 1; + dgst_pos2 = 2; + dgst_pos3 = 3; + break; - sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest + case 13731: hash_type = HASH_TYPE_WHIRLPOOL; + salt_type = SALT_TYPE_EMBEDDED; + attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL; + opts_type = OPTS_TYPE_PT_GENERATE_LE; + kern_type = KERN_TYPE_TCWHIRLPOOL_XTS512; + dgst_size = DGST_SIZE_4_8; + parse_func = veracrypt_parse_hash_500000; + sort_by_digest = sort_by_digest_4_8; + opti_type = OPTI_TYPE_ZERO_BYTE; + dgst_pos0 = 0; + dgst_pos1 = 1; + dgst_pos2 = 2; + dgst_pos3 = 3; + break; - data.hash_type = hash_type; - data.attack_mode = attack_mode; - data.attack_kern = attack_kern; - data.attack_exec = attack_exec; - data.kern_type = kern_type; - data.opts_type = opts_type; - data.dgst_size = dgst_size; - data.salt_type = salt_type; - data.isSalted = isSalted; - data.sort_by_digest = sort_by_digest; - data.dgst_pos0 = dgst_pos0; - data.dgst_pos1 = dgst_pos1; - data.dgst_pos2 = dgst_pos2; - data.dgst_pos3 = dgst_pos3; + case 13732: hash_type = HASH_TYPE_WHIRLPOOL; + salt_type = SALT_TYPE_EMBEDDED; + attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL; + opts_type = OPTS_TYPE_PT_GENERATE_LE; + kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1024; + dgst_size = DGST_SIZE_4_8; + parse_func = veracrypt_parse_hash_500000; + sort_by_digest = sort_by_digest_4_8; + opti_type = OPTI_TYPE_ZERO_BYTE; + dgst_pos0 = 0; + dgst_pos1 = 1; + dgst_pos2 = 2; + dgst_pos3 = 3; + break; - esalt_size = 0; + case 13733: hash_type = HASH_TYPE_WHIRLPOOL; + salt_type = SALT_TYPE_EMBEDDED; + attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL; + opts_type = OPTS_TYPE_PT_GENERATE_LE; + kern_type = KERN_TYPE_TCWHIRLPOOL_XTS1536; + dgst_size = DGST_SIZE_4_8; + parse_func = veracrypt_parse_hash_500000; + sort_by_digest = sort_by_digest_4_8; + opti_type = OPTI_TYPE_ZERO_BYTE; + dgst_pos0 = 0; + dgst_pos1 = 1; + dgst_pos2 = 2; + dgst_pos3 = 3; + break; - switch (hash_mode) - { - case 2500: esalt_size = sizeof (wpa_t); break; - case 5300: esalt_size = sizeof (ikepsk_t); break; - case 5400: esalt_size = sizeof (ikepsk_t); break; - case 5500: esalt_size = sizeof (netntlm_t); break; - case 5600: esalt_size = sizeof (netntlm_t); break; - case 6211: esalt_size = sizeof (tc_t); break; - case 6212: esalt_size = sizeof (tc_t); break; - case 6213: esalt_size = sizeof (tc_t); break; - case 6221: esalt_size = sizeof (tc_t); break; - case 6222: esalt_size = sizeof (tc_t); break; - case 6223: esalt_size = sizeof (tc_t); break; - case 6231: esalt_size = sizeof (tc_t); break; - case 6232: esalt_size = sizeof (tc_t); break; - case 6233: esalt_size = sizeof (tc_t); break; - case 6241: esalt_size = sizeof (tc_t); break; - case 6242: esalt_size = sizeof (tc_t); break; - case 6243: esalt_size = sizeof (tc_t); break; - case 6600: esalt_size = sizeof (agilekey_t); break; - case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break; - case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break; - case 7300: esalt_size = sizeof (rakp_t); break; - case 7500: esalt_size = sizeof (krb5pa_t); break; - case 8200: esalt_size = sizeof (cloudkey_t); break; - case 8800: esalt_size = sizeof (androidfde_t); break; - case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break; - case 9400: esalt_size = sizeof (office2007_t); break; - case 9500: esalt_size = sizeof (office2010_t); break; - case 9600: esalt_size = sizeof (office2013_t); break; - case 9700: esalt_size = sizeof (oldoffice01_t); break; - case 9710: esalt_size = sizeof (oldoffice01_t); break; - case 9720: esalt_size = sizeof (oldoffice01_t); break; - case 9800: esalt_size = sizeof (oldoffice34_t); break; - case 9810: esalt_size = sizeof (oldoffice34_t); break; - case 9820: esalt_size = sizeof (oldoffice34_t); break; - case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break; - case 10200: esalt_size = sizeof (cram_md5_t); break; - case 10400: esalt_size = sizeof (pdf_t); break; - case 10410: esalt_size = sizeof (pdf_t); break; - case 10420: esalt_size = sizeof (pdf_t); break; - case 10500: esalt_size = sizeof (pdf_t); break; - case 10600: esalt_size = sizeof (pdf_t); break; - case 10700: esalt_size = sizeof (pdf_t); break; - case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break; - case 11300: esalt_size = sizeof (bitcoin_wallet_t); break; - case 11400: esalt_size = sizeof (sip_t); break; - case 11600: esalt_size = sizeof (seven_zip_t); break; - case 11900: esalt_size = sizeof (pbkdf2_md5_t); break; - case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break; - case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break; - case 13000: esalt_size = sizeof (rar5_t); break; - case 13100: esalt_size = sizeof (krb5tgs_t); break; - case 13400: esalt_size = sizeof (keepass_t); break; - case 13500: esalt_size = sizeof (pstoken_t); break; - case 13600: esalt_size = sizeof (zip2_t); break; - } + case 13741: hash_type = HASH_TYPE_RIPEMD160; + salt_type = SALT_TYPE_EMBEDDED; + attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL; + opts_type = OPTS_TYPE_PT_GENERATE_LE; + kern_type = KERN_TYPE_TCRIPEMD160_XTS512; + dgst_size = DGST_SIZE_4_5; + parse_func = veracrypt_parse_hash_327661; + sort_by_digest = sort_by_digest_4_5; + opti_type = OPTI_TYPE_ZERO_BYTE; + dgst_pos0 = 0; + dgst_pos1 = 1; + dgst_pos2 = 2; + dgst_pos3 = 3; + break; - data.esalt_size = esalt_size; + case 13742: hash_type = HASH_TYPE_RIPEMD160; + salt_type = SALT_TYPE_EMBEDDED; + attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL; + opts_type = OPTS_TYPE_PT_GENERATE_LE; + kern_type = KERN_TYPE_TCRIPEMD160_XTS1024; + dgst_size = DGST_SIZE_4_5; + parse_func = veracrypt_parse_hash_327661; + sort_by_digest = sort_by_digest_4_5; + opti_type = OPTI_TYPE_ZERO_BYTE; + dgst_pos0 = 0; + dgst_pos1 = 1; + dgst_pos2 = 2; + dgst_pos3 = 3; + break; - /** + case 13743: hash_type = HASH_TYPE_RIPEMD160; + salt_type = SALT_TYPE_EMBEDDED; + attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL; + opts_type = OPTS_TYPE_PT_GENERATE_LE; + kern_type = KERN_TYPE_TCRIPEMD160_XTS1536; + dgst_size = DGST_SIZE_4_5; + parse_func = veracrypt_parse_hash_327661; + sort_by_digest = sort_by_digest_4_5; + opti_type = OPTI_TYPE_ZERO_BYTE; + dgst_pos0 = 0; + dgst_pos1 = 1; + dgst_pos2 = 2; + dgst_pos3 = 3; + break; + + case 13751: hash_type = HASH_TYPE_SHA256; + salt_type = SALT_TYPE_EMBEDDED; + attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL; + opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE + kern_type = KERN_TYPE_VCSHA256_XTS512; + dgst_size = DGST_SIZE_4_8; + parse_func = veracrypt_parse_hash_500000; + sort_by_digest = sort_by_digest_4_8; + opti_type = OPTI_TYPE_ZERO_BYTE; + dgst_pos0 = 0; + dgst_pos1 = 1; + dgst_pos2 = 2; + dgst_pos3 = 3; + break; + + case 13752: hash_type = HASH_TYPE_SHA256; + salt_type = SALT_TYPE_EMBEDDED; + attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL; + opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE + kern_type = KERN_TYPE_VCSHA256_XTS1024; + dgst_size = DGST_SIZE_4_8; + parse_func = veracrypt_parse_hash_500000; + sort_by_digest = sort_by_digest_4_8; + opti_type = OPTI_TYPE_ZERO_BYTE; + dgst_pos0 = 0; + dgst_pos1 = 1; + dgst_pos2 = 2; + dgst_pos3 = 3; + break; + + case 13753: hash_type = HASH_TYPE_SHA256; + salt_type = SALT_TYPE_EMBEDDED; + attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL; + opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE + kern_type = KERN_TYPE_VCSHA256_XTS1536; + dgst_size = DGST_SIZE_4_8; + parse_func = veracrypt_parse_hash_500000; + sort_by_digest = sort_by_digest_4_8; + opti_type = OPTI_TYPE_ZERO_BYTE; + dgst_pos0 = 0; + dgst_pos1 = 1; + dgst_pos2 = 2; + dgst_pos3 = 3; + break; + + case 13761: hash_type = HASH_TYPE_SHA256; + salt_type = SALT_TYPE_EMBEDDED; + attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL; + opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE + kern_type = KERN_TYPE_VCSHA256_XTS512; + dgst_size = DGST_SIZE_4_8; + parse_func = veracrypt_parse_hash_200000; + sort_by_digest = sort_by_digest_4_8; + opti_type = OPTI_TYPE_ZERO_BYTE; + dgst_pos0 = 0; + dgst_pos1 = 1; + dgst_pos2 = 2; + dgst_pos3 = 3; + break; + + case 13762: hash_type = HASH_TYPE_SHA256; + salt_type = SALT_TYPE_EMBEDDED; + attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL; + opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE + kern_type = KERN_TYPE_VCSHA256_XTS1024; + dgst_size = DGST_SIZE_4_8; + parse_func = veracrypt_parse_hash_200000; + sort_by_digest = sort_by_digest_4_8; + opti_type = OPTI_TYPE_ZERO_BYTE; + dgst_pos0 = 0; + dgst_pos1 = 1; + dgst_pos2 = 2; + dgst_pos3 = 3; + break; + + case 13763: hash_type = HASH_TYPE_SHA256; + salt_type = SALT_TYPE_EMBEDDED; + attack_exec = ATTACK_EXEC_OUTSIDE_KERNEL; + opts_type = OPTS_TYPE_PT_GENERATE_LE; // should be OPTS_TYPE_PT_GENERATE_BE + kern_type = KERN_TYPE_VCSHA256_XTS1536; + dgst_size = DGST_SIZE_4_8; + parse_func = veracrypt_parse_hash_200000; + sort_by_digest = sort_by_digest_4_8; + opti_type = OPTI_TYPE_ZERO_BYTE; + dgst_pos0 = 0; + dgst_pos1 = 1; + dgst_pos2 = 2; + dgst_pos3 = 3; + break; + + case 13800: hash_type = HASH_TYPE_SHA256; + salt_type = SALT_TYPE_EMBEDDED; + attack_exec = ATTACK_EXEC_INSIDE_KERNEL; + opts_type = OPTS_TYPE_PT_GENERATE_BE + | OPTS_TYPE_PT_UNICODE; + kern_type = KERN_TYPE_WIN8PHONE; + dgst_size = DGST_SIZE_4_8; + parse_func = win8phone_parse_hash; + sort_by_digest = sort_by_digest_4_8; + opti_type = OPTI_TYPE_ZERO_BYTE + | OPTI_TYPE_PRECOMPUTE_INIT + | OPTI_TYPE_EARLY_SKIP + | OPTI_TYPE_NOT_ITERATED + | OPTI_TYPE_RAW_HASH; + dgst_pos0 = 3; + dgst_pos1 = 7; + dgst_pos2 = 2; + dgst_pos3 = 6; + break; + + default: usage_mini_print (PROGNAME); return (-1); + } + + /** + * parser + */ + + data.parse_func = parse_func; + + /** + * misc stuff + */ + + if (hex_salt) + { + if (salt_type == SALT_TYPE_INTERN) + { + opts_type |= OPTS_TYPE_ST_HEX; + } + else + { + log_error ("ERROR: Parameter hex-salt not valid for hash-type %u", hash_mode); + + return (-1); + } + } + + uint isSalted = ((salt_type == SALT_TYPE_INTERN) + | (salt_type == SALT_TYPE_EXTERN) + | (salt_type == SALT_TYPE_EMBEDDED) + | (salt_type == SALT_TYPE_VIRTUAL)); + + sort_by_digest = sort_by_digest_p0p1; // overruled by 64 bit digest + + data.hash_type = hash_type; + data.attack_mode = attack_mode; + data.attack_kern = attack_kern; + data.attack_exec = attack_exec; + data.kern_type = kern_type; + data.opts_type = opts_type; + data.dgst_size = dgst_size; + data.salt_type = salt_type; + data.isSalted = isSalted; + data.sort_by_digest = sort_by_digest; + data.dgst_pos0 = dgst_pos0; + data.dgst_pos1 = dgst_pos1; + data.dgst_pos2 = dgst_pos2; + data.dgst_pos3 = dgst_pos3; + + esalt_size = 0; + + switch (hash_mode) + { + case 2500: esalt_size = sizeof (wpa_t); break; + case 5300: esalt_size = sizeof (ikepsk_t); break; + case 5400: esalt_size = sizeof (ikepsk_t); break; + case 5500: esalt_size = sizeof (netntlm_t); break; + case 5600: esalt_size = sizeof (netntlm_t); break; + case 6211: esalt_size = sizeof (tc_t); break; + case 6212: esalt_size = sizeof (tc_t); break; + case 6213: esalt_size = sizeof (tc_t); break; + case 6221: esalt_size = sizeof (tc_t); break; + case 6222: esalt_size = sizeof (tc_t); break; + case 6223: esalt_size = sizeof (tc_t); break; + case 6231: esalt_size = sizeof (tc_t); break; + case 6232: esalt_size = sizeof (tc_t); break; + case 6233: esalt_size = sizeof (tc_t); break; + case 6241: esalt_size = sizeof (tc_t); break; + case 6242: esalt_size = sizeof (tc_t); break; + case 6243: esalt_size = sizeof (tc_t); break; + case 6600: esalt_size = sizeof (agilekey_t); break; + case 7100: esalt_size = sizeof (pbkdf2_sha512_t); break; + case 7200: esalt_size = sizeof (pbkdf2_sha512_t); break; + case 7300: esalt_size = sizeof (rakp_t); break; + case 7500: esalt_size = sizeof (krb5pa_t); break; + case 8200: esalt_size = sizeof (cloudkey_t); break; + case 8800: esalt_size = sizeof (androidfde_t); break; + case 9200: esalt_size = sizeof (pbkdf2_sha256_t); break; + case 9400: esalt_size = sizeof (office2007_t); break; + case 9500: esalt_size = sizeof (office2010_t); break; + case 9600: esalt_size = sizeof (office2013_t); break; + case 9700: esalt_size = sizeof (oldoffice01_t); break; + case 9710: esalt_size = sizeof (oldoffice01_t); break; + case 9720: esalt_size = sizeof (oldoffice01_t); break; + case 9800: esalt_size = sizeof (oldoffice34_t); break; + case 9810: esalt_size = sizeof (oldoffice34_t); break; + case 9820: esalt_size = sizeof (oldoffice34_t); break; + case 10000: esalt_size = sizeof (pbkdf2_sha256_t); break; + case 10200: esalt_size = sizeof (cram_md5_t); break; + case 10400: esalt_size = sizeof (pdf_t); break; + case 10410: esalt_size = sizeof (pdf_t); break; + case 10420: esalt_size = sizeof (pdf_t); break; + case 10500: esalt_size = sizeof (pdf_t); break; + case 10600: esalt_size = sizeof (pdf_t); break; + case 10700: esalt_size = sizeof (pdf_t); break; + case 10900: esalt_size = sizeof (pbkdf2_sha256_t); break; + case 11300: esalt_size = sizeof (bitcoin_wallet_t); break; + case 11400: esalt_size = sizeof (sip_t); break; + case 11600: esalt_size = sizeof (seven_zip_t); break; + case 11900: esalt_size = sizeof (pbkdf2_md5_t); break; + case 12000: esalt_size = sizeof (pbkdf2_sha1_t); break; + case 12100: esalt_size = sizeof (pbkdf2_sha512_t); break; + case 13000: esalt_size = sizeof (rar5_t); break; + case 13100: esalt_size = sizeof (krb5tgs_t); break; + case 13400: esalt_size = sizeof (keepass_t); break; + case 13500: esalt_size = sizeof (pstoken_t); break; + case 13600: esalt_size = sizeof (zip2_t); break; + case 13711: esalt_size = sizeof (tc_t); break; + case 13712: esalt_size = sizeof (tc_t); break; + case 13713: esalt_size = sizeof (tc_t); break; + case 13721: esalt_size = sizeof (tc_t); break; + case 13722: esalt_size = sizeof (tc_t); break; + case 13723: esalt_size = sizeof (tc_t); break; + case 13731: esalt_size = sizeof (tc_t); break; + case 13732: esalt_size = sizeof (tc_t); break; + case 13733: esalt_size = sizeof (tc_t); break; + case 13741: esalt_size = sizeof (tc_t); break; + case 13742: esalt_size = sizeof (tc_t); break; + case 13743: esalt_size = sizeof (tc_t); break; + case 13751: esalt_size = sizeof (tc_t); break; + case 13752: esalt_size = sizeof (tc_t); break; + case 13753: esalt_size = sizeof (tc_t); break; + case 13761: esalt_size = sizeof (tc_t); break; + case 13762: esalt_size = sizeof (tc_t); break; + case 13763: esalt_size = sizeof (tc_t); break; + case 13800: esalt_size = sizeof (win8phone_t); break; + } + + data.esalt_size = esalt_size; + + /** * choose dictionary parser */ @@ -10723,6 +11670,8 @@ int main (int argc, char **argv) break; case 7400: if (pw_max > 16) pw_max = 16; break; + case 7700: if (pw_max > 8) pw_max = 8; + break; case 7900: if (pw_max > 48) pw_max = 48; break; case 8500: if (pw_max > 8) pw_max = 8; @@ -10790,7 +11739,7 @@ int main (int argc, char **argv) uint hashes_avail = 0; - if (benchmark == 0) + if ((benchmark == 0) && (stdout_flag == 0)) { struct stat f; @@ -10798,7 +11747,8 @@ int main (int argc, char **argv) if ((hash_mode == 2500) || (hash_mode == 5200) || - ((hash_mode >= 6200) && (hash_mode <= 6299)) || + ((hash_mode >= 6200) && (hash_mode <= 6299)) || + ((hash_mode >= 13700) && (hash_mode <= 13799)) || (hash_mode == 9000)) { hashlist_mode = HL_MODE_ARG; @@ -10971,6 +11921,10 @@ int main (int argc, char **argv) { // useless to read hash file for keyspace, cheat a little bit w/ optind } + else if (stdout_flag == 1) + { + // useless to read hash file for stdout, cheat a little bit w/ optind + } else if (hashes_avail == 0) { } @@ -10994,7 +11948,7 @@ int main (int argc, char **argv) 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 { @@ -11291,7 +12245,7 @@ int main (int argc, char **argv) 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; } @@ -11304,7 +12258,7 @@ int main (int argc, char **argv) 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; } @@ -11326,7 +12280,7 @@ int main (int argc, char **argv) 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; } @@ -11345,7 +12299,7 @@ int main (int argc, char **argv) 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; } @@ -11546,6 +12500,42 @@ int main (int argc, char **argv) break; case 9000: data.hashfile = mystrdup ("hashcat.psafe2"); break; + case 13711: data.hashfile = mystrdup ("hashcat.vc"); + break; + case 13712: data.hashfile = mystrdup ("hashcat.vc"); + break; + case 13713: data.hashfile = mystrdup ("hashcat.vc"); + break; + case 13721: data.hashfile = mystrdup ("hashcat.vc"); + break; + case 13722: data.hashfile = mystrdup ("hashcat.vc"); + break; + case 13723: data.hashfile = mystrdup ("hashcat.vc"); + break; + case 13731: data.hashfile = mystrdup ("hashcat.vc"); + break; + case 13732: data.hashfile = mystrdup ("hashcat.vc"); + break; + case 13733: data.hashfile = mystrdup ("hashcat.vc"); + break; + case 13741: data.hashfile = mystrdup ("hashcat.vc"); + break; + case 13742: data.hashfile = mystrdup ("hashcat.vc"); + break; + case 13743: data.hashfile = mystrdup ("hashcat.vc"); + break; + case 13751: data.hashfile = mystrdup ("hashcat.vc"); + break; + case 13752: data.hashfile = mystrdup ("hashcat.vc"); + break; + case 13753: data.hashfile = mystrdup ("hashcat.vc"); + break; + case 13761: data.hashfile = mystrdup ("hashcat.vc"); + break; + case 13762: data.hashfile = mystrdup ("hashcat.vc"); + break; + case 13763: data.hashfile = mystrdup ("hashcat.vc"); + break; } // set default iterations @@ -11680,6 +12670,42 @@ int main (int argc, char **argv) break; case 13600: hashes_buf[0].salt->salt_iter = ROUNDS_ZIP2; break; + case 13711: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331; + break; + case 13712: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331; + break; + case 13713: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_655331; + break; + case 13721: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000; + break; + case 13722: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000; + break; + case 13723: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000; + break; + case 13731: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000; + break; + case 13732: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000; + break; + case 13733: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000; + break; + case 13741: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661; + break; + case 13742: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661; + break; + case 13743: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_327661; + break; + case 13751: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000; + break; + case 13752: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000; + break; + case 13753: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_500000; + break; + case 13761: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000; + break; + case 13762: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000; + break; + case 13763: hashes_buf[0].salt->salt_iter = ROUNDS_VERACRYPT_200000; + break; } hashes_cnt = 1; @@ -11708,7 +12734,7 @@ int main (int argc, char **argv) return (0); } - if (keyspace == 0) + if ((keyspace == 0) && (stdout_flag == 0)) { if (hashes_cnt == 0) { @@ -11882,7 +12908,8 @@ int main (int argc, char **argv) // no solution for these special hash types (for instane because they use hashfile in output etc) if ((hash_mode != 5200) && - !((hash_mode >= 6200) && (hash_mode <= 6299)) && + !((hash_mode >= 6200) && (hash_mode <= 6299)) && + !((hash_mode >= 13700) && (hash_mode <= 13799)) && (hash_mode != 9000)) { FILE *fp = fopen (potfile, "rb"); @@ -12232,6 +13259,24 @@ int main (int argc, char **argv) case 6241: salts_buf->truecrypt_mdlen = 1 * 512; break; case 6242: salts_buf->truecrypt_mdlen = 2 * 512; break; case 6243: salts_buf->truecrypt_mdlen = 3 * 512; break; + case 13711: salts_buf->truecrypt_mdlen = 1 * 512; break; + case 13712: salts_buf->truecrypt_mdlen = 2 * 512; break; + case 13713: salts_buf->truecrypt_mdlen = 3 * 512; break; + case 13721: salts_buf->truecrypt_mdlen = 1 * 512; break; + case 13722: salts_buf->truecrypt_mdlen = 2 * 512; break; + case 13723: salts_buf->truecrypt_mdlen = 3 * 512; break; + case 13731: salts_buf->truecrypt_mdlen = 1 * 512; break; + case 13732: salts_buf->truecrypt_mdlen = 2 * 512; break; + case 13733: salts_buf->truecrypt_mdlen = 3 * 512; break; + case 13741: salts_buf->truecrypt_mdlen = 1 * 512; break; + case 13742: salts_buf->truecrypt_mdlen = 2 * 512; break; + case 13743: salts_buf->truecrypt_mdlen = 3 * 512; break; + case 13751: salts_buf->truecrypt_mdlen = 1 * 512; break; + case 13752: salts_buf->truecrypt_mdlen = 2 * 512; break; + case 13753: salts_buf->truecrypt_mdlen = 3 * 512; break; + case 13761: salts_buf->truecrypt_mdlen = 1 * 512; break; + case 13762: salts_buf->truecrypt_mdlen = 2 * 512; break; + case 13763: salts_buf->truecrypt_mdlen = 3 * 512; break; } if (truecrypt_keyfiles) @@ -12251,7 +13296,24 @@ int main (int argc, char **argv) free (keyfiles); } - data.digests_cnt = digests_cnt; + if (veracrypt_keyfiles) + { + uint *keyfile_buf = ((tc_t *) esalts_buf)->keyfile_buf; + + char *keyfiles = strdup (veracrypt_keyfiles); + + char *keyfile = strtok (keyfiles, ","); + + do + { + truecrypt_crc32 (keyfile, (u8 *) keyfile_buf); + + } while ((keyfile = strtok (NULL, ",")) != NULL); + + free (keyfiles); + } + + data.digests_cnt = digests_cnt; data.digests_done = digests_done; data.digests_buf = digests_buf; data.digests_shown = digests_shown; @@ -12461,14 +13523,14 @@ int main (int argc, char **argv) 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 OpenCL 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 @@ -12478,7 +13540,7 @@ int main (int argc, char **argv) /* its so slow if (rulefind (&kernel_rules_buf[kernel_rules_cnt], kernel_rules_buf, kernel_rules_cnt, sizeof (kernel_rule_t), sort_by_kernel_rule)) { - log_info ("Duplicate rule for use on device in file %s in line %u: %s", rp_file, rule_line, rule_buf); + log_info ("Duplicate rule for use on OpenCL device in file %s in line %u: %s", rp_file, rule_line, rule_buf); continue; } @@ -12582,7 +13644,7 @@ int main (int argc, char **argv) * generate NOP rules */ - if (kernel_rules_cnt == 0) + if ((rp_files_cnt == 0) && (rp_gen == 0)) { kernel_rules_buf = (kernel_rule_t *) mymalloc (sizeof (kernel_rule_t)); @@ -12594,6 +13656,13 @@ int main (int argc, char **argv) data.kernel_rules_cnt = kernel_rules_cnt; data.kernel_rules_buf = kernel_rules_buf; + if (kernel_rules_cnt == 0) + { + log_error ("ERROR: No valid rules left"); + + return (-1); + } + /** * OpenCL platforms: detect */ @@ -12635,40 +13704,13 @@ int main (int argc, char **argv) } } - /** - * OpenCL platforms: For each platform check if we need to unset features that we can not use, eg: temp_retain - */ - - for (uint platform_id = 0; platform_id < platforms_cnt; platform_id++) - { - cl_platform_id platform = platforms[platform_id]; - - char platform_vendor[INFOSZ] = { 0 }; - - hc_clGetPlatformInfo (data.ocl, platform, CL_PLATFORM_VENDOR, sizeof (platform_vendor), platform_vendor, NULL); - - #ifdef HAVE_HWMON - #if defined(HAVE_NVML) || defined(HAVE_NVAPI) - if (strcmp (platform_vendor, CL_VENDOR_NV) == 0) - { - // make sure that we do not directly control the fan for NVidia - - gpu_temp_retain = 0; - - data.gpu_temp_retain = gpu_temp_retain; - } - #endif // HAVE_NVML || HAVE_NVAPI - #endif - } - - /** - * 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++) @@ -12691,16 +13733,34 @@ int main (int argc, char **argv) } } + // 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; + } + } } /** * OpenCL devices: simply push all devices from all platforms into the same device array */ + int need_adl = 0; + int need_nvapi = 0; + int need_nvml = 0; + int need_xnvctrl = 0; + hc_device_param_t *devices_param = (hc_device_param_t *) mycalloc (DEVICES_MAX, sizeof (hc_device_param_t)); data.devices_param = devices_param; @@ -12711,8 +13771,6 @@ int main (int argc, char **argv) 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); @@ -12725,41 +13783,71 @@ int main (int argc, char **argv) // this causes trouble with vendor id based macros // we'll assign generic to those without special optimization available - cl_uint vendor_id = 0; + cl_uint platform_vendor_id = 0; if (strcmp (platform_vendor, CL_VENDOR_AMD) == 0) { - vendor_id = VENDOR_ID_AMD; + platform_vendor_id = VENDOR_ID_AMD; + } + else if (strcmp (platform_vendor, CL_VENDOR_AMD_USE_INTEL) == 0) + { + platform_vendor_id = VENDOR_ID_AMD_USE_INTEL; } else if (strcmp (platform_vendor, CL_VENDOR_APPLE) == 0) { - vendor_id = VENDOR_ID_APPLE; + platform_vendor_id = VENDOR_ID_APPLE; } else if (strcmp (platform_vendor, CL_VENDOR_INTEL_BEIGNET) == 0) { - vendor_id = VENDOR_ID_INTEL_BEIGNET; + platform_vendor_id = VENDOR_ID_INTEL_BEIGNET; } else if (strcmp (platform_vendor, CL_VENDOR_INTEL_SDK) == 0) { - vendor_id = VENDOR_ID_INTEL_SDK; + platform_vendor_id = VENDOR_ID_INTEL_SDK; } else if (strcmp (platform_vendor, CL_VENDOR_MESA) == 0) { - vendor_id = VENDOR_ID_MESA; + platform_vendor_id = VENDOR_ID_MESA; } else if (strcmp (platform_vendor, CL_VENDOR_NV) == 0) { - vendor_id = VENDOR_ID_NV; + platform_vendor_id = VENDOR_ID_NV; } else if (strcmp (platform_vendor, CL_VENDOR_POCL) == 0) { - vendor_id = VENDOR_ID_POCL; + platform_vendor_id = VENDOR_ID_POCL; } else { - vendor_id = VENDOR_ID_GENERIC; + 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; @@ -12768,7 +13856,7 @@ int main (int argc, char **argv) hc_device_param_t *device_param = &data.devices_param[device_id]; - device_param->vendor_id = vendor_id; + device_param->platform_vendor_id = platform_vendor_id; device_param->device = platform_devices[platform_devices_id]; @@ -12796,6 +13884,57 @@ int main (int argc, char **argv) device_param->device_name = device_name; + // device_vendor + + hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, 0, NULL, ¶m_value_size); + + char *device_vendor = (char *) mymalloc (param_value_size); + + hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_VENDOR, param_value_size, device_vendor, NULL); + + device_param->device_vendor = device_vendor; + + cl_uint device_vendor_id = 0; + + if (strcmp (device_vendor, CL_VENDOR_AMD) == 0) + { + device_vendor_id = VENDOR_ID_AMD; + } + else if (strcmp (device_vendor, CL_VENDOR_AMD_USE_INTEL) == 0) + { + device_vendor_id = VENDOR_ID_AMD_USE_INTEL; + } + else if (strcmp (device_vendor, CL_VENDOR_APPLE) == 0) + { + device_vendor_id = VENDOR_ID_APPLE; + } + else if (strcmp (device_vendor, CL_VENDOR_INTEL_BEIGNET) == 0) + { + device_vendor_id = VENDOR_ID_INTEL_BEIGNET; + } + else if (strcmp (device_vendor, CL_VENDOR_INTEL_SDK) == 0) + { + device_vendor_id = VENDOR_ID_INTEL_SDK; + } + else if (strcmp (device_vendor, CL_VENDOR_MESA) == 0) + { + device_vendor_id = VENDOR_ID_MESA; + } + else if (strcmp (device_vendor, CL_VENDOR_NV) == 0) + { + device_vendor_id = VENDOR_ID_NV; + } + else if (strcmp (device_vendor, CL_VENDOR_POCL) == 0) + { + device_vendor_id = VENDOR_ID_POCL; + } + else + { + device_vendor_id = VENDOR_ID_GENERIC; + } + + device_param->device_vendor_id = device_vendor_id; + // tuning db tuning_db_entry_t *tuningdb_entry = tuning_db_search (tuning_db, device_param, attack_mode, hash_mode); @@ -12902,7 +14041,7 @@ int main (int argc, char **argv) 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; } @@ -12915,7 +14054,7 @@ int main (int argc, char **argv) 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; } @@ -12928,7 +14067,7 @@ int main (int argc, char **argv) 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; } @@ -12941,7 +14080,7 @@ int main (int argc, char **argv) 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; } @@ -12958,14 +14097,14 @@ int main (int argc, char **argv) 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; } @@ -12980,11 +14119,33 @@ int main (int argc, char **argv) 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 there's both an Intel CPU and an AMD OpenCL runtime it's a tricky situation + // Both platforms support CPU device types and therefore both will try to use 100% of the physical resources + // This results in both utilizing it for 50% + // However, Intel has much better SIMD control over their own hardware + // It makes sense to give them full control over their own hardware + + if (device_type & CL_DEVICE_TYPE_CPU) + { + if (device_param->device_vendor_id == VENDOR_ID_AMD_USE_INTEL) + { + if (data.force == 0) + { + if (algorithm_pos == 0) + { + 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; + } + } + } // skipped @@ -13006,9 +14167,9 @@ int main (int argc, char **argv) char *device_name_chksum = (char *) mymalloc (INFOSZ); #if __x86_64__ - snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%u-%s-%s-%s-%u", 64, device_param->vendor_id, device_param->vector_width, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME); + snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%u-%s-%s-%s-%u", 64, device_param->platform_vendor_id, device_param->vector_width, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME); #else - snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%u-%s-%s-%s-%u", 32, device_param->vendor_id, device_param->vector_width, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME); + snprintf (device_name_chksum, INFOSZ - 1, "%u-%u-%u-%s-%s-%s-%u", 32, device_param->platform_vendor_id, device_param->vector_width, device_param->device_name, device_param->device_version, device_param->driver_version, COMPTIME); #endif uint device_name_digest[4] = { 0 }; @@ -13019,28 +14180,32 @@ int main (int argc, char **argv) device_param->device_name_chksum = device_name_chksum; - // device_processor_cores - - if (device_type & CL_DEVICE_TYPE_CPU) - { - cl_uint device_processor_cores = 1; + // vendor specific - device_param->device_processor_cores = device_processor_cores; - } - - if (device_type & CL_DEVICE_TYPE_GPU) + if (device_param->device_type & CL_DEVICE_TYPE_GPU) { - if (vendor_id == VENDOR_ID_AMD) + if ((device_param->platform_vendor_id == VENDOR_ID_AMD) && (device_param->device_vendor_id == VENDOR_ID_AMD)) { - cl_uint device_processor_cores = 0; + need_adl = 1; + } - #define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043 + if ((device_param->platform_vendor_id == VENDOR_ID_NV) && (device_param->device_vendor_id == VENDOR_ID_NV)) + { + need_nvml = 1; - hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WAVEFRONT_WIDTH_AMD, sizeof (device_processor_cores), &device_processor_cores, NULL); + #ifdef LINUX + need_xnvctrl = 1; + #endif - device_param->device_processor_cores = device_processor_cores; + #ifdef WIN + need_nvapi = 1; + #endif } - else if (vendor_id == VENDOR_ID_NV) + } + + if (device_type & CL_DEVICE_TYPE_GPU) + { + if (device_vendor_id == VENDOR_ID_NV) { cl_uint kernel_exec_timeout = 0; @@ -13050,14 +14215,6 @@ int main (int argc, char **argv) device_param->kernel_exec_timeout = kernel_exec_timeout; - cl_uint device_processor_cores = 0; - - #define CL_DEVICE_WARP_SIZE_NV 0x4003 - - hc_clGetDeviceInfo (data.ocl, device_param->device, CL_DEVICE_WARP_SIZE_NV, sizeof (device_processor_cores), &device_processor_cores, NULL); - - device_param->device_processor_cores = device_processor_cores; - cl_uint sm_minor = 0; cl_uint sm_major = 0; @@ -13069,12 +14226,29 @@ int main (int argc, char **argv) device_param->sm_minor = sm_minor; device_param->sm_major = sm_major; - } - else - { - cl_uint device_processor_cores = 1; - device_param->device_processor_cores = device_processor_cores; + // CPU burning loop damper + // Value is given as number between 0-100 + // By default 100% + + device_param->nvidia_spin_damp = (double) nvidia_spin_damp; + + if (nvidia_spin_damp_chgd == 0) + { + if (data.attack_mode == ATTACK_MODE_STRAIGHT) + { + /** + * the workaround is not a friend of rule based attacks + * the words from the wordlist combined with fast and slow rules cause + * fluctuations which cause inaccurate wait time estimations + * using a reduced damping percentage almost compensates this + */ + + device_param->nvidia_spin_damp = 64; + } + } + + device_param->nvidia_spin_damp /= 100; } } @@ -13082,21 +14256,20 @@ int main (int argc, char **argv) if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0)) { - if (status_automat == 0) + if (machine_readable == 0) { if (device_param->skipped == 0) { - log_info ("Device #%u: %s, %lu/%lu MB allocatable, %dMhz, %uMCU", + log_info ("- Device #%u: %s, %lu/%lu MB allocatable, %uMCU", device_id + 1, device_name, (unsigned int) (device_maxmem_alloc / 1024 / 1024), (unsigned int) (device_global_mem / 1024 / 1024), - (unsigned int) (device_maxclock_frequency), (unsigned int) device_processors); } else { - log_info ("Device #%u: %s, skipped", + log_info ("- Device #%u: %s, skipped", device_id + 1, device_name); } @@ -13109,7 +14282,7 @@ int main (int argc, char **argv) { if (device_type & CL_DEVICE_TYPE_GPU) { - if (vendor_id == VENDOR_ID_AMD) + if (platform_vendor_id == VENDOR_ID_AMD) { int catalyst_check = (force == 1) ? 0 : 1; @@ -13133,8 +14306,8 @@ int main (int argc, char **argv) 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 (""); @@ -13145,8 +14318,8 @@ int main (int argc, char **argv) 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"); @@ -13157,19 +14330,20 @@ int main (int argc, char **argv) return (-1); } } - else if (vendor_id == VENDOR_ID_NV) + else if (platform_vendor_id == VENDOR_ID_NV) { 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"); } } } + /* turns out pocl still creates segfaults (because of llvm) if (device_type & CL_DEVICE_TYPE_CPU) { - if (vendor_id == VENDOR_ID_AMD) + if (platform_vendor_id == VENDOR_ID_AMD) { if (force == 0) { @@ -13184,6 +14358,7 @@ int main (int argc, char **argv) } } } + */ /** * kernel accel and loops tuning db adjustment @@ -13249,6 +14424,14 @@ int main (int argc, char **argv) devices_cnt++; } + + if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0)) + { + if (machine_readable == 0) + { + log_info (""); + } + } } if (keyspace == 0 && devices_active == 0) @@ -13276,114 +14459,125 @@ int main (int argc, char **argv) data.devices_active = devices_active; - if ((benchmark == 1 || quiet == 0) && (algorithm_pos == 0)) - { - if (status_automat == 0) - { - log_info (""); - } - } - /** * HM devices: init */ #ifdef HAVE_HWMON - #if defined(HAVE_NVML) || defined(HAVE_NVAPI) - hm_attrs_t hm_adapters_nv[DEVICES_MAX] = { { { 0 }, 0, 0 } }; - #endif - - #ifdef HAVE_ADL - hm_attrs_t hm_adapters_amd[DEVICES_MAX] = { { { 0 }, 0, 0 } }; - #endif + hm_attrs_t hm_adapters_adl[DEVICES_MAX] = { { 0 } }; + hm_attrs_t hm_adapters_nvapi[DEVICES_MAX] = { { 0 } }; + hm_attrs_t hm_adapters_nvml[DEVICES_MAX] = { { 0 } }; + hm_attrs_t hm_adapters_xnvctrl[DEVICES_MAX] = { { 0 } }; if (gpu_temp_disable == 0) { - #if defined(WIN) && defined(HAVE_NVAPI) - NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR)); + ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR)); + NVAPI_PTR *nvapi = (NVAPI_PTR *) mymalloc (sizeof (NVAPI_PTR)); + NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR)); + XNVCTRL_PTR *xnvctrl = (XNVCTRL_PTR *) mymalloc (sizeof (XNVCTRL_PTR)); - if (nvapi_init (nvapi) == 0) - data.hm_nv = nvapi; + data.hm_adl = NULL; + data.hm_nvapi = NULL; + data.hm_nvml = NULL; + data.hm_xnvctrl = NULL; + + if ((need_nvml == 1) && (nvml_init (nvml) == 0)) + { + data.hm_nvml = nvml; + } - if (data.hm_nv) + if (data.hm_nvml) { - if (hm_NvAPI_Initialize (data.hm_nv) == NVAPI_OK) + if (hm_NVML_nvmlInit (data.hm_nvml) == NVML_SUCCESS) { - HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 }; + HM_ADAPTER_NVML nvmlGPUHandle[DEVICES_MAX] = { 0 }; - int tmp_in = hm_get_adapter_index_nv (nvGPUHandle); + int tmp_in = hm_get_adapter_index_nvml (nvmlGPUHandle); int tmp_out = 0; for (int i = 0; i < tmp_in; i++) { - hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i]; + hm_adapters_nvml[tmp_out++].nvml = nvmlGPUHandle[i]; } for (int i = 0; i < tmp_out; i++) { - NV_GPU_COOLER_SETTINGS pCoolerSettings; + unsigned int speed; - pCoolerSettings.Version = GPU_COOLER_SETTINGS_VER | sizeof (NV_GPU_COOLER_SETTINGS); + if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nvml, 0, hm_adapters_nvml[i].nvml, &speed) == NVML_SUCCESS) hm_adapters_nvml[i].fan_get_supported = 1; - if (hm_NvAPI_GPU_GetCoolerSettings (data.hm_nv, hm_adapters_nv[i].adapter_index.nv, 0, &pCoolerSettings) != NVAPI_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1; + // doesn't seem to create any advantages + //hm_NVML_nvmlDeviceSetComputeMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_COMPUTEMODE_EXCLUSIVE_PROCESS); + //hm_NVML_nvmlDeviceSetGpuOperationMode (data.hm_nvml, 1, hm_adapters_nvml[i].nvml, NVML_GOM_ALL_ON); } } } - #endif // WIN && HAVE_NVAPI - - #if defined(LINUX) && defined(HAVE_NVML) - NVML_PTR *nvml = (NVML_PTR *) mymalloc (sizeof (NVML_PTR)); - if (nvml_init (nvml) == 0) - data.hm_nv = nvml; + if ((need_nvapi == 1) && (nvapi_init (nvapi) == 0)) + { + data.hm_nvapi = nvapi; + } - if (data.hm_nv) + if (data.hm_nvapi) { - if (hm_NVML_nvmlInit (data.hm_nv) == NVML_SUCCESS) + if (hm_NvAPI_Initialize (data.hm_nvapi) == NVAPI_OK) { - HM_ADAPTER_NV nvGPUHandle[DEVICES_MAX] = { 0 }; + HM_ADAPTER_NVAPI nvGPUHandle[DEVICES_MAX] = { 0 }; - int tmp_in = hm_get_adapter_index_nv (nvGPUHandle); + int tmp_in = hm_get_adapter_index_nvapi (nvGPUHandle); int tmp_out = 0; for (int i = 0; i < tmp_in; i++) { - hm_adapters_nv[tmp_out++].adapter_index.nv = nvGPUHandle[i]; + hm_adapters_nvapi[tmp_out++].nvapi = nvGPUHandle[i]; } + } + } - for (int i = 0; i < tmp_out; i++) + if ((need_xnvctrl == 1) && (xnvctrl_init (xnvctrl) == 0)) + { + data.hm_xnvctrl = xnvctrl; + } + + if (data.hm_xnvctrl) + { + if (hm_XNVCTRL_XOpenDisplay (data.hm_xnvctrl) == 0) + { + for (uint device_id = 0; device_id < data.devices_cnt; device_id++) { - unsigned int speed; + hc_device_param_t *device_param = &data.devices_param[device_id]; + + if ((device_param->device_type & CL_DEVICE_TYPE_GPU) == 0) continue; + + hm_adapters_xnvctrl[device_id].xnvctrl = device_id; + + int speed = 0; - if (hm_NVML_nvmlDeviceGetFanSpeed (data.hm_nv, 1, hm_adapters_nv[i].adapter_index.nv, &speed) != NVML_ERROR_NOT_SUPPORTED) hm_adapters_nv[i].fan_supported = 1; + if (get_fan_speed_current (data.hm_xnvctrl, device_id, &speed) == 0) hm_adapters_xnvctrl[device_id].fan_get_supported = 1; } } } - #endif // LINUX && HAVE_NVML - data.hm_amd = NULL; - - #ifdef HAVE_ADL - ADL_PTR *adl = (ADL_PTR *) mymalloc (sizeof (ADL_PTR)); - - if (adl_init (adl) == 0) - data.hm_amd = adl; + if ((need_adl == 1) && (adl_init (adl) == 0)) + { + data.hm_adl = adl; + } - if (data.hm_amd) + if (data.hm_adl) { - if (hm_ADL_Main_Control_Create (data.hm_amd, ADL_Main_Memory_Alloc, 0) == ADL_OK) + if (hm_ADL_Main_Control_Create (data.hm_adl, ADL_Main_Memory_Alloc, 0) == ADL_OK) { // total number of adapters int hm_adapters_num; - if (get_adapters_num_amd (data.hm_amd, &hm_adapters_num) != 0) return (-1); + if (get_adapters_num_adl (data.hm_adl, &hm_adapters_num) != 0) return (-1); // adapter info - LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_amd (data.hm_amd, hm_adapters_num); + LPAdapterInfo lpAdapterInfo = hm_get_adapter_info_adl (data.hm_adl, hm_adapters_num); if (lpAdapterInfo == NULL) return (-1); @@ -13397,12 +14591,12 @@ int main (int argc, char **argv) { hc_thread_mutex_lock (mux_adl); - // hm_get_opencl_busid_devid (hm_adapters_amd, devices_all_cnt, devices_all); + // hm_get_opencl_busid_devid (hm_adapters_adl, devices_all_cnt, devices_all); - hm_get_adapter_index_amd (hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo); + hm_get_adapter_index_adl (hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo); - hm_get_overdrive_version (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo); - hm_check_fanspeed_control (data.hm_amd, hm_adapters_amd, valid_adl_device_list, num_adl_adapters, lpAdapterInfo); + hm_get_overdrive_version (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo); + hm_check_fanspeed_control (data.hm_adl, hm_adapters_adl, valid_adl_device_list, num_adl_adapters, lpAdapterInfo); hc_thread_mutex_unlock (mux_adl); } @@ -13411,9 +14605,8 @@ int main (int argc, char **argv) myfree (lpAdapterInfo); } } - #endif // HAVE_ADL - if (data.hm_amd == NULL && data.hm_nv == NULL) + if (data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL) { gpu_temp_disable = 1; } @@ -13423,34 +14616,16 @@ int main (int argc, char **argv) * OpenCL devices: allocate buffer for device specific information */ - #ifdef HAVE_HWMON - int *temp_retain_fanspeed_value = (int *) mycalloc (data.devices_cnt, sizeof (int)); - - #ifdef HAVE_ADL ADLOD6MemClockState *od_clock_mem_status = (ADLOD6MemClockState *) mycalloc (data.devices_cnt, sizeof (ADLOD6MemClockState)); int *od_power_control_status = (int *) mycalloc (data.devices_cnt, sizeof (int)); - #endif // ADL - #endif - /** - * enable custom signal handler(s) - */ - - if (benchmark == 0) - { - hc_signal (sigHandler_default); - } - else - { - hc_signal (sigHandler_benchmark); - } + unsigned int *nvml_power_limit = (unsigned int *) mycalloc (data.devices_cnt, sizeof (unsigned int)); /** * User-defined GPU temp handling */ - #ifdef HAVE_HWMON if (gpu_temp_disable == 1) { gpu_temp_abort = 0; @@ -13461,7 +14636,7 @@ int main (int argc, char **argv) { 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); } @@ -13472,6 +14647,19 @@ int main (int argc, char **argv) data.gpu_temp_retain = gpu_temp_retain; #endif + /** + * enable custom signal handler(s) + */ + + if (benchmark == 0) + { + hc_signal (sigHandler_default); + } + else + { + hc_signal (sigHandler_benchmark); + } + /** * inform the user */ @@ -13504,7 +14692,7 @@ int main (int argc, char **argv) */ #ifdef HAVE_HWMON - if (gpu_temp_disable == 0 && data.hm_amd == NULL && data.hm_nv == NULL) + if (gpu_temp_disable == 0 && data.hm_adl == NULL && data.hm_nvml == NULL && data.hm_xnvctrl == NULL) { log_info ("Watchdog: Hardware Monitoring Interface not found on your system"); } @@ -13531,6 +14719,8 @@ int main (int argc, char **argv) #endif } + #ifdef HAVE_HWMON + /** * HM devices: copy */ @@ -13547,31 +14737,34 @@ int main (int argc, char **argv) const uint platform_devices_id = device_param->platform_devices_id; - #if defined(HAVE_NVML) || defined(HAVE_NVAPI) - if (device_param->vendor_id == VENDOR_ID_NV) + if (device_param->device_vendor_id == VENDOR_ID_AMD) { - memcpy (&data.hm_device[device_id], &hm_adapters_nv[platform_devices_id], sizeof (hm_attrs_t)); + data.hm_device[device_id].adl = hm_adapters_adl[platform_devices_id].adl; + data.hm_device[device_id].nvapi = 0; + data.hm_device[device_id].nvml = 0; + data.hm_device[device_id].xnvctrl = 0; + data.hm_device[device_id].od_version = hm_adapters_adl[platform_devices_id].od_version; + data.hm_device[device_id].fan_get_supported = hm_adapters_adl[platform_devices_id].fan_get_supported; + data.hm_device[device_id].fan_set_supported = 0; } - #endif - #ifdef HAVE_ADL - if (device_param->vendor_id == VENDOR_ID_AMD) + if (device_param->device_vendor_id == VENDOR_ID_NV) { - memcpy (&data.hm_device[device_id], &hm_adapters_amd[platform_devices_id], sizeof (hm_attrs_t)); + data.hm_device[device_id].adl = 0; + data.hm_device[device_id].nvapi = hm_adapters_nvapi[platform_devices_id].nvapi; + data.hm_device[device_id].nvml = hm_adapters_nvml[platform_devices_id].nvml; + data.hm_device[device_id].xnvctrl = hm_adapters_xnvctrl[platform_devices_id].xnvctrl; + data.hm_device[device_id].od_version = 0; + data.hm_device[device_id].fan_get_supported = hm_adapters_nvml[platform_devices_id].fan_get_supported; + data.hm_device[device_id].fan_set_supported = 0; } - #endif } } - /* - * Temporary fix: - * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff - * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately - * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem) - * Driver / ADL bug? - */ + /** + * powertune on user request + */ - #ifdef HAVE_ADL if (powertune_enable == 1) { hc_thread_mutex_lock (mux_adl); @@ -13582,38 +14775,177 @@ int main (int argc, char **argv) if (device_param->skipped) continue; - if (data.hm_device[device_id].od_version == 6) + if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD) { - // set powertune value only - - int powertune_supported = 0; - - int ADL_rc = 0; + /** + * Temporary fix: + * with AMD r9 295x cards it seems that we need to set the powertune value just AFTER the ocl init stuff + * otherwise after hc_clCreateContext () etc, powertune value was set back to "normal" and cards unfortunately + * were not working @ full speed (setting hm_ADL_Overdrive_PowerControl_Set () here seems to fix the problem) + * Driver / ADL bug? + */ - if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK) + if (data.hm_device[device_id].od_version == 6) { - log_error ("ERROR: Failed to get ADL PowerControl Capabilities"); + int ADL_rc; - return (-1); - } + // check powertune capabilities first, if not available then skip device - if (powertune_supported != 0) - { - // powertune set - ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0}; + int powertune_supported = 0; - if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) != ADL_OK) + if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK) { - log_error ("ERROR: Failed to get current ADL PowerControl settings"); + log_error ("ERROR: Failed to get ADL PowerControl Capabilities"); return (-1); } - if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK) + // first backup current value, we will restore it later + + if (powertune_supported != 0) + { + // powercontrol settings + + ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0}; + + if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) == ADL_OK) + { + ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_adl, data.hm_device[device_id].adl, &od_power_control_status[device_id]); + } + + if (ADL_rc != ADL_OK) + { + log_error ("ERROR: Failed to get current ADL PowerControl settings"); + + return (-1); + } + + if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK) + { + log_error ("ERROR: Failed to set new ADL PowerControl values"); + + return (-1); + } + + // clocks + + memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState)); + + od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2; + + if ((ADL_rc = hm_ADL_Overdrive_StateInfo_Get (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK) + { + log_error ("ERROR: Failed to get ADL memory and engine clock frequency"); + + return (-1); + } + + // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings + + ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0}; + + if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_adl, data.hm_device[device_id].adl, &caps)) != ADL_OK) + { + log_error ("ERROR: Failed to get ADL device capabilities"); + + return (-1); + } + + int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666; + int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250; + + int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max); + int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max); + + int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock; + int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock; + + // warning if profile has too low max values + + 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"); + } + + 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"); + } + + ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel)); + + performance_state->iNumberOfPerformanceLevels = 2; + + performance_state->aLevels[0].iEngineClock = engine_clock_profile_max; + performance_state->aLevels[1].iEngineClock = engine_clock_profile_max; + performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max; + performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max; + + if ((ADL_rc = hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK) + { + log_info ("ERROR: Failed to set ADL performance state"); + + return (-1); + } + + local_free (performance_state); + } + + // set powertune value only + + if (powertune_supported != 0) + { + // powertune set + ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0}; + + if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_adl, data.hm_device[device_id].adl, &powertune)) != ADL_OK) + { + log_error ("ERROR: Failed to get current ADL PowerControl settings"); + + return (-1); + } + + if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, powertune.iMaxValue)) != ADL_OK) + { + log_error ("ERROR: Failed to set new ADL PowerControl values"); + + return (-1); + } + } + } + } + + if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV) + { + // first backup current value, we will restore it later + + unsigned int limit; + + int powertune_supported = 0; + + if (hm_NVML_nvmlDeviceGetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, &limit) == NVML_SUCCESS) + { + powertune_supported = 1; + } + + // if backup worked, activate the maximum allowed + + if (powertune_supported != 0) + { + unsigned int minLimit; + unsigned int maxLimit; + + if (hm_NVML_nvmlDeviceGetPowerManagementLimitConstraints (data.hm_nvml, 0, data.hm_device[device_id].nvml, &minLimit, &maxLimit) == NVML_SUCCESS) { - log_error ("ERROR: Failed to set new ADL PowerControl values"); + if (maxLimit > 0) + { + if (hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, maxLimit) == NVML_SUCCESS) + { + // now we can be sure we need to reset later - return (-1); + nvml_power_limit[device_id] = limit; + } + } } } } @@ -13621,7 +14953,7 @@ int main (int argc, char **argv) hc_thread_mutex_unlock (mux_adl); } - #endif // HAVE_ADK + #endif // HAVE_HWMON #ifdef DEBUG @@ -13630,8 +14962,6 @@ int main (int argc, char **argv) if (data.quiet == 0) log_info_nn ("Initializing device kernels and memory..."); - uint kernel_power_all = 0; - for (uint device_id = 0; device_id < data.devices_cnt; device_id++) { /** @@ -13648,7 +14978,6 @@ int main (int argc, char **argv) const char *device_name_chksum = device_param->device_name_chksum; const u32 device_processors = device_param->device_processors; - const u32 device_processor_cores = device_param->device_processor_cores; /** * create context for each device @@ -13682,7 +15011,9 @@ int main (int argc, char **argv) if (hash_mode == 3000) kernel_threads = 64; // DES if (hash_mode == 3200) kernel_threads = 8; // Blowfish if (hash_mode == 7500) kernel_threads = 64; // RC4 + if (hash_mode == 8900) kernel_threads = 64; // Scrypt if (hash_mode == 9000) kernel_threads = 8; // Blowfish + if (hash_mode == 9300) kernel_threads = 64; // Scrypt if (hash_mode == 9700) kernel_threads = 64; // RC4 if (hash_mode == 9710) kernel_threads = 64; // RC4 if (hash_mode == 9800) kernel_threads = 64; // RC4 @@ -13692,6 +15023,10 @@ int main (int argc, char **argv) if (hash_mode == 10500) kernel_threads = 64; // RC4 if (hash_mode == 13100) kernel_threads = 64; // RC4 + device_param->kernel_threads = kernel_threads; + + device_param->hardware_power = device_processors * kernel_threads; + /** * create input buffers on device : calculate size of fixed memory buffers */ @@ -13702,7 +15037,7 @@ int main (int argc, char **argv) device_param->size_root_css = size_root_css; device_param->size_markov_css = size_markov_css; - size_t size_results = kernel_threads * sizeof (uint); + size_t size_results = sizeof (uint); device_param->size_results = size_results; @@ -13724,10 +15059,28 @@ int main (int argc, char **argv) // scryptV stuff - size_t size_scryptV = 1; + size_t size_scrypt = 4; if ((hash_mode == 8900) || (hash_mode == 9300)) { + // we need to check that all hashes have the same scrypt settings + + const u32 scrypt_N = data.salts_buf[0].scrypt_N; + const u32 scrypt_r = data.salts_buf[0].scrypt_r; + const u32 scrypt_p = data.salts_buf[0].scrypt_p; + + for (uint i = 1; i < salts_cnt; i++) + { + if ((data.salts_buf[i].scrypt_N != scrypt_N) + || (data.salts_buf[i].scrypt_r != scrypt_r) + || (data.salts_buf[i].scrypt_p != scrypt_p)) + { + log_error ("ERROR: Mixed scrypt settings not supported"); + + return -1; + } + } + uint tmto_start = 0; uint tmto_stop = 10; @@ -13738,75 +15091,86 @@ int main (int argc, char **argv) else { // in case the user did not specify the tmto manually - // use some values known to run best (tested on 290x for AMD and 980ti for NV) - // but set the lower end only in case the user has a device with too less memory + // use some values known to run best (tested on 290x for AMD and GTX1080 for NV) if (hash_mode == 8900) { - if (device_param->vendor_id == VENDOR_ID_AMD) + if (device_param->device_vendor_id == VENDOR_ID_AMD) { - tmto_start = 1; + tmto_start = 3; } - else if (device_param->vendor_id == VENDOR_ID_NV) + else if (device_param->device_vendor_id == VENDOR_ID_NV) { tmto_start = 2; } } else if (hash_mode == 9300) { - if (device_param->vendor_id == VENDOR_ID_AMD) + if (device_param->device_vendor_id == VENDOR_ID_AMD) { tmto_start = 2; } - else if (device_param->vendor_id == VENDOR_ID_NV) + else if (device_param->device_vendor_id == VENDOR_ID_NV) { - tmto_start = 2; + tmto_start = 4; } } } - for (uint tmto = tmto_start; tmto < tmto_stop; tmto++) + data.scrypt_tmp_size = (128 * scrypt_r); + + device_param->kernel_accel_min = 1; + device_param->kernel_accel_max = 8; + + uint tmto; + + for (tmto = tmto_start; tmto < tmto_stop; tmto++) { - // TODO: in theory the following calculation needs to be done per salt, not global - // we assume all hashes have the same scrypt settings + size_scrypt = (128 * scrypt_r) * scrypt_N; - size_scryptV = (128 * data.salts_buf[0].scrypt_r) * data.salts_buf[0].scrypt_N; + size_scrypt /= 1 << tmto; - size_scryptV /= 1 << tmto; + size_scrypt *= device_param->device_processors * device_param->kernel_threads * device_param->kernel_accel_max; - size_scryptV *= device_processors * device_processor_cores; + if ((size_scrypt / 4) > device_param->device_maxmem_alloc) + { + if (quiet == 0) log_info ("WARNING: Not enough single-block device memory allocatable to use --scrypt-tmto %d, increasing...", tmto); + + continue; + } - if (size_scryptV > device_param->device_maxmem_alloc) + if (size_scrypt > device_param->device_global_mem) { - 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 total device memory allocatable to use --scrypt-tmto %d, increasing...", tmto); continue; } for (uint salts_pos = 0; salts_pos < data.salts_cnt; salts_pos++) { - data.salts_buf[salts_pos].scrypt_tmto = tmto; - data.salts_buf[salts_pos].scrypt_phy = device_processors * device_processor_cores; + data.scrypt_tmto_final = tmto; } break; } - if (data.salts_buf[0].scrypt_phy == 0) + if (tmto == tmto_stop) { - log_error ("ERROR: can't allocate enough device memory"); + log_error ("ERROR: Can't allocate enough device memory"); return -1; } - if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.salts_buf[0].scrypt_tmto, size_scryptV); + if (quiet == 0) log_info ("SCRYPT tmto optimizer value set to: %u, mem: %u\n", data.scrypt_tmto_final, size_scrypt); } + size_t size_scrypt4 = size_scrypt / 4; + /** * some algorithms need a fixed kernel-loops count */ - if (hash_mode == 1500) + if (hash_mode == 1500 && attack_mode == ATTACK_MODE_BF) { const u32 kernel_loops_fixed = 1024; @@ -13814,7 +15178,7 @@ int main (int argc, char **argv) device_param->kernel_loops_max = kernel_loops_fixed; } - if (hash_mode == 3000) + if (hash_mode == 3000 && attack_mode == ATTACK_MODE_BF) { const u32 kernel_loops_fixed = 1024; @@ -13850,28 +15214,26 @@ int main (int argc, char **argv) * some algorithms have a maximum kernel-loops count */ - if (attack_exec == ATTACK_EXEC_OUTSIDE_KERNEL) + if (device_param->kernel_loops_min < device_param->kernel_loops_max) { - if (data.salts_buf[0].salt_iter < device_param->kernel_loops_max) + u32 innerloop_cnt = 0; + + if (data.attack_exec == ATTACK_EXEC_INSIDE_KERNEL) { - device_param->kernel_loops_max = data.salts_buf[0].salt_iter; + if (data.attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = data.kernel_rules_cnt; + else if (data.attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = data.combs_cnt; + else if (data.attack_kern == ATTACK_KERN_BF) innerloop_cnt = data.bfs_cnt; + } + else + { + innerloop_cnt = data.salts_buf[0].salt_iter; } - } - - /** - * some algorithms need a special kernel-accel - */ - - if (hash_mode == 8900) - { - device_param->kernel_accel_min = 1; - device_param->kernel_accel_max = 64; - } - if (hash_mode == 9300) - { - device_param->kernel_accel_min = 1; - device_param->kernel_accel_max = 64; + if ((innerloop_cnt >= device_param->kernel_loops_min) && + (innerloop_cnt <= device_param->kernel_loops_max)) + { + device_param->kernel_loops_max = innerloop_cnt; + } } u32 kernel_accel_min = device_param->kernel_accel_min; @@ -13929,11 +15291,11 @@ int main (int argc, char **argv) case 7900: size_tmps = kernel_power_max * sizeof (drupal7_tmp_t); break; case 8200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha512_tmp_t); break; case 8800: size_tmps = kernel_power_max * sizeof (androidfde_tmp_t); break; - case 8900: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break; + case 8900: size_tmps = kernel_power_max * data.scrypt_tmp_size; break; case 9000: size_tmps = kernel_power_max * sizeof (pwsafe2_tmp_t); break; case 9100: size_tmps = kernel_power_max * sizeof (lotus8_tmp_t); break; case 9200: size_tmps = kernel_power_max * sizeof (pbkdf2_sha256_tmp_t); break; - case 9300: size_tmps = kernel_power_max * sizeof (scrypt_tmp_t); break; + case 9300: size_tmps = kernel_power_max * data.scrypt_tmp_size; break; case 9400: size_tmps = kernel_power_max * sizeof (office2007_tmp_t); break; case 9500: size_tmps = kernel_power_max * sizeof (office2010_tmp_t); break; case 9600: size_tmps = kernel_power_max * sizeof (office2013_tmp_t); break; @@ -13959,52 +15321,78 @@ int main (int argc, char **argv) case 13200: size_tmps = kernel_power_max * sizeof (axcrypt_tmp_t); break; case 13400: size_tmps = kernel_power_max * sizeof (keepass_tmp_t); break; case 13600: size_tmps = kernel_power_max * sizeof (pbkdf2_sha1_tmp_t); break; + case 13711: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break; + case 13712: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break; + case 13713: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break; + case 13721: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break; + case 13722: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break; + case 13723: size_tmps = kernel_power_max * sizeof (tc64_tmp_t); break; + case 13731: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break; + case 13732: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break; + case 13733: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break; + case 13741: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break; + case 13742: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break; + case 13743: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break; + case 13751: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break; + case 13752: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break; + case 13753: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break; + case 13761: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break; + case 13762: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break; + case 13763: size_tmps = kernel_power_max * sizeof (tc_tmp_t); break; }; // size_hooks if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23)) { - // none yet + switch (hash_mode) + { + } } // now check if all device-memory sizes which depend on the kernel_accel_max amplifier are within its boundaries // if not, decrease amplifier and try again - int skip = 0; - - if (size_pws > device_param->device_maxmem_alloc) skip = 1; - if (size_tmps > device_param->device_maxmem_alloc) skip = 1; - if (size_hooks > device_param->device_maxmem_alloc) skip = 1; - - if (( bitmap_size - + bitmap_size - + bitmap_size - + bitmap_size - + bitmap_size - + bitmap_size - + bitmap_size - + bitmap_size - + size_bfs - + size_combs - + size_digests - + size_esalts - + size_hooks - + size_markov_css - + size_plains - + size_pws - + size_pws // not a bug - + size_results - + size_root_css - + size_rules - + size_rules_c - + size_salts - + size_scryptV - + size_shown - + size_tm - + size_tmps) > device_param->device_global_mem) skip = 1; - - if (skip == 1) + int memory_limit_hit = 0; + + if (size_pws > device_param->device_maxmem_alloc) memory_limit_hit = 1; + if (size_tmps > device_param->device_maxmem_alloc) memory_limit_hit = 1; + if (size_hooks > device_param->device_maxmem_alloc) memory_limit_hit = 1; + + const u64 size_total + = bitmap_size + + bitmap_size + + bitmap_size + + bitmap_size + + bitmap_size + + bitmap_size + + bitmap_size + + bitmap_size + + size_bfs + + size_combs + + size_digests + + size_esalts + + size_hooks + + size_markov_css + + size_plains + + size_pws + + size_pws // not a bug + + size_results + + size_root_css + + size_rules + + size_rules_c + + size_salts + + size_scrypt4 + + size_scrypt4 + + size_scrypt4 + + size_scrypt4 + + size_shown + + size_tm + + size_tmps; + + if (size_total > device_param->device_global_mem) memory_limit_hit = 1; + + if (memory_limit_hit == 1) { kernel_accel_max--; @@ -14014,14 +15402,12 @@ int main (int argc, char **argv) break; } - /* - if (kernel_accel_max == 0) + if (kernel_accel_max < kernel_accel_min) { - 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 this attack", device_id + 1); return -1; } - */ device_param->kernel_accel_min = kernel_accel_min; device_param->kernel_accel_max = kernel_accel_max; @@ -14029,7 +15415,7 @@ int main (int argc, char **argv) /* 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; } @@ -14043,38 +15429,118 @@ int main (int argc, char **argv) device_param->size_tmps = size_tmps; device_param->size_hooks = size_hooks; - // do not confuse kernel_accel_max with kernel_accel here - - const u32 kernel_power = device_processors * kernel_threads * kernel_accel_max; - - device_param->kernel_threads = kernel_threads; - device_param->kernel_power_user = kernel_power; - - kernel_power_all += kernel_power; - /** * default building options */ + char cpath[1024] = { 0 }; + char build_opts[1024] = { 0 }; - // we don't have sm_* on vendors not NV but it doesn't matter + #if _WIN + + snprintf (cpath, sizeof (cpath) - 1, "%s\\OpenCL\\", shared_dir); + + char *cpath_real = mymalloc (MAX_PATH); + + if (GetFullPathName (cpath, MAX_PATH, cpath_real, NULL) == 0) + { + log_error ("ERROR: %s: %s", cpath, "GetFullPathName()"); + + return -1; + } - snprintf (build_opts, sizeof (build_opts) - 1, "-cl-std=CL1.1 -I\"%s/\" -DVENDOR_ID=%u -DCUDA_ARCH=%d -DVECT_SIZE=%u -DDEVICE_TYPE=%u -DKERN_TYPE=%u -D_unroll", shared_dir, device_param->vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type, kern_type); + naive_replace (cpath_real, '\\', '/'); - if (device_param->vendor_id == VENDOR_ID_INTEL_SDK) + // not escaping here, windows has quotes + + snprintf (build_opts, sizeof (build_opts) - 1, "-I \"%s\"", cpath_real); + + #else + + snprintf (cpath, sizeof (cpath) - 1, "%s/OpenCL/", shared_dir); + + char *cpath_real = mymalloc (PATH_MAX); + + if (realpath (cpath, cpath_real) == NULL) + { + log_error ("ERROR: %s: %s", cpath, strerror (errno)); + + return -1; + } + + naive_escape (cpath_real, PATH_MAX, ' ', '\\'); + + snprintf (build_opts, sizeof (build_opts) - 1, "-I %s", cpath_real); + + #endif + + // include check + // this test needs to be done manually because of osx opencl runtime + // if there's a problem with permission, its not reporting back and erroring out silently + + #define files_cnt 15 + + const char *files_names[files_cnt] = + { + "inc_cipher_aes256.cl", + "inc_cipher_serpent256.cl", + "inc_cipher_twofish256.cl", + "inc_common.cl", + "inc_comp_multi_bs.cl", + "inc_comp_multi.cl", + "inc_comp_single_bs.cl", + "inc_comp_single.cl", + "inc_hash_constants.h", + "inc_hash_functions.cl", + "inc_rp.cl", + "inc_rp.h", + "inc_simd.cl", + "inc_types.cl", + "inc_vendor.cl", + }; + + for (int i = 0; i < files_cnt; i++) { - // we do vectorizing much better than the auto-vectorizer + char path[1024] = { 0 }; + + snprintf (path, sizeof (path) - 1, "%s/%s", cpath_real, files_names[i]); + + FILE *fd = fopen (path, "r"); + + if (fd == NULL) + { + log_error ("ERROR: %s: fopen(): %s", path, strerror (errno)); + + return -1; + } + + char buf[1]; + + size_t n = fread (buf, 1, 1, fd); - char build_opts_new[1024] = { 0 }; + if (n != 1) + { + log_error ("ERROR: %s: fread(): %s", path, strerror (errno)); - snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -cl-opt-disable", build_opts); + return -1; + } - strncpy (build_opts, build_opts_new, sizeof (build_opts) - 1); + fclose (fd); } + myfree (cpath_real); + + // we don't have sm_* on vendors not NV but it doesn't matter + + char build_opts_new[1024] = { 0 }; + + snprintf (build_opts_new, sizeof (build_opts_new) - 1, "%s -D VENDOR_ID=%u -D CUDA_ARCH=%d -D VECT_SIZE=%u -D DEVICE_TYPE=%u -D DGST_R0=%u -D DGST_R1=%u -D DGST_R2=%u -D DGST_R3=%u -D DGST_ELEM=%u -D KERN_TYPE=%u -D _unroll -cl-std=CL1.1", build_opts, device_param->device_vendor_id, (device_param->sm_major * 100) + device_param->sm_minor, device_param->vector_width, (u32) device_param->device_type, data.dgst_pos0, data.dgst_pos1, data.dgst_pos2, data.dgst_pos3, data.dgst_size / 4, kern_type); + + strncpy (build_opts, build_opts_new, sizeof (build_opts)); + #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 /** @@ -14128,7 +15594,7 @@ int main (int argc, char **argv) { 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); @@ -14159,7 +15625,7 @@ int main (int argc, char **argv) { 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; } @@ -14179,7 +15645,7 @@ int main (int argc, char **argv) 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); @@ -14192,7 +15658,7 @@ int main (int argc, char **argv) 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); @@ -14203,11 +15669,11 @@ int main (int argc, char **argv) if (force_jit_compilation == 1500) { - snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%d", build_opts, data.salts_buf[0].salt_buf[0]); + snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DDESCRYPT_SALT=%u", build_opts, data.salts_buf[0].salt_buf[0]); } else if (force_jit_compilation == 8900) { - snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DSCRYPT_N=%d -DSCRYPT_R=%d -DSCRYPT_P=%d -DSCRYPT_TMTO=%d", build_opts, data.salts_buf[0].scrypt_N, data.salts_buf[0].scrypt_r, data.salts_buf[0].scrypt_p, 1 << data.salts_buf[0].scrypt_tmto); + snprintf (build_opts_update, sizeof (build_opts_update) - 1, "%s -DSCRYPT_N=%u -DSCRYPT_R=%u -DSCRYPT_P=%u -DSCRYPT_TMTO=%u -DSCRYPT_TMP_ELEM=%u", build_opts, data.salts_buf[0].scrypt_N, data.salts_buf[0].scrypt_r, data.salts_buf[0].scrypt_p, 1 << data.scrypt_tmto_final, data.scrypt_tmp_size / 16); } else { @@ -14239,7 +15705,7 @@ int main (int argc, char **argv) { 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); } } @@ -14298,7 +15764,7 @@ int main (int argc, char **argv) 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); @@ -14311,7 +15777,7 @@ int main (int argc, char **argv) { 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; } @@ -14331,7 +15797,7 @@ int main (int argc, char **argv) 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); @@ -14400,7 +15866,7 @@ int main (int argc, char **argv) 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); @@ -14413,7 +15879,7 @@ int main (int argc, char **argv) { 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; } @@ -14433,7 +15899,7 @@ int main (int argc, char **argv) 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); @@ -14479,7 +15945,10 @@ int main (int argc, char **argv) device_param->d_digests_shown = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_shown, NULL); device_param->d_salt_bufs = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_salts, NULL); device_param->d_result = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_results, NULL); - device_param->d_scryptV_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scryptV, NULL); + device_param->d_scryptV0_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL); + device_param->d_scryptV1_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL); + device_param->d_scryptV2_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL); + device_param->d_scryptV3_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_WRITE, size_scrypt4, NULL); hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s1_a, CL_TRUE, 0, bitmap_size, bitmap_s1_a, 0, NULL, NULL); hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_bitmap_s1_b, CL_TRUE, 0, bitmap_size, bitmap_s1_b, 0, NULL, NULL); @@ -14493,13 +15962,6 @@ int main (int argc, char **argv) hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_digests_shown, CL_TRUE, 0, size_shown, data.digests_shown, 0, NULL, NULL); hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_salt_bufs, CL_TRUE, 0, size_salts, data.salts_buf, 0, NULL, NULL); - run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws); - run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws); - run_kernel_bzero (device_param, device_param->d_tmps, size_tmps); - run_kernel_bzero (device_param, device_param->d_hooks, size_hooks); - run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains); - run_kernel_bzero (device_param, device_param->d_result, size_results); - /** * special buffers */ @@ -14510,8 +15972,6 @@ int main (int argc, char **argv) device_param->d_rules_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_rules_c, NULL); hc_clEnqueueWriteBuffer (data.ocl, device_param->command_queue, device_param->d_rules, CL_TRUE, 0, size_rules, kernel_rules_buf, 0, NULL, NULL); - - run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c); } else if (attack_kern == ATTACK_KERN_COMBI) { @@ -14519,11 +15979,6 @@ int main (int argc, char **argv) device_param->d_combs_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_combs, NULL); device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL); device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL); - - run_kernel_bzero (device_param, device_param->d_combs, size_combs); - run_kernel_bzero (device_param, device_param->d_combs_c, size_combs); - run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css); - run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css); } else if (attack_kern == ATTACK_KERN_BF) { @@ -14532,12 +15987,6 @@ int main (int argc, char **argv) device_param->d_tm_c = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_tm, NULL); device_param->d_root_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_root_css, NULL); device_param->d_markov_css_buf = hc_clCreateBuffer (data.ocl, device_param->context, CL_MEM_READ_ONLY, size_markov_css, NULL); - - run_kernel_bzero (device_param, device_param->d_bfs, size_bfs); - run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs); - run_kernel_bzero (device_param, device_param->d_tm_c, size_tm); - run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css); - run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css); } if (size_esalts) @@ -14551,10 +16000,6 @@ int main (int argc, char **argv) * main host data */ - uint *result = (uint *) mymalloc (size_results); - - device_param->result = result; - pw_t *pws_buf = (pw_t *) mymalloc (size_pws); device_param->pws_buf = pws_buf; @@ -14571,17 +16016,17 @@ int main (int argc, char **argv) * kernel args */ - device_param->kernel_params_buf32[21] = bitmap_mask; - device_param->kernel_params_buf32[22] = bitmap_shift1; - device_param->kernel_params_buf32[23] = bitmap_shift2; - device_param->kernel_params_buf32[24] = 0; // salt_pos - device_param->kernel_params_buf32[25] = 0; // loop_pos - device_param->kernel_params_buf32[26] = 0; // loop_cnt - device_param->kernel_params_buf32[27] = 0; // kernel_rules_cnt - device_param->kernel_params_buf32[28] = 0; // digests_cnt - device_param->kernel_params_buf32[29] = 0; // digests_offset - device_param->kernel_params_buf32[30] = 0; // combs_mode - device_param->kernel_params_buf32[31] = 0; // gid_max + device_param->kernel_params_buf32[24] = bitmap_mask; + device_param->kernel_params_buf32[25] = bitmap_shift1; + device_param->kernel_params_buf32[26] = bitmap_shift2; + device_param->kernel_params_buf32[27] = 0; // salt_pos + device_param->kernel_params_buf32[28] = 0; // loop_pos + device_param->kernel_params_buf32[29] = 0; // loop_cnt + device_param->kernel_params_buf32[30] = 0; // kernel_rules_cnt + device_param->kernel_params_buf32[31] = 0; // digests_cnt + device_param->kernel_params_buf32[32] = 0; // digests_offset + device_param->kernel_params_buf32[33] = 0; // combs_mode + device_param->kernel_params_buf32[34] = 0; // gid_max device_param->kernel_params[ 0] = (attack_exec == ATTACK_EXEC_INSIDE_KERNEL) ? &device_param->d_pws_buf @@ -14605,10 +16050,10 @@ int main (int argc, char **argv) device_param->kernel_params[17] = &device_param->d_salt_bufs; device_param->kernel_params[18] = &device_param->d_esalt_bufs; device_param->kernel_params[19] = &device_param->d_result; - device_param->kernel_params[20] = &device_param->d_scryptV_buf; - device_param->kernel_params[21] = &device_param->kernel_params_buf32[21]; - device_param->kernel_params[22] = &device_param->kernel_params_buf32[22]; - device_param->kernel_params[23] = &device_param->kernel_params_buf32[23]; + device_param->kernel_params[20] = &device_param->d_scryptV0_buf; + device_param->kernel_params[21] = &device_param->d_scryptV1_buf; + device_param->kernel_params[22] = &device_param->d_scryptV2_buf; + device_param->kernel_params[23] = &device_param->d_scryptV3_buf; device_param->kernel_params[24] = &device_param->kernel_params_buf32[24]; device_param->kernel_params[25] = &device_param->kernel_params_buf32[25]; device_param->kernel_params[26] = &device_param->kernel_params_buf32[26]; @@ -14617,6 +16062,9 @@ int main (int argc, char **argv) device_param->kernel_params[29] = &device_param->kernel_params_buf32[29]; device_param->kernel_params[30] = &device_param->kernel_params_buf32[30]; device_param->kernel_params[31] = &device_param->kernel_params_buf32[31]; + device_param->kernel_params[32] = &device_param->kernel_params_buf32[32]; + device_param->kernel_params[33] = &device_param->kernel_params_buf32[33]; + device_param->kernel_params[34] = &device_param->kernel_params_buf32[34]; device_param->kernel_params_mp_buf64[3] = 0; device_param->kernel_params_mp_buf32[4] = 0; @@ -14685,6 +16133,13 @@ int main (int argc, char **argv) device_param->kernel_params_tm[0] = &device_param->d_bfs_c; device_param->kernel_params_tm[1] = &device_param->d_tm_c; + device_param->kernel_params_memset_buf32[1] = 0; // value + device_param->kernel_params_memset_buf32[2] = 0; // gid_max + + device_param->kernel_params_memset[0] = NULL; + device_param->kernel_params_memset[1] = &device_param->kernel_params_memset_buf32[1]; + device_param->kernel_params_memset[2] = &device_param->kernel_params_memset_buf32[2]; + /** * kernel name */ @@ -14773,7 +16228,7 @@ int main (int argc, char **argv) hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel2, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp); hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel3, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp); - for (uint i = 0; i <= 20; i++) + for (uint i = 0; i <= 23; i++) { hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_mem), device_param->kernel_params[i]); hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_mem), device_param->kernel_params[i]); @@ -14783,7 +16238,7 @@ int main (int argc, char **argv) if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_mem), device_param->kernel_params[i]); } - for (uint i = 21; i <= 31; i++) + for (uint i = 24; i <= 34; i++) { hc_clSetKernelArg (data.ocl, device_param->kernel1, i, sizeof (cl_uint), device_param->kernel_params[i]); hc_clSetKernelArg (data.ocl, device_param->kernel2, i, sizeof (cl_uint), device_param->kernel_params[i]); @@ -14793,6 +16248,18 @@ int main (int argc, char **argv) if (opts_type & OPTS_TYPE_HOOK23) hc_clSetKernelArg (data.ocl, device_param->kernel23, i, sizeof (cl_uint), device_param->kernel_params[i]); } + // GPU memset + + device_param->kernel_memset = hc_clCreateKernel (data.ocl, device_param->program, "gpu_memset"); + + hc_clGetKernelWorkGroupInfo (data.ocl, device_param->kernel_memset, device_param->device, CL_KERNEL_WORK_GROUP_SIZE, sizeof (size_t), &kernel_wgs_tmp, NULL); kernel_threads = MIN (kernel_threads, kernel_wgs_tmp); + + hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 0, sizeof (cl_mem), device_param->kernel_params_memset[0]); + hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 1, sizeof (cl_uint), device_param->kernel_params_memset[1]); + hc_clSetKernelArg (data.ocl, device_param->kernel_memset, 2, sizeof (cl_uint), device_param->kernel_params_memset[2]); + + // MP start + if (attack_mode == ATTACK_MODE_BF) { device_param->kernel_mp_l = hc_clCreateKernel (data.ocl, device_param->program_mp, "l_markov"); @@ -14853,185 +16320,103 @@ int main (int argc, char **argv) device_param->kernel_threads = kernel_threads; + // zero some data buffers + + run_kernel_bzero (device_param, device_param->d_pws_buf, size_pws); + run_kernel_bzero (device_param, device_param->d_pws_amp_buf, size_pws); + run_kernel_bzero (device_param, device_param->d_tmps, size_tmps); + run_kernel_bzero (device_param, device_param->d_hooks, size_hooks); + run_kernel_bzero (device_param, device_param->d_plain_bufs, size_plains); + run_kernel_bzero (device_param, device_param->d_result, size_results); + /** - * Store initial fanspeed if gpu_temp_retain is enabled + * special buffers */ - #if defined(HAVE_HWMON) && defined(HAVE_ADL) - int gpu_temp_retain_set = 0; - - if (gpu_temp_disable == 0) + if (attack_kern == ATTACK_KERN_STRAIGHT) { - if (gpu_temp_retain != 0) // VENDOR_ID_AMD implied - { - hc_thread_mutex_lock (mux_adl); - - if (data.hm_device[device_id].fan_supported == 1) - { - if (gpu_temp_retain_chgd == 0) - { - uint cur_temp = 0; - uint default_temp = 0; - - int ADL_rc = hm_ADL_Overdrive6_TargetTemperatureData_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, (int *) &cur_temp, (int *) &default_temp); - - if (ADL_rc == ADL_OK) - { - #define GPU_TEMP_RETAIN_ABORT_DIFF 15 - - const uint gpu_temp_retain_target = default_temp - GPU_TEMP_RETAIN_ABORT_DIFF; - - // special case with multi gpu setups: always use minimum retain - - if (gpu_temp_retain_set == 0) - { - gpu_temp_retain = gpu_temp_retain_target; - gpu_temp_retain_set = 1; - } - else - { - gpu_temp_retain = MIN (gpu_temp_retain, gpu_temp_retain_target); - } - - if (gpu_temp_abort_chgd == 0) gpu_temp_abort = gpu_temp_retain + GPU_TEMP_RETAIN_ABORT_DIFF; - } - } - - const int fan_speed = hm_get_fanspeed_with_device_id (device_id); - - temp_retain_fanspeed_value[device_id] = fan_speed; - - if (fan_speed == -1) - { - log_info ("WARNING: Failed to get current fan speed settings for gpu number: %i:", device_id + 1); - - temp_retain_fanspeed_value[device_id] = 0; - } - } - - hc_thread_mutex_unlock (mux_adl); - } + run_kernel_bzero (device_param, device_param->d_rules_c, size_rules_c); + } + else if (attack_kern == ATTACK_KERN_COMBI) + { + run_kernel_bzero (device_param, device_param->d_combs, size_combs); + run_kernel_bzero (device_param, device_param->d_combs_c, size_combs); + run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css); + run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css); + } + else if (attack_kern == ATTACK_KERN_BF) + { + run_kernel_bzero (device_param, device_param->d_bfs, size_bfs); + run_kernel_bzero (device_param, device_param->d_bfs_c, size_bfs); + run_kernel_bzero (device_param, device_param->d_tm_c, size_tm); + run_kernel_bzero (device_param, device_param->d_root_css_buf, size_root_css); + run_kernel_bzero (device_param, device_param->d_markov_css_buf, size_markov_css); } + #if defined(HAVE_HWMON) + /** - * Store original powercontrol/clocks settings, set overdrive 6 performance tuning settings + * Store initial fanspeed if gpu_temp_retain is enabled */ - if (powertune_enable == 1) // VENDOR_ID_AMD implied + if (gpu_temp_disable == 0) { - hc_thread_mutex_lock (mux_adl); - - if (data.hm_device[device_id].od_version == 6) + if (gpu_temp_retain != 0) { - int ADL_rc; - - // check powertune capabilities first, if not available then skip device - - int powertune_supported = 0; - - if ((ADL_rc = hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK) - { - log_error ("ERROR: Failed to get ADL PowerControl Capabilities"); - - return (-1); - } + hc_thread_mutex_lock (mux_adl); - if (powertune_supported != 0) + if (data.hm_device[device_id].fan_get_supported == 1) { - // powercontrol settings - - ADLOD6PowerControlInfo powertune = {0, 0, 0, 0, 0}; - - if ((ADL_rc = hm_ADL_Overdrive_PowerControlInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune)) == ADL_OK) - { - ADL_rc = hm_ADL_Overdrive_PowerControl_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &od_power_control_status[device_id]); - } - - if (ADL_rc != ADL_OK) - { - log_error ("ERROR: Failed to get current ADL PowerControl settings"); - - return (-1); - } - - if ((ADL_rc = hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, powertune.iMaxValue)) != ADL_OK) - { - log_error ("ERROR: Failed to set new ADL PowerControl values"); - - return (-1); - } - - // clocks - - memset (&od_clock_mem_status[device_id], 0, sizeof (ADLOD6MemClockState)); - - od_clock_mem_status[device_id].state.iNumberOfPerformanceLevels = 2; - - if ((ADL_rc = hm_ADL_Overdrive_StateInfo_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE, &od_clock_mem_status[device_id])) != ADL_OK) - { - log_error ("ERROR: Failed to get ADL memory and engine clock frequency"); - - return (-1); - } - - // Query capabilities only to see if profiles were not "damaged", if so output a warning but do accept the users profile settings + const int fanspeed = hm_get_fanspeed_with_device_id (device_id); + const int fanpolicy = hm_get_fanpolicy_with_device_id (device_id); - ADLOD6Capabilities caps = {0, 0, 0, {0, 0, 0}, {0, 0, 0}, 0, 0}; + // we also set it to tell the OS we take control over the fan and it's automatic controller + // if it was set to automatic. we do not control user-defined fanspeeds. - if ((ADL_rc = hm_ADL_Overdrive_Capabilities_Get (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &caps)) != ADL_OK) + if (fanpolicy == 1) { - log_error ("ERROR: Failed to get ADL device capabilities"); - - return (-1); - } - - int engine_clock_max = caps.sEngineClockRange.iMax * 0.6666; - int memory_clock_max = caps.sMemoryClockRange.iMax * 0.6250; + data.hm_device[device_id].fan_set_supported = 1; - int warning_trigger_engine = (int) (0.25 * (float) engine_clock_max); - int warning_trigger_memory = (int) (0.25 * (float) memory_clock_max); + int rc = -1; - int engine_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock; - int memory_clock_profile_max = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock; + if (device_param->device_vendor_id == VENDOR_ID_AMD) + { + rc = hm_set_fanspeed_with_device_id_adl (device_id, fanspeed, 1); + } + else if (device_param->device_vendor_id == VENDOR_ID_NV) + { + #ifdef LINUX + rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_TRUE); + #endif - // warning if profile has too low max values + #ifdef WIN + rc = hm_set_fanspeed_with_device_id_nvapi (device_id, fanspeed, 1); + #endif + } - 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"); - } + if (rc == 0) + { + data.hm_device[device_id].fan_set_supported = 1; + } + else + { + log_info ("WARNING: Failed to set initial fan speed for device #%u", device_id + 1); - 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"); + data.hm_device[device_id].fan_set_supported = 0; + } } - - ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel)); - - performance_state->iNumberOfPerformanceLevels = 2; - - performance_state->aLevels[0].iEngineClock = engine_clock_profile_max; - performance_state->aLevels[1].iEngineClock = engine_clock_profile_max; - performance_state->aLevels[0].iMemoryClock = memory_clock_profile_max; - performance_state->aLevels[1].iMemoryClock = memory_clock_profile_max; - - if ((ADL_rc = hm_ADL_Overdrive_State_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK) + else { - log_info ("ERROR: Failed to set ADL performance state"); - - return (-1); + data.hm_device[device_id].fan_set_supported = 0; } - - local_free (performance_state); } - } - hc_thread_mutex_unlock (mux_adl); + hc_thread_mutex_unlock (mux_adl); + } } - #endif // HAVE_HWMON && HAVE_ADL - } - data.kernel_power_all = kernel_power_all; + #endif // HAVE_HWMON + } if (data.quiet == 0) log_info_nn (""); @@ -15041,7 +16426,7 @@ int main (int argc, char **argv) if (benchmark == 1) { - if (status_automat == 0) + if (machine_readable == 0) { quiet = 0; @@ -15105,10 +16490,6 @@ int main (int argc, char **argv) wl_data->cnt = 0; wl_data->pos = 0; - uint wordlist_mode = ((optind + 1) < myargc) ? WL_MODE_FILE : WL_MODE_STDIN; - - data.wordlist_mode = wordlist_mode; - cs_t *css_buf = NULL; uint css_cnt = 0; uint dictcnt = 0; @@ -15153,7 +16534,7 @@ int main (int argc, char **argv) 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); } @@ -15616,7 +16997,7 @@ int main (int argc, char **argv) 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); } @@ -15795,7 +17176,7 @@ int main (int argc, char **argv) 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); } @@ -15901,42 +17282,39 @@ int main (int argc, char **argv) * status and monitor threads */ - if (data.devices_status != STATUS_CRACKED) data.devices_status = STATUS_STARTING; - - hc_thread_t i_thread = 0; - - if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK)) + if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT)) { - hc_thread_create (i_thread, thread_keypress, &benchmark); + data.devices_status = STATUS_STARTING; } - if (wordlist_mode == WL_MODE_STDIN) data.status = 1; + uint inner_threads_cnt = 0; - uint ni_threads_cnt = 0; + hc_thread_t *inner_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t)); - hc_thread_t *ni_threads = (hc_thread_t *) mycalloc (10, sizeof (hc_thread_t)); - - hc_thread_create (ni_threads[ni_threads_cnt], thread_monitor, NULL); - - ni_threads_cnt++; + data.shutdown_inner = 0; /** * Outfile remove */ - if (keyspace == 0) + if (keyspace == 0 && benchmark == 0 && stdout_flag == 0) { + hc_thread_create (inner_threads[inner_threads_cnt], thread_monitor, NULL); + + inner_threads_cnt++; + if (outfile_check_timer != 0) { if (data.outfile_check_directory != NULL) { if ((hash_mode != 5200) && - !((hash_mode >= 6200) && (hash_mode <= 6299)) && + !((hash_mode >= 6200) && (hash_mode <= 6299)) && + !((hash_mode >= 13700) && (hash_mode <= 13799)) && (hash_mode != 9000)) { - hc_thread_create (ni_threads[ni_threads_cnt], thread_outfile_remove, NULL); + hc_thread_create (inner_threads[inner_threads_cnt], thread_outfile_remove, NULL); - ni_threads_cnt++; + inner_threads_cnt++; } else { @@ -15958,8 +17336,8 @@ int main (int argc, char **argv) { 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); } } @@ -15982,9 +17360,9 @@ int main (int argc, char **argv) for (uint maskpos = rd->maskpos; maskpos < maskcnt; maskpos++) { - if (data.devices_status == STATUS_CRACKED) break; - - data.devices_status = STATUS_INIT; + if (data.devices_status == STATUS_CRACKED) continue; + if (data.devices_status == STATUS_ABORTED) continue; + if (data.devices_status == STATUS_QUIT) continue; if (maskpos > rd->maskpos) { @@ -16223,15 +17601,24 @@ int main (int argc, char **argv) } } - for (uint dictpos = rd->dictpos; dictpos < dictcnt; ) + for (uint dictpos = rd->dictpos; dictpos < dictcnt; dictpos++) { + if (data.devices_status == STATUS_CRACKED) continue; + if (data.devices_status == STATUS_ABORTED) continue; + if (data.devices_status == STATUS_QUIT) continue; + + rd->dictpos = dictpos; + char *subid = logfile_generate_subid (); data.subid = subid; logfile_sub_msg ("START"); - data.devices_status = STATUS_INIT; + if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT)) + { + data.devices_status = STATUS_INIT; + } memset (data.words_progress_done, 0, data.salts_cnt * sizeof (u64)); memset (data.words_progress_rejected, 0, data.salts_cnt * sizeof (u64)); @@ -16256,6 +17643,8 @@ int main (int argc, char **argv) data.ms_paused = 0; + data.kernel_power_final = 0; + data.words_cur = rd->words_cur; for (uint device_id = 0; device_id < data.devices_cnt; device_id++) @@ -16273,8 +17662,6 @@ int main (int argc, char **argv) memset (device_param->exec_ms, 0, EXEC_CACHE * sizeof (double)); - device_param->kernel_power = device_param->kernel_power_user; - device_param->outerloop_pos = 0; device_param->outerloop_left = 0; device_param->innerloop_pos = 0; @@ -16290,8 +17677,6 @@ int main (int argc, char **argv) device_param->words_done = 0; } - data.kernel_power_div = 0; - // figure out some workload if (attack_mode == ATTACK_MODE_STRAIGHT) @@ -16333,10 +17718,7 @@ int main (int argc, char **argv) if (data.words_cnt == 0) { - if (data.devices_status == STATUS_CRACKED) break; - if (data.devices_status == STATUS_ABORTED) break; - - dictpos++; + logfile_sub_msg ("STOP"); continue; } @@ -16383,10 +17765,7 @@ int main (int argc, char **argv) if (data.words_cnt == 0) { - if (data.devices_status == STATUS_CRACKED) break; - if (data.devices_status == STATUS_ABORTED) break; - - dictpos++; + logfile_sub_msg ("STOP"); continue; } @@ -16426,10 +17805,7 @@ int main (int argc, char **argv) if (data.words_cnt == 0) { - if (data.devices_status == STATUS_CRACKED) break; - if (data.devices_status == STATUS_ABORTED) break; - - dictpos++; + logfile_sub_msg ("STOP"); continue; } @@ -16483,20 +17859,16 @@ int main (int argc, char **argv) { 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 - dictpos++; - - rd->dictpos = dictpos; - logfile_sub_msg ("STOP"); continue; @@ -16703,7 +18075,7 @@ int main (int argc, char **argv) if (data.words_cur > data.words_base) { - log_error ("ERROR: restore value greater keyspace"); + log_error ("ERROR: Restore value greater keyspace"); return (-1); } @@ -16733,26 +18105,6 @@ int main (int argc, char **argv) } } - /* - * Inform user about possible slow speeds - */ - - if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK)) - { - if (data.words_base < kernel_power_all) - { - if (quiet == 0) - { - log_info ("ATTENTION!"); - log_info (" The wordlist or mask you are using is too small."); - log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s)."); - log_info (" The cracking speed will drop."); - log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed"); - log_info (""); - } - } - } - /* * Update loopback file */ @@ -16788,7 +18140,73 @@ int main (int argc, char **argv) } } - data.devices_status = STATUS_RUNNING; + /** + * create autotune threads + */ + + hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t)); + + if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT)) + { + data.devices_status = STATUS_AUTOTUNE; + } + + for (uint device_id = 0; device_id < data.devices_cnt; device_id++) + { + hc_device_param_t *device_param = &devices_param[device_id]; + + hc_thread_create (c_threads[device_id], thread_autotune, device_param); + } + + hc_thread_wait (data.devices_cnt, c_threads); + + /* + * Inform user about possible slow speeds + */ + + uint hardware_power_all = 0; + + uint kernel_power_all = 0; + + for (uint device_id = 0; device_id < data.devices_cnt; device_id++) + { + hc_device_param_t *device_param = &devices_param[device_id]; + + hardware_power_all += device_param->hardware_power; + + kernel_power_all += device_param->kernel_power; + } + + data.hardware_power_all = hardware_power_all; // hardware_power_all is the same as kernel_power_all but without the influence of kernel_accel on the devices + + data.kernel_power_all = kernel_power_all; + + if ((wordlist_mode == WL_MODE_FILE) || (wordlist_mode == WL_MODE_MASK)) + { + if (data.words_base < kernel_power_all) + { + if (quiet == 0) + { + clear_prompt (); + + log_info ("ATTENTION!"); + log_info (" The wordlist or mask you are using is too small."); + log_info (" Therefore, hashcat is unable to utilize the full parallelization power of your device(s)."); + log_info (" The cracking speed will drop."); + log_info (" Workaround: https://hashcat.net/wiki/doku.php?id=frequently_asked_questions#how_to_create_more_work_for_full_speed"); + log_info (""); + } + } + } + + /** + * create cracker threads + */ + + if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT)) + { + data.devices_status = STATUS_RUNNING; + } if (initial_restore_done == 0) { @@ -16819,12 +18237,6 @@ int main (int argc, char **argv) data.runtime_start = runtime_start; - /** - * create cracker threads - */ - - hc_thread_t *c_threads = (hc_thread_t *) mycalloc (data.devices_cnt, sizeof (hc_thread_t)); - for (uint device_id = 0; device_id < data.devices_cnt; device_id++) { hc_device_param_t *device_param = &devices_param[device_id]; @@ -16839,27 +18251,18 @@ int main (int argc, char **argv) } } - // wait for crack threads to exit - hc_thread_wait (data.devices_cnt, c_threads); local_free (c_threads); - data.restore = 0; - - // finalize task + if ((data.devices_status != STATUS_BYPASS) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT)) + { + data.devices_status = STATUS_EXHAUSTED; + } logfile_sub_var_uint ("status-after-work", data.devices_status); - if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint (); - - if (data.devices_status == STATUS_CRACKED) break; - if (data.devices_status == STATUS_ABORTED) break; - - if (data.devices_status == STATUS_BYPASS) - { - data.devices_status = STATUS_RUNNING; - } + data.restore = 0; if (induction_dictionaries_cnt) { @@ -16875,47 +18278,34 @@ int main (int argc, char **argv) induction_dictionaries_cnt = count_dictionaries (induction_dictionaries); } - if (benchmark == 0) + if (benchmark == 1) { - if (((dictpos + 1) < dictcnt) || ((maskpos + 1) < maskcnt) || induction_dictionaries_cnt) - { - if (quiet == 0) clear_prompt (); - - if (quiet == 0) log_info (""); + status_benchmark (); - if (status == 1) - { - status_display (); - } - else - { - if (quiet == 0) status_display (); - } - - if (quiet == 0) log_info (""); + if (machine_readable == 0) + { + log_info (""); } } - - if (attack_mode == ATTACK_MODE_BF) - { - dictpos++; - - rd->dictpos = dictpos; - } else { - if (induction_dictionaries_cnt) + if (quiet == 0) { - qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime); - } - else - { - dictpos++; + clear_prompt (); + + log_info (""); - rd->dictpos = dictpos; + if (stdout_flag == 0) status_display (); + + log_info (""); } } + if (induction_dictionaries_cnt) + { + qsort (induction_dictionaries, induction_dictionaries_cnt, sizeof (char *), sort_by_mtime); + } + time_t runtime_stop; time (&runtime_stop); @@ -16928,22 +18318,37 @@ int main (int argc, char **argv) logfile_sub_msg ("STOP"); global_free (subid); - } - if (data.devices_status == STATUS_STOP_AT_CHECKPOINT) check_checkpoint (); + // from this point we handle bypass as running + + if (data.devices_status == STATUS_BYPASS) + { + data.devices_status = STATUS_RUNNING; + } + + // and overwrite benchmark aborts as well + + if (data.benchmark == 1) + { + if (data.devices_status == STATUS_ABORTED) + { + data.devices_status = STATUS_RUNNING; + } + } + + // finalize task + + if (data.devices_status == STATUS_CRACKED) break; + if (data.devices_status == STATUS_ABORTED) break; + if (data.devices_status == STATUS_QUIT) break; + } if (data.devices_status == STATUS_CRACKED) break; if (data.devices_status == STATUS_ABORTED) break; if (data.devices_status == STATUS_QUIT) break; - - if (data.devices_status == STATUS_BYPASS) - { - data.devices_status = STATUS_RUNNING; - } } // problems could occur if already at startup everything was cracked (because of .pot file reading etc), we must set some variables here to avoid NULL pointers - if (attack_mode == ATTACK_MODE_STRAIGHT) { if (data.wordlist_mode == WL_MODE_FILE) @@ -16982,11 +18387,6 @@ int main (int argc, char **argv) } } - if ((data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT)) - { - data.devices_status = STATUS_EXHAUSTED; - } - // if cracked / aborted remove last induction dictionary for (int file_pos = 0; file_pos < induction_dictionaries_cnt; file_pos++) @@ -16999,22 +18399,17 @@ int main (int argc, char **argv) } } - // wait for non-interactive threads + // wait for inner threads - for (uint thread_idx = 0; thread_idx < ni_threads_cnt; thread_idx++) - { - hc_thread_wait (1, &ni_threads[thread_idx]); - } - - local_free (ni_threads); - - // wait for interactive threads + data.shutdown_inner = 1; - if ((data.wordlist_mode == WL_MODE_FILE) || (data.wordlist_mode == WL_MODE_MASK)) + for (uint thread_idx = 0; thread_idx < inner_threads_cnt; thread_idx++) { - hc_thread_wait (1, &i_thread); + hc_thread_wait (1, &inner_threads[thread_idx]); } + local_free (inner_threads); + // we dont need restore file anymore if (data.restore_disable == 0) { @@ -17040,51 +18435,17 @@ int main (int argc, char **argv) * Clean up */ - if (benchmark == 1) - { - status_benchmark (); - - if (status_automat == 0) - { - log_info (""); - } - } - else - { - if (quiet == 0) clear_prompt (); - - if (quiet == 0) log_info (""); - - if (status == 1) - { - status_display (); - } - else - { - if (quiet == 0) status_display (); - } - - if (quiet == 0) log_info (""); - } - for (uint device_id = 0; device_id < data.devices_cnt; device_id++) { hc_device_param_t *device_param = &data.devices_param[device_id]; if (device_param->skipped) continue; - local_free (device_param->result); - local_free (device_param->combs_buf); - local_free (device_param->hooks_buf); - local_free (device_param->device_name); - local_free (device_param->device_name_chksum); - local_free (device_param->device_version); - local_free (device_param->driver_version); if (device_param->pws_buf) myfree (device_param->pws_buf); @@ -17112,7 +18473,10 @@ int main (int argc, char **argv) if (device_param->d_tmps) hc_clReleaseMemObject (data.ocl, device_param->d_tmps); if (device_param->d_hooks) hc_clReleaseMemObject (data.ocl, device_param->d_hooks); if (device_param->d_result) hc_clReleaseMemObject (data.ocl, device_param->d_result); - if (device_param->d_scryptV_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV_buf); + if (device_param->d_scryptV0_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV0_buf); + if (device_param->d_scryptV1_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV1_buf); + if (device_param->d_scryptV2_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV2_buf); + if (device_param->d_scryptV3_buf) hc_clReleaseMemObject (data.ocl, device_param->d_scryptV3_buf); if (device_param->d_root_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_root_css_buf); if (device_param->d_markov_css_buf) hc_clReleaseMemObject (data.ocl, device_param->d_markov_css_buf); if (device_param->d_tm_c) hc_clReleaseMemObject (data.ocl, device_param->d_tm_c); @@ -17127,6 +18491,7 @@ int main (int argc, char **argv) if (device_param->kernel_mp_r) hc_clReleaseKernel (data.ocl, device_param->kernel_mp_r); if (device_param->kernel_tm) hc_clReleaseKernel (data.ocl, device_param->kernel_tm); if (device_param->kernel_amp) hc_clReleaseKernel (data.ocl, device_param->kernel_amp); + if (device_param->kernel_memset) hc_clReleaseKernel (data.ocl, device_param->kernel_memset); if (device_param->program) hc_clReleaseProgram (data.ocl, device_param->program); if (device_param->program_mp) hc_clReleaseProgram (data.ocl, device_param->program_mp); @@ -17141,8 +18506,7 @@ int main (int argc, char **argv) #ifdef HAVE_HWMON if (gpu_temp_disable == 0) { - #ifdef HAVE_ADL - if (gpu_temp_retain != 0) // VENDOR_ID_AMD is implied here + if (gpu_temp_retain != 0) { hc_thread_mutex_lock (mux_adl); @@ -17152,27 +18516,36 @@ int main (int argc, char **argv) if (device_param->skipped) continue; - if (data.hm_device[device_id].fan_supported == 1) + if (data.hm_device[device_id].fan_set_supported == 1) { - int fanspeed = temp_retain_fanspeed_value[device_id]; + int rc = -1; - if (fanspeed == -1) continue; + if (device_param->device_vendor_id == VENDOR_ID_AMD) + { + rc = hm_set_fanspeed_with_device_id_adl (device_id, 100, 0); + } + else if (device_param->device_vendor_id == VENDOR_ID_NV) + { + #ifdef LINUX + rc = set_fan_control (data.hm_xnvctrl, data.hm_device[device_id].xnvctrl, NV_CTRL_GPU_COOLER_MANUAL_CONTROL_FALSE); + #endif - int rc = hm_set_fanspeed_with_device_id_amd (device_id, fanspeed); + #ifdef WIN + rc = hm_set_fanspeed_with_device_id_nvapi (device_id, 100, 0); + #endif + } - if (rc == -1) log_info ("WARNING: Failed to restore default fan speed for gpu number: %i:", device_id); + if (rc == -1) log_info ("WARNING: Failed to restore default fan speed and policy for device #%", device_id + 1); } } hc_thread_mutex_unlock (mux_adl); } - #endif // HAVE_ADL } - #ifdef HAVE_ADL // reset power tuning - if (powertune_enable == 1) // VENDOR_ID_AMD is implied here + if (powertune_enable == 1) { hc_thread_mutex_lock (mux_adl); @@ -17182,89 +18555,106 @@ int main (int argc, char **argv) if (device_param->skipped) continue; - if (data.hm_device[device_id].od_version == 6) + if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_AMD) { - // check powertune capabilities first, if not available then skip device - - int powertune_supported = 0; - - if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_amd, data.hm_device[device_id].adapter_index.amd, &powertune_supported)) != ADL_OK) + if (data.hm_device[device_id].od_version == 6) { - log_error ("ERROR: Failed to get ADL PowerControl Capabilities"); - - return (-1); - } + // check powertune capabilities first, if not available then skip device - if (powertune_supported != 0) - { - // powercontrol settings + int powertune_supported = 0; - if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, od_power_control_status[device_id])) != ADL_OK) + if ((hm_ADL_Overdrive6_PowerControl_Caps (data.hm_adl, data.hm_device[device_id].adl, &powertune_supported)) != ADL_OK) { - log_info ("ERROR: Failed to restore the ADL PowerControl values"); + log_error ("ERROR: Failed to get ADL PowerControl Capabilities"); return (-1); } - // clocks + if (powertune_supported != 0) + { + // powercontrol settings + + if ((hm_ADL_Overdrive_PowerControl_Set (data.hm_adl, data.hm_device[device_id].adl, od_power_control_status[device_id])) != ADL_OK) + { + log_info ("ERROR: Failed to restore the ADL PowerControl values"); + + return (-1); + } - ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel)); + // clocks - performance_state->iNumberOfPerformanceLevels = 2; + ADLOD6StateInfo *performance_state = (ADLOD6StateInfo*) mycalloc (1, sizeof (ADLOD6StateInfo) + sizeof (ADLOD6PerformanceLevel)); - performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock; - performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock; - performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock; - performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock; + performance_state->iNumberOfPerformanceLevels = 2; - if ((hm_ADL_Overdrive_State_Set (data.hm_amd, data.hm_device[device_id].adapter_index.amd, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK) - { - log_info ("ERROR: Failed to restore ADL performance state"); + performance_state->aLevels[0].iEngineClock = od_clock_mem_status[device_id].state.aLevels[0].iEngineClock; + performance_state->aLevels[1].iEngineClock = od_clock_mem_status[device_id].state.aLevels[1].iEngineClock; + performance_state->aLevels[0].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[0].iMemoryClock; + performance_state->aLevels[1].iMemoryClock = od_clock_mem_status[device_id].state.aLevels[1].iMemoryClock; - return (-1); + if ((hm_ADL_Overdrive_State_Set (data.hm_adl, data.hm_device[device_id].adl, ADL_OD6_SETSTATE_PERFORMANCE, performance_state)) != ADL_OK) + { + log_info ("ERROR: Failed to restore ADL performance state"); + + return (-1); + } + + local_free (performance_state); } + } + } + + if (data.devices_param[device_id].device_vendor_id == VENDOR_ID_NV) + { + unsigned int limit = nvml_power_limit[device_id]; - local_free (performance_state); + if (limit > 0) + { + hm_NVML_nvmlDeviceSetPowerManagementLimit (data.hm_nvml, 0, data.hm_device[device_id].nvml, limit); } } } hc_thread_mutex_unlock (mux_adl); } - #endif // HAVE_ADL if (gpu_temp_disable == 0) { - #if defined(HAVE_NVML) || defined(HAVE_NVAPI) - if (data.hm_nv) + if (data.hm_nvml) { - #if defined(LINUX) && defined(HAVE_NVML) + hm_NVML_nvmlShutdown (data.hm_nvml); + + nvml_close (data.hm_nvml); - hm_NVML_nvmlShutdown (data.hm_nv); + data.hm_nvml = NULL; + } - nvml_close (data.hm_nv); + if (data.hm_nvapi) + { + hm_NvAPI_Unload (data.hm_nvapi); - #elif defined(WIN) && (HAVE_NVAPI) + nvapi_close (data.hm_nvapi); - hm_NvAPI_Unload (data.hm_nv); + data.hm_nvapi = NULL; + } - nvapi_close (data.hm_nv); + if (data.hm_xnvctrl) + { + hm_XNVCTRL_XCloseDisplay (data.hm_xnvctrl); - #endif + xnvctrl_close (data.hm_xnvctrl); - data.hm_nv = NULL; + data.hm_xnvctrl = NULL; } - #endif - #ifdef HAVE_ADL - if (data.hm_amd) + if (data.hm_adl) { - hm_ADL_Main_Control_Destroy (data.hm_amd); + hm_ADL_Main_Control_Destroy (data.hm_adl); - adl_close (data.hm_amd); - data.hm_amd = NULL; + adl_close (data.hm_adl); + + data.hm_adl = NULL; } - #endif } #endif // HAVE_HWMON @@ -17306,11 +18696,9 @@ int main (int argc, char **argv) local_free (bitmap_s2_d); #ifdef HAVE_HWMON - local_free (temp_retain_fanspeed_value); - #ifdef HAVE_ADL local_free (od_clock_mem_status); local_free (od_power_control_status); - #endif // ADL + local_free (nvml_power_limit); #endif global_free (devices_param); @@ -17338,6 +18726,17 @@ int main (int argc, char **argv) if (data.devices_status == STATUS_QUIT) break; } + // wait for outer threads + + data.shutdown_outer = 1; + + for (uint thread_idx = 0; thread_idx < outer_threads_cnt; thread_idx++) + { + hc_thread_wait (1, &outer_threads[thread_idx]); + } + + local_free (outer_threads); + // destroy others mutex hc_thread_mutex_delete (mux_dispatcher);