appsec.fyi

GraphQL Resources

Post Share

A curated AppSec resource library covering XSS, SQLi, SSRF, IDOR, RCE, XXE, OSINT, and more.

GraphQL

GraphQL is a query language for APIs and a runtime for fulfilling those queries with your existing data. It gives clients the power to ask for exactly what they need, makes it easier to evolve APIs over time, and enables powerful developer tools.

From a security perspective, GraphQL introduces a unique attack surface that differs significantly from traditional REST APIs. Introspection queries can expose the entire schema — every type, field, and relationship — giving attackers a detailed map of the application's data model. Deeply nested queries enable denial-of-service through resource exhaustion, while batch queries can bypass rate limiting designed for REST endpoints.

Common GraphQL security issues include broken authorization on field-level resolvers, information disclosure through verbose error messages, and injection vulnerabilities in custom directives or filters. Many applications disable introspection in production but forget to restrict it in staging environments, or expose schema details through autocomplete suggestions.

Testing GraphQL requires specialized tools and techniques. Unlike REST APIs where endpoints are enumerable, GraphQL consolidates everything behind a single endpoint, requiring schema-aware fuzzing and query manipulation.

This page collects security research, testing methodologies, and real-world vulnerabilities specific to GraphQL APIs — from introspection abuse to authorization bypasses and injection attacks.

From graphql.org

GraphQL moves the bugs rather than removing them

A GraphQL endpoint is one URL that can express an enormous number of queries, and almost every security property people assume it has comes from the resolver layer rather than the protocol. Teams migrating from REST tend to port their authentication and lose their authorization, because in REST the route was the unit of access control and in GraphQL there are no routes.

Start with schema discovery. Introspection is the intended mechanism and is frequently left enabled in production; when it is disabled, field suggestion in error messages, persisted query listings and client bundles usually give up most of the schema anyway. Knowing the schema is what turns GraphQL testing from guesswork into reading — once you can see the types, you can see which edges connect user-controlled input to sensitive objects.

The authorization problems follow from nesting. A field that is properly protected at the top level is often reachable through a relation on another type, because the check was written on the query entry point rather than on the resolver that loads the data. This is the GraphQL form of IDOR, and it is more common than the REST version because the traversal paths are so much harder to enumerate by hand. Aliasing compounds it: the same field requested fifty times under fifty names in one document will defeat a rate limiter that counts requests.

Then there is cost. Nested and recursive queries let a small request produce enormous server work, and batching lets a single HTTP request carry many operations — which also turns a per-request brute-force limit into no limit at all. Depth limiting, query cost analysis and persisted queries are the standard answers, and the research below is largely about the gaps between them.

If you are testing one of these for the first time, the practical order is: recover the schema, map which types expose user or tenant data, test authorization on nested paths rather than root fields, then look at batching and aliasing for the rate-limit and enumeration work.

