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.

8.3 KB
Raw Blame
"""
Shared CLI persistence helpers - campaign JSON store on local disk.
Used by typer_main.py for all campaign read/write operations.
"""
from __future__ import annotations

import json
from pathlib import Path
from typing import Any


def campaigns_dir() -> Path:
    p = Path.home() / ".ares" / "campaigns"
    p.mkdir(parents=True, exist_ok=True)
    return p


def save_campaign(campaign: Any) -> None:
    path = campaigns_dir() / f"{campaign.id}.json"
    path.write_text(campaign.model_dump_json(indent=2), encoding="utf-8")


def load_campaign(partial_id: str) -> dict[str, Any] | None:
    for p in campaigns_dir().glob("*.json"):
        data: dict[str, Any] = json.loads(p.read_text(encoding="utf-8"))
        if data["id"].startswith(partial_id):
            return data
    return None


def load_all_campaigns() -> list[dict[str, Any]]:
    return [
        json.loads(p.read_text(encoding="utf-8"))
        for p in sorted(
            campaigns_dir().glob("*.json"),
            key=lambda x: x.stat().st_mtime,
            reverse=True,
        )
    ]


def calc_risk(c: dict[str, Any]) -> float:
    sev_map = {"critical": 5, "high": 4, "medium": 3, "low": 2, "info": 1}
    return sum(
        sev_map.get(f.get("severity", "info"), 1) * f.get("confidence", 1.0)
        for f in c.get("findings", [])
        if not f.get("false_positive")
    )


# ── Campaign Store class (returned by get_store()) ────────────────────────────

class CampaignStore:
    """
    Simple file-based campaign store.
    Wraps the module-level helpers for use as an object.
    """

    def list_campaigns(self) -> list[dict]:
        return load_all_campaigns()

    def get_campaign(self, partial_id: str) -> dict | None:
        return load_campaign(partial_id)

    def save_campaign(self, campaign: Any) -> None:
        save_campaign(campaign)

    def active_campaign_id(self) -> str | None:
        """Return ID of most recently modified campaign, or None."""
        all_c = load_all_campaigns()
        return all_c[0]["id"] if all_c else None

    def add_target(self, campaign_partial_id: str, target: "str | dict") -> bool:
        """Append a target entry to a campaign and re-save. Returns True if found."""
        import json

        # Normalise: accept either a plain string or a dict like {"target": ip, "tags": [...]}
        if isinstance(target, dict):
            entry = target
            ip_str = entry.get("target", "")
        else:
            entry  = {"target": str(target), "tags": [], "notes": ""}
            ip_str = str(target)

        for p in campaigns_dir().glob("*.json"):
            data: dict = json.loads(p.read_text(encoding="utf-8"))
            if data["id"].startswith(campaign_partial_id):
                targets = data.get("targets", [])
                # Avoid duplicate IPs
                existing_ips = [
                    (t["target"] if isinstance(t, dict) else t)
                    for t in targets
                ]
                if ip_str not in existing_ips:
                    targets.append(entry)
                    data["targets"] = targets
                    p.write_text(json.dumps(data, indent=2), encoding="utf-8")
                return True
        return False

    def list_targets(self, campaign_partial_id: str) -> list[dict]:
        """Return targets (as dicts) for a campaign, or [] if not found."""
        c = load_campaign(campaign_partial_id)
        raw = c.get("targets", []) if c else []
        # Normalise old string entries
        result = []
        for t in raw:
            if isinstance(t, dict):
                result.append(t)
            else:
                result.append({"target": str(t), "tags": [], "notes": ""})
        return result

    # ── Checkpoint management ─────────────────────────────────────────────

    def save_checkpoint(self, campaign_partial_id: str, notes: str = "") -> dict | None:
        """Snapshot a campaign state as an AES-256-GCM encrypted checkpoint."""
        import json
        import os
        import time
        c = load_campaign(campaign_partial_id)
        if not c:
            return None

        from ares.checkpoint.manager import CheckpointManager
        from ares.core.config import get_settings

        settings = get_settings()
        enc_key = getattr(settings, "ares_encryption_key", "") or getattr(settings, "ares_secret_key", "")
        if not enc_key:
            enc_key = "ares-default-local-checkpoint-key-32b"

        mgr = CheckpointManager(enc_key)

        cp_dir = campaigns_dir() / "checkpoints" / c["id"]
        cp_dir.mkdir(parents=True, exist_ok=True)

        ts = int(time.time())
        cp_id = f"cp_{ts}"
        checkpoint = {
            "checkpoint_id": cp_id,
            "campaign_id":   c["id"],
            "saved_at":      time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime(ts)),
            "notes":         notes,
            "state":         c,
        }
        raw_bytes = json.dumps(checkpoint, indent=2, default=str).encode("utf-8")
        nonce = os.urandom(mgr._GCM_NONCE_LEN)
        ct = mgr._aesgcm.encrypt(nonce, raw_bytes, None)
        encrypted = mgr._V2_MAGIC + nonce + ct

        cp_path = cp_dir / f"{cp_id}.json"
        cp_path.write_bytes(encrypted)

        # Mark campaign as paused
        for p in campaigns_dir().glob("*.json"):
            try:
                data_raw = json.loads(p.read_text(encoding="utf-8"))
                if data_raw.get("id") == c["id"]:
                    data_raw["status"] = "paused"
                    data_raw["last_checkpoint"] = cp_id
                    p.write_text(json.dumps(data_raw, indent=2), encoding="utf-8")
                    break
            except Exception:
                continue

        return {"checkpoint_id": cp_id, "path": str(cp_path), "saved_at": checkpoint["saved_at"]}

    def load_checkpoint(self, campaign_partial_id: str, cp_id: str = "latest") -> dict | None:
        """Load an AES-256-GCM encrypted checkpoint. cp_id='latest' returns the most recent."""
        import json
        c = load_campaign(campaign_partial_id)
        if not c:
            return None

        cp_dir = campaigns_dir() / "checkpoints" / c["id"]
        if not cp_dir.exists():
            return None

        checkpoints = sorted(cp_dir.glob("cp_*.json"), key=lambda p: p.stat().st_mtime, reverse=True)
        if not checkpoints:
            return None

        if cp_id == "latest":
            target = checkpoints[0]
        else:
            matches = [p for p in checkpoints if cp_id in p.name]
            target = matches[0] if matches else checkpoints[0]

        data_bytes = target.read_bytes()
        from ares.checkpoint.manager import CheckpointManager
        from ares.core.config import get_settings

        settings = get_settings()
        enc_key = getattr(settings, "ares_encryption_key", "") or getattr(settings, "ares_secret_key", "")
        if not enc_key:
            enc_key = "ares-default-local-checkpoint-key-32b"

        mgr = CheckpointManager(enc_key)
        try:
            decrypted = mgr._decrypt_checkpoint(data_bytes)
            return json.loads(decrypted.decode("utf-8"))
        except Exception:
            # Fallback: legacy unencrypted JSON
            return json.loads(data_bytes.decode("utf-8"))

    def list_reports(self, campaign_partial_id: str = "") -> list[dict]:
        """List generated report files from ~/.ares/reports/."""
        from pathlib import Path
        reports_dir = Path.home() / ".ares" / "reports"
        if not reports_dir.exists():
            return []

        results = []
        for p in sorted(reports_dir.iterdir(), key=lambda x: x.stat().st_mtime, reverse=True):
            if p.suffix in (".html", ".json", ".md", ".pdf"):
                results.append({
                    "filename": p.name,
                    "format":   p.suffix.lstrip("."),
                    "size_kb":  round(p.stat().st_size / 1024, 1),
                    "path":     str(p),
                })
        return results


_store_instance: CampaignStore | None = None


def get_store() -> CampaignStore:
    """Return singleton CampaignStore instance."""
    global _store_instance
    if _store_instance is None:
        _store_instance = CampaignStore()
    return _store_instance