langchain-core

The agent engineering platform.

View on Pypi

View on Github

Activity

Latest release: 2d ago
Total releases: 317
Cadence: ~2 days
Last 12 months: 91

Reach

Stars: 148.7k

Details

License: MIT
First release: Nov 20, 2023

Releases

Version	Released
`1.7.2` patch	Oct 29, 2026
`1.7.1` patch	Oct 28, 2026
`1.7.0` minor	Oct 22, 2026
`1.6.13` patch	Oct 21, 2026
`1.6.12` patch	Oct 16, 2026
`1.6.11` patch	Oct 15, 2026
`1.6.10` patch	Oct 12, 2026
`1.6.9` patch	Oct 08, 2026
`1.6.8` patch	Oct 08, 2026
`1.6.7` patch	Oct 06, 2026
`1.6.6` patch	Sep 29, 2026
`1.6.5` patch	Sep 24, 2026
`1.6.4` patch	Sep 21, 2026
`1.6.3` patch	Sep 11, 2026
`1.6.2` patch	Sep 04, 2026
`1.6.1` patch	Aug 27, 2026
`1.6.0` minor	Aug 19, 2026
`1.5.6` patch	Aug 17, 2026
`1.5.5` patch	Aug 14, 2026
`1.5.4` patch	Aug 11, 2026
`1.5.3` patch	Jul 30, 2026
`1.5.2` patch	Jul 28, 2026
`1.5.1` patch	Jul 23, 2026
`1.5.0` minor	Jul 21, 2026
`1.4.9` patch	Jul 08, 2026
`1.4.8` patch	Jun 18, 2026
`1.4.7` patch	Jun 12, 2026
`1.4.6` patch	Jun 11, 2026
`1.4.5` patch	Jun 11, 2026
`1.4.4` patch	Jun 10, 2026
`1.4.3` patch	Jun 09, 2026
`1.4.2` patch	Jun 08, 2026
`1.4.1` patch	Jun 05, 2026
`1.4.0` minor	May 11, 2026
`0.3.86` patch 2 CVEs	May 07, 2026
`0.3.85` patch 2 CVEs	May 05, 2026
`1.3.3` patch	May 05, 2026
`1.4.0a2` pre	May 01, 2026
`1.4.0a1` pre	May 01, 2026
`1.3.2` patch 1 CVE	Apr 24, 2026
`1.3.1` patch 1 CVE	Apr 23, 2026
`1.3.0` minor 1 CVE	Apr 17, 2026
`1.3.0a3` pre 1 CVE	Apr 16, 2026
`1.2.31` patch 1 CVE	Apr 16, 2026
`1.2.30` patch 1 CVE	Apr 15, 2026
`1.2.29` patch 1 CVE	Apr 14, 2026
`1.3.0a2` pre 1 CVE	Apr 13, 2026
`1.3.0a1` pre 1 CVE	Apr 10, 2026
`0.3.84` patch 3 CVEs	Apr 08, 2026
`1.2.28` patch 1 CVE	Apr 08, 2026

1–50 of 317

Repository

langchain-ai/langchain

Forks: 25.0k
Open issues: 568
Language: Python
: 5.7/ 10

ai
anthropic
gemini
langchain
llm
openai

Dependencies (10)

Depends on

1.7.2

Used by

6555

Supply-chain exposure

6,555 tracked projects depend on this, <1% of every package we track.

A known CVE here directly exposes every one of them.

Known CVEs (9)

CVE-2026-44843 PYSEC-2026-2564 GHSA-pjwx-r37v-7724 Jul 13, 2026

LangChain vulnerable to unsafe deserialization of attacker-controlled objects through overly broad `load()` allowlists

8.2 / 10
High
Network Low None None Unchanged High Low None

LangChain contains older runtime code paths that deserialize run inputs, run outputs, or other application-controlled payloads using overly broad object allowlists. These paths may call load() with allowed_objects="all". This does not enable arbitrary Python object deserialization, but it does allow any trusted LangChain-serializable object to be revived, which is broader than these runtime paths require. As a result, attacker-supplied LangChain serialized constructor dictionaries may cause trusted runtime paths to instantiate classes with untrusted constructor arguments.

Applications are exposed only when all of the following are true:

The application accepts untrusted structured input, such as JSON, from a user or network request.

The application does not validate or canonicalize that input into an inert schema before invoking LangChain.

Attacker-controlled nested dictionaries or lists are preserved in LangChain run inputs or outputs.

The application uses an affected API path that later deserializes that run data.

Known affected runtime surfaces include:

RunnableWithMessageHistory

astream_log()

astream_events(version="v1")

Related unsafe deserialization patterns may also affect applications that explicitly load serialized LangChain prompt or runnable objects from untrusted sources, including shared prompt stores, Hub artifacts with model configuration, or other application-controlled serialization stores.

Applications that validate incoming requests against a fixed schema, such as coercing user input to a plain string or message-content field before invoking LangChain, are unlikely to expose this deserialization primitive.

This release also fixes a related secret-marker validation bypass in the serialization and deserialization layer (_is_lc_secret). That issue creates an additional path by which attacker-controlled constructor dictionaries can avoid escaping during dumps() -> loads() round-trips and reach LangChain object revival logic.

Impact

An attacker who can submit untrusted structured input to an affected application, and have that structure preserved in LangChain run data, may be able to inject LangChain serialized constructor payloads such as:

{ "lc": 1, "type": "constructor", "id": ["langchain_core", "messages", "ai", "AIMessage"], "kwargs": {"content": "attacker-controlled content"} }

If this payload reaches a broad load() call, LangChain may instantiate the referenced class instead of treating the payload as inert user data.

Realistic impacts include:

Persistent chat-history poisoning when revived AIMessage, HumanMessage, or SystemMessage objects are stored by RunnableWithMessageHistory.

Prompt injection or behavior manipulation if attacker-controlled messages are later included in model context.

Instantiation of unexpected trusted LangChain objects with attacker-controlled constructor arguments.

Possible credential disclosure or server-side requests if a reachable object reads environment credentials, creates clients, or contacts attacker-controlled endpoints during initialization.

Additional prompt-template or runnable-configuration impacts in applications that separately load and execute untrusted serialized LangChain objects.

Remediation

LangChain will deprecate the affected APIs as part of this fix:

RunnableWithMessageHistory

astream_log()

astream_events(version="v1")

These are older code paths that are no longer recommended for new applications. They were not previously marked as deprecated, but recent LangChain documentation has primarily directed users toward newer streaming and memory patterns, including the stream API. Applications should migrate to the currently recommended APIs rather than continue depending on these older surfaces.

Separately, LangChain will update load() and loads() to tighten deserialization behavior so broad object revival is not applied implicitly to untrusted or application-controlled payloads. The older runtime surfaces listed above are being deprecated rather than preserved as supported paths for broad runtime deserialization.

This release also fixes a related secret-marker validation bypass in the serialization and deserialization layer (_is_lc_secret). That issue creates an additional path by which attacker-controlled constructor dictionaries can avoid escaping during dumps() -> loads() round-trips and reach LangChain object revival logic.

Guidance for load() and loads()

load() and loads() should be used only with trusted LangChain manifests or serialized objects from trusted storage. Do not pass user-controlled data to load() or loads(), and do not use them as general parsers for request bodies, tool inputs, chat messages, or other attacker-controlled data.

load() and loads() are beta APIs, and their behavior may change as LangChain narrows unsafe defaults. Future LangChain versions will require callers to be explicit about which objects may be revived. Users should pass a narrow allowed_objects value appropriate for the specific trusted manifest they are loading, rather than relying on broad defaults or allowed_objects="all", which permits the full trusted LangChain serialization allowlist.

Credits

The original issue was first reported by @u-ktdi.

