Grey Repo

Files

cli/libfish.src cli/proxy.src libs/thor.src src/shell.src src/machine.src libs/optionSelector.src cli/npcRshell.src src/rndIP.src src/rserverInstaller.src

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")
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(machine.random_ip, PASSWORDS_DISK, EXPLOITS_DISK)~~
machine.init(rnd_ip, PASSWORDS_DISK, EXPLOITS_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")
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"] = []~~
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)
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
~~print "[" + i + "] " + proxies[i]~~
proxies[i] = [@re_hack, proxies[i], proxies[i]]
end for
print "[" + proxies.len + "] hack a new one"
~~option = user_input("select a option: ")~~
proxies.push ["return", null, "hack a new one"]
if proxies.hasIndex(option) then
~~machine = new Machine~~
~~machine.init(proxies[option], PASSWORDS_DISK, EXPLOITS_DISK)~~
~~root_shell = machine.quick_attack(true, TABLEATTACK_SCRIPT)~~
~~root_shell.clear_logs(EMPTY_LOG_PATH)~~
~~root_shell.start_terminal~~
~~end if~~
option_selector proxies
end if
while true
machine = new Machine
~~machine.init(machine.random_ip, PASSWORDS_DISK, EXPLOITS_DISK)~~
machine.init(rnd_ip, PASSWORDS_DISK, EXPLOITS_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")

libs/thor.src

ThorParam = {}
ThorParam.init = function(obj)
self.name = obj
if obj isa list then self.name = obj[0]
if obj isa map then self.name = obj.indexes[0]
self.description = null
if obj isa list then self.description = obj[1]
if obj isa map then self.description = obj.values[1]
self.is_required = self.name[-1] == "*"
self.is_optional = not self.is_required
end function
ThorCommand = {}
ThorCommand.init = function(func, sig, name)
self.name = name
self.func = @func
if sig.hasIndex("description") then self.description = sig["description"]
if sig.hasIndex("args") then
f = function(o)
r = new ThorParam
r.init(o)
return r
end function
self.args = sig["args"].map(@f)
end if
if sig.hasIndex("options") then
f = function(obj)
param = {}
param["name"] = obj.indexes[0]
param["description"] = obj[obj.indexes[0]]
return param
end function
self.options = sig["options"].map(@f)
end if
end function
ThorCommand.required_args = function()
f = function(obj)
return obj.is_required
end function
return self.args.select(@f)
end function
ThorCommand.optional_args = function()
f = function(obj)
return self.required_args.indexOf(obj) == null
end function
return self.args.select(@f)
end function
ThorCommand.options_list = function()
f = function(o)
return o.name
end function
return self.options.map(@f)
end function
ThorCommand.args_help = function()
out = self.name
for arg in self.args
out = out + " " + arg.name
end for
f = function(o)
return o.description != null
end function
args_with_description = self.args.select(@f)
if args_with_description.len > 0 then
out = out + char(10) * 2 + "args description:" + char(10)
for arg in args_with_description
out = out + arg.name + " : " + arg.description
end for
end if
return out
end function
ThorCommand.options_help = function()
out = "options for " + self.name + ":" + char(10)
for i in self.options
n = i.name
if typeof(i.name) == "list" then n = i.name.join(" or ")
out = out + n + " : " + i.description
if self.options.indexOf(i) < self.options.len - 1 then out = out + char(10)
end for
return out
end function
ThorCommand.help = function()
out = self.args_help + char(10) + char(10)
if self.options_list.len > 0 then
out = out + self.options_help + char(10) + char(10)
end if
out = out + "program description: " + char(10)
out = out + self.description
return out
end function
ThorCommand.exec = function()
self.func(self.passed_args.compact, self.passed_options)
end function
// class divider ---------------------------------------
ThorManager = {}
ThorManager.init = function(thor)
self.thor = thor
end function
ThorManager.eval_command = function(command)
used_args = self.thor.global_args
self.thor.global_args = self.thor.global_args
self.thor.used_options = self.thor.used_options + command.options_list.flat
for i in range(command.args.len - used_args.len - 1)
used_args.push(null)
end for
command["passed_args"] = used_args
command["passed_options"] = self.options_by_key(command)
self.thor.global_execution_queue.push(command)
end function
ThorManager.options_by_key = function(command)
scope = self
r = {}
get_value = function(o)
if o.indexOf("=") then
striped_options = scope.thor.striped_global_options
if striped_options.indexOf(o) then
value = scope.thor.global_options[striped_options.indexOf(o)]
return value[value.indexOf("=")+1:]
else
return null
end if
else
if scope.thor.global_options.indexOf(i) != null then return true
return null
end if
end function
for o in command.options_list
if typeof(o) == "list" then
v = null
for i in o
if get_value(i) != null then v = get_value(i)
end for
for i in o
r[i] = v
end for
else
r[o] = get_value(o)
end if
end for
return r
end function
// class divider ---------------------------------------
Thor = {}
Thor.init = function(class, main_func_name)
self.class = null
self.global_args = []
self.passed_args_count = 0
self.global_options = []
self.used_options = []
self.global_execution_queue = []
self.manager = new ThorManager
self.manager.init(self)
main_command = new ThorCommand
main_command.init(class[main_func_name], class[main_func_name+"_sig"], main_func_name)
self.params_to_args_options(params)
self.manager.eval_command(main_command)
self.catch_errors
self.exec_queue
end function
Thor.striped_global_options = function()
f = function(ob)
if ob.indexOf("=") then
return ob[:ob.indexOf("=")+1]
end if
return ob
end function
return self.global_options.map(@f)
end function
Thor.params_to_args_options = function(params)
// filter for args
f = function(p)
return p[0] == "-"
end function
args = params.reject(@f)
options = {}
f = function(param)
return param[:1] == "-" and param.indexOf("=") == null
end function
params_options = params.select(@f)
f = function(param)
if param[:2] != "--" and param.len > 2 then
r = []
for i in param[1:].values
r.push("-" + i)
end for
return r
else
return param
end if
end function
params_options = params_options.map(@f).flat.uniq
f = function(param)
return param[:1] == "-" and param.indexOf("=") != null
end function
params_value_options = params.select(@f)
options = params_options + params_value_options
self.global_args = args
self.passed_args_count = args.len
self.global_options = options
end function
Thor.catch_errors = function()
if self.global_options.indexOf("-h") != null or self.global_options.indexOf("--help") != null then
print(self.global_execution_queue[-1].help)
exit()
end if
f = function(c)
return c.required_args.len
end function
required_args = self.global_execution_queue.map(@f)
if self.passed_args_count < required_args.sum then
print("error: required params not passed, check the docs")
exit()
end if
used_options = self.used_options + ["-h", "--help"] //cant use self inside the block
f = function(p)
return used_options.indexOf(p) == null
end function
undefined_options = self.striped_global_options.select(@f)
for i in undefined_options
print("error: " + i + " option is not defined, check the docs")
exit()
end for
end function
Thor.exec_queue = function()
self.global_execution_queue[-1].exec
end function

src/shell.src

// extend shell objs
map.clear_logs = function(empty_log_path)
if typeof(self) != "shell" then
print "<color=red>error obj is not an shell</color>"
end if
shell = self
comp = shell.host_computer
new_log_name = empty_log_path.split("/")[-1]
get_shell.scp(empty_log_path, "/var", shell)
new_log_file = comp.File("/var/"+new_log_name)
copy_out = new_log_file.copy("/var", "system.log")
if copy_out != 1 then print copy_out
new_log_file.rename(".log")
return shell
end function
map.install_rserver = function(installer_script)
if typeof(self) != "shell" then
print "<color=red>error obj is not an shell</color>"
end if
shell = self
comp = shell.host_computer
if comp.File("/home/guest/rinstaller.src") != null then
comp.File("/home/guest/rinstaller.src").delete
end if
comp.touch("/home/guest", "rinstaller.src")
comp.File("/home/guest/rinstaller.src").set_content(installer_script.get_content)
print "building installer"
shell.build("/home/guest/rinstaller.src", "/home/guest")
shell.launch("/home/guest/rinstaller")
return shell
end function

src/machine.src

~~MachineServices = {}~~
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.set_exploits = function()
exploits = self.machine.json.to_object(self.machine.exploits_disk.read_chars)
if exploits.hasIndex(self.info_to_key) then
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
else
self.scan = new Scan
self.scan.init(self.nmap.ip, self.port)
self.scan.execute
self.exploits = self.scan.get_exploits
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
remote_shell = x.result
remote_comp = remote_shell.host_computer
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")
root_shell = get_custom_object.shell
return root_shell
end for
return null
end function
Machine = {}
//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)
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.json = new JSON
if not get_custom_object.hasIndex("passwords") then
get_custom_object.passwords = self.passwords
end if
~~end function~~
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
~~f = function(o)~~
~~return o.port == null~~
~~end function~~
target_services.map(@f)
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.random_ip = function()~~
~~first_byte_range = range(0, 255)~~
~~first_byte_range.remove(192) //reserved~~
~~first_byte_range.remove(191) //reserved~~
~~first_byte_range.remove(0) //reserved~~
~~first_byte_range.remove(10) //private~~
~~first_byte_range.remove(172) //private~~
~~first_byte_range.remove(128) //reserved~~
~~first_byte_range.remove(223) //reserved~~
~~rest_byte_range = range(0,255)~~
~~ip = []~~
~~ip.push(floor(rnd() * first_byte_range.len))~~
~~for i in range(2)~~
~~ip.push(floor(rnd() * rest_byte_range.len))~~
~~end for~~
~~ip = ip.join(".")~~
~~if is_valid_ip(ip) and get_router(ip) and get_shell.ping(ip) then~~
~~return ip~~
~~end if~~
~~return self.random_ip~~
~~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

libs/optionSelector.src

~~// expect a l(list) containing this structure [func, params, display_text]~~
~~// also instead of a func in the first param you can set the string "return" to make the function return instead~~
~~option_selector = function(m)~~
~~while true~~
~~for i in m.indexes~~
~~print "[<color=yellow>" + i + "</color>] " + m[i][2]~~
~~end for~~
~~selected = user_input("select a option: ").to_int~~
~~if selected isa string or m.hasIndex(selected) == false then~~
~~print "<color=red>ERROR: invalid option, try again</color>"~~
~~continue~~
~~end if~~
~~selected = m[selected]~~
~~if selected[0] == "return" then return~~
~~selected[0](selected[1])~~
~~return~~
~~end while~~
~~end function~~

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")~~
~~Machine.metaxploit = include_lib("/lib/metaxploit.so")~~
~~Scan.metaxploit = include_lib("/lib/metaxploit.so")~~
~~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 = {})~~
~~while true~~
~~machine = new Machine~~
~~machine.init(rnd_ip, PASSWORDS_DISK, EXPLOITS_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)~~
~~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")~~

