Grey Repo

Files

setup.src cli/libfish.src cli/proxy.src cli/npcRshell.src cli/searchMails.src cli/hostImg.src src/machine.src src/img.html

setup.src

import_code("/home/me/h/libs/list.src")
import_code("/home/me/h/libs/disk.src")
import_code("/home/me/h/libs/passwords.src")
comp = get_shell.host_computer
print "setup hacking script"
comp.File("/home/me/h/src/tableAttack.src").copy(home_dir + "/Config", "tableAttack.src")
comp.File("/home/me/h/src/rserverInstaller.src").copy(home_dir + "/Config", "rserverInstaller.src")
print "compiling cli tools"
if comp.File(home_dir + "/vegaTools") then comp.File(home_dir + "/vegaTools").delete
comp.File("/home/me/h/cli").copy(home_dir, "vegaTools")
for f in comp.File(home_dir + "/vegaTools").get_files
get_shell.build(home_dir + "/vegaTools/" + f.name, home_dir + "/vegaTools")
f.delete
end for
Disk.init("/home/me/Config", "passwords")
// setup passwords db
if Disk.read_chars.len > 0 then exit
if(Disk.blobs.len > 1) then exit("password generation setup already completed")
PasswordGenerator.init(PASSWORDS)
print "generating passwords, it will take a while"
HASH_TABLE=PasswordGenerator.AllPasswords
print "done"
print "parsing passwords obj"
f = function(o)
return o[1]
end function
pass_list = HASH_TABLE.to_list.map(@f)
print "done"
print "writing to disk"
Disk.write(pass_list.join(char(10)))
print "done"

cli/libfish.src

import_code("/home/me/h/src/utils.src") // exports map.inspect, p
import_code("/home/me/h/libs/list.src") // exports list utils and map utils
import_code("/home/me/h/libs/disk.src") // exports Disk, Block
import_code("/home/me/h/libs/nmap.src") // exports Nmap, Service
import_code("/home/me/h/libs/scan.src") // exports Scan
import_code("/home/me/h/libs/json.src") // exports Json
import_code("/home/me/h/src/rndIP.src") // exports rnd_ip
import_code("/home/me/h/src/machine.src") // exports Machine, MachineService, depends on Scan, Nmap , Json
import_code("/home/me/h/libs/meta.src") // exports Meta
import_code("/home/me/h/src/shell.src") // extend map
TABLEATTACK_SCRIPT = get_shell.host_computer.File(home_dir + "/Config/tableAttack.src")
EMPTY_LOG_PATH = home_dir + "/Config/emptyLog"
PASSWORDS_DISK = new Disk
PASSWORDS_DISK.init(home_dir + "/Config", "passwords")
EXPLOITS_DISK = new Disk
EXPLOITS_DISK.init(home_dir + "/Config", "exploits")
ENTRIES_DISK = new Disk
ENTRIES_DISK.init(home_dir + "/Config", "entries")
LIB_STORE_PATH = home_dir + "/Config/libs"
Machine.metaxploit = include_lib("/lib/metaxploit.so")
Scan.metaxploit = include_lib("/lib/metaxploit.so")
Command = {}
Command.libfish_sig = {}
Command.libfish_sig["description"] = "hack random npcs to find libs"
lib_param_desc = []
lib_param_desc.push "libs to search for, if this param is present the command will only search for the specific libs passed "
lib_param_desc.push "but you can pass as many lib names as you want, the valid params are: "
lib_param_desc.push Service.lib_dict.indexes.join(", ")
lib_param_desc = lib_param_desc.join("")
Command.libfish_sig["args"] = [["lib", lib_param_desc]]
Command.libfish_sig["options"] = []
Command.libfish = function(args = [], options = {})
if args.len > 0 then
for arg in args
if Service.lib_dict.hasIndex(arg) == 0 then exit("invalid param, look at the docs")
end for
for i in Service.lib_dict.indexes
if args.indexOf(i) == null then Service.lib_dict.remove(i)
end for
end if
while true
machine = new Machine
~~machine.init(rnd_ip, PASSWORDS_DISK, EXPLOITS_DISK)~~
machine.init(rnd_ip, PASSWORDS_DISK, EXPLOITS_DISK, ENTRIES_DISK)
for s in machine.services
known_libs = get_shell.host_computer.File(LIB_STORE_PATH).get_files
for i in known_libs.indexes
known_libs[i] = known_libs[i].name
end for
s.set_exploits
if not Service.lib_dict.hasIndex(s.info.split(" ")[0]) then continue
key = s.info.replace(".", "").replace(" ", "")
if known_libs.indexOf(key) then continue
so_name = Service.lib_dict[s.info.split(" ")[0]]
sh = s.quick_root_shell(TABLEATTACK_SCRIPT)
if typeof(sh) != "shell" then continue
sh.scp("/lib/" + so_name, LIB_STORE_PATH, get_shell)
sh.clear_logs(EMPTY_LOG_PATH)
get_shell.host_computer.File(LIB_STORE_PATH + "/" + so_name).rename(key)
end for
end while
end function
import_code("/home/me/h/libs/thor.src") //depends on Listlib, exports Thor
Thor.init(Command, "libfish")

