Hack na Bitget Set. 2026: Análise do Ataque de $351M

Tava eu ontem à noite mexendo na configuração de um endpoint novo pra nossa testnet interna, tomando aquele café que já tinha esfriado faz tempo, quando de repente os monitores nos canais de segurança começaram a piscar em vermelho vivo. Foi um baque tão forte que deu até aquele aperto no peito — aquela sensação dolorosamente familiar da época em que eu passava as noites jogando CTF.

Começaram a pipocar os primeiros dumps na blockchain, o pessoal da Arkham soltou o alerta e os números nas telas dos terminais começaram a mudar loucamente. A Bitget, uma das gigantes do mercado, sofreu um incidente brutal estimado em cerca de 351,6 milhões de dólares. E quer saber? Meu primeiro pensamento nem foi "nossa, roubaram mais uma grana", mas sim um estalo puramente técnico: qual vetor de ataque esses caras conseguiram explorar dessa vez? Afinal, ninguém derruba uma infraestrutura desse porte assim do nada.

Vetor de ataque e os detalhes técnicos da brecha na infra

Com base na telemetria preliminar e nos relatórios da galera de Sec, os caras nem perderam tempo com smart contracts complexos ou phishing básico contra retail trader. Eles foram direto no ponto mais vulnerável das plataformas centralizadas: a infraestrutura de backend que gerencia as hot wallets.

• Comprometimento do backend de autorização de transações: Os invasores conseguiram injetar lógica própria ou obter acesso não autorizado aos serviços internos de assinatura. Eles burlaram o sistema de controle de risco se passando por um serviço legítimo de processamento. Para os gateways, as transações pareciam 100% válidas porque o próprio sistema as assinou, enganado por metadados forjados.
• Drain cross-chain instantâneo: O ataque drenou várias blockchains de uma vez só — saíram ativos em AVAX, BNB, ETH e diversas stablecoins. E os hackers jogaram frio: todo o ativo com liquidez foi imediatamente convertido e enviado via bridge para Ethereum nativo, onde os emissores centralizados não conseguem simplesmente congelar os fundos com um clique. É a assinatura clássica de um grupo muito bem preparado — e, pelos padrões de obfuscamento de rastros, a sombra do famoso Lazarus Group aparece de novo.

Análise do impacto por principais ativos

O que os usuários devem fazer agora?

Sendo bem sincero, entrar em pânico é a pior coisa nessas horas, mas também não dá para fingir que tá tudo bem. Quando limpam hot wallets na casa dos centenas de milhões, as exchanges inevitavelmente pausam os gateways de saque para rodar um audit completo de segurança e refazer toda a infraestrutura de chaves.

Não caiam na lábia de golpistas nas redes sociais. Os caras criam centenas de perfis fakes de suporte em minutos oferecendo "compensação" ou "resgate de depósitos por formulário especial". É o clássico phishing aproveitando o hype do caos.

Se seus fundos estavam nos book de ofertas ou no saldo spot, não adianta entrar em desespero e deletar a conta: a diretoria da exchange já declarou oficialmente que vai cobrir o rombo usando o próprio Fundo de Proteção ao Usuário (User Protection Fund), que foi criado justamente para lidar com esse tipo de emergência.

O código de verificação de chaves de API internas que a gente costuma usar na construção de gateways parecidos para barrar requisições anômalas no backend é mais ou menos assim. Esse é um trecho de código de proteção real:

import hmac
import hashlib
import time
from fastapi import HTTPException, Security, Request
from fastapi.security.api_key import APIKeyHeader
API_KEY_HEADER = APIKeyHeader(name="X-Internal-Signature", auto_error=False)
SECRET_WORKER_KEY = b"sec_live_9982_x_cluster_node"
async def verify_critical_transaction_gateway(request: Request, api_key: str = Security(API_KEY_HEADER)):
    if not api_key:
        raise HTTPException(status_code=403, detail="Signature missing")
    
    body_bytes = await request.body()
    timestamp = request.headers.get("X-Timestamp", "0")
    
    if abs(time.time() - int(timestamp)) > 30:
        raise HTTPException(status_code=401, detail="Replay attack detected")
        
    digest = hmac.new(SECRET_WORKER_KEY, body_bytes + timestamp.encode(), hashlib.sha256).hexdigest()
    
    if not hmac.compare_digest(digest, api_key):
        raise HTTPException(status_code=403, detail="Cryptographic mismatch")
    return True

Quando bati o olho nos gráficos de movimentação dos fundos roubados da Bitget pela primeira vez, até gelou a espinha — a execução foi tão limpa que parecia que os caras tinham a planta inteira da nossa infraestrutura interna na mesa. Existe uma regra de ouro no mundo da segurança da informação: por mais paranoia que você coloque na sua arquitetura, sempre vai sobrar um fator humano ou um gateway legado esquecido lá de 2021.

Bora escovar esse bit e entender a mecânica técnica: como exatamente os hackers lavam uma bolada dessas em poucas horas enquanto o time de SecOps da exchange corre feito doido pra achar o botão de emergência?

Brechas de Arquitetura & a Engenharia do Lavagem Flash

Quando drenam centenas de milhões de uma custódia centralizada, os invasores não ficam simplesmente sentados em cima dos sacos de ETH. Eles ativam todo um ecossistema pré-montado de smart contracts autônomos e protocolos DeFi pra pulverizar os rastros antes mesmo dos nós validadores pensarem em colocar os endereços na blacklist.

