Ataque à cadeia de fornecimento: proteja scripts de terceiros

Ataque à cadeia de fornecimento: proteja scripts de terceiros

Um site legítimo pode entregar código malicioso sem que os atacantes invadam a infraestrutura de cada empresa. No ataque descrito pelo Sapo.pt, os criminosos comprometeram a Optimizely, uma plataforma de otimização usada por várias organizações, e aproveitaram essa dependência para chegar a 178 sites — entre eles CNN, IKEA, Zoom, Ledger e Air France-KLM. Para quem desenvolve, a lição é direta: cada script de terceiro também faz parte da superfície de ataque da aplicação.

Como o ataque à Optimizely chegou a 178 sites

Segundo o Sapo.pt, os atacantes não precisaram obter acesso independente aos servidores da BBC, da CNN, do HSBC ou das outras empresas afetadas. A cadeia de fornecimento de software fez o trabalho por eles: ao comprometer uma plataforma integrada nos sites, conseguiram distribuir código malicioso por páginas de organizações que confiavam naquele fornecedor.

Esse tipo de incidente é chamado de ataque à cadeia de fornecimento, ou software supply chain attack. O risco não está apenas no código que a equipe escreve ou nos pacotes instalados no projeto. Está também nos serviços de analytics, testes A/B, chat, publicidade, gestão de tags e monitoramento que o navegador carrega em tempo de execução.

De acordo com o investigador Scott Helme, os scripts tentavam substituir endereços de pagamento em criptomoedas pelos endereços controlados pelos atacantes. Também copiavam números de cartões digitados, recolhiam cookies e capturas de ecrã. A HudsonRock, empresa de cibersegurança, encontrou indícios de que os sites serviram código malicioso, em linha com as conclusões de Helme.

Isso não significa que todos os dados de todos os visitantes foram roubados. O relato indica que o valor levado foi baixo, mas o impacto potencial de um script capaz de observar uma página e alterar seu conteúdo é maior do que o prejuízo identificado. Um endereço de carteira trocado, por exemplo, pode passar despercebido até ser tarde demais: transações em blockchain normalmente não podem ser revertidas.

Por que um script de terceiros tem tanto poder no navegador

Quando uma página carrega um JavaScript de um fornecedor, esse código costuma executar no contexto daquela página. Dependendo de como foi integrado e das proteções disponíveis, pode ler campos do formulário, observar alterações no DOM, capturar interações e enviar informações para outro servidor. O visitante vê o domínio conhecido da empresa, mas o código pode ter vindo de uma dependência comprometida.

Essa é uma diferença importante entre instalar uma biblioteca durante o build e carregar um script externo em cada visita. Uma dependência fixada no lockfile pode ser revisada, testada e incluída no artefato de produção. Um script remoto, por outro lado, pode mudar sem uma nova versão da aplicação. A conveniência operacional vem acompanhada de uma confiança contínua no fornecedor e no caminho de entrega.

Na minha experiência, o erro mais comum é tratar serviços de terceiros como “apenas uma tag”. Na prática, cada integração precisa de dono, justificativa, revisão de permissões e plano de remoção. Se ninguém sabe por que um script está na página, ninguém consegue decidir com rapidez se deve bloqueá-lo durante um incidente.

O que o componente Coruna e as versões do iOS indicam

O ataque também incluiu uma tentativa de explorar o iOS. Segundo o relato, a HudsonRock identificou código malicioso servido pelos sites, e o componente de exploração chamado Coruna era semelhante a um analisado em outra campanha. Comentários encontrados no próprio kit indicavam correções no iOS 18.7.3 e posteriores, além do iOS 26.3 e posteriores.

Essas versões são as indicadas na notícia; não as interpreto como uma lista completa de todos os aparelhos ou correções aplicáveis. O ponto operacional é manter o sistema atualizado e instalar as atualizações de segurança disponibilizadas para o modelo e a versão em uso. A fonte relata que, em sistemas corrigidos, o risco era muito reduzido.

