pybinaryguard 1.0.0__py3-none-any.whl

pybinaryguard/probes/board_probe.py

@@ -0,0 +1,248 @@
+"""Probe for embedded / single-board computer detection."""
+
+from __future__ import annotations
+
+import os
+import platform
+from typing import Any, Dict, Optional
+
+from .base import ProbeBase
+
+
+class BoardProbe(ProbeBase):
+    """Detects common embedded boards and single-board computers.
+
+    Supported boards:
+    - NVIDIA Jetson (Nano, TX2, Xavier, Orin)
+    - Raspberry Pi (all models)
+    - BeagleBone (Black, AI, etc.)
+    - Google Coral (Dev Board)
+    - Generic ARM SBCs (aarch64/armv7l without a desktop GPU)
+
+    Detection relies on ``/proc/device-tree/model``,
+    ``/etc/nv_tegra_release``, and device-node presence.
+    """
+
+    name = "board"
+
+    def collect(self) -> Dict[str, Any]:
+        """Return board detection results."""
+        data: Dict[str, Any] = {}
+
+        dt_model = self._read_device_tree_model()
+
+        # Try each board family in order of specificity
+        board = self._detect_jetson(dt_model)
+        if board is not None:
+            data["is_embedded_board"] = True
+            data["board_name"] = board["name"]
+            if board.get("jetpack_version"):
+                data["jetpack_version"] = board["jetpack_version"]
+            return data
+
+        board_name = self._detect_raspberry_pi(dt_model)
+        if board_name is not None:
+            data["is_embedded_board"] = True
+            data["board_name"] = board_name
+            return data
+
+        board_name = self._detect_beaglebone(dt_model)
+        if board_name is not None:
+            data["is_embedded_board"] = True
+            data["board_name"] = board_name
+            return data
+
+        board_name = self._detect_coral(dt_model)
+        if board_name is not None:
+            data["is_embedded_board"] = True
+            data["board_name"] = board_name
+            return data
+
+        board_name = self._detect_generic_arm_sbc(dt_model)
+        if board_name is not None:
+            data["is_embedded_board"] = True
+            data["board_name"] = board_name
+            return data
+
+        data["is_embedded_board"] = False
+        return data
+
+    # ------------------------------------------------------------------
+    # Common helpers
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _read_device_tree_model() -> str:
+        """Read ``/proc/device-tree/model``.
+
+        The file is NUL-terminated on many kernels, so we strip trailing
+        NUL bytes and whitespace.
+        """
+        try:
+            with open("/proc/device-tree/model", "rb") as fh:
+                raw = fh.read()
+            return raw.decode("utf-8", errors="replace").strip("\x00").strip()
+        except (FileNotFoundError, PermissionError, OSError):
+            return ""
+
+    @staticmethod
+    def _read_text_file(path: str) -> str:
+        """Read a text file, returning empty string on failure."""
+        try:
+            with open(path, "r") as fh:
+                return fh.read().strip()
+        except (FileNotFoundError, PermissionError, OSError):
+            return ""
+
+    # ------------------------------------------------------------------
+    # Jetson
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _detect_jetson(dt_model: str) -> Optional[Dict[str, str]]:
+        """Detect NVIDIA Jetson boards.
+
+        Primary indicator: ``/etc/nv_tegra_release`` exists.
+        Secondary: device-tree model contains "Jetson" or "NVIDIA".
+        """
+        tegra_release = BoardProbe._read_text_file("/etc/nv_tegra_release")
+        is_jetson = bool(tegra_release)
+
+        if not is_jetson:
+            # Fallback: check device-tree model
+            model_lower = dt_model.lower()
+            if "jetson" in model_lower or ("nvidia" in model_lower and "tegra" in model_lower):
+                is_jetson = True
+
+        if not is_jetson:
+            return None
+
+        name = dt_model if dt_model else "NVIDIA Jetson (unknown model)"
+
+        # Try to determine JetPack version from L4T version
+        jetpack_version = BoardProbe._jetpack_from_l4t(tegra_release)
+
+        result: Dict[str, str] = {"name": name}
+        if jetpack_version:
+            result["jetpack_version"] = jetpack_version
+
+        return result
+
+    @staticmethod
+    def _jetpack_from_l4t(tegra_release: str) -> str:
+        """Map L4T release string to JetPack version.
+
+        ``/etc/nv_tegra_release`` contains a line like::
+
+            # R35 (release), REVISION: 4.1, ...
+
+        Known L4T-to-JetPack mappings (approximate):
+        - R36.x -> JetPack 6.x
+        - R35.x -> JetPack 5.x
+        - R32.x -> JetPack 4.x
+        """
+        if not tegra_release:
+            return ""
+
+        import re
+
+        match = re.search(r"R(\d+)\s.*?REVISION:\s*(\d+(?:\.\d+)?)", tegra_release)
+        if not match:
+            return ""
+
+        major = int(match.group(1))
+        revision = match.group(2)
+        l4t_tag = f"L4T R{major} rev {revision}"
+
+        # Coarse mapping
+        if major >= 36:
+            return f"6.x ({l4t_tag})"
+        elif major >= 35:
+            return f"5.x ({l4t_tag})"
+        elif major >= 32:
+            return f"4.x ({l4t_tag})"
+        else:
+            return l4t_tag
+
+    # ------------------------------------------------------------------
+    # Raspberry Pi
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _detect_raspberry_pi(dt_model: str) -> Optional[str]:
+        """Detect Raspberry Pi boards via the device-tree model string."""
+        if "raspberry pi" in dt_model.lower():
+            return dt_model
+        return None
+
+    # ------------------------------------------------------------------
+    # BeagleBone
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _detect_beaglebone(dt_model: str) -> Optional[str]:
+        """Detect BeagleBone boards via the device-tree model string."""
+        if "beaglebone" in dt_model.lower() or "beagle bone" in dt_model.lower():
+            return dt_model
+        return None
+
+    # ------------------------------------------------------------------
+    # Google Coral
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _detect_coral(dt_model: str) -> Optional[str]:
+        """Detect Google Coral dev board.
+
+        Checks the device-tree model and also looks for the Edge TPU
+        USB device node at ``/dev/apex_0``.
+        """
+        model_lower = dt_model.lower()
+        if "coral" in model_lower:
+            return dt_model
+
+        # Some Coral boards identify as "Freescale" in the DT model;
+        # check for the TPU device node as a secondary signal
+        if os.path.exists("/dev/apex_0"):
+            if dt_model:
+                return f"{dt_model} (Coral TPU detected)"
+            return "Google Coral (TPU detected)"
+
+        return None
+
+    # ------------------------------------------------------------------
+    # Generic ARM SBC
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _detect_generic_arm_sbc(dt_model: str) -> Optional[str]:
+        """Detect a generic ARM single-board computer.
+
+        Criteria:
+        - Architecture is aarch64 or armv7l.
+        - No desktop GPU is detected (no ``/dev/nvidia*`` or ``/dev/dri/card*``).
+        - A device-tree model string is available (bare-metal servers
+          typically do not populate ``/proc/device-tree/model``).
+        """
+        machine = ""
+        try:
+            machine = platform.machine()
+        except Exception:
+            pass
+
+        if machine not in ("aarch64", "arm64", "armv7l", "armv6l"):
+            return None
+
+        # Must have a device-tree model to differentiate from cloud ARM servers
+        if not dt_model:
+            return None
+
+        # Exclude systems with a desktop GPU
+        has_desktop_gpu = (
+            os.path.exists("/dev/nvidia0")
+            or os.path.exists("/dev/dri/card0")
+        )
+        if has_desktop_gpu:
+            return None
+
+        return dt_model

