secator 0.22.0__py3-none-any.whl

secator/output_types/record.py

@@ -0,0 +1,36 @@
+import time
+from dataclasses import dataclass, field
+
+from secator.definitions import HOST, NAME, TYPE
+from secator.output_types import OutputType
+from secator.utils import rich_to_ansi, format_object
+
+
+@dataclass
+class Record(OutputType):
+	name: str
+	type: str
+	host: str = ''
+	extra_data: dict = field(default_factory=dict, compare=False)
+	_source: str = field(default='', repr=True, compare=False)
+	_type: str = field(default='record', repr=True)
+	_timestamp: int = field(default_factory=lambda: time.time(), compare=False)
+	_uuid: str = field(default='', repr=True, compare=False)
+	_context: dict = field(default_factory=dict, repr=True, compare=False)
+	_tagged: bool = field(default=False, repr=True, compare=False)
+	_duplicate: bool = field(default=False, repr=True, compare=False)
+	_related: list = field(default_factory=list, compare=False)
+
+	_table_fields = [NAME, HOST, TYPE]
+	_sort_by = (TYPE, NAME)
+
+	def __str__(self) -> str:
+		return self.name
+
+	def __repr__(self) -> str:
+		s = rf'🎤 [bold white]{self.name}[/] \[[green]{self.type}[/]]'
+		if self.host:
+			s += rf' \[[magenta]{self.host}[/]]'
+		if self.extra_data:
+			s += format_object(self.extra_data, 'yellow')
+		return rich_to_ansi(s)

secator/output_types/stat.py

@@ -0,0 +1,41 @@
+import time
+from dataclasses import dataclass, field
+
+from secator.output_types import OutputType
+from secator.utils import rich_to_ansi
+
+
+@dataclass
+class Stat(OutputType):
+	name: str
+	pid: int
+	cpu: int
+	memory: int
+	memory_limit: int
+	net_conns: int = field(default=None, repr=True)
+	extra_data: dict = field(default_factory=dict)
+	_source: str = field(default='', repr=True, compare=False)
+	_type: str = field(default='stat', repr=True)
+	_timestamp: int = field(default_factory=lambda: time.time(), compare=False)
+	_uuid: str = field(default='', repr=True, compare=False)
+	_context: dict = field(default_factory=dict, repr=True, compare=False)
+	_tagged: bool = field(default=False, repr=True, compare=False)
+	_duplicate: bool = field(default=False, repr=True, compare=False)
+	_related: list = field(default_factory=list, compare=False)
+
+	_table_fields = ['name', 'pid', 'cpu', 'memory']
+	_sort_by = ('name', 'pid')
+
+	def __str__(self) -> str:
+		return f'{self.name} ([bold]pid[/]:{self.pid}) ([bold]cpu[/]:{self.cpu:.2f}%) ([bold]memory[/]:{self.memory:.2f}MB / {self.memory_limit}MB)'  # noqa: E501
+
+	def __repr__(self) -> str:
+		s = rf'[dim yellow3]📊 {self.name} ([bold]pid[/]:{self.pid}) ([bold]cpu[/]:{self.cpu:.2f}%)'
+		s += rf' ([bold]memory[/]:{self.memory:.2f}MB'
+		if self.memory_limit != -1:
+			s += rf' / {self.memory_limit}MB'
+		s += ')'
+		if self.net_conns:
+			s += rf' ([bold]connections[/]:{self.net_conns})'
+		s += ' [/]'
+		return rich_to_ansi(s)

secator/output_types/state.py

@@ -0,0 +1,29 @@
+import time
+from dataclasses import dataclass, field
+
+from secator.output_types._base import OutputType
+from secator.utils import rich_to_ansi
+
+
+@dataclass
+class State(OutputType):
+	"""Represents the state of a Celery task."""
+
+	task_id: str
+	state: str
+	_type: str = field(default='state', repr=True)
+	_source: str = field(default='', repr=True, compare=False)
+	_timestamp: int = field(default_factory=lambda: time.time(), compare=False)
+	_uuid: str = field(default='', repr=True, compare=False)
+	_context: dict = field(default_factory=dict, repr=True, compare=False)
+	_tagged: bool = field(default=False, repr=True, compare=False)
+	_duplicate: bool = field(default=False, repr=True, compare=False)
+	_related: list = field(default_factory=list, compare=False)
+	_icon = '📊'
+	_color = 'bright_blue'
+
+	def __str__(self) -> str:
+		return f"Task {self.task_id} is {self.state}"
+
+	def __repr__(self) -> str:
+		return rich_to_ansi(f"{self._icon} [bold {self._color}]{self.state}[/] {self.task_id}")