cli/proxy.src

import_code("/home/me/h/src/utils.src") // exports map.inspect, p
import_code("/home/me/h/libs/list.src") // exports list utils and map utils
import_code("/home/me/h/libs/disk.src") // exports Disk, Block
import_code("/home/me/h/libs/nmap.src") // exports Nmap, Service
import_code("/home/me/h/libs/scan.src") // exports Scan
import_code("/home/me/h/libs/json.src") // exports Json
import_code("/home/me/h/src/rndIP.src") // exports rnd_ip
import_code("/home/me/h/libs/optionSelector.src") // exports option_selector
import_code("/home/me/h/src/machine.src") // exports Machine, MachineService, depends on Scan, Nmap , Json
import_code("/home/me/h/libs/meta.src") // exports Meta
import_code("/home/me/h/src/shell.src") // extend map
TABLEATTACK_SCRIPT = get_shell.host_computer.File(home_dir + "/Config/tableAttack.src")
EMPTY_LOG_PATH = home_dir + "/Config/emptyLog"
PASSWORDS_DISK = new Disk
PASSWORDS_DISK.init(home_dir + "/Config", "passwords")
EXPLOITS_DISK = new Disk
EXPLOITS_DISK.init(home_dir + "/Config", "exploits")
ENTRIES_DISK = new Disk
ENTRIES_DISK.init(home_dir + "/Config", "entries")
Machine.metaxploit = include_lib("/lib/metaxploit.so")
Scan.metaxploit = include_lib("/lib/metaxploit.so")
get_shell.host_computer.touch(home_dir + "/Config", "proxy.txt")
PROXY_FILE = get_shell.host_computer.File(home_dir + "/Config/proxy.txt")
Command = {}
Command.proxy_sig = {}
Command.proxy_sig["description"] = "hack a random router to use to hide you ip"
Command.proxy_sig["args"] = []
Command.proxy_sig["options"] = [{["-w", "--wipe"]: "wipe the server logs instead of connecting"}]
Command.proxy = function(args = [], options = {})
re_hack = function(ip)
machine = new Machine
~~machine.init(ip, PASSWORDS_DISK, EXPLOITS_DISK)~~
machine.init(ip, PASSWORDS_DISK, EXPLOITS_DISK, ENTRIES_DISK)
root_shell = machine.quick_attack(true, TABLEATTACK_SCRIPT)
if root_shell == null then exit("could not reconnect")
root_shell.clear_logs(EMPTY_LOG_PATH)
if options["-w"] then exit
root_shell.start_terminal
end function
proxies = PROXY_FILE.get_content.split(char(10)).compact
if proxies.len > 0 then
print "you arealdy have hacked proxies, do you want to reuse them?" + char(10)
for i in proxies.indexes
proxies[i] = [@re_hack, proxies[i], proxies[i]]
end for
proxies.push ["return", null, "hack a new one"]
option_selector proxies
end if
while true
machine = new Machine
~~machine.init(rnd_ip, PASSWORDS_DISK, EXPLOITS_DISK)~~
machine.init(rnd_ip, PASSWORDS_DISK, EXPLOITS_DISK, ENTRIES_DISK)
root_shell = machine.quick_attack(true, TABLEATTACK_SCRIPT)
if root_shell == null then continue
PROXY_FILE.set_content(PROXY_FILE.get_content + char(10) + machine.ip)
machine.save_exploits
root_shell.clear_logs(EMPTY_LOG_PATH)
root_shell.start_terminal
end while
end function
import_code("/home/me/h/libs/thor.src") //depends on Listlib, exports Thor
Thor.init(Command, "proxy")

