Skip to content
Exploit for CVE-2026

Exploit for CVE-2026

Sploitus • November 15, 2026

# CVE-2026-129359 — Magma orc8r: the hardcoded inter-service credential `7ZZXAF7CAETF241KL22B8YRR7B5UF401` authenticates any gRPC caller as a trusted internal cloud service

[![License: MIT](

[![Research status: validated](

| **Component** | Linux Foundation Magma orc8r — `orc8r/lib/go/registry/interceptors.go` (the constant) 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)

Extracted Entities

Attack Types (1)

MITRE ATT&CK (1)