Skill v1.0.1
currentAutomated scan100/100+5 new
name: cc-skill-security-review description: "This skill guides review of security practices and potential vulnerabilities; no checklist ensures all code is secure. Use when implementing authentication or authorization, handling user input or file uploads, or creating new API endpoints." risk: critical source: community date_added: "2026-02-27" metadata: version: "1.0.1"
Security Review Skill
This skill guides review of security practices and potential vulnerabilities; no checklist ensures all code is secure.
Detailed Guide
Read the detailed guide before executing this skill. It retains the complete procedure and reference material. Treat its safety, prerequisites, and validation requirements as mandatory. For focused work, load the relevant sections; for end-to-end work, read the guide completely.
When to Use
- Implementing authentication or authorization
- Handling user input or file uploads
- Creating new API endpoints
- Working with secrets or credentials
- Implementing payment features
- Storing or transmitting sensitive data
- Integrating third-party APIs
Security Checklist
1. Secrets Management
❌ NEVER Do This
const leakedToken = "[redacted API key]" // Hardcoded secretconst dbCredential = "[redacted password]" // In source code
✅ ALWAYS Do This
const apiKey = process.env.OPENAI_API_KEYconst dbUrl = process.env.DATABASE_URL// Verify secrets existif (!apiKey) {throw new Error('OPENAI_API_KEY not configured')}
Verification Steps
- [ ] No hardcoded API keys, tokens, or passwords
- [ ] All secrets in environment variables
- [ ]
.env.localin .gitignore - [ ] No secrets in git history
- [ ] Production secrets in hosting platform (Vercel, Railway)
2. Input Validation
Always Validate User Input
import { z } from 'zod'// Define validation schemaconst CreateUserSchema = z.object({email: z.string().email(),name: z.string().min(1).max(100),age: z.number().int().min(0).max(150)})// Validate before processingexport async function createUser(input: unknown) {try {const validated = CreateUserSchema.parse(input)return await db.users.create(validated)} catch (error) {if (error instanceof z.ZodError) {return { success: false, errors: error.errors }}throw error}}
File Upload Validation
function validateFileUpload(file: File) {// Size check (5MB max)const maxSize = 5 * 1024 * 1024if (file.size > maxSize) {throw new Error('File too large (max 5MB)')}// Type checkconst allowedTypes = ['image/jpeg', 'image/png', 'image/gif']if (!allowedTypes.includes(file.type)) {throw new Error('Invalid file type')}// Extension checkconst allowedExtensions = ['.jpg', '.jpeg', '.png', '.gif']const extension = file.name.toLowerCase().match(/\.[^.]+$/)?.[0]if (!extension || !allowedExtensions.includes(extension)) {throw new Error('Invalid file extension')}return true}
Verification Steps
- [ ] All user inputs validated with schemas
- [ ] File uploads restricted (size, type, extension)
- [ ] No direct use of user input in queries
- [ ] Whitelist validation (not blacklist)
- [ ] Error messages don't leak sensitive info
3. SQL Injection Prevention
❌ NEVER Concatenate SQL
// DANGEROUS - SQL Injection vulnerabilityconst query = `SELECT * FROM users WHERE email = '${userEmail}'`await db.query(query)
✅ ALWAYS Use Parameterized Queries
// Safe - parameterized queryconst { data } = await supabase.from('users').select('*').eq('email', userEmail)// Or with raw SQLawait db.query('SELECT * FROM users WHERE email = $1',[userEmail])
Verification Steps
- [ ] All database queries use parameterized queries
- [ ] No string concatenation in SQL
- [ ] ORM/query builder used correctly
- [ ] Supabase queries properly sanitized
4. Authentication & Authorization
JWT Token Handling
// ❌ WRONG: localStorage (vulnerable to XSS)localStorage.setItem('token', token)// ✅ CORRECT: httpOnly cookiesres.setHeader('Set-Cookie',`token=${token}; HttpOnly; Secure; SameSite=Strict; Max-Age=3600`)
Authorization Checks
export async function deleteUser(userId: string, requesterId: string) {// ALWAYS verify authorization firstconst requester = await db.users.findUnique({where: { id: requesterId }})if (!requester || requester.role !== 'admin') {return NextResponse.json({ error: 'Unauthorized' },{ status: 403 })}// Proceed with deletionawait db.users.delete({ where: { id: userId } })}
Row Level Security (Supabase)
-- Enable RLS on all tablesALTER TABLE users ENABLE ROW LEVEL SECURITY;-- Users can only view their own dataCREATE POLICY "Users view own data"ON users FOR SELECTUSING (auth.uid() = id);-- Users can only update their own dataCREATE POLICY "Users update own data"ON users FOR UPDATEUSING (auth.uid() = id);
Verification Steps
- [ ] Tokens stored in httpOnly cookies (not localStorage)
- [ ] Authorization checks before sensitive operations
- [ ] Row Level Security enabled in Supabase
- [ ] Role-based access control implemented
- [ ] Session management secure
5. XSS Prevention
Sanitize HTML
import DOMPurify from 'isomorphic-dompurify'// ALWAYS sanitize user-provided HTMLfunction renderUserContent(html: string) {const clean = DOMPurify.sanitize(html, {ALLOWED_TAGS: ['b', 'i', 'em', 'strong', 'p'],ALLOWED_ATTR: []})return <div dangerouslySetInnerHTML={{ __html: clean }} />}
Content Security Policy
// next.config.jsconst securityHeaders = [{key: 'Content-Security-Policy',value: `default-src 'self';script-src 'self';style-src 'self' 'unsafe-inline';img-src 'self' data: https:;font-src 'self';connect-src 'self' https://api.example.com;`.replace(/\s{2,}/g, ' ').trim()}]
Verification Steps
- [ ] User-provided HTML sanitized
- [ ] CSP headers configured
- [ ] No unvalidated dynamic content rendering
- [ ] React's built-in XSS protection used
6. CSRF Protection
CSRF Tokens
import { csrf } from '@/lib/csrf'export async function POST(request: Request) {const token = request.headers.get('X-CSRF-Token')if (!csrf.verify(token)) {return NextResponse.json({ error: 'Invalid CSRF token' },{ status: 403 })}// Process request}
SameSite Cookies
res.setHeader('Set-Cookie',`session=${sessionId}; HttpOnly; Secure; SameSite=Strict`)
Verification Steps
- [ ] CSRF tokens on state-changing operations
- [ ] SameSite policy fits the flow; test OAuth redirects and CSRF controls
- [ ] Use a vetted synchronizer or signed session-bound double-submit pattern where required
7. Rate Limiting
API Rate Limiting
import rateLimit from 'express-rate-limit'const limiter = rateLimit({windowMs: 15 * 60 * 1000, // 15 minutesmax: 100, // 100 requests per windowmessage: 'Too many requests'})// Apply to routesapp.use('/api/', limiter)
Expensive Operations
// Aggressive rate limiting for searchesconst searchLimiter = rateLimit({windowMs: 60 * 1000, // 1 minutemax: 10, // 10 requests per minutemessage: 'Too many search requests'})app.use('/api/search', searchLimiter)
Verification Steps
- [ ] Rate limiting on all API endpoints
- [ ] Stricter limits on expensive operations
- [ ] IP-based rate limiting
- [ ] User-based rate limiting (authenticated)
8. Sensitive Data Exposure
Logging
// ❌ WRONG: Logging sensitive dataconsole.log('User login:', { email, password })console.log('Payment:', { cardNumber, cvv })// ✅ CORRECT: Redact sensitive dataconsole.log('User login event:', { userId })console.log('Payment:', { last4: card.last4, userId })
Error Messages
// ❌ WRONG: Exposing internal detailscatch (error) {return NextResponse.json({ error: error.message, stack: error.stack },{ status: 500 })}// ✅ CORRECT: Generic error messagescatch (error) {console.error('Internal error:', error)return NextResponse.json({ error: 'An error occurred. Please try again.' },{ status: 500 })}
Verification Steps
- [ ] No passwords, tokens, or secrets in logs
- [ ] Error messages generic for users
- [ ] Detailed errors only in server logs
- [ ] No stack traces exposed to users
9. Blockchain Security (Solana)
Wallet Verification
import { PublicKey } from '@solana/web3.js'import nacl from 'tweetnacl'async function verifyWalletOwnership(publicKey: string,signature: string,message: string) {try {const isValid = nacl.sign.detached.verify(Buffer.from(message),Buffer.from(signature, 'base64'),new PublicKey(publicKey).toBytes())return isValid} catch (error) {return false}}
Application Intent Validation (not a Solana Transaction API)
async function verifyTransactionIntent(transaction: {to: string; amount: bigint; from: string}) {// Verify recipientif (transaction.to !== expectedRecipient) {throw new Error('Invalid recipient')}// Verify amountif (transaction.amount > maxAmount) {throw new Error('Amount exceeds limit')}// Verify user has sufficient balanceconst balance = await getBalance(transaction.from)if (balance < transaction.amount) {throw new Error('Insufficient balance')}return true}
Verification Steps
- [ ] Wallet signatures verified
- [ ] Transaction details validated
- [ ] Balance checks before transactions
- [ ] No blind transaction signing
10. Dependency Security
Regular Updates
# Check for vulnerabilitiesnpm audit# Fix automatically fixable issuesnpm audit fix# Update dependenciesnpm update# Check for outdated packagesnpm outdated
Lock Files
# ALWAYS commit lock filesgit add package-lock.json# Use in CI/CD for reproducible buildsnpm ci # Instead of npm install
Verification Steps
- [ ] Dependencies up to date
- [ ] No known vulnerabilities (npm audit clean)
- [ ] Lock files committed
- [ ] Dependabot enabled on GitHub
- [ ] Regular security updates
Security Testing
Automated Security Tests
// Test authenticationtest('requires authentication', async () => {const response = await fetch('/api/protected')expect(response.status).toBe(401)})// Test authorizationtest('requires admin role', async () => {const response = await fetch('/api/admin', {headers: { Authorization: `Bearer ${userToken}` }})expect(response.status).toBe(403)})// Test input validationtest('rejects invalid input', async () => {const response = await fetch('/api/users', {method: 'POST',body: JSON.stringify({ email: 'not-an-email' })})expect(response.status).toBe(400)})// Test rate limitingtest('enforces rate limits', async () => {const requests = Array(101).fill(null).map(() =>fetch('/api/endpoint'))const responses = await Promise.all(requests)const tooManyRequests = responses.filter(r => r.status === 429)expect(tooManyRequests.length).toBeGreaterThan(0)})
Limitations
- Use this skill only when the task clearly matches the scope described above.
- Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
- Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.
Derive requester identity from a verified server session, never a caller-supplied requesterId. Browser MIME/extension checks are only usability filters: enforce server byte limits, inspect/decode file content, and store with safe names/origins. Use a cookie serializer and deliberate Path/Domain; HttpOnly does not prevent XSS from issuing requests. Adapt CSP with per-response nonces/hashes and real Next.js header wiring rather than adding unsafe-inline/eval. For wallet login, bind a server-issued single-use nonce, domain, purpose and expiry and consume it atomically; signature validity alone permits replay. The transaction-intent sketch does not decode or validate actual Solana instructions, fees, programs, token mints or confirmation. Pin dependencies, validate codemods/audit fixes on a branch, and report accepted findings rather than equating audit-clean with security. Tests are illustrative and rate tests require bounded authorized fixtures.