pybinaryguard/probes/cpu_probe.py

@@ -0,0 +1,176 @@
+"""Probe for CPU architecture and feature flags."""
+
+from __future__ import annotations
+
+import os
+import platform
+from typing import Any, Dict, FrozenSet
+
+from pybinaryguard.models.enums import Architecture
+
+from .base import ProbeBase
+
+
+class CpuProbe(ProbeBase):
+    """Collects CPU architecture, model, core count, and feature flags.
+
+    On x86 the flags are read from the ``flags`` line in
+    ``/proc/cpuinfo``.  On ARM/AArch64 the equivalent is the
+    ``Features`` line.  This probe works without external dependencies.
+    """
+
+    name = "cpu"
+
+    def collect(self) -> Dict[str, Any]:
+        """Return architecture, CPU model, core count, and feature flags."""
+        data: Dict[str, Any] = {}
+
+        machine = self._get_machine()
+        data["architecture"] = Architecture.from_machine(machine)
+
+        cpuinfo = self._read_cpuinfo()
+
+        data["cpu_model"] = self._extract_cpu_model(cpuinfo, machine)
+        data["cpu_cores"] = self._get_core_count()
+
+        flags = self._extract_flags(cpuinfo, machine)
+        data["cpu_flags"] = flags
+
+        # Feature detection based on flags
+        data["has_sse42"] = self._has_flag(flags, {"sse4_2", "sse4.2"})
+        data["has_avx"] = self._has_flag(flags, {"avx"})
+        data["has_avx2"] = self._has_flag(flags, {"avx2"})
+        data["has_avx512"] = self._has_any_avx512(flags)
+        data["has_neon"] = self._detect_neon(flags, machine)
+
+        return data
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _get_machine() -> str:
+        """Return the raw machine string from the platform module."""
+        try:
+            return platform.machine()
+        except Exception:
+            return ""
+
+    @staticmethod
+    def _read_cpuinfo() -> str:
+        """Read ``/proc/cpuinfo`` and return its content as a string."""
+        try:
+            with open("/proc/cpuinfo", "r") as fh:
+                return fh.read()
+        except (FileNotFoundError, PermissionError, OSError):
+            return ""
+
+    @staticmethod
+    def _extract_cpu_model(cpuinfo: str, machine: str) -> str:
+        """Extract the CPU model name from cpuinfo text.
+
+        On x86: ``model name  : Intel(R) Core(TM) ...``
+        On ARM: ``Hardware    : BCM2835`` or ``model name`` if present.
+        """
+        # Try "model name" first (works on x86 and some ARM)
+        for line in cpuinfo.splitlines():
+            stripped = line.strip()
+            if stripped.lower().startswith("model name"):
+                parts = stripped.split(":", 1)
+                if len(parts) == 2:
+                    return parts[1].strip()
+
+        # ARM fallback: "Hardware" line
+        if machine.startswith(("aarch64", "arm")):
+            for line in cpuinfo.splitlines():
+                stripped = line.strip()
+                if stripped.lower().startswith("hardware"):
+                    parts = stripped.split(":", 1)
+                    if len(parts) == 2:
+                        return parts[1].strip()
+
+        # Last resort: "CPU implementer" + "CPU part" (common on AArch64)
+        if machine.startswith(("aarch64", "arm")):
+            implementer = ""
+            part = ""
+            for line in cpuinfo.splitlines():
+                stripped = line.strip().lower()
+                if stripped.startswith("cpu implementer"):
+                    p = stripped.split(":", 1)
+                    if len(p) == 2:
+                        implementer = p[1].strip()
+                elif stripped.startswith("cpu part"):
+                    p = stripped.split(":", 1)
+                    if len(p) == 2:
+                        part = p[1].strip()
+            if implementer or part:
+                return f"implementer={implementer} part={part}"
+
+        return ""
+
+    @staticmethod
+    def _get_core_count() -> int:
+        """Return the number of logical CPU cores."""
+        try:
+            count = os.cpu_count()
+            return count if count is not None else 0
+        except Exception:
+            return 0
+
+    @staticmethod
+    def _extract_flags(cpuinfo: str, machine: str) -> FrozenSet[str]:
+        """Extract CPU feature flags from ``/proc/cpuinfo``.
+
+        On x86, flags appear on a ``flags`` line.
+        On ARM/AArch64, they appear on a ``Features`` line.
+        """
+        # Determine which key to look for
+        if machine in ("x86_64", "AMD64", "i686", "i386"):
+            key_candidates = ["flags"]
+        elif machine.startswith(("aarch64", "arm")):
+            key_candidates = ["features", "flags"]
+        else:
+            key_candidates = ["flags", "features"]
+
+        for line in cpuinfo.splitlines():
+            stripped = line.strip().lower()
+            for key in key_candidates:
+                if stripped.startswith(key):
+                    parts = line.split(":", 1)
+                    if len(parts) == 2:
+                        flag_list = parts[1].strip().split()
+                        return frozenset(f.lower() for f in flag_list)
+
+        return frozenset()
+
+    @staticmethod
+    def _has_flag(flags: FrozenSet[str], names: set) -> bool:  # type: ignore[type-arg]
+        """Return ``True`` if *any* of the given names are present in *flags*."""
+        return bool(flags & names)
+
+    @staticmethod
+    def _has_any_avx512(flags: FrozenSet[str]) -> bool:
+        """Return ``True`` if any AVX-512 feature flag is present.
+
+        AVX-512 is reported as multiple sub-features (``avx512f``,
+        ``avx512bw``, ``avx512vl``, etc.).  The foundation flag
+        ``avx512f`` must be present for any AVX-512 to be usable, but
+        we also accept any flag starting with ``avx512``.
+        """
+        return any(f.startswith("avx512") for f in flags)
+
+    @staticmethod
+    def _detect_neon(flags: FrozenSet[str], machine: str) -> bool:
+        """Detect ARM NEON support.
+
+        On AArch64 NEON is mandatory, so we return ``True`` even when
+        the ``neon`` flag is not explicitly listed in ``/proc/cpuinfo``.
+        On 32-bit ARM we look for the ``neon`` flag.
+        """
+        if machine in ("aarch64", "arm64"):
+            # NEON is mandatory in the ARMv8-A architecture
+            return True
+        if "neon" in flags:
+            return True
+        return False