• Uso de Bridges Non-Custodial e Mixers Cross-Chain: Todo o loot vindo da BNB Chain e da Avalanche foi imediatamente desovado através de uma esteira de atomic swaps e pools de liquidez descentralizados, driblando qualquer ponto de controle centralizado. Os caras nem precisaram recorrer a balcões OTC — Automated Market Makers (AMMs) configurados com alta tolerância a slippage engolem volumes milionários em segundos, convertendo uma salada inteira de altcoins em ETH limpo e privacy coins.
• Apagão dos Sistemas de Anti-Fraude: O que fez esse exploit passar batido? Muito provavelmente os atacantes fisgaram tokens de API comprometidos de algum DevOps sênior ou de um operador da hot wallet. Quando a requisição de saque vem assinada com uma chave privada legítima da infraestrutura, nenhuma IA de análise comportamental apita — pro sistema, é sinal verde vindo de um admin verificado.

Comparativo de Impacto: Hack da Bitget vs. Maiores Drenagens da História

Pra dimensionar o tamanho do estrago, vale a pena dar uma olhada nesta tabela comparativa com os maiores vexames de segurança das CEXs nos últimos anos. Os números não mentem e mostram bem como o apetite dos cibercriminosos escalou.

Hardening na Prática: Como Blindar seus Assets AGORA

Se você mantém uma fração do seu bankroll guardada em corretoras centralizadas pra girar no day trade — e vamos ser sinceros, todo trader ativo faz isso, apesar do mantra do "not your keys, not your coins" —, a hora de ligar o modo paranoia máxima é agora. Não fica esperando e-mail fofo do suporte, toma a iniciativa.

• Revogue IMEDIATAMENTE todas as API keys ativas que tenham permissão de saque (Withdrawal), mesmo que estejam travadas por IP whitelist. Sabe-se lá quais bancos de dados de acesso interno vazaram junto com o perímetro.
• Chaveie suas ações críticas usando um token físico de segurança (YubiKey ou padrão FIDO2/WebAuthn similar). Esqueça 2FA por SMS ou aquele Google Authenticator básico rodando em celular Android roteado ou vulnerável.

Pra galera dev que constrói soluções de custódia própria ou integrações com exchanges: o tráfego de saída precisa ser esmagado sem dó no nível do firewall. Se liga nesse exemplo de rate-limiter blindado pra rodar direto no backend:

import redis
import time
from fastapi import HTTPException
redis_client = redis.Redis(host='localhost', port=6379, db=0)
def enforce_withdrawal_rate_limit(user_id: str, amount_usd: float) -> bool:
    window_key = f"rate_limit:withdrawal:{user_id}"
    current_time = int(time.time())
    pipeline = redis_client.pipeline()
    
    pipeline.zremrangebyscore(window_key, 0, current_time - 3600)
    pipeline.zcard(window_key)
    pipeline.zadd(window_key, {str(current_time): current_time})
    pipeline.expire(window_key, 3600)
    
    _, active_requests_count, _, _ = pipeline.execute()
    
    if active_requests_count >= 3:
        raise HTTPException(status_code=429, detail="Too many withdrawal attempts. Security lockout engaged.")
        
    if amount_usd > 50000.0:
        manual_review_flag = f"review_required:{user_id}:{current_time}"
        redis_client.set(manual_review_flag, "1", ex=86400)
        return False
        
    return True

Mas pera aí, calma... Esqueci de mencionar um detalhe crucial que tá sendo o assunto principal entre os seniors de segurança nos canais fechados do Telegram. É que o grande X da questão nesse tipo de incidente nem é o hack em si, mas sim como a exchange vai se virar para cobrir esse rombo no caixa.

E aí surge a pergunta que não quer calar: será que a indústria vai finalmente superar essa doença infantil de confiar cegamente em hot wallets monolíticas? Spoiler: enquanto a ganância falar mais alto que a paranoia, esses fogos de artifício vão continuar acontecendo com uma regularidade impressionante.

Lições de Arquitetura: Por que as hot wallets tradicionais são uma bomba-relógio

Muita gente ainda insiste em projetar sistemas de custódia naquele modelo antigo: "um servidor parrudo com acesso às chaves privadas via arquivo criptografado no disco, escondido atrás de um firewall". Quando o perímetro vai pro espaço sob o impacto de um ataque direcionado (APT), esse servidor vira um verdadeiro banquete para os hackers, que rapam toda a liquidez em questão de minutos enquanto o sysadmin de plantão toma o café da manhã tranquilamente.

• Assinaturas Limiar (TSS): Divisão da chave em várias partes independentes distribuídas entre nós isolados, sem a necessidade de reconstituir a chave completa em um único ponto da rede.
• Módulos de Segurança de Hardware (HSM): Isolamento dos fluxos de assinatura diretamente no nível de hardware, com validação criptográfica rigorosa das regras.

Para quem quer implementar uma verificação de autenticidade de transações usando esquemas de limiar no seu homelab ou em produção, aqui vai um trecho de código em Python bem limpo. Ele barra qualquer tentativa de forja de assinatura no endpoint sem precisar carregar frameworks pesados:

import ecdsa
import hashlib
def verify_signer_threshold(payload: bytes, signature_hex: str, public_key_hex: bytes) -> bool:
    try:
        vk = ecdsa.VerifyingKey.from_string(bytes.fromhex(public_key_hex), curve=ecdsa.SECP256k1)
        sig = bytes.fromhex(signature_hex)
        return vk.verify(sig, payload, hashfunc=hashlib.sha256)
    except (ecdsa.BadSignatureError, ValueError):
        return False

Lógico que isso não é o protocolo FROST/CGGMP completo (que exige milhares de linhas de código e várias rodadas de interação), mas já traduz perfeitamente o conceito do esquema de limiar: exigir a participação de múltiplos validadores. O FROST é, de fato, um esquema limiar onde t participantes geram juntos uma assinatura válida.

Por hoje é isso, pessoal. Mandem suas dúvidas nos comentários que eu faço questão de responder todo mundo.