Sigstore

Eliminates the complexity of managing static private keys. Instead of generating and securely storing a long-lived secret, Sigstore binds a signature to an OpenID Connect (OIDC) identity.

• Ephemeral Key Pairs: A short-lived key pair is generated at the moment of signing.
• Identity Token: The public key is bound to an OIDC token from providers like Google, GitHub, or Microsoft.
• Automatic Cleanup: The private key is discarded immediately after the signature is created, removing the risk of future key compromise.

This mechanism allows developers to prove 'I am a valid GitHub Actions workflow' rather than 'I possess a specific secret file.'

An append-only, cryptographically verifiable ledger that records every signing event. Rekor provides a global, immutable record of software supply chain metadata, enabling monitoring and auditability.

• Tamper-Evident: Once an entry is written, it cannot be altered or deleted without detection.
• Verifiable Data Structures: Uses Merkle trees to generate a root hash that represents the state of the entire log at a specific point in time.
• Inclusion Proofs: Provides cryptographic proof that a specific signature entry exists in the log, which can be verified offline.

This ensures that even if a signing identity is compromised, historical signatures cannot be backdated or forged without leaving a detectable trace.

A root Certificate Authority (CA) that issues short-lived code-signing certificates. Fulcio acts as the bridge between an OIDC identity and a verifiable X.509 certificate.

• Short-Lived Certificates: Certificates are typically valid for only 10 minutes, eliminating the need for complex certificate revocation lists (CRLs).
• Identity Embedding: The verified OIDC identity, such as an email address or a workflow URI, is embedded directly into the certificate's Subject Alternative Name (SAN).
• Zero-Touch Operation: Fulcio authenticates the OIDC token, verifies the challenge, and issues the certificate automatically without manual approval.

This creates a direct, auditable link between a specific developer or build system and the artifact they signed.

Enforces organizational compliance by validating signatures against custom rules at deployment time. The Policy Controller integrates with Kubernetes admission control to block unsigned or improperly attested images.

• CUE/Rego Policies: Define complex verification logic using policy-as-code languages to check certificate issuers, subjects, and transparency log entries.
• Admission Webhook: Intercepts pod creation requests and validates that all container images match the defined signature and attestation policies.
• Chain of Trust: Verifies the entire chain from the artifact signature up to the Fulcio root CA and the Rekor transparency log entry.

This prevents supply chain attacks by ensuring only artifacts with verified, policy-compliant provenance can run in production clusters.

The primary client tool for interacting with the Sigstore ecosystem. Cosign handles signing, verification, and management of OCI artifacts and arbitrary blobs.

• Container Signing: Generates a signature object stored as an OCI artifact alongside the image in the registry.
• Blob Signing: Signs and verifies arbitrary files, such as release binaries or SBOMs, storing the signature in a separate .sig file.
• Attestation Support: Creates and verifies in-toto attestations, allowing you to cryptographically assert facts about an artifact, such as an SBOM or a vulnerability scan result.

Cosign provides a unified interface for implementing keyless signing in CI/CD pipelines without requiring complex PKI infrastructure.

Protects the integrity of the Sigstore public good service itself. Sigstore uses The Update Framework (TUF) to securely distribute and rotate its root keys and trust metadata.

• Compromise-Resilient: Even if a single root key is compromised, the TUF specification requires a threshold of keys to sign new metadata, preventing a unilateral takeover.
• Secure Key Rotation: Defines a robust process for rotating root signing keys without breaking existing verification clients.
• Timestamping: Protects against freeze attacks by ensuring clients always fetch the latest, unexpired trust metadata.

This ensures that the foundational trust anchors of the entire Sigstore ecosystem cannot be silently subverted.

The primary command-line tool for interacting with the Sigstore ecosystem. Cosign performs keyless signing of container images and OCI artifacts using OpenID Connect identities, storing signatures in the registry alongside the artifact.

• Generates ephemeral key pairs for each signing event
• Supports signing blobs, images, and in-toto attestations
• Verifies signatures against the Rekor transparency log
• Integrates directly into CI/CD pipelines like GitHub Actions

An append-only, immutable ledger that records signed metadata about software artifacts. Rekor provides a tamper-proof record of signing events, enabling auditors to verify that a signature existed at a specific point in time.

• Stores hashes of signed artifacts and public keys
• Enables monitoring for unauthorized signing events
• Built on the Merkle Tree data structure for cryptographic consistency
• Provides a public API for querying and verifying entries

A root Certificate Authority that issues short-lived code-signing certificates bound to OpenID Connect identities. Fulcio eliminates the need for developers to manage long-lived private keys by issuing certificates valid for only 10 minutes.

• Authenticates users via OIDC providers like Google, GitHub, or Microsoft
• Binds the verified identity to an ephemeral X.509 certificate
• Does not require prior registration or manual key approval
• Certificates are automatically logged in Rekor for auditability

A framework for generating verifiable claims about the software supply chain. Sigstore integrates with in-toto to sign attestations that describe how an artifact was produced, including the build environment, source code, and dependencies.

• Defines the SLSA Provenance predicate format
• Attestations are stored as OCI artifacts alongside the image
• Enables policy enforcement based on build-level claims
• Supports custom predicate types for organization-specific metadata

A Kubernetes admission controller that enforces signature and attestation policies at deployment time. The Policy Controller validates that all container images in a pod spec are signed by trusted identities before allowing the pod to run.

• Integrates with Cosign for signature verification
• Supports CUE and Rego policy languages
• Blocks deployments of unsigned or untrusted images
• Enforces SLSA provenance requirements at the cluster boundary