mirror of
https://github.com/hashcat/hashcat.git
synced 2025-07-19 13:08:19 +00:00
894ded7e14
Improved argument handling Added --backend-devices-keepfree option Supported multiple Attack Type filter (ex: -a 0,3) Supported multiple Device ID filter (ex: -d 1,2) Supported multiple Device-Type ID filter (ex: -D 1,2) Supported multiple verbose levels
1020 lines
38 KiB
Bash
Executable File
1020 lines
38 KiB
Bash
Executable File
#!/usr/bin/env bash
|
|
|
|
##
|
|
## Author......: See docs/credits.txt
|
|
## License.....: MIT
|
|
##
|
|
|
|
VERSION="1.1"
|
|
|
|
function usage()
|
|
{
|
|
echo "> Edge Testing Suite, version ${VERSION}"
|
|
echo ""
|
|
echo "> Usage: $0 [<OPTIONS>]"
|
|
echo ""
|
|
echo "<OPTIONS>:"
|
|
echo ""
|
|
echo "-m / --hash-type <arg> : set Hash Type (default: all)"
|
|
echo " --hash-type-min <arg> : set min hash-type (default: 0)"
|
|
echo " --hash-type-max <arg> : set max hash-type (default: 99999)"
|
|
echo ""
|
|
echo "-a / --attack-type <arg> : set Attack Type or a list of comma-separated Attack Types"
|
|
echo " (default: all. supported: 0 (Straight), 1 (Combination), 3 (Brute-force), 6 (Hybrid Wordlist + Mask), 7 (Hybrid Mask + Wordlist))"
|
|
echo "-K / --kernel-type <arg> : set Kernel Type (default: all. supported: 0 (Pure), 1 (Optimized))"
|
|
echo ""
|
|
echo "-t / --target-type <arg> : set Target Type (default: all. supported: single, multi)"
|
|
echo ""
|
|
echo "-V / --vector-width <arg> : set Vector Width (default: all. supported: 1, 2, 4, 8, 16)"
|
|
echo " --vector-width-min <arg> : set min vector-width (default: 1)"
|
|
echo " --vector-width-max <arg> : set max vector-width (default: 16)"
|
|
echo ""
|
|
echo "-d <arg> : set Device ID or a list of comma-separated Device IDs (default: not set)"
|
|
echo ""
|
|
echo "-D <arg> : set Device-Type ID or a list of comma-separated Device-Type IDs (default: not set)"
|
|
echo ""
|
|
echo "-r <arg> : set max runtime, in seconds, for each kernel execution (default: 270)"
|
|
echo ""
|
|
echo " --metal-compiler-runtime <arg> : set max runtime, in seconds, for each kernel build using Apple Metal (default: 120)"
|
|
echo ""
|
|
echo " --metal-backend : exclude all hash types that do not work with Metal, exclude vector-width > 4, set --metal-compiler-runtime argument"
|
|
echo ""
|
|
echo " --backend-devices-keepfree : Keep specified percentage of device memory free (default: disabled. supported: from 1 to 100)"
|
|
echo ""
|
|
echo "-f / --force : run hashcat using --force"
|
|
echo ""
|
|
echo "-v / --verbose : show debug messages (supported: -v or -vv)"
|
|
echo ""
|
|
echo "-h / --help : show this help, then exit"
|
|
echo ""
|
|
|
|
exit 1
|
|
}
|
|
|
|
function is_in_array()
|
|
{
|
|
for e in "${@:2}"; do
|
|
[ "$e" = "$1" ] && return 0
|
|
done
|
|
|
|
return 1
|
|
}
|
|
|
|
export LC_CTYPE=C
|
|
export LANG=C
|
|
|
|
OUTD="test_edge_$(date +%s)"
|
|
|
|
HASH_TYPE=all
|
|
HASH_TYPE_MIN=0
|
|
HASH_TYPE_MAX=99999
|
|
ATTACK_TYPE=all
|
|
ATTACK_TYPES="0 1 3 6 7"
|
|
KERNEL_TYPE=all
|
|
TARGET_TYPE=all
|
|
VECTOR_WIDTH=all
|
|
VECTOR_WIDTHS="1 2 4 8 16"
|
|
VECTOR_WIDTH_MIN=1
|
|
VECTOR_WIDTH_MAX=16
|
|
DEVICE_TYPE=""
|
|
|
|
FORCE=0
|
|
VERBOSE=0
|
|
RUNTIME_MAX=270 # 4.5 min
|
|
METAL_BACKEND=0
|
|
METAL_COMPILER_RUNTIME=120
|
|
BACKEND_DEVICES_KEEPFREE=0
|
|
|
|
OPTS="--quiet --potfile-disable --hwmon-disable --self-test-disable --machine-readable --logfile-disable"
|
|
|
|
SKIP_HASH_TYPES="2000 2500 2501 16800 16801 99999 32000"
|
|
SKIP_HASH_TYPES_METAL="1800 10700 11700 11750 11760 11800 11850 11860 19200 21600"
|
|
SKIP_METAL_SCRYPT="8900 15700 9300 22700 27700 28200 29800"
|
|
|
|
SKIP_OUT_MATCH_HASH_TYPES="14000 14100 18100 22000"
|
|
SKIP_SAME_SALT_HASH_TYPES="6600 7100 7200 8200 13200 13400 15300 15310 15900 15910 16900 18300 18900 20200 20300 20400 27000 27100 29700 29930 29940"
|
|
#SKIP_SAME_SALT_HASH_TYPES="400 3200 5800 6400 6500 6600 6700 7100 7200 7401 7900 8200 9100 9200 9400 10500 10901 12001 12200 12300 12400 12500 12700 12800 12900 13000 13200 13400 13600 14700 14800 15100 15200 15300 15310 15400 15600 15900 15910 16200 16300 16700 16900 18300 18400 18800 18900 19000 19100 19600 19700 19800 19900 20011 20012 20013 20200 20300 20400 21501 22100 22400 22600 23100 23300 23500 23600 23700 23900 24100 24200 24410 24420 24500 25300 25400 25500 25600 25800 26100 26500 26600 27000 27100 27400 27500 27600 28100 28400 28600 28800 28900 29600 29700 29910 29920 29930 29940 30600 31200 31900"
|
|
|
|
# Parse long options manually
|
|
#while [[ "$1" == --* ]]; do
|
|
while [[ $# -gt 0 ]]; do
|
|
case "$1" in
|
|
--backend-devices-keepfree)
|
|
BACKEND_DEVICES_KEEPFREE=$2
|
|
shift 2
|
|
|
|
# Validate: must be numeric and > 0
|
|
if ! [[ "$BACKEND_DEVICES_KEEPFREE" =~ ^[0-9]+$ ]]; then
|
|
echo "Error: --backend-devices-keepfree must be a positive integer."
|
|
usage
|
|
elif (( BACKEND_DEVICES_KEEPFREE < 1 || BACKEND_DEVICES_KEEPFREE > 100 )); then
|
|
echo "Error: --backend-devices-keepfree must be between 1 and 100."
|
|
usage
|
|
fi
|
|
;;
|
|
--metal-backend)
|
|
METAL_BACKEND=1
|
|
shift
|
|
;;
|
|
--metal-compiler-runtime)
|
|
if [[ "$2" =~ ^-?[0-9]+$ ]]; then
|
|
METAL_COMPILER_RUNTIME=$2
|
|
else
|
|
echo "Error: --metal-compiler-runtime requires a valid argument (integer)"
|
|
usage
|
|
fi
|
|
shift 2
|
|
;;
|
|
--vector-width-min)
|
|
if [[ "$2" =~ ^(1|2|4|8|16)$ ]]; then
|
|
VECTOR_WIDTH_MIN=$2
|
|
else
|
|
echo "Error: --vector-width-min requires a valid argument"
|
|
usage
|
|
fi
|
|
shift 2
|
|
;;
|
|
--vector-width-max)
|
|
if [[ "$2" =~ ^(1|2|4|8|16)$ ]]; then
|
|
VECTOR_WIDTH_MAX=$2
|
|
else
|
|
echo "Error: --vector-width-max requires a valid argument"
|
|
usage
|
|
fi
|
|
shift 2
|
|
;;
|
|
--hash-type-min)
|
|
if [[ "$2" =~ ^[0-9]+$ ]] && (( $2 >= 0 && $2 <= 99999 )); then
|
|
HASH_TYPE_MIN=$2
|
|
else
|
|
echo "Error: --hash-type-min requires a valid argument (integer between 0 and 99999)"
|
|
usage
|
|
fi
|
|
shift 2
|
|
;;
|
|
--hash-type-max)
|
|
if [[ "$2" =~ ^[0-9]+$ ]] && (( $2 >= 0 && $2 <= 99999 )); then
|
|
HASH_TYPE_MAX=$2
|
|
else
|
|
echo "Error: --hash-type-max requires a valid argument (integer between 0 and 99999)"
|
|
usage
|
|
fi
|
|
shift 2
|
|
;;
|
|
--help)
|
|
usage
|
|
;;
|
|
-?*)
|
|
optstring="${1:1}" # strip leading '-'
|
|
# Parse each char in the cluster
|
|
for (( i=0; i<${#optstring}; i++ )); do
|
|
opt="${optstring:i:1}"
|
|
case "$opt" in
|
|
r)
|
|
if [[ "$2" =~ ^-?[0-9]+$ ]]; then
|
|
RUNTIME_MAX="$2"
|
|
else
|
|
echo "Error: -r requires a valid argument (integer)"
|
|
usage
|
|
fi
|
|
;;
|
|
v)
|
|
(( VERBOSE++ ))
|
|
if [ ${VERBOSE} -gt 2 ]; then
|
|
echo "Error: too many -v specified (max: 2)"
|
|
usage
|
|
fi
|
|
;;
|
|
f)
|
|
FORCE=1
|
|
;;
|
|
h)
|
|
usage
|
|
;;
|
|
d)
|
|
if (( i + 1 < ${#optstring} )); then
|
|
optarg="${optstring:$((i+1))}"
|
|
shift_inline=1
|
|
elif [[ -n "$2" && "$2" != -* ]]; then
|
|
optarg="$2"
|
|
shift_inline=0
|
|
else
|
|
echo "Error: -d requires an argument"
|
|
usage
|
|
fi
|
|
|
|
if [[ "$optarg" == -* ]]; then
|
|
echo "Error: -d requires a valid argument, not another option (-$optarg)"
|
|
usage
|
|
fi
|
|
|
|
if [[ ! "$optarg" =~ ^[0-9,]+$ ]]; then
|
|
echo "Error: -d argument must be comma-separated numbers"
|
|
usage
|
|
fi
|
|
|
|
OPTS="${OPTS} -d ${optarg}"
|
|
|
|
[[ "$shift_inline" -eq 0 ]] && shift
|
|
|
|
break
|
|
;;
|
|
D)
|
|
if (( i + 1 < ${#optstring} )); then
|
|
optarg="${optstring:$((i+1))}"
|
|
shift_inline=1
|
|
elif [[ -n "$2" && "$2" != -* ]]; then
|
|
optarg="$2"
|
|
shift_inline=0
|
|
else
|
|
echo "Error: -D requires an argument"
|
|
usage
|
|
fi
|
|
|
|
if [[ "$optarg" == -* ]]; then
|
|
echo "Error: -D requires a valid argument, not another option (-$optarg)"
|
|
usage
|
|
fi
|
|
|
|
if [[ ! "$optarg" =~ ^[0-9,]+$ ]]; then
|
|
echo "Error: -D argument must be comma-separated numbers"
|
|
usage
|
|
fi
|
|
|
|
case "$optarg" in
|
|
1) OPTS="${OPTS} -D 1"; DEVICE_TYPE="Cpu" ;;
|
|
2) OPTS="${OPTS} -D 2"; DEVICE_TYPE="Gpu" ;;
|
|
*) OPTS="${OPTS} -D $optarg"; DEVICE_TYPE="Cpu + Gpu" ;;
|
|
esac
|
|
|
|
[[ "$shift_inline" -eq 0 ]] && shift
|
|
|
|
break
|
|
;;
|
|
V)
|
|
if (( i + 1 < ${#optstring} )); then
|
|
optarg="${optstring:$((i+1))}"
|
|
shift_inline=1
|
|
elif [[ -n "$2" && "$2" != -* ]]; then
|
|
optarg="$2"
|
|
shift_inline=0
|
|
else
|
|
echo "Error: -V requires an argument"
|
|
usage
|
|
fi
|
|
|
|
if [[ "$optarg" == -* ]]; then
|
|
echo "Error: -V requires a valid argument, not another option (-$optarg)"
|
|
usage
|
|
fi
|
|
|
|
if [[ "$optarg" == "all" ]]; then
|
|
:
|
|
elif [[ "$optarg" =~ ^(1|2|4|8|16)$ ]]; then
|
|
VECTOR_WIDTH="$optarg"
|
|
else
|
|
echo "Invalid vector width: $optarg"
|
|
usage
|
|
fi
|
|
|
|
[[ "$shift_inline" -eq 0 ]] && shift
|
|
|
|
break
|
|
;;
|
|
t)
|
|
if (( i + 1 < ${#optstring} )); then
|
|
optarg="${optstring:$((i+1))}"
|
|
shift_inline=1
|
|
elif [[ -n "$2" && "$2" != -* ]]; then
|
|
optarg="$2"
|
|
shift_inline=0
|
|
else
|
|
echo "Error: -t requires an argument"
|
|
usage
|
|
fi
|
|
|
|
if [[ "$optarg" == -* ]]; then
|
|
echo "Error: -t requires a valid argument, not another option (-$optarg)"
|
|
usage
|
|
fi
|
|
|
|
if [[ "$optarg" == "single" ]]; then
|
|
TARGET_TYPE=0
|
|
elif [[ "$optarg" == "multi" ]]; then
|
|
TARGET_TYPE=1
|
|
elif [[ "$optarg" == "all" ]]; then
|
|
:
|
|
else
|
|
echo "Invalid target type: $optarg"
|
|
usage
|
|
fi
|
|
|
|
[[ "$shift_inline" -eq 0 ]] && shift
|
|
|
|
break
|
|
;;
|
|
m)
|
|
if (( i + 1 < ${#optstring} )); then
|
|
optarg="${optstring:$((i+1))}"
|
|
shift_inline=1
|
|
elif [[ -n "$2" && "$2" != -* ]]; then
|
|
optarg="$2"
|
|
shift_inline=0
|
|
else
|
|
echo "Error: -m requires an argument"
|
|
usage
|
|
fi
|
|
|
|
if [[ "$optarg" == -* ]]; then
|
|
echo "Error: -m requires a valid argument, not another option (-$optarg)"
|
|
usage
|
|
fi
|
|
|
|
if [[ "$optarg" == "all" ]]; then
|
|
:
|
|
elif [[ "$optarg" =~ ^[0-9]+$ ]]; then
|
|
HASH_TYPE="$optarg"
|
|
else
|
|
echo "Invalid hash type: $optarg"
|
|
usage
|
|
fi
|
|
|
|
[[ "$shift_inline" -eq 0 ]] && shift
|
|
|
|
break
|
|
;;
|
|
a)
|
|
if (( i + 1 < ${#optstring} )); then
|
|
optarg="${optstring:$((i+1))}"
|
|
shift_inline=1
|
|
elif [[ -n "$2" && "$2" != -* ]]; then
|
|
optarg="$2"
|
|
shift_inline=0
|
|
else
|
|
echo "Error: -a requires an argument"
|
|
usage
|
|
fi
|
|
|
|
if [[ "$optarg" == -* ]]; then
|
|
echo "Error: -a requires a valid argument, not another option (-$optarg)"
|
|
usage
|
|
fi
|
|
|
|
if [[ "$optarg" == "all" ]]; then
|
|
:
|
|
else
|
|
ATTACK_TYPES=""
|
|
|
|
IFS=',' read -ra INPUT_ATTACK_TYPES <<< "$optarg"
|
|
for atk in "${INPUT_ATTACK_TYPES[@]}"; do
|
|
if [[ "$atk" =~ ^(0|1|3|6|7)$ ]]; then
|
|
ATTACK_TYPES+=" $atk"
|
|
else
|
|
echo "Invalid attack type: $atk"
|
|
usage
|
|
fi
|
|
done
|
|
|
|
ATTACK_TYPES="$(echo "$ATTACK_TYPES" | xargs)" # Trim leading/trailing spaces
|
|
fi
|
|
|
|
[[ "$shift_inline" -eq 0 ]] && shift
|
|
|
|
break
|
|
;;
|
|
K)
|
|
if (( i + 1 < ${#optstring} )); then
|
|
optarg="${optstring:$((i+1))}"
|
|
shift_inline=1
|
|
elif [[ -n "$2" && "$2" != -* ]]; then
|
|
optarg="$2"
|
|
shift_inline=0
|
|
else
|
|
echo "Error: -K requires an argument"
|
|
usage
|
|
fi
|
|
|
|
if [[ "$optarg" == -* ]]; then
|
|
echo "Error: -K requires a valid argument, not another option (-$optarg)"
|
|
usage
|
|
fi
|
|
|
|
if [[ "$optarg" == "all" ]]; then
|
|
:
|
|
elif [[ "$optarg" =~ ^(0|1)$ ]]; then
|
|
KERNEL_TYPE="$optarg"
|
|
else
|
|
echo "Invalid kernel type: $optarg"
|
|
usage
|
|
fi
|
|
|
|
[[ "$shift_inline" -eq 0 ]] && shift
|
|
|
|
break
|
|
;;
|
|
*)
|
|
echo "Unknown option: -$opt"
|
|
usage
|
|
;;
|
|
esac
|
|
done
|
|
shift
|
|
;;
|
|
--*)
|
|
echo "Unknown long option: $1"
|
|
usage
|
|
;;
|
|
*)
|
|
echo "empty $1"
|
|
shift
|
|
;;
|
|
esac
|
|
done
|
|
|
|
OPTS="${OPTS} --runtime ${RUNTIME_MAX}"
|
|
|
|
if [[ "$HASH_TYPE" != "all" && ( "$HASH_TYPE_MIN" -ne 0 || "$HASH_TYPE_MAX" -ne 99999 ) ]]; then
|
|
echo "Error: cannot set --hash-type and --hash-type-min/--hash-type-max"
|
|
usage
|
|
fi
|
|
|
|
if [[ "$VECTOR_WIDTH" != "all" && ( "$VECTOR_WIDTH_MIN" -ne 1 || "$VECTOR_WIDTH_MAX" -ne 16 ) ]]; then
|
|
echo "Error: cannot set --vector-width and --vector-width-min/--vector-width-max"
|
|
usage
|
|
fi
|
|
|
|
if [ ${FORCE} -eq 1 ]; then
|
|
OPTS="${OPTS} --force"
|
|
fi
|
|
|
|
if [ $METAL_BACKEND -eq 1 ]; then
|
|
VECTOR_WIDTHS="1 2 4"
|
|
|
|
if [ $VECTOR_WIDTH_MAX -gt 4 ]; then
|
|
VECTOR_WIDTH_MAX=4
|
|
fi
|
|
|
|
if [ $METAL_COMPILER_RUNTIME -ne 120 ]; then
|
|
OPTS="${OPTS} --metal-compiler-runtime ${METAL_COMPILER_RUNTIME}"
|
|
fi
|
|
fi
|
|
|
|
if [ $BACKEND_DEVICES_KEEPFREE -gt 0 ]; then
|
|
OPTS="${OPTS} --backend-devices-keepfree ${BACKEND_DEVICES_KEEPFREE}"
|
|
fi
|
|
|
|
if [ ${VERBOSE} -ge 1 ]; then
|
|
echo "Global hashcat options selected: ${OPTS}"
|
|
fi
|
|
|
|
mkdir -p ${OUTD} &> /dev/null
|
|
|
|
for hash_type in $(ls tools/test_modules/*.pm | cut -d'm' -f3 | cut -d'.' -f1 | awk '{print $1+=0}'); do
|
|
|
|
if [ $HASH_TYPE != "all" ]; then
|
|
if [ $HASH_TYPE -ne $hash_type ]; then continue; fi
|
|
else
|
|
if [ $hash_type -lt ${HASH_TYPE_MIN} ]; then continue; fi
|
|
if [ $hash_type -gt ${HASH_TYPE_MAX} ]; then continue; fi
|
|
fi
|
|
|
|
if is_in_array "${hash_type}" ${SKIP_HASH_TYPES}; then
|
|
echo "[ ${OUTD} ] > Skip processing Hash-Type ${hash_type} (common)" | tee -a ${OUTD}/test_edge.details.log
|
|
continue
|
|
fi
|
|
|
|
if [ $METAL_BACKEND -eq 1 ]; then
|
|
if is_in_array "${hash_type}" ${SKIP_HASH_TYPES_METAL}; then
|
|
echo "[ ${OUTD} ] > Skip processing Hash-Type ${hash_type} (due to metal kernel build failed)" | tee -a ${OUTD}/test_edge.details.log
|
|
continue
|
|
fi
|
|
|
|
if is_in_array "${hash_type}" ${SKIP_METAL_SCRYPT}; then
|
|
echo "[ ${OUTD} ] > Skip processing Hash-Type ${hash_type} (due to metal scrypt is broken)" | tee -a ${OUTD}/test_edge.details.log
|
|
continue
|
|
fi
|
|
fi
|
|
|
|
build_failed_err=0
|
|
test_vectors_err=0
|
|
|
|
for attack_type in ${ATTACK_TYPES}; do
|
|
|
|
if [ $ATTACK_TYPE != "all" ] && [ $ATTACK_TYPE -ne $attack_type ]; then continue; fi
|
|
|
|
kernel_types=$(./hashcat -m ${hash_type} -HH | grep 'Kernel.Type(s' | cut -d: -f2 | xargs | sed -e 's/,//g')
|
|
|
|
for kernel_type in ${kernel_types}; do
|
|
|
|
kernel_type_pad=$(printf "%9s\n" ${kernel_type})
|
|
|
|
CUR_OPTS="${OPTS}"
|
|
|
|
optimized=0
|
|
if [ "${kernel_type}" == "optimized" ]; then
|
|
optimized=1
|
|
CUR_OPTS="${CUR_OPTS} -O"
|
|
fi
|
|
|
|
if [ $KERNEL_TYPE != "all" ] && [ $KERNEL_TYPE -ne $optimized ]; then continue; fi
|
|
|
|
tmp_salt=$(./hashcat -m ${hash_type} -HH | grep Salt\\.Type)
|
|
have_salt=$?
|
|
|
|
if [ $have_salt -eq 0 ]; then
|
|
salt_type=$(echo $tmp_salt | awk '{print $2}')
|
|
|
|
if [ $salt_type == "Virtual" ]; then
|
|
have_salt=1
|
|
fi
|
|
fi
|
|
|
|
slow_hash=0
|
|
tmp_slow_hash=$(./hashcat -m ${hash_type} -HH | grep Slow\\.Hash | awk '{print $2}')
|
|
if [ "${tmp_slow_hash}" == "Yes" ]; then
|
|
slow_hash=1
|
|
fi
|
|
|
|
pt_hex=0
|
|
tmp_pw_type=$(./hashcat -m ${hash_type} -HH | grep Password\\.Type | awk '{print $2}')
|
|
if [ "${tmp_pw_type}" == "HEX" ]; then
|
|
pt_hex=1
|
|
fi
|
|
|
|
echo "[ ${OUTD} ] # Export tests for Hash-Type ${hash_type}, Attack-Type ${attack_type}, Kernel-Type ${kernel_type}" >> ${OUTD}/test_edge.details.log
|
|
|
|
edge_out="${OUTD}/edge_${hash_type}_${kernel_type}_${attack_type}.out"
|
|
|
|
./tools/test.pl edge ${hash_type} ${attack_type} ${optimized} 2>/dev/null > ${edge_out}
|
|
|
|
if [ ${VERBOSE} -ge 2 ]; then
|
|
cat ${edge_out}
|
|
fi
|
|
|
|
if [ $? -eq 0 ]; then
|
|
|
|
check_hash=$(cat ${edge_out} | cut -d, -f8- | head -1)
|
|
if [ ${#check_hash} -eq 2 ] || [ ${#check_hash} -eq 3 ]; then
|
|
echo "[ ${OUTD} ] !> error detected with Hash-Type ${hash_type}: empty test vectors" | tee -a ${OUTD}/test_edge.details.log
|
|
break
|
|
fi
|
|
|
|
for vector_width in ${VECTOR_WIDTHS}; do
|
|
|
|
if [ $VECTOR_WIDTH != "all" ]; then
|
|
if [ $VECTOR_WIDTH -ne $vector_width ]; then continue; fi
|
|
else
|
|
if [ ${vector_width} -lt ${VECTOR_WIDTH_MIN} ]; then continue; fi
|
|
if [ ${vector_width} -gt ${VECTOR_WIDTH_MAX} ]; then continue; fi
|
|
fi
|
|
|
|
CUR_OPTS_V="${CUR_OPTS} --backend-vector-width ${vector_width}"
|
|
|
|
if [ $pt_hex -eq 1 ]; then
|
|
CUR_OPTS_V="${CUR_OPTS_V} --hex-charset"
|
|
fi
|
|
|
|
# single hash
|
|
if [ $TARGET_TYPE == all ] || [ $TARGET_TYPE == 0 ]; then
|
|
|
|
echo "[ ${OUTD} ] # Processing Hash-Type ${hash_type}, Attack-Type ${attack_type}, Kernel-Type ${kernel_type}, Vector-Width ${vector_width}, Target-Type single" | tee -a ${OUTD}/test_edge.details.log
|
|
|
|
cnt=$(wc -l ${edge_out} | awk '{print $1}')
|
|
|
|
for ((i = 1; i <= cnt; i++)); do
|
|
word_compare=None
|
|
word_len=$(cat ${edge_out} | cut -d, -f4 | head -${i} | tail -1)
|
|
salt_len=$(cat ${edge_out} | cut -d, -f5 | head -${i} | tail -1)
|
|
word=$(cat ${edge_out} | cut -d, -f6 | head -${i} | tail -1)
|
|
salt=$(cat ${edge_out} | cut -d, -f7 | head -${i} | tail -1)
|
|
hash=$(cat ${edge_out} | cut -d, -f8- | head -${i} | tail -1)
|
|
|
|
x="echo -n '${word}'"
|
|
|
|
if [ "${hash_type}" == "20510" ]; then
|
|
word_compare="echo -n '${word}'"
|
|
x="echo -n '${word}' | cut -b7-"
|
|
fi
|
|
|
|
if [ ${have_salt} -eq 1 ]; then
|
|
salt_len="None"
|
|
salt=
|
|
else
|
|
z="echo -n '${salt}'"
|
|
salt=$(eval $z)
|
|
fi
|
|
|
|
word=$(eval $x)
|
|
|
|
if [ ${VERBOSE} -ge 1 ]; then
|
|
echo "[ ${OUTD} ] > Hash-Type ${hash_type}, Attack-Type ${attack_type}, Kernel-Type ${kernel_type}, Test ID ${i}, Word len ${word_len}, Salt len ${salt_len}, Word '${word}', Salt '${salt}', Hash ${hash}" | tee -a ${OUTD}/test_edge.details.log
|
|
else
|
|
echo "[ ${OUTD} ] > Hash-Type ${hash_type}, Attack-Type ${attack_type}, Kernel-Type ${kernel_type}, Test ID ${i}, Word len ${word_len}, Salt len ${salt_len}, Word '${word}', Salt '${salt}', Hash ${hash}" >> ${OUTD}/test_edge.details.log
|
|
fi
|
|
|
|
CMD=""
|
|
|
|
if [ "${attack_type}" -eq 0 ]; then
|
|
#echo ${word} > test_${hash_type}_${kernel_type}_${attack_type}_${i}.word
|
|
|
|
CMD="echo ${word} | ./hashcat ${CUR_OPTS_V} -m ${hash_type} ${hash} -a 0"
|
|
elif [ "${attack_type}" -eq 1 ]; then
|
|
word=$(eval $x)
|
|
|
|
if [ "${word_len}" -eq 2 ]; then
|
|
word_1=$(echo $word | cut -c -1)
|
|
word_2=$(echo $word | cut -c 2-)
|
|
elif [ "${word_len}" -gt 2 ]; then
|
|
word_1_cnt=$((word_len/2))
|
|
|
|
word_1=$(echo $word | cut -c -${word_1_cnt})
|
|
|
|
((word_1_cnt++))
|
|
|
|
word_2=$(echo $word | cut -c ${word_1_cnt}-)
|
|
fi
|
|
|
|
echo ${word_1} > ${OUTD}/test_${hash_type}_${kernel_type}_${attack_type}_${i}.1.word
|
|
echo ${word_2} > ${OUTD}/test_${hash_type}_${kernel_type}_${attack_type}_${i}.2.word
|
|
|
|
CMD="./hashcat ${CUR_OPTS_V} -m ${hash_type} ${hash} -a 1 ${OUTD}/test_${hash_type}_${kernel_type}_${attack_type}_${i}.1.word ${OUTD}/test_${hash_type}_${kernel_type}_${attack_type}_${i}.2.word"
|
|
elif [ "${attack_type}" -eq 3 ]; then
|
|
|
|
if [ $pt_hex -eq 1 ]; then
|
|
word_1="${word%??}"
|
|
mask_1="?b"
|
|
else
|
|
if [ "${word_len}" -eq 2 ]; then
|
|
word_1="${word%?}"
|
|
mask_1="?d"
|
|
elif [ "${slow_hash}" -eq 1 ]; then
|
|
word_1="${word%??}"
|
|
mask_1="?d?d"
|
|
else
|
|
word_1="${word%???}"
|
|
mask_1="?d?d?d"
|
|
fi
|
|
fi
|
|
|
|
CMD="./hashcat ${CUR_OPTS_V} -m ${hash_type} ${hash} -a 3 ${word_1}${mask_1}"
|
|
elif [ "${attack_type}" -eq 6 ]; then
|
|
|
|
if [ $pt_hex -eq 1 ]; then
|
|
word_1="${word%??}"
|
|
mask_1="?b"
|
|
else
|
|
if [ "${word_len}" -eq 2 ] || [ "${slow_hash}" -eq 1 ]; then
|
|
word_1="${word%?}"
|
|
mask_1="?d"
|
|
else
|
|
word_1="${word%??}"
|
|
mask_1="?d?d"
|
|
fi
|
|
fi
|
|
|
|
echo -n ${word_1} > ${OUTD}/test_${hash_type}_${kernel_type}_${attack_type}_${i}_1.word
|
|
|
|
CMD="./hashcat ${CUR_OPTS_V} -m ${hash_type} ${hash} -a 6 ${OUTD}/test_${hash_type}_${kernel_type}_${attack_type}_${i}_1.word ${mask_1}"
|
|
elif [ "${attack_type}" -eq 7 ]; then
|
|
|
|
if [ $pt_hex -eq 1 ]; then
|
|
word_1="${word#??}"
|
|
mask_1="?b"
|
|
else
|
|
if [ "${word_len}" -eq 2 ] || [ "${slow_hash}" -eq 1 ]; then
|
|
word_1="${word#?}"
|
|
mask_1="?d"
|
|
else
|
|
word_1="${word#??}"
|
|
mask_1="?d?d"
|
|
fi
|
|
fi
|
|
|
|
echo -n ${word_1} > ${OUTD}/test_${hash_type}_${kernel_type}_${attack_type}_${i}_2.word
|
|
|
|
CMD="./hashcat ${CUR_OPTS_V} -m ${hash_type} ${hash} -a 7 ${mask_1} ${OUTD}/test_${hash_type}_${kernel_type}_${attack_type}_${i}_2.word"
|
|
fi
|
|
|
|
cmd_out="${OUTD}/cmd_${hash_type}_${kernel_type}_${attack_type}_${i}.single.log"
|
|
|
|
eval ${CMD} &> ${cmd_out}
|
|
retVal=$?
|
|
|
|
#echo "RET: $retVal"
|
|
|
|
cat ${cmd_out} >> ${OUTD}/test_edge.details.log
|
|
|
|
if [ "${retVal}" -ne 0 ]; then
|
|
echo "[ ${OUTD} ] !> error ($retVal) detected with CMD: ${CMD}" | tee -a ${OUTD}/test_edge.details.log
|
|
echo "[ ${OUTD} ] !> Hash-Type ${hash_type}, Attack-Type ${attack_type}, Kernel-Type ${kernel_type}, Vector-Width ${vector_width}, Test ID ${i}, Word len ${word_len}, Salt len ${salt_len}, Word '${word}', Hash ${hash}" | tee -a ${OUTD}/test_edge.details.log
|
|
echo '```' | tee -a ${OUTD}/test_edge.details.log
|
|
cat ${cmd_out} | tee -a ${OUTD}/test_edge.details.log
|
|
echo '```' | tee -a ${OUTD}/test_edge.details.log
|
|
|
|
if [ "${retVal}" -eq 250 ]; then
|
|
echo "[ ${OUTD} ] > Skipping current tests due to build error ..." | tee -a ${OUTD}/test_edge.details.log
|
|
break
|
|
fi
|
|
else
|
|
if is_in_array "${hash_type}" ${SKIP_OUT_MATCH_HASH_TYPES}; then
|
|
echo "[ ${OUTD} ] > Skip output check for Hash-Type ${hash_type} (due to collisions)" >> ${OUTD}/test_edge.details.log
|
|
continue
|
|
fi
|
|
|
|
./hashcat -m ${hash_type} -HH | grep 'Keep.Guessing.......: Yes' &> /dev/null
|
|
if [ $? -eq 0 ]; then
|
|
echo "[ ${OUTD} ] > Skip output check for Hash-Type ${hash_type} (due to keep guessing)" >> ${OUTD}/test_edge.details.log
|
|
continue
|
|
fi
|
|
|
|
out=$(grep -v "Unsupported\|STATUS\|^$" ${cmd_out} | sed -e 's/ (user password.*$//g')
|
|
|
|
x="echo -n ${hash}"
|
|
hash=$(eval $x)
|
|
|
|
md5_1=$(echo ${out} | md5sum | cut -d' ' -f1)
|
|
|
|
hc_out="${hash}:${word}"
|
|
|
|
if [ "${word_compare}" != "None" ]; then
|
|
word_tmp=$(eval $word_compare)
|
|
hc_out="${hash}:${word_tmp}"
|
|
fi
|
|
|
|
md5_2=$(echo ${hc_out} | md5sum | cut -d' ' -f1)
|
|
|
|
if [ $md5_1 != $md5_2 ]; then
|
|
echo "[ ${OUTD} ] !> error detected with CMD: ${CMD}" | tee -a ${OUTD}/test_edge.details.log
|
|
echo "[ ${OUTD} ] !> Hash-Type ${hash_type}, Attack-Type ${attack_type}, Kernel-Type ${kernel_type}, Vector-Width ${vector_width}, Test ID ${i}, Word len ${word_len}, Salt len ${salt_len}, Word '${word}', Salt '${salt}', Hash ${hash}" | tee -a ${OUTD}/test_edge.details.log
|
|
echo "[ ${OUTD} ] !> output don't match" | tee -a ${OUTD}/test_edge.details.log
|
|
echo '```' | tee -a ${OUTD}/test_edge.details.log
|
|
echo ${out} | tee -a ${OUTD}/test_edge.details.log
|
|
echo '```' | tee -a ${OUTD}/test_edge.details.log
|
|
echo "! expected output" | tee -a ${OUTD}/test_edge.details.log
|
|
echo '```' | tee -a ${OUTD}/test_edge.details.log
|
|
echo ${hc_out} | tee -a ${OUTD}/test_edge.details.log
|
|
echo '```' | tee -a ${OUTD}/test_edge.details.log
|
|
fi
|
|
fi
|
|
done
|
|
fi
|
|
|
|
# multi hash
|
|
if [ $TARGET_TYPE == all ] || [ $TARGET_TYPE == 1 ]; then
|
|
cnt_max=-1
|
|
tmp_cnt_max=$(./hashcat -m ${hash_type} -HH | grep Hashes\\.Count\\.Max | awk '{print $2}')
|
|
if [[ $tmp_cnt_max =~ ^-?[0-9]+$ ]]; then
|
|
cnt_max=$tmp_cnt_max
|
|
fi
|
|
|
|
if [ $hash_type -eq 20510 ]; then
|
|
cnt_max=1
|
|
fi
|
|
|
|
if [ $cnt_max -eq 1 ]; then
|
|
# cannot exec multi-hash because this hash_type allow max 1 hash at time
|
|
echo "[ ${OUTD} ] > Skipping Hash-Type ${hash_type}, Attack-Type ${attack_type}, Kernel-Type ${kernel_type}, Vector-Width ${vector_width}, Target-Type multi (max 1 hash at time allowed)" | tee -a ${OUTD}/test_edge.details.log
|
|
cnt=0
|
|
continue
|
|
fi
|
|
|
|
# check if hash_type cannot crack multiple hashes with the same salt
|
|
same_salt=1
|
|
|
|
is_in_array "${hash_type}" ${SKIP_SAME_SALT_HASH_TYPES}
|
|
if [ ${?} -eq 1 ]; then
|
|
multi_hashes_same_salt_allowed=$(./hashcat -m ${hash_type} -HH | grep Hashes\\.w/\\.Same\\.Salt | awk '{print $2}')
|
|
if [ "${multi_hashes_same_salt_allowed}" == "Not" ]; then
|
|
same_salt=0
|
|
fi
|
|
fi
|
|
|
|
cnt=$(wc -l ${edge_out} | awk '{print $1}')
|
|
|
|
if [ $cnt -eq 0 ]; then
|
|
echo "[ ${OUTD} ] > Skipping Hash-Type ${hash_type}, Attack-Type ${attack_type}, Kernel-Type ${kernel_type}, Vector-Width ${vector_width}, Target-Type multi (due to no valid test vectors)" | tee -a ${OUTD}/test_edge.details.log
|
|
continue
|
|
fi
|
|
|
|
echo "[ ${OUTD} ] # Processing Hash-Type ${hash_type}, Attack-Type ${attack_type}, Kernel-Type ${kernel_type}, Vector-Width ${vector_width}, Target-Type multi" | tee -a ${OUTD}/test_edge.details.log
|
|
|
|
CMD=""
|
|
SALTS_VAL=""
|
|
|
|
hash_cnt=0
|
|
|
|
hash_in="${OUTD}/edge_${hash_type}_${kernel_type}_${attack_type}_${vector_width}.hashes"
|
|
|
|
for ((i = 1; i <= cnt; i++)); do
|
|
|
|
# limit to cnt_max if is set
|
|
if [ ${cnt_max} -gt 1 ] && [ ${hash_cnt} -gt ${cnt_max} ]; then continue; fi
|
|
|
|
word_compare=None
|
|
word_len=$(cat ${edge_out} | cut -d, -f4 | head -${i} | tail -1)
|
|
salt_len=$(cat ${edge_out} | cut -d, -f5 | head -${i} | tail -1)
|
|
word=$(cat ${edge_out} | cut -d, -f6 | head -${i} | tail -1)
|
|
salt=$(cat ${edge_out} | cut -d, -f7 | head -${i} | tail -1)
|
|
hash=$(cat ${edge_out} | cut -d, -f8- | head -${i} | tail -1)
|
|
|
|
x="echo -n '${word}'"
|
|
y="echo -n ${hash}"
|
|
|
|
if [ "${hash_type}" == "20510" ]; then
|
|
word_compare="echo -n '${word}'"
|
|
x="echo -n '${word}' | cut -b7-"
|
|
fi
|
|
|
|
if [ ${have_salt} -eq 1 ]; then
|
|
salt_len="None"
|
|
salt=
|
|
else
|
|
z="echo -n '${salt}'"
|
|
salt=$(eval $z)
|
|
|
|
# skip hashes with same salt if are not allowed
|
|
if [ ${same_salt} -eq 0 ]; then
|
|
if is_in_array "${salt_len}:${salt}" ${SALTS_VAL}; then
|
|
continue
|
|
fi
|
|
if [ ${#SALTS_VAL} -eq 0 ]; then
|
|
SALTS_VAL="${salt_len}:${salt}"
|
|
else
|
|
SALTS_VAL="${SALTS_VAL} ${salt_len}:${salt}"
|
|
fi
|
|
fi
|
|
fi
|
|
|
|
word=$(eval $x)
|
|
hash=$(eval $y)
|
|
|
|
echo $hash >> ${hash_in}
|
|
|
|
if [ "${word_compare}" != "None" ]; then
|
|
w=$(eval $word_compare)
|
|
echo $w >> ${OUTD}/edge_${hash_type}_${kernel_type}_${attack_type}_${vector_width}.words_compare
|
|
else
|
|
echo ${word} >> ${OUTD}/edge_${hash_type}_${kernel_type}_${attack_type}_${vector_width}.words
|
|
fi
|
|
|
|
if [ "${attack_type}" -eq 0 ]; then
|
|
((hash_cnt++))
|
|
|
|
echo ${word} >> ${OUTD}/edge_${hash_type}_${kernel_type}_${attack_type}.1.words
|
|
|
|
CMD="cat ${OUTD}/edge_${hash_type}_${kernel_type}_${attack_type}.1.words | ./hashcat ${CUR_OPTS_V} -m ${hash_type} ${hash_in} -a 0"
|
|
elif [ "${attack_type}" -eq 1 ]; then
|
|
((hash_cnt++))
|
|
|
|
if [ "${word_len}" -eq 2 ]; then
|
|
word_1=$(echo $word | cut -c -1)
|
|
word_2=$(echo $word | cut -c 2-)
|
|
elif [ "${word_len}" -gt 2 ]; then
|
|
word_1_cnt=$((word_len/2))
|
|
word_1=$(echo $word | cut -c -${word_1_cnt})
|
|
((word_1_cnt++))
|
|
word_2=$(echo $word | cut -c ${word_1_cnt}-)
|
|
fi
|
|
|
|
echo ${word_1} >> ${OUTD}/test_${hash_type}_${kernel_type}_${attack_type}.1.words
|
|
echo ${word_2} >> ${OUTD}/test_${hash_type}_${kernel_type}_${attack_type}.2.words
|
|
|
|
CMD="./hashcat ${CUR_OPTS_V} -m ${hash_type} ${hash_in} -a 1 ${OUTD}/test_${hash_type}_${kernel_type}_${attack_type}.1.words ${OUTD}/test_${hash_type}_${kernel_type}_${attack_type}.2.words"
|
|
elif [ "${attack_type}" -eq 3 ]; then
|
|
((hash_cnt++))
|
|
|
|
if [ $pt_hex -eq 1 ]; then
|
|
word_1="${word%??}"
|
|
mask_1="?b"
|
|
else
|
|
if [ "${word_len}" -eq 2 ]; then
|
|
word_1="${word%?}"
|
|
mask_1="?d"
|
|
elif [ "${slow_hash}" -eq 1 ]; then
|
|
word_1="${word%??}"
|
|
mask_1="?d?d"
|
|
else
|
|
word_1="${word%???}"
|
|
mask_1="?d?d?d"
|
|
fi
|
|
fi
|
|
|
|
echo -n ${word_1} >> ${OUTD}/test_${hash_type}_${kernel_type}_${attack_type}.1.words.masks
|
|
echo ${mask_1} >> ${OUTD}/test_${hash_type}_${kernel_type}_${attack_type}.1.words.masks
|
|
|
|
CMD="./hashcat ${CUR_OPTS_V} -m ${hash_type} ${hash_in} -a 3 ${OUTD}/test_${hash_type}_${kernel_type}_${attack_type}.1.words.masks"
|
|
elif [ "${attack_type}" -eq 6 ]; then
|
|
((hash_cnt++))
|
|
|
|
if [ $pt_hex -eq 1 ]; then
|
|
word_1="${word%??}"
|
|
mask_1="?b"
|
|
else
|
|
if [ "${word_len}" -eq 2 ] || [ "${slow_hash}" -eq 1 ]; then
|
|
word_1="${word%?}"
|
|
mask_1="?d"
|
|
else
|
|
word_1="${word%??}"
|
|
mask_1="?d?d"
|
|
fi
|
|
fi
|
|
|
|
echo ${word_1} >> ${OUTD}/test_${hash_type}_${kernel_type}_${attack_type}.1.words
|
|
echo ${mask_1} >> ${OUTD}/test_${hash_type}_${kernel_type}_${attack_type}.1.masks
|
|
|
|
CMD="./hashcat ${CUR_OPTS_V} -m ${hash_type} ${hash_in} -a 6 ${OUTD}/test_${hash_type}_${kernel_type}_${attack_type}.1.words ${OUTD}/test_${hash_type}_${kernel_type}_${attack_type}.1.masks"
|
|
elif [ "${attack_type}" -eq 7 ]; then
|
|
((hash_cnt++))
|
|
|
|
if [ $pt_hex -eq 1 ]; then
|
|
word_1="${word#??}"
|
|
mask_1="?b"
|
|
else
|
|
if [ "${word_len}" -eq 2 ] || [ "${slow_hash}" -eq 1 ]; then
|
|
word_1="${word#?}"
|
|
mask_1="?d"
|
|
else
|
|
word_1="${word#??}"
|
|
mask_1="?d?d"
|
|
fi
|
|
fi
|
|
|
|
echo ${word_1} >> ${OUTD}/test_${hash_type}_${kernel_type}_${attack_type}.2.words
|
|
echo ${mask_1} >> ${OUTD}/test_${hash_type}_${kernel_type}_${attack_type}.2.masks
|
|
|
|
CMD="./hashcat ${CUR_OPTS_V} -m ${hash_type} ${hash_in} -a 7 ${OUTD}/test_${hash_type}_${kernel_type}_${attack_type}.2.masks ${OUTD}/test_${hash_type}_${kernel_type}_${attack_type}.2.words"
|
|
fi
|
|
done
|
|
|
|
# echo "hash_cnt: $hash_cnt"
|
|
# cat ${OUTD}/edge_${hash_type}_${kernel_type}_${attack_type}.hashes
|
|
|
|
if [ $hash_cnt -gt 1 ]; then
|
|
cmd_out="${OUTD}/cmd_${hash_type}_${kernel_type}_${attack_type}_${vector_width}.multi.log"
|
|
eval ${CMD} &> ${cmd_out}
|
|
retVal=$?
|
|
|
|
cat ${cmd_out} >> ${OUTD}/test_edge.details.log
|
|
|
|
hc_out="${OUTD}/edge_${hash_type}_${kernel_type}_${attack_type}_${vector_width}.hashes.words"
|
|
|
|
if [ "${word_compare}" != "None" ]; then
|
|
word_in="${OUTD}/edge_${hash_type}_${kernel_type}_${attack_type}_${vector_width}.words_compare"
|
|
else
|
|
word_in="${OUTD}/edge_${hash_type}_${kernel_type}_${attack_type}_${vector_width}.words"
|
|
fi
|
|
|
|
paste -d ":" ${hash_in} ${word_in} > ${hc_out}
|
|
|
|
if [ "${retVal}" -ne 0 ]; then
|
|
echo "[ ${OUTD} ] !> error ($retVal) detected with CMD: ${CMD}" | tee -a ${OUTD}/test_edge.details.log
|
|
echo "[ ${OUTD} ] !> Hash-Type ${hash_type}, Attack-Type ${attack_type}, Kernel-Type ${kernel_type}, Vector-Width ${vector_width}, Words ${word_in}, Hashes ${hash_in}" | tee -a ${OUTD}/test_edge.details.log
|
|
echo '```' | tee -a ${OUTD}/test_edge.details.log
|
|
cat ${cmd_out} | tee -a ${OUTD}/test_edge.details.log
|
|
echo '```' | tee -a ${OUTD}/test_edge.details.log
|
|
|
|
if [ "${retVal}" -eq 250 ]; then
|
|
echo "[ ${OUTD} ] > Skipping current tests due to build error ..." | tee -a ${OUTD}/test_edge.details.log
|
|
break
|
|
fi
|
|
else
|
|
if is_in_array "${hash_type}" ${SKIP_OUT_MATCH_HASH_TYPES}; then
|
|
echo "[ ${OUTD} ] > Skip output check for Hash-Type ${hash_type} (due to collisions)" >> ${OUTD}/test_edge.details.log
|
|
continue
|
|
fi
|
|
|
|
./hashcat -m ${hash_type} -HH | grep 'Keep.Guessing.......: Yes' &> /dev/null
|
|
if [ $? -eq 0 ]; then
|
|
echo "[ ${OUTD} ] > Skip output check for Hash-Type ${hash_type} (due to keep guessing)" >> ${OUTD}/test_edge.details.log
|
|
continue
|
|
fi
|
|
|
|
out=$(grep -v "Unsupported\|STATUS\|^$" ${cmd_out} | sed -e 's/ (user password.*$//g')
|
|
|
|
md5_1=$(echo "${out}" | sort -s | md5sum | cut -d' ' -f1)
|
|
md5_2=$(cat ${hc_out} | sort -s | md5sum | cut -d' ' -f1)
|
|
|
|
if [ $md5_1 != $md5_2 ]; then
|
|
echo "[ ${OUTD} ] !> error detected (output don't match) with CMD: ${CMD}" | tee -a ${OUTD}/test_edge.details.log
|
|
echo "[ ${OUTD} ] !> Hash-Type ${hash_type}, Attack-Type ${attack_type}, Kernel-Type ${kernel_type}, Vector-Width ${vector_width}, Words ${word_in}, Hashes ${hash_in}" | tee -a ${OUTD}/test_edge.details.log
|
|
echo "! output" | tee -a ${OUTD}/test_edge.details.log
|
|
echo '```' | tee -a ${OUTD}/test_edge.details.log
|
|
echo "${out}" | sort -s | tee -a ${OUTD}/test_edge.details.log
|
|
echo '```' | tee -a ${OUTD}/test_edge.details.log
|
|
echo "! expected output" | tee -a ${OUTD}/test_edge.details.log
|
|
echo '```' | tee -a ${OUTD}/test_edge.details.log
|
|
cat ${hc_out} | sort -s | tee -a ${OUTD}/test_edge.details.log
|
|
echo '```' | tee -a ${OUTD}/test_edge.details.log
|
|
fi
|
|
fi
|
|
else
|
|
echo "[ ${OUTD} ] > Skipping Hash-Type ${hash_type}, Attack-Type ${attack_type}, Kernel-Type ${kernel_type}, Vector-Width ${vector_width}, Target-Type multi, Hashes ${hash_in} (hashes < 2)" | tee -a ${OUTD}/test_edge.details.log
|
|
echo "hash_cnt: ${hash_cnt}"
|
|
fi
|
|
fi
|
|
done
|
|
fi
|
|
done
|
|
done
|
|
done
|