Summary
Budibase versions 3.24.0 and earlier enforce file extension restrictions only in the browser, leaving the backend unaware of what file types are permitted.
An attacker who bypasses the UI (for example, by using crafted HTTP requests) can upload arbitrary files, including potentially executable or script files, which may later be processed or served in dangerous ways.
Affected context
This vulnerability affects Budibase deployments that rely on built-in file upload components with extension restrictions configured through the UI.
The risk materializes when:
- File type checks are performed only in client-side code (JavaScript or UI configuration), and
- The server accepts and stores uploaded files without validating their type, content, or intended use.
In such environments, files that would normally be blocked by the UI may still be uploaded if the HTTP requests bypass client-side logic.
Exploit preconditions
- Attack surface: Budibase HTTP endpoints that handle file uploads.
- Required access: Ability to reach the application's upload interface (usually authenticated internal users, but depends on how the app is exposed).
- Trigger point: Submitting a crafted upload request directly to the server (e.g., via intercepted/modifed requests or custom clients) that ignores UI-imposed extension filters.
- Why exploitation is possible: File validation logic is implemented only on the client side; the server trusts the client and does not enforce equivalent file-type or content restrictions.
Why this happens
The underlying issue is a classic client-side enforcement mistake, aligned with CWE-602: Client-Side Enforcement of Server-Side Security.
Budibase's upload flow uses UI-level configuration and client-side checks to limit which file extensions users can select or submit, but the backend accepts whatever is sent over the wire.
Because clients are under the attacker's control, these checks are trivially bypassed by modifying HTTP requests.
Once arbitrary files can be uploaded, downstream behaviors—such as serving files directly from a web-accessible directory, parsing uploaded content, or using them in server-side workflows—can intersect with other bug classes, including:
- CWE-79 (Cross-Site Scripting) if malicious scripts are uploaded and then rendered in browsers.
- CWE-918 (Server-Side Request Forgery) if uploaded configuration or template files influence outbound server requests.
Potential impact
- Upload of executable or script files that could be executed by the server environment.
- Storage and serving of HTML/JS payloads that may lead to stored XSS when other users access them.
- Abuse of uploaded configuration or template-like files to influence server behavior, potentially enabling SSRF.
- Use of uploaded files as a foothold for data exfiltration or lateral movement within internal tools.
- Violation of organizational file-handling policies and potential exposure of sensitive infrastructure through malicious workflows.
General mitigation guidance
Effective mitigation centers on moving all critical checks to the server side and treating clients as untrusted:
- Perform server-side validation of file extensions, MIME types, and—where feasible—file signatures (magic numbers).
- Restrict accepted file types to the smallest necessary set and reject all others by default.
- Store uploaded files outside of directly web-accessible paths, and serve them via controlled handlers that sanitize headers and content where appropriate.
- Apply strict content-handling rules for any file that might be interpreted as active content (HTML, JS, templates, scripts).
- Use role- and context-based authorization for upload endpoints, applying least privilege to who can upload and where those files can be consumed.
- Design internal workflows so that uploaded files are never blindly used to drive outbound requests or dynamic server logic.
How teams detect issues like this
Detection typically involves verifying that server-side protections exist and are effective:
- Use static analysis or code review to ensure upload endpoints enforce:
- Extension and MIME-type allowlists.
- Size limits and content-type checks.
- Isolation of uploaded content from executable or template contexts.
- Define security review checklists that flag any security logic implemented exclusively in client-side code (JavaScript, UI rules, or form metadata).
- Incorporate automated tests or security scanning that attempt to upload disallowed file types and verify that the server rejects them regardless of UI constraints.
- Monitor logs for anomalous uploads (e.g.,
.html,.js, script, or configuration-like files) and failed validations as signals of probing or exploitation attempts. - Employ application security testing tools that focus on file upload abuse, including checks for stored XSS and SSRF triggered by uploaded content.

