supraj.dev

Explainer · Supply chain security

Prove what runs in your clusterSigning images, SBOMs and provenance, then checking them at the door.

Your security lead asks: can you prove every image in production was built by our pipeline from our source, and list what is inside it? Here is how to make the answer yes, with Sigstore, SBOMs, SLSA provenance and an admission policy that refuses anything else.

Supraj Maripeddi · · 17 min read

Cover: a container image box with a sha256 lot number, carrying three labels: a signature, an SBOM ingredients list and a build record. It passes a pharmacy counter that checks who signed it before it reaches the cluster.
Start hereYou ship container images from CI to Kubernetes, and you've used a registry tag like :v1.4.2.
Leave knowingHow keyless signing works, what an SBOM and provenance add, and how to make the cluster reject images your pipeline didn't sign.
Keep in mindA signature proves who signed, not that the code is safe. The value is in checking the signer's identity.

Picture a hospital pharmacy. Boxes of medicine arrive every day. Each box carries a lot number, an ingredients leaflet, a batch record from the factory, and a tamper seal. The pharmacist doesn't take any of that on trust. At the counter, they check that the seal belongs to the right factory before a single box goes on the shelf.

Most Kubernetes clusters have no counter. Images arrive from a registry, and the cluster runs whatever the tag points to. That works until a security lead, reading about the latest supply chain attack, asks the platform team a short question: can you prove every image running in production was built by our pipeline, from our source, and list what is inside it? This article builds the counter. The lot number is the image digest, the seal is a Sigstore signature, the leaflet is an SBOM, the batch record is SLSA provenance, and the counter is an admission policy.

01 / The situation

Why can't the platform team answer the question?

Because nothing in a normal pipeline records the answer in a form anyone can check. The registry knows which bytes it holds. It doesn't know who built them, from which commit, or whether someone with push access swapped them later.

SLSA, a supply chain security specification now at version 1.2, maps where attacks happen. [1] Three of its examples match the security lead's worry. An attacker compromised the SolarWinds build platform and injected malicious behaviour "during each build". Codecov's attacker "used leaked credentials to upload a malicious artifact" to a storage bucket that users downloaded from. And in a typosquatting attack, someone uploaded a malicious package "with a similar name as the original". [1]

That's a tampered build, a tampered artifact after the build, and the wrong artifact chosen by mistake. Sigstore's overview lists similar risks for unsigned software, including "tampering after being published". [7] SLSA is honest that it doesn't fix everything. For typosquatting it says it "does not directly address this threat", though provenance linking back to source can help other defences. [1]

In the pharmacy
Boxes go straight from the delivery van to the shelf. Nobody checks the seal, so a swapped or look-alike box is shelved like any other.
In the cluster
Pods pull whatever the registry returns for a tag. Nothing ties the image to your pipeline, your commit or a list of its contents.

02 / The lot number

Why isn't a tag enough?

A tag is a label that can move. A digest is the identity of the content. The Kubernetes docs put it directly: digests "are hashes of the image's content, and are immutable. Tags can be moved to point to different images, but digests are fixed." [6] A digest looks like sha256: followed by the hash. If an image reference has both a tag and a digest, Kubernetes says "only the digest will be used for pulling". [6]

That matters for proof. If you deploy by tag and the registry's tag changes, the docs warn you "might end up with a mix of Pods running the old and new code". Pinning by digest means "a change at the registry cannot lead to that mix of versions". [6] The same docs mention third-party admission controllers that rewrite pods to use digests. The policy in chapter 7 does exactly that.

Signatures depend on this too. Cosign's signature payload includes "the digest of the container image they are attached to", and by default cosign verify checks that the digest matches. [14] So you sign the digest, never the tag. Sigstore's CI example builds the reference as tag@digest before signing for this reason. [13]

In the pharmacy
"Paracetamol 500" is a shelf label. The lot number printed on the box is what the batch record and the recall notice refer to.
In the cluster
:v1.4.2 is a movable tag. @sha256:... is the content itself, and it's what signatures and attestations point at.

03 / The seal

How does keyless signing work?

Classic signing means guarding a private key for years, and revoking it if it leaks. [7] Sigstore swaps the long-lived key for an identity. Your artifact is "signed" by a client such as Cosign, "associated" with an identity through the Fulcio certificate authority, and "witnessed" in the Rekor transparency log. [7]

