Vulnerabilities in pkg:npm/@langchain/langgraph-checkpoint-redis

PACKAGE
Advisory Identifier: GHSA-5mx2-w598-339m
Advisory Summary

CVE-2026-27022 is a MODERATE (CVSS 6.5) redisearch query injection vulnerability (CWE-74: Improper Neutralization of Special Elements in Output Used by a Downstream Component ('Injection')) affecting @langchain/langgraph checkpoint redis libraries in the npm ecosystem. The issue involves redisearch query injection in @langchain/langgraph-checkpoint-redis. Remediation is available by upgrading affected packages to version 1.0.2.

1 Known Advisory Record(s)
Package Vulnerability Intelligence

pkg:npm/@langchain/langgraph-checkpoint-redis

1 Known Advisory Record(s)

Vulnerability advisories affecting package pkg:npm/@langchain/langgraph-checkpoint-redis. Select an advisory below to view technical details or fixes.

Advisory ID CVE / NVD Severity Summary
GHSA-5mx2-w598-339m CVE-2026-27022 MODERATE RediSearch Query Injection in @langchain/langgraph-checkpoint-redis

CVE-2026-27022 at a Glance

CVE Identifier CVE-2026-27022
GHSA Identifier GHSA-5mx2-w598-339m
Severity MODERATE
CVSS v3.1 Base Score 6.5
CWE Classification CWE-74: Improper Neutralization of Special Elements in Output Used by a Downstream Component ('Injection')
Affected Product @langchain/langgraph checkpoint redis
Package Ecosystem npm
Published Date
Last Updated

Security Impact

CVSS: 6.5

The security impact metrics below are parsed directly from the CVSS v3.1 vector string (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N).

Attack Vector Network (AV:N)
Attack Complexity Low (AC:L)
Privileges Required Low (PR:L)
User Interaction None (UI:N)
Scope Unchanged (S:U)
Confidentiality High (C:H)
Integrity None (I:N)
Availability None (A:N)

How to Fix CVE-2026-27022

To remediate this vulnerability, upgrade all affected @langchain/langgraph checkpoint redis dependencies to a patched release. Both direct and transitive dependencies should be checked, as frameworks or security libraries may pull in vulnerable versions transitively.

@langchain/langgraph-checkpoint-redis fixed: 1.0.2
npm install @langchain/langgraph-checkpoint-redis@1.0.2
Verify Direct and Transitive Dependencies

Run the following command in your project directory to verify that all resolved dependencies use the patched release:

npm ls @langchain/langgraph-checkpoint-redis

How to Check if You Are Affected

To determine whether your Node.js application is affected by CVE-2026-27022, inspect your project dependencies using npm:

npm ls @langchain/langgraph-checkpoint-redis

Analyze the terminal output to locate any version of @langchain/langgraph checkpoint redis in your dependency tree. If any resolved version matches the vulnerable ranges listed in the table below (for example, versions earlier than 1.0.2), your application is affected.

Note: The npm ls @langchain/langgraph-checkpoint-redis command inspects dependencies declared in your package.json and lockfile; it does not perform automated runtime dynamic scanning.

Technical Details

Vulnerability Mechanism & Technical Analysis

This vulnerability is classified under CWE-74: Improper Neutralization of Special Elements in Output Used by a Downstream Component ('Injection'), where the product constructs all or part of a command, data structure, or record using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify how it is parsed or interpreted when it is sent to a downstream component. In @langchain/langgraph checkpoint redis, software state validation or input boundaries are circumvented during processing. Review the official source advisory statement below for specific affected components, classes, and reproduction details.

Source Advisory Statement

