Chapter 23Lesson 03190–260 min

SBOMs, Component Provenance, Vulnerability Governance, Repository Firewall Concepts, and Supply-Chain Risk: Configuration, Design Choices, and Tradeoffs

Design supply-chain governance so repository controls, build-time analysis, evidence retention, current intelligence, and exception workflows complement one another. The goal is not maximum blocking; it is defensible, observable control with a known blast radius.

ArchitectureTradeoffsGovernanceEvidence retentionDeveloper experience

Learning objectives

  • Compare central repository governance with build-time/application scanners without treating them as substitutes.
  • Choose allowlist, denylist, quarantine, or review patterns according to evidence quality and bypass risk.
  • Separate immutable build evidence from mutable vulnerability and policy state in retention and audit designs.
  • Treat internal provenance and third-party package evidence differently while retaining a common artifact-digest link.
  • Design exception and deletion policies that preserve forensic, rollback, and reproducibility evidence.
Version/product baseline (27 August 2026). The dated Nexus reference line is 3.95.2-01 with Java 21. Repository Firewall/IQ examples are architecture or fixture exercises unless the learner already has an authorized license. Re-check live release notes, feature matrix, and integration documentation before applying version-specific UI/API steps.
Evidence boundary. A checksum/digest can prove byte identity relative to an expected value; an SBOM inventories declared/discovered components; provenance describes build origin/process; a signature authenticates according to its key/trust model; vulnerability intelligence is time-varying; policy is a governance decision. None of these alone proves that software is safe.
Safety boundary. Use only synthetic artifacts, loopback/private endpoints, fake namespaces, and local fixtures. Do not fetch suspicious packages for demonstrations, publish employer SBOMs, expose provenance secrets, delete production artifacts because a CVE appears, or bypass governed Nexus endpoints to make a build pass.

1. Start with the decision you need to defend

Architecture should begin with a decision, not a product logo. Examples: “May developers download this third-party component?”, “May this build enter release?”, “May this exact digest deploy to production?”, or “Which applications must be remediated after new intelligence appears?” Each decision has a different evidence context.

Nexus and Repository Firewall are strongest at controlled repository admission/consumption. Build scanners and application analysis have richer knowledge of which components are actually assembled into an application. Provenance verification belongs near build/release trust boundaries. A mature design connects these controls rather than forcing one control to answer every question.

2. Central repository governance versus build-time scanners

Pattern Strength Blind spot Production use
Repository admission Controls shared entry point before many builds consume a component. May not know application-specific reachability/context; bypassable if clients use public upstream directly. Govern dependency procurement and cache only approved content where supported.
Build/application scan Sees application composition and stage context. Acts later; the component may already have entered developer environments. Application policy, remediation, release gate, continuous monitoring.
Provenance verification Validates build-origin expectations for exact output digest. Does not enumerate every vulnerability. Release/deployment trust boundary.
SBOM archive + re-evaluation Preserves composition and enables later impact analysis. Inventory quality depends on generation/identification completeness. Incident response, customer/compliance evidence, new-CVE response.

3. Allowlists and denylists are governance shortcuts, not complete risk models

An allowlist can be appropriate for highly constrained production environments where only reviewed component identities/digests may enter. Its operational cost grows quickly and can block updates if ownership is weak. A denylist is easier to start but reacts only to what has already been identified as disallowed. Policy engines combine multiple attributes and can express richer rules, but policy quality and exception process become critical.

Whatever the choice, anchor entries to the right identity. A package name without version/digest may be too broad; a digest-only rule may ignore package semantics and ecosystem metadata. Record why the rule exists and who owns it.

4. Immutable bytes versus mutable risk state

Keep the immutable and mutable records separate:

  • Immutable build packet: artifact digest, source commit, build ID, SBOM for that build, provenance/attestation, signatures, publication timestamp.
  • Mutable governance stream: vulnerability intelligence updates, exploitability context, policy version, waiver state, owner, remediation status, deployment disposition.

