Dependency and Artifact Signing

An SBOM tells you what is inside an artifact. Provenance tells you where it came from and how it was built. Signing binds an artifact to a verifiable origin so consumers can reject anything that was not produced by your trusted pipeline.

Without provenance, an attacker who swaps a tarball in your registry is indistinguishable from a legitimate release.

The foundation of integrity is content addressing. A cryptographic hash (digest) of an artifact uniquely identifies that exact bytes. Mutable tags like latest can be re-pointed; a digest cannot.

A digital signature uses a private key to sign the artifact's hash; anyone with the matching public key can verify it. This gives two guarantees:

• Integrity — the artifact was not modified after signing
• Authenticity — it was signed by the holder of the private key

The hard part is not the math; it is key management and trust distribution: how does a verifier know which public key to trust?

Traditional signing forces teams to guard long-lived private keys, which leak. Sigstore offers keyless signing: it issues a short-lived certificate tied to an OIDC identity (like a CI workload or developer email), signs, and records the event in a public transparency log called Rekor.

There is no long-lived key to steal, and every signature is publicly auditable.

Cosign is the Sigstore tool for signing container images and other artifacts. In keyless mode it uses the pipeline's OIDC token, so no key file lives on disk.

Sigstore records each signing event in Rekor, a tamper-evident, append-only public log. This is a powerful detective control:

• You can prove when something was signed
• An attacker who steals an identity cannot sign secretly — the event is publicly logged
• Anomalous signatures (unexpected identity, off-hours) become detectable

Transparency turns silent compromise into observable evidence.

SLSA (Supply-chain Levels for Software Artifacts) is a framework that grades how trustworthy your build process is. Higher levels demand stronger guarantees against tampering.

• L1 — provenance exists and is documented
• L2 — signed provenance from a hosted build service
• L3 — hardened, isolated builds; provenance is non-forgeable even by a pipeline insider

SLSA is a roadmap: pick a target level and close the gaps.

A provenance attestation is a signed statement describing how an artifact was built: the source commit, builder identity, build parameters, and inputs. The in-toto format standardizes this.

Signing is only useful if something refuses unsigned artifacts. In Kubernetes, an admission controller can block any image lacking a valid signature and provenance from your trusted identity.

• Policy controllers verify cosign signatures before a pod starts
• Reject images signed by unexpected identities
• Require provenance pointing to your approved source repository

This closes the loop: untrusted artifacts never run.

Provenance is most valuable when it extends to what you consume, not just what you ship. Ecosystems are adding native signing and provenance:

• npm provenance links a published package to its source commit and CI run
• Container base images increasingly ship cosign signatures
• Language registries are piloting Sigstore-backed verification

Prefer dependencies that publish verifiable provenance, and verify it during install where supported.

A practical signing strategy is layered and verified end to end:

• Pin inputs by digest
• Keyless-sign artifacts and attach SBOM plus provenance attestations
• Record everything in a transparency log
• Enforce verification at deploy with an admission policy

The chain is only as strong as its weakest unverified link, so verify at every consumption point.

Reason about why keyless signing improves supply chain security.

You learned to prove provenance and enforce it.

• Pin by digest, not mutable tags
• Digital signatures give integrity and authenticity; the challenge is key management
• Sigstore + cosign enable keyless signing with a public Rekor transparency log
• SLSA grades build integrity; provenance attestations record how artifacts were built
• Admission policies reject anything unsigned or untrusted at deploy time

Next: hardening the CI/CD pipeline that produces these artifacts.