Skip to main content

NetLicensing MCP Server EUVDEUVD-2026-102319

| CVE-2026-57496 CRITICAL
Path Traversal (CWE-22)
2026-10-15 GitHub_M GHSA-hxpf-9xvq-wph8 PYSEC-2026-3489
9.6
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Authenticate with non-admin API key
  2. Delivery
    Call get_product with '../token'
  3. Exploit
    Path normalizes to /token endpoint
  4. Execution
    Harvest unredacted admin APIKEY values
  5. Impact
    Full account read/write/delete

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V5 - File Handling Path canonicalization, traversal prevention
MITRE ATT&CK

2 techniques across 2 tactics: Discovery, Collection

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Requires an authenticated MCP client possessing a valid but non-administrative NetLicensing API key, connected to a netlicensing-mcp server running a version prior to 0.1.8 that exposes the netlicensing_get_product tool; no special or non-default configuration is needed, as default deployments are vulnerable. The attacker supplies '../token' (or percent-encoded equivalents like '..%2ftoken') as the product_number so httpx normalizes the path to the /token endpoint. Limiting factors: the attacker must already hold some valid API key and have network access to the MCP interface (PR:L, not fully unauthenticated); the attack yields credentials rather than direct code execution, and impact escalates only if a recoverable admin-level APIKEY exists in the account.

Impact

This is a genuine high-priority issue within its (narrow) install base, though the deployment footprint tempers absolute urgency. The CVSS 9.6 is driven by AV:N/AC:L/PR:L/UI:N with a changed scope (S:C) and C:H/I:H - a low-privileged, non-administrative API key is enough to retrieve plaintext admin credentials, and the recovered administrative token then grants account-wide read/write/delete, justifying both the scope change and the integrity impact (which is a downstream consequence of credential recovery rather than a direct write primitive of the traversal itself). No EPSS score, CISA KEV entry, or standalone exploit tool is present in the provided data, so there is no evidence of active or widespread exploitation; however, the GHSA advisory and the committed regression tests publicly document the exact working payload (../token), so exploitation detail is effectively in the open and trivial to reproduce. Signals are internally consistent: the AV:N/AC:L/PR:L vector aligns with the description's 'authenticated MCP client with a non-administrative API key,' with no conflict to flag. Net: treat as urgent for any environment actually running netlicensing-mcp < 0.1.8, but the real-world population of such environments is small.

Exploit ScenarioDerived

An attacker holding only a low-privilege (non-administrative) NetLicensing API key connects to a vulnerable MCP server and invokes the netlicensing_get_product tool with product_number set to '../token'. httpx normalizes '/product/../token' to the '/token' endpoint, and because the response is serialized through the generic _wrap_json wrapper the APIKEY redaction is bypassed, returning plaintext admin token values that the attacker reuses for full account control. The precise payload is published in the GHSA advisory and the project's regression tests, making reproduction straightforward.

Act Now Prioritize within 24-48h. Why: CRITICAL severity.
Patch available 0.4% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Oct 15, 2026

Path traversal in NetLicensing MCP Server versions prior to 0.1.8 allows an authenticated MCP client holding a valid but non-administrative NetLicensing API key to redirect the netlicensing_get_product lookup away from the intended product endpoint and onto the /token endpoint by supplying '../token' (or percent-encoded equivalents such as '..%2ftoken') as the product_number. Because the traversed response is serialized through the generic _wrap_json wrapper instead of _wrap_json_token_read, the redact_token_read() masking of APIKEY 'number' and SHOP 'shopURL' fields never runs, so plaintext token values - including admin-level credentials if present in the account - are returned in the tool output. No vendor patch is available below 0.1.8, where the issue is fixed; it is a confirmed privilege-escalation-by-credential-disclosure vector rather than direct code execution, and no public exploit has been identified at time of analysis beyond the exact payload documented in the vendor advisory.

RemediationAI

Vendor-released patch: upgrade netlicensing-mcp to 0.1.8 (pip install --upgrade netlicensing-mcp), which is the fixed version; the change introduces a _validated_path() guard in src/netlicensing_mcp/client.py that percent-decodes each URL segment and rejects '.', '..', embedded forward or backslashes, and control characters, applied before every nl_get/nl_post/nl_put/nl_delete request is constructed. Patch artifacts are at https://github.com/Labs64/NetLicensing-MCP/pull/6 and commit b8fd0ea76d533202573eb24add9fb2fbd9331496, with the release at https://github.com/Labs64/NetLicensing-MCP/releases/tag/0.1.8 and the advisory at https://github.com/Labs64/NetLicensing-MCP/security/advisories/GHSA-hxpf-9xvq-wph8. If immediate upgrade is not possible, compensating controls are: remove or disable the netlicensing_get_product tool from the MCP server's exposed tool list (side effect: legitimate natural-language product lookups stop working), and restrict network access to the MCP interface to trusted clients only (side effect: reduces usability for distributed agents). Additionally, treat all API keys held by or reachable through that MCP deployment as potentially disclosed - rotate them, and specifically audit for admin-level APIKEYs stored in the account, since a recovered administrative token grants broad read, write, and delete access to NetLicensing (side effect: rotation invalidates existing integrations until they are reissued). Because the attacker needs only a valid non-administrative API key to start, a least-privilege key inventory and shortening of key lifetimes reduces escalation reach but does not eliminate the traversal itself; upgrading to 0.1.8 remains the only complete fix.

