CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



GHSA-6Q22-G298-GRJH

GHSA-6Q22-G298-GRJH: Unauthenticated Denial of Service via GraphQL Alias Amplification in Directus

Amit Schendel
Amit Schendel
Senior Security Researcher

Apr 4, 2026·6 min read·45 visits

Executive Summary (TL;DR)

Unauthenticated attackers can cause a Denial of Service (DoS) in Directus < 11.17.0 by sending a single GraphQL request with thousands of aliases targeting the expensive `server_health` resolver, rapidly exhausting database, storage, and network resources.

Directus versions prior to 11.17.0 are vulnerable to an unauthenticated Denial of Service (DoS) attack. The vulnerability arises from a lack of request-scoped deduplication in the GraphQL API, allowing attackers to exploit GraphQL alias amplification against resource-intensive resolvers such as the system health check.

Vulnerability Overview

Directus exposes a comprehensive GraphQL API to facilitate data querying and system management. The vulnerability exists within the implementation of this GraphQL engine, specifically in how it processes identical resolver requests within a single HTTP payload. Versions prior to 11.17.0 fail to deduplicate these requests, leading to unbounded backend resource consumption.

The flaw is classified as a Denial of Service (DoS) vulnerability triggered by GraphQL alias amplification. The GraphQL specification permits clients to request the same field multiple times within a single query by utilizing different aliases. When an attacker targets a resource-intensive system resolver, the server executes the underlying function for every alias provided in the query structure.

The server_health field is exposed via the system GraphQL endpoint and serves as the primary vector for this vulnerability. Unauthenticated attackers can send a single HTTP request containing thousands of aliases for this specific field. This forces the server to process an equivalent number of concurrent backend infrastructure checks, leading to severe resource exhaustion and service unavailability.

Root Cause Analysis

The root cause lies in the absence of request-scoped resolver deduplication within the GraphQL execution pipeline. Standard GraphQL engines invoke the defined resolver function for each field present in the abstract syntax tree (AST) of the query. When aliases are used, the engine treats each alias as a distinct execution path, even if the target field and its arguments are strictly identical.

The server_health resolver in Directus performs a comprehensive suite of backend infrastructure health checks. These checks include validating database connectivity, confirming cache service availability, verifying storage system write permissions, and testing outbound SMTP server connections. Executing this resolver requires substantial I/O operations and blocking network handshakes.

Prior to version 11.17.0, Directus processed these amplified requests linearly without caching the results of identical resolver executions during the lifecycle of the HTTP request. Consequently, an attacker supplying 1,000 aliases for the server_health field forces the application to initiate 1,000 database connections and 1,000 SMTP handshakes simultaneously.

This behavior entirely bypasses standard edge-level rate limiting. The amplification occurs entirely within a single HTTP request boundary, multiplying the server-side processing cost by orders of magnitude while requiring minimal bandwidth from the attacker.

Code Analysis

The maintainers addressed this vulnerability in Pull Request #26949 by introducing a dedupeResolver utility. This utility leverages a transient cache stored within the GraphQL context map for the duration of the HTTP request. The fix ensures that repeated calls to the same resolver with identical arguments return the result of the initial execution.

The patch implemented the dedupeResolver function within the dedupe-resolvers.ts file. This function acts as a wrapper around vulnerable resolvers. It generates a unique cacheKey based on the field name, a cryptographic hash of the provided arguments, and the specific selection set, ensuring exact query matching.

export function dedupeResolver(resolver, overrideKey) {
  return (source, args, context, info) => {
    const { cache } = context;
    const cacheKey = overrideKey ?? resolverCacheKey(args, info);
 
    if (!cache.has(cacheKey)) {
      cache.set(cacheKey, resolver(source, args, context, info));
    }
 
    return cache.get(cacheKey);
  };
}

The implementation evaluates whether the cacheKey exists in the request context cache. This cache object is a standard JavaScript Map initialized uniquely for every incoming HTTP request. If the key is absent, the application executes the target resolver and stores the returned Promise object in the map.

Subsequent resolver invocations matching the generated key bypass the expensive execution phase entirely. Instead, the function retrieves and awaits the stored Promise from the context map. This architectural modification reduces the execution complexity of identical aliases from O(N) to O(1), effectively neutralizing the amplification vector.

Exploitation Methodology

Exploitation requires no authentication and relies solely on network access to the Directus GraphQL endpoint. The attacker constructs a single HTTP POST request containing a GraphQL query with thousands of aliases referencing the server_health field. The server parses the payload and begins executing the mapped resolver for each alias concurrently.

