Menu
>-
The review-first prompt is selected by default. You can switch to a direct command or download a local copy.
Read SKILL.md and any companion files shown by SkillsMP before deciding whether to install.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
A direct command skips the review prompt. Inspect the source before running it.
npx skills add https://github.com/CleanExpo/NodeJS-Starter-V1 --skill input-sanitisationThe command stays on one line. Scroll horizontally to inspect it before copying.
Prefer a local copy? Download the files currently available to SkillsMP.
Showing SKILL.md
Route complex requests to the right specialist agent or chain of agents. This skill acts as the central brain of an agent swarm โ it analyses what the user needs, determines which specialist domain(s) are required, and coordinates parallel or sequential agent execution. Use this skill when a request spans multiple domains (e.g., "research competitors and create a pitch deck"), when you need to decide which specialist should handle an ambiguous request, or when a task requires a multi-step pipeline across different skills. Triggers on: multi-step requests, cross-domain tasks, "coordinate", "plan this out", "I need help with multiple things", or any complex request that touches more than one specialist area. Also triggers when the user seems unsure which tool or approach to use.
>-
Hybrid DAG execution primitive combining deterministic and agentic nodes with hard iteration caps
Based on SOC occupation classification
| id | input-sanitisation |
| name | input-sanitisation |
| type | skill |
| version | 1.0.0 |
| created | 20/03/2026 |
| modified | 20/03/2026 |
| status | active |
| metadata | {"author":"NodeJS-Starter-V1","version":"1.0.0","locale":"en-AU"} |
| description | >- |
| context | fork |
Defence-in-depth patterns preventing injection attacks across the full stack. Complements data-validation (which checks shape/type) by ensuring data is safe for its destination context (HTML, SQL, shell, URL).
Covers XSS, SQL injection, command injection, URL redirect, and SSRF prevention patterns for the Next.js frontend and FastAPI backend. Enforces output encoding, parameterised queries, and safe subprocess handling aligned with OWASP Top 10 guidelines.
data-validation instead)error-taxonomy instead)Validation checks what data IS. Sanitisation ensures data is SAFE for its destination.
โโโโโโโโโโโโโโโ
User Input โโโบ Validate โโโบ Sanitise โโโบ Use in Context
(shape) (safety) (HTML/SQL/shell/URL)
Untrusted data rendered as HTML can execute arbitrary JavaScript in the user's browser.
React escapes all JSX expressions by default. This is safe:
// SAFE: React auto-escapes this
function UserComment({ text }: { text: string }) {
return <p>{text}</p>;
}
// Input: <script>alert('XSS')</script>
// Output: <script>alert('XSS')</script>
These patterns bypass React's escaping and require manual sanitisation:
// DANGEROUS: dangerouslySetInnerHTML
// Only use with sanitised content
import DOMPurify from 'dompurify';
function RichContent({ html }: { html: string }) {
const clean = DOMPurify.sanitize(html, {
ALLOWED_TAGS: ['b', 'i', 'em', 'strong', 'a', 'p', 'br', 'ul', 'li'],
ALLOWED_ATTR: ['href', 'target', 'rel'],
});
return <div dangerouslySetInnerHTML={{ __html: clean }} />;
}
// DANGEROUS: href with user input (javascript: protocol)
function UserLink({ url }: { url: string }) {
// Validate protocol before rendering
const safeUrl = /^https?:\/\//i.test(url) ? url : '#';
return <a href={safeUrl}>{url}</a>;
}
Add CSP headers in next.config.ts to prevent inline script execution:
// next.config.ts
const securityHeaders = [
{
key: 'Content-Security-Policy',
value: [
"default-src 'self'",
"script-src 'self' 'nonce-{random}'",
"style-src 'self' 'unsafe-inline'", // Required for Tailwind
"img-src 'self' data: https:",
"connect-src 'self' http://localhost:8000",
"frame-ancestors 'none'",
].join('; '),
},
];
Untrusted data interpolated into SQL queries can read, modify, or delete database content.
The project uses SQLAlchemy ORM which parameterises queries by default:
# SAFE: SQLAlchemy ORM (parameterised automatically)
result = await session.execute(
select(User).where(User.email == user_email)
)
# SAFE: SQLAlchemy text() with bound parameters
from sqlalchemy import text
result = await session.execute(
text("SELECT * FROM users WHERE email = :email"),
{"email": user_email}
)
# DANGEROUS: f-string interpolation in SQL
query = f"SELECT * FROM users WHERE email = '{user_email}'"
# DANGEROUS: .format() in SQL
query = "SELECT * FROM users WHERE email = '{}'".format(user_email)
# DANGEROUS: % formatting in SQL
query = "SELECT * FROM users WHERE email = '%s'" % user_email
Grep for SQL injection risks:
rg "f['\"].*SELECT|\.format\(.*SELECT|%.*SELECT" apps/backend/src/
Any matches are Critical security findings.
Untrusted data in shell commands can execute arbitrary system commands.
import subprocess
import shlex
# SAFE: List form (no shell interpretation)
subprocess.run(
["git", "log", "--oneline", "-n", str(count)],
capture_output=True, text=True
)
# SAFE: shlex.quote for unavoidable string commands
filename = shlex.quote(user_filename)
subprocess.run(f"wc -l {filename}", shell=True)
# DANGEROUS: Unquoted user input in shell
subprocess.run(f"cat {user_input}", shell=True)
# DANGEROUS: os.system with user input
import os
os.system(f"rm {filename}")
rg "os\.system\(|shell=True" apps/backend/src/
Open redirects allow attackers to redirect users to malicious sites after login.
// Whitelist allowed redirect destinations
const ALLOWED_HOSTS = ['localhost:3000', 'yourdomain.com.au'];
function safeRedirect(url: string, fallback = '/'): string {
try {
const parsed = new URL(url, window.location.origin);
if (ALLOWED_HOSTS.includes(parsed.host)) {
return parsed.pathname + parsed.search;
}
} catch {
// Invalid URL โ fall through to fallback
}
return fallback;
}
from urllib.parse import urlparse
ALLOWED_HOSTS = {"localhost", "yourdomain.com.au"}
def validate_redirect(url: str, default: str = "/") -> str:
"""Validate redirect URL against whitelist."""
try:
parsed = urlparse(url)
if parsed.hostname in ALLOWED_HOSTS or not parsed.hostname:
return url
except ValueError:
pass
return default
User-controlled URLs in server-side requests can access internal services.
import ipaddress
from urllib.parse import urlparse
BLOCKED_RANGES = [
ipaddress.ip_network("10.0.0.0/8"),
ipaddress.ip_network("172.16.0.0/12"),
ipaddress.ip_network("192.168.0.0/16"),
ipaddress.ip_network("127.0.0.0/8"),
ipaddress.ip_network("169.254.0.0/16"),
]
def is_safe_url(url: str) -> bool:
"""Reject URLs pointing to internal/private networks."""
parsed = urlparse(url)
if parsed.scheme not in ("http", "https"):
return False
try:
ip = ipaddress.ip_address(parsed.hostname)
return not any(ip in net for net in BLOCKED_RANGES)
except ValueError:
# Hostname, not IP โ allow (DNS resolution happens later)
return True
When reviewing code for injection risks:
dangerouslySetInnerHTML without DOMPurifyjavascript: or data: URLs in href/src attributesshell=True with user input โ use list form or shlex.quotefetch/requests without SSRF check| Pattern | Problem | Correct Approach |
|---|---|---|
String concatenation in SQL (f"SELECT ... WHERE id = '{user_id}'") | SQL injection vulnerability | Use SQLAlchemy ORM or bound parameters with text() |
innerHTML or dangerouslySetInnerHTML for user content without sanitisation | XSS attack vector | Sanitise with DOMPurify before rendering |
| No output encoding for context (HTML, URL, shell) | Injection in the destination context | Encode output appropriate to context: HTML-escape, URL-encode, shlex.quote |
| Trusting client-side validation as the only defence | Attackers bypass the browser entirely | Always re-validate and sanitise on the server side |
shell=True with user-controlled arguments | Command injection vulnerability | Use list-form subprocess calls or shlex.quote |
shell=True with user input)next.config.ts[AGENT_ACTIVATED]: Input Sanitisation
[PHASE]: {Audit | Implementation | Review}
[STATUS]: {in_progress | complete}
{security analysis or implementation guidance}
[NEXT_ACTION]: {what to do next}
data-validation runs first (checks shape), then input-sanitisation ensures safety:
Input โ data-validation (is it valid?) โ input-sanitisation (is it safe?) โ Use
Sanitisation failures should use AUTH_PERMISSION_* or DATA_VALIDATION_* error codes. Never reveal internal details in error messages to untrusted clients.
Sanitisation functions must be O(n) โ no recursive regex or backtracking patterns that could cause ReDoS (Regular Expression Denial of Service).