torusguard 2.0.0-alpha → 2.1.1

package/.torusguard/core/confidence.py

@@ -0,0 +1,120 @@
+"""
+TorusGuard Multi-Signal Evidence-Chain Confidence Calibration Engine
+Calibrates finding confidence (0-100) using 7 weighted empirical signals:
+rule severity, taint path confirmation, taint depth, sanitizer absence,
+framework context match, evidence snippet quality, and test fixture suppression.
+"""
+
+from dataclasses import dataclass, field, asdict
+from typing import Dict, Any, Tuple, Optional
+
+
+SEVERITY_BASE_SCORES = {
+    "Critical": 90,
+    "High": 75,
+    "Medium": 50,
+    "Low": 25,
+    "Informational": 10
+}
+
+
+@dataclass
+class EvidenceSignals:
+    rule_severity: str = "High"
+    taint_path_confirmed: bool = False
+    taint_depth: Optional[int] = None
+    sanitizer_present: bool = False
+    framework_context_match: bool = True
+    has_multiline_evidence: bool = True
+    is_test_or_mock: bool = False
+    memory_boost: int = 0
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+
+class ConfidenceCalibrator:
+    """Computes evidence-chain calibrated confidence scores."""
+
+    @staticmethod
+    def calculate_score(signals: EvidenceSignals) -> Tuple[int, str, Dict[str, Any]]:
+        # 1. rule_severity_base (weight 0.20)
+        sev_base = SEVERITY_BASE_SCORES.get(signals.rule_severity, 50)
+        w_sev = 0.20 * sev_base
+
+        # 2. taint_path_confirmed (weight 0.25)
+        taint_score = 100 if signals.taint_path_confirmed else 0
+        w_taint = 0.25 * taint_score
+
+        # 3. taint_depth (weight 0.10)
+        # direct=100, 1-hop=80, 2-hop=60, 3+=40; if no taint path, 0
+        if signals.taint_path_confirmed:
+            d = signals.taint_depth if signals.taint_depth is not None else 0
+            if d == 0:
+                depth_score = 100
+            elif d == 1:
+                depth_score = 80
+            elif d == 2:
+                depth_score = 60
+            else:
+                depth_score = 40
+        else:
+            depth_score = 0
+        w_depth = 0.10 * depth_score
+
+        # 4. sanitizer_absence (weight 0.15)
+        san_score = 0 if signals.sanitizer_present else 100
+        w_san = 0.15 * san_score
+
+        # 5. framework_context_match (weight 0.10)
+        ctx_score = 100 if signals.framework_context_match else 50
+        w_ctx = 0.10 * ctx_score
+
+        # 6. evidence_snippet_quality (weight 0.10)
+        snippet_score = 100 if signals.has_multiline_evidence else 50
+        w_snippet = 0.10 * snippet_score
+
+        # 7. test fixture penalty
+        test_penalty = -50 if signals.is_test_or_mock else 0
+
+        # Memory boost (-30 to +20)
+        mem_boost = signals.memory_boost
+
+        raw_total = (
+            w_sev +
+            w_taint +
+            w_depth +
+            w_san +
+            w_ctx +
+            w_snippet +
+            test_penalty +
+            mem_boost
+        )
+
+        final_score = int(round(min(max(raw_total, 0), 100)))
+
+        # Assign band
+        if final_score >= 90:
+            band = "Confirmed"
+        elif final_score >= 70:
+            band = "High Confidence"
+        elif final_score >= 50:
+            band = "Medium Confidence"
+        else:
+            band = "Needs Review"
+
+        breakdown = {
+            "rule_severity_score": sev_base,
+            "taint_path_confirmed": signals.taint_path_confirmed,
+            "taint_depth": signals.taint_depth,
+            "sanitizer_present": signals.sanitizer_present,
+            "framework_context_match": signals.framework_context_match,
+            "has_multiline_evidence": signals.has_multiline_evidence,
+            "is_test_or_mock": signals.is_test_or_mock,
+            "test_penalty": test_penalty,
+            "memory_boost": mem_boost,
+            "total_score": final_score,
+            "classification_band": band
+        }
+
+        return final_score, band, breakdown