Também vale separar duas coisas: a exploração de uma falha do sistema e o roubo de dados por JavaScript. Atualizar o iPhone reduz o risco associado ao exploit mencionado, mas não transforma um site comprometido em confiável. Um script malicioso ainda pode tentar manipular conteúdo ou dados acessíveis à página, mesmo sem conseguir instalar código de exploração no sistema.

Na Prática: reduza a exposição a scripts externos

Uma política de segurança de conteúdo, ou CSP, ajuda a restringir de onde a página pode carregar scripts e outros recursos. Ela não substitui a segurança do fornecedor nem corrige código malicioso já autorizado, mas reduz caminhos de execução que não deveriam existir. O exemplo abaixo mostra uma política básica em Express, com um nonce aleatório por resposta para scripts inline autorizados pelo template.

import express from "express";
import { randomBytes } from "node:crypto";

const app = express();

app.use((req, res, next) => {
  const nonce = randomBytes(16).toString("base64");
  res.locals.cspNonce = nonce;

  res.setHeader(
    "Content-Security-Policy",
    [
      "default-src 'self'",
      `script-src 'self' 'nonce-${nonce}'`,
      `style-src 'self' 'nonce-${nonce}'`,
      "img-src 'self' data:",
      "font-src 'self'",
      "connect-src 'self'",
      "form-action 'self'",
      "base-uri 'self'",
      "object-src 'none'",
      "frame-ancestors 'none'",
      "upgrade-insecure-requests"
    ].join("; ")
  );

  next();
});

app.get("/", (req, res) => {
  res.render("index", { nonce: res.locals.cspNonce });
});

app.listen(3000);

No template, o nonce precisa ser aplicado aos scripts inline autorizados, por exemplo: <script nonce="VALOR_GERADO_PARA_A_RESPOSTA">...</script>. Na aplicação real, o mecanismo de template deve inserir o valor gerado no servidor; não se deve reutilizar um nonce fixo. A política também precisa ser testada em modo de relatório antes de ser aplicada em produção, porque pode bloquear recursos legítimos.

Repare que o exemplo não autoriza automaticamente a Optimizely nem qualquer outro domínio externo. Isso é intencional: adicionar um fornecedor a script-src significa aceitar que scripts daquele domínio possam executar na página, e um comprometimento no fornecedor pode aproveitar essa confiança. Se uma integração for indispensável, limite sua presença às páginas necessárias e avalie se existe uma alternativa com menos privilégio.

Controles adicionais para páginas com pagamentos

Para pagamentos em criptomoedas, não confie apenas no que aparece no DOM. A aplicação deve obter o endereço esperado de uma fonte controlada pelo servidor e exibi-lo de forma consistente; o usuário deve compará-lo com um canal independente antes de confirmar uma transferência relevante. Essa verificação não torna a página imune a comprometimento, mas dificulta que uma simples alteração visual passe despercebida.

Para dados de cartão, use um provedor de pagamentos que mantenha os campos sensíveis fora do DOM da sua aplicação, como campos hospedados ou componentes tokenizados, quando isso atender aos requisitos do produto. Isso reduz a quantidade de dados que o JavaScript da página pode observar. Não elimina todos os riscos: um script comprometido ainda pode alterar a interface ou redirecionar o usuário.

Também inventarie as integrações periodicamente. Registre o domínio de origem, a finalidade, as páginas em que o script roda, o responsável interno e o procedimento para removê-lo. Para arquivos estáticos e versionados, o SRI (Subresource Integrity) pode verificar se o conteúdo recebido corresponde a um hash esperado. Ele é menos adequado a scripts dinâmicos que mudam frequentemente e não resolve, sozinho, integrações gerenciadas por plataformas de tags.