cli/npcRshell.src

import_code("/home/me/h/src/utils.src") // exports map.inspect, p
import_code("/home/me/h/libs/list.src") // exports list utils and map utils
import_code("/home/me/h/libs/disk.src") // exports Disk, Block
import_code("/home/me/h/libs/nmap.src") // exports Nmap, Service
import_code("/home/me/h/libs/scan.src") // exports Scan
import_code("/home/me/h/libs/json.src") // exports Json
import_code("/home/me/h/src/rndIP.src") // exports rnd_ip
import_code("/home/me/h/libs/optionSelector.src") // exports option_selector
import_code("/home/me/h/src/machine.src") // exports Machine, MachineService, depends on Scan, Nmap , Json, rnd_ip
import_code("/home/me/h/src/shell.src") // extend map
TABLEATTACK_SCRIPT = get_shell.host_computer.File(home_dir + "/Config/tableAttack.src")
EMPTY_LOG_PATH = home_dir + "/Config/emptyLog"
RSERVER_INSTALLER_SCRIPT = get_shell.host_computer.File(home_dir + "/Config/rserverInstaller.src")
PASSWORDS_DISK = new Disk
PASSWORDS_DISK.init(home_dir + "/Config", "passwords")
EXPLOITS_DISK = new Disk
EXPLOITS_DISK.init(home_dir + "/Config", "exploits")
ENTRIES_DISK = new Disk
ENTRIES_DISK.init(home_dir + "/Config", "entries")
Machine.metaxploit = include_lib("/lib/metaxploit.so")
Scan.metaxploit = include_lib("/lib/metaxploit.so")
get_shell.host_computer.touch(home_dir + "/Config", "rservers.txt")
RSERVERS_FILE = get_shell.host_computer.File(home_dir + "/Config/rservers.txt")
Command = {}
Command.npcRsrv_sig = {}
Command.npcRsrv_sig["description"] = "hack a random pc and setup rshell server in it"
Command.npcRsrv_sig["args"] = []
Command.npcRsrv_sig["options"] = [{["-w", "--wipe"]: "wipe the server logs instead of connecting"}]
Command.npcRsrv = function(args = [], options = {})
re_hack = function(s)
ip = s.split(":")[0]
port = s.split(":")[1].to_int
machine = new Machine
~~machine.init(ip, PASSWORDS_DISK, EXPLOITS_DISK)~~
machine.init(ip, PASSWORDS_DISK, EXPLOITS_DISK, ENTRIES_DISK)
server_service = null
for s in machine.services
if s.port == port then server_service = s
end for
server_service.set_exploits
server_shell = server_service.quick_root_shell(TABLEATTACK_SCRIPT)
router_shell = machine.router_service
router_shell.set_exploits
router_shell = router_shell.quick_root_shell(TABLEATTACK_SCRIPT)
router_shell.clear_logs(EMPTY_LOG_PATH)
server_shell.clear_logs(EMPTY_LOG_PATH)
if options["-w"] then exit
server_shell.start_terminal
end function
rservers = RSERVERS_FILE.get_content.split(char(10)).compact
if rservers.len > 0 then
print "you arealdy have hacked rservers, do you want to reuse them?" + char(10)
for i in rservers.indexes
rservers[i] = [@re_hack, rservers[i], rservers[i]]
end for
rservers.push ["return", null, "hack a new one"]
option_selector rservers
end if
while true
machine = new Machine
~~machine.init(rnd_ip, PASSWORDS_DISK, EXPLOITS_DISK)~~
machine.init(rnd_ip, PASSWORDS_DISK, EXPLOITS_DISK, ENTRIES_DISK)
if machine.open_services.len == 0 then continue
server_shell = null
server_port = null
for s in machine.open_services
s.set_exploits
shell = s.quick_root_shell(TABLEATTACK_SCRIPT)
if shell != null then
server_shell = shell
server_port = s.port
break
end if
end for
if server_shell == null then continue
server_shell.clear_logs(EMPTY_LOG_PATH)
router_shell = machine.router_service
router_shell.set_exploits
router_shell = router_shell.quick_root_shell(TABLEATTACK_SCRIPT)
if router_shell == null then continue
router_shell.clear_logs(EMPTY_LOG_PATH)
machine.save_exploits
server_shell.install_rserver(RSERVER_INSTALLER_SCRIPT)
RSERVERS_FILE.set_content(RSERVERS_FILE.get_content + char(10) + machine.ip + ":" + server_port)
server_shell.start_terminal
end while
end function
import_code("/home/me/h/libs/thor.src") //depends on Listlib, exports Thor
Thor.init(Command, "npcRsrv")

