CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-71417

CVE-2026-71417: Authorization Bypass Leading to Unauthorized TLS Certificate Revocation in Netflix Lemur

Amit Schendel
Amit Schendel
Senior Security Researcher

Aug 18, 2026·6 min read·66 visits

Executive Summary (TL;DR)

An authorization bypass in Netflix Lemur prior to v1.9.3 allows authenticated users to revoke arbitrary TLS certificates at the upstream CA. By uploading a duplicate metadata record of a victim's certificate, an attacker becomes the owner of that local record and can bypass safety checks to trigger CA-level revocation, resulting in immediate service disruption.

CVE-2026-71417 is an authorization bypass vulnerability (CWE-639) in Netflix Lemur, an open-source TLS certificate management framework. In versions prior to 1.9.3, a low-privileged authenticated user can bypass role and certificate-level permission boundaries to revoke arbitrary managed TLS certificates at the upstream Certificate Authority (CA). This vulnerability stems from an architectural issue where Lemur evaluates authorization against internal database row ownership rather than the unique, cryptographic identity of the certificate. An attacker can exploit this flaw by uploading a duplicate record of a target certificate and requesting its revocation, triggering a downstream CA-side revocation and a subsequent denial-of-service (DoS) condition for services relying on the target certificate.

Vulnerability Overview