secator/output_types/subdomain.py

@@ -0,0 +1,45 @@
+import time
+from dataclasses import dataclass, field
+from typing import List
+
+from secator.definitions import DOMAIN, HOST, SOURCES
+from secator.output_types import OutputType
+from secator.utils import rich_to_ansi, format_object
+
+
+@dataclass
+class Subdomain(OutputType):
+	host: str
+	domain: str
+	verified: bool = field(default=False, compare=False)
+	sources: List[str] = field(default_factory=list, compare=False)
+	extra_data: dict = field(default_factory=dict, compare=False)
+	_source: str = field(default='', repr=True, compare=False)
+	_type: str = field(default='subdomain', repr=True)
+	_timestamp: int = field(default_factory=lambda: time.time(), compare=False)
+	_uuid: str = field(default='', repr=True, compare=False)
+	_context: dict = field(default_factory=dict, repr=True, compare=False)
+	_tagged: bool = field(default=False, repr=True, compare=False)
+	_duplicate: bool = field(default=False, repr=True, compare=False)
+	_related: list = field(default_factory=list, compare=False)
+
+	_table_fields = [
+		HOST,
+		DOMAIN,
+		SOURCES
+	]
+	_sort_by = (HOST,)
+
+	def __str__(self):
+		return self.host
+
+	def __repr__(self):
+		sources_str = ', '.join([f'[magenta]{source}[/]' for source in self.sources])
+		s = f'🏰 [white]{self.host}[/]'
+		if sources_str:
+			s += f' [{sources_str}]'
+		if self.extra_data:
+			s += format_object(self.extra_data, 'yellow')
+		if not self.verified:
+			s = f'[dim]{s}[/]'
+		return rich_to_ansi(s)

secator/output_types/tag.py

@@ -0,0 +1,69 @@
+import time
+from dataclasses import dataclass, field
+
+from secator.output_types import OutputType
+from secator.utils import rich_to_ansi, trim_string, rich_escape as _s
+
+
+@dataclass
+class Tag(OutputType):
+	name: str
+	value: str
+	match: str
+	category: str = field(default='general')
+	extra_data: dict = field(default_factory=dict, repr=True, compare=False)
+	stored_response_path: str = field(default='', compare=False)
+	_source: str = field(default='', repr=True, compare=False)
+	_type: str = field(default='tag', repr=True)
+	_timestamp: int = field(default_factory=lambda: time.time(), compare=False)
+	_uuid: str = field(default='', repr=True, compare=False)
+	_context: dict = field(default_factory=dict, repr=True, compare=False)
+	_tagged: bool = field(default=False, repr=True, compare=False)
+	_duplicate: bool = field(default=False, repr=True, compare=False)
+	_related: list = field(default_factory=list, compare=False)
+
+	_table_fields = ['match', 'category', 'name', 'extra_data']
+	_sort_by = ('match', 'name')
+
+	def __post_init__(self):
+		super().__post_init__()
+
+	def __str__(self) -> str:
+		return self.match
+
+	def __repr__(self) -> str:
+		content = self.value
+		s = rf'🏷️  \[[bold yellow]{self.category}[/]] [bold magenta]{self.name}[/]'
+		small_content = False
+		if len(content) < 100:
+			small_content = True
+		# content_xs = trim_string(content, max_length=50).replace('\n', '/')
+		if small_content:
+			s += f' [bold orange4]{content}[/]'
+		s += f' found @ [bold]{_s(self.match)}[/]'
+		ed = ''
+		if self.stored_response_path:
+			s += rf' [link=file://{self.stored_response_path}]:incoming_envelope:[/]'
+		if not small_content:
+			sep = ' '
+			content = trim_string(content, max_length=1000)
+			content = content.replace('\n', '\n    ')
+			sep = '\n    '
+			ed += f'\n    [bold red]value[/]:{sep}[yellow]{_s(content)}[/]'
+		if self.extra_data:
+			for k, v in self.extra_data.items():
+				sep = ' '
+				if not v:
+					continue
+				if isinstance(v, str):
+					v = trim_string(v, max_length=1000)
+					if len(v) > 1000:
+						v = v.replace('\n', '\n' + sep)
+						sep = '\n    '
+				if k == 'content' and not small_content:
+					ed += f'\n    [bold red]{_s(k)}[/]:{sep}[yellow]{_s(v)}[/]'
+				else:
+					ed += f'\n    [dim red]{_s(k)}[/]:{sep}[dim yellow]{_s(v)}[/]'
+		if ed:
+			s += ed
+		return rich_to_ansi(s)

