exploitgraph 1.0.0__py3-none-any.whl

core/http_client.py

@@ -0,0 +1,243 @@
+"""
+ExploitGraph - Centralised HTTP Client
+All modules use this instead of calling requests.get() directly.
+
+Provides:
+  - Automatic retry with exponential backoff (3 attempts)
+  - Consistent User-Agent header
+  - SSL verification control from config
+  - Connection pool reuse (session-based)
+  - Structured response object with helper methods
+  - Per-request timeout enforcement
+  - Silent-failure protection: never raises, always returns a Response
+"""
+from __future__ import annotations
+import time
+from typing import Any, Optional
+
+import requests
+import urllib3
+
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+DEFAULT_TIMEOUT    = 8
+DEFAULT_UA         = "ExploitGraph/1.2 (Security Research; +https://github.com/prajwal-infosec/ExploitGraph)"
+MAX_RETRIES        = 3
+RETRY_BACKOFF      = [0, 1, 2]   # seconds before each attempt
+RETRY_ON_STATUS    = {429, 500, 502, 503, 504}
+NO_RETRY_ON_STATUS = {400, 401, 403, 404, 405}
+
+
+class EGResponse:
+    """
+    Wrapper around requests.Response that never raises and provides
+    helper methods for the most common access patterns in modules.
+    """
+    def __init__(self, resp: Optional[requests.Response], error: str = ""):
+        self._resp  = resp
+        self._error = error
+
+    # ── Core properties ────────────────────────────────────────────────────
+
+    @property
+    def ok(self) -> bool:
+        return self._resp is not None and self._resp.status_code < 400
+
+    @property
+    def status_code(self) -> int:
+        return self._resp.status_code if self._resp is not None else 0
+
+    @property
+    def text(self) -> str:
+        if self._resp is None:
+            return ""
+        try:
+            return self._resp.text
+        except Exception:
+            return ""
+
+    @property
+    def content(self) -> bytes:
+        if self._resp is None:
+            return b""
+        return self._resp.content or b""
+
+    @property
+    def error(self) -> str:
+        return self._error
+
+    @property
+    def headers(self) -> dict:
+        if self._resp is None:
+            return {}
+        return dict(self._resp.headers)
+
+    @property
+    def url(self) -> str:
+        if self._resp is None:
+            return ""
+        return self._resp.url or ""
+
+    # ── Helper methods ─────────────────────────────────────────────────────
+
+    def json(self, default: Any = None) -> Any:
+        """Parse JSON body. Returns `default` on failure — never raises."""
+        if self._resp is None:
+            return default
+        try:
+            return self._resp.json()
+        except Exception:
+            return default
+
+    def contains(self, *strings: str) -> bool:
+        """True if all strings are in the response text."""
+        body = self.text
+        return all(s in body for s in strings)
+
+    def header(self, name: str, default: str = "") -> str:
+        return self.headers.get(name, self.headers.get(name.lower(), default))
+
+    def __bool__(self) -> bool:
+        return self.ok
+
+    def __repr__(self) -> str:
+        if self._resp is None:
+            return f"<EGResponse ERROR: {self._error}>"
+        return f"<EGResponse {self.status_code} {self.url[:60]}>"
+
+
+class HTTPClient:
+    """
+    Thread-safe HTTP client using a shared requests.Session.
+    All ExploitGraph modules get one instance via the module-level `http` singleton.
+    """
+
+    def __init__(self, timeout: int = DEFAULT_TIMEOUT,
+                 verify_ssl: bool = False,
+                 user_agent: str = DEFAULT_UA):
+        self.timeout    = timeout
+        self.verify_ssl = verify_ssl
+        self._session   = self._make_session(user_agent)
+
+    def _make_session(self, user_agent: str) -> requests.Session:
+        s = requests.Session()
+        s.headers.update({
+            "User-Agent": user_agent,
+            "Accept":     "application/json, text/html, */*",
+        })
+        # Connection pool: reuse up to 20 connections
+        adapter = requests.adapters.HTTPAdapter(
+            pool_connections=20,
+            pool_maxsize=50,
+            max_retries=0,   # We handle retries ourselves
+        )
+        s.mount("http://",  adapter)
+        s.mount("https://", adapter)
+        return s
+
+    def get(self, url: str, *,
+            headers:  dict    = None,
+            params:   dict    = None,
+            timeout:  int     = None,
+            allow_redirects: bool = True,
+            retries:  int     = MAX_RETRIES) -> EGResponse:
+        return self._request("GET", url, headers=headers, params=params,
+                              timeout=timeout, allow_redirects=allow_redirects,
+                              retries=retries)
+
+    def post(self, url: str, *,
+             json:    Any  = None,
+             data:    Any  = None,
+             headers: dict = None,
+             timeout: int  = None,
+             retries: int  = 1) -> EGResponse:   # POST: fewer retries by default
+        return self._request("POST", url, json=json, data=data,
+                              headers=headers, timeout=timeout, retries=retries)
+
+    def _request(self, method: str, url: str, *,
+                 headers:  dict  = None,
+                 params:   dict  = None,
+                 json:     Any   = None,
+                 data:     Any   = None,
+                 timeout:  int   = None,
+                 allow_redirects: bool = True,
+                 retries:  int   = MAX_RETRIES) -> EGResponse:
+        """
+        Execute HTTP request with retry + exponential backoff.
+        Never raises — always returns EGResponse.
+        """
+        effective_timeout = timeout or self.timeout
+        kwargs = {
+            "headers":         headers or {},
+            "params":          params,
+            "timeout":         effective_timeout,
+            "verify":          self.verify_ssl,
+            "allow_redirects": allow_redirects,
+        }
+        if json is not None:
+            kwargs["json"] = json
+        if data is not None:
+            kwargs["data"] = data
+
+        last_error = ""
+        for attempt in range(retries):
+            if attempt > 0:
+                delay = RETRY_BACKOFF[min(attempt, len(RETRY_BACKOFF) - 1)]
+                if delay:
+                    time.sleep(delay)
+
+            try:
+                resp = self._session.request(method, url, **kwargs)
+
+                # Don't retry on definitive failure codes
+                if resp.status_code in NO_RETRY_ON_STATUS:
+                    return EGResponse(resp)
+
+                # Retry on transient failures
+                if resp.status_code in RETRY_ON_STATUS and attempt < retries - 1:
+                    last_error = f"HTTP {resp.status_code}"
+                    continue
+
+                return EGResponse(resp)
+
+            except requests.exceptions.Timeout:
+                last_error = f"Timeout after {effective_timeout}s"
+            except requests.exceptions.ConnectionError as e:
+                last_error = f"Connection error: {_short_err(e)}"
+            except requests.exceptions.TooManyRedirects:
+                last_error = "Too many redirects"
+                break
+            except Exception as e:
+                last_error = f"Unexpected error: {_short_err(e)}"
+                break   # Don't retry unknown errors
+
+        return EGResponse(None, last_error)
+
+    def update_config(self, timeout: int = None, verify_ssl: bool = None):
+        if timeout is not None:
+            self.timeout = timeout
+        if verify_ssl is not None:
+            self.verify_ssl = verify_ssl
+
+
+def _short_err(e: Exception) -> str:
+    s = str(e)
+    return s[:120] + "..." if len(s) > 120 else s
+
+
+# ── Global singleton ───────────────────────────────────────────────────────────
+# All modules import this and call http.get(...) / http.post(...)
+http = HTTPClient()
+
+
+def configure(timeout: int = None, verify_ssl: bool = None, user_agent: str = None):
+    """Called at startup from config.py to apply framework settings."""
+    global http
+    if user_agent:
+        http = HTTPClient(
+            timeout    = timeout    or http.timeout,
+            verify_ssl = verify_ssl if verify_ssl is not None else http.verify_ssl,
+            user_agent = user_agent,
+        )
+    else:
+        http.update_config(timeout=timeout, verify_ssl=verify_ssl)

