165 KiB
165 KiB
Policy Engine Data Pipeline
Overview
This document provides a comprehensive view of how StellaOps feeds data to the Policy Engine for vulnerability risk decisions. The pipeline spans multiple subsystems: SBOM generation with 20+ analyzers, runtime observation via eBPF agents, static/dynamic call graph analysis, binary fingerprinting, and confidence-weighted scoring.
Design Principle: Every policy decision links back to concrete, verifiable evidence. The system aggregates evidence from multiple sources without silently merging conflicts (aggregation-not-merge).
Master Data Flow Diagram
┌─────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│ POLICY ENGINE DATA PIPELINE - COMPLETE VIEW │
└─────────────────────────────────────────────────────────────────────────────────────────────────────────┘
┌──────────────────────┐
│ CONTAINER IMAGE │
│ (OCI/Docker/tar) │
└──────────┬───────────┘
│
┌──────────────────────────┼──────────────────────────┐
│ │ │
▼ ▼ ▼
┌───────────────────────┐ ┌───────────────────────┐ ┌───────────────────────┐
│ LAYER EXTRACTION │ │ BINARY EXTRACTION │ │ RUNTIME DEPLOYMENT │
│ (FS + Metadata) │ │ (ELF/PE/Mach-O) │ │ (K8s/Docker/Podman) │
└───────────┬───────────┘ └───────────┬───────────┘ └───────────┬───────────┘
│ │ │
┌───────────┴───────────┐ ┌───────────┴───────────┐ ┌───────────┴───────────┐
│ │ │ │ │ │
▼ ▼ ▼ ▼ ▼ ▼
┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐
│LANGUAGE │ │ OS │ │ BINARY │ │ eBPF │
│ANALYZERS│ │ANALYZERS│ │ INDEX │ │ AGENTS │
│ (11) │ │ (9) │ │ │ │ │
└────┬────┘ └────┬────┘ └────┬────┘ └────┬────┘
│ │ │ │
│ ┌────────────────┘ │ │
│ │ ┌─────────────────────────────────────┘ │
│ │ │ │
▼ ▼ ▼ ▼
┌─────────────────────┐ ┌─────────────────────┐ ┌─────────────────────────────────┐
│ SBOM │ │ SYMBOL MANIFEST │ │ RUNTIME SIGNALS │
│ (CycloneDX/SPDX) │ │ (Function Hashes) │ │ (Function Calls + Syscalls) │
└──────────┬──────────┘ └──────────┬──────────┘ └───────────────┬─────────────────┘
│ │ │
│ ┌────────────────────┘ │
│ │ │
▼ ▼ ▼
┌─────────────────────┐ ┌─────────────────────┐
│ CALL GRAPH │ │ HOT SYMBOL INDEX │
│ CONSTRUCTION │◄──────────────────────────────│ (Invocation Freq) │
│ (Static + Dynamic) │ └─────────────────────┘
└──────────┬──────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ REACHABILITY ANALYSIS │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Entry Point │ │ Path BFS │ │ K4 Lattice │ │ 8-State │ │
│ │ Detection │ │ Traversal │ │ Resolution │ │ Classification│ │
│ └──────────────┘ └──────────────┘ └──────────────┘ └──────────────┘ │
└──────────────────────────────────┬──────────────────────────────────────────┘
│
┌──────────────────────────────────┼──────────────────────────────────────────┐
│ │ │
▼ ▼ ▼
┌─────────────────────┐ ┌─────────────────────┐ ┌─────────────────────────────┐
│ ADVISORY MATCHING │ │ VEX STATEMENTS │ │ EXCEPTION REGISTRY │
│ (CVE/GHSA/OSV) │ │ (OpenVEX) │ │ (Approved Waivers) │
│ │ │ │ │ │
│ ┌───────────────┐ │ │ ┌───────────────┐ │ │ ┌───────────────────────┐ │
│ │ Concelier │ │ │ │ VexLens │ │ │ │ Exception Store │ │
│ │ (NVD,GHSA,OSV)│ │ │ │ (Consensus) │ │ │ │ (Time-bounded) │ │
│ └───────────────┘ │ │ └───────────────┘ │ │ └───────────────────────┘ │
└──────────┬──────────┘ └──────────┬──────────┘ └─────────────┬───────────────┘
│ │ │
└───────────────────────────┼───────────────────────────────┘
│
▼
┌─────────────────────────────────────────┐
│ CONFIDENCE SCORING │
│ ┌─────────────────────────────────┐ │
│ │ Reachability │ 0.30 weight │ │
│ │ Runtime │ 0.25 weight │ │
│ │ VEX │ 0.20 weight │ │
│ │ Provenance │ 0.15 weight │ │
│ │ Policy │ 0.10 weight │ │
│ └─────────────────────────────────┘ │
└───────────────────┬─────────────────────┘
│
▼
┌─────────────────────────────────────────┐
│ POLICY ENGINE │
│ ┌─────────────────────────────────┐ │
│ │ K4 Lattice Evaluation │ │
│ │ (Unknown, True, False, Both) │ │
│ ├─────────────────────────────────┤ │
│ │ Gates: │ │
│ │ • MinimumConfidenceGate │ │
│ │ • ReachabilityRequirementGate │ │
│ │ • UnknownsBudgetGate │ │
│ └─────────────────────────────────┘ │
└───────────────────┬─────────────────────┘
│
▼
┌─────────────────────────────────────────┐
│ VERDICT │
│ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ │
│ │PASS │ │WARN │ │FAIL │ │SKIP │ │
│ └─────┘ └─────┘ └─────┘ └─────┘ │
│ │
│ + Explain Trace (evidence chain) │
│ + DSSE Attestation │
└─────────────────────────────────────────┘
1. SBOM Generation Layer
1.1 Language Analyzers (11 Total)
The Scanner module implements specialized analyzers for each language ecosystem. Each analyzer extracts package manifests, lockfiles, and dependency trees.
┌─────────────────────────────────────────────────────────────────────────────────────┐
│ LANGUAGE ANALYZERS INVENTORY │
├─────────────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────────────────────────┐ │
│ │ .NET ECOSYSTEM │ │
│ │ ┌──────────────────┐ │ │
│ │ │ DotNetAnalyzer │ Files: *.csproj, *.fsproj, *.vbproj, packages.config │ │
│ │ │ │ *.deps.json, *.nuspec, paket.lock │ │
│ │ │ PackageRef → │ Output: pkg:nuget/Package@Version │ │
│ │ │ TransitiveDeps │ Features: Framework targeting, runtime deps │ │
│ │ └──────────────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────────────────┐ │
│ │ JVM ECOSYSTEM │ │
│ │ ┌──────────────────┐ │ │
│ │ │ JavaAnalyzer │ Files: pom.xml, build.gradle, build.gradle.kts │ │
│ │ │ │ *.jar (META-INF/MANIFEST.MF), ivy.xml │ │
│ │ │ Maven/Gradle → │ Output: pkg:maven/groupId/artifactId@version │ │
│ │ │ JAR Inspection │ Features: Shaded JARs, BOM imports, classifiers │ │
│ │ └──────────────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────────────────┐ │
│ │ JAVASCRIPT ECOSYSTEM │ │
│ │ ┌──────────────────┐ ┌──────────────────┐ ┌──────────────────┐ │ │
│ │ │ NodeAnalyzer │ │ DenoAnalyzer │ │ BunAnalyzer │ │ │
│ │ │ │ │ │ │ │ │ │
│ │ │ package.json │ │ deno.json │ │ bun.lockb │ │ │
│ │ │ package-lock │ │ deno.lock │ │ package.json │ │ │
│ │ │ yarn.lock │ │ import_map.json │ │ │ │ │
│ │ │ pnpm-lock.yaml │ │ │ │ │ │ │
│ │ │ │ │ │ │ │ │ │
│ │ │ pkg:npm/... │ │ pkg:deno/... │ │ pkg:npm/... │ │ │
│ │ └──────────────────┘ └──────────────────┘ └──────────────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────────────────┐ │
│ │ PYTHON ECOSYSTEM │ │
│ │ ┌──────────────────┐ │ │
│ │ │ PythonAnalyzer │ Files: requirements.txt, Pipfile.lock, poetry.lock │ │
│ │ │ │ setup.py, setup.cfg, pyproject.toml │ │
│ │ │ Pip/Poetry → │ *.egg-info/PKG-INFO, METADATA │ │
│ │ │ Wheel Metadata │ Output: pkg:pypi/package@version │ │
│ │ └──────────────────┘ Features: Extras, environment markers │ │
│ └─────────────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────────────────┐ │
│ │ GO ECOSYSTEM │ │
│ │ ┌──────────────────┐ │ │
│ │ │ GoAnalyzer │ Files: go.mod, go.sum, vendor/modules.txt │ │
│ │ │ │ Binary: __go_buildinfo section │ │
│ │ │ Module Graph → │ Output: pkg:golang/module@version │ │
│ │ │ Binary Embed │ Features: Replace directives, pseudo-versions │ │
│ │ └──────────────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────────────────┐ │
│ │ RUST ECOSYSTEM │ │
│ │ ┌──────────────────┐ │ │
│ │ │ RustAnalyzer │ Files: Cargo.toml, Cargo.lock │ │
│ │ │ │ Binary: .comment section (rustc version) │ │
│ │ │ Cargo.lock → │ Output: pkg:cargo/crate@version │ │
│ │ │ Feature Flags │ Features: Features, target-specific deps │ │
│ │ └──────────────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────────────────┐ │
│ │ SCRIPTING ECOSYSTEMS │ │
│ │ ┌──────────────────┐ ┌──────────────────┐ │ │
│ │ │ PhpAnalyzer │ │ RubyAnalyzer │ │ │
│ │ │ │ │ │ │ │
│ │ │ composer.json │ │ Gemfile │ │ │
│ │ │ composer.lock │ │ Gemfile.lock │ │ │
│ │ │ │ │ *.gemspec │ │ │
│ │ │ pkg:composer/... │ │ pkg:gem/... │ │ │
│ │ └──────────────────┘ └──────────────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────────────────┐ │
│ │ NATIVE BINARIES │ │
│ │ ┌──────────────────┐ │ │
│ │ │ NativeAnalyzer │ Formats: ELF (Linux), PE (Windows), Mach-O (macOS) │ │
│ │ │ │ Extracts: Build-ID, linked libraries, symbols │ │
│ │ │ ELF Parsing → │ Output: pkg:generic/binary@build-id │ │
│ │ │ Symbol Tables │ Features: DWARF debug info, .note.gnu.build-id │ │
│ │ └──────────────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────────────┘
1.2 OS/Distribution Analyzers (9 Total)
OS-level package analyzers extract installed system packages with version information using distribution-specific formats.
┌─────────────────────────────────────────────────────────────────────────────────────┐
│ OS/DISTRIBUTION ANALYZERS │
├─────────────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌────────────────────────────────────────────────────────────────────────────┐ │
│ │ LINUX DISTRIBUTIONS │ │
│ │ │ │
│ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │
│ │ │ APK │ │ DPKG │ │ RPM │ │ │
│ │ │ (Alpine) │ │ (Debian) │ │ (RHEL) │ │ │
│ │ ├─────────────┤ ├─────────────┤ ├─────────────┤ │ │
│ │ │/lib/apk/db/ │ │/var/lib/dpkg│ │/var/lib/rpm │ │ │
│ │ │ installed │ │ status │ │ Packages │ │ │
│ │ │ │ │ available │ │ rpmdb.sqlite│ │ │
│ │ ├─────────────┤ ├─────────────┤ ├─────────────┤ │ │
│ │ │pkg:apk/ │ │pkg:deb/ │ │pkg:rpm/ │ │ │
│ │ │alpine/pkg │ │debian/pkg │ │rhel/pkg │ │ │
│ │ │@version │ │@version │ │@evr │ │ │
│ │ └─────────────┘ └─────────────┘ └─────────────┘ │ │
│ │ │ │
│ │ Version Semantics: │ │
│ │ • APK: semver-like with -r suffix (1.2.3-r4) │ │
│ │ • DPKG: epoch:upstream-debian (1:2.3.4-5ubuntu6) │ │
│ │ • RPM: NEVRA (name-epoch:version-release.arch) │ │
│ │ │ │
│ └────────────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌────────────────────────────────────────────────────────────────────────────┐ │
│ │ macOS │ │
│ │ │ │
│ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │
│ │ │ Homebrew │ │ Pkgutil │ │ MacOsBundle │ │ │
│ │ │ │ │ (System) │ │ (.app) │ │ │
│ │ ├─────────────┤ ├─────────────┤ ├─────────────┤ │ │
│ │ │/opt/homebrew│ │pkgutil │ │Info.plist │ │ │
│ │ │/Cellar/ │ │--pkgs │ │Contents/ │ │ │
│ │ │INSTALL_RCPT │ │ │ │ │ │ │
│ │ ├─────────────┤ ├─────────────┤ ├─────────────┤ │ │
│ │ │pkg:brew/ │ │pkg:macos/ │ │pkg:swift/ │ │ │
│ │ │formula@ver │ │pkg@version │ │bundle@ver │ │ │
│ │ └─────────────┘ └─────────────┘ └─────────────┘ │ │
│ │ │ │
│ └────────────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌────────────────────────────────────────────────────────────────────────────┐ │
│ │ WINDOWS │ │
│ │ │ │
│ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │
│ │ │ Chocolatey │ │ MSI │ │ WinSxS │ │ │
│ │ │ │ │ (Installer) │ │ (Side-by- │ │ │
│ │ │ │ │ │ │ Side) │ │ │
│ │ ├─────────────┤ ├─────────────┤ ├─────────────┤ │ │
│ │ │C:\Programdata│ │Registry │ │C:\Windows\ │ │ │
│ │ │\chocolatey\ │ │HKLM\SOFTWARE│ │WinSxS\ │ │ │
│ │ │lib\ │ │\Microsoft\ │ │Manifests\ │ │ │
│ │ │ │ │Windows\ │ │ │ │ │
│ │ ├─────────────┤ ├─────────────┤ ├─────────────┤ │ │
│ │ │pkg:choco/ │ │pkg:msi/ │ │pkg:winsxs/ │ │ │
│ │ │package@ver │ │product@ver │ │assembly@ver │ │ │
│ │ └─────────────┘ └─────────────┘ └─────────────┘ │ │
│ │ │ │
│ └────────────────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────────────┘
1.3 Surface Analyzers
Surface analyzers extract metadata beyond packages: secrets, environment, filesystem attributes.
┌─────────────────────────────────────────────────────────────────────────────────────┐
│ SURFACE ANALYZERS │
├─────────────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌────────────────────┐ ┌────────────────────┐ ┌────────────────────┐ │
│ │ FileSystemAnalyzer │ │ EnvironmentAnalyzer│ │ SecretsAnalyzer │ │
│ ├────────────────────┤ ├────────────────────┤ ├────────────────────┤ │
│ │ │ │ │ │ │ │
│ │ • File permissions │ │ • ENV variables │ │ • API keys │ │
│ │ • SUID/SGID bits │ │ • PATH entries │ │ • Private keys │ │
│ │ • Capabilities │ │ • User context │ │ • Passwords │ │
│ │ • Symlink targets │ │ • Shell config │ │ • Tokens │ │
│ │ • World-writable │ │ • Locale settings │ │ • Connection strs │ │
│ │ │ │ │ │ │ │
│ │ Output: │ │ Output: │ │ Output: │ │
│ │ property:fs/... │ │ property:env/... │ │ finding:secret/... │ │
│ └────────────────────┘ └────────────────────┘ └────────────────────┘ │
│ │
│ ┌────────────────────┐ ┌────────────────────┐ │
│ │ ValidationAnalyzer │ │ CapabilityAnalyzer │ │
│ ├────────────────────┤ ├────────────────────┤ │
│ │ │ │ │ │
│ │ • SBOM completeness│ │ Detects usage of: │ │
│ │ • Hash verification│ │ • Exec (shell out) │ │
│ │ • Signature checks │ │ • Network (sockets)│ │
│ │ • Format compliance│ │ • Filesystem I/O │ │
│ │ │ │ • Crypto operations│ │
│ │ │ │ • Database access │ │
│ │ │ │ • Dynamic code │ │
│ │ │ │ • Reflection │ │
│ │ │ │ • Native interop │ │
│ └────────────────────┘ └────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────────────┘
1.4 SBOM Composition Layer
All analyzer outputs are composed into standardized SBOM formats with DSSE attestation.
┌─────────────────────────────────────────────────────────────────────────────────────┐
│ SBOM COMPOSITION LAYER │
├─────────────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────────────────────┐ │
│ │ ANALYZER OUTPUTS │ │
│ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │
│ │ │ Lang │ │ OS │ │ Binary │ │ Surface │ │ Secrets │ │ │
│ │ │ Deps │ │ Pkgs │ │ IDs │ │ Props │ │ Findings│ │ │
│ │ └────┬────┘ └────┬────┘ └────┬────┘ └────┬────┘ └────┬────┘ │ │
│ │ │ │ │ │ │ │ │
│ │ └───────────┴───────────┴───────────┴───────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────┐ │ │
│ │ │ SBOM Composer │ │ │
│ │ │ (Deduplication + │ │ │
│ │ │ Relationship │ │ │
│ │ │ Inference) │ │ │
│ │ └──────────┬──────────┘ │ │
│ │ │ │ │
│ └───────────────────────────────┼─────────────────────────────────────────┘ │
│ │ │
│ ┌──────────────────────────┼──────────────────────────┐ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │
│ │ CycloneDX │ │ SPDX │ │ CBOM │ │
│ │ 1.4 / 1.5 / │ │ 2.3 / 3.0.1 │ │ (Cryptographic) │ │
│ │ 1.6 │ │ │ │ │ │
│ ├─────────────────┤ ├─────────────────┤ ├─────────────────┤ │
│ │ • components[] │ │ • packages[] │ │ • algorithms[] │ │
│ │ • dependencies[]│ │ • relationships │ │ • certificates[]│ │
│ │ • vulnerabilities│ │ • files[] │ │ • keys[] │ │
│ │ • services[] │ │ • snippets[] │ │ • protocols[] │ │
│ │ • formulation │ │ • annotations │ │ │ │
│ └────────┬────────┘ └────────┬────────┘ └────────┬────────┘ │
│ │ │ │ │
│ └─────────────────────────┼─────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────┐ │
│ │ DSSE Envelope │ │
│ │ (in-toto) │ │
│ ├─────────────────────┤ │
│ │ payloadType: │ │
│ │ application/vnd. │ │
│ │ cyclonedx+json │ │
│ │ │ │
│ │ payload: <base64> │ │
│ │ │ │
│ │ signatures: [ │ │
│ │ { keyid, sig } │ │
│ │ ] │ │
│ └─────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────────────┘
2. Runtime Observation Layer
2.1 eBPF Agent Architecture
The Signals module provides kernel-level observability through eBPF probes.
┌─────────────────────────────────────────────────────────────────────────────────────┐
│ eBPF RUNTIME OBSERVATION │
├─────────────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ KERNEL SPACE │ │
│ │ │ │
│ │ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │ │
│ │ │ kprobe/kretprobe│ │ tracepoint │ │ uprobe │ │ │
│ │ │ (syscalls) │ │ (scheduler, │ │ (userspace │ │ │
│ │ │ │ │ network, fs) │ │ functions) │ │ │
│ │ └────────┬────────┘ └────────┬────────┘ └────────┬────────┘ │ │
│ │ │ │ │ │ │
│ │ └────────────────────┼────────────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────┐ │ │
│ │ │ eBPF Ring Buffer │ │ │
│ │ │ (per-CPU) │ │ │
│ │ └────────────┬────────────┘ │ │
│ │ │ │ │
│ └─────────────────────────────────┼─────────────────────────────────────────────┘ │
│ │ │
│ ┌─────────────────────────────────┼─────────────────────────────────────────────┐ │
│ │ USER SPACE │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────┐ │ │
│ │ │ RuntimeSignalCollector │ │ │
│ │ │ (StellaOps.Signals) │ │ │
│ │ ├─────────────────────────────────┤ │ │
│ │ │ • Perf event polling │ │ │
│ │ │ • Symbol resolution │ │ │
│ │ │ • Stack trace unwinding │ │ │
│ │ │ • Container ID correlation │ │ │
│ │ └──────────────┬──────────────────┘ │ │
│ │ │ │ │
│ │ ┌──────────────┴──────────────┐ │ │
│ │ │ │ │ │
│ │ ▼ ▼ │ │
│ │ ┌─────────────────────┐ ┌─────────────────────┐ │ │
│ │ │ Function Call Event │ │ Syscall Event │ │ │
│ │ ├─────────────────────┤ ├─────────────────────┤ │ │
│ │ │ timestamp: i64 │ │ timestamp: i64 │ │ │
│ │ │ container_id: str │ │ container_id: str │ │ │
│ │ │ pid/tid: u32 │ │ syscall_nr: u32 │ │ │
│ │ │ function_name: str │ │ args: [u64; 6] │ │ │
│ │ │ module: str │ │ retval: i64 │ │ │
│ │ │ stack_trace: [addr] │ │ stack_trace: [addr] │ │ │
│ │ │ latency_ns: u64 │ │ latency_ns: u64 │ │ │
│ │ └─────────────────────┘ └─────────────────────┘ │ │
│ │ │ │
│ └───────────────────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────────────┘
2.2 Container Observation (Zastava)
Zastava observes container lifecycle events and runtime posture.
┌─────────────────────────────────────────────────────────────────────────────────────┐
│ ZASTAVA CONTAINER OBSERVER │
├─────────────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ CONTAINER RUNTIME │ │
│ │ │ │
│ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │
│ │ │ Docker │ │ containerd │ │ CRI-O │ │ │
│ │ │ Engine │ │ │ │ │ │ │
│ │ └──────┬──────┘ └──────┬──────┘ └──────┬──────┘ │ │
│ │ │ │ │ │ │
│ │ └──────────────────┼──────────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────┐ │ │
│ │ │ Container Events │ │ │
│ │ │ (via API socket) │ │ │
│ │ └──────────┬──────────┘ │ │
│ │ │ │ │
│ └─────────────────────────────┼─────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────┐ │
│ │ ZastavaObserver │ │
│ ├─────────────────────────────┤ │
│ │ • Image digest extraction │ │
│ │ • Container ID tracking │ │
│ │ • Lifecycle events │ │
│ │ • Runtime posture eval │ │
│ └──────────────┬──────────────┘ │
│ │ │
│ ┌───────────────────────┼───────────────────────┐ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ CREATE │ │ START │ │ STOP │ │
│ ├─────────────┤ ├─────────────┤ ├─────────────┤ │
│ │ image_ref │ │ container_id│ │ exit_code │ │
│ │ image_digest│ │ pid │ │ duration │ │
│ │ labels │ │ started_at │ │ stopped_at │ │
│ │ env_vars │ │ cgroups │ │ oom_killed │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
│ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ RUNTIME POSTURES │ │
│ │ │ │
│ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │
│ │ │ Posture │ Description │ Evidence Level │ │ │
│ │ ├───────────────────┼───────────────────────────────┼─────────────────┤ │ │
│ │ │ None │ No runtime observation │ Static only │ │ │
│ │ │ Passive │ Container events only │ Low │ │ │
│ │ │ ActiveTracing │ Syscall + network monitoring │ Medium │ │ │
│ │ │ EbpfDeep │ Full eBPF instrumentation │ High │ │ │
│ │ │ FullInstrumentation│ eBPF + userspace probes │ Maximum │ │ │
│ │ └─────────────────────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ └──────────────────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────────────┘
2.3 Hot Symbol Index
Runtime observations are aggregated into the Hot Symbol Index for reachability correlation.
┌─────────────────────────────────────────────────────────────────────────────────────┐
│ HOT SYMBOL INDEX │
├─────────────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ PostgreSQL Storage │ │
│ │ │ │
│ │ Table: signals.hot_symbols │ │
│ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │
│ │ │ Column │ Type │ Description │ │ │
│ │ ├─────────────────────┼─────────────┼─────────────────────────────────┤ │ │
│ │ │ image_digest │ text │ Container image SHA256 │ │ │
│ │ │ function_name │ text │ Fully qualified function name │ │ │
│ │ │ module │ text │ Package/library containing func │ │ │
│ │ │ purl │ text │ Package URL for module │ │ │
│ │ │ invocation_count │ bigint │ Total observed calls │ │ │
│ │ │ first_observed │ timestamptz │ First invocation timestamp │ │ │
│ │ │ last_observed │ timestamptz │ Most recent invocation │ │ │
│ │ │ unique_callers │ int │ Distinct call sites │ │ │
│ │ │ sample_stack │ jsonb │ Representative stack trace │ │ │
│ │ └─────────────────────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ │ Indexes: │ │
│ │ • (image_digest, function_name) - PRIMARY │ │
│ │ • (purl, function_name) - lookup by package │ │
│ │ • (invocation_count DESC) - hot path ranking │ │
│ │ │ │
│ └──────────────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ Query Patterns │ │
│ │ │ │
│ │ -- Is function in vulnerable package ever called? │ │
│ │ SELECT invocation_count > 0 │ │
│ │ FROM signals.hot_symbols │ │
│ │ WHERE image_digest = $1 │ │
│ │ AND purl = $2 │ │
│ │ AND function_name = $3; │ │
│ │ │ │
│ │ -- Get all observed functions for a package │ │
│ │ SELECT function_name, invocation_count, sample_stack │ │
│ │ FROM signals.hot_symbols │ │
│ │ WHERE image_digest = $1 AND purl = $2 │ │
│ │ ORDER BY invocation_count DESC; │ │
│ │ │ │
│ └──────────────────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────────────┘
3. Call Graph Analysis Layer
3.1 ReachGraph Architecture
The ReachGraph module constructs and analyzes call graphs for reachability determination.
┌─────────────────────────────────────────────────────────────────────────────────────┐
│ REACHGRAPH ARCHITECTURE │
├─────────────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────┐ │
│ │ SBOM + Binaries │ │
│ └──────────┬──────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ GRAPH INDEXER │ │
│ │ │ │
│ │ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │ │
│ │ │ SBOM Ingestion │ │ Binary Symbol │ │ Advisory Overlay│ │ │
│ │ │ │ │ Extraction │ │ │ │ │
│ │ ├─────────────────┤ ├─────────────────┤ ├─────────────────┤ │ │
│ │ │ • Package nodes │ │ • Function nodes│ │ • CVE → Package │ │ │
│ │ │ • Dependency │ │ • Call edges │ │ • Affected func │ │ │
│ │ │ edges │ │ • Import edges │ │ (if known) │ │ │
│ │ └─────────────────┘ └─────────────────┘ └─────────────────┘ │ │
│ │ │ │
│ └───────────────────────────────────┬───────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ GRAPH DATA MODEL │ │
│ │ │ │
│ │ Node Types: Edge Types: │ │
│ │ ┌─────────────┐ ┌─────────────────────┐ │ │
│ │ │ Package │ │ DEPENDS_ON │ │ │
│ │ │ Function │ │ CALLS │ │ │
│ │ │ File │ │ IMPORTS │ │ │
│ │ │ EntryPoint │ │ CONTAINS │ │ │
│ │ │ CVE │ │ AFFECTS │ │ │
│ │ └─────────────┘ │ ENTRY_FOR │ │ │
│ │ └─────────────────────┘ │ │
│ │ │ │
│ │ Example Graph Fragment: │ │
│ │ │ │
│ │ [EntryPoint:main.js] ──CALLS──► [Function:lodash.template] │ │
│ │ │ │ │ │
│ │ │ │ │ │
│ │ ──ENTRY_FOR──► [Package:myapp@1.0] ◄──DEPENDS_ON── [Package:lodash@4.17]│ │
│ │ ▲ │ │
│ │ │ │ │
│ │ [CVE-2021-23337] ─┘ AFFECTS │ │
│ │ │ │
│ └──────────────────────────────────────────────────────────────────────────────┘ │
│ │
│ │ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ GRAPH ANALYTICS ENGINE │ │
│ │ │ │
│ │ ┌───────────────────────┐ ┌───────────────────────┐ │ │
│ │ │ Label Propagation │ │ Centrality Scoring │ │ │
│ │ │ Clustering │ │ │ │ │
│ │ ├───────────────────────┤ ├───────────────────────┤ │ │
│ │ │ Groups related │ │ Identifies critical │ │ │
│ │ │ components into │ │ nodes (high impact │ │ │
│ │ │ clusters for impact │ │ if compromised) │ │ │
│ │ │ analysis │ │ │ │ │
│ │ └───────────────────────┘ └───────────────────────┘ │ │
│ │ │ │
│ └──────────────────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────────────┘
3.2 Reachability Slice Service
BFS-based path finding for reachability queries.
┌─────────────────────────────────────────────────────────────────────────────────────┐
│ REACHGRAPH SLICE SERVICE │
├─────────────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ SLICE OPERATIONS │ │
│ │ │ │
│ │ Query: "Is CVE-2021-23337 reachable from any entry point?" │ │
│ │ │ │
│ │ ┌────────────────────────────────────────────────────────────────────┐ │ │
│ │ │ BFS TRAVERSAL │ │ │
│ │ │ │ │ │
│ │ │ [EntryPoint:main.js] │ │ │
│ │ │ │ │ │ │
│ │ │ │ depth=0 │ │ │
│ │ │ ▼ │ │ │
│ │ │ [Function:app.renderTemplate] │ │ │
│ │ │ │ │ │ │
│ │ │ │ depth=1 │ │ │
│ │ │ ▼ │ │ │
│ │ │ [Function:lodash.template] ◄── CVE-2021-23337 │ │ │
│ │ │ │ │ │ │
│ │ │ │ depth=2 │ │ │
│ │ │ ▼ │ │ │
│ │ │ REACHABLE! Path length: 2 │ │ │
│ │ │ │ │ │
│ │ └────────────────────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ └──────────────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ SLICE TYPES │ │
│ │ │ │
│ │ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │ │
│ │ │ Package Slice │ │ CVE Slice │ │ File Slice │ │ │
│ │ ├─────────────────┤ ├─────────────────┤ ├─────────────────┤ │ │
│ │ │ All paths to │ │ All paths to │ │ All functions │ │ │
│ │ │ functions in │ │ affected │ │ in a specific │ │ │
│ │ │ a package │ │ function │ │ source file │ │ │
│ │ └─────────────────┘ └─────────────────┘ └─────────────────┘ │ │
│ │ │ │
│ │ ┌─────────────────┐ │ │
│ │ │ EntryPoint Slice│ │ │
│ │ ├─────────────────┤ │ │
│ │ │ All reachable │ │ │
│ │ │ code from a │ │ │
│ │ │ given entry │ │ │
│ │ └─────────────────┘ │ │
│ │ │ │
│ └──────────────────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────────────┘
3.3 Eight-State Reachability Classification
┌─────────────────────────────────────────────────────────────────────────────────────┐
│ 8-STATE REACHABILITY LATTICE │
├─────────────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌───────────────────┐ │
│ │ LiveExploitPath │ Confirmed exploit path │
│ │ (Highest) │ exists with runtime proof │
│ └─────────┬─────────┘ │
│ │ │
│ ┌─────────▼─────────┐ │
│ │ DynamicReachable │ Runtime observed │
│ │ │ (eBPF evidence) │
│ └─────────┬─────────┘ │
│ │ │
│ ┌─────────▼─────────┐ │
│ │ StaticReachable │ Static analysis found │
│ │ │ call path exists │
│ └─────────┬─────────┘ │
│ │ │
│ ┌─────────▼─────────┐ │
│ │PotentiallyReachable│ Import exists but │
│ │ │ no direct call found │
│ └─────────┬─────────┘ │
│ │ │
│ ┌─────────▼─────────┐ │
│ │ Unknown │ Insufficient data │
│ │ (Default) │ to determine │
│ └─────────┬─────────┘ │
│ │ │
│ ┌───────────────────────┼───────────────────────┐ │
│ │ │ │ │
│ ┌────────▼────────┐ ┌─────────▼─────────┐ ┌────────▼────────┐ │
│ │ NotReachable │ │ GateBlocked │ │ NotApplicable │ │
│ │ │ │ │ │ │ │
│ │ Static analysis │ │ Dead code path │ │ Language/OS │ │
│ │ proves no path │ │ behind feature │ │ mismatch │ │
│ │ │ │ flag or ifdef │ │ │ │
│ └─────────────────┘ └───────────────────┘ └─────────────────┘ │
│ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ STATE TRANSITION RULES │ │
│ │ │ │
│ │ Unknown + RuntimeEvidence → DynamicReachable │ │
│ │ Unknown + StaticPathFound → StaticReachable │ │
│ │ StaticReachable + RuntimeEvidence → DynamicReachable │ │
│ │ DynamicReachable + ExploitProof → LiveExploitPath │ │
│ │ Unknown + NoPath → NotReachable │ │
│ │ Any + DeadCodeFlag → GateBlocked │ │
│ │ Any + PlatformMismatch → NotApplicable │ │
│ │ │ │
│ └──────────────────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────────────┘
4. Binary Analysis Layer
4.1 Binary Identity Extraction
┌─────────────────────────────────────────────────────────────────────────────────────┐
│ BINARY IDENTITY EXTRACTION │
├─────────────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ SUPPORTED FORMATS │ │
│ │ │ │
│ │ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │ │
│ │ │ ELF │ │ PE │ │ Mach-O │ │ │
│ │ │ (Linux) │ │ (Windows) │ │ (macOS) │ │ │
│ │ ├─────────────────┤ ├─────────────────┤ ├─────────────────┤ │ │
│ │ │ │ │ │ │ │ │ │
│ │ │ .note.gnu. │ │ CodeView GUID │ │ LC_UUID │ │ │
│ │ │ build-id │ │ (PDB link) │ │ load command │ │ │
│ │ │ │ │ │ │ │ │ │
│ │ │ Build-ID: │ │ GUID: │ │ UUID: │ │ │
│ │ │ SHA1 or SHA256 │ │ 16-byte + age │ │ 16-byte │ │ │
│ │ │ │ │ │ │ │ │ │
│ │ └─────────────────┘ └─────────────────┘ └─────────────────┘ │ │
│ │ │ │
│ └──────────────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ IDENTITY EXTRACTION FLOW │ │
│ │ │ │
│ │ Binary File │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────┐ │ │
│ │ │ Format Detection │ │ │
│ │ │ (Magic bytes: 0x7F ELF, MZ, etc) │ │ │
│ │ └──────────────────┬──────────────────┘ │ │
│ │ │ │ │
│ │ ┌──────────────┼──────────────┐ │ │
│ │ ▼ ▼ ▼ │ │
│ │ ┌───────┐ ┌───────┐ ┌───────┐ │ │
│ │ │ ELF │ │ PE │ │Mach-O │ │ │
│ │ │Parser │ │Parser │ │Parser │ │ │
│ │ └───┬───┘ └───┬───┘ └───┬───┘ │ │
│ │ │ │ │ │ │
│ │ └──────────────┼──────────────┘ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────┐ │ │
│ │ │ BinaryIdentity │ │ │
│ │ ├─────────────────────────────────────┤ │ │
│ │ │ build_id: string │ │ │
│ │ │ format: ELF | PE | MachO │ │ │
│ │ │ arch: x86_64 | arm64 | ... │ │ │
│ │ │ linked_libraries: [string] │ │ │
│ │ │ exported_symbols: [Symbol] │ │ │
│ │ │ imported_symbols: [Symbol] │ │ │
│ │ │ sections: [Section] │ │ │
│ │ └─────────────────────────────────────┘ │ │
│ │ │ │
│ └──────────────────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────────────┘
4.2 Function Fingerprinting
┌─────────────────────────────────────────────────────────────────────────────────────┐
│ FUNCTION FINGERPRINTING │
├─────────────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ FINGERPRINT COMPONENTS │ │
│ │ │ │
│ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │
│ │ │ BasicBlockHash │ │ │
│ │ │ │ │ │
│ │ │ • Hash of normalized instruction sequence per basic block │ │ │
│ │ │ • Ignores register names (normalized to r0, r1, etc.) │ │ │
│ │ │ • Ignores immediate addresses (normalized to <addr>) │ │ │
│ │ │ • Preserves instruction opcodes and operand types │ │ │
│ │ │ │ │ │
│ │ │ Example: │ │ │
│ │ │ mov rax, [rbp-8] → mov r0, [r1-<off>] │ │ │
│ │ │ call 0x401000 → call <addr> │ │ │
│ │ │ ret → ret │ │ │
│ │ │ │ │ │
│ │ │ Hash: SHA256(normalized_bytes) → 32-byte fingerprint │ │ │
│ │ │ │ │ │
│ │ └─────────────────────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │
│ │ │ CfgHash │ │ │
│ │ │ │ │ │
│ │ │ • Hash of control flow graph structure │ │ │
│ │ │ • Encodes: (basic_block_count, edge_count, edge_types) │ │ │
│ │ │ • Captures function complexity and branching pattern │ │ │
│ │ │ │ │ │
│ │ │ CFG: ┌─────┐ │ │ │
│ │ │ │ BB0 │──────┐ │ │ │
│ │ │ └──┬──┘ │ (conditional) │ │ │
│ │ │ │ ▼ │ │ │
│ │ │ ┌──▼──┐ ┌─────┐ │ │ │
│ │ │ │ BB1 │ │ BB2 │ │ │ │
│ │ │ └──┬──┘ └──┬──┘ │ │ │
│ │ │ │ │ │ │ │
│ │ │ └────┬────┘ │ │ │
│ │ │ ┌──▼──┐ │ │ │
│ │ │ │ BB3 │ (exit) │ │ │
│ │ │ └─────┘ │ │ │
│ │ │ │ │ │
│ │ │ CfgHash = hash(4 blocks, 4 edges, [fall,cond,fall,fall]) │ │ │
│ │ │ │ │ │
│ │ └─────────────────────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │
│ │ │ StringRefsHash │ │ │
│ │ │ │ │ │
│ │ │ • Hash of string literals referenced by function │ │ │
│ │ │ • Useful for identifying specific error handlers, log messages │ │ │
│ │ │ • Sorted before hashing for determinism │ │ │
│ │ │ │ │ │
│ │ │ References: ["error: invalid input", "debug: %s", "OK"] │ │ │
│ │ │ Sorted: ["OK", "debug: %s", "error: invalid input"] │ │ │
│ │ │ StringRefsHash = SHA256(sorted_refs) │ │ │
│ │ │ │ │ │
│ │ └─────────────────────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ └──────────────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ COMPOSITE FINGERPRINT │ │
│ │ │ │
│ │ FunctionFingerprint { │ │
│ │ name: "vulnerable_func", │ │
│ │ basic_block_hash: "a1b2c3...", │ │
│ │ cfg_hash: "d4e5f6...", │ │
│ │ string_refs_hash: "789abc...", │ │
│ │ instruction_count: 47, │ │
│ │ cyclomatic_complexity: 5, │ │
│ │ composite_hash: SHA256(bb_hash || cfg_hash || str_hash) │ │
│ │ } │ │
│ │ │ │
│ └──────────────────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────────────┘
4.3 Patch Detection Engine
┌─────────────────────────────────────────────────────────────────────────────────────┐
│ PATCH DETECTION ENGINE │
├─────────────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ DETECTION WORKFLOW │ │
│ │ │ │
│ │ ┌─────────────────┐ ┌─────────────────┐ │ │
│ │ │ Target Binary │ │ Known Patched │ │ │
│ │ │ (from scan) │ │ Reference │ │ │
│ │ └────────┬────────┘ └────────┬────────┘ │ │
│ │ │ │ │ │
│ │ ▼ ▼ │ │
│ │ ┌─────────────────┐ ┌─────────────────┐ │ │
│ │ │ Extract │ │ Extract │ │ │
│ │ │ Fingerprints │ │ Fingerprints │ │ │
│ │ └────────┬────────┘ └────────┬────────┘ │ │
│ │ │ │ │ │
│ │ └───────────┬───────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────┐ │ │
│ │ │ PatchDiffEngine │ │ │
│ │ ├─────────────────────────┤ │ │
│ │ │ │ │ │
│ │ │ For each CVE function: │ │ │
│ │ │ 1. Find in target │ │ │
│ │ │ 2. Compare fingerprint │ │ │
│ │ │ 3. Compute similarity │ │ │
│ │ │ │ │ │
│ │ └────────────┬────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────┐ │ │
│ │ │ SIMILARITY SCORING │ │ │
│ │ │ │ │ │
│ │ │ CFG Similarity: │ │ │
│ │ │ cfg_sim = 1 - (edit_distance / max_size) │ │ │
│ │ │ │ │ │
│ │ │ Block Similarity: │ │ │
│ │ │ block_sim = matching_blocks / total │ │ │
│ │ │ │ │ │
│ │ │ Composite: │ │ │
│ │ │ score = 0.6*cfg_sim + 0.4*block_sim │ │ │
│ │ │ │ │ │
│ │ │ Thresholds: │ │ │
│ │ │ > 0.95 : Exact match (patched) │ │ │
│ │ │ 0.80-0.95: Likely patched │ │ │
│ │ │ 0.50-0.80: Uncertain │ │ │
│ │ │ < 0.50 : Likely vulnerable │ │ │
│ │ │ │ │ │
│ │ └─────────────────────────────────────────────┘ │ │
│ │ │ │
│ └──────────────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ BACKPORT DETECTION │ │
│ │ │ │
│ │ Scenario: Package reports version 1.2.3 but has backported patch │ │
│ │ │ │
│ │ Version Mismatch: │ │
│ │ Declared: lodash@4.17.15 (vulnerable per NVD) │ │
│ │ Binary Analysis: patch_similarity = 0.97 (matches 4.17.21 fix) │ │
│ │ │ │
│ │ Result: │ │
│ │ evidence_type: BACKPORTED_PATCH │ │
│ │ confidence: 0.97 │ │
│ │ recommendation: Consider NOT_AFFECTED despite version │ │
│ │ │ │
│ └──────────────────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────────────┘
5. Confidence Scoring System
5.1 Evidence-Weighted Score Formula
┌─────────────────────────────────────────────────────────────────────────────────────┐
│ CONFIDENCE SCORING SYSTEM │
├─────────────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ SCORING FORMULA │ │
│ │ │ │
│ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │
│ │ │ │ │ │
│ │ │ FinalScore = Σ (Weight_i × NormalizedScore_i) × 100 │ │ │
│ │ │ │ │ │
│ │ │ Where: │ │ │
│ │ │ i ∈ {Reachability, Runtime, VEX, Provenance, Policy} │ │ │
│ │ │ Σ Weight_i = 1.0 │ │ │
│ │ │ NormalizedScore_i ∈ [0.0, 1.0] │ │ │
│ │ │ │ │ │
│ │ └─────────────────────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ └──────────────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ FACTOR BREAKDOWN │ │
│ │ │ │
│ │ ┌───────────────────────────────────────────────────────────────────┐ │ │
│ │ │ FACTOR │ WEIGHT │ DESCRIPTION │ │ │
│ │ ├─────────────────┼────────┼────────────────────────────────────────┤ │ │
│ │ │ Reachability │ 0.30 │ Can code path reach vulnerable func? │ │ │
│ │ │ (RCH) │ │ │ │ │
│ │ │ │ │ 1.0 = LiveExploitPath │ │ │
│ │ │ │ │ 0.9 = DynamicReachable │ │ │
│ │ │ │ │ 0.7 = StaticReachable │ │ │
│ │ │ │ │ 0.5 = PotentiallyReachable │ │ │
│ │ │ │ │ 0.3 = Unknown │ │ │
│ │ │ │ │ 0.1 = NotReachable │ │ │
│ │ ├─────────────────┼────────┼────────────────────────────────────────┤ │ │
│ │ │ Runtime │ 0.25 │ Is function observed at runtime? │ │ │
│ │ │ (RTS) │ │ │ │ │
│ │ │ │ │ 1.0 = Observed with high frequency │ │ │
│ │ │ │ │ 0.8 = Observed at least once │ │ │
│ │ │ │ │ 0.5 = No observation (neutral) │ │ │
│ │ │ │ │ 0.2 = Never observed (long window) │ │ │
│ │ ├─────────────────┼────────┼────────────────────────────────────────┤ │ │
│ │ │ VEX │ 0.20 │ Vendor VEX statement consensus │ │ │
│ │ │ (VEX) │ │ │ │ │
│ │ │ │ │ 1.0 = Exploitable (high trust vendor) │ │ │
│ │ │ │ │ 0.7 = Under investigation │ │ │
│ │ │ │ │ 0.5 = No VEX (neutral) │ │ │
│ │ │ │ │ 0.2 = Not affected (high trust) │ │ │
│ │ ├─────────────────┼────────┼────────────────────────────────────────┤ │ │
│ │ │ Provenance │ 0.15 │ Build/supply chain evidence │ │ │
│ │ │ (PRV) │ │ │ │ │
│ │ │ │ │ 1.0 = Untrusted/unknown source │ │ │
│ │ │ │ │ 0.7 = Partial attestation │ │ │
│ │ │ │ │ 0.3 = Full SLSA L3+ attestation │ │ │
│ │ │ │ │ 0.1 = Verified reproducible build │ │ │
│ │ ├─────────────────┼────────┼────────────────────────────────────────┤ │ │
│ │ │ Policy │ 0.10 │ Exception/override status │ │ │
│ │ │ (POL) │ │ │ │ │
│ │ │ │ │ 1.0 = No exception │ │ │
│ │ │ │ │ 0.5 = Time-bounded exception │ │ │
│ │ │ │ │ 0.1 = Permanent waiver │ │ │
│ │ └───────────────────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ └──────────────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ EXAMPLE CALCULATION │ │
│ │ │ │
│ │ CVE-2021-23337 in lodash@4.17.15: │ │
│ │ │ │
│ │ ┌────────────────────────────────────────────────────────────────┐ │ │
│ │ │ Factor │ Value │ Norm │ Weight │ Weighted │ │ │
│ │ ├──────────────┼──────────────────┼───────┼────────┼────────────┤ │ │
│ │ │ Reachability │ StaticReachable │ 0.70 │ 0.30 │ 0.210 │ │ │
│ │ │ Runtime │ Not observed │ 0.50 │ 0.25 │ 0.125 │ │ │
│ │ │ VEX │ No VEX │ 0.50 │ 0.20 │ 0.100 │ │ │
│ │ │ Provenance │ Partial attest │ 0.70 │ 0.15 │ 0.105 │ │ │
│ │ │ Policy │ No exception │ 1.00 │ 0.10 │ 0.100 │ │ │
│ │ ├──────────────┼──────────────────┼───────┼────────┼────────────┤ │ │
│ │ │ TOTAL │ │ │ │ 0.640 │ │ │
│ │ └────────────────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ │ Final Confidence Score: 0.640 × 100 = 64 │ │
│ │ Interpretation: Medium-High confidence this is exploitable │ │
│ │ │ │
│ └──────────────────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────────────┘
5.2 Confidence Factor Visualization
┌─────────────────────────────────────────────────────────────────────────────────────┐
│ CONFIDENCE FACTOR DIAGRAM │
├─────────────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────┐ │
│ │ FINDING │ │
│ │ CVE-2021-23337 │ │
│ │ lodash@4.17.15 │ │
│ └──────────┬──────────┘ │
│ │ │
│ ┌──────────────────────────────────┼──────────────────────────────────┐ │
│ │ │ │ │
│ │ ┌──────────────────────────────┼──────────────────────────────┐ │ │
│ │ │ │ │ │ │
│ ▼ ▼ ▼ ▼ ▼ │
│ ┌───────────┐ ┌───────────┐ ┌───────────┐ ┌───────────┐ ┌───────────┐ │
│ │REACHABILITY│ │ RUNTIME │ │ VEX │ │PROVENANCE │ │ POLICY │ │
│ │ (0.30) │ │ (0.25) │ │ (0.20) │ │ (0.15) │ │ (0.10) │ │
│ ├───────────┤ ├───────────┤ ├───────────┤ ├───────────┤ ├───────────┤ │
│ │ │ │ │ │ │ │ │ │ │ │
│ │ ReachGraph│ │ Signals │ │ VexLens │ │ Attestor │ │ Exception │ │
│ │ call path │ │ eBPF │ │ Consensus│ │ SLSA │ │ Store │ │
│ │ analysis │ │ Hot Syms │ │ OpenVEX │ │ DSSE │ │ │ │
│ │ │ │ │ │ │ │ │ │ │ │
│ └─────┬─────┘ └─────┬─────┘ └─────┬─────┘ └─────┬─────┘ └─────┬─────┘ │
│ │ │ │ │ │ │
│ │ ┌──────────┘ │ │ │ │
│ │ │ ┌───────────────────────┘ │ │ │
│ │ │ │ ┌────────────────────────────────────┘ │ │
│ │ │ │ │ ┌───────────────────────────────────────────────┘ │
│ │ │ │ │ │ │
│ ▼ ▼ ▼ ▼ ▼ │
│ ┌─────────────────────────────────────────────────────────────────────┐ │
│ │ CONFIDENCE AGGREGATOR │ │
│ │ │ │
│ │ score = Σ(weight_i × factor_score_i) │ │
│ │ │ │
│ │ ┌─────────────────────────────────────────────────────────────┐ │ │
│ │ │ │ │ │
│ │ │ ████████████████████████████████████████░░░░░░░░░░░░░░░░ │ │ │
│ │ │ |-------- 64% confidence this is exploitable ---------| │ │ │
│ │ │ │ │ │
│ │ │ Components: │ │ │
│ │ │ [RCH: 21%] [RTS: 12.5%] [VEX: 10%] [PRV: 10.5%] [POL: 10%]│ │ │
│ │ │ │ │ │
│ │ └─────────────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ └──────────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────────────┘
6. Policy Engine Decision Layer
6.1 K4 Belnap Four-Valued Logic
┌─────────────────────────────────────────────────────────────────────────────────────┐
│ K4 BELNAP FOUR-VALUED LOGIC │
├─────────────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ TRUTH VALUES │ │
│ │ │ │
│ │ ┌───────┐ │ │
│ │ │ ⊤ │ BOTH (Conflict) │ │
│ │ │ Both │ Evidence says both true AND false │ │
│ │ └───┬───┘ │ │
│ │ ╱ ╲ │ │
│ │ ╱ ╲ │ │
│ │ ╱ ╲ │ │
│ │ ┌─────┴─────┐ ┌─────┴─────┐ │ │
│ │ │ T │ │ F │ │ │
│ │ │ True │ │ False │ │ │
│ │ │ │ │ │ │ │
│ │ └─────┬─────┘ └─────┬─────┘ │ │
│ │ ╲ ╱ │ │
│ │ ╲ ╱ │ │
│ │ ╲ ╱ │ │
│ │ └───┬───┘ │ │
│ │ │ ⊥ │ UNKNOWN (Neither) │ │
│ │ │Neither│ No evidence either way │ │
│ │ └───────┘ │ │
│ │ │ │
│ └──────────────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ LATTICE OPERATIONS │ │
│ │ │ │
│ │ JOIN (∨) - combines evidence, prefers "more information" │ │
│ │ ┌─────────┬─────────┬─────────┬─────────┬─────────┐ │ │
│ │ │ ∨ │ ⊥ │ T │ F │ ⊤ │ │ │
│ │ ├─────────┼─────────┼─────────┼─────────┼─────────┤ │ │
│ │ │ ⊥ │ ⊥ │ T │ F │ ⊤ │ │ │
│ │ │ T │ T │ T │ ⊤ │ ⊤ │ │ │
│ │ │ F │ F │ ⊤ │ F │ ⊤ │ │ │
│ │ │ ⊤ │ ⊤ │ ⊤ │ ⊤ │ ⊤ │ │ │
│ │ └─────────┴─────────┴─────────┴─────────┴─────────┘ │ │
│ │ │ │
│ │ MEET (∧) - requires agreement, prefers "less information" │ │
│ │ ┌─────────┬─────────┬─────────┬─────────┬─────────┐ │ │
│ │ │ ∧ │ ⊥ │ T │ F │ ⊤ │ │ │
│ │ ├─────────┼─────────┼─────────┼─────────┼─────────┤ │ │
│ │ │ ⊥ │ ⊥ │ ⊥ │ ⊥ │ ⊥ │ │ │
│ │ │ T │ ⊥ │ T │ ⊥ │ T │ │ │
│ │ │ F │ ⊥ │ ⊥ │ F │ F │ │ │
│ │ │ ⊤ │ ⊥ │ T │ F │ ⊤ │ │ │
│ │ └─────────┴─────────┴─────────┴─────────┴─────────┘ │ │
│ │ │ │
│ └──────────────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ APPLICATION IN POLICY │ │
│ │ │ │
│ │ Rule: "Block if vulnerability is reachable" │ │
│ │ │ │
│ │ ┌────────────────────────────────────────────────────────────────┐ │ │
│ │ │ Evidence Sources │ Individual │ Combined (∨) │ Decision │ │ │
│ │ ├───────────────────────┼────────────┼──────────────┼───────────┤ │ │
│ │ │ Static analysis │ T │ │ │ │ │
│ │ │ Runtime observation │ ⊥ │ T ∨ ⊥ │ │ │ │
│ │ │ VEX says not affected │ F │ = T ∨ F │ │ │ │
│ │ │ │ │ = ⊤ (Both) │ CONFLICT │ │ │
│ │ └────────────────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ │ Conflict resolution: escalate for human review, default to cautious │ │
│ │ │ │
│ └──────────────────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────────────┘
6.2 Policy Gates
┌─────────────────────────────────────────────────────────────────────────────────────┐
│ POLICY GATES │
├─────────────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────────────────────────────────────────────────────────────────────┐ │
│ │ GATE EVALUATION ORDER │ │
│ │ │ │
│ │ Finding │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │
│ │ │ GATE 1: MinimumConfidenceGate │ │ │
│ │ │ │ │ │
│ │ │ Purpose: Skip low-confidence findings that would cause noise │ │ │
│ │ │ │ │ │
│ │ │ Config: │ │ │
│ │ │ min_confidence_to_evaluate: 0.3 │ │ │
│ │ │ min_confidence_to_fail: 0.5 │ │ │
│ │ │ │ │ │
│ │ │ Logic: │ │ │
│ │ │ if confidence < 0.3 → SKIP (don't evaluate) │ │ │
│ │ │ if confidence < 0.5 → WARN (evaluate but don't fail) │ │ │
│ │ │ else → continue to next gate │ │ │
│ │ │ │ │ │
│ │ └──────────────────────────────┬──────────────────────────────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │
│ │ │ GATE 2: ReachabilityRequirementGate │ │ │
│ │ │ │ │ │
│ │ │ Purpose: Only fail on findings with sufficient reachability proof │ │ │
│ │ │ │ │ │
│ │ │ Config: │ │ │
│ │ │ require_reachability_for: [critical, high] │ │ │
│ │ │ minimum_state: StaticReachable │ │ │
│ │ │ │ │ │
│ │ │ Logic: │ │ │
│ │ │ if severity in [critical,high]: │ │ │
│ │ │ if reachability < StaticReachable → WARN (downgrade) │ │ │
│ │ │ else → continue │ │ │
│ │ │ else → continue (reachability not required for medium/low) │ │ │
│ │ │ │ │ │
│ │ └──────────────────────────────┬──────────────────────────────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │
│ │ │ GATE 3: UnknownsBudgetGate │ │ │
│ │ │ │ │ │
│ │ │ Purpose: Allow some unknown components, fail if too many │ │ │
│ │ │ │ │ │
│ │ │ Config: │ │ │
│ │ │ max_unknown_packages: 10 │ │ │
│ │ │ max_unknown_percentage: 5% │ │ │
│ │ │ │ │ │
│ │ │ Logic: │ │ │
│ │ │ unknown_count = count(packages where purl is unparseable) │ │ │
│ │ │ if unknown_count > 10 OR unknown_count/total > 5% → FAIL │ │ │
│ │ │ else → continue │ │ │
│ │ │ │ │ │
│ │ └──────────────────────────────┬──────────────────────────────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │
│ │ │ GATE 4: SeverityThresholdGate │ │ │
│ │ │ │ │ │
│ │ │ Config: │ │ │
│ │ │ fail_on: [critical] │ │ │
│ │ │ warn_on: [high, medium] │ │ │
│ │ │ allow: [low, none] │ │ │
│ │ │ │ │ │
│ │ └──────────────────────────────┬──────────────────────────────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ FINAL VERDICT │ │
│ │ │ │
│ └──────────────────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────────────┘
6.3 Complete Decision Flow
┌─────────────────────────────────────────────────────────────────────────────────────┐
│ COMPLETE POLICY DECISION FLOW │
├─────────────────────────────────────────────────────────────────────────────────────┤
│ │
│ INPUTS PROCESSING OUTPUT │
│ ────── ────────── ────── │
│ │
│ ┌─────────────┐ │
│ │ SBOM │──┐ │
│ │ (packages) │ │ │
│ └─────────────┘ │ │
│ │ ┌─────────────────────────────────────┐ │
│ ┌─────────────┐ │ │ │ │
│ │ Advisories │──┼────►│ FINDING MATCHER │ │
│ │ (CVE/GHSA) │ │ │ │ │
│ └─────────────┘ │ │ package × advisory → findings │ │
│ │ │ │ │
│ ┌─────────────┐ │ └──────────────────┬──────────────────┘ │
│ │ VEX │──┘ │ │
│ │ (OpenVEX) │ │ │
│ └─────────────┘ │ │
│ ▼ │
│ ┌─────────────┐ ┌─────────────────────────────────────┐ │
│ │ Reachability│─────────────►│ │ │
│ │ (K4/8st) │ │ EVIDENCE AGGREGATOR │ │
│ └─────────────┘ │ │ │
│ │ For each finding: │ │
│ ┌─────────────┐ │ • Collect all evidence sources │ │
│ │ Runtime │─────────────►│ • Resolve conflicts (K4 logic) │ │
│ │ (Hot Syms) │ │ • Compute confidence score │ │
│ └─────────────┘ │ │ │
│ └──────────────────┬──────────────────┘ │
│ ┌─────────────┐ │ │
│ │ Exceptions │──┐ │ │
│ │ (waivers) │ │ ▼ │
│ └─────────────┘ │ ┌─────────────────────────────────────┐ │
│ │ │ │ │
│ ┌─────────────┐ │ │ GATE EVALUATOR │ │
│ │ Unknowns │──┼──────────►│ │ │
│ │ (budget) │ │ │ Gate 1: MinimumConfidence │ │
│ └─────────────┘ │ │ Gate 2: ReachabilityRequirement │ │
│ │ │ Gate 3: UnknownsBudget │ │
│ ┌─────────────┐ │ │ Gate 4: SeverityThreshold │ │
│ │ Policy │──┘ │ │ │
│ │ (rules) │ └──────────────────┬──────────────────┘ │
│ └─────────────┘ │ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────┐ │
│ │ │ │
│ │ VERDICT BUILDER │ │
│ │ │ ┌────────┐ │
│ │ Aggregate gate results: │ │ │ │
│ │ • Any FAIL → FAIL │──►│ VERDICT│ │
│ │ • Any WARN → WARN │ │ │ │
│ │ • All PASS → PASS │ │ (DSSE) │ │
│ │ │ │ │ │
│ │ Generate explain trace │ └────────┘ │
│ │ │ │
│ └─────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────────────┘
7. Data Contracts Summary
7.1 Input Data Structures
// SBOM Input
interface SbomInput {
format: 'cyclonedx' | 'spdx';
version: string;
components: Component[];
dependencies: Dependency[];
metadata: SbomMetadata;
}
// Advisory Input
interface AdvisoryInput {
source: 'nvd' | 'ghsa' | 'osv' | 'oval';
id: string; // CVE-2021-23337
severity: Severity;
affected_packages: AffectedRange[];
fixed_versions?: string[];
references: Reference[];
}
// VEX Input
interface VexInput {
format: 'openvex' | 'csaf' | 'cyclonedx-vex';
issuer: string;
trust_level: number; // 0.0-1.0
statements: VexStatement[];
}
// Reachability Input
interface ReachabilityInput {
state: ReachabilityState; // 8-state enum
evidence: {
static_paths?: CallPath[];
runtime_observations?: RuntimeObservation[];
binary_match?: BinaryMatchResult;
};
confidence: number;
}
// Runtime Input
interface RuntimeInput {
image_digest: string;
hot_symbols: HotSymbol[];
runtime_posture: RuntimePosture;
observation_window: TimeRange;
}
7.2 Output Data Structures
// Policy Verdict
interface PolicyVerdict {
scan_id: string;
verdict: 'PASS' | 'WARN' | 'FAIL' | 'SKIP';
timestamp: string; // ISO-8601 UTC
findings: EvaluatedFinding[];
summary: {
total_findings: number;
by_verdict: Record<Verdict, number>;
by_severity: Record<Severity, number>;
confidence_distribution: Distribution;
};
explain_trace: ExplainTrace;
attestation: DsseEnvelope;
}
// Evaluated Finding
interface EvaluatedFinding {
finding_id: string;
cve: string;
package: string; // PURL
verdict: 'PASS' | 'WARN' | 'FAIL' | 'SKIP';
evidence: {
severity: SeverityEvidence;
reachability: ReachabilityEvidence;
vex: VexEvidence;
runtime: RuntimeEvidence;
exception: ExceptionEvidence;
};
confidence: {
score: number; // 0-100
factors: ConfidenceFactors;
};
gate_results: GateResult[];
k4_value: K4Value; // Unknown, True, False, Both
}
8. Related Documentation
- Policy Evaluation Flow - Policy evaluation sequence
- SBOM Generation Flow - SBOM creation process
- Reachability Drift Alert Flow - Runtime drift detection
- Risk Score Dashboard Flow - Risk aggregation
- Module Matrix - Complete module inventory
- Scanner Architecture - Scanner module dossier
- Policy Architecture - Policy engine dossier
- Signals Architecture - Runtime observation