def ReverseCipher(message):
logging.info("trying reverse cipher")
File.write("\n")
File.write("This is the result of the Reverse Cipher")
ReversedCipher = Reverse.reverseCipher(message) # Creates varialbe of the reversed string
logging.info("Reverse Cipher")
# creates varaible, and goes to Reverse module to reverse string
if detectEnglish.isEnglish(ReversedCipher) == True:
# If Engish is detected, write the english into a variable
# and the name of the cipher into a variable, send it to
# EnglishDetected()
EnglishMSG = ReversedCipher
CipherName = "Reverse Cipher"
EnglishDetected(EnglishMSG, CipherName, File)
else:
File.write("\n")
File.write(ReversedCipher)
File.write("\n")
print("\nThis is the result of the Reverse cipher\n"
"{}".format(ReversedCipher))
# Prints and logs to debug
logging.debug("reverse cipher sucessful. result is ")
logging.debug(ReversedCipher)
def push_frame():
#TODO: (Bug) len(command)不更新
# 防止多线程时 command 未被设置
while True:
if len(command) > 0:
# 管道配置
p = sp.Popen(command, stdin=sp.PIPE)
break
while True:
if frame_queue.empty() != True:
frame = frame_queue.get()
angle = rospy.get_param("wheel_angle")
Array = Reverse.getPointArray(angle)
for point in Array:
cv.circle(frame, (point[0], point[1]), point_size, point_color,
thickness)
# write to pipe
p.stdin.write(frame.tostring())
print "░ ░▒ ▒ ░ ▒▒ ▓▒█░ ▒ ░░"
print " ░ ▒ ▒ ▒▒ ░ ░"
print "░ ░ ▒ ░"
print "░ ░ ░ ░"
print "░"
x = open("/home/elchala/Escritorio/veremos.txt", "a")
ips = []
subpaginas = [] # lista que va recopilando las paginas y subdominios
subdominios_paginas = []
subdominios_ips = []
dir = raw_input("Ingrese una direccion web : ")
Subdomain.subdomain(dir) # analizo los subdominios de la direccion
Reverse.reverse(
dir, ips
) # imprime el IP de la pagina e imprime las paginas asociadas a dicha ip
subpaginas.append(dir) # insertaba la pagina inicial a la lista de paginas
ips.append(socket.gethostbyname(dir)) # insertaba la primera ip encontrada
archivo = open('SubDomain.temp', 'r')
for lines in archivo.readlines():
pos = lines.find(",")
subpaginas.append((lines[:pos]).rstrip("\n"))
ips.append(lines[pos + 1:].rstrip("\n"))
archivo.close()
print "****APLICANDO EL REVERSE IP A LOS RESULTADOS DE Subdomain Y OBTENER LAS IP'S DE CADA UNO****"
x.write(
"****APLICANDO EL REVERSE IP A LOS RESULTADOS DE Subdomain Y OBTENER LAS IP'S DE CADA UNO****\n"
import Prime as p
import Reverse as r
for num in range(1, 100):
if (p.isPrime(num)):
revNum = r.getReverse(num)
if (revNum == num): continue
if (p.isPrime(revNum)): print(num)
import Reverse
from Reverse import Reverse
reverse = Reverse("Hello World!")
for character in reverse:
print(character, end="")
import socket
import Nmap
import Subdomain
import Reverse
import Shodan
import Builtwith
import commands
ips = []
subpaginas = []
dir = raw_input("Ingrese una direccion web : ")
Reverse.reverse(dir, ips)
Subdomain.subdomain(dir)
f = open('reverse.temp', 'r')
for linea in f.readlines():
subpaginas.append(linea)
f.close
commands.getoutput('rm reverse.temp')
dir_ip = socket.gethostbyname(dir)
ips.append(dir_ip)
dir_2 = dir_ip
Nmap.nmap(dir_ip)
Shodan.shodan(dir_2)
Builtwith.builtwith(dir)
print " "
print "############### ANALIZANDO LAS PAGINAS ANIDADAS QUE FUERON ENCONTRADAS ###############"
import Reverse
dictionary_1 = {'name': 'Leo', 'birthday': 20030819, 'sex': 'M', 'note': 'M'}
print(Reverse.reverse(dictionary_1, 'M'))
def main():
global interface, sniff, protocol, flags, target_ip, port_range, reverse, scanType, detection
if len(sys.argv[1:]):
try:
opts, args = getopt.getopt(sys.argv[1:], "sS:P:f:t:p:rd:h:", [
"sniff", "scan=", "proto=", "flags=", "target=", "port=",
"reverse", "detect=", "help"
])
except:
usage()
sys.exit()
try:
for o, a in opts:
if o in ("-h", "--help"):
usage()
sys.exit()
elif o in ("-s", "--sniff"):
sniff = True
elif o in ("-S", "--scan"):
scanType = a
elif o in ("-P", "--proto"):
protocol = a
elif o in ("-f", "--flags"):
flags = a
elif o in ("-t", "--target"):
if outils.is_valid_ip(a):
target_ip = a
else:
try:
target_ip = socket.gethostbyname(a)
except:
print "Impossible de trouver l'adresse IP correspondante ."
usage()
sys.exit()
elif o in ("-p", "--port"):
list = a.split(",")
if len(list) == 2:
p, q = map(int, list)
port_range = range(p, q + 1)
elif len(list) == 1:
port_range = [int(a)]
elif o in ("-r", "--reverse"):
reverse = True
elif o in ("-i", "--interface"):
interface = a
elif o in ("-d", "--detect"):
detection = a
elif o in ("-h", "--help"):
usage()
sys.exit()
except:
sys.exit()
if scanType:
if sniff or reverse or protocol or (scanType == "udp" and flags) or (
scanType == "icmp-echo" and (flags or port_range)):
usage()
sys.exit()
import scanner
queue = Queue.Queue()
cidr = outils.cidr(target_ip)
if len(cidr) == 2:
ip_list = outils.get_addresses(cidr[0], cidr[1])
else:
ip_list = cidr
startTime = time.time()
if scanType != "icmp-echo":
for ip in ip_list:
scanner.target_ip = ip
for j in range(15):
if scanType == "tcp":
scan = scanner.TCPScanner(queue, flags)
scan.setDaemon(True)
scan.start()
elif scanType == "udp":
scan = scanner.UDPScanner(queue)
scan.setDaemon(True)
scan.start()
if port_range:
for port in port_range:
queue.put(port)
else:
for port in range(1, 1025):
queue.put(port)
queue.join()
scanner.scan_report(startTime, scanType, port_range)
else:
for j in range(15):
scan = scanner.pingScan(queue)
scan.setDaemon(True)
scan.start()
for ip in ip_list:
queue.put(ip)
queue.join()
scanner.scan_report(startTime, scanType, None)
elif detection:
import Detect
if detection == "dhcpserver":
Detect.detect_DHCP_servers(interface)
elif detection == "arppoison":
Detect.detect_arp_poison(target_ip, interface)
elif protocol:
if sniff or scanType or flags or target_ip or reverse:
usage()
sys.exit()
if protocol == "dhcp":
import DHCPtester
DHCPtester.DHCPtester()
elif protocol == "dns":
import DNS
DNS.DNStester()
elif protocol == "arp":
import ARP_attaque
ARP_attaque.menu()
elif reverse:
if sniff or scanType or flags or target_ip or port_range or protocol:
usage()
sys.exit()
import Reverse
Reverse.reverse()
elif sniff:
if scanType or flags or not (target_ip) or port_range or not (
interface) or reverse or protocol:
import Sniffer
sniffer = Sniffer.Sniffer(interface, "tcp", 80, target_ip)
sniffer.sniff()
import cv2 as cv
import Reverse
import numpy as np
if __name__ == '__main__':
camera_path = "D://test.mkv"
cap = cv.VideoCapture(camera_path)
point_size = 1
point_color = (0, 0, 255)
thickness = 4
while (cap.isOpened()):
ret, frame = cap.read()
Array = Reverse.getPointArray(30)
for point in Array:
cv.circle(frame, (point[0], point[1]), point_size, point_color,
thickness)
cv.imshow("hello", frame)
cv.waitKey(20)
import Maxim
import Remove # Importing modules
import Reverse
nums = input('Enter a natural number: ') # Taking input
if int(nums) > 0:
largest_num = str() # Defining variable before using in line 9
while nums != '':
max_num = Maxim.maxim(nums) # Using Maxim module
largest_num = max_num + largest_num # Storing in descending order
nums = Remove.remove_max(
max_num, nums) # Removing the max_num for next iteration
print(f'\nThe Largest Number possible: {int(largest_num)}')
smallest_num = Reverse.reverse(
int(largest_num)) # Reversing the largest number
print(f'The Smallest Number possibe: {smallest_num}\n')
else: # Natural Numbers only
print('Invalid Input... Natural Numbers only.')
def main():
print("""
#################################################
# <<<<<< Nili Demo Version >>>>>> #
# <<<<<< Created on July 2017 >>>>>> #
# <<<<<< Author: Kheirkhah & Mir >>>>>> #
#################################################
""")
parser = argparse.ArgumentParser(
description='', formatter_class=argparse.RawTextHelpFormatter)
parser.add_argument(
'-N',
'--netscan',
help=
'scan the network for devices: (for more help use "-NH")\n-N -r [range] -i [interface]',
action='store_true')
parser.add_argument(
'-P',
'--portscan',
help=
'check the open ports of a device: (for more help use "-PH")\n-P -t [target] -mp [minPort] -xp [maxPort]',
action='store_true')
parser.add_argument(
'-M',
'--mitm',
help=
'man in the middle attack: (for more help use "-MH")\n-M -t [target] -g [gateway] -i [interface] -f [filter (use BPF syntax)]',
action='store_true')
parser.add_argument(
'-R',
'--reverse',
help=
'protocol reverse engineering: (for more help use "-RH")\n-R -d [delimiter]',
action='store_true')
parser.add_argument(
'-F',
'--fuzz',
help=
'fuzzing: (for more help use "-FH")\n-F -d [delimiter] -c [command] -l [field] -ml [minLength] -xl [maxLength] -t [target] -p [port]',
action='store_true')
parser.add_argument('-NH', '--nh', action='store_true')
parser.add_argument('-PH', '--ph', action='store_true')
parser.add_argument('-MH', '--mh', action='store_true')
parser.add_argument('-RH', '--rh', action='store_true')
parser.add_argument('-FH', '--fh', action='store_true')
parser.add_argument('-r', '--range')
parser.add_argument('-i', '--interface')
parser.add_argument('-p', '--port')
parser.add_argument('-t', '--target')
parser.add_argument('-mp', '--minPort')
parser.add_argument('-xp', '--maxPort')
parser.add_argument('-g', '--gateway')
parser.add_argument('-f', '--filter')
parser.add_argument('-d', '--delimiter')
parser.add_argument('-c', '--command')
parser.add_argument('-l', '--field')
parser.add_argument('-ml', '--minLength')
parser.add_argument('-xl', '--maxLength')
p = parser.parse_args()
# netscan
if p.netscan and p.range and p.interface:
NetScan.NetScan(p.range, p.interface)
# portscan
elif p.portscan and p.target and p.minPort and p.maxPort:
PortScan.PortScan(p.target, p.minPort, p.maxPort)
# man in the meiddle
elif p.mitm and p.target and p.gateway and p.interface and p.filter:
MitM.MitM(p.target, p.gateway, p.interface, p.filter)
# reverse
if p.reverse:
Reverse.Reverse(p.delimiter)
# fuzzing
elif p.fuzz and p.command and p.field and p.minLength and p.maxLength and p.delimiter and p.target and p.port:
Fuzzing.Fuzzing(p.delimiter, p.command, p.field, p.minLength,
p.maxLength, p.target, p.port)
# Help
elif p.nh:
print("network scan help:\n")
print("nili.py -N -r [range] -i [interface]\n")
print("[range]: ip range \n[interface]: network interface")
exit(0)
elif p.ph:
print("port scan help:\n")
print("nili.py -P -t [target] -mp [minPort] -xp [maxPort]\n")
print(
"[target]: target ip \n[minPort]: minimum port to scan \n[maxPort]: maximum port to scan"
)
exit(0)
elif p.mh:
print("man in the middle attack help:\n")
print(
"nili.py -M -t [target] -g [gateway] -i [interface] -f [filter (use BPF syntax)]\n"
)
print(
"[target]: target ip \n[gateway]: gateway ip \n[interface]: network inteface \n[filter]: sniffing filter using BPF syntax.\n\t see BPF documentation at: https://biot.com/capstats/bpf.html. example:\n\t\t-tcp src port 21 and (tcp[tcpflags] & (tcp-syn|tcp-fin) != 0)"
)
exit(0)
elif p.rh:
print("protocol reverse engineering help:\n")
print("nili.py -R -d [delimiter] \n")
print("[delimiter]: protocol fields delimiter ")
exit(0)
elif p.fh:
print("fuzzing help:\n")
print(
"nili.py -F -d [delimiter] -c [command] -l [field] -ml [minLength] -xl [maxLength] -t [target] -p [port]\n"
)
print(
"[delimiter]: protocol fields delimiter \n[command]: specify a protocol command \n[field]: specify a protocol field \n[minLength]: minimum length of fuzzing buffer \n[maxLength]: maximum length of fuzzing buffer \n[target]: target IP \n[port]: target port "
)
exit(0)
else:
parser.print_help()