Works with the AI Agents you already use
Backend Security Auditor Pro - Find real security flaws
Deep backend and API security audits with evidence-based findings, risk prioritization, and actionable fixes.
$14.99
Backend Security Auditor Pro - Find real security flaws
Example session with this skill installed
Use Backend Security Auditor Pro to perform a Standard security audit of this backend repository.
Review authentication, authorization, multi-tenant isolation, API endpoints, database operations, injection risks, SSRF, and business logic vulnerabilities.
Trace requests through routes, middleware, services, and persistence layers. Identify where security controls are missing, ineffective, or incorrectly applied.
For each finding, provide file-and-line evidence, severity, evidence status, realistic attack preconditions, recommended remediation, and regression-test suggestions.
Prioritize exploitable security weaknesses over generic best-practice warnings.
Separate confirmed source-level findings from issues requiring additional verification.
Perform a read-only static analysis. Do not modify code or send live network requests.
- Read your context and instructions
- Compiled the backend security auditor
Backend Security Audit Report
Mode: Standard
Scope: Backend API sample
Method: Static source review only
Runtime testing: Not performed
Executive Summary
| Category | Result |
|---|---|
| High severity | 1 |
| Medium severity | 0 |
| Confirmed source-level findings | 1 |
| Additional verification required | 1 |
The review identified an object-level authorization weakness that could permit cross-tenant data modification. A separate server-side URL-fetching path also requires verification of network restrictions.
Finding BSA-001 — Broken Object-Level Authorization
Severity: High
Evidence status: Confirmed in source code; not runtime-tested
Category: BOLA / IDOR / Multi-tenant isolation
Location: src/routes/invoices.ts:12–20 (illustrative path)
Evidence:
const invoice = await db.invoice.findUnique({
where: { id: req.params.invoiceId }
});
const updated = await db.invoice.update({
where: { id: req.params.invoiceId },
data: { ...req.body }
});
Security analysis:
The endpoint authenticates users but retrieves and updates invoices using a client-provided identifier without an observable ownership or tenant authorization check.
Authentication alone does not establish permission to modify a particular resource.
The update also spreads the request body into the database operation, potentially allowing unauthorized modification of protected fields.
Potential impact:
An authenticated user who knows another tenant's invoice identifier could modify that invoice if no additional controls apply.
Recommended remediation:
Enforce resource-level authorization and tenant scoping during database operations. Explicitly allowlist editable fields rather than spreading arbitrary request data.
Regression tests:
- Tenant A can modify an authorized invoice.
- Tenant B cannot modify Tenant A's invoice.
- Unauthorized updates leave database records unchanged.
- Attempts to overwrite server-controlled fields are rejected.
Additional Verification — Potential SSRF
Evidence status: Needs verification
An endpoint passes a client-controlled URL into a server-side fetch() call.
Verify whether outbound network restrictions, address validation, redirect policies, or other controls prevent access to internal services before classifying runtime exploitability.
Recommended Next Steps
- Correct object-level authorization enforcement.
- Add cross-tenant negative tests.
- Restrict writable resource properties.
- Review related service and worker authorization paths.
- Verify outbound network protections in an authorized environment.
Deliverables: Prioritized findings, file-and-line evidence, realistic attack conditions, remediation guidance, regression tests, and structured Markdown/JSON reporting.
The report distinguishes source-level evidence from deployment assumptions and unverified attack paths.
Connects securely to your tools. The creator never sees your data.
About this skill
Find the backend vulnerabilities that simple code scanners often miss.
Backend Security Auditor Pro transforms your AI coding agent into an evidence-driven backend and API security reviewer, capable of analyzing authentication, authorization, data access, trust boundaries, and complex application logic.
Rather than merely searching for dangerous functions, it follows requests through routes, middleware, services, databases, background workers, and external integrations to identify realistic security failures.
What it covers:
- Broken authentication, JWT validation, and session management
- Broken object-level authorization (BOLA/IDOR) and function-level authorization
- Multi-tenant isolation and cross-tenant data access
- SQL/NoSQL injection, command injection, and unsafe deserialization
- Server-side request forgery (SSRF) and outbound integrations
- REST, GraphQL, gRPC, and WebSocket security
- Webhook verification, message queues, and background workers
- Business logic abuse, race conditions, and privilege escalation
- File uploads, secrets, encryption, dependencies, and runtime configuration
Choose your audit depth:
- Quick: Focus on high-risk endpoints, sensitive operations, and obvious security weaknesses.
- Standard: Systematic analysis of request flows, authorization controls, dangerous data flows, and backend configuration.
- Deep: Extended cross-module analysis covering complex attack chains, business logic, background processing, and regression-test design.
What you receive:
A prioritized security audit report documenting affected files and lines, severity, evidence status, security impact, attack preconditions, recommended fixes, and regression-test suggestions.
The skill includes structured Markdown/JSON reporting, backend-specific security playbooks, and an optional local source-discovery utility.
Designed for common backend ecosystems, including Node.js/TypeScript, Python, Go, Java/Kotlin, .NET, PHP, Ruby, and Rust.
Safe by default: Source-code review is read-only. No live endpoints are probed, dependencies installed, or project files modified without explicit authorization.
Ideal for API developers, engineering teams, security reviewers, SaaS builders, and teams working with AI-generated backend code.
Go beyond syntax. Find broken trust boundaries, missing authorization, and vulnerabilities that matter.
- Static analysis by default: Does not automatically execute applications, exploit vulnerabilities, or perform live penetration testing.
- No guarantee of complete detection: Some vulnerabilities depend on runtime behavior, infrastructure, business context, or deployment configuration unavailable in source code.
- Evidence-dependent findings: Potential risks without sufficient supporting evidence are reported separately as issues requiring verification.
- Dependency vulnerability checks: Identifying known vulnerable package versions may require current advisory data or additional tooling.
- Optional Python utility: The bundled discovery script requires Python 3.9+ and performs pattern discovery, not conclusive vulnerability verification.
- Not a compliance certification: Does not replace professional penetration testing, security assessments, or formal OWASP ASVS verification.
- Agent-dependent results: Audit depth and accuracy depend on the underlying AI model, repository access, and available context.
How to use
- 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
Sign in to Agensi
Your agent shows a sign-in link. Sign in and click Allow.
- 3
Ask for what you need
Your agent loads this skill and uses it on your task. It always asks before any payment.
Reviews
No reviews yet
Be one of the first to try it. Every listed skill goes through the trust checks below.
Security scanned
Checked by our 8-point scan before listing
Fresh listing
Recently published to Agensi
Money-back guarantee
Doesn't do what its page promises? You get your money back.
Trust & safety
Security scan
Security scan passed 27 days ago
Requires
Permissions
File Scopes
This skill performs read-only security analysis of repositories explicitly authorized by the user. It requires file-reading access to inspect backend source code, configuration, dependencies, and request flows. Terminal access is optional for running the bundled Python discovery script, which does not execute application code or contact external services. No credentials, API keys, connected accounts, or production access are required. The skill does not modify source code, install dependencies, run live penetration tests, or transmit repository data by default. Any additional testing, file writing, or network access requires explicit user authorization. Sensitive information encountered during auditing must be redacted from reports.