secator 0.10.1a12__py3-none-any.whl → 0.15.1__py3-none-any.whl

secator/celery.py

@@ -223,10 +223,11 @@ def forward_results(results):
 
 
 @app.task
-def mark_runner_started(runner, enable_hooks=True):
+def mark_runner_started(results, runner, enable_hooks=True):
 	"""Mark a runner as started and run on_start hooks.
 
 	Args:
+		results (List): Previous results.
 		runner (Runner): Secator runner instance.
 		enable_hooks (bool): Enable hooks.
 
@@ -234,9 +235,12 @@ def mark_runner_started(runner, enable_hooks=True):
 		list: Runner results
 	"""
 	debug(f'Runner {runner.unique_name} has started, running mark_started', sub='celery')
+	if results:
+		runner.results = forward_results(results)
 	runner.enable_hooks = enable_hooks
-	runner.mark_started()
-	return forward_results(runner.results)
+	if not runner.dry_run:
+		runner.mark_started()
+	return runner.results
 
 
 @app.task
@@ -254,8 +258,9 @@ def mark_runner_completed(results, runner, enable_hooks=True):
 	debug(f'Runner {runner.unique_name} has finished, running mark_completed', sub='celery')
 	results = forward_results(results)
 	runner.enable_hooks = enable_hooks
-	[runner.add_result(item) for item in results]
-	runner.mark_completed()
+	if not runner.dry_run:
+		[runner.add_result(item) for item in results]
+		runner.mark_completed()
 	return runner.results
 
 

secator/celery_signals.py

@@ -65,16 +65,6 @@ def setup_idle_timer(timeout):
     timer.start()
 
 
