← Voltar ao Blog

US$ 2,7 milhões por um script de terceiro: o que perguntar sobre CSP e SRI

O caso Polymarket mostra que ter CSP não significa estar protegido contra JavaScript de terceiros. Um guia: o que falhou, quais controles funcionam, que decisões de arquitetura e de processo tomar e quais métricas acompanhar.

G
Gila Security
3 de novembro de 2026
US$ 2,7 milhões por um script de terceiro: o que perguntar sobre CSP e SRI

Em 29 de outubro de 2026, a Polymarket teve 726 carteiras drenadas, num total de cerca de US$ 2,7 milhões. Contando os traders afetados pela pausa nas negociações, o reembolso anunciado chega a cerca de US$ 3,9 milhões. Segundo a análise da Hudson Rock, ninguém teve senha, seed ou chave privada roubada. Segundo a própria DebugBear, atacantes comprometeram o DNS dela por meio do registrador de domínio, e o endereço de um script de monitoramento de performance que a Polymarket carregava passou a servir código malicioso.

Este texto é uma conversa entre segurança e engenharia. Para quem cuida do risco e para quem cuida da arquitetura e das entregas, o caso Polymarket levanta a mesma pergunta: o que a nossa página carrega de terceiros, e quem confere o que chega ao navegador do cliente? A seguir, o que o incidente mostra, por que a CSP que a maioria das empresas já tem não cobre esse cenário e como reduzir o risco sem atrapalhar o dia a dia do time.

Resumo executivo

  • O que aconteceu: o DNS de um fornecedor foi comprometido por atacantes no registrador de domínio, e o endereço do script, que estava autorizado na página, passou a servir um arquivo adulterado. O código operou com a sessão autenticada do próprio usuário.
  • Por que os controles comuns falham: uma CSP (Content Security Policy) baseada em lista de domínios confia no endereço do script, não no conteúdo. Contrato, questionário de segurança e teste de invasão do fornecedor também não enxergam a troca do arquivo em tempo de execução.
  • O que funciona: reduzir a quantidade de scripts de terceiros em telas críticas, hospedar você mesmo o que for essencial e, para o que continuar externo, fixar a versão e verificar o conteúdo com SRI (Subresource Integrity), combinado a uma CSP restritiva.
  • O que não se resolve só com header: se um script malicioso chega a executar, ele age como o usuário. A prevenção precisa acontecer antes da execução, e a detecção precisa ser contínua.
  • Decisão pedida: um dono para o tema, um inventário de scripts de terceiros nas telas autenticadas e de pagamento, um fluxo de aprovação na engenharia para qualquer script novo e métricas de acompanhamento.

Como este texto foi feito. Os fatos do incidente vêm da análise da Hudson Rock, da The Hacker News (01/11), da cobertura da NBC News e das comunicações da Polymarket e da DebugBear. O incidente é recente: os valores variam entre as fontes (de US$ 2,5 mi a US$ 2,7 mi) e podem ser atualizados. Este texto não atribui responsabilidade à DebugBear, que, segundo a própria empresa, foi vítima do comprometimento do DNS. As fontes estão no fim do texto.

O que é CSP e o que é SRI

Uma página web moderna não é um arquivo único. Ao abrir uma tela do seu banco ou do seu e-commerce, o navegador baixa e executa código de vários lugares: do seu próprio servidor e de fornecedores de analytics, chat, monitoramento, publicidade e testes A/B. Qualquer um desses códigos, quando executa, tem os mesmos poderes da página, inclusive o acesso à sessão do usuário logado.

CSP (Content Security Policy) é uma política de segurança que o seu servidor envia ao navegador, em um cabeçalho HTTP, dizendo de onde a página pode carregar e executar código (e para onde pode enviar dados). Tudo o que não está na lista, o navegador bloqueia. Foi criada principalmente para conter ataques de injeção de código, como o XSS: se um atacante consegue inserir <script src="https://site-do-atacante.com/x.js"> na página, a CSP recusa, porque aquele domínio não foi autorizado.

Uma analogia: a CSP é a lista de convidados na portaria. Ela confere o nome de quem chega, mas não olha o que a pessoa carrega na mochila.

SRI (Subresource Integrity) cobre justamente isso. Você registra na página uma “impressão digital” (hash) do arquivo que revisou. Antes de executar, o navegador calcula a impressão digital do que baixou e compara. Se o arquivo foi trocado, ele não executa. É o lacre na embalagem: não importa quem entregou, importa se o conteúdo é o que foi aprovado.

Resumindo: a CSP controla a origem, a SRI controla o conteúdo. O incidente da Polymarket aconteceu no espaço entre as duas.

