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

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()

secator/exporters/txt.py

@@ -1,24 +1,28 @@
 from secator.exporters._base import Exporter
+from secator.output_types import Info
 from secator.rich import console
 
 
 class TxtExporter(Exporter):
-    def send(self):
-        results = self.report.data['results']
-        txt_paths = []
+	def send(self):
+		results = self.report.data['results']
+		if not results:
+			return
+		txt_paths = []
 
-        for output_type, items in results.items():
-            items = [str(i) for i in items]
-            if not items:
-                continue
-            txt_path = f'{self.report.output_folder}/report_{output_type}.txt'
-            with open(txt_path, 'w') as f:
-                f.write('\n'.join(items))
-            txt_paths.append(txt_path)
+		for output_type, items in results.items():
+			items = [str(i) for i in items]
+			if not items:
+				continue
+			txt_path = f'{self.report.output_folder}/report_{output_type}.txt'
+			with open(txt_path, 'w') as f:
+				f.write('\n'.join(items))
+			txt_paths.append(txt_path)
 
-        if len(txt_paths) == 1:
-            txt_paths_str = txt_paths[0]
-        else:
-            txt_paths_str = '\n   • ' + '\n   • '.join(txt_paths)
+		if len(txt_paths) == 1:
+			txt_paths_str = txt_paths[0]
+		else:
+			txt_paths_str = '\n   • ' + '\n   • '.join(txt_paths)
 
-        console.print(f':file_cabinet: Saved TXT reports to {txt_paths_str}')
+		info = Info(f'Saved TXT reports to {txt_paths_str}')
+		console.print(info)

secator/hooks/gcs.py

@@ -0,0 +1,53 @@
+from pathlib import Path
+from time import time
+
+from google.cloud import storage
+
+from secator.config import CONFIG
+from secator.runners import Task
+from secator.thread import Thread
+from secator.utils import debug
+
+
+GCS_BUCKET_NAME = CONFIG.addons.gcs.bucket_name
+ITEMS_TO_SEND = {
+	'url': ['screenshot_path']
+}
+
+
+def process_item(self, item):
+	if item._type not in ITEMS_TO_SEND.keys():
+		return item
+	if not GCS_BUCKET_NAME:
+		debug('skipped since addons.gcs.bucket_name is empty.', sub='hooks.gcs')
+		return item
+	to_send = ITEMS_TO_SEND[item._type]
+	for k, v in item.toDict().items():
+		if k in to_send and v:
+			path = Path(v)
+			if not path.exists():
+				continue
+			ext = path.suffix
+			blob_name = f'{item._uuid}_{k}{ext}'
+			t = Thread(target=upload_blob, args=(GCS_BUCKET_NAME, v, blob_name))
+			t.start()
+			self.threads.append(t)
+			setattr(item, k, f'gs://{GCS_BUCKET_NAME}/{blob_name}')
+	return item
+
+
+def upload_blob(bucket_name, source_file_name, destination_blob_name):
+	"""Uploads a file to the bucket."""
+	start_time = time()
+	storage_client = storage.Client()
+	bucket = storage_client.bucket(bucket_name)
+	blob = bucket.blob(destination_blob_name)
+	blob.upload_from_filename(source_file_name)
+	end_time = time()
+	elapsed = end_time - start_time
+	debug(f'in {elapsed:.4f}s', obj={'blob': 'CREATED', 'blob_name': destination_blob_name, 'bucket': bucket_name}, obj_after=False, sub='hooks.gcs', verbose=True)  # noqa: E501
+
+
+HOOKS = {
+	Task: {'on_item': [process_item]}
+}

secator/hooks/mongodb.py

@@ -6,7 +6,7 @@ from bson.objectid import ObjectId
 from celery import shared_task
 
 from secator.config import CONFIG
-from secator.output_types import OUTPUT_TYPES
+from secator.output_types import FINDING_TYPES
 from secator.runners import Scan, Task, Workflow
 from secator.utils import debug, escape_mongodb_url
 
