CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-105795

CVE-2026-105795: Unvalidated Custom Extension Path Traversal in Microsoft Kiota

Alon Barad
Alon Barad
Software Engineer

Oct 7, 2026·6 min read·18 visits

Executive Summary (TL;DR)

Microsoft Kiota versions 1.25.1 to < 1.35.0 fail to validate the `oauth_card_path` parameter in custom OpenAPI extensions. An attacker can supply a malicious OpenAPI document to generate a compromised plugin manifest containing directory traversal segments, absolute paths, or external URIs, causing downstream execution hosts to access unauthorized files or external servers.

CVE-2026-105795 (GHSA-6gw6-rv2g-25mg) is a critical path traversal vulnerability in Microsoft Kiota, an OpenAPI-based HTTP client and plugin manifest generator. In affected versions (1.25.1 to < 1.35.0), Kiota propagates the unvalidated `x-ai-capabilities.response_semantics.oauth_card_path` vendor extension directly into generated API plugin manifests, leading to potential path traversal exploitation by downstream consumers.

Vulnerability Overview

Microsoft Kiota is an OpenAPI-based client and plugin generator designed to compile OpenAPI descriptions into reusable software libraries and plugin manifests. Among its functions is the generation of declarative API plugin manifests, which downstream hosts like Microsoft Copilot or Teams resolve to run plugins dynamically. The attack surface centers on Kiota's parser when processing custom OpenAPI extensions starting with the prefix x-ai-capabilities.

During the manifest construction process, Kiota attempts to extract declarative configuration metadata. Specifically, it parses the response_semantics mapping, which includes an optional field known as oauth_card_path. This field points to adaptive cards or OAuth flow configurations used by the plugin runtime during authorization phases.

In vulnerable versions of Kiota, the generator accepts and serializes this property without running security checks or path normalization. The security boundary is breached because the code generation engine implicitly trusts the OpenAPI specification, compiling traversal sequences or external resources directly into the manifest. Downstream integration engines then ingest these manifests and can be forced to break containment boundaries, exposing local files or contacting remote servers.

Root Cause Analysis

The root cause of this vulnerability lies in the lack of input validation and serialization logic inside src/Kiota.Builder/Plugins/PluginsGenerationService.cs. Prior to version 1.35.0, the PluginsGenerationService extracted the OauthCardPath string from parsed OpenAPI documents and directly assigned it to the generated object instance.