Similar findings were reported by @dewankpant, @shrutilohani, @Moaaz-0x, @pucagit.

A related _is_lc_secret marker bypass affecting dumps() -> loads() round-trips was reported by @yardenporat353 (and a similar report by @localhost-detect)

Affected versions

0.0.10.0.100.0.110.0.120.0.130.0.13rc10.0.13rc20.0.20.0.30.0.40.0.50.0.6

+ 254 more Show less

0.0.70.0.80.0.90.1.00.1.10.1.100.1.110.1.120.1.12rc10.1.130.1.140.1.150.1.15rc10.1.15rc20.1.160.1.170.1.180.1.190.1.20.1.200.1.210.1.220.1.230.1.240.1.250.1.260.1.270.1.280.1.290.1.30.1.300.1.310.1.320.1.330.1.33rc10.1.340.1.350.1.360.1.370.1.380.1.390.1.40.1.400.1.410.1.420.1.42rc10.1.430.1.440.1.450.1.460.1.470.1.47rc10.1.480.1.490.1.50.1.500.1.510.1.520.1.530.1.60.1.70.1.80.1.90.2.00.2.0rc10.2.10.2.100.2.110.2.120.2.130.2.150.2.160.2.170.2.180.2.190.2.20.2.200.2.210.2.220.2.230.2.240.2.250.2.260.2.270.2.280.2.290.2.29rc10.2.2rc10.2.30.2.300.2.310.2.320.2.330.2.340.2.350.2.360.2.370.2.380.2.390.2.40.2.400.2.410.2.420.2.430.2.50.2.60.2.70.2.80.2.90.3.00.3.0.dev00.3.0.dev10.3.0.dev20.3.0.dev30.3.0.dev40.3.0.dev50.3.10.3.100.3.110.3.120.3.130.3.140.3.150.3.160.3.170.3.180.3.190.3.20.3.200.3.210.3.220.3.230.3.240.3.250.3.260.3.270.3.280.3.290.3.30.3.300.3.310.3.320.3.330.3.340.3.34rc10.3.34rc20.3.350.3.360.3.370.3.380.3.390.3.40.3.400.3.410.3.420.3.430.3.440.3.450.3.45rc10.3.460.3.470.3.480.3.490.3.50.3.500.3.510.3.520.3.530.3.540.3.550.3.560.3.56rc10.3.570.3.580.3.590.3.60.3.600.3.610.3.620.3.630.3.640.3.650.3.660.3.670.3.680.3.690.3.70.3.700.3.710.3.720.3.730.3.740.3.750.3.760.3.770.3.780.3.790.3.80.3.800.3.810.3.820.3.830.3.840.3.91.0.01.0.11.0.21.0.31.0.41.0.51.0.61.0.71.1.01.1.11.1.21.1.31.2.01.2.11.2.101.2.111.2.121.2.131.2.141.2.151.2.161.2.171.2.181.2.191.2.21.2.201.2.211.2.221.2.231.2.241.2.251.2.261.2.271.2.281.2.291.2.31.2.301.2.311.2.41.2.51.2.61.2.71.2.81.2.91.3.01.3.0a11.3.0a21.3.0a31.3.11.3.2

Fixed in

0.3.851.3.3

References

https://github.com/langchain-ai/langchain/security/advisories/GHSA-pjwx-r37v-7724
https://nvd.nist.gov/vuln/detail/CVE-2026-44843
https://github.com/langchain-ai/langchain
https://pypi.org/project/langchain-core
https://github.com/advisories/GHSA-pjwx-r37v-7724

Updated Jul 13, 2026 · Source: OSV.dev
CVE-2026-40087 PYSEC-2026-2563 GHSA-926x-3r5x-gfhw Jul 13, 2026

LangChain has incomplete f-string validation in prompt templates

5.3 / 10
Medium
Network Low None None Unchanged Low None None

LangChain's f-string prompt-template validation was incomplete in two respects.

First, some prompt template classes accepted f-string templates and formatted them without enforcing the same attribute-access validation as PromptTemplate. In particular, DictPromptTemplate and ImagePromptTemplate could accept templates containing attribute access or indexing expressions and subsequently evaluate those expressions during formatting.

Examples of the affected shape include:

"{message.additional_kwargs[secret]}" "https://example.com/{image.__class__.__name__}.png"

Second, f-string validation based on parsed top-level field names did not reject nested replacement fields inside format specifiers. For example:

"{name:{name.__class__.__name__}}"

In this pattern, the nested replacement field appears in the format specifier rather than in the top-level field name. As a result, earlier validation based on parsed field names did not reject the template even though Python formatting would still attempt to resolve the nested expression at runtime.

Affected usage

This issue is only relevant for applications that accept untrusted template strings, rather than only untrusted template variable values.

In addition, practical impact depends on what objects are passed into template formatting:

If applications only format simple values such as strings and numbers, impact is limited and may only result in formatting errors.

If applications format richer Python objects, attribute access and indexing may interact with internal object state during formatting.

In many deployments, these conditions are not commonly present together. Applications that allow end users to author arbitrary templates often expose only a narrow set of simple template variables, while applications that work with richer internal Python objects often keep template structure under developer control. As a result, the highest-impact scenario is plausible but is not representative of all LangChain applications.

Applications that use hardcoded templates or that only allow users to provide variable values are not affected by this issue.

Impact

The direct issue in DictPromptTemplate and ImagePromptTemplate allowed attribute access and indexing expressions to survive template construction and then be evaluated during formatting. When richer Python objects were passed into formatting, this could expose internal fields or nested data to prompt output, model context, or logs.

The nested format-spec issue is narrower in scope. It bypassed the intended validation rules for f-string templates, but in simple cases it results in an invalid format specifier error rather than direct disclosure. Accordingly, its practical impact is lower than that of direct top-level attribute traversal.

Overall, the practical severity depends on deployment. Meaningful confidentiality impact requires attacker control over the template structure itself, and higher impact further depends on the surrounding application passing richer internal Python objects into formatting.

Fix

The fix consists of two changes.

First, LangChain now applies f-string safety validation consistently to DictPromptTemplate and ImagePromptTemplate, so templates containing attribute access or indexing expressions are rejected during construction and deserialization.

Second, LangChain now rejects nested replacement fields inside f-string format specifiers.

Concretely, LangChain validates parsed f-string fields and raises an error for:

variable names containing attribute access or indexing syntax such as . or []

format specifiers containing { or }

This blocks templates such as:

"{message.additional_kwargs[secret]}" "https://example.com/{image.__class__.__name__}.png" "{name:{name.__class__.__name__}}"

The fix preserves ordinary f-string formatting features such as standard format specifiers and conversions, including examples like:

"{value:.2f}" "{value:>10}" "{value!r}"

In addition, the explicit template-validation path now applies the same structural f-string checks before performing placeholder validation, ensuring that the security checks and validation checks remain aligned.

Affected versions

0.0.10.0.100.0.110.0.120.0.130.0.13rc10.0.13rc20.0.20.0.30.0.40.0.50.0.6

+ 254 more Show less