Erros comuns ao proteger aplicações contra scripts maliciosos

  • Confiar em uma lista de domínios sem revisar permissões. Autorizar um domínio inteiro em CSP pode permitir scripts que a equipe não pretendia executar. Restrinja origens e recursos ao mínimo necessário.
  • Achar que HTTPS garante que o JavaScript é confiável. HTTPS protege o transporte entre navegador e servidor; não impede que um fornecedor legítimo entregue conteúdo malicioso ou comprometido.
  • Usar SRI em scripts que mudam sem controle de versão. O hash precisa corresponder exatamente ao arquivo. Se o fornecedor altera o conteúdo, a verificação falha; se a equipe atualiza o hash sem revisar o novo código, perde parte do benefício.
  • Deixar scripts de marketing em páginas sensíveis. Uma ferramenta necessária em páginas públicas talvez não precise rodar em checkout, área autenticada ou telas de recuperação de conta.
  • Tratar CSP como substituto de monitoramento. CSP pode bloquear ou reportar violações, mas não informa, por si só, se uma integração autorizada mudou de comportamento. Combine a política com inventário, revisão de mudanças e alertas.
  • Não preparar uma resposta rápida. Sem saber quem pode remover uma tag, publicar uma correção e preservar logs, a equipe perde tempo justamente quando precisa conter o incidente.

O que fazer se uma dependência de navegador for comprometida

  1. Remova ou bloqueie a integração suspeita. Se necessário, publique uma versão emergencial sem o script ou restrinja temporariamente o domínio na CSP.
  2. Preserve evidências. Guarde logs, versões do código, cabeçalhos de resposta e registros de mudanças antes de limpar caches ou fazer alterações que eliminem rastros.
  3. Identifique o alcance. Verifique quais páginas carregavam o recurso, durante que período e que tipos de dados estavam presentes nessas páginas.
  4. Avalie exposição de dados e credenciais. Se formulários ou sessões puderem ter sido observados, siga o processo de resposta da organização e considere medidas como invalidar sessões ou notificar usuários, conforme a evidência e as obrigações aplicáveis.
  5. Reative apenas após validação. Confirme com o fornecedor a origem do problema, revise o conteúdo servido e monitore o comportamento depois da restauração.

FAQ: segurança de scripts de terceiros e iPhone

Atualizar o iOS basta para ficar protegido contra esse ataque?

Segundo o relato, as versões iOS 18.7.3 e posteriores e iOS 26.3 e posteriores já corrigiam a falha associada ao componente citado. A atualização reduz o risco de exploração do sistema, mas não impede que um site comprometido tente manipular conteúdo ou dados acessíveis à página.

Os 178 sites foram invadidos individualmente?

Não é isso que a notícia descreve. Os atacantes comprometeram a Optimizely, uma plataforma usada por várias organizações, e aproveitaram essa integração para alcançar sites clientes. A falha de um fornecedor pode, portanto, produzir efeitos em muitos domínios ao mesmo tempo.

Uma CSP impede qualquer ataque por JavaScript de terceiros?

Não. Uma CSP bem configurada restringe origens e tipos de recursos, mas um script malicioso servido por um domínio explicitamente autorizado ainda pode executar. A política reduz a superfície de ataque; não substitui a revisão de fornecedores, o isolamento de páginas sensíveis nem a resposta a incidentes.

O SRI protege scripts de plataformas como ferramentas de otimização?

O SRI funciona melhor para arquivos estáticos e versionados cujo conteúdo não muda sem controle. Em scripts dinâmicos, cada alteração exige atualizar e revisar o hash. Para integrações que geram código variável, o inventário, a limitação de permissões e a redução do escopo de execução tendem a ser mais práticos.

O impacto para quem desenvolve

Esse caso reforça uma decisão de arquitetura que muitas equipes adiam: limitar o JavaScript executado em páginas sensíveis. Menos tags significa menos dependências com capacidade de observar a página, menos mudanças fora do ciclo de deploy e uma resposta mais simples quando um fornecedor sofre um incidente.

Eu trataria scripts externos como dependências de produção, não como decoração do front-end. Documentaria cada integração, aplicaria CSP em etapas, usaria SRI quando o recurso fosse estático e manteria um caminho rápido para removê-lo. O navegador executa o que a página autoriza; cabe à equipe tornar essa autorização explícita e proporcional ao risco.

Gostou? Me segue no GitHub e deixa um comentário se tiver dúvida ou quiser aprofundar algum ponto.

Y

Yuri Sousa

Front-End Developer / Designer

Desenvolvedor apaixonado por criar experiências digitais acessíveis e visualmente perfeitas. Escrevo sobre desenvolvimento web, design e tecnologia.