Here's the flow when a CI job runs cosign sign with no key.

Figure 1 · One keyless signature, step by step

  1. 1. Key in memoryCosign makes a fresh key pair that never leaves the job.
  2. 2. Identity tokenThe CI provider issues an OIDC token with aud sigstore.
  3. 3. Fulcio certificateFulcio checks the token and binds the identity to the public key.
  4. 4. Sign the digestThe image digest is signed. The private key is thrown away.
  5. 5. Rekor entryThe signing event goes into a public, append-only log.
  6. 6. VerifyCheck the signature, the identity, the issuer and the log entry.
Whole picture

Six steps, and no long-lived key anywhere. Step through to see what each one proves.

Based on Sigstore's overview, its keyless signing overview and the Fulcio docs. The same flow runs on GitHub Actions, GitLab CI and other supported OIDC issuers.

The details matter. Cosign creates "an in-memory public/private keypair". [8] The identity token must include an audience of sigstore. [12] Fulcio "signs X.509 certificates valid for 10 minutes". [9] The private key "is discarded after a single signing", and Sigstore services "never obtain your private key". [7] Rekor is "an immutable, tamper-resistant ledger"; the public instance at rekor.sigstore.dev has a 99.5% availability SLO. [10]

A ten-minute certificate sounds fragile. It isn't, because verifiers don't ask whether the certificate is valid now. They ask whether the artifact was signed while it was valid, and the Rekor entry's signed timestamp answers that. [11] Fulcio was "designed to avoid revocation" this way. [11]

What identity ends up in the certificate?

For a GitHub Actions job, Fulcio takes the token's job_workflow_ref claim and writes it as a URI: https://github.com/{job_workflow_ref}. [12] Sigstore's docs give the values to expect when verifying. [12]

certificate-oidc-issuer: https://token.actions.githubusercontent.com
certificate-identity:    https://github.com/USERNAME/REPOSITORY_NAME/.github/workflows/WORKFLOW_NAME@refs/heads/BRANCH_NAME

That string is the heart of the whole system. It names a repository, a workflow file and a branch. "Signed" on its own means very little, since anyone with a GitHub or Google account can get a certificate. Verification has to ask: signed by which identity? Sigstore says verifying "requires the user of your software to have prior knowledge of the identity of the signer". [33]

In the pharmacy
The factory's packer shows staff ID at a licensing office and gets a stamp that works for ten minutes. Every stamping is written in a public register.
In the cluster
The CI job shows an OIDC token to Fulcio, gets a ten-minute certificate for a one-time key, signs the digest, and the event lands in Rekor.

04 / The leaflet

What is an SBOM, and should it be SPDX or CycloneDX?

A software bill of materials lists what an artifact contains: packages, versions, licences and their dependencies. It answers the second half of the security lead's question. When the next vulnerable library makes the news, you search SBOMs instead of guessing.

There are two widely used formats, and Cosign supports both. [19]

The two SBOM standards, as their own sites describe them
QuestionSPDXCycloneDX
Standard ISO/IEC 5962:2021. Version 3.0.0 released April 2024. [20] ECMA-424, driven by OWASP and Ecma TC54. [21]
Roots Started in 2010 at the Linux Foundation; 3.0 added Security, Build, Dataset and AI profiles. [20] Built for supply chain risk; also covers services, VEX, hardware and ML BOMs. [21]
Attestation predicate type https://spdx.dev/Document from cosign attest --type spdxjson. [34] https://cyclonedx.org/bom, which OWASP names "the official predicate type". [21]

Either is fine. Pick the one your scanners and auditors already read. If nobody has a preference, CycloneDX JSON is a practical default here, because it's the format the Kyverno documentation's worked SBOM checks use. [27]

A loose file isn't proof. Attach it as an attestation.

An SBOM sitting in a bucket can be swapped like any other file. So you wrap it in a signed attestation: an in-toto statement whose subject is the image digest and whose predicate is the SBOM. [15] Cosign signs these payloads with the DSSE signing spec and stores them next to the image. [15] Its --type flag accepts spdx, spdxjson, cyclonedx, slsaprovenance1 and others. [17]

