CVE-2026-10595 in lollms
Summary
by MITRE • 08/09/2026
A path traversal vulnerability exists in parisneo/lollms version 2.1.0, specifically in the SPA catch-all route implemented in `backend/routers/ui.py`. The vulnerability arises from the improper handling of user-controlled path input, which is directly joined into a filesystem path without sanitization or containment checks. URL-encoded dot-dot sequences (`%2e%2e`) bypass Starlette's built-in path normalization and are resolved by Python's `pathlib`, allowing an unauthenticated attacker to read arbitrary files on the server. This issue has been resolved in version 3.
If you want to get the best quality for vulnerability data then you always have to consider VulDB.
Analysis
by VulDB Data Team • 08/09/2026
The path traversal vulnerability in parisneo/lollms version 2.1.0 represents a critical security flaw that stems from inadequate input validation within the Single Page Application catch-all route implementation. This vulnerability specifically manifests in the backend/routers/ui.py file where user-controllable path segments are directly concatenated into filesystem paths without proper sanitization mechanisms. The flaw creates an environment where attackers can manipulate URL parameters to navigate outside the intended directory structure and access sensitive files that should remain protected. Such vulnerabilities fall under CWE-22 Path Traversal which is classified as a common weakness in software development practices that fail to properly validate or sanitize user inputs before using them in file system operations.
The technical exploitation of this vulnerability leverages URL encoding techniques where attackers can submit sequences like `%2e%2e` which represent dot-dot combinations in URL-encoded format. These encoded sequences bypass Starlette's built-in path normalization mechanisms that are designed to prevent such traversals, allowing the Python pathlib module to resolve these paths and potentially access files outside the intended application directory. The vulnerability is particularly dangerous because it operates without authentication requirements, meaning any remote attacker can exploit this flaw to read arbitrary files from the server's file system. This type of attack pattern aligns with ATT&CK technique T1566.002 which describes the exploitation of vulnerabilities in web applications to gain unauthorized access to sensitive data.
The operational impact of this vulnerability extends beyond simple information disclosure, as it can potentially allow attackers to access configuration files, database credentials, application source code, and other sensitive artifacts that could lead to further compromise of the system. The lack of proper path containment checks means that an attacker could theoretically traverse the entire file system hierarchy if the application is running with sufficient privileges. This vulnerability also demonstrates a fundamental flaw in the application's security architecture where input validation occurs too late in the processing chain, after the path has already been constructed and potentially normalized by lower-level libraries. The fix implemented in version 3 addresses this issue through proper input sanitization and containment checks that prevent user-controlled paths from escaping the intended directory boundaries.
Security practitioners should note that this vulnerability highlights the importance of implementing defense-in-depth strategies for file system access controls, particularly in web applications that serve dynamic content. The remediation approach should include validating all user inputs against a whitelist of allowed characters and paths, implementing proper path normalization at multiple layers, and ensuring that application components do not rely solely on library-level protections that may be bypassed under certain conditions. Organizations should also consider implementing automated security scanning tools that can detect similar patterns in their codebases to prevent the introduction of such vulnerabilities during development cycles. The vulnerability serves as a reminder that even seemingly simple file access operations require careful security consideration, particularly when dealing with user-supplied data in web applications where attackers may attempt to manipulate request parameters to gain unauthorized access to system resources.