## Summary A query injection vulnerability exists in the `@langchain/langgraph-checkpoint-redis` package's filter handling. The `RedisSaver` and `ShallowRedisSaver` classes construct RediSearch queries by directly interpolating user-provided filter keys and values without proper escaping. RediSearch has special syntax characters that can modify query behavior, and when user-controlled data contains these characters, the query logic can be manipulated to bypass intended access controls. ## Attack surface The core vulnerability was in the `list()` methods of both `RedisSaver` and `ShallowRedisSaver`: these methods failed to escape RediSearch special characters in filter keys and values when constructing queries. When unescaped data containing RediSearch syntax was used, the injected operators were interpreted by RediSearch rather than treated as literal search values. This escaping bug enabled the following attack vector: - **Thread boundary escape via OR operator**: RediSearch uses `|` as an OR operator with specific precedence rules. A query like `A B | C` is interpreted as `(A AND B) OR C`. By injecting `}) | (@thread_id:{*` into a filter value, an attacker can append an OR clause that matches all threads, effectively bypassing the thread isolation constraint. The injected query `(@thread_id:{legitimate-thread}) (@source:{x}) | (@thread_id:{*})` matches: - Documents with `thread_id:legitimate-thread AND source:x`, OR - Documents with ANY `thread_id` The second clause matches all threads, bypassing thread isolation entirely. ## Who is affected? Applications are vulnerable if they: - **Pass user-controlled input to filter parameters** — When using `getStateHistory()` or `checkpointer.list()` with filter values derived from user input, HTTP parameters, or other untrusted sources. - **Use Redis checkpointing in multi-tenant applications** — Applications that rely on thread isolation to separate data between users or tenants are at risk of cross-tenant data access. The most common attack vector is through API endpoints that expose filtering capabilities to end users, allowing them to search or filter their conversation history. ## Impact Attackers who control filter input can bypass thread isolation by injecting RediSearch OR operators to construct queries that match all threads regardless of the intended thread constraint. This enables access to checkpoint data from threads the attacker is not authorized to view. Key severity factors: - Enables complete bypass of thread-based access controls - Sensitive conversation data from other users may be exposed - Affects multi-tenant applications relying on thread isolation for data separation - Requires only control over filter input values (common in user-facing APIs) ## Exploit example ```typescript import { RedisSaver } from "@langchain/langgraph-checkpoint-redis"; const saver = new RedisSaver({ /* redis config */ }); // Normal usage - should only see thread "user-123-thread" const legitHistory = saver.list({ configurable: { thread_id: "user-123-thread" } }, { filter: { source: "loop" } }); // Attacker crafts malicious filter value const attackerFilter = { source: "x}) | (@thread_id:{*" // Injects OR clause matching ALL threads }; // This produces a query like: // (@thread_id:{user-123-thread}) (@source:{x}) | (@thread_id:{*}) // Due to precedence, this matches ALL threads! const stolenHistory = saver.list({ configurable: { thread_id: "user-123-thread" } }, { filter: attackerFilter }); // stolenHistory now contains checkpoints from ALL threads - DATA LEAKED! ``` ## Security hardening changes The 1.0.2 patch introduces the following changes: - **Escape utility function**: A new `escapeRediSearchTagValue()` function properly escapes all RediSearch special characters (`- . < > { } [ ] " ' : ; ! @ # $ % ^ & * ( ) + = ~ | \ ? /`) by prefixing them with backslashes. - **Filter key escaping**: All filter keys are escaped before being used in query construction. - **Filter value escaping**: All filter values are escaped before being interpolated into RediSearch tag queries. ## Migration guide ### No changes needed for most users The fix is backward compatible. Existing code will work without modifications—filter values that previously worked will continue to work, with the added protection against injection: ```typescript import { RedisSaver } from "@langchain/langgraph-checkpoint-redis"; // Works exactly as before, now with injection protection const history = saver.list(config, { filter: { source: "loop" } }); ``` ### If you were relying on special characters If your application intentionally used RediSearch syntax in filter values (unlikely but possible), be aware that these characters will now be escaped and treated as literals. ### For applications with user-facing filters No code changes required, but this is a good time to review your API design: ```typescript // Before: Vulnerable to injection app.get("/history", async (req, res) => { const history = await saver.list(config, { filter: req.query.filter // User-controlled - was vulnerable }); }); // After: Now safe, but consider validating allowed filter keys app.get("/history", async (req, res) => { const allowedKeys = ["source", "step"]; const sanitizedFilter = Object.fromEntries( Object.entries(req.query.filter || {}) .filter(([key]) => allowedKeys.includes(key)) ); const history = await saver.list(config, { filter: sanitizedFilter }); }); ``` > **Recommendation**: Even with the fix in place, consider validating that filter keys are from an allowed list as a defense-in-depth measure. ## References - [RediSearch Query Syntax](https://redis.io/docs/interact/search-and-query/query/) - [LangGraph Checkpoint Documentation](https://langchain-ai.github.io/langgraphjs/)

CVE-2026-27022 Affected @langchain/langgraph checkpoint redis Versions

1 component(s)
Fixed Versions:
1.0.2
Product / Package Ecosystem Affected Versions Fixed Version
@langchain/langgraph-checkpoint-redis
npm
< 1.0.2
1.0.2

References

Frequently Asked Questions