No checks were performed to see if the value contained directory traversal sequences (such as ..), absolute directory pathways (such as /etc/ or C:\), or network URIs (such as http:// or \\UNC\). Because Kiota acts as an intermediate compiler, it does not access the file paths during compilation. This design decision caused developers to overlook the security implications of storing raw paths in the output.

When Kiota outputs the generated plugin manifest JSON, the unvalidated path is embedded as an official configuration attribute. The responsibility of resolving this path is shifted to the downstream execution host. When the host environment parses the generated manifest and executes file lookup actions relative to the plugin directory, it processes the malicious traversal sequence.

Code Analysis and Patch Walkthrough

The vulnerability was mitigated in version 1.35.0 via Pull Request #8055, applying a security check before property serialization. The patch introduces a helper validation method, ExtensionResponseSemanticsStaticTemplate.IsSafeFileReference, to ensure path references do not violate containment boundaries.

Below is the comparison of the vulnerable codebase against the patched version in src/Kiota.Builder/Plugins/PluginsGenerationService.cs:

// VULNERABLE CODE (Kiota < 1.35.0)
// The raw string was assigned directly to the output object without sanitization
responseSemantics.OAuthCardPath = capabilities.ResponseSemantics.OauthCardPath;
// PATCHED CODE (Kiota >= 1.35.0)
// The generation engine now validates the presence of oauthCardPath
if (capabilities.ResponseSemantics.OauthCardPath is { } oauthCardPath)
{
    // Check if the path points outside the manifest directory or contains URIs
    if (ExtensionResponseSemanticsStaticTemplate.IsSafeFileReference(oauthCardPath))
    {
        responseSemantics.OAuthCardPath = oauthCardPath;
    }
    else
    {
        // Unsafe references are dropped, and a warning is emitted to logs
        LogUnsafeOAuthCardPathFileReference(logger, oauthCardPath);
    }
}

The validation routine IsSafeFileReference ensures the value does not contain absolute structures, Windows UNC paths, or parent directory markers. The implementation of LogUnsafeOAuthCardPathFileReference registers a warning stating that oauth_card_path must be a relative path that does not point outside the manifest package structure.

Exploitation Methodology

To exploit this vulnerability, an attacker must supply a compromised OpenAPI document to a user compiling an API plugin manifest with Kiota. This can happen through shared repository specifications, public API catalogs, or social engineering.

An attacker crafts an OpenAPI spec containing a path traversal sequence in the oauth_card_path property of the x-ai-capabilities extension. Below is a structural example of a malicious specification:

openapi: 3.0.0
info:
  title: Traversal Exploit Specification
  version: 1.0
paths:
  /api/v1/auth:
    get:
      operationId: triggerAuth
      x-ai-capabilities:
        response_semantics:
          data_path: $.data
          oauth_card_path: '../../../../../../etc/passwd'
      responses:
        '200':
          description: Success

When a developer processes this document using a vulnerable version of Kiota (e.g., kiota generate --plugin openapi), Kiota writes the value directly to the output. The resulting manifest file contains the payload:

{
  "capabilities": {
    "response_semantics": {
      "data_path": "$.data",
      "oauth_card_path": "../../../../../../etc/passwd"
    }
  }
}

If the generated manifest is loaded into a downstream environment that executes file lookups relative to the plugin root without enforcing canonical path boundaries, the host reads and exposes the targeted system file.

Downstream Security Impact

The impact of CVE-2026-105795 depends heavily on the privilege level and configuration of the downstream host processing the generated manifest. In an insecure environment, an attacker can achieve local file disclosure or force unauthorized network interactions.

Under POSIX-compliant systems, directory traversal payloads can target files like /etc/passwd or application configuration files. On Windows-based systems, attackers can target registry configurations or system files using absolute path syntax or drive-letter prefixes. If a Windows host processes a UNC path payload (e.g., \\attacker-server\share\card.json), the host may attempt an SMB connection, leaking NetNTLM credentials to an external server.

Furthermore, if the host environment accepts URI schemes, an attacker could supply an HTTP or HTTPS link, leading to Server-Side Request Forgery (SSRF). This would allow the downstream service to fetch card configurations from arbitrary internet hosts, potentially executing secondary payloads.

Remediation and Defensive Engineering

Remediation of CVE-2026-105795 requires updating the Kiota builder toolchain and implementing defensive validation policies. Organizations utilizing Kiota must upgrade their CLI tools and NuGet dependencies to version 1.35.0 or higher.

To update the Kiota CLI globally, execute the following dotnet command:

dotnet tool update -g Microsoft.OpenApi.Kiota

For projects consuming Kiota as a C# library, edit your .csproj file to ensure that dependencies for Microsoft.OpenApi.Kiota and Microsoft.OpenApi.Kiota.Builder are set to 1.35.0 or greater.

In addition, downstream host systems must implement defense-in-depth measures. Run-time environments should never trust paths declared in manifest files. Runtimes must canonicalize all paths using platform-specific APIs and verify that the target path resides strictly within the sandboxed application directory before initiating file-read operations.

Official Patches

MicrosoftPull Request #8055 introducing safe static template checking logic.

Fix Analysis (1)

Technical Appendix

CVSS Score
3.1/ 10
CVSS:3.1/AV:N/AC:H/PR:N/UI:R/S:U/C:N/I:L/A:N

Affected Systems

Microsoft Kiota CLIMicrosoft.OpenApi.Kiota NuGet PackageMicrosoft.OpenApi.Kiota.Builder NuGet Package

Affected Versions Detail

Product
Affected Versions
Fixed Version
Microsoft Kiota CLI
Microsoft
>= 1.25.1, < 1.35.01.35.0
Microsoft.OpenApi.Kiota
Microsoft
>= 1.25.1, < 1.35.01.35.0
Microsoft.OpenApi.Kiota.Builder
Microsoft
>= 1.25.1, < 1.35.01.35.0
AttributeDetail
CWE IDCWE-22
Attack VectorNetwork
CVSS v3.1 Score3.1
EPSS ScoreNot Registered
ImpactLow Integrity Impact, Downstream File Disclosure risk
Exploit StatusProof-of-Concept
KEV StatusNot Listed

MITRE ATT&CK Mapping

T1083File and Directory Discovery
Discovery
T1005Data from Local System
Collection
CWE-22
Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal')

The application uses external input to construct a pathname that is intended to identify a file or directory that is located under a restricted parent directory, but the application does not properly neutralize special elements within the pathname.

Known Exploits & Detection

GitHub Security AdvisoryInformation regarding replication of path traversal payloads within standard test vectors.

Vulnerability Timeline

Remediation patch submitted via Pull Request #8055.
2026-08-14
Vulnerability publicly disclosed and patch published within Kiota v1.35.0.
2026-10-06

References & Sources

  • [1]Official Microsoft Kiota Security Advisory
  • [2]Fix Commit (fc0f219)
  • [3]Kiota Version 1.35.0 Release Details
  • [4]NVD CVE-2026-105795 Record

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•about 3 hours ago•CVE-2026-58254
6.5

CVE-2026-58254: Authorization Bypass in NATS Server Message Tracing for Leaf Node Connections

NATS Server prior to versions 2.12.8 and 2.14.3 contains an incorrect authorization vulnerability (CWE-863) in its message tracing subsystem. When evaluating whether a connection is permitted to publish trace events to a destination subject specified in the Nats-Trace-Dest header, the server only checks standard client permissions and omits permission checks for leaf node connections. This allows a connected leaf node operator with restricted publishing privileges to emit internal trace events to unauthorized subjects and suppress standard message delivery using the Nats-Trace-Only header.

Alon Barad
Alon Barad
3 views•10 min read
•about 4 hours ago•CVE-2026-63341
7.5

CVE-2026-63341: Unauthenticated Denial of Service via Unbounded Topic Depth in Aedes MQTT Broker

CVE-2026-63341 is a high-severity Denial of Service (DoS) vulnerability in the Aedes MQTT broker for Node.js affecting all versions prior to 1.1.1. The flaw stems from missing input validation on the hierarchical depth of incoming MQTT topic strings before they are passed to the underlying topic-matching engine, qlobber. Because qlobber enforces a hardcoded limit of 100 topic levels and throws a synchronous exception when this threshold is exceeded, an attacker can send a single MQTT packet containing 101 or more forward-slash-separated levels to trigger an uncaught exception that immediately terminates the Node.js broker process.

Alon Barad
Alon Barad
3 views•12 min read
•about 5 hours ago•CVE-2026-61725
6.1

CVE-2026-61725: Path Traversal and Arbitrary File Overwrite in sevenz-rust2

CVE-2026-61725 is a path traversal vulnerability (CWE-22) in the sevenz-rust2 Cargo package prior to version 0.21.1. The vulnerability occurs because the decompression utility fails to validate or sanitize archive entry filenames before joining them with the destination directory path via std::path::Path::join. An attacker who supplies a crafted 7z archive containing parent directory traversal sequences or absolute paths can write or overwrite arbitrary files on the host filesystem with the privileges of the extracting process.

Alon Barad
Alon Barad
4 views•12 min read
•about 6 hours ago•CVE-2026-77309
8.8

CVE-2026-77309: Unauthenticated Remote Code Execution in NASA-AMMOS AIT-GUI via Incomplete File Cleanup and Path Traversal

CVE-2026-77309 (GHSA-jrjx-9jjw-747m) is a high-severity unauthenticated remote code execution vulnerability affecting NASA-AMMOS AIT-GUI versions 1.0.0 through 2.5.0. The flaw results from chaining an incomplete file cleanup error in the telemetry query endpoint (/tlm/query) with a directory traversal flaw in the script execution endpoint (/script/run). An attacker on an adjacent network can stage arbitrary Python statements into a static file on disk and execute that file under the privileges of the AIT-GUI web server process.

Amit Schendel
Amit Schendel
4 views•10 min read
•about 7 hours ago•CVE-2026-77332
2.3

CVE-2026-77332: Surfaced-Memory Envelope Injection and Stored Prompt Injection in memtomem-stm

A vulnerability classified under CWE-116 (Improper Encoding or Escaping of Output) exists in memtomem-stm versions 0.1.0 through 0.1.33. The software acts as a Model Context Protocol (MCP) short-term memory proxy gateway for AI agent architectures. When surfacing retrieved memories and scratchpad items into downstream Large Language Model (LLM) context envelopes, the SurfacingFormatter component fails to properly sanitize untrusted memory attributes. An attacker with the ability to plant untrusted content into the agent's long-term or working memory store can inject arbitrary structural delimiters, close the <surfaced-memories> XML boundary prematurely, visually obscure instructions using Unicode bidirectional overrides, and execute stored prompt injection attacks against downstream LLM agents.

Alon Barad
Alon Barad
7 views•10 min read
•about 8 hours ago•CVE-2026-77331
2.0

CVE-2026-77331: Race Condition and Session State Corruption in memtomem-stm

CVE-2026-77331 (GHSA-72jh-722p-rqr3) is a concurrency and session-state synchronization vulnerability in memtomem-stm, a short-term memory proxy gateway for AI agents. In versions 0.1.2 prior to 0.1.34, concurrent Model Context Protocol (MCP) Remote Procedure Call (RPC) failures or mid-flight task cancellations can initiate duplicate reconnect loops and permit dirty or cancelled transport sessions to be reused. This deficiency results in session-state integrity loss and local service degradation.

Amit Schendel
Amit Schendel
5 views•9 min read