cli/searchMails.src

import_code("/home/me/h/src/utils.src") // exports map.inspect, p
import_code("/home/me/h/libs/list.src") // exports list utils and map utils
import_code("/home/me/h/libs/disk.src") // exports Disk, Block
import_code("/home/me/h/libs/nmap.src") // exports Nmap, Service
import_code("/home/me/h/libs/scan.src") // exports Scan
import_code("/home/me/h/libs/json.src") // exports Json
import_code("/home/me/h/src/rndIP.src") // exports rnd_ip
import_code("/home/me/h/libs/optionSelector.src") // exports option_selector
import_code("/home/me/h/src/machine.src") // exports Machine, MachineService, depends on Scan, Nmap , Json, rnd_ip
import_code("/home/me/h/src/shell.src") // extend map
TABLEATTACK_SCRIPT = get_shell.host_computer.File(home_dir + "/Config/tableAttack.src")
EMPTY_LOG_PATH = home_dir + "/Config/emptyLog"
PASSWORDS_DISK = new Disk
PASSWORDS_DISK.init(home_dir + "/Config", "passwords")
EXPLOITS_DISK = new Disk
EXPLOITS_DISK.init(home_dir + "/Config", "exploits")
ENTRIES_DISK = new Disk
ENTRIES_DISK.init(home_dir + "/Config", "entries")
Machine.metaxploit = include_lib("/lib/metaxploit.so")
Scan.metaxploit = include_lib("/lib/metaxploit.so")
Command = {}
Command.searchMails_sig = {}
Command.searchMails_sig["description"] = "target router bounce exploits to get mails"
Command.searchMails_sig["args"] = ["ip*"]
Command.searchMails_sig["options"] = []
next_ip = function(ip)
numbers = ip.split(".")
numbers[-1] = numbers[-1].to_int + 1
return numbers.join(".")
end function
Command.searchMails = function(args = [], options = {})
machine = new Machine
~~machine.init(args[0], PASSWORDS_DISK, EXPLOITS_DISK)~~
machine.init(args[0], PASSWORDS_DISK, EXPLOITS_DISK, ENTRIES_DISK)
machine.scan_strategy = "scan_everytime"
router_ips = machine.nmap.router.devices_lan_ip
//p machine.router_service
p machine.router_service.info
// find computer bounce exploits
exploits = []
machine.router_service.set_exploits
for x in machine.router_service.exploits
for i in router_ips
x.set_result next_ip(i)
if typeof(x.result) == "computer" then
exploits.push x
break
end if
end for
end for
p exploits.inspect(["value", "address"])
// war dial ips
computers = []
for x in exploits
for ip in router_ips
for i in range(10)
ip = next_ip(ip)
x.set_result(ip)
if typeof(x.result) == "computer" then computers.push x.result
end for
end for
end for
creds = []
mails = []
banks = []
for c in computers
passwdfile = c.File("/etc/passwd")
if passwdfile.has_permission("r") then
passwdfile = passwdfile.get_content.replace(char(10), " from " + c.local_ip + char(10))
creds = passwdfile.split(char(10))
end if
for user_home in c.File("/home").get_folders
mail_file = c.File("/home/" + user_home.name + "/Config/Mail.txt")
bank_file = c.File("/home/" + user_home.name + "/Config/Bank.txt")
if mail_file then mails.push mail_file.get_content + " from " + c.local_ip
if bank_file then banks.push bank_file.get_content + " from " + c.local_ip
end for
end for
mails = mails.uniq
banks = banks.uniq
print "CREDENTIALS"
print creds.join(char(10))
print "BANKS"
print banks.join(char(10))
print "MAILS"
print mails.join(char(10))
end function
import_code("/home/me/h/libs/thor.src") //depends on Listlib, exports Thor
Thor.init(Command, "searchMails")

cli/hostImg.src