Generate the SBOM from the built image, not from a lockfile, so it reflects what shipped. Syft does this and writes both formats, for example syft <image> -o cyclonedx-json=./cdx.json. [22]

In the pharmacy
The ingredients leaflet is printed inside the sealed box, so nobody can swap it without breaking the seal.
In the cluster
The SBOM is the predicate of a signed attestation whose subject is the image digest. Change either and verification fails.

05 / The batch record

What does SLSA provenance add on top of a signature?

A signature says who signed. Provenance says how the artifact was made. SLSA defines it as an attestation "that a particular build platform produced a set of software artifacts", with the predicate type https://slsa.dev/provenance/v1. [4] The fields you'll check most: [4]

  • builder.id: the build platform you are trusting.
  • buildType: the template that ran, which tells you how to read the parameters.
  • externalParameters: the inputs from outside the platform, such as the repository and ref. SLSA calls these untrusted: they "MUST be verified downstream".
  • resolvedDependencies: what the build fetched, such as the exact commit, if known.

What do the Build levels promise?

SLSA's Build track has four levels. [2]

SLSA v1.2 Build levels
LevelRequirementProtects against
Build L0NoneNothing
Build L1Provenance showing how the package was builtMistakes. "Trivial to bypass or forge."
Build L2Signed provenance, generated by a hosted build platformTampering after the build
Build L3Hardened build platformTampering during the build

One requirement catches teams out. From L2 up, provenance "MUST be generated by the control plane" and not by a tenant of the build platform. [3] A JSON file your own build script writes and signs is L1 at best, however official it looks. At L3, signing secrets "MUST NOT be accessible to the environment running the user-defined build steps". [3]

On GitHub, the platform does this for you. GitHub's artifact attestations sign provenance with Sigstore, and GitHub says they provide "SLSA v1.0 Build Level 2" on their own. [23] Running the build in a shared reusable workflow can "provide isolation between the build process and the calling workflow, to meet SLSA v1.0 Build Level 3". [23]

How is provenance verified?

SLSA's verification steps are a useful checklist. Check the builder identity is one you trust, verify the signature, confirm the statement's subject "matches the digest of the artifact", and compare buildType and externalParameters with what you expect. [5] Its table of expectations includes the canonical source repository, "to prevent an adversary from building from an unofficial fork". [5] And keep the limit in view: L3 "does not cover compromise of the build platform itself, such as by a malicious insider". [5]

In the pharmacy
The batch record is written by the factory's own control system, not by the worker on the line. The line worker can't edit it.
In the cluster
Provenance is generated and signed by the build platform's control plane. Build steps you wrote can't forge it at L3.

06 / The playbook, part one

How do you build a pipeline that produces all three?

The example uses GitHub Actions and GHCR, since that's what Sigstore's CI quickstart documents. Other OIDC issuers work the same way with a different identity string. Assume an organization acme, a repository payments and a workflow file release.yml that runs on pushes to main.

The job builds and pushes once, captures the digest, then signs it, attests an SBOM to it and asks the platform for provenance about it.

name: release
on:
  push:
    branches: [ main ]
jobs:
  build:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      packages: write
      id-token: write      # OIDC token for keyless signing
      attestations: write  # GitHub artifact attestations
    steps:
      # Pin every action to a full commit SHA in real use.
      - uses: actions/checkout@v4
        with:
          persist-credentials: false
      - uses: sigstore/cosign-installer@v4.0.0
      - uses: docker/login-action@v3.6.0
        with:
          registry: ghcr.io
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}
      - id: build
        uses: docker/build-push-action@v6.18.0
        with:
          push: true
          tags: ghcr.io/acme/payments:${{ github.sha }}

      - name: Sign the digest
        env:
          DIGEST: ${{ steps.build.outputs.digest }}
        run: cosign sign --yes "ghcr.io/acme/payments@${DIGEST}"

      - name: SBOM, attested to the same digest
        env:
          DIGEST: ${{ steps.build.outputs.digest }}
        run: |
          syft "ghcr.io/acme/payments@${DIGEST}" -o cyclonedx-json=./cdx.json
          cosign attest --yes --type cyclonedx --predicate ./cdx.json \
            "ghcr.io/acme/payments@${DIGEST}"

      - name: SLSA provenance from the platform
        uses: actions/attest@v4
        with:
          subject-name: ghcr.io/acme/payments
          subject-digest: ${{ steps.build.outputs.digest }}
          push-to-registry: true