core/logger.py

@@ -0,0 +1,97 @@
+"""ExploitGraph - Structured Logger (colored console + rotating file)."""
+from __future__ import annotations
+import logging
+from pathlib import Path
+from colorama import Fore, Style, init
+
+init(autoreset=True)
+LOG_DIR = Path(__file__).parent.parent / "logs"
+LOG_DIR.mkdir(exist_ok=True)
+
+
+class ExploitGraphLogger:
+    def __init__(self):
+        self._quiet = False
+        self._flog = None
+        self._setup("startup")
+
+    def _setup(self, sid: str):
+        self._flog = logging.getLogger(f"eg_{sid}")
+        self._flog.setLevel(logging.DEBUG)
+        if not self._flog.handlers:
+            fh = logging.FileHandler(LOG_DIR / f"exploitgraph_{sid}.log", encoding="utf-8")
+            fh.setFormatter(logging.Formatter("%(asctime)s | %(levelname)s | %(message)s",
+                                               datefmt="%Y-%m-%d %H:%M:%S"))
+            self._flog.addHandler(fh)
+
+    def new_session(self, sid: str): self._setup(sid)
+    def set_quiet(self, q: bool):    self._quiet = q
+
+    def _p(self, prefix, msg, color=""):
+        c = color or Fore.WHITE
+        if not self._quiet:
+            print(f"{c}{prefix}{Style.RESET_ALL} {msg}")
+        if self._flog:
+            self._flog.info(f"{prefix} {msg}")
+
+    def info(self, m):     self._p("[*]", m, Fore.CYAN)
+    def success(self, m):  self._p("[+]", m, Fore.GREEN)
+    def warning(self, m):  self._p("[!]", m, Fore.YELLOW)
+    def error(self, m):    self._p("[-]", m, Fore.RED)
+    def result(self, m):   self._p("[>]", m, Fore.MAGENTA)
+    def step(self, m):     self._p("  →", m, Fore.BLUE)
+    def newline(self):     print()
+
+    def critical(self, m):
+        print(f"{Fore.WHITE}[{Fore.RED}CRITICAL{Fore.WHITE}]{Style.RESET_ALL} {Fore.RED}{m}{Style.RESET_ALL}")
+        if self._flog: self._flog.critical(m)
+
+    def found(self, m):
+        self._p("[FOUND]", m, Fore.GREEN)
+
+    def secret(self, label: str, value: str):
+        print(f"  {Fore.RED}►{Style.RESET_ALL} {Fore.YELLOW}{label:<26}{Style.RESET_ALL}{Fore.WHITE}{value}{Style.RESET_ALL}")
+        if self._flog: self._flog.info(f"SECRET | {label}: {value}")
+
+    def kv(self, key: str, val: str, w: int = 28):
+        print(f"  {Fore.CYAN}{key:<{w}}{Style.RESET_ALL}{val}")
+
+    def banner(self, title: str, width: int = 62):
+        bar = "═" * width
+        print(f"\n{Fore.RED}╔{bar}╗")
+        print(f"║{Fore.WHITE}  {title.center(width-2)}{Fore.RED}  ║")
+        print(f"╚{bar}╝{Style.RESET_ALL}")
+
+    def section(self, title: str):
+        print(f"\n{Fore.CYAN}{'─'*60}\n{Fore.WHITE}{title.upper()}{Style.RESET_ALL}\n{Fore.CYAN}{'─'*60}{Style.RESET_ALL}")
+
+    def phase(self, n: int, total: int, name: str):
+        print(f"\n{Fore.CYAN}{'─'*60}")
+        print(f"{Fore.CYAN}[{n}/{total}]{Fore.WHITE} {name.upper()}{Style.RESET_ALL}")
+        print(f"{Fore.CYAN}{'─'*60}{Style.RESET_ALL}")
+
+    def severity_badge(self, s: str) -> str:
+        m = {"CRITICAL": Fore.RED, "HIGH": Fore.YELLOW,
+             "MEDIUM": Fore.CYAN, "LOW": Fore.GREEN, "INFO": Fore.WHITE}
+        c = m.get(s.upper(), Fore.WHITE)
+        return f"{c}[{s}]{Style.RESET_ALL}"
+
+    def table(self, headers, rows, title=""):
+        try:
+            from tabulate import tabulate
+            if title: print(f"\n{Fore.YELLOW}{title}{Style.RESET_ALL}")
+            print(tabulate(rows, headers=headers, tablefmt="rounded_outline") if rows
+                  else f"  {Fore.CYAN}(no data){Style.RESET_ALL}")
+        except ImportError:
+            if title: print(f"\n{title}")
+            for r in rows: print("  " + " | ".join(str(c) for c in r))
+
+    # Module-facing aliases
+    def module_info(self, m):     self.info(m)
+    def module_success(self, m):  self.success(m)
+    def module_warn(self, m):     self.warning(m)
+    def module_error(self, m):    self.error(m)
+    def module_critical(self, m): self.critical(m)
+
+
+log = ExploitGraphLogger()

