Security Review
Use this skill when adding authentication, handling user input, working with secrets, creating API endpoints, or implementing payment/sensitive features. Provides comprehensive security checklist and patterns.
Get the complete skill folder, including its scripts and reference files.
·
When to use this skill
Use Security Review when an AI agent needs a reusable SKILL.md workflow for this job: Use this skill when adding authentication, handling user input, working with secrets, creating API endpoints, or implementing payment/sensitive features. Provides comprehensive security checklist and patterns.
When not to use it
Skip Security Review when the task is outside the coding category, or when a more specific skill in this directory already covers the same workflow with clearer triggers.
How to install
Where will you use it?
mkdir -p ~/.claude/skills/security-review # Save SKILL.md to ~/.claude/skills/security-review/SKILL.md
- Claude Code personal install: place the skill and its bundled files at ~/.claude/skills/security-review/SKILL.md. For a shared project, commit the folder at .claude/skills/security-review/ instead.
- Current Claude Code detects SKILL.md changes in watched directories during the session. If you just created a top-level skills directory, run /reload-skills. Check that the skill is listed before testing its trigger.
- For Claude chat or Cowork in the Desktop app, manage uploaded skills in Customize > Skills; copying files into a local Claude Code folder is not a Desktop install. Other agents may use different install locations.
Full install guide for Claude, Cursor, and Codex →
Try a starter prompt
After installing the skill, paste this starter prompt into your agent to verify it triggers on a small task.
Use the Security Review skill for this task: Use Security Review when this documented workflow matches the task. Confirm any required inputs or files before making changes.
What supports this recommendation?
71/100 provisional content score. This measures documentation, practical detail and source signals. It is not a measured task success rate or a security certification.
- Documentation
- 77/100
- Practical detail
- 68/100
- Source evidence
- 63/100
- Source signals
- 72/100
Model compatibility evidence
- claudeuntested
No model-specific signal or recorded compatibility test was found.
- chatgptinferred
The skill text mentions ChatGPT or a closely associated term. This is keyword-derived compatibility; no hands-on model test is recorded.
- geminiuntested
No model-specific signal or recorded compatibility test was found.
- copilotuntested
No model-specific signal or recorded compatibility test was found.
- llamauntested
No model-specific signal or recorded compatibility test was found.
- perplexityuntested
No model-specific signal or recorded compatibility test was found.
- mistraluntested
No model-specific signal or recorded compatibility test was found.
- grokuntested
No model-specific signal or recorded compatibility test was found.
Inferred compatibility is based on content signals. Check the app, its available tools and setup requirements before running a skill.
What this skill does
# Security Review Skill
This skill ensures all code follows security best practices and identifies potential vulnerabilities.
## When to Activate
- 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
#### FAIL: NEVER Do This ```typescript const apiKey = "sk-proj-xxxxx" // Hardcoded secret const dbPassword = "password123" // In source code ```
#### PASS: ALWAYS Do This ```typescript const apiKey = process.env.OPENAI_API_KEY const dbUrl = process.env.DATABASE_URL
// Verify secrets exist if (!apiKey) { throw new Error('OPENAI_API_KEY not configured') } ```
#### Verification Steps - [ ] No hardcoded API keys, tokens, or passwords - [ ] All secrets in environment variables - [ ] `.env.local` in .gitignore - [ ] No secrets in git history - [ ] Production secrets in hosting platform (Vercel, Railway)
### 2. Input Validation
#### Always Validate User Input ```typescript import { z } from 'zod'
// Define validation schema const CreateUserSchema = z.object({ email: z.string().email(), name: z.string().min(1).max(100), age: z.number().int().min(0).max(150) })
// Validate before processing export 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.issues } } throw error } } ```
#### File Upload Validation ```typescript function validateFileUpload(file: File) { // Size check (5MB max) const maxSize = 5 * 1024 * 1024 if (file.size > maxSize) { throw new Error('File too large (max 5MB)') }
// Type check const allowedTypes = ['image/jpeg', 'image/png', 'image/gif'] if (!allowedTypes.includes(file.type)) { throw new Error('Invalid file type') }
// Extension check const 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
#### FAIL: NEVER Concatenate SQL ```typescript // DANGEROUS - SQL Injection vulnerability const query = `SELECT * FROM users WHERE email = '${userEmail}'` await db.query(query) ```
#### PASS: ALWAYS Use Parameterized Queries ```typescript // Safe - parameterized query const { data } = await supabase .from('users') .select('*') .eq('email', userEmail)
// Or with raw SQL -- the value goes in the params array, never in the // string. Use your driver's placeholder syntax (Postgres numbers its // placeholders, MySQL uses "?"). await db.query( 'SELECT * FROM users WHERE email = ?', [userEmail] ) ```
<!-- Do not write a literal dollar-sign-N placeholder anywhere in this file. Invoking this skill with arguments substitutes it away, and the example above then renders as concatenated SQL -- the exact anti-pattern this section warns against. Use "?" and name the Postgres form in prose. -->
#### 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 ```typescript // FAIL: WRONG: localStorage (vulnerable to XSS) localStorage.setItem('token', token)
// PASS: CORRECT: httpOnly cookies res.setHeader('Set-Cookie', `token=${token}; HttpOnly; Secure; SameSite=Strict; Max-Age=3600`) ```
#### Authorization Checks ```typescript export async function deleteUser(userId: string, requesterId: string) { // ALWAYS verify authorization first const requester = await db.users.findUnique({ where: { id: requesterId } })
if (requester.role !== 'admin') { return NextResponse.json( { error: 'Unauthorized' }, { status: 403 } ) }
// Proceed with deletion await db.users.delete({ where: { id: userId } }) } ```
#### Row Level Security (Supabase) ```sql -- Enable RLS on all tables ALTER TABLE users ENABLE ROW LEVEL SECURITY;
-- Users can only view their own data CREATE POLICY "Users view own data" ON users FOR SELECT USING (auth.uid() = id);
-- Users can only update their own data CREATE POLICY "Users update own data" ON users FOR UPDATE USING (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 ```typescript import DOMPurify from 'isomorphic-dompurify'
// ALWAYS sanitize user-provided HTML function 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
Start strict and loosen only with a documented removal plan. Do not default to `'unsafe-inline'` or `'unsafe-eval'`; they neutralize much of CSP's protection and should be treated as temporary compatibility debt.
```typescript // next.config.js const securityHeaders = [ { key: 'Content-Security-Policy', value: ` default-src 'self'; base-uri 'self'; object-src 'none'; frame-ancestors 'none'; script-src 'self'; style-src 'self'; 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 ```typescript 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 ```typescript res.setHeader('Set-Cookie', `session=${sessionId}; HttpOnly; Secure; SameSite=Strict`) ```
#### Verification Steps - [ ] CSRF tokens on state-changing operations - [ ] SameSite=Strict on all cookies - [ ] Double-submit cookie pattern implemented
### 7. Rate Limiting
#### API Rate Limiting ```typescript import rateLimit from 'express-rate-limit'
const limiter = rateLimit({ windowMs: 15 * 60 * 1000, // 15 minutes max: 100, // 100 requests per window message: 'Too many requests' })
// Apply to routes app.use('/api/', limiter) ```
#### Expensive Operations ```typescript // Aggressive rate limiting for searches const searchLimiter = rateLimit({ windowMs: 60 * 1000, // 1 minute max: 10, // 10 requests per minute message: '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 ```typescript // FAIL: WRONG: Logging sensitive data console.log('User login:', { email, password }) console.log('Payment:', { cardNumber, cvv })
// PASS: CORRECT: Redact sensitive data console.log('User login:', { email, userId }) console.log('Payment:', { last4: card.last4, userId }) ```
#### Error Messages ```typescript // FAIL: WRONG: Exposing internal details catch (error) { return NextResponse.json( { error: error.message, stack: error.stack }, { status: 500 } ) }
// PASS: CORRECT: Generic error messages catch (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 ```typescript import { verify } from '@solana/web3.js'
async function verifyWalletOwnership( publicKey: string, signature: string, message: string ) { try { const isValid = verify( Buffer.from(message), Buffer.from(signature, 'base64'), Buffer.from(publicKey, 'base64') ) return isValid } catch (error) { return false } } ```
#### Transaction Verification ```typescript async function verifyTransaction(transaction: Transaction) { // Verify recipient if (transaction.to !== expectedRecipient) { throw new Error('Invalid recipient') }
// Verify amount if (transaction.amount > maxAmount) { throw new Error('Amount exceeds limit') }
// Verify user has sufficient balance const 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 ```bash # Check for vulnerabilities npm audit
# Fix automatically fixable issues npm audit fix
# Update dependencies npm update
# Check for outdated packages npm outdated ```
#### Lock Files ```bash # ALWAYS commit lock files git add package-lock.json
# Use in CI/CD for reproducible builds npm 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 ```typescript // Test authentication test('requires authentication', async () => { const response = await fetch('/api/protected') expect(response.status).toBe(401) })
// Test authorization test('requires admin role', async () => { const response = await fetch('/api/admin', { headers: { Authorization: `Bearer ${userToken}` } }) expect(response.status).toBe(403) })
// Test input validation test('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 limiting test('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) }) ```
## Pre-Deployment Security Checklist
Before ANY production deployment:
- [ ] **Secrets**: No hardcoded secrets, all in env vars - [ ] **Input Validation**: All user inputs validated - [ ] **SQL Injection**: All queries parameterized - [ ] **XSS**: User content sanitized - [ ] **CSRF**: Protection enabled - [ ] **Authentication**: Proper token handling - [ ] **Authorization**: Role checks in place - [ ] **Rate Limiting**: Enabled on all endpoints - [ ] **HTTPS**: Enforced in production - [ ] **Security Headers**: CSP, X-Frame-Options configured - [ ] **Error Handling**: No sensitive data in errors - [ ] **Logging**: No sensitive data logged - [ ] **Dependencies**: Up to date, no vulnerabilities - [ ] **Row Level Security**: Enabled in Supabase - [ ] **CORS**: Properly configured - [ ] **File Uploads**: Validated (size, type) - [ ] **Wallet Signatures**: Verified (if blockchain)
## Resources
- [OWASP Top 10](https://owasp.org/www-project-top-ten/) - [Next.js Security](https://nextjs.org/docs/security) - [Supabase Security](https://supabase.com/docs/guides/auth) - [Web Security Academy](https://portswigger.net/web-security)
---
**Remember**: Security is not optional. One vulnerability can compromise the entire platform. When in doubt, err on the side of caution.
Intended uses
- Use Security Review when this documented workflow matches the task.
Implementation notes
- Review the source instructions and adapt inputs before running the workflow.
Try it, then tell us how it went
A copied prompt does not tell us whether the task worked. Report your result after checking the output. We collect your tool and outcome, never your files or prompt.