Automated Threat Modeling

Quick Look: CVE-2026-110697, a Red Hat Quay SQL LIKE Wildcard Flaw That Leaks Cross-Tenant Robot Tokens

A brief summary of CVE-2026-110697, a CVSS 9.9 flaw in Red Hat Quay where an unescaped underscore in a namespace name lets an authenticated user list other tenants' robot accounts and decrypted tokens. Covers root cause, fixed releases, and detection approaches.

CVE Analysis

9 min read

Gaurav Sarraf
Gaurav Sarraf

2026-11-11

Quick Look: CVE-2026-110697, a Red Hat Quay SQL LIKE Wildcard Flaw That Leaks Cross-Tenant Robot Tokens

Introduction

A single underscore in a namespace name was enough to break tenant isolation in Red Hat Quay, letting an authenticated user retrieve other tenants' robot accounts together with their decrypted authentication tokens. Because robot accounts are the identities that CI/CD systems use to pull and push images, Red Hat rates CVE-2026-110697 at CVSS 9.9 and notes that stolen credentials can be used to read, push, or overwrite a victim tenant's images.

Red Hat Quay is a private container registry for storing and distributing images across datacenter and cloud environments, including OpenShift and Kubernetes clusters. Red Hat says Quay launched in late 2013 as the first private hosted registry on the market. Today it ships as a self-managed product, is included with OpenShift Platform Plus, and runs as the hosted Quay.io service, all built from the upstream Project Quay codebase. That makes it a shared trust boundary for many organizations' software supply chains, which is exactly the boundary this bug crosses.

Technical information

Root cause

The flaw is classified as CWE 89 and sits in how Quay lists robot accounts for a namespace. Robot accounts are stored as User rows whose username follows the format <namespace>+<shortname>. To find all robots belonging to a namespace, _list_entity_robots in data/model/user.py performs a prefix match using Peewee's ** operator, which compiles to a SQL LIKE (or ILIKE). The current upstream code builds the pattern through plain string concatenation:

.where(User.robot == True, User.username ** (entity_name + "+%"))

In LIKE syntax, % matches any run of characters and _ matches exactly one character. Quay namespace names are allowed to contain _, and nothing on this path escapes it. If an attacker's namespace is ab_c, the generated pattern is ab_c+%. That pattern matches the attacker's own robots, but it also matches robots such as abxc+deploy that belong to an entirely different tenant.

The robot listing response includes tokens, so the matched robots come back to the attacker with their decrypted credentials. Bugzilla lists two further impacts: the attacker can take over a victim's robots by renaming the attacker's namespace, and can delete a victim's robots by deleting it.

Quay already contains a correct helper. As the Bugzilla entry points out, prefix_search in data/text.py escapes every LIKE metacharacter and adds an explicit escape clause, but the robot listing path never calls it:

def _escape_wildcard(search_query): search_query = ( search_query.replace("!", "!!").replace("%", "!%").replace("_", "!_").replace("[", "![") ) ... def prefix_search(field, prefix_query): prefix_query = _escape_wildcard(prefix_query) return Field.__pow__(field, NodeList((prefix_query + "%", SQL("ESCAPE '!'"))))

Attack flow

Based on the Red Hat record and Bugzilla, the attack proceeds at a high level as follows:

  1. The attacker holds an authenticated Quay account with the ability to create a namespace. Red Hat's record says elevated privileges and victim interaction are not required. The sources do not specify the exact role needed.
  2. The attacker picks a target namespace (for example abxc) and creates a namespace of the same length with an underscore in place of one character (for example ab_c).
  3. The attacker lists robots for their own namespace. The backend builds ab_c+%, which matches abxc+deploy and any other abxc robots.
  4. The response returns those robots along with their decrypted tokens.
  5. The attacker uses the tokens to read, push, or overwrite images in the victim's repositories. Red Hat specifically calls out risk to CI/CD pipelines in OpenShift environments where Quay is the integrated registry.
  6. Optionally, renaming or deleting the attacker namespace can take over or delete the victim's robots.

Every request in this chain is an ordinary, authorized call against a namespace the attacker legitimately owns. Nothing about the traffic is malformed, so detection cannot rely on spotting a bad request.

Patch information

Red Hat, acting as CNA, says the flaw is fixed in these Red Hat Quay releases:

  • 3.9.28
  • 3.10.28
  • 3.12.24
  • 3.14.10
  • 3.15.9
  • 3.16.7
  • 3.17.7
  • 3.18.3

The hosted Quay.io service has already been fixed. Red Hat states there is no other complete workaround, so upgrading is the only full fix.

Some caveats about the public record at the time of writing:

  • The Red Hat CVE page's product table still marks the Quay 3 RHEL 8 and RHEL 9 container images and Quay 5 as "Affected", with no errata links. Bugzilla 2552237 is still NEW and its "Fixed In Version" field is empty. The fixed versions above come from the advisory text, which also points to a CSAF/VEX document.
  • We could not find a public upstream commit or pull request for this CVE in quay/quay.
  • The master copy of data/model/user.py still contains the unescaped pattern shown above, so the fix has either not been pushed upstream yet or exists only on release branches.

Conceptually, the fix needs to route the robot prefix through escaping equivalent to prefix_search. With escaping applied, ab_c+ becomes the literal prefix ab!_c+, the database only matches usernames that genuinely start with ab_c+, and tenant isolation is restored. The helper also escapes ! itself, since ! becomes the escape character and an unescaped one would let an attacker inject an escape sequence. Quay has fixed this class of bug before: the like: tag filter was changed to use match_like after _ and % were found to be treated as wildcards.

