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