Gain Better Visibility into Container Image Signatures

Containerization has revolutionized software development and deployment by providing a portable, lightweight way to package applications. However, ensuring the integrity and security of container images has become a critical concern. One aspect of container security is verifying the authenticity and integrity of container images through proper container image signatures. In this blog, we will explore the importance of container image signatures and discuss strategies to gain better visibility into them.

Container image signature visibility, defined: the ability to answer, for any image in your registry, whether it’s signed, by whom, with what tool, and whether that signature has actually been verified anywhere, using the OCI registry’s own artifact discovery, a public transparency log, and admission-controller audit data as the three sources of truth, rather than assuming coverage because a signing step exists somewhere in the pipeline.

Key Takeaways

• A signing step in your pipeline doesn’t guarantee signature coverage; the only way to know is to query the registry or transparency log directly, per image, and compare against what you expected to be signed.
• Cosign’s tree command and Notation’s inspect command both list the signatures, SBOMs, and attestations already attached to an image, the starting point for any visibility effort.
• This page covers gaining visibility into signatures that already exist. For choosing between Cosign and Notation, key-based versus keyless signing, and admission-policy enforcement in depth, see Signing Containers and OCI Artifacts: Notation, Cosign, and the Trust Model Decision.
• Admission controller logs, run in audit mode before enforcement, are themselves a visibility source: they tell you exactly which images would fail a signature check today, before you flip the switch that blocks them.

Understanding Container Image Signatures

Container image signatures serve as digital fingerprints that verify the authenticity and integrity of container images. The act of signing container images allows developers to guarantee both the integrity and trustworthiness of the image, ensuring it has not undergone any unauthorized modifications and originates from a reliable source. These signatures are created using cryptographic algorithms and embedded within the container image. When a container is deployed, the signature is validated to ensure that it matches the image and has not been altered.

The Importance of Container Image Signatures, Container image signatures provide several key benefits that contribute to improved security and trust in containerized applications:

1. Integrity Verification

   Container image signatures allow users to confirm the authenticity of the image by verifying that it has remained unaltered and free from tampering. Any unauthorized changes to the image can be detected, protecting against potential security breaches.

2. Authentication

   Signatures provide a means to authenticate the origin of a container image. Users can verify that the image comes from a trusted source and has not been maliciously replaced or compromised during distribution.

3. Trust and Compliance

   Container image signatures build trust between developers, system administrators, and end-users. Organizations can enforce policies to only allow signed images, ensuring compliance with security standards and minimizing the risk of deploying unverified or vulnerable containers.

4. Supply Chain Security

   Container image signatures provide organizations with improved visibility and enhanced control over the software supply chain. They can ensure that all images, including those from third-party sources, are properly signed and meet the required security standards.

Gaining Visibility into Container Image Signatures

Visibility comes from three distinct sources, and a mature program checks all three rather than relying on any one of them:

Registry-Level Discovery

Both Cosign and Notation store signatures as OCI artifacts attached to the image via the OCI 1.1 Referrers API, which means you can query any image directly to see what’s actually attached to it, independent of what your pipeline documentation claims should be there. For Cosign-signed images:

cosign tree registry.example.com/myapp:v1.0.0

This lists every signature, SBOM, and attestation attached to that image digest. For Notation-signed images, the equivalent is:

notation inspect registry.example.com/myapp:v1.0.0

Run either command against an image with no expected signature and you’ll get an empty result, which is itself useful information: it confirms a gap rather than leaving you to assume coverage based on pipeline configuration alone.

Transparency Log Visibility

For Cosign’s keyless signing specifically, every signing event is recorded in Rekor, a public, append-only transparency log, independent of the registry itself. This gives you a second, tamper-evident source to confirm when and by which identity a signature was created, useful for reconstructing signing history even if registry metadata is ever altered or an image is re-tagged. Notation’s certificate-based model doesn’t have a public transparency log equivalent by default; visibility there depends on your own CA’s issuance logs and the signing platform’s own audit trail.

Admission Controller Audit Data

