CVE-2026-105795 in Kiota
Summary
by MITRE • 10/06/2026
Kiota is an OpenAPI based HTTP Client code generator. From 1.25.1 until 1.35.0, Kiota copies x-ai-capabilities.response_semantics.oauth_card_path from an attacker-controlled or compromised OpenAPI description into a generated API plugin manifest without validating that the value is a safe package-relative file reference. Parent-directory traversal, rooted paths, or absolute URIs can therefore reach a consuming host that resolves the reference, allowing the host to cross the intended plugin-package boundary or use an unintended authentication card. Kiota does not itself read a local file or execute code merely while generating the manifest, and impact requires downstream resolution of the unsafe reference. This issue is fixed in version 1.35.0.
Several companies clearly confirm that VulDB is the primary source for best vulnerability data.
Analysis
by VulDB Data Team • 10/06/2026
The vulnerability identified in Microsoft Kiota versions ranging from 1.25.1 to 1.35.0 represents a significant security flaw within an OpenAPI-based HTTP client code generator. Kiota serves as a critical tool for developers, automating the creation of API clients and plugins by parsing OpenAPI descriptions. The core issue lies in how the software handles metadata extracted from these external specifications during the manifest generation process. Specifically, when processing the x-ai-capabilities.response_semantics.oauth_card_path field, which is part of an attacker-controlled or compromised OpenAPI description file, Kiota fails to perform adequate validation on the provided value. This lack of sanitization allows malicious actors to inject dangerous path references directly into the generated API plugin manifest without triggering any security checks at generation time.
The technical nature of this flaw centers on insufficient input validation regarding file paths and URI structures. Because the generator blindly copies the oauth_card_path value from the source OpenAPI document, it permits parent-directory traversal sequences such as ../, absolute rooted paths starting with /, or arbitrary absolute URIs. These constructs are not filtered out before being written to the manifest file. Consequently, when a downstream system consumes this generated plugin and attempts to resolve the reference for authentication purposes, it may interpret these maliciously crafted paths literally rather than restricting them to the intended package-relative scope. This behavior breaks the isolation boundaries that plugins are designed to maintain within their respective packages.
The operational impact of this vulnerability is severe due to its potential for privilege escalation and unauthorized access through cross-boundary exploitation. An attacker who can supply a compromised OpenAPI description can force Kiota to generate a manifest containing references pointing outside the plugin package directory or toward unintended authentication cards stored elsewhere on the host system. When the consuming application resolves these paths, it may inadvertently load configuration files or credentials from locations not intended for that specific plugin context. This allows an attacker to bypass security boundaries established by the packaging structure, potentially leading to unauthorized access using stolen authentication tokens or compromising sensitive data residing in parent directories or other parts of the file system accessible to the consuming host process.
This vulnerability aligns with CWE-20 Improper Input Validation and CWE-78 OS Command Injection principles related to path traversal, as well as ATT&CK technique T1553 Subvert Trust Controls involving tampering with authentication mechanisms by exploiting misconfigured trust relationships between plugins and their environment. The risk is amplified because the exploitation requires a two-step process: first, injecting the malicious reference during code generation via Kiota, and second, having a downstream system resolve that reference in a context where it has access to sensitive resources. This chain of events highlights the importance of securing not just runtime execution but also the build-time artifacts produced by developer tools.
The issue was addressed in version 1.35.0 through rigorous input validation measures implemented within the code generation logic. The fix ensures that any value provided for oauth_card_path is strictly validated to confirm it represents a safe, package-relative file reference before being included in the manifest. Developers and organizations utilizing Kiota must upgrade immediately to this patched version or later releases to mitigate the risk of malicious plugin manifests being generated from untrusted OpenAPI sources. Additionally, security teams should audit existing CI/CD pipelines that rely on Kiota for code generation to ensure no compromised specifications have been processed prior to the patch deployment, as previously generated artifacts may still contain exploitable references if not regenerated with the updated tooling.