Auth Review

Static security review for authentication and authorization vulnerabilities — enumerates routes, builds an authorization matrix, and…

You say
Buy it · $49 Read it before you buy $49 Written by descope · unverified publisher
Context cost
9.5k tokensestimated from the bundle, loaded when it triggers
Bundle
5 files · 37.9 kBtext throughout, nothing executable
Licence
MITpaid listing
Last change
no release on file
Servers it uses
Noneruns standalone

What it does

Static security review for authentication and authorization vulnerabilities. Use when the user invokes /auth-review, asks to audit auth, find identity breaches, review access control, hunt for IDOR/BOLA, or check authorization. Framework- and vendor-agnostic. Enumerates every route/endpoint, builds an authorization matrix, applies a vulnerability catalog, and writes a triage report ready to turn into issues or PRs.

Installed, it changes the agent in these ways.

What this skill changes about the agent is not written down here yet. The listing was collected from its source, and the description is in its own SKILL.md.

Guardrail

Constrains what the agent is allowed to do.

auditauthorizationidorsecurity

The skill itself

This is the whole product. A skill is instructions the model reads, so there is nothing behind the listing you cannot see first — the front matter loads with every session, and the body below it loads when the skill triggers.

SKILL.md5.1 kB · 84 lines
--- name: auth-review description: Static security review for authentication and authorization vulnerabilities. Use when the user invokes /auth-review, asks to audit auth, find identity breaches, review access control, hunt for IDOR/BOLA, or check authorization. Framework- and vendor-agnostic. Enumerates every route/endpoint, builds an authorization matrix, applies a vulnerability catalog, and writes a triage report ready to turn into issues or PRs. ---
6# Auth Review
7
8Perform a **static, read-only** security review of authentication and authorization in the current codebase. Framework- and vendor-agnostic. Output: a triage report in ./auth-review/ with findings ready to file as issues or PRs.
9
10## When to Use
11
12- User invokes /auth-review.
13- Requests like "audit auth", "find authz bugs", "review access control", "check for IDOR", "identity security review".
14- Pre-release hardening or post-incident forensic code review focused on identity.
15
16## Workflow
17
18Run these phases **in order**. Do not skip ahead.
19
20### Phase 1 — Enumerate every entrypoint
21
22Identify every code path reachable by an external or semi-trusted caller. See references/enumeration.md for exhaustive patterns. A single repo often mixes HTTP, GraphQL, WebSocket, queue consumers, serverless handlers, and admin CLIs — list them all.
23
24**Deliverable:** an **Endpoint Inventory** table: method, path / trigger, handler (file:line), auth required? (y/n/unknown), roles or scopes, notes.
25
26Reconcile against router files, OpenAPI specs, and GraphQL schemas before moving on.
27
28### Phase 2 — Build the authorization matrix
29
30For each endpoint answer: *who should reach this, and what does the code actually enforce?* Use references/authz-matrix.md to infer the expected principal from conventions and classify gaps.
31
32**Deliverable:** an **Authorization Matrix** table: endpoint, expected principal, enforced check (file:line), gap.
33
34### Phase 3 — Apply the vulnerability catalog
35
36Walk references/vulnerability-catalog.md category by category. For each, run the detection heuristics, then **read** the matched files to confirm. Never flag from a grep hit alone.
37
38Before calling a check missing, confirm no upstream middleware, decorator, guard, filter, interceptor, framework default, or reverse proxy enforces it. Trace at least one concrete caller path end-to-end for each finding. If a check is conditional, record the condition and whether an attacker controls it.
39
40### Phase 4 — Write the report
41
42Create ./auth-review/ if absent. Write to ./auth-review/report-YYYY-MM-DD.md (append -HHMM if one already exists for today). Use the structure in references/report-template.md.
43
44The report must include:
45
461. Executive summary with counts by severity.
472. Endpoint inventory (Phase 1).
483. Authorization matrix (Phase 2).
494. Findings — each with title, severity, CWE, file:line, evidence, exploit reasoning, remediation.
505. "Issues to file" — findings pre-formatted as ready-to-paste issue bodies.
516. Open questions the maintainer must answer.
52
53After writing, summarize severity counts to the user and point at the file path. Do not create issues or PRs.
54
55## Severity Scale
56
57| Level | Meaning |
58|--------|---------|
59| High | Exploitable by unauthenticated or low-privilege attacker; leads to account takeover, data breach, privilege escalation, or tenant crossing. |
60| Medium | Requires specific conditions, partial impact, or defense-in-depth failure. |
61| Low | Hardening recommendation; minor information disclosure; missing best practice. |
62
63Always include a CWE ID (e.g., CWE-287, CWE-639, CWE-862, CWE-863). Use identifiers from references/vulnerability-catalog.md — do not invent IDs.
64
65## DO NOT
66
67- DO NOT modify source code. This skill is read-only.
68- DO NOT execute the application, run network probes, or make outbound requests.
69- DO NOT report a finding without a file.ext:line reference and evidence snippet.
70- DO NOT flag a missing check before confirming no upstream middleware, guard, decorator, or proxy enforces it.
71- DO NOT invent CWE IDs, CVSS scores, or framework behaviors — if unsure, mark the finding "unconfirmed" and move it to Open Questions.
72- DO NOT include secrets, tokens, private keys, or real user data in the report. Redact as [REDACTED].
73- DO NOT commit the report to git unless the user asks.
74- DO NOT create GitHub issues or PRs directly. Output issue-ready text and let the user file them.
75- DO NOT stop after finding one bug. Enumerate everything, then report.
76- DO NOT trust code comments or documentation over the code itself. A comment saying "admin only" is not a security control.
77
78## References
79
80- references/enumeration.md — entrypoint patterns across HTTP, GraphQL, WebSocket, RPC, serverless, and background stacks.
81- references/vulnerability-catalog.md — full taxonomy with detection heuristics, CWE IDs, and fixes.
82- references/authz-matrix.md — matrix schema and expected-principal inference rules.
83- references/report-template.md — exact report structure and issue-body format.
84
In the file
SKILL.md721 words
Files5
LicenceMIT
Why you can read it

