More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    appsec review

    1

    Threat-model-driven security reviews: full attack surface coverage, every finding verified by an independent agent and scored with CVSS 4.0.

    Free

    8 uses5.0 (1 review)
    appsec review

    appsec review

    Example session with this skill installed

    /appsec-review # current branch vs. its base, plus uncommitted changes
    /appsec-review whole repo # the whole repository
    /appsec-review deep # in-depth review for high-stakes code

    • Read your context and instructions
    • Compiled the appsec review
    • Generated the document

    Example run of /appsec-review deep on acme-shop, the fictional online shop used for the public
    sample report. Every name, path and finding
    is invented to show the output format.

    Summary

    A deep review of the acme-shop Node.js/Express API and its React storefront on branch main, ahead of a release
    that opens guest checkout. 8 root causes in 10 locations: 1 critical, 2 bugs, 2 warnings and 3 suggestions,
    with 2 candidates rejected by verification. Two issues block the release: admin tokens are accepted without a
    signature check, and the payment webhook trusts any caller. SQL access, password hashing, session cookies and file
    uploads were checked and found secure.

    Findings

    Backend

    [Security] Admin token signature not verified (A07:2025, API2:2023, CWE-347) · critical
    api/src/middleware/auth.js:12-19

    • Attack: with no account, send GET /api/admin/customers with a hand-made token whose payload is
      {"sub":"1","role":"admin"} and any signature. requireAdmin reads it with jwt.decode and trusts the role.
    • Impact: full admin access without credentials: every customer, order, product and refund.
    • Fix: use jwt.verify(token, config.jwtSecret, { algorithms: ['HS256'] }), as requireUser already does in
      the same file, and add a test that a token signed with another key gets 401.
    • CVSS 4.0: 9.3 Critical · verified by an independent verifier

    [Security] Payment webhook accepts unsigned callbacks (A08:2025, API6:2023, CWE-345) · bug
    api/src/routes/webhooks.js:18-31

    • Attack: place an order, stop at the payment page, then POST /api/webhooks/payment with
      {"orderId":"<own order>","status":"succeeded"}. The order moves to paid and ships.
    • Impact: goods shipped without payment, for any order the attacker can create.
    • Fix: verify the Payment-Signature header with the provider SDK's constructEvent before reading the body,
      and re-fetch the payment from the provider by id before changing the order.
    • CVSS 4.0: 8.7 High · verified by an independent verifier

    [Security] Order details readable by any customer (A01:2025, API1:2023, CWE-639) · bug
    api/src/routes/orders.js:42-51

    • Attack: sign up as an ordinary customer and request GET /api/orders/1, /2, /3 and so on.
    • Impact: every customer's order history, name, delivery address and phone number.
    • Fix: load through orders.findForCustomer(id, req.user.id), the helper the order list already uses, and
      return 404 when nothing comes back.
    • CVSS 4.0: 7.1 High

    [Security] Stack traces returned in error responses (A10:2025, CWE-209) · warning
    api/src/app.js:88-92

    • Fix: return { error: 'internal_error', requestId } and log the stack server side under the same id.
    • CVSS 4.0: 6.9 Medium

    [Security] Single-use coupon redeemable twice in a race (A06:2025, API6:2023, CWE-362) · suggestion · needs confirmation
    api/src/services/coupons.js:21-33

    • Attack: fire two checkouts with the same coupon at once; both read used_at IS NULL before either writes.
    • Confirm: the production isolation level (SHOW default_transaction_isolation;). Under serializable the
      second redemption fails.
    • Fix: redeem with one conditional UPDATE ... WHERE code = $1 AND used_at IS NULL RETURNING id.
    • CVSS 4.0: 2.3 Low

    Web frontend

    [Security] Stored XSS in product reviews (A05:2025, CWE-79) · warning
    web/src/components/ReviewList.jsx:27-33

    • Attack: post a review containing <img src=x onerror=...>; it runs in every shopper's session that opens the
      product page.
    • Fix: render the text as a React child with CSS white-space: pre-line instead of dangerouslySetInnerHTML.
    • CVSS 4.0: 6.2 Medium

    [Security] Refresh token kept in localStorage (A07:2025, CWE-922) · suggestion
    web/src/api/client.js:9-14

    • Fix: have the API set it as an HttpOnly, Secure, SameSite=Strict cookie scoped to /api/auth/refresh.

    [Security] No Content Security Policy (A02:2025, CWE-1021) · suggestion
    web/index.html:1-12

    • Fix: send a default-src 'self' policy from the static host, in report-only mode first.

    Checked and found clean

    • Every SQL query uses pg parameters, including dynamic sorting through an allow-list (api/src/db/products.js:22).
    • Passwords hashed with Argon2id and compared in constant time (api/src/services/users.js:40).
    • requireUser verifies signature, expiry and algorithm (api/src/middleware/auth.js:4-10).
    • Uploads checked by content type and size and stored outside the web root (api/src/routes/uploads.js:15).
    • No secrets in the built frontend bundle.

    Coverage: 64 ledger units, 61 covered, 3 out of scope (generated API client, Storybook stories, seed scripts).
    Abuse paths: 4 realised, 1 blocked (SQL injection through product search, by the parameterised query at
    api/src/db/products.js:22), 1 blocked on an outside fact (database isolation level).

    Rejected by verification

    • SQL injection in product search, api/src/routes/products.js:15. The search term is passed as a query
      parameter, never concatenated (api/src/db/products.js:22).
    • Open redirect after login, web/src/screens/Login.jsx:48. The next value is checked against an allow-list
      of in-app paths (web/src/lib/redirect.js:6).

    You can overrule a rejection you disagree with. One rejection was already reviewed and overruled: the refresh
    token finding above.

    Run summary

    Run summary
    - Mode: deep
    - Time: 38m 12s
    - Tokens: 1,284,500 (main session and subagents; exact usage: /cost or /usage)
    - Subagents: 2 hunters (wildcard and obvious-things, sink trace), 1 verifier per serious candidate, 1 rejection reviewer
    - Findings: 8 root causes: 1 critical ; 2 bug ; 2 warning ; 3 suggestion ; 1 needs confirmation ; 2 rejected by verification
    - Findings by layer: backend 5 ; web-frontend 3
    - This run consumed much more time and tokens than standard would. For routine reviews use standard.
    

    Report

    Report
    - HTML: C:\Users\<you>\.appsec-review\acme-shop\report.html
    - Markdown: C:\Users\<you>\.appsec-review\acme-shop\report.md
    - Artifact: https://claude.ai/artifact/<id> (private)
    

    The HTML report adds an executive summary, risk profile, threat model, security controls checklist, CVSS 4.0
    vectors, references to OWASP, ASVS, CWE and PCI DSS, a remediation plan and an appendix:
    see the full sample.

    Next steps

    1. Fix before release: the admin token check and the payment webhook signature. Reply "fix 1 and 2" and the
      agent applies the fixes with negative tests that prove the attack now fails.
    2. Confirm the database isolation level to settle the coupon race.
    3. Schedule the order IDOR and the stored XSS for the next sprint.
    4. Gate CI: ledger.py ... --fail-on critical blocks future merges with a critical finding, and --sarif
      sends findings to GitHub code scanning.

    sample-report.html

    PDF · document

    Generated

    Example file from a real run - the skill writes it into your workspace.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Most security bugs that reach production aren't the kind a linter catches: a missing ownership check, a payment callback that trusts the client, a race between two requests. This skill runs a threat-model-driven, pentest-style security review inside Claude Code. It maps the full attack surface with a script, works through realistic attack paths, and has an independent agent try to disprove every finding before it reaches you. Each verified finding comes with file:line, the exploit path, a fix using your own code's helpers, and a CVSS 4.0 score computed by script, never estimated.

    What it does

    • Scripted attack surface inventory lists every route, handler, resolver, consumer, screen, deep link, CI pipeline and dangerous sink. A coverage ledger fails the run if any of them was skipped, so each run covers the same ground.
    • Threat model and STRIDE: trust boundaries, data classes and attacker goals, then abuse paths worked step by step either to the goal or to the line of code that stops them.
    • Independent verification: a fresh verifier agent that never saw the finder's reasoning tries to refute each candidate. A rejection must cite the line that stops the attack, and rejected candidates are listed so you can overrule them.
    • Chained exploits: verified findings are combined into worse end-to-end attacks, and each step of the chain is verified too.
    • Deep business-logic coverage: IDOR/BOLA, mass assignment, multi-tenancy, payment callbacks, idempotency, race conditions, JWT/OAuth/SAML/passkeys, SSRF, request smuggling, cache poisoning, and AI agent tool authorization.
    • Library-aware: reads the source of the exact dependency version in your lock file instead of guessing what a library does.
    • Audit-ready output: a private HTML report (executive summary, threat model, remediation plan) plus a Markdown copy you can hand to another session to fix findings. Every finding is mapped to OWASP Top 10:2025, API Top 10, ASVS 5.0, MASVS, CWE and PCI DSS.

    How it works

    1. Invoke /appsec-review on a branch, PR, file, endpoint, the whole repository, or every repository in a folder.
    2. Map: it detects your stack, builds the scripted inventory, and writes the threat model and abuse paths.
    3. Assess: it follows each input forward from its entry point to its sinks, while hunter agents look for what the main pass missed. In deep mode a sink tracer also works backward from every dangerous call.
    4. Verify: every candidate goes through a disproof pass and independent verifiers. Serious rejections get a second look.
    5. Report: you get findings ordered by severity, the facts that still need confirming, what was checked and found clean, a coverage summary, and the HTML and Markdown reports.

    Three modes: diff (default, fast, for branches and PRs), standard (whole repositories) and deep (high-stakes code, more agents and an entry point × category ledger).

    Frameworks & tools

    • Back ends: Spring Boot, Node.js (NestJS, Express, Fastify, Next.js server code), Python (Django, FastAPI, Flask), PHP (Laravel, Symfony, WordPress), ASP.NET Core and Go.
    • Front ends: React, Next.js, Angular, Vue, Nuxt, Svelte, Solid and Astro.
    • Mobile: React Native, Expo, Flutter, and native Android and iOS.
    • Backend as a service: Supabase and Firebase.
    • Infrastructure: GitHub Actions, GitLab CI, Jenkins, Docker, Kubernetes, Helm and Terraform.

    It runs gitleaks, trivy, semgrep, your ecosystem's audit tool, zizmor, actionlint, checkov and hadolint when they are installed, and never installs anything itself.

    Why this beats prompting it yourself

    A plain "find vulnerabilities" prompt reads whatever catches its eye, reports guesses as facts, and finds different things each run. This skill starts every run from a scripted inventory, tracks coverage in a ledger that is checked against it, requires each finding to survive an agent whose only job is to disprove it, and scores severity with a CVSS 4.0 calculator instead of an opinion. You also see why each rejected candidate was rejected.

    Use cases

    • PR review before merge, focused on what the change added or removed, including deleted security controls.
    • CI gate: --fail-on <severity> blocks merges, accepted risks expire on a date, and SARIF export feeds GitHub code scanning or Jenkins.
    • Pre-audit and pentest prep: an audit-ready report mapped to OWASP, ASVS, PCI DSS and NIST SP 800-63B before an external assessment.
    • Platform-wide reviews across several microservices, with weaknesses they share reported once.
    • Mobile, BaaS and AI apps: deep links, WebViews, token storage, Supabase RLS, Firebase rules, and LLM agents with dangerous tool combinations.

    Requirements and limitations

    • Needs Claude Code and Python 3.10+ (helper scripts use only the standard library). Runs on Linux, macOS and Windows, interactively or headless in CI.
    • Runs only when you invoke it; it is never an automatic background check.
    • It reads code and doesn't execute it. A finding that depends on a fact outside the repository (proxy config, IdP policy) is reported as "needs confirmation" with the exact fact to check.
    • Stacks outside the list get the general checks only, without a scripted inventory, and the report says so.
    • deep mode takes several times longer and uses much more tokens than standard.
    • Reports describe how to exploit open issues. They are stored outside your repository in ~/.appsec-review/ and published privately.

    GitHub: https://github.com/ibrahimabdallatif/appsec-review

    Manual trigger only. Deep mode is token-intensive. Accuracy depends on the presence of stack manifests. Tool integration requires pre-installed binaries.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    5.0
    1 review
    5
    1
    4
    0
    3
    0
    2
    0
    1
    0

    This skill has been used 8 times.

    Trust & safety

    Security scan

    Security scan passed 27 days ago

    • Free with an Agensi account

    Requires

    Node.js
    Git
    Python 3.10+

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Network Access
    Environment Variables
    Browser
    Listed27 days ago
    Updated13 days ago

    What's inside

    Frequently Asked Questions

    Unlike standard linters, this skill uses specialized subagents to analyze business logic (like IDOR and BOLA) and runs a 'disproof pass' to verify findings, significantly reducing the false positives common in generic AI prompts.

    The skill supports a wide array of stacks including Node.js, Python, Go, and .NET, along with mobile frameworks like React Native, Flutter, and native iOS/Android codebases.

    Each finding includes a CVSS 4.0 score, detailed evidence of the vulnerability, and mappings to industry standards like the OWASP Top 10 and PCI DSS for compliance tracking.

    Once added to your AI agent environment, simply use the `/appsec-review` command to target a specific pull request, file, or your entire repository to begin the analysis.

    The skill can integrate with and ingest data from local tools like Gitleaks, Trivy, and Semgrep if they are already installed, providing a unified security report within your workflow.

    New in Security