Before an admission controller (Kyverno, the Sigstore Policy Controller, or OPA Gatekeeper with Ratify) ever blocks anything, running it in audit mode generates exactly the coverage report most teams are missing: a log of every image that would have failed signature verification, without actually breaking a deployment. This is the fastest way to find your real coverage gap, the images running in production today that were never signed, before committing to enforcement.

Visibility Sources at a Glance

Source	What It Tells You	Limitation
Registry query (cosign tree / notation inspect)	What’s actually attached to a specific image right now	Only as good as your ability to enumerate every image in the registry
Rekor transparency log	When and by which identity a keyless signature was created, independent of the registry	Applies to Cosign keyless signing specifically, not Notation’s PKI model
Admission controller audit logs	Which images would fail verification today, before enforcement	Only covers images that actually reach a deployment attempt
Centralized signing platform audit trail	Who requested and approved every signing event, across every format you sign, not just containers	Only covers signing done through that platform

The remaining strategies below round out a visibility program once these three sources are in place.

To gain better visibility into container image signatures, consider the following strategies:

1. Automated Scanning and Verification

   Implement automated scanning and verification processes to validate container image signatures throughout the entire software development and deployment lifecycle. Utilize specialized tools that can automatically verify the signatures of container images and provide real-time feedback on their integrity.

2. Centralized Container Image Registry

   Establish a centralized container image registry that enforces strict policies regarding signed images. Implement access controls to ensure that only trusted and signed images can be pushed and pulled from the registry. This helps in maintaining a consistent and secure image inventory.

3. Continuous Monitoring and Auditing

   Implement a continuous monitoring and auditing system to track the usage and integrity of container images. Regularly review logs and reports to identify any anomalies or suspicious activities related to container image signatures. This proactive approach helps in detecting and mitigating potential security incidents promptly.

4. Vulnerability Management

   Integrate vulnerability management practices into the container image pipeline. Regularly scan container images for known vulnerabilities and ensure that they are promptly patched or updated. The visibility gained through vulnerability management helps maintain the security and integrity of containerized applications.

5. Education and Training

   Organize training sessions and workshops to educate developers, system administrators, and other stakeholders about container image signatures and their importance. Promote best practices for securely signing and verifying container images to ensure that everyone involved understands their role in maintaining container security.

Running a Signature Coverage Audit

1. Enumerate every image currently deployed or in the registry, not just the ones your pipeline documentation lists.
2. Run cosign tree or notation inspect against each one to confirm what’s actually attached.
3. Cross-reference against Rekor for keyless-signed images to confirm the signing identity matches your expected build system.
4. Deploy the relevant admission controller in audit mode and review the log for images that would fail verification.
5. Reconcile any gap found against your CI/CD signing configuration before moving the admission controller to enforcing mode.

Conclusion

Container image signatures play a vital role in ensuring the integrity, authenticity, and security of containerized applications. Encryption Consulting’s CodeSign Secure provides a comprehensive solution for container image signing, ensuring the integrity and authenticity of your applications. By gaining better visibility into these signatures, organizations can mitigate the risks associated with unverified or compromised container images.

With CodeSign Secure, you can simplify the container image signing process, enhance security, and maintain the integrity of your software supply chain. Implementing automated scanning, maintaining a centralized image registry, continuous monitoring, vulnerability management, and educating stakeholders are essential to achieving better visibility into container image signatures.

Frequently Asked Questions

How do I check if an existing image has a signature without re-signing it?

Query the registry directly: cosign tree <image> for Cosign-signed images or notation inspect <image> for Notation-signed ones. Both read what’s already attached via the OCI Referrers API without modifying the image.

Does Notation have an equivalent to Cosign’s Rekor transparency log?

Not by default. Notation’s certificate-based trust model relies on your own CA’s issuance and revocation records rather than a public append-only log. Visibility for Notation-signed images depends more heavily on your signing platform’s own audit trail.

What’s the fastest way to find unsigned images already running in production?

Run your admission controller (Kyverno, Sigstore Policy Controller, or Gatekeeper with Ratify) in audit mode rather than enforcing mode. It logs every image that would fail signature verification without blocking any deployment, giving you a real coverage report before you commit to enforcement.