pybinaryguard 1.0.0__py3-none-any.whl

pybinaryguard/predictor/predictor.py

@@ -0,0 +1,144 @@
+"""Main predictor module for runtime failure prediction.
+
+Combines symbol resolution, dependency analysis, and linker simulation
+to predict ImportErrors before they happen.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import List, Optional
+
+from pybinaryguard.models.package import PackageBinaryInfo
+from pybinaryguard.models.system import SystemProfile
+from pybinaryguard.predictor.linker_simulator import LinkerSimulator
+
+
+@dataclass
+class PredictedFailure:
+    """A predicted runtime failure."""
+
+    package: str
+    module_path: str
+    error_type: str  # "ImportError", "SymbolError", "LibraryMissing"
+    error_message: str
+    missing_symbol: Optional[str] = None
+    missing_library: Optional[str] = None
+    confidence: float = 0.0
+
+
+def predict_import_failures(
+    package: PackageBinaryInfo,
+    profile: SystemProfile
+) -> List[PredictedFailure]:
+    """Predict import failures for a package.
+
+    Args:
+        package: Package binary information
+        profile: System profile
+
+    Returns:
+        List of predicted failures
+    """
+    failures: List[PredictedFailure] = []
+
+    # Get library paths from system
+    library_paths = profile.library_search_paths or None
+
+    simulator = LinkerSimulator(library_paths)
+
+    # Simulate loading each shared object
+    for so in package.shared_objects:
+        if not so.path:
+            continue
+
+        # Predict import error
+        error_msg = simulator.predict_import_error(so.path, f"{package.name}._C")
+
+        if error_msg:
+            # Parse error type
+            if "undefined symbol" in error_msg:
+                error_type = "SymbolError"
+                # Extract symbol name
+                if "undefined symbol:" in error_msg:
+                    parts = error_msg.split("undefined symbol:")
+                    if len(parts) > 1:
+                        missing_symbol = parts[1].strip()
+                    else:
+                        missing_symbol = "unknown"
+                else:
+                    missing_symbol = "unknown"
+
+                failures.append(
+                    PredictedFailure(
+                        package=package.name,
+                        module_path=so.path,
+                        error_type=error_type,
+                        error_message=error_msg,
+                        missing_symbol=missing_symbol,
+                        confidence=0.95,
+                    )
+                )
+
+            elif "cannot open shared object file" in error_msg:
+                error_type = "LibraryMissing"
+                # Extract library name
+                if "file:" in error_msg:
+                    parts = error_msg.split("file:")
+                    if len(parts) > 1:
+                        lib_part = parts[1].split(":")[0].strip()
+                        missing_library = lib_part
+                    else:
+                        missing_library = "unknown"
+                else:
+                    missing_library = "unknown"
+
+                failures.append(
+                    PredictedFailure(
+                        package=package.name,
+                        module_path=so.path,
+                        error_type=error_type,
+                        error_message=error_msg,
+                        missing_library=missing_library,
+                        confidence=0.9,
+                    )
+                )
+
+            else:
+                # Generic import error
+                failures.append(
+                    PredictedFailure(
+                        package=package.name,
+                        module_path=so.path,
+                        error_type="ImportError",
+                        error_message=error_msg,
+                        confidence=0.8,
+                    )
+                )
+
+    return failures
+
+
+def format_predicted_failure(failure: PredictedFailure) -> str:
+    """Format a predicted failure as a human-readable message.
+
+    Args:
+        failure: PredictedFailure to format
+
+    Returns:
+        Formatted message string
+    """
+    lines = [
+        f"Predicted {failure.error_type} in {failure.package}:",
+        f"  {failure.error_message}",
+    ]
+
+    if failure.missing_symbol:
+        lines.append(f"  Missing symbol: {failure.missing_symbol}")
+
+    if failure.missing_library:
+        lines.append(f"  Missing library: {failure.missing_library}")
+
+    lines.append(f"  Confidence: {failure.confidence * 100:.0f}%")
+
+    return "\n".join(lines)

pybinaryguard/predictor/resolver.py

@@ -0,0 +1,282 @@
+"""Symbol resolution for ELF binaries.
+
+Resolves undefined symbols against available shared libraries,
+simulating the behavior of the dynamic linker.
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, List, Optional, Set
+
+from pybinaryguard.analyzers.elf_analyzer import MinimalELFParser
+
+
+@dataclass
+class Symbol:
+    """Represents a symbol from an ELF binary."""
+
+    name: str
+    library: Optional[str] = None  # Which library provides this symbol
+    version: Optional[str] = None  # Symbol version (e.g., GLIBC_2.34)
+    weak: bool = False  # Whether this is a weak symbol
+    undefined: bool = False  # Whether this symbol needs to be resolved
+
+
+@dataclass
+class LibrarySymbols:
+    """Symbol table for a shared library."""
+
+    path: str
+    provided_symbols: Set[str] = field(default_factory=set)
+    required_symbols: Set[str] = field(default_factory=set)
+    versioned_symbols: Dict[str, str] = field(default_factory=dict)  # symbol -> version
+
+
+class SymbolResolver:
+    """Resolves symbols from ELF binaries against system libraries."""
+
+    def __init__(self, library_paths: Optional[List[str]] = None):
+        """Initialize the symbol resolver.
+
+        Args:
+            library_paths: List of directories to search for libraries.
+                          If None, uses standard system paths.
+        """
+        if library_paths is None:
+            library_paths = self._get_default_library_paths()
+
+        self.library_paths = library_paths
+        self._symbol_cache: Dict[str, LibrarySymbols] = {}
+
+    def _get_default_library_paths(self) -> List[str]:
+        """Get default library search paths."""
+        paths = [
+            "/lib",
+            "/lib64",
+            "/usr/lib",
+            "/usr/lib64",
+            "/usr/local/lib",
+            "/usr/local/lib64",
+        ]
+
+        # Add LD_LIBRARY_PATH if set
+        ld_lib_path = os.environ.get("LD_LIBRARY_PATH", "")
+        if ld_lib_path:
+            paths.extend(ld_lib_path.split(":"))
+
+        # Filter to existing directories
+        return [p for p in paths if os.path.isdir(p)]
+
+    def resolve_undefined_symbols(
+        self,
+        binary_path: str,
+        needed_libraries: List[str]
+    ) -> Dict[str, Optional[str]]:
+        """Resolve undefined symbols in a binary.
+
+        Args:
+            binary_path: Path to the ELF binary
+            needed_libraries: List of DT_NEEDED libraries (from ELF)
+
+        Returns:
+            Dictionary mapping symbol name to providing library (or None if unresolved)
+        """
+        # Get undefined symbols from the binary
+        undefined_symbols = self._extract_undefined_symbols(binary_path)
+
+        # Build symbol index from needed libraries
+        symbol_index: Dict[str, str] = {}
+        for lib_name in needed_libraries:
+            lib_path = self._find_library(lib_name)
+            if lib_path:
+                lib_symbols = self._get_library_symbols(lib_path)
+                for sym in lib_symbols.provided_symbols:
+                    if sym not in symbol_index:
+                        symbol_index[sym] = lib_name
+
+        # Resolve each undefined symbol
+        resolution: Dict[str, Optional[str]] = {}
+        for sym in undefined_symbols:
+            resolution[sym] = symbol_index.get(sym)
+
+        return resolution
+
+    def _extract_undefined_symbols(self, binary_path: str) -> Set[str]:
+        """Extract undefined symbols from an ELF binary.
+
+        Args:
+            binary_path: Path to the ELF binary
+
+        Returns:
+            Set of undefined symbol names
+        """
+        # This is a simplified implementation
+        # A full implementation would parse the .dynsym section
+        # For now, we return an empty set as a placeholder
+        undefined = set()
+
+        try:
+            # Parse ELF to get dynamic symbols
+            parser = MinimalELFParser(binary_path)
+            # TODO: Extend MinimalELFParser to extract symbol table
+            # For now, we can extract from version requirements
+            for version in parser.get_version_requirements():
+                # Version strings like "GLIBC_2.34" indicate required symbols
+                undefined.add(version)
+        except Exception:
+            pass
+
+        return undefined
+
+    def _find_library(self, lib_name: str) -> Optional[str]:
+        """Find a library by name in the search paths.
+
+        Args:
+            lib_name: Library name (e.g., "libc.so.6")
+
+        Returns:
+            Full path to library or None if not found
+        """
+        for search_path in self.library_paths:
+            lib_path = os.path.join(search_path, lib_name)
+            if os.path.exists(lib_path):
+                return lib_path
+
+        # Also try without directory component if lib_name is absolute
+        if lib_name.startswith("/") and os.path.exists(lib_name):
+            return lib_name
+
+        return None
+
+    def _get_library_symbols(self, lib_path: str) -> LibrarySymbols:
+        """Get symbols provided by a library.
+
+        Args:
+            lib_path: Path to the library
+
+        Returns:
+            LibrarySymbols object with provided/required symbols
+        """
+        # Check cache first
+        if lib_path in self._symbol_cache:
+            return self._symbol_cache[lib_path]
+
+        lib_symbols = LibrarySymbols(path=lib_path)
+
+        try:
+            parser = MinimalELFParser(lib_path)
+
+            # Get version requirements (symbols this library requires)
+            for version in parser.get_version_requirements():
+                lib_symbols.required_symbols.add(version)
+                lib_symbols.versioned_symbols[version] = version
+
+            # For provided symbols, we'd need to parse .dynsym
+            # This is a simplified version
+            # In a full implementation, we'd extract exported symbols
+            # For now, mark GLIBC versions as "provided" if this is libc
+            if "libc.so" in lib_path:
+                for version in parser.get_version_requirements():
+                    lib_symbols.provided_symbols.add(version)
+
+        except Exception:
+            pass
+
+        # Cache the result
+        self._symbol_cache[lib_path] = lib_symbols
+
+        return lib_symbols
+
+    def check_symbol_availability(
+        self,
+        symbol_name: str,
+        version_requirement: Optional[str] = None
+    ) -> bool:
+        """Check if a symbol is available in system libraries.
+
+        Args:
+            symbol_name: Name of the symbol
+            version_requirement: Optional version requirement (e.g., "GLIBC_2.34")
+
+        Returns:
+            True if symbol is available, False otherwise
+        """
+        # Search all system libraries
+        for search_path in self.library_paths:
+            if not os.path.isdir(search_path):
+                continue
+
+            try:
+                for entry in os.listdir(search_path):
+                    if entry.endswith(".so") or ".so." in entry:
+                        lib_path = os.path.join(search_path, entry)
+                        if os.path.isfile(lib_path):
+                            lib_symbols = self._get_library_symbols(lib_path)
+                            if symbol_name in lib_symbols.provided_symbols:
+                                if version_requirement:
+                                    # Check version compatibility
+                                    sym_version = lib_symbols.versioned_symbols.get(symbol_name)
+                                    if sym_version and self._version_gte(sym_version, version_requirement):
+                                        return True
+                                else:
+                                    return True
+            except (OSError, PermissionError):
+                continue
+
+        return False
+
+    @staticmethod
+    def _version_gte(v1: str, v2: str) -> bool:
+        """Compare version strings (simple comparison).
+
+        Args:
+            v1: First version (e.g., "GLIBC_2.35")
+            v2: Second version (e.g., "GLIBC_2.34")
+
+        Returns:
+            True if v1 >= v2
+        """
+        try:
+            # Extract numeric parts (e.g., "GLIBC_2.34" -> [2, 34])
+            parts1 = [int(x) for x in v1.split("_")[-1].split(".")]
+            parts2 = [int(x) for x in v2.split("_")[-1].split(".")]
+            return parts1 >= parts2
+        except (ValueError, IndexError):
+            return False
+
+
+def resolve_symbol(
+    symbol_name: str,
+    library_paths: Optional[List[str]] = None
+) -> Optional[str]:
+    """Convenience function to resolve a single symbol.
+
+    Args:
+        symbol_name: Name of the symbol to resolve
+        library_paths: Optional list of library search paths
+
+    Returns:
+        Path to library providing the symbol, or None if not found
+    """
+    resolver = SymbolResolver(library_paths)
+
+    # Search for the symbol
+    for search_path in resolver.library_paths:
+        if not os.path.isdir(search_path):
+            continue
+
+        try:
+            for entry in os.listdir(search_path):
+                if entry.endswith(".so") or ".so." in entry:
+                    lib_path = os.path.join(search_path, entry)
+                    if os.path.isfile(lib_path):
+                        lib_symbols = resolver._get_library_symbols(lib_path)
+                        if symbol_name in lib_symbols.provided_symbols:
+                            return lib_path
+        except (OSError, PermissionError):
+            continue
+
+    return None

