""" 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}")