@@ -15,11 +15,27 @@ from secator.utils import debug, escape_mongodb_url
 
 MONGODB_URL = CONFIG.addons.mongodb.url
 MONGODB_UPDATE_FREQUENCY = CONFIG.addons.mongodb.update_frequency
-MAX_POOL_SIZE = 100
+MONGODB_CONNECT_TIMEOUT = CONFIG.addons.mongodb.server_selection_timeout_ms
+MONGODB_MAX_POOL_SIZE = CONFIG.addons.mongodb.max_pool_size
 
 logger = logging.getLogger(__name__)
 
-client = pymongo.MongoClient(escape_mongodb_url(MONGODB_URL), maxPoolSize=MAX_POOL_SIZE)
+client = pymongo.MongoClient(
+	escape_mongodb_url(MONGODB_URL),
+	maxPoolSize=MONGODB_MAX_POOL_SIZE,
+	serverSelectionTimeoutMS=MONGODB_CONNECT_TIMEOUT
+)
+
+
+def get_runner_dbg(runner):
+	"""Runner debug object"""
+	return {
+		runner.unique_name: runner.status,
+		'type': runner.config.type,
+		'class': runner.__class__.__name__,
+		'caller': runner.config.name,
+		**runner.context
+	}
 
 
 def update_runner(self):
@@ -27,25 +43,19 @@ def update_runner(self):
 	type = self.config.type
 	collection = f'{type}s'
 	update = self.toDict()
-	debug_obj = {'type': 'runner', 'name': self.name, 'status': self.status}
 	chunk = update.get('chunk')
 	_id = self.context.get(f'{type}_chunk_id') if chunk else self.context.get(f'{type}_id')
-	debug('update', sub='hooks.mongodb', id=_id, obj=update, obj_after=True, level=4)
+	debug('to_update', sub='hooks.mongodb', id=_id, obj=get_runner_dbg(self), obj_after=True, obj_breaklines=False, verbose=True)  # noqa: E501
 	start_time = time.time()
 	if _id:
-		delta = start_time - self.last_updated if self.last_updated else MONGODB_UPDATE_FREQUENCY
-		if self.last_updated and delta < MONGODB_UPDATE_FREQUENCY and self.status == 'RUNNING':
-			debug(f'skipped ({delta:>.2f}s < {MONGODB_UPDATE_FREQUENCY}s)',
-				  sub='hooks.mongodb', id=_id, obj=debug_obj, obj_after=False, level=3)
-			return
 		db = client.main
 		start_time = time.time()
 		db[collection].update_one({'_id': ObjectId(_id)}, {'$set': update})
 		end_time = time.time()
 		elapsed = end_time - start_time
 		debug(
-			f'[dim gold4]updated in {elapsed:.4f}s[/]', sub='hooks.mongodb', id=_id, obj=debug_obj, obj_after=False, level=2)
-		self.last_updated = start_time
+			f'[dim gold4]updated in {elapsed:.4f}s[/]', sub='hooks.mongodb', id=_id, obj=get_runner_dbg(self), obj_after=False)  # noqa: E501
+		self.last_updated_db = start_time
 	else:  # sync update and save result to runner object
 		runner = db[collection].insert_one(update)
 		_id = str(runner.inserted_id)
@@ -55,13 +65,16 @@ def update_runner(self):
 			self.context[f'{type}_id'] = _id
 		end_time = time.time()
 		elapsed = end_time - start_time
-		debug(f'created in {elapsed:.4f}s', sub='hooks.mongodb', id=_id, obj=debug_obj, obj_after=False, level=2)
+		debug(f'in {elapsed:.4f}s', sub='hooks.mongodb', id=_id, obj=get_runner_dbg(self), obj_after=False)
 
 
 def update_finding(self, item):
+	if type(item) not in FINDING_TYPES:
+		return item
 	start_time = time.time()
 	db = client.main
 	update = item.toDict()