import_code("/home/me/h/src/utils.src") // exports map.inspect, p
import_code("/home/me/h/libs/list.src") // exports list utils and map utils
import_code("/home/me/h/libs/disk.src") // exports Disk, Block
import_code("/home/me/h/libs/nmap.src") // exports Nmap, Service
import_code("/home/me/h/libs/scan.src") // exports Scan
import_code("/home/me/h/libs/json.src") // exports Json
import_code("/home/me/h/src/rndIP.src") // exports rnd_ip
import_code("/home/me/h/libs/optionSelector.src") // exports option_selector
import_code("/home/me/h/src/machine.src") // exports Machine, MachineService, depends on Scan, Nmap , Json, rnd_ip
import_code("/home/me/h/src/shell.src") // extend map
TABLEATTACK_SCRIPT = get_shell.host_computer.File(home_dir + "/Config/tableAttack.src")
EMPTY_LOG_PATH = home_dir + "/Config/emptyLog"
PASSWORDS_DISK = new Disk
PASSWORDS_DISK.init(home_dir + "/Config", "passwords")
EXPLOITS_DISK = new Disk
EXPLOITS_DISK.init(home_dir + "/Config", "exploits")
ENTRIES_DISK = new Disk
ENTRIES_DISK.init(home_dir + "/Config", "entries")
Machine.metaxploit = include_lib("/lib/metaxploit.so")
Scan.metaxploit = include_lib("/lib/metaxploit.so")
get_shell.host_computer.touch(home_dir + "/Config", "sites.txt")
SITES_FILE = get_shell.host_computer.File(home_dir + "/Config/sites.txt")
Command = {}
Command.hostImg_sig = {}
Command.hostImg_sig["description"] = "hack a random site"
Command.hostImg_sig["args"] = []
Command.hostImg_sig["options"] = [{["-w", "--wipe"]: "wipe the server logs instead of connecting"}]
Command.hostImg = function(args = [], options = {})
re_hack = function(ip)
machine = new Machine
~~machine.init(ip, PASSWORDS_DISK, EXPLOITS_DISK)~~
machine.init(ip, PASSWORDS_DISK, EXPLOITS_DISK, ENTRIES_DISK)
site_service = null
for s in machine.services
if s.port == 80 then
site_service = s
end if
end for
site_service.set_exploits
site_shell = site_service.quick_root_shell(TABLEATTACK_SCRIPT)
site_shell.clear_logs(EMPTY_LOG_PATH)
router_shell = machine.router_service
router_shell.set_exploits
router_shell = router_shell.quick_root_shell(TABLEATTACK_SCRIPT)
router_shell.clear_logs(EMPTY_LOG_PATH)
if options["-w"] then exit
site_shell.start_terminal
end function
sites = SITES_FILE.get_content.split(char(10)).compact
if sites.len > 0 then
print "you arealdy have hacked proxies, do you want to reuse them?" + char(10)
for i in sites.indexes
sites[i] = [@re_hack, sites[i], sites[i]]
end for
sites.push ["return", null, "hack a new one"]
option_selector sites
end if
while true
machine = new Machine
machine.init(rnd_ip, PASSWORDS_DISK, EXPLOITS_DISK)
site_service = null
for s in machine.services
if s.port == 80 then
site_service = s
end if
end for
if not site_service then continue
site_service.set_exploits
site_shell = site_service.quick_root_shell(TABLEATTACK_SCRIPT)
if site_shell == null then continue
site_shell.clear_logs(EMPTY_LOG_PATH)
router_shell = machine.router_service
router_shell.set_exploits
router_shell = router_shell.quick_root_shell(TABLEATTACK_SCRIPT)
if router_shell == null then continue
router_shell.clear_logs(EMPTY_LOG_PATH)
SITES_FILE.set_content(SITES_FILE.get_content + char(10) + machine.ip)
machine.save_exploits
site_shell.start_terminal
end while
end function
import_code("/home/me/h/libs/thor.src") //depends on Listlib, exports Thor
Thor.init(Command, "hostImg")

src/machine.src