0.0.70.0.80.0.90.1.00.1.10.1.100.1.110.1.120.1.12rc10.1.130.1.140.1.150.1.15rc10.1.15rc20.1.160.1.170.1.180.1.190.1.20.1.200.1.210.1.220.1.230.1.240.1.250.1.260.1.270.1.280.1.290.1.30.1.300.1.310.1.320.1.330.1.33rc10.1.340.1.350.1.360.1.370.1.380.1.390.1.40.1.400.1.410.1.420.1.42rc10.1.430.1.440.1.450.1.460.1.470.1.47rc10.1.480.1.490.1.50.1.500.1.510.1.520.1.530.1.60.1.70.1.80.1.90.2.00.2.0rc10.2.10.2.100.2.110.2.120.2.130.2.150.2.160.2.170.2.180.2.190.2.20.2.200.2.210.2.220.2.230.2.240.2.250.2.260.2.270.2.280.2.290.2.29rc10.2.2rc10.2.30.2.300.2.310.2.320.2.330.2.340.2.350.2.360.2.370.2.380.2.390.2.40.2.400.2.410.2.420.2.430.2.50.2.60.2.70.2.80.2.90.3.00.3.0.dev00.3.0.dev10.3.0.dev20.3.0.dev30.3.0.dev40.3.0.dev50.3.10.3.100.3.110.3.120.3.130.3.140.3.150.3.160.3.170.3.180.3.190.3.20.3.200.3.210.3.220.3.230.3.240.3.250.3.260.3.270.3.280.3.290.3.30.3.300.3.310.3.320.3.330.3.340.3.34rc10.3.34rc20.3.350.3.360.3.370.3.380.3.390.3.40.3.400.3.410.3.420.3.430.3.440.3.450.3.45rc10.3.460.3.470.3.480.3.490.3.50.3.500.3.510.3.520.3.530.3.540.3.550.3.560.3.56rc10.3.570.3.580.3.590.3.60.3.600.3.610.3.620.3.630.3.640.3.650.3.660.3.670.3.680.3.690.3.70.3.700.3.710.3.720.3.730.3.740.3.750.3.760.3.770.3.780.3.790.3.80.3.800.3.810.3.820.3.830.3.91.0.01.0.0a11.0.0a21.0.0a31.0.0a41.0.0a51.0.0a61.0.0a71.0.0a81.0.0rc11.0.0rc21.0.0rc31.0.11.0.21.0.31.0.41.0.51.0.61.0.71.1.01.1.11.1.21.1.31.2.01.2.11.2.101.2.111.2.121.2.131.2.141.2.151.2.161.2.171.2.181.2.191.2.21.2.201.2.211.2.221.2.231.2.241.2.251.2.261.2.271.2.31.2.41.2.51.2.61.2.71.2.81.2.9

Fixed in

0.3.841.2.28

References

https://github.com/langchain-ai/langchain/security/advisories/GHSA-926x-3r5x-gfhw
https://nvd.nist.gov/vuln/detail/CVE-2026-40087
https://github.com/langchain-ai/langchain/pull/36612
https://github.com/langchain-ai/langchain/pull/36613
https://github.com/langchain-ai/langchain/commit/6bab0ba3c12328008ddca3e0d54ff5a6151cd27b
https://github.com/langchain-ai/langchain/commit/af2ed47c6f008cdd551f3c0d87db3774c8dfe258

Updated Jul 13, 2026 · Source: OSV.dev
CVE-2026-26013 PYSEC-2026-2562 GHSA-2g6r-c272-w58r Jul 13, 2026

LangChain affected by SSRF via image_url token counting in ChatOpenAI.get_num_tokens_from_messages

3.7 / 10
Low
Network High None None Unchanged None None Low

Server-Side Request Forgery (SSRF) in ChatOpenAI Image Token Counting

Summary

The ChatOpenAI.get_num_tokens_from_messages() method fetches arbitrary image_url values without validation when computing token counts for vision-enabled models. This allows attackers to trigger Server-Side Request Forgery (SSRF) attacks by providing malicious image URLs in user input.

Severity

Low - The vulnerability allows SSRF attacks but has limited impact due to:

Responses are not returned to the attacker (blind SSRF)

Default 5-second timeout limits resource exhaustion

Non-image responses fail at PIL image parsing

Impact

An attacker who can control image URLs passed to get_num_tokens_from_messages() can:

Trigger HTTP requests from the application server to arbitrary internal or external URLs

Cause the server to access internal network resources (private IPs, cloud metadata endpoints)

Cause minor resource consumption through image downloads (bounded by timeout)

Note: This vulnerability occurs during token counting, which may happen outside of model invocation (e.g., in logging, metrics, or token budgeting flows).

Details

The vulnerable code path:

get_num_tokens_from_messages() processes messages containing image_url content blocks

For images without detail: "low", it calls _url_to_size() to fetch the image and compute token counts

_url_to_size() performs httpx.get(image_source) on any URL without validation

Prior to the patch, there was no SSRF protection, size limits, or explicit timeout

File: libs/partners/openai/langchain_openai/chat_models/base.py

Patches

The vulnerability has been patched in langchain-openai==1.1.9 (requires langchain-core==1.2.11).

The patch adds:

SSRF validation using langchain_core._security._ssrf_protection.validate_safe_url() to block:

Private IP ranges (RFC 1918, loopback, link-local)

Cloud metadata endpoints (169.254.169.254, etc.)

Invalid URL schemes