secator/output_types/target.py

@@ -0,0 +1,38 @@
+import time
+from dataclasses import dataclass, field
+
+from secator.output_types import OutputType
+from secator.utils import autodetect_type, rich_to_ansi, rich_escape as _s
+
+
+@dataclass
+class Target(OutputType):
+	name: str
+	type: str = ''
+	_source: str = field(default='', repr=True, compare=False)
+	_type: str = field(default='target', repr=True)
+	_timestamp: int = field(default_factory=lambda: time.time(), compare=False)
+	_uuid: str = field(default='', repr=True, compare=False)
+	_context: dict = field(default_factory=dict, repr=True, compare=False)
+	_tagged: bool = field(default=False, repr=True, compare=False)
+	_duplicate: bool = field(default=False, repr=True, compare=False)
+	_related: list = field(default_factory=list, compare=False)
+
+	_table_fields = [
+		'name',
+		'type',
+	]
+	_sort_by = ('type', 'name')
+
+	def __post_init__(self):
+		if not self.type:
+			self.type = autodetect_type(self.name)
+
+	def __str__(self):
+		return self.name
+
+	def __repr__(self):
+		s = f'🎯 {_s(self.name)}'
+		if self.type:
+			s += f' ({self.type})'
+		return rich_to_ansi(s)

secator/output_types/url.py

@@ -0,0 +1,112 @@
+import time
+
+from dataclasses import dataclass, field
+
+from urllib.parse import urlparse
+
+from secator.definitions import (CONTENT_LENGTH, CONTENT_TYPE, STATUS_CODE,
+								 TECH, TITLE, URL, WEBSERVER, METHOD)
+from secator.output_types import OutputType
+from secator.utils import rich_to_ansi, trim_string, format_object, rich_escape as _s
+from secator.config import CONFIG
+
+
+@dataclass
+class Url(OutputType):
+	url: str
+	host: str = field(default='', compare=False)
+	verified: bool = field(default=False, compare=False)
+	status_code: int = field(default=0, compare=False)
+	title: str = field(default='', compare=False)
+	webserver: str = field(default='', compare=False)
+	tech: list = field(default_factory=list, compare=False)
+	content_type: str = field(default='', compare=False)
+	content_length: int = field(default=0, compare=False)
+	time: str = field(default='', compare=False)
+	method: str = field(default='', compare=False)
+	words: int = field(default=0, compare=False)
+	lines: int = field(default=0, compare=False)
+	screenshot_path: str = field(default='', compare=False)
+	stored_response_path: str = field(default='', compare=False)
+	response_headers: dict = field(default_factory=dict, repr=True, compare=False)
+	request_headers: dict = field(default_factory=dict, repr=True, compare=False)
+	is_directory: dict = field(default='', compare=False)
+	extra_data: dict = field(default_factory=dict, compare=False)
+	_source: str = field(default='', repr=True, compare=False)
+	_type: str = field(default='url', repr=True)
+	_timestamp: int = field(default_factory=lambda: time.time(), compare=False)
+	_uuid: str = field(default='', repr=True, compare=False)
+	_context: dict = field(default_factory=dict, repr=True, compare=False)
+	_tagged: bool = field(default=False, repr=True, compare=False)
+	_duplicate: bool = field(default=False, repr=True, compare=False)
+	_related: list = field(default_factory=list, compare=False)
+
+	_table_fields = [
+		URL,
+		METHOD,
+		STATUS_CODE,
+		TITLE,
+		WEBSERVER,
+		TECH,
+		CONTENT_TYPE,
+		CONTENT_LENGTH,
+		'stored_response_path',
+		'screenshot_path',
+	]
+	_sort_by = (URL,)
+
+	def __post_init__(self):
+		super().__post_init__()
+		if not self.host:
+			self.host = urlparse(self.url).hostname
+		if self.status_code != 0:
+			self.verified = True
+		if self.title and 'Index of' in self.title:
+			self.is_directory = True
+
+	def __gt__(self, other):
+		# favor httpx over other url info tools
+		if self._source == 'httpx' and other._source != 'httpx':
+			return True
+		return super().__gt__(other)
+
+	def __str__(self):
+		return self.url
+
+	def __repr__(self):
+		s = f'🔗 [white]{_s(self.url)}'
+		if self.method and self.method != 'GET':
+			s += rf' \[[turquoise4]{self.method}[/]]'
+		if self.request_headers:
+			s += rf'{format_object(self.request_headers, "gold3", skip_keys=["user_agent"])}'
+		if self.status_code and self.status_code != 0:
+			if self.status_code < 400:
+				s += rf' \[[green]{self.status_code}[/]]'
+			else:
+				s += rf' \[[red]{self.status_code}[/]]'
+		if self.title:
+			s += rf' \[[spring_green3]{trim_string(self.title)}[/]]'
+		if self.is_directory:
+			s += r' \[[bold gold3]directory[/]]'
+		if self.webserver:
+			s += rf' \[[bold magenta]{_s(self.webserver)}[/]]'
+		if self.tech:
+			techs_str = ', '.join([f'[magenta]{_s(tech)}[/]' for tech in self.tech])
+			s += f' [{techs_str}]'
+		if self.content_type:
+			s += rf' \[[magenta]{_s(self.content_type)}[/]]'
+		if self.content_length:
+			cl = str(self.content_length)
+			cl += '[bold red]+[/]' if self.content_length == CONFIG.http.response_max_size_bytes else ''
+			s += rf' \[[magenta]{cl}[/]]'
+		if self.response_headers and CONFIG.cli.show_http_response_headers:
+			s += rf'{format_object(self.response_headers, "magenta", skip_keys=CONFIG.cli.exclude_http_response_headers)}'  # noqa: E501
+		if self.extra_data:
+			s += format_object(self.extra_data, 'yellow')
+		if self.screenshot_path:
+			s += rf' [link=file://{self.screenshot_path}]:camera:[/]'
+		if self.stored_response_path:
+			s += rf' [link=file://{self.stored_response_path}]:pencil:[/]'
+		if not self.verified:
+			s = f'[dim]{s}[/]'
+		return rich_to_ansi(s)