+	_type = item._type
 	_id = ObjectId(item._uuid) if ObjectId.is_valid(item._uuid) else None
 	if _id:
 		finding = db['findings'].update_one({'_id': _id}, {'$set': update})
@@ -72,7 +85,14 @@ def update_finding(self, item):
 		status = 'CREATED'
 	end_time = time.time()
 	elapsed = end_time - start_time
-	debug(f'in {elapsed:.4f}s', sub='hooks.mongodb', id=str(item._uuid), obj={'finding': status}, obj_after=False)
+	debug_obj = {
+		_type: status,
+		'type': 'finding',
+		'class': self.__class__.__name__,
+		'caller': self.config.name,
+		**self.context
+	}
+	debug(f'in {elapsed:.4f}s', sub='hooks.mongodb', id=str(item._uuid), obj=debug_obj, obj_after=False)  # noqa: E501
 	return item
 
 
@@ -80,20 +100,23 @@ def find_duplicates(self):
 	ws_id = self.toDict().get('context', {}).get('workspace_id')
 	if not ws_id:
 		return
-	celery_id = tag_duplicates.delay(ws_id)
-	debug(f'running duplicate check on workspace {ws_id}', id=celery_id, sub='hooks.mongodb')
+	if self.sync:
+		debug(f'running duplicate check on workspace {ws_id}', sub='hooks.mongodb')
+		tag_duplicates(ws_id)
+	else:
+		celery_id = tag_duplicates.delay(ws_id)
+		debug(f'running duplicate check on workspace {ws_id}', id=celery_id, sub='hooks.mongodb')
 
 
 def load_finding(obj):
 	finding_type = obj['_type']
 	klass = None
-	for otype in OUTPUT_TYPES:
+	for otype in FINDING_TYPES:
 		if finding_type == otype.get_name():
 			klass = otype
 			item = klass.load(obj)
 			item._uuid = str(obj['_id'])
 			return item
-	debug('could not load Secator output type from MongoDB object', obj=obj, sub='hooks.mongodb')
 	return None
 
 
@@ -149,18 +172,19 @@ def tag_duplicates(ws_id: str = None):
 				'seen dupes': len(seen_dupes)
 			},
 			id=ws_id,
-			sub='hooks.mongodb')
+			sub='hooks.mongodb.duplicates',
+			verbose=True)
 		tmp_duplicates_ids = list(dict.fromkeys([i._uuid for i in tmp_duplicates]))
-		debug(f'duplicate ids: {tmp_duplicates_ids}', id=ws_id, sub='hooks.mongodb')
+		debug(f'duplicate ids: {tmp_duplicates_ids}', id=ws_id, sub='hooks.mongodb.duplicates', verbose=True)
 
 		# Update latest object as non-duplicate
 		if tmp_duplicates:
 			duplicates.extend([f for f in tmp_duplicates])
 			db.findings.update_one({'_id': ObjectId(item._uuid)}, {'$set': {'_related': tmp_duplicates_ids}})
-			debug(f'adding {item._uuid} as non-duplicate', id=ws_id, sub='hooks.mongodb')
+			debug(f'adding {item._uuid} as non-duplicate', id=ws_id, sub='hooks.mongodb.duplicates', verbose=True)
 			non_duplicates.append(item)
 		else:
-			debug(f'adding {item._uuid} as non-duplicate', id=ws_id, sub='hooks.mongodb')
+			debug(f'adding {item._uuid} as non-duplicate', id=ws_id, sub='hooks.mongodb.duplicates', verbose=True)
 			non_duplicates.append(item)
 
 	# debug(f'found {len(duplicates)} total duplicates')
@@ -184,19 +208,21 @@ def tag_duplicates(ws_id: str = None):
 			'duplicates': len(duplicates_ids),
 			'non-duplicates': len(non_duplicates_ids)
 		},
