oscura 0.8.0__py3-none-any.whl → 0.11.0__py3-none-any.whl

oscura/hardware/security/side_channel_detector.py

@@ -1,14 +1,10 @@
 """Side-Channel Attack Detection and Vulnerability Assessment.
 
 This module implements comprehensive side-channel vulnerability detection for
-cryptographic implementations including timing attacks, power analysis, EM
-emissions, and cache timing vulnerabilities.
+cryptographic implementations including timing attacks and constant-time validation.
 
 Key capabilities:
 - Timing-based leakage detection (variable-time operations)
-- Power analysis vulnerability detection (data-dependent consumption)
-- EM emission analysis for information leakage
-- Cache timing attack detection
 - Constant-time operation validation
 - T-test for leakage detection (Welch's t-test)
 - Mutual information calculation
@@ -18,35 +14,25 @@ Typical use cases:
 - Evaluate cryptographic implementation security
 - Detect non-constant-time operations
 - Identify data-dependent branching
-- Assess power consumption leakage
 - Generate vulnerability reports for security audits
 
 Example:
     >>> from oscura.hardware.security.side_channel_detector import SideChannelDetector
-    >>> from oscura.side_channel.dpa import PowerTrace
     >>> import numpy as np
     >>> # Create detector
     >>> detector = SideChannelDetector(
     ...     timing_threshold=0.01,
-    ...     power_threshold=0.7,
     ...     ttest_threshold=4.5
     ... )
-    >>> # Analyze power traces
-    >>> traces = [
-    ...     PowerTrace(
-    ...         timestamp=np.arange(1000),
-    ...         power=np.random.randn(1000),
-    ...         plaintext=bytes([i % 256 for i in range(16)])
-    ...     )
-    ...     for _ in range(100)
-    ... ]
-    >>> report = detector.analyze_power_traces(traces, fixed_key=bytes(16))
-    >>> print(f"Found {len(report.vulnerabilities)} vulnerabilities")
     >>> # Check for timing vulnerabilities
     >>> timing_data = [(bytes([i]), 0.001 + i*1e-6) for i in range(256)]
     >>> result = detector.detect_timing_leakage(timing_data)
     >>> if result.severity != "low":
     ...     print(f"Timing vulnerability: {result.evidence}")
+
+Note:
+    For actual power analysis attacks (DPA/CPA), use ChipWhisperer:
+    https://chipwhisperer.com/
 """
 
 from __future__ import annotations
@@ -66,8 +52,6 @@ if TYPE_CHECKING:
 
     from numpy.typing import NDArray
 
-    from oscura.side_channel.dpa import PowerTrace
-
 logger = logging.getLogger(__name__)
 
 
@@ -75,8 +59,6 @@ class VulnerabilityType(str, Enum):
     """Type of side-channel vulnerability detected."""
 
     TIMING = "timing"  # Timing-based leakage
-    POWER = "power"  # Power consumption leakage
-    EM = "electromagnetic"  # EM emission leakage
     CACHE = "cache"  # Cache timing leakage
     CONSTANT_TIME = "constant_time"  # Non-constant-time operations
 
