Como evitar ataques de envenenamento de cache da web

O envenenamento de cache da web é um ataque cibernético que causa estragos em sites desavisados. Ele explora vulnerabilidades nos mecanismos de cache usados por servidores web, proxies e redes de distribuição de conteúdo (CDNs), comprometendo a integridade dos dados. Agentes mal-intencionados podem usar o envenenamento de cache para entregar conteúdo malicioso, adulterar informações confidenciais ou redirecionar usuários para sites fraudulentos.

Neste artigo, vamos explorar a fundo os ataques de envenenamento de cache da web e como eles funcionam. Também vamos abordar as estratégias de mitigação mais eficazes para ajudar a proteger nossas aplicações web.

Entenda o cache da web e sua importância

O cache da web é essencial para melhorar o desempenho de um site. Ele consiste em armazenar conteúdo da web, como arquivos HTML, imagens, scripts e folhas de estilo, em locais temporários chamados caches. Isso torna mais rápido e fácil acessar esse conteúdo novamente em solicitações futuras dos usuários.

Há vários tipos de mecanismos de cache, definidos de acordo com o local onde os caches da web são armazenados. Entre eles estão:

• Cache do navegador: Nesse tipo de cache, os navegadores armazenam cópias de recursos estáticos no dispositivo do usuário. Quando essa pessoa acessa o site novamente, o navegador verifica se há arquivos baixados anteriormente no cache. Se ainda forem válidos, o navegador os recupera em vez de enviar uma nova solicitação ao servidor.

• Cache do servidor: Enquanto o cache do navegador fica no lado do cliente, o cache do servidor armazena conteúdo no próprio servidor para reutilizá-lo mais tarde. Quando um usuário envia uma solicitação ao servidor de origem, o cache salva uma cópia da resposta gerada. Nas solicitações seguintes pelo mesmo conteúdo, o cache entrega essa cópia em vez de recorrer ao servidor de origem.

• Cache de rede de distribuição de conteúdo (CDN): As CDNs são redes de servidores distribuídas geograficamente que armazenam em cache e entregam conteúdo estático da web. Quando um usuário quer acessar esse conteúdo novamente, o servidor de borda mais próximo de sua localização atende à solicitação. Assim, o servidor de origem não precisa processar todas as solicitações.

O cache reduz o tempo e os recursos necessários para recuperar conteúdo da web, resultando em carregamentos mais rápidos e em uma experiência melhor para o usuário. Também diminui a carga no servidor, permitindo que ele processe um volume maior de solicitações.

No entanto, o cache também traz riscos em potencial, especialmente quando não é implementado ou gerenciado corretamente. Se o conteúdo em cache não for atualizado a tempo, ele pode ficar desatualizado ou incorreto, causando inconsistências ou vulnerabilidades de segurança que atacantes podem explorar.

Armazenar informações confidenciais em cache também pode representar riscos à privacidade. Por exemplo, se o cache contiver dados pessoais ou credenciais de acesso de um usuário, o acesso não autorizado poderá levar a violações de dados e de privacidade.

Como funcionam os ataques de envenenamento de cache da web

O envenenamento de cache da web tenta enganar a infraestrutura de cache para que ela entregue conteúdo comprometido ou não autorizado aos usuários. Em geral, o processo segue quatro etapas:

1. Identificação de um alvo vulnerável: O atacante procura um site com possíveis falhas nos mecanismos de cache, como configurações incorretas ou validação inadequada de entradas.

2. Manipulação de solicitações HTTP: O atacante envia ao site-alvo solicitações HTTP elaboradas para explorar essas vulnerabilidades.

3. Exploração dos mecanismos de cache: O atacante usa diferentes técnicas para injetar conteúdo malicioso ou manipular o conteúdo existente no cache.

4. Entrega de conteúdo comprometido: Quando o ataque é concluído, as solicitações seguintes ao cache recuperam o conteúdo envenenado em vez do conteúdo legítimo.