This separation lets you answer both “what did we know then?” and “what do we know now?” without rewriting historical evidence.

5. Internal provenance versus third-party packages

For internally built software, the organization can often control the builder, source repository, build definition, signing/attestation identity, and provenance retention. For third-party packages, you may receive only ecosystem coordinates, hashes, vendor signatures, published SBOMs, or external provenance of varying quality. Do not invent internal-grade provenance for external packages.

A common model is to attach the evidence you actually have to the exact digest, record evidence source/trust level, and apply different admission requirements for first-party and third-party content.

6. Quarantine versus deletion

Quarantine or “hold” preserves evidence while preventing normal consumption. Deletion removes content from a repository and can destroy rollback or forensic options if done carelessly. When a vulnerability is discovered, the first action is usually to identify affected artifacts/deployments and govern new consumption—not to delete production evidence reflexively.

Storage reclamation is not security remediation. Chapter 18 showed that logical deletion and blob reclamation are separate. A security finding does not justify direct blob-file deletion or database edits.

7. SBOM/provenance evidence can itself be sensitive

SBOMs may reveal internal component names, versions, architecture, or dependency choices. Provenance may expose source URIs, builder identifiers, workflow names, or parameters. Treat evidence as governed data: classify it, redact secrets, control who can read it, and decide what customers or regulators receive. Do not put CI tokens, private keys, Authorization headers, or secret environment variables into attestations.

8. Evidence retention and rollback value

Retention should align artifact and evidence lifetimes. If you keep a release binary for two years but discard its SBOM/provenance after 30 days, future incident response loses context. Conversely, retaining every temporary development SBOM forever may be expensive and privacy-heavy. Define retention by artifact class and regulatory/forensic needs.

9. Worked scenario: choose controls for three paths

Path Recommended minimum controls Reason
Public dependency enters CI Governed Nexus proxy; optional licensed Firewall; package identity; current vulnerability policy; bypass controls. Admission happens before broad internal reuse.
Internal release publication Hosted repository; immutable version/digest; SBOM; build provenance; scoped publisher identity; signature where ecosystem/process supports it. Organization controls production and can preserve high-quality evidence.
Production deployment Verify exact digest + provenance expectation; re-evaluate current risk/policy; record deployment decision. Deployment should consume the exact artifact already built and reviewed.

10. Decision table

Choice Prefer left when… Prefer right when…
Central repository vs scanner only You can enforce one governed dependency route. Repository control is impossible; compensate with stronger build/application controls.
Allowlist vs risk policy Environment is small, safety-critical, tightly curated. Scale/diversity requires attribute-based decisions and exception workflow.
Quarantine vs immediate deletion You need review, evidence, rollback, or forensic preservation. Deletion is explicitly approved after impact/recovery analysis.
Evidence inline vs separate service Format supports stable association and scale is small. You need cross-repository search, signatures, retention, or continuous re-evaluation.

11. Knowledge check

Why is “scan only in CI” weaker than a governed proxy for procurement control?

Why might you retain a quarantined artifact/evidence rather than delete it immediately?

What evidence can an organization usually make stronger for first-party software than for third-party packages?

Why should policy decisions store a timestamp and policy version?

Can one global denylist replace provenance verification?

12. Summary and next step

The design pattern is layered: control shared dependency ingress, preserve immutable build evidence, re-evaluate mutable risk, and make exceptions auditable. Lesson 4 now breaks this design intentionally—stale intelligence, bypassed proxies, misunderstood signatures, unsafe deletion, and performance symptoms—to practice evidence-first diagnosis.

Official references and version notes

Keep the academy open

Support free, practical DevOps education.

Every lesson is designed to remain readable in a browser, downloadable from GitHub, and usable without a paid learning platform. Contributions help expand and maintain the curriculum.

Ethereum / ERC-20
0x716c4Ab160C4B66F31a28AE2448BfF68fc3a2ef0 Send only Ethereum/ERC-20 compatible assets to this address.