Neste Artigo
A Source Engine, motor gráfico de jogos desenvolvido pela Valve e utilizado por títulos como Counter-Strike: Global Offensive (CS:GO), Team Fortress 2, Portal e Half-Life 2, permanece ativa até hoje, com milhões de usuários em 2025. Apesar disso, a estrutura interna da engine mantém um legado técnico que, por trás de sua flexibilidade e poder, carrega sérios riscos de segurança cibernética.
Entre 2019 e 2021, diversas vulnerabilidades foram publicamente relatadas especialmente aquelas relacionadas à execução remota de código (RCE). O que muitos jogadores, administradores de servidores e até profissionais da área ignoram é que essa janela temporal ainda é extremamente recente em termos de segurança, especialmente quando falamos de falhas que afetam componentes centrais da arquitetura do jogo, como parsing de mapas, assets externos e manipulação de buffers.
O cenário de ameaça: ataques via mapas e servidores personalizados
Jogos como CS:GO são projetados para aceitar conteúdo personalizado. Isso inclui mapas (.bsp), sons (.wav), modelos (.mdl), texturas, scripts de entidade (.ent) e pacotes completos (.vpk).
Quando um jogador conecta a um servidor comunitário, o jogo automaticamente baixa todos os arquivos necessários sem qualquer sandboxing robusto ou verificação de integridade avançada.
Esse modelo favorece a criatividade, mas também abre uma brecha séria: basta um atacante hospedar um mapa malicioso para explorar falhas do parser do cliente. Se esse parser não validar corretamente os dados recebidos (como strings, buffers ou índices de array), é possível causar overflows, corromper memória ou até executar código arbitrário no computador da vítima.
Esse tipo de exploração foi possível, por exemplo, por meio da manipulação maliciosa de:
Campos no cabeçalho do mapa
.bsp, como o tamanho e número de entidadesScript de entidades (
entity lump) que define comportamentos no jogoVariações de pacotes
.vpkcom metadados corrompidosDados enviados por convites de servidor no Steam (como no caso de 2021, ainda sem patch completo até quase 2023)
2021 ainda é ontem em segurança
Pode parecer que um bug reportado em 2021 é “antigo”. Mas do ponto de vista de segurança digital, isso está a poucos ciclos de atualizações atrás. Principalmente em engines legadas como a Source Engine, onde atualizações críticas são raras, demoradas e com histórico de resposta lenta da desenvolvedora.
Em termos práticos:
O bug do Steam Invite (2021) permaneceu ativo por meses, mesmo após alertas de segurança
O ataque por mapas
.bspcorrompidos ainda pode ser reproduzido com engenharia reversaA maior parte dos servidores comunitários não validam os arquivos antes de aceitar uploads
Ou seja, mesmo que o executável do CS:GO atual tenha recebido patches, o ecossistema que envolve mapas, servidores e bibliotecas da engine continua exposto.
A arquitetura de segurança da Source Engine: legado e riscos
A Source Engine foi desenvolvida com foco em performance, jogabilidade e modabilidade. Mas não com segurança em mente. Componentes como:
O sistema de arquivos virtual (para carregar VPKs)
O módulo de parsing de mapas e entidades
A integração com a Steam via comandos de entrada externa
O carregamento dinâmico de bibliotecas (
vphysics.dll,engine.dll)
...têm histórico de falta de checagem de limites, uso de ponteiros sem proteção, e falhas em parsing que ignoram user input validation. Em ataques bem estruturados, esses pontos podem ser usados como trampolim para execução remota e persistência dentro do sistema da vítima.
Técnica: Explorando o RCE em mapas e servidores da Source Engine
Como o ataque realmente acontece
O vetor mais comum para RCE em jogos da Source Engine é através de arquivos .bsp (Binary Space Partition), que são os mapas do jogo. Esses arquivos contêm tudo: geometria do mapa, entidades (como portas, NPCs, explosivos), sons, scripts e referências a modelos e texturas. Dentro da estrutura de um .bsp, há seções chamadas lumps, que guardam diferentes tipos de dados binários.
Anatomia de um .bsp
Um .bsp é dividido em dezenas de lumps, como:
Entities Lump: Armazena os scripts e configurações das entidades do mapa em formato string.
Model Lump: Modelos estáticos e móveis do mapa.
Pakfile Lump: Um mini-VPK embutido com arquivos extras (sons, scripts, etc.).
Texture Data Lump: Dados de textura usados nas superfícies.
Leaf Lump, Node Lump: Estrutura de divisão do mundo 3D para renderização e colisão.
Essas seções são lidas sequencialmente pela engine. E é aqui que mora o perigo: nem todos os campos são validados corretamente quanto ao tamanho ou conteúdo. Em testes passados, já foi possível:
Criar entidades com valores extremamente grandes ou negativos
Substituir valores de posição por referências a áreas de memória
Abusar do Pakfile para forçar a leitura de arquivos DLL ou executáveis disfarçados
Exemplo prático de RCE via Entity Lump
A Entity Lump é um campo de texto com várias definições do tipo:
| { "classname" "logic_relay" "targetname" "run_code" "OnTrigger" "player,RunScriptCode,os.execute('calc.exe'),0,-1" } |
A engine não interpreta diretamente Lua ou código nativo, mas em versões anteriores e com uso de complementos ou hooks externos, era possível manipular esse campo para disparar ações perigosas. Mesmo sem os.execute, muitas falhas antigas permitiam:
Injeção de código nas chamadas de eventos
Abuso da função
OnUser1,OnTimerouOnPlayerSpawnpara executar loopsCriação de loops infinitos que causam denial of service ou corrompem a pilha
Além disso, há casos onde o cliente carrega bibliotecas compartilhadas (.dll ou .so) do mapa caso estejam no Pakfile e sejam referenciadas por algum script do jogo.
Persistência e pós-exploração
Após a execução inicial, o atacante pode persistir no sistema da vítima de diversas formas:
Colocar executáveis dentro de pastas do jogo (
csgo/custom/) que sejam chamados em cada inicialização.Modificar scripts de inicialização como
autoexec.cfgpara chamar código externo.Instalar malwares reais, como stealer ou keylogger, que rodam em background.
Colocar scripts em
Steam/config/ou manipular os arquivos.vdf.
Em casos reais, já foi identificado malware que se disfarçava de arquivo .wav ou .mdl, era baixado com o mapa e depois extraído por scripts usando falhas antigas no sistema de addons da engine.
Ferramentas que auxiliaram os ataques
GCFScape: para abrir arquivos
.vpke.pakembutidosBSPSource: decompilar mapas
.bspe manipular entidadesHL2 SDK: usado para entender os parsers de mapas
Python e C: para montar payloads que visavam RCE por overflow
Defesa e mitigação
Apesar dos riscos, existem formas de se proteger:
Nunca aceitar mapas de fontes desconhecidas
Desativar o download automático de conteúdo
Monitorar modificações em pastas como
custom,cfg,binUsar antivírus com escaneamento em tempo real de downloads
Administradores de servidores devem usar plugins que bloqueiem Pakfiles externos
Conclusão
O caso das vulnerabilidades de RCE na Source Engine é um alerta claro: mesmo jogos famosos, mantidos por grandes empresas como a Valve, podem carregar falhas estruturais sérias que sobrevivem por anos. Em um cenário onde milhões de jogadores ainda acessam servidores personalizados com arquivos não verificados, as chances de exploração silenciosa ainda existem em 2025.
Jogos antigos, quando combinados com uma engine poderosa e permissiva como a Source, são alvos perfeitos para ataques sofisticados, principalmente com a popularização de malware distribuído via gaming. É fundamental que a comunidade e os profissionais de segurança não subestimem essas ameaças. Afinal, uma simples partida em um mapa “novo” pode ser a porta de entrada para o comprometimento completo de um sistema.
Referências e Ferramentas
Relatórios e CVEs