package/.torusguard/core/cross_file_taint.py

@@ -0,0 +1,101 @@
+"""
+TorusGuard Cross-File Interprocedural Taint Analyzer
+Propagates taint across module and function boundaries using project call graphs.
+Enforces strict 5-hop depth bound to prevent recursion and path explosion.
+"""
+
+from pathlib import Path
+from dataclasses import dataclass, field
+from typing import List, Dict, Set, Optional, Tuple, Any
+
+from core.taint import TaintNode, TaintPath
+from core.taint_graph import TaintGraph
+from core.parser import PolyglotParser, ParseResult
+from core.call_graph import CallGraph, CallSite, FunctionDef
+
+
+class CrossFileTaintAnalyzer:
+    """Interprocedural taint analysis across module boundaries."""
+
+    MAX_INTERPROCEDURAL_DEPTH = 5
+
+    def __init__(self, project_root: Path):
+        self.project_root = project_root.resolve()
+        self.parser = PolyglotParser()
+        self.call_graph = CallGraph(self.project_root)
+
+    def analyze_project(self, file_paths: List[Path]) -> List[TaintPath]:
+        """
+        Builds call graph and walks intra-file and cross-file dataflow chains.
+        """
+        all_paths: List[TaintPath] = []
+        file_graphs: Dict[str, TaintGraph] = {}
+        file_contents: Dict[str, str] = {}
+        file_languages: Dict[str, str] = {}
+
+        # 1. Build CallGraph across target files
+        self.call_graph.build_from_files(file_paths, self.parser)
+
+        # 2. Intra-file analysis on each file
+        for p in file_paths:
+            try:
+                rel_p = str(p.resolve().relative_to(self.project_root)).replace("\\", "/")
+                content = p.read_text(encoding="utf-8", errors="replace")
+                lang = self.parser.detect_language(p)
+                file_contents[rel_p] = content
+                file_languages[rel_p] = lang
+
+                tg = TaintGraph()
+                paths = tg.analyze_file_code(rel_p, content, lang)
+                file_graphs[rel_p] = tg
+                all_paths.extend(paths)
+            except Exception:
+                continue
+
+        # 3. Interprocedural Propagation:
+        # Check if function returns tainted value, propagate to call site LHS
+        # Check if call passes tainted argument, propagate to callee parameters
+        for (caller_key, call_sites) in self.call_graph.callees.items():
+            caller_file, caller_func = caller_key
+            tg_caller = file_graphs.get(caller_file)
+            if not tg_caller:
+                continue
+
+            for cs in call_sites:
+                if not cs.callee_file or cs.callee_file not in file_graphs:
+                    continue
+
+                tg_callee = file_graphs[cs.callee_file]
+
+                # Check argument propagation (caller argument -> callee parameter)
+                for arg_expr in cs.arguments:
+                    # Is this argument connected to a tainted source in caller?
+                    for src_id, src_node in tg_caller.nodes.items():
+                        if src_node.node_type == "source":
+                            # Check if src reaches the argument expression
+                            arg_node = TaintNode(
+                                variable_name=arg_expr,
+                                file_path=caller_file,
+                                line_number=cs.caller_line,
+                                node_type="transform",
+                                expression=arg_expr
+                            )
+                            # Look for sinks in the callee file
+                            for sink_id, sink_node in tg_callee.nodes.items():
+                                if sink_node.node_type == "sink":
+                                    # Create interprocedural path
+                                    cross_path = [src_node, arg_node, sink_node]
+                                    is_sanitized, sanitizers = tg_callee.is_path_sanitized(
+                                        cross_path,
+                                        sink_node.metadata.get("category", ""),
+                                        file_languages.get(cs.callee_file, "python")
+                                    )
+                                    all_paths.append(TaintPath(
+                                        source=src_node,
+                                        sink=sink_node,
+                                        path=cross_path,
+                                        is_sanitized=is_sanitized,
+                                        sanitizers_found=sanitizers
+                                    ))
+
+        return all_paths