Each piece comes from the official docs. The id-token: write permission is what lets the job request an OIDC token. [13] The --yes flag "agrees to Sigstore's terms of use". [13] GitHub's attest action needs attestations: write, and for images also packages: write; subject-name must not include a tag. [24] Syft isn't installed in the snippet. Install it from a pinned, verified release, the way you'd want others to install your software.

Verify before you promote

Sigstore's own CI example verifies straight after signing, with the exact identity. [13] Do the same, and check the SBOM attestation and the provenance too. For keyless flows, cosign verify needs both an identity and an issuer: "Either --certificate-identity or --certificate-identity-regexp must be set", and the same for the issuer. [18]

IMG="ghcr.io/acme/payments@${DIGEST}"
ID="https://github.com/acme/payments/.github/workflows/release.yml@refs/heads/main"
ISS="https://token.actions.githubusercontent.com"

cosign verify "$IMG" \
  --certificate-identity "$ID" --certificate-oidc-issuer "$ISS"

cosign verify-attestation "$IMG" --type cyclonedx \
  --certificate-identity "$ID" --certificate-oidc-issuer "$ISS"

gh attestation verify "oci://ghcr.io/acme/payments:${GITHUB_SHA}" -R acme/payments

cosign tree "$IMG"   # list what is attached to the digest

gh attestation verify takes the image with an oci:// prefix and the repository with -R. [24] If the build runs in a reusable workflow, add --signer-workflow to require that exact workflow. [25] Signatures are stored with the OCI 1.1 referrers specification, and cosign tree lists what's attached. [16]

In the pharmacy
One production run gets one lot number. The seal, the leaflet and the batch record all quote that number, and quality control checks them before the boxes leave.
In the cluster
One build gets one digest. The signature, the SBOM attestation and the provenance all name that digest, and the pipeline verifies them before promotion.

07 / The playbook, part two

How does the cluster refuse what it can't verify?

An admission controller checks each pod before it's stored. Two are built for this.

Kyverno ImageValidatingPolicy and the Sigstore policy-controller
QuestionKyverno ImageValidatingPolicySigstore policy-controller
Policy language CEL expressions calling verifyImageSignatures and verifyAttestationSignatures. [27] ClusterImagePolicy with authorities, plus optional CUE or Rego on attestations. [31]
Trial mode validationActions: [Audit], results in PolicyReports. [29] mode: warn admits but warns. [31]
Scope Image globs or CEL in matchImageReferences. [27] Namespaces opt in with a label; unmatched images are rejected by default. [31]
Good fit You already run Kyverno for other policies. You want GitHub's documented provenance enforcement, which uses this controller. [26]
If you run Kyverno, check your version first Kyverno 1.20, announced on 12 November 2026, removed the legacy engine. ClusterPolicy rules, including verifyImages, "no longer execute in any Kyverno controller". The replacement for verifyImages is ImageValidatingPolicy. [28] Older blog posts and examples using kind: ClusterPolicy with verifyImages won't enforce anything on 1.20.

My recommendation: if Kyverno is already in the cluster, use ImageValidatingPolicy for your own images. Here is a policy that requires the exact release workflow identity and a signed CycloneDX SBOM from the same identity. It starts in Audit.

apiVersion: policies.kyverno.io/v1
kind: ImageValidatingPolicy
metadata:
  name: require-acme-release-pipeline