O incidente em quatro passos

  1. A Polymarket carregava nas páginas de negociação um script de monitoramento de performance de terceiro (cdn.debugbear.com).
  2. Em 29/10, os registros DNS da DebugBear foram comprometidos por atacantes por meio da conta no registrador de domínio (versão da própria DebugBear). Com isso, o mesmo endereço passou a servir um arquivo malicioso, e não o script original.
  3. O navegador do usuário logado executou o arquivo como se fosse legítimo.
  4. Segundo a Hudson Rock, o código não tem rotina que envie senha, seed ou chave privada. Ele localiza o cliente de negociação já autenticado e pede ao signer da própria sessão que assine as operações. Os valores foram movidos em cerca de 52 minutos, até a Polymarket pausar as negociações e retirar o script.

A conta autorizou o próprio roubo. Não houve, até onde as análises mostram, quebra de criptografia nem de autenticação.

Por que isso é um problema de governança, não de header

Três pontos que costumam escapar da conversa técnica:

1. O fornecedor do seu fornecedor é parte da sua superfície de ataque. A DebugBear também foi vítima: segundo ela, o ponto de entrada foi a conta no registrador de domínio, fora da aplicação da Polymarket e do código da DebugBear. Poucas empresas perguntam a um fornecedor de script como ele protege o registro do próprio domínio.

2. Gestão de risco de terceiros costuma parar no contrato. Questionários e certificações avaliam o fornecedor em um ponto no tempo. O script, porém, é baixado e executado a cada visita, no navegador do seu cliente, com a autoridade da sessão dele. Esse risco acontece em tempo de execução e raramente aparece no inventário de terceiros.

3. “Temos CSP” não responde à pergunta certa. A própria Hudson Rock aponta que a CSP da Polymarket permitia o host da DebugBear e que confiar em um CDN não verifica os bytes que ele entrega. Uma política que autoriza o domínio do fornecedor continua autorizando o domínio depois que ele é sequestrado.

CSP e SRI: o que cada uma faz

ControlePergunta que respondeO que não cobre
CSPDe onde um script pode vir? Bloqueia injeção a partir de origens não autorizadas.Conteúdo adulterado entregue por uma origem autorizada.
SRIO arquivo é exatamente o que foi revisado? O navegador compara o hash e recusa um arquivo trocado.Scripts sem versão fixa, scripts que carregam outros scripts e código inline.
JuntasSó executa o que vem de origem autorizada e tem o conteúdo esperado.Código malicioso que já estava no arquivo quando o hash foi calculado.

Segundo a análise da Aviatrix, o script foi carregado sem SRI, e analistas apontam que um hash fixo teria impedido a execução do arquivo trocado. A Polymarket diz que está recolocando o script do fornecedor com controles de integridade e monitoramento adicionais.

Os limites que vale conhecer

  • SRI exige versão fixa. Muitos fornecedores atualizam o script no servidor, na mesma URL, sem aviso. Com SRI, uma atualização legítima quebra a funcionalidade. Isso obriga a ter processo de atualização, e é um custo operacional real.
  • A SRI não cobre o que o script carrega depois. Se o arquivo aprovado injeta outros, esses ficam fora do hash.
  • Nada disso ajuda se o código malicioso já rodou. Com ele ativo, as chamadas às APIs legítimas do seu site usam os cookies do usuário. Por isso o controle é preventivo, e a detecção de mudanças precisa existir como segunda linha.

Priorizando as ações: impacto contra esforço

AçãoEfeito sobre o riscoEsforçoObservação
Remover scripts de terceiros de telas críticas (login, pagamento, transferência, alteração cadastral)Alto: elimina o vetorBaixoSession replay, teste A/B, chatbot e monitoramento raramente se justificam onde há movimentação de valor.
Hospedar internamente o que for essencial, com versão fixa e revisãoAlto: remove a dependência do DNS e da infraestrutura do fornecedorMédioExige processo de atualização.
Fixar versão + SRI no que continuar externoAlto para troca de arquivoMédioNão funciona para scripts que mudam sem aviso.
CSP restritiva (sem 'unsafe-inline', sem curingas, com nonce ou hash)Médio a alto: reduz injeção e limita o destino de dadosMédio a altoImplantar primeiro em modo de relatório.
Isolar widgets que não aceitam SRI em iframe com sandbox e de outra origemMédioMédioO widget deixa de operar dentro da sessão.
Monitorar mudanças e violações (relatórios de CSP, comparação periódica com o aprovado)Médio: detecta o que a prevenção deixou passarMédioAtende também ao PCI DSS 11.6.1.
Cláusulas e verificação do registrador nos fornecedores críticosMédioBaixoBloqueio de transferência, MFA e DNSSEC no domínio que entrega o script.