Netflix Lemur functions as a centralized orchestration engine for managing the lifecycle of TLS certificates across large enterprise infrastructures. It interacts with upstream Certificate Authorities (such as DigiCert or Let's Encrypt) to automate issuance, renewal, and revocation. Because Lemur serves as a high-privilege gateway to external CA infrastructure, it maintains strict internal authorization controls. Users are typically organized into roles with specific 'AuthorityPermissions' and 'CertificatePermissions' to restrict access to sensitive keys and domains.

CVE-2026-71417 describes a critical flaw within Lemur's multi-tenant permission model. Specifically, the software fails to properly restrict manually uploaded certificate metadata and subsequently relies on database-row-level ownership check rather than cryptographic identity checks during revocation requests. This architectural decoupling allows any low-privileged, authenticated user to subvert the intended security controls.

The impact is categorized under CWE-639 (Authorization Bypass Through User-Controlled Key). Because the vulnerability results in the revocation of active production certificates at the upstream CA level, it carries a severe availability impact. Services utilizing the revoked certificates will immediately experience trust failures during client TLS handshakes, leading to wide-scale, enterprise-wide service outages.

Root Cause Analysis

The root cause of CVE-2026-71417 is a two-part failure involving unrestricted manual database entry and flawed authorization validation logic.

First, the certificate upload endpoint ('POST /api/1/certificates/upload') did not validate whether the uploading user possessed administrative or ownership privileges over the Certificate Authority associated with the certificate. Furthermore, the Lemur database schema did not enforce unique constraints on combinations of the authority identifier and the certificate serial number. Consequently, a malicious user could manually upload the public metadata of an active certificate owned by another team, associating it with any arbitrary CA configured in the system. Since the attacker uploaded the record, Lemur designated the attacker as the 'owner' of this newly created database row.

Second, the revocation endpoint ('PUT /api/1/certificates/<id>/revoke') relied on row-level authorization rather than global certificate identity. When the attacker requested revocation for their newly uploaded duplicate row, Lemur's access control check succeeded because the attacker was the registered owner of that specific database entry. Additionally, Lemur's built-in safeguard—which blocks the revocation of certificates currently mapped to active endpoints ('cert.endpoints')—failed. Because the attacker's newly uploaded duplicate record had no active endpoints associated with it in the Lemur tracking database, the safeguard query returned empty. The application then passed the revocation instruction to the upstream CA integration plugin, which executed the revocation using the certificate's shared cryptographic identifiers, invalidating the victim's production certificate.

Exploitation Methodology & Attack Sequence

An attacker with standard, authenticated API access to Lemur can execute this attack sequence with minimal complexity. The exploitation flow follows these steps:

  1. Reconnaissance: The attacker queries the Lemur API to retrieve the public certificate metadata of the target certificate, capturing the public PEM certificate block and the associated authority identifier.

  2. Database Shadowing: The attacker calls 'POST /api/1/certificates/upload' and submits the victim's public PEM certificate. The attacker specifies themselves as the owner and links the certificate to the target authority. Because no authority validation or uniqueness checks are performed, the application database inserts a new row (e.g., ID 9999) pointing to the same cryptographic identity as the victim's legitimate row (e.g., ID 1111).

  3. Bypassing Safeguards & Requesting Revocation: The attacker targets their newly created row by issuing a 'PUT /api/1/certificates/9999/revoke' request. The backend verifies that the caller owns row 9999 (which is true) and that row 9999 has no deployed endpoints (which is also true).

  4. CA-Side Execution: The issuer plugin processes the request and transmits the revocation instruction to the external CA using the serial number. The CA revokes the certificate, terminating its validity globally.

Code-Level Patch Analysis

The vulnerability was resolved in commit 851389ae737a6d6bf16c1f9ca64a2ce56c1cc5c6. The patch implements validation at both the upload (ingestion) and revocation (action) boundaries.

At the ingestion boundary ('POST /api/1/certificates/upload'), the patch verifies that the user possesses permission to interact with the specified authority. It then parses the uploaded certificate body to extract the serial number and queries the database for existing records sharing the same 'authority_id' and 'serial' combination. If a matching record is found, the application rejects the upload with a '409 Conflict' error:

# lemur/certificates/views.py - Upload Fix
authority = data.get("authority")
if authority:
    authority_roles = [x.name for x in authority.roles]
    if not AuthorityPermission(authority.id, authority_roles).can():
        return (
            dict(message="You are not authorized to upload a certificate for the specified authority."),
            403,
        )
 
    parsed_cert = utils.parse_certificate(data["body"])
    serial = defaults.serial(parsed_cert)
    existing = Certificate.query.filter(
        Certificate.authority_id == authority.id,
        Certificate.serial == str(serial),
    ).first()
    if existing:
        return (
            dict(
                message=f"A certificate with serial={serial} already exists for this authority "
                        f"(Certificate id={existing.id})."
            ),
            409,
        )

At the action boundary ('PUT /api/1/certificates/<id>/revoke'), the patch modifies the authorization logic to query for all database rows sharing the target certificate's 'authority_id' and 'serial'. The handler then enforces ownership and endpoint checks across all retrieved records, preventing attackers from using a self-owned alias to bypass checks on a production certificate:

# lemur/certificates/views.py - Revocation Fix
related_certs = [cert]
if cert.authority_id and cert.serial:
    related_certs = Certificate.query.filter(
        Certificate.authority_id == cert.authority_id,
        Certificate.serial == cert.serial,
    ).all()
 
for related in related_certs:
    if g.current_user != related.user:
        owner_role = role_service.get_by_name(related.owner)
        permission = CertificatePermission(owner_role, [x.name for x in related.roles])
        if not permission.can():
            return dict(message="You are not authorized to revoke this certificate. Blocked by related row."), 403

Post-Patch Evaluation & Security Caveats

Although the patch successfully addresses the primary exploit vector, security teams should remain aware of specific implementation limits and risks.

First, the duplicate check during upload is performed at the application layer via an ORM query ('Certificate.query.filter(...)') rather than a unique constraint at the database layer. This introduces a Time-of-Check to Time-of-Use (TOCTOU) race condition. If an attacker submits concurrent duplicate upload requests, the database could potentially commit multiple matching rows before the application checks complete. However, the updated revocation endpoint mitigates the impact of this condition because it queries for all matching serials and authorities dynamically, meaning any subsequent revocation attempt will still be blocked by the original, legitimate record's permissions.

Second, the patch introduces a potential operational issue for legacy deployments containing pre-existing duplicate rows. If duplicate rows were inserted before applying the v1.9.3 upgrade, a legitimate owner attempting to revoke their certificate will be blocked. The updated revocation code will locate the legacy duplicate row owned by the other user and fail the authorization check. Administrators must clean up duplicate database rows during the upgrade process.

Official Patches

NetflixNetflix Security Advisory for LEMUR-BUG-08 / GHSA-pxmc-2ffp-8j67
NetflixOfficial patch commit resolving unauthorized revocation

Fix Analysis (1)

Technical Appendix

CVSS Score
7.3/ 10
CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:C/C:N/I:L/A:H

Affected Systems

Netflix Lemur prior to version 1.9.3

Affected Versions Detail

Product
Affected Versions
Fixed Version
Lemur
Netflix
< 1.9.31.9.3
AttributeDetail
Vulnerability TypeCWE-639: Authorization Bypass Through User-Controlled Key
Attack VectorLocal API Access (Authenticated User Session)
CVSS v3.1 Base Score7.3
EPSS ScoreNot available
Exploit StatusProof of Concept (PoC) available in official repository
CISA KEV StatusNot Listed
Scope ImpactChanged (S:C) - Lemur exploitation leads to external CA revocation

MITRE ATT&CK Mapping

T1553.001Subvert Trust Controls: Gatekeeper Bypass
Defense Evasion
T1078Valid Accounts
Initial Access
CWE-639
Authorization Bypass Through User-Controlled Key

The system fails to check if the user is authorized to perform the action on the referenced object by its key.

Known Exploits & Detection

GitHub Security AdvisoryGHSA-pxmc-2ffp-8j67 contains comprehensive reproduction steps and the official unit tests showing the verification bypass.

Vulnerability Timeline

Official fix commit 851389ae737a6d6bf16c1f9ca64a2ce56c1cc5c6 is authored
2026-07-03
Netflix publishes GHSA-pxmc-2ffp-8j67 and releases Lemur version 1.9.3
2026-08-18
CVE-2026-71417 is assigned and published in the NVD
2026-08-18

References & Sources

  • [1]GHSA-pxmc-2ffp-8j67: Netflix Lemur Row-level Certificate Revocation Bypass
  • [2]Netflix Lemur Release Tag v1.9.3

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•about 1 hour ago•CVE-2026-58254
6.5

CVE-2026-58254: Authorization Bypass in NATS Server Message Tracing for Leaf Node Connections

NATS Server prior to versions 2.12.8 and 2.14.3 contains an incorrect authorization vulnerability (CWE-863) in its message tracing subsystem. When evaluating whether a connection is permitted to publish trace events to a destination subject specified in the Nats-Trace-Dest header, the server only checks standard client permissions and omits permission checks for leaf node connections. This allows a connected leaf node operator with restricted publishing privileges to emit internal trace events to unauthorized subjects and suppress standard message delivery using the Nats-Trace-Only header.

Alon Barad
Alon Barad
3 views•10 min read
•about 2 hours ago•CVE-2026-63341
7.5

CVE-2026-63341: Unauthenticated Denial of Service via Unbounded Topic Depth in Aedes MQTT Broker

CVE-2026-63341 is a high-severity Denial of Service (DoS) vulnerability in the Aedes MQTT broker for Node.js affecting all versions prior to 1.1.1. The flaw stems from missing input validation on the hierarchical depth of incoming MQTT topic strings before they are passed to the underlying topic-matching engine, qlobber. Because qlobber enforces a hardcoded limit of 100 topic levels and throws a synchronous exception when this threshold is exceeded, an attacker can send a single MQTT packet containing 101 or more forward-slash-separated levels to trigger an uncaught exception that immediately terminates the Node.js broker process.

Alon Barad
Alon Barad
3 views•12 min read
•about 3 hours ago•CVE-2026-61725
6.1

CVE-2026-61725: Path Traversal and Arbitrary File Overwrite in sevenz-rust2

CVE-2026-61725 is a path traversal vulnerability (CWE-22) in the sevenz-rust2 Cargo package prior to version 0.21.1. The vulnerability occurs because the decompression utility fails to validate or sanitize archive entry filenames before joining them with the destination directory path via std::path::Path::join. An attacker who supplies a crafted 7z archive containing parent directory traversal sequences or absolute paths can write or overwrite arbitrary files on the host filesystem with the privileges of the extracting process.

Alon Barad
Alon Barad
3 views•12 min read
•about 4 hours ago•CVE-2026-77309
8.8

CVE-2026-77309: Unauthenticated Remote Code Execution in NASA-AMMOS AIT-GUI via Incomplete File Cleanup and Path Traversal

CVE-2026-77309 (GHSA-jrjx-9jjw-747m) is a high-severity unauthenticated remote code execution vulnerability affecting NASA-AMMOS AIT-GUI versions 1.0.0 through 2.5.0. The flaw results from chaining an incomplete file cleanup error in the telemetry query endpoint (/tlm/query) with a directory traversal flaw in the script execution endpoint (/script/run). An attacker on an adjacent network can stage arbitrary Python statements into a static file on disk and execute that file under the privileges of the AIT-GUI web server process.

Amit Schendel
Amit Schendel
4 views•10 min read
•about 5 hours ago•CVE-2026-77332
2.3

CVE-2026-77332: Surfaced-Memory Envelope Injection and Stored Prompt Injection in memtomem-stm

A vulnerability classified under CWE-116 (Improper Encoding or Escaping of Output) exists in memtomem-stm versions 0.1.0 through 0.1.33. The software acts as a Model Context Protocol (MCP) short-term memory proxy gateway for AI agent architectures. When surfacing retrieved memories and scratchpad items into downstream Large Language Model (LLM) context envelopes, the SurfacingFormatter component fails to properly sanitize untrusted memory attributes. An attacker with the ability to plant untrusted content into the agent's long-term or working memory store can inject arbitrary structural delimiters, close the <surfaced-memories> XML boundary prematurely, visually obscure instructions using Unicode bidirectional overrides, and execute stored prompt injection attacks against downstream LLM agents.

Alon Barad
Alon Barad
7 views•10 min read
•about 6 hours ago•CVE-2026-77331
2.0

CVE-2026-77331: Race Condition and Session State Corruption in memtomem-stm

CVE-2026-77331 (GHSA-72jh-722p-rqr3) is a concurrency and session-state synchronization vulnerability in memtomem-stm, a short-term memory proxy gateway for AI agents. In versions 0.1.2 prior to 0.1.34, concurrent Model Context Protocol (MCP) Remote Procedure Call (RPC) failures or mid-flight task cancellations can initiate duplicate reconnect loops and permit dirty or cancelled transport sessions to be reused. This deficiency results in session-state integrity loss and local service degradation.

Amit Schendel
Amit Schendel
5 views•9 min read