secator 0.10.1a7__tar.gz → 0.10.1a8__tar.gz

{secator-0.10.1a7 → secator-0.10.1a8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: secator
-Version: 0.10.1a7
+Version: 0.10.1a8
 Summary: The pentester's swiss knife.
 Project-URL: Homepage, https://github.com/freelabz/secator
 Project-URL: Issues, https://github.com/freelabz/secator/issues

{secator-0.10.1a7 → secator-0.10.1a8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = 'hatchling.build'
 
 [project]
 name = 'secator'
-version = "0.10.1a7"
+version = "0.10.1a8"
 authors = [{ name = 'FreeLabz', email = 'sales@freelabz.com' }]
 readme = 'README.md'
 description = "The pentester's swiss knife."

{secator-0.10.1a7 → secator-0.10.1a8}/secator/celery.py

@@ -170,8 +170,8 @@ def run_scan(self, args=[], kwargs={}):
 def run_command(self, results, name, targets, opts={}):
 	if IN_CELERY_WORKER_PROCESS:
 		opts.update({'print_item': True, 'print_line': True, 'print_cmd': True})
-		routing_key = self.request.delivery_info['routing_key']
-		console.print(Info(message=f'Task "{name}" running with routing key "{routing_key}"'))
+		# routing_key = self.request.delivery_info['routing_key']
+		# console.print(Info(message=f'Task "{name}" running with routing key "{routing_key}"'))
 
 	# Flatten + dedupe + filter results
 	results = forward_results(results)
@@ -188,8 +188,7 @@ def run_command(self, results, name, targets, opts={}):
 	sync = not IN_CELERY_WORKER_PROCESS
 	task_cls = Task.get_task_class(name)
 	task = task_cls(targets, **opts)
-	task.started = True
-	task.run_hooks('on_start')
+	task.mark_started()
 	update_state(self, task, force=True)
 
 	# Chunk task if needed
@@ -220,56 +219,43 @@ def forward_results(results):
 		results = results['results']
 	results = flatten(results)
 	results = deduplicate(results, attr='_uuid')
-	if IN_CELERY_WORKER_PROCESS:
-		console.print(Info(message=f'Forwarding {len(results)} results ...'))
 	return results
 
 
 @app.task
-def mark_runner_started(runner):
+def mark_runner_started(runner, enable_hooks=True):
 	"""Mark a runner as started and run on_start hooks.
 
 	Args:
-		runner (Runner): Secator runner instance
+		runner (Runner): Secator runner instance.
+		enable_hooks (bool): Enable hooks.
 
 	Returns:
 		list: Runner results
 	"""
-	if IN_CELERY_WORKER_PROCESS:
-		console.print(Info(message=f'Marking runner {runner.unique_name} as started'))
-	runner.started = True
-	# runner.start_time = time()
-	runner.run_hooks('on_start')
-	return runner.results
+	debug(f'Runner {runner.unique_name} has started, running mark_started', sub='celery')
+	runner.enable_hooks = enable_hooks
+	runner.mark_started()
+	return forward_results(runner.results)
 
 
 @app.task
-def mark_runner_complete(results, runner):
+def mark_runner_completed(results, runner, enable_hooks=True):
 	"""Mark a runner as completed and run on_end hooks.
 
 	Args:
 		results (list): Task results
 		runner (Runner): Secator runner instance
+		enable_hooks (bool): Enable hooks.
 
 	Returns:
 		list: Final results
 	"""
-	if IN_CELERY_WORKER_PROCESS:
-		console.print(Info(message=f'Marking runner {runner.unique_name} as completed'))
+	debug(f'Runner {runner.unique_name} has finished, running mark_completed', sub='celery')
 	results = forward_results(results)
-
-	# If sync mode, don't update the runner as it's already done
-	if runner.sync:
-		if IN_CELERY_WORKER_PROCESS:
-			console.print(Info(message=f'Runner {runner.unique_name} is in sync mode, skipping final processing'))
-		return results
-
-	# Run final processing
-	runner.results = results
-	# if not runner.no_process:
-		# runner.mark_duplicates()
-	runner.log_results()
-	runner.run_hooks('on_end')
+	runner.enable_hooks = enable_hooks
+	[runner.add_result(item) for item in results]
+	runner.mark_completed()
 	return runner.results
 
 
@@ -331,6 +317,6 @@ def break_task(task, task_opts, results=[]):
 	# Build Celery workflow
 	workflow = chord(
 		tuple(sigs),
-		mark_runner_complete.s(runner=task).set(queue='results')
+		mark_runner_completed.s(runner=task).set(queue='results')
 	)
 	return workflow

{secator-0.10.1a7 → secator-0.10.1a8}/secator/celery_utils.py

@@ -144,7 +144,7 @@ class CeleryData(object):
 					_source='celery'
 				)
 				debug(f"Main task state: {result.id} - {result.state}", sub='celery.poll', verbose=True)
-				yield {'id': result.id, 'results': [main_task]}
+				yield {'id': result.id, 'state': result.state, 'results': [main_task]}
 				yield from CeleryData.get_all_data(result, ids_map)
 
 				if result.ready():
@@ -155,7 +155,7 @@ class CeleryData(object):
 						_source='celery'
 					)
 					debug(f"Final main task state: {result.id} - {result.state}", sub='celery.poll', verbose=True)