@@ -187,8 +169,6 @@ class SideChannelDetector:
     def __init__(
         self,
         timing_threshold: float = 0.01,
-        power_threshold: float = 0.7,
-        em_threshold: float = 0.6,
         cache_threshold: float = 0.05,
         ttest_threshold: float = 4.5,
         mutual_info_threshold: float = 0.1,
@@ -197,8 +177,6 @@ class SideChannelDetector:
 
         Args:
             timing_threshold: Timing correlation threshold for vulnerability (0.0-1.0).
-            power_threshold: Power correlation threshold for vulnerability (0.0-1.0).
-            em_threshold: EM emission correlation threshold (0.0-1.0).
             cache_threshold: Cache timing threshold for vulnerability (0.0-1.0).
             ttest_threshold: T-test statistic threshold (typically 4.5 for p<0.00001).
             mutual_info_threshold: Mutual information threshold in bits (0.0-8.0).
@@ -211,8 +189,6 @@ class SideChannelDetector:
             ... )
         """
         self.timing_threshold = timing_threshold
-        self.power_threshold = power_threshold
-        self.em_threshold = em_threshold
         self.cache_threshold = cache_threshold
         self.ttest_threshold = ttest_threshold
         self.mutual_info_threshold = mutual_info_threshold
@@ -392,302 +368,6 @@ class SideChannelDetector:
         )
         return f"Timing analysis of '{operation_name}' shows {significance} input-dependent execution time"
 
-    def analyze_power_traces(
-        self,
-        traces: Sequence[PowerTrace],
-        fixed_key: bytes | None = None,
-        use_ttest: bool = True,
-    ) -> VulnerabilityReport:
-        """Analyze power traces for DPA/CPA vulnerabilities.
-
-        Performs comprehensive power analysis to detect data-dependent power
-        consumption patterns that could enable DPA or CPA attacks.
-
-        Analysis Methods:
-            1. Welch's t-test (TVLA) for first-order leakage
-            2. Correlation analysis between power and hypothetical values
-            3. Variance analysis across different inputs
-            4. Frequency-domain analysis for EM leakage
-
-        Args:
-            traces: List of power consumption traces with plaintexts.
-            fixed_key: Known key for hypothesis testing (optional).
-            use_ttest: Whether to perform t-test analysis.
-
-        Returns:
-            VulnerabilityReport with all detected power-related vulnerabilities.
-
-        Example:
-            >>> # Analyze AES implementation for DPA vulnerabilities
-            >>> traces = collect_power_traces(plaintexts, key)
-            >>> report = detector.analyze_power_traces(traces, fixed_key=key)
-            >>> critical = [v for v in report.vulnerabilities
-            ...             if v.severity == Severity.CRITICAL]
-            >>> print(f"Critical vulnerabilities: {len(critical)}")
-        """
-        if not traces:
-            return VulnerabilityReport(
-                vulnerabilities=[],
-                summary_statistics={"error": "No traces provided"},
-            )
-
-        power_matrix = np.array([t.power for t in traces])
-        num_traces, num_samples = power_matrix.shape
-
-        vulnerabilities = self._collect_power_vulnerabilities(
-            traces, power_matrix, use_ttest, fixed_key
-        )
-        summary_stats = self._build_summary_statistics(vulnerabilities, num_traces, num_samples)
-        recommendations = self._generate_recommendations(vulnerabilities)
-
-        return VulnerabilityReport(
-            vulnerabilities=vulnerabilities,
-            summary_statistics=summary_stats,
-            analysis_config={
-                "power_threshold": self.power_threshold,
-                "ttest_threshold": self.ttest_threshold,
-                "use_ttest": use_ttest,
-            },
-            recommendations=recommendations,
-        )
-
-    def _collect_power_vulnerabilities(
-        self,
-        traces: Sequence[PowerTrace],
-        power_matrix: np.ndarray[Any, Any],
-        use_ttest: bool,
-        fixed_key: bytes | None,
-    ) -> list[SideChannelVulnerability]:
-        """Collect all power-related vulnerabilities from traces.
-
-        Args:
-            traces: Power consumption traces.
-            power_matrix: 2D array of power measurements.
-            use_ttest: Whether to perform t-test analysis.
-            fixed_key: Known key for CPA analysis.
-
-        Returns:
-            List of detected vulnerabilities.
-        """
-        vulnerabilities: list[SideChannelVulnerability] = []
-
-        # T-test analysis
-        if use_ttest and len(traces) >= 10:
-            ttest_vuln = self._analyze_ttest_leakage(traces, power_matrix)
-            if ttest_vuln is not None:
-                vulnerabilities.append(ttest_vuln)
-
-        # Correlation analysis
-        if fixed_key is not None and len(traces) >= 10:
-            cpa_vuln = self._analyze_cpa_vulnerability(traces, fixed_key)
-            if cpa_vuln is not None:
-                vulnerabilities.append(cpa_vuln)
-
-        # EM leakage analysis
-        em_vuln = self._analyze_em_leakage(power_matrix)
-        if em_vuln.severity != Severity.LOW:
-            vulnerabilities.append(em_vuln)
-
-        # Variance analysis
-        variance_vuln = self._analyze_power_variance(traces)
-        if variance_vuln.severity != Severity.LOW:
-            vulnerabilities.append(variance_vuln)
-
-        return vulnerabilities
-
-    def _analyze_ttest_leakage(
-        self, traces: Sequence[PowerTrace], power_matrix: np.ndarray[Any, Any]
-    ) -> SideChannelVulnerability | None:
-        """Analyze power traces using Welch's t-test for leakage.
-
-        Args:
-            traces: Power consumption traces.
-            power_matrix: 2D array of power measurements.
-
-        Returns:
-            Vulnerability if leakage detected, None otherwise.
-        """
-        t_stats = self._perform_ttest_leakage(traces)
-        if t_stats is None:
-            return None
-
-        num_samples = power_matrix.shape[1]
-        max_t_stat = float(np.max(np.abs(t_stats)))
-        leakage_points = int(np.sum(np.abs(t_stats) > self.ttest_threshold))
-
-        if max_t_stat <= self.ttest_threshold:
-            return None
-
-        severity = self._assess_ttest_severity(max_t_stat)
-        confidence = min(1.0, len(traces) / 100.0)
-
-        return SideChannelVulnerability(
-            vulnerability_type=VulnerabilityType.POWER,
-            severity=severity,
-            confidence=confidence,
-            evidence=(
-                f"Max T-statistic: {max_t_stat:.2f}, Leakage points: {leakage_points}/{num_samples}"
-            ),
-            description="Welch's t-test reveals significant first-order power leakage",
-            mitigation_suggestions=[
-                "Implement power-balanced logic gates",
-                "Add random noise to power consumption",
-                "Use masking or hiding countermeasures",
-                "Employ dual-rail precharge logic (DPL)",
-            ],
-            metadata={
-                "max_t_statistic": max_t_stat,
-                "leakage_points": leakage_points,
-                "threshold": self.ttest_threshold,
-            },
-        )
-
-    def _assess_ttest_severity(self, max_t_stat: float) -> Severity:
-        """Assess severity based on t-test statistic magnitude.
-
-        Args:
-            max_t_stat: Maximum t-statistic value.
-
-        Returns:
-            Severity level.
-        """
-        if max_t_stat > 20.0:
-            return Severity.CRITICAL
-        if max_t_stat > 10.0:
-            return Severity.HIGH
-        if max_t_stat > self.ttest_threshold:
-            return Severity.MEDIUM
-        return Severity.LOW
-
-    def _analyze_cpa_vulnerability(
-        self, traces: Sequence[PowerTrace], fixed_key: bytes
-    ) -> SideChannelVulnerability | None:
-        """Analyze CPA vulnerability using correlation analysis.
-
-        Args:
-            traces: Power consumption traces.
-            fixed_key: Known encryption key.
-
-        Returns:
-            Vulnerability if CPA attack successful, None otherwise.
-        """
-        from oscura.side_channel.dpa import DPAAnalyzer
-
-        analyzer = DPAAnalyzer(attack_type="cpa", leakage_model="hamming_weight")
-
-        try:
-            result = analyzer.cpa_attack(list(traces), target_byte=0)
-            if result.correlation_traces is None:
-                return None
-
-            max_correlation = float(np.max(result.correlation_traces))
-            if max_correlation <= self.power_threshold:
-                return None
-
-            severity = self._assess_correlation_severity(max_correlation)
-
-            return SideChannelVulnerability(
-                vulnerability_type=VulnerabilityType.POWER,
-                severity=severity,
-                confidence=result.confidence,
-                evidence=(
-                    f"Max correlation: {max_correlation:.4f}, "
-                    f"Attack confidence: {result.confidence:.2%}"
-                ),
-                description=(
-                    "CPA attack successful - power consumption correlates with Hamming weight"
-                ),
-                mitigation_suggestions=[
-                    "Implement algorithmic masking (boolean/arithmetic)",
-                    "Use shuffling to randomize operation order",
-                    "Add random delays between operations",
-                    "Employ constant-power hardware primitives",
-                ],
-                metadata={
-                    "max_correlation": max_correlation,
-                    "recovered_key_byte": int(result.recovered_key[0]),
-                    "attack_successful": result.successful,
-                },
-            )
-        except Exception as e:
-            logger.warning(f"CPA analysis failed: {e}")
-            return None
-
-    def _assess_correlation_severity(self, max_correlation: float) -> Severity:
-        """Assess severity based on correlation magnitude.
-
-        Args:
-            max_correlation: Maximum correlation value.
-
-        Returns:
-            Severity level.
-        """
-        if max_correlation > 0.95:
-            return Severity.CRITICAL
-        if max_correlation > 0.85:
-            return Severity.HIGH
-        if max_correlation > self.power_threshold:
-            return Severity.MEDIUM
-        return Severity.LOW
-
-    def _build_summary_statistics(
-        self,
-        vulnerabilities: list[SideChannelVulnerability],
-        num_traces: int,
-        num_samples: int,
-    ) -> dict[str, Any]:
-        """Build summary statistics from detected vulnerabilities.
-
-        Args:
-            vulnerabilities: List of detected vulnerabilities.
-            num_traces: Number of power traces analyzed.
-            num_samples: Number of samples per trace.
-
-        Returns:
-            Dictionary of summary statistics.
-        """
-        return {
-            "total_vulnerabilities": len(vulnerabilities),
-            "critical_count": sum(1 for v in vulnerabilities if v.severity == Severity.CRITICAL),
-            "high_count": sum(1 for v in vulnerabilities if v.severity == Severity.HIGH),
-            "medium_count": sum(1 for v in vulnerabilities if v.severity == Severity.MEDIUM),
-            "low_count": sum(1 for v in vulnerabilities if v.severity == Severity.LOW),
-            "num_traces": num_traces,
-            "num_samples": num_samples,
-        }
-
-    def _generate_recommendations(
-        self, vulnerabilities: list[SideChannelVulnerability]
-    ) -> list[str]:
-        """Generate security recommendations based on vulnerabilities.
-
-        Args:
-            vulnerabilities: List of detected vulnerabilities.
-
-        Returns:
-            List of recommendation strings.
-        """
-        recommendations = []
-
-        if any(v.severity == Severity.CRITICAL for v in vulnerabilities):
-            recommendations.append(
-                "CRITICAL: Immediate countermeasures required - implementation is highly "
-                "vulnerable to power analysis attacks"
-            )
-        if any(v.vulnerability_type == VulnerabilityType.POWER for v in vulnerabilities):
-            recommendations.append(
-                "Consider hardware countermeasures (noise generation, power filtering)"
-            )
-        if any(v.vulnerability_type == VulnerabilityType.EM for v in vulnerabilities):
-            recommendations.append("Add EM shielding and filtering to reduce emissions")
-
-        if not vulnerabilities:
-            recommendations.append(
-                "No significant vulnerabilities detected with current thresholds"
-            )
-
-        return recommendations
-
     def detect_constant_time_violation(
         self,
         timing_measurements: Sequence[tuple[Any, float]],
@@ -941,186 +621,3 @@ class SideChannelDetector:
             f.write("\n".join(html_content))
 
         logger.info(f"HTML report exported to {output_path}")
-
-    def _perform_ttest_leakage(
-        self,
-        traces: Sequence[PowerTrace],
-    ) -> NDArray[np.float64] | None:
-        """Perform Welch's t-test for leakage detection (TVLA).
-
-        Args:
-            traces: Power traces with plaintexts.
-
-        Returns:
-            T-statistics for each sample point, or None if insufficient data.
-        """
-        if len(traces) < 10:
-            return None
-
-        # Partition traces by first plaintext byte (odd vs even)
-        group0_traces = []
-        group1_traces = []
-
-        for trace in traces:
-            if trace.plaintext is None or len(trace.plaintext) == 0:
-                continue
-
-            if trace.plaintext[0] % 2 == 0:
-                group0_traces.append(trace.power)
-            else:
-                group1_traces.append(trace.power)
-
-        if len(group0_traces) < 5 or len(group1_traces) < 5:
-            return None
-
-        power0 = np.array(group0_traces)
-        power1 = np.array(group1_traces)
-
-        # Perform Welch's t-test at each time point
-        t_stats = np.zeros(power0.shape[1])
-
-        for i in range(power0.shape[1]):
-            t_stat, _ = stats.ttest_ind(power0[:, i], power1[:, i], equal_var=False)
-            t_stats[i] = abs(t_stat) if not np.isnan(t_stat) else 0.0
-
-        return t_stats
-
-    def _analyze_em_leakage(
-        self,
-        power_matrix: NDArray[np.float64],
-    ) -> SideChannelVulnerability:
-        """Analyze electromagnetic emission leakage via frequency domain.
-
-        Args:
-            power_matrix: Power traces matrix (num_traces x num_samples).
-
-        Returns:
-            SideChannelVulnerability for EM analysis.
-        """
-        # Compute FFT for each trace
-        fft_traces = np.fft.rfft(power_matrix, axis=1)
-        magnitude_spectrum = np.abs(fft_traces)
-
-        # Calculate variance across traces at each frequency
-        freq_variance = np.var(magnitude_spectrum, axis=0)
-        max_variance = float(np.max(freq_variance))
-        mean_variance = float(np.mean(freq_variance))
-
-        # Normalize by mean to get relative peaks
-        if mean_variance > 0:
-            peak_ratio = max_variance / mean_variance
-        else:
-            peak_ratio = 0.0
-
-        # Assess EM leakage
-        if peak_ratio > 10.0:
-            severity = Severity.HIGH
-        elif peak_ratio > 5.0:
-            severity = Severity.MEDIUM
-        elif peak_ratio > 3.0:
-            severity = Severity.LOW
-        else:
-            severity = Severity.LOW
-
-        confidence = min(1.0, power_matrix.shape[0] / 100.0)
-
-        return SideChannelVulnerability(
-            vulnerability_type=VulnerabilityType.EM,
-            severity=severity,
-            confidence=confidence,
-            evidence=f"Peak frequency variance ratio: {peak_ratio:.2f}",
-            description=(
-                "Frequency-domain analysis shows potential EM emission leakage"
-                if severity != Severity.LOW
-                else "No significant EM leakage detected"
-            ),
-            mitigation_suggestions=[
-                "Add EM shielding to device enclosure",
-                "Use frequency-domain filtering",
-                "Implement spread-spectrum techniques",
-            ]
-            if severity != Severity.LOW
-            else [],
-            metadata={
-                "peak_variance_ratio": float(peak_ratio),
-                "max_variance": max_variance,
-                "mean_variance": mean_variance,
-            },
-        )
-
-    def _analyze_power_variance(
-        self,
-        traces: Sequence[PowerTrace],
-    ) -> SideChannelVulnerability:
-        """Analyze power consumption variance across different inputs.
-
-        Args:
-            traces: Power traces with plaintexts.
-
-        Returns:
-            SideChannelVulnerability for variance analysis.
-        """
-        # Group traces by first plaintext byte
-        power_by_input: dict[int, list[NDArray[np.float64]]] = {}
-
-        for trace in traces:
-            if trace.plaintext is None or len(trace.plaintext) == 0:
-                continue
-
-            first_byte = trace.plaintext[0]
-            if first_byte not in power_by_input:
-                power_by_input[first_byte] = []
-            power_by_input[first_byte].append(trace.power)
-
-        if len(power_by_input) < 2:
-            return SideChannelVulnerability(
-                vulnerability_type=VulnerabilityType.POWER,
-                severity=Severity.LOW,
-                confidence=0.0,
-                evidence="Insufficient input variation",
-                description="Cannot assess variance - need multiple input values",
-            )
-
-        # Calculate mean power for each input
-        mean_powers = {}
-        for byte_val, powers in power_by_input.items():
-            power_array = np.array(powers)
-            mean_powers[byte_val] = np.mean(power_array, axis=0)
-
-        # Calculate variance across different inputs
-        mean_power_matrix = np.array(list(mean_powers.values()))
-        inter_input_variance = np.var(mean_power_matrix, axis=0)
-        max_variance = float(np.max(inter_input_variance))
-
-        # Assess severity
-        if max_variance > 0.1:
-            severity = Severity.MEDIUM
-        elif max_variance > 0.01:
-            severity = Severity.LOW
-        else:
-            severity = Severity.LOW
-
-        confidence = min(1.0, len(traces) / 100.0)
-
-        return SideChannelVulnerability(
-            vulnerability_type=VulnerabilityType.POWER,
-            severity=severity,
-            confidence=confidence,
-            evidence=f"Max power variance across inputs: {max_variance:.6f}",
-            description=(
-                "Power variance analysis shows data-dependent consumption"
-                if severity != Severity.LOW
-                else "Power variance across inputs is low"
-            ),
-            mitigation_suggestions=[
-                "Implement power balancing techniques",
-                "Use dual-rail encoding",
-                "Add noise injection",
-            ]
-            if severity != Severity.LOW
-            else [],
-            metadata={
-                "max_variance": max_variance,
-                "num_unique_inputs": len(power_by_input),
-            },
-        )