-def maybe_override_logging():
-    def decorator(func):
-        if CONFIG.celery.override_default_logging:
-            return signals.setup_logging.connect(func)
-        else:
-            return func
-    return decorator
-
-
-@maybe_override_logging()
 def setup_logging(*args, **kwargs):
     """Override celery's logging setup to prevent it from altering our settings.
     github.com/celery/celery/issues/1867
@@ -134,8 +124,9 @@ def worker_shutdown_handler(**kwargs):
 
 
 def setup_handlers():
+    if CONFIG.celery.override_default_logging:
+        signals.setup_logging.connect(setup_logging)
     signals.celeryd_after_setup.connect(capture_worker_name)
-    signals.setup_logging.connect(setup_logging)
     signals.task_prerun.connect(task_prerun_handler)
     signals.task_postrun.connect(task_postrun_handler)
     signals.task_revoked.connect(task_revoked_handler)

secator/cli.py

@@ -18,14 +18,14 @@ from rich.table import Table
 
 from secator.config import CONFIG, ROOT_FOLDER, Config, default_config, config_path
 from secator.decorators import OrderedGroup, register_runner
-from secator.definitions import ADDONS_ENABLED, ASCII, DEV_PACKAGE, OPT_NOT_SUPPORTED, VERSION, STATE_COLORS
+from secator.definitions import ADDONS_ENABLED, ASCII, DEV_PACKAGE, VERSION, STATE_COLORS
 from secator.installer import ToolInstaller, fmt_health_table_row, get_health_table, get_version_info, get_distro_config
 from secator.output_types import FINDING_TYPES, Info, Warning, Error
 from secator.report import Report
 from secator.rich import console
 from secator.runners import Command, Runner
 from secator.serializers.dataclass import loads_dataclass
-from secator.template import TemplateLoader
+from secator.template import TEMPLATES, TemplateLoader
 from secator.utils import (
 	debug, detect_host, discover_tasks, flatten, print_version, get_file_date,
 	sort_files_by_date, get_file_timestamp, list_reports, get_info_from_report_path, human_to_timedelta
@@ -34,26 +34,29 @@ from secator.utils import (
 click.rich_click.USE_RICH_MARKUP = True
 
 ALL_TASKS = discover_tasks()
-ALL_CONFIGS = TemplateLoader.load_all()
-ALL_WORKFLOWS = ALL_CONFIGS.workflow
-ALL_SCANS = ALL_CONFIGS.scan
+ALL_WORKFLOWS = [t for t in TEMPLATES if t.type == 'workflow']
+ALL_SCANS = [t for t in TEMPLATES if t.type == 'scan']
+ALL_PROFILES = [t for t in TEMPLATES if t.type == 'profile']
 FINDING_TYPES_LOWER = [c.__name__.lower() for c in FINDING_TYPES]
+CONTEXT_SETTINGS = dict(help_option_names=['-h', '-help', '--help'])
 
 
 #-----#
 # CLI #
 #-----#
 
-@click.group(cls=OrderedGroup, invoke_without_command=True)
-@click.option('--version', '-version', is_flag=True, default=False)
+
+@click.group(cls=OrderedGroup, invoke_without_command=True, context_settings=CONTEXT_SETTINGS)
+@click.option('--version', '-version', '-v', is_flag=True, default=False)
+@click.option('--quiet', '-quiet', '-q', is_flag=True, default=False)
 @click.pass_context
-def cli(ctx, version):
+def cli(ctx, version, quiet):
 	"""Secator CLI."""
 	ctx.obj = {
 		'piped_input': S_ISFIFO(os.fstat(0).st_mode),
 		'piped_output': not sys.stdout.isatty()
 	}
-	if not ctx.obj['piped_output']:
+	if not ctx.obj['piped_output'] and not quiet:
 		console.print(ASCII, highlight=False)
 	if ctx.invoked_subcommand is None:
 		if version:
@@ -66,11 +69,16 @@ def cli(ctx, version):
 # TASK #
 #------#
 
-@cli.group(aliases=['x', 't'])
+@cli.group(aliases=['x', 't'], invoke_without_command=True)
+@click.option('--list', '-list', is_flag=True, default=False)
 @click.pass_context
-def task(ctx):
+def task(ctx, list=False):
 	"""Run a task."""
-	pass
+	if list:
+		print("\n".join(sorted([t.__name__ for t in ALL_TASKS])))
+		return
+	if ctx.invoked_subcommand is None:
+		ctx.get_help()
 
 
 for cls in ALL_TASKS:
@@ -82,11 +90,16 @@ for cls in ALL_TASKS:
 #----------#
 
 
-@cli.group(cls=OrderedGroup, aliases=['w'])
+@cli.group(cls=OrderedGroup, aliases=['w'], invoke_without_command=True)
+@click.option('--list', '-list', is_flag=True, default=False)
 @click.pass_context
-def workflow(ctx):
+def workflow(ctx, list=False):
 	"""Run a workflow."""
-	pass
+	if list:
+		print("\n".join(sorted([t.name for t in ALL_WORKFLOWS])))
+		return
+	if ctx.invoked_subcommand is None:
+		ctx.get_help()
 
 
 for config in sorted(ALL_WORKFLOWS, key=lambda x: x['name']):
@@ -97,17 +110,41 @@ for config in sorted(ALL_WORKFLOWS, key=lambda x: x['name']):
 # SCAN #
 #------#
 
-@cli.group(cls=OrderedGroup, aliases=['s'])
+@cli.group(cls=OrderedGroup, aliases=['s'], invoke_without_command=True)
+@click.option('--list', '-list', is_flag=True, default=False)
 @click.pass_context
-def scan(ctx):
+def scan(ctx, list=False):
 	"""Run a scan."""
-	pass
+	if list:
+		print("\n".join(sorted([t.name for t in ALL_SCANS])))
+		return
+	if ctx.invoked_subcommand is None:
+		ctx.get_help()
 
 
 for config in sorted(ALL_SCANS, key=lambda x: x['name']):
 	register_runner(scan, config)
 
 
+@cli.group(aliases=['p'])
+@click.pass_context
+def profile(ctx):
+	"""Show profiles"""
+	pass
+
+
+@profile.command('list')
+def profile_list():
+	table = Table()
+	table.add_column("Profile name", style="bold gold3")
+	table.add_column("Description", overflow='fold')
+	table.add_column("Options", overflow='fold')
+	for profile in ALL_PROFILES:
+		opts_str = ','.join(f'{k}={v}' for k, v in profile.opts.items())
+		table.add_row(profile.name, profile.description, opts_str)
+	console.print(table)
+
+
 #--------#
 # WORKER #
 #--------#
@@ -118,12 +155,13 @@ for config in sorted(ALL_SCANS, key=lambda x: x['name']):
 @click.option('-r', '--reload', is_flag=True, help='Autoreload Celery on code changes.')
 @click.option('-Q', '--queue', type=str, default='', help='Listen to a specific queue.')
 @click.option('-P', '--pool', type=str, default='eventlet', help='Pool implementation.')
-@click.option('--quiet', is_flag=True, help='Quiet mode.')
+@click.option('--quiet', is_flag=True, default=False, help='Quiet mode.')
+@click.option('--loglevel', type=str, default='INFO', help='Log level.')
 @click.option('--check', is_flag=True, help='Check if Celery worker is alive.')
 @click.option('--dev', is_flag=True, help='Start a worker in dev mode (celery multi).')
 @click.option('--stop', is_flag=True, help='Stop a worker in dev mode (celery multi).')
 @click.option('--show', is_flag=True, help='Show command (celery multi).')
-def worker(hostname, concurrency, reload, queue, pool, quiet, check, dev, stop, show):
+def worker(hostname, concurrency, reload, queue, pool, quiet, loglevel, check, dev, stop, show):
 	"""Run a worker."""
 
 	# Check Celery addon is installed
@@ -169,6 +207,7 @@ def worker(hostname, concurrency, reload, queue, pool, quiet, check, dev, stop,
 
 	cmd += f' -P {pool}' if pool else ''
 	cmd += f' -c {concurrency}' if concurrency else ''
+	cmd += f' -l {loglevel}' if loglevel else ''
 
 	if reload:
 		patterns = "celery.py;tasks/*.py;runners/*.py;serializers/*.py;output_types/*.py;hooks/*.py;exporters/*.py"
@@ -666,7 +705,7 @@ def report_show(report_query, output, runner_type, time_delta, type, query, work
 					all_results.extend(runner.results)
 					continue
 				report = Report(runner, title=f"Consolidated report - {current}", exporters=exporters)
-				report.build(extractors=extractors if not unified else [])
+				report.build(extractors=extractors if not unified else [], dedupe=unified)
 				file_date = get_file_date(path)
 				runner_name = data['info']['name']
 				console.print(
@@ -744,7 +783,7 @@ def report_list(workspace, runner_type, time_delta):
 @report.command('export')
 @click.argument('json_path', type=str)
 @click.option('--output-folder', '-of', type=str)
-@click.option('-output', '-o', type=str)
+@click.option('-output', '-o', type=str, required=True)
 def report_export(json_path, output_folder, output):
 	with open(json_path, 'r') as f:
 		data = loads_dataclass(f.read())
@@ -857,13 +896,21 @@ def health(json, debug, strict):
 		import json as _json
 		print(_json.dumps(status))
 
+	# Print errors and warnings
+	error = False
+	for tool, info in status['tools'].items():
+		if not info['installed']:
+			console.print(Warning(message=f'{tool} is not installed.'))
+			error = True
+		elif info['outdated']:
+			message = (
+				f'{tool} is outdated (current:{info["version"]}, latest:{info["latest_version"]}).'
+				f' Run `secator install tools {tool}` to update it.'
+			)
+			console.print(Warning(message=message))
+
 	# Strict mode
 	if strict:
-		error = False
-		for tool, info in status['tools'].items():
-			if not info['installed']:
-				console.print(Error(message=f'{tool} not installed and strict mode is enabled.'))
-				error = True
 		if error:
 			sys.exit(1)
 		console.print(Info(message='Strict healthcheck passed !'))
@@ -878,21 +925,21 @@ def run_install(title=None, cmd=None, packages=None, next_steps=None):
 	if CONFIG.offline_mode:
 		console.print(Error(message='Cannot run this command in offline mode.'))
 		return
-	with console.status(f'[bold yellow] Installing {title}...'):
-		if cmd:
-			from secator.installer import SourceInstaller
-			status = SourceInstaller.install(cmd)
-		elif packages:
-			from secator.installer import PackageInstaller
-			status = PackageInstaller.install(packages)
-		return_code = 1
-		if status.is_ok():
-			return_code = 0
-			if next_steps:
-				console.print('[bold gold3]:wrench: Next steps:[/]')
-				for ix, step in enumerate(next_steps):
-					console.print(f'   :keycap_{ix}: {step}')
-		sys.exit(return_code)
+	# with console.status(f'[bold yellow] Installing {title}...'):
+	if cmd:
+		from secator.installer import SourceInstaller
+		status = SourceInstaller.install(cmd)
+	elif packages:
+		from secator.installer import PackageInstaller
+		status = PackageInstaller.install(packages)
+	return_code = 1
+	if status.is_ok():
+		return_code = 0
+		if next_steps:
+			console.print('[bold gold3]:wrench: Next steps:[/]')
+			for ix, step in enumerate(next_steps):
+				console.print(f'   :keycap_{ix}: {step}')
+	sys.exit(return_code)
 
 
 @cli.group()
@@ -1051,28 +1098,42 @@ def install_ruby():
 
 @install.command('tools')
 @click.argument('cmds', required=False)
-@click.option('--cleanup', is_flag=True, default=False)
-def install_tools(cmds, cleanup):
+@click.option('--cleanup', is_flag=True, default=False, help='Clean up tools after installation.')
+@click.option('--fail-fast', is_flag=True, default=False, help='Fail fast if any tool fails to install.')
+def install_tools(cmds, cleanup, fail_fast):
 	"""Install supported tools."""
 	if CONFIG.offline_mode:
 		console.print(Error(message='Cannot run this command in offline mode.'))
 		return
+	tools = []
 	if cmds is not None:
 		cmds = cmds.split(',')
-		tools = [cls for cls in ALL_TASKS if cls.__name__ in cmds]
+		for cmd in cmds:
+			if '==' in cmd:
+				cmd, version = tuple(cmd.split('=='))
+			else:
+				cmd, version = cmd, None
+			cls = next((cls for cls in ALL_TASKS if cls.__name__ == cmd), None)
+			if cls:
+				if version:
+					cls.install_version = version
+				tools.append(cls)
+			else:
+				console.print(Warning(message=f'Tool {cmd} is not supported or inexistent.'))
 	else:
 		tools = ALL_TASKS
 	tools.sort(key=lambda x: x.__name__)
 	return_code = 0
 	if not tools:
-		cmd_str = ' '.join(cmds)
-		console.print(Error(message=f'No tools found for {cmd_str}.'))
+		console.print(Error(message='No tools found for installing.'))
 		return
 	for ix, cls in enumerate(tools):
-		with console.status(f'[bold yellow][{ix + 1}/{len(tools)}] Installing {cls.__name__} ...'):
-			status = ToolInstaller.install(cls)
-			if not status.is_ok():
-				return_code = 1
+		# with console.status(f'[bold yellow][{ix + 1}/{len(tools)}] Installing {cls.__name__} ...'):
+		status = ToolInstaller.install(cls)
+		if not status.is_ok():
+			return_code = 1
+			if fail_fast:
+				sys.exit(return_code)
 		console.print()
 	if cleanup:
 		distro = get_distro_config()
@@ -1132,14 +1193,13 @@ def update(all):
 		return_code = 0
 		for cls in ALL_TASKS:
 			cmd = cls.cmd.split(' ')[0]
-			version_flag = cls.version_flag or f'{cls.opt_prefix}version'
-			version_flag = None if cls.version_flag == OPT_NOT_SUPPORTED else version_flag
+			version_flag = cls.get_version_flag()
 			info = get_version_info(cmd, version_flag, cls.install_github_handle)
-			if not info['installed'] or info['status'] == 'outdated' or not info['latest_version']:
-				with console.status(f'[bold yellow]Installing {cls.__name__} ...'):
-					status = ToolInstaller.install(cls)
-					if not status.is_ok():
-						return_code = 1
+			if not info['installed'] or info['outdated'] or not info['latest_version']:
+				# with console.status(f'[bold yellow]Installing {cls.__name__} ...'):
+				status = ToolInstaller.install(cls)
+				if not status.is_ok():
+					return_code = 1
 		sys.exit(return_code)
 
 #-------#
@@ -1250,24 +1310,35 @@ def test():
 	pass
 
 
-def run_test(cmd, name):
+def run_test(cmd, name=None, exit=True, verbose=False):
 	"""Run a test and return the result.
 
 	Args:
