ARES - authorized red-team engagement automation with dashboard, campaign scope, module orchestration, OPSEC controls, encrypted vault, and reporting.
Python active-directorycloud-securitydefensive-validationfastapigood-first-issuemitre-attackopsecreactred-teamreportingsecurity
"""Security Audit Remediation Regression Tests.
Validates fixes for:
- ARES-SEC-01: MCP SSE Transport network access control and ephemeral auth on external binds.
- ARES-SEC-02: Strict campaign authorization on execution and feasibility endpoints.
- ARES-SEC-03: Prevention of API key scope escalation based on caller role.
"""
from __future__ import annotations
import base64
import hashlib
import os
from types import SimpleNamespace
from unittest.mock import AsyncMock, MagicMock
import httpx
import pytest
# Ensure test environment variables
os.environ.setdefault("ARES_SECRET_KEY", "test-sec-secret-key-min32-chars!!")
os.environ.setdefault("ARES_ENCRYPTION_KEY", "test-enc-key-min32-chars-xxxxxxx")
os.environ.setdefault("ARES_DEFAULT_ADMIN_PASSWORD", "TestApiPass1!")
os.environ.setdefault("ARES_DEBUG", "true")
os.environ.setdefault("ARES_BROWSER_ORIGIN", "http://localhost:5173")
# ── Helpers for Auth and Principals ──────────────────────────────────────────
_MOCK_ROLES: dict[str, str] = {}
def _make_token(username: str, role: str) -> str:
from ares.core.config import AresSettings
from ares.core.security import create_access_token
_MOCK_ROLES[username] = role
s = AresSettings()
family_id = base64.urlsafe_b64encode(
hashlib.sha256(username.encode("utf-8")).digest()
).rstrip(b"=").decode("ascii")
return create_access_token(
data={"sub": username, "sid": family_id, "ver": 1},
secret_key=s.secret_key_value,
expires_minutes=60,
)
def _auth_headers(username: str, role: str) -> dict[str, str]:
return {
"Authorization": f"Bearer {_make_token(username, role)}",
"Idempotency-Key": "22222222-2222-4222-8222-222222222222",
}
# ── 1. ARES-SEC-01: MCP SSE Transport Access Control Tests ───────────────────
class MockMcpServer:
async def handle_message(self, body: dict) -> dict | None:
return {"jsonrpc": "2.0", "id": body.get("id"), "result": "pong"}
@pytest.mark.asyncio
async def test_mcp_sse_loopback_allowed_without_api_key():
from ares.mcp.transport.sse import create_sse_app
server = MockMcpServer()
app = create_sse_app(server, api_key=None)
transport = httpx.ASGITransport(app=app, client=("127.0.0.1", 50000))
async with httpx.AsyncClient(transport=transport, base_url="http://localhost") as client:
# Loopback client: auth passes, proceeds to session validation (400 Bad Request)
res = await client.post("/messages?session_id=fake_sess", json={"jsonrpc": "2.0"})
assert res.status_code == 400
assert "Invalid or expired session_id" in res.json().get("error", "")
@pytest.mark.asyncio
async def test_mcp_sse_non_loopback_rejected_without_api_key():
from ares.mcp.transport.sse import create_sse_app
server = MockMcpServer()
app = create_sse_app(server, api_key=None)
# External IP client trying to access open MCP server without key
transport = httpx.ASGITransport(app=app, client=("192.168.1.105", 50000))
async with httpx.AsyncClient(transport=transport, base_url="http://192.168.1.1") as client:
res = await client.get("/sse")
# Non-loopback client without API key must be 401 Unauthorized
assert res.status_code == 401
assert "Unauthorized" in res.json().get("error", "")
res_msg = await client.post("/messages?session_id=fake_sess", json={"jsonrpc": "2.0"})
assert res_msg.status_code == 401
@pytest.mark.asyncio
async def test_mcp_sse_drive_by_cross_origin_rejected_without_api_key():
"""Operator browser visits malicious site which attempts to CSRF/drive-by local MCP server."""
from ares.mcp.transport.sse import create_sse_app
server = MockMcpServer()
app = create_sse_app(server, api_key=None)
# Client IP is loopback (from operator's local browser), BUT Origin is malicious website
transport = httpx.ASGITransport(app=app, client=("127.0.0.1", 50000))
async with httpx.AsyncClient(transport=transport, base_url="http://localhost") as client:
# Cross-origin drive-by attempt from attacker.com
res = await client.post(
"/messages?session_id=fake_sess",
json={"jsonrpc": "2.0"},
headers={"Origin": "https://malicious-attacker.com"},
)
assert res.status_code == 401
assert "Unauthorized" in res.json().get("error", "")
# GET /sse drive-by stream hijack attempt
res_sse = await client.get("/sse", headers={"Origin": "https://malicious-attacker.com"})
assert res_sse.status_code == 401
@pytest.mark.asyncio
async def test_mcp_sse_dns_rebinding_rejected_without_api_key():
"""Attacker uses DNS rebinding (evil.com -> 127.0.0.1) against local MCP server."""
from ares.mcp.transport.sse import create_sse_app
server = MockMcpServer()
app = create_sse_app(server, api_key=None)
# Client IP is loopback, but Host header contains attacker-controlled domain
transport = httpx.ASGITransport(app=app, client=("127.0.0.1", 50000))
async with httpx.AsyncClient(transport=transport, base_url="http://localhost") as client:
res = await client.post(
"/messages?session_id=fake_sess",
json={"jsonrpc": "2.0"},
headers={"Host": "rebind.attacker-domain.xyz:8765"},
)
assert res.status_code == 401
assert "Unauthorized" in res.json().get("error", "")
@pytest.mark.asyncio
async def test_mcp_sse_cross_site_fetch_rejected():
"""Browser sends Sec-Fetch-Site: cross-site indicator."""
from ares.mcp.transport.sse import create_sse_app
server = MockMcpServer()
app = create_sse_app(server, api_key=None)
transport = httpx.ASGITransport(app=app, client=("127.0.0.1", 50000))
async with httpx.AsyncClient(transport=transport, base_url="http://localhost") as client:
res = await client.post(
"/messages?session_id=fake_sess",
json={"jsonrpc": "2.0"},
headers={"Sec-Fetch-Site": "cross-site"},
)
assert res.status_code == 401
@pytest.mark.asyncio
async def test_mcp_sse_loopback_valid_origin_allowed():
"""Legitimate local frontend (e.g. Vite on localhost:5173) connects to local MCP server."""
from ares.mcp.transport.sse import create_sse_app
server = MockMcpServer()
app = create_sse_app(server, api_key=None)
transport = httpx.ASGITransport(app=app, client=("127.0.0.1", 50000))
async with httpx.AsyncClient(transport=transport, base_url="http://localhost") as client:
res = await client.post(
"/messages?session_id=fake_sess",
json={"jsonrpc": "2.0"},
headers={"Origin": "http://localhost:5173"},
)
# Auth succeeds; proceeds to MCP session check (400)
assert res.status_code == 400
assert "Invalid or expired session_id" in res.json().get("error", "")
@pytest.mark.asyncio
async def test_mcp_sse_non_loopback_allowed_with_valid_bearer_token():
from ares.mcp.transport.sse import create_sse_app
server = MockMcpServer()
app = create_sse_app(server, api_key="secret-token-xyz-12345")
transport = httpx.ASGITransport(app=app, client=("192.168.1.105", 50000))
async with httpx.AsyncClient(transport=transport, base_url="http://192.168.1.1") as client:
# Without token -> 401
res_no_auth = await client.get("/sse")
assert res_no_auth.status_code == 401
# With Bearer token -> auth passes, proceeds to session validation (400)
res_auth = await client.post(
"/messages?session_id=fake_sess",
json={"jsonrpc": "2.0"},
headers={"Authorization": "Bearer secret-token-xyz-12345"},
)
assert res_auth.status_code == 400
@pytest.mark.asyncio
async def test_mcp_sse_non_loopback_allowed_with_header_or_query_key():
from ares.mcp.transport.sse import create_sse_app
server = MockMcpServer()
app = create_sse_app(server, api_key="network-key-999")
transport = httpx.ASGITransport(app=app, client=("10.0.0.42", 50000))
async with httpx.AsyncClient(transport=transport, base_url="http://10.0.0.1") as client:
# X-ARES-API-Key header -> auth passes (400)
res_hdr = await client.post(
"/messages?session_id=fake_sess",
json={"jsonrpc": "2.0"},
headers={"X-ARES-API-Key": "network-key-999"},
)
assert res_hdr.status_code == 400
# Query param -> auth passes (400)
res_query = await client.post(
"/messages?session_id=fake_sess&api_key=network-key-999",
json={"jsonrpc": "2.0"},
)
assert res_query.status_code == 400
# Wrong token -> 401
res_bad = await client.get("/sse", headers={"Authorization": "Bearer wrong-token"})
assert res_bad.status_code == 401
res_bad_msg = await client.post(
"/messages?session_id=fake_sess",
json={"jsonrpc": "2.0"},
headers={"Authorization": "Bearer wrong-token"},
)
assert res_bad_msg.status_code == 401
# ── 2. ARES-SEC-02: Campaign Authorization on Execution / Feasibility ───────
@pytest.fixture
def api_test_setup():
from ares.api.server import app, get_db, get_engine
db = MagicMock()
db.is_access_token_revoked = AsyncMock(return_value=False)
db.get_user = AsyncMock(return_value={"id": "usr-1", "username": "alice", "role": "operator"})
async def resolve_principal(subject, _jti, _family_id, auth_epoch):
role = _MOCK_ROLES.get(subject, "operator")
return {"id": f"uid-{subject}", "username": subject, "role": role, "auth_epoch": auth_epoch}
db.resolve_access_token_principal = AsyncMock(side_effect=resolve_principal)
campaigns = {
"camp-alice": {
"id": "camp-alice",
"name": "Alice Campaign",
"client": "Internal",
"operator": "alice",
"noise_profile": "normal",
"status": "created",
"scope_json": "[]",
"targets_json": '["10.0.0.1"]',
"notes": "",
}
}
async def get_campaign(cid):
return campaigns.get(cid)
db.get_campaign = AsyncMock(side_effect=get_campaign)
db.save_finding = AsyncMock()
db.save_loot = AsyncMock()
db.upsert_host = AsyncMock()
db.update_campaign_status = AsyncMock()
db.audit = AsyncMock()
db.create_api_key = AsyncMock(return_value=("key-123", "ares_key_mock_secret_abcdef123456"))
engine = MagicMock()
engine.bind_database = MagicMock()
fake_report = MagicMock()
fake_report.to_dict.return_value = {"feasibility": "high", "risk_score": 10}
engine.assess_module_feasibility = AsyncMock(return_value=fake_report)
fake_result = SimpleNamespace(
module_id="plugin.safe",
status="success",
findings=[],
raw_output={},
duration_ms=5.0,
)
fake_result.model_dump = lambda: {"module_id": "plugin.safe", "status": "success", "findings": []}
engine.run_module = AsyncMock(return_value=fake_result)
engine.dry_run_module = MagicMock(return_value={"status": "dry_run_ok"})
engine.dry_run_plan = MagicMock(return_value={"status": "dry_run_ok", "modules": []})
orig_state_db = getattr(app.state, "db", None)
orig_state_engine = getattr(app.state, "engine", None)
app.state.db = db
app.state.engine = engine
app.dependency_overrides[get_db] = lambda: db
app.dependency_overrides[get_engine] = lambda: engine
transport = httpx.ASGITransport(app=app)
client = httpx.AsyncClient(transport=transport, base_url="http://localhost")
yield client, db, engine, app
app.state.db = orig_state_db
app.state.engine = orig_state_engine
app.dependency_overrides.pop(get_db, None)
app.dependency_overrides.pop(get_engine, None)
@pytest.mark.asyncio
async def test_feasibility_cross_operator_rejected_with_404(api_test_setup):
client, db, engine, app = api_test_setup
# Bob (operator) tries to assess feasibility for Alice's campaign -> 404
bob_headers = _auth_headers("bob", "operator")
res = await client.post(
"/modules/plugin.safe/feasibility",
json={"campaign_id": "camp-alice", "target": "10.0.0.1", "params": {}},
headers=bob_headers,
)
assert res.status_code == 404
assert "Campaign not found" in res.json().get("detail", "")
engine.assess_module_feasibility.assert_not_awaited()
@pytest.mark.asyncio
async def test_feasibility_owner_operator_allowed(api_test_setup):
client, db, engine, app = api_test_setup
# Alice (the owner operator) assesses feasibility for her own campaign -> 200
alice_headers = _auth_headers("alice", "operator")
res = await client.post(
"/modules/plugin.safe/feasibility",
json={"campaign_id": "camp-alice", "target": "10.0.0.1", "params": {}},
headers=alice_headers,
)
assert res.status_code == 200
assert res.json()["campaign_id"] == "camp-alice"
@pytest.mark.asyncio
async def test_feasibility_team_lead_allowed(api_test_setup):
client, db, engine, app = api_test_setup
# Charlie (team_lead) assesses feasibility for Alice's campaign -> 200
lead_headers = _auth_headers("charlie", "team_lead")
res = await client.post(
"/modules/plugin.safe/feasibility",
json={"campaign_id": "camp-alice", "target": "10.0.0.1", "params": {}},
headers=lead_headers,
)
assert res.status_code == 200
# ── 3. ARES-SEC-03: API Key Scope Privilege Escalation Defense ───────────────
@pytest.mark.asyncio
async def test_api_key_reporter_cannot_mint_write_or_admin(api_test_setup):
client, db, engine, app = api_test_setup
async def get_user(username):
return {"id": "uid-rep", "username": username, "role": "reporter"}
db.get_user = AsyncMock(side_effect=get_user)
rep_headers = _auth_headers("reporter_user", "reporter")
# Reporter requesting admin -> 403
res_admin = await client.post(
"/auth/api-keys",
json={"name": "test-admin-key", "scopes": "admin"},
headers=rep_headers,
)
assert res_admin.status_code == 403
assert "not authorized" in res_admin.json().get("detail", "")
# Reporter requesting write -> 403
res_write = await client.post(
"/auth/api-keys",
json={"name": "test-write-key", "scopes": "write"},
headers=rep_headers,
)
assert res_write.status_code == 403
# Reporter requesting read -> 200
res_read = await client.post(
"/auth/api-keys",
json={"name": "test-read-key", "scopes": "read"},
headers=rep_headers,
)
assert res_read.status_code == 200
assert "key" in res_read.json()
@pytest.mark.asyncio
async def test_api_key_operator_cannot_mint_admin(api_test_setup):
client, db, engine, app = api_test_setup
async def get_user(username):
return {"id": "uid-op", "username": username, "role": "operator"}
db.get_user = AsyncMock(side_effect=get_user)
op_headers = _auth_headers("op_user", "operator")
# Operator requesting admin -> 403
res_admin = await client.post(
"/auth/api-keys",
json={"name": "op-admin-key", "scopes": "admin"},
headers=op_headers,
)
assert res_admin.status_code == 403
assert "not authorized" in res_admin.json().get("detail", "")
# Operator requesting write -> 200
res_write = await client.post(
"/auth/api-keys",
json={"name": "op-write-key", "scopes": "write"},
headers=op_headers,
)
assert res_write.status_code == 200
# Operator requesting read -> 200
res_read = await client.post(
"/auth/api-keys",
json={"name": "op-read-key", "scopes": "read"},
headers=op_headers,
)
assert res_read.status_code == 200
@pytest.mark.asyncio
async def test_api_key_team_lead_can_mint_admin(api_test_setup):
client, db, engine, app = api_test_setup
async def get_user(username):
return {"id": "uid-lead", "username": username, "role": "team_lead"}
db.get_user = AsyncMock(side_effect=get_user)
lead_headers = _auth_headers("lead_user", "team_lead")
# Team Lead requesting admin -> 200
res_admin = await client.post(
"/auth/api-keys",
json={"name": "lead-admin-key", "scopes": "admin"},
headers=lead_headers,
)
assert res_admin.status_code == 200
assert "key" in res_admin.json()
# ── 4. Deep Hardening: MCP Scope Invariance & Secret Masking Tests ────────────
@pytest.mark.asyncio
async def test_mcp_database_scope_strict_enforcement():
"""Verify that real DB scope_json is strictly parsed and blocks out-of-scope targets."""
from ares.mcp.security import ConfirmationTokenManager
from ares.mcp.tools import McpToolRegistry
mock_db = MagicMock()
# Campaign configured strictly for 192.168.50.0/24 (no 10.0.0.0/8 allowed!)
mock_db.get_campaign = AsyncMock(return_value={
"id": "camp-strict-50",
"name": "Strict Scope Engagement",
"scope_json": '["192.168.50.0/24"]',
"targets_json": '["192.168.50.5"]',
})
token_mgr = ConfirmationTokenManager()
registry = McpToolRegistry(token_manager=token_mgr, db=mock_db)
# 1. Target in scope (192.168.50.5:445) -> succeeds
res_in = await registry.call_tool("ares_verify_target_scope", {
"campaign_id": "camp-strict-50",
"target": "192.168.50.5:445",
})
assert not res_in.isError
assert "APPROVED_FOR_TESTING" in res_in.content[0].text
# 2. Target OUT of scope (10.0.0.1: previously allowed by broad fallback!) -> must be REJECTED
res_out = await registry.call_tool("ares_verify_target_scope", {
"campaign_id": "camp-strict-50",
"target": "10.0.0.1",
})
assert not res_out.isError
assert "REJECTED_OUT_OF_SCOPE" in res_out.content[0].text
# 3. Dry-run execution on out-of-scope target must raise McpSecurityViolation
res_dry = await registry.call_tool("ares_dry_run_module", {
"campaign_id": "camp-strict-50",
"module_id": "ad.kerberoast",
"target": "10.0.0.1",
})
assert res_dry.isError
assert "SECURITY VIOLATION" in res_dry.content[0].text
assert "SCOPE VIOLATION [BLOCKED]" in res_dry.content[0].text
@pytest.mark.asyncio
async def test_mcp_nonexistent_campaign_rejected():
"""Verify that querying a non-existent campaign ID in MCP fails closed."""
from ares.mcp.security import ConfirmationTokenManager
from ares.mcp.tools import McpToolRegistry
mock_db = MagicMock()
mock_db.get_campaign = AsyncMock(return_value=None) # Campaign does not exist!
token_mgr = ConfirmationTokenManager()
registry = McpToolRegistry(token_manager=token_mgr, db=mock_db)
res = await registry.call_tool("ares_verify_target_scope", {
"campaign_id": "camp-ghost-999",
"target": "10.0.0.1",
})
assert res.isError
assert "Campaign 'camp-ghost-999' not found in database" in res.content[0].text
def test_mcp_scope_gate_port_and_naked_domain():
"""Verify McpScopeGate handles port notation and naked domain rules."""
from ares.mcp.security import McpScopeGate
rules = ["10.0.0.0/24", "corp.local", "192.168.1.1"]
# IP with port matching CIDR
assert McpScopeGate.is_in_scope("10.0.0.5:445", rules) is True
# Hostname with port matching naked domain
assert McpScopeGate.is_in_scope("dc01.corp.local:88", rules) is True
# Exact host matching naked domain
assert McpScopeGate.is_in_scope("corp.local", rules) is True
# IP with port matching exact IP
assert McpScopeGate.is_in_scope("192.168.1.1:8080", rules) is True
# Out of scope
assert McpScopeGate.is_in_scope("10.0.1.5:445", rules) is False
assert McpScopeGate.is_in_scope("other.com", rules) is False
def test_mcp_secret_masker_pem_block():
"""Verify SecretMasker scrubs raw PEM private key blocks in strings."""
from ares.mcp.security import SecretMasker
fake_pem = (
"-----BEGIN RSA PRIVATE KEY-----\n"
"MIIEowIBAAKCAQEA0YpW3H...\n"
"-----END RSA PRIVATE KEY-----"
)
raw_output = f"Connecting to target... Found SSH key:\n{fake_pem}\nDone."
masked = SecretMasker.mask(raw_output)
assert "-----BEGIN RSA PRIVATE KEY-----" not in masked
assert "[REDACTED_PRIVATE_KEY_BLOCK]" in masked