-					yield {'id': result.id, 'results': [main_task]}
+					yield {'id': result.id, 'state': result.state, 'results': [main_task]}
 					yield from CeleryData.get_all_data(result, ids_map)
 					break
 			except (KeyboardInterrupt, GreenletExit):

{secator-0.10.1a7 → secator-0.10.1a8}/secator/configs/workflows/cidr_recon.yaml

@@ -11,7 +11,7 @@ tasks:
   fping:
     description: Check for alive IPs
     targets_: ip.ip
-  naabu:
+  nmap:
     description: Scan alive IPs' ports
     targets_:
     - type: ip

{secator-0.10.1a7 → secator-0.10.1a8}/secator/configs/workflows/host_recon.yaml

@@ -7,21 +7,23 @@ input_types:
   - host
   - cidr_range
 tasks:
-  naabu:
-    description: Find open ports
   nmap:
     description: Search for vulnerabilities on open ports
     skip_host_discovery: True
-    version_detection: True
-    targets_: port.host
-    ports_: port.port
-  httpx:
-    description: Probe HTTP services on open ports
-    targets_:
-      - type: port
-        field: '{host}:{port}'
-        condition: item._source.startswith('nmap')
-  _group:
+    ports: "-"  # scan all ports
+  _group/1:
+    httpx:
+      description: Probe HTTP services on open ports
+      targets_:
+        - type: port
+          field: '{host}:{port}'
+    searchsploit:
+      description: Search for related exploits
+      targets_:
+        - type: port
+          field: service_name
+          condition: len(item.service_name.split('/')) > 1
+  _group/2:
     nuclei/network:
       description: Scan network and SSL vulnerabilities
       tags: [network, ssl]
@@ -32,12 +34,3 @@ tasks:
         - type: url
           field: url
           condition: item.status_code != 0
-results:
-  - type: port
-    condition: item._source.startswith('nmap')
-
-  - type: vulnerability
-  #   condition: item.confidence == 'high'
-
-  - type: url
-    condition: item.status_code != 0

{secator-0.10.1a7 → secator-0.10.1a8}/secator/runners/_base.py

@@ -1,6 +1,5 @@
 import json
 import logging
-import os
 import sys
 import uuid
 from datetime import datetime
@@ -65,9 +64,6 @@ class Runner:
 	# Run hooks
 	enable_hooks = True
 
-	# Reports folder
-	reports_folder = None
-
 	def __init__(self, config, inputs=[], results=[], run_opts={}, hooks={}, validators={}, context={}):
 		self.uuids = []
 		self.results = []
@@ -98,6 +94,8 @@ class Runner:
 		self.no_poll = self.run_opts.get('no_poll', False)
 		self.quiet = self.run_opts.get('quiet', False)
 		self.started = False
+		self.enable_reports = self.run_opts.get('enable_reports', not self.sync)
+		self._reports_folder = self.run_opts.get('reports_folder', None)
 
 		# Runner process options
 		self.no_process = self.run_opts.get('no_process', False)
@@ -135,7 +133,7 @@ class Runner:
 			inputs, run_opts, errors = run_extractors(self.results, run_opts, inputs)
 			for error in errors:
 				self.add_result(error, print=True)
