Severity:

CRITICAL RISK

(9.8)

Unrestricted File Upload in Airleader Master Web Interface

CVE-2026-1358

Awaiting Analysis

Vulnerability type

Category:

Unrestricted File Upload

CWE:

CWE-434

Impact:

Remote Code Execution

Severity:

CRITICAL RISK

(9.8)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

Airleader Master up to version 6.381 allows unauthenticated users to upload arbitrary files to multiple web pages that execute with maximum privileges.

Under these conditions, an attacker can upload executable code and potentially achieve remote code execution on the server.

Affected context

The vulnerability occurs in the Airleader Master web interface where certain upload endpoints accept files without adequate restrictions.

These pages run with high or maximum privileges on the server, and the uploaded content may be stored in locations that are accessible and executable by the application or underlying system.

Environments that expose the Airleader Master interface to untrusted networks (including the internet or flat internal networks) are at higher risk, especially when default configurations and accounts remain unchanged.

Exploit preconditions

  • Attack surface: HTTP(S) endpoints on the Airleader Master web interface that accept file uploads.
  • Required access: No prior authentication is required; the vulnerable upload functionality is reachable by any network user who can send requests to the device.
  • Trigger point: Submission of specially crafted upload requests to affected webpages, followed by direct or indirect access to the uploaded file.
  • Why exploitation is possible: The upload logic does not enforce strict validation of file type, name, or content, nor does it ensure safe storage locations. Because the affected pages run with maximum privileges, uploaded files can be processed or executed with elevated rights.

Why this happens

This issue stems from insufficient validation and control over user-supplied files, aligning with CWE-434: Unrestricted Upload of File with Dangerous Type.

The upload handlers accept arbitrary files without robust checks on file extension, MIME type, content inspection, or storage path, and do not enforce separation between data and executable areas.

As a result, an attacker can introduce files that the server or application subsequently treats as executable code or scripts, effectively converting a simple upload feature into a code execution primitive.

Potential impact

  • Remote execution of arbitrary code with the privileges of the Airleader Master service.
  • Installation of backdoors or web shells for persistent access.
  • Modification, deletion, or exfiltration of configuration and operational data.
  • Use of the compromised server as a pivot point to attack other systems in the network.
  • Disruption of service availability through malicious uploads or configuration manipulation.

General mitigation guidance

Mitigation generally focuses on treating file uploads as untrusted input and minimizing their ability to influence execution:

  • Enforce strict allowlists for file types, checking both extension and content signatures, and rejecting all other formats.
  • Store uploaded files outside any web-accessible or executable directory, ensuring they are treated strictly as data.
  • Normalize and sanitize file names, removing control characters, path separators, and disallowed patterns, and use server-generated names instead of client-supplied ones.
  • Apply least-privilege principles to the web service and file storage locations so that uploaded content cannot run with high or system-level permissions.
  • Introduce server-side checks that prevent direct execution, inclusion, or interpretation of uploaded files by interpreters or shells.
  • Where uploads are not functionally required, disable or remove the corresponding endpoints to reduce attack surface.

How teams detect issues like this

Effective detection involves both code-level analysis and runtime monitoring:

  • Use static analysis and secure code review to identify upload handlers that:
  • Accept arbitrary file types.
  • Write to webroot or executable directories.
  • Lack extension/content validation or access control checks.
  • Define security review checklists requiring explicit justification for any executable or script-related uploads, and verification that uploads go to non-executable storage.
  • Implement logging around upload endpoints, including filename, size, source IP, and outcome, then alert on anomalous patterns such as unexpected file types or repeated uploads.
  • Periodically scan upload directories for executable content (scripts, binaries) that do not match approved patterns.
  • Integrate automated application security testing tools or dynamic scanners configured to probe file upload functionality for unsafe behavior.

Sources

SourceLink
airleader.usairleader.us/contact/
github.comgithub.com/cisagov/CSAF/blob/develop/csaf_files/OT/white/2026/icsa-26-043-10.json
cisa.govcisa.gov/news-events/ics-advisories/icsa-26-043-10
syss.desyss.de/fileadmin/dokumente/Publikationen/Advisories/SYSS-2025-044.txt

Frequently asked

questions

Yes. If the Airleader Master web interface is network-accessible, an unauthenticated attacker can remotely reach the upload endpoints and attempt to gain code execution.

No. The description indicates that an unauthenticated user can reach the vulnerable upload pages, so no valid credentials are required to attempt exploitation.

The most robust pattern is to strictly control upload behavior: disable non-essential uploads, enforce a narrow allowlist of harmless file types, store uploads outside executable paths, and ensure the web service runs with minimal privileges so uploaded content cannot execute.

Adopt a secure design approach for file uploads: treat all uploaded files as untrusted, enforce strong validation and storage isolation, include upload reviews in security design and code review processes, and use automated checks in CI to flag unrestricted upload patterns.

Find out what's already
exploitable in your codebase.