Software Supply Chain Security: Implement SBOMs, Signing, and Provenance in CI/CD
DevSecOpsSBOMSLSAContainer SecurityCI/CDSupply Chain Security

Software Supply Chain Security: Implement SBOMs, Signing, and Provenance in CI/CD

DDeployed Cloud Editorial Team
2026-11-14
9 min read

A practical checklist for adding SBOMs, signing, provenance, scanning, and verification to CI/CD without blocking routine releases.

Software supply chain security becomes manageable when it is treated as a sequence of verifiable release steps rather than a single scanning product. This checklist shows how to add dependency checks, SBOM generation, container image signing, provenance attestations, registry policy, and verification to a CI/CD pipeline without turning every release into a manual review.

Overview

A secure software supply chain should answer four practical questions for every production artifact:

  • What is in it? An SBOM records components, versions, and relationships discovered during the build or packaging process.
  • How was it built? Provenance describes relevant source, build inputs, workflow, and the relationship between the source and the resulting artifact.
  • Who produced it? A digital signature connects an artifact or attestation to an identity that your organization can verify.
  • May it be deployed? Verification and policy checks decide whether the artifact meets the requirements for a given environment.

These controls complement one another. A vulnerability scanner can identify a known issue, but it does not by itself prove where an image came from. A signature can show that an authorized identity signed an artifact, but it does not prove that the artifact is free of vulnerabilities. An SBOM improves investigation and inventory, while provenance helps establish build context. The goal is a chain of evidence that is useful to developers, platform engineers, security teams, and incident responders.

Start with one service and one delivery path. Document the artifact types you produce, the registries where they are stored, the identities used by CI, and the environments in which verification will occur. A narrow pilot makes it easier to identify missing permissions, incompatible registry behavior, and noisy vulnerability results before expanding the policy.

For background on inventory design, see the SBOM Implementation Guide. If container images are your first target, the Container Image Signing with Cosign guide provides a complementary signing and verification workflow.

Checklist by scenario

Scenario 1: Establish the minimum release inventory

Before adding release gates, create an inventory of the software and processes you need to protect.

  • List deployable artifacts, including container images, packages, binaries, Helm charts, and infrastructure modules where relevant.
  • Record each artifact's source repository, build workflow, registry, owner, and deployment environments.
  • Identify whether dependencies are downloaded during the build, copied from a base image, or supplied by another internal pipeline.
  • Define immutable identifiers for releases, such as a commit digest, image digest, package checksum, or release version.
  • Decide where SBOMs, signatures, and attestations will be stored and how they will be retained with the associated artifact.
  • Document the CI identity that is allowed to sign or attest. Avoid sharing signing credentials between unrelated projects.

Do not begin by requiring every historical artifact to meet a new standard. Define the boundary for new builds first, then create a migration plan for older releases.

Scenario 2: Add dependency and image scanning

Scanning is most useful when it produces an actionable result tied to a specific build. Run dependency and image scans at a point where the pipeline can still prevent publication, and repeat the relevant check before deployment if the artifact has changed.

  • Scan direct and transitive application dependencies using the package manifests and lockfiles available to the build.
  • Scan container base images and operating-system packages as well as application libraries.
  • Record the scanner, database or advisory source, scan timestamp, artifact digest, and result.
  • Separate exploitable production risk from a finding that is present but unreachable, unused, or mitigated by configuration.
  • Set a documented policy for blocking releases. Consider severity, exploitability, package reachability, exposure, and available remediation rather than severity alone.
  • Route accepted exceptions to an owner with an expiration date and compensating action.

Scanning should not be the only gate. A release can have no matching vulnerability and still be untrusted if its source, build process, or signing identity cannot be verified.

Scenario 3: Generate and retain an SBOM

Generate the SBOM from the build output or from the exact artifact that will be deployed. Choose a format supported by your inventory, security, and incident-response workflows; common choices include SPDX and CycloneDX.

  • Include the artifact name, version or digest, package identifiers, dependency relationships, and generation timestamp.
  • Capture the tool and process used to generate the SBOM so results can be compared after tool changes.
  • Attach the SBOM to the immutable artifact digest rather than only to a mutable tag.
  • Publish the SBOM to an access-controlled location that developers and responders can use.
  • Test whether your vulnerability platform can ingest the selected format and preserve component-to-artifact relationships.
  • Use the SBOM during incident response to find affected artifacts, but verify findings against the actual deployed digest.

An SBOM is an inventory, not a security verdict. Its value depends on completeness, accurate version identification, and a process for updating it when the artifact changes.

Scenario 4: Sign images and other release artifacts

Sign the digest that is released, not merely the source tag or a build directory. A signing system may use key-based or keyless identities, but the verification policy must state which identities and issuers are trusted.

  • Use a dedicated CI identity for signing and restrict its permissions to the repositories and environments it serves.
  • Ensure signatures are associated with immutable artifact digests.
  • Store signatures where the deployment system or admission control can retrieve them.
  • Verify a signature in a separate job before promotion, then verify again at the deployment boundary where practical.
  • Define behavior for missing, invalid, expired, or untrusted signatures.
  • Protect signing credentials and review access to identity-provider configuration, workload identity, and registry permissions.

For Kubernetes, signature verification can be placed in an admission or deployment policy. The policy should produce a clear failure message so the owning team can distinguish a missing signature from an identity mismatch or registry access problem.

Scenario 5: Add provenance attestations