Red Hat has not published the exact diff for the fixed releases. The snippets in this post are the vulnerable line and the existing helper from public upstream source, not the shipped patch. Do not attempt a manual backport. Upgrade to one of the fixed builds.

If an immediate upgrade is not possible, Red Hat recommends:

  • Restricting who can create organizations or namespaces containing an underscore.
  • Rotating robot tokens for namespaces that collide with underscore-containing names.
  • Monitoring registry activity for unexpected pulls or pushes.

Red Hat is explicit that these steps reduce exposure but do not correct the underlying flaw.

Detection methods

There is no public YARA, Sigma, Snort or Suricata rule and no discrete IoC (IPs, hashes, payload strings) for CVE-2026-110697. That is expected, because exploitation is an ordinary robot listing call and the only unusual property is an underscore in the namespace name. A network IDS has nothing to match, so detection rests on exposure analysis and behavioral analysis of robot credential use.

1. Find namespaces that collide through the underscore wildcard

  • List every user and organization namespace in the registry.
  • For each name containing _, treat each underscore as "any one character" and look for other existing namespaces of the same length that match.
  • Any match is a pair where the owner of the underscore namespace could have listed the other tenant's robots, including decrypted tokens.

Pay particular attention to underscore namespaces that were recently created or that sit one character away from a high-value organization, such as a CI/CD or production image org. That looks more like deliberate namespace squatting than coincidence. Each colliding victim namespace becomes the scope for the log hunting below.

2. Look for robot activity that does not match expected use

Robot accounts are automation identities with predictable behavior: the same runners or cluster nodes, the same repositories, often on a schedule. Quay's usage logs record the fields needed to baseline them:

  • performer (acting user or robot)
  • account
  • ip
  • repository
  • kind (Project Quay documents pull_repo and push_repo, logentrykind IDs 41 and 42)
  • metadata_json
  • datetime

For each robot in a colliding victim namespace, compare recent pull_repo and push_repo events to a baseline. Strong anomalies include:

  • New source IPs or networks outside the victim tenant's known build or runtime infrastructure.
  • Pushes from robots that normally only pull. Red Hat warns that stolen credentials could be used to inject malicious images into CI/CD pipelines.
  • Pulls of repositories the robot has never touched, or activity at unusual times or volumes.
  • Pushes that overwrite existing tags in production repositories.

3. Watch for robot lifecycle side effects

Because renaming or deleting the attacker namespace can take over or delete victim robots, review create_robot and delete_robot events. Unexplained delete_robot events, or robots disappearing from a victim organization around the time a colliding underscore namespace was renamed or deleted, should be treated as possible exploitation and correlated with the inventory from step 1.

4. Make the logs searchable at scale

By default Quay stores usage logs in its database. They are visible in the UI under Organization > Logs, Repository > Logs, or Superuser > Usage Logs, and can be queried directly in PostgreSQL via the logentry, logentry2, logentry3 and logentrykind tables. For multi-tenant deployments, Project Quay supports forwarding action logs to Elasticsearch (optionally via a Kinesis stream) or to Splunk, including Splunk HEC, through LOGS_MODEL in config.yaml. The documented Splunk HEC setup looks like this:

LOGS_MODEL: splunk producer: splunk_hec

Centralized logs let you baseline each robot's performer, IP, repository and action combinations over time and alert when a new combination appears, which is the closest practical substitute for a signature here.

Caveats

A clean result does not prove tokens were never exposed. Listing robots to harvest tokens may leave little or no trace, and an attacker using a token from infrastructure that resembles the victim's, or only performing pulls the robot already does, may blend into the baseline. Treat any colliding namespace pair as potentially compromised even if the log review finds nothing, and rotate the affected robot tokens.

Affected systems and versions

  • Product: Red Hat Quay (self-managed), built from upstream Project Quay.
  • Fixed releases by branch: 3.9.28, 3.10.28, 3.12.24, 3.14.10, 3.15.9, 3.16.7, 3.17.7, 3.18.3. Builds on those branches earlier than the listed fixed release should be treated as needing the update, but Red Hat does not publish explicit vulnerable version ranges, so verify your installed release against Red Hat's current CVE guidance.
  • The Red Hat CVE page product table currently lists the Quay 3 RHEL 8 and RHEL 9 container images and Quay 5 as "Affected".
  • Quay.io: already fixed by Red Hat.
  • Vulnerable configuration: any deployment where users who do not fully trust each other can create namespaces, particularly multi-tenant registries, since the attacker needs to be able to create a namespace containing an underscore.

Vendor security history

The sources describe Red Hat's security process rather than a comparative track record. Red Hat has been a CVE Program partner since 2002 and operates as a CVE Numbering Authority with a documented triage and publication process. Within Quay specifically, this is not the first wildcard handling bug: the like: tag filter was previously corrected to use match_like after _ and % were found to be interpreted as wildcards. The codebase also already contained a properly escaping helper, prefix_search, which the robot listing path did not use. Red Hat also notes that the Clair project provides container vulnerability scanning in Quay, though image scanning has no bearing on a SQL logic flaw like this one.

References

Detect & fix
what others miss

Works with
  • GitHub
  • GitLab
  • Bitbucket
  • Azure DevOps Services
  • Gerrit
  • CVS
  • Jira
  • Linear
  • Slack
  • Security Compass
Explore integrations
Security magnifying glass visualization