Como adotar CSP e SRI sem quebrar a página nem frear o time

O risco é de segurança, mas as alavancas estão na engenharia. Cinco decisões de arquitetura e de processo:

  1. Trate script de terceiro como dependência de código. Declare cada script (origem, versão, hash, dono e justificativa) em um arquivo versionado no repositório e exija pull request com aprovação de segurança para incluir ou atualizar. O script que entra em produção por fora desse fluxo é justamente o que a CSP e a SRI não enxergam.
  2. Feche o atalho do gerenciador de tags. Essas ferramentas permitem que marketing e produto publiquem código sem passar por release. Em telas críticas, ou não use, ou restrinja quem publica, o que pode ser publicado e exija revisão. Uma CSP que autoriza o gerenciador de tags herda o risco de tudo que ele carrega.
  3. Hospede e versione o que for essencial. Copiar o arquivo para o seu CDN, com versão fixa e hash, elimina a dependência do DNS do fornecedor e costuma reduzir conexões externas. O custo é o processo de atualização: automatize a detecção de novas versões e a revisão do que mudou.
  4. Escolha o modelo de confiança da CSP de forma consciente. Política por nonce ou hash é mais forte do que lista de domínios. A diretiva 'strict-dynamic' simplifica a adoção, mas faz o navegador confiar nos scripts carregados por um script já aprovado, o que deixa sem verificação o que ele carrega depois. Decida isso de forma explícita, e não pelo padrão do framework.
  5. Verifique continuamente, e não só no deploy. Um teste automatizado que abre as telas críticas em navegador headless e compara os domínios e hashes dos scripts carregados com a lista aprovada detecta mudanças que acontecem depois do deploy, como a troca de um arquivo remoto. Some a isso os relatórios de violação da CSP (report-to).

O custo precisa estar na mesa. Esse modelo exige esforço contínuo de engenharia e atrito com times que dependem de ferramentas de terceiros. Duas decisões precisam ser tomadas em conjunto por segurança e engenharia: quem tem poder de veto sobre um novo script em tela crítica, e em quanto tempo se remove um script que perdeu a justificativa.

Roteiro passo a passo: da CSP em modo de relatório ao bloqueio

Uma CSP restritiva aplicada de uma vez, sem preparo, costuma bloquear scripts, estilos, fontes e conexões legítimas, e a página quebra. Por isso o caminho abaixo vai do mais seguro ao mais rígido. Cada passo só começa quando o anterior está estável, e o ritmo é o do seu time.

1. Enxergar o que existe. Faça o inventário dos scripts de terceiros nas telas autenticadas e de pagamento, com dono de negócio, justificativa e a indicação de quais têm versão fixa e SRI. Um levantamento deste tipo costuma revelar scripts que ninguém lembra de ter autorizado.

2. Decidir o destino de cada script. Para cada item, escolha entre remover, hospedar internamente ou manter externo com versão fixa e SRI. Comece pelos que não têm justificativa: remover é a ação de maior efeito e menor risco para a página.

3. Publicar a CSP em modo de relatório. Use o cabeçalho Content-Security-Policy-Report-Only com uma política inicial que reflita o que a página já carrega hoje. Nesse modo nada é bloqueado: o navegador só avisa o que a política recusaria. Comece em homologação e em uma tela de baixo risco.

4. Ler os relatórios e ajustar. Colete as violações (report-to) e separe o que é uso legítimo do que é ruído, como extensões de navegador. Revise as diretivas que mais costumam ser esquecidas: connect-src, frame-src, font-src, img-src, style-src e workers. Teste os fluxos completos (login, pagamento, transferência) em mais de um navegador.

5. Fixar versão e aplicar SRI nos scripts que ficam externos. Antes de ligar a SRI, confirme com o fornecedor que a URL é versionada. Se o arquivo muda na mesma URL sem aviso, a SRI vai quebrar a funcionalidade, e a melhor saída nesse caso é hospedar uma cópia sua ou isolar o widget.

6. Apertar a política aos poucos. Retire curingas e 'unsafe-inline' e troque a lista de domínios por nonce ou hash. Faça uma mudança por vez e mantenha cada uma em modo de relatório até que as violações novas parem de aparecer.

7. Ativar o bloqueio por tela. Passe de Report-Only para Content-Security-Policy em uma tela de menor tráfego, com plano de reversão pronto (o cabeçalho deve poder voltar ao modo de relatório em minutos). Depois estenda às telas críticas, uma de cada vez. Mantenha a política seguinte, mais rígida, rodando em relatório ao lado.

8. Colocar a verificação no processo de entrega. Inclua no pipeline o teste que compara os scripts carregados com a lista aprovada e ligue alertas para domínios e hashes novos.