core/module_loader.py

@@ -0,0 +1,69 @@
+"""ExploitGraph - Dynamic module discovery and loading."""
+from __future__ import annotations
+import sys, importlib.util
+from pathlib import Path
+from typing import Optional
+from modules.base import BaseModule
+
+MODULE_ROOT = Path(__file__).parent.parent / "modules"
+CATEGORY_ORDER = ["discovery","cloud","secrets","exploitation","reporting","misc","custom"]
+
+
+class ModuleLoader:
+    def __init__(self):
+        self._registry: dict[str, type[BaseModule]] = {}
+        self._errors:   list[str] = []
+
+    def discover(self) -> int:
+        self._registry.clear(); self._errors.clear()
+        for cat_dir in sorted(MODULE_ROOT.iterdir()):
+            if not cat_dir.is_dir() or cat_dir.name.startswith("_"): continue
+            for py in sorted(cat_dir.glob("*.py")):
+                if not py.name.startswith("_"):
+                    self._try_load(py, cat_dir.name)
+        return len(self._registry)
+
+    def _try_load(self, path: Path, category: str):
+        mod_name = f"_eg_{category}_{path.stem}"
+        try:
+            spec = importlib.util.spec_from_file_location(mod_name, path)
+            mod  = importlib.util.module_from_spec(spec)
+            sys.modules[mod_name] = mod
+            spec.loader.exec_module(mod)
+            for attr in dir(mod):
+                obj = getattr(mod, attr)
+                if (isinstance(obj, type) and issubclass(obj, BaseModule)
+                        and obj is not BaseModule and obj.NAME != "unnamed_module"):
+                    self._registry[f"{category}/{obj.NAME}"] = obj
+                    break
+        except Exception as e:
+            self._errors.append(f"{path.name}: {e}")
+
+    def get(self, path: str) -> Optional[type[BaseModule]]:
+        if path in self._registry: return self._registry[path]
+        matches = [k for k in self._registry if k.split("/")[-1] == path]
+        if len(matches) == 1: return self._registry[matches[0]]
+        if len(matches) > 1: raise ValueError(f"Ambiguous: {path} → {matches}")
+        return None
+
+    def instantiate(self, path: str) -> Optional[BaseModule]:
+        cls = self.get(path)
+        return cls() if cls else None
+
+    def all_modules(self) -> dict[str, list[dict]]:
+        grouped = {c: [] for c in CATEGORY_ORDER}
+        for key, cls in self._registry.items():
+            cat = key.split("/")[0]
+            grouped.setdefault(cat, []).append({
+                "path": key, "name": cls.NAME, "description": cls.DESCRIPTION,
+                "severity": cls.SEVERITY, "author": cls.AUTHOR,
+                "version": cls.VERSION, "mitre": ", ".join(cls.MITRE),
+            })
+        return {k: v for k, v in grouped.items() if v}
+
+    def list_names(self) -> list[str]: return sorted(self._registry.keys())
+    def count(self) -> int:            return len(self._registry)
+    def load_errors(self) -> list[str]: return self._errors
+
+
+loader = ModuleLoader()

