Habilidade de Revisão de Segurança
Esta habilidade garante que todo o código siga as melhores práticas de segurança e identifique vulnerabilidades potenciais.
Quando Ativar
- Implementando autenticação ou autorização
- Manipulando entrada do usuário ou uploads de arquivos
- Criando novos endpoints de API
- Trabalhando com segredos ou credenciais
- Implementando funcionalidades de pagamento
- Armazenando ou transmitindo dados sensíveis
- Integrando APIs de terceiros
Lista de Verificação de Segurança
1. Gerenciamento de Segredos
FALHA: NUNCA Faça Isso
const apiKey = "sk-proj-xxxxx" // Segredo codificado
const dbPassword = "password123" // No código fonte
PASSO: SEMPRE Faça Isso
const apiKey = process.env.OPENAI_API_KEY
const dbUrl = process.env.DATABASE_URL
// Verifique se os segredos existem
if (!apiKey) {
throw new Error('OPENAI_API_KEY não configurada')
}
Etapas de Verificação
- Nenhuma chave de API, token ou senha codificada
- Todos os segredos em variáveis de ambiente
-
.env.localno .gitignore - Nenhum segredo no histórico do git
- Segredos de produção na plataforma de hospedagem (Vercel, Railway)
2. Validação de Entrada
Sempre Valide a Entrada do Usuário
import { z } from 'zod'
// Defina o esquema de validação
const CreateUserSchema = z.object({
email: z.string().email(),
name: z.string().min(1).max(100),
age: z.number().int().min(0).max(150)
})
// Valide antes de processar
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
}
}
Validação de Upload de Arquivos
function validateFileUpload(file: File) {
// Verificação de tamanho (máx. 5 MB)
const maxSize = 5 * 1024 * 1024
if (file.size > maxSize) {
throw new Error('Arquivo muito grande (máx. 5 MB)')
}
// Verificação de tipo
const allowedTypes = ['image/jpeg', 'image/png', 'image/gif']
if (!allowedTypes.includes(file.type)) {
throw new Error('Tipo de arquivo inválido')
}
// Verificação de extensão
const allowedExtensions = ['.jpg', '.jpeg', '.png', '.gif']
const extension = file.name.toLowerCase().match(/\.[^\.]+$/)?.[0]
if (!extension || !allowedExtensions.includes(extension)) {
throw new Error('Extensão de arquivo inválida')
}
return true
}
Etapas de Verificação
- Todas as entradas do usuário validadas com esquemas
- Uploads de arquivos restritos (tamanho, tipo, extensão)
- Nenhum uso direto de entrada do usuário em consultas
- Validação por lista de permissões (não por lista de bloqueios)
- Mensagens de erro não vazam informações sensíveis
3. Prevenção de Injeção SQL
FALHA: NUNCA Concatene SQL
// PERIGOSO - Vulnerabilidade de injeção SQL
const query = `SELECT * FROM users WHERE email = '${userEmail}'`
await db.query(query)
PASSO: SEMPRE Use Consultas Parametrizadas
// Seguro - consulta parametrizada
const { data } = await supabase
.from('users')
.select('*')
.eq('email', userEmail)
// Ou com SQL bruto
await db.query(
'SELECT * FROM users WHERE email = $1',
[userEmail]
)
Etapas de Verificação
- Todas as consultas ao banco de dados usam consultas parametrizadas
- Nenhuma concatenação de strings no SQL
- ORM/criador de consultas usado corretamente
- Consultas do Supabase devidamente sanitizadas
4. Autenticação e Autorização
Manipulação de Tokens JWT
// FALHA: ERRADO: localStorage (vulnerável a XSS)
localStorage.setItem('token', token)
// PASSO: CORRETO: cookies httpOnly
res.setHeader('Set-Cookie',
`token=${token}; HttpOnly; Secure; SameSite=Strict; Max-Age=3600`)
Verificações de Autorização
export async function deleteUser(userId: string, requesterId: string) {
// SEMPRE verifique a autorização primeiro
const requester = await db.users.findUnique({
where: { id: requesterId }
})
if (requester.role !== 'admin') {
return NextResponse.json(
{ error: 'Não autorizado' },
{ status: 403 }
)
}
// Prossiga com a exclusão
await db.users.delete({ where: { id: userId } })
}
Segurança em Nível de Linha (Supabase)
-- Ativar RLS em todas as tabelas
ALTER TABLE users ENABLE ROW LEVEL SECURITY;
-- Usuários só podem visualizar seus próprios dados
CREATE POLICY "Usuários visualizam seus próprios dados"
ON users FOR SELECT
USING (auth.uid() = id);
-- Usuários só podem atualizar seus próprios dados
CREATE POLICY "Usuários atualizam seus próprios dados"
ON users FOR UPDATE
USING (auth.uid() = id);
Etapas de Verificação
- Tokens armazenados em cookies httpOnly (não localStorage)
- Verificações de autorização antes de operações sensíveis
- Segurança em Nível de Linha ativada no Supabase
- Controle de acesso baseado em funções implementado
- Gerenciamento de sessão seguro
5. Prevenção de XSS
Sanitize HTML
import DOMPurify from 'isomorphic-dompurify'
// SEMPRE sanitize HTML fornecido pelo usuário
function renderUserContent(html: string) {
const clean = DOMPurify.sanitize(html, {
ALLOWED_TAGS: ['b', 'i', 'em', 'strong', 'p'],
ALLOWED_ATTR: []
})
return <div dangerouslySetInnerHTML={{ __html: clean }} />
}
Política de Segurança de Conteúdo
Comece estrito e só afrouxe com um plano de remoção documentado. Não use padrão
'unsafe-inline' ou 'unsafe-eval'; eles neutralizam grande parte da proteção CSP
e devem ser tratados como dívida de compatibilidade temporária.
// 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()
}
]
Etapas de Verificação
- HTML fornecido pelo usuário sanitizado
- Cabeçalhos CSP configurados
- Nenhuma renderização de conteúdo dinâmico não validado
- Proteção XSS integrada do React usada
6. Proteção CSRF
Tokens CSRF
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: 'Token CSRF inválido' },
{ status: 403 }
)
}
// Processar solicitação
}
Cookies SameSite
res.setHeader('Set-Cookie',
`session=${sessionId}; HttpOnly; Secure; SameSite=Strict`)
Etapas de Verificação
- Tokens CSRF em operações de mudança de estado
- SameSite=Strict em todos os cookies
- Padrão de cookie de duplo envio implementado
7. Limitação de Taxa
Limitação de Taxa de API
import rateLimit from 'express-rate-limit'
const limiter = rateLimit({
windowMs: 15 * 60 * 1000, // 15 minutos
max: 100, // 100 solicitações por janela
message: 'Muitas solicitações'
})
// Aplicar a rotas
app.use('/api/', limiter)
Operações Caras
// Limitação de taxa agressiva para pesquisas
const searchLimiter = rateLimit({
windowMs: 60 * 1000, // 1 minuto
max: 10, // 10 solicitações por minuto
message: 'Muitas solicitações de pesquisa'
})
app.use('/api/search', searchLimiter)
Etapas de Verificação
- Limitação de taxa em todos os endpoints de API
- Limites mais rigorosos em operações caras
- Limitação de taxa baseada em IP
- Limitação de taxa baseada em usuário (autenticado)
8. Exposição de Dados Sensíveis
Logging
// FALHA: ERRADO: Logging de dados sensíveis
console.log('Login do usuário:', { email, password })
console.log('Pagamento:', { cardNumber, cvv })
// PASSO: CORRETO: Redação de dados sensíveis
console.log('Login do usuário:', { email, userId })
console.log('Pagamento:', { last4: card.last4, userId })
Mensagens de Erro
// FALHA: ERRADO: Expondo detalhes internos
catch (error) {
return NextResponse.json(
{ error: error.message, stack: error.stack },
{ status: 500 }
)
}
// PASSO: CORRETO: Mensagens de erro genéricas
catch (error) {
console.error('Erro interno:', error)
return NextResponse.json(
{ error: 'Ocorreu um erro. Tente novamente.' },
{ status: 500 }
)
}
Etapas de Verificação
- Nenhuma senha, token ou segredo nos logs
- Mensagens de erro genéricas para usuários
- Erros detalhados apenas nos logs do servidor
- Nenhum stack trace exposto aos usuários
9. Segurança Blockchain (Solana)
Verificação de Carteira
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
}
}
Verificação de Transação
async function verifyTransaction(transaction: Transaction) {
// Verificar destinatário
if (transaction.to !== expectedRecipient) {
throw new Error('Destinatário inválido')
}
// Verificar valor
if (transaction.amount > maxAmount) {
throw new Error('Valor excede o limite')
}
// Verificar se o usuário tem saldo suficiente
const balance = await getBalance(transaction.from)
if (balance < transaction.amount) {
throw new Error('Saldo insuficiente')
}
return true
}
Etapas de Verificação
- Assinaturas de carteira verificadas
- Detalhes da transação validados
- Verificações de saldo antes das transações
- Nenhuma assinatura de transação às cegas
10. Segurança de Dependências
Atualizações Regulares
# Verificar vulnerabilidades
npm audit
# Corrigir problemas automaticamente
npm audit fix
# Atualizar dependências
npm update
# Verificar pacotes desatualizados
npm outdated
Arquivos de Bloqueio
# SEMPRE commitar arquivos de bloqueio
git add package-lock.json
# Usar em CI/CD para builds reproduzíveis
npm ci # Em vez de npm install
Etapas de Verificação
- Dependências atualizadas
- Nenhuma vulnerabilidade conhecida (npm audit limpo)
- Arquivos de bloqueio commitados
- Dependabot ativado no GitHub
- Atualizações de segurança regulares
Testes de Segurança
Testes de Segurança Automatizados
// Testar autenticação
test('requer autenticação', async () => {
const response = await fetch('/api/protected')
expect(response.status).toBe(401)
})
// Testar autorização
test('requer função de admin', async () => {
const response = await fetch('/api/admin', {
headers: { Authorization: `Bearer ${userToken}` }
})
expect(response.status).toBe(403)
})
// Testar validação de entrada
test('rejeita entrada inválida', async () => {
const response = await fetch('/api/users', {
method: 'POST',
body: JSON.stringify({ email: 'not-an-email' })
})
expect(response.status).toBe(400)
})
// Testar limitação de taxa
test('impõe limites de taxa', 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)
})
Lista de Verificação de Segurança Pré-Implantação
Antes de QUALQUER implantação em produção:
- Segredos: Nenhum segredo codificado, todos em variáveis de ambiente
- Validação de Entrada: Todas as entradas do usuário validadas
- Injeção SQL: Todas as consultas parametrizadas
- XSS: Conteúdo do usuário sanitizado
- CSRF: Proteção ativada
- Autenticação: Manipulação adequada de tokens
- Autorização: Verificações de função em vigor
- Limitação de Taxa: Ativada em todos os endpoints
- HTTPS: Imposto em produção
- Cabeçalhos de Segurança: CSP, X-Frame-Options configurados
- Tratamento de Erros: Nenhum dado sensível em erros
- Logging: Nenhum dado sensível registrado
- Dependências: Atualizadas, sem vulnerabilidades
- Segurança em Nível de Linha: Ativada no Supabase
- CORS: Configurado corretamente
- Uploads de Arquivos: Validados (tamanho, tipo)
- Assinaturas de Carteira: Verificadas (se blockchain)
Recursos
Lembre-se: Segurança não é opcional. Uma vulnerabilidade pode comprometer toda a plataforma. Em caso de dúvida, erre pelo lado da cautela.