pybinaryguard/probes/__init__.py

@@ -0,0 +1,73 @@
+"""System probes for PyBinaryGuard.
+
+This package contains all probes that collect information about the
+current system's environment.  Each probe is a subclass of
+:class:`ProbeBase` and implements a ``collect()`` method that returns
+a dictionary whose keys correspond to :class:`SystemProfile` fields.
+
+Usage::
+
+    from pybinaryguard.probes import get_all_probes
+
+    for probe in get_all_probes():
+        if probe.is_applicable():
+            data = probe.collect()
+"""
+
+from __future__ import annotations
+
+from typing import List
+
+from .base import ProbeBase
+from .board_probe import BoardProbe
+from .cpu_probe import CpuProbe
+from .glibc_probe import GlibcProbe
+from .gpu_probe import GpuProbe
+from .library_probe import LibraryProbe
+from .os_probe import OsProbe
+from .python_probe import PythonProbe
+from .toolchain_probe import ToolchainProbe
+from .venv_probe import VenvProbe
+
+__all__ = [
+    "ProbeBase",
+    "BoardProbe",
+    "CpuProbe",
+    "GlibcProbe",
+    "GpuProbe",
+    "LibraryProbe",
+    "OsProbe",
+    "PythonProbe",
+    "ToolchainProbe",
+    "VenvProbe",
+    "get_all_probes",
+]
+
+
+def get_all_probes() -> List[ProbeBase]:
+    """Return an instance of every available probe.
+
+    The probes are returned in a deterministic order chosen so that
+    cheaper / more fundamental probes run first:
+
+    1. **PythonProbe** -- interpreter info (fast, no I/O beyond stdlib)
+    2. **VenvProbe** -- virtual environment detection (fast)
+    3. **CpuProbe** -- CPU architecture and flags (reads /proc/cpuinfo)
+    4. **OsProbe** -- OS and container detection
+    5. **GlibcProbe** -- C library version
+    6. **ToolchainProbe** -- build toolchain (gcc, cmake, etc.)
+    7. **LibraryProbe** -- shared library paths and ldconfig cache
+    8. **BoardProbe** -- embedded board detection
+    9. **GpuProbe** -- GPU / CUDA detection (most expensive)
+    """
+    return [
+        PythonProbe(),
+        VenvProbe(),
+        CpuProbe(),
+        OsProbe(),
+        GlibcProbe(),
+        ToolchainProbe(),
+        LibraryProbe(),
+        BoardProbe(),
+        GpuProbe(),
+    ]

