def inject_custom_header(url, vuln_parameter, payload, proxy):
if proxy == None:
opener = urllib2.build_opener()
else:
opener = urllib2.build_opener(proxy)
# Check if defined POST data
if menu.options.data:
menu.options.data = settings.USER_DEFINED_POST_DATA
request = urllib2.Request(url, menu.options.data)
else:
url = parameters.get_url_part(url)
request = urllib2.Request(url)
#Check if defined extra headers.
headers.do_check(request)
payload = urllib.unquote(payload)
# Fix for %0a, %0d%0a separators
if payload[:1] == "\n":
payload = urllib.quote(payload[:1]) + payload[1:]
elif payload[:2] == "\r\n":
payload = urllib.quote(payload[:2]) + payload[2:]
request.add_header(settings.CUSTOM_HEADER_NAME, payload)
try:
headers.check_http_traffic(request)
response = opener.open(request)
return response
except ValueError:
pass
def estimate_response_time(url, timesec):
if settings.VERBOSITY_LEVEL >= 1:
info_msg = "Estimating the target URL response time... "
sys.stdout.write(settings.print_info_msg(info_msg))
sys.stdout.flush()
# Check if defined POST data
if menu.options.data:
request = urllib2.Request(url, menu.options.data)
else:
url = parameters.get_url_part(url)
request = urllib2.Request(url)
headers.do_check(request)
start = time.time()
try:
response = urllib2.urlopen(request)
response.read(1)
response.close()
except urllib2.URLError, err:
err_msg = "Unable to connect to the target URL"
try:
err_msg += " (" + str(err.args[0]).split("] ")[1] + ")."
except IndexError:
err_msg += "."
print settings.print_critical_msg(err_msg + ").")
raise SystemExit()
def inject_cookie(url, vuln_parameter, payload, proxy):
if proxy == None:
opener = urllib2.build_opener()
else:
opener = urllib2.build_opener(proxy)
if settings.TIME_RELATIVE_ATTACK :
payload = urllib.quote(payload)
# Check if defined POST data
if menu.options.data:
menu.options.data = settings.USER_DEFINED_POST_DATA
request = urllib2.Request(url, menu.options.data)
else:
url = parameters.get_url_part(url)
request = urllib2.Request(url)
#Check if defined extra headers.
headers.do_check(request)
request.add_header('Cookie', menu.options.cookie.replace(settings.INJECT_TAG, payload))
try:
headers.check_http_traffic(request)
response = opener.open(request)
return response
except ValueError:
pass
def inject_cookie(url, vuln_parameter, payload, proxy):
if proxy == None:
opener = urllib2.build_opener()
else:
opener = urllib2.build_opener(proxy)
if settings.TIME_RELATIVE_ATTACK :
payload = urllib.quote(payload)
# Check if defined POST data
if menu.options.data:
menu.options.data = settings.USER_DEFINED_POST_DATA
request = urllib2.Request(url, menu.options.data)
else:
url = parameters.get_url_part(url)
request = urllib2.Request(url)
#Check if defined extra headers.
headers.do_check(request)
payload = checks.newline_fixation(payload)
request.add_header('Cookie', menu.options.cookie.replace(settings.INJECT_TAG, payload))
try:
headers.check_http_traffic(request)
response = opener.open(request)
return response
except ValueError:
pass
def inject_host(url, vuln_parameter, payload, proxy):
if proxy == None:
opener = urllib2.build_opener()
else:
opener = urllib2.build_opener(proxy)
# Check if defined POST data
if menu.options.data:
menu.options.data = settings.USER_DEFINED_POST_DATA
request = urllib2.Request(url, menu.options.data)
else:
url = parameters.get_url_part(url)
request = urllib2.Request(url)
#Check if defined extra headers.
headers.do_check(request)
payload = urllib.unquote(payload)
# Fix for %0a, %0d%0a separators
if "\n" in payload:
_ = payload.find("\n") + 1
payload = urllib.quote(payload[:_]) + payload[_:]
elif "\r\n" in payload:
_ = payload.find("\r\n") + 1
payload = urllib.quote(payload[:_]) + payload[_:]
request.add_header('Host', payload)
try:
headers.check_http_traffic(request)
response = opener.open(request)
return response
except ValueError:
pass
def estimate_response_time(url, http_request_method, delay):
if http_request_method == "GET":
# Find the host part.
url = parameters.get_url_part(url)
request = urllib2.Request(url)
headers.do_check(request)
start = time.time()
try:
response = urllib2.urlopen(request)
response.read(1)
response.close()
except urllib2.HTTPError, e:
pass
def estimate_response_time(url, http_request_method, delay):
if http_request_method == "GET":
# Find the host part.
url = parameters.get_url_part(url)
request = urllib2.Request(url)
headers.do_check(request)
start = time.time()
try:
response = urllib2.urlopen(request)
response.read(1)
response.close()
except urllib2.HTTPError, e:
pass
def estimate_response_time(url, delay):
# Check if defined POST data
if menu.options.data:
request = urllib2.Request(url, menu.options.data)
else:
url = parameters.get_url_part(url)
request = urllib2.Request(url)
headers.do_check(request)
start = time.time()
try:
response = urllib2.urlopen(request)
response.read(1)
response.close()
except urllib2.HTTPError, e:
pass
def estimate_response_time(url, timesec):
if settings.VERBOSITY_LEVEL >= 1:
info_msg = "Estimating the target URL response time... "
sys.stdout.write(settings.print_info_msg(info_msg))
sys.stdout.flush()
# Check if defined POST data
if menu.options.data:
request = urllib2.Request(url, menu.options.data)
else:
url = parameters.get_url_part(url)
request = urllib2.Request(url)
headers.do_check(request)
start = time.time()
try:
response = urllib2.urlopen(request)
response.read(1)
response.close()
except urllib2.HTTPError, e:
pass
def inject_user_agent(url, vuln_parameter, payload, proxy):
if proxy == None:
opener = urllib2.build_opener()
else:
opener = urllib2.build_opener(proxy)
# Check if defined POST data
if menu.options.data:
menu.options.data = settings.USER_DEFINED_POST_DATA
request = urllib2.Request(url, menu.options.data)
else:
url = parameters.get_url_part(url)
request = urllib2.Request(url)
#Check if defined extra headers.
headers.do_check(request)
request.add_header('User-Agent', urllib.unquote(payload))
try:
headers.check_http_traffic(request)
response = opener.open(request)
return response
except ValueError:
pass
def inject_user_agent(url, vuln_parameter, payload, proxy):
if proxy == None:
opener = urllib2.build_opener()
else:
opener = urllib2.build_opener(proxy)
# Check if defined POST data
if menu.options.data:
menu.options.data = settings.USER_DEFINED_POST_DATA
request = urllib2.Request(url, menu.options.data)
else:
url = parameters.get_url_part(url)
request = urllib2.Request(url)
#Check if defined extra headers.
headers.do_check(request)
payload = checks.newline_fixation(payload)
request.add_header('User-Agent', payload)
try:
headers.check_http_traffic(request)
response = opener.open(request)
return response
except ValueError:
pass
def inject_user_agent(url, vuln_parameter, payload, proxy):
if proxy == None:
opener = _urllib.request.build_opener()
else:
opener = _urllib.request.build_opener(proxy)
# Check if defined POST data
if menu.options.data:
menu.options.data = settings.USER_DEFINED_POST_DATA
request = _urllib.request.Request(url, menu.options.data.encode(settings.UNICODE_ENCODING))
else:
url = parameters.get_url_part(url)
request = _urllib.request.Request(url)
#Check if defined extra headers.
headers.do_check(request)
payload = checks.newline_fixation(payload)
request.add_header('User-Agent', payload)
try:
headers.check_http_traffic(request)
response = opener.open(request)
return response
except ValueError:
pass
def inject_custom_header(url, vuln_parameter, payload, proxy):
if proxy == None:
opener = urllib2.build_opener()
else:
opener = urllib2.build_opener(proxy)
# Check if defined POST data
if menu.options.data:
menu.options.data = settings.USER_DEFINED_POST_DATA
request = urllib2.Request(url, menu.options.data)
else:
url = parameters.get_url_part(url)
request = urllib2.Request(url)
#Check if defined extra headers.
headers.do_check(request)
payload = checks.newline_fixation(payload)
request.add_header(settings.CUSTOM_HEADER_NAME, payload)
try:
headers.check_http_traffic(request)
response = opener.open(request)
return response
except ValueError:
pass
def estimate_response_time(url, timesec):
stored_auth_creds = False
if settings.VERBOSITY_LEVEL >= 1:
info_msg = "Estimating the target URL response time... "
sys.stdout.write(settings.print_info_msg(info_msg))
sys.stdout.flush()
# Check if defined POST data
if menu.options.data:
request = urllib2.Request(url, menu.options.data)
else:
url = parameters.get_url_part(url)
request = urllib2.Request(url)
headers.do_check(request)
start = time.time()
try:
response = urllib2.urlopen(request)
response.read(1)
response.close()
# except urllib2.HTTPError, err:
# pass
except urllib2.HTTPError, err:
ignore_start = time.time()
if "Unauthorized" in str(err) and menu.options.ignore_code == settings.UNAUTHORIZED_ERROR:
pass
else:
if settings.VERBOSITY_LEVEL >= 1:
print "[ " + Fore.RED + "FAILED" + Style.RESET_ALL + " ]"
err_msg = "Unable to connect to the target URL"
try:
err_msg += " (" + str(err.args[0]).split("] ")[1] + ")."
except IndexError:
err_msg += " (" + str(err) + ")."
print settings.print_critical_msg(err_msg)
# Check for HTTP Error 401 (Unauthorized).
if str(err.getcode()) == settings.UNAUTHORIZED_ERROR:
try:
# Get the auth header value
auth_line = err.headers.get('www-authenticate', '')
# Checking for authentication type name.
auth_type = auth_line.split()[0]
settings.SUPPORTED_HTTP_AUTH_TYPES.index(auth_type.lower())
# Checking for the realm attribute.
try:
auth_obj = re.match('''(\w*)\s+realm=(.*)''', auth_line).groups()
realm = auth_obj[1].split(',')[0].replace("\"", "")
except:
realm = False
except ValueError:
err_msg = "The identified HTTP authentication type (" + str(auth_type) + ") "
err_msg += "is not yet supported."
print settings.print_critical_msg(err_msg) + "\n"
raise SystemExit()
except IndexError:
err_msg = "The provided pair of " + str(menu.options.auth_type)
err_msg += " HTTP authentication credentials '" + str(menu.options.auth_cred) + "'"
err_msg += " seems to be invalid."
print settings.print_critical_msg(err_msg)
raise SystemExit()
if menu.options.auth_type and menu.options.auth_type != auth_type.lower():
if checks.identified_http_auth_type(auth_type):
menu.options.auth_type = auth_type.lower()
else:
menu.options.auth_type = auth_type.lower()
# Check for stored auth credentials.
if not menu.options.auth_cred:
try:
stored_auth_creds = session_handler.export_valid_credentials(url, auth_type.lower())
except:
stored_auth_creds = False
if stored_auth_creds:
menu.options.auth_cred = stored_auth_creds
success_msg = "Identified a valid (stored) pair of credentials '"
success_msg += menu.options.auth_cred + Style.RESET_ALL + Style.BRIGHT + "'."
print settings.print_success_msg(success_msg)
else:
# Basic authentication
if menu.options.auth_type == "basic":
if not menu.options.ignore_code == settings.UNAUTHORIZED_ERROR:
warn_msg = "(" + menu.options.auth_type.capitalize() + ") "
warn_msg += "HTTP authentication credentials are required."
print settings.print_warning_msg(warn_msg)
while True:
if not menu.options.batch:
question_msg = "Do you want to perform a dictionary-based attack? [Y/n] > "
sys.stdout.write(settings.print_question_msg(question_msg))
do_update = sys.stdin.readline().replace("\n","").lower()
else:
do_update = ""
if len(do_update) == 0:
do_update = "y"
if do_update in settings.CHOICE_YES:
auth_creds = authentication.http_auth_cracker(url, realm)
if auth_creds != False:
menu.options.auth_cred = auth_creds
settings.REQUIRED_AUTHENTICATION = True
break
else:
raise SystemExit()
elif do_update in settings.CHOICE_NO:
checks.http_auth_err_msg()
elif do_update in settings.CHOICE_QUIT:
raise SystemExit()
else:
err_msg = "'" + do_update + "' is not a valid answer."
print settings.print_error_msg(err_msg)
pass
# Digest authentication
elif menu.options.auth_type == "digest":
if not menu.options.ignore_code == settings.UNAUTHORIZED_ERROR:
warn_msg = "(" + menu.options.auth_type.capitalize() + ") "
warn_msg += "HTTP authentication credentials are required."
print settings.print_warning_msg(warn_msg)
# Check if heuristics have failed to identify the realm attribute.
if not realm:
warn_msg = "Heuristics have failed to identify the realm attribute."
print settings.print_warning_msg(warn_msg)
while True:
if not menu.options.batch:
question_msg = "Do you want to perform a dictionary-based attack? [Y/n] > "
sys.stdout.write(settings.print_question_msg(question_msg))
do_update = sys.stdin.readline().replace("\n","").lower()
else:
do_update = ""
if len(do_update) == 0:
do_update = "y"
if do_update in settings.CHOICE_YES:
auth_creds = authentication.http_auth_cracker(url, realm)
if auth_creds != False:
menu.options.auth_cred = auth_creds
settings.REQUIRED_AUTHENTICATION = True
break
else:
raise SystemExit()
elif do_update in settings.CHOICE_NO:
checks.http_auth_err_msg()
elif do_update in settings.CHOICE_QUIT:
raise SystemExit()
else:
err_msg = "'" + do_update + "' is not a valid answer."
print settings.print_error_msg(err_msg)
pass
else:
checks.http_auth_err_msg()
else:
pass
ignore_end = time.time()
start = start - (ignore_start - ignore_end)
def estimate_response_time(url, timesec):
if settings.VERBOSITY_LEVEL >= 1:
info_msg = "Estimating the target URL response time... "
sys.stdout.write(settings.print_info_msg(info_msg))
sys.stdout.flush()
# Check if defined POST data
if menu.options.data:
request = urllib2.Request(url, menu.options.data)
else:
url = parameters.get_url_part(url)
request = urllib2.Request(url)
headers.do_check(request)
start = time.time()
try:
response = urllib2.urlopen(request)
response.read(1)
response.close()
# except urllib2.HTTPError, err:
# pass
except urllib2.HTTPError, err:
ignore_start = time.time()
if "Unauthorized" in str(err) and menu.options.ignore_401:
pass
else:
if settings.VERBOSITY_LEVEL >= 1:
print "[ " + Fore.RED + "FAILED" + Style.RESET_ALL + " ]"
err_msg = "Unable to connect to the target URL"
try:
err_msg += " (" + str(err.args[0]).split("] ")[1] + ")."
except IndexError:
err_msg += " (" + str(err) + ")."
print settings.print_critical_msg(err_msg)
# Check for HTTP Error 401 (Unauthorized).
if str(err.getcode()) == settings.UNAUTHORIZED_ERROR:
try:
# Get the auth header value
auth_line = err.headers.get('www-authenticate', '')
# Checking for authentication type name.
auth_type = auth_line.split()[0]
settings.SUPPORTED_HTTP_AUTH_TYPES.index(auth_type.lower())
# Checking for the realm attribute.
try:
auth_obj = re.match('''(\w*)\s+realm=(.*)''', auth_line).groups()
realm = auth_obj[1].split(',')[0].replace("\"", "")
except:
realm = False
except ValueError:
err_msg = "The identified HTTP authentication type (" + auth_type + ") "
err_msg += "is not yet supported."
print settings.print_critical_msg(err_msg) + "\n"
raise SystemExit()
except IndexError:
err_msg = "The provided pair of " + menu.options.auth_type
err_msg += " HTTP authentication credentials '" + menu.options.auth_cred + "'"
err_msg += " seems to be invalid."
print settings.print_critical_msg(err_msg)
raise SystemExit()
if menu.options.auth_type and menu.options.auth_type != auth_type.lower():
if checks.identified_http_auth_type(auth_type):
menu.options.auth_type = auth_type.lower()
else:
menu.options.auth_type = auth_type.lower()
# Check for stored auth credentials.
if not menu.options.auth_cred:
try:
stored_auth_creds = session_handler.export_valid_credentials(url, auth_type.lower())
except:
stored_auth_creds = False
if stored_auth_creds:
menu.options.auth_cred = stored_auth_creds
success_msg = "Identified a valid (stored) pair of credentials '"
success_msg += menu.options.auth_cred + Style.RESET_ALL + Style.BRIGHT + "'."
print settings.print_success_msg(success_msg)
else:
# Basic authentication
if menu.options.auth_type == "basic":
if not menu.options.ignore_401:
warn_msg = "(" + menu.options.auth_type.capitalize() + ") "
warn_msg += "HTTP authentication credentials are required."
print settings.print_warning_msg(warn_msg)
while True:
if not menu.options.batch:
question_msg = "Do you want to perform a dictionary-based attack? [Y/n] > "
sys.stdout.write(settings.print_question_msg(question_msg))
do_update = sys.stdin.readline().replace("\n","").lower()
else:
do_update = ""
if len(do_update) == 0:
do_update = "y"
if do_update in settings.CHOICE_YES:
auth_creds = authentication.http_auth_cracker(url, realm)
if auth_creds != False:
menu.options.auth_cred = auth_creds
settings.REQUIRED_AUTHENTICATION = True
break
else:
raise SystemExit()
elif do_update in settings.CHOICE_NO:
checks.http_auth_err_msg()
elif do_update in settings.CHOICE_QUIT:
raise SystemExit()
else:
err_msg = "'" + do_update + "' is not a valid answer."
print settings.print_error_msg(err_msg)
pass
# Digest authentication
elif menu.options.auth_type == "digest":
if not menu.options.ignore_401:
warn_msg = "(" + menu.options.auth_type.capitalize() + ") "
warn_msg += "HTTP authentication credentials are required."
print settings.print_warning_msg(warn_msg)
# Check if heuristics have failed to identify the realm attribute.
if not realm:
warn_msg = "Heuristics have failed to identify the realm attribute."
print settings.print_warning_msg(warn_msg)
while True:
if not menu.options.batch:
question_msg = "Do you want to perform a dictionary-based attack? [Y/n] > "
sys.stdout.write(settings.print_question_msg(question_msg))
do_update = sys.stdin.readline().replace("\n","").lower()
else:
do_update = ""
if len(do_update) == 0:
do_update = "y"
if do_update in settings.CHOICE_YES:
auth_creds = authentication.http_auth_cracker(url, realm)
if auth_creds != False:
menu.options.auth_cred = auth_creds
settings.REQUIRED_AUTHENTICATION = True
break
else:
raise SystemExit()
elif do_update in settings.CHOICE_NO:
checks.http_auth_err_msg()
elif do_update in settings.CHOICE_QUIT:
raise SystemExit()
else:
err_msg = "'" + do_update + "' is not a valid answer."
print settings.print_error_msg(err_msg)
pass
else:
checks.http_auth_err_msg()
else:
pass
ignore_end = time.time()
start = start - (ignore_start - ignore_end)
def estimate_response_time(url, timesec):
stored_auth_creds = False
if settings.VERBOSITY_LEVEL >= 1:
info_msg = "Estimating the target URL response time... "
sys.stdout.write(settings.print_info_msg(info_msg))
sys.stdout.flush()
# Check if defined POST data
if menu.options.data:
request = _urllib.request.Request(url, menu.options.data.encode(settings.UNICODE_ENCODING))
else:
url = parameters.get_url_part(url)
request = _urllib.request.Request(url)
headers.do_check(request)
start = time.time()
try:
response = _urllib.request.urlopen(request)
response.read(1)
response.close()
# except _urllib.error.HTTPError as err:
# pass
except _urllib.error.HTTPError as err:
ignore_start = time.time()
if "Unauthorized" in str(err) and menu.options.ignore_code == settings.UNAUTHORIZED_ERROR:
pass
else:
if settings.VERBOSITY_LEVEL >= 1:
print("[ " + Fore.RED + "FAILED" + Style.RESET_ALL + " ]")
err_msg = "Unable to connect to the target URL"
try:
err_msg += " (" + str(err.args[0]).split("] ")[1] + ")."
except IndexError:
err_msg += " (" + str(err) + ")."
print(settings.print_critical_msg(err_msg))
# Check for HTTP Error 401 (Unauthorized).
if str(err.getcode()) == settings.UNAUTHORIZED_ERROR:
try:
# Get the auth header value
auth_line = err.headers.get('www-authenticate', '')
# Checking for authentication type name.
auth_type = auth_line.split()[0]
settings.SUPPORTED_HTTP_AUTH_TYPES.index(auth_type.lower())
# Checking for the realm attribute.
try:
auth_obj = re.match('''(\w*)\s+realm=(.*)''', auth_line).groups()
realm = auth_obj[1].split(',')[0].replace("\"", "")
except:
realm = False
except ValueError:
err_msg = "The identified HTTP authentication type (" + str(auth_type) + ") "
err_msg += "is not yet supported."
print(settings.print_critical_msg(err_msg) + "\n")
raise SystemExit()
except IndexError:
err_msg = "The provided pair of " + str(menu.options.auth_type)
err_msg += " HTTP authentication credentials '" + str(menu.options.auth_cred) + "'"
err_msg += " seems to be invalid."
print(settings.print_critical_msg(err_msg))
raise SystemExit()
if menu.options.auth_type and menu.options.auth_type != auth_type.lower():
if checks.identified_http_auth_type(auth_type):
menu.options.auth_type = auth_type.lower()
else:
menu.options.auth_type = auth_type.lower()
# Check for stored auth credentials.
if not menu.options.auth_cred:
try:
stored_auth_creds = session_handler.export_valid_credentials(url, auth_type.lower())
except:
stored_auth_creds = False
if stored_auth_creds:
menu.options.auth_cred = stored_auth_creds
success_msg = "Identified a valid (stored) pair of credentials '"
success_msg += menu.options.auth_cred + Style.RESET_ALL + Style.BRIGHT + "'."
print(settings.print_success_msg(success_msg))
else:
# Basic authentication
if menu.options.auth_type == "basic":
if not menu.options.ignore_code == settings.UNAUTHORIZED_ERROR:
warn_msg = "(" + menu.options.auth_type.capitalize() + ") "
warn_msg += "HTTP authentication credentials are required."
print(settings.print_warning_msg(warn_msg))
while True:
if not menu.options.batch:
question_msg = "Do you want to perform a dictionary-based attack? [Y/n] > "
do_update = _input(settings.print_question_msg(question_msg))
else:
do_update = ""
if len(do_update) == 0:
do_update = "y"
if do_update in settings.CHOICE_YES:
auth_creds = authentication.http_auth_cracker(url, realm)
if auth_creds != False:
menu.options.auth_cred = auth_creds
settings.REQUIRED_AUTHENTICATION = True
break
else:
raise SystemExit()
elif do_update in settings.CHOICE_NO:
checks.http_auth_err_msg()
elif do_update in settings.CHOICE_QUIT:
raise SystemExit()
else:
err_msg = "'" + do_update + "' is not a valid answer."
print(settings.print_error_msg(err_msg))
pass
# Digest authentication
elif menu.options.auth_type == "digest":
if not menu.options.ignore_code == settings.UNAUTHORIZED_ERROR:
warn_msg = "(" + menu.options.auth_type.capitalize() + ") "
warn_msg += "HTTP authentication credentials are required."
print(settings.print_warning_msg(warn_msg))
# Check if heuristics have failed to identify the realm attribute.
if not realm:
warn_msg = "Heuristics have failed to identify the realm attribute."
print(settings.print_warning_msg(warn_msg))
while True:
if not menu.options.batch:
question_msg = "Do you want to perform a dictionary-based attack? [Y/n] > "
do_update = _input(settings.print_question_msg(question_msg))
else:
do_update = ""
if len(do_update) == 0:
do_update = "y"
if do_update in settings.CHOICE_YES:
auth_creds = authentication.http_auth_cracker(url, realm)
if auth_creds != False:
menu.options.auth_cred = auth_creds
settings.REQUIRED_AUTHENTICATION = True
break
else:
raise SystemExit()
elif do_update in settings.CHOICE_NO:
checks.http_auth_err_msg()
elif do_update in settings.CHOICE_QUIT:
raise SystemExit()
else:
err_msg = "'" + do_update + "' is not a valid answer."
print(settings.print_error_msg(err_msg))
pass
else:
checks.http_auth_err_msg()
else:
pass
ignore_end = time.time()
start = start - (ignore_start - ignore_end)
except socket.timeout:
if settings.VERBOSITY_LEVEL >= 1:
print("[ " + Fore.RED + "FAILED" + Style.RESET_ALL + " ]")
err_msg = "The connection to target URL has timed out."
print(settings.print_critical_msg(err_msg) + "\n")
raise SystemExit()
except _urllib.error.URLError as err_msg:
if settings.VERBOSITY_LEVEL >= 1:
print("[ " + Fore.RED + "FAILED" + Style.RESET_ALL + " ]")
print(settings.print_critical_msg(str(err_msg.args[0]).split("] ")[1] + "."))
raise SystemExit()
except ValueError as err_msg:
if settings.VERBOSITY_LEVEL >= 1:
print("[ " + Fore.RED + "FAILED" + Style.RESET_ALL + " ]")
print(settings.print_critical_msg(str(err_msg) + "."))
raise SystemExit()
end = time.time()
diff = end - start
# if settings.VERBOSITY_LEVEL >= 1:
# info_msg = "Estimating the target URL response time... "
# sys.stdout.write(settings.print_info_msg(info_msg))
# sys.stdout.flush()
if int(diff) < 1:
if settings.VERBOSITY_LEVEL >= 1 and stored_auth_creds == False:
print("[ " + Fore.GREEN + "SUCCEED" + Style.RESET_ALL + " ]")
url_time_response = int(diff)
if settings.TARGET_OS == "win":
warn_msg = "Due to the relatively slow response of 'cmd.exe' in target "
warn_msg += "host, there may be delays during the data extraction procedure."
print(settings.print_warning_msg(warn_msg))
else:
if settings.VERBOSITY_LEVEL >= 1:
print("[ " + Fore.GREEN + "SUCCEED" + Style.RESET_ALL + " ]")
url_time_response = int(round(diff))
warn_msg = "The estimated response time is " + str(url_time_response)
warn_msg += " second" + "s"[url_time_response == 1:] + ". That may cause"
if url_time_response >= 3:
warn_msg += " serious"
warn_msg += " delays during the data extraction procedure"
if url_time_response >= 3:
warn_msg += " and/or possible corruptions over the extracted data"
warn_msg += "."
print(settings.print_warning_msg(warn_msg))
if int(timesec) == int(url_time_response):
timesec = int(timesec) + int(url_time_response)
else:
timesec = int(timesec)
# Against windows targets (for more stability), add one extra second delay.
if settings.TARGET_OS == "win" :
timesec = timesec + 1
return timesec, url_time_response