Explicit size limits (50 MB maximum, matching OpenAI's payload limit)

Explicit timeout (5 seconds, same as httpx.get default)

Allow disabling image fetching via allow_fetching_images=False parameter

Workarounds

If you cannot upgrade immediately:

Sanitize input: Validate and filter image_url values before passing messages to token counting or model invocation

Use network controls: Implement egress filtering to prevent outbound requests to private IPs

Affected versions

0.0.10.0.100.0.110.0.120.0.130.0.13rc10.0.13rc20.0.20.0.30.0.40.0.50.0.6

+ 241 more Show less

0.0.70.0.80.0.90.1.00.1.10.1.100.1.110.1.120.1.12rc10.1.130.1.140.1.150.1.15rc10.1.15rc20.1.160.1.170.1.180.1.190.1.20.1.200.1.210.1.220.1.230.1.240.1.250.1.260.1.270.1.280.1.290.1.30.1.300.1.310.1.320.1.330.1.33rc10.1.340.1.350.1.360.1.370.1.380.1.390.1.40.1.400.1.410.1.420.1.42rc10.1.430.1.440.1.450.1.460.1.470.1.47rc10.1.480.1.490.1.50.1.500.1.510.1.520.1.530.1.60.1.70.1.80.1.90.2.00.2.0rc10.2.10.2.100.2.110.2.120.2.130.2.150.2.160.2.170.2.180.2.190.2.20.2.200.2.210.2.220.2.230.2.240.2.250.2.260.2.270.2.280.2.290.2.29rc10.2.2rc10.2.30.2.300.2.310.2.320.2.330.2.340.2.350.2.360.2.370.2.380.2.390.2.40.2.400.2.410.2.420.2.430.2.50.2.60.2.70.2.80.2.90.3.00.3.0.dev00.3.0.dev10.3.0.dev20.3.0.dev30.3.0.dev40.3.0.dev50.3.10.3.100.3.110.3.120.3.130.3.140.3.150.3.160.3.170.3.180.3.190.3.20.3.200.3.210.3.220.3.230.3.240.3.250.3.260.3.270.3.280.3.290.3.30.3.300.3.310.3.320.3.330.3.340.3.34rc10.3.34rc20.3.350.3.360.3.370.3.380.3.390.3.40.3.400.3.410.3.420.3.430.3.440.3.450.3.45rc10.3.460.3.470.3.480.3.490.3.50.3.500.3.510.3.520.3.530.3.540.3.550.3.560.3.56rc10.3.570.3.580.3.590.3.60.3.600.3.610.3.620.3.630.3.640.3.650.3.660.3.670.3.680.3.690.3.70.3.700.3.710.3.720.3.730.3.740.3.750.3.760.3.770.3.780.3.790.3.80.3.800.3.810.3.820.3.830.3.840.3.850.3.860.3.90.4.0.dev01.0.01.0.0a11.0.0a21.0.0a31.0.0a41.0.0a51.0.0a61.0.0a71.0.0a81.0.0rc11.0.0rc21.0.0rc31.0.11.0.21.0.31.0.41.0.51.0.61.0.71.1.01.1.11.1.21.1.31.2.01.2.11.2.101.2.21.2.31.2.41.2.51.2.61.2.71.2.81.2.9

Fixed in

1.2.11

References

https://github.com/langchain-ai/langchain/security/advisories/GHSA-2g6r-c272-w58r
https://nvd.nist.gov/vuln/detail/CVE-2026-26013
https://github.com/langchain-ai/langchain/commit/2b4b1dc29a833d4053deba4c2b77a3848c834565
https://github.com/langchain-ai/langchain
https://github.com/langchain-ai/langchain/releases/tag/langchain-core%3D%3D1.2.11
https://pypi.org/project/langchain-core

Updated Jul 13, 2026 · Source: OSV.dev
CVE-2025-65106 PYSEC-2026-1518 GHSA-6qv9-48xg-fc7f Jul 07, 2026

LangChain Vulnerable to Template Injection via Attribute Access in Prompt Templates

High
Network Low None None

Context

A template injection vulnerability exists in LangChain's prompt template system that allows attackers to access Python object internals through template syntax. This vulnerability affects applications that accept untrusted template strings (not just template variables) in ChatPromptTemplate and related prompt template classes.

Templates allow attribute access (.) and indexing ([]) but not method invocation (()).

The combination of attribute access and indexing may enable exploitation depending on which objects are passed to templates. When template variables are simple strings (the common case), the impact is limited. However, when using MessagesPlaceholder with chat message objects, attackers can traverse through object attributes and dictionary lookups (e.g., __globals__) to reach sensitive data such as environment variables.

The vulnerability specifically requires that applications accept template strings (the structure) from untrusted sources, not just template variables (the data). Most applications either do not use templates or else use hardcoded templates and are not vulnerable.

Affected Components

langchain-core package

Template formats:

F-string templates (template_format="f-string") - Vulnerability fixed

Mustache templates (template_format="mustache") - Defensive hardening

Jinja2 templates (template_format="jinja2") - Defensive hardening

Impact

Attackers who can control template strings (not just template variables) can:

Access Python object attributes and internal properties via attribute traversal

Extract sensitive information from object internals (e.g., __class__, __globals__)

Potentially escalate to more severe attacks depending on the objects passed to templates

Attack Vectors

1. F-string Template Injection

Before Fix:

from langchain_core.prompts import ChatPromptTemplate malicious_template = ChatPromptTemplate.from_messages( [("human", "{msg.__class__.__name__}")], template_format="f-string" ) # Note that this requires passing a placeholder variable for "msg.__class__.__name__". result = malicious_template.invoke({"msg": "foo", "msg.__class__.__name__": "safe_placeholder"}) # Previously returned # >>> result.messages[0].content # >>> 'str'

2. Mustache Template Injection

Before Fix:

from langchain_core.prompts import ChatPromptTemplate from langchain_core.messages import HumanMessage msg = HumanMessage("Hello") # Attacker controls the template string malicious_template = ChatPromptTemplate.from_messages( [("human", "{{question.__class__.__name__}}")], template_format="mustache" ) result = malicious_template.invoke({"question": msg}) # Previously returned: "HumanMessage" (getattr() exposed internals)

3. Jinja2 Template Injection

Before Fix:

from langchain_core.prompts import ChatPromptTemplate from langchain_core.messages import HumanMessage msg = HumanMessage("Hello") # Attacker controls the template string malicious_template = ChatPromptTemplate.from_messages( [("human", "{{question.parse_raw}}")], template_format="jinja2" ) result = malicious_template.invoke({"question": msg}) # Could access non-dunder attributes/methods on objects

Root Cause

F-string templates: The implementation used Python's string.Formatter().parse() to extract variable names from template strings. This method returns the complete field expression, including attribute access syntax:
from string import Formatter template = "{msg.__class__} and {x}" print([var_name for (_, var_name, _, _) in Formatter().parse(template)]) # Returns: ['msg.__class__', 'x']
The extracted names were not validated to ensure they were simple identifiers. As a result, template strings containing attribute traversal and indexing expressions (e.g., {obj.__class__.__name__} or {obj.method.__globals__[os]}) were accepted and subsequently evaluated during formatting. While f-string templates do not support method calls with (), they do support [] indexing, which could allow traversal through dictionaries like __globals__ to reach sensitive objects.

Mustache templates: By design, used getattr() as a fallback to support accessing attributes on objects (e.g., {{user.name}} on a User object). However, we decided to restrict this to simpler primitives that subclass dict, list, and tuple types as defensive hardening, since untrusted templates could exploit attribute access to reach internal properties like class on arbitrary objects

Jinja2 templates: Jinja2's default SandboxedEnvironment blocks dunder attributes (e.g., __class__) but permits access to other attributes and methods on objects. While Jinja2 templates in LangChain are typically used with trusted template strings, as a defense-in-depth measure, we've restricted the environment to block all attribute and method access on objects passed to templates.

Who Is Affected?

High Risk Scenarios

You are affected if your application:

Accepts template strings from untrusted sources (user input, external APIs, databases)

Dynamically constructs prompt templates based on user-provided patterns

Allows users to customize or create prompt templates

Example vulnerable code:

# User controls the template string itself user_template_string = request.json.get("template") # DANGEROUS prompt = ChatPromptTemplate.from_messages( [("human", user_template_string)], template_format="mustache" ) result = prompt.invoke({"data": sensitive_object})

Low/No Risk Scenarios

You are NOT affected if:

Template strings are hardcoded in your application code

Template strings come only from trusted, controlled sources

Users can only provide values for template variables, not the template structure itself

Example safe code:

# Template is hardcoded - users only control variables prompt = ChatPromptTemplate.from_messages( [("human", "User question: {question}")], # SAFE template_format="f-string" ) # User input only fills the 'question' variable result = prompt.invoke({"question": user_input})

The Fix

F-string Templates

F-string templates had a clear vulnerability where attribute access syntax was exploitable. We've added strict validation to prevent this:

Added validation to enforce that variable names must be valid Python identifiers

Rejects syntax like {obj.attr}, {obj[0]}, or {obj.__class__}

Only allows simple variable names: {variable_name}

# After fix - these are rejected at template creation time ChatPromptTemplate.from_messages( [("human", "{msg.__class__}")], # ValueError: Invalid variable name template_format="f-string" )

Mustache Templates (Defensive Hardening)

As defensive hardening, we've restricted what Mustache templates support to reduce the attack surface:

Replaced getattr() fallback with strict type checking

Only allows traversal into dict, list, and tuple types

Blocks attribute access on arbitrary Python objects

# After hardening - attribute access returns empty string prompt = ChatPromptTemplate.from_messages( [("human", "{{msg.__class__}}")], template_format="mustache" ) result = prompt.invoke({"msg": HumanMessage("test")}) # Returns: "" (access blocked)

Jinja2 Templates (Defensive Hardening)

As defensive hardening, we've significantly restricted Jinja2 template capabilities:

Introduced _RestrictedSandboxedEnvironment that blocks ALL attribute/method access

Only allows simple variable lookups from the context dictionary

Raises SecurityError on any attribute access attempt

# After hardening - all attribute access is blocked prompt = ChatPromptTemplate.from_messages( [("human", "{{msg.content}}")], template_format="jinja2" ) # Raises SecurityError: Access to attributes is not allowed

Important Recommendation: Due to the expressiveness of Jinja2 and the difficulty of fully sandboxing it, we recommend reserving Jinja2 templates for trusted sources only. If you need to accept template strings from untrusted users, use f-string or mustache templates with the new restrictions instead.

While we've hardened the Jinja2 implementation, the nature of templating engines makes comprehensive sandboxing challenging. The safest approach is to only use Jinja2 templates when you control the template source.

Important Reminder: Many applications do not need prompt templates. Templates are useful for variable substitution and dynamic logic (if statements, loops, conditionals). However, if you're building a chatbot or conversational application, you can often work directly with message objects (e.g., HumanMessage, AIMessage, ToolMessage) without templates. Direct message construction avoids template-related security concerns entirely.

Remediation

Immediate Actions

Audit your code for any locations where template strings come from untrusted sources

Update to the patched version of langchain-core

Review template usage to ensure separation between template structure and user data

Best Practices

Consider if you need templates at all - Many applications can work directly with message objects (HumanMessage, AIMessage, etc.) without templates## Context

A template injection vulnerability exists in LangChain's prompt template system that allows attackers to access Python object internals through template syntax. This vulnerability affects applications that accept untrusted template strings (not just template variables) in ChatPromptTemplate and related prompt template classes.

Templates allow attribute access (.) and indexing ([]) but not method invocation (()).

The combination of attribute access and indexing may enable exploitation depending on which objects are passed to templates. When template variables are simple strings (the common case), the impact is limited. However, when using MessagesPlaceholder with chat message objects, attackers can traverse through object attributes and dictionary lookups (e.g., __globals__) to reach sensitive data such as environment variables.

The vulnerability specifically requires that applications accept template strings (the structure) from untrusted sources, not just template variables (the data). Most applications either do not use templates or else use hardcoded templates and are not vulnerable.

Affected Components

langchain-core package

Template formats:

F-string templates (template_format="f-string") - Vulnerability fixed

Mustache templates (template_format="mustache") - Defensive hardening

Jinja2 templates (template_format="jinja2") - Defensive hardening

Impact

Attackers who can control template strings (not just template variables) can:

Access Python object attributes and internal properties via attribute traversal

Extract sensitive information from object internals (e.g., __class__, __globals__)

Potentially escalate to more severe attacks depending on the objects passed to templates

Attack Vectors

1. F-string Template Injection

Before Fix:

from langchain_core.prompts import ChatPromptTemplate malicious_template = ChatPromptTemplate.from_messages( [("human", "{msg.__class__.__name__}")], template_format="f-string" ) # Note that this requires passing a placeholder variable for "msg.__class__.__name__". result = malicious_template.invoke({"msg": "foo", "msg.__class__.__name__": "safe_placeholder"}) # Previously returned # >>> result.messages[0].content # >>> 'str'

2. Mustache Template Injection

Before Fix:

from langchain_core.prompts import ChatPromptTemplate from langchain_core.messages import HumanMessage msg = HumanMessage("Hello") # Attacker controls the template string malicious_template = ChatPromptTemplate.from_messages( [("human", "{{question.__class__.__name__}}")], template_format="mustache" ) result = malicious_template.invoke({"question": msg}) # Previously returned: "HumanMessage" (getattr() exposed internals)

3. Jinja2 Template Injection

Before Fix:

from langchain_core.prompts import ChatPromptTemplate from langchain_core.messages import HumanMessage msg = HumanMessage("Hello") # Attacker controls the template string malicious_template = ChatPromptTemplate.from_messages( [("human", "{{question.parse_raw}}")], template_format="jinja2" ) result = malicious_template.invoke({"question": msg}) # Could access non-dunder attributes/methods on objects

Root Cause

F-string templates: The implementation used Python's string.Formatter().parse() to extract variable names from template strings. This method returns the complete field expression, including attribute access syntax:
from string import Formatter template = "{msg.__class__} and {x}" print([var_name for (_, var_name, _, _) in Formatter().parse(template)]) # Returns: ['msg.__class__', 'x']
The extracted names were not validated to ensure they were simple identifiers. As a result, template strings containing attribute traversal and indexing expressions (e.g., {obj.__class__.__name__} or {obj.method.__globals__[os]}) were accepted and subsequently evaluated during formatting. While f-string templates do not support method calls with (), they do support [] indexing, which could allow traversal through dictionaries like __globals__ to reach sensitive objects.

Mustache templates: By design, used getattr() as a fallback to support accessing attributes on objects (e.g., {{user.name}} on a User object). However, we decided to restrict this to simpler primitives that subclass dict, list, and tuple types as defensive hardening, since untrusted templates could exploit attribute access to reach internal properties like class on arbitrary objects

Jinja2 templates: Jinja2's default SandboxedEnvironment blocks dunder attributes (e.g., __class__) but permits access to other attributes and methods on objects. While Jinja2 templates in LangChain are typically used with trusted template strings, as a defense-in-depth measure, we've restricted the environment to block all attribute and method access on objects passed to templates.

Who Is Affected?

High Risk Scenarios

You are affected if your application:

Accepts template strings from untrusted sources (user input, external APIs, databases)

Dynamically constructs prompt templates based on user-provided patterns

Allows users to customize or create prompt templates

Example vulnerable code:

# User controls the template string itself user_template_string = request.json.get("template") # DANGEROUS prompt = ChatPromptTemplate.from_messages( [("human", user_template_string)], template_format="mustache" ) result = prompt.invoke({"data": sensitive_object})

Low/No Risk Scenarios

You are NOT affected if:

Template strings are hardcoded in your application code

Template strings come only from trusted, controlled sources

Users can only provide values for template variables, not the template structure itself

Example safe code:

# Template is hardcoded - users only control variables prompt = ChatPromptTemplate.from_messages( [("human", "User question: {question}")], # SAFE template_format="f-string" ) # User input only fills the 'question' variable result = prompt.invoke({"question": user_input})

The Fix

F-string Templates

F-string templates had a clear vulnerability where attribute access syntax was exploitable. We've added strict validation to prevent this:

Added validation to enforce that variable names must be valid Python identifiers

Rejects syntax like {obj.attr}, {obj[0]}, or {obj.__class__}

Only allows simple variable names: {variable_name}

# After fix - these are rejected at template creation time ChatPromptTemplate.from_messages( [("human", "{msg.__class__}")], # ValueError: Invalid variable name template_format="f-string" )

Mustache Templates (Defensive Hardening)

As defensive hardening, we've restricted what Mustache templates support to reduce the attack surface:

Replaced getattr() fallback with strict type checking

Only allows traversal into dict, list, and tuple types

Blocks attribute access on arbitrary Python objects

# After hardening - attribute access returns empty string prompt = ChatPromptTemplate.from_messages( [("human", "{{msg.__class__}}")], template_format="mustache" ) result = prompt.invoke({"msg": HumanMessage("test")}) # Returns: "" (access blocked)

Jinja2 Templates (Defensive Hardening)

As defensive hardening, we've significantly restricted Jinja2 template capabilities:

Introduced _RestrictedSandboxedEnvironment that blocks ALL attribute/method access

Only allows simple variable lookups from the context dictionary

Raises SecurityError on any attribute access attempt

# After hardening - all attribute access is blocked prompt = ChatPromptTemplate.from_messages( [("human", "{{msg.content}}")], template_format="jinja2" ) # Raises SecurityError: Access to attributes is not allowed

Important Recommendation: Due to the expressiveness of Jinja2 and the difficulty of fully sandboxing it, we recommend reserving Jinja2 templates for trusted sources only. If you need to accept template strings from untrusted users, use f-string or mustache templates with the new restrictions instead.

While we've hardened the Jinja2 implementation, the nature of templating engines makes comprehensive sandboxing challenging. The safest approach is to only use Jinja2 templates when you control the template source.

Important Reminder: Many applications do not need prompt templates. Templates are useful for variable substitution and dynamic logic (if statements, loops, conditionals). However, if you're building a chatbot or conversational application, you can often work directly with message objects (e.g., HumanMessage, AIMessage, ToolMessage) without templates. Direct message construction avoids template-related security concerns entirely.

Remediation

Immediate Actions

Audit your code for any locations where template strings come from untrusted sources

Update to the patched version of langchain-core

Review template usage to ensure separation between template structure and user data

Best Practices

Consider if you need templates at all - Many applications can work directly with message objects (HumanMessage, AIMessage, etc.) without templates

Reserve Jinja2 for trusted sources - Only use Jinja2 templates when you fully control the template content

Update: Jinja2 Restrictions Reverted

The Jinja2 hardening introduced in the initial patch has been reverted as of langchain-core 1.1.3. The restriction was not addressing a direct vulnerability but was part of broader defensive hardening. In practice, it significantly limited legitimate Jinja2 usage and broke existing templates. Since Jinja2 is intended to be used only with trusted template sources, the original behavior has been restored. Users should continue to avoid accepting untrusted template strings when using Jinja2, but no security issue exists with trusted templates.

Affected versions

0.0.10.0.100.0.110.0.120.0.130.0.13rc10.0.13rc20.0.20.0.30.0.40.0.50.0.6

+ 206 more Show less

0.0.70.0.80.0.90.1.00.1.10.1.100.1.110.1.120.1.12rc10.1.130.1.140.1.150.1.15rc10.1.15rc20.1.160.1.170.1.180.1.190.1.20.1.200.1.210.1.220.1.230.1.240.1.250.1.260.1.270.1.280.1.290.1.30.1.300.1.310.1.320.1.330.1.33rc10.1.340.1.350.1.360.1.370.1.380.1.390.1.40.1.400.1.410.1.420.1.42rc10.1.430.1.440.1.450.1.460.1.470.1.47rc10.1.480.1.490.1.50.1.500.1.510.1.520.1.530.1.60.1.70.1.80.1.90.2.00.2.0rc10.2.10.2.100.2.110.2.120.2.130.2.150.2.160.2.170.2.180.2.190.2.20.2.200.2.210.2.220.2.230.2.240.2.250.2.260.2.270.2.280.2.290.2.29rc10.2.2rc10.2.30.2.300.2.310.2.320.2.330.2.340.2.350.2.360.2.370.2.380.2.390.2.40.2.400.2.410.2.420.2.430.2.50.2.60.2.70.2.80.2.90.3.00.3.0.dev00.3.0.dev10.3.0.dev20.3.0.dev30.3.0.dev40.3.0.dev50.3.10.3.100.3.110.3.120.3.130.3.140.3.150.3.160.3.170.3.180.3.190.3.20.3.200.3.210.3.220.3.230.3.240.3.250.3.260.3.270.3.280.3.290.3.30.3.300.3.310.3.320.3.330.3.340.3.34rc10.3.34rc20.3.350.3.360.3.370.3.380.3.390.3.40.3.400.3.410.3.420.3.430.3.440.3.450.3.45rc10.3.460.3.470.3.480.3.490.3.50.3.500.3.510.3.520.3.530.3.540.3.550.3.560.3.56rc10.3.570.3.580.3.590.3.60.3.600.3.610.3.620.3.630.3.640.3.650.3.660.3.670.3.680.3.690.3.70.3.700.3.710.3.720.3.730.3.740.3.750.3.760.3.770.3.780.3.790.3.80.3.91.0.01.0.11.0.21.0.31.0.41.0.51.0.6

Fixed in

0.3.801.0.7

References

https://github.com/langchain-ai/langchain/security/advisories/GHSA-6qv9-48xg-fc7f
https://nvd.nist.gov/vuln/detail/CVE-2025-65106
https://github.com/langchain-ai/langchain/commit/c4b6ba254e1a49ed91f2e268e6484011c540542a
https://github.com/langchain-ai/langchain/commit/fa7789d6c21222b85211755d822ef698d3b34e00
https://github.com/langchain-ai/langchain
https://pypi.org/project/langchain-core

Updated Jul 07, 2026 · Source: OSV.dev
CVE-2024-10940 PYSEC-2026-1517 GHSA-5chr-fjjv-38qv Jul 07, 2026

langchain-core allows unauthorized users to read arbitrary files from the host file system

5.3 / 10
Medium
Network Low None None Unchanged Low None None

A vulnerability in langchain-core versions >=0.1.17,<0.1.53, >=0.2.0,<0.2.43, and >=0.3.0,<0.3.15 allows unauthorized users to read arbitrary files from the host file system. The issue arises from the ability to create langchain_core.prompts.ImagePromptTemplate's (and by extension langchain_core.prompts.ChatPromptTemplate's) with input variables that can read any user-specified path from the server file system. If the outputs of these prompt templates are exposed to the user, either directly or through downstream model outputs, it can lead to the exposure of sensitive information.