secator/output_types/user_account.py

@@ -0,0 +1,41 @@
+import time
+from dataclasses import dataclass, field
+
+from secator.definitions import SITE_NAME, URL, USERNAME
+from secator.output_types import OutputType
+from secator.utils import rich_to_ansi, rich_escape as _s, format_object
+
+
+@dataclass
+class UserAccount(OutputType):
+	username: str
+	url: str = ''
+	email: str = ''
+	site_name: str = ''
+	extra_data: dict = field(default_factory=dict, compare=False)
+	_source: str = field(default='', repr=True, compare=False)
+	_type: str = field(default='user_account', repr=True)
+	_timestamp: int = field(default_factory=lambda: time.time(), compare=False)
+	_uuid: str = field(default='', repr=True, compare=False)
+	_context: dict = field(default_factory=dict, repr=True, compare=False)
+	_tagged: bool = field(default=False, repr=True, compare=False)
+	_duplicate: bool = field(default=False, repr=True, compare=False)
+	_related: list = field(default_factory=list, compare=False)
+
+	_table_fields = [SITE_NAME, USERNAME, URL]
+	_sort_by = (URL, USERNAME)
+
+	def __str__(self) -> str:
+		return self.url
+
+	def __repr__(self) -> str:
+		s = f'👤 [green]{_s(self.username)}[/]'
+		if self.email:
+			s += rf' \[[bold yellow]{_s(self.email)}[/]]'
+		if self.site_name:
+			s += rf' \[[bold blue]{self.site_name}[/]]'
+		if self.url:
+			s += rf' \[[white]{_s(self.url)}[/]]'
+		if self.extra_data:
+			s += format_object(self.extra_data, 'yellow')
+		return rich_to_ansi(s)

secator/output_types/vulnerability.py

@@ -0,0 +1,101 @@
+import time
+from dataclasses import dataclass, field
+from typing import List
+
+from secator.definitions import (CONFIDENCE, CVSS_SCORE, EXTRA_DATA, ID,
+								 MATCHED_AT, NAME, REFERENCE, SEVERITY, TAGS)
+from secator.output_types import OutputType
+from secator.utils import rich_to_ansi, rich_escape as _s, format_object
+
+
+@dataclass
+class Vulnerability(OutputType):
+	name: str
+	provider: str = ''
+	id: str = ''
+	matched_at: str = ''
+	ip: str = field(default='', compare=False)
+	confidence: str = 'low'
+	severity: str = 'unknown'
+	cvss_score: float = 0
+	cvss_vec: str = ''
+	epss_score: float = 0
+	tags: List[str] = field(default_factory=list, compare=False)
+	extra_data: dict = field(default_factory=dict, compare=False)
+	description: str = field(default='', compare=False)
+	references: List[str] = field(default_factory=list, compare=False)
+	reference: str = field(default='', compare=False)
+	confidence_nb: int = 0
+	severity_nb: int = 0
+	_source: str = field(default='', repr=True, compare=False)
+	_type: str = field(default='vulnerability', repr=True)
+	_timestamp: int = field(default_factory=lambda: time.time(), compare=False)
+	_uuid: str = field(default='', repr=True, compare=False)
+	_context: dict = field(default_factory=dict, repr=True, compare=False)
+	_tagged: bool = field(default=False, repr=True, compare=False)
+	_duplicate: bool = field(default=False, repr=True, compare=False)
+	_related: list = field(default_factory=list, compare=False)
+
+	_table_fields = [
+		MATCHED_AT,
+		SEVERITY,
+		CONFIDENCE,
+		NAME,
+		ID,
+		CVSS_SCORE,
+		TAGS,
+		EXTRA_DATA,
+		REFERENCE
+	]
+	_sort_by = ('confidence_nb', 'severity_nb', 'matched_at', 'cvss_score')
+
+	def __post_init__(self):
+		super().__post_init__()
+		severity_map = {
+			'critical': 0,
+			'high': 1,
+			'medium': 2,
+			'low': 3,
+			'info': 4,
+			'unknown': 5,
+			None: 6
+		}
+		self.severity = self.severity.lower()  # normalize severity
+		self.severity_nb = severity_map.get(self.severity, 6)
+		self.confidence_nb = severity_map[self.confidence]
+		if len(self.references) > 0:
+			self.reference = self.references[0]
+
+	def __repr__(self):
+		data = self.extra_data
+
+		# TODO: review this
+		if 'data' in data and isinstance(data['data'], list):
+			data = data['data']
+
+		tags = self.tags
+		colors = {
+			'critical': 'bold red',
+			'high': 'red',
+			'medium': 'yellow',
+			'low': 'green',
+			'info': 'magenta',
+			'unknown': 'dim magenta'
+		}
+		c = colors.get(self.severity, 'dim magenta')
+		name = self.name
+		if self.reference:
+			name += rf' [link={_s(self.reference)}]🡕[/link]'
+		s = rf'🚨 \[[green]{name}[/]]'
+		s += rf' \[[{c}]{self.severity}[/]] {_s(self.matched_at)}'  # noqa: E501
+		if tags:
+			tags_str = ','.join(tags)
+			s += rf' \[[cyan]{_s(tags_str)}[/]]'
+		if data:
+			s += format_object(data, 'yellow')
+		if self.confidence == 'low':
+			s = f'[dim]{s}[/]'
+		return rich_to_ansi(s)
+
+	def __str__(self):
+		return self.matched_at + ' -> ' + self.name

secator/output_types/warning.py

@@ -0,0 +1,30 @@
+from dataclasses import dataclass, field
+import time
+from secator.output_types import OutputType
+from secator.utils import strip_rich_markup, rich_to_ansi
+
+
+@dataclass
+class Warning(OutputType):
+	message: str
+	message_color: str = field(default='', compare=False)
+	task_id: str = field(default='', compare=False)
+	_source: str = field(default='', repr=True)
+	_type: str = field(default='warning', repr=True)
+	_timestamp: int = field(default_factory=lambda: time.time(), compare=False)
+	_uuid: str = field(default='', repr=True, compare=False)
+	_context: dict = field(default_factory=dict, repr=True, compare=False)
+	_duplicate: bool = field(default=False, repr=True, compare=False)
+	_related: list = field(default_factory=list, compare=False)
+
+	_table_fields = ['task_name', 'message']
+	_sort_by = ('_timestamp',)
+
+	def __post_init__(self):
+		super().__post_init__()
+		self.message_color = self.message
+		self.message = strip_rich_markup(self.message)
+
+	def __repr__(self):
+		s = rf"\[[yellow]WRN[/]] {self.message_color}"
+		return rich_to_ansi(s)

secator/report.py

