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 BENCHMARK_MODE="0 1"
 179   local DEBUG_MODE="1 2 3 4"
 180   local WORKLOAD_PROFILE="1 2 3"
 181   local KERNEL_ACCEL="1 8 16 24 32 40 48 56 64 62 80 88 96 104 112 120 128 136 144 152 160"
 182   local KERNEL_LOOPS="8 16 32 64 128 256 512 1024"
 183   local HIDDEN_FILES="exe|bin|pot|hcstat|dictstat|accepted|sh|cmd|bat|restore"
 184   local HIDDEN_FILES_AGGRESIVE="exe|bin|pot|hcstat|dictstat|hcmask|hcchr|accepted|sh|cmd|restore"
 185   local BUILD_IN_CHARSETS='?l ?u ?d ?a ?b ?s'
 186
 187   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"
 188   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 --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"
 189   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 --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"
 190
 191   COMPREPLY=()
 192   local cur="${COMP_WORDS[COMP_CWORD]}"
 193   local prev="${COMP_WORDS[COMP_CWORD-1]}"
 194
 195   # if cur is just '=', ignore the '=' and treat it as only the prev was provided
 196   if [[ "${cur}" == '=' ]]; then
 197
 198     cur=""
 199
 200   elif [[ "${prev}" == '=' ]]; then
 201
 202     if [ "${COMP_CWORD}" -gt 2 ]; then
 203
 204       prev="${COMP_WORDS[COMP_CWORD-2]}"
 205
 206     fi
 207
 208   fi
 209
 210   case "${prev}" in
 211
 212     -m|--hash-type)
 213       COMPREPLY=($(compgen -W "${HASH_MODES}" -- ${cur}))
 214       return 0
 215       ;;
 216
 217     -a|--attack-mode)
 218       COMPREPLY=($(compgen -W "${ATTACK_MODES}" -- ${cur}))
 219       return 0
 220       ;;
 221
 222     --outfile-format)
 223       COMPREPLY=($(compgen -W "${OUTFILE_FORMATS}" -- ${cur}))
 224       return 0
 225       ;;
 226
 227     --benchmark-mode)
 228       COMPREPLY=($(compgen -W "${BENCHMARK_MODE}" -- ${cur}))
 229       return 0
 230       ;;
 231
 232     -w|--workload-profile)
 233       COMPREPLY=($(compgen -W "${WORKLOAD_PROFILE}" -- ${cur}))
 234       return 0
 235       ;;
 236
 237     -n|--kernel-accel)
 238       COMPREPLY=($(compgen -W "${KERNEL_ACCEL}" -- ${cur}))
 239       return 0
 240       ;;
 241
 242     -u|--kernel-loops)
 243       COMPREPLY=($(compgen -W "${KERNEL_LOOPS}" -- ${cur}))
 244       return 0
 245       ;;
 246
 247     -o|--outfile|-r|--rules-file|--debug-file)
 248       local files=$(ls -d ${cur}* 2> /dev/null | grep -Eiv '*\.('${HIDDEN_FILES_AGGRESIVE}')' 2> /dev/null)
 249       COMPREPLY=($(compgen -W "${files}" -- ${cur})) # or $(compgen -f -X '*.+('${HIDDEN_FILES_AGGRESIVE}')' -- ${cur})
 250       return 0
 251       ;;
 252
 253     --markov-hcstat)
 254       local files=$(ls -d ${cur}* 2> /dev/null | grep -Eiv '*\.('${HIDDEN_FILES}')' 2> /dev/null)
 255       COMPREPLY=($(compgen -W "${files}" -- ${cur})) # or $(compgen -f -X '*.+('${HIDDEN_FILES_AGGRESIVE}')' -- ${cur})
 256       return 0
 257       ;;
 258
 259      -d|--opencl-devices)
 260       _oclHashcat_opencl_devices
 261       local num_devices=${?}
 262
 263       _oclHashcat_get_permutations ${num_devices}
 264
 265       COMPREPLY=($(compgen -W "${oclHashcat_devices_permutation}" -- ${cur}))
 266       return 0
 267       ;;
 268
 269     --opencl-device-types)
 270       COMPREPLY=($(compgen -W "${OPENCL_DEVICE_TYPES}" -- ${cur}))
 271       return 0
 272       ;;
 273
 274     --opencl-platforms)
 275       local icd_list=$(ls -1 /etc/OpenCL/vendors/*.icd 2> /dev/null)
 276
 277       local architecture=$(getconf LONG_BIT 2> /dev/null)
 278
 279       if [ -z "${architecture}" ]; then
 280         return 0
 281       fi
 282
 283       # filter the icd_list (do not show 32 bit on 64bit systems and vice versa)
 284
 285       if [ "${architecture}" -eq 64 ]; then
 286
 287         icd_list=$(echo "${icd_list}" | grep -v "32.icd")
 288
 289       else
 290
 291         icd_list=$(echo "${icd_list}" | grep -v "64.icd")
 292
 293       fi
 294
 295       local number_icds=$(seq 1 $(echo "${icd_list}" | wc -l))
 296
 297       COMPREPLY=($(compgen -W "${number_icds}" -- ${cur}))
 298
 299       return 0
 300       ;;
 301
 302     --cpu-affinity)
 303       _oclHashcat_cpu_devices
 304       local num_devices=${?}
 305
 306       _oclHashcat_get_permutations ${num_devices}
 307
 308       COMPREPLY=($(compgen -W "${oclHashcat_devices_permutation}" -- ${cur}))
 309       return 0
 310       ;;
 311
 312     -1|-2|-3|-4|--custom-charset1|--custom-charset2|--custom-charset3|--custom-charset4)
 313       local mask=${BUILD_IN_CHARSETS}
 314
 315       if [ -e "${cur}" ]; then # should be hcchr file (but not enforced)
 316
 317         COMPREPLY=($(compgen -W "${cur}" -- ${cur}))
 318         return 0
 319
 320       fi
 321
 322       if [ -n "${cur}" ]; then
 323
 324         local cur_var=$(echo "${cur}" | sed 's/\?$//')
 325
 326         mask="${mask} ${cur_var}"
 327         local h
 328         for h in ${mask}; do
 329
 330           if ! echo ${cur} | grep -q ${h} 2> /dev/null; then
 331
 332             if echo ${cur} | grep -q '?a' 2> /dev/null; then
 333
 334               if   [[ "${h}" == "?l" ]] ; then
 335                 continue
 336               elif [[ "${h}" == "?u" ]] ; then
 337                 continue
 338               elif [[ "${h}" == "?d" ]] ; then
 339                 continue
 340               elif [[ "${h}" == "?s" ]] ; then
 341                 continue
 342               elif [[ "${h}" == "?b" ]] ; then
 343                 continue
 344               fi
 345
 346             fi
 347
 348             mask="${mask} ${cur_var}${h}"
 349
 350           fi
 351
 352         done
 353       fi
 354
 355       local files=$(ls -d ${cur}* 2> /dev/null | grep -Eiv '*\.('${HIDDEN_FILES}')' 2> /dev/null)
 356
 357       mask="${mask} ${files}"
 358
 359       COMPREPLY=($(compgen -W "${mask}" -- ${cur}))
 360       return 0
 361       ;;
 362
 363     -t|-p|-c|-j|-k|-g| \
 364       --status-timer|--markov-threshold|--runtime|--session|--separator|--segment-size|--rule-left|--rule-right| \
 365       --gpu-temp-abort|--gpu-temp-retain|--generate-rules|--generate-rules-func-min|--generate-rules-func-max| \
 366       --increment-min|--increment-max|--remove-timer|--bitmap-min|--bitmap-max|--skip|--limit|--generate-rules-seed| \
 367       --weak-hash-threshold|--outfile-check-timer|--outfile-check-dir|--induction-dir|--scrypt-tmto)
 368       return 0
 369       ;;
 370
 371     --debug-mode)
 372       COMPREPLY=($(compgen -W "${DEBUG_MODE}" -- ${cur}))
 373       return 0
 374       ;;
 375
 376     --truecrypt-keyfiles)
 377       # first: remove the quotes such that file matching is possible
 378
 379       local cur_part0=$(echo "${cur}" | grep -Eo '^("|'"'"')')
 380
 381       local cur_mod=$(echo "${cur}" | sed 's/^["'"'"']//')
 382       local cur_part1=$(echo "${cur_mod}" | grep ',' 2> /dev/null | sed 's/^\(.*, *\)[^,]*$/\1/')
 383       local cur_part2=$(echo "${cur_mod}" | sed 's/^.*, *\([^,]*\)$/\1/')
 384
 385       # generate lines with the file name and a duplicate of it with a comma at the end
 386
 387       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}/")
 388       COMPREPLY=($(compgen -W "${files}" -- ${cur}))
 389       return 0
 390
 391   esac
 392
 393   # allow also the VARIANTS w/o spaces
 394   # we could use compgen -P prefix, but for some reason it doesn't seem to work always
 395
 396   case "$cur" in
 397
 398     -m*)
 399       local hash_modes_var="$(echo -n "-m ${HASH_MODES}" | sed 's/ / -m/g')"
 400       COMPREPLY=($(compgen -W "${hash_modes_var}" -- ${cur}))
 401       return 0
 402       ;;
 403
 404     -a*)
 405       local attack_modes_var="$(echo -n "-a ${ATTACK_MODES}" | sed 's/ / -a/g')"
 406       COMPREPLY=($(compgen -W "${attack_modes_var}" -- ${cur}))
 407       return 0
 408       ;;
 409
 410     -w*)
 411       local workload_profile_var="$(echo -n "-w ${WORKLOAD_PROFILE}" | sed 's/ / -w/g')"
 412       COMPREPLY=($(compgen -W "${workload_profile_var}" -- ${cur}))
 413       return 0
 414       ;;
 415
 416     -n*)
 417       local kernel_accel_var="$(echo -n "-n ${KERNEL_ACCEL}" | sed 's/ / -n/g')"
 418       COMPREPLY=($(compgen -W "${kernel_accel_var}" -- ${cur}))
 419       return 0
 420       ;;
 421
 422     -u*)
 423       local kernel_loops_var="$(echo -n "-u ${KERNEL_LOOPS}" | sed 's/ / -u/g')"
 424       COMPREPLY=($(compgen -W "${kernel_loops_var}" -- ${cur}))
 425       return 0
 426       ;;
 427
 428     -o*)
 429       local outfile_var=$(ls -d ${cur:2}* 2> /dev/null | grep -Eiv '*\.('${HIDDEN_FILES_AGGRESIVE}')' 2> /dev/null)
 430       outfile_var="$(echo -e "\n${outfile_var}" | sed 's/^/-o/g')"
 431       COMPREPLY=($(compgen -W "${outfile_var}" -- ${cur}))
 432       return 0
 433       ;;
 434
 435     -r*)
 436       local outfile_var=$(ls -d ${cur:2}* 2> /dev/null | grep -Eiv '*\.('${HIDDEN_FILES_AGGRESIVE}')' 2> /dev/null)
 437       outfile_var="$(echo -e "\n${outfile_var}" | sed 's/^/-r/g')"
 438       COMPREPLY=($(compgen -W "${outfile_var}" -- ${cur}))
 439       return 0
 440       ;;
 441
 442     -d*)
 443       _oclHashcat_opencl_devices
 444       local num_devices=${?}
 445
 446       _oclHashcat_get_permutations ${num_devices}
 447
 448       local opencl_devices_var="$(echo "  "${oclHashcat_devices_permutation} | sed 's/ / -d/g')"
 449       COMPREPLY=($(compgen -W "${opencl_devices_var}" -- ${cur}))
 450       return 0
 451       ;;
 452   esac
 453
 454   # Complete options/switches (not the arguments)
 455
 456   if [[ "${cur}" == -* ]]; then
 457
 458       COMPREPLY=($(compgen -W "${SHORT_OPTS} ${LONG_OPTS}" -- ${cur}))
 459       return 0
 460
 461   fi
 462
 463   # additional parameter, no switch nor option but maybe hash file, dictionary, mask, directory
 464
 465   # check if first option out of (hash.txt and dictionary|mask|directory)
 466   # is first option iff: here
 467   # 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!)
 468
 469   local h=1
 470   local no_opts=0
 471   local attack_mode=0 # also default of oclHashcat
 472   local has_charset_1=0
 473   local has_charset_2=0
 474   local has_charset_3=0
 475   local has_charset_4=0
 476
 477   while [ ${h} -le ${COMP_CWORD} ]; do
 478
 479     if   [[ "${COMP_WORDS[h]}" == "-a" ]]; then
 480
 481       attack_mode=${COMP_WORDS[$((h + 1))]}
 482
 483     elif   [[ "${COMP_WORDS[h]}" == -a* ]]; then
 484
 485       attack_mode=${COMP_WORDS[h]:2}
 486
 487     elif [[ "${COMP_WORDS[h]}" == "--attack-mode" ]]; then
 488
 489       attack_mode=${COMP_WORDS[$((h + 1))]}
 490
 491     elif [[ "${COMP_WORDS[h]}" == "-1" ]]; then
 492
 493       has_charset_1=1
 494
 495     elif [[ "${COMP_WORDS[h]}" == "--custom-charset1" ]]; then
 496
 497       has_charset_1=1
 498
 499     elif [[ "${COMP_WORDS[h]}" == "-2" ]]; then
 500
 501       has_charset_2=1
 502
 503     elif [[ "${COMP_WORDS[h]}" == "--custom-charset2" ]]; then
 504
 505       has_charset_2=1
 506
 507     elif [[ "${COMP_WORDS[h]}" == "-3" ]]; then
 508
 509       has_charset_3=1
 510
 511     elif [[ "${COMP_WORDS[h]}" == "--custom-charset3" ]]; then
 512
 513       has_charset_3=1
 514
 515     elif [[ "${COMP_WORDS[h]}" == "-4" ]]; then
 516
 517       has_charset_4=1
 518
 519     elif [[ "${COMP_WORDS[h]}" == "--custom-charset4" ]]; then
 520
 521       has_charset_4=1
 522
 523     fi
 524
 525     if _oclHashcat_contains "${OPTIONS}" "${COMP_WORDS[h]}"; then
 526
 527       h=$((h + 2))
 528
 529     else
 530
 531       if ! _oclHashcat_contains "${LONG_OPTS}${SHORT_OPTS}" "${COMP_WORDS[h]}"; then
 532         local variants="-m -a -w -n -u -o -r -d"
 533         local skip=0
 534         local v
 535         for v in ${variants}; do
 536
 537           if [[ "${COMP_WORDS[h]:0:2}" == "${v}" ]]; then
 538             skip=1
 539           fi
 540
 541         done
 542
 543         if [ "${skip}" -eq 0 ]; then
 544
 545           no_opts=$((no_opts + 1))
 546
 547         fi
 548       fi
 549
 550       h=$((h + 1))
 551
 552     fi
 553
 554   done
 555
 556   case "${no_opts}" in
 557
 558     0)
 559       return 0
 560       ;;
 561
 562     1)
 563       local files=$(ls -d ${cur}* 2> /dev/null | grep -Eiv '*\.('${HIDDEN_FILES_AGGRESIVE}')' 2> /dev/null)
 564       COMPREPLY=($(compgen -W "${files}" -- ${cur}))
 565       return 0
 566       ;;
 567
 568     *)
 569       case "${attack_mode}" in
 570
 571         0)
 572           # dict/directory are files here
 573           local files=$(ls -d ${cur}* 2> /dev/null | grep -Eiv '*\.('${HIDDEN_FILES_AGGRESIVE}')' 2> /dev/null)
 574           COMPREPLY=($(compgen -W "${files}" -- ${cur}))
 575           return 0
 576           ;;
 577
 578         1)
 579           if [ "${no_opts}" -gt 4 ]; then
 580             return 0
 581           fi
 582
 583           local files=$(ls -d ${cur}* 2> /dev/null | grep -Eiv '*\.('${HIDDEN_FILES_AGGRESIVE}')' 2> /dev/null)
 584           COMPREPLY=($(compgen -W "${files}" -- ${cur}))
 585           return 0
 586           ;;
 587
 588         3)
 589           if [ "${no_opts}" -eq 2 ]; then
 590             local mask=${BUILD_IN_CHARSETS}
 591
 592             if [ "${has_charset_1}" -eq 1 ]; then
 593
 594               mask="${mask} ?1"
 595
 596             fi
 597
 598             if [ "${has_charset_2}" -eq 1 ]; then
 599
 600               mask="${mask} ?2"
 601
 602             fi
 603
 604             if [ "${has_charset_3}" -eq 1 ]; then
 605
 606               mask="${mask} ?3"
 607
 608             fi
 609
 610             if [ "${has_charset_4}" -eq 1 ]; then
 611
 612               mask="${mask} ?4"
 613
 614             fi
 615
 616             if [ -e "${cur}" ]; then # should be hcmask file (but not enforced)
 617
 618               COMPREPLY=($(compgen -W "${cur}" -- ${cur}))
 619               return 0
 620
 621             fi
 622
 623             if [ -n "${cur}" ]; then
 624
 625               local cur_var=$(echo "${cur}" | sed 's/\?$//')
 626
 627               mask="${mask} ${cur_var}"
 628
 629               local h
 630               for h in ${mask}; do
 631
 632                   mask="${mask} ${cur_var}${h}"
 633
 634               done
 635             fi
 636
 637             local files=$(ls -d ${cur}* 2> /dev/null | grep -Eiv '*\.('${HIDDEN_FILES}')' 2> /dev/null)
 638
 639             mask="${mask} ${files}"
 640
 641             COMPREPLY=($(compgen -W "${mask}" -- ${cur}))
 642             return 0
 643           fi
 644           ;;
 645
 646         6)
 647           if [ "${no_opts}" -eq 2 ]; then
 648
 649             local files=$(ls -d ${cur}* 2> /dev/null | grep -Eiv '*\.('${HIDDEN_FILES_AGGRESIVE}')' 2> /dev/null)
 650             COMPREPLY=($(compgen -W "${files}" -- ${cur}))
 651
 652           elif [ "${no_opts}" -eq 3 ]; then
 653             local mask=${BUILD_IN_CHARSETS}
 654
 655             if [ "${has_charset_1}" -eq 1 ]; then
 656
 657               mask="${mask} ?1"
 658
 659             fi
 660
 661             if [ "${has_charset_2}" -eq 1 ]; then
 662
 663               mask="${mask} ?2"
 664
 665             fi
 666
 667             if [ "${has_charset_3}" -eq 1 ]; then
 668
 669               mask="${mask} ?3"
 670
 671             fi
 672
 673             if [ "${has_charset_4}" -eq 1 ]; then
 674
 675               mask="${mask} ?4"
 676
 677             fi
 678
 679             if [ -e "${cur}" ]; then # should be hcmask file (but not enforced)
 680
 681               COMPREPLY=($(compgen -W "${cur}" -- ${cur}))
 682               return 0
 683
 684             fi
 685
 686             if [ -n "${cur}" ]; then
 687
 688               local cur_var=$(echo "${cur}" | sed 's/\?$//')
 689
 690               mask="${mask} ${cur_var}"
 691
 692               local h
 693               for h in ${mask}; do
 694
 695                   mask="${mask} ${cur_var}${h}"
 696
 697               done
 698             fi
 699
 700             local files=$(ls -d ${cur}* 2> /dev/null | grep -Eiv '*\.('${HIDDEN_FILES}')' 2> /dev/null)
 701
 702             mask="${mask} ${files}"
 703
 704             COMPREPLY=($(compgen -W "${mask}" -- ${cur}))
 705             return 0
 706
 707           fi
 708           ;;
 709
 710         7)
 711           if [ "${no_opts}" -eq 2 ]; then
 712             local mask=${BUILD_IN_CHARSETS}
 713
 714             if [ "${has_charset_1}" -eq 1 ]; then
 715
 716               mask="${mask} ?1"
 717
 718             fi
 719
 720             if [ "${has_charset_2}" -eq 1 ]; then
 721
 722               mask="${mask} ?2"
 723
 724             fi
 725
 726             if [ "${has_charset_3}" -eq 1 ]; then
 727
 728               mask="${mask} ?3"
 729
 730             fi
 731
 732             if [ "${has_charset_4}" -eq 1 ]; then
 733
 734               mask="${mask} ?4"
 735
 736             fi
 737
 738             if [ -e "${cur}" ]; then # should be hcmask file (but not enforced)
 739
 740               COMPREPLY=($(compgen -W "${cur}" -- ${cur}))
 741               return 0
 742
 743             fi
 744
 745             if [ -n "${cur}" ]; then
 746
 747               local cur_var=$(echo "${cur}" | sed 's/\?$//')
 748
 749               mask="${mask} ${cur_var}"
 750
 751               local h
 752               for h in ${mask}; do
 753
 754                   mask="${mask} ${cur_var}${h}"
 755
 756               done
 757             fi
 758
 759             local files=$(ls -d ${cur}* 2> /dev/null | grep -Eiv '*\.('${HIDDEN_FILES}')' 2> /dev/null)
 760
 761             mask="${mask} ${files}"
 762
 763             COMPREPLY=($(compgen -W "${mask}" -- ${cur}))
 764             return 0
 765
 766           elif [ "${no_opts}" -eq 3 ]; then
 767
 768             local files=$(ls -d ${cur}* 2> /dev/null | grep -Eiv '*\.('${HIDDEN_FILES_AGGRESIVE}')' 2> /dev/null)
 769             COMPREPLY=($(compgen -W "${files}" -- ${cur}))
 770             return
 771
 772           fi
 773           ;;
 774
 775       esac
 776
 777     esac
 778 }
 779
 780 complete -F _oclHashcat -o filenames "${OCLHASHCAT_ROOT}"/oclHashcat64.bin "${OCLHASHCAT_ROOT}"/oclHashcat32.bin "${OCLHASHCAT_ROOT}"/oclHashcat oclHashcat