MachineServices = {}
//class eval shit
exploits_inspect = function(obj, scope)
exploits_len = 0
if scope.hasIndex("exploits") then exploits_len = scope.exploits.len
return scope.exploits.len
end function
Service.attrs.push("exploits")
Service.load_exploits_from_cache = function()
exploits = self.machine.exploits_cache
if exploits.hasIndex(self.info_to_key) == 0 then return 0
self.scan = new Scan
self.scan.init(self.nmap.ip, self.port)
self.exploits = []
for x in exploits[self.info_to_key]
exploit = new ScanExploit
exploit.init(self.scan, x)
self.exploits.push(exploit)
end for
return 1
end function
Service.load_exploits_from_scan = function()
exploits = self.machine.exploits_cache
self.scan = new Scan
self.scan.init(self.nmap.ip, self.port)
self.scan.execute
self.exploits = self.scan.get_exploits
end function
Service.set_exploits = function()
// skip_if_no_cache scan_only_if_no_cache scan_everytime
if self.machine.scan_strategy == "scan_everytime" then
self.load_exploits_from_scan
else if self.machine.scan_strategy == "skip_if_no_cache" then
self.load_exploits_from_cache
else if self.machine.scan_strategy == "scan_only_if_no_cache" then
if self.load_exploits_from_cache == 0 then self.load_exploits_from_scan
end if
end function
// require passwords list set in custom_object
Service.quick_root_shell = function(attack_script)
for x in self.exploits
x.set_result
~~if typeof(x.result) != "shell" then continue~~
if typeof(x.result) != "shell" then continue
remote_shell = x.result
remote_comp = remote_shell.host_computer
// save entry
entries = self.machine.json.to_object(self.machine.entries_disk.read_chars)
key = entries.indexes.len
entry = {}
entry.local_ip = remote_comp.local_ip
entry.public_ip = remote_comp.public_ip
entry.exploit = {"address": x.address, "value": x.value, "port": str(self.port)}
entries[key] = entry
self.machine.entries_disk.nuke
self.machine.entries_disk.write(self.machine.json.to_string(entries))
if remote_comp.File("/home/guest/tableAttack.src") != null then
remote_comp.File("/home/guest/tableAttack.src").delete
end if
remote_comp.touch("/home/guest", "tableAttack.src")
remote_comp.File("/home/guest/tableAttack.src").set_content(attack_script.get_content)
print "building script"
remote_shell.build("/home/guest/tableAttack.src", "/home/guest")
remote_shell.launch("/home/guest/tableAttack")
// update entry
entries = self.machine.json.to_object(self.machine.entries_disk.read_chars)
entries[key].credentials = {"user": "root", "password": get_custom_object.password}
self.machine.entries_disk.nuke
self.machine.entries_disk.write(self.machine.json.to_string(entries))
root_shell = get_custom_object.shell
return root_shell
end for
return null
end function
Machine = {}
Machine.exploits_cache = function
return self.json.to_object(self.exploits_disk.read_chars)
end function
//Machine.passwords_list : required passwords list
//Machine.table_attack_script : required table attack script
Machine.services_inspect = function(obj, scope)
f = function(o)
exploits_len = 0
if o.hasIndex("exploits") then exploits_len = o.exploits.len
return o.inspect(["info", [exploits_len, "exploits_len"], "port"])
end function
return scope.services.map(@f)
end function
Machine.attrs = ["ip", [@Machine.services_inspect, "services"]]
Machine.metaxploit = null //required
~~Machine.init = function(ip, passwords_disk, exploits_disk)~~
Machine.init = function(ip, passwords_disk, exploits_disk, entries_disk)
// skip_if_no_cache scan_only_if_no_cache scan_everytime
self.scan_strategy = "scan_only_if_no_cache"
self.ip = ip
self.set_services
self.passwords_disk = passwords_disk
self.passwords = self.passwords_disk.read_chars.split(char(10))
self.exploits_disk = exploits_disk
if self.exploits_disk.read_chars.len == 0 then
self.exploits_disk.write("{}")
end if
self.entries_disk = entries_disk
if self.entries_disk.read_chars.len == 0 then
self.entries_disk.write("{}")
end if
self.json = new JSON
if not get_custom_object.hasIndex("passwords") then
get_custom_object.passwords = self.passwords
end if
end function
Machine.save_exploits = function()
for s in self.services
key = s.info_to_key
exploits = []
if s.hasIndex("exploits") == 0 then continue
for x in s.exploits
x_obj = {}
x_obj["address"] = x.address
x_obj["value"] = x.value
x_obj["requirements"] = x.requirements
x_obj["requirements_len"] = x.requirements_len
if x.hasIndex("result") == 1 then x_obj["result"] = typeof(x.result)
exploits.push x_obj
end for
exploits_db = self.json.to_object(self.exploits_disk.read_chars)
exploits_db[key] = exploits
self.exploits_disk.nuke
self.exploits_disk.write(self.json.to_string(exploits_db))
end for
end function
Machine.quick_attack = function(only_routers = true, table_attack_script)
target_services = self.services
if only_routers == true then
target_services = [self.router_service]
end if
for service in target_services
service.set_exploits
root_shell = service.quick_root_shell(table_attack_script)
if typeof(root_shell) == "shell" then return root_shell
end for
return null
end function
Machine.set_services = function()
self.nmap = new Nmap
self.nmap.init(self.ip)
self.nmap.machine = self
self.services = self.nmap.services
for s in self.services
s.machine = self
end for
end function
Machine.router_service = function()
for s in self.services
if s.port == null then return s
end for
return null
end function
Machine.open_services = function()
f = function(o)
return o.status == "open"
end function
return self.services.select(@f)
end function
// this will get more complicated later on, i want to choose a port that i have the most change of getting in
// so i can check a database of exploits see or see the local ip with most ports open etc
Machine.most_vulnerable_service = function()
if self.services.len == 1 then return self.services[0]
if self.services.len == 0 then return null
with_smallest_version = self.services[0]
for service in self.services[1:]
if service.version_to_int < with_smallest_version.version_to_int then
with_smallest_version = service
end if
end for
return with_smallest_version
end function

