/

CVE-2026-71303

Severity:

HIGH RISK

(7.7)

SSRF (CWE-918) in Lemur TLS Certificate Authority Updates

CVE-2026-71303

Deferred

Vulnerability type

Category:

Server-Side Request Forgery

CWE:

CWE-918

Impact:

Internal Service and Cloud Metadata Exposure

Severity:

HIGH RISK

(7.7)

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

Lemur contains a server-side request forgery vulnerability in authority updates, where an authorized user can replace a stored ACME directory URL without the validation applied during authority creation. When a later certificate issuance uses that URL, the backend may send requests to internal services or cloud metadata endpoints.

Affected context

The issue occurs in Lemur deployments where authority options can be updated through the authority API and the resulting ACME URL is later used by the backend during certificate issuance. It is relevant when update operations bypass the host allowlist or equivalent URL validation enforced during initial authority creation.

Exploit preconditions

  • Attack surface: The authority update API and subsequent certificate issuance workflow - Required access: An authenticated account with authority-management privileges - Trigger point: Updating the stored ACME URL, followed by an issuance operation - Why exploitation is possible: The update path accepts the new URL without reapplying the creation-time host validation, allowing backend-controlled outbound requests to destinations selected by the authorized user

Why this happens

The underlying bug is inconsistent validation across create and update operations. The authority creation path enforced an ACME directory host allowlist, but the authority update path forwarded user-controlled options without applying the same check. When the stored value was later consumed by the ACME client, the backend treated an insufficiently validated URL as a trusted destination. This behavior maps to CWE-918, Server-Side Request Forgery, because attacker-influenced input controls a server-side network request.

Potential impact

  • The backend may access internal services that are unreachable from outside the deployment.
  • Cloud instance metadata or temporary credentials could be exposed.
  • Internal service responses could be disclosed to an authorized attacker, depending on response handling.
  • Network segmentation assumptions could be weakened through backend-originated requests.
  • Certificate issuance workflows could be disrupted or redirected to unintended ACME services.

General mitigation guidance

Mitigation generally focuses on applying the same destination-validation policy to every lifecycle operation, including creation, update, import, and runtime use. ACME URLs should be accepted only from an explicit, narrowly scoped allowlist and should be parsed and normalized before validation. Backend request clients can further reduce trust by restricting redirects, permitted schemes, destination ports, and resolution of private or link-local addresses. Egress filtering, network policies, isolated service accounts, and least-privilege permissions provide defense in depth. Validation should occur before persistence and again at the point of use where configuration may have changed.

How teams detect issues like this

Detection approaches include static analysis and taint tracking for user-controlled URL values that reach HTTP client or ACME directory APIs. Code review should compare validation behavior across create, update, import, and execution paths, with particular attention to persisted configuration values. Runtime monitoring can alert on backend requests to private, loopback, link-local, or otherwise disallowed address ranges. Policy enforcement may include outbound firewall rules, DNS and IP destination controls, and automated security checks for missing URL allowlist validation.

Sources

SourceLink
github.comgithub.com/Netflix/lemur/commit/edca0390f930344d65ff4ca37a669c2320e3dfad
github.comgithub.com/Netflix/lemur/releases/tag/v1.9.3
github.comgithub.com/Netflix/lemur/security/advisories/GHSA-v5rc-cpwc-cfpr

Frequently asked

questions

It can be exploited through the Lemur API by an authenticated user who has

authority-management permissions, provided the deployment exposes the

vulnerable update and issuance workflow.

No. The defining risk is that the Lemur backend makes the outbound request,

so the target may be reachable only from the backend's network environment.

Apply consistent URL validation to all authority configuration changes and

validate again before the ACME client performs a request. Use a strict

destination allowlist and reject private, loopback, and link-local targets

unless explicitly required and controlled.

Treat persisted URLs as untrusted input, test every configuration lifecycle

path, restrict backend egress, disable unsafe redirects, and monitor requests

to sensitive internal address ranges.

Find out what's already
exploitable in your codebase.