Affected versions

0.1.170.1.180.1.190.1.200.1.210.1.220.1.230.1.240.1.250.1.260.1.270.1.28

+ 86 more Show less

0.1.290.1.300.1.310.1.320.1.330.1.33rc10.1.340.1.350.1.360.1.370.1.380.1.390.1.400.1.410.1.420.1.42rc10.1.430.1.440.1.450.1.460.1.470.1.47rc10.1.480.1.490.1.500.1.510.1.520.2.00.2.10.2.100.2.110.2.120.2.130.2.150.2.160.2.170.2.180.2.190.2.20.2.200.2.210.2.220.2.230.2.240.2.250.2.260.2.270.2.280.2.290.2.29rc10.2.2rc10.2.30.2.300.2.310.2.320.2.330.2.340.2.350.2.360.2.370.2.380.2.390.2.40.2.400.2.410.2.420.2.50.2.60.2.70.2.80.2.90.3.00.3.10.3.100.3.110.3.120.3.130.3.140.3.20.3.30.3.40.3.50.3.60.3.70.3.80.3.9

Fixed in

0.1.530.2.430.3.15

References

https://nvd.nist.gov/vuln/detail/CVE-2024-10940
https://github.com/langchain-ai/langchain/commit/7d481f10102f43559cc57bcad7eba291067939ee
https://github.com/langchain-ai/langchain/commit/c1e742347f9701aadba8920e4d1f79a636e50b68
https://github.com/langchain-ai/langchain/commit/e711034713259ae448981bc0fd1d7a5671499c31
https://github.com/langchain-ai/langchain
https://huntr.com/bounties/be1ee1cb-2147-4ff4-a57b-b6045271cf27