-		sub='hooks.mongodb')
+		sub='hooks.mongodb.duplicates')
 
 
-MONGODB_HOOKS = {
+HOOKS = {
 	Scan: {
+		'on_init': [update_runner],
 		'on_start': [update_runner],
-		'on_iter': [update_runner],
+		'on_interval': [update_runner],
 		'on_duplicate': [update_finding],
 		'on_end': [update_runner],
 	},
 	Workflow: {
+		'on_init': [update_runner],
 		'on_start': [update_runner],
-		'on_iter': [update_runner],
+		'on_interval': [update_runner],
 		'on_duplicate': [update_finding],
 		'on_end': [update_runner],
 	},
@@ -205,7 +231,7 @@ MONGODB_HOOKS = {
 		'on_start': [update_runner],
 		'on_item': [update_finding],
 		'on_duplicate': [update_finding],
-		'on_iter': [update_runner],
+		'on_interval': [update_runner],
 		'on_end': [update_runner, find_duplicates]
 	}
 }

secator/output_types/__init__.py

@@ -1,15 +1,20 @@
 __all__ = [
-    'OutputType',
-    'Ip',
-    'Port',
-    'Record',
-    'Subdomain',
-    'Url',
-    'UserAccount',
-    'Vulnerability'
+	'Error',
+	'OutputType',
+	'Info',
+	'Ip',
+	'Port',
+	'Progress',
+	'Record',
+	'Stat',
+	'Subdomain',
+	'Url',
+	'UserAccount',
+	'Vulnerability',
+	'Warning',
 ]
-from secator.output_types._base import OutputType  # noqa: F401
-from secator.output_types.progress import Progress  # noqa: F401
+from secator.output_types._base import OutputType
+from secator.output_types.progress import Progress
 from secator.output_types.ip import Ip
 from secator.output_types.exploit import Exploit
 from secator.output_types.port import Port
@@ -20,5 +25,18 @@ from secator.output_types.url import Url
 from secator.output_types.user_account import UserAccount
 from secator.output_types.vulnerability import Vulnerability
 from secator.output_types.record import Record
+from secator.output_types.info import Info
+from secator.output_types.warning import Warning
+from secator.output_types.error import Error
+from secator.output_types.stat import Stat
 
-OUTPUT_TYPES = [Target, Progress, Subdomain, Ip, Port, Url, Tag, Exploit, UserAccount, Vulnerability, Record]
+EXECUTION_TYPES = [
+	Target, Progress, Info, Warning, Error
+]
+STAT_TYPES = [
+	Stat
+]
+FINDING_TYPES = [
+	Subdomain, Ip, Port, Url, Tag, Exploit, UserAccount, Vulnerability
+]
+OUTPUT_TYPES = FINDING_TYPES + EXECUTION_TYPES + STAT_TYPES

secator/output_types/_base.py

@@ -1,6 +1,8 @@
 import logging
 import re
 from dataclasses import _MISSING_TYPE, dataclass, fields
+from secator.definitions import DEBUG
+from secator.rich import console
 
 logger = logging.getLogger(__name__)
 
@@ -66,7 +68,15 @@ class OutputType:
 			if key in output_map:
 				mapped_key = output_map[key]
 				if callable(mapped_key):
-					mapped_val = mapped_key(item)
+					try:
+						mapped_val = mapped_key(item)
+					except Exception as e:
+						mapped_val = None
+						if DEBUG > 1:
+							console.print_exception(show_locals=True)
+						raise TypeError(
+							f'Fail to transform value for "{key}" using output_map function. Exception: '
+							f'{type(e).__name__}: {str(e)}')
 				else:
 					mapped_val = item.get(mapped_key)
 				new_item[key] = mapped_val

secator/output_types/error.py

@@ -0,0 +1,36 @@
+from dataclasses import dataclass, field
+import time
+from secator.output_types import OutputType
+from secator.utils import rich_to_ansi, traceback_as_string
+
+
+@dataclass
+class Error(OutputType):
+	message: str
+	traceback: str = field(default='', compare=False)
+	_source: str = field(default='', repr=True)
+	_type: str = field(default='error', 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 = ['message', 'traceback']
+	_sort_by = ('_timestamp',)
+
+	def from_exception(e, **kwargs):
+		message = type(e).__name__
+		if str(e):
+			message += f': {str(e)}'
+		return Error(message=message, traceback=traceback_as_string(e), **kwargs)
+
+	def __str__(self):
+		return self.message
+
+	def __repr__(self):
+		s = f'[bold red]❌ {self.message}[/]'
+		if self.traceback:
+			traceback_pretty = '   ' + self.traceback.replace('\n', '\n   ')
+			s += f'\n[dim]{traceback_pretty}[/]'
+		return rich_to_ansi(s)

secator/output_types/exploit.py

@@ -17,7 +17,7 @@ class Exploit(OutputType):
 	tags: list = field(default_factory=list, compare=False)
 	extra_data: dict = field(default_factory=dict, compare=False)
 	_source: str = field(default='', repr=True)
-	_type: str = field(default='vulnerability', repr=True)
+	_type: str = field(default='exploit', 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)

secator/output_types/info.py

@@ -0,0 +1,24 @@
+from dataclasses import dataclass, field
+import time
+from secator.output_types import OutputType
+from secator.utils import rich_to_ansi
+
+
+@dataclass
+class Info(OutputType):
+	message: str
+	task_id: str = field(default='', compare=False)
+	_source: str = field(default='', repr=True)
+	_type: str = field(default='info', 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 = ['message', 'task_id']
+	_sort_by = ('_timestamp',)
+
+	def __repr__(self):
+		s = f" ℹ️ {self.message}"
+		return rich_to_ansi(s)

secator/output_types/ip.py

@@ -1,16 +1,23 @@
 import time
 from dataclasses import dataclass, field
+from enum import Enum
 
 from secator.definitions import ALIVE, IP
 from secator.output_types import OutputType
 from secator.utils import rich_to_ansi
 
 
+class IpProtocol(str, Enum):
+	IPv6 = 'IPv6'
+	IPv4 = 'IPv4'
+
+
 @dataclass
 class Ip(OutputType):
 	ip: str
 	host: str = ''
 	alive: bool = False
+	protocol: str = field(default=IpProtocol.IPv4)
 	_source: str = field(default='', repr=True)
 	_type: str = field(default='ip', repr=True)
 	_timestamp: int = field(default_factory=lambda: time.time(), compare=False)

secator/output_types/port.py

@@ -14,7 +14,9 @@ class Port(OutputType):
 	service_name: str = field(default='', compare=False)
 	cpes: list = field(default_factory=list, compare=False)
 	host: str = field(default='', repr=True, compare=False)
+	protocol: str = field(default='tcp', repr=True, compare=False)
 	extra_data: dict = field(default_factory=dict, compare=False)
+	confidence: str = field(default='low', repr=False, compare=False)
 	_timestamp: int = field(default_factory=lambda: time.time(), compare=False)
 	_source: str = field(default='', repr=True, compare=False)
 	_type: str = field(default='port', repr=True)
@@ -38,8 +40,13 @@ class Port(OutputType):
 
 	def __repr__(self) -> str:
 		s = f'🔓 {self.ip}:[bold red]{self.port:<4}[/] [bold yellow]{self.state.upper()}[/]'
+		if self.protocol != 'TCP':
+			s += f' \[[yellow3]{self.protocol}[/]]'
 		if self.service_name:
-			s += f' \[[bold purple]{self.service_name}[/]]'
+			conf = ''
+			if self.confidence == 'low':
+				conf = '?'
+			s += f' \[[bold purple]{self.service_name}{conf}[/]]'
 		if self.host:
 			s += f' \[[cyan]{self.host}[/]]'
 		return rich_to_ansi(s)