Mar 30, 2026·5 min read·32 visits
A flaw in Fleet prior to version 4.81.0 allows attackers with a leaked invitation token to register an account using an arbitrary email address. This bypasses intended identity verification and grants the attacker the roles associated with the invite, potentially yielding Global Admin access.
Fleet, an open-source device management platform, contains an improper authentication vulnerability in its user invitation flow. Prior to version 4.81.0, the application failed to validate that the email address submitted during account registration matched the address associated with the provided invitation token. This allows attackers possessing a valid invitation token to provision accounts under arbitrary email addresses while inheriting the privilege level assigned to the original invitee.
Fleet is an open-source device management software solution used to monitor and manage endpoint infrastructure. It exposes a web-based administration interface that includes an invitation mechanism for onboarding new users. Administrators generate these invitations to grant specific roles, such as Global Admin, to target email addresses.
The vulnerability, tracked as CVE-2026-34389, resides within the server-side logic responsible for processing these user invitations. Specifically, it involves the account registration endpoint that consumes an invitation token and finalizes the user provisioning process.
Prior to version 4.81.0, the application failed to enforce consistency between the email address submitted by the user and the email address originally bound to the invitation token. This architectural flaw allows an unauthenticated attacker who obtains a valid token to register an account under an arbitrary email address while assuming the role intended for the original recipient.
The core issue is classified as Improper Authentication (CWE-287). It manifests in the final stage of the user invitation workflow. When an administrator creates an invite, Fleet generates a unique token and stores it in the database alongside the intended recipient's email address and assigned role.
Upon navigating to the registration link, the invited user submits a payload containing their desired name, password, and email address. The server-side registration handler receives this payload and verifies the cryptographic validity and expiration status of the provided token.
However, the vulnerable implementation omitted a critical validation step. It did not cross-reference the email address provided in the HTTP request payload with the email address stored in the database record for that specific token. Consequently, the server created a new user record utilizing the attacker-supplied email address, while querying the token record solely to apply the predefined role assignments.
This oversight decouples the token's authorization context from the intended identity. The system trusts the token as proof of authorization to create an account with a specific role, but erroneously accepts the user-supplied email as the definitive identity for that account.
Exploitation requires the attacker to obtain a valid, unexpired invitation token. These tokens are typically transmitted via email but are frequently shared out-of-band in communication channels such as Slack, Microsoft Teams, or internal wikis where exposure is more likely.
Once a token is acquired, the attacker navigates to the public-facing Fleet registration endpoint. They populate the registration form with their own email address, such as attacker@evil.com, alongside a password of their choosing.
Submitting the form triggers the vulnerable server-side logic. The application processes the token, confirms it is active, and provisions the new account. The system applies the role linked to the token, which may include highly privileged roles like Global Admin.
The attacker now possesses a fully functional, authenticated session on the Fleet instance. Since the account uses their specified email address, they retain persistent access and control over the platform, bypassing the administrator's original identity constraints.
The primary impact of this vulnerability is a complete compromise of the authorization boundary surrounding new user onboarding. By successfully exploiting this flaw, an unauthorized actor gains persistent, authenticated access to the Fleet instance.
The severity of the compromise scales directly with the privilege level assigned to the leaked invitation token. If the token was generated for a Global Admin role, the attacker achieves total administrative control over the device management platform.
Administrative access allows the attacker to manipulate device configurations, issue commands to managed endpoints, access sensitive telemetry data, and further compromise the network infrastructure. The integrity of the system is fundamentally undermined.
According to the CVSS 4.0 framework, the vulnerability carries a base score of 4.9. This score reflects the low attack complexity and lack of required user interaction, balanced against the prerequisite of obtaining a valid invitation token prior to exploitation.
The definitive resolution for CVE-2026-34389 is upgrading the Fleet installation to version 4.81.0 or later. This release introduces strict server-side validation to ensure the submitted email address matches the address bound to the invitation token before provisioning the account.
If an immediate upgrade is not feasible, administrators must implement strict operational controls regarding invitation links. These links should be treated as sensitive credentials and transmitted exclusively through secure, direct communication channels.
Administrators should proactively revoke and reissue any invitation links suspected of exposure in semi-public channels. Additionally, applying the principle of least privilege by issuing invites with minimal permissions and manually elevating roles post-registration reduces the potential impact of a leaked token.
Security teams should audit the user directory for recent registrations. Reviewing the email domains of newly created accounts helps identify unauthorized access attempts that may have exploited this vulnerability prior to patching.
CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:N/VI:H/VA:N/SC:N/SI:N/SA:N/E:U| Product | Affected Versions | Fixed Version |
|---|---|---|
Fleet Fleet | < 4.81.0 | 4.81.0 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-287 |
| Attack Vector | Network |
| CVSS 4.0 Score | 4.9 |
| EPSS Score | 0.00038 |
| Exploit Status | Unproven |
| CISA KEV | Not Listed |
Improper Authentication
Froxlor prior to version 2.3.8 contains a high-severity architectural flaw where the standalone lib/ajax.php entry point bypasses the centralized request validation in lib/init.php. Unauthenticated remote attackers can leverage Cross-Site Request Forgery (CSRF) to induce authenticated administrators to submit forged requests that modify API key whitelists and expiration dates, potentially yielding persistent, out-of-band administrative control.
An insecure data retrieval flaw in the Froxlor server administration panel API allows authenticated remote attackers to retrieve unredacted bcrypt password hashes and Base32-encoded Time-Based One-Time Password (TOTP) seeds. Affected endpoints include several 'get' and 'listing' handlers for customers, administrators, and FTP accounts. Utilizing these leaked parameters, attackers can crack the password hashes offline and concurrently generate valid second-factor authentication codes to completely bypass access controls.
CVE-2026-70666 is a critical Server-Side Request Forgery (SSRF) vulnerability in Netflix Lemur's ACME certificate management integration. Prior to version 1.9.3, the system allowed authority-role users to bypass initial ACME URL allowlist validations when updating an existing authority. Additionally, the underlying ACME network client blindly parsed and connected to dynamic endpoint URLs supplied in JSON responses from the configured ACME directory, allowing attackers to route arbitrary JWS-signed requests to internal services or cloud metadata endpoints.
A security vulnerability in Netflix Lemur, a TLS certificate management framework, allows authenticated operators to bypass Server-Side Request Forgery (SSRF) mitigations. The issue exists within the certificate revocation verification workflow, specifically inside the CRL and OCSP retrieval logic. By exploiting HTTP redirects or DNS rebinding (Time-of-Check Time-of-Use) mechanisms, an attacker can coerce the server into issuing arbitrary network requests to internal services, such as the cloud instance metadata service (IMDS) or loopback addresses. This bypass neutralizes previous network-boundary validation logic and allows blind read/write SSRF targeting internal infrastructure resources.
Netflix Lemur, an open-source TLS certificate management framework, is affected by a Server-Side Request Forgery (SSRF) vulnerability. This vulnerability arises from an incomplete patch for a previous security flaw, CVE-2026-55166. While Lemur version 1.9.2 validated the ACME directory URL against an allowlist during authority creation, it failed to perform the same checks when updating existing authorities. An authenticated user possessing an authority role can exploit this omission to replace the directory URL with internal or cloud metadata endpoints. During subsequent certificate issuance, the Lemur backend executes unauthorized requests, potentially leaking sensitive metadata or credentials.
An authorization bypass and information disclosure vulnerability in Netflix Lemur before version 1.9.3 allows authenticated, low-privilege users to retrieve raw destination configurations, exposing plaintext credentials such as SFTP passwords and private key passphrases.