core/hermes_memory.py

"""
HermesMemory – Persistent tiered memory with write verification and
high-level helpers for the RRA pentest runtime.

This module is intentionally *runtime-driven*:
- The LLM never calls this directly.
- Orchestrator and tools use HermesMemory to store/retrieve arsenal tools,
  exploit successes, and semantic relationships (CVE → Exploit → TargetOS/Service).
"""

import logging
from typing import Any, Dict, List, Optional
from uuid import uuid4

import redis
from neo4j import GraphDatabase
from qdrant_client import QdrantClient
from qdrant_client.http import models as qmodels

logger = logging.getLogger(__name__)


class HermesMemory:
    """
    Tiered memory wrapper:
      - Tier 1: Redis KV (fast lookups / arsenal)
      - Tier 2: Qdrant vector store (semantic search)
      - Tier 3: Neo4j graph (relationships)
    """

    def __init__(
        self,
        redis_url: str = "redis://localhost:6379",
        qdrant_host: str = "localhost",
        qdrant_port: int = 6333,
        neo4j_url: str = "bolt://localhost:7687",
        neo4j_user: str = "neo4j",
        neo4j_password: str = "password",
    ) -> None:
        # Redis
        try:
            self.redis = redis.Redis.from_url(redis_url, decode_responses=True)
            # Simple health check
            self.redis.ping()
        except Exception as e:
            logger.warning(f"HermesMemory: Redis init failed: {e}")
            self.redis = None

        # Qdrant
        try:
            self.qdrant = QdrantClient(host=qdrant_host, port=qdrant_port)
            # Optional: a light ping via get_collections
            _ = self.qdrant.get_collections()
        except Exception as e:
            logger.warning(f"HermesMemory: Qdrant init failed: {e}")
            self.qdrant = None

        # Neo4j
        try:
            self.neo4j = GraphDatabase.driver(
                neo4j_url, auth=(neo4j_user, neo4j_password)
            )
            # Optional: test a simple query
            with self.neo4j.session() as session:
                _ = session.run("RETURN 1").single()
        except Exception as e:
            logger.warning(f"HermesMemory: Neo4j init failed: {e}")
            self.neo4j = None

    # -------------------------------------------------------------------------
    # Tier 1 – Redis KV
    # -------------------------------------------------------------------------

    def kv_set(self, key: str, value: str) -> None:
        """Set a key/value pair in Redis, if available."""
        if not self.redis:
            logger.debug("HermesMemory.kv_set skipped: Redis not available")
            return
        self.redis.set(key, value)

    def kv_get(self, key: str) -> Optional[str]:
        """Get a value by key from Redis."""
        if not self.redis:
            logger.debug("HermesMemory.kv_get: Redis not available")
            return None
        return self.redis.get(key)

    def kv_verify(self, key: str, value: str) -> bool:
        """Verify that key in Redis matches provided value."""
        if not self.redis:
            logger.debug("HermesMemory.kv_verify: Redis not available")
            return False
        stored = self.redis.get(key)
        return stored == value

    # -------------------------------------------------------------------------
    # Tier 2 – Qdrant Vector Store
    # -------------------------------------------------------------------------

    def ensure_collection(
        self,
        collection: str,
        vector_size: int,
        distance: str = "Cosine",
    ) -> None:
        """
        Ensure a Qdrant collection exists with given vector size and distance.
        Safe to call multiple times.
        """
        if not self.qdrant:
            logger.debug("HermesMemory.ensure_collection: Qdrant not available")
            return

        try:
            existing = self.qdrant.get_collection(collection)
            logger.debug(f"Qdrant collection '{collection}' already exists: {existing}")
        except Exception:
            logger.info(f"Creating Qdrant collection '{collection}'")
            self.qdrant.create_collection(
                collection_name=collection,
                vectors_config=qmodels.VectorParams(
                    size=vector_size,
                    distance=distance,
                ),
            )

    def vector_store(
        self,
        collection: str,
        vector: List[float],
        metadata: Dict[str, Any],
    ) -> Optional[str]:
        """
        Upsert a vector + payload into a Qdrant collection.
        Returns the point id used (string) or None if Qdrant is unavailable.
        """
        if not self.qdrant:
            logger.debug("HermesMemory.vector_store: Qdrant not available")
            return None

        point_id = metadata.get("id") or str(uuid4())
        metadata = dict(metadata)
        metadata["id"] = point_id  # ensure consistency

        try:
            self.qdrant.upsert(
                collection_name=collection,
                points=[
                    qmodels.PointStruct(
                        id=point_id,
                        vector=vector,
                        payload=metadata,
                    )
                ],
            )
            return point_id
        except Exception as e:
            logger.warning(f"HermesMemory.vector_store failed: {e}")
            return None

    def vector_search(
        self,
        collection: str,
        vector: List[float],
        limit: int = 5,
    ) -> List[Any]:
        """Search similar vectors in the given collection."""
        if not self.qdrant:
            logger.debug("HermesMemory.vector_search: Qdrant not available")
            return []
        try:
            return self.qdrant.search(
                collection_name=collection,
                query_vector=vector,
                limit=limit,
            )
        except Exception as e:
            logger.warning(f"HermesMemory.vector_search failed: {e}")
            return []

    def vector_verify(self, collection: str, point_id: str) -> bool:
        """Check if a given point id exists in the collection."""
        if not self.qdrant:
            logger.debug("HermesMemory.vector_verify: Qdrant not available")
            return False
        try:
            points = self.qdrant.retrieve(
                collection_name=collection,
                ids=[point_id],
            )
            return len(points) > 0
        except Exception as e:
            logger.warning(f"HermesMemory.vector_verify failed: {e}")
            return False

    # -------------------------------------------------------------------------
    # Tier 3 – Neo4j Graph Store
    # -------------------------------------------------------------------------

    @staticmethod
    def _validate_label(label: str) -> str:
        """
        Basic Neo4j label validation to avoid Cypher injection.
        Accepts only alphanumeric + underscore, starting with letter/underscore.
        """
        import re

        if not re.fullmatch(r"[A-Za-z_][A-Za-z0-9_]*", label):
            raise ValueError(f"Invalid Neo4j label: {label}")
        return label

    def graph_query(self, query: str, params: Optional[Dict[str, Any]] = None) -> List[Dict[str, Any]]:
        """
        Run an arbitrary Cypher query (for internal use).
        Prefer using the higher-level helpers where possible.
        """
        if not self.neo4j:
            logger.debug("HermesMemory.graph_query: Neo4j not available")
            return []
        try:
            with self.neo4j.session() as session:
                result = session.run(query, **(params or {}))
                return [record.data() for record in result]
        except Exception as e:
            logger.warning(f"HermesMemory.graph_query failed: {e}")
            return []

    def graph_create_node(self, label: str, properties: Dict[str, Any]) -> None:
        """Create a node with given label and properties."""
        if not self.neo4j:
            logger.debug("HermesMemory.graph_create_node: Neo4j not available")
            return
        label = self._validate_label(label)
        try:
            with self.neo4j.session() as session:
                session.run(
                    f"CREATE (n:{label} $props)",
                    props=properties,
                )
        except Exception as e:
            logger.warning(f"HermesMemory.graph_create_node failed: {e}")

    def graph_verify(self, label: str, key: str, value: Any) -> bool:
        """Verify that a node with given label and key=value exists."""
        if not self.neo4j:
            logger.debug("HermesMemory.graph_verify: Neo4j not available")
            return False
        label = self._validate_label(label)
        try:
            with self.neo4j.session() as session:
                result = session.run(
                    f"MATCH (n:{label} {{{key}: $value}}) RETURN n LIMIT 1",
                    value=value,
                )
                return result.single() is not None
        except Exception as e:
            logger.warning(f"HermesMemory.graph_verify failed: {e}")
            return False

    # -------------------------------------------------------------------------
    # High-level helpers for RRA: Arsenal & Exploit Knowledge
    # -------------------------------------------------------------------------

    def store_arsenal_tool(
        self,
        tool_key: str,
        path: str,
        sha256: str,
        metadata: Optional[Dict[str, Any]] = None,
    ) -> None:
        """
        Store basic arsenal info in Redis (Tier 1) and optionally graph/vector.

        - tool_key: logical key, e.g., "CVE-2024-23897"
        - path: path on disk where tool/exploit lives
        - sha256: integrity hash
        - metadata: optional extra info (service, target_os, tags, etc.)
        """
        meta = metadata or {}
        value = {
            "path": path,
            "sha256": sha256,
            **meta,
        }

        # Redis KV
        self.kv_set(f"arsenal:{tool_key}", str(value))

        # Optionally, record tool node in graph
        try:
            props = {"tool_key": tool_key, "path": path, "sha256": sha256}
            props.update(meta)
            self.graph_create_node("ExploitTool", props)
        except Exception as e:
            logger.warning(f"store_arsenal_tool graph_create_node failed: {e}")

    def get_arsenal_tool_raw(self, tool_key: str) -> Optional[str]:
        """
        Low-level getter for the raw Redis string. The orchestrator is
        expected to parse it (e.g., with ast.literal_eval or json).
        """
        return self.kv_get(f"arsenal:{tool_key}")

    def record_exploit_success(
        self,
        cve: str,
        service: str,
        target_os: str,
        tool_key: str,
    ) -> None:
        """
        Create relationships in the graph to track successful exploits.

        (CVE)-[:HAS_EXPLOIT]->(ExploitTool)-[:TARGETS]->(TargetProfile)
        """
        if not self.neo4j:
            logger.debug("record_exploit_success: Neo4j not available")
            return

        try:
            with self.neo4j.session() as session:
                session.run(
                    """
                    MERGE (c:CVE {id: $cve})
                    MERGE (t:ExploitTool {tool_key: $tool_key})
                    MERGE (p:TargetProfile {service: $service, os: $os})
                    MERGE (c)-[:HAS_EXPLOIT]->(t)
                    MERGE (t)-[:TARGETS]->(p)
                    """,
                    cve=cve,
                    tool_key=tool_key,
                    service=service,
                    os=target_os,
                )
        except Exception as e:
            logger.warning(f"record_exploit_success failed: {e}")