Home Blog Developer Experience and Pl Sigstore for software signing: getting started guide
Developer Experience and Pl January 29, 2026 8 min read

Sigstore for software signing: getting started guide

Developer Experience and Pl Enterprise Guide 2026 SCALE D2C D2C Technology Developer Experience and Pl Enterprise Guide 2026 SCALE D2C D2C Technology

Sigstore is an open-source project that makes cryptographic signing of software artefacts — container images, binaries, packages, and SBOMs — as easy as logging in with an email account. It eliminates the complexity of traditional GPG-based signing that has kept software supply chain security out of reach for most teams. In 2026, Sigstore is the emerging standard for supply chain integrity.

Why Software Signing Matters

Software supply chain attacks — where attackers compromise the build process, package registries, or distribution infrastructure to inject malicious code — have become one of the most impactful attack vectors in enterprise security. SolarWinds, Log4Shell exploitation, and XZ Utils backdoor all exploited weaknesses in software distribution trust. Cryptographic signing of software artefacts with verifiable identity provides a defence: consumers can verify that what they received was built by the expected party and has not been tampered with in transit.

633%
Increase in software supply chain attacks (2022–2024, Sonatype)
78%
Of enterprises now require SBOM with software purchases
SLSA 3
Minimum supply chain security level recommended for enterprise software

Sigstore Architecture

Sigstore is a set of tools and services working together to enable transparent, verifiable software signing:

✍️
Cosign
The primary CLI tool for signing and verifying container images and other OCI artefacts. Cosign attaches signatures as OCI artefacts to the same registry as the image, making distribution of signatures seamless.
🔐
Fulcio (Certificate Authority)
Sigstore's certificate authority that issues short-lived signing certificates tied to OIDC identity (GitHub Actions, Google Accounts, GitHub identity). No long-lived private keys to manage or rotate.
📋
Rekor (Transparency Log)
An immutable, append-only transparency log that records all signing events. Similar to Certificate Transparency for TLS certificates. Enables detection of unauthorised signing and provides an audit trail.
📦
Gitsign
Signs git commits using Sigstore identity, tying commits to the committer's OIDC identity (GitHub login) rather than a long-lived GPG key — solving the key management problem for commit signing.
💡 Keyless Signing

Sigstore's "keyless" signing model is its key innovation. Instead of generating and managing a long-lived private key (which can be stolen, lost, or forgotten), Sigstore generates an ephemeral key pair, binds it to an OIDC identity token (from GitHub Actions, Google, etc.), and records the short-lived certificate in Rekor. Verification does not require knowing the signer's public key in advance — you verify against the Rekor transparency log and the OIDC identity claim.

Signing Container Images with Cosign

Signing and verifying container images with Cosign in a GitHub Actions CI pipeline:

# GitHub Actions: Sign image after push
- name: Sign the container image
  uses: sigstore/cosign-installer@v3
  
- name: Sign
  run: |
    cosign sign --yes       ghcr.io/myorg/myimage@${{ steps.build.outputs.digest }}
  env:
    COSIGN_EXPERIMENTAL: 1  # Enables keyless signing

# Verify at deployment time
cosign verify   --certificate-identity-regexp="https://github.com/myorg/myrepo"   --certificate-oidc-issuer="https://token.actions.githubusercontent.com"   ghcr.io/myorg/myimage:latest

Policy Enforcement with Sigstore

Signing is only valuable if unsigned or incorrectly signed images cannot be deployed. Policy enforcement connects Sigstore to your Kubernetes admission control:

Policy ToolDescriptionBest For
Sigstore Policy ControllerKubernetes admission webhook enforcing Cosign signature policiesKubernetes-native enforcement
KyvernoKubernetes policy engine with Sigstore/Cosign integrationTeams already using Kyverno for policy
OPA / GatekeeperOpen Policy Agent with Cosign signature verificationComplex policy logic requirements
ConnaisseurKubernetes admission controller for image signature validationOrganisations wanting dedicated signing admission control

Signing SBOMs and Attestations

Sigstore's Cosign supports attaching signed attestations — structured claims about an artefact — alongside the signature. This enables signing SBOMs (Software Bill of Materials), SLSA provenance records, vulnerability scan results, and test results as verifiable claims tied to the artefact's identity:

# Generate and sign SBOM
syft ghcr.io/myorg/myimage:latest -o cyclonedx-json > sbom.json

cosign attest --yes   --predicate sbom.json   --type cyclonedx   ghcr.io/myorg/myimage@$DIGEST

# Verify SBOM attestation
cosign verify-attestation   --type cyclonedx   --certificate-identity-regexp="..."   ghcr.io/myorg/myimage:latest

Implementation Roadmap

