跳至正文
OpenAgentSkill
浏览已开放 · 目录记录日期 2026-11-21 · 自动更新和账户服务暂时关闭。
安全

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 · 已有静态检查记录

安装与使用

运行命令前先阅读来源与依赖说明。复制命令不会自动安装或执行。

npx skills add jefflester/claude-skills-supercharged --skill api-security

技能说明


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:

阅读完整来源 ↗