spec:
  validationActions: [Audit]        # switch to [Deny] in chapter 8
  failurePolicy: Fail
  webhookConfiguration:
    timeoutSeconds: 15
  matchConstraints:
    resourceRules:
      - apiGroups: ['']
        apiVersions: ['v1']
        operations: ['CREATE', 'UPDATE']
        resources: ['pods']
  matchImageReferences:
    - glob: 'ghcr.io/acme/*'
  validationConfigurations:
    mutateDigest: true    # rewrite tags to digests
    verifyDigest: true
    required: true
  attestors:
    - name: release
      cosign:
        keyless:
          identities:
            - issuer: 'https://token.actions.githubusercontent.com'
              subject: 'https://github.com/acme/payments/.github/workflows/release.yml@refs/heads/main'
        ctlog:
          url: 'https://rekor.sigstore.dev'
  attestations:
    - name: sbom
      intoto:
        type: https://cyclonedx.org/bom
  validations:
    - expression: >-
        images.containers.map(image, verifyImageSignatures(image, [attestors.release])).all(e, e > 0)
      message: image must be signed by the acme/payments release workflow on main
    - expression: >-
        images.containers.map(image, verifyAttestationSignatures(image, attestations.sbom, [attestors.release])).all(e, e > 0) &&
        images.containers.map(image, extractPayload(image, attestations.sbom).predicate.bomFormat == 'CycloneDX').all(e, e)
      message: image must carry a signed CycloneDX SBOM from the same workflow

Every field here appears in Kyverno's ImageValidatingPolicy docs. [27] Two details are easy to get wrong. For an attestation made with cosign attest, extractPayload() returns the whole in-toto statement, so the SBOM's fields sit under predicate. And extractPayload() "requires prior attestation verification via verifyAttestationSignatures()". [27]

Why the exact subject matters

Kyverno's docs also allow subjectRegExp and issuerRegExp. [27] A pattern like https://github\.com/.+ with the GitHub issuer looks strict. It isn't. It matches every workflow in every repository on GitHub, including one an attacker creates in five minutes. Try it below.

Figure 2 · Will this pod get through the door?

The image being deployed
What the policy checks
Policy mode

Pick an image, a check and a mode to see what the admission policy would do.

Toy example for ghcr.io/acme/payments. Certificate identities follow Sigstore's documented formats. The regexp option is subjectRegExp: https://github\.com/.+ with the GitHub issuer.

The same idea with policy-controller

In a ClusterImagePolicy, keyless authorities list identities the same way, and subject is a strict match while subjectRegExp is a regular expression. [32] Each policy that matches an image must pass, and within a policy any one authority is enough: "each ClusterImagePolicy that matches is AND for admission, and within each ClusterImagePolicy authorities are OR". [31]

apiVersion: policy.sigstore.dev/v1beta1
kind: ClusterImagePolicy
metadata:
  name: acme-release-pipeline
spec:
  mode: warn              # default is enforce
  images:
    - glob: "ghcr.io/acme/**"
  authorities:
    - keyless:
        identities:
          - issuer: https://token.actions.githubusercontent.com
            subject: https://github.com/acme/payments/.github/workflows/release.yml@refs/heads/main

Namespaces opt in with kubectl label namespace NAME policy.sigstore.dev/include=true. [31] To enforce GitHub's provenance attestations, GitHub documents installing this controller with its own trust-policies Helm chart, which "will reject artifacts that have not originated from within your GitHub organization". [26]

In the pharmacy
The counter checks the stamp names this factory and this production line. A genuine stamp from a different factory is still turned away.
In the cluster
The policy checks issuer and exact subject. A valid Sigstore signature from any other workflow or account fails.

08 / Rolling it out

How do you switch it on without breaking every deploy?

Start by watching, not blocking. Kyverno's reports guide says it plainly: "Use audit results to assess the impact of a policy before switching to Deny." [29] In Audit, a non-compliant pod is created and the failure is recorded in a report. [29]

  1. Sign everything first. Ship the pipeline from chapter 6 to every service that deploys to the target clusters. Redeploy so running pods use signed digests.
  2. Apply the policy in Audit. List failures with kubectl get policyreport -A and read the failed results. [29]
  3. Sort every failure into a bucket. Unsigned own image: fix the pipeline. Wrong identity: fix the workflow or the policy. Third-party image: see below.
  4. Switch one namespace to Deny. Pick a low-risk one. For Kyverno, a NamespacedImageValidatingPolicy keeps the change inside that namespace. [27]
  5. Widen to production once reports stay clean, and keep a written exception process.

What about images you didn't build?

