secator 0.18.0__tar.gz → 0.19.0__tar.gz

{secator-0.18.0 → secator-0.19.0}/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.19.0](https://github.com/freelabz/secator/compare/v0.18.0...v0.19.0) (2025-10-23)
+
+
+### Features
+
+* add monitor thread ([#727](https://github.com/freelabz/secator/issues/727)) ([5377e77](https://github.com/freelabz/secator/commit/5377e77186c88b1331b7ddc4a5304a610ad3e253))
+
 ## [0.18.0](https://github.com/freelabz/secator/compare/v0.17.0...v0.18.0) (2025-10-22)
 
 

{secator-0.18.0 → secator-0.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: secator
-Version: 0.18.0
+Version: 0.19.0
 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.18.0 → secator-0.19.0}/pyproject.toml

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

{secator-0.18.0 → secator-0.19.0}/secator/config.py

@@ -67,6 +67,8 @@ class Celery(StrictModel):
 	task_acks_late: bool = False
 	task_send_sent_event: bool = False
 	task_reject_on_worker_lost: bool = False
+	task_max_timeout: int = -1
+	task_memory_limit_mb: int = -1
 	worker_max_tasks_per_child: int = 20
 	worker_prefetch_multiplier: int = 1
 	worker_send_task_events: bool = False
@@ -100,7 +102,6 @@ class Security(StrictModel):
 	allow_local_file_access: bool = True
 	auto_install_commands: bool = True
 	force_source_install: bool = False
-	memory_limit_mb: int = -1
 
 
 class HTTP(StrictModel):

{secator-0.18.0 → secator-0.19.0}/secator/installer.py

@@ -150,7 +150,7 @@ class PackageInstaller:
 
 		# Installer cmd
 		cmd = distribution.pm_installer
-		if CONFIG.security.autoinstall_commands and IN_CELERY_WORKER_PROCESS:
+		if CONFIG.security.auto_install_commands and IN_CELERY_WORKER_PROCESS:
 			cmd = f'flock /tmp/install.lock {cmd}'
 		if getpass.getuser() != 'root':
 			cmd = f'sudo {cmd}'

{secator-0.18.0 → secator-0.19.0}/secator/output_types/stat.py

@@ -11,6 +11,7 @@ class Stat(OutputType):
 	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)
@@ -26,11 +27,15 @@ class Stat(OutputType):
 	_sort_by = ('name', 'pid')
 
 	def __str__(self) -> str:
-		return f'{self.name} [pid={self.pid}] [cpu={self.cpu:.2f}%] [memory={self.memory:.2f}%]'
+		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} \[pid={self.pid}] \[cpu={self.cpu:.2f}%] \[memory={self.memory:.2f}%]'
+		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' \[connections={self.net_conns}]'
+			s += rf' ([bold]connections[/]:{self.net_conns})'
 		s += ' [/]'
 		return rich_to_ansi(s)

{secator-0.18.0 → secator-0.19.0}/secator/runners/_base.py

@@ -788,8 +788,6 @@ class Runner:
 					continue
 				result = hook(self, *args)
 				self.debug('hook success', obj={'name': hook_type, 'fun': fun}, sub=sub, verbose='item' in sub)  # noqa: E501
-				if isinstance(result, Error):
-					self.add_result(result, hooks=False)
 			except Exception as e:
 				self.debug('hook failed', obj={'name': hook_type, 'fun': fun}, sub=sub)  # noqa: E501
 				error = Error.from_exception(e, message=f'Hook "{fun}" execution failed')

{secator-0.18.0 → secator-0.19.0}/secator/runners/command.py

@@ -2,11 +2,13 @@ import copy
 import getpass
 import logging
 import os
+import queue
 import re
 import shlex
 import signal
 import subprocess
 import sys
+import threading
 
 from time import time
 
@@ -178,6 +180,13 @@ class Command(Runner):
 		# Process
 		self.process = None
 
+		# Monitor thread (lazy initialization)
+		self.monitor_thread = None
+		self.monitor_stop_event = None
+		self.monitor_queue = None
+		self.process_start_time = None
+		# self.retry_count = 0  # TODO: remove this
+
 		# Sudo
 		self.requires_sudo = False
 
@@ -205,6 +214,13 @@ class Command(Runner):
 			item_loaders.append(instance_func)
 		self.item_loaders = item_loaders
 
+	def _init_monitor_objects(self):
+		"""Initialize monitor thread objects when needed (lazy initialization)."""
+		if self.monitor_stop_event is None:
+			self.monitor_stop_event = threading.Event()
+		if self.monitor_queue is None:
+			self.monitor_queue = queue.Queue()
+
 	def toDict(self):
 		res = super().toDict()
 		res.update({
@@ -443,7 +459,7 @@ class Command(Runner):
 			# Output and results
 			self.return_code = 0
 			self.killed = False
-			self.memory_limit_mb = CONFIG.security.memory_limit_mb
+			self.memory_limit_mb = CONFIG.celery.task_memory_limit_mb
 
 			# Run the command using subprocess
 			env = os.environ
@@ -458,6 +474,13 @@ class Command(Runner):
 				env=env,
 				cwd=self.cwd)
 
+			# Initialize monitor objects and start monitor thread
+			self._init_monitor_objects()
+			self.process_start_time = time()
+			self.monitor_stop_event.clear()
+			self.monitor_thread = threading.Thread(target=self._monitor_process, daemon=True)
+			self.monitor_thread.start()
+
 			# If sudo password is provided, send it to stdin
 			if sudo_password:
 				self.process.stdin.write(f"{sudo_password}\n")
@@ -469,6 +492,7 @@ class Command(Runner):
 				if not line:
 					break
 				yield from self.process_line(line)
+				yield from self.process_monitor_queue()
 
 			# Run hooks after cmd has completed successfully
 			result = self.run_hooks('on_cmd_done', sub='end')
@@ -478,11 +502,6 @@ class Command(Runner):
 		except FileNotFoundError as e:
 			yield from self.handle_file_not_found(e)
 
-		except MemoryError as e:
-			self.debug(f'{self.unique_name}: {type(e).__name__}.', sub='end')
-			self.stop_process(exit_ok=True, sig=signal.SIGTERM)
-			yield Warning(message=f'Memory limit {self.memory_limit_mb}MB reached for {self.unique_name}')
-
 		except BaseException as e:
 			self.debug(f'{self.unique_name}: {type(e).__name__}.', sub='end')
 			self.stop_process()
@@ -532,13 +551,16 @@ class Command(Runner):
 		if self.no_process:
 			return
 
-		# Yield command stats (CPU, memory, conns ...)
-		# TODO: enable stats support with timer
-		if self.last_updated_stat and (time() - self.last_updated_stat) < CONFIG.runners.stat_update_frequency:
+	def process_monitor_queue(self):
+		"""Process and yield any queued items from monitor thread."""
+		if self.monitor_queue is None:
 			return
-
-		yield from self.stats(self.memory_limit_mb)
-		self.last_updated_stat = time()
+		while not self.monitor_queue.empty():
+			try:
+				monitor_item = self.monitor_queue.get_nowait()
+				yield monitor_item
+			except queue.Empty:
+				break
 
 	def print_description(self):
 		"""Print description"""
@@ -585,6 +607,100 @@ class Command(Runner):
 		if exit_ok:
 			self.exit_ok = True
 
+	def _stop_monitor_thread(self):
+		"""Stop monitor thread."""
+		if self.monitor_thread and self.monitor_thread.is_alive() and self.monitor_stop_event:
+			self.monitor_stop_event.set()
+			self.monitor_thread.join(timeout=2.0)
+
+	def _monitor_process(self):
+		"""Monitor thread that checks process health and kills if necessary."""
+		last_stats_time = 0
+
+		while not self.monitor_stop_event.is_set():
+			if not self.process or not self.process.pid:
+				break
+
+			try:
+				current_time = time()
+				self.debug('Collecting monitor items', sub='monitor')
+
+				# Collect and queue stats at regular intervals
+				if (current_time - last_stats_time) >= CONFIG.runners.stat_update_frequency:
+					stats_items = list(self._collect_stats())
+					for stat_item in stats_items:
+						if self.monitor_queue is not None:
+							self.monitor_queue.put(stat_item)
+					last_stats_time = current_time
+
+					# Check memory usage from collected stats
+					if self.memory_limit_mb and self.memory_limit_mb != -1:
+						total_mem = sum(stat_item.extra_data.get('memory_info', {}).get('rss', 0) / 1024 / 1024 for stat_item in stats_items)  # noqa: E501
+						if total_mem > self.memory_limit_mb:
+							warning = Warning(message=f'Memory limit {self.memory_limit_mb}MB exceeded (actual: {total_mem:.2f}MB)')
+							if self.monitor_queue is not None:
+								self.monitor_queue.put(warning)
+							self.stop_process(exit_ok=True, sig=signal.SIGTERM)
+							break
+
+				# Check execution time
+				if self.process_start_time and CONFIG.celery.task_max_timeout != -1:
+					elapsed_time = current_time - self.process_start_time
+					if elapsed_time > CONFIG.celery.task_max_timeout:
+						warning = Warning(message=f'Task timeout {CONFIG.celery.task_max_timeout}s exceeded')
+						if self.monitor_queue is not None:
+							self.monitor_queue.put(warning)
+						self.stop_process(exit_ok=True, sig=signal.SIGTERM)
+						break
+
+				# Check retry count
+				# TODO: remove this
+				# if CONFIG.celery.task_max_retries and self.retry_count >= CONFIG.celery.task_max_retries:
+				# 	warning = Warning(message=f'Max retries {CONFIG.celery.task_max_retries} exceeded (actual: {self.retry_count})')
+				# 	self.monitor_queue.put(warning)
+				# 	self.stop_process(exit_ok=False, sig=signal.SIGTERM)
+				# 	break
+
+			except Exception as e:
+				self.debug(f'Monitor thread error: {e}', sub='monitor')
+				warning = Warning(message=f'Monitor thread error: {e}')
+				if self.monitor_queue is not None:
+					self.monitor_queue.put(warning)
+				break
+
+			# Sleep for a short interval before next check (stat update frequency)
+			self.monitor_stop_event.wait(CONFIG.runners.stat_update_frequency)
+
+	def _collect_stats(self):
+		"""Collect stats about the current running process, if any."""
+		if not self.process or not self.process.pid:
+			return
+		proc = psutil.Process(self.process.pid)
+		stats = Command.get_process_info(proc, children=True)
+		total_mem = 0
+		for info in stats:
+			name = info['name']
+			pid = info['pid']
+			cpu_percent = info['cpu_percent']
+			# mem_percent = info['memory_percent']
+			mem_rss = round(info['memory_info']['rss'] / 1024 / 1024, 2)
+			total_mem += mem_rss
+			self.debug(f'{name} {pid} {mem_rss}MB', sub='monitor')
+			net_conns = info.get('net_connections') or []
+			extra_data = {k: v for k, v in info.items() if k not in ['cpu_percent', 'memory_percent', 'net_connections']}
+			yield Stat(
+				name=name,
+				pid=pid,
+				cpu=cpu_percent,
+				memory=mem_rss,
+				memory_limit=self.memory_limit_mb,
+				net_conns=len(net_conns),
+				extra_data=extra_data
+			)
+		# self.debug(f'Total mem: {total_mem}MB, memory limit: {self.memory_limit_mb}', sub='monitor')
+		# if self.memory_limit_mb and self.memory_limit_mb != -1 and total_mem > self.memory_limit_mb:
+		# 	raise MemoryError(f'Memory limit {self.memory_limit_mb}MB reached for {self.unique_name}')
+
 	def stats(self, memory_limit_mb=None):
 		"""Gather stats about the current running process, if any."""
 		if not self.process or not self.process.pid:
@@ -599,7 +715,7 @@ class Command(Runner):
 			mem_percent = info['memory_percent']
 			mem_rss = round(info['memory_info']['rss'] / 1024 / 1024, 2)
 			total_mem += mem_rss
-			self.debug(f'{name} {pid} {mem_rss}MB', sub='stats')
+			self.debug(f'process: {name} pid: {pid} memory: {mem_rss}MB', sub='stats')
 			net_conns = info.get('net_connections') or []
 			extra_data = {k: v for k, v in info.items() if k not in ['cpu_percent', 'memory_percent', 'net_connections']}
 			yield Stat(
@@ -701,6 +817,8 @@ class Command(Runner):
 
 	def _wait_for_end(self):
 		"""Wait for process to finish and process output and return code."""
+		self._stop_monitor_thread()
+		yield from self.process_monitor_queue()
 		if not self.process:
 			return
 		for line in self.process.stdout.readlines():