Updated Jul 07, 2026 · Source: OSV.dev
CVE-2024-1455 PYSEC-2026-1519 GHSA-q84m-rmw3-4382 Jul 07, 2026

LangChain's XMLOutputParser vulnerable to XML Entity Expansion

5.9 / 10
Medium
Network High None None Unchanged None None High

The XMLOutputParser in LangChain uses the etree module from the XML parser in the standard python library which has some XML vulnerabilities; see: https://docs.python.org/3/library/xml.html

This primarily affects users that combine an LLM (or agent) with the XMLOutputParser and expose the component via an endpoint on a web-service.

This would allow a malicious party to attempt to manipulate the LLM to produce a malicious payload for the parser that would compromise the availability of the service.

A successful attack is predicated on:

Usage of XMLOutputParser

Passing of malicious input into the XMLOutputParser either directly or by trying to manipulate an LLM to do so on the users behalf

Exposing the component via a web-service

Affected versions

0.0.10.0.100.0.110.0.120.0.130.0.13rc10.0.13rc20.0.20.0.30.0.40.0.50.0.6

+ 42 more Show less

0.0.70.0.80.0.90.1.00.1.10.1.100.1.110.1.120.1.12rc10.1.130.1.140.1.150.1.15rc10.1.15rc20.1.160.1.170.1.180.1.190.1.20.1.200.1.210.1.220.1.230.1.240.1.250.1.260.1.270.1.280.1.290.1.30.1.300.1.310.1.320.1.330.1.33rc10.1.340.1.40.1.50.1.60.1.70.1.80.1.9

Fixed in

0.1.35

References

