CVE-2026-33186 (grpc-go): authorization bypass via a slash-less HTTP/2 :path -- b63 showcase, lab-verified with patched and config-leg negatives
:path authorization bypassA denied, privileged gRPC method executes for an unauthenticated caller when the
HTTP/2 :path pseudo-header omits its mandatory leading slash.
Lab-verified PoC, a two-twin Docker lab (grpc-go v1.79.2 vulnerable / v1.79.3 patched), and the evidence transcripts for every claim below.
grpc-go's server strips the leading / from :path only when it is present,
then splits on the last /. A path like admin.v1.Admin/DeleteUser therefore
still routes to the right service and method -- but path-based authorization
sees the raw, non-canonical string. A policy that denies a canonical path and
allows everything else by default never matches the deny rule, so the denied
RPC runs.
In this lab the denied method is admin.v1.Admin/DeleteUser on a policy of the
exact shape the advisory describes (one deny rule on /admin.v1.Admin/DeleteUser
plus an allow-all fallback). The attacker deletes the root-admin administrator
account without ever authenticating.
| CVE | CVE-2026-33186 |
| GHSA | GHSA-p77j-4mvh-x3m3 (grpc/grpc-go) |
| Class | CWE-285 improper authorization; Red Hat also files CWE-551 (authorization before parsing/canonicalization) |
| CVSS 3.1 | 9.1 AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N (as published) |
| Affected | google.golang.org/grpc < 1.79.3 |
| Fixed | v1.79.3 -- commit 72186f163e, PR #8981 |
Preconditions (both required, per the advisory): authorization is path-based
(grpc/authz, or a custom interceptor reading grpc.Method(ctx) / a stream
interceptor's FullMethod), and the policy denies specific canonical paths
while allowing the rest by default.
One nuance worth stating because it is easy to get wrong: on protoc-generated
unary handlers, UnaryServerInfo.FullMethod is a compile-time constant, so a
unary interceptor that reads only that field sees the canonical path and is not
bypassed. The vulnerable readers are grpc.Method(ctx), the grpc/authz
package, and stream interceptors. The lab mirrors generated-stub semantics and
logs both values side by side (evidence 01, 04).
Everything below was captured in this lab. "Captured" means the transcript is
shipped; nothing here is claimed from reading the advisory alone. The evidence/
set was re-captured from a fresh clone of this repository at its current tip
(after review found the first set was anchored to the private authoring tree),
so every Command: line is a command a reader can run from the repo root;
MANIFEST.txt is the sha256 inventory of the release tree.
| claim | level | evidence |
|---|---|---|
| Two builds of one source tree: grpc-go v1.79.2 (vulnerable) and v1.79.3 (patched), pinned by tag commit, identity baked in and read back from the running containers | captured | evidence/01-lab-identity.txt |
A stock grpc-go client (cc.Invoke with a slash-less method string) reproduces the bypass: canonical method -> PermissionDenied, slash-less -> the denied account deletion | captured | evidence/02-impact-go-stock-client.txt |
Raw HTTP/2 driver (poc/exploit_opt.py, one TCP connection): control leg denied, bypass deletes root-admin, nonce-matched receipt + post-state | captured | evidence/03-impact-opt-driver.txt |
Same via the annotated driver (poc/exploit_readable.py) | captured | evidence/04-impact-readable-driver.txt |
Patched v1.79.3 refuses with grpc-status 12 Unimplemented before interceptors; grpc-core logs its own rejection; store unchanged | captured | evidence/05-negative-patched.txt |
Config leg: the byte-identical v1.79.3 binary with GRPC_GO_EXPERIMENTAL_DISABLE_STRICT_PATH_CHECKING=true restores the bypass | captured | evidence/06-config-escape-hatch.txt |
| Four-leg matrix, both drivers (vuln / patched / config / closed port) | captured | evidence/07-matrix-four-legs.txt |
| Reliability, vulnerable twin: 10/10 hits (opt) and 5/5 (readable), fresh lab per run | captured | evidence/08-reliability-vulnerable.txt |
| Reliability, patched twin: 0/10 and 0/5 -- no false positives | captured | evidence/09-reliability-patched.txt |
| Non-vacuous control: on a vulnerable binary whose policy has no deny rule, both drivers refuse to claim a hit; exit codes 0/1/2/3 exercised live | captured | evidence/10-control-nonvacuity-exit-codes.txt |
| A lying target (status 0 with a plausible but unverifiable receipt) makes both drivers exit 1 | captured | evidence/11-receipt-validation-lying-target.txt |
Not claimed: code execution (gRPC offers no shell primitive for this class), versions other than the two pins above, and any real deployment's authentication layer.
poc/
go_stock_client/ # primary driver: a stock grpc-go client (Go)
exploit_opt.py # raw HTTP/2 driver, compact (python-h2)
exploit_readable.py # raw HTTP/2 driver, staged and annotated (python-h2)
tests/ # fake gRPC target + post-condition test runner
lab/
build.sh # clones grpc-go v1.79.2 / v1.79.3, builds both twins
compose.yml # vulnerable / patched / config-escape-hatch / control
runtime.Dockerfile
server-src/main.go # the twin server (grpc/authz policy + 2 services)
server-assets/ # policies, seed roster, entrypoint
harness/
matrix.sh # four-leg matrix
reliability.sh # N-run loop, fresh lab per run
verify-exitcodes.sh # control non-vacuity + exit-code table
evidence/ # captured transcripts (path-scrubbed, see below)
Every command below targets 127.0.0.1 containers built from this repo. Do not
point any of this at a system you do not own or have written authorization to
test.
python3 -m venv .venv && .venv/bin/pip install h2 # for the python drivers
cd lab && ./build.sh # clones the two grpc-go tags
docker compose build
docker compose up -d --force-recreate
Four loopback-only services:
| port | role | build |
|---|---|---|
| 19130 | vulnerable | grpc-go v1.79.2 |
| 19131 | patched | grpc-go v1.79.3 |
| 19132 | config escape hatch | v1.79.3 + GRPC_GO_EXPERIMENTAL_DISABLE_STRICT_PATH_CHECKING=true |
| 19133 | control | v1.79.2 with an allow-all policy (no deny rule) |
No raw frames, no HTTP/2 library -- a normal grpc.NewClient + cc.Invoke, with
the method string missing its leading slash:
(cd poc/go_stock_client && go build -o stockclient .)
# canonical method -> the deny rule fires
poc/go_stock_client/stockclient 127.0.0.1:19130 /admin.v1.Admin/DeleteUser b11-victim-1
# INVOKE_ERROR: rpc error: code = PermissionDenied desc = unauthorized RPC request rejected
# slash-less method -> the denied RPC executes
poc/go_stock_client/stockclient 127.0.0.1:19130 admin.v1.Admin/DeleteUser b11-victim-2
# INVOKE_OK: {"by_method":"admin.v1.Admin/DeleteUser","deleted_user":"b11-victim-2",...}
# against the patched twin the same call is refused before authorization runs
poc/go_stock_client/stockclient 127.0.0.1:19131 admin.v1.Admin/DeleteUser b11-victim-2
# the Unimplemented behavior below is DERIVED from the captured server-side
# transcripts (evidence 05 and 07 show grpc-status 12 + the core reject line
# for the same call shape); the transcript ships the server's rejection, not
# this wrapper's wording:
# INVOKE_ERROR: rpc error: code = Unimplemented desc = malformed method name: ...
The python drivers build the HEADERS frame themselves, which is how the
malformed :path can be inspected and how the control leg (canonical path
denied) is exercised in the same run: