secator 0.6.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

secator/decorators.py

@@ -1,30 +1,33 @@
 import sys
+
 from collections import OrderedDict
 
 import rich_click as click
 from rich_click.rich_click import _get_rich_console
 from rich_click.rich_group import RichGroup
 
-from secator.definitions import ADDONS_ENABLED, OPT_NOT_SUPPORTED
 from secator.config import CONFIG
+from secator.definitions import ADDONS_ENABLED, OPT_NOT_SUPPORTED
 from secator.runners import Scan, Task, Workflow
-from secator.utils import (deduplicate, expand_input, get_command_category,
-						   get_command_cls)
+from secator.utils import (deduplicate, expand_input, get_command_category)
 
 RUNNER_OPTS = {
 	'output': {'type': str, 'default': None, 'help': 'Output options (-o table,json,csv,gdrive)', 'short': 'o'},
 	'workspace': {'type': str, 'default': 'default', 'help': 'Workspace', 'short': 'ws'},
-	'json': {'is_flag': True, 'default': False, 'help': 'Enable JSON mode'},
-	'orig': {'is_flag': True, 'default': False, 'help': 'Enable original output (no schema conversion)'},
-	'raw': {'is_flag': True, 'default': False, 'help': 'Enable text output for piping to other tools'},
+	'print_json': {'is_flag': True, 'short': 'json', 'default': False, 'help': 'Print items as JSON lines'},
+	'print_raw': {'is_flag': True, 'short': 'raw', 'default': False, 'help': 'Print items in raw format'},
+	'print_stat': {'is_flag': True, 'short': 'stat', 'default': False, 'help': 'Print runtime statistics'},
+	'print_format': {'default': '', 'short': 'fmt', 'help': 'Output formatting string'},
+	'enable_profiler': {'is_flag': True, 'short': 'prof', 'default': False, 'help': 'Enable runner profiling'},
 	'show': {'is_flag': True, 'default': False, 'help': 'Show command that will be run (tasks only)'},
-	'format': {'default': '', 'short': 'fmt', 'help': 'Output formatting string'},
+	'no_process': {'is_flag': True, 'default': False, 'help': 'Disable secator processing'},
 	# 'filter': {'default': '', 'short': 'f', 'help': 'Results filter', 'short': 'of'}, # TODO add this
 	'quiet': {'is_flag': True, 'default': False, 'help': 'Enable quiet mode'},
 }
 
 RUNNER_GLOBAL_OPTS = {
 	'sync': {'is_flag': True, 'help': 'Run tasks synchronously (automatic if no worker is alive)'},
+	'worker': {'is_flag': True, 'default': False, 'help': 'Run tasks in worker'},
 	'proxy': {'type': str, 'help': 'HTTP proxy'},
 	'driver': {'type': str, 'help': 'Export real-time results. E.g: "mongodb"'}
 	# 'debug': {'type': int, 'default': 0, 'help': 'Debug mode'},
@@ -100,20 +103,34 @@ class OrderedGroup(RichGroup):
 		return self.commands
 
 
-def get_command_options(*tasks):
-	"""Get unified list of command options from a list of secator tasks classes.
+def get_command_options(config):
+	"""Get unified list of command options from a list of secator tasks classes and optionally a Runner config.
 
 	Args:
-		tasks (list): List of secator command classes.
+		config (TemplateLoader): Current runner config.
 
 	Returns:
 		list: List of deduplicated options.
 	"""
+	from secator.utils import debug
 	opt_cache = []
 	all_opts = OrderedDict({})
+	tasks = config.flat_tasks
+	tasks_cls = set([c['class'] for c in tasks.values()])
 
-	for cls in tasks:
+	# Loop through tasks and set options
+	for cls in tasks_cls:
 		opts = OrderedDict(RUNNER_GLOBAL_OPTS, **RUNNER_OPTS, **cls.meta_opts, **cls.opts)
+
+		# Find opts defined in config corresponding to this task class
+		# TODO: rework this as this ignores subsequent tasks of the same task class
+		task_config_opts = {}
+		if config.type != 'task':
+			for k, v in tasks.items():
+				if v['class'] == cls:
+					task_config_opts = v['opts']
+
+		# Loop through options
 		for opt, opt_conf in opts.items():
 
 			# Get opt key map if any
@@ -126,6 +143,7 @@ def get_command_options(*tasks):
 				and opt not in RUNNER_GLOBAL_OPTS:
 				continue
 
+			# Opt is defined as unsupported
 			if opt_key_map.get(opt) == OPT_NOT_SUPPORTED:
 				continue
 
@@ -143,17 +161,50 @@ def get_command_options(*tasks):
 			elif opt in RUNNER_GLOBAL_OPTS:
 				prefix = 'Execution'
 
+			# Get opt conf
+			conf = opt_conf.copy()
+			conf['show_default'] = True
+			conf['prefix'] = prefix
+			opt_default = conf.get('default', None)
+			opt_is_flag = conf.get('is_flag', False)
+			opt_value_in_config = task_config_opts.get(opt)
+
+			# Check if opt already defined in config
+			if opt_value_in_config:
+				if conf.get('required', False):
+					debug('OPT (skipped: opt is required and defined in config)', obj={'opt': opt}, sub=f'cli.{config.name}', verbose=True)  # noqa: E501
+					continue
+				mapped_value = cls.opt_value_map.get(opt)
+				if callable(mapped_value):
+					opt_value_in_config = mapped_value(opt_value_in_config)
+				elif mapped_value:
+					opt_value_in_config = mapped_value
+				if opt_value_in_config != opt_default:
+					if opt in opt_cache:
+						continue
+					if opt_is_flag:
+						conf['reverse'] = True
+						conf['default'] = not conf['default']
+					# print(f'{opt}: change default to {opt_value_in_config}')
+					conf['default'] = opt_value_in_config
+
+			# If opt is a flag but the default is True, add opposite flag
+			if opt_is_flag and opt_default is True:
+				conf['reverse'] = True
+
 			# Check if opt already processed before
-			opt = opt.replace('_', '-')
 			if opt in opt_cache:
+				# debug('OPT (skipped: opt is already in opt cache)', obj={'opt': opt}, sub=f'cli.{config.name}', verbose=True)
 				continue
 
 			# Build help
-			conf = opt_conf.copy()
-			conf['show_default'] = True
-			conf['prefix'] = prefix
-			all_opts[opt] = conf
 			opt_cache.append(opt)
+			opt = opt.replace('_', '-')
+			all_opts[opt] = conf
+
+			# Debug
+			debug_conf = OrderedDict({'opt': opt, 'config_val': opt_value_in_config or 'N/A', **conf.copy()})
+			debug('OPT', obj=debug_conf, sub=f'cli.{config.name}', verbose=True)
 
 	return all_opts
 
@@ -171,11 +222,19 @@ def decorate_command_options(opts):
 		reversed_opts = OrderedDict(list(opts.items())[::-1])
 		for opt_name, opt_conf in reversed_opts.items():
 			conf = opt_conf.copy()
-			short = conf.pop('short', None)
-			conf.pop('internal', False)
+			short_opt = conf.pop('short', None)
+			conf.pop('internal', None)
 			conf.pop('prefix', None)
+			conf.pop('shlex', None)
+			conf.pop('meta', None)
+			conf.pop('supported', None)
+			conf.pop('process', None)
+			reverse = conf.pop('reverse', False)
 			long = f'--{opt_name}'
-			short = f'-{short}' if short else f'-{opt_name}'
+			short = f'-{short_opt}' if short_opt else f'-{opt_name}'
+			if reverse:
+				long += f'/--no-{opt_name}'
+				short += f'/-n{short_opt}' if short else f'/-n{opt_name}'
 			f = click.option(long, short, **conf)(f)
 		return f
 	return decorator
@@ -188,66 +247,56 @@ def task():
 	return decorator
 
 
+def generate_cli_subcommand(cli_endpoint, func, **opts):
+	return cli_endpoint.command(**opts)(func)
+
+
 def register_runner(cli_endpoint, config):
-	fmt_opts = {
-		'print_cmd': True,
-	}
-	short_help = ''
-	input_type = 'targets'
+	name = config.name
 	input_required = True
-	runner_cls = None
-	tasks = []
-	no_args_is_help = True
+	input_type = 'targets'
+	command_opts = {
+		'no_args_is_help': True,
+		'context_settings': {
+			'ignore_unknown_options': False,
+			'allow_extra_args': False
+		}
+	}
 
 	if cli_endpoint.name == 'scan':
-		# TODO: this should be refactored to scan.get_tasks_from_conf() or scan.tasks
-		from secator.cli import ALL_CONFIGS
-		tasks = [
-			get_command_cls(task)
-			for workflow in ALL_CONFIGS.workflow
-			for task in Task.get_tasks_from_conf(workflow.tasks)
-			if workflow.name in list(config.workflows.keys())
-		]
-		input_type = 'targets'
-		name = config.name
-		short_help = config.description or ''
-		if config.alias:
-			short_help += f' [dim]alias: {config.alias}'
-		fmt_opts['print_start'] = True
-		fmt_opts['print_run_summary'] = True
-		fmt_opts['print_progress'] = False
 		runner_cls = Scan
+		short_help = config.description or ''
+		short_help += f' [dim]alias: {config.alias}' if config.alias else ''
+		command_opts.update({
+			'name': name,
+			'short_help': short_help
+		})
 
 	elif cli_endpoint.name == 'workflow':
-		# TODO: this should be refactored to workflow.get_tasks_from_conf() or workflow.tasks
-		tasks = [
-			get_command_cls(task) for task in Task.get_tasks_from_conf(config.tasks)
-		]
-		input_type = 'targets'
-		name = config.name
-		short_help = config.description or ''
-		if config.alias:
-			short_help = f'{short_help:<55} [dim](alias)[/][bold cyan] {config.alias}'
-		fmt_opts['print_start'] = True
-		fmt_opts['print_run_summary'] = True
-		fmt_opts['print_progress'] = False
 		runner_cls = Workflow
+		short_help = config.description or ''
+		short_help = f'{short_help:<55} [dim](alias)[/][bold cyan] {config.alias}' if config.alias else ''
+		command_opts.update({
+			'name': name,
+			'short_help': short_help
+		})
 
 	elif cli_endpoint.name == 'task':
-		tasks = [
-			get_command_cls(config.name)
-		]
+		runner_cls = Task
+		input_required = False  # allow targets from stdin
 		task_cls = Task.get_task_class(config.name)
 		task_category = get_command_category(task_cls)
 		input_type = task_cls.input_type or 'targets'
-		name = config.name
 		short_help = f'[magenta]{task_category:<15}[/]{task_cls.__doc__}'
-		fmt_opts['print_item_count'] = True
-		runner_cls = Task
-		no_args_is_help = False
-		input_required = False
+		command_opts.update({
+			'name': name,
+			'short_help': short_help,
+			'no_args_is_help': False
+		})
 
-	options = get_command_options(*tasks)
+	else:
+		raise ValueError(f"Unrecognized runner endpoint name {cli_endpoint.name}")
+	options = get_command_options(config)
 
 	# TODO: maybe allow this in the future
 	# def get_unknown_opts(ctx):
@@ -262,24 +311,59 @@ def register_runner(cli_endpoint, config):
 	@decorate_command_options(options)
 	@click.pass_context
 	def func(ctx, **opts):
-		opts.update(fmt_opts)
 		sync = opts['sync']
-		# debug = opts['debug']
+		worker = opts.pop('worker')
 		ws = opts.pop('workspace')
 		driver = opts.pop('driver', '')
 		show = opts['show']
 		context = {'workspace_name': ws}
+
+		# Remove options whose values are default values
+		for k, v in options.items():
+			opt_name = k.replace('-', '_')
+			if opt_name in opts and opts[opt_name] == v.get('default', None):
+				del opts[opt_name]
+
 		# TODO: maybe allow this in the future
 		# unknown_opts = get_unknown_opts(ctx)
 		# opts.update(unknown_opts)
-		targets = opts.pop(input_type)
-		targets = expand_input(targets)
+
+		# Expand input
+		inputs = opts.pop(input_type)
+		inputs = expand_input(inputs, ctx)
+
+		# Build hooks from driver name
+		hooks = []
+		drivers = driver.split(',') if driver else []
+		console = _get_rich_console()
+		supported_drivers = ['mongodb', 'gcs']
+		for driver in drivers:
+			if driver in supported_drivers:
+				if not ADDONS_ENABLED[driver]:
+					console.print(f'[bold red]Missing "{driver}" addon: please run `secator install addons {driver}`[/].')
+					sys.exit(1)
+				from secator.utils import import_dynamic
+				driver_hooks = import_dynamic(f'secator.hooks.{driver}', 'HOOKS')
+				if driver_hooks is None:
+					console.print(f'[bold red]Missing "secator.hooks.{driver}.HOOKS".[/]')
+					sys.exit(1)
+				hooks.append(driver_hooks)
+			else:
+				supported_drivers_str = ', '.join([f'[bold green]{_}[/]' for _ in supported_drivers])
+				console.print(f'[bold red]Driver "{driver}" is not supported.[/]')
+				console.print(f'Supported drivers: {supported_drivers_str}')
+				sys.exit(1)
+
+		from secator.utils import deep_merge_dicts
+		hooks = deep_merge_dicts(*hooks)
+
+		# Enable sync or not
 		if sync or show:
 			sync = True
 		else:
 			from secator.celery import is_celery_worker_alive
 			worker_alive = is_celery_worker_alive()
-			if not worker_alive:
+			if not worker_alive and not worker:
 				sync = True
 			else:
 				sync = False
@@ -289,34 +373,28 @@ def register_runner(cli_endpoint, config):
 					if (broker_protocol == 'redis' or backend_protocol == 'redis') and not ADDONS_ENABLED['redis']:
 						_get_rich_console().print('[bold red]Missing `redis` addon: please run `secator install addons redis`[/].')
 						sys.exit(1)
-		opts['sync'] = sync
+
+		from secator.utils import debug
+		debug('Run options', obj=opts, sub='cli')
+
+		# Set run options
 		opts.update({
-			'print_item': not sync,
-			'print_line': sync,
-			'print_remote_status': not sync,
-			'print_start': not sync
+			'print_cmd': True,
+			'print_item': True,
+			'print_line': True,
+			'print_progress': True,
+			'print_remote_info': not sync,
+			'piped_input': ctx.obj['piped_input'],
+			'piped_output': ctx.obj['piped_output'],
+			'caller': 'cli',
+			'sync': sync,
 		})
 
-		# Build hooks from driver name
-		hooks = {}
-		if driver == 'mongodb':
-			if not ADDONS_ENABLED['mongodb']:
-				_get_rich_console().print('[bold red]Missing `mongodb` addon: please run `secator install addons mongodb`[/].')
-				sys.exit(1)
-			from secator.hooks.mongodb import MONGODB_HOOKS
-			hooks = MONGODB_HOOKS
-
-		# Build exporters
-		runner = runner_cls(config, targets, run_opts=opts, hooks=hooks, context=context)
+		# Start runner
+		runner = runner_cls(config, inputs, run_opts=opts, hooks=hooks, context=context)
 		runner.run()
 
-	settings = {'ignore_unknown_options': False, 'allow_extra_args': False}
-	cli_endpoint.command(
-		name=config.name,
-		context_settings=settings,
-		no_args_is_help=no_args_is_help,
-		short_help=short_help)(func)
-
+	generate_cli_subcommand(cli_endpoint, func, **command_opts)
 	generate_rich_click_opt_groups(cli_endpoint, name, input_type, options)
 
 

secator/definitions.py

@@ -9,7 +9,7 @@ from secator.config import CONFIG, ROOT_FOLDER
 
 # Globals
 VERSION = version('secator')
-ASCII = f"""
+ASCII = rf"""
 			 __            
    ________  _________ _/ /_____  _____
   / ___/ _ \/ ___/ __ `/ __/ __ \/ ___/
@@ -24,14 +24,19 @@ DEBUG = CONFIG.debug.level
 DEBUG_COMPONENT = CONFIG.debug.component.split(',')
 
 # Default tasks settings
-DEFAULT_HTTPX_FLAGS = os.environ.get('DEFAULT_HTTPX_FLAGS', '-td')
-DEFAULT_KATANA_FLAGS = os.environ.get('DEFAULT_KATANA_FLAGS', '-jc -js-crawl -known-files all -or -ob')
 DEFAULT_NUCLEI_FLAGS = os.environ.get('DEFAULT_NUCLEI_FLAGS', '-stats -sj -si 20 -hm -or')
 DEFAULT_FEROXBUSTER_FLAGS = os.environ.get('DEFAULT_FEROXBUSTER_FLAGS', '--auto-bail --no-state')
 
 # Constants
 OPT_NOT_SUPPORTED = -1
 OPT_PIPE_INPUT = -1
+STATE_COLORS = {
+	'PENDING': 'dim yellow3',
+	'RUNNING': 'bold yellow3',
+	'SUCCESS': 'bold green',
+	'FAILURE': 'bold red',
+	'REVOKED': 'bold magenta'
+}
 
 # Vocab
 ALIVE = 'alive'
@@ -54,6 +59,7 @@ FILTER_SIZE = 'filter_size'
 HEADER = 'header'
 HOST = 'host'
 IP = 'ip'
+PROTOCOL = 'protocol'
 LINES = 'lines'
 METHOD = 'method'
 MATCH_CODES = 'match_codes'
@@ -119,7 +125,8 @@ ADDONS_ENABLED = {}
 
 for addon, module in [
 	('worker', 'eventlet'),
-	('google', 'gspread'),
+	('gdrive', 'gspread'),
+	('gcs', 'google.cloud.storage'),
 	('mongodb', 'pymongo'),
 	('redis', 'redis'),
 	('dev', 'flake8'),

secator/exporters/__init__.py

@@ -1,10 +1,12 @@
 __all__ = [
-    'CsvExporter',
-    'GdriveExporter',
-    'JsonExporter',
-    'TableExporter',
-    'TxtExporter'
+	'ConsoleExporter',
+	'CsvExporter',
+	'GdriveExporter',
+	'JsonExporter',
+	'TableExporter',
+	'TxtExporter'
 ]
+from secator.exporters.console import ConsoleExporter
 from secator.exporters.csv import CsvExporter
 from secator.exporters.gdrive import GdriveExporter
 from secator.exporters.json import JsonExporter

secator/exporters/console.py

@@ -0,0 +1,10 @@
+from secator.exporters._base import Exporter
+from secator.rich import console
+
+
+class ConsoleExporter(Exporter):
+	def send(self):
+		results = self.report.data['results']
+		for items in results.values():
+			for item in items:
+				console.print(item)

secator/exporters/csv.py

@@ -1,29 +1,37 @@
 import csv as _csv
 
+from dataclasses import fields
+
 from secator.exporters._base import Exporter
 from secator.rich import console
+from secator.output_types import FINDING_TYPES
+from secator.output_types import Info
 
 
 class CsvExporter(Exporter):
-    def send(self):
-        results = self.report.data['results']
-        csv_paths = []
+	def send(self):
+		results = self.report.data['results']
+		if not results:
+			return
+		csv_paths = []
 
-        for output_type, items in results.items():
-            items = [i.toDict() for i in items]
-            if not items:
-                continue
-            keys = list(items[0].keys())
-            csv_path = f'{self.report.output_folder}/report_{output_type}.csv'
-            csv_paths.append(csv_path)
-            with open(csv_path, 'w', newline='') as output_file:
-                dict_writer = _csv.DictWriter(output_file, keys)
-                dict_writer.writeheader()
-                dict_writer.writerows(items)
+		for output_type, items in results.items():
+			output_cls = [o for o in FINDING_TYPES if o._type == output_type][0]
+			keys = [o.name for o in fields(output_cls)]
+			items = [i.toDict() for i in items]
+			if not items:
+				continue
+			csv_path = f'{self.report.output_folder}/report_{output_type}.csv'
+			csv_paths.append(csv_path)
+			with open(csv_path, 'w', newline='') as output_file:
+				dict_writer = _csv.DictWriter(output_file, keys)
+				dict_writer.writeheader()
+				dict_writer.writerows(items)
 
-        if len(csv_paths) == 1:
-            csv_paths_str = csv_paths[0]
-        else:
-            csv_paths_str = '\n   • ' + '\n   • '.join(csv_paths)
+		if len(csv_paths) == 1:
+			csv_paths_str = csv_paths[0]
+		else:
+			csv_paths_str = '\n   • ' + '\n   • '.join(csv_paths)
 
-        console.print(f':file_cabinet: Saved CSV reports to {csv_paths_str}')
+		info = Info(message=f'Saved CSV reports to {csv_paths_str}')
+		console.print(info)

secator/exporters/gdrive.py

@@ -4,6 +4,7 @@ import yaml
 
 from secator.config import CONFIG
 from secator.exporters._base import Exporter
+from secator.output_types import Info, Error
 from secator.rich import console
 from secator.utils import pluralize
 
@@ -16,20 +17,22 @@ class GdriveExporter(Exporter):
 		title = self.report.data['info']['title']
 		sheet_title = f'{self.report.data["info"]["title"]}_{self.report.timestamp}'
 		results = self.report.data['results']
-		if not CONFIG.addons.google.credentials_path:
-			console.print(':file_cabinet: Missing CONFIG.addons.google.credentials_path to save to Google Sheets', style='red')
+		if not CONFIG.addons.gdrive.credentials_path:
+			error = Error('Missing CONFIG.addons.gdrive.credentials_path to save to Google Sheets')
+			console.print(error)
 			return
-		if not CONFIG.addons.google.drive_parent_folder_id:
-			console.print(':file_cabinet: Missing CONFIG.addons.google.drive_parent_folder_id to save to Google Sheets.', style='red')  # noqa: E501
+		if not CONFIG.addons.gdrive.drive_parent_folder_id:
+			error = Error('Missing CONFIG.addons.gdrive.drive_parent_folder_id to save to Google Sheets.')
+			console.print(error)
 			return
-		client = gspread.service_account(CONFIG.addons.google.credentials_path)
+		client = gspread.service_account(CONFIG.addons.gdrive.credentials_path)
 
 		# Create workspace folder if it doesn't exist
-		folder_id = self.get_folder_by_name(ws, parent_id=CONFIG.addons.google.drive_parent_folder_id)
+		folder_id = self.get_folder_by_name(ws, parent_id=CONFIG.addons.gdrive.drive_parent_folder_id)
 		if ws and not folder_id:
 			folder_id = self.create_folder(
 				folder_name=ws,
-				parent_id=CONFIG.addons.google.drive_parent_folder_id)
+				parent_id=CONFIG.addons.gdrive.drive_parent_folder_id)
 
 		# Create worksheet
 		sheet = client.create(title, folder_id=folder_id)
@@ -57,8 +60,9 @@ class GdriveExporter(Exporter):
 			]
 			csv_path = f'{self.report.output_folder}/report_{output_type}.csv'
 			if not os.path.exists(csv_path):
-				console.print(
+				error = Error(
 					f'Unable to find CSV at {csv_path}. For Google sheets reports, please enable CSV reports as well.')
+				console.print(error)
 				return
 			sheet_title = pluralize(output_type).upper()
 			ws = sheet.add_worksheet(sheet_title, rows=len(items), cols=len(keys))
@@ -79,12 +83,13 @@ class GdriveExporter(Exporter):
 		ws = sheet.get_worksheet(0)
 		sheet.del_worksheet(ws)
 
-		console.print(f':file_cabinet: Saved Google Sheets reports to [u magenta]{sheet.url}[/]')
+		info = Info(message=f'Saved Google Sheets reports to [u magenta]{sheet.url}')
+		console.print(info)
 
 	def create_folder(self, folder_name, parent_id=None):
 		from googleapiclient.discovery import build
 		from google.oauth2 import service_account
-		creds = service_account.Credentials.from_service_account_file(CONFIG.addons.google.credentials_path)
+		creds = service_account.Credentials.from_service_account_file(CONFIG.addons.gdrive.credentials_path)
 		service = build('drive', 'v3', credentials=creds)
 		body = {
 			'name': folder_name,
@@ -98,7 +103,7 @@ class GdriveExporter(Exporter):
 	def list_folders(self, parent_id):
 		from googleapiclient.discovery import build
 		from google.oauth2 import service_account
-		creds = service_account.Credentials.from_service_account_file(CONFIG.addons.google.credentials_path)
+		creds = service_account.Credentials.from_service_account_file(CONFIG.addons.gdrive.credentials_path)
 		service = build('drive', 'v3', credentials=creds)
 		driveid = service.files().get(fileId='root').execute()['id']
 		response = service.files().list(

secator/exporters/json.py

@@ -1,4 +1,5 @@
 from secator.exporters._base import Exporter
+from secator.output_types import Info
 from secator.rich import console
 from secator.serializers.dataclass import dumps_dataclass
 
@@ -11,4 +12,5 @@ class JsonExporter(Exporter):
 		with open(json_path, 'w') as f:
 			f.write(dumps_dataclass(self.report.data, indent=2))
 
-		console.print(f':file_cabinet: Saved JSON report to {json_path}')
+		info = Info(f'Saved JSON report to {json_path}')
+		console.print(info)

secator/exporters/table.py

@@ -1,7 +1,35 @@
 from secator.exporters._base import Exporter
-from secator.utils import print_results_table
+from secator.utils import pluralize
+from secator.rich import build_table, console
+from rich.markdown import Markdown
+from secator.output_types import OutputType
 
 
 class TableExporter(Exporter):
 	def send(self):
-		print_results_table(self.report.runner.results, self.report.title)
+		results = self.report.data['results']
+		if not results:
+			return
+		title = self.report.title
+		_print = console.print
+		_print()
+		if title:
+			title = ' '.join(title.capitalize().split('_')) + ' results'
+			h1 = Markdown(f'# {title}')
+			_print(h1, style='bold magenta', width=50)
+			_print()
+		for output_type, items in results.items():
+			if output_type == 'progress':
+				continue
+			if items:
+				is_output_type = isinstance(items[0], OutputType)
+				output_fields = items[0]._table_fields if is_output_type else None
+				sort_by = items[0]._sort_by if is_output_type else []
+				_table = build_table(
+					items,
+					output_fields=output_fields,
+					sort_by=sort_by)
+				title = pluralize(items[0]._type).upper() if is_output_type else 'Results'
+				_print(f':wrench: {title}', style='bold gold3', justify='left')
+				_print(_table)
+				_print()