# CVE-2026-129359 — Magma orc8r: the hardcoded inter-service credential `7ZZXAF7CAETF241KL22B8YRR7B5UF401` authenticates any gRPC caller as a trusted internal cloud service
[ and `orc8r/cloud/go/service/middleware/unary/identity_decorator.go` (the accepting check) |
| **Affected** | Magma ≤ 1.9.0 (the constant and the accepting branch are unchanged in master) |
| **Fixed in** | nothing upstream at the time of this laboratory; the fixed side here is a hash-checked one-line synthetic remediation (documented as such) |
| **CWE** | CWE-798 (Use of Hard-coded Credentials) |
| **Impact** | Authentication bypass at the orc8r gRPC tier: any network client that can reach an orchestrator service port and knows the public constant is treated as a trusted internal cloud call — the same trust level as an in-cluster service, with no certificate, no identity, and no lookup |
| **Vector** | Network — a gRPC call carrying `x-magma-client-cert-serial: 7ZZXAF7CAETF241KL22B8YRR7B5UF401` |
| **Trigger** | the exact constant; every other serial goes through the real certifier lookup and is rejected when unknown |
Magma's cloud services authenticate each other with a shared secret that
`ORC8R_CLIENT_CERT_VALUE = "7ZZXAF7CAETF241KL22B8YRR7B5UF401"` ships in
the public source, is attached by internal clients to every inter-service
call, and — on the server side — is accepted verbatim with zero
ORC8R_CLIENT_CERT_VALUE = "7ZZXAF7CAETF241KL22B8YRR7B5UF401" // public since 2020
// orc8r/cloud/go/service/middleware/unary/identity_decorator.go
func findIdentityFromUniqueCSN(ctx context.Context, sn string, ...) {
if sn == registry.ORC8R_CLIENT_CERT_VALUE {
return newCtx, nil // trusted internal cloud call — no lookup
... // every other serial: real certifier lookup
This laboratory mounts the **real** magma identity interceptor (release
tag v1.9.0) in front of a real gRPC service and proves both directions:
the public constant is accepted as an internal cloud call, while an
unknown serial is rejected through the real lookup path. The remediated
side carries a one-line synthetic patch (the magic serial goes through
the same lookup) because no upstream fix exists; the advisory is public.
Internal orc8r clients stamp their gRPC metadata with the constant
(`outgoingCloudClientCtx` in `interceptors.go`). The universal server
interceptor resolves caller identity from the same metadata
(`SetIdentityFromContext` → `findIdentityFromCSNList` →
`findIdentityFromUniqueCSN`), where the constant short-circuits **before**
if sn == registry.ORC8R_CLIENT_CERT_VALUE {
return newCtx, nil // ← accepted, identity-less, trusted
gwIdentity, certExpTime, err = findGatewayIdentity(ctx, sn, ctxMetadata)
The design assumes only in-cluster services know the value — but the
value is in the public repository (since commit `e56a45b`, 2020-12-22,
"Fix intra cloud magic cert SN set logic"). Any caller that can reach an
orchestrator gRPC port obtains internal-cloud trust by sending the
string. The flaw is compositional: a hardcoded credential treated as an
| `magma-vuln` | `cve-2026-129359:vuln` | Magma **v1.9.0** as released; the real interceptor in front of a real gRPC health service |
| `magma-fixed` | `cve-2026-129359:fixed` | the same tree with `lab/patch-fixed.py` applied (hash-checked precondition): the magic serial no longer short-circuits |
| `poc` | `cve-2026-129359-poc:local` | stdlib-only Python driver |
The harness (`lab/harness/main.go`) is a Go program that links the real
`orc8r/cloud/go/service/middleware/unary` package (via the upstream
consumer-module replace pattern, grpc pinned to the magma-era version)
and adapts its legacy interceptor signature onto a modern gRPC server.
An HTTP endpoint `/probe?sn=…` performs a gRPC call carrying that
serial and reports whether the real interceptor accepted it, what error
the real lookup path produced, and what identity the handler context
carried. No certifier, database, or serf is needed: the magic-serial
branch short-circuits before all of them (verified — that is precisely
the bug), and the unknown-serial branch fails through the real lookup
./run-lab.sh build # fetches magma v1.9.0, builds vuln + fixed harnesses
./run-lab.sh up # cve129359lab network, magma-vuln, magma-fixed
./run-lab.sh sweep # check / exploit / probe / mitigation on both sides
podman run --rm --network cve129359lab cve-2026-129359-poc:local \
* **check** — one call with the public constant and one with an unknown
serial; classification by acceptance asymmetry. Exit 1 vulnerable,
* **exploit** — authenticates with the constant, then a control matrix:
unknown, lowercased, suffixed, and empty serials (all rejected) —
proving the bypass is the exact public string.
* **probe** — serial-shape matrix: magic, unknown, gateway-style, empty,
* **mitigation** — no upstream fix; the fixed container is the form a
fix takes; deployment mitigation is network isolation of orchestrator
| run | `magma-vuln` (v1.9.0) | `magma-fixed` (synthetic) |
| `check` unknown serial | rejected — `PermissionDenied: Unknown Client Certificate` | rejected (same) |
| `check` magic constant | **accepted, status SERVING, identity "none (internal/trusted cloud call)"** | rejected like an unknown serial |
| `exploit` mutated serials (lowercase/suffix/empty) | rejected | rejected |
| `probe` gateway-style / 200-byte / spaced | rejected through the real lookup | rejected |
| `/info` magic_sn | `7ZZXAF7CAETF241KL22B8YRR7B5UF401` (from the running binary) | same |
Captured runs: `evidence/check-*-run.txt`, `evidence/exploit-*-run.txt`,
`evidence/probe-*-run.txt`, `evidence/mitigation-*-run.txt`,
`evidence/versions.txt`, `evidence/0day-sweep.txt`.
* Podman (or Docker) with network-creation rights; containers bounded
* Outbound HTTPS at image build (GitHub: magma tag v1.9.0; Go module
## 7. Additional findings (0-day sweep on the fixed line)
The serial-shape matrix is the surface sweep (`evidence/0day-sweep.txt`):
on the shipped build only the exact constant is accepted — every
mutated form is rejected through the real certifier lookup — and on the
remediated build every form, including the constant, is rejected. No
second bypass form was found. The sibling header-trust issue in the
HTTP tier (`X-Magma-Client-Cert-Serial` → operator identity) is
run-lab.sh environment driver (build / up / sweep / down)
Makefile convenience targets
poc/poc.py the PoC (check / exploit / probe / mitigation)
poc/Dockerfile runner image (python:3.12-alpine)
lab/lab.Dockerfile multi-stage build (magma v1.9.0 + harness)
lab/patch-fixed.py the hash-checked one-line synthetic remediation
lab/harness/main.go real-interceptor gRPC harness + HTTP probe
lab/harness/go.mod upstream consumer-module replace pattern
evidence/ captured runs of every mode on both sides
TRACKING.md excluded (working record)
* CVE record —
* VulDB entry —
* Magma — (orc8r/lib/go/registry/interceptors.go,
orc8r/cloud/go/service/middleware/unary/identity_decorator.go)
The full story
This article is one source in a clustered incident — the cluster page carries the summary, timeline and every other outlet covering it.