Ataques de envenenamento de cache da web bem-sucedidos podem expor informações confidenciais ou sigilosas. Em seguida, os atacantes podem manipular o conteúdo em cache para desfigurar o site-alvo, espalhar informações falsas ou distribuir links maliciosos.

Para piorar, os atacantes costumam combinar o envenenamento de cache da web com outros ataques cibernéticos para ampliar os danos. Por exemplo, em 2018, atacantes conseguiram envenenar o cache do site da British Airways. Eles injetaram conteúdo malicioso que redirecionava os usuários para um site fraudulento. Com isso, conseguiram roubar endereços de e-mail e informações de cartão de crédito de mais de 40 mil usuários do Reino Unido.

Vetores comuns de ataques de envenenamento de cache da web

Para proteger nossos sites contra ataques de envenenamento de cache, precisamos identificar e corrigir possíveis vulnerabilidades. Veja alguns dos vetores de ataque mais comuns e como agentes mal-intencionados podem explorá-los:

• Manipulação de cabeçalhos HTTP: Os atacantes frequentemente modificam cabeçalhos HTTP para associar conteúdo malicioso a URLs ou chaves de cache legítimas. Por exemplo, podem manipular o cabeçalho HTTP Cache-Control para instruir o sistema de cache a armazenar o conteúdo do atacante. Assim, o atacante consegue entregar seu conteúdo malicioso aos próximos usuários que solicitarem o mesmo recurso, mesmo que o conteúdo legítimo tenha mudado.

• Manipulação de strings de consulta: Os atacantes podem explorar a forma como as aplicações web lidam com strings de consulta. Eles manipulam os parâmetros de consulta adicionados à URL para criar várias versões em cache do mesmo recurso, que podem incluir conteúdo malicioso.

• Manipulação de cookies: Os atacantes também podem envenenar o cache modificando os valores e atributos dos cookies. Com isso, enganam o sistema de cache para que armazene o conteúdo do atacante associado à sessão de um usuário legítimo.

Vale lembrar, porém, que esses são apenas alguns exemplos. Os atacantes estão sempre explorando novas técnicas e vulnerabilidades para atingir seus objetivos. Ficar de olho apenas nesses vetores comuns não é suficiente para proteger os dados da web.

Ataque de envenenamento de cache por manipulação de cabeçalhos HTTP

Vamos analisar um caso de envenenamento de cache da web em que um atacante explora uma vulnerabilidade em um site por meio de cabeçalhos HTTP. O cabeçalho X-Forwarded-Host (XFH) é um alvo comum. Esse cabeçalho, que se tornou um padrão de fato, é usado para identificar o host original solicitado pelo cliente na requisição HTTP/HTTPS à sua aplicação ou API. Normalmente, o valor desse cabeçalho é um nome de host que representa o destino original da solicitação do cliente.

Embora esse cabeçalho tenha sido criado para ajudar em ambientes que usam proxy reverso ou balanceador de carga, um atacante pode explorá-lo se ele não for validado corretamente. É importante observar, porém, que o atacante pode usar vários outros cabeçalhos para realizar ataques semelhantes.

Agora, vamos ao exemplo, que mostra uma possível vulnerabilidade em código JavaScript que usa um serviço de cache. Para esta demonstração, vamos usar o Redis.

1const express = require('express');
2const app = express();
3const redis = require('redis');
4const client = redis.createClient();
5
6// Middleware to handle caching
7app.use((req, res, next) => {
8    const key = req.originalUrl; // use request url as a key
9
10    client.get(key, (err, data) => {
11        if (err) throw err;
12
13        if (data !== null) {
14            res.send(data);
15        } else {
16            next();
17        }
18    });
19});
20
21app.get('/user', (req, res, next) => {
22    const host = req.headers['x-forwarded-host'] || 'unknown host';
23    const response = `Welcome, user ${req.query.userId}! You're accessing from ${host}`;
24
25    // Cache the response using the URL as a key
26    client.set(req.originalUrl, response, 'EX', 3600); // Cache for 1 hour
27
28    res.send(response);
29    next();
30});
31
32app.listen(3000, () => {
33  console.log('Server running on port 3000');
34});