Base images, databases, operators and cloud agents won't carry your identity. You have three honest options.

  • Verify the vendor's own identity. If the publisher signs with Sigstore and publishes its signer identity, add a separate attestor for it. Sigstore asks projects to publish that identity "in an easily discoverable place". [33] Don't guess it from a blog post.
  • Mirror, review and re-sign. Copy the image into your registry by digest through a pipeline that scans it, generates an SBOM and signs it with your identity. Then one policy covers everything in ghcr.io/acme/.
  • Exempt it on purpose. Policy-controller supports a static authority with action: pass for images that may have no signatures. [31] Kyverno supports PolicyExceptions to bypass a policy without editing it, and 1.20 added expiration and metadata to them. [27] [28] Keep the list short and reviewed.

Policy-controller has one more switch worth knowing. An image that matches no policy is rejected by default; the no-match-policy setting can be warn, allow or deny, and the docs suggest warn while rolling out. [31]

In the pharmacy
For a month the counter logs every unsealed box but still shelves it. Then one ward at a time starts refusing them, with a signed list of approved exceptions.
In the cluster
Audit mode records failures in PolicyReports. Then Deny goes live one namespace at a time, with reviewed exceptions for third-party images.

09 / In production

What goes wrong, and what should you watch?

Common mistakes

  • Checking for a signature, not a signer. A regexp that admits any GitHub workflow admits strangers.
  • Trusting a shared reusable workflow alone. The certificate's URI is the job_workflow_ref, which names the workflow that ran, not necessarily the repository that called it. Sigstore's own example shows a workflow in octo-org/octo-automation running for octo-org/octo-repo. [12] Kyverno's docs warn that since workflows can be reused, "it is important to verify the identity of both the executing workflow and the actual workflow used for signing". [27] Cosign has --certificate-github-workflow-repository for this check, and Kyverno 1.20 can match certificate extensions. [18] [28]
  • Signing tags. Sign image@digest. A signature on what a tag pointed to yesterday doesn't cover what it points to today.
  • Mismatched predicate types. Cosign's spdxjson type produces https://spdx.dev/Document, while GitHub's docs verify SPDX SBOM attestations with https://spdx.dev/Document/v2.3. [34] [24] Write the policy for the string your producer actually emits.
  • Private registries. ImageValidatingPolicy doesn't read the pod's imagePullSecrets; registry secrets must be listed in the policy and live in the Kyverno namespace. [27]
  • Private GitHub repositories. Their artifact attestations use GitHub's own Sigstore instance, which "does not have a transparency log". Public repositories use the public-good instance. [23] Your verifier needs the right trust root. Kyverno 1.20 added support for this. [28]
  • Failing open by accident. Sigstore's attestation docs warn that an attacker may "delete or hide" attestations, and that systems "should be designed to fail closed rather than open". [15] Keep failurePolicy: Fail. In Kubernetes, that means an error calling the webhook "causes the admission to fail and the API request to be rejected", while Ignore lets the request through. [35] Test what your deploys do when the policy engine is slow or down.

What to monitor

  • Policy failures. Kyverno exports kyverno_image_validating_policy_results_total. Its docs give this query for failures in the last day: sum(increase(kyverno_image_validating_policy_results_total{result="fail"}[24h])) by (policy_name). [30] In Audit, a rising count is your to-do list. In Deny, it's blocked deploys.
  • Admission latency. Verification adds work to every pod admission. Watch kyverno_admission_review_duration_seconds so slow checks show up before timeouts do. [30]
  • Your identity in the logs. Sigstore says artifact owners "should monitor the log for their identity", and Fulcio "does not monitor the certificate transparency log" for you. [8] [11] A signing event for your release identity that no pipeline run explains points to a compromised workflow or token. Rekor's docs point to a Rekor monitor that runs as a reusable GitHub workflow. [10]
  • Reports in Deny mode. Reports describe resources that exist, so for blocked requests Kyverno says to "use metrics and Kubernetes Events". [29]
In the pharmacy
The pharmacist reads the stamping register each week. A stamp in the factory's name that no production run explains means someone has the stamp who shouldn't.
In the cluster
You monitor Rekor for your release identity, plus policy failures and admission latency. An unexplained signing event is an incident.

With this in place, the security lead's question has an answer. Every image in production passed a check that its digest was signed by your release workflow on main, logged in Rekor, with a signed SBOM and platform provenance attached. You can show the policy, the reports and the attestations for any pod.

Keep these names

A small glossary

