mirror of https://github.com/hashcat/hashcat.git
Added tunings/ folder in order to replace hashcat.hctune. Configuration files with *.hctune suffix are automatically load on startup
jsteube
2 years ago
parent
7668ec5865
commit
c8350eb555
@ -0,0 +1,22 @@
|
||||
#Device Attack Hash Vector Kernel Kernel
|
||||
#Name Mode Type Width Accel Loops
|
||||
|
||||
##
|
||||
## The following cards were manually tuned, as example
|
||||
##
|
||||
|
||||
GeForce_GTX_TITAN 3 0 4 A A
|
||||
GeForce_GTX_TITAN 3 11 4 A A
|
||||
GeForce_GTX_TITAN 3 12 4 A A
|
||||
GeForce_GTX_TITAN 3 21 1 A A
|
||||
GeForce_GTX_TITAN 3 22 1 A A
|
||||
GeForce_GTX_TITAN 3 23 1 A A
|
||||
GeForce_GTX_TITAN 3 30 4 A A
|
||||
GeForce_GTX_TITAN 3 200 2 A A
|
||||
GeForce_GTX_TITAN 3 900 4 A A
|
||||
GeForce_GTX_TITAN 3 1000 4 A A
|
||||
GeForce_GTX_TITAN 3 1100 4 A A
|
||||
GeForce_GTX_TITAN 3 2400 4 A A
|
||||
GeForce_GTX_TITAN 3 2410 2 A A
|
||||
GeForce_GTX_TITAN 3 5500 1 A A
|
||||
GeForce_GTX_TITAN 3 9900 2 A A
|
||||
@ -0,0 +1,36 @@
|
||||
#
|
||||
# Find the right -n value for your GPU:
|
||||
# =====================================
|
||||
#
|
||||
# 1. For example, to find the value for 8900, first create a valid hash for 8900 as follows:
|
||||
#
|
||||
# $ ./hashcat --example-hashes -m 8900 | grep Example.Hash | grep -v Format | cut -b 25- > tmp.hash.8900
|
||||
#
|
||||
# 2. Now let it iterate through all -n values to a certain point. In this case, I'm using 200, but in general it's a value that is at least twice that of the multiprocessor. If you don't mind you can just leave it as it is, it just runs a little longer.
|
||||
#
|
||||
# $ export i=1; while [ $i -ne 201 ]; do echo $i; ./hashcat --quiet tmp.hash.8900 --keep-guessing --self-test-disable --markov-disable --restore-disable --outfile-autohex-disable --wordlist-autohex-disable --potfile-disable --logfile-disable --hwmon-disable --status --status-timer 1 --runtime 28 --machine-readable --optimized-kernel-enable --workload-profile 3 --hash-type 8900 --attack-mode 3 ?b?b?b?b?b?b?b --backend-devices 1 --force -n $i; i=$(($i+1)); done | tee x
|
||||
#
|
||||
# 3. Determine the highest measured H/s speed. But don't just use the highest value. Instead, use the number that seems most stable, usually at the beginning.
|
||||
#
|
||||
# $ grep "$(printf 'STATUS\t3')" x | cut -f4 -d$'\t' | sort -n | tail
|
||||
#
|
||||
# 4. To match the speed you have chosen to the correct value in the 'x' file, simply search for it in it. Then go up a little on the block where you found him. The value -n is the single value that begins before the block start. If you have multiple blocks at the same speed, choose the lowest value for -n
|
||||
|
||||
#Device Attack Hash Vector Kernel Kernel
|
||||
#Name Mode Type Width Accel Loops
|
||||
|
||||
DEVICE_TYPE_CPU * 8900 1 N A
|
||||
DEVICE_TYPE_GPU * 8900 1 N A
|
||||
|
||||
GeForce_GTX_980 * 8900 1 29 A
|
||||
GeForce_GTX_1080 * 8900 1 15 A
|
||||
GeForce_RTX_2080_Ti * 8900 1 68 A
|
||||
GeForce_RTX_3060_Ti * 8900 1 51 A
|
||||
GeForce_RTX_3070 * 8900 1 46 A
|
||||
GeForce_RTX_3090 * 8900 1 82 A
|
||||
GeForce_RTX_3090_Ti * 8900 1 84 A
|
||||
NVS_510 * 8900 1 12 A
|
||||
ALIAS_AMD_RX480 * 8900 1 15 A
|
||||
ALIAS_AMD_Vega64 * 8900 1 30 A
|
||||
ALIAS_AMD_MI100 * 8900 1 79 A
|
||||
ALIAS_AMD_RX6900XT * 8900 1 123 A
|
||||
@ -0,0 +1,34 @@
|
||||
#
|
||||
# Find the right -n value for your GPU:
|
||||
# =====================================
|
||||
#
|
||||
# 1. For example, to find the value for 9300, first create a valid hash for 9300 as follows:
|
||||
#
|
||||
# $ ./hashcat --example-hashes -m 9300 | grep Example.Hash | grep -v Format | cut -b 25- > tmp.hash.9300
|
||||
#
|
||||
# 2. Now let it iterate through all -n values to a certain point. In this case, I'm using 1032, but in general it's a value that is at least twice that of the multiprocessor. If you don't mind you can just leave it as it is, it just runs a little longer.
|
||||
#
|
||||
# $ export i=8; while [ $i -ne 1032 ]; do echo $i; ./hashcat --quiet tmp.hash.9300 --keep-guessing --self-test-disable --markov-disable --restore-disable --outfile-autohex-disable --wordlist-autohex-disable --potfile-disable --logfile-disable --hwmon-disable --status --status-timer 1 --runtime 28 --machine-readable --optimized-kernel-enable --workload-profile 3 --hash-type 9300 --attack-mode 3 ?b?b?b?b?b?b?b --backend-devices 1 --force -n $i; i=$(($i+8)); done | tee x
|
||||
#
|
||||
# 3. Determine the highest measured H/s speed. But don't just use the highest value. Instead, use the number that seems most stable, usually at the beginning.
|
||||
#
|
||||
# $ grep "$(printf 'STATUS\t3')" x | cut -f4 -d$'\t' | sort -n | tail
|
||||
#
|
||||
# 4. To match the speed you have chosen to the correct value in the 'x' file, simply search for it in it. Then go up a little on the block where you found him. The value -n is the single value that begins before the block start. If you have multiple blocks at the same speed, choose the lowest value for -n
|
||||
|
||||
#Device Attack Hash Vector Kernel Kernel
|
||||
#Name Mode Type Width Accel Loops
|
||||
|
||||
DEVICE_TYPE_CPU * 9300 1 N A
|
||||
DEVICE_TYPE_GPU * 9300 1 N A
|
||||
|
||||
GeForce_GTX_980 * 9300 1 128 A
|
||||
GeForce_GTX_1080 * 9300 1 256 A
|
||||
GeForce_RTX_2080_Ti * 9300 1 528 A
|
||||
GeForce_RTX_3060_Ti * 9300 1 256 A
|
||||
GeForce_RTX_3070 * 9300 1 368 A
|
||||
GeForce_RTX_3090 * 9300 1 984 A
|
||||
ALIAS_AMD_RX480 * 9300 1 232 A
|
||||
ALIAS_AMD_Vega64 * 9300 1 440 A
|
||||
ALIAS_AMD_MI100 * 9300 1 1000 A
|
||||
ALIAS_AMD_RX6900XT * 9300 1 720 A
|
||||
@ -0,0 +1,35 @@
|
||||
#
|
||||
# Find the right -n value for your GPU:
|
||||
# =====================================
|
||||
#
|
||||
# 1. For example, to find the value for 15700, first create a valid hash for 15700 as follows:
|
||||
#
|
||||
# $ ./hashcat --example-hashes -m 15700 | grep Example.Hash | grep -v Format | cut -b 25- > tmp.hash.15700
|
||||
#
|
||||
# 2. Now let it iterate through all -n values to a certain point. In this case, I'm using 200, but in general it's a value that is at least twice that of the multiprocessor. If you don't mind you can just leave it as it is, it just runs a little longer.
|
||||
#
|
||||
# $ export i=1; while [ $i -ne 201 ]; do echo $i; ./hashcat --quiet tmp.hash.15700 --keep-guessing --self-test-disable --markov-disable --restore-disable --outfile-autohex-disable --wordlist-autohex-disable --potfile-disable --logfile-disable --hwmon-disable --status --status-timer 1 --runtime 28 --machine-readable --optimized-kernel-enable --workload-profile 3 --hash-type 15700 --attack-mode 3 ?b?b?b?b?b?b?b --backend-devices 1 --force -n $i; i=$(($i+1)); done | tee x
|
||||
#
|
||||
# 3. Determine the highest measured H/s speed. But don't just use the highest value. Instead, use the number that seems most stable, usually at the beginning.
|
||||
#
|
||||
# $ grep "$(printf 'STATUS\t3')" x | cut -f4 -d$'\t' | sort -n | tail
|
||||
#
|
||||
# 4. To match the speed you have chosen to the correct value in the 'x' file, simply search for it in it. Then go up a little on the block where you found him. The value -n is the single value that begins before the block start. If you have multiple blocks at the same speed, choose the lowest value for -n
|
||||
|
||||
#Device Attack Hash Vector Kernel Kernel
|
||||
#Name Mode Type Width Accel Loops
|
||||
|
||||
DEVICE_TYPE_CPU * 15700 1 N A
|
||||
DEVICE_TYPE_GPU * 15700 1 1 A
|
||||
|
||||
GeForce_GTX_980 * 15700 1 24 A
|
||||
GeForce_GTX_1080 * 15700 1 28 A
|
||||
GeForce_RTX_2080_Ti * 15700 1 68 A
|
||||
GeForce_RTX_3060_Ti * 15700 1 11 A
|
||||
GeForce_RTX_3070 * 15700 1 22 A
|
||||
GeForce_RTX_3090 * 15700 1 82 A
|
||||
GeForce_RTX_3090_Ti * 15700 1 84 A
|
||||
ALIAS_AMD_RX480 * 15700 1 58 A
|
||||
ALIAS_AMD_Vega64 * 15700 1 53 A
|
||||
ALIAS_AMD_MI100 * 15700 1 120 A
|
||||
ALIAS_AMD_RX6900XT * 15700 1 56 A
|
||||
@ -0,0 +1,36 @@
|
||||
#
|
||||
# Find the right -n value for your GPU:
|
||||
# =====================================
|
||||
#
|
||||
# 1. For example, to find the value for 22700, first create a valid hash for 22700 as follows:
|
||||
#
|
||||
# $ ./hashcat --example-hashes -m 22700 | grep Example.Hash | grep -v Format | cut -b 25- > tmp.hash.22700
|
||||
#
|
||||
# 2. Now let it iterate through all -n values to a certain point. In this case, I'm using 200, but in general it's a value that is at least twice that of the multiprocessor. If you don't mind you can just leave it as it is, it just runs a little longer.
|
||||
#
|
||||
# $ export i=1; while [ $i -ne 201 ]; do echo $i; ./hashcat --quiet tmp.hash.22700 --keep-guessing --self-test-disable --markov-disable --restore-disable --outfile-autohex-disable --wordlist-autohex-disable --potfile-disable --logfile-disable --hwmon-disable --status --status-timer 1 --runtime 28 --machine-readable --optimized-kernel-enable --workload-profile 3 --hash-type 22700 --attack-mode 3 ?b?b?b?b?b?b?b --backend-devices 1 --force -n $i; i=$(($i+1)); done | tee x
|
||||
#
|
||||
# 3. Determine the highest measured H/s speed. But don't just use the highest value. Instead, use the number that seems most stable, usually at the beginning.
|
||||
#
|
||||
# $ grep "$(printf 'STATUS\t3')" x | cut -f4 -d$'\t' | sort -n | tail
|
||||
#
|
||||
# 4. To match the speed you have chosen to the correct value in the 'x' file, simply search for it in it. Then go up a little on the block where you found him. The value -n is the single value that begins before the block start. If you have multiple blocks at the same speed, choose the lowest value for -n
|
||||
|
||||
#Device Attack Hash Vector Kernel Kernel
|
||||
#Name Mode Type Width Accel Loops
|
||||
|
||||
DEVICE_TYPE_CPU * 22700 1 N A
|
||||
DEVICE_TYPE_GPU * 22700 1 N A
|
||||
|
||||
GeForce_GTX_980 * 22700 1 29 A
|
||||
GeForce_GTX_1080 * 22700 1 15 A
|
||||
GeForce_RTX_2080_Ti * 22700 1 68 A
|
||||
GeForce_RTX_3060_Ti * 22700 1 51 A
|
||||
GeForce_RTX_3070 * 22700 1 46 A
|
||||
GeForce_RTX_3090 * 22700 1 82 A
|
||||
GeForce_RTX_3090_Ti * 22700 1 84 A
|
||||
NVS_510 * 22700 1 12 A
|
||||
ALIAS_AMD_RX480 * 22700 1 15 A
|
||||
ALIAS_AMD_Vega64 * 22700 1 30 A
|
||||
ALIAS_AMD_MI100 * 22700 1 79 A
|
||||
ALIAS_AMD_RX6900XT * 22700 1 123 A
|
||||
@ -0,0 +1,36 @@
|
||||
#
|
||||
# Find the right -n value for your GPU:
|
||||
# =====================================
|
||||
#
|
||||
# 1. For example, to find the value for 27700, first create a valid hash for 27700 as follows:
|
||||
#
|
||||
# $ ./hashcat --example-hashes -m 27700 | grep Example.Hash | grep -v Format | cut -b 25- > tmp.hash.27700
|
||||
#
|
||||
# 2. Now let it iterate through all -n values to a certain point. In this case, I'm using 200, but in general it's a value that is at least twice that of the multiprocessor. If you don't mind you can just leave it as it is, it just runs a little longer.
|
||||
#
|
||||
# $ export i=1; while [ $i -ne 201 ]; do echo $i; ./hashcat --quiet tmp.hash.27700 --keep-guessing --self-test-disable --markov-disable --restore-disable --outfile-autohex-disable --wordlist-autohex-disable --potfile-disable --logfile-disable --hwmon-disable --status --status-timer 1 --runtime 28 --machine-readable --optimized-kernel-enable --workload-profile 3 --hash-type 27700 --attack-mode 3 ?b?b?b?b?b?b?b --backend-devices 1 --force -n $i; i=$(($i+1)); done | tee x
|
||||
#
|
||||
# 3. Determine the highest measured H/s speed. But don't just use the highest value. Instead, use the number that seems most stable, usually at the beginning.
|
||||
#
|
||||
# $ grep "$(printf 'STATUS\t3')" x | cut -f4 -d$'\t' | sort -n | tail
|
||||
#
|
||||
# 4. To match the speed you have chosen to the correct value in the 'x' file, simply search for it in it. Then go up a little on the block where you found him. The value -n is the single value that begins before the block start. If you have multiple blocks at the same speed, choose the lowest value for -n
|
||||
|
||||
#Device Attack Hash Vector Kernel Kernel
|
||||
#Name Mode Type Width Accel Loops
|
||||
|
||||
DEVICE_TYPE_CPU * 27700 1 N A
|
||||
DEVICE_TYPE_GPU * 27700 1 N A
|
||||
|
||||
GeForce_GTX_980 * 27700 1 29 A
|
||||
GeForce_GTX_1080 * 27700 1 15 A
|
||||
GeForce_RTX_2080_Ti * 27700 1 68 A
|
||||
GeForce_RTX_3060_Ti * 27700 1 51 A
|
||||
GeForce_RTX_3070 * 27700 1 46 A
|
||||
GeForce_RTX_3090 * 27700 1 82 A
|
||||
GeForce_RTX_3090_Ti * 27700 1 84 A
|
||||
NVS_510 * 27700 1 12 A
|
||||
ALIAS_AMD_RX480 * 27700 1 15 A
|
||||
ALIAS_AMD_Vega64 * 27700 1 30 A
|
||||
ALIAS_AMD_MI100 * 27700 1 79 A
|
||||
ALIAS_AMD_RX6900XT * 27700 1 123 A
|
||||
@ -0,0 +1,36 @@
|
||||
#
|
||||
# Find the right -n value for your GPU:
|
||||
# =====================================
|
||||
#
|
||||
# 1. For example, to find the value for 28200, first create a valid hash for 28200 as follows:
|
||||
#
|
||||
# $ ./hashcat --example-hashes -m 28200 | grep Example.Hash | grep -v Format | cut -b 25- > tmp.hash.28200
|
||||
#
|
||||
# 2. Now let it iterate through all -n values to a certain point. In this case, I'm using 200, but in general it's a value that is at least twice that of the multiprocessor. If you don't mind you can just leave it as it is, it just runs a little longer.
|
||||
#
|
||||
# $ export i=1; while [ $i -ne 201 ]; do echo $i; ./hashcat --quiet tmp.hash.28200 --keep-guessing --self-test-disable --markov-disable --restore-disable --outfile-autohex-disable --wordlist-autohex-disable --potfile-disable --logfile-disable --hwmon-disable --status --status-timer 1 --runtime 28 --machine-readable --optimized-kernel-enable --workload-profile 3 --hash-type 28200 --attack-mode 3 ?b?b?b?b?b?b?b --backend-devices 1 --force -n $i; i=$(($i+1)); done | tee x
|
||||
#
|
||||
# 3. Determine the highest measured H/s speed. But don't just use the highest value. Instead, use the number that seems most stable, usually at the beginning.
|
||||
#
|
||||
# $ grep "$(printf 'STATUS\t3')" x | cut -f4 -d$'\t' | sort -n | tail
|
||||
#
|
||||
# 4. To match the speed you have chosen to the correct value in the 'x' file, simply search for it in it. Then go up a little on the block where you found him. The value -n is the single value that begins before the block start. If you have multiple blocks at the same speed, choose the lowest value for -n
|
||||
|
||||
#Device Attack Hash Vector Kernel Kernel
|
||||
#Name Mode Type Width Accel Loops
|
||||
|
||||
DEVICE_TYPE_CPU * 28200 1 N A
|
||||
DEVICE_TYPE_GPU * 28200 1 N A
|
||||
|
||||
GeForce_GTX_980 * 28200 1 29 A
|
||||
GeForce_GTX_1080 * 28200 1 15 A
|
||||
GeForce_RTX_2080_Ti * 28200 1 68 A
|
||||
GeForce_RTX_3060_Ti * 28200 1 51 A
|
||||
GeForce_RTX_3070 * 28200 1 46 A
|
||||
GeForce_RTX_3090 * 28200 1 82 A
|
||||
GeForce_RTX_3090_Ti * 28200 1 84 A
|
||||
NVS_510 * 28200 1 12 A
|
||||
ALIAS_AMD_RX480 * 28200 1 15 A
|
||||
ALIAS_AMD_Vega64 * 28200 1 30 A
|
||||
ALIAS_AMD_MI100 * 28200 1 79 A
|
||||
ALIAS_AMD_RX6900XT * 28200 1 123 A
|
||||
@ -0,0 +1,89 @@
|
||||
|
||||
#Device Attack Hash Vector Kernel Kernel
|
||||
#Name Mode Type Width Accel Loops
|
||||
|
||||
DEVICE_TYPE_CPU * 6100 1 A A
|
||||
DEVICE_TYPE_CPU * 6231 1 A A
|
||||
DEVICE_TYPE_CPU * 6232 1 A A
|
||||
DEVICE_TYPE_CPU * 6233 1 A A
|
||||
DEVICE_TYPE_CPU * 13731 1 A A
|
||||
DEVICE_TYPE_CPU * 13732 1 A A
|
||||
DEVICE_TYPE_CPU * 13733 1 A A
|
||||
|
||||
#Device Attack Hash Vector Kernel Kernel
|
||||
#Name Mode Type Width Accel Loops
|
||||
|
||||
ALIAS_nv_real_simd 3 0 2 A A
|
||||
ALIAS_nv_real_simd 3 10 2 A A
|
||||
ALIAS_nv_real_simd 3 11 2 A A
|
||||
ALIAS_nv_real_simd 3 12 2 A A
|
||||
ALIAS_nv_real_simd 3 20 2 A A
|
||||
ALIAS_nv_real_simd 3 21 2 A A
|
||||
ALIAS_nv_real_simd 3 22 2 A A
|
||||
ALIAS_nv_real_simd 3 23 2 A A
|
||||
ALIAS_nv_real_simd 3 200 2 A A
|
||||
ALIAS_nv_real_simd 3 400 2 A A
|
||||
ALIAS_nv_real_simd 3 900 4 A A
|
||||
ALIAS_nv_real_simd 3 1000 4 A A
|
||||
ALIAS_nv_real_simd 3 1100 4 A A
|
||||
ALIAS_nv_real_simd 3 2400 2 A A
|
||||
ALIAS_nv_real_simd 3 2410 2 A A
|
||||
ALIAS_nv_real_simd 3 2600 4 A A
|
||||
ALIAS_nv_real_simd 3 2611 4 A A
|
||||
ALIAS_nv_real_simd 3 2612 4 A A
|
||||
ALIAS_nv_real_simd 3 2711 4 A A
|
||||
ALIAS_nv_real_simd 3 2811 4 A A
|
||||
ALIAS_nv_real_simd 3 3711 2 A A
|
||||
ALIAS_nv_real_simd 3 5100 2 A A
|
||||
ALIAS_nv_real_simd 3 5300 2 A A
|
||||
ALIAS_nv_real_simd 3 5500 4 A A
|
||||
ALIAS_nv_real_simd 3 5600 2 A A
|
||||
ALIAS_nv_real_simd 3 8700 4 A A
|
||||
ALIAS_nv_real_simd 3 9900 2 A A
|
||||
ALIAS_nv_real_simd 3 11000 4 A A
|
||||
ALIAS_nv_real_simd 3 11100 2 A A
|
||||
ALIAS_nv_real_simd 3 11900 2 A A
|
||||
ALIAS_nv_real_simd 3 13300 4 A A
|
||||
ALIAS_nv_real_simd 3 18700 8 A A
|
||||
|
||||
ALIAS_nv_sm50_or_higher 3 0 8 A A
|
||||
ALIAS_nv_sm50_or_higher 3 10 8 A A
|
||||
ALIAS_nv_sm50_or_higher 3 11 8 A A
|
||||
ALIAS_nv_sm50_or_higher 3 12 8 A A
|
||||
ALIAS_nv_sm50_or_higher 3 20 4 A A
|
||||
ALIAS_nv_sm50_or_higher 3 21 4 A A
|
||||
ALIAS_nv_sm50_or_higher 3 22 4 A A
|
||||
ALIAS_nv_sm50_or_higher 3 23 4 A A
|
||||
ALIAS_nv_sm50_or_higher 3 30 4 A A
|
||||
ALIAS_nv_sm50_or_higher 3 40 4 A A
|
||||
ALIAS_nv_sm50_or_higher 3 200 8 A A
|
||||
ALIAS_nv_sm50_or_higher 3 900 8 A A
|
||||
ALIAS_nv_sm50_or_higher 3 1000 8 A A
|
||||
ALIAS_nv_sm50_or_higher 3 1100 4 A A
|
||||
ALIAS_nv_sm50_or_higher 3 2400 8 A A
|
||||
ALIAS_nv_sm50_or_higher 3 2410 4 A A
|
||||
ALIAS_nv_sm50_or_higher 3 3800 4 A A
|
||||
ALIAS_nv_sm50_or_higher 3 4800 8 A A
|
||||
ALIAS_nv_sm50_or_higher 3 5500 2 A A
|
||||
ALIAS_nv_sm50_or_higher 3 9900 4 A A
|
||||
ALIAS_nv_sm50_or_higher 3 16400 8 A A
|
||||
ALIAS_nv_sm50_or_higher 3 18700 8 A A
|
||||
|
||||
##
|
||||
## BCRYPT
|
||||
##
|
||||
|
||||
DEVICE_TYPE_CPU * 3200 1 N A
|
||||
DEVICE_TYPE_CPU * 25600 1 N A
|
||||
DEVICE_TYPE_CPU * 25800 1 N A
|
||||
|
||||
##
|
||||
## SCRYPT: Tunings for SCRYPT based hash-modes can be found in separate files in the tunings/ folder
|
||||
##
|
||||
|
||||
##
|
||||
## CryptoAPI
|
||||
##
|
||||
|
||||
DEVICE_TYPE_CPU * 14500 1 A A
|
||||
DEVICE_TYPE_GPU * 14500 1 A A
|
||||
@ -0,0 +1,48 @@
|
||||
The files in this folder are used to override autotune settings
|
||||
|
||||
You can override configuration settings for Vector-Width, Kernel-Accel and/or Kernel-Loops values
|
||||
You can filter by Device-Name, Device-Name alias, Attack-Mode and/or Hash-Type
|
||||
|
||||
Each file in this folder with the filename suffix .hctune will be automatically loaded by hashcat on startup with random order
|
||||
|
||||
- A valid line consists of the following fields (in that order):
|
||||
- Device-Name
|
||||
- Attack-Mode
|
||||
- Hash-Type
|
||||
- Vector-Width
|
||||
- Kernel-Accel
|
||||
- Kernel-Loops
|
||||
- The first three columns define the filter, the other three is what is assigned when that filter matches
|
||||
- If no filter matches, autotune is used
|
||||
- Columns are separated with one or many spaces or tabs
|
||||
- A line can not start with a space or a tab
|
||||
- Comment lines are allowed, use a # as first character
|
||||
- Invalid lines are ignored
|
||||
- The Device-Name is the OpenCL Device-Name. It's shown on hashcat startup.
|
||||
- If the device contains spaces, replace all spaces with _ character.
|
||||
- The Device-Name can be assigned an alias. This is useful if many devices share the same chip
|
||||
- If you assign an alias, make sure to not use the devices name directly
|
||||
- There's also a hard-wired Device-Name which matches all device types called:
|
||||
- DEVICE_TYPE_CPU
|
||||
- DEVICE_TYPE_GPU
|
||||
- DEVICE_TYPE_ACCELERATOR
|
||||
- The use of wildcards is allowed, some rules:
|
||||
- Wildcards can only replace an entire Device-Name, not parts just of it. eg: not Geforce_*
|
||||
- The policy is local > global, means the closer you configure something, the more likely it is selected
|
||||
- The policy testing order is from left to right
|
||||
- Attack modes can be:
|
||||
- 0 = Dictionary-Attack
|
||||
- 1 = Combinator-Attack, will also be used for attack-mode 6 and 7 since they share the same kernel
|
||||
- 3 = Mask-Attack
|
||||
- The Kernel-Accel is a multiplier to OpenCL's concept of a workitem, not the workitem count
|
||||
- The Kernel-Loops has a functionality depending on the hash-type:
|
||||
- Slow Hash: Number of iterations calculated per workitem
|
||||
- Fast Hash: Number of mutations calculated per workitem
|
||||
- None of both should be confused with the OpenCL concept of a "thread", this one is maintained automatically
|
||||
- The Vector-Width can have only the values 1, 2, 4, 8 or 'N', where 'N' stands for native, which is an OpenCl-queried data value
|
||||
- The Kernel-Accel is limited to 1024
|
||||
- The Kernel-Loops is limited to 1024
|
||||
- The Kernel-Accel can have 'A', where 'A' stands for autotune
|
||||
- The Kernel-Accel can have 'M', where 'M' stands for maximum possible
|
||||
- The Kernel-Loops can have 'A', where 'A' stands for autotune
|
||||
- The Kernel-Loops can have 'M', where 'M' stands for maximum possible
|
||||
Loading…
Reference in new issue