src/rndIP.src

~~rnd_ip = function()~~
~~first_byte_range = range(0, 255)~~
~~first_byte_range.remove(192) //reserved~~
~~first_byte_range.remove(191) //reserved~~
~~first_byte_range.remove(0) //reserved~~
~~first_byte_range.remove(10) //private~~
~~first_byte_range.remove(172) //private~~
~~first_byte_range.remove(128) //reserved~~
~~first_byte_range.remove(223) //reserved~~
~~rest_byte_range = range(0,255)~~
~~ip = []~~
~~ip.push(floor(rnd() * first_byte_range.len))~~
~~for i in range(2)~~
~~ip.push(floor(rnd() * rest_byte_range.len))~~
~~end for~~
~~ip = ip.join(".")~~
~~if is_valid_ip(ip) and get_router(ip) and get_shell.ping(ip) then~~
~~return ip~~
~~end if~~
~~return rnd_ip~~
~~end function~~

src/rserverInstaller.src

~~rnd_ip = function()~~
~~first_byte_range = range(0, 255)~~
~~first_byte_range.remove(192) //reserved~~
~~first_byte_range.remove(191) //reserved~~
~~first_byte_range.remove(0) //reserved~~
~~first_byte_range.remove(10) //private~~
~~first_byte_range.remove(172) //private~~
~~first_byte_range.remove(128) //reserved~~
~~first_byte_range.remove(223) //reserved~~
~~rest_byte_range = range(0,255)~~
~~ip = []~~
~~ip.push(floor(rnd() * first_byte_range.len))~~
~~for i in range(2)~~
~~ip.push(floor(rnd() * rest_byte_range.len))~~
~~end for~~
~~ip = ip.join(".")~~
~~if is_valid_ip(ip) and get_router(ip) and get_shell.ping(ip) then~~
~~return ip~~
~~end if~~
~~return rnd_ip~~
~~end function~~
~~get_hackshop_ip = function()~~
~~while true~~
~~ip = rnd_ip~~
~~router = get_router(ip)~~
~~ports = router.used_ports~~
~~is_hack_shop = false~~
~~for port in ports~~
~~info = router.port_info(port)~~
~~if info.indexOf("repository") != null then~~
~~return ip~~
~~end if~~
~~end for~~
~~end while~~
~~end function~~
~~repo_ip = get_hackshop_ip~~
~~get_shell.launch("/bin/apt-get", "addrepo " + repo_ip)~~
~~get_shell.launch("/bin/apt-get", "update")~~
~~get_shell.launch("/bin/apt-get", "install librshell.so")~~
~~rshelld = include_lib("/lib/librshell.so")~~
~~if not rshelld then exit("Error: Missing librshell.so library in the /lib path or the current folder")~~
~~output = rshelld.install_service~~
~~if output != true then exit(output)~~
~~print("<b>Type 'Browser.exe " + get_router.local_ip + ":8080' to access the router configuration to make sure the service it's accesible</b>")~~