CVE-2026-100680 in Budibase
Summary
by MITRE • 09/26/2026
Budibase versions before 3.45.0 fail to disable external JSON reference resolution in the OpenAPI/Swagger import validator, allowing authenticated builders to read arbitrary local files. Attackers with builder access can embed file:// references in OpenAPI specifications submitted to the import endpoint to exfiltrate sensitive files including environment variables containing JWT secrets, API keys, and database credentials.
If you want to get best quality of vulnerability data, you may have to visit VulDB.
Analysis
by VulDB Data Team • 09/26/2026
The vulnerability identified in Budibase versions prior to 3.45.0 represents a critical security flaw within the application's OpenAPI and Swagger import functionality. This issue stems from an improper configuration of the JSON schema validator used during the ingestion process for external API definitions. Specifically, the system fails to disable or restrict external reference resolution mechanisms that are inherent in standard JSON Schema processing libraries. In typical usage, these references allow a document to point to other documents via URLs, facilitating modular documentation structures. However, when this feature is left enabled without adequate sanitization or restriction on protocol schemes, it creates an avenue for Local File Read (LFR) attacks. The flaw lies not in the core application logic itself but in how the underlying parsing library interprets and resolves these external pointers during the validation phase of the import workflow.
This technical deficiency allows authenticated users with builder-level privileges to exploit the system by embedding malicious file:// URIs within their submitted OpenAPI specifications. When a user submits such a specification, the validator attempts to resolve the referenced resource as part of its standard compliance check against JSON Schema standards. Because the application does not restrict access to local filesystem resources during this resolution step, an attacker can craft a payload that points to sensitive files on the server hosting the Budibase instance. This effectively bypasses traditional network-based security controls since the request originates from within the trusted internal environment and targets local storage rather than external services. The ability to read arbitrary local files is particularly dangerous in containerized or cloud-native deployments where configuration data, secrets, and credentials are often stored as plain text files accessible by the application process.
The operational impact of this vulnerability is severe due to the potential for comprehensive credential theft and system compromise. Attackers leveraging this flaw can exfiltrate critical environment variable files that contain JWT signing secrets, which are essential for maintaining session integrity and authentication trust within the Budibase platform. Additionally, attackers can access configuration files containing API keys for integrated services such as databases, email providers, or third-party APIs. The exposure of database credentials is especially alarming as it may grant direct read or write access to persistent data stores, potentially leading to full data breach scenarios involving customer information, business logic, and proprietary assets. Since the vulnerability requires only authenticated builder access, which is a common role for developers and integrators within Budibase environments, the attack surface is relatively broad among legitimate users who might have their accounts compromised through phishing or weak password practices.
From a classification perspective, this vulnerability aligns with CWE-20 Improper Input Validation as it involves insufficient checking of user-supplied input regarding protocol schemes and resource accessibility. It also maps to ATT&CK technique T1552 Unsecured Credentials specifically under the sub-technique of finding local system properties or configuration files. The exploitation chain relies on the attacker's ability to inject structured data that triggers internal library behavior, making it a form of server-side request forgery variant where the target is the local filesystem rather than an external network endpoint. This distinction highlights the importance of treating input validation not just as a boundary defense but as a mechanism for controlling internal resource access patterns within application components.
Mitigation strategies must focus on both immediate patching and architectural hardening. The primary remediation is to upgrade Budibase to version 3.45.0 or later, where this specific configuration flaw has been addressed by disabling external reference resolution in the OpenAPI/Swagger import validator. For organizations unable to immediately apply patches, implementing strict input filtering on the import endpoint can provide temporary relief by rejecting any JSON payloads containing file:// protocols or other non-HTTP(S) URI schemes. Additionally, applying principle of least privilege principles is crucial; administrators should review builder-level permissions and ensure that only trusted individuals have access to sensitive configuration areas. Running the Budibase application with restricted filesystem permissions can also limit the scope of files accessible even if an exploit succeeds, thereby reducing the blast radius of potential credential theft incidents. Regular auditing of import logs for anomalous patterns involving file paths or unusual URI structures can aid in early detection of exploitation attempts before significant data loss occurs.