pybinaryguard/probes/glibc_probe.py

@@ -0,0 +1,215 @@
+"""Probe for GLIBC / musl libc information."""
+
+from __future__ import annotations
+
+import ctypes
+import os
+import re
+import subprocess
+from typing import Any, Dict, Optional, Tuple
+
+from .base import ProbeBase
+
+
+class GlibcProbe(ProbeBase):
+    """Collects C library version information (GLIBC or musl).
+
+    Detection strategy for GLIBC:
+    1. ``os.confstr("CS_GNU_LIBC_VERSION")`` -- fast and authoritative.
+    2. ctypes fallback: load ``libc.so.6`` and call ``gnu_get_libc_version()``.
+
+    Detection strategy for musl:
+    1. Scan ``/proc/self/maps`` for paths containing ``musl``.
+    2. Fall back to running ``ldd --version`` and inspecting stderr for
+       the ``musl`` banner.
+    """
+
+    name = "glibc"
+
+    def collect(self) -> Dict[str, Any]:
+        """Return ``glibc_version`` and/or ``musl_version``."""
+        data: Dict[str, Any] = {}
+
+        # Try musl first -- if the system is musl-based there is no glibc
+        musl_ver = self._detect_musl()
+        if musl_ver is not None:
+            data["musl_version"] = musl_ver
+            return data
+
+        # Try glibc
+        glibc_ver = self._detect_glibc()
+        if glibc_ver is not None:
+            data["glibc_version"] = glibc_ver
+
+        return data
+
+    # ------------------------------------------------------------------
+    # GLIBC detection
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _detect_glibc() -> Optional[Tuple[int, int]]:
+        """Detect the GLIBC version.
+
+        Returns a ``(major, minor)`` tuple or ``None`` if GLIBC cannot be
+        found.
+        """
+        # Method 1: os.confstr
+        ver = GlibcProbe._glibc_via_confstr()
+        if ver is not None:
+            return ver
+
+        # Method 2: ctypes
+        ver = GlibcProbe._glibc_via_ctypes()
+        if ver is not None:
+            return ver
+
+        return None
+
+    @staticmethod
+    def _glibc_via_confstr() -> Optional[Tuple[int, int]]:
+        """Parse ``os.confstr('CS_GNU_LIBC_VERSION')``."""
+        try:
+            libc_string = os.confstr("CS_GNU_LIBC_VERSION")  # e.g. "glibc 2.35"
+            if not libc_string:
+                return None
+            return GlibcProbe._parse_glibc_version_string(libc_string)
+        except (ValueError, OSError, AttributeError):
+            return None
+
+    @staticmethod
+    def _glibc_via_ctypes() -> Optional[Tuple[int, int]]:
+        """Load ``libc.so.6`` via ctypes and call ``gnu_get_libc_version``."""
+        try:
+            libc = ctypes.CDLL("libc.so.6")
+            gnu_get_libc_version = libc.gnu_get_libc_version
+            gnu_get_libc_version.restype = ctypes.c_char_p
+            version_bytes: bytes = gnu_get_libc_version()
+            version_str = version_bytes.decode("ascii", errors="replace")
+            return GlibcProbe._parse_dotted_version(version_str)
+        except (OSError, AttributeError, TypeError):
+            return None
+
+    @staticmethod
+    def _parse_glibc_version_string(s: str) -> Optional[Tuple[int, int]]:
+        """Parse a string like ``'glibc 2.35'`` into ``(2, 35)``."""
+        match = re.search(r"(\d+)\.(\d+)", s)
+        if match:
+            return (int(match.group(1)), int(match.group(2)))
+        return None
+
+    @staticmethod
+    def _parse_dotted_version(s: str) -> Optional[Tuple[int, int]]:
+        """Parse ``'2.35'`` into ``(2, 35)``."""
+        match = re.match(r"(\d+)\.(\d+)", s.strip())
+        if match:
+            return (int(match.group(1)), int(match.group(2)))
+        return None
+
+    # ------------------------------------------------------------------
+    # musl detection
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _detect_musl() -> Optional[Tuple[int, int]]:
+        """Detect musl libc and its version.
+
+        Returns a ``(major, minor)`` tuple or ``None``.
+        """
+        # Method 1: /proc/self/maps
+        ver = GlibcProbe._musl_via_proc_maps()
+        if ver is not None:
+            return ver
+
+        # Method 2: ldd --version (musl ldd writes to stderr)
+        ver = GlibcProbe._musl_via_ldd()
+        if ver is not None:
+            return ver
+
+        return None
+
+    @staticmethod
+    def _musl_via_proc_maps() -> Optional[Tuple[int, int]]:
+        """Scan ``/proc/self/maps`` for musl shared objects.
+
+        A musl-based system maps something like::
+
+            7f...  /lib/ld-musl-x86_64.so.1
+
+        We then try to extract the version by reading the library's
+        banner (the first few bytes often contain the version string)
+        or by invoking the linker with ``--version``.
+        """
+        try:
+            with open("/proc/self/maps", "r") as fh:
+                for line in fh:
+                    if "musl" in line:
+                        # Extract the library path
+                        parts = line.strip().split()
+                        if len(parts) >= 6:
+                            lib_path = parts[-1]
+                            ver = GlibcProbe._musl_version_from_binary(lib_path)
+                            if ver is not None:
+                                return ver
+                        # Even if we cannot determine the version, signal
+                        # that musl is present with a fallback.
+                        return (1, 0)
+        except (FileNotFoundError, PermissionError, OSError):
+            pass
+        return None
+
+    @staticmethod
+    def _musl_version_from_binary(path: str) -> Optional[Tuple[int, int]]:
+        """Execute the musl linker binary to extract version information.
+
+        ``ld-musl-*.so.1 --version`` prints something like::
+
+            musl libc (x86_64)
+            Version 1.2.3
+        """
+        try:
+            result = subprocess.run(
+                [path],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            # musl's ld.so exits non-zero when invoked directly but
+            # prints version info to stderr.
+            output = result.stdout + result.stderr
+            return GlibcProbe._parse_musl_version_output(output)
+        except (FileNotFoundError, PermissionError, OSError, subprocess.TimeoutExpired):
+            return None
+
+    @staticmethod
+    def _musl_via_ldd() -> Optional[Tuple[int, int]]:
+        """Run ``ldd --version`` and parse musl's banner."""
+        try:
+            result = subprocess.run(
+                ["ldd", "--version"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            output = result.stdout + result.stderr
+            if "musl" not in output.lower():
+                return None
+            return GlibcProbe._parse_musl_version_output(output)
+        except (FileNotFoundError, PermissionError, OSError, subprocess.TimeoutExpired):
+            return None
+
+    @staticmethod
+    def _parse_musl_version_output(output: str) -> Optional[Tuple[int, int]]:
+        """Extract musl version from its banner text.
+
+        Looks for patterns like ``Version 1.2.3`` or ``musl libc ... 1.2.3``.
+        """
+        # "Version 1.2.3"
+        match = re.search(r"[Vv]ersion\s+(\d+)\.(\d+)", output)
+        if match:
+            return (int(match.group(1)), int(match.group(2)))
+        # Fallback: any x.y after "musl"
+        match = re.search(r"musl.*?(\d+)\.(\d+)", output, re.IGNORECASE)
+        if match:
+            return (int(match.group(1)), int(match.group(2)))
+        return None