extra/tab_completion/oclHashcat.sh

   1 OCLHASHCAT_ROOT="."
   2
   3 # helper functions
   4 _oclHashcat_get_permutations ()
   5 {
   6   local num_devices=${1}
   7   oclHashcat_devices_permutation=""
   8
   9   # Formula: Sum (k=1...num_devices) (num_devices! / (k! * (num_devices - k)!))
  10   # or ofc (2 ^ num_devices) - 1
  11   if [ "${num_devices}" -gt 0 ]; then
  12
  13     oclHashcat_devices_permutation=$(seq 1 $num_devices)
  14
  15     local k
  16
  17     for k in $(seq 2 $num_devices); do
  18
  19       if [ "${k}" -eq ${num_devices} ];then
  20
  21         oclHashcat_devices_permutation="${oclHashcat_devices_permutation} $(seq 1 $num_devices | tr '\n' ',' | sed 's/, *$//')"
  22
  23       else
  24
  25         local j
  26         local max_pos=$((num_devices - ${k} + 1))
  27
  28         for j in $(seq 1 ${max_pos}); do
  29
  30           local max_value=$((j + ${k} - 1))
  31
  32           # init
  33           local out_str=""
  34
  35           local l
  36           for l in $(seq ${j} ${max_value}); do
  37
  38             if [ ${l} -gt ${j} ]; then
  39               out_str=${out_str},
  40             fi
  41
  42             out_str=${out_str}${l}
  43
  44           done
  45
  46           local chg_len=0
  47           local last=$((k - 1))
  48           local max_device=$((num_devices + 1))
  49           local pos_changed=0
  50
  51           while [ "${chg_len}" -lt ${last} ]; do
  52
  53             local had_pos_changed=${pos_changed}
  54             local old_chg_len=${chg_len}
  55
  56             local idx=$(((k - chg_len)))
  57             local cur_num=$(echo ${out_str} | cut -d, -f ${idx})
  58             local next_num=$((cur_num + 1))
  59
  60             if [ "${pos_changed}" -eq 0 ]; then
  61
  62               oclHashcat_devices_permutation="${oclHashcat_devices_permutation} ${out_str}"
  63
  64             else
  65
  66               pos_changed=0
  67
  68             fi
  69
  70             if [ "${next_num}" -lt ${max_device} -a "${next_num}" -le "${num_devices}" ]; then
  71
  72               out_str=$(echo ${out_str} | sed "s/,${cur_num},/,${next_num},/;s/,${cur_num}\$/,${next_num}/")
  73
  74             else
  75
  76               pos_changed=1
  77               max_device=${cur_num}
  78               chg_len=$((chg_len + 1))
  79
  80             fi
  81
  82             if [ "${had_pos_changed}" -eq 1 ];then
  83
  84               local changed=0
  85               local m
  86
  87               for m in $(seq 1 ${old_chg_len}); do
  88
  89                 local reset_idx=$((k - ${old_chg_len} + ${m}))
  90                 local last_num=$(echo ${out_str} | cut -d, -f ${reset_idx})
  91                 next_num=$((next_num + 1))
  92
  93                 if [ "${next_num}" -lt ${max_device} -a "${next_num}" -le "${num_devices}" ]; then
  94
  95                   out_str=$(echo ${out_str} | sed "s/,${last_num},/,${next_num},/;s/,${last_num}\$/,${next_num}/")
  96                   max_device=$((next_num + 2))
  97                   changed=$((changed + 1))
  98
  99                 else
 100                   break
 101                 fi
 102
 103               done
 104
 105               if [ "${changed}" -gt 0 ]; then
 106
 107                 max_device=$((num_devices + 1))
 108                 chg_len=0
 109
 110               fi
 111
 112             fi
 113
 114           done
 115
 116         done
 117
 118       fi
 119
 120     done
 121   fi
 122 }
 123
 124 _oclHashcat_opencl_devices ()
 125 {
 126   local num_devices=0
 127
 128   if which clinfo &> /dev/null; then
 129
 130     num_devices=$(clinfo 2>/dev/null 2> /dev/null)
 131
 132   elif which nvidia-smi &> /dev/null; then
 133
 134     num_devices=$(nvidia-smi --list-gpus | wc -l)
 135
 136   fi
 137
 138   return ${num_devices}
 139 }
 140
 141 _oclHashcat_cpu_devices ()
 142 {
 143   local num_devices=0
 144
 145   if [ -f "/proc/cpuinfo" ]; then
 146
 147     num_devices=$(cat /proc/cpuinfo | grep -c processor 2> /dev/null)
 148
 149   fi
 150
 151   return ${num_devices}
 152 }
 153
 154 _oclHashcat_contains ()
 155 {
 156   local haystack=${1}
 157   local needle="${2}"
 158
 159   if   echo "${haystack}" | grep -q " ${needle} " 2> /dev/null; then
 160     return 0
 161   elif echo "${haystack}" | grep -q "^${needle} " 2> /dev/null; then
 162     return 0
 163   elif echo "${haystack}" | grep -q " ${needle}\$" 2> /dev/null; then
 164     return 0
 165   fi
 166
 167   return 1
 168 }
 169
 170 _oclHashcat ()
 171 {
 172   local VERSION=2.10
 173
 174   local HASH_MODES="0 10 11 12 20 21 22 23 30 40 50 60 100 101 110 111 112 120 121 122 124 130 131 132 133 140 141 150 160 190 200 300 400 500 501 900 1000 1100 1400 1410 1420 1421 1430 1440 1441 1450 1460 1500 1600 1700 1710 1711 1720 1722 1730 1731 1740 1750 1760 1800 2100 2400 2410 2500 2600 2611 2612 2711 2811 3000 3100 3200 3710 3711 3800 4300 4400 4500 4700 4800 4900 5000 5100 5200 5300 5400 5500 5600 5700 5800 6000 6100 6211 6212 6213 6221 6222 6223 6231 6232 6233 6241 6242 6243 6300 6400 6500 6600 6700 6800 6900 7100 7200 7300 7400 7500 7600 7700 7800 7900 8000 8100 8200 8300 8400 8500 8600 8700 8800 8900 9000 9100 9200 9300 9400 9500 9600 9700 9710 9720 9800 9810 9820 9900 10000 10100 10200 10300 10400 10410 10420 10500 10600 10700 10800 10900 11000 11100 11200 11300 11400 11500 11600 11700 11800 11900 12000 12100 12200 12300 12400 12500 12600 12700 12800 12900 13000"
 175   local ATTACK_MODES="0 1 3 6 7"
 176   local OUTFILE_FORMATS="1 2 3 4 5 6 7 8 9 10 11 12 13 14 15"
 177   local OPENCL_DEVICE_TYPES="1 2 3"
 178   local OPENCL_VECTOR_WIDTH="1 2 4 8"
 179   local BENCHMARK_MODE="0 1"
 180   local DEBUG_MODE="1 2 3 4"
 181   local WORKLOAD_PROFILE="1 2 3"
 182   local KERNEL_ACCEL="1 8 16 24 32 40 48 56 64 62 80 88 96 104 112 120 128 136 144 152 160"
 183   local KERNEL_LOOPS="8 16 32 64 128 256 512 1024"
 184   local HIDDEN_FILES="exe|bin|pot|hcstat|dictstat|accepted|sh|cmd|bat|restore"
 185   local HIDDEN_FILES_AGGRESIVE="exe|bin|pot|hcstat|dictstat|hcmask|hcchr|accepted|sh|cmd|restore"
 186   local BUILD_IN_CHARSETS='?l ?u ?d ?a ?b ?s'
 187
 188   local SHORT_OPTS="-m -a -V -v -h -b -t -o -p -c -d -w -n -u -j -k -r -g -1 -2 -3 -4 -i -s -l"
 189   local LONG_OPTS="--hash-type --attack-mode --version --help --eula --quiet --benchmark --benchmark-mode --hex-salt --hex-wordlist --hex-charset --force --status --status-timer --status-automat --loopback --weak-hash-threshold --markov-hcstat --markov-disable --markov-classic --markov-threshold --runtime --session --restore --restore-disable --outfile --outfile-format --outfile-autohex-disable --outfile-check-timer --outfile-check-dir --separator --show --left --username --remove --remove-timer --potfile-disable --debug-mode --debug-file --induction-dir --segment-size --bitmap-min --bitmap-max --cpu-affinity --opencl-devices --opencl-platforms --opencl-device-types --opencl-vector-width --workload-profile --kernel-accel --kernel-loops --gpu-temp-disable --gpu-temp-abort --gpu-temp-retain --powertune-enable --skip --limit --keyspace --rule-left --rule-right --rules-file --generate-rules --generate-rules-func-min --generate-rules-func-max --generate-rules-seed --rules-cleanup --custom-charset1 --custom-charset2 --custom-charset3 --custom-charset4 --increment --increment-min --increment-max --logfile-disable --scrypt-tmto --truecrypt-keyfiles"
 190   local OPTIONS="-m -a -t -o -p -c -d -w -n -u -j -k -r -g -1 -2 -3 -4 -s -l --hash-type --attack-mode --benchmark-mode --status-timer --weak-hash-threshold --markov-hcstat --markov-threshold --runtime --session --timer --outfile --outfile-format --outfile-check-timer --outfile-check-dir --separator --remove-timer --debug-mode --debug-file --induction-dir --segment-size --bitmap-min --bitmap-max --cpu-affinity --opencl-devices --opencl-platforms --opencl-device-types --opencl-vector-width --workload-profile --kernel-accel --kernel-loops --gpu-temp-abort --gpu-temp-retain -disable --skip --limit --rule-left --rule-right --rules-file --generate-rules --generate-rules-func-min --generate-rules-func-max --generate-rules-seed --custom-charset1 --custom-charset2 --custom-charset3 --custom-charset4 --increment-min --increment-max --scrypt-tmto --truecrypt-keyfiles"
 191
 192   COMPREPLY=()
 193   local cur="${COMP_WORDS[COMP_CWORD]}"
 194   local prev="${COMP_WORDS[COMP_CWORD-1]}"
 195
 196   # if cur is just '=', ignore the '=' and treat it as only the prev was provided
 197   if [[ "${cur}" == '=' ]]; then
 198
 199     cur=""
 200
 201   elif [[ "${prev}" == '=' ]]; then
 202
 203     if [ "${COMP_CWORD}" -gt 2 ]; then
 204
 205       prev="${COMP_WORDS[COMP_CWORD-2]}"
 206
 207     fi
 208
 209   fi
 210
 211   case "${prev}" in
 212
 213     -m|--hash-type)
 214       COMPREPLY=($(compgen -W "${HASH_MODES}" -- ${cur}))
 215       return 0
 216       ;;
 217
 218     -a|--attack-mode)
 219       COMPREPLY=($(compgen -W "${ATTACK_MODES}" -- ${cur}))
 220       return 0
 221       ;;
 222
 223     --outfile-format)
 224       COMPREPLY=($(compgen -W "${OUTFILE_FORMATS}" -- ${cur}))
 225       return 0
 226       ;;
 227
 228     --benchmark-mode)
 229       COMPREPLY=($(compgen -W "${BENCHMARK_MODE}" -- ${cur}))
 230       return 0
 231       ;;
 232
 233     -w|--workload-profile)
 234       COMPREPLY=($(compgen -W "${WORKLOAD_PROFILE}" -- ${cur}))
 235       return 0
 236       ;;
 237
 238     -n|--kernel-accel)
 239       COMPREPLY=($(compgen -W "${KERNEL_ACCEL}" -- ${cur}))
 240       return 0
 241       ;;
 242
 243     -u|--kernel-loops)
 244       COMPREPLY=($(compgen -W "${KERNEL_LOOPS}" -- ${cur}))
 245       return 0
 246       ;;
 247
 248     -o|--outfile|-r|--rules-file|--debug-file)
 249       local files=$(ls -d ${cur}* 2> /dev/null | grep -Eiv '*\.('${HIDDEN_FILES_AGGRESIVE}')' 2> /dev/null)
 250       COMPREPLY=($(compgen -W "${files}" -- ${cur})) # or $(compgen -f -X '*.+('${HIDDEN_FILES_AGGRESIVE}')' -- ${cur})
 251       return 0
 252       ;;
 253
 254     --markov-hcstat)
 255       local files=$(ls -d ${cur}* 2> /dev/null | grep -Eiv '*\.('${HIDDEN_FILES}')' 2> /dev/null)
 256       COMPREPLY=($(compgen -W "${files}" -- ${cur})) # or $(compgen -f -X '*.+('${HIDDEN_FILES_AGGRESIVE}')' -- ${cur})
 257       return 0
 258       ;;
 259
 260      -d|--opencl-devices)
 261       _oclHashcat_opencl_devices
 262       local num_devices=${?}
 263
 264       _oclHashcat_get_permutations ${num_devices}
 265
 266       COMPREPLY=($(compgen -W "${oclHashcat_devices_permutation}" -- ${cur}))
 267       return 0
 268       ;;
 269
 270     --opencl-device-types)
 271       COMPREPLY=($(compgen -W "${OPENCL_DEVICE_TYPES}" -- ${cur}))
 272       return 0
 273       ;;
 274
 275     --opencl-vector-width)
 276       COMPREPLY=($(compgen -W "${OPENCL_VECTOR_WIDTH}" -- ${cur}))
 277       return 0
 278       ;;
 279
 280     --opencl-platforms)
 281       local icd_list=$(ls -1 /etc/OpenCL/vendors/*.icd 2> /dev/null)
 282
 283       local architecture=$(getconf LONG_BIT 2> /dev/null)
 284
 285       if [ -z "${architecture}" ]; then
 286         return 0
 287       fi
 288
 289       # filter the icd_list (do not show 32 bit on 64bit systems and vice versa)
 290
 291       if [ "${architecture}" -eq 64 ]; then
 292
 293         icd_list=$(echo "${icd_list}" | grep -v "32.icd")
 294
 295       else
 296
 297         icd_list=$(echo "${icd_list}" | grep -v "64.icd")
 298
 299       fi
 300
 301       local number_icds=$(seq 1 $(echo "${icd_list}" | wc -l))
 302
 303       COMPREPLY=($(compgen -W "${number_icds}" -- ${cur}))
 304
 305       return 0
 306       ;;
 307
 308     --cpu-affinity)
 309       _oclHashcat_cpu_devices
 310       local num_devices=${?}
 311
 312       _oclHashcat_get_permutations ${num_devices}
 313
 314       COMPREPLY=($(compgen -W "${oclHashcat_devices_permutation}" -- ${cur}))
 315       return 0
 316       ;;
 317
 318     -1|-2|-3|-4|--custom-charset1|--custom-charset2|--custom-charset3|--custom-charset4)
 319       local mask=${BUILD_IN_CHARSETS}
 320
 321       if [ -e "${cur}" ]; then # should be hcchr file (but not enforced)
 322
 323         COMPREPLY=($(compgen -W "${cur}" -- ${cur}))
 324         return 0
 325
 326       fi
 327
 328       if [ -n "${cur}" ]; then
 329
 330         local cur_var=$(echo "${cur}" | sed 's/\?$//')
 331
 332         mask="${mask} ${cur_var}"
 333         local h
 334         for h in ${mask}; do
 335
 336           if ! echo ${cur} | grep -q ${h} 2> /dev/null; then
 337
 338             if echo ${cur} | grep -q '?a' 2> /dev/null; then
 339
 340               if   [[ "${h}" == "?l" ]] ; then
 341                 continue
 342               elif [[ "${h}" == "?u" ]] ; then
 343                 continue
 344               elif [[ "${h}" == "?d" ]] ; then
 345                 continue
 346               elif [[ "${h}" == "?s" ]] ; then
 347                 continue
 348               elif [[ "${h}" == "?b" ]] ; then
 349                 continue
 350               fi
 351
 352             fi
 353
 354             mask="${mask} ${cur_var}${h}"
 355
 356           fi
 357
 358         done
 359       fi
 360
 361       local files=$(ls -d ${cur}* 2> /dev/null | grep -Eiv '*\.('${HIDDEN_FILES}')' 2> /dev/null)
 362
 363       mask="${mask} ${files}"
 364
 365       COMPREPLY=($(compgen -W "${mask}" -- ${cur}))
 366       return 0
 367       ;;
 368
 369     -t|-p|-c|-j|-k|-g| \
 370       --status-timer|--markov-threshold|--runtime|--session|--separator|--segment-size|--rule-left|--rule-right| \
 371       --gpu-temp-abort|--gpu-temp-retain|--generate-rules|--generate-rules-func-min|--generate-rules-func-max| \
 372       --increment-min|--increment-max|--remove-timer|--bitmap-min|--bitmap-max|--skip|--limit|--generate-rules-seed| \
 373       --weak-hash-threshold|--outfile-check-timer|--outfile-check-dir|--induction-dir|--scrypt-tmto)
 374       return 0
 375       ;;
 376
 377     --debug-mode)
 378       COMPREPLY=($(compgen -W "${DEBUG_MODE}" -- ${cur}))
 379       return 0
 380       ;;
 381
 382     --truecrypt-keyfiles)
 383       # first: remove the quotes such that file matching is possible
 384
 385       local cur_part0=$(echo "${cur}" | grep -Eo '^("|'"'"')')
 386
 387       local cur_mod=$(echo "${cur}" | sed 's/^["'"'"']//')
 388       local cur_part1=$(echo "${cur_mod}" | grep ',' 2> /dev/null | sed 's/^\(.*, *\)[^,]*$/\1/')
 389       local cur_part2=$(echo "${cur_mod}" | sed 's/^.*, *\([^,]*\)$/\1/')
 390
 391       # generate lines with the file name and a duplicate of it with a comma at the end
 392
 393       local files=$(ls -d ${cur_part2}* 2> /dev/null | grep -Eiv '*\.('${HIDDEN_FILES_AGGRESIVE}')' 2> /dev/null | sed 's/^\(.*\)$/\1\n\1,\n/' | sed "s/^/${cur_part0}${cur_part1}/" | sed "s/$/${cur_part0}/")
 394       COMPREPLY=($(compgen -W "${files}" -- ${cur}))
 395       return 0
 396
 397   esac
 398
 399   # allow also the VARIANTS w/o spaces
 400   # we could use compgen -P prefix, but for some reason it doesn't seem to work always
 401
 402   case "$cur" in
 403
 404     -m*)
 405       local hash_modes_var="$(echo -n "-m ${HASH_MODES}" | sed 's/ / -m/g')"
 406       COMPREPLY=($(compgen -W "${hash_modes_var}" -- ${cur}))
 407       return 0
 408       ;;
 409
 410     -a*)
 411       local attack_modes_var="$(echo -n "-a ${ATTACK_MODES}" | sed 's/ / -a/g')"
 412       COMPREPLY=($(compgen -W "${attack_modes_var}" -- ${cur}))
 413       return 0
 414       ;;
 415
 416     -w*)
 417       local workload_profile_var="$(echo -n "-w ${WORKLOAD_PROFILE}" | sed 's/ / -w/g')"
 418       COMPREPLY=($(compgen -W "${workload_profile_var}" -- ${cur}))
 419       return 0
 420       ;;
 421
 422     -n*)
 423       local kernel_accel_var="$(echo -n "-n ${KERNEL_ACCEL}" | sed 's/ / -n/g')"
 424       COMPREPLY=($(compgen -W "${kernel_accel_var}" -- ${cur}))
 425       return 0
 426       ;;
 427
 428     -u*)
 429       local kernel_loops_var="$(echo -n "-u ${KERNEL_LOOPS}" | sed 's/ / -u/g')"
 430       COMPREPLY=($(compgen -W "${kernel_loops_var}" -- ${cur}))
 431       return 0
 432       ;;
 433
 434     -o*)
 435       local outfile_var=$(ls -d ${cur:2}* 2> /dev/null | grep -Eiv '*\.('${HIDDEN_FILES_AGGRESIVE}')' 2> /dev/null)
 436       outfile_var="$(echo -e "\n${outfile_var}" | sed 's/^/-o/g')"
 437       COMPREPLY=($(compgen -W "${outfile_var}" -- ${cur}))
 438       return 0
 439       ;;
 440
 441     -r*)
 442       local outfile_var=$(ls -d ${cur:2}* 2> /dev/null | grep -Eiv '*\.('${HIDDEN_FILES_AGGRESIVE}')' 2> /dev/null)
 443       outfile_var="$(echo -e "\n${outfile_var}" | sed 's/^/-r/g')"
 444       COMPREPLY=($(compgen -W "${outfile_var}" -- ${cur}))
 445       return 0
 446       ;;
 447
 448     -d*)
 449       _oclHashcat_opencl_devices
 450       local num_devices=${?}
 451
 452       _oclHashcat_get_permutations ${num_devices}
 453
 454       local opencl_devices_var="$(echo "  "${oclHashcat_devices_permutation} | sed 's/ / -d/g')"
 455       COMPREPLY=($(compgen -W "${opencl_devices_var}" -- ${cur}))
 456       return 0
 457       ;;
 458   esac
 459
 460   # Complete options/switches (not the arguments)
 461
 462   if [[ "${cur}" == -* ]]; then
 463
 464       COMPREPLY=($(compgen -W "${SHORT_OPTS} ${LONG_OPTS}" -- ${cur}))
 465       return 0
 466
 467   fi
 468
 469   # additional parameter, no switch nor option but maybe hash file, dictionary, mask, directory
 470
 471   # check if first option out of (hash.txt and dictionary|mask|directory)
 472   # is first option iff: here
 473   # is second option iff: COMP_CWORD > 2 and no switch before (-*) if no option afterwards (for mask -a 3, -a 6, -a 7 - but possible for dicts!)
 474
 475   local h=1
 476   local no_opts=0
 477   local attack_mode=0 # also default of oclHashcat
 478   local has_charset_1=0
 479   local has_charset_2=0
 480   local has_charset_3=0
 481   local has_charset_4=0
 482
 483   while [ ${h} -le ${COMP_CWORD} ]; do
 484
 485     if   [[ "${COMP_WORDS[h]}" == "-a" ]]; then
 486
 487       attack_mode=${COMP_WORDS[$((h + 1))]}
 488
 489     elif   [[ "${COMP_WORDS[h]}" == -a* ]]; then
 490
 491       attack_mode=${COMP_WORDS[h]:2}
 492
 493     elif [[ "${COMP_WORDS[h]}" == "--attack-mode" ]]; then
 494
 495       attack_mode=${COMP_WORDS[$((h + 1))]}
 496
 497     elif [[ "${COMP_WORDS[h]}" == "-1" ]]; then
 498
 499       has_charset_1=1
 500
 501     elif [[ "${COMP_WORDS[h]}" == "--custom-charset1" ]]; then
 502
 503       has_charset_1=1
 504
 505     elif [[ "${COMP_WORDS[h]}" == "-2" ]]; then
 506
 507       has_charset_2=1
 508
 509     elif [[ "${COMP_WORDS[h]}" == "--custom-charset2" ]]; then
 510
 511       has_charset_2=1
 512
 513     elif [[ "${COMP_WORDS[h]}" == "-3" ]]; then
 514
 515       has_charset_3=1
 516
 517     elif [[ "${COMP_WORDS[h]}" == "--custom-charset3" ]]; then
 518
 519       has_charset_3=1
 520
 521     elif [[ "${COMP_WORDS[h]}" == "-4" ]]; then
 522
 523       has_charset_4=1
 524
 525     elif [[ "${COMP_WORDS[h]}" == "--custom-charset4" ]]; then
 526
 527       has_charset_4=1
 528
 529     fi
 530
 531     if _oclHashcat_contains "${OPTIONS}" "${COMP_WORDS[h]}"; then
 532
 533       h=$((h + 2))
 534
 535     else
 536
 537       if ! _oclHashcat_contains "${LONG_OPTS}${SHORT_OPTS}" "${COMP_WORDS[h]}"; then
 538         local variants="-m -a -w -n -u -o -r -d"
 539         local skip=0
 540         local v
 541         for v in ${variants}; do
 542
 543           if [[ "${COMP_WORDS[h]:0:2}" == "${v}" ]]; then
 544             skip=1
 545           fi
 546
 547         done
 548
 549         if [ "${skip}" -eq 0 ]; then
 550
 551           no_opts=$((no_opts + 1))
 552
 553         fi
 554       fi
 555
 556       h=$((h + 1))
 557
 558     fi
 559
 560   done
 561
 562   case "${no_opts}" in
 563
 564     0)
 565       return 0
 566       ;;
 567
 568     1)
 569       local files=$(ls -d ${cur}* 2> /dev/null | grep -Eiv '*\.('${HIDDEN_FILES_AGGRESIVE}')' 2> /dev/null)
 570       COMPREPLY=($(compgen -W "${files}" -- ${cur}))
 571       return 0
 572       ;;
 573
 574     *)
 575       case "${attack_mode}" in
 576
 577         0)
 578           # dict/directory are files here
 579           local files=$(ls -d ${cur}* 2> /dev/null | grep -Eiv '*\.('${HIDDEN_FILES_AGGRESIVE}')' 2> /dev/null)
 580           COMPREPLY=($(compgen -W "${files}" -- ${cur}))
 581           return 0
 582           ;;
 583
 584         1)
 585           if [ "${no_opts}" -gt 4 ]; then
 586             return 0
 587           fi
 588
 589           local files=$(ls -d ${cur}* 2> /dev/null | grep -Eiv '*\.('${HIDDEN_FILES_AGGRESIVE}')' 2> /dev/null)
 590           COMPREPLY=($(compgen -W "${files}" -- ${cur}))
 591           return 0
 592           ;;
 593
 594         3)
 595           if [ "${no_opts}" -eq 2 ]; then
 596             local mask=${BUILD_IN_CHARSETS}
 597
 598             if [ "${has_charset_1}" -eq 1 ]; then
 599
 600               mask="${mask} ?1"
 601
 602             fi
 603
 604             if [ "${has_charset_2}" -eq 1 ]; then
 605
 606               mask="${mask} ?2"
 607
 608             fi
 609
 610             if [ "${has_charset_3}" -eq 1 ]; then
 611
 612               mask="${mask} ?3"
 613
 614             fi
 615
 616             if [ "${has_charset_4}" -eq 1 ]; then
 617
 618               mask="${mask} ?4"
 619
 620             fi
 621
 622             if [ -e "${cur}" ]; then # should be hcmask file (but not enforced)
 623
 624               COMPREPLY=($(compgen -W "${cur}" -- ${cur}))
 625               return 0
 626
 627             fi
 628
 629             if [ -n "${cur}" ]; then
 630
 631               local cur_var=$(echo "${cur}" | sed 's/\?$//')
 632
 633               mask="${mask} ${cur_var}"
 634
 635               local h
 636               for h in ${mask}; do
 637
 638                   mask="${mask} ${cur_var}${h}"
 639
 640               done
 641             fi
 642
 643             local files=$(ls -d ${cur}* 2> /dev/null | grep -Eiv '*\.('${HIDDEN_FILES}')' 2> /dev/null)
 644
 645             mask="${mask} ${files}"
 646
 647             COMPREPLY=($(compgen -W "${mask}" -- ${cur}))
 648             return 0
 649           fi
 650           ;;
 651
 652         6)
 653           if [ "${no_opts}" -eq 2 ]; then
 654
 655             local files=$(ls -d ${cur}* 2> /dev/null | grep -Eiv '*\.('${HIDDEN_FILES_AGGRESIVE}')' 2> /dev/null)
 656             COMPREPLY=($(compgen -W "${files}" -- ${cur}))
 657
 658           elif [ "${no_opts}" -eq 3 ]; then
 659             local mask=${BUILD_IN_CHARSETS}
 660
 661             if [ "${has_charset_1}" -eq 1 ]; then
 662
 663               mask="${mask} ?1"
 664
 665             fi
 666
 667             if [ "${has_charset_2}" -eq 1 ]; then
 668
 669               mask="${mask} ?2"
 670
 671             fi
 672
 673             if [ "${has_charset_3}" -eq 1 ]; then
 674
 675               mask="${mask} ?3"
 676
 677             fi
 678
 679             if [ "${has_charset_4}" -eq 1 ]; then
 680
 681               mask="${mask} ?4"
 682
 683             fi
 684
 685             if [ -e "${cur}" ]; then # should be hcmask file (but not enforced)
 686
 687               COMPREPLY=($(compgen -W "${cur}" -- ${cur}))
 688               return 0
 689
 690             fi
 691
 692             if [ -n "${cur}" ]; then
 693
 694               local cur_var=$(echo "${cur}" | sed 's/\?$//')
 695
 696               mask="${mask} ${cur_var}"
 697
 698               local h
 699               for h in ${mask}; do
 700
 701                   mask="${mask} ${cur_var}${h}"
 702
 703               done
 704             fi
 705
 706             local files=$(ls -d ${cur}* 2> /dev/null | grep -Eiv '*\.('${HIDDEN_FILES}')' 2> /dev/null)
 707
 708             mask="${mask} ${files}"
 709
 710             COMPREPLY=($(compgen -W "${mask}" -- ${cur}))
 711             return 0
 712
 713           fi
 714           ;;
 715
 716         7)
 717           if [ "${no_opts}" -eq 2 ]; then
 718             local mask=${BUILD_IN_CHARSETS}
 719
 720             if [ "${has_charset_1}" -eq 1 ]; then
 721
 722               mask="${mask} ?1"
 723
 724             fi
 725
 726             if [ "${has_charset_2}" -eq 1 ]; then
 727
 728               mask="${mask} ?2"
 729
 730             fi
 731
 732             if [ "${has_charset_3}" -eq 1 ]; then
 733
 734               mask="${mask} ?3"
 735
 736             fi
 737
 738             if [ "${has_charset_4}" -eq 1 ]; then
 739
 740               mask="${mask} ?4"
 741
 742             fi
 743
 744             if [ -e "${cur}" ]; then # should be hcmask file (but not enforced)
 745
 746               COMPREPLY=($(compgen -W "${cur}" -- ${cur}))
 747               return 0
 748
 749             fi
 750
 751             if [ -n "${cur}" ]; then
 752
 753               local cur_var=$(echo "${cur}" | sed 's/\?$//')
 754
 755               mask="${mask} ${cur_var}"
 756
 757               local h
 758               for h in ${mask}; do
 759
 760                   mask="${mask} ${cur_var}${h}"
 761
 762               done
 763             fi
 764
 765             local files=$(ls -d ${cur}* 2> /dev/null | grep -Eiv '*\.('${HIDDEN_FILES}')' 2> /dev/null)
 766
 767             mask="${mask} ${files}"
 768
 769             COMPREPLY=($(compgen -W "${mask}" -- ${cur}))
 770             return 0
 771
 772           elif [ "${no_opts}" -eq 3 ]; then
 773
 774             local files=$(ls -d ${cur}* 2> /dev/null | grep -Eiv '*\.('${HIDDEN_FILES_AGGRESIVE}')' 2> /dev/null)
 775             COMPREPLY=($(compgen -W "${files}" -- ${cur}))
 776             return
 777
 778           fi
 779           ;;
 780
 781       esac
 782
 783     esac
 784 }
 785
 786 complete -F _oclHashcat -o filenames "${OCLHASHCAT_ROOT}"/oclHashcat64.bin "${OCLHASHCAT_ROOT}"/oclHashcat32.bin "${OCLHASHCAT_ROOT}"/oclHashcat oclHashcat