9. Acompanhar e revisar. Acompanhe os indicadores da seção seguinte e revise a lista aprovada sempre que um script for incluído, atualizado ou removido.

Como saber se está funcionando

  1. Número de scripts de terceiros carregados nas telas autenticadas e de pagamento, e sua tendência.
  2. Percentual desses scripts hospedados internamente ou com versão fixa e SRI.
  3. Tempo entre uma mudança em um script de terceiro e o alerta correspondente.
  4. Percentual dos fornecedores críticos que comprovam controles sobre o registrador e o DNS do domínio que entrega o código.
  5. Violações de CSP em produção por mês, com a proporção tratada.

Isto também é um risco de home banking

Troque “trader” por “correntista”. A arquitetura de uma área logada de banco é a mesma: uma página autenticada carregando dezenas de scripts de terceiros (analytics, session replay, chatbot, monitoramento, teste A/B) ao lado de uma sessão que agenda transferências, cadastra chaves PIX e aprova dispositivos. Um script trocado em um desses fornecedores não precisa da senha do cliente: opera como ele, chamando as APIs do próprio banco com os cookies dele.

Isso também aparece em exigências de conformidade. O PCI DSS 4.0 pede, para páginas de pagamento de cartão, que cada script seja autorizado, justificado, tenha a integridade garantida e conste de um inventário (requisito 6.4.3), e que haja um mecanismo de detecção de alterações não autorizadas nos cabeçalhos HTTP e no conteúdo da página (requisito 11.6.1, com avaliação ao menos semanal). Ambos são obrigatórios desde 31/03/2025. No setor financeiro brasileiro, a política de segurança cibernética da Resolução CMN 4.893 (alterada pela Resolução CMN 5.274/2025) se estende a prestadores de serviço, e vale perguntar se o seu inventário de terceiros inclui quem entrega JavaScript ao navegador do cliente.

Perguntas para começar

  1. Quantos scripts de terceiros carregam nas nossas telas autenticadas e de pagamento? Quem aprovou cada um?
  2. Se um desses domínios fosse comprometido hoje, em quanto tempo saberíamos?
  3. Nossos fornecedores críticos protegem o registrador e o DNS do domínio que entrega o código?
  4. Quantos desses scripts têm versão fixa e SRI, ou são hospedados por nós?
  5. Nossa CSP restringe por conteúdo (nonce, hash, SRI) ou só por domínio?
  6. Existe um fluxo de revisão que impeça um script novo, ou um arquivo atualizado, de chegar à produção sem aprovação, inclusive pelo gerenciador de tags?

Se a resposta para a maioria for “não sei”, o primeiro passo é o inventário. A diferença entre um header que custa US$ 0 e um que evita US$ 2,7 milhões está em poucas linhas de configuração, mas só quem sabe o que carrega consegue escrevê-las.

Apêndice técnico para o seu time

Inventário rápido. No console do navegador, na página que importa:

[...document.scripts]
  .filter(s => s.src && new URL(s.src).origin !== location.origin)
  .map(s => ({ src: s.src, integrity: s.integrity || null }));

Cada linha com integrity: null é um script de terceiro rodando sem verificação de conteúdo. Confira também a aba Network para os scripts carregados por outros scripts.

Script com versão fixa e SRI. O hash abaixo é ilustrativo:

<script
  src="https://cdn.vendor.com/monitor-1.8.2.js"
  integrity="sha384-HASH-ILUSTRATIVO-DO-ARQUIVO-REVISADO"
  crossorigin="anonymous"></script>

Para gerar o hash de um arquivo revisado, prefixe o resultado com sha384-:

curl -sS https://cdn.vendor.com/monitor-1.8.2.js \
  | openssl dgst -sha384 -binary | openssl base64 -A

Automatize a verificação no CI: uma mudança no arquivo remoto deve derrubar o build, e não a produção.

CSP de partida (ajuste ao seu ambiente e implante antes em Content-Security-Policy-Report-Only):

Content-Security-Policy:
  default-src 'self';
  script-src 'self' 'nonce-{aleatório-por-requisição}';
  connect-src 'self' https://api.seudominio.com;
  object-src 'none';
  base-uri 'none';
  frame-ancestors 'none';
  report-to csp-endpoint

Evite 'unsafe-inline', 'unsafe-eval' e curingas (https:, *.cdn.com) em script-src. Restrinja connect-src para limitar o destino de dados exfiltrados.


Quer saber quais scripts de terceiros rodam nas suas telas críticas? O time da Gila Security pode mapear a superfície de terceiros, revisar sua CSP e testar se ela realmente bloqueia o que deveria. Fale com a gente.

Referências

O incidente

Padrões e documentação técnica

Conformidade