O middleware de cache usa a URL original como chave para armazenar respostas no Redis. A originalURL corresponde a tudo o que vem depois do nome do host (por exemplo, /user?userId=1 em http://example.com/user?userId=1). Se houver uma resposta associada a essa URL no cache, ela será enviada imediatamente. Caso contrário, a solicitação segue para o manipulador de rota adequado, que, neste caso, gera uma saudação personalizada para o usuário e a armazena em cache.

No entanto, essa implementação pode abrir caminho para ataques de envenenamento de cache. Um atacante pode se aproveitar do fato de armazenarmos respostas em cache com base nas URLs. Imagine que o cabeçalho X-Forwarded-Host, uma entrada controlada pelo usuário, seja usado para gerar a resposta. O código exibe uma saudação com base no valor de X-Forwarded-Host (por exemplo, “Boas-vindas, usuário ${req.query.userId}, você está acessando de ${req.headers['x-forwarded-host']}!”). Se esse valor não for validado corretamente, um atacante poderá incluir scripts maliciosos no cabeçalho, que serão armazenados em cache e entregues a outros usuários.

Veja como isso poderia acontecer:

• O atacante envia uma solicitação GET para /user?userId=1 com o cabeçalho X-Forwarded-Host definido como foo."><script>alert(document.cookie)</script>.

• O servidor gera uma saudação que inclui o valor do cabeçalho, armazena-a em cache com a chave /user?userId=1 e a envia de volta ao atacante.

• A partir daí, todas as solicitações seguintes para /user?userId=1 recebem do cache uma saudação maliciosa.

Uma forma de reforçar a segurança do código acima é sanitizar a URL usada como chave do cache. Veja como implementar uma função básica de sanitização que usa o método escape do módulo validator:

1const validator = require('validator');
2
3function sanitize(url) {
4    let parsedUrl;
5
6    try {
7        parsedUrl = new URL(url);
8    } catch (err) {
9        throw new Error('Invalid URL');
10    }
11
12    parsedUrl.searchParams.forEach((val, param) => {
13        // Escaping potentially harmful characters in the query parameters
14        parsedUrl.searchParams.set(param, validator.escape(val));
15    });
16
17    return parsedUrl.toString();
18}

A função sanitize que implementamos pode ser usada para remover de req.originalUrl os caracteres que possam representar uma ameaça:

1const key = sanitize(req.originalUrl);

Além disso, é possível validar as entradas dos usuários executando uma função de middleware no servidor Express. O exemplo abaixo mostra uma abordagem básica para validar os cabeçalhos:

1const validator = require('validator');
2
3app.use((req, res, next) => {
4    const forwardedHostHeader = req.headers['x-forwarded-host'];
5    if (forwardedHostHeader) {
6        const isFQDN = validator.isFQDN(forwardedHostHeader);
7        if (!isFQDN) {
8            // If the header does not represent a fully qualified domain name, the request is rejected
9            return res.status(400).send('Invalid X-Forwarded-Host header');
10        }
11    }
12
13    next();
14});

Aqui, usamos a função isFQDN do módulo validator para verificar se o cabeçalho X-Forwarded-Host contém um nome de domínio válido. Se não contiver, a função de middleware rejeita a solicitação e retorna o status 400 Bad Request.

Implementar esta etapa de validação é essencial para impedir a injeção de scripts maliciosos por meio do X-Forwarded-Host header. Como vimos, essa situação pode levar a um ataque de envenenamento de cache.

Boas práticas para mitigar o envenenamento de cache da web

Definir uma política de cache robusta é a forma mais eficaz de evitar o envenenamento de cache da web. Essa política especifica claramente que conteúdo deve ser armazenado em cache, por quanto tempo e em quais condições. Ao defini-la, precisamos considerar fatores como o tipo de dado, os requisitos de autenticação e o conteúdo dinâmico que não deve ser armazenado em cache.

Outras técnicas que ajudam a proteger os mecanismos de cache incluem:

• Normalização de chaves de cache: Normalizar as chaves de cache ajuda a evitar variações causadas pela formatação das entradas ou pela diferenciação entre maiúsculas e minúsculas.

• Valide as entradas dos usuários: A validação rigorosa e a sanitização das entradas podem evitar ataques de injeção que levam ao envenenamento de cache. Entre as técnicas estão a filtragem de entradas, a criação de listas de parâmetros permitidos e as verificações com expressões regulares.

• Cabeçalhos de controle de cache: Os cabeçalhos de controle de cache ajudam a definir o comportamento do cache e a reduzir riscos. Por exemplo, cabeçalhos como “no-store” e “no-cache” podem impedir o armazenamento de dados confidenciais em cache.

• Não confie em entradas de terceiros: Tenha cuidado ao depender de entradas de terceiros, como cabeçalhos, cookies ou strings de consulta. Valide e sanitize cuidadosamente todas as entradas externas antes de usá-las em operações relacionadas ao cache. Trate todos os dados fornecidos pelos usuários como potencialmente maliciosos e aplique validação e filtragem rigorosas para impedir que atacantes injetem conteúdo manipulado no cache.

• Use firewalls de aplicações web (WAFs): A implementação de um WAF robusto pode ajudar a detectar e bloquear tentativas de envenenamento de cache. Os WAFs analisam as solicitações recebidas e identificam padrões suspeitos que indicam esse tipo de ataque. Você pode configurar o WAF para alertar sobre essas solicitações ou bloqueá-las, adicionando uma camada extra de defesa.

Monitoramento e detecção de ataques de envenenamento de cache da web

Mesmo com as estratégias de mitigação adequadas, ainda pode ocorrer envenenamento de cache da web. Por isso, é essencial monitorar regularmente o tráfego da web e analisar os logs para detectar possíveis ataques. Fique atento a atividades incomuns ou suspeitas, como anomalias nos padrões de solicitação, variações inesperadas no cache ou conteúdo incomum entregue pelo cache.

Outra boa prática é realizar testes de segurança e de penetração regularmente. Essas avaliações ajudam a identificar vulnerabilidades que podem levar a ataques de envenenamento de cache. Os testes de segurança incluem varreduras de vulnerabilidades e auditorias de segurança. Os testes de penetração vão além, simulando cenários de ataque do mundo real. Eles reproduzem as técnicas e a mentalidade de um invasor para explorar vulnerabilidades específicas que testes de segurança regulares podem não detectar.

Há muitas ferramentas e recursos que podem ajudar a detectar e prevenir ataques de envenenamento de cache da Web. Por exemplo, podemos implementar:

• Scanners de vulnerabilidade, como o Snyk, que podemos usar para identificar automaticamente vulnerabilidades comuns de envenenamento de cache.

• Ferramentas de diagnóstico e análise de cache para ajudar a analisar configurações de cache, monitorar seu comportamento e detectar anomalias.

Resumo

O envenenamento de cache da Web é um tipo de ataque que força caches a servir conteúdo desatualizado ou manipulado sem que o usuário saiba. Isso pode levar a vazamentos de dados e violações de privacidade, prejudicando, em última instância, a reputação de um site.

Nossa melhor defesa contra esses ataques é estabelecer uma política de cache robusta e acompanhar as últimas tendências de segurança para aplicações Web. Também precisamos seguir as boas práticas de segurança, como implementar a validação adequada de entradas e normalizar as chaves de cache.

Seguir essas práticas de desenvolvimento seguro pode nos ajudar a aproveitar os benefícios do cache da Web e, ao mesmo tempo, minimizar o risco de um cache envenenado.