01
Start with Container Image Signing
Add Cosign signing to your container image CI pipeline first — this is the highest-impact, lowest-friction starting point. Use keyless signing with GitHub Actions OIDC identity. One pipeline step; no key management required.
02
Add Signature Verification at Deployment
Install the Sigstore Policy Controller or Kyverno in your Kubernetes cluster. Start in audit mode (log policy violations without blocking) to understand your current signing coverage before enforcing.
03
Enforce Policy for New Deployments
Switch from audit to enforce mode for new applications. Allow a grace period for existing workloads while you sign their images. Define exceptions for third-party images you cannot sign (enforce on registry allow-list instead).
04
Add SBOM Attestations
Generate and sign SBOMs for all container images. Use Syft or Trivy for SBOM generation. Include SBOM attestation verification in your deployment policy — only images with valid SBOM attestations can deploy to production.

Frequently Asked Questions

Sigstore is an open-source project (developed by Google, Red Hat, and Purdue University, hosted by the Linux Foundation) that provides free, easy-to-use infrastructure for cryptographic signing and verification of software artefacts. It was created to solve the software supply chain security problem: existing signing tools (GPG) were too complex for most developers, leading to widespread adoption of unsigned software that could be tampered with in transit. Sigstore's keyless, OIDC-based signing model eliminates key management complexity while providing cryptographically strong supply chain integrity guarantees backed by a public transparency log.

Keyless signing in Sigstore means you do not generate, manage, or store a long-lived private key for signing. Instead, Cosign generates an ephemeral key pair at signing time, obtains a short-lived signing certificate from Fulcio (tied to your OIDC identity — GitHub Actions token, Google account, etc.), signs the artefact, and records the event in Rekor's transparency log. The ephemeral keys are discarded after signing. Verification uses the Rekor log and the OIDC identity claim to verify authenticity without needing to know the signer's public key in advance. This eliminates the most common failure mode of traditional signing: compromised or lost private keys.

Cosign signs container images by generating a signature over the image's content digest (SHA256 hash) and pushing that signature as a separate OCI artefact to the same container registry, tagged with a predictable naming convention. This co-locates the signature with the image — no separate signature distribution infrastructure required. For keyless signing, Cosign also records the signing event (certificate and image digest) in the Rekor transparency log. Verifiers use cosign verify with the expected OIDC identity constraints to check both the signature against the image digest and the signing event against the Rekor log.

Rekor is Sigstore's tamper-evident transparency log for signing events. Similar to Certificate Transparency logs for TLS certificates, Rekor is an append-only, cryptographically verifiable log that records all software signing events submitted to the public Sigstore instance. This provides: detection of unauthorised signing (if someone signs your software with a stolen identity, it appears in the public log); a verifiable audit trail of all signing events; and the ability to verify a signature without pre-distributing the signer's public key (look it up in Rekor). Organisations can run private Rekor instances for sensitive internal signing workflows.

Sigstore integrates with Kubernetes via admission webhook controllers that intercept pod creation requests and verify that container images have valid Sigstore signatures before allowing deployment. The Sigstore Policy Controller (the official Sigstore Kubernetes integration) defines ClusterImagePolicy resources specifying which images require signatures and from which OIDC identities. Kyverno provides an alternative with Cosign signature verification built into Kyverno policy rules. Both can be run in audit mode first (logging violations without blocking) then switched to enforcement mode once signing coverage is complete across your image portfolio.

Yes. Cosign can sign any file or OCI artefact, including: container images (primary use case); SBOMs (Software Bills of Materials) attached as signed attestations; SLSA provenance records; binary files; Helm charts (via OCI); NPM packages (via provenance attestation, supported by npmjs.com since 2023); Python packages (via sigstore-python library); and git commits (via Gitsign). The attestation mechanism allows attaching structured, signed claims to container images — including vulnerability scan results, test results, and compliance evidence — creating a verifiable chain of custody from source code to deployed image.

Traditional GPG-based signing requires: generating a long-lived key pair; securely storing the private key (risk of theft or loss); distributing the public key to all verifiers (key distribution problem); manually managing key rotation and expiry; and developer discipline to actually sign artefacts. Sigstore eliminates all of these: ephemeral keys eliminate key management risk; OIDC identity ties signatures to existing identity providers (no separate key distribution); the Rekor log enables verification without pre-distributing public keys; and CI/CD integration (one pipeline step) makes signing automatic. The trade-off is a dependency on Sigstore's public infrastructure (Rekor, Fulcio) or the cost of running private instances.

Yes. Sigstore is production-ready and is already used at significant scale. PyPI (Python Package Index) uses Sigstore for package provenance for all Python packages. npm supports Sigstore-based provenance for published packages. The Kubernetes project itself uses Cosign to sign all release artefacts. Major container registries (GitHub Container Registry, Google Artifact Registry) natively support Cosign signatures. The public Sigstore infrastructure (Rekor, Fulcio) has SLA-backed availability. For enterprises with data sovereignty requirements, private Sigstore deployments (private Rekor + private Fulcio connected to corporate OIDC) are available and used in production at large financial services and government organisations.

SIGSTORE F

Ready to Implement Sigstore for software signing: getting started gui...?

Our specialist team delivers measurable ROI from Developer Experience and Pl programmes for enterprise and D2C brands.

Free Audit