Summary
A certificate authorization flaw in Lemur allows a non-read-only user to create a duplicate certificate record without permission on the underlying certificate authority. The duplicate can then be used to revoke another managed certificate, potentially causing widespread TLS service disruption.
Affected context
The vulnerability occurs in Lemur certificate management workflows when certificate uploads accept duplicate identity fields without verifying access to the associated authority. It becomes risky when revocation authorization is based only on a selected database row and downstream issuer plugins act on certificate identifiers or authority credentials without resolving all related records.
Exploit preconditions
- Attack surface: Lemur certificate upload and revocation API endpoints
- Required access: An authenticated non-read-only Lemur user able to submit certificate data
- Trigger point: Creation of a duplicate certificate record followed by a revocation request
- Why exploitation is possible: Upload authorization does not sufficiently verify authority access, while revocation checks only the attacker-controlled duplicate row and may invoke issuer plugins against the real certificate
Why this happens
The underlying bug is an authorization decision based on an incomplete object identity. Duplicate certificate attributes could create a database row that was treated as independently authorized, even though it referenced the same authority or certificate identity as another row. Revocation then validated permissions and deployment safeguards against only the selected row rather than every matching certificate record. This behavior maps to CWE-639, Authorization Bypass Through User-Controlled Key, because a user-controlled identifier influenced which protected object was authorized.
Potential impact
- An attacker may revoke certificates managed by another user or authority.
- Production services could experience TLS authentication failures.
- Fleet-wide denial of service could occur when shared or widely deployed certificates are revoked.
- Certificate rotation, incident response, and dependent integrations could be disrupted.
- Trust in certificate lifecycle records could be reduced through unauthorized duplicate entries.
General mitigation guidance
Mitigation generally focuses on binding authorization to the canonical certificate and authority identity rather than to an arbitrary database row. Secure-by-default patterns include enforcing uniqueness for authority and serial identities, requiring authority-level permission during certificate creation, and resolving every matching record before sensitive operations. Revocation safeguards should evaluate deployment status and permissions across all relevant records. Input trust can be reduced through server-derived identities, canonical lookups, and immutable relationships. Certificate management services should also use least-privilege authority credentials, scoped service accounts, and separate permissions for creation, deployment, and revocation.
How teams detect issues like this
Detection approaches include static analysis and code review for authorization checks performed only on user-selected rows, identifier-based lookups that do not enforce uniqueness, and downstream actions that trust external_id, serial, or authority_id without canonical resolution. API tests can attempt duplicate identity creation and verify that revocation evaluates every matching record. Policy enforcement can require object-level and authority-level authorization for certificate lifecycle operations, while audit monitoring can alert on duplicate certificate identities, unexpected revocations, and revocation requests by users without authority ownership.