https://nvd.nist.gov/vuln/detail/CVE-2024-1455
https://github.com/langchain-ai/langchain/pull/17250
https://github.com/langchain-ai/langchain/pull/19653
https://github.com/langchain-ai/langchain/pull/19660
https://github.com/langchain-ai/langchain/commit/727d5023ce88e18e3074ef620a98137d26ff92a3
https://github.com/langchain-ai/langchain

Updated Jul 07, 2026 · Source: OSV.dev
CVE-2025-68664 PYSEC-2026-373 GHSA-c67j-w6g6-q2cm Jun 29, 2026

LangChain serialization injection vulnerability enables secret extraction in dumps/loads APIs

9.3 / 10
Critical
Network Low None None Changed High Low None

Summary

A serialization injection vulnerability exists in LangChain's dumps() and dumpd() functions. The functions do not escape dictionaries with 'lc' keys when serializing free-form dictionaries. The 'lc' key is used internally by LangChain to mark serialized objects. When user-controlled data contains this key structure, it is treated as a legitimate LangChain object during deserialization rather than plain user data.

Attack surface

The core vulnerability was in dumps() and dumpd(): these functions failed to escape user-controlled dictionaries containing 'lc' keys. When this unescaped data was later deserialized via load() or loads(), the injected structures were treated as legitimate LangChain objects rather than plain user data.

This escaping bug enabled several attack vectors:

Injection via user data: Malicious LangChain object structures could be injected through user-controlled fields like metadata, additional_kwargs, or response_metadata

Class instantiation within trusted namespaces: Injected manifests could instantiate any Serializable subclass, but only within the pre-approved trusted namespaces (langchain_core, langchain, langchain_community). This includes classes with side effects in __init__ (network calls, file operations, etc.). Note that namespace validation was already enforced before this patch, so arbitrary classes outside these trusted namespaces could not be instantiated.

Security hardening

This patch fixes the escaping bug in dumps() and dumpd() and introduces new restrictive defaults in load() and loads(): allowlist enforcement via allowed_objects="core" (restricted to serialization mappings), secrets_from_env changed from True to False, and default Jinja2 template blocking via init_validator. These are breaking changes for some use cases.

Who is affected?

Applications are vulnerable if they:

Use astream_events(version="v1") — The v1 implementation internally uses vulnerable serialization. Note: astream_events(version="v2") is not vulnerable.

Use Runnable.astream_log() — This method internally uses vulnerable serialization for streaming outputs.

Call dumps() or dumpd() on untrusted data, then deserialize with load() or loads() — Trusting your own serialization output makes you vulnerable if user-controlled data (e.g., from LLM responses, metadata fields, or user inputs) contains 'lc' key structures.

Deserialize untrusted data with load() or loads() — Directly deserializing untrusted data that may contain injected 'lc' structures.

Use RunnableWithMessageHistory — Internal serialization in message history handling.

Use InMemoryVectorStore.load() to deserialize untrusted documents.

Load untrusted generations from cache using langchain-community caches.

Load untrusted manifests from the LangChain Hub via hub.pull.

Use StringRunEvaluatorChain on untrusted runs.

Use create_lc_store or create_kv_docstore with untrusted documents.

Use MultiVectorRetriever with byte stores containing untrusted documents.

Use LangSmithRunChatLoader with runs containing untrusted messages.

The most common attack vector is through LLM response fields like additional_kwargs or response_metadata, which can be controlled via prompt injection and then serialized/deserialized in streaming operations.

Impact

Attackers who control serialized data can extract environment variable secrets by injecting {"lc": 1, "type": "secret", "id": ["ENV_VAR"]} to load environment variables during deserialization (when secrets_from_env=True, which was the old default). They can also instantiate classes with controlled parameters by injecting constructor structures to instantiate any class within trusted namespaces with attacker-controlled parameters, potentially triggering side effects such as network calls or file operations.

Key severity factors:

Affects the serialization path - applications trusting their own serialization output are vulnerable

Enables secret extraction when combined with secrets_from_env=True (the old default)

LLM responses in additional_kwargs can be controlled via prompt injection

Exploit example

from langchain_core.load import dumps, load import os # Attacker injects secret structure into user-controlled data attacker_dict = { "user_data": { "lc": 1, "type": "secret", "id": ["OPENAI_API_KEY"] } } serialized = dumps(attacker_dict) # Bug: does NOT escape the 'lc' key os.environ["OPENAI_API_KEY"] = "sk-secret-key-12345" deserialized = load(serialized, secrets_from_env=True) print(deserialized["user_data"]) # "sk-secret-key-12345" - SECRET LEAKED!

Security hardening changes (breaking changes)

This patch introduces three breaking changes to load() and loads():

New allowed_objects parameter (defaults to 'core'): Enforces allowlist of classes that can be deserialized. The 'all' option corresponds to the list of objects specified in mappings.py while the 'core' option limits to objects within langchain_core. We recommend that users explicitly specify which objects they want to allow for serialization/deserialization.

secrets_from_env default changed from True to False: Disables automatic secret loading from environment

New init_validator parameter (defaults to default_init_validator): Blocks Jinja2 templates by default

Migration guide

No changes needed for most users

If you're deserializing standard LangChain types (messages, documents, prompts, trusted partner integrations like ChatOpenAI, ChatAnthropic, etc.), your code will work without changes:

from langchain_core.load import load # Uses default allowlist from serialization mappings obj = load(serialized_data)

For custom classes

If you're deserializing custom classes not in the serialization mappings, add them to the allowlist:

from langchain_core.load import load from my_package import MyCustomClass # Specify the classes you need obj = load(serialized_data, allowed_objects=[MyCustomClass])

For Jinja2 templates

Jinja2 templates are now blocked by default because they can execute arbitrary code. If you need Jinja2 templates, pass init_validator=None:

from langchain_core.load import load from langchain_core.prompts import PromptTemplate obj = load( serialized_data, allowed_objects=[PromptTemplate], init_validator=None )

[!WARNING] Only disable init_validator if you trust the serialized data. Jinja2 templates can execute arbitrary Python code.

For secrets from environment

secrets_from_env now defaults to False. If you need to load secrets from environment variables:

from langchain_core.load import load obj = load(serialized_data, secrets_from_env=True)

Credits

Dumps bug was reported by @yardenporat

Changes for security hardening due to findings from @0xn3va and @VladimirEliTokarev

Affected versions

0.0.10.0.100.0.110.0.120.0.130.0.13rc10.0.13rc20.0.20.0.30.0.40.0.50.0.6

+ 217 more Show less

0.0.70.0.80.0.90.1.00.1.10.1.100.1.110.1.120.1.12rc10.1.130.1.140.1.150.1.15rc10.1.15rc20.1.160.1.170.1.180.1.190.1.20.1.200.1.210.1.220.1.230.1.240.1.250.1.260.1.270.1.280.1.290.1.30.1.300.1.310.1.320.1.330.1.33rc10.1.340.1.350.1.360.1.370.1.380.1.390.1.40.1.400.1.410.1.420.1.42rc10.1.430.1.440.1.450.1.460.1.470.1.47rc10.1.480.1.490.1.50.1.500.1.510.1.520.1.530.1.60.1.70.1.80.1.90.2.00.2.0rc10.2.10.2.100.2.110.2.120.2.130.2.150.2.160.2.170.2.180.2.190.2.20.2.200.2.210.2.220.2.230.2.240.2.250.2.260.2.270.2.280.2.290.2.29rc10.2.2rc10.2.30.2.300.2.310.2.320.2.330.2.340.2.350.2.360.2.370.2.380.2.390.2.40.2.400.2.410.2.420.2.430.2.50.2.60.2.70.2.80.2.90.3.00.3.0.dev00.3.0.dev10.3.0.dev20.3.0.dev30.3.0.dev40.3.0.dev50.3.10.3.100.3.110.3.120.3.130.3.140.3.150.3.160.3.170.3.180.3.190.3.20.3.200.3.210.3.220.3.230.3.240.3.250.3.260.3.270.3.280.3.290.3.30.3.300.3.310.3.320.3.330.3.340.3.34rc10.3.34rc20.3.350.3.360.3.370.3.380.3.390.3.40.3.400.3.410.3.420.3.430.3.440.3.450.3.45rc10.3.460.3.470.3.480.3.490.3.50.3.500.3.510.3.520.3.530.3.540.3.550.3.560.3.56rc10.3.570.3.580.3.590.3.60.3.600.3.610.3.620.3.630.3.640.3.650.3.660.3.670.3.680.3.690.3.70.3.700.3.710.3.720.3.730.3.740.3.750.3.760.3.770.3.780.3.790.3.80.3.800.3.91.0.01.0.11.0.21.0.31.0.41.0.51.0.61.0.71.1.01.1.11.1.21.1.31.2.01.2.11.2.21.2.31.2.4