src/img.html

~~<!DOCTYPE html>~~
~~<html>~~
~~<style>~~
~~.p {~~
~~width: 0px;~~
~~height: 0px;~~
~~display: table-cell;~~
~~border: solid #000000 2x;~~
}
~~.p0 {~~
~~width: 0px;~~
~~height: 0px;~~
~~display: table-cell;~~
~~border: solid #000000 0.5x;~~
}
~~.p1 {~~
~~width: 0px;~~
~~height: 0px;~~
~~display: table-cell;~~
~~border: solid #000000 1x;~~
}
~~.p2 {~~
~~width: 0px;~~
~~height: 0px;~~
~~display: table-cell;~~
~~border: solid #000000 2x;~~
}
~~.p3 {~~
~~width: 0px;~~
~~height: 0px;~~
~~display: table-cell;~~
~~border: solid #000000 3x;~~
}
~~body {~~
~~overflow-y: auto;~~
~~height: 100%;~~
~~margin :0;~~
~~background-color: #ffffff;~~
~~color: #000000;~~
}
~~html{~~
~~background-color: #21333D;~~
~~height:100%;~~
}
~~</style>~~
~~<body id="body">~~
~~<button onclick="gen_image(img_data, target_element_id, 0)">scale 0</button>~~
~~<button onclick="gen_image(img_data, target_element_id, 1)">scale 1</button>~~
~~<button onclick="gen_image(img_data, target_element_id, 2)">scale 2</button>~~
~~<button onclick="gen_image(img_data, target_element_id, 3)">scale 3</button>~~
~~<p>output: </p>~~
~~<div id="imgout">~~
~~loading img~~
~~</div>~~
~~<script>~~
~~function divide(s, n) {~~
~~let offset = 0~~
~~let r = []~~
~~while(true) {~~
~~r.push(s.slice(0, n ))~~
~~s = s.slice(n)~~
~~if (s.length == 0) {~~
~~break~~
}
}
~~return r~~
}
~~function hex_to_tag(s, scale) {~~
~~return "<div class=\"p" + scale + "\" style=\"border-color: #" + s + "\"></div>"~~
}
~~function to_line(s) {~~
~~return "<div>" + s.join("") + "</div>"~~
}
~~function gen_image(img, target_element_id, scale) {~~
~~let out_element = document.getElementById(target_element_id)~~
~~data = img~~
~~data = data.replace("\n", "")~~
~~let width = Number(data.split(" ")[0])~~
~~data = data.split(" ")[1]~~
~~data = divide(data,6)~~
~~data = data.map(function(i) {return hex_to_tag(i, scale)})~~
~~data = divide(data, width)~~
~~data = data.map(to_line)~~
~~out_element.innerHTML = data.join("")~~
}
~~img_data = "IMG_DATA_HERE"~~
~~target_element_id = "imgout"~~
~~scale = "1"~~
~~gen_image(img_data, target_element_id, scale)~~
~~</script>~~
~~</body>~~
~~</html>~~