pybinaryguard/probes/base.py

@@ -0,0 +1,45 @@
+"""Abstract base class for all system probes."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict
+
+
+class ProbeBase(ABC):
+    """Base class for system probes that collect environment information.
+
+    Every probe must:
+    - Have a unique ``name`` attribute used for identification and logging.
+    - Implement ``collect()`` which returns a dict whose keys correspond to
+      field names on ``SystemProfile``.
+    - Be completely read-only -- probes must never modify system state.
+    - Handle all internal errors gracefully and return partial data rather
+      than raising.
+    """
+
+    name: str  # Probe identifier -- must be set by subclasses
+
+    @abstractmethod
+    def collect(self) -> Dict[str, Any]:
+        """Collect system information.
+
+        Returns
+        -------
+        Dict[str, Any]
+            A dictionary whose keys are ``SystemProfile`` field names and
+            whose values are the detected values for those fields.  If a
+            value cannot be determined, it should be omitted from the dict
+            rather than set to ``None`` (unless ``None`` is the intended
+            sentinel).
+        """
+        ...
+
+    def is_applicable(self) -> bool:
+        """Return whether this probe can run on the current system.
+
+        The default implementation returns ``True``.  Subclasses may
+        override to skip probing when the current platform is
+        incompatible (e.g. GPU probe on a system with no GPU devices).
+        """
+        return True