-		cmd: Command to run.
-		name: Name of the test.
+		cmd (str): Command to run.
+		name (str, optional): Name of the test.
+		exit (bool, optional): Exit after running the test with the return code.
+		verbose (bool, optional): Print verbose output.
+
+	Returns:
+		Return code of the test.
 	"""
-	result = Command.execute(cmd, name=name + ' tests', cwd=ROOT_FOLDER)
-	if result.return_code == 0:
-		console.print(f':tada: {name.capitalize()} tests passed !', style='bold green')
-	sys.exit(result.return_code)
+	cmd_name = name + ' tests' if name else 'tests'
+	result = Command.execute(cmd, name=cmd_name, cwd=ROOT_FOLDER, quiet=not verbose)
+	if name:
+		if result.return_code == 0:
+			console.print(f':tada: {name.capitalize()} tests passed !', style='bold green')
+		else:
+			console.print(f':x: {name.capitalize()} tests failed !', style='bold red')
+	if exit:
+		sys.exit(result.return_code)
+	return result.return_code
 
 
 @test.command()
 def lint():
 	"""Run lint tests."""
 	cmd = f'{sys.executable} -m flake8 secator/'
-	run_test(cmd, 'lint')
+	run_test(cmd, 'lint', verbose=True)
 
 
 @test.command()
@@ -1285,13 +1356,21 @@ def unit(tasks, workflows, scans, test):
 	os.environ['SECATOR_HTTP_STORE_RESPONSES'] = '0'
 	os.environ['SECATOR_RUNNERS_SKIP_CVE_SEARCH'] = '1'
 
+	if not test:
+		if tasks:
+			test = 'test_tasks'
+		elif workflows:
+			test = 'test_workflows'
+		elif scans:
+			test = 'test_scans'
+
 	import shutil
 	shutil.rmtree('/tmp/.secator', ignore_errors=True)
 	cmd = f'{sys.executable} -m coverage run --omit="*test*" --data-file=.coverage.unit -m pytest -s -v tests/unit'
 	if test:
 		test_str = ' or '.join(test.split(','))
 		cmd += f' -k "{test_str}"'
-	run_test(cmd, 'unit')
+	run_test(cmd, 'unit', verbose=True)
 
 
 @test.command()
@@ -1307,6 +1386,14 @@ def integration(tasks, workflows, scans, test):
 	os.environ['SECATOR_DIRS_DATA'] = '/tmp/.secator'
 	os.environ['SECATOR_RUNNERS_SKIP_CVE_SEARCH'] = '1'
 
+	if not test:
+		if tasks:
+			test = 'test_tasks'
+		elif workflows:
+			test = 'test_workflows'
+		elif scans:
+			test = 'test_scans'
+
 	import shutil
 	shutil.rmtree('/tmp/.secator', ignore_errors=True)
 
@@ -1314,7 +1401,7 @@ def integration(tasks, workflows, scans, test):
 	if test:
 		test_str = ' or '.join(test.split(','))
 		cmd += f' -k "{test_str}"'
-	run_test(cmd, 'integration')
+	run_test(cmd, 'integration', verbose=True)
 
 
 @test.command()
@@ -1337,7 +1424,160 @@ def performance(tasks, workflows, scans, test):
 	if test:
 		test_str = ' or '.join(test.split(','))
 		cmd += f' -k "{test_str}"'
-	run_test(cmd, 'performance')
+	run_test(cmd, 'performance', verbose=True)
+
+
+@test.command()
+@click.argument('name', type=str)
+@click.option('--verbose', '-v', is_flag=True, default=False, help='Print verbose output')
+@click.option('--check', '-c', is_flag=True, default=False, help='Check task semantics only (no unit + integration tests)')  # noqa: E501
+def task(name, verbose, check):
+	"""Test a single task for semantics errors, and run unit + integration tests."""
+	console.print(f'[bold gold3]:wrench: Testing task {name} ...[/]')
+	task = [task for task in ALL_TASKS if task.__name__ == name]
+	warnings = []
+	errors = []
+	exit_code = 0
+
+	# Check if task is correctly registered
+	task = task[0]
+	task_name = task.__name__
+
+	# Check task command is set
+	check_test(
+		task.cmd,
+		'Check task command is set (cls.cmd)',
+		'Task has no cmd attribute.',
+		errors
+	)
+	if errors:
+		sys.exit(0)
+
+	# Run install
+	cmd = f'secator install tools {task_name}'
+	ret_code = Command.execute(cmd, name='install', quiet=not verbose, cwd=ROOT_FOLDER)
+	version_info = task.get_version_info()
+	if verbose:
+		console.print(f'Version info:\n{version_info}')
+	status = version_info['status']
+	check_test(
+		version_info['installed'],
+		'Check task is installed',
+		'Failed to install command. Fix your installation command.',
+		errors
+	)
+	check_test(
+		any(cmd for cmd in [task.install_pre, task.install_cmd, task.install_github_handle]),
+		'Check task installation command is defined',
+		'Task has no installation command. Please define one or more of the following class attributes: `install_pre`, `install_cmd`, `install_post`, `install_github_handle`.',  # noqa: E501
+		errors
+	)
+	check_test(
+		version_info['version'],
+		'Check task version can be fetched',
+		'Failed to detect current version. Consider updating your `version_flag` class attribute.',
+		warnings,
+		warn=True
+	)
+	check_test(
+		status != 'latest unknown',
+		'Check latest version',
+		'Failed to detect latest version.',
+		warnings,
+		warn=True
+	)
+	check_test(
+		not version_info['outdated'],
+		'Check task version is up to date',
+		f'Task is not up to date (current version: {version_info["version"]}, latest: {version_info["latest_version"]}). Consider updating your `install_version` class attribute.',  # noqa: E501
+		warnings,
+		warn=True
+	)
+
+	# Run task-specific tests
+	check_test(
+		task.__doc__,
+		'Check task description is set (cls.__doc__)',
+		'Task has no description (class docstring).',
+		errors
+	)
+	check_test(
+		task.input_types,
+		'Check task input type is set (cls.input_type)',
+		'Task has no input_type attribute.',
+		warnings,
+		warn=True
+	)
+	check_test(
+		task.output_types,
+		'Check task output types is set (cls.output_types)',
+		'Task has no output_types attribute. Consider setting some so that secator can load your task outputs.',
+		warnings,
+		warn=True
+	)
+	check_test(
+		task.install_version,
+		'Check task install_version is set (cls.install_version)',
+		'Task has no install_version attribute. Consider setting it to pin the tool version and ensure it does not break in the future.',  # noqa: E501
+		warnings,
+		warn=True
+	)
+
+	if not check:
+
+		# Run unit tests
+		cmd = f'secator test unit --tasks {name}'
+		ret_code = run_test(cmd, exit=False, verbose=verbose)
+		check_test(
+			ret_code == 0,
+			'Check unit tests pass',
+			'Unit tests failed.',
+			errors
+		)
+
+		# Run integration tests
+		cmd = f'secator test integration --tasks {name}'
+		ret_code = run_test(cmd, exit=False, verbose=verbose)
+		check_test(
+			ret_code == 0,
+			'Check integration tests pass',
+			'Integration tests failed.',
+			errors
+		)
+
+	# Exit with exit code
+	exit_code = 1 if len(errors) > 0 else 0
+	if exit_code == 0:
+		console.print(f':tada: Task {name} tests passed !', style='bold green')
+	else:
+		console.print('\n[bold gold3]Errors:[/]')
+		for error in errors:
+			console.print(error)
+		console.print(Error(message=f'Task {name} tests failed. Please fix the issues above.'))
+
+	if warnings:
+		console.print('\n[bold gold3]Warnings:[/]')
+		for warning in warnings:
+			console.print(warning)
+
+	console.print("\n")
+	sys.exit(exit_code)
+
+
+def check_test(condition, message, fail_message, results=[], warn=False):
+	console.print(f'[bold magenta]:zap: {message} ...[/]', end='')
+	if not condition:
+		if not warn:
+			error = Error(message=fail_message)
+			console.print(' [bold red]FAILED[/]', style='dim')
+			results.append(error)
+		else:
+			warning = Warning(message=fail_message)
+			console.print(' [bold yellow]WARNING[/]', style='dim')
+			results.append(warning)
+	else:
+		console.print(' [bold green]OK[/]', style='dim')
+	return True
 
 
 @test.command()

secator/config.py

@@ -94,6 +94,7 @@ class Runners(StrictModel):
 	skip_cve_low_confidence: bool = False
 	remove_duplicates: bool = False
 	show_chunk_progress: bool = False
+	show_command_output: bool = False
 
 
 class Security(StrictModel):
@@ -623,8 +624,8 @@ for name, dir in CONFIG.dirs.items():
 		console.print('[bold green]ok.[/]')
 
 # Download wordlists and payloads
-download_files(CONFIG.wordlists.templates, CONFIG.dirs.wordlists, CONFIG.offline_mode, 'wordlist')
-download_files(CONFIG.payloads.templates, CONFIG.dirs.payloads, CONFIG.offline_mode, 'payload')
+# download_files(CONFIG.wordlists.templates, CONFIG.dirs.wordlists, CONFIG.offline_mode, 'wordlist')
+# download_files(CONFIG.payloads.templates, CONFIG.dirs.payloads, CONFIG.offline_mode, 'payload')
 
 # Print config
 if CONFIG.debug.component == 'config':

secator/configs/profiles/aggressive.yaml

@@ -1,7 +1,8 @@
 type: profile
 name: aggressive
-options:
-  rate_limit: 100000
-  delay: 0
-  proxy: random
-  user_agent: random
+description: "Internal networks or time-sensitive scans"
+opts:
+    rate_limit: 10000
+    delay: 0
+    timeout: 1
+    retries: 1

secator/configs/profiles/default.yaml

@@ -1,9 +1,8 @@
 type: profile
 name: default
-options:
-  rate_limit: 1000
-  delay: 1
-  proxy: null
-  user_agent: 'Mozilla ...'
-  nuclei.retries: 5
-  nuclei.timeout: 15
+description: "General scanning"
+opts:
+    rate_limit: 1000
+    delay: 0
+    timeout: 5
+    retries: 3