Start here: the GraphQL learning pathAn ordered route through this library — orientation, then methodology, then research. Read the GraphQL guideA long-form, source-cited deep dive synthesized from every resource below. The comprehensive GraphQL guide on chs.usA hand-written, in-depth practitioner guide — attacks, testing, and prevention.
Date Added Link Excerpt
2026-11-18 NEW 2026Testing GraphQL mutations: the checklist I wish I had before my last outage intermediate API SecThis article provides a checklist for effectively testing GraphQL mutations, aiming to prevent production outages. The author shares lessons learned from a past incident where seemingly successful mutations failed to update user data. The checklist focuses on crucial aspects beyond a simple 200 OK response and a "happy" JSON, emphasizing the need for comprehensive testing to ensure mutations function as intended and data integrity is maintained.
2026-11-18 NEW 2026Prime CMS auth bypass via createUser GraphQL mutation intermediate 2 min read AuthNWriteup of CVE-2026-129941 in Prime CMS, detailing an authentication bypass via the createUser GraphQL mutation. This vulnerability, impacting versions up to 0.4.0-beta.0, allows unauthenticated attackers to gain administrative control by exploiting a commented-out `isAuthenticated()` guard and hard-coded admin roles within the `createAbility()` function. The exploit has a network-reachable, unauthenticated path with no user interaction, classified under CWE-306: Missing Authentication for Critical Function.
2026-11-17 NEW 2026GraphQL persisted queries allowlist bypass via ID manipulation intermediate API SecLibrary `graphql_persisted.js` demonstrates an access control bypass vulnerability in GraphQL persisted queries. When a `queryId` is not found, the server executes the client-provided query instead of rejecting the request, allowing for arbitrary query execution and potential denial-of-service. The exploit involves sending a nonexistent `queryId` alongside a malicious query.
2026-11-17 NEW 2026@tinacms/graphql symlink path traversal intermediateAdvisory for @tinacms/graphql 2.2.2 through 4.1.0 detailing a path traversal vulnerability. Authenticated users can exploit dangling symlinks to write files outside the content root, enabling the creation of controlled content like authorized_keys in server-writable locations. References include GHSA-g9c2-gf25-3x67 and CVE-2026-129861.
2026-11-16 NEW 2026Kong graphql-proxy-cache-advanced leaks cached responses across callers news API SecThe graphql-proxy-cache-advanced plugin in Kong Gateway has a vulnerability that can leak cached GraphQL responses between different callers. This means one user's sensitive data could be exposed to another. The issue stems from improper handling of cache keys. Successful exploitation could lead to unauthorized access of private information. This vulnerability affects specific versions of the plugin.
2026-11-16 NEW 2026GraphQL Core Schema: critical account takeover news 2 min read AuthN AuthZWriteup detailing CVE-2026-126725, a critical account takeover vulnerability in the GraphQL Core Schema module for Drupal. This flaw allows any authenticated user to change another user's password if the "User Login" schema extension is enabled, leading to full account compromise. Exploitation requires a user-level account, and default configurations are susceptible. Mitigation involves disabling the "User Login" extension or updating to version 1.0.29.
2026-11-16 NEW 2026Snapchat: Delete anyone's content spotlight remotely. news Bug Bounty IDORA high-severity Insecure Direct Object Reference (IDOR) vulnerability was discovered in Snapchat's Spotlight feature. This allows an attacker to remotely delete any user's Spotlight content by manipulating the `id` parameter in delete requests. By obtaining another user's Spotlight ID, an attacker can replace their own ID with the target's, effectively deleting their video. The impact could be significant, potentially allowing the deletion of content from major influencers. → hackerone.com
2026-11-15 NEW 2026graphql-orm-router: HTTP SSE/multipart subscriptions bypass WebSocket gateway auth controls intermediate 4 min read API Sec AuthN AuthZLibrary for securing GraphQL applications. This library addresses a critical vulnerability where HTTP Server-Sent Events (SSE) and multipart subscriptions bypass WebSocket gateway authentication and authorization controls. The bypass allows unauthenticated access and prevents proper token expiry enforcement, as detailed in audit finding RTR-2. The vulnerability affects the `graphql-orm-router` component, specifically the handling of HTTP subscription requests. Mitigation involves enforcing principal and expiry for HTTP streams or rejecting subscriptions off the trusted internal path.
2026-11-15 NEW 2026GraphQL's blind spots: introspection, batching, and nested queries beginner 12 min read API SecLibrary for securing GraphQL APIs, this resource details how introspection, batching, and nested queries, while valuable features, create significant attack surfaces. It explains how attackers leverage introspection for reconnaissance, bypassing rate limits via batching and aliases, and exploiting complexity in nested queries. Security controls discussed include disabling introspection in production, restricting it to authenticated sessions, implementing operation-level rate limiting, and enforcing query complexity limits.
2026-11-15 NEW 2026GraphQL penetration testing beyond introspection intermediate 11 min read API SecLibrary for probing GraphQL endpoints beyond basic introspection, focusing on authorization flaws like BOLA via node IDs and mutation vulnerabilities. It details techniques to bypass rate limiting using query batching and aliasing, and to exploit resource exhaustion through deep or wide queries, addressing OWASP API Security Top 10 issues API1 and API4. The library's approach requires concrete proof of exploitation with raw requests and responses.
2026-11-15 NEW 2026GraphQL batching abuse and how to stop it intermediate 3 min read API SecLibrary for detecting and mitigating GraphQL batching abuse. This resource details how GraphQL aliasing and array batching allow a single HTTP request to execute numerous operations, bypassing naive rate limiters and enabling brute-force attacks. It demonstrates testing techniques using tools like InQL and graphql-cop, and offers remediation strategies such as counting aliases and batched operations, disabling HTTP-level batching, adopting persisted queries, and implementing resolver-level rate limits. Specific middleware like graphql-armor-max-aliases is mentioned for Apollo and Yoga.
2026-11-15 NEW 2026Offense and defense in GraphQL: introspection, batching, and depth abuse intermediate 4 min read API SecLibrary for securing GraphQL APIs by addressing vulnerabilities stemming from introspection, batching, and depth abuse. It details techniques for auditing attack surfaces via introspection, bypassing WAF rate limits using field aliasing and HTTP request array batching, and executing denial-of-service attacks through deeply nested queries. The library also outlines defenses like disabling introspection, implementing query depth limits using `graphql-depth-limit`, and enforcing query cost and complexity analysis with `graphql-validation-complexity`.
2026-11-14 NEW 2026Schemathesis 4.33.0: GraphQL coverage phase and unary gRPC fuzzing intermediate 4 min read API Sec Fuzzing PythonLibrary with coverage phase for GraphQL schemas and unary gRPC fuzzing, supporting Open API 3.2 for XML request bodies and cookie parameters. Enhancements include faster pytest collection, WFC reports, and numerous fixes for data generation, request serialization, XML handling, GraphQL processing, schema loading, checks, authentication, timeouts, test execution, and reporting.
2026-11-14 NEW 2026Confirming GraphQL DAST findings: introspection, batching, depth/cost, CSRF over GET intermediate 16 min read API Sec CSRFLibrary for confirming GraphQL DAST findings, focusing on introspection, batching, depth/cost limits, and CSRF over GET. It analyzes how dynamic scans can misinterpret findings related to GraphQL configurations, such as introspection, field suggestions, aliasing for batching, and the use of GET requests. The library provides methodologies and practical examples for verifying the actual security impact of these configurations, including identifying authorization flaws like the `setRole` mutation and SQL injection vulnerabilities masked by error handling, rather than relying solely on scanner interpretations.
2026-11-14 NEW 2026What is GraphQL security testing? beginner 10 min read API SecLibrary for assessing GraphQL API security, focusing on vulnerabilities in the query interface, schema, and resolver logic. It addresses risks unique to GraphQL, such as open introspection enabling schema enumeration, field-level authorization bypasses, and resource exhaustion through batch or nested query abuse. Testing encompasses introspection abuse, injection via arguments, authorization bypasses, denial-of-service through batching and nested queries, and schema/field exposure.
2026-11-14 NEW 2026Arize Phoenix: format string injection in applyChatTemplate GraphQL query leaks secrets / JWT signing key news 2 min read AI JWT Python SecretsWriteup of GHSA-gfv3-m769-5xm3, a format string injection vulnerability in Arize Phoenix's `applyChatTemplate` GraphQL endpoint. Versions v13.0.0 through v14.8.0 are affected. Exploitation allows attackers to read server environment variables, including the JWT signing key (`PHOENIX_SECRET`), enabling session token forgery and decryption of stored credentials. The vulnerability stems from ineffective attribute access control within the template rendering function. Recommended fixes include restricting attribute traversal, adding authentication to the resolver, and limiting F_STRING format usage.
2026-11-13 2026Drupal GraphQL Core Schema critical improper authorization: password change account takeover (SA-CONTRIB-2026-316) news AuthN AuthZAdvisory SA-CONTRIB-2026-316 addresses a critical improper authorization vulnerability in Drupal's GraphQL Core Schema module, specifically within its user login and password management extensions. This flaw allows an authenticated user to change the password of any other user, including administrators, leading to account takeover, by failing to sufficiently check access during password reset operations. Users are advised to upgrade to GraphQL Core 1.0.29 or disable the User Login schema extension if an immediate update is not feasible.
2026-11-13 2026GraphQL security testing and pentest checklist beginner 9 min read API SecChecklist for GraphQL security testing and penetration, detailing vulnerability classes like broken object-level authorization (BOLA), field-level authorization, batching and alias abuse for rate limit bypass, denial-of-service through query complexity, injection through resolvers, and CSRF risks. The checklist covers techniques for identifying the GraphQL endpoint, fingerprinting the server engine with tools like graphw00f, recovering schemas via introspection or field suggestions using Clairvoyance, and testing authorization flaws often missed by scanners. It also addresses rate limiting bypass via aliased or batched operations and the importance of disabling introspection and schema details in production environments.
2026-11-13 2026GraphQL Tools utils prototype pollution in incremental result merge (CVE-2026-114604) news 3 min readLibrary flaw, CVE-2026-114604, within GraphQL Tools' utilities package enables prototype pollution by manipulating JavaScript object prototypes when processing untrusted incremental results from @defer or @stream directives. Versions 10.10.1 through 12.0.1 are affected, risking Node.js process compromise. Monitoring for anomalous property additions and updating to version 12.0.2 mitigates this high-severity vulnerability.
2026-11-13 2026GraphQL BOLA: one object, many paths, and how to prove the gap intermediate 10 min read API Sec AuthZ IDORLibrary for discovering and exploiting GraphQL Broken Object Level Authorization (BOLA) vulnerabilities. It details how to map all paths to an object using schema introspection or front-end analysis, and then test these paths with two accounts in a single request to identify authorization gaps. The library references OWASP API Security Top 10 2023 (API1:2023) and the OWASP GraphQL Cheat Sheet, highlighting techniques such as using the `node` field and understanding Relay-style global IDs for identification and exploitation.
2026-11-12 2026GraphQL injection in Chatwoot's Linear integration intermediate API SecLibrary for detecting GraphQL injection vulnerabilities, specifically highlighting an instance in Chatwoot's Linear integration. This vulnerability arises from improper escaping of `team_id` and `link_id` arguments when constructing GraphQL queries, allowing attackers to manipulate Linear API requests by injecting crafted IDs.
2026-11-12 2026GraphQL introspection: disabling it leaves the field open intermediate 6 min read API Sec AuthZLibrary for testing GraphQL introspection security, this fixture demonstrates how disabling introspection in `graphql-core` 3.2.14 alone does not prevent unauthorized access to sensitive fields like `adminUserRecord`. The downloadable Python and curl scripts simulate scenarios with different user roles and server configurations, highlighting that proper authorization checks within resolvers are crucial for securing GraphQL APIs against attacks like unauthorized data disclosure, even when introspection is turned off.
2026-11-12 2026Overgrowth: GraphQL aliased-mutation brute force of a password reset (HI CyberCon 2026) intermediate 1 min read API Sec AuthNLibrary for identifying GraphQL aliased-mutation brute-force vulnerabilities. This technique, demonstrated in the "Overgrowth" GraphQL API at HI CyberCon 2026, exploits unauthenticated password reset endpoints that lack rate limiting. By leveraging GraphQL's ability to execute multiple mutations with unique aliases in a single request, attackers can rapidly iterate through all possible four-digit reset codes (10,000 in under 4 seconds) to gain unauthorized access and retrieve sensitive data, such as the flag.
2026-11-12 2026@neo4j/graphql aggregation queries bypass @authentication (CVE-2026-92684) intermediate AuthN AuthZLibrary advisories detail CVE-2026-92684 impacting @neo4j/graphql, where aggregation queries bypass @authentication. This vulnerability allows unauthenticated access to protected data through string aggregates and connection-root aggregates, even when direct field queries are restricted. Users are advised to upgrade to version 7.6.8 (latest) or 5.12.17 (LTS) when available, or restrict access to aggregate queries over sensitive information.
2026-11-11 2026GraphQL Is a Gift to Bug Hunters — Here’s My Introspection-to-Takeover Workflow intermediate API Sec Bug Bounty ReconGraphQL, often mishandled by bug hunters who treat it like REST, offers lucrative opportunities for those who understand its intricacies. The key lies in introspecting the schema to map available mutations. This allows for a deeper understanding of the API's capabilities, enabling hunters to uncover vulnerabilities that might otherwise be overlooked, potentially leading to significant findings. → thexssrat.medium.com
2026-11-11 2026Abusing GraphQL introspection and batching: hands-on API attack lab intermediate 12 min read API SecLibrary for hands-on GraphQL API security testing, focusing on exploiting introspection and batching vulnerabilities. The lab guides users through attacking a self-hosted vulnerable Apollo Server 4 application, demonstrating how exposed introspection, error-based field suggestions via tools like Clairvoyance and InQL, query depth abuse, and aliased batch requests can lead to schema mapping, data exfiltration, and denial-of-service. It also covers essential defenses, including restricting introspection, enforcing query depth and cost limits, and implementing persisted queries with operation allowlisting.
2026-11-11 2026GraphQL introspection abuse and batch query attacks intermediate 10 min read API SecLibrary for detecting GraphQL introspection abuse and batch query attacks, which exploit the specification's inherent design rather than implementation flaws. It highlights how a single endpoint, runtime query construction, and batching capabilities allow attackers to bypass traditional security measures like WAFs and rate limiting. Techniques discussed include the misuse of introspection queries to reveal the entire schema, field suggestion errors used by tools like Clairvoyance to reconstruct schemas, and client-side JavaScript leaks, as well as batch query attacks via alias and array batching that circumvent request-based rate limiting.
2026-11-11 2026GraphQL batching and aliasing attacks: rate-limit bypass, brute force, DoS intermediate 7 min read API Sec AuthNLibrary for demonstrating GraphQL batching and aliasing attacks, detailing how these features bypass traditional per-request rate limiting. It explains techniques for achieving brute-force attacks on OTPs or coupon codes, and Denial of Service by packing numerous expensive operations into a single request. The library assists in measuring amplification factors and implementing defenses based on query cost analysis, rather than solely counting HTTP requests.
2026-11-11 2026Craft CMS 5.0.0 before 5.11.2 GraphQL schema scope bypass via prev/next (critical) news API Sec AuthZLibrary for Craft CMS addressing GHSA-xpg7-m6gm-4xfh, a critical GraphQL schema scope bypass. Anonymous clients can read out-of-scope section content, including full custom-field data and enumerate the entire entry list by chaining `prev`/`next` operations. This vulnerability impacts installations with an enabled GraphQL API and a schema that grants read access to at least one section while withholding others.
2026-11-11 2026@neo4j/graphql: only the first condition of a multi-condition @authentication JWT filter is evaluated intermediate AuthN AuthZ JWTLibrary vulnerability GHSA-58qp-3mmm-5vh8 affects @neo4j/graphql, where multi-condition @authentication JWT filters using generic operator syntax only evaluate the first condition, allowing bypass of subsequent checks like role requirements. This can grant unauthorized access to data or operations. Upgrade to version 7.6.7 or use explicit AND arrays or inline operator syntax as a workaround in earlier versions.
2026-11-10 2026graphql-ruby interpreter renders objects whose authorized? checks failed (GHSA-q3cc-p5hm-55wj) news 1 min read AuthZLibrary advisory concerning GHSA-q3cc-p5hm-55wj for graphql-ruby details a bug in the legacy interpreter where `Execution::Interpreter` renders unauthorized objects when `authorized?` raises `GraphQL::UnauthorizedError` and `Schema.unauthorized_object` returns a replacement. This differs from returning `false` from `authorized?`, which functions correctly. The vulnerability, rated CVSS 6.5, is fixed in versions 2.6.14 and later, while versions prior to 1.10.0 are unaffected.
2026-11-10 2026Neo4j GraphQL CVE-2026-92683: JWT filter bypass news 2 min read API Sec AuthZ JWTLibrary advisory for CVE-2026-92683 details a high-severity authorization bypass in Neo4j's @neo4j/graphql library, affecting versions 7.0.0 through 7.6.6. Attackers with a valid JSON Web Token can circumvent most filter conditions when multi-condition JWT filters are implemented using generic operator syntax, due to an issue in the @authentication directive.
2026-11-10 2026Mass account takeover of 29,000 accounts by abusing GraphQL intermediate API Sec AuthN Bug BountyA security researcher discovered a vulnerability in a platform's GraphQL implementation that allowed for the mass takeover of 29,000 user accounts. The exploit involved abusing specific GraphQL queries to gain unauthorized access. This significant breach highlights the importance of securing API endpoints and thoroughly auditing GraphQL implementations for potential abuse.
2026-11-10 2026GraphQL rate-limit bypass via batching intermediate 6 min read API Sec AuthNLibrary for identifying and mitigating GraphQL rate-limit bypass vulnerabilities. This library addresses a specific weakness where GraphQL's aliasing feature allows an attacker to bundle numerous authentication attempts, such as one-time code guesses, within a single HTTP request. Since rate limiters often count requests rather than individual attempts, this batching technique effectively bypasses intended security controls. The library also highlights the compounded risk when clients can control one-time code length, further reducing the brute-force search space. Developers can leverage this resource to implement robust security by counting actual attempts, rejecting or capping batched operations on sensitive fields, enforcing server-side code length, and establishing account lockouts after multiple failed attempts.
2026-11-09 2026Allowed to view the Location, handed the Device: a GraphQL permission gap in Nautobot… intermediate API Sec AuthZNautobot's GraphQL API had a permission vulnerability (GHSA-mfwj-pjgx-22v2) where object permissions were not consistently enforced. While root-level queries were checked, nested data access within those queries bypassed these checks. This allowed users with "view_location" permissions to gain access to "device" data, even if they lacked explicit "view_device" rights.
2026-11-09 2026GraphQL Tools prototype pollution in mergeIncrementalResult (CVE-2026-114604) intermediate API SecLibrary fix addresses CVE-2026-114604 in @graphql-tools/utils, specifically the mergeIncrementalResult function. Versions prior to 12.0.2 are vulnerable to prototype pollution due to insufficient validation of incrementalResult.path segments, allowing attacker-controlled properties to be written to Object.prototype when merging untrusted @defer or @stream transport results. This vulnerability is fixed in version 12.0.2.
2026-11-09 2026WPGraphQL = 2.26.0 unauthenticated info exposure via comments connection filters intermediate 1 min read API SecWriteup of WPSEC-2026-2525, detailing an unauthenticated sensitive information exposure vulnerability in WPGraphQL versions prior to 2.26.1. Attackers can leverage insufficient restriction of query arguments in the comments connection filters to infer commenter email addresses, IP addresses, and the existence of private or draft content by exploiting filtering by author email, search parameters, and ordering by email, IP, or user agent.
2026-11-09 2026The 200 OK That Hands Over Someone Else’s Data intermediate API Sec AuthZ IDORA security researcher discovered a vulnerability where a "200 OK" HTTP response, typically indicating success, was instead leaking sensitive personal data of other users. This occurred due to an insecure direct object reference (IDOR) flaw in a web application. The application failed to properly validate user permissions, allowing unauthorized access to data belonging to different accounts. This highlights a critical security weakness in how applications handle resource access and validation, potentially exposing user information through seemingly benign successful requests.
2026-11-09 2026Delete anyone's Snapchat Spotlight content remotely ($15,000 IDOR via GraphQL mutation) intermediate API Sec AuthZ Bug Bounty IDORA security researcher discovered an Insecure Direct Object Reference (IDOR) vulnerability in Snapchat's GraphQL API, allowing remote deletion of any user's Spotlight content. The vulnerability, identified as an IDOR, means attackers could manipulate other users' data without proper authorization. Snapchat awarded the researcher $15,000 for responsibly disclosing this significant security flaw.
2026-11-08 2026Directus unthrottled system GraphQL resolvers allow anonymous DoS via alias amplification intermediate 1 min read API SecAdvisory GHSA-g293-vf99-xv36 details Directus unthrottled system GraphQL resolvers enabling anonymous DoS via alias amplification. Exploitable anonymously at `/graphql/system`, an attacker can craft a single POST request with numerous aliased calls to execute expensive server-side operations like account lockout via `auth_login`, mail flooding through `auth_password_request`, CPU exhaustion with `utils_hash_generate`, and accelerated credential probing using `utils_hash_verify`. This bypasses HTTP rate limiting and impacts deployments with exposed system GraphQL endpoints, particularly when default configurations with disabled rate limiters are in use.
2026-11-08 2026Nautobot object view permissions bypass via GraphQL traversal intermediate API Sec AuthZLibrary of security patches for Nautobot addressing object view permission bypass via GraphQL traversal. This vulnerability allows users with limited model access to retrieve data from unauthorized related models by exploiting insufficient permission enforcement during graph traversal. Patches are available in Nautobot v2.4.38+ and v3.2.0+.
2026-11-08 2026Allowed to view the Location, handed the Device: a GraphQL permission gap in Nautobot intermediate 8 min read API Sec AuthZWriteup on a GraphQL permission gap in Nautobot v3.1.4, GHSA-mfwj-pjgx-22v2, which allowed users with view permissions on certain models to retrieve data from related models for which they lacked explicit permissions. This vulnerability, rated Moderate (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N), was patched in Nautobot 2.4.38 and 3.2.0, addressing issues with nested GraphQL queries and related object access.
2026-11-08 2026AshGraphql Subscription.Batcher sends unauthorized notifications intermediate 4 min read API Sec AuthZLibrary for AshGraphql.Subscription.Batcher that fixes broken access control in GraphQL subscriptions. Versions prior to 1.10.1 could send unauthorized notifications, exposing record existence and data to subscribers who should not have access, due to the authorization suppression filter being applied only to the first notification in a batch.
2026-11-08 2026Neo4j GraphQL @authentication not enforced on top-level @cypher fields intermediate API Sec AuthN AuthZA security vulnerability has been identified in Neo4j's GraphQL integration where the `@authentication` directive is not being enforced on top-level `@cypher` fields within `Query` and `Mutation` types. This means that authenticated access controls defined by `@authentication` might not be respected for these specific GraphQL fields, potentially exposing sensitive data or functionality. The provided example illustrates how this issue can manifest in the GraphQL schema.
2026-11-07 2026graphql-core unbounded memory growth (CVE-2026-119286) news 1 min read PythonWriteup of CVE-2026-119286 in graphql-core, detailing unbounded memory growth. The vulnerability resides in the `validate` function, which mishandles `ValidationAbortedError` by appending stack frames to a shared error instance on repeated invalid document validations. This leads to continuous memory consumption, as demonstrated by a proof-of-concept showing exponential growth with numerous invalid field checks. Upgrading to graphql-core 3.3.1 or higher mitigates this issue. → security.snyk.io
2026-11-07 2026graphql-ruby Execution::Next renders objects whose authorized check failed news AuthZLibrary patch for GHSA-4rw8-495r-pf6j in graphql-ruby, addressing an authorization bypass in `Execution::Next` that could render unauthorized objects. This high-severity vulnerability (CVSS v3 7.5) is resolved in versions 2.6.14 and later, with versions below 2.5.20 unaffected.
2026-11-07 2026graphql-tools prototype pollution in mergeIncrementalResult (CVE-2026-114604) news 1 min read API SecLibrary advisory for CVE-2026-114604 details a high-severity prototype pollution vulnerability within Ardatan graphql-tools' `@graphql-tools/utils` package. Exploiting the `mergeIncrementalResult` helper allows unauthenticated attackers to inject malicious segments into incremental GraphQL responses, potentially leading to remote code execution or denial of service in Node.js applications. Updating to version 12.0.2 or later is critical for remediation.
2026-11-07 2026GraphQL Tools prototype pollution advisory news 1 min readAdvisory for CVE-2026-114604 in `@graphql-tools/utils` details a prototype pollution vulnerability within the `mergeIncrementalResult` function. The issue arises because path segments are not validated as primitive strings or numbers, allowing array segments like `["__proto__"]` to bypass strict equality checks and be coerced into global prototype keys, thereby enabling attackers to modify `Object.prototype` via malicious incremental GraphQL responses. → advisories.gitlab.com
2026-11-07 2026GraphQL Hive Gateway batch-execute authorization bypass news API Sec AuthZA security vulnerability has been discovered in GraphQL Hive Gateway's batch execution feature. Researchers identified an authorization bypass flaw that occurs due to context confusion. This means an attacker could potentially gain unauthorized access to data or perform actions they shouldn't be able to by exploiting how the gateway handles context during batch requests. The specific vulnerability lies within GraphQL Tools' Batch Execute implementation.
2026-11-06 2026GHSL-2026-152: privilege escalation via authorization bypass in graphql-ruby intermediate 3 min read API Sec AuthZWriteup of GHSL-2026-152 details an authorization bypass vulnerability in graphql-ruby affecting versions between 2.5.23 and 2.6.5. When a resolver's `authorized?` hook raises `GraphQL::UnauthorizedError` within the `Execution::Next` runner, the library incorrectly marks the user as authenticated, leading to the execution of the resolver's `resolve` method and disclosure of sensitive data. This bypasses the intended authorization mechanism, potentially resulting in data breaches, unauthorized mutations, and privilege escalation. → securitylab.github.com

Frequently Asked Questions

How is GraphQL security different from REST?
GraphQL consolidates all operations behind a single endpoint, making traditional API enumeration ineffective. Unique risks include schema introspection exposure, deeply nested query denial-of-service, batch query abuse to bypass rate limiting, and field-level authorization gaps in resolvers.
Should you disable GraphQL introspection in production?
Yes, disabling introspection in production is a recommended security practice. It prevents attackers from mapping your entire schema, including types, fields, and relationships. However, schema details can still leak through error messages, autocomplete, and field suggestion features.
What tools are used to test GraphQL security?
Common tools include GraphQL Voyager for schema visualization, InQL for Burp Suite integration, graphql-cop for automated security testing, and Clairvoyance for schema reconstruction when introspection is disabled. Manual testing with crafted queries remains essential.

Weekly AppSec Digest

Get new resources delivered every Monday.