@@ -0,0 +1,140 @@
+import operator
+
+from secator.config import CONFIG
+from secator.output_types import FINDING_TYPES, OutputType
+from secator.utils import get_file_timestamp, traceback_as_string
+from secator.rich import console
+from secator.runners._helpers import extract_from_results
+
+import concurrent.futures
+from threading import Lock
+
+
+def remove_duplicates(objects):
+	unique_objects = []
+	lock = Lock()
+
+	def add_if_unique(obj):
+		nonlocal unique_objects  # noqa: F824
+		with lock:
+			# Perform linear search to check for duplicates
+			if all(obj != existing_obj for existing_obj in unique_objects):
+				unique_objects.append(obj)
+
+	with concurrent.futures.ThreadPoolExecutor(max_workers=100) as executor:
+		# Execute the function concurrently for each object
+		executor.map(add_if_unique, objects)
+
+	return unique_objects
+
+
+# TODO: initialize from data, not from runner
+class Report:
+	"""Report class.
+
+	Args:
+		runner (secator.runners.Runner): Runner instance.
+		title (str): Report title.
+		exporters (list): List of exporter classes.
+	"""
+	def __init__(self, runner, title=None, exporters=[]):
+		self.title = title or f'{runner.config.type}_{runner.config.name}'
+		self.runner = runner
+		self.timestamp = get_file_timestamp()
+		self.exporters = exporters
+		self.workspace_name = runner.workspace_name
+		self.output_folder = runner.reports_folder
+
+	def send(self):
+		for report_cls in self.exporters:
+			try:
+				report_cls(self).send()
+			except Exception as e:
+				console.print(
+					f'[bold red]Could not create exporter {report_cls.__name__} for {self.__class__.__name__}: '
+					f'{str(e)}[/]\n[dim]{traceback_as_string(e)}[/]',
+				)
+
+	def build(self, extractors=[], dedupe=CONFIG.runners.remove_duplicates):
+		# Prepare report structure
+		runner_fields = {
+			'name',
+			'status',
+			'targets',
+			'start_time',
+			'end_time',
+			'elapsed',
+			'elapsed_human',
+			'run_opts',
+			'results_count'
+		}
+		data = {
+			'info': {k: v for k, v in self.runner.toDict().items() if k in runner_fields},
+			'results': {}
+		}
+		if 'results' in data['info']:
+			del data['info']['results']
+		data['info']['title'] = self.title
+		data['info']['errors'] = self.runner.errors
+
+		# Fill report
+		for output_type in FINDING_TYPES:
+			output_name = output_type.get_name()
+			sort_by, _ = get_table_fields(output_type)
+			items = [
+				item for item in self.runner.results
+				if isinstance(item, OutputType) and item._type == output_name
+			]
+			if items:
+				if sort_by and all(sort_by):
+					try:
+						items = sorted(items, key=operator.attrgetter(*sort_by))
+					except TypeError as e:
+						console.print(f'[bold red]Could not sort {output_name} by {sort_by}: {str(e)}[/]')
+						console.print(f'[dim]{traceback_as_string(e)}[/]')
+				if dedupe:
+					items = remove_duplicates(items)
+				if extractors:
+					all_res = []
+					extractors_type = [extractor for extractor in extractors if extractor.get('type') == output_name]
+					for extractor in extractors_type:
+						op = extractor.get('op', 'or')
+						res, errors = extract_from_results(items, extractors=[extractor])
+						# console.print(f'{extractor} --> {len(res)} results')
+						if not res:
+							continue
+						if errors:
+							data['info']['errors'] = errors
+						if res:
+							if op == 'or':
+								all_res = all_res + res
+							else:
+								if not all_res:
+									all_res = res
+								else:
+									all_res = [item for item in res if item in all_res]
+					items = remove_duplicates(all_res) if dedupe else all_res
+				data['results'][output_name] = items
+
+		# Save data
+		self.data = data
+
+	def is_empty(self):
+		return all(not items for items in self.data['results'].values())
+
+
+def get_table_fields(output_type):
+	"""Get output fields and sort fields based on output type.
+
+	Args:
+		output_type (str): Output type.
+
+	Returns:
+		tuple: Tuple of sort_by (tuple), output_fields (list).
+	"""
+	sort_by = ()
+	output_fields = []
+	if output_type in FINDING_TYPES:
+		sort_by = output_type._sort_by
+		output_fields = output_type._table_fields
+	return sort_by, output_fields