Provenance connects an artifact to its source and build process. At minimum, capture the source revision, repository or project, build workflow, builder identity, and resulting artifact digest. The exact fields depend on the provenance format and CI system.

  • Generate provenance from the trusted build system rather than accepting a file supplied by an untrusted workspace.
  • Make the source revision and artifact digest unambiguous.
  • Record whether the build used external inputs, reusable workflows, privileged steps, or unpinned dependencies.
  • Prevent a later job from silently replacing the artifact after provenance is generated.
  • Verify that the attestation was signed by the expected workflow identity.
  • Use provenance as a promotion condition for sensitive environments once the pilot is reliable.

SLSA is a framework for describing and improving build integrity and provenance. Treat its levels or requirements as an adoption roadmap, not as a substitute for understanding your own threat model. A useful first milestone is verifiable provenance for a reproducible, centrally controlled build path.

Scenario 6: Enforce policy at the registry and deployment boundary

CI checks reduce risk, but they should not be the only place where trust is evaluated. A developer, compromised runner, or alternate publishing path could bypass a pipeline gate unless the registry and deployment platform apply their own controls.

  • Restrict who can push, delete, or retag release artifacts.
  • Prefer digest-based deployment references for production.
  • Require a valid signature and, where appropriate, an approved provenance attestation.
  • Allow only approved registries and repositories in deployment configuration.
  • Log verification decisions, policy failures, overrides, and changes to trust configuration.
  • Test rollback behavior when an older artifact no longer meets a newly introduced policy.

Deployment automation should make the trusted path easier than an exception. If teams must copy metadata manually or request repeated approvals for routine releases, they will be more likely to bypass the process.

Control or standardPrimary questionTypical use
SBOMWhat components are in the artifact?Inventory, vulnerability analysis, and incident response
Digital signatureWhich trusted identity signed this artifact?Artifact authenticity and deployment verification
Provenance attestationHow and from which source was it built?Build integrity, audit evidence, and promotion policy
SLSAHow can build and provenance integrity be improved?Adoption roadmap and supply chain requirements
Vulnerability scanDoes the artifact match known security findings?Risk assessment and release triage

What to double-check before enabling release gates

  • Digest consistency: Confirm that the digest scanned, signed, attested, stored, and deployed is the same digest.
  • Identity scope: Verify that a CI identity can sign only for the repositories and environments it is intended to serve.
  • Metadata availability: Test whether registries, proxies, and deployment tools preserve and retrieve signatures, SBOMs, and attestations.
  • Failure clarity: Ensure pipeline output distinguishes a vulnerability finding, a missing SBOM, an invalid signature, and an unavailable registry.
  • Exception ownership: Require a reason, responsible owner, compensating control, and review date for every exception.
  • Runner trust: Review who can modify workflows, use privileged build steps, access secrets, or influence release metadata.
  • Reproducibility expectations: Decide whether builds must be reproducible, merely traceable, or both. Do not claim reproducibility without testing it.
  • Operational recovery: Confirm that emergency releases and rollback artifacts have a documented, auditable path.

Keep verification close to the system that makes the deployment decision. A dashboard showing a green scan is useful, but it should not replace an enforceable check against the artifact digest and trust policy.

Common mistakes

  1. Generating an SBOM for the source tree only. The deployed image may include base-image packages, generated files, or dependencies that are not represented in the source repository.
  2. Signing mutable tags. Tags can move. Use the immutable digest as the object being signed and verified.
  3. Blocking on every scanner result. An unprioritized gate creates noise and encourages unsafe overrides. Define risk-based rules and a time-bound exception process.
  4. Trusting the CI job without validating its identity. A successful job is not sufficient evidence if unauthorized workflows can run with the same signing permissions.
  5. Keeping metadata separate from releases. If responders cannot locate the SBOM or provenance for a deployed digest, the control has limited operational value.
  6. Introducing policy without a migration path. Existing images, rollback versions, and emergency procedures need an explicit treatment before enforcement begins.
  7. Failing silently. A policy gate that emits only a generic error slows remediation and leads teams to bypass it.

When to revisit

Review the supply chain checklist before seasonal planning cycles, after a major CI/CD or registry change, and whenever the organization adds a new artifact type or deployment environment. Revisit it immediately after a supply chain incident, a compromised credential, an unexpected dependency, or a failed rollback.

Also schedule a periodic review of:

  • Signing identities, workload permissions, and trust roots.
  • SBOM format support, generation tools, and inventory retention.
  • Provenance fields and the security of reusable workflows and build runners.
  • Vulnerability thresholds, exception age, and remediation ownership.
  • Registry retention, immutability, access logs, and deletion controls.
  • Deployment verification coverage across Kubernetes, virtual machines, serverless workloads, and other targets.

Finish each review with one concrete improvement: protect another artifact class, remove a signing permission, automate an exception expiry, improve a failure message, or verify a previously unverified deployment path. For related operational context, see the Kubernetes Deployment Best Practices checklist and the GitOps vs. CI/CD decision guide. The objective is not to add every control at once; it is to make each release increasingly easy to trace, verify, and defend.

Related Topics

#DevSecOps#SBOM#SLSA#Container Security#CI/CD#Supply Chain Security
D

Deployed Cloud Editorial Team

Cloud Security and DevOps Editors

Senior editor and content strategist. Writing about technology, design, and the future of digital media. Follow along for deep dives into the industry's moving parts.