Artifact Signing & Sigstore

A Fulcio certificate binds a one-time public key, generated locally at signing time, to the OIDC identity and issuer in the token you presented. It stays valid for roughly ten minutes, so no signing key is ever stored.

It proves the file is byte-for-byte what the holder of that private key signed. It does not prove the key belongs to the project, that the build was clean, or that the code is safe.

Keyless signing still uses a private key, but it is generated for that one signing operation and destroyed immediately afterwards. Nothing long-lived is left behind to store, guard, rotate, or lose.

Nothing about behaviour. A signature binds a signer identity to one exact set of bytes: it says who vouched for them, not that the chart's contents, defaults or dependencies are safe to install.

Only that some identity signed those exact bytes and they were not altered afterwards. It says nothing about whether that identity is yours. Without an expected-signer check, any signature the trust root accepts passes.

A bare cosign verify proves only that somebody obtained a Sigstore certificate and signed the artifact, which anyone with an email or a CI account can do. Pin the expected identity and the issuer that asserted it.

Verification asks whether the certificate was valid when the signature was logged, not whether it is valid now. The Rekor entry supplies that moment as a log-signed timestamp, plus an inclusion proof binding it to the log.

Custody moved rather than disappeared. The new crown jewels are whoever can cause an identity to be minted for your workload, the certificate authority your verifiers trust, and the transparency log — which only helps if somebody actually watches it.

Organisation membership is not the build you meant. Every repository, workflow and branch in the org can mint an identity that passes, so anyone able to push a workflow anywhere in the org can sign an artifact production will run.

cosign sign signs an artifact already in an OCI registry, addressed by its digest, and pushes the signature back there. cosign sign-blob signs any local file and hands the signature material back to you to store and ship yourself.

Rekor appends an entry holding the artifact's digest, the signature over it, and the signing certificate or public key. It never stores the artifact itself — only a timestamped, publicly readable record that this signature existed.

Mostly the registry, at upload time. A normal npm install or pip install verifies nothing. Consumers have to opt in: npm audit signatures checks an installed tree, and PyPI attestations must be fetched and checked deliberately.

The CI job's identity buys a certificate that lives only minutes, so it is long expired when anyone checks. Sigstore's append-only transparency log timestamps the entry, proving the signature was made while that certificate was still valid.

A human signer's Fulcio certificate names an email address asserted by a consumer or corporate identity provider. A CI job's certificate names a pipeline URI asserted by the CI platform, plus extensions recording the repository, ref and build configuration.

Cryptography cannot answer it; you need a channel independent of the download. Practical options are a key shipped in your OS vendor's keyring, a fingerprint published out of band, or a key certified by one you already trust.

Revocation only works if the verifier checks a revocation source at verify time. Artifact verification is usually offline against a trusted key the consumer already holds, so the key keeps verifying until every consumer updates that trusted set.

Only that the vendor signed some statement. Until the device hashes the bytes it is about to flash and matches that digest against the signed subject, the signature is not bound to the payload at all.

A subject string is only a claim, and it means something solely because a particular issuer asserted it. Accept any issuer and a different one can mint an identical-looking identity, turning your identity check into a name check.

cosign attest signs a claim about an artifact, not the artifact itself, so the signature records only who asserted the claim. Run it later, or by hand, and you get a valid signature over an unverified statement.

The short window removes key custody: no durable private key to store, rotate or revoke. It does nothing against an attacker who controls the identity, who can simply request a fresh certificate.

You monitor the log. Because Rekor is public and append-only, you can watch new entries for your signing identities and reconcile each one against your own record of intended releases. Anything unmatched is an alert — detection, not prevention.

Any other genuinely signed crate. A signature answers who vouched for some bytes, never whether those bytes are the package and version that was requested, so substitution and downgrade both pass a presence check.

Decide on who verifies. A long-lived key buys offline verification and universal tooling at the cost of decade-long key custody; keyless buys no durable secret and a public record, but depends on services you do not run.

Sign outside the enclave and carry the proof in. A bundle ships the signature, the signing certificate and the transparency-log entry beside the artifact, and a trust root cached in advance lets cosign check them with no network call.

Enforce provenance where it exists, record its absence elsewhere. Gate the six against an expected source repository, fall back to lockfile integrity hashes for the other thirty-four, and never report a missing attestation as a failed one.

OpenPGP revocation is metadata attached to the key, and signature verification is offline against the copy already in the local keyring. Nothing in the verification path fetches revocation status, so nobody sees it.

Run a private Fulcio when signer identities must not be public, when releases happen in isolated environments, or when only your own directory can assert those identities. The cost is owning a certificate authority and an offboarding process that now gates signing.

Treat the root as unverifiable, not merely overdue, and say so in writing. Then choose deliberately: re-key under a witnessed ceremony, retire the private root for short-lived issued identities, or accept the risk with a named owner and review date.

Concede the leak: identities, artifact digests and timing are published permanently, enough to map repositories and release cadence. Then price the alternative — a private log keeps that internal but loses the outside scrutiny that gives transparency its value.