Digest
A hash of an image's content, such as sha256:.... It can't be moved.
Tag
A human-friendly name for an image, such as :v1.4.2. It can be moved.
Keyless signing
Signing with a one-time key bound to an OIDC identity by a short-lived certificate.
OIDC identity token
A signed token from an issuer such as GitHub Actions that says who or what is running.
Fulcio
Sigstore's certificate authority. It issues certificates valid for 10 minutes.
Rekor
Sigstore's append-only transparency log of signing events.
Certificate identity
The subject in the certificate, such as a workflow URI. Policies match on it with the issuer.
Attestation
A signed in-toto statement: a subject (the image digest) plus a typed predicate.
Predicate type
A URI naming what the attestation contains, such as https://cyclonedx.org/bom.
SBOM
Software bill of materials: what an artifact contains. SPDX and CycloneDX are the main formats.
Provenance
An attestation of how, where and from what an artifact was built.
SLSA Build level
L0 to L3: how hard it is to forge provenance or tamper with the build.
Admission controller
A Kubernetes webhook that checks or changes objects before they're stored.

Check the concept

Can you explain it back?

1. Why sign the digest and not the tag?

A tag can be moved to different content. The digest is a hash of the content itself, and Cosign's signature payload includes it, so verification fails if the bytes change.

2. Fulcio certificates last ten minutes. Why does a signature still verify next year?

Verifiers check that the artifact was signed while the certificate was valid. Rekor's signed timestamp on the log entry proves when the signing happened.

3. A policy accepts any subject matching https://github\.com/.+ with the GitHub issuer. What's wrong?

Any workflow in any GitHub repository can get a valid certificate that matches. The policy proves an image was signed by someone on GitHub, not by your pipeline.

4. Your build script writes a provenance JSON file and signs it. What SLSA Build level is that?

L1 at most. From L2, provenance must be generated by the build platform's control plane, not by a tenant's build steps.

5. Why start the admission policy in Audit?

Audit admits non-compliant pods but records failures in PolicyReports, so you can find unsigned images, wrong identities and third-party images before Deny blocks deploys.

Continue the thread

Related reading

Read further

Sources

All accessed 20 November 2026. SLSA pages are specification version 1.2; other docs are the live pages that day.

  1. SLSA v1.2: Supply chain threats
  2. SLSA v1.2: Build track basics
  3. SLSA v1.2: Build requirements for producing artifacts
  4. SLSA v1.2: Build provenance
  5. SLSA v1.2: Verifying artifacts
  6. Kubernetes docs: Images
  7. Sigstore docs: Overview
  8. Sigstore docs: Cosign signing overview (keyless)
  9. Sigstore docs: Fulcio
  10. Sigstore docs: Rekor
  11. Sigstore docs: Security model
  12. Sigstore docs: OIDC usage in Fulcio
  13. Sigstore docs: Sigstore CI quickstart
  14. Sigstore docs: Verifying signatures
  15. Sigstore docs: In-toto attestations
  16. Sigstore docs: Signing containers
  17. Cosign CLI reference: cosign attest
  18. Cosign CLI reference: cosign verify and cosign verify-attestation
  19. Sigstore docs: Cosign specifications (SBOM in OCI)
  20. SPDX: About SPDX
  21. CycloneDX: Specification overview and CycloneDX home
  22. Syft README (Anchore)
  23. GitHub Docs: Artifact attestations
  24. GitHub Docs: Using artifact attestations to establish provenance for builds
  25. GitHub Docs: Using artifact attestations and reusable workflows to achieve SLSA v1 Build Level 3
  26. GitHub Docs: Enforcing artifact attestations with a Kubernetes admission controller
  27. Kyverno docs: ImageValidatingPolicy and Sigstore (legacy verifyImages)
  28. Kyverno blog: Announcing Kyverno 1.20 (12 November 2026)
  29. Kyverno docs: Policy reports
  30. Kyverno docs: Metrics
  31. Sigstore docs: Kubernetes policy controller
  32. policy-controller source: ClusterImagePolicy v1beta1 types
  33. Sigstore docs: The importance of verification
  34. Cosign source: predicate types and in-toto-golang predicate URIs
  35. Kubernetes docs: Dynamic admission control (failure policy)

Written with AI assistance. Every technical claim was checked against the original sources listed above.