# CVE-2026-129360 — Magma orc8r Obsidian REST: the operator identity follows the spoofable `X-Magma-Client-Cert-Serial` header
[ behind `CertificateMiddleware` (`rest_middleware.go`) |
| **Affected** | Magma ≤ 1.9.0 (logic unchanged in master at lab time) |
| **Fixed in** | nothing upstream at the time of this laboratory; the fixed side is a hash-checked synthetic remediation (documented as such) |
| **CWE** | CWE-290 (Authentication Bypass by Spoofing) |
| **Impact** | Operator impersonation on the NMS/obsidian REST tier: a caller who knows (or guesses) a registered operator certificate serial authenticates as that operator with nothing but a header — certificate serials are not secret, and no certificate possession is checked |
| **Vector** | Network — an HTTP request carrying `X-Magma-Client-Cert-Serial: ` |
| **Trigger** | the header value alone; unknown serials are rejected through the real certifier lookup |
The obsidian REST tier resolves the caller's identity from a header:
// orc8r/cloud/go/services/obsidian/access/operator.go
csn := req.Header.Get(CLIENT_CERT_SN_KEY) // attacker-controlled header
certInfo, err := certifier.GetCertificateIdentity(req.Context(), csn)
return certInfo.Id, nil // operator identity
The design assumes a trusted TLS-terminating proxy injects that header
from the **verified** client certificate. When the header is reachable
by the client (direct service exposure, a proxy that forwards
client-supplied headers, or any topology where the assumption breaks),
knowing a registered operator **serial** — which is not a secret — is
the whole authentication. This laboratory runs the **real**
`CertificateMiddleware` behind the **real** certifier client against a
certifier gRPC server implementing the **real** protobuf service with
one registered operator certificate, and proves the spoof: the
registered serial authenticates with no certificate at all, while
unknown serials are rejected through the real lookup path.
`getOperator` treats the header as ground truth certificate
possession. Three facts compose into the spoof:
1. the serial arrives from an HTTP header with no binding to the TLS
session — `req.TLS` and `req.TLS.PeerCertificates` are never
2. the certifier lookup itself is correct — it returns the identity
bound to the serial — but the caller only needs to *know* the
3. certificate serials are not secret: they surface in logs, proxies,
and administrative interfaces, and (per the sibling
CVE-2026-129359) one cloud-wide serial is even hardcoded in the
The middleware chain (`CertificateMiddleware`) calls `getOperator`
before anything else; on success the operator identity flows into the
ACL check. The lab mounts the middleware on a static-READ path (GET
under `/swagger`), which skips the entity-ACL stage — isolating exactly
| `obs-vuln` | `cve-2026-129360:vuln` | Magma **v1.9.0** as released: the real middleware + real certifier client + a real-proto certifier server with one registered operator certificate |
| `obs-fixed` | `cve-2026-129360:fixed` | the same tree with `lab/patch-fixed.py` (hash-checked): the serial header is only trusted when a TLS client certificate was actually presented |
| `poc` | `cve-2026-129360-poc:local` | stdlib-only Python driver |
The harness (`lab/harness/main.go`) links the real `obsidian/access`
package (echo v4, the framework magma itself uses) and the real
`certifier.GetCertificateIdentity` client. The certifier backend
implements the real `CertifierServer` protobuf interface and holds one
registered operator certificate (serial `LABOPERATORSN0001`, operator
`lab-operator`) — a minimal faithful model of a production certifier.
The HTTP endpoint never requests a TLS client certificate, exactly like
the header-trusting topology of the advisory.
./run-lab.sh build # fetches magma v1.9.0, builds vuln + fixed harnesses
./run-lab.sh up # cve129360lab network, obs-vuln, obs-fixed
./run-lab.sh sweep # check / exploit / probe / mitigation on both sides
podman run --rm --network cve129360lab cve-2026-129360-poc:local \
* **check** — the registered serial without any certificate vs an
unknown serial vs no header. Exit 1 vulnerable, 0 safe, 3 no worker,
* **exploit** — authenticates as the operator with the header alone,
then the control matrix (unknown, empty, absent serials).
* **probe** — serial-shape and verb matrix (GET/HEAD/POST, lowercased,
* **mitigation** — no upstream fix; the fixed container is the form a
fix takes; the deployment mitigation is header hygiene at the
| run | `obs-vuln` (v1.9.0) | `obs-fixed` (synthetic) |
| `check` registered SN, no certificate | **HTTP 200, `authenticated: true`, operator resolved** | HTTP 401 (client certificate required) |
| `check` unknown SN | HTTP 401 (unknown certificate SN — real lookup) | HTTP 401 |
| `check` no header | HTTP 401 (missing client certificate) | HTTP 401 |
| `exploit` controls (unknown/empty/absent) | all 401 | all 401 |
| `probe` GET/HEAD/POST with registered SN | 200 on every verb | 401 on every verb |
| `probe` lowercased / 200-byte serials | 401 through the real lookup | 401 |
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
proxy; npm is not required — the harness is Go-only).
## 7. Additional findings (0-day sweep on the fixed line)
The serial-shape and verb matrix is the surface sweep
(`evidence/0day-sweep.txt`): only the exact registered serial
authenticates on the shipped build (every mutation goes through the
real lookup and is rejected), and on the remediated build every form is
rejected. No second bypass form was found. The gRPC-tier hardcoded
constant is CVE-2026-129359, reproduced in
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 synthetic remediation
lab/harness/main.go real-middleware + real-certifier-client harness
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/cloud/go/services/obsidian/access/)
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.
