authz-matrix
Skill1 starsChanged 2 days agoMITView on GitHub
Systematic multi-identity authorization matrix: replay every captured request under each provisioned identity (A, B, higher-privilege, and anonymous) and diff the responses to surface broken access control at scale, instead of spot-checking one endpoint at a time. Use after a request corpus exists (crawl/HAR/proxy history) and at least two identities are provisioned — this is the breadth sweep that feeds idor and broken-access-control. Keywords: authorization matrix, autorize, multi-identity diff, horizontal access, vertical access, BOLA sweep, access-control coverage, response diffing, identity replay, anonymous reachability. Do NOT use to prove a single IDOR in depth — use idor for the focused two-account proof. Do NOT use for authentication/session forgery — use auth-bypass.
In this repository134 other files it gives its agents.
- CLAUDE.mdCLAUDE.md
- ai-agent-reconSkill
- ai-supply-chainSkill
- exfiltration-via-aiSkill
- indirect-injectionSkill
- llm-fuzzingSkill
- prompt-injectionSkill
- rag-poisoningSkill
- tool-abuseSkill
- chain-analysisSkill
- chain-auth-to-takeoverSkill
- chain-customSkill
- chain-graph-walkSkill
- chain-idor-to-mass-dataSkill
- chain-info-to-exploitSkill
- chain-multi-appSkill
- chain-ssrf-to-cloudSkill
- chain-web-to-rceSkill
- chain-xss-to-account-takeoverSkill
- artifact-cleanupSkill
- credential-hygieneSkill
- data-retentionSkill
- email-securitySkill
- engagement-flowSkill
- evidence-sealSkill
- finding-disciplineSkill
- http-headers-securitySkill
- oob-interactionsSkill
- opsec-disciplineSkill
- research-firstSkill
- scope-disciplineSkill
- scope-importSkill
- session-contextSkill
- security-policy-parserSkill
- 2fa-bypassSkill
- api-abuseSkill
- auth-bypassSkill
- broken-access-controlSkill
- business-logicSkill
- cache-poisoningSkill
- clickjackingSkill
- corsSkill
- credential-testingSkill
- crlf-injectionSkill
- cryptographic-oracleSkill
- csrfSkill
- css-injectionSkill
- data-exfiltration-testSkill
- deserializationSkill
- email-injectionSkill
- file-uploadSkill
- fuzzingSkill
- graphqlSkill
- grpcSkill
- host-headerSkill
- http-smugglingSkill
- idorSkill
- info-disclosureSkill
- jwtSkill
- lateral-movementSkill
- The first 60 shown.
The file
We split this skill into the rules it gives an agent
2 rules. About 0 are common, 2 are distinctive, and 0 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈2
Distinctive · estimate
This author's own choices. Worth a look.
0
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 78
Write-method cells (gated): Only after operator sign-off, replay a minimal set of mutating requests under a non-owning identity against a …
- Distinctive: line 127
Before declaring this finding complete, probe these escalation paths:
≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Signals
- A sizeable request corpus exists (proxy history, HAR, crawl, OpenAPI/GraphQL schema) and more than one identity is provisioned for the engagement — the preconditions for a sweep rather than a one-off IDOR test.
- Multi-tenant / multi-role application where the same endpoints are reachable by many roles and the question is which endpoint × identity cells leak, not whether one specific ID leaks.
- An API surface large enough that manual per-endpoint authorization testing would miss cells — the matrix is about coverage, not depth.
Prerequisites
- At least two low-privilege identities (A, B) with their own data, ideally one higher-privilege
identity, plus the anonymous (no-credential) identity — all provisioned for this engagement.
engine/sessions.pytracks these as parallel identities; the minimum pair is mandatory. - A captured request corpus to replay. Each request should be attributable to the identity that legitimately produced it (so the matrix knows the "owner" baseline per cell).
- Agreement on which HTTP methods may be replayed ungated: GET/HEAD/OPTIONS are read-only and may be swept freely; PUT/POST/PATCH/DELETE mutate state and need an operator gate before replay.
Methodology
- Build the request corpus and identity set. Collect each distinct request (method + path +
relevant params) once. Define the identity set:
A,B,highpriv(optional),anon. Capture each identity's auth material (cookie jar / bearer token) into its own store. - Normalize before diffing. Strip or template volatile fields so equal-authorization responses compare equal: CSRF tokens, timestamps, request IDs, nonces, per-request ETags, and the identity's own name/email where echoed. Record the normalization rules used — an un-normalized diff produces false "differences" and hides real ones.
- Replay the matrix (read methods first). For every request R legitimately made by its owner,
re-issue R under each other identity and under
anon, keeping method/path/body identical and only swapping the auth material:# R = GET /api/orders/1042, owned by A for id in A B highpriv anon; do code=$(curl -s -o "resp_$id.json" -w "%{http_code}" \ ${COOKIE[$id]:+-b "${COOKIE[$id]}"} "https://target/api/orders/1042") echo "$id -> $code" done - Classify each cell against the owner baseline, not just by status code:
200 + owner's real data under a non-owner identity→ broken access control (leak).200 + empty/placeholder→ inconclusive; needs a data-bearing baseline to judge.200 + the caller's own data→ correct (per-identity scoping working).401/403/404→ control working (or masking — note 404-as-403 obfuscation).- size/shape diff vs. owner baseline → candidate; escalate to
idorfor focused proof.
- Anonymous row is its own priority. Any request that returns owner data with no credential
is the highest-severity cell — sweep the
anonidentity across the whole corpus first. - Write-method cells (gated). Only after operator sign-off, replay a minimal set of mutating requests under a non-owning identity against a disposable test object, then verify the mutation landed via a privileged read. Never sweep destructive methods across the whole corpus.
- Automate with Burp Autorize for large corpora: configure the low-priv session as the
"replay" identity and let it diff every proxied high-priv request, flagging
Bypassed!/Is enforced?per request — but still hand-confirm flagged cells with the normalization rules from step 2 before reporting.
Tooling
- Burp Suite + Autorize — the standard engine for the two-session replay-and-diff sweep.
curlwith per-identity cookie jars / token env vars — scriptable matrix for APIs.engine/sessions.py(record_diff()) — records per-identity response diffs with the interpretation table; use it to keep the matrix auditable.- A small diff harness (python
difflib/ JSON structural diff) for normalized body comparison.
Root Causes
- Authorization enforced per-UI or per-route but not per-object/per-tenant at the data layer.
- "Is authenticated" middleware mistaken for "is authorized for this object/action."
- Some endpoints in a family hardened (detail view) while siblings (export, list, bulk, GraphQL field) share no common guard.
Validation Gate (minimum proof)
- A specific cell (request × identity) where a non-owning or anonymous identity received the owner's genuine data or executed a privileged action, with request + normalized response + owner baseline captured for that one cell.
- A coverage statement: which requests were swept under which identities, and which cells were skipped and why (e.g., mutating methods left ungated).
- Each confirmed leak promoted to an
idor/broken-access-controlfinding with its own focused proof — the matrix locates, the dedicated skill proves.
Gotchas
- Normalization is the whole game. Most false positives are volatile fields; most false negatives are over-aggressive normalization that erases the leaked field. Record the rules.
- Coverage, not exfiltration. The matrix flags cells; it does not loop the ID space pulling
records — that bulk step is gated and belongs to
idor/pii handling. - Common N/A: differing responses that are both the caller's own correctly-scoped data are not a finding — the diff must show cross-owner leakage.
- Overclaim trap: a
200size-diff alone is a candidate, not a confirmed leak; confirm the content is another identity's real data before reporting. - 404-as-403: an app that returns 404 for unauthorized objects can hide a leak that only shows up on a valid cross-owner ID — pair the sweep with known cross-owner IDs, not random ones.
Chain Anchors
Before declaring this finding complete, probe these escalation paths:
- Anonymous reach — Does any cell leak to the no-credential identity (worst case)?
- Write cells — Do mutating methods leak under a non-owning identity, not just reads?
- Family consistency — Do list/detail/export/delete siblings of a leaking endpoint share the same gap, or only the one cell found?
- Privilege direction — Does a low-priv identity reach high-priv actions (vertical), owner data of peers (horizontal), or both?
- Blast radius — From the leaking cells, roughly how much of the object/tenant space is exposed?
A finding without chain anchor results is INCOMPLETE. Record each anchor as tested/not-applicable/blocked with the reason.
Chains & Compositions
- authz-matrix → idor for each horizontal leak's focused two-account proof.
- authz-matrix → broken-access-control for vertical/privileged-action cells.
- authz-matrix → mass-assignment when a body field flips ownership in a leaking write cell.
- authz-matrix → api-abuse when GraphQL/batch endpoints expose per-resolver authz gaps.
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