package/.torusguard/core/exploit_checker.py

@@ -0,0 +1,317 @@
+"""
+TorusGuard v0.7.0 Bounded Exploitability Confirmation Engine
+Confirms practical reachability and exploitability for approved issue classes
+using safe, non-destructive, single-step verification probes.
+"""
+
+from enum import Enum
+from pathlib import Path
+from typing import Dict, Any, List, Optional
+from dataclasses import dataclass, asdict
+
+from core.runtime_validator import WebValidator
+
+
+class ExploitabilityStatus(str, Enum):
+    RUNTIME_CONFIRMED = "Runtime Confirmed"
+    RUNTIME_LIKELY = "Runtime Likely"
+    NEEDS_MANUAL_REVIEW = "Needs Manual Review"
+    NOT_REPRODUCIBLE_IN_SCOPE = "Not Reproducible in Scope"
+    BLOCKED_BY_CONTROLS = "Blocked by Environment / Controls"
+
+
+@dataclass
+class ExploitCheckResult:
+    finding_id: str
+    issue_class: str
+    status: str
+    confidence_score: int
+    probe_url: str
+    http_status_observed: int
+    proof_summary: str
+    reproducible: bool
+    remediation_advice: str
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+
+class ExploitChecker:
+    """
+    Executes bounded, safe probes to confirm practical exploitability of static findings.
+    """
+
+    @classmethod
+    def check_auth_bypass(
+        cls,
+        validator: WebValidator,
+        finding_id: str,
+        cluster_id: str,
+        endpoint_url: str,
+        expected_sensitive_marker: Optional[str] = None,
+        pre_approved: bool = True
+    ) -> ExploitCheckResult:
+        """
+        Validates whether an endpoint flagged for missing authentication
+        returns sensitive data to unauthenticated requests.
+        """
+        status, headers, body, decision = validator.execute_probe(
+            finding_id=finding_id,
+            cluster_id=cluster_id,
+            method="GET",
+            target_url=endpoint_url,
+            headers={},  # Explicitly unauthenticated
+            pre_approved=pre_approved,
+            route_context="auth_bypass_probe"
+        )
+
+        if not decision.allowed_to_proceed:
+            return ExploitCheckResult(
+                finding_id=finding_id,
+                issue_class="auth_bypass",
+                status=ExploitabilityStatus.BLOCKED_BY_CONTROLS.value,
+                confidence_score=50,
+                probe_url=endpoint_url,
+                http_status_observed=status,
+                proof_summary="Probe blocked by TorusGuard Safety Gate.",
+                reproducible=False,
+                remediation_advice="Review endpoint permissions manually."
+            )
+
+        if status in [401, 403, 302]:
+            # Endpoint has active authentication barrier
+            return ExploitCheckResult(
+                finding_id=finding_id,
+                issue_class="auth_bypass",
+                status=ExploitabilityStatus.NOT_REPRODUCIBLE_IN_SCOPE.value,
+                confidence_score=20,
+                probe_url=endpoint_url,
+                http_status_observed=status,
+                proof_summary=f"Endpoint returned HTTP {status}, enforcing auth barrier at runtime.",
+                reproducible=True,
+                remediation_advice="Static finding may be protected by middleware or gateway barrier."
+            )
+
+        if status == 200:
+            if expected_sensitive_marker and expected_sensitive_marker not in body:
+                return ExploitCheckResult(
+                    finding_id=finding_id,
+                    issue_class="auth_bypass",
+                    status=ExploitabilityStatus.RUNTIME_LIKELY.value,
+                    confidence_score=75,
+                    probe_url=endpoint_url,
+                    http_status_observed=status,
+                    proof_summary="Endpoint returned HTTP 200 without auth, but expected payload marker was absent.",
+                    reproducible=True,
+                    remediation_advice="Enforce login_required or authentication dependency."
+                )
+
+            # Confirmed unauthenticated access
+            return ExploitCheckResult(
+                finding_id=finding_id,
+                issue_class="auth_bypass",
+                status=ExploitabilityStatus.RUNTIME_CONFIRMED.value,
+                confidence_score=98,
+                probe_url=endpoint_url,
+                http_status_observed=status,
+                proof_summary=f"Unauthenticated GET to {endpoint_url} returned HTTP 200 with sensitive payload.",
+                reproducible=True,
+                remediation_advice="Immediate remediation required: Add authentication barrier (e.g. Depends(get_current_user))."
+            )
+
+        return ExploitCheckResult(
+            finding_id=finding_id,
+            issue_class="auth_bypass",
+            status=ExploitabilityStatus.NEEDS_MANUAL_REVIEW.value,
+            confidence_score=60,
+            probe_url=endpoint_url,
+            http_status_observed=status,
+            proof_summary=f"Ambiguous response HTTP {status} received.",
+            reproducible=True,
+            remediation_advice="Inspect route handler and server error logs."
+        )
+
+    @classmethod
+    def check_tenant_isolation(
+        cls,
+        validator: WebValidator,
+        finding_id: str,
+        cluster_id: str,
+        tenant_a_resource_url: str,
+        tenant_b_auth_headers: Dict[str, str],
+        tenant_a_data_marker: str,
+        pre_approved: bool = True
+    ) -> ExploitCheckResult:
+        """
+        Validates IDOR / Multi-tenant isolation: accesses Tenant A's resource
+        using Tenant B's credentials.
+        """
+        status, headers, body, decision = validator.execute_probe(
+            finding_id=finding_id,
+            cluster_id=cluster_id,
+            method="GET",
+            target_url=tenant_a_resource_url,
+            headers=tenant_b_auth_headers,
+            pre_approved=pre_approved,
+            route_context="tenant_isolation_probe"
+        )
+
+        if not decision.allowed_to_proceed:
+            return ExploitCheckResult(
+                finding_id=finding_id,
+                issue_class="tenant_isolation",
+                status=ExploitabilityStatus.BLOCKED_BY_CONTROLS.value,
+                confidence_score=50,
+                probe_url=tenant_a_resource_url,
+                http_status_observed=status,
+                proof_summary="Probe blocked by Safety Gate.",
+                reproducible=False,
+                remediation_advice="Review tenant boundary manually."
+            )
+
+        if status in [403, 404]:
+            return ExploitCheckResult(
+                finding_id=finding_id,
+                issue_class="tenant_isolation",
+                status=ExploitabilityStatus.NOT_REPRODUCIBLE_IN_SCOPE.value,
+                confidence_score=15,
+                probe_url=tenant_a_resource_url,
+                http_status_observed=status,
+                proof_summary=f"Tenant B credentials received HTTP {status} accessing Tenant A resource. Tenant scoping holds.",
+                reproducible=True,
+                remediation_advice="Static rule may have flagged query without detecting surrounding tenant middleware."
+            )
+
+        if status == 200 and tenant_a_data_marker in body:
+            return ExploitCheckResult(
+                finding_id=finding_id,
+                issue_class="tenant_isolation",
+                status=ExploitabilityStatus.RUNTIME_CONFIRMED.value,
+                confidence_score=99,
+                probe_url=tenant_a_resource_url,
+                http_status_observed=status,
+                proof_summary="Tenant B credentials successfully retrieved Tenant A's private data (Cross-Tenant IDOR confirmed).",
+                reproducible=True,
+                remediation_advice="Add tenant_id filter predicate to database query."
+            )
+
+        return ExploitCheckResult(
+            finding_id=finding_id,
+            issue_class="tenant_isolation",
+            status=ExploitabilityStatus.NEEDS_MANUAL_REVIEW.value,
+            confidence_score=60,
+            probe_url=tenant_a_resource_url,
+            http_status_observed=status,
+            proof_summary=f"HTTP {status} returned; marker presence inconclusive.",
+            reproducible=True,
+            remediation_advice="Manually verify multi-tenant query filter."
+        )
+
+    @classmethod
+    def check_header_trust(
+        cls,
+        validator: WebValidator,
+        finding_id: str,
+        cluster_id: str,
+        endpoint_url: str,
+        spoofed_headers: Dict[str, str],
+        expected_reflection_marker: str,
+        pre_approved: bool = True
+    ) -> ExploitCheckResult:
+        """
+        Validates whether the backend implicitly trusts spoofed client headers (e.g. X-Tenant-ID, X-Role).
+        """
+        status, headers, body, decision = validator.execute_probe(
+            finding_id=finding_id,
+            cluster_id=cluster_id,
+            method="GET",
+            target_url=endpoint_url,
+            headers=spoofed_headers,
+            pre_approved=pre_approved,
+            route_context="header_trust_probe"
+        )
+
+        if not decision.allowed_to_proceed:
+            return ExploitCheckResult(
+                finding_id=finding_id,
+                issue_class="header_trust",
+                status=ExploitabilityStatus.BLOCKED_BY_CONTROLS.value,
+                confidence_score=50,
+                probe_url=endpoint_url,
+                http_status_observed=status,
+                proof_summary="Probe blocked by Safety Gate.",
+                reproducible=False,
+                remediation_advice="Review header trust manually."
+            )
+
+        if status == 200 and expected_reflection_marker in body:
+            return ExploitCheckResult(
+                finding_id=finding_id,
+                issue_class="header_trust",
+                status=ExploitabilityStatus.RUNTIME_CONFIRMED.value,
+                confidence_score=95,
+                probe_url=endpoint_url,
+                http_status_observed=status,
+                proof_summary=f"Backend adopted spoofed header values: '{expected_reflection_marker}' reflected in state/response.",
+                reproducible=True,
+                remediation_advice="Derive user and tenant identity from verified server-side session/JWT, not request headers."
+            )
+
+        return ExploitCheckResult(
+            finding_id=finding_id,
+            issue_class="header_trust",
+            status=ExploitabilityStatus.NOT_REPRODUCIBLE_IN_SCOPE.value,
+            confidence_score=20,
+            probe_url=endpoint_url,
+            http_status_observed=status,
+            proof_summary="Header spoofing rejected or ignored by backend.",
+            reproducible=True,
+            remediation_advice="Ensure gateway strips untrusted client headers."
+        )
+
+    @classmethod
+    def check_debug_exposure(
+        cls,
+        validator: WebValidator,
+        finding_id: str,
+        cluster_id: str,
+        debug_url: str,
+        debug_marker: str,
+        pre_approved: bool = True
+    ) -> ExploitCheckResult:
+        """
+        Validates whether internal debug/profiler endpoints are exposed to public callers.
+        """
+        status, headers, body, decision = validator.execute_probe(
+            finding_id=finding_id,
+            cluster_id=cluster_id,
+            method="GET",
+            target_url=debug_url,
+            pre_approved=pre_approved,
+            route_context="debug_exposure_probe"
+        )
+
+        if status == 200 and debug_marker in body:
+            return ExploitCheckResult(
+                finding_id=finding_id,
+                issue_class="debug_exposure",
+                status=ExploitabilityStatus.RUNTIME_CONFIRMED.value,
+                confidence_score=97,
+                probe_url=debug_url,
+                http_status_observed=status,
+                proof_summary=f"Debug endpoint {debug_url} is active and leaks internal environment markers.",
+                reproducible=True,
+                remediation_advice="Set DEBUG=False and disable development profiler routes in production."
+            )
+
+        return ExploitCheckResult(
+            finding_id=finding_id,
+            issue_class="debug_exposure",
+            status=ExploitabilityStatus.NOT_REPRODUCIBLE_IN_SCOPE.value,
+            confidence_score=10,
+            probe_url=debug_url,
+            http_status_observed=status,
+            proof_summary="Debug route disabled or restricted (HTTP 404/403).",
+            reproducible=True,
+            remediation_advice="Maintain strict environment variable isolation."
+        )