What Is Sigstore? Keyless Software Signing Explained
Sigstore signs software artifacts with short-lived certificates tied to an identity and logs every signature publicly, removing long-lived signing keys.
Sigstore is an open-source system for signing and verifying software artifacts, such as container images, packages, and binaries, without maintaining long-lived private keys. Instead of guarding a signing key for years, a developer or CI pipeline proves who it is through an identity provider, receives a certificate valid for a few minutes, signs the artifact, and records the signature in a public, append-only transparency log. Verifiers then check the identity and the log entry rather than trusting a key they had to obtain some other way.
The approach is often called keyless signing. There are still keys involved, but they are generated on the spot, used once, and thrown away.
The problem with traditional signing
Classic code signing relies on a long-lived key pair. The publisher keeps the private key secret and distributes the public key so users can verify signatures. That model has persistent weaknesses:
- Key management is hard. The private key must be stored somewhere, backed up, rotated, and protected from theft for its entire lifetime. A leaked key lets an attacker sign malware that verifies perfectly.
- Distribution is awkward. Users need a trustworthy copy of the public key. In practice many projects publish keys on the same website that hosts the downloads, which an attacker who compromises the site can replace together.
- Revocation is slow. If a key leaks, everyone who trusted it must learn about the compromise and stop trusting old signatures.
- Adoption is low. Because all of this is tedious, many open-source projects simply do not sign their releases.
These gaps matter because the build and distribution pipeline is a favourite target. Our overview of software supply chain security covers the broader landscape of attacks that signing is meant to blunt.
The three core components
Sigstore splits the job across three services and a client.
Fulcio, the certificate authority. Fulcio issues short-lived X.509 certificates. Rather than verifying domain ownership like a web CA, it verifies an OpenID Connect token. That token comes from an identity provider, such as an email account login or, more commonly for automation, a CI platform that issues tokens describing the exact repository and workflow that is running. The certificate binds the signer’s public key to that identity. The OIDC side is explained in OAuth vs OIDC vs SAML.
Rekor, the transparency log. Rekor is an append-only, publicly auditable log of signing events. Each entry records the artifact’s digest, the signature, and the certificate. Like Certificate Transparency for TLS certificates, it is built on a Merkle tree, so anyone can prove an entry is included and that the log has not been rewritten.
Cosign and other clients. Cosign is the best-known command-line tool for signing and verifying container images and other files, and language ecosystems have their own Sigstore client libraries. The client orchestrates the whole flow so the developer usually runs a single command.
How a keyless signature is made
- The client generates a fresh key pair in memory.
- It obtains an OIDC identity token, either through a browser login or automatically from the CI environment.
- It sends the public key and the token to Fulcio. Fulcio validates the token and returns a certificate binding the public key to the identity, valid for only a few minutes.
- The client signs the artifact’s digest with the private key.
- The signature, certificate, and digest are uploaded to Rekor, which returns a signed inclusion record with a timestamp.
- The private key is discarded. It never touches disk.
Because the certificate expires almost immediately, there is nothing worth stealing afterwards. The proof that the signature was made while the certificate was valid comes from the Rekor timestamp, not from the key’s continued secrecy.
How verification works
A verifier checks several things:
- The signature is valid for the artifact’s digest under the public key in the certificate.
- The certificate chains to the Fulcio root of trust.
- The certificate’s identity matches what the verifier expects, for example a specific repository’s release workflow, and the issuer is the expected identity provider.
- The Rekor entry exists, and its timestamp falls within the certificate’s short validity window.
The identity check is the heart of it. A valid signature on its own means little; what matters is that the artifact was signed by the specific workflow or person you expected. Policies are therefore expressed in terms of identities rather than key fingerprints, which is much easier to reason about and survives key rotation automatically, since every signature uses a new key anyway.
Traditional signing vs Sigstore
| Long-lived key signing | Sigstore keyless signing | |
|---|---|---|
| Private key lifetime | Months to years | Seconds to minutes |
| Trust anchored in | Possession of a public key | Verified identity plus transparency log |
| Key storage burden | High | None for the signer |
| Detecting misuse | Hard; stolen-key signatures look legitimate | Every signature is publicly logged |
| Verification policy | Trust this key | Trust this identity from this issuer |
| Works offline | Yes | Needs log data, which can be bundled |
What it does not do
Sigstore proves who signed an artifact and when. It does not prove the artifact is safe. A compromised CI workflow can still produce a validly signed malicious build, which is why signing is usually paired with build provenance attestations describing how an artifact was built and with an SBOM describing what is inside it.
There are also privacy considerations. Because the log is public, signing with a personal email identity publishes that address. Organisations that cannot use the public infrastructure can run their own Fulcio and Rekor instances.
Finally, verification is only as good as the policy. A verifier that accepts any valid Sigstore signature from any identity gains almost nothing. The benefit comes from pinning the expected signer.
The takeaway
Sigstore replaces long-lived signing keys with ephemeral keys, short-lived certificates bound to an OpenID Connect identity, and a public transparency log that records every signature. Signers no longer have secrets to protect, and verifiers write policies about trusted identities instead of key fingerprints. Use it to make artifact signing routine in CI, verify signer identity strictly, and combine it with provenance and SBOMs, because a signature tells you who built something, not whether it is trustworthy.
Tagged
Keep reading
The Lycoris Team · · 4 min read What Is an SBOM? Software Bill of Materials Explained
An SBOM is a complete inventory of every component in a piece of software, including its dependencies. Why it matters for tracking vulnerabilities at scale.
The Lycoris Team · · 5 min read Software Supply Chain Security & SBOMs: A Practical Primer
Supply chain attacks exploit your dependencies, not your code. Learn SBOMs, SLSA, and Sigstore to defend against them before a CVE drops.
Chisato · · 6 min read Mistral Large 4 Open Weights: 1T Model for Cyber Defense
Mistral has released open weights for Large 4, a 1.05-trillion-parameter mixture-of-experts model it is pitching to coders and cyber defenders.