query {
  h1: server_health
  h2: server_health
  h3: server_health
  h4: server_health
  # Amplified selection sequence repeats
  h1000: server_health
}

Upon receiving this payload, the GraphQL engine initiates the execution phase. For the example query above, the Directus application attempts to allocate 1,000 concurrent database connections from its connection pool. Simultaneously, it initiates 1,000 filesystem write operations and 1,000 outbound network connections to the configured SMTP server.

The immediate result is resource saturation at multiple layers of the application stack. The database connection pool is exhausted, preventing legitimate application queries from executing. Furthermore, the volume of outbound SMTP connection attempts often results in upstream timeouts or temporary IP bans from the configured mail provider.

Impact Assessment

The vulnerability results in a high-impact Denial of Service condition affecting the primary application and its downstream dependencies. By exhausting the database connection pool, the attack effectively halts all read and write operations for legitimate users interacting with the Directus instance. The service remains functionally unavailable until the malicious query times out or the server process is forcefully terminated.

The severity is reflected in the CVSS v3.1 base score of 7.5. The attack vector is strictly network-based and requires no elevated privileges or user interaction. The execution of the exploit consumes minimal resources on the attacker's side while forcing a disproportionately large resource allocation on the target infrastructure.

Secondary impacts include the potential disruption of shared backend components. The rapid succession of connection attempts to the SMTP server and the underlying database can trigger rate-limiting mechanisms or infrastructure-level denial of service protections. This extends the scope of the service degradation beyond the Directus application container itself.

Remediation and Mitigation

The authoritative remediation for this vulnerability is upgrading the Directus instance to version 11.17.0 or later. The official patch implements request-scoped deduplication logic, entirely mitigating the alias amplification attack vector. Administrators should prioritize the deployment of this update to all internet-facing instances.

If immediate patching is not operationally feasible, administrators can deploy mitigation rules at the API Gateway or Web Application Firewall (WAF) layer. A structural parsing rule can be implemented to inspect inbound GraphQL JSON payloads and block requests containing an excessive number of aliases or repeated references to the server_health field.

Security teams should also review application telemetry for signatures of active exploitation. Relevant indicators include abrupt spikes in database connection pool utilization, spikes in filesystem write latency, or sudden bursts of outbound network connections on standard SMTP ports. These metrics, when correlating with single large inbound HTTP POST requests to the /graphql/system endpoint, indicate active alias amplification attempts.

Official Patches

DirectusPull Request implementing the fix
DirectusRelease Notes for Version 11.17.0

Fix Analysis (1)

Technical Appendix

CVSS Score
7.5/ 10
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H

Affected Systems

Directus GraphQL API EngineDirectus System Endpoint (/graphql/system)Database Connection PoolSMTP Integration Service

Affected Versions Detail

Product
Affected Versions
Fixed Version
directus
Directus
< 11.17.011.17.0
AttributeDetail
Vulnerability ClassUncontrolled Resource Consumption
CWE IDCWE-400
CVSS v3.1 Score7.5 (High)
Attack VectorNetwork
Authentication RequiredNone
Exploit StatusProof of Concept (PoC)
Fixed Version11.17.0

MITRE ATT&CK Mapping

T1499Endpoint Denial of Service
Impact
T1499.004Endpoint Denial of Service: Application or System Exploitation
Impact
CWE-400
Uncontrolled Resource Consumption

The software does not properly control the allocation and maintenance of a limited resource thereby enabling an actor to influence the amount of resources consumed, eventually leading to the exhaustion of available resources.

Known Exploits & Detection

ConceptualGraphQL alias amplification query targeting server_health

Vulnerability Timeline

Security advisory published and Directus version 11.17.0 released
2026-02-12
Fix developed and tested in PR #26949 by Directus maintainers
2026-03-01
OSV record updated with comprehensive technical details
2026-04-04

References & Sources

  • [1]GitHub Security Advisory: GHSA-6Q22-G298-GRJH
  • [2]OSV Record: GHSA-6q22-g298-grjh
  • [3]Directus Fix PR #26949
  • [4]BugBunny.ai Discoverer

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•2 days ago•CVE-2026-16454
4.3

CVE-2026-16454: Object-Level Authorization Bypass in Eclipse hawkBit Direct Device Integration Controller

