Tracked as CVE-2026-123710, the flaw carries a CVSS severity score of 9.8 out of 10, placing it in the critical category. According to Red Hat, the vulnerability affects deployments in which the service responsible for managing signing keys is accessible to untrusted clients.
The vulnerability exists in Quay's service key server, which manages the cryptographic keys used to sign registry access tokens. These tokens determine whether users and applications can download or upload container images.
According to Red Hat's security advisory, an unauthenticated attacker can exploit weaknesses in the key rotation mechanism to install an unauthorized signing key that the registry automatically trusts. When anonymous access is enabled, an attacker can obtain a registry token and use it to manipulate the key rotation process.
Once the malicious key has been installed, attackers can generate their own registry tokens with read and write permissions across repositories. This allows them to access private container images belonging to other users or organizations without following the platform's normal access restrictions.
According to Red Hat's Bugzilla report, "rotation also deletes the legitimate instance key as a side effect, and the attacker key can delete replacement instance keys."
Beyond stealing images, attackers could also replace or overwrite repository contents. Such modifications could affect software development and deployment processes, particularly when automated systems download compromised images from the registry. Sensitive credentials and other secrets stored within container images could also be exposed.
Another scaring aspect of the vulnerability is the persistence of unauthorized access. The malicious signing key can be configured without an expiration date and remains active even after the registry is restarted. Red Hat also warned that attackers could use the compromised key to delete legitimate signing keys, potentially disrupting normal image uploads and downloads.
Disabling anonymous access does not completely eliminate the risk, as users with valid Quay accounts can also exploit the vulnerability. Similarly, changing account passwords or regenerating robot account tokens will not invalidate an unauthorized signing key.
Red Hat recommends administrators immediately restrict access to the key-management service.
Red Hat cautioned that removing malicious keys alone may not provide lasting protection until a fixed version is installed, as attackers could potentially reinstall them.
The vulnerability was discovered by Red Hat researcher Dave O'Connor. Fixes for the issue were merged into the project's GitHub repository on November 11.
The research was conducted by Google DeepMind in collaboration with cryptography researchers from the University of California San Diego and Inria.
RSA is a widely used public-key cryptographic algorithm that relies on the mathematical difficulty of factoring large numbers. Although RSA-1024 was once considered sufficiently secure, advances in computing and cryptanalysis have made it unsuitable for protecting sensitive information. Modern systems generally use RSA keys of 2048 bits or longer.
The first major finding focused on digital signature forgery involving the PKCS#1 v1.5 padding format. Padding is additional data inserted into a message before signing to ensure that it meets the required block size. Researchers examined how this protection behaves when an attacker can influence the content of the message being signed.
The team found that when an attacker controls approximately half or more of the signed data block, the padding may no longer provide additional protection against forgery. This weakness is relevant to the PKCS#11 signing interface used by cryptographic devices, including hardware security modules.
To show the improvement, DeepMind's AI agents reproduced an earlier academic signature-forgery attack against an RSA-1024 key. The agents reduced the required computing time from approximately 1,380 CPU core-years to 391 CPU core-years, making the process around 3.5 times more efficient.
Two AI agents reportedly designed, executed and debugged the computation in less than four days, with approximately 20 messages from a human researcher, most of which involved approving their actions.
Researchers also developed a more efficient approach for situations where attackers control a smaller portion of the signed message, such as a 32-byte hash. Their theoretical calculations suggest that the proposed method could be approximately 1,600 times more efficient than the previous best approach for certain RSA-1024 signature-forgery scenarios.
The second major finding concerns RSA key factoring. RSA security depends on the difficulty of breaking down a large number into its original prime factors. The researchers developed an algorithm that could make factoring each additional RSA-1024 key approximately 30 times cheaper on average after an expensive initial computation.
However, this technique remains theoretical and has not yet been implemented. The initial computation would also require substantial resources, meaning the findings do not show an immediate practical attack against deployed encryption systems.
The researchers also highlighted important limitations of the signature-forgery technique. It requires approximately four billion signing queries in advance, does not recover the private key and does not work against devices that internally hash messages before signing.
According to Pushmeet Kohli, Vice President at Google DeepMind and Chief Scientist at Google Cloud, modern cryptographic protocols generally use RSA keys of 2048 bits or larger and remain secure against the demonstrated techniques.