Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessPublish malicious model/config with crafted classpath
-
ExploitVictim calls hanlp.load on untrusted model
-
ExecutionDeserialization instantiates attacker class in reflection.py
-
ImpactCode executes in victim process
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A08:2025 - Software or Data Integrity Failures
ASVS 5.0
V1 - Encoding and Sanitization Safe deserialization, type allowlists
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Initial Access The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires the victim to invoke hanlp.load() on an attacker-controlled model/config in which the classpath argument is manipulated, triggering unsafe deserialization/reflection in plugins/hanlp_common/hanlp_common/reflection.py. The key LIMITING factor is required user interaction (UI:P in the supplied vector): the victim must obtain and load a malicious or untrusted model - it is not triggered against a default, idle installation. No authentication is required (PR:N). Systems that only load trusted, first-party HanLP models are not realistically exposed; risk concentrates on pipelines that load third-party or externally sourced models. |
| Impact | This is a CWE-502 deserialization flaw in hankcs HanLP (≤2.1.0-beta.64) reached through the classpath argument during model config loading in hanlp.load. Signals are mixed and point to a moderate, not urgent, priority. The supplied CVSS 4.0 vector (AV:N/AC:L/PR:N/UI:P/VC:L/VI:L/VA:L, score 5.3) describes low partial impact and, critically, requires user interaction (UI:P) - the victim must load an attacker-supplied model/config. There is NO EPSS score and NO SSVC decision in the input, so exploitation probability and automatability cannot be quantified. The flaw is NOT in CISA KEV, so there is no confirmed active exploitation; however a public POC (poc.zip) exists, so publicly available exploit code exists. CONFLICT TO NOTE: the VulDB CVSS caps impact at Low across C/I/A, yet CWE-502 deserialization driven by an attacker-controlled classpath typically yields arbitrary code execution (High impact) - this low scoring appears conservative and should be verified; my independent assessment rates impact higher. The decisive mitigating factor is the UI requirement plus an unresponsive-but-niche project: this is a real but conditional issue, not a mass-exploitable internet-facing RCE. Treat as medium priority - patch/pin when a fix lands and avoid loading untrusted models in the interim. |
| Exploit ScenarioDerived | An attacker publishes or distributes a malicious HanLP model package whose config specifies an attacker-chosen classpath. A developer or application calls hanlp.load() on that untrusted model, and the deserialization/instantiation of the attacker-controlled class executes attacker code in the victim's Python process. A public proof-of-concept (poc.zip) has been released demonstrating the issue. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 19, 2026
Unsafe deserialization in hankcs HanLP through 2.1.0-beta.64 allows unauthenticated remote attackers to achieve code execution when a victim loads an attacker-supplied model or config in which the classpath argument passed through hanlp.load() has been manipulated, reaching the reflection logic in plugins/hanlp_common/hanlp_common/reflection.py. Exploitation is not automatic against an idle installation: it requires the user to obtain and load an untrusted model, so exposure is concentrated in pipelines that consume third-party or externally sourced models rather than those loading only first-party artifacts. Publicly available exploit code exists (a PoC archive is linked from the VulDB entry), but there is no CISA KEV confirmation of active exploitation; the project was notified via GitHub issue #1969 and has not responded at time of analysis.
RemediationAI
No vendor-released patch was identified at time of analysis: the issue was filed at https://github.com/hankcs/HanLP/issues/1969 and the maintainers had not responded, so there is no fixed version to cite. Until an upstream fix lands, the effective control is provenance-based: treat model artifacts as executable code, and only call hanlp.load() on models your organization built or downloaded over an authenticated channel and verified by pinned hash/signature - the trade-off is that ad-hoc or community model downloads must be blocked or run through an internal review-and-republish step. Where models must come from external sources, load them inside a disposable, unprivileged container with a read-only filesystem and no outbound network, and separate the model-loading step from any service holding credentials; this costs extra orchestration and blocks features that expect live downloads at load time. If you control the configs passed to hanlp.load(), pin or hard-restrict the classpath field to an explicit allowlist of known classes before loading, and strip or reject model configs containing unexpected classpath entries - this requires maintaining an allowlist per HanLP upgrade and cannot protect callers who pass arbitrary user configs straight through. Also monitor https://github.com/hankcs/HanLP/issues/1969 and https://vuldb.com/vuln/421760 for a patched release and upgrade to the first version that validates or restricts the classpath argument. Note that a public PoC is available (referenced from the VulDB entry), so untrusted model ingestion should be treated as an immediate exposure rather than a theoretical one.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
HanLP is a Python natural-language-processing library whose model/config loading path resolves a user-facing configuration (including a classpath argument naming a Python dotted import path) and instantiates the referenced class through dynamic reflection rather than restricting it to an internal allowlist. That reflection helper in plugins/hanlp_common/hanlp_common/reflection.py is the specific sink: because the classpath value is attacker-influencable in a supplied model config, a malicious model can steer class resolution and, combined with the library's Python object deserialization of model data, trigger arbitrary object construction and code execution during what appears to be a routine model load. The weakness class is CWE-502 (Deserialization of Untrusted Data) - the library treats model artifacts as trusted content and neither validates the classpath against a fixed set of permitted classes nor uses a safe deserialization format, so the integrity of the whole load pipeline rests on the provenance of the model file. The affected CPE is cpe:2.3:a:hankcs:hanlp:*:*:*:*:*:*:*:* covering releases up to and including 2.1.0-beta.64; note that the reporter's CVSS 4.0 vector scores this 5.3 with only low confidentiality/integrity/availability impact, whereas the assessed CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:R/C:H/I:H/A:H) reflects that successful deserialization yields full code execution in the loading process's context.
Know when Hanlp gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:P/VC:L/VI:L/VA:L/SC:N/SI:N/SA:N/E:P
Attacker-controlled classpath deserialization enables code execution (C/I/A:H), but the victim must load the malicious model, so UI:R; no privileges needed (PR:N).
Primary rating from Vendor (VulDB).
CVSS VectorVendor: VulDB
Lifecycle Timeline
3DescriptionCVE.org
A vulnerability was determined in hankcs HanLP up to 2.1.0-beta.64. This affects the function hanlp.load of the file plugins/hanlp_common/hanlp_common/reflection.py of the component Model Config Loading. This manipulation of the argument classpath causes deserialization. It is possible to initiate the attack remotely. The exploit has been publicly disclosed and may be utilized. The project was informed of the problem early through an issue report but has not responded yet.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Insecure deserialization occurs when an application converts serialized data (a stream of bytes representing an object's state) back into a living object without proper validation.
EUVD-2026-104071
GHSA-g4wc-qgxw-hw24
NVD
CVE.org
EPSS
VulDB
Exploit-DB