What is CVE-2026-27022?
CVE-2026-27022 is a security vulnerability in @langchain/langgraph checkpoint redis involving RediSearch Query Injection in @langchain/langgraph-checkpoint-redis under CWE-74: Improper Neutralization of Special Elements in Output Used by a Downstream Component ('Injection').
Which @langchain/langgraph checkpoint redis versions are affected?
Affected versions include releases prior to 1.0.2 across affected packages: @langchain/langgraph-checkpoint-redis.
What version fixes CVE-2026-27022?
Upgrading to 1.0.2 (or the latest patched release for your respective branch) resolves the vulnerability.
Is @langchain/langgraph-checkpoint-redis affected?
Yes, @langchain/langgraph-checkpoint-redis is affected in releases prior to 1.0.2. Upgrade your dependency to 1.0.2 or later.
What is the CVSS score of CVE-2026-27022?
CVE-2026-27022 has a CVSS v3.1 base score of 6.5 (MODERATE) with vector string CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N.
What CWE is associated with CVE-2026-27022?
CVE-2026-27022 is classified under CWE-74: Improper Neutralization of Special Elements in Output Used by a Downstream Component ('Injection') (The product constructs all or part of a command, data structure, or record using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify how it is parsed or interpreted when it is sent to a downstream component.).
How can I check npm dependencies for CVE-2026-27022?
Run the dependency tree command: 'npm ls @langchain/langgraph-checkpoint-redis'. This command lists direct and transitive dependencies in your build configuration so you can verify if a vulnerable version is resolved.
Machine-readable OSV JSON OSV v1.5 Schema
Normalized schema output
{
  "schema_version" : "1.4.0",
  "id" : "GHSA-5mx2-w598-339m",
  "modified" : "2026-02-23T22:20:29Z",
  "published" : "2026-02-18T22:40:09Z",
  "aliases" : [ "CVE-2026-27022" ],
  "summary" : "RediSearch Query Injection in @langchain/langgraph-checkpoint-redis",
  "details" : "## Summary\n\nA query injection vulnerability exists in the `@langchain/langgraph-checkpoint-redis` package's filter handling. The `RedisSaver` and `ShallowRedisSaver` classes construct RediSearch queries by directly interpolating user-provided filter keys and values without proper escaping. RediSearch has special syntax characters that can modify query behavior, and when user-controlled data contains these characters, the query logic can be manipulated to bypass intended access controls.\n\n## Attack surface\n\nThe core vulnerability was in the `list()` methods of both `RedisSaver` and `ShallowRedisSaver`: these methods failed to escape RediSearch special characters in filter keys and values when constructing queries. When unescaped data containing RediSearch syntax was used, the injected operators were interpreted by RediSearch rather than treated as literal search values.\n\nThis escaping bug enabled the following attack vector:\n\n- **Thread boundary escape via OR operator**: RediSearch uses `|` as an OR operator with specific precedence rules. A query like `A B | C` is interpreted as `(A AND B) OR C`. By injecting `}) | (@thread_id:{*` into a filter value, an attacker can append an OR clause that matches all threads, effectively bypassing the thread isolation constraint.\n\nThe injected query `(@thread_id:{legitimate-thread}) (@source:{x}) | (@thread_id:{*})` matches:\n\n- Documents with `thread_id:legitimate-thread AND source:x`, OR\n- Documents with ANY `thread_id`\n\nThe second clause matches all threads, bypassing thread isolation entirely.\n\n## Who is affected?\n\nApplications are vulnerable if they:\n\n- **Pass user-controlled input to filter parameters** — When using `getStateHistory()` or `checkpointer.list()` with filter values derived from user input, HTTP parameters, or other untrusted sources.\n- **Use Redis checkpointing in multi-tenant applications** — Applications that rely on thread isolation to separate data between users or tenants are at risk of cross-tenant data access.\n\nThe most common attack vector is through API endpoints that expose filtering capabilities to end users, allowing them to search or filter their conversation history.\n\n## Impact\n\nAttackers who control filter input can bypass thread isolation by injecting RediSearch OR operators to construct queries that match all threads regardless of the intended thread constraint. This enables access to checkpoint data from threads the attacker is not authorized to view.\n\nKey severity factors:\n\n- Enables complete bypass of thread-based access controls\n- Sensitive conversation data from other users may be exposed\n- Affects multi-tenant applications relying on thread isolation for data separation\n- Requires only control over filter input values (common in user-facing APIs)\n\n## Exploit example\n\n```typescript\nimport { RedisSaver } from \"@langchain/langgraph-checkpoint-redis\";\n\nconst saver = new RedisSaver({ /* redis config */ });\n\n// Normal usage - should only see thread \"user-123-thread\"\nconst legitHistory = saver.list({\n  configurable: { thread_id: \"user-123-thread\" }\n}, {\n  filter: { source: \"loop\" }\n});\n\n// Attacker crafts malicious filter value\nconst attackerFilter = {\n  source: \"x}) | (@thread_id:{*\"  // Injects OR clause matching ALL threads\n};\n\n// This produces a query like:\n// (@thread_id:{user-123-thread}) (@source:{x}) | (@thread_id:{*})\n// Due to precedence, this matches ALL threads!\n\nconst stolenHistory = saver.list({\n  configurable: { thread_id: \"user-123-thread\" }\n}, {\n  filter: attackerFilter\n});\n\n// stolenHistory now contains checkpoints from ALL threads - DATA LEAKED!\n```\n\n## Security hardening changes\n\nThe 1.0.2 patch introduces the following changes:\n\n- **Escape utility function**: A new `escapeRediSearchTagValue()` function properly escapes all RediSearch special characters (`- . < > { } [ ] \" ' : ; ! @ # $ % ^ & * ( ) + = ~ | \\ ? /`) by prefixing them with backslashes.\n- **Filter key escaping**: All filter keys are escaped before being used in query construction.\n- **Filter value escaping**: All filter values are escaped before being interpolated into RediSearch tag queries.\n\n## Migration guide\n\n### No changes needed for most users\n\nThe fix is backward compatible. Existing code will work without modifications—filter values that previously worked will continue to work, with the added protection against injection:\n\n```typescript\nimport { RedisSaver } from \"@langchain/langgraph-checkpoint-redis\";\n\n// Works exactly as before, now with injection protection\nconst history = saver.list(config, {\n  filter: { source: \"loop\" }\n});\n```\n\n### If you were relying on special characters\n\nIf your application intentionally used RediSearch syntax in filter values (unlikely but possible), be aware that these characters will now be escaped and treated as literals.\n\n### For applications with user-facing filters\n\nNo code changes required, but this is a good time to review your API design:\n\n```typescript\n// Before: Vulnerable to injection\napp.get(\"/history\", async (req, res) => {\n  const history = await saver.list(config, {\n    filter: req.query.filter  // User-controlled - was vulnerable\n  });\n});\n\n// After: Now safe, but consider validating allowed filter keys\napp.get(\"/history\", async (req, res) => {\n  const allowedKeys = [\"source\", \"step\"];\n  const sanitizedFilter = Object.fromEntries(\n    Object.entries(req.query.filter || {})\n      .filter(([key]) => allowedKeys.includes(key))\n  );\n  const history = await saver.list(config, {\n    filter: sanitizedFilter\n  });\n});\n```\n\n> **Recommendation**: Even with the fix in place, consider validating that filter keys are from an allowed list as a defense-in-depth measure.\n\n## References\n\n- [RediSearch Query Syntax](https://redis.io/docs/interact/search-and-query/query/)\n- [LangGraph Checkpoint Documentation](https://langchain-ai.github.io/langgraphjs/)",
  "severity" : [ {
    "type" : "CVSS_V3",
    "score" : "CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N"
  } ],
  "affected" : [ {
    "package" : {
      "ecosystem" : "npm",
      "name" : "@langchain/langgraph-checkpoint-redis"
    },
    "ranges" : [ {
      "type" : "ECOSYSTEM",
      "events" : [ {
        "introduced" : "0"
      }, {
        "fixed" : "1.0.2"
      } ]
    } ]
  } ],
  "references" : [ {
    "type" : "WEB",
    "url" : "https://github.com/langchain-ai/langgraphjs/security/advisories/GHSA-5mx2-w598-339m"
  }, {
    "type" : "ADVISORY",
    "url" : "https://nvd.nist.gov/vuln/detail/CVE-2026-27022"
  }, {
    "type" : "WEB",
    "url" : "https://github.com/langchain-ai/langgraphjs/pull/1943"
  }, {
    "type" : "WEB",
    "url" : "https://github.com/langchain-ai/langgraphjs/commit/814c76dc3938d0f6f7e17ca3bc11d6a12270b2a1"
  }, {
    "type" : "PACKAGE",
    "url" : "https://github.com/langchain-ai/langgraphjs"
  }, {
    "type" : "WEB",
    "url" : "https://github.com/langchain-ai/langgraphjs/releases/tag/@langchain/langgraph-checkpoint-redis@1.0.2"
  } ],
  "database_specific" : {
    "cwe_ids" : [ "CWE-74" ],
    "severity" : "MODERATE",
    "github_reviewed" : true,
    "github_reviewed_at" : "2026-02-18T22:40:09Z",
    "nvd_published_at" : "2026-02-20T22:16:28Z"
  }
}