Introduction
A Kubernetes cluster pulls a container image from an approved registry.
The image has the expected name and version tag. Vulnerability scanning reports no known critical issues.
But one important question remains unanswered.
Who authorized this exact image, and can the deployment system verify that it has not been replaced since publication?
A registry address does not establish authorship. An image tag can be moved. Vulnerability scanning cannot prove that an artifact came from an approved build process.
Artifact and container signing tools address these problems through cryptographic signatures and verification policies.
Sigstore, including its Cosign tooling, has become an important part of this ecosystem.
However, signing software is only one part of a secure distribution process. Organizations must also establish trusted identities, protect signing credentials, and enforce verification before deployment.
What Artifact Signing Actually Proves
A digital signature creates cryptographic evidence associated with particular data.
When applied correctly, it can help establish that an artifact has not changed since it was signed and that the signature corresponds to a particular key or authenticated identity.
However, a valid signature does not automatically mean that software is safe.
A malicious artifact can be signed by an authorized account.
A compromised build system can produce software that receives a legitimate signature.
Signing is therefore an integrity and identity mechanism, not a complete malware detection system.
Its security value depends on which identities are trusted and which policies determine whether an artifact is acceptable.
Why Container Image Tags Are Not Enough
Container images are commonly referenced using tags.
A tag such as release or stable is convenient, but it is a mutable reference in many registry workflows.
The same tag may later point to different image content.
This creates uncertainty when verifying exactly what was deployed.
A cryptographic digest identifies particular content.
Signing and verifying an image by digest provides a stronger basis for binding the signature to the intended artifact.
Organizations should avoid treating a familiar tag as proof of integrity.
The relevant security question is whether the exact image digest satisfies the required verification policy.
The Sigstore Ecosystem Explained
Sigstore combines several technologies for signing, identity, transparency, and verification.
Its components serve different responsibilities.
Cosign
Cosign provides tooling for signing and verifying container images and other software artifacts.
It also supports attestation-related workflows.
Fulcio
Fulcio is a certificate authority associated with Sigstore’s keyless signing model.
It issues short-lived signing certificates linked to authenticated identities.
Rekor
Rekor provides transparency logging for signed metadata.
Transparency records help support auditing and detection of suspicious signing activity.
OpenID Connect
OpenID Connect, or OIDC, provides identity information that can be used in supported keyless signing workflows.
Sigstore Policy Controller
Sigstore Policy Controller supports policy enforcement for Kubernetes workloads based on verifiable software supply chain information.
These components can work together, but they are not interchangeable.
Keyless Signing vs. Traditional Key-Based Signing
Traditional signing relies on a private key controlled by the signer.
The corresponding public key can be used for verification.
This approach is well established, but private key management creates responsibilities.
Keys must be generated securely, stored appropriately, rotated when necessary, and protected from unauthorized access.
Keyless signing takes a different approach.
In Sigstore workflows, an authenticated identity can obtain a short-lived certificate associated with an ephemeral signing key.
This reduces the need for developers to manage long-lived signing keys directly.
However, keyless does not mean trustless.
The verifier still needs to trust the relevant identity provider, certificate authority, and signing identity.
Compromise of an authorized identity can remain a serious risk.
Comparing Artifact and Container Signing Tools
| Tool or project | Primary role | Important consideration |
|---|---|---|
| Sigstore Cosign | Signing and verifying OCI images and other artifacts | Identity and verification policy |
| Sigstore Fulcio | Short-lived signing certificates | Identity provider trust |
| Sigstore Rekor | Transparency logging | Log verification and monitoring |
| Sigstore Policy Controller | Kubernetes admission policy enforcement | Cluster policy design |
| Notation | Artifact signing and verification using Notary Project specifications | Trust stores and signing identities |
| Notary Project | Specifications and tooling for OCI artifact trust | Ecosystem and registry compatibility |
| Kyverno | Kubernetes policy enforcement | Signature verification configuration |
| Ratify | Verification framework for artifact security metadata | Supported verifiers and policy integration |
| Connaisseur | Kubernetes image signature verification | Supported signing backends and operational fit |
| Docker Content Trust | Legacy image trust workflows | Existing deployment dependencies and modernization plans |
These tools operate at different points in the software delivery process.
A signing client, certificate authority, transparency log, and admission controller should not be compared as though they provide the same function.
Cosign: Signing and Verifying Software Artifacts
Cosign is one of the central tools in the Sigstore ecosystem.
It supports signing and verifying container images and other supported artifacts.
Its design works with OCI registries and associated artifact metadata.
This makes it relevant to organizations distributing container images through established registry infrastructure.
Cosign supports workflows involving traditional signing keys as well as keyless identity-based signing.
However, the correct verification process depends on the signing method.
A keyless signature should be checked against expected identity information.
A key-based signature should be checked against the appropriate trusted public key.
Simply confirming that some signature exists is not sufficient.
Fulcio: Connecting Signatures to Identities
Fulcio supports Sigstore’s identity-based signing model.
It issues short-lived certificates after authentication through supported identity mechanisms.
The certificate can associate a signing operation with an identity.
This helps address the challenge of distributing and managing long-lived developer signing keys.
However, identity trust requires careful interpretation.
An organization may trust a specific CI/CD workflow identity but not every account associated with the same identity provider.
Verification policies should therefore be appropriately narrow.
For example, an organization might accept signatures associated with a designated release workflow rather than every workflow in a repository.
Rekor: Transparency and Auditability
Rekor provides a transparency log for signed metadata.
The purpose of transparency logging is to make signing activity more observable and auditable.
This can help identify unexpected signatures or investigate potential identity compromise.
However, a transparency log is not the same as an authorization system.
The presence of a log entry does not mean an artifact should be deployed.
Verification must still establish that the signer and artifact satisfy policy.
Transparency also requires an appropriate trust model and monitoring strategy.
An organization that never reviews suspicious signing activity may fail to realize the full value of transparency logging.
Notation and the Notary Project
Notation is a signing and verification tool associated with the Notary Project.
It supports OCI artifact signing workflows using the project’s specifications.
This provides another approach to establishing trust in container images and related artifacts.
Notation is particularly relevant to organizations that want signing workflows based on its certificate and trust policy model.
The evaluation should include registry compatibility, certificate management, trust store configuration, and deployment integration.
Cosign and Notation both support artifact trust workflows, but they differ in signature formats, trust models, and ecosystem integrations.
The right choice depends on the organization’s existing infrastructure and verification requirements.
Kubernetes Admission Verification
Signing an image during CI/CD is useful.
However, the security benefit is limited if Kubernetes can still deploy unsigned or unauthorized images.
Admission controls can enforce policies before workloads are accepted into a cluster.
For example, a policy may require an image to have a valid signature from an approved release identity.
Sigstore Policy Controller, Kyverno, and other suitable policy tools can participate in this process.
However, enforcement must be designed carefully.
A policy that blocks every image without considering essential system workloads can disrupt cluster operations.
Organizations should test policies in controlled environments and establish procedures for handling exceptions.
Ratify and Artifact Verification
Ratify provides a framework for verifying security-related metadata associated with artifacts.
It can participate in policy enforcement architectures where artifact verification needs to be integrated with deployment decisions.
Its usefulness depends on the supported verifiers, artifact formats, and surrounding policy systems.
Ratify is not automatically a replacement for a signing client.
It addresses verification and integration requirements within a broader trust architecture.
Organizations should test whether their chosen signing format and registry workflow are supported.
Signature Verification Is a Policy Decision
Cryptographic verification answers whether a signature is valid under a particular trust configuration.
Authorization asks whether that valid signature should be accepted.
These are different questions.
A company may have several teams capable of signing images.
Only one team may be authorized to publish the production payment service.
A verification policy should distinguish those identities.
It may also require particular repositories, build workflows, or provenance claims.
The strongest policies are specific enough to reject unauthorized software while remaining maintainable.
A Practical Container Signing Workflow
A secure release process can be organized into several stages.
Stage 1: Build the Artifact
The CI/CD system produces a container image from approved source code.
Stage 2: Identify the Exact Image
The image is referenced by its cryptographic digest.
This prevents the verification process from depending solely on a mutable tag.
Stage 3: Authenticate the Signer
The signing workflow uses an approved key or authenticated identity.
Stage 4: Sign the Artifact
A compatible signing tool creates a signature associated with the image.
Stage 5: Publish the Image and Evidence
The image and its associated signature or verification material are made available through supported distribution mechanisms.
Stage 6: Verify Before Deployment
A consumer checks the signature, artifact digest, identity, and applicable policy requirements.
Stage 7: Enforce the Result
An unauthorized artifact is rejected rather than deployed.
This process is more meaningful than signing artifacts without downstream verification.
Protecting Signing Identities
Signing infrastructure becomes a sensitive part of the software delivery process.
If an attacker gains access to an authorized signing identity, malicious artifacts may appear legitimate.
Organizations should therefore protect CI/CD identities and signing credentials.
Relevant controls include least privilege, strong authentication, isolated build environments, and appropriate audit logging.
For key-based signing, private key protection is essential.
For keyless signing, identity provider and workflow security become especially important.
The signing mechanism should fit the organization’s broader identity and access management strategy.
Signing and Provenance Work Better Together
A signature helps establish integrity and a relationship with a signing identity.
Provenance describes how an artifact was produced.
Together, they can provide stronger evidence about software origin.
For example, a deployment policy may require both a valid signature and provenance showing that the artifact came from an approved build workflow.
However, the evidence must be checked independently.
A signed provenance statement containing inaccurate claims does not become true merely because it is signed.
The trustworthiness of the build platform remains central.
What Signing Cannot Protect Against
Artifact signing has important limitations.
It cannot guarantee that source code is free from vulnerabilities.
It cannot prove that all dependencies are safe.
It cannot prevent an authorized but compromised build system from producing malicious output.
It cannot replace runtime security controls.
It also cannot compensate for a verification policy that accepts untrusted identities.
Signing is most effective when combined with secure builds, dependency management, vulnerability scanning, provenance verification, and deployment controls.
Common Signing Implementation Mistakes
Signing by Tag Without Verifying the Digest
Mutable tags can create ambiguity.
Verification should be bound to exact artifact content.
Accepting Any Signature
A signature from an unknown identity should not satisfy a production trust policy.
Storing Signing Keys in Unprotected CI Variables
Sensitive credentials require appropriate protection and access restrictions.
Failing to Verify in Production
Signing during build does not prevent deployment of unauthorized artifacts unless verification is enforced.
Ignoring Certificate and Trust Root Management
Verification depends on trusted keys, certificates, and associated metadata.
These components need lifecycle management.
Assuming Transparency Equals Approval
Transparency logs help with auditability.
They do not independently authorize an artifact for deployment.
How to Choose an Artifact Signing Stack
Start by identifying the artifact types.
Some organizations need to sign only OCI container images.
Others also distribute binaries, archives, software packages, and attestations.
Next, define the trust model.
Determine whether the organization prefers managed signing keys, keyless identity-based workflows, or another supported approach.
Then examine the deployment environment.
Kubernetes-based organizations may need admission policy enforcement.
Teams using managed cloud services should assess the available native integrations.
Finally, test the entire release process.
A useful pilot should verify a legitimate artifact and reject an unauthorized one.
It should also test what happens when signatures are missing, identities change, or verification services become unavailable.
Final Thoughts
Artifact and container signing tools help organizations establish cryptographic trust in software distribution.
Cosign, Fulcio, Rekor, and related Sigstore components provide complementary capabilities for signing, identity, transparency, and verification.
Notation and the Notary Project offer another approach to OCI artifact trust.
Policy enforcement tools help turn verified evidence into deployment decisions.
The most important principle is straightforward: a signature is useful only when the verifier knows which identities to trust and enforces that decision.
A reliable signing architecture connects approved build identities, exact artifact digests, verifiable evidence, and deployment policies.
That connection is what turns software signing from a release-time checkbox into a meaningful supply chain security control.