Fixed in

0.3.811.2.5

References

https://github.com/langchain-ai/langchain/security/advisories/GHSA-c67j-w6g6-q2cm
https://nvd.nist.gov/vuln/detail/CVE-2025-68664
https://github.com/langchain-ai/langchain/pull/34455
https://github.com/langchain-ai/langchain/pull/34458
https://github.com/langchain-ai/langchain/commit/5ec0fa69de31bbe3d76e4cf9cd65a6accb8466c8
https://github.com/langchain-ai/langchain/commit/d9ec4c5cc78960abd37da79b0250f5642e6f0ce6

Updated Jul 02, 2026 · Source: OSV.dev
CVE-2026-34070 PYSEC-2026-2193 GHSA-qh6h-p6c9-ff54 Mar 31, 2026

7.5 / 10
High
Network Low None None Unchanged High None None

LangChain is a framework for building agents and LLM-powered applications. Prior to version 1.2.22, multiple functions in langchain_core.prompts.loading read files from paths embedded in deserialized config dicts without validating against directory traversal or absolute path injection. When an application passes user-influenced prompt configurations to load_prompt() or load_prompt_from_config(), an attacker can read arbitrary files on the host filesystem, constrained only by file-extension checks (.txt for templates, .json/.yaml for examples). This issue has been patched in version 1.2.22.

Affected versions

0.0.10.0.100.0.110.0.120.0.130.0.13rc10.0.13rc20.0.20.0.30.0.40.0.50.0.6

+ 252 more Show less

0.0.70.0.80.0.90.1.00.1.10.1.100.1.110.1.120.1.12rc10.1.130.1.140.1.150.1.15rc10.1.15rc20.1.160.1.170.1.180.1.190.1.20.1.200.1.210.1.220.1.230.1.240.1.250.1.260.1.270.1.280.1.290.1.30.1.300.1.310.1.320.1.330.1.33rc10.1.340.1.350.1.360.1.370.1.380.1.390.1.40.1.400.1.410.1.420.1.42rc10.1.430.1.440.1.450.1.460.1.470.1.47rc10.1.480.1.490.1.50.1.500.1.510.1.520.1.530.1.60.1.70.1.80.1.90.2.00.2.0rc10.2.10.2.100.2.110.2.120.2.130.2.150.2.160.2.170.2.180.2.190.2.20.2.200.2.210.2.220.2.230.2.240.2.250.2.260.2.270.2.280.2.290.2.29rc10.2.2rc10.2.30.2.300.2.310.2.320.2.330.2.340.2.350.2.360.2.370.2.380.2.390.2.40.2.400.2.410.2.420.2.430.2.50.2.60.2.70.2.80.2.90.3.00.3.0.dev00.3.0.dev10.3.0.dev20.3.0.dev30.3.0.dev40.3.0.dev50.3.10.3.100.3.110.3.120.3.130.3.140.3.150.3.160.3.170.3.180.3.190.3.20.3.200.3.210.3.220.3.230.3.240.3.250.3.260.3.270.3.280.3.290.3.30.3.300.3.310.3.320.3.330.3.340.3.34rc10.3.34rc20.3.350.3.360.3.370.3.380.3.390.3.40.3.400.3.410.3.420.3.430.3.440.3.450.3.45rc10.3.460.3.470.3.480.3.490.3.50.3.500.3.510.3.520.3.530.3.540.3.550.3.560.3.56rc10.3.570.3.580.3.590.3.60.3.600.3.610.3.620.3.630.3.640.3.650.3.660.3.670.3.680.3.690.3.70.3.700.3.710.3.720.3.730.3.740.3.750.3.760.3.770.3.780.3.790.3.80.3.800.3.810.3.820.3.830.3.840.3.850.3.860.3.90.4.0.dev01.0.01.0.0a11.0.0a21.0.0a31.0.0a41.0.0a51.0.0a61.0.0a71.0.0a81.0.0rc11.0.0rc21.0.0rc31.0.11.0.21.0.31.0.41.0.51.0.61.0.71.1.01.1.11.1.21.1.31.2.01.2.11.2.101.2.111.2.121.2.131.2.141.2.151.2.161.2.171.2.181.2.191.2.21.2.201.2.211.2.31.2.41.2.51.2.61.2.71.2.81.2.9

Fixed in

1.2.22

References

https://access.redhat.com/security/cve/CVE-2026-34070
https://security.access.redhat.com/data/csaf/v2/vex/2026/cve-2026-34070.json
https://access.redhat.com/errata/RHSA-2026:24766
https://access.redhat.com/errata/RHSA-2026:37275
https://github.com/langchain-ai/langchain/releases/tag/langchain-core==1.2.22
https://bugzilla.redhat.com/show_bug.cgi?id=2453287

Updated Jul 13, 2026 · Source: OSV.dev
CVE-2024-28088 GHSA-h59x-p739-982c PYSEC-2024-43 PYSEC-2024-45 Mar 04, 2024

LangChain directory traversal vulnerability

Low

LangChain through 0.1.10 allows ../ directory traversal by an actor who is able to control the final part of the path parameter in a load_chain call. This bypasses the intended behavior of loading configurations only from the hwchase17/langchain-hub GitHub repository. The outcome can be disclosure of an API key for a large language model online service, or remote code execution.

Affected versions

0.0.10.0.100.0.110.0.120.0.130.0.13rc10.0.13rc20.0.20.0.30.0.40.0.50.0.6

+ 36 more Show less

0.0.70.0.80.0.90.1.00.1.10.1.100.1.110.1.120.1.12rc10.1.130.1.140.1.150.1.15rc10.1.15rc20.1.160.1.170.1.180.1.190.1.20.1.200.1.210.1.220.1.230.1.240.1.250.1.260.1.270.1.280.1.290.1.30.1.40.1.50.1.60.1.70.1.80.1.9

Fixed in

0.1.30

References

https://nvd.nist.gov/vuln/detail/CVE-2024-28088
https://github.com/langchain-ai/langchain/pull/18600
https://github.com/langchain-ai/langchain/commit/e1924b3e93d513ca950c72f8e80e1c133749fba5
https://github.com/PinkDraconian/PoC-Langchain-RCE/blob/main/README.md
https://github.com/langchain-ai/langchain
https://github.com/langchain-ai/langchain/blob/f96dd57501131840b713ed7c2e86cbf1ddc2761f/libs/core/langchain_core/utils/loading.py

Updated Dec 03, 2024 · Source: OSV.dev

Insights

Releases per month

last 12 months

Release mix

major 1
minor 10
patch 267
pre 38

317 releases

Dependencies over time

per release

Release calendar

2026

Jan

Feb

Mar

Apr

May

Jun

Jul

Aug

Sep

Oct

Nov

Dec

Less More