CVE-2026-16454 is an object-level authorization bypass vulnerability (CWE-284, CWE-862) in Eclipse hawkBit versions 1.0.3 and prior. The flaw exists within the Direct Device Integration (DDI) REST controller (hawkbit-ddi-resource), where endpoints responsible for enumerating software module metadata and serving firmware binaries fail to verify whether the requested software module is assigned to the authenticated device. Consequently, any device with valid credentials (such as a TargetToken or GatewayToken) can enumerate software module identifiers and download arbitrary firmware artifacts across the entire tenant namespace.

Amit Schendel
Amit Schendel
11 views•9 min read
•2 days ago•CVE-2026-62284
8.6

CVE-2026-62284: Remote Code Execution and SSRF via Unsanitized Kubeconfig in OSAC Operator

CVE-2026-62284 (GHSA-5w5g-j6hw-6p8f) is a code injection and server-side request forgery vulnerability in the console-proxy component of the OSAC Operator. The RemoteConfigResolver parses Kubernetes Secrets containing kubeconfig files via clientcmd.RESTConfigFromKubeConfig without sanitizing execution-related fields. An attacker with RBAC permissions to create or modify labeled Secrets in monitored namespaces can supply a malicious exec credential plugin, resulting in arbitrary command execution within the console-proxy pod.

Amit Schendel
Amit Schendel
8 views•8 min read
•2 days ago•CVE-2026-62361
5.5

CVE-2026-62361: Authenticated SQL Injection and Table Access Control Bypass in Listmonk Subscriber Export

CVE-2026-62361 (GHSA-xgjr-7j9q-2h4r) is an authenticated SQL injection and authorization bypass vulnerability in listmonk, an open-source, self-hosted newsletter and mailing list manager written in Go. In versions prior to 6.2.0, the subscriber export endpoint (GET /api/subscribers/export) directly interpolates user-supplied SQL filter expressions into a PostgreSQL query without invoking the table allowlist validation function (validateQueryTables). Consequently, authenticated users possessing the subscribers:sql_query and subscribers:get_all permissions can bypass relational access controls, execute arbitrary subqueries against restricted tables such as users and settings, and modify database state via writable Common Table Expressions (CTEs).

Alon Barad
Alon Barad
10 views•11 min read
•2 days ago•CVE-2026-28385
5.0

CVE-2026-28385: Server-Side Request Forgery in Canonical LXD Image Import

CVE-2026-28385 (GHSA-3gq2-x4qg-p4g6) is a Server-Side Request Forgery (SSRF) vulnerability in Canonical LXD versions 4.12 through 6.9. An authenticated user possessing the can_create_images entitlement can force the LXD daemon to execute arbitrary outbound HTTP and HTTPS requests via the /1.0/images API endpoint. Due to the absence of egress destination validation, an attacker can probe host loopback services, RFC 1918 private network segments, and cloud Instance Metadata Services (IMDS) from the network position of the privileged LXD daemon.

Amit Schendel
Amit Schendel
10 views•9 min read
•2 days ago•GHSA-9J25-MM2H-2F76
9.9

CVE-2026-48750: Arbitrary File Write on Host via exec-output Symlink in Canonical LXD and Incus

Canonical LXD and LXC Incus contain an arbitrary file write vulnerability (CWE-73 / CWE-59) in the `/1.0/instances/<name>/exec` REST API endpoint. When an instance is unpacked from an image archive, top-level symbolic links are extracted directly onto the host filesystem within the instance storage directory. If a crafted image includes a symbolic link named `exec-output` pointing to an arbitrary host path, invoking the execution endpoint with `record-output: true` causes the privileged host daemon to follow the symlink and write command output files directly to the target host directory. An authenticated attacker with permissions to import images and execute commands can exploit this flaw to write controlled content to sensitive host directories such as `/etc/cron.d`, resulting in arbitrary code execution on the host as `root`.

Alon Barad
Alon Barad
8 views•12 min read
•2 days ago•GHSA-VGHH-5RFX-XHQ8
9.9

CVE-2026-48749: Arbitrary Host File Read and Write via Malicious Image Symlink in Canonical LXD and Incus

CVE-2026-48749 (tracked as GHSA-vghh-5rfx-xhq8 for LXD and GHSA-2q3f-q5pq-g8wv for Incus) is a critical container escape vulnerability in the Canonical LXD and Linux Containers Incus system container managers. By importing a specially crafted container image archive containing duplicate tar member headers, an authenticated attacker can replace the instance rootfs directory with a symbolic link pointing to the underlying host root filesystem. When performing file operations on a stopped container, the privileged forkfile helper binary resolves the symbolic link without confinement and chroots directly into the host filesystem, granting arbitrary root-level file read and write access.

Amit Schendel
Amit Schendel
8 views•9 min read