Nothing in a skill executes. The client loads the text and the model follows it, so a skill can be audited the way a runbook is — by reading it.

What it costs in context

Skills are not billed by the call. They are paid for in context: every token the instructions occupy is a token your code, your diff and your conversation cannot use. Here is what this one takes and when it takes it.

≈110
always loaded
The name and description, so the model knows the skill exists and when to reach for it.
9,365
on trigger
The instruction body and 4 supporting files, read only when the skill fires.
4.7%
of a 200k window
Ten skills this size would take about 47% of the window before you open a file.
050k100k150k200k context window

9.5k tokens, estimated from the bundle at four bytes to the token, held for the rest of the session once it triggers. Heavy. Teams tend to install this one per project rather than globally, and load it only when the job comes up.

Servers bill, skills cost

A server charges by the month. A skill charges once per session, in context, and then keeps charging it for as long as the session lives.

Before and after

The same question, put to the same model twice: once as it comes, and once with these instructions loaded.

No worked example has been published for this skill yet.

Adoption
Installsnone yet
Ratingno reviews yet

The procedure it runs

The procedure has not been published here. It is in the skill’s own SKILL.md, which its author has not sent to the marketplace yet.

Prose, not code

These steps are written for a model to follow, not executed by a runtime. It can still be told to skip one, and it will say so when it does.

Servers it uses

None. This skill calls no MCP servers at all.

Everything it needs is in the instructions, so it works in a project with nothing connected — the model reads the file and changes how it works with what it can already reach.

It writes no files and reaches no network. All it changes is how the model reasons and writes.

What it asks for
Writes filesno
Network accessno

Read from the allowed-tools line of this skill’s own SKILL.md. A skill grants no permissions of its own — it can only ask for tools your client already has.

What it will not do

Every skill is narrow, and the useful ones say where they stop. These are the jobs this one is the wrong tool for.

What this skill is not for has not been published here. Nothing is implied by that: it is a section the author has not filled in.

What is in the bundle

5 files, 37.9 kB on disk. A bundle is text throughout: the instructions the model reads, plus the templates it fills in.

  • SKILL.md5.1 kB
  • references/authz-matrix.md5.5 kB
  • references/enumeration.md5.5 kB
  • references/report-template.md5.8 kB
  • references/vulnerability-catalog.md16.0 kB
What is not in it

No dependencies and nothing executable: a skill is text the agent reads, so the bundle is 5 files you can review in full before installing. The MIT licence covers the templates and examples as well as the instructions.

Install

Installing copies the bundle into your project. Nothing runs at install time — the files sit on disk until the model reads them.

$49 once
Auth Review · MIT · descope
one-time
Price$49 once
LicenceMIT — the author’s, unchanged by this purchase
Paid throughStripe, once, on the card you add at the checkout
Keeps workingfor good — the files are yours once they are on disk
Updatesevery update its author ships, delivered through this account

You can read the whole bundle before paying — the SKILL.md above is the product, not a preview of it. What the money buys is the delivery: the folder packaged and handed to your machine by key, every update its author ships, and our support if it does not do what this listing says. The terms of use are MIT, set by the author and unchanged by buying it here.

Payment runs through Stripe, on a page like this one rather than a redirect. Once there is an account it joins the same mcprush invoice as everything else you run, so there is never a second card to enter.

Which clients pick it up on their own

A skill is a folder of text. A client with a skills folder reads it without being told; everywhere else the same text works, it is just handed to the model rather than found.

Claude Code.claude/skills/
Claude Desktop
ChatGPT
Cursor.cursor/skills/
VS Code.github/skills/
Codex CLI.agents/skills/
Gemini CLI.gemini/skills/
Grok.grok/skills/
Zed.agents/skills/
Windsurf.windsurf/skills/
Agent SDK.claude/skills/
HTTP / API
This release
Versionnot versioned
Publishedno release date on file
Price$49
Referencedescope/auth-review

Versions

Its author publishes no version number, so there is nothing here to pin to: what you install is the folder as it stands today. Instructions change more often than APIs do — a skill can be rewritten entirely without anything it depends on moving.

v
  • No earlier releases have been published to the marketplace.
Pinning

Nothing to pin to: this skill carries no version number of its own. What you install is what the folder holds on the day you install it.

Reviews

no reviews yet · no installs yet

Nobody has reviewed this skill yet. The rating is the mean of the reviews written here, so there is none until somebody writes the first.

Who can post

Only accounts that have had the skill installed for fourteen days, so a review is written after living with it rather than after reading it. Publishers may reply once.

Publisher
Servers0