core/risk_engine.py

@@ -0,0 +1,47 @@
+"""ExploitGraph - CVSS-style risk scoring engine."""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from core.session_manager import Session
+
+SEVERITY_BASE  = {"CRITICAL":9.0,"HIGH":7.0,"MEDIUM":5.0,"LOW":3.0,"INFO":1.0}
+CLASSIFICATION = [(9.0,"CRITICAL"),(7.0,"HIGH"),(4.0,"MEDIUM"),(1.0,"LOW"),(0.0,"INFO")]
+
+
+class RiskEngine:
+    def score_finding(self, f: dict) -> tuple[float, str]:
+        if f.get("cvss_score", 0) > 0:
+            raw = float(f["cvss_score"])
+        else:
+            raw = SEVERITY_BASE.get(f.get("severity","INFO"), 1.0)
+        score = round(min(raw, 10.0), 1)
+        return score, self._classify(score)
+
+    def session_score(self, session: "Session") -> tuple[float, str]:
+        if not session.findings: return 0.0, "INFO"
+        scores = sorted([self.score_finding(f)[0] for f in session.findings], reverse=True)
+        if len(scores) == 1:
+            agg = scores[0]
+        else:
+            chain_bonus = min(len(session.graph_edges) * 0.2, 1.5)
+            agg = min((scores[0]*0.5 + sum(scores[1:])/len(scores[1:])*0.5) + chain_bonus, 10.0)
+        score = round(agg, 1)
+        return score, self._classify(score)
+
+    def score_breakdown(self, session: "Session") -> dict:
+        score, label = self.session_score(session)
+        sev = {k: 0 for k in ("CRITICAL","HIGH","MEDIUM","LOW","INFO")}
+        for f in session.findings:
+            s = f.get("severity","INFO")
+            sev[s] = sev.get(s, 0) + 1
+        return dict(session_score=score, classification=label, severity_counts=sev,
+                    total_findings=len(session.findings), secrets_found=len(session.secrets),
+                    graph_nodes=len(session.graph_nodes), graph_edges=len(session.graph_edges))
+
+    def _classify(self, score: float) -> str:
+        for threshold, label in CLASSIFICATION:
+            if score >= threshold: return label
+        return "INFO"
+
+
+risk_engine = RiskEngine()