def test_server_scan_completed(self):
output_file = StringIO()
generator = ConsoleOutputGenerator(output_file)
server_info = MockServerConnectivityInfo()
plugin_result_1 = MockPluginScanResult(server_info,
MockPluginScanCommandOne(),
u'Plugin ûnicôdé output', None)
plugin_result_2 = MockPluginScanResult(server_info,
MockPluginScanCommandTwo(),
u'other plugin Output', None)
server_scan = CompletedServerScan(server_info,
[plugin_result_1, plugin_result_2])
generator.server_scan_completed(server_scan)
received_output = output_file.getvalue()
output_file.close()
# Ensure the console output displayed the server's info
self.assertIn(server_info.hostname, received_output.lower())
self.assertIn(str(server_info.port), received_output)
self.assertIn(server_info.ip_address, received_output.lower())
# Ensure the console output displayed the plugin text outputs
self.assertIn(plugin_result_1.text_output, received_output)
self.assertIn(plugin_result_2.text_output, received_output)
def test_scans_completed(self):
output_file = StringIO()
generator = ConsoleOutputGenerator(output_file)
scan_time = 1.3
generator.scans_completed(scan_time)
received_output = output_file.getvalue()
output_file.close()
# Ensure the console output displayed the total scan time
self.assertIn(str(scan_time), received_output)
def test_scans_started(self):
output_file = StringIO()
generator = ConsoleOutputGenerator(output_file)
generator.scans_started()
received_output = output_file.getvalue()
output_file.close()
# Ensure the console output displayed something
self.assertTrue(received_output)
def test_scans_started(self):
output_file = StringIO()
generator = ConsoleOutputGenerator(output_file)
generator.scans_started()
received_output = output_file.getvalue()
output_file.close()
# Ensure the console output displayed something
self.assertTrue(received_output)
def test_scans_completed(self):
output_file = StringIO()
generator = ConsoleOutputGenerator(output_file)
scan_time = 1.3
generator.scans_completed(scan_time)
received_output = output_file.getvalue()
output_file.close()
# Ensure the console output displayed the total scan time
self.assertIn(str(scan_time), received_output)
def test_scans_completed(self):
# Given the time sslyze took to complete all scans
scan_time = 1.3
# When generating the console output for this
with StringIO() as file_out:
console_gen = ConsoleOutputGenerator(file_to=file_out)
console_gen.scans_completed(scan_time)
final_output = file_out.getvalue()
# It succeeds and the total scan time is displayed
assert str(scan_time) in final_output
def test_server_connectivity_test_succeeded_with_optional_client_auth(self):
# Test when client authentication is optional
output_file = StringIO()
generator = ConsoleOutputGenerator(output_file)
server_info = MockServerConnectivityInfo(ClientAuthenticationServerConfigurationEnum.OPTIONAL)
generator.server_connectivity_test_succeeded(server_info)
received_output = output_file.getvalue()
output_file.close()
# Ensure the console output properly warned about client authentication
self.assertIn('Server requested optional client authentication', received_output)
def test_server_connectivity_test_failed(self):
# Given a server to scan to which sslyze could not connect
error = ConnectionToServerFailedFactory.create()
# When generating the console output for this
with StringIO() as file_out:
console_gen = ConsoleOutputGenerator(file_to=file_out)
console_gen.server_connectivity_test_failed(error)
final_output = file_out.getvalue()
# It succeeds and the connectivity error was displayed
assert final_output
assert error.error_message in final_output
def test_server_connectivity_test_succeeded(self):
# Given a server to scan to which sslyze was able to connect
server_info = ServerConnectivityInfoFactory.create()
# When generating the console output for this
with StringIO() as file_out:
console_gen = ConsoleOutputGenerator(file_to=file_out)
console_gen.server_connectivity_test_succeeded(server_info)
final_output = file_out.getvalue()
# It succeeds and the server is displayed
assert final_output
assert server_info.server_location.hostname in final_output
def test_server_connectivity_test_succeeded_with_optional_client_auth(self):
# Test when client authentication is optional
output_file = StringIO()
generator = ConsoleOutputGenerator(output_file)
server_info = MockServerConnectivityInfo(ClientAuthenticationServerConfigurationEnum.OPTIONAL)
generator.server_connectivity_test_succeeded(server_info)
received_output = output_file.getvalue()
output_file.close()
# Ensure the console output properly warned about client authentication
assert 'Server requested optional client authentication' in received_output
def test_server_connectivity_test_succeeded_with_required_client_auth(self):
# Test when client authentication is required
output_file = StringIO()
generator = ConsoleOutputGenerator(output_file)
server_info = MockServerConnectivityInfo(ClientAuthenticationServerConfigurationEnum.REQUIRED)
generator.server_connectivity_test_succeeded(server_info)
received_output = output_file.getvalue()
output_file.close()
# Ensure the console output properly warned about client authentication
assert 'Server REQUIRED client authentication' in received_output
def test_server_connectivity_test_failed(self):
output_file = StringIO()
generator = ConsoleOutputGenerator(output_file)
failed_scan = ServerConnectivityError(server_info=MockServerConnectivityTester(), error_message='Some érrôr')
generator.server_connectivity_test_failed(failed_scan)
received_output = output_file.getvalue()
output_file.close()
# Ensure the console output properly listed the connectivity error with unicode
self.assertIn('unicödeéè.com', received_output)
self.assertIn('Some érrôr', received_output)
self.assertIn('discarding corresponding tasks', received_output)
def test_server_connectivity_test_failed(self):
output_file = StringIO()
generator = ConsoleOutputGenerator(output_file)
failed_scan = ServerConnectivityError(server_info=MockServerConnectivityTester(), error_message='Some érrôr')
generator.server_connectivity_test_failed(failed_scan)
received_output = output_file.getvalue()
output_file.close()
# Ensure the console output properly listed the connectivity error with unicode
assert 'unicödeéè.com' in received_output
assert 'Some érrôr' in received_output
assert 'discarding corresponding tasks' in received_output
def test_server_connectivity_test_succeeded(self):
output_file = StringIO()
generator = ConsoleOutputGenerator(output_file)
server_info = MockServerConnectivityInfo()
generator.server_connectivity_test_succeeded(server_info)
received_output = output_file.getvalue()
output_file.close()
# Ensure the console output properly listed the online domain
self.assertIn(server_info.hostname, received_output)
self.assertIn(str(server_info.port), received_output)
self.assertIn(server_info.ip_address, received_output)
def test_server_connectivity_test_succeeded(self):
output_file = StringIO()
generator = ConsoleOutputGenerator(output_file)
server_info = MockServerConnectivityInfo()
generator.server_connectivity_test_succeeded(server_info)
received_output = output_file.getvalue()
output_file.close()
# Ensure the console output properly listed the online domain
self.assertIn(server_info.hostname, received_output)
self.assertIn(str(server_info.port), received_output)
self.assertIn(server_info.ip_address, received_output)
def test_server_connectivity_test_failed(self):
output_file = StringIO()
generator = ConsoleOutputGenerator(output_file)
failed_scan = FailedServerScan(server_string=u'unicödeéè.com',
connection_exception=ServerConnectivityError(error_msg=u'Some érrôr'))
generator.server_connectivity_test_failed(failed_scan)
received_output = output_file.getvalue()
output_file.close()
# Ensure the console output properly listed the connectivity error with unicode
self.assertIn(u'unicödeéè.com', received_output)
self.assertIn(u'Some érrôr', received_output)
self.assertIn('discarding corresponding tasks', received_output)
def test_server_connectivity_test_succeeded_with_required_client_auth(
self):
# Test when client authentication is required
output_file = StringIO()
generator = ConsoleOutputGenerator(output_file)
server_info = MockServerConnectivityInfo(
ClientAuthenticationServerConfigurationEnum.REQUIRED)
generator.server_connectivity_test_succeeded(server_info)
received_output = output_file.getvalue()
output_file.close()
# Ensure the console output properly warned about client authentication
self.assertIn('Server REQUIRED client authentication', received_output)
def test_server_connectivity_test_succeeded_with_http_tunneling(self):
# Given a server to scan to which sslyze was able to connect
server_info = ServerConnectivityInfoFactory.create(
# And sslyze connected to it via an HTTP proxy
server_location=ServerNetworkLocationViaHttpProxyFactory.create())
# When generating the console output for this
with StringIO() as file_out:
console_gen = ConsoleOutputGenerator(file_to=file_out)
console_gen.server_connectivity_test_succeeded(server_info)
final_output = file_out.getvalue()
# It succeeds and the fact that an HTTP proxy was used was displayed
assert final_output
assert "proxy" in final_output
def command_line_parsed(
self,
available_plugins: Set[Type[Plugin]],
args_command_list: Any,
malformed_servers: List[ServerStringParsingError],
) -> None:
# Configure the console output
should_print_text_results = (
not args_command_list.quiet and args_command_list.xml_file != "-" and args_command_list.json_file != "-"
)
if should_print_text_results:
self._output_generator_list.append(ConsoleOutputGenerator(sys.stdout))
# Configure the JSON output
if args_command_list.json_file:
json_file_to = (
sys.stdout
if args_command_list.json_file == "-"
else open(args_command_list.json_file, "wt", encoding="utf-8")
)
self._output_generator_list.append(JsonOutputGenerator(json_file_to)) # type: ignore
# Configure the XML output
if args_command_list.xml_file:
xml_file_to = (
sys.stdout
if args_command_list.xml_file == "-"
else open(args_command_list.xml_file, "wt", encoding="utf-8")
)
self._output_generator_list.append(XmlOutputGenerator(xml_file_to)) # type: ignore
# Forward the notification
for out_generator in self._output_generator_list:
out_generator.command_line_parsed(available_plugins, args_command_list, malformed_servers)
def command_line_parsed(self, available_plugins, args_command_list):
# Configure the console output
should_print_text_results = not args_command_list.quiet and args_command_list.xml_file != '-' \
and args_command_list.json_file != '-'
if should_print_text_results:
self._output_generator_list.append(
ConsoleOutputGenerator(sys.stdout))
# Configure the JSON output
json_file_to = None
if args_command_list.json_file:
json_file_to = sys.stdout if args_command_list.json_file == '-' else open(
args_command_list.json_file, 'w')
if json_file_to:
self._output_generator_list.append(
JsonOutputGenerator(json_file_to))
# Configure the XML output
xml_file_to = None
if args_command_list.xml_file:
xml_file_to = sys.stdout if args_command_list.xml_file == '-' else open(
args_command_list.xml_file, 'w')
if xml_file_to:
self._output_generator_list.append(XmlOutputGenerator(xml_file_to))
# Forward the notification
for out_generator in self._output_generator_list:
out_generator.command_line_parsed(available_plugins,
args_command_list)
def command_line_parsed(self, available_plugins, args_command_list,
malformed_servers):
# type: (Set[Type[Plugin]], Any, List[ServerStringParsingError]) -> None
# Configure the console output
should_print_text_results = not args_command_list.quiet and args_command_list.xml_file != '-' \
and args_command_list.json_file != '-'
if should_print_text_results:
self._output_generator_list.append(
ConsoleOutputGenerator(sys.stdout))
# Configure the JSON output
if args_command_list.json_file:
json_file_to = sys.stdout if args_command_list.json_file == '-' else open(
args_command_list.json_file, 'wt')
self._output_generator_list.append(
JsonOutputGenerator(json_file_to)) # type: ignore
# Configure the XML output
if args_command_list.xml_file:
xml_file_to = sys.stdout if args_command_list.xml_file == '-' else open(
args_command_list.xml_file, 'wt')
self._output_generator_list.append(
XmlOutputGenerator(xml_file_to)) # type: ignore
# Forward the notification
for out_generator in self._output_generator_list:
out_generator.command_line_parsed(available_plugins,
args_command_list,
malformed_servers)
def test_server_connectivity_test_failed(self):
output_file = StringIO()
generator = ConsoleOutputGenerator(output_file)
failed_scan = FailedServerScan(
server_string=u'unicödeéè.com',
connection_exception=ServerConnectivityError(
error_msg=u'Some érrôr'))
generator.server_connectivity_test_failed(failed_scan)
received_output = output_file.getvalue()
output_file.close()
# Ensure the console output properly listed the connectivity error with unicode
self.assertIn(u'unicödeéè.com', received_output)
self.assertIn(u'Some érrôr', received_output)
self.assertIn(u'discarding corresponding tasks', received_output)
def test_command_line_parsed(self):
output_file = StringIO()
generator = ConsoleOutputGenerator(output_file)
class FakePlugin1:
pass
class FakePlugin2:
pass
generator.command_line_parsed({FakePlugin1, FakePlugin2}, None, [])
received_output = output_file.getvalue()
output_file.close()
# Ensure the console output properly listed the available plugins
assert 'FakePlugin1' in received_output
assert 'FakePlugin2' in received_output
def test_server_scan_completed(self):
# Given a completed scan for a server
scan_results = {
ScanCommand.TLS_COMPRESSION:
CompressionScanResult(supports_compression=True)
}
scan_result = ServerScanResultFactory.create(
scan_commands_results=scan_results)
# When generating the console output for this server scan
with StringIO() as file_out:
console_gen = ConsoleOutputGenerator(file_to=file_out)
console_gen.server_scan_completed(scan_result)
final_output = file_out.getvalue()
# It succeeds
assert final_output
assert "Compression" in final_output
def test_command_line_parsed(self):
output_file = StringIO()
generator = ConsoleOutputGenerator(output_file)
class FakePlugin1(object):
pass
class FakePlugin2(object):
pass
generator.command_line_parsed([FakePlugin1, FakePlugin2], None)
received_output = output_file.getvalue()
output_file.close()
# Ensure the console output properly listed the available plugins
self.assertIn(u'FakePlugin1', received_output)
self.assertIn(u'FakePlugin2', received_output)
def test_command_line_parsed(self):
output_file = StringIO()
generator = ConsoleOutputGenerator(output_file)
class FakePlugin1:
pass
class FakePlugin2:
pass
generator.command_line_parsed({FakePlugin1, FakePlugin2}, None, [])
received_output = output_file.getvalue()
output_file.close()
# Ensure the console output properly listed the available plugins
self.assertIn('FakePlugin1', received_output)
self.assertIn('FakePlugin2', received_output)
def command_line_parsed(self, parsed_command_line: ParsedCommandLine) -> None:
if not parsed_command_line.should_disable_console_output:
self._output_generator_list.append(ConsoleOutputGenerator(sys.stdout))
if parsed_command_line.json_file_out:
self._output_generator_list.append(JsonOutputGenerator(parsed_command_line.json_file_out))
# Forward the notification
for out_generator in self._output_generator_list:
out_generator.command_line_parsed(parsed_command_line)
def test_command_line_parsed(self):
# Given a command line used to run sslyze
parsed_cmd_line = ParsedCommandLineFactory.create()
# Which contained some valid, and some invalid servers
assert parsed_cmd_line.invalid_servers
assert parsed_cmd_line.servers_to_scans
# When generating the console output for this
with StringIO() as file_out:
console_gen = ConsoleOutputGenerator(file_to=file_out)
console_gen.command_line_parsed(parsed_cmd_line)
final_output = file_out.getvalue()
# It succeeds and the invalid servers were displayed
assert final_output
for bad_server in parsed_cmd_line.invalid_servers:
assert bad_server.server_string in final_output
assert bad_server.error_message in final_output
def test_server_connectivity_test_succeeded_with_http_tunneling(self):
output_file = StringIO()
generator = ConsoleOutputGenerator(output_file)
# When scanning through a proxy, we do not know the final server's IP address
# This makes sure the console output properly handles that
tunneling_settings = HttpConnectTunnelingSettings('ûnicôdé.com', 3128)
server_info = MockServerConnectivityInfo(http_tunneling_settings=tunneling_settings)
generator.server_connectivity_test_succeeded(server_info)
received_output = output_file.getvalue()
output_file.close()
# Ensure the console output properly listed the online domain and that it was going through a proxy
assert server_info.hostname in received_output
assert str(server_info.port) in received_output
assert 'Proxy' in received_output
assert tunneling_settings.hostname in received_output
assert str(tunneling_settings.port) in received_output
def test_server_scan_completed_with_error(self):
# Given a completed scan for a server that triggered an error
error_trace = TracebackExceptionFactory.create()
scan_errors = {
ScanCommand.TLS_COMPRESSION:
ScanCommandError(reason=ScanCommandErrorReasonEnum.BUG_IN_SSLYZE,
exception_trace=error_trace)
}
scan_result = ServerScanResultFactory.create(
scan_commands_errors=scan_errors)
# When generating the console output for this server scan
with StringIO() as file_out:
console_gen = ConsoleOutputGenerator(file_to=file_out)
console_gen.server_scan_completed(scan_result)
final_output = file_out.getvalue()
# It succeeds and displays the error
assert final_output
assert error_trace.stack.format()[0] in final_output
def test_server_connectivity_test_succeeded_with_required_client_auth(
self):
# Given a server to scan to which sslyze was able to connect
server_info = ServerConnectivityInfoFactory.create(
tls_probing_result=ServerTlsProbingResult(
highest_tls_version_supported=TlsVersionEnum.TLS_1_2,
cipher_suite_supported="AES",
# And the server requires client authentication
client_auth_requirement=ClientAuthRequirementEnum.REQUIRED,
))
# When generating the console output for this
with StringIO() as file_out:
console_gen = ConsoleOutputGenerator(file_to=file_out)
console_gen.server_connectivity_test_succeeded(server_info)
final_output = file_out.getvalue()
# It succeeds and the fact that the server requires client auth was displayed
assert final_output
assert "Server REQUIRED client authentication" in final_output
def test_server_connectivity_test_succeeded_with_http_tunneling(self):
output_file = StringIO()
generator = ConsoleOutputGenerator(output_file)
# When scanning through a proxy, we do not know the final server's IP address
# This makes sure the console output properly handles that
tunneling_settings = HttpConnectTunnelingSettings('ûnicôdé.com', 3128)
server_info = MockServerConnectivityInfo(http_tunneling_settings=tunneling_settings)
generator.server_connectivity_test_succeeded(server_info)
received_output = output_file.getvalue()
output_file.close()
# Ensure the console output properly listed the online domain and that it was going through a proxy
self.assertIn(server_info.hostname, received_output)
self.assertIn(str(server_info.port), received_output)
self.assertIn('Proxy', received_output)
self.assertIn(tunneling_settings.hostname, received_output)
self.assertIn(str(tunneling_settings.port), received_output)
def test_server_scan_completed_with_http_tunneling(self):
output_file = StringIO()
generator = ConsoleOutputGenerator(output_file)
# When scanning through a proxy, we do not know the final server's IP address
# This makes sure the console output properly handles that
tunneling_settings = HttpConnectTunnelingSettings('ûnicôdé.com', 3128)
server_info = MockServerConnectivityInfo(http_tunneling_settings=tunneling_settings)
server_scan = CompletedServerScan(server_info, [])
generator.server_scan_completed(server_scan)
received_output = output_file.getvalue()
output_file.close()
# Ensure the console output properly listed the online domain and that it was going through a proxy
assert server_info.hostname in received_output.lower()
assert str(server_info.port) in received_output.lower()
assert 'proxy' in received_output.lower()
assert tunneling_settings.hostname in received_output.lower()
assert str(tunneling_settings.port) in received_output.lower()
def test_server_scan_completed(self):
output_file = StringIO()
generator = ConsoleOutputGenerator(output_file)
server_info = MockServerConnectivityInfo()
plugin_result_1 = MockPluginScanResult(server_info, MockPluginScanCommandOne(), 'Plugin ûnicôdé output', None)
plugin_result_2 = MockPluginScanResult(server_info, MockPluginScanCommandTwo(), 'other plugin Output', None)
server_scan = CompletedServerScan(server_info, [plugin_result_1, plugin_result_2])
generator.server_scan_completed(server_scan)
received_output = output_file.getvalue()
output_file.close()
# Ensure the console output displayed the server's info
self.assertIn(server_info.hostname, received_output.lower())
self.assertIn(str(server_info.port), received_output)
self.assertIn(server_info.ip_address, received_output.lower())
# Ensure the console output displayed the plugin text outputs
self.assertIn(plugin_result_1.text_output, received_output)
self.assertIn(plugin_result_2.text_output, received_output)
def test_server_scan_completed_with_proxy(self):
# Given a completed scan for a server
server_info = ServerConnectivityInfoFactory.create(
# And sslyze connected to the server via an HTTP proxy
server_location=ServerNetworkLocationViaHttpProxyFactory.create())
scan_results = {
ScanCommand.TLS_COMPRESSION:
CompressionScanResult(supports_compression=True)
}
scan_result = ServerScanResultFactory.create(
server_info=server_info, scan_commands_results=scan_results)
# When generating the console output for this server scan
with StringIO() as file_out:
console_gen = ConsoleOutputGenerator(file_to=file_out)
console_gen.server_scan_completed(scan_result)
final_output = file_out.getvalue()
# It succeeds and mentions the HTTP proxy
assert final_output
assert "HTTP PROXY" in final_output
assert "Compression" in final_output
def test_server_scan_completed_with_http_tunneling(self):
output_file = StringIO()
generator = ConsoleOutputGenerator(output_file)
# When scanning through a proxy, we do not know the final server's IP address
# This makes sure the console output properly handles that
tunneling_settings = HttpConnectTunnelingSettings(u'ûnicôdé.com', 3128)
server_info = MockServerConnectivityInfo(
http_tunneling_settings=tunneling_settings)
server_scan = CompletedServerScan(server_info, [])
generator.server_scan_completed(server_scan)
received_output = output_file.getvalue()
output_file.close()
# Ensure the console output properly listed the online domain and that it was going through a proxy
self.assertIn(server_info.hostname, received_output.lower())
self.assertIn(str(server_info.port), received_output.lower())
self.assertIn('proxy', received_output.lower())
self.assertIn(tunneling_settings.hostname, received_output.lower())
self.assertIn(str(tunneling_settings.port), received_output.lower())
def command_line_parsed(self, parsed_command_line: ParsedCommandLine) -> None:
# Setup console output if needed
if not parsed_command_line.should_disable_console_output:
self._output_generator_list.append(ConsoleOutputGenerator(sys.stdout))
# Setup JSON output if needed
json_file_out = None
if parsed_command_line.should_print_json_to_console:
json_file_out = sys.stdout
elif parsed_command_line.json_path_out:
json_file_out = parsed_command_line.json_path_out.open("wt", encoding="utf-8")
if json_file_out:
self._output_generator_list.append(JsonOutputGenerator(json_file_out))
# Forward the notification
for out_generator in self._output_generator_list:
out_generator.command_line_parsed(parsed_command_line)
def test_scans_started(self):
with StringIO() as file_out:
console_gen = ConsoleOutputGenerator(file_to=file_out)
console_gen.scans_started()
final_output = file_out.getvalue()
assert final_output