-		self.inputs = inputs
+		self.inputs = list(set(inputs))
 
 		# Debug
 		self.debug('Inputs', obj=self.inputs, sub='init')
@@ -146,16 +144,6 @@ class Runner:
 		exporters_str = self.run_opts.get('output') or self.default_exporters
 		self.exporters = self.resolve_exporters(exporters_str)
 
-		# Determine report folder
-		default_reports_folder_base = f'{CONFIG.dirs.reports}/{self.workspace_name}/{self.config.type}s'
-		_id = get_task_folder_id(default_reports_folder_base)
-		self.reports_folder = f'{default_reports_folder_base}/{_id}'
-
-		# Make reports folders
-		os.makedirs(self.reports_folder, exist_ok=True)
-		os.makedirs(f'{self.reports_folder}/.inputs', exist_ok=True)
-		os.makedirs(f'{self.reports_folder}/.outputs', exist_ok=True)
-
 		# Profiler
 		self.enable_profiler = self.run_opts.get('enable_profiler', False) and ADDONS_ENABLED['trace']
 		if self.enable_profiler:
@@ -260,6 +248,23 @@ class Runner:
 			'descr': self.config.description or '',
 		}
 
+	@property
+	def reports_folder(self):
+		if self._reports_folder and Path(self._reports_folder).exists():
+			return self._reports_folder
+		_base = f'{CONFIG.dirs.reports}/{self.workspace_name}/{self.config.type}s'
+		_id = get_task_folder_id(_base)
+		path = Path(f'{_base}/{_id}')
+		path_inputs = path / '.inputs'
+		path_outputs = path / '.outputs'
+		if not path.exists():
+			self.debug(f'Creating reports folder {path}')
+			path.mkdir(parents=True, exist_ok=True)
+			path_inputs.mkdir(exist_ok=True)
+			path_outputs.mkdir(exist_ok=True)
+		self._reports_folder = path.resolve()
+		return self._reports_folder
+
 	def run(self):
 		"""Run method.
 
@@ -275,16 +280,14 @@ class Runner:
 			OutputType: runner result.
 		"""
 		try:
-			self.log_start()
-			self.run_hooks('on_start')
+			# If sync mode, set started
+			if self.sync:
+				self.mark_started()
 
-			# If any errors happened during valid ation, exit
+			# If any errors happened during validation, exit
 			if self.errors:
 				yield from self.errors
-				if self.no_process:
-					return
-				self.log_results()
-				self.run_hooks('on_end')
+				self.mark_completed()
 				return
 
 			# Loop and process items
@@ -304,13 +307,13 @@ class Runner:
 			self.stop_celery_tasks()
 			yield from self.join_threads()
 			yield error
+			self.mark_completed()
 
 		finally:
-			if self.no_process:
-				return
-			self.mark_duplicates()
-			self.log_results()
-			self.run_hooks('on_end')
+			if self.sync:
+				self.mark_completed()
+			if self.enable_reports:
+				self.export_reports()
 
 	def join_threads(self):
 		"""Wait for all running threads to complete."""
@@ -496,7 +499,6 @@ class Runner:
 		# Run workflow and get results
 		if self.sync:
 			self.print_item = False
-			self.started = True
 			results = workflow.apply().get()
 			yield from results
 		else:
@@ -508,6 +510,7 @@ class Runner:
 			)
 			if self.no_poll:
 				self.enable_hooks = False