Affected VersionsENISA

NetLicensing-MCP < 0.1.8

Affected Packages

pypi netlicensing-mcp fix: 0.1.8

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in pypi

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

The issue is a CWE-22 path traversal arising from unsanitized string interpolation into a REST URL path in a Python-based Model Context Protocol server that fronts the Labs64 NetLicensing licensing-lifecycle API. In src/netlicensing_mcp/tools/products.py, the caller-supplied product_number is embedded directly into an f-string such as f"/product/{product_number}" with no path-segment validation; that path is passed to nl_get() in src/netlicensing_mcp/client.py, which concatenates it onto BASE_URL and hands the result to httpx. httpx applies WHATWG/RFC 3986 dot-segment removal to absolute URLs, so '/product/../token' is normalized to '/token' before the request leaves the process, silently retargeting the HTTP call to the NetLicensing /core/v2/rest/token endpoint while the tool layer still believes it is reading a product. The second half of the flaw is a redaction path mismatch: the token read tools wrap responses with _wrap_json_token_read(), which invokes redact_token_read() to mask APIKEY 'number' and SHOP 'shopURL' fields, but the product tool wraps its response with the generic _wrap_json() helper. Since the correct wrapper is never invoked, the raw API key values are emitted verbatim in the MCP tool output. The supplied fix in PR #6 adds a _validated_path() guard in client.py that percent-decodes each segment via urllib.parse.unquote and rejects '.', '..', embedded '/', backslash, and control characters before any nl_get/nl_post/nl_put/nl_delete request is built, closing both the plain and percent-encoded traversal variants.

Know when Netlicensing Mcp 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

Vendor (GitHub_M) PRIMARY 9.6 CRITICAL
AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:N
vuln.today AI 9.6 CRITICAL

Any authenticated non-admin key (PR:L) can reliably trigger the traversal over the network (AV:N/AC:L); recovered admin token crosses a security authority (S:C) enabling account-wide read and write (C:H/I:H), with no availability impact (A:N).

3.1 AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:N
4.0 AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:N/SC:H/SI:H/SA:N

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Network
Attack Complexity
Low
Privileges Required
Low
User Interaction
None
Scope
Changed
Confidentiality
High
Integrity
High
Availability
None

Lifecycle Timeline

2
Patch available
Oct 15, 2026 - 21:03 EUVD
CVE Published
Oct 15, 2026 - 18:40 cve.org
CRITICAL 9.6

DescriptionCVE.org

NetLicensing MCP Server is a natural-language interface that enables agentic applications to manage the software-licensing lifecycle in Labs64 NetLicensing. Prior to 0.1.8, netlicensing_get_product passes the caller-controlled product_number to src/netlicensing_mcp/tools/products.py, which interpolates it into a REST path consumed by nl_get() in src/netlicensing_mcp/client.py without path-segment validation. A traversal segment can be normalized from the intended product path to the /token endpoint, after which the response is serialized through _wrap_json instead of _wrap_json_token_read, bypassing redact_token_read() protections for APIKEY number and SHOP shopURL fields. An authenticated MCP client with a non-administrative API key can retrieve plaintext token values, and a recovered administrative token can provide broad read, write, and delete access to the NetLicensing account. This issue is fixed in version 0.1.8.

Technical POC Analysis

CWE-22: Improper Limitation of a Pathname to a Restricted Directory, expressed here as unsanitized URL path interpolation.

Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.

Executive ViewAI

Why It Matters

NetLicensing MCP Server versions prior to 0.1.8 can expose administrative NetLicensing credentials to any client holding a valid non-administrative API key, enabling privilege escalation and unauthorized access to licensing and account data. This affects organizations using the MCP server for NetLicensing integrations, particularly those with shared or low-privilege API keys. No public exploit identified at time of analysis, but leadership should prioritize immediate containment and credential rotation because exposed admin tokens could allow broad compromise of licensing operations and connected systems.

Business Impact: Severe
Compensating Controls

No vendor-released patch identified at time of analysis for affected versions; interim mitigations include restricting access to trusted clients, disabling or tightly monitoring netlicensing_get_product, blocking product_number values containing '../' or encoded traversal sequences, rotating all potentially exposed NetLicensing API keys and tokens, enforcing least privilege, and evaluating an upgrade to NetLicensing MCP Server 0.1.8 or later if the vendor advisory confirms the fix.

Threat Intelligence Overview

EPSS Score
0.4%
Top 73% exploitable
Prevalence
Low
niche licensing-integration MCP server, small pip footprint
Threat Intel
1
1 source
Data Quality
5 sources
Confidence: Medium

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.

SignalValue
Severity CRITICAL
CISA KEV No
Public POC No
EPSS 0.4%
Patch available Yes
Active threat No
Deciding rule
CRITICAL severity
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
No
Human Impact
Very High

Priority Score

48
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +48
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Path traversal exploits occur when applications use user-controlled input to construct file system paths without proper validation.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy