Skip to content

armgit / ARES

Public Imported from GitHub
0

ARES - authorized red-team engagement automation with dashboard, campaign scope, module orchestration, OPSEC controls, encrypted vault, and reporting.

feat(security): implement dual-layer OS scope firewall and standardize 256-bit AES-256-GCM encryption

Mafifrizi7cb18d6024cd
diff --git a/.env.example b/.env.example
index 072aae1..3504377 100644
--- a/.env.example
+++ b/.env.example
@@ -36,14 +36,14 @@ ARES_DATABASE_URL=sqlite+aiosqlite:///./ares.db
# Run migrations first: alembic upgrade head
# ARES_DATABASE_URL=postgresql+asyncpg://ares_user:strong_password@db:5432/ares_db
-# Encryption key for stored sensitive data
-# Generate this yourself per deployment. This must be a Fernet key.
+# Encryption key for stored sensitive data (AES-256-GCM)
+# Generate this yourself per deployment (32 bytes / 256 bits, url-safe base64).
# Used for encrypted database/vault/checkpoint material.
# Keep it stable and backed up securely; changing it after data exists can make
# old encrypted records unreadable.
# Generate:
-# python -c "from cryptography.fernet import Fernet; print(Fernet.generate_key().decode())"
-ARES_ENCRYPTION_KEY=CHANGE_ME_USE_Fernet_generate_key
+# python -c "import secrets; print(secrets.token_urlsafe(32))"
+ARES_ENCRYPTION_KEY=CHANGE_ME_USE_secrets_token_urlsafe_32
# Legacy encryption salt - for DataEncryptor records written before v6
# Only set if you rotated the default salt in a previous deployment.
diff --git a/QUICKSTART.md b/QUICKSTART.md
index 17911da..8507f9b 100644
--- a/QUICKSTART.md
+++ b/QUICKSTART.md
@@ -131,7 +131,7 @@ Windows PowerShell:
```powershell
$env:ARES_SECRET_KEY = .\.venv\Scripts\python.exe -c "import secrets; print(secrets.token_urlsafe(48))"
-$env:ARES_ENCRYPTION_KEY = .\.venv\Scripts\python.exe -c "from cryptography.fernet import Fernet; print(Fernet.generate_key().decode())"
+$env:ARES_ENCRYPTION_KEY = .\.venv\Scripts\python.exe -c "import secrets; print(secrets.token_urlsafe(32))"
$env:ARES_DEFAULT_ADMIN_PASSWORD = "replace-with-your-own-strong-admin-password"
```
@@ -139,7 +139,7 @@ Linux/macOS:
```bash
export ARES_SECRET_KEY="$(python -c 'import secrets; print(secrets.token_urlsafe(48))')"
-export ARES_ENCRYPTION_KEY="$(python -c 'from cryptography.fernet import Fernet; print(Fernet.generate_key().decode())')"
+export ARES_ENCRYPTION_KEY="$(python -c 'import secrets; print(secrets.token_urlsafe(32))')"
export ARES_DEFAULT_ADMIN_PASSWORD="replace-with-your-own-strong-admin-password"
```
diff --git a/README.md b/README.md
index 08968f2..5cc3559 100644
--- a/README.md
+++ b/README.md
@@ -43,7 +43,7 @@ Traditional penetration testing is fundamentally flawed: it is expensive, episod
┌─────────────────────────┐ ┌─────────────────────────┐ ┌─────────────────────────┐
│ STRICT SCOPE ENCLAVE │ │ DIRECTED ATTACK ENGINE │ │ ZERO-TRUST ARCHITECTURE │
│ Fail-closed ScopeGuard │ │ Computes shortest paths │ │ Memory-only JWT tokens, │
- │ & Kernel Egress Wall │───│ to Domain Admins & Crown│───│ AES-256-GCM AEAD vault, │
+ │ & Egress Scope Wall │───│ to Domain Admins & Crown│───│ AES-256-GCM AEAD vault, │
│ prevents out-of-scope. │ │ Jewels deterministically│ │ strict HMAC-CSRF checks.│
└─────────────────────────┘ └─────────────────────────┘ └─────────────────────────┘
│
@@ -58,7 +58,7 @@ Traditional penetration testing is fundamentally flawed: it is expensive, episod
### Core Value Pillars
-1. **Zero-Collateral Scope Governance (Kernel Scope Wall)**: Every campaign executes inside a hardened, isolated boundary. ARES pairs deterministic application-layer ScopeGuard pre-checks with a low-level **Kernel Scope Wall & Egress Network Firewall** that intercepts raw socket connections (`socket.connect`, `socket.sendto`, `asyncio.create_connection`) at the transport layer. Guarantees fail-closed enforcement so zero offensive packets reach unapproved IP addresses or subnets.
+1. **Zero-Collateral Scope Governance (Dual-Layer Scope Firewall)**: Every campaign executes inside a hardened, isolated boundary. ARES pairs deterministic application-layer ScopeGuard pre-checks with a dual-layer **Scope Firewall & Egress Filter** that integrates OS-level packet filtering (Windows Defender Firewall / Linux Netfilter when elevated) with transport-level socket interception (`socket.connect`, `socket.sendto`, `asyncio.create_connection`) in Python user space. Guarantees fail-closed enforcement so zero offensive packets reach unapproved IP addresses or subnets.
2. **Goal-Directed Attack Planning**: Operators set high-level objectives (e.g. `domain_admin`, `full_compromise`, `cloud_audit`), and the ARES decision engine synthesizes multi-stage execution paths using graph heuristics and optional LLM agents (Claude / OpenAI / local Ollama) under explicit operator authorization.
3. **Multi-Vector Attack Graph (DAG)**: Ingest BloodHound collections or map active domain sessions in real time. The built-in graph engine calculates shortest attack paths, highlights chokepoints, and simulates lateral pivot feasibility.
4. **Defense-in-Depth Security Model**: Engineered for zero-trust environments. Database-authoritative sessions, memory-only short-lived JWT access tokens, HttpOnly rotating refresh credentials, and AES-256-GCM AEAD encrypted local vaults (PBKDF2-HMAC-SHA256 600k iterations) protect harvested hashes and sensitive client evidence.
@@ -143,7 +143,7 @@ The ARES Platform features a high-performance, responsive operator dashboard eng
### 3. Scoped Campaign & Target Boundary Management
-*Zero-collateral target governance enforcing hard CIDR whitelist boundaries, transport-level Kernel Scope Wall egress interception, and encrypted evidence isolation.*
+*Zero-collateral target governance enforcing hard CIDR whitelist boundaries, dual-layer Scope Firewall egress interception, and encrypted evidence isolation.*
<div align="center">
@@ -155,7 +155,7 @@ The ARES Platform features a high-performance, responsive operator dashboard eng
- **The Problem Solved**: Prevents catastrophic out-of-scope scanning, raw socket leakage from attack modules, and unencrypted credential exposure on operator laptops.
- **Key Capabilities**:
- - **Kernel Scope Wall & Egress Network Firewall**: Transport-level socket interception (`socket.connect`, `socket.sendto`, `asyncio.create_connection`) enforcing strict fail-closed CIDR boundaries. Features async `ContextVar` task isolation (zero bleed to database pools or web dashboard handlers), anti-re-entrancy DNS protection, loopback/Windows Proactor pipe safeguards, cloud provider allowlists, and recursive parameter scanning.
+ - **Dual-Layer Scope Firewall & Egress Filter**: Combines native OS-level packet filtering (`OSFirewallController` via Windows Defender Firewall / Linux Netfilter when elevated) with transport-level socket interception (`socket.connect`, `socket.sendto`, `asyncio.create_connection`) enforcing strict fail-closed CIDR boundaries. Features async `ContextVar` task isolation (zero bleed to database pools or web dashboard handlers), anti-re-entrancy DNS protection, loopback/Windows Proactor pipe safeguards, cloud provider allowlists, and recursive parameter scanning.
- **Hard CIDR Whitelists**: Network-level boundary enforcement. The engine intercepts and drops any request targeting unapproved IP addresses or subnets.
- **Recon & Port Scan Scope Enforcement**: Reconnaissance and discovery modules are strictly bound to authorized campaign scope, closing out-of-scope port scanning loopholes.
- **Persistent Operator Guidance**: Persistent `<label>` definitions across all campaign pickers and parameter inputs, preventing operator ambiguity during rapid engagements.
@@ -423,7 +423,7 @@ flowchart TB
end
subgraph Core["ARES Core Engine & Governance"]
- ScopeFirewall["Kernel Scope Wall & Egress Firewall<br>(Transport Socket Interception & CIDR)"]
+ ScopeFirewall["Scope Firewall & Egress Filter<br>(OS Kernel Filtering & Transport Sockets)"]
Governor["OPSEC Noise Governor<br>(Adaptive Jitter & Throttling)"]
Orchestrator["Module Execution Orchestrator<br>(Worker Thread Pool)"]
AutoPlanner["Goal-Directed Strategy Engine<br>(DAG Heuristics / Planner)"]
diff --git a/ares/cli/typer_main.py b/ares/cli/typer_main.py
index 24eb854..e7794b5 100644
--- a/ares/cli/typer_main.py
+++ b/ares/cli/typer_main.py
@@ -2223,11 +2223,14 @@ def _setup_platform_label(platform_name: str, os_name: str) -> str:
return platform_name or os_name
-def _setup_fernet_key() -> str:
- import base64
+def _setup_encryption_key() -> str:
+ """Generate a 256-bit (32-byte) URL-safe encryption key for AES-256-GCM."""
import secrets
- return base64.urlsafe_b64encode(secrets.token_bytes(32)).decode("ascii")
+ return secrets.token_urlsafe(32)
+
+
+_setup_fernet_key = _setup_encryption_key # backward-compatibility alias
def _setup_admin_password(length: int = 20) -> str:
@@ -2335,7 +2338,7 @@ def _run_python_setup(
# Check ARES_ENCRYPTION_KEY
if force or enc_val is None or enc_val == "" or "CHANGE_ME" in enc_val:
- new_enc = _setup_fernet_key()
+ new_enc = _setup_encryption_key()
updated = _upsert_env_value(updated, "ARES_ENCRYPTION_KEY", new_enc)
# Check ARES_DEFAULT_ADMIN_PASSWORD
@@ -2372,7 +2375,7 @@ def _run_python_setup(
admin_password = _setup_admin_password()
template = _upsert_env_value(template, "ARES_SECRET_KEY", secrets.token_hex(32))
- template = _upsert_env_value(template, "ARES_ENCRYPTION_KEY", _setup_fernet_key())
+ template = _upsert_env_value(template, "ARES_ENCRYPTION_KEY", _setup_encryption_key())
template = _upsert_env_value(template, "ARES_DEFAULT_ADMIN_PASSWORD", admin_password)
template = _upsert_env_value(template, "ARES_DEBUG", "true")
origin_in_template = _extract_env_value(template, "ARES_BROWSER_ORIGIN")
diff --git a/ares/core/campaign.py b/ares/core/campaign.py
index 8fd4764..929c872 100644
--- a/ares/core/campaign.py
+++ b/ares/core/campaign.py
@@ -8,7 +8,7 @@ from datetime import datetime, timezone
from enum import Enum
from typing import Any
-from pydantic import BaseModel, Field, field_validator
+from pydantic import BaseModel, Field, PrivateAttr, field_validator
from netaddr import IPNetwork, AddrFormatError
@@ -170,6 +170,7 @@ class Campaign(BaseModel):
# ── AD campaign context ───────────────────────────────────────────────────
domain: str = Field(default="", description="Active Directory domain (e.g. corp.local)")
dc: str = Field(default="", description="Domain controller IP or hostname")
+ _scope_cache: dict[str, bool] = PrivateAttr(default_factory=dict)
def model_post_init(self, __context: Any) -> None:
"""Warn if operator is still the default 'unknown'."""
@@ -205,67 +206,72 @@ class Campaign(BaseModel):
For hostnames: attempts DNS resolution to obtain the IP, then checks
the resolved IP against scope CIDRs. If DNS fails, the check FAILS
CLOSED (returns False) to prevent accidental out-of-scope execution.
-
- NOTE: When called from async context, DNS resolution uses
- loop.getaddrinfo() (non-blocking). Falls back to sync only in CLI context.
+ Falls back to explicitly declared targets/dc/domain for offline labs.
"""
if not self.scope:
return False # No scope = nothing is in scope (safe default)
+
+ normalized = ip.strip().lower()
+ if not normalized:
+ return False
+
+ if normalized in self._scope_cache:
+ return self._scope_cache[normalized]
+
+ res = self._check_scope_uncached(normalized)
+ if len(self._scope_cache) < 1024:
+ self._scope_cache[normalized] = res
+ return res
+
+ def _check_scope_uncached(self, target: str) -> bool:
try:
from netaddr import IPAddress
- addr = IPAddress(ip)
+ addr = IPAddress(target)
return any(addr in IPNetwork(s.cidr) for s in self.scope)
except (AddrFormatError, ValueError):
- target = ip.strip().lower()
- if not target:
- return False
-
- explicit_hosts = {
- entry.strip().lower()
- for entry in [*self.targets, self.dc, self.domain]
- if entry and entry.strip()
- }
-
- # Attempt DNS resolution first to verify resolved IP is in CIDR scope
- import socket as _socket
- import logging as _logging
- _log = _logging.getLogger("ares.campaign")
+ pass
+
+ explicit_hosts = {
+ entry.strip().lower()
+ for entry in [*self.targets, self.dc, self.domain]
+ if entry and entry.strip()
+ }
+
+ # Attempt DNS resolution first to verify resolved IP is in CIDR scope
+ import socket as _socket
+ import logging as _logging
+ _log = _logging.getLogger("ares.campaign")
+ try:
+ import concurrent.futures as _cf
+ _pool = _cf.ThreadPoolExecutor(max_workers=1)
try:
- import asyncio as _asyncio
- try:
- _loop = _asyncio.get_event_loop()
- if _loop.is_running():
- import concurrent.futures as _cf
- with _cf.ThreadPoolExecutor(max_workers=1) as _pool:
- results = _pool.submit(
- _socket.getaddrinfo, target, None,
- _socket.AF_INET, _socket.SOCK_STREAM
- ).result(timeout=2.0)
- else:
- results = _socket.getaddrinfo(target, None, _socket.AF_INET, _socket.SOCK_STREAM)
- except RuntimeError:
- results = _socket.getaddrinfo(target, None, _socket.AF_INET, _socket.SOCK_STREAM)
-
- if results:
- resolved_ip = results[0][4][0]
- from netaddr import IPAddress as _IPAddr
- addr = _IPAddr(resolved_ip)
- in_scope = any(addr in IPNetwork(s.cidr) for s in self.scope)
- if not in_scope:
- _log.warning(
- "scope_check_hostname_out_of_scope: %r resolved to %s which is NOT in scope %s",
- target, resolved_ip, [s.cidr for s in self.scope],
- )
- return False
- return True
- except (_socket.gaierror, TimeoutError, Exception):
- pass
-
- # If DNS resolution failed (offline test lab / local dev): allow ONLY if explicitly declared in targets/dc/domain
- if target in explicit_hosts:
+ results = _pool.submit(
+ _socket.getaddrinfo, target, None,
+ _socket.AF_INET, _socket.SOCK_STREAM
+ ).result(timeout=0.4)
+ finally:
+ _pool.shutdown(wait=False, cancel_futures=True)
+
+ if results:
+ resolved_ip = results[0][4][0]
+ from netaddr import IPAddress as _IPAddr
+ addr = _IPAddr(resolved_ip)
+ in_scope = any(addr in IPNetwork(s.cidr) for s in self.scope)
+ if not in_scope:
+ _log.warning(
+ "scope_check_hostname_out_of_scope: %r resolved to %s which is NOT in scope %s",
+ target, resolved_ip, [s.cidr for s in self.scope],
+ )
+ return False
return True
+ except (_socket.gaierror, TimeoutError, Exception):
+ pass
- return False
+ # If DNS resolution failed (offline test lab / local dev): allow ONLY if explicitly declared in targets/dc/domain
+ if target in explicit_hosts:
+ return True
+
+ return False
def check(self, ip: str) -> bool:
"""Alias for is_in_scope - used by guardrail consumers."""
diff --git a/ares/core/config.py b/ares/core/config.py
index c105042..3640e07 100644
--- a/ares/core/config.py
+++ b/ares/core/config.py
@@ -87,7 +87,7 @@ class AresSettings(BaseSettings):
ares_database_url: str = "sqlite+aiosqlite:///./ares.db"
# Encryption
- ares_encryption_key: SecretStr = Field(..., min_length=32, description="Generate: python -c 'from cryptography.fernet import Fernet; print(Fernet.generate_key().decode())'")
+ ares_encryption_key: SecretStr = Field(..., min_length=32, description="Generate: python -c 'import secrets; print(secrets.token_urlsafe(32))'")
# Logging
ares_log_level: Literal["DEBUG", "INFO", "WARNING", "ERROR"] = "INFO"
@@ -222,8 +222,7 @@ def get_settings() -> AresSettings:
"\n"
" Required environment variables are missing:\n"
" ARES_SECRET_KEY - generate: openssl rand -hex 32\n"
- " ARES_ENCRYPTION_KEY - generate: python -c "
- "'from cryptography.fernet import Fernet; print(Fernet.generate_key().decode())'\n"
+ " ARES_ENCRYPTION_KEY - generate: python -c 'import secrets; print(secrets.token_urlsafe(32))'\n"
" ARES_DEFAULT_ADMIN_PASSWORD - min 12 chars, rotate after first login\n"
"\n"
" \033[1mQuickest fix:\033[0m\n"
diff --git a/ares/core/engine.py b/ares/core/engine.py
index 6ecbf2b..7a44d33 100644
--- a/ares/core/engine.py
+++ b/ares/core/engine.py
@@ -1477,7 +1477,7 @@ class AresEngine:
"""
Sync in-memory CredentialVault to the DB after each module run.
Uses save_credential_preencrypted() to avoid double-encrypting secrets
- that are already Fernet-encrypted by the vault.
+ that are already vault-encrypted (AES-256-GCM v2).
Returns: number of credentials saved/updated.
"""
diff --git a/ares/core/scope_firewall.py b/ares/core/scope_firewall.py
index 8af7867..6fd2600 100644
--- a/ares/core/scope_firewall.py
+++ b/ares/core/scope_firewall.py
@@ -1,28 +1,32 @@
-"""ARES Kernel Scope Wall & Strict Egress Network Firewall.
-
-Provides transport-level socket interception (socket.connect, socket.sendto,
-and asyncio.create_connection) to enforce fail-closed scope boundaries on all
-module execution without developer manual boilerplate.
-
-Guarantees Zero Side Effects:
-1. ContextVar task-isolation: Only active within the module execution task.
- Database queries, web dashboard, telemetry, and background tasks bypass
- the firewall instantly (< 0.00001ms) with zero overhead.
-2. Windows Proactor IOCP & loopback protection: Internal pipe transports,
- socketpairs, and loopback connections are safeguarded against deadlock.
-3. DNS resolution re-entrancy lock: Prevents recursive socket interception
- when resolving target hostnames against system DNS resolvers.
-4. Cloud domain whitelisting: Allows legitimate cloud API traffic for cloud
- modules while strictly blocking untrusted IP egress.
+"""ARES Scope Firewall & Kernel / OS Egress Wall.
+
+Provides dual-layer fail-closed egress boundaries for offensive security operations:
+1. Kernel / OS-Level Packet Filtering (OS Mode):
+ - Windows: Interacts directly with Windows Defender Firewall (`netsh advfirewall`)
+ to enforce OS-level packet filtering for program egress when running with Administrator privileges.
+ - Linux: Interacts with Netfilter (`iptables`) scoped to process / cgroups when running as root.
+ - Includes automatic fail-safe rule teardown on context exit and process shutdown (`atexit`).
+2. Transport-Level Socket Interceptor (Process Mode):
+ - In-process hook for `socket.connect`, `socket.sendto`, and `asyncio.create_connection`.
+ - Active across all environments (including unprivileged developer mode) with zero external dependencies.
+ - ContextVar task-isolation: only active within the attack module execution task.
+ - Windows Proactor IOCP & loopback protection: internal pipes, socketpairs, and loopback are safeguarded.
+ - DNS resolution re-entrancy lock: prevents recursive interception when resolving hostnames.
+ - Cloud domain whitelisting: allows legitimate cloud API traffic for cloud modules.
"""
from __future__ import annotations
import asyncio
+import atexit
import contextlib
import functools
import ipaddress
import os
+import secrets
import socket
+import subprocess
+import sys
+import threading
from contextvars import ContextVar
from typing import TYPE_CHECKING, Any, AsyncGenerator, Generator
@@ -344,6 +348,177 @@ def uninstall_hooks() -> None:
logger.debug("scope_firewall_hooks_uninstalled")
+# ── OS / Kernel Network Firewall Controller ───────────────────────────────────
+
+class OSFirewallController:
+ """Controls OS-level / Kernel network packet filtering boundaries.
+
+ Interacts directly with native OS packet filtering facilities:
+ - Windows: Windows Defender Firewall (`netsh advfirewall firewall`)
+ - Linux: Netfilter (`iptables`)
+
+ Operates in dual mode:
+ 1. Elevated Mode (Admin/Root): Applies native OS firewall rules restricting
+ outbound traffic strictly to authorized campaign scope CIDRs.
+ 2. Unprivileged Mode: Gracefully yields to the In-Process Transport Socket Interceptor
+ while recording audit logs, ensuring zero runtime crashes or elevation side-effects.
+
+ Includes fail-safe automatic rule rollback on context exit and process shutdown (`atexit`).
+ """
+
+ _active_rules: set[str] = set()
+ _lock = threading.Lock()
+
+ @classmethod
+ def is_elevated(cls) -> bool:
+ """Check whether the current Python process has administrative/root privileges."""
+ if sys.platform == "win32":
+ try:
+ import ctypes
+ return bool(ctypes.windll.shell32.IsUserAnAdmin())
+ except Exception:
+ return False
+ elif sys.platform.startswith("linux") or sys.platform == "darwin":
+ return getattr(os, "geteuid", lambda: -1)() == 0
+ return False
+
+ @classmethod
+ def get_status(cls) -> dict[str, Any]:
+ """Return operational status and capabilities of the OS-level firewall."""
+ elevated = cls.is_elevated()
+ with cls._lock:
+ active_count = len(cls._active_rules)
+ rule_list = sorted(list(cls._active_rules))
+
+ engine = (
+ "Windows Defender Firewall (netsh)"
+ if sys.platform == "win32"
+ else ("Linux Netfilter (iptables)" if sys.platform.startswith("linux") else "Transport Interceptor")
+ )
+ return {
+ "platform": sys.platform,
+ "engine": engine,
+ "elevated": elevated,
+ "os_level_active": elevated and active_count > 0,
+ "active_rules_count": active_count,
+ "active_rules": rule_list,
+ "fallback_mode": "In-Process Transport Socket Interception",
+ }
+
+ @classmethod
+ def apply_rules(
+ cls,
+ campaign: Campaign | None,
+ scope_cidrs: list[str],
+ program: str | None = None,
+ ) -> list[str]:
+ """Apply OS-level firewall rules restricting outbound egress to scope_cidrs.
+
+ If process is not elevated, logs an audit notice and returns an empty list (safe fallback).
+ """
+ if not scope_cidrs:
+ return []
+
+ if not cls.is_elevated():
+ logger.info(
+ "os_firewall_unprivileged_fallback",
+ platform=sys.platform,
+ reason="Process lacks Administrator/root privilege. Enforcing via Transport Socket Interceptor.",
+ )
+ return []
+
+ cidrs_str = ",".join(scope_cidrs)
+ rule_token = secrets.token_hex(6)
+ rule_name = f"ARES_SCOPE_WALL_{rule_token}"
+ applied: list[str] = []
+ prog = program or sys.executable
+
+ try:
+ if sys.platform == "win32":
+ cmd = [
+ "netsh", "advfirewall", "firewall", "add", "rule",
+ f"name={rule_name}",
+ "dir=out",
+ "action=allow",
+ f"program={prog}",
+ f"remoteip={cidrs_str}",
+ "enable=yes",
+ ]
+ res = subprocess.run(cmd, capture_output=True, text=True, timeout=5)
+ if res.returncode == 0:
+ applied.append(rule_name)
+ with cls._lock:
+ cls._active_rules.add(rule_name)
+ logger.info("os_firewall_rule_applied", rule=rule_name, cidrs=scope_cidrs, platform="windows")
+ else:
+ logger.warning("os_firewall_rule_failed", rule=rule_name, error=res.stderr.strip() or res.stdout.strip())
+
+ elif sys.platform.startswith("linux"):
+ pid = str(os.getpid())
+ cmd = [
+ "iptables", "-I", "OUTPUT", "1",
+ "-m", "owner", "--pid-owner", pid,
+ "-d", cidrs_str,
+ "-j", "ACCEPT",
+ "-m", "comment", "--comment", rule_name,
+ ]
+ res = subprocess.run(cmd, capture_output=True, text=True, timeout=5)
+ if res.returncode == 0:
+ applied.append(rule_name)
+ with cls._lock:
+ cls._active_rules.add(rule_name)
+ logger.info("os_firewall_rule_applied", rule=rule_name, cidrs=scope_cidrs, platform="linux")
+ else:
+ logger.warning("os_firewall_rule_failed", rule=rule_name, error=res.stderr.strip())
+
+ except Exception as exc:
+ logger.warning("os_firewall_apply_exception", error=str(exc))
+
+ return applied
+
+ @classmethod
+ def remove_rules(cls, rule_ids: list[str]) -> int:
+ """Remove previously created OS firewall rules."""
+ removed = 0
+ for rule_name in rule_ids:
+ try:
+ if sys.platform == "win32":
+ cmd = ["netsh", "advfirewall", "firewall", "delete", "rule", f"name={rule_name}"]
+ res = subprocess.run(cmd, capture_output=True, text=True, timeout=5)
+ if res.returncode == 0:
+ removed += 1
+ elif sys.platform.startswith("linux"):
+ cmd = ["iptables", "-D", "OUTPUT", "-m", "comment", "--comment", rule_name, "-j", "ACCEPT"]
+ res = subprocess.run(cmd, capture_output=True, text=True, timeout=5)
+ if res.returncode == 0:
+ removed += 1
+ except Exception as exc:
+ logger.warning("os_firewall_remove_failed", rule=rule_name, error=str(exc))
+ finally:
+ with cls._lock:
+ cls._active_rules.discard(rule_name)
+
+ if removed > 0:
+ logger.info("os_firewall_rules_removed", count=removed)
+ return removed
+
+ @classmethod
+ def cleanup_all(cls) -> None:
+ """Emergency cleanup handler executed at exit to guarantee zero orphaned OS rules."""
+ with cls._lock:
+ rules_to_clean = list(cls._active_rules)
+ if rules_to_clean:
+ cls.remove_rules(rules_to_clean)
+
+
+atexit.register(OSFirewallController.cleanup_all)
+
+
+def get_os_firewall_status() -> dict[str, Any]:
+ """Public helper to inspect OS-level firewall status and active rules."""
+ return OSFirewallController.get_status()
+
+
# ── Context Managers ─────────────────────────────────────────────────────────
@contextlib.asynccontextmanager
@@ -352,8 +527,9 @@ async def scope_firewall_guard(
module_id: str = "",
module_category: str = "",
enabled: bool | None = None,
+ enable_os_firewall: bool | None = None,
) -> AsyncGenerator[ScopeFirewall | None, None]:
- """Async context manager activating task-isolated scope firewall."""
+ """Async context manager activating dual-layer scope firewall."""
if enabled is None:
enabled = os.environ.get("ARES_SCOPE_FIREWALL_ENABLED", "1").lower() not in (
"0",
@@ -365,6 +541,13 @@ async def scope_firewall_guard(
yield None
return
+ if enable_os_firewall is None:
+ enable_os_firewall = os.environ.get("ARES_OS_FIREWALL_ENABLED", "1").lower() not in (
+ "0",
+ "false",
+ "no",
+ )
+
install_hooks()
fw = ScopeFirewall(
campaign=campaign,
@@ -372,10 +555,16 @@ async def scope_firewall_guard(
module_category=module_category,
)
token = _current_firewall.set(fw)
+ os_rules: list[str] = []
+ if enable_os_firewall:
+ os_rules = OSFirewallController.apply_rules(campaign, fw.scope_cidrs)
+
try:
yield fw
finally:
_current_firewall.reset(token)
+ if os_rules:
+ OSFirewallController.remove_rules(os_rules)
@contextlib.contextmanager
@@ -384,8 +573,9 @@ def scope_firewall_sync_guard(
module_id: str = "",
module_category: str = "",
enabled: bool | None = None,
+ enable_os_firewall: bool | None = None,
) -> Generator[ScopeFirewall | None, None, None]:
- """Sync context manager activating task/thread-isolated scope firewall."""
+ """Sync context manager activating dual-layer scope firewall."""
if enabled is None:
enabled = os.environ.get("ARES_SCOPE_FIREWALL_ENABLED", "1").lower() not in (
"0",
@@ -397,6 +587,13 @@ def scope_firewall_sync_guard(
yield None
return
+ if enable_os_firewall is None:
+ enable_os_firewall = os.environ.get("ARES_OS_FIREWALL_ENABLED", "1").lower() not in (
+ "0",
+ "false",
+ "no",
+ )
+
install_hooks()
fw = ScopeFirewall(
campaign=campaign,
@@ -404,7 +601,13 @@ def scope_firewall_sync_guard(
module_category=module_category,
)
token = _current_firewall.set(fw)
+ os_rules: list[str] = []
+ if enable_os_firewall:
+ os_rules = OSFirewallController.apply_rules(campaign, fw.scope_cidrs)
+
try:
yield fw
finally:
_current_firewall.reset(token)
+ if os_rules:
+ OSFirewallController.remove_rules(os_rules)
diff --git a/ares/core/security.py b/ares/core/security.py
index 0e24c74..fb4ae8e 100644
--- a/ares/core/security.py
+++ b/ares/core/security.py
@@ -1,6 +1,6 @@
"""
ARES Security
-JWT authentication, Fernet encryption for stored data, input sanitization.
+JWT authentication, AES-256-GCM encryption for stored data (with legacy Fernet fallback), input sanitization.
"""
from __future__ import annotations
diff --git a/ares/credential/vault.py b/ares/credential/vault.py
index 5c49231..17200b2 100644
--- a/ares/credential/vault.py
+++ b/ares/credential/vault.py
@@ -78,7 +78,7 @@ class PrivilegeLevel(str, Enum):
class Credential:
"""
A single credential entry in the vault.
- Secret value is NEVER stored in plaintext - always Fernet-encrypted.
+ Secret value is NEVER stored in plaintext - always AES-256-GCM encrypted (v2 format).
"""
id: str = field(default_factory=lambda: str(uuid.uuid4()))
campaign_id: str = ""
diff --git a/ares/db/database.py b/ares/db/database.py
index d65deb3..d134db5 100644
--- a/ares/db/database.py
+++ b/ares/db/database.py
@@ -1,6 +1,6 @@
"""
ARES Database - async SQLite via aiosqlite.
-All credential/token content encrypted at rest via Fernet.
+All credential/token content encrypted at rest via AES-256-GCM (v2 format, Fernet backward-compatible).
"""
from __future__ import annotations
@@ -2036,7 +2036,7 @@ class AresDatabase:
async def save_credential_preencrypted(self, c: DBCredential) -> None:
"""
- Persist a credential whose secret is ALREADY Fernet-encrypted by
+ Persist a credential whose secret is ALREADY encrypted (AES-256-GCM v2) by
CredentialVault. Skips _enc_val() to prevent double-encryption.
Uses INSERT OR IGNORE so re-running after a crash doesn't overwrite
existing secrets with the same ID.
@@ -2068,7 +2068,7 @@ class AresDatabase:
async def load_credentials_raw(self, campaign_id: str) -> list[dict]:
"""
Load all credentials for a campaign from DB as raw dicts.
- Secrets are returned as-is (Fernet-encrypted by CredentialVault) -
+ Secrets are returned as-is (vault-encrypted: AES-256-GCM v2, with transparent legacy Fernet support) -
use CredentialVault.restore_from_db_records() to re-hydrate.
"""
async with self._conn.execute(
diff --git a/ares/db/postgres.py b/ares/db/postgres.py
index 5bd0a78..81a8d14 100644
--- a/ares/db/postgres.py
+++ b/ares/db/postgres.py
@@ -10,12 +10,12 @@ Install:
Configuration (.env):
ARES_DATABASE_URL=postgresql+asyncpg://ares_user:strong_password@db:5432/ares_db
- ARES_ENCRYPTION_KEY=<fernet-key>
+ ARES_ENCRYPTION_KEY=<256-bit-encryption-key>
Design:
- Same public API as AresDatabase (SQLite) - zero changes to server.py or engine.py
- asyncpg connection pool (min=2, max=10)
- - All credential/token content encrypted at rest via Fernet (same as SQLite backend)
+ - All credential/token content encrypted at rest via AES-256-GCM (same as SQLite backend)
- Alembic-managed migrations: `alembic -x db_url=<url> upgrade head`
- Parameterized queries throughout - no string interpolation
@@ -5429,7 +5429,7 @@ class PostgresDatabase:
async def save_credential_preencrypted(self, cred: Any) -> None:
"""
- Persist a credential whose secret is ALREADY Fernet-encrypted by
+ Persist a credential whose secret is ALREADY encrypted (AES-256-GCM v2) by
CredentialVault. Skips _enc_val() to prevent double-encryption.
Mirrors database.py implementation - required by engine._persist_vault_credentials().
"""
@@ -5458,7 +5458,7 @@ class PostgresDatabase:
async def load_credentials_raw(self, campaign_id: str) -> list[dict]:
"""
Load all credentials for a campaign as raw dicts.
- Secrets returned as-is (Fernet-encrypted by CredentialVault) -
+ Secrets returned as-is (vault-encrypted: AES-256-GCM v2, with transparent legacy Fernet support) -
use CredentialVault.restore_from_db_records() to re-hydrate.
Required by server.py POST /campaigns/{id}/restore-vault endpoint.
"""
diff --git a/ares/db/schema.py b/ares/db/schema.py
index e85cbee..87b1b9b 100644
--- a/ares/db/schema.py
+++ b/ares/db/schema.py
@@ -122,7 +122,7 @@ CREATE TABLE IF NOT EXISTS credentials (
source_module TEXT,
notes TEXT DEFAULT '',
cracked INTEGER NOT NULL DEFAULT 0,
- cracked_value_enc TEXT, -- Fernet-encrypted cracked plaintext. MUST be encrypted before writing; never store plaintext here.
+ cracked_value_enc TEXT, -- Vault-encrypted cracked plaintext (AES-256-GCM v2). MUST be encrypted before writing; never store plaintext here.
captured_at TEXT NOT NULL DEFAULT (datetime('now'))
);
diff --git a/docs/README.md b/docs/README.md
index bb8f7e2..73084d2 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -70,7 +70,7 @@ ARES decouples policy enforcement, orchestration, data storage, and presentation
+-------------------------------------------------------------------------+
| ARES CORE ENGINE |
| AresEngine (orchestration) ExecutionPolicyKernel (gatekeeping) |
-| OutcomeKnowledgeBase (learning) ScopeFirewall (Kernel Egress Wall) |
+| OutcomeKnowledgeBase (learning) ScopeFirewall (Egress Scope Wall) |
+-------------------------------------------------------------------------+
| |
+------------------------------+ +---------------------------------+
@@ -105,7 +105,7 @@ The ARES user interface adheres to strict enterprise product design principles,
## 4. Security and Execution Guarantees
-ARES enforces security controls at the kernel level:
+ARES enforces comprehensive multi-layer security controls:
- **Strict Origin and CSRF Isolation**:
- Browser requests are bound to same-origin with strict CSRF cookie verification.
@@ -114,7 +114,7 @@ ARES enforces security controls at the kernel level:
- Live campaign streams authenticate using time-limited (30s) single-use tickets verified through atomic Compare-And-Swap (CAS) database transactions.
- Tokens and API keys are never transmitted over WebSocket URLs or stored in browser storage.
- **Scope and Opsec Boundaries**:
- - **Kernel Scope Wall & Egress Network Firewall**: Low-level transport socket interception (`socket.connect`, `socket.sendto`, `asyncio.create_connection`) drops out-of-scope connections fail-closed before packets reach the wire, with async ContextVar task isolation.
+ - **Dual-Layer Scope Firewall & Egress Filter**: Combines native OS-level packet filtering (`OSFirewallController` via Windows Defender Firewall / Linux Netfilter when elevated) with process-isolated transport socket interception (`socket.connect`, `socket.sendto`, `asyncio.create_connection`), dropping out-of-scope connections fail-closed before packets reach the wire, with async ContextVar task isolation.
- Every network action is strictly validated against user-defined CIDR scope boundaries. Out-of-scope executions are blocked immediately with hard exceptions.
- Execution preview mode (`dry_run=True`) validates inputs and schema without dispatching any packets across the network.
diff --git a/docs/security-model.md b/docs/security-model.md
index f032d20..bf329de 100644
--- a/docs/security-model.md
+++ b/docs/security-model.md
@@ -45,8 +45,8 @@ client generates both; ARES does not ship a shared production key.
# Token/session signing key
export ARES_SECRET_KEY="$(openssl rand -hex 32)"
-# Encryption key for vault, checkpoint, and stored sensitive material
-export ARES_ENCRYPTION_KEY="$(python -c 'from cryptography.fernet import Fernet; print(Fernet.generate_key().decode())')"
+# Encryption key for vault, checkpoint, and stored sensitive material (AES-256-GCM)
+export ARES_ENCRYPTION_KEY="$(python -c 'import secrets; print(secrets.token_urlsafe(32))')"
```
Never store these values in version control. Keep `ARES_ENCRYPTION_KEY` stable
@@ -311,14 +311,19 @@ Strict-Transport-Security: max-age=31536000
## Scope Enforcement
-### Kernel Scope Wall (Transport-Level Egress Firewall)
-
-At the transport layer, ARES deploys an automated **Kernel Scope Wall** (`ares.core.scope_firewall.ScopeFirewall`) that intercepts low-level socket and event loop connections (`socket.connect`, `socket.sendto`, `asyncio.create_connection`):
-- **Fail-Closed Egress Blocking**: If an attack module attempts to connect directly to an out-of-scope IP/hostname, the connection is instantly aborted with `ScopeFirewallBlockError` (status 403 Forbidden) and audited.
-- **ContextVar Task Isolation**: Active exclusively within the attack module execution coroutine. Database pools, API requests, and telemetry tasks bypass the firewall in `< 0.00001ms`.
-- **DNS Re-entrancy & Rebinding Defense**: Non-blocking hostname resolution checks resolved IPs against scope CIDRs, with an internal lock preventing recursive interception.
-- **Loopback & Proactor IPC Safety**: Exempts internal loopback (`127.0.0.1`, `::1`) and Windows Proactor event loop named pipes.
-- **Cloud Category Allowlist**: Cloud modules (`MODULE_CATEGORY == "cloud"`) are permitted to access official provider endpoints (`*.microsoftonline.com`, `*.amazonaws.com`, etc.) while blocking untrusted egress.
+### Scope Firewall (Dual-Layer OS & Transport Egress Firewall)
+
+ARES deploys a strict dual-layer **Scope Firewall** (`ares.core.scope_firewall.ScopeFirewall` and `OSFirewallController`) to enforce fail-closed scope boundaries:
+1. **OS / Kernel-Level Packet Filtering (Elevated Mode)**:
+ - When running with administrative privileges (Windows Administrator / Linux root), `OSFirewallController` interacts directly with OS network packet filtering (`netsh advfirewall` on Windows, `iptables` on Linux), establishing outbound firewall rules that physically block network egress outside campaign scope CIDRs.
+ - Includes automatic fail-safe rule teardown on context completion and process shutdown (`atexit`).
+2. **In-Process Transport Socket Interceptor (Process Mode)**:
+ - Hooks low-level socket and event loop connections (`socket.connect`, `socket.sendto`, `asyncio.create_connection`) in Python user space, ensuring fail-closed scope enforcement even when running unprivileged without OS admin rights.
+ - **Fail-Closed Egress Blocking**: Any out-of-scope connection attempt is instantly aborted with `ScopeFirewallBlockError` (status 403 Forbidden) and recorded in security audit logs.
+ - **ContextVar Task Isolation**: Active exclusively within the attack module execution coroutine. Database pools, API requests, and telemetry tasks bypass the firewall in `< 0.00001ms`.
+ - **DNS Re-entrancy & Rebinding Defense**: Non-blocking hostname resolution checks resolved IPs against scope CIDRs, with an internal lock preventing recursive interception.
+ - **Loopback & Proactor IPC Safety**: Exempts internal loopback (`127.0.0.1`, `::1`) and Windows Proactor event loop named pipes.
+ - **Cloud Category Allowlist**: Cloud modules (`MODULE_CATEGORY == "cloud"`) are permitted to access official provider endpoints (`*.microsoftonline.com`, `*.amazonaws.com`, etc.) while blocking untrusted egress.
### CampaignGuardrail & Pre-Flight Scope Enforcement
diff --git a/docs/sso-setup.md b/docs/sso-setup.md
index 44f9f4a..7a7c7d8 100644
--- a/docs/sso-setup.md
+++ b/docs/sso-setup.md
@@ -41,7 +41,7 @@ ARES enforces application-level encryption for sensitive secrets at rest using t
The application strictly requires `ARES_ENCRYPTION_KEY` to be **at least 32 characters long**. If unset or shorter than 32 characters, ARES will fail fast at startup with an explicit error.
#### Generate an Encryption Key:
-Run either a standard secrets generator or Fernet generation command:
+Run the 256-bit AES key generator:
```bash
python -c "import secrets; print(secrets.token_urlsafe(32))"
```
diff --git a/docs/validation-lab.md b/docs/validation-lab.md
index dee0385..b6ad5b0 100644
--- a/docs/validation-lab.md
+++ b/docs/validation-lab.md
@@ -26,7 +26,7 @@ Start the backend with the matching development policy:
$bytes = [byte[]]::new(32)
[System.Security.Cryptography.RandomNumberGenerator]::Fill($bytes)
$env:ARES_SECRET_KEY = -join ($bytes | ForEach-Object { $_.ToString("x2") })
-$env:ARES_ENCRYPTION_KEY = .\.venv\Scripts\python.exe -c "from cryptography.fernet import Fernet; print(Fernet.generate_key().decode())"
+$env:ARES_ENCRYPTION_KEY = .\.venv\Scripts\python.exe -c "import secrets; print(secrets.token_urlsafe(32))"
$env:ARES_DEFAULT_ADMIN_PASSWORD = "replace-with-your-own-strong-admin-password"
$env:ARES_DEBUG = "true"
$env:ARES_BROWSER_ORIGIN = "http://127.0.0.1:5173"
diff --git a/scripts/setup.sh b/scripts/setup.sh
index 3530b7b..61e7401 100644
--- a/scripts/setup.sh
+++ b/scripts/setup.sh
@@ -43,7 +43,7 @@ fi
if grep -q "CHANGE_ME" .env 2>/dev/null; then
echo "[*] Replacing CHANGE_ME placeholders in .env with secure keys..."
SECRET=$(python3 -c "import secrets; print(secrets.token_hex(32))")
- ENC=$(python3 -c "from cryptography.fernet import Fernet; print(Fernet.generate_key().decode())")
+ ENC=$(python3 -c "import secrets; print(secrets.token_urlsafe(32))")
ARES_GENERATED_SECRET="$SECRET" ARES_GENERATED_ENC="$ENC" python3 - <<'PY'
import os
from pathlib import Path
diff --git a/tests/unit/test_cli_doctor.py b/tests/unit/test_cli_doctor.py
index 38b65d2..502dbca 100644
--- a/tests/unit/test_cli_doctor.py
+++ b/tests/unit/test_cli_doctor.py
@@ -637,6 +637,29 @@ def test_python_setup_replaces_change_me_placeholders_in_existing_env(tmp_path,
assert "ARES_API_PORT=8080" in env_content
+def test_python_setup_replaces_new_256bit_placeholder_in_existing_env(tmp_path, capsys):
+ from ares.cli.typer_main import _run_python_setup
+
+ (tmp_path / ".env").write_text(
+ "ARES_SECRET_KEY=CHANGE_ME_USE_openssl_rand_-hex_32\n"
+ "ARES_ENCRYPTION_KEY=CHANGE_ME_USE_secrets_token_urlsafe_32\n"
+ "ARES_DEFAULT_ADMIN_PASSWORD=YOUR_STRONG_ADMIN_PASSWORD_HERE\n"
+ "ARES_API_PORT=8080\n",
+ encoding="utf-8",
+ )
+
+ _run_python_setup(root=tmp_path, platform_name="win32", os_name="nt")
+
+ output = capsys.readouterr().out
+ assert "Replaced CHANGE_ME placeholders in .env with secure generated keys" in output
+ assert "Admin password:" in output
+
+ env_content = (tmp_path / ".env").read_text(encoding="utf-8")
+ assert "CHANGE_ME" not in env_content
+ assert "YOUR_STRONG_ADMIN_PASSWORD_HERE" not in env_content
+ assert "ARES_API_PORT=8080" in env_content
+
+
def test_python_setup_leaves_configured_env_unchanged(tmp_path, capsys):
from ares.cli.typer_main import _run_python_setup
diff --git a/tests/unit/test_scope_firewall.py b/tests/unit/test_scope_firewall.py
index ee1272e..802cf49 100644
--- a/tests/unit/test_scope_firewall.py
+++ b/tests/unit/test_scope_firewall.py
@@ -1,7 +1,7 @@
"""
-Tests for ARES Kernel Scope Wall & Egress Network Firewall.
-Verifies socket-level interception, ContextVar task isolation, DNS resolution safety,
-cloud allowlists, and engine integration.
+Tests for ARES Dual-Layer Scope Firewall & Egress Network Filter.
+Verifies OS-level packet filtering controller, socket-level interception, ContextVar
+task isolation, DNS resolution safety, cloud allowlists, and engine integration.
"""
from __future__ import annotations
@@ -14,6 +14,8 @@ from ares.core.campaign import Campaign, ScopeEntry
from ares.core.errors import ScopeFirewallBlockError
from ares.core.scope_firewall import (
ScopeFirewall,
+ OSFirewallController,
+ get_os_firewall_status,
scope_firewall_guard,
scope_firewall_sync_guard,
install_hooks,
@@ -244,3 +246,75 @@ class TestEngineIntegration:
assert result.status == ModuleStatus.FAILED
assert result.outcome == "scope_firewall_blocked"
assert "[ScopeFirewall]" in (result.error or "")
+
+
+class TestOSFirewallController:
+ """Tests for native OS / Kernel packet filtering controller."""
+
+ def test_status_reporting(self):
+ status = get_os_firewall_status()
+ assert "platform" in status
+ assert "engine" in status
+ assert "elevated" in status
+ assert "fallback_mode" in status
+ assert status["fallback_mode"] == "In-Process Transport Socket Interception"
+
+ def test_unprivileged_fallback_produces_no_errors(self, sample_campaign: Campaign):
+ with patch.object(OSFirewallController, "is_elevated", return_value=False):
+ rules = OSFirewallController.apply_rules(sample_campaign, ["10.0.0.0/24"])
+ assert rules == []
+ status = OSFirewallController.get_status()
+ assert status["elevated"] is False
+ assert status["active_rules_count"] == 0
+
+ def test_windows_elevated_rule_application_and_cleanup(self, sample_campaign: Campaign):
+ with (
+ patch.object(OSFirewallController, "is_elevated", return_value=True),
+ patch("sys.platform", "win32"),
+ patch("subprocess.run") as mock_run,
+ ):
+ mock_run.return_value = MagicMock(returncode=0, stdout="Ok.", stderr="")
+ rules = OSFirewallController.apply_rules(sample_campaign, ["10.0.0.0/24", "192.168.1.0/24"])
+ assert len(rules) == 1
+ assert rules[0].startswith("ARES_SCOPE_WALL_")
+ assert mock_run.call_count == 1
+ cmd = mock_run.call_args[0][0]
+ assert cmd[0] == "netsh"
+ assert "advfirewall" in cmd
+ assert "remoteip=10.0.0.0/24,192.168.1.0/24" in cmd
+
+ # Verify cleanup
+ removed = OSFirewallController.remove_rules(rules)
+ assert removed == 1
+ del_cmd = mock_run.call_args[0][0]
+ assert del_cmd[0] == "netsh"
+ assert f"name={rules[0]}" in del_cmd
+
+ def test_linux_elevated_rule_application_and_cleanup(self, sample_campaign: Campaign):
+ with (
+ patch.object(OSFirewallController, "is_elevated", return_value=True),
+ patch("sys.platform", "linux"),
+ patch("os.getpid", return_value=12345),
+ patch("subprocess.run") as mock_run,
+ ):
+ mock_run.return_value = MagicMock(returncode=0, stdout="", stderr="")
+ rules = OSFirewallController.apply_rules(sample_campaign, ["172.16.0.0/16"])
+ assert len(rules) == 1
+ assert rules[0].startswith("ARES_SCOPE_WALL_")
+ cmd = mock_run.call_args[0][0]
+ assert cmd[0] == "iptables"
+ assert "-d" in cmd
+ assert "172.16.0.0/16" in cmd
+
+ removed = OSFirewallController.remove_rules(rules)
+ assert removed == 1
+
+ def test_scope_firewall_guard_wires_os_firewall(self, sample_campaign: Campaign):
+ with (
+ patch.object(OSFirewallController, "apply_rules", return_value=["ARES_SCOPE_WALL_test"]) as mock_apply,
+ patch.object(OSFirewallController, "remove_rules") as mock_remove,
+ ):
+ with scope_firewall_sync_guard(sample_campaign, enable_os_firewall=True) as fw:
+ assert fw is not None
+ mock_apply.assert_called_once()
+ mock_remove.assert_called_once_with(["ARES_SCOPE_WALL_test"])