+				self.enable_reports = False
 				self.no_process = True
 				return
 			results = CeleryData.iter_results(
@@ -677,30 +680,53 @@ class Runner:
 				self.debug('', obj={name + ' [dim yellow]->[/] ' + fun: 'registered (user)'}, sub='validators')
 			self.validators[key].extend(user_validators)
 
+	def mark_started(self):
+		"""Mark runner as started."""
+		if self.started:
+			return
+		self.started = True
+		self.start_time = datetime.fromtimestamp(time())
+		self.debug(f'started (sync: {self.sync}, hooks: {self.enable_hooks})')
+		self.log_start()
+		self.run_hooks('on_start')
+
+	def mark_completed(self):
+		"""Mark runner as completed."""
+		if self.done:
+			return
+		self.started = True
+		self.done = True
+		self.progress = 100
+		self.end_time = datetime.fromtimestamp(time())
+		self.debug(f'completed (sync: {self.sync}, reports: {self.enable_reports}, hooks: {self.enable_hooks})')
+		self.mark_duplicates()
+		self.run_hooks('on_end')
+		self.export_profiler()
+		self.log_results()
+
 	def log_start(self):
 		"""Log runner start."""
 		if not self.print_remote_info:
 			return
 		remote_str = 'starting' if self.sync else 'sent to Celery worker'
-		runner_name = self.__class__.__name__
-		info = Info(message=f'{runner_name} {self.config.name} {remote_str}...', _source=self.unique_name)
+		info = Info(message=f'{self.config.type.capitalize()} {self.unique_name} {remote_str}...', _source=self.unique_name)
 		self._print_item(info)
 
 	def log_results(self):
 		"""Log runner results."""
-		self.started = True
-		self.done = True
-		self.progress = 100
-		self.end_time = datetime.fromtimestamp(time())
-		if self.status == 'FAILURE':
-			self.debug('', obj={self.__class__.__name__: self.status, 'errors': [str(_.message) for _ in self.errors]}, sub='status')  # noqa: E501
-		else:
-			self.debug('', obj={self.__class__.__name__: self.status}, sub='status')
-		if self.exporters and not self.no_process:
+		info = Info(message=f'{self.config.type.capitalize()} {self.unique_name} finished with status {self.status} and found {len(self.self_findings)} findings', _source=self.unique_name)  # noqa: E501
+		self._print_item(info)
+
+	def export_reports(self):
+		"""Export reports."""
+		if self.enable_reports and self.exporters and not self.no_process:
 			report = Report(self, exporters=self.exporters)
 			report.build()
 			report.send()
 			self.report = report
+
+	def export_profiler(self):
+		"""Export profiler."""
 		if self.enable_profiler:
 			self.profiler.stop()
 			profile_path = Path(self.reports_folder) / f'{self.unique_name}_profile.html'
@@ -858,13 +884,16 @@ class Runner:
 
 		# Check for state updates
 		if isinstance(item, State) and self.celery_result and item.task_id == self.celery_result.id:
-			self.debug(f'Updating runner state from Celery: {item.state}', sub='state')
+			self.debug(f'Sync runner state from remote: {item.state}')
 			if item.state in ['FAILURE', 'SUCCESS', 'REVOKED']:
 				self.started = True
 				self.done = True
+				self.progress = 100
+				self.end_time = datetime.fromtimestamp(time())
 			elif item.state in ['RUNNING']:
 				self.started = True
-			self.debug(f'Runner {self.unique_name} is {self.status} (started: {self.started}, done: {self.done})', sub='state')
+				self.start_time = datetime.fromtimestamp(time())
+				self.end_time = None
 			self.last_updated_celery = item._timestamp
 			return
 

{secator-0.10.1a7 → secator-0.10.1a8}/secator/runners/scan.py

@@ -24,7 +24,7 @@ class Scan(Runner):
 			celery.Signature: Celery task signature.
 		"""
 		from celery import chain
-		from secator.celery import mark_runner_started, mark_runner_complete
+		from secator.celery import mark_runner_started, mark_runner_completed
 		from secator.template import TemplateLoader
 
 		scan_opts = self.config.options
@@ -52,5 +52,5 @@ class Scan(Runner):
 		return chain(
 			mark_runner_started.si(self).set(queue='results'),
 			*sigs,
-			mark_runner_complete.s(self).set(queue='results'),
+			mark_runner_completed.s(self).set(queue='results'),
 		)

{secator-0.10.1a7 → secator-0.10.1a8}/secator/runners/task.py

@@ -24,7 +24,7 @@ class Task(Runner):
 		Returns:
 			celery.Signature: Celery task signature.
 		"""
-		from secator.celery import run_command, mark_runner_started, mark_runner_complete
+		from secator.celery import run_command
 
 		# Get task class
 		task_cls = Task.get_task_class(self.config.name)
@@ -34,27 +34,25 @@ class Task(Runner):
 		opts.pop('output', None)
 		opts.pop('no_poll', False)
 
-		# Set task output types
+		# Set output types
 		self.output_types = task_cls.output_types
-		self.enable_duplicate_check = False
-		self.enable_hooks = False
+
+		# Set hooks and reports
+		self.enable_hooks = False   # Celery will handle hooks
+		self.enable_reports = True  # Task will handle reports
 
 		# Get hooks
 		hooks = self._hooks.get(Task, {})
 		opts['hooks'] = hooks
-		opts['context'] = self.context
+		opts['context'] = self.context.copy()
+		opts['reports_folder'] = str(self.reports_folder)
+		opts['enable_reports'] = False  # Task will handle reports
 
 		# Create task signature
 		task_id = str(uuid.uuid4())
-		sig = run_command.s(self.config.name, self.inputs, opts).set(queue=task_cls.profile, task_id=task_id)
+		sig = run_command.si(self.results, self.config.name, self.inputs, opts).set(queue=task_cls.profile, task_id=task_id)
 		self.add_subtask(task_id, self.config.name, self.config.description or '')
-
-		# Build signature chain with lifecycle management
-		return chain(
-			mark_runner_started.si(self).set(queue='results'),
-			sig,
-			mark_runner_complete.s(self).set(queue='results'),
-		)
+		return chain(sig)
 
 	@staticmethod
 	def get_task_class(name):

{secator-0.10.1a7 → secator-0.10.1a8}/secator/runners/workflow.py

@@ -27,13 +27,25 @@ class Workflow(Runner):
 			celery.Signature: Celery task signature.
 		"""
 		from celery import chain
-		from secator.celery import mark_runner_started, mark_runner_complete
+		from secator.celery import mark_runner_started, mark_runner_completed
 
 		# Prepare run options
 		opts = self.run_opts.copy()
-		opts['hooks'] = self._hooks.get(Task, {})
+		opts.pop('output', None)
 		opts.pop('no_poll', False)
 
+		# Set hooks and reports
+		self.enable_reports = True  # Workflow will handle reports
+		self.enable_hooks = False   # Celery will handle hooks
+		# Get hooks
+		hooks = self._hooks.get(Task, {})
+		opts['hooks'] = hooks
+		opts['context'] = self.context.copy()
+		opts['reports_folder'] = str(self.reports_folder)
+		opts['enable_reports'] = False  # Workflow will handle reports
+		opts['has_parent'] = True
+		opts['skip_if_no_inputs'] = True
+
 		# Build task signatures
 		sigs = self.get_tasks(
 			self.config.tasks.toDict(),
@@ -43,9 +55,9 @@ class Workflow(Runner):
 
 		# Build workflow chain with lifecycle management
 		return chain(
-			mark_runner_started.si(self).set(queue='results'),
+			mark_runner_started.si(self, enable_hooks=True).set(queue='results'),
 			*sigs,
-			mark_runner_complete.s(self).set(queue='results'),
+			mark_runner_completed.s(self, enable_hooks=True).set(queue='results'),
 		)
 
 	def get_tasks(self, config, inputs, workflow_opts, run_opts):
@@ -91,13 +103,7 @@ class Workflow(Runner):
 
 				# Merge task options (order of priority with overrides)
 				opts = merge_opts(workflow_opts, task_opts, run_opts)
-
-				# Add task context and hooks to options
-				opts['hooks'] = {task: self._hooks.get(Task, {})}
-				opts['context'] = self.context.copy()
 				opts['name'] = task_name
-				opts['has_parent'] = True
-				opts['skip_if_no_inputs'] = True
 
 				# Create task signature
 				task_id = str(uuid.uuid4())

{secator-0.10.1a7 → secator-0.10.1a8}/secator/tasks/naabu.py

@@ -48,7 +48,7 @@ class naabu(ReconPort):
 	}
 	output_types = [Port]
 	install_cmd = 'go install -v github.com/projectdiscovery/naabu/v2/cmd/naabu@v2.3.3'
-	# install_github_handle = 'projectdiscovery/naabu'
+	install_github_handle = 'projectdiscovery/naabu'
 	install_pre = {'apt': ['libpcap-dev'], 'apk': ['libpcap-dev', 'libc6-compat'], 'pacman|brew': ['libpcap']}
 	install_post = {'arch|alpine': 'sudo ln -sf /usr/lib/libpcap.so /usr/lib/libpcap.so.0.8'}
 	proxychains = False

{secator-0.10.1a7 → secator-0.10.1a8}/secator/tasks/nmap.py

@@ -30,14 +30,55 @@ class nmap(VulnMulti):
 	opt_prefix = '--'
 	output_types = [Port, Vulnerability, Exploit]
 	opts = {
-		PORTS: {'type': str, 'short': 'p', 'help': 'Ports to scan'},
-		TOP_PORTS: {'type': int, 'short': 'tp', 'help': 'Top ports to scan [full, 100, 1000]'},
-		SCRIPT: {'type': str, 'default': 'vulners', 'help': 'NSE scripts'},
+		# Port specification and scan order
+		PORTS: {'type': str, 'short': 'p', 'help': 'Ports to scan (- to scan all)'},
+		TOP_PORTS: {'type': int, 'short': 'tp', 'help': 'Top ports to scan [100, 1000, full]'},
+
+		# Script scanning
+		SCRIPT: {'type': str, 'default': None, 'help': 'NSE scripts'},
+		'script_args': {'type': str, 'default': None, 'help': 'NSE script arguments (n1=v1,n2=v2,...)'},
+
+		# Host discovery
 		'skip_host_discovery': {'is_flag': True, 'short': 'Pn', 'default': False, 'help': 'Skip host discovery (no ping)'},
-		'version_detection': {'is_flag': True, 'short': 'sV', 'default': False, 'help': 'Version detection'},
+
+		# Service and version detection
+		'version_detection': {'is_flag': True, 'short': 'sV', 'default': False, 'help': 'Enable version detection (slow)'},
+		'detect_all': {'is_flag': True, 'short': 'A', 'default': False, 'help': 'Enable OS detection, version detection, script scanning, and traceroute on open ports'},  # noqa: E501
+		'detect_os': {'is_flag': True, 'short': 'O', 'default': False, 'help': 'Enable OS detection'},
+
+		# Scan techniques
 		'tcp_syn_stealth': {'is_flag': True, 'short': 'sS', 'default': False, 'help': 'TCP SYN Stealth'},
 		'tcp_connect': {'is_flag': True, 'short': 'sT', 'default': False, 'help': 'TCP Connect scan'},
 		'udp_scan': {'is_flag': True, 'short': 'sU', 'default': False, 'help': 'UDP scan'},
+		'tcp_null_scan': {'is_flag': True, 'short': 'sN', 'default': False, 'help': 'TCP Null scan'},
+		'tcp_fin_scan': {'is_flag': True, 'short': 'sF', 'default': False, 'help': 'TCP FIN scan'},
+		'tcp_xmas_scan': {'is_flag': True, 'short': 'sX', 'default': False, 'help': 'TCP Xmas scan'},
+		'tcp_ack_scan': {'is_flag': True, 'short': 'sA', 'default': False, 'help': 'TCP ACK scan'},
+		'tcp_window_scan': {'is_flag': True, 'short': 'sW', 'default': False, 'help': 'TCP Window scan'},
+		'tcp_maimon_scan': {'is_flag': True, 'short': 'sM', 'default': False, 'help': 'TCP Maimon scan'},
+		'sctp_init_scan': {'is_flag': True, 'short': 'sY', 'default': False, 'help': 'SCTP Init scan'},
+		'sctp_cookie_echo_scan': {'is_flag': True, 'short': 'sZ', 'default': False, 'help': 'SCTP Cookie Echo scan'},
+		'ping_scan': {'is_flag': True, 'short': 'sn', 'default': False, 'help': 'Ping scan (disable port scan)'},
+		'ip_protocol_scan': {'type': str, 'short': 'sO', 'default': None, 'help': 'IP protocol scan'},
+		'script_scan': {'is_flag': True, 'short': 'sC', 'default': False, 'help': 'Enable default scanning'},
+		'zombie_host': {'type': str, 'short': 'sI', 'default': None, 'help': 'Use a zombie host for idle scan'},
+		'ftp_relay_host': {'type': str, 'short': 'sB', 'default': None, 'help': 'FTP bounce scan relay host'},
+
+		# Firewall / IDS evasion and spoofing
+		'spoof_source_port': {'type': int, 'short': 'g', 'default': None, 'help': 'Send packets from a specific port'},
+		'spoof_source_ip': {'type': str, 'short': 'S', 'default': None, 'help': 'Spoof source IP address'},
+		'spoof_source_mac': {'type': str, 'short': 'spoofmac', 'default': None, 'help': 'Spoof MAC address'},
+		'fragment': {'is_flag': True, 'short': 'fragment', 'default': False, 'help': 'Fragment packets'},
+		'mtu': {'type': int, 'short': 'mtu', 'default': None, 'help': 'Fragment packets with given MTU'},
+		'ttl': {'type': int, 'short': 'ttl', 'default': None, 'help': 'Set TTL'},
+		'badsum': {'is_flag': True, 'short': 'badsum', 'default': False, 'help': 'Create a bad checksum in the TCP header'},
+		'ipv6': {'is_flag': True, 'short': 'ipv6', 'default': False, 'help': 'Enable IPv6 scanning'},
+
+		# Host discovery
+		'traceroute': {'is_flag': True, 'short': 'traceroute', 'default': False, 'help': 'Traceroute'},
+		'disable_arp_ping': {'is_flag': True, 'short': 'disable-arp-ping', 'default': False, 'help': 'Disable ARP ping'},
+
+		# Misc
 		'output_path': {'type': str, 'short': 'oX', 'default': None, 'help': 'Output XML file path'},
 	}
 	opt_key_map = {
@@ -55,9 +96,34 @@ class nmap(VulnMulti):
 		PORTS: '-p',
 		'skip_host_discovery': '-Pn',
 		'version_detection': '-sV',
-		'tcp_connect': '-sT',
+		'detect_all': '-A',
+		'detect_os': '-O',
 		'tcp_syn_stealth': '-sS',
+		'tcp_connect': '-sT',
+		'tcp_window_scan': '-sW',
+		'tcp_maimon_scan': '-sM',
 		'udp_scan': '-sU',
+		'tcp_null_scan': '-sN',
+		'tcp_fin_scan': '-sF',
+		'tcp_xmas_scan': '-sX',
+		'tcp_ack_scan': '-sA',
+		'sctp_init_scan': '-sY',
+		'sctp_cookie_echo_scan': '-sZ',
+		'ping_scan': '-sn',
+		'ip_protocol_scan': '-sO',
+		'script_scan': '-sC',
+		'zombie_host': '-sI',
+		'ftp_relay_host': '-b',
+		'spoof_source_port': '-g',
+		'spoof_source_ip': '-S',
+		'spoof_source_mac': '--spoof-mac',
+		'fragmentation': '-f',
+		'mtu': '--mtu',
+		'ttl': '--ttl',
+		'badsum': '--badsum',
+		'ipv6': '-6',
+		'traceroute': '--traceroute',
+		'disable_arp_ping': '--disable-arp-ping',
 		'output_path': '-oX',
 	}
 	opt_value_map = {

{secator-0.10.1a7 → secator-0.10.1a8}/secator/tasks/wpscan.py

@@ -16,7 +16,7 @@ from secator.tasks._categories import VulnHttp
 @task()
 class wpscan(VulnHttp):
 	"""Wordpress security scanner."""
-	cmd = 'wpscan --random-user-agent --force --verbose'
+	cmd = 'wpscan --random-user-agent --force --verbose --disable-tls-checks --ignore-main-redirect'
 	file_flag = None
 	input_flag = '--url'
 	input_type = URL

{secator-0.10.1a7 → secator-0.10.1a8}/tests/integration/test_celery.py

@@ -150,12 +150,15 @@ class TestCelery(unittest.TestCase):
 			return
 
 		size = CONFIG.runners.input_chunk_size + 1
-		targets = [URL_TARGETS[0]] * size
+		import uuid
+		targets = []
+		for _ in range(size):
+			targets.append(URL_TARGETS[0] + '?id=' + str(uuid.uuid4()))
 		result = httpx.delay(targets)
 		results = result.get()
 		urls = [r.url for r in results if r._type == 'url']
 		infos = [r.message for r in results if r._type == 'info']
-		self.assertEqual(len(urls), 2)  # same URL, but twice because 2 chunks and same input
+		self.assertEqual(len(urls), size)  # same URL, but twice because 2 chunks and same input
 		# self.assertEqual(len(infos), 2) # one chunk message for each chunk
 		# for message in infos:
 			# self.assertIn('Celery chunked task created', message)