api-security
API security best practices and common vulnerability prevention. Enforces security checks for authentication, input validation, SQL injection, XSS, and OWASP Top 10 vulnerabilities. Use when building or modifying APIs.
jefflester · Static checks on file
Installation
Read the source and dependencies before running a command. Copying does not install or execute anything.
npx skills add jefflester/claude-skills-supercharged --skill api-securityAbout this skill
name: api-security description: API security best practices and common vulnerability prevention. Enforces security checks for authentication, input validation, SQL injection, XSS, and OWASP Top 10 vulnerabilities. Use when building or modifying APIs.
API Security Best Practices
Purpose
This guardrail skill enforces critical security practices when building APIs. It helps prevent common vulnerabilities including OWASP Top 10 threats, ensuring your API is secure by design.
When to Use This Skill
Auto-activates when:
- Working with API endpoints or routes
- Mentions of "api", "endpoint", "authentication", "authorization"
- Adding request handlers or middleware
- Working with user input or database queries
Authentication & Authorization
Always Require Authentication
Every API endpoint must have explicit authentication:
# Good - Authentication required
@app.post("/api/users")
@require_auth # Explicit authentication decorator
async def create_user(request: Request):
user = get_current_user(request)
# Implementation
// Good - Authentication middleware
router.post('/api/users', authenticate, async (req, res) => {
const user = req.user; // Set by authenticate middleware
// Implementation
});
Never skip authentication:
# BAD - No authentication!
@app.post("/api/users")
async def create_user(request: Request):
# Anyone can call this!
pass
Implement Proper Authorization
Authentication (who you are) is not enough - check authorization (what you can do):
@app.delete("/api/users/{user_id}")
@require_auth
async def delete_user(user_id: str, request: Request):
current_user = get_current_user(request)
# Authorization check
if not current_user.is_admin and current_user.id != user_id:
raise HTTPException(status_code=403, detail="Forbidden")
# Proceed with deletion
await delete_user_by_id(user_id)
Use Strong Token Standards
Use industry-standard tokens:
# Good - JWT with expiration
import jwt
from datetime import datetime, timedelta
def create_access_token(user_id: str) -> str:
payload = {
"sub": user_id,
"exp": datetime.utcnow() + timedelta(hours=1),
"iat": datetime.utcnow(),
}
return jwt.encode(payload, SECRET_KEY, algorithm="HS256")
# Validate tokens properly
def verify_token(token: str) -> dict:
try:
payload = jwt.decode(token, SECRET_KEY, algorithms=["HS256"])
return payload
except jwt.ExpiredSignatureError:
raise HTTPException(status_code=401, detail="Token expired")
except jwt.InvalidTokenError:
raise HTTPException(status_code=401, detail="Invalid token")
Input Validation
Validate All User Input
Never trust user input - always validate:
from pydantic import BaseModel, Field, validator
class CreateUserRequest(BaseModel):
"""Validated user creation request."""
username: str = Field(..., min_length=3, max_length=50, regex="^[a-zA-Z0-9_]+$")
email: str = Field(..., regex=r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$")
age: int = Field(..., ge=0, le=150)
@validator("username")
def username_no_admin(cls, v):
if "admin" in v.lower():
raise ValueError("Username cannot contain 'admin'")
return v
@app.post("/api/users")
async def create_user(data: CreateUserRequest): # Automatic validation
# data is guaranteed valid here
pass
Sanitize Output
Prevent XSS by escaping output:
import html
@app.get("/api/users/{user_id}")
async def get_user(user_id: str):
user = await get_user_by_id(user_id)
# Sanitize output for web display
return {
"username": html.escape(user.username),
"bio": html.escape(user.bio),
}
Rate Limiting
Prevent abuse with rate limiting:
from slowapi import Limiter
from slowapi.util import get_remote_address
limiter = Limiter(key_func=get_remote_address)
@app.post("/api/login")
@limiter.limit("5/minute") # Max 5 attempts per minute
async def login(request: Request, credentials: LoginRequest):
# Implementation
pass
SQL Injection Prevention
Always Use Parameterized Queries
NEVER concatenate user input into SQL:
# CRITICAL VULNERABILITY - SQL Injection!
user_id = request.query_params.get("id")
query = f"SELECT * FROM users WHERE id = {user_id}" # NEVER DO THIS!
result = db.execute(query)
# Good - Parameterized query
user_id = request.query_params.get("id")
query = "SELECT * FROM users WHERE id = ?"
result = db.execute(query, (user_id,))
# Better - Use ORM
user = await User.filter(id=user_id).first()
ORM Best Practices
Use ORMs correctly to prevent injection:
from sqlalchemy import select
# Good - ORM with parameters
async def get_users_by_role(role: str):
query = select(User).where(User.role == role) # Parameterized
result = await session.execute(query)
return result.scalars().all()
# BAD - Raw SQL with concatenation
async def get_users_by_role_bad(role: str):
query = f"SELECT * FROM users WHERE role = '{role}'" # Vulnerable!
result = await session.execute(query)
return result.all()
Cross-Site Scripting (XSS) Prevention
Content Security Policy
Set CSP headers to prevent XSS:
@app.middleware("http")
async def add_security_headers(request: Request, call_next):
response = await call_next(request)
response.headers["Content-Security-Policy"] = (
"default-src 'self'; "
"script-src 'self' 'unsafe-inline'; "
"style-src 'self' 'unsafe-inline'; "
"img-src 'self' data: https:;"
)
response.headers["X-Content-Type-Options"] = "nosniff"
response.headers["X-Frame-Options"] = "DENY"
response.headers["X-XSS-Protection"] = "1; mode=block"
return response
Escape User Content
Always escape user-generated content:
Read the complete source ↗