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=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 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"
 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 KERNEL_ACCEL="1 8 16 24 32 40 48 56 64 62 80 88 96 104 112 120 128 136 144 152 160"
 181   local KERNEL_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 --opencl-devices --opencl-platform --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"
 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 --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-platform --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"
 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|--kernel-accel)
 237       COMPREPLY=($(compgen -W "${KERNEL_ACCEL}" -- ${cur}))
 238       return 0
 239       ;;
 240
 241     -u|--kernel-loops)
 242       COMPREPLY=($(compgen -W "${KERNEL_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|--opencl-devices)
 259       _oclHashcat_opencl_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       --weak-hash-threshold|--outfile-check-timer|--outfile-check-dir|--induction-dir|--scrypt-tmto)
 334       return 0
 335       ;;
 336
 337     --debug-mode)
 338       COMPREPLY=($(compgen -W "${DEBUG_MODE}" -- ${cur}))
 339       return 0
 340       ;;
 341
 342     --truecrypt-keyfiles)
 343       # first: remove the quotes such that file matching is possible
 344
 345       local cur_part0=$(echo "${cur}" | grep -Eo '^("|'"'"')')
 346
 347       local cur_mod=$(echo "${cur}" | sed 's/^["'"'"']//')
 348       local cur_part1=$(echo "${cur_mod}" | grep ',' 2> /dev/null | sed 's/^\(.*, *\)[^,]*$/\1/')
 349       local cur_part2=$(echo "${cur_mod}" | sed 's/^.*, *\([^,]*\)$/\1/')
 350
 351       # generate lines with the file name and a duplicate of it with a comma at the end
 352
 353       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}/")
 354       COMPREPLY=($(compgen -W "${files}" -- ${cur}))
 355       return 0
 356
 357   esac
 358
 359   # allow also the VARIANTS w/o spaces
 360   # we could use compgen -P prefix, but for some reason it doesn't seem to work always
 361
 362   case "$cur" in
 363
 364     -m*)
 365       local hash_modes_var="$(echo -n "-m ${HASH_MODES}" | sed 's/ / -m/g')"
 366       COMPREPLY=($(compgen -W "${hash_modes_var}" -- ${cur}))
 367       return 0
 368       ;;
 369
 370     -a*)
 371       local attack_modes_var="$(echo -n "-a ${ATTACK_MODES}" | sed 's/ / -a/g')"
 372       COMPREPLY=($(compgen -W "${attack_modes_var}" -- ${cur}))
 373       return 0
 374       ;;
 375
 376     -w*)
 377       local workload_profile_var="$(echo -n "-w ${WORKLOAD_PROFILE}" | sed 's/ / -w/g')"
 378       COMPREPLY=($(compgen -W "${workload_profile_var}" -- ${cur}))
 379       return 0
 380       ;;
 381
 382     -n*)
 383       local kernel_accel_var="$(echo -n "-n ${KERNEL_ACCEL}" | sed 's/ / -n/g')"
 384       COMPREPLY=($(compgen -W "${kernel_accel_var}" -- ${cur}))
 385       return 0
 386       ;;
 387
 388     -u*)
 389       local kernel_loops_var="$(echo -n "-u ${KERNEL_LOOPS}" | sed 's/ / -u/g')"
 390       COMPREPLY=($(compgen -W "${kernel_loops_var}" -- ${cur}))
 391       return 0
 392       ;;
 393
 394     -o*)
 395       local outfile_var=$(ls -d ${cur:2}* 2> /dev/null | grep -Eiv '*\.('${HIDDEN_FILES_AGGRESIVE}')' 2> /dev/null)
 396       outfile_var="$(echo -e "\n${outfile_var}" | sed 's/^/-o/g')"
 397       COMPREPLY=($(compgen -W "${outfile_var}" -- ${cur}))
 398       return 0
 399       ;;
 400
 401     -r*)
 402       local outfile_var=$(ls -d ${cur:2}* 2> /dev/null | grep -Eiv '*\.('${HIDDEN_FILES_AGGRESIVE}')' 2> /dev/null)
 403       outfile_var="$(echo -e "\n${outfile_var}" | sed 's/^/-r/g')"
 404       COMPREPLY=($(compgen -W "${outfile_var}" -- ${cur}))
 405       return 0
 406       ;;
 407
 408     -d*)
 409       _oclHashcat_opencl_devices
 410       local num_devices=${?}
 411
 412       _oclHashcat_get_permutations ${num_devices}
 413
 414       local opencl_devices_var="$(echo "  "${oclHashcat_devices_permutation} | sed 's/ / -d/g')"
 415       COMPREPLY=($(compgen -W "${opencl_devices_var}" -- ${cur}))
 416       return 0
 417       ;;
 418   esac
 419
 420   # Complete options/switches (not the arguments)
 421
 422   if [[ "${cur}" == -* ]]; then
 423
 424       COMPREPLY=($(compgen -W "${SHORT_OPTS} ${LONG_OPTS}" -- ${cur}))
 425       return 0
 426
 427   fi
 428
 429   # additional parameter, no switch nor option but maybe hash file, dictionary, mask, directory
 430
 431   # check if first option out of (hash.txt and dictionary|mask|directory)
 432   # is first option iff: here
 433   # 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!)
 434
 435   local h=1
 436   local no_opts=0
 437   local attack_mode=0 # also default of oclHashcat
 438   local has_charset_1=0
 439   local has_charset_2=0
 440   local has_charset_3=0
 441   local has_charset_4=0
 442
 443   while [ ${h} -le ${COMP_CWORD} ]; do
 444
 445     if   [[ "${COMP_WORDS[h]}" == "-a" ]]; then
 446
 447       attack_mode=${COMP_WORDS[$((h + 1))]}
 448
 449     elif   [[ "${COMP_WORDS[h]}" == -a* ]]; then
 450
 451       attack_mode=${COMP_WORDS[h]:2}
 452
 453     elif [[ "${COMP_WORDS[h]}" == "--attack-mode" ]]; then
 454
 455       attack_mode=${COMP_WORDS[$((h + 1))]}
 456
 457     elif [[ "${COMP_WORDS[h]}" == "-1" ]]; then
 458
 459       has_charset_1=1
 460
 461     elif [[ "${COMP_WORDS[h]}" == "--custom-charset1" ]]; then
 462
 463       has_charset_1=1
 464
 465     elif [[ "${COMP_WORDS[h]}" == "-2" ]]; then
 466
 467       has_charset_2=1
 468
 469     elif [[ "${COMP_WORDS[h]}" == "--custom-charset2" ]]; then
 470
 471       has_charset_2=1
 472
 473     elif [[ "${COMP_WORDS[h]}" == "-3" ]]; then
 474
 475       has_charset_3=1
 476
 477     elif [[ "${COMP_WORDS[h]}" == "--custom-charset3" ]]; then
 478
 479       has_charset_3=1
 480
 481     elif [[ "${COMP_WORDS[h]}" == "-4" ]]; then
 482
 483       has_charset_4=1
 484
 485     elif [[ "${COMP_WORDS[h]}" == "--custom-charset4" ]]; then
 486
 487       has_charset_4=1
 488
 489     fi
 490
 491     if _oclHashcat_contains "${OPTIONS}" "${COMP_WORDS[h]}"; then
 492
 493       h=$((h + 2))
 494
 495     else
 496
 497       if ! _oclHashcat_contains "${LONG_OPTS}${SHORT_OPTS}" "${COMP_WORDS[h]}"; then
 498         local variants="-m -a -w -n -u -o -r -d"
 499         local skip=0
 500         local v
 501         for v in ${variants}; do
 502
 503           if [[ "${COMP_WORDS[h]:0:2}" == "${v}" ]]; then
 504             skip=1
 505           fi
 506
 507         done
 508
 509         if [ "${skip}" -eq 0 ]; then
 510
 511           no_opts=$((no_opts + 1))
 512
 513         fi
 514       fi
 515
 516       h=$((h + 1))
 517
 518     fi
 519
 520   done
 521
 522   case "${no_opts}" in
 523
 524     0)
 525       return 0
 526       ;;
 527
 528     1)
 529       local files=$(ls -d ${cur}* 2> /dev/null | grep -Eiv '*\.('${HIDDEN_FILES_AGGRESIVE}')' 2> /dev/null)
 530       COMPREPLY=($(compgen -W "${files}" -- ${cur}))
 531       return 0
 532       ;;
 533
 534     *)
 535       case "${attack_mode}" in
 536
 537         0)
 538           # dict/directory are files here
 539           local files=$(ls -d ${cur}* 2> /dev/null | grep -Eiv '*\.('${HIDDEN_FILES_AGGRESIVE}')' 2> /dev/null)
 540           COMPREPLY=($(compgen -W "${files}" -- ${cur}))
 541           return 0
 542           ;;
 543
 544         1)
 545           if [ "${no_opts}" -gt 4 ]; then
 546             return 0
 547           fi
 548
 549           local files=$(ls -d ${cur}* 2> /dev/null | grep -Eiv '*\.('${HIDDEN_FILES_AGGRESIVE}')' 2> /dev/null)
 550           COMPREPLY=($(compgen -W "${files}" -- ${cur}))
 551           return 0
 552           ;;
 553
 554         3)
 555           if [ "${no_opts}" -eq 2 ]; then
 556             local mask=${BUILD_IN_CHARSETS}
 557
 558             if [ "${has_charset_1}" -eq 1 ]; then
 559
 560               mask="${mask} ?1"
 561
 562             fi
 563
 564             if [ "${has_charset_2}" -eq 1 ]; then
 565
 566               mask="${mask} ?2"
 567
 568             fi
 569
 570             if [ "${has_charset_3}" -eq 1 ]; then
 571
 572               mask="${mask} ?3"
 573
 574             fi
 575
 576             if [ "${has_charset_4}" -eq 1 ]; then
 577
 578               mask="${mask} ?4"
 579
 580             fi
 581
 582             if [ -e "${cur}" ]; then # should be hcmask file (but not enforced)
 583
 584               COMPREPLY=($(compgen -W "${cur}" -- ${cur}))
 585               return 0
 586
 587             fi
 588
 589             if [ -n "${cur}" ]; then
 590
 591               local cur_var=$(echo "${cur}" | sed 's/\?$//')
 592
 593               mask="${mask} ${cur_var}"
 594
 595               local h
 596               for h in ${mask}; do
 597
 598                   mask="${mask} ${cur_var}${h}"
 599
 600               done
 601             fi
 602
 603             local files=$(ls -d ${cur}* 2> /dev/null | grep -Eiv '*\.('${HIDDEN_FILES}')' 2> /dev/null)
 604
 605             mask="${mask} ${files}"
 606
 607             COMPREPLY=($(compgen -W "${mask}" -- ${cur}))
 608             return 0
 609           fi
 610           ;;
 611
 612         6)
 613           if [ "${no_opts}" -eq 2 ]; then
 614
 615             local files=$(ls -d ${cur}* 2> /dev/null | grep -Eiv '*\.('${HIDDEN_FILES_AGGRESIVE}')' 2> /dev/null)
 616             COMPREPLY=($(compgen -W "${files}" -- ${cur}))
 617
 618           elif [ "${no_opts}" -eq 3 ]; then
 619             local mask=${BUILD_IN_CHARSETS}
 620
 621             if [ "${has_charset_1}" -eq 1 ]; then
 622
 623               mask="${mask} ?1"
 624
 625             fi
 626
 627             if [ "${has_charset_2}" -eq 1 ]; then
 628
 629               mask="${mask} ?2"
 630
 631             fi
 632
 633             if [ "${has_charset_3}" -eq 1 ]; then
 634
 635               mask="${mask} ?3"
 636
 637             fi
 638
 639             if [ "${has_charset_4}" -eq 1 ]; then
 640
 641               mask="${mask} ?4"
 642
 643             fi
 644
 645             if [ -e "${cur}" ]; then # should be hcmask file (but not enforced)
 646
 647               COMPREPLY=($(compgen -W "${cur}" -- ${cur}))
 648               return 0
 649
 650             fi
 651
 652             if [ -n "${cur}" ]; then
 653
 654               local cur_var=$(echo "${cur}" | sed 's/\?$//')
 655
 656               mask="${mask} ${cur_var}"
 657
 658               local h
 659               for h in ${mask}; do
 660
 661                   mask="${mask} ${cur_var}${h}"
 662
 663               done
 664             fi
 665
 666             local files=$(ls -d ${cur}* 2> /dev/null | grep -Eiv '*\.('${HIDDEN_FILES}')' 2> /dev/null)
 667
 668             mask="${mask} ${files}"
 669
 670             COMPREPLY=($(compgen -W "${mask}" -- ${cur}))
 671             return 0
 672
 673           fi
 674           ;;
 675
 676         7)
 677           if [ "${no_opts}" -eq 2 ]; then
 678             local mask=${BUILD_IN_CHARSETS}
 679
 680             if [ "${has_charset_1}" -eq 1 ]; then
 681
 682               mask="${mask} ?1"
 683
 684             fi
 685
 686             if [ "${has_charset_2}" -eq 1 ]; then
 687
 688               mask="${mask} ?2"
 689
 690             fi
 691
 692             if [ "${has_charset_3}" -eq 1 ]; then
 693
 694               mask="${mask} ?3"
 695
 696             fi
 697
 698             if [ "${has_charset_4}" -eq 1 ]; then
 699
 700               mask="${mask} ?4"
 701
 702             fi
 703
 704             if [ -e "${cur}" ]; then # should be hcmask file (but not enforced)
 705
 706               COMPREPLY=($(compgen -W "${cur}" -- ${cur}))
 707               return 0
 708
 709             fi
 710
 711             if [ -n "${cur}" ]; then
 712
 713               local cur_var=$(echo "${cur}" | sed 's/\?$//')
 714
 715               mask="${mask} ${cur_var}"
 716
 717               local h
 718               for h in ${mask}; do
 719
 720                   mask="${mask} ${cur_var}${h}"
 721
 722               done
 723             fi
 724
 725             local files=$(ls -d ${cur}* 2> /dev/null | grep -Eiv '*\.('${HIDDEN_FILES}')' 2> /dev/null)
 726
 727             mask="${mask} ${files}"
 728
 729             COMPREPLY=($(compgen -W "${mask}" -- ${cur}))
 730             return 0
 731
 732           elif [ "${no_opts}" -eq 3 ]; then
 733
 734             local files=$(ls -d ${cur}* 2> /dev/null | grep -Eiv '*\.('${HIDDEN_FILES_AGGRESIVE}')' 2> /dev/null)
 735             COMPREPLY=($(compgen -W "${files}" -- ${cur}))
 736             return
 737
 738           fi
 739           ;;
 740
 741       esac
 742
 743     esac
 744 }
 745
 746 complete -F _oclHashcat -o filenames "${OCLHASHCAT_ROOT}"/oclHashcat64.bin "${OCLHASHCAT_ROOT}"/oclHashcat32.bin "${OCLHASHCAT_ROOT}"/oclHashcat oclHashcat