Hacking de jogos

Prévia do material em texto

03/07/2021 Hacking de jogos
https://translate.googleusercontent.com/translate_f 1/187
Página 1
dentro do jogo
Cano
Ha
Dese
pDesenvolvimento de
Página 2
Hacking de jogos
03/07/2021 Hacking de jogos
https://translate.googleusercontent.com/translate_f 2/187
www.allitebooks.com
Página 3
https://translate.google.com/translate?hl=pt-BR&prev=_t&sl=en&tl=pt&u=http://www.allitebooks.org
03/07/2021 Hacking de jogos
https://translate.googleusercontent.com/translate_f 3/187
www.allitebooks.com
Página 4
JOGOS
HACKING
Desenvolvimento autônomo
Bots para jogos online
por Nick Cano
São Francisco
www.allitebooks.com
Página 5
Hacking do jogo. Copyright © 2016 por Nick Cano.
Todos os direitos reservados. Nenhuma parte deste trabalho pode ser reproduzida ou transmitida de qualquer forma ou por qualquer meio,
eletrônico ou mecânico, incluindo fotocópia, gravação ou por qualquer armazenamento ou recuperação de informações
sistema, sem a permissão prévia por escrito do proprietário dos direitos autorais e do editor.
Impresso nos EUA
Primeira impressão
20 19 18 17 16 1 2 3 4 5 6 7 8 9
ISBN-10: 1-59327-669-9
ISBN-13: 978-1-59327-669-0
Editor: William Pollock
Editor de produção: Laurel Chun
Ilustração da capa: Ryan Milner
Design de interiores: Octopod Studios
Editor de Desenvolvimento: Jennifer Griffith-Delgado
Revisor Técnico: Stephen Lawler
Editora de Texto: Rachel Monaghan
Compositor: Laurel Chun
Revisor: Paula L. Fleming
Indexador: BIM Creatives, LLC
Para obter informações sobre distribuição, traduções ou vendas a granel, entre em contato diretamente com a No Starch Press, Inc.:
No Starch Press, Inc.
245 8th Street, San Francisco, CA 94103
telefone: 415.863.9900; info@nostarch.com
www.nostarch.com
Dados de Catalogação na Publicação da Biblioteca do Congresso
Cano, Nick, autor.
https://translate.google.com/translate?hl=pt-BR&prev=_t&sl=en&tl=pt&u=http://www.allitebooks.org
https://translate.google.com/translate?hl=pt-BR&prev=_t&sl=en&tl=pt&u=http://www.allitebooks.org
https://translate.google.com/translate?hl=pt-BR&prev=_t&sl=en&tl=pt&u=http://www.nostarch.com
03/07/2021 Hacking de jogos
https://translate.googleusercontent.com/translate_f 4/187
Hacking de jogos: desenvolvendo bots autônomos para jogos online / por Nick Cano.
páginas cm
Inclui índice.
Resumo: "Um guia prático para hackear jogos de computador. Mostra aos programadores como dissecar o computador
jogos e criar bots para alterar seu ambiente de jogo. Abrange os conceitos básicos de hacking de jogos,
incluindo engenharia reversa, análise de código de montagem, manipulação de memória programática, persistente
hacks, hacks responsivos e injeção de código. "- Fornecido pelo editor.
ISBN 978-1-59327-669-0 - ISBN 1-59327-669-9
1. Agentes inteligentes (software de computador) 2. Programação para Internet. 3. Jogos da Internet -
Programação. 4. Hacking. I. Título.
QA76.76.I58C36 2016
005,8 - dc23
2015036294
No Starch Press e o logotipo No Starch Press são marcas registradas da No Starch Press, Inc. Outros
os nomes de produtos e empresas mencionados aqui podem ser marcas comerciais de seus respectivos proprietários. Em vez de
do que usar um símbolo de marca registrada em cada ocorrência de um nome de marca registrada, estamos usando apenas os nomes
de forma editorial e em benefício do proprietário da marca, sem intenção de violação do
marca comercial.
As informações neste livro são distribuídas "no estado em que se encontram", sem garantia. Enquanto todas as precauções
foi tomada na preparação deste trabalho, nem o autor nem a No Starch Press, Inc. deve ter qualquer
responsabilidade para qualquer pessoa ou entidade com relação a qualquer perda ou dano causado ou alegadamente causado diretamente ou
indiretamente pelas informações nele contidas.
www.allitebooks.com
Página 6
Sobre o autor
Nick Cano escreveu seus primeiros scripts para servidores de jogos de código aberto quando
tinha 12 anos e começou um negócio vendendo seus bots quando ele tinha 16. Ele tem
faz parte da comunidade de hackers de jogos desde então e aconselha jogos
desenvolvedores e designers sobre as práticas recomendadas para proteger seus jogos contra
bots. Nick também tem anos de experiência na detecção e defesa contra
malware, e ele falou em muitas conferências sobre sua pesquisa e
Ferramentas.
sobre o revisor técnico
Stephen Lawler é o fundador e presidente de um pequeno software de computador
e firma de consultoria de segurança. Ele tem trabalhado ativamente com informação
segurança por mais de 10 anos, principalmente em engenharia reversa, análise de malware
sis e pesquisa de vulnerabilidade. Ele era um membro do malware Mandiant
equipe de análise e auxiliou com intrusões de computador de alto perfil que afetam
várias empresas da Fortune 100. Stephen também desenvolveu e ensina o
Aula prática de exploração ARM, que foi oferecida na BlackHat e
várias outras conferências de segurança nos últimos cinco anos.
www.allitebooks.com
Página 7
https://translate.google.com/translate?hl=pt-BR&prev=_t&sl=en&tl=pt&u=http://www.allitebooks.org
https://translate.google.com/translate?hl=pt-BR&prev=_t&sl=en&tl=pt&u=http://www.allitebooks.org
03/07/2021 Hacking de jogos
https://translate.googleusercontent.com/translate_f 5/187
www.allitebooks.com
Página 8
CONTEÚDOS RESUMIDOS
Prefácio do Dr. Jared DeMott. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xv
Agradecimentos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .xvii
Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xix
PARTE 1: FERRAMENTAS DO COMÉRCIO
Capítulo 1: Varredura de memória usando o Cheat Engine. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
Capítulo 2: Depurando jogos com OllyDbg. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Capítulo 3: Reconhecimento com Process Monitor e Process Explorer. . . . . . . . . . . . . . . 49
PARTE 2: DISSECÇÃO DO JOGO
Capítulo 4: Do Código à Memória: Um Manual Geral. . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
Capítulo 5: Análise forense avançada de memória. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
Capítulo 6: Lendo e gravando na memória do jogo. . . . . . . . . . . . . . . . . . . . . . . . 119
PARTE 3: PUPPETEERING DE PROCESSO
Capítulo 7: Injeção de código. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
Capítulo 8: Manipulando o Fluxo de Controle em um Jogo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
https://translate.google.com/translate?hl=pt-BR&prev=_t&sl=en&tl=pt&u=http://www.allitebooks.org
03/07/2021 Hacking de jogos
https://translate.googleusercontent.com/translate_f 6/187
PARTE 4: CRIANDO BOTS
Capítulo 9: Usando a percepção extra-sensorial para afastar a névoa de guerra. . . . . . . . . . . . . . . . 189
Capítulo 10: Hacks responsivos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
Capítulo 11: Juntando tudo: Escrevendo Bots Autônomos. . . . . . . . . . . . . . . . . . . . . 221
Capítulo 12: Permanecendo Oculto. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245
Índice. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265
www.allitebooks.com
Página 9
www.allitebooks.com
Página 10
CONTEÚDOS EM DEtAL
PREFÁCIO pelo dr. Jared Demott xv
acknOwLedGmenTS xvii
https://translate.google.com/translate?hl=pt-BR&prev=_t&sl=en&tl=pt&u=http://www.allitebooks.org
https://translate.google.com/translate?hl=pt-BR&prev=_t&sl=en&tl=pt&u=http://www.allitebooks.org
03/07/2021 Hacking de jogos
https://translate.googleusercontent.com/translate_f 7/187
introdução xix
Pré-requisitos para o leitor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . xx
Uma breve história de hackeamento do jogo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xx
Por que hackear jogos? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xxi
Como este livro está organizado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xxii
Sobre os recursos online. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .xxiv
Como usar este livro. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .xxiv
PaRT 1
FERRAMENTAS DO COMÉRCIO
1
ScannGing memORy uSinG cHeaT enGine 3
Por que os scanners de memória são importantes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
Varredura de memória básica. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
Scanner de memória do Cheat Engine. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Tipos de digitalização. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Executando sua primeira varredura. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Próximas varreduras. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Quando você não consegue obter um único resultado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Tabelas de trapaça. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Modificação de memória em jogos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Modificação manual com Cheat Engine. . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Trainer Generator. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Varredura de ponteiro. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
Cadeias de ponteiros. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
Fundamentos da varredura de ponteiro. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
Pointer Scanning with Cheat Engine. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Rescanning do ponteiro. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
Ambiente de script Lua. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
Procurando padrões de montagem. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
Procurando Strings. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
Pensamentos finais. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
www.allitebooks.com
Página 11
2
depurar jogos com OLLydbG 23
Uma breve olhada na interface do usuário do OllyDbg. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
Janela da CPU de OllyDbg. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
Visualizando e navegando no código de montagem de um jogo. . . . . . . . . . . . . . . . . . . 27
Visualizando e editando o conteúdo do registro. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Visualizando e pesquisando a memória de um jogo. . . . . . . . . . . . . . . . . . . . . . . . . 29
Visualizando a Pilha de Chamadas de um Jogo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
Criando Patches de Código. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
Rastreamento através do código de montagem. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Motor de expressão de OllyDbg. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
Usando expressões em pontos de interrupção. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Usando operadores no Expression Engine. . . . . . . . . . . . . . . . . . . . . . . . . . 34
Trabalhando com elementos básicos de expressão. . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Acessando o conteúdo da memória com expressões. . . . . . . . . . . . . . . . . . . . . . . 36
Expressões OllyDbg em ação. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Pausando a execução quando o nome de um jogador específico é impresso. . . . . . . . . . . . . 37
Pausando a execução quando a saúde do seu personagem diminui. . . . . . . . . . . . . . . 39
Plug-ins OllyDbg para hackers de jogos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Copiando o código de montagem com Asm2Clipboard. . . . . . . . . . . . . . . . . . . . . . . 42
Adicionando Cheat Engine ao OllyDbg com Cheat Utility. . . . . . . . . . . . . . . . . . . . 42
Controlando OllyDbg por meio da linha de comando. . . . . . . . . . . . . . . . . . . . . . 43
Visualizando o fluxo de controle com OllyFlow. . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
Pensamentos finais. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
3
RECONHECIMENTO COM MOnTOR DE PROCESSO
e PROCESS EXPLOReR 49
Monitor de processo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
Registrando eventos no jogo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
Inspecionando Eventos no Log do Monitor de Processo. . . . . . . . . . . . . . . . . . . . . . . . . 52
Depurando um jogo para coletar mais dados. . . . . . . . . . . . . . . . . . . . . . . . . . 53
Process Explorer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
Interface do usuário e controles do Process Explorer. . . . . . . . . . . . . . . . . . . . . . . 56
Examinando as propriedades do processo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
Opções de manipulação de manipulação. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
Pensamentos finais. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
Parte 2
DiSSecçãO do jogo
https://translate.google.com/translate?hl=pt-BR&prev=_t&sl=en&tl=pt&u=http://www.allitebooks.org
03/07/2021 Hacking de jogos
https://translate.googleusercontent.com/translate_f 8/187
x Conteúdo em detalhe
4
FROm cOde to memORy: a GeneRaL PRimeR 65
Como as variáveis e outros dados se manifestam na memória. . . . . . . . . . . . . . . . . . . . . . . . . 66
Dados numéricos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
String Data. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
Estruturas de dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
Página 12
Conteúdo em detalhe XI
Sindicatos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
Classes e tabelas de VF. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
Curso intensivo de montagem x86. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
Sintaxe do comando. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
Registros do processador. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
A pilha de chamadas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
Instruções importantes do x86 para hack de jogos. . . . . . . . . . . . . . . . . . . . . . . . 89
Pensamentos finais. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . 96
5
FORENSICS DE MEMÓRIA AVANÇADA 97
Varredura de memória avançada. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
Deduzindo o propósito. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
Encontrando a Saúde do Jogador com OllyDbg. . . . . . . . . . . . . . . . . . . . . . . . . . . 99
Determinando novos endereços após as atualizações do jogo. . . . . . . . . . . . . . . . . . . 101
Identificando Estruturas Complexas em Dados de Jogo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
A classe std :: string. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
A classe std :: vector. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
A classe std :: list. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
A classe std :: map. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
Pensamentos finais. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
6
Lendo FROm e ESCREVENDO A MEMÓRIA DO JOGO 119
Obtenção do identificador de processo do jogo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
Obtenção de identificadores de processo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
Trabalhando com OpenProcess (). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
Acessando a memória. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
Trabalhando com ReadProcessMemory () e WriteProcessMemory (). . . . . . . . . 122
Acessando um valor na memória com ReadProcessMemory ()
e WriteProcessMemory (). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
Escrevendo funções de acesso à memória modelada. . . . . . . . . . . . . . . . . . . . . . . 123
Proteção de memória. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
Diferenciando os atributos de proteção de memória do Windows x86. . . . . . . . . . . . . 125
Alterando a proteção da memória. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
Randomização do Layout do Espaço de Endereço. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
Desativando ASLR para simplificar o desenvolvimento de bots. . . . . . . . . . . . . . . . . . . . . . . . 128
Ignorando ASLR na produção. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
Pensamentos finais. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
PaRT 3
PROCESS PuPPeTeeRinG
7
cOde inJecTiOn 133
Injetando Cavernas de Código com Injeção de Thread. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
Criando uma Caverna de Código de Montagem. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
Traduzindo o Assembly para Shellcode. . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
Página 13
Escrevendo a Caverna de Código na Memória. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
Usando Injeção de Thread para Executar a Caverna de Código. . . . . . . . . . . . . . . . . . . . 137
Sequestrando o thread principal de um jogo para executar as cavernas de código. . . . . . . . . . . . . . . . . . . . 138
Construindo a Caverna do Código de Montagem. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
Gerando Código Shell de Esqueleto e Alocando Memória. . . . . . . . . . . . . . . . 140
Localizando e congelando o thread principal. . . . . . . . . . . . . . . . . . . . . . . . . . . 141
Injetando DLLs para controle total. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
Enganando um processo para carregar sua DLL. . . . . . . . . . . . . . . . . . . . . . . . . . 143
Acessando a memória em uma DLL injetada. . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
Ignorando ASLR em uma DLL injetada. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
Pensamentos finais. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
8
MANIPULAÇÃO DO FLUXO DE CONTROLE EM UM JOGO 149
NOPing para remover código indesejado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
Quando NOP. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
Como fazer NOP. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
Enganchando para redirecionar a execução do jogo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
03/07/2021 Hacking de jogos
https://translate.googleusercontent.com/translate_f 9/187
xii Conteúdo em detalhe
Call Hooking. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
VF Table Hooking. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
IAT Hooking. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
Jump Hooking. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
Aplicação de ganchos de chamada ao Adobe AIR. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
Acessando o RTMP Goldmine. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
Conectando a função encode () do RTMPS. . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
Conectando a função decode () do RTMPS. . . . . . . . . . . . . . . . . . . . . . . . . . . . 172
Colocando os ganchos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
Aplicando Jump Hooks e VF Hooks ao Direct3D. . . . . . . . . . . . . . . . . . . . . . . . . . . 175
O loop de desenho. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176
Encontrando o dispositivo Direct3D. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
Escrevendo um gancho para EndScene (). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
Escrevendo um Gancho para Reset (). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
Qual é o próximo?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
Pensamentos finais. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
PaRT 4
cReaTing bOTS
9
USANDO O EXTRASENSÓRIO PERCEPÇÃO PARA DESLIGAR
Névoa da Guerra 189
Conhecimento prévio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
Revelando detalhes ocultos com Lighthacks. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
Adicionando uma fonte de luz ambiente central. . . . . . . . . . . . . . . . . . . . . . . . . . . 190
Aumentando a luz ambiente absoluta. . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
Criando outros tipos de Lighthacks. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
Página 14
Revelando inimigos furtivos com Wallhacks. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
Renderizando com Z-Buffering. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
Criando um Wallhack Direct3D. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
Impressão digital do modelo que você deseja revelar. . . . . . . . . . . . . . . . . . . . . . . 196
Obtendo um campo de visão mais amplo com o Zoomhacks. . . . . . . . . . . . . . . . . . . . . . . . . . . 197
Usando NOPing Zoomhacks. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
Arranhar a superfície dos Zoomhacks de enganchamento. . . . . . . . . . . . . . . . . . . . . . 198
Exibindo dados ocultos com HUDs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . 198
Criando um HUD de experiência. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
Usando ganchos para localizar dados. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
Uma Visão Geral de Outros Hacks ESP. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
Pensamentos finais. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
10
Hacks ReSPOnSive 203
Observando eventos do jogo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204
Memória de monitoramento. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204
Detectando pistas visuais. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205
Interceptando o tráfego da rede. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
Execução de ações no jogo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211
Emulando o teclado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211
Enviando pacotes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215
Amarrando as peças juntas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
Fazendo o Curandeiro Perfeito. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
Resistindo a ataques de controle de multidão do inimigo. . . . . . . . . . . . . . . . . . . . . . . . . . . 218
Evitando Mana Desperdiçado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
Pensamentos finais. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
11
PUTANDO TUDO JUNTO:
MANUTENÇÃO DE BOTÕES AUTOMÁTICOS 221
Teoria de controle e hacking de jogos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
Máquinas de estado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
Combinando Teoria de Controle e Máquinas de Estado. . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
Uma Máquina de Estado Básica do Curandeiro. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
Uma Máquina de Estado Hipotética Complexa. . . . . . . . . . . . . . . . . . . . . . . . . . . 228
Correção de erros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230
Pathfinding com algoritmos de pesquisa. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232
Duas técnicas de pesquisa comuns. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
Como os obstáculos interrompem as pesquisas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
Um algoritmo de pesquisa A *. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234
Quando as pesquisas A * são particularmente úteis. . . . . . . . . . . . . . . . . . . . . . . . . 240
Hacks automatizados comuns e interessantes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241
Pilhagem com Cavebots. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241
Automatizando Combate com Warbots. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243
Pensamentos finais. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244
03/07/2021 Hacking de jogos
https://translate.googleusercontent.com/translate_f 10/187
Conteúdo em detalhe xiii
Página 15
xiv Conteúdo em detalhe
12
STayinG Hidden 245
Software anti-cheat proeminente. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246
O PunkBuster Toolkit. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246
Detecção baseada em assinatura. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246
Capturas de tela. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247
Validação de hash. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247
O ESEA Anti-Cheat Toolkit. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247
O kit de ferramentas VAC. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247
Varreduras de cache DNS. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248
Validação binária. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248
Falso-positivo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248
O GameGuard Toolkit. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248
Rootkit em modo de usuário. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248
Rootkit em modo kernel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249
O Warden Toolkit. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249
Gerenciando cuidadosamente a pegada de um bot. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250
Minimizando a pegada de um bot. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250
Mascarando sua pegada. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251
Ensinando um bot a detectar depuradores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251
Técnicas anti-depuração. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255
Derrotando a detecção baseada em assinatura. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256
Derrotando screenshots. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258
Derrotando a validação binária. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259
Derrotando um Rootkit anti-cheat. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261
Derrotando Heurísticas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262
Pensamentos finais. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263
índice 265
Página 16
prefácio
03/07/2021 Hacking de jogos
https://translate.googleusercontent.com/translate_f 11/187
Nick é ótimo. Primeiro nos demos bem de todas as maneiras certas e erradas, como você pode
Imagine. Estou no campo da segurança há um tempo; ele é um pouco mais jovem. eu tenho tido
a escolaridade, ao passo que ele não é muito para a faculdade. Eu sou um cara de fé, e ele é
não. O interessante é que nada disso importa; nós tivemos uma explosão
qualquer maneira. Idade, raça, gênero, graus - quando se trata de jogos, hacking e
codificação, ninguém se importa!
Nick faz isso. Ele é divertido. Ele é brilhante. Ele trabalha duro. E prob-
habilmente mais pertinente: ele é um dos raros poucos que entendem o
ção de jogos, hacking e codificação. Ele trabalhou neste nicho e criou
bots lucrativos.
Neste livro inédito, Nick explica o que significa
separar jogos. Ele ensina as ferramentas e truques de investigação de software
do comércio. Você aprenderá sobre os componentes internos do jogo, como separá-los e
como modificar o jogo. Por exemplo, Nick ensina como evitar o anti-cheat para
que você pode automatizar o jogo. Não seria legal ter seu próprio bot que
coleta experiência, ouro, itens e muito mais - tudo enquanto você está fora?
Você já se perguntou como os trapaceiros trapaceiam? Sempre quis remendar ou proteger
seu jogo? Pegue um café, abra seu laptop e divirta-se.
Bênçãos para você e seus,
Dr. Jared DeMott
Especialista em segurança e construtor de software
Página 17Página 18
AGRADECIMENTOS
Escrever este livro foi uma jornada incrível,e eu não poderia ter feito isso
sozinho. No Starch Press tem sido extremamente favorável e trabalhado em estreita colaboração
comigo para levar este livro do conceito à realidade. Em particular, eu gostaria de
agradeço a minha editora de desenvolvimento, Jennifer Griffith-Delgado, e meu produtor
editora de certificação, Laurel Chun. Bill Pollock, Tyler Ortman, Alison Law e o
o resto da equipe da No Starch são pessoas maravilhosas, e estou feliz por ter
trabalhei com eles.
Agradecimentos à editora Rachel Monaghan, revisora Paula L. Fleming,
e revisor técnico Stephen Lawler. Agradeço também aos meus amigos Cavitt
“Synt4x” Glover e Vadim Kotov, que se deram ao trabalho de folhear alguns capítulos
antes da submissão, e a Jared DeMott por escrever o prefácio do livro.
Eu gostaria de agradecer a todas as pessoas no TPForums que me acolheram quando eu
era apenas uma criança ingênua e me ajudou a aprender como hackear jogos. Em particular,
Devo meus agradecimentos a Joseph “jo3bingham” Bingham, Ian Obermiller e
jerêmica, que teve uma influência significativa em minha progressão como hacker,
e ao fundador do TPForums, Josh “Zyphrus” Hartzell, que me ajudou a encontrar meu
confiança e habilidades quando meu futuro parecia mais sombrio.
Agradeço também a toda a minha equipe do fórum e a todos os clientes que já
usei meus bots. E, finalmente, graças à minha família, amigos e colegas,
que têm sido divertidos e solidários e ajudaram a me transformar no homem que sou
hoje.
Página 19Página 20
03/07/2021 Hacking de jogos
https://translate.googleusercontent.com/translate_f 12/187
Introdução
Um equívoco comum no mundo
de jogos online é a ideia de que o único
o jogo que você pode jogar é o do título.
Na verdade, os hackers gostam de jogar o jogo
que se esconde atrás da cortina: um jogo de gato e rato
de inteligência entre eles e os desenvolvedores do jogo. Enquanto
hackers de jogos trabalham para fazer engenharia reversa de binários de jogos, automatizar aspectos
de jogo e modificar ambientes de jogo, combate de desenvolvedores de jogos
as ferramentas projetadas por hackers (normalmente chamadas de bots ) usando anti-reversão
técnicas, algoritmos de detecção de bot e mineração de dados heurística.
À medida que a batalha entre hackers e desenvolvedores de jogos progredia, o
métodos técnicos implementados por ambas as partes, muitos dos quais se assemelham
técnicas utilizadas por desenvolvedores de malware e fornecedores de antivírus - têm
evoluiu, tornando-se mais complexo. Este livro destaca a luta levantada por
hackers de jogos e os métodos avançados que eles desenvolveram para manipular
jogos atrasados e, ao mesmo tempo, iludindo desenvolvedores de jogos no escuro
usuários de seu próprio software.
Página 21
Embora o livro se concentre em ensinar você a desenvolver ferramentas que
provavelmente ser considerado um incômodo ou até mesmo malicioso por empresas de jogos,
você descobrirá que muitas das técnicas são úteis para o desenvolvimento de ferramentas
que são perfeitamente benignos e neutros. Além disso, o conhecimento de como
essas técnicas são implementadas é a chave para o trabalho dos desenvolvedores de jogos
para evitar seu uso.
Pré-requisitos para o leitor
Este livro não tem como objetivo ensinar desenvolvimento de software e, portanto,
pressupõe que você tenha, no mínimo, um sólido back-back de desenvolvimento de software
chão. Este histórico deve incluir familiaridade com o Windows nativo
desenvolvimento baseado, bem como experiência leve com desenvolvimento de jogos e
gerenciamento de memória. Embora essas habilidades sejam suficientes para você seguir
neste livro, a experiência com x86 assembly e componentes internos do Windows irá garantir
que os detalhes de implementações mais avançadas não são perdidos por você.
Além disso, uma vez que todos os hacks avançados discutidos neste livro dependem
na injeção de código, a capacidade de escrever código em uma linguagem nativa como C ou
C ++ é uma obrigação. Todo o código de exemplo neste livro é escrito em C ++ e
pode ser compilado com o Microsoft Visual C ++ Express Edition. (Você pode
baixe o MSVC ++ Express Edition em http://www.visualstudio.com/en-US/
produtos / visual-studio-express-vs .)
Nota Outras linguagens que compilam para código nativo, como Delphi, também são capazes de injetar
, mas não os discutirei neste livro.
um breve histórico de hackers em jogos
Desde o início dos jogos online para PC no início dos anos 1980, uma guerra contínua de
A inteligência entre hackers e desenvolvedores de jogos vem ocorrendo.
Esta luta aparentemente interminável levou os desenvolvedores de jogos a dedicar
03/07/2021 Hacking de jogos
https://translate.googleusercontent.com/translate_f 13/187
xx Introdução
incontáveis horas para evitar que hackers desmontem seus jogos
e lubrificação entre as engrenagens. Esses hackers, que revidam com seus
implementações furtivas sofisticadas, têm muitas motivações: personalizadas
gráficos, melhor desempenho, facilidade de uso, jogo autônomo, recursos no jogo
aquisição e, claro, lucro na vida real.
O final dos anos 1990 e o início dos anos 2000 foram a era de ouro do hacking de jogos,
quando os jogos online para PC se tornaram avançados o suficiente para atrair grandes multidões
mas ainda eram simples o suficiente para facilmente fazer engenharia reversa e manipular.
Jogos online que surgiram nessa época, como Tibia (janeiro de 1997),
Runescape (janeiro de 2001) e Ultima Online (setembro de 1997) foram fortemente
direcionado por desenvolvedores de bot. Os desenvolvedores desses jogos e outros como
eles ainda lutam hoje para controlar as enormes comunidades de desenvolvimento de bots
opers e usuários de bot. A falta de ação dos desenvolvedores de jogos e dos hackers
Página 22
Introdução xxi
a tenacidade não só destruiu completamente as economias dos jogos,
mas também produziram uma indústria próspera com fins lucrativos focada em bot
desenvolvimento e defesa de bot.
Nos anos desde a idade de ouro, as empresas de jogos mais maduras
começou a levar a defesa de bots muito a sério. Essas empresas agora têm dedi-
equipes designadas com foco no desenvolvimento de sistemas de prevenção de bots, e muitos também
vê os bots como uma questão legal e não hesitará em banir os jogadores que usam
bots e processar os desenvolvedores de bot que os forneceram. Como resultado, muitos jogos
hackers foram forçados a desenvolver técnicas avançadas de furtividade para manter
seus usuários estão seguros.
Esta guerra continua, e os números de ambos os lados da luta irão contra
continua a crescer à medida que os jogos online se tornam mais prevalentes no futuro
anos. Os principais desenvolvedores de jogos estão perseguindo hackers com determinação infinita.
ção, até mesmo atacando alguns gigantes do hacking de jogos com milhões de dólares
ações judiciais. Isso significa que os hackers de jogos que levam seus negócios a sério
devem ter como alvo empresas de jogos menores ou comercializar anonimamente seus
produtos das sombras, a fim de escapar da acusação. Para o previsto
futuro, hacking de jogos e desenvolvimento de bots continuarão a crescer em
uma indústria maior e mais lucrativa para os hackers de jogos ousados o suficiente para
assumir os riscos.
porque Hack Games?
Além de seu atrativo óbvio e natureza desafiadora, o hacking de jogos
alguns objetivos práticos e lucrativos. Todos os dias, milhares de novatos
programadores experimentam hacking de jogos em pequena escala como uma forma de automatizar
tarefas monótonas ou executar ações servis. Esses script kiddies usarão
ferramentas de automação como AutoIt para seus pequenos hacks relativamente inofensivos. Sobre
por outro lado, hackers de jogos profissionais, apoiados por seus grandes kits de ferramentas
e anos de experiência em programação, dedicará centenas de horas ao
desenvolvimento de hacks de jogos avançados. Esses tipos de hacks de jogos, que
são o foco deste livro, muitas vezes são criados com a intenção de tornar grandes
quantias de dinheiro.
Os jogossão uma grande indústria que gerou US $ 22,4 bilhões em vendas em
2014, de acordo com a Entertainment Software Association. Das dezenas
de milhões de jogadores que jogam diariamente, 20 por cento jogam massivamente multi
jogos de RPG online (MMORPGs). Esses MMORPGs frequentemente
tem milhares de jogadores que negociam bens virtuais dentro do próspero jogo
economias. Os jogadores muitas vezes precisam de recursos no jogo e estão dispostos a
compre esses ativos com dinheiro do mundo real. Consequentemente, jogadores de MMORPG
acabam desenvolvendo grandes comunidades que fornecem serviços ouro por dinheiro.
Esses serviços muitas vezes vão tão longe quanto a aplicação de taxas de câmbio do jogo
ouro para moedas do mundo real.
Para tirar vantagem disso, os hackers de jogos criarão bots que são capazes
de cultivar ouro automaticamente e nivelar personagens. Então, dependendo
em seu objetivo, os hackers criarão enormes fazendas de ouro e venderão seus
Página 23
lucros no jogo, ou aperfeiçoe e venda seu software para jogadores que desejam
obter níveis e ouro perfeitamente com o mínimo de interferência. Devido ao
enormes comunidades em torno de MMORPGs populares, esses hackers de jogos
pode fazer entre seis e sete dígitos anualmente.
Embora os MMORPGs forneçam a maior superfície de ataque para hackers, eles
têm um público relativamente pequeno em geral. Cerca de 38 por cento dos jogadores favorecem
jogos de estratégia em tempo real (RTS) e enormes jogos de arena de batalha online (MOBA),
e outros 6% jogam principalmente jogos de tiro em primeira pessoa (FPS).
Esses jogos competitivos jogador versus jogador (PvP) representam coletivamente
03/07/2021 Hacking de jogos
https://translate.googleusercontent.com/translate_f 14/187
xxii Introdução
44 por cento do mercado de jogos e oferece grandes recompensas para determinados
hackers de jogos.
Os jogos PvP costumam ser episódicos por natureza; cada partida é um jogo isolado,
e normalmente não há muita progressão lucrativa para o uso de bots fora do
teclado (AFK). Isso significa que, em vez de administrar fazendas de ouro ou criações
usando bots autônomos para aumentar o nível dos personagens, os hackers criarão bots reativos
que auxiliam os jogadores em combate.
Esses jogos altamente competitivos são sobre habilidade e tática, e a maioria
jogadores participam para provar suas habilidades para si próprios e para os outros. Como um
conseqüência, o número de pessoas procurando bots para jogos do tipo PvP é
substancialmente mais baixo do que você encontraria no mundo pesado dos MMORPGs.
No entanto, os hackers ainda podem ganhar muito dinheiro vendendo seus bots PvP,
que geralmente são muito mais fáceis de desenvolver do que bots autônomos completos.
Como este livro está organizado
Este livro está dividido em quatro partes, cada uma das quais se concentra em um núcleo diferente
aspecto do hack de jogos. Na Parte 1: Ferramentas do Comércio , você receberá uma caixa cheia
de ferramentas para ajudá-lo a hackear jogos.
• Capítulo 1: Varredura de memória usando o Cheat Engine irá ensiná-lo como
para verificar a memória de um jogo em busca de valores importantes usando o Cheat Engine.
• No Capítulo 2: Depurando jogos com OllyDbg , você obterá um travamento
curso de depuração e engenharia reversa com OllyDbg. O
habilidades que você aprende aqui serão extremamente úteis quando você começar a fazer
bots avançados e injeção de código.
• Para finalizar, Capítulo 3: Reconhecimento com Monitor de Processo e
Process Explorer , irá ensiná-lo a usar duas ferramentas de reconhecimento para
inspecionar como os jogos interagem com arquivos, outros processos, a rede e
o sistema operacional.
Os recursos online para cada capítulo da Parte 1 incluem binários personalizados
Eu criei para lhe dar um lugar seguro para testar e aprimorar seus recém-descobertos
Habilidades.
Quando estiver confortável com cada chave e martelo, Parte 2: Jogo
Dissecação , vai te ensinar como entrar no capô e descobrir como
jogos funcionam.
Página 24
• No Capítulo 4: Do Código à Memória: Um Manual Geral , você aprenderá
como o código-fonte e os dados de um jogo se parecem, uma vez compilados em um
binário do jogo.
• Capítulo 5: Análise de memória avançada baseia-se no conhecimento
você aprenderá com o Capítulo 4. Você aprenderá como escanear a memória e usar
depuração para localizar perfeitamente valores de memória complicados e dissecar
classes e estruturas complexas.
• Finalmente, o Capítulo 6: Lendo e escrevendo na memória do jogo mostra
você como ler e modificar dados em um jogo em execução.
Estes capítulos fornecem muitos exemplos de código de prova de conceito em profundidade
que você pode usar para verificar tudo o que lê.
Na Parte 3: Marionete de processo , você se tornará um titereiro enquanto você
aprenda a transformar qualquer jogo em uma marionete.
• Aproveitando as habilidades das Partes 1 e 2, Capítulo 7: Injeção de Código
descreve como injetar e executar seu próprio código no espaço de endereço
de um jogo.
• Depois de dominar a injeção, Capítulo 8: Manipulando o fluxo de controle
em um jogo irá ensiná-lo a usar injeção para interceptar, modificar ou
desativa qualquer chamada de função feita por um jogo, e irá encerrar com alguns
exemplos úteis do mundo real para as bibliotecas comuns Adobe AIR e
3D direto.
Para complementar suas aulas de marionetes, estes capítulos são acompanhados
contado por milhares de linhas de código pronto para produção que você pode usar como um
biblioteca padrão para um futuro bot.
Na Parte 4: Criando Bots , você verá como combinar sua caixa de ferramentas, dis-
habilidades de seção, habilidades de manipulador de marionetes e formação em engenharia de software
para criar bots poderosos.
• Capítulo 9: Usando a percepção extra-sensorial para afastar a névoa de guerra
explora maneiras de fazer um jogo exibir informações úteis que não são
exposto por padrão, como a localização de inimigos ocultos e o
quantidade de experiência que você ganha por hora.
• Capítulo 10: Hacks responsivos mostra padrões de código que você pode usar para
detectar eventos no jogo, como diminuição da saúde, e fazer bots que
reage a esses eventos mais rápido do que jogadores humanos.
• Capítulo 11: Juntando tudo: revelando como escrever robôs autônomos
como bots que jogam jogos sem interação humana funcionam. Automatizado
03/07/2021 Hacking de jogos
https://translate.googleusercontent.com/translate_f 15/187
Introdução xxiii
bots combinam teoria de controle, máquinas de estado, algoritmos de pesquisa emodelos matemáticos, e este capítulo é um curso intensivo sobre esses tópicos.
• No Capítulo 12: Permanecendo Oculto , você aprenderá sobre alguns dos
técnicas de nível que você pode usar para escapar e evadir qualquer sistema que poderia
interferir com seus bots.
Página 25
xxiv Introdução
Como você provavelmente deve esperar, esses capítulos têm muitos exemplos
código. Alguns dos hacks mostrados nesta parte são construídos no código de exemplo de
capítulos anteriores. Outros exploram padrões de design simples e sucintos
você pode usar para criar seus próprios bots. Depois de terminar todos os quatro
partes deste livro, você será enviado ao mundo virtual com seu novo
superpotência.
sobre os recursos online
Você encontrará muitos recursos adicionais para este livro em https: //www.nostarc h
.com / gamehacking / . Esses recursos incluem binários compilados para testar seu
habilidades, uma quantidade considerável de código de exemplo e alguns trechos de
código de hack de jogos pronto para produção. Esses recursos andam de mãos dadas
com o livro, e ele realmente não está completo sem eles, então certifique-se de
baixe-os antes de continuar.
Como usar este livro
Este livro deve ser usado principalmente como um guia para você começar
no hack de jogos. A progressão é tal que o conteúdo de cada capítulo
ter apresenta novas habilidades e habilidades que se baseiam em todos os capítulos anteriores.
Conforme você completa os capítulos, encorajo você a brincar com o código deexemplo
e teste suas habilidades em um jogo real antes de continuar a leitura. Isso é
importante, pois alguns tópicos cobertos terão casos de uso que não se tornam
amasse até estar a 3 metros de profundidade na lama.
Depois de terminar o livro, espero que ainda possa ser útil para você como um
manual de campo. Se você encontrar alguma estrutura de dados sobre a qual não tem certeza, talvez
os detalhes no Capítulo 5 podem ajudar. Se você fizer engenharia reversa no mapa de um jogo para-
e estão prontos para criar um pathfinder, você pode sempre voltar para o Capítulo 11,
estude o conteúdo e use parte do código de exemplo como ponto de partida.
Embora seja impossível prever todos os problemas que você pode enfrentar quando
você está hackeando, tentei garantir que você encontrará algumas respostas dentro
essas páginas.
UMA OBSERVAÇÃO DO PuBlIsHEr
Este livro não tolera a pirataria, violando o DMCA, infringindo direitos autorais,
ou quebrar os Termos de Serviço do jogo. Hackers de jogos foram banidos de
jogos pelo resto da vida, processados por milhões de dólares e até presos por seu trabalho.
Página 26
Parte 1
https://translate.google.com/translate?hl=pt-BR&prev=_t&sl=en&tl=pt&u=https://www.nostarch.com/gamehacking
https://translate.google.com/translate?hl=pt-BR&prev=_t&sl=en&tl=pt&u=https://www.nostarch.com/gamehacking
03/07/2021 Hacking de jogos
https://translate.googleusercontent.com/translate_f 16/187
TOOls DO COMÉRCIO
Página 27Página 28
1
ESCANEANDO MEMÓRIA
USANDO O CHEAt ENGINE
Os melhores hackers de jogos do mundo gastam
anos personalizando arsenais expansivos com
ferramentas personalizadas. Kits de ferramentas tão potentes
permitem que esses hackers analisem perfeitamente
jogos, protótipos de hacks sem esforço e de forma eficaz
desenvolver bots. No fundo, no entanto, cada kit exclusivo é
construído a partir da mesma usina de quatro peças: uma memória
scanner, um depurador em nível de assembler, um monitor de processo
tor e um editor hexadecimal.
A varredura de memória é a porta de entrada para hackear jogos, e este capítulo
ensiná-lo sobre o Cheat Engine, um poderoso scanner de memória que procura um
memória operacional do jogo (que vive na RAM) para valores como o do jogador
nível, saúde ou dinheiro no jogo. Primeiro, vou me concentrar na digitalização de memória básica,
modificação de memória e varredura de ponteiro. Depois disso, vamos mergulhar em
O poderoso mecanismo de script Lua embutido do Cheat Engine.
03/07/2021 Hacking de jogos
https://translate.googleusercontent.com/translate_f 17/187
Página 29
4 Capítulo 1
Nota Você pode obter o Cheat Engine em http://www.cheatengine.org/ . Preste atenção
ao executar o instalador porque ele tentará instalar algumas barras de ferramentas e outros bloat-
porcelana. Você pode desativar essas opções, se desejar.
porque os scanners de memória são importantes
Saber o estado de um jogo é fundamental para interagir com a inteligência do jogo
Ligeiramente, mas ao contrário dos humanos, o software não pode determinar o estado de um jogo
simplesmente olhando para o que está na tela. Felizmente, por baixo de todos
os estímulos produzidos por um jogo, a memória de um computador contém um puramente
representação numérica do estado do jogo - e os programas podem
números de suporte facilmente. Hackers usam scanners de memória para encontrar esses valores em
memória, e então em seus programas, eles lêem a memória nestes locais
para entender o estado do jogo.
Por exemplo, um programa que cura jogadores quando eles caem abaixo de 500
saúde precisa saber como fazer duas coisas: monitorar a saúde atual de um jogador
e lançar um feitiço de cura. O primeiro requer acesso ao estado do jogo,
enquanto o último pode exigir apenas que um botão seja pressionado. Dado o local
ção onde a saúde de um jogador é armazenada e a forma de ler a memória de um jogo,
o programa seria parecido com este pseudocódigo:
// faça isso em algum loop
saúde = readMemory (jogo, HEALTH_LOCATION)
if (saúde <500)
pressione o botão (HEAL_BUTTON)
Um scanner de memória permite que você encontre HEALTH_LOCATION para que seu software
ware pode consultá-lo para você mais tarde.
Varredura de memória básica
O scanner de memória é a ferramenta mais básica, porém mais importante, para o
aspirante a hacker de jogos. Como em qualquer programa, todos os dados na memória de um jogo
reside em um local absoluto denominado endereço de memória . Se você pensa no
memória como uma matriz de bytes muito grande, um endereço de memória é um índice que aponta
a um valor nessa matriz. Quando um scanner de memória é instruído a encontrar algum valor
x (chamado de valor de varredura , porque é o valor que você está procurando) em um jogo
memória, o scanner percorre a matriz de bytes procurando por qualquer valor
igual a x . Cada vez que encontra um valor correspondente, ele adiciona o índice do
corresponder a uma lista de resultados.
Devido ao tamanho da memória de um jogo, no entanto, o valor de x pode
aparecem em centenas de locais. Imagine que x é a saúde do jogador, que
atualmente é 500. Nosso x detém exclusivamente 500 , mas 500 não é detido exclusivamente por
x , portanto, uma varredura para x retorna todas as variáveis com um valor de 500 . Quaisquer endereços não
relacionados ax são, em última análise, desordem; eles compartilham um valor de 500 com x apenas por
Página 30
chance. Para filtrar esses valores indesejados, o scanner de memória permite que você
para verificar novamente a lista de resultados, removendo endereços que não são mais os mesmos
valor como x , se x ainda é 500 ou mudou.
Para que essas novas digitalizações sejam eficazes, o estado geral do jogo deve
têm entropia significativa - uma medida de desordem. Você aumenta a entropia em
mudando o ambiente do jogo, muitas vezes movendo-se, matando cria-
ou alternar entre personagens. Conforme aumenta a entropia, os endereços não relacionados são
menos provável de continuar a manter arbitrariamente o mesmo valor, e dado o suficiente
entropia, algumas novas varreduras devem filtrar todos os falsos positivos e deixá-lo com
o verdadeiro endereço de x .
Scanner de memória do mecanismo de trapaça
Esta seção fornece um tour pelas opções de verificação de memória do Cheat Engine,
que o ajudará a rastrear os endereços dos valores de estado do jogo em mem-
ory. Vou lhe dar a chance de experimentar o scanner em “Edição de memória básica”
na página 11 ; por enquanto, abra o Cheat Engine e dê uma olhada. O
scanner de memória está firmemente encapsulado em sua janela principal, conforme mostrado em
Figura 1-1.
03/07/2021 Hacking de jogos
https://translate.googleusercontent.com/translate_f 18/187
Verificando a memória usando o Cheat Engine 5
Figura 1-1: Tela principal do Cheat Engine
Para começar a escanear a memória de um jogo, clique no ícone Anexar ❶ para anexar
a um processo e, em seguida, insira o valor de varredura (referido como x em nosso conceito
scanner digital) que deseja localizar ➌. Ao anexar a um processo, estamos dizendo
www.allitebooks.com
Página 31
6 Capítulo 1
Cheat Engine para se preparar para operar nele; neste caso, essa operação é um
Varredura. Também ajuda a informar ao Cheat Engine que tipo de varredura executar, pois irei descartar
xingar próximo.
Tipos de digitalização
O Cheat Engine permite que você selecione duas diretivas de varredura diferentes, chamadas Scan
Tipo e tipo de valor ➍. Tipo de digitalização informa ao scanner como comparar o seu
valor de varredura com a memória sendo varrida usando uma das seguintes varreduras
tipos:
Valor exato Retorna endereços apontando para valores iguais ao
valor de varredura. Escolha esta opção se o valor que você está procurando não for
mudança durante a varredura; saúde, mana e nível normalmente caem neste
categoria.
Endereços Bigger Than Returns apontando para valores maiores que o
valor de varredura. Esta opção é útil quando o valor que você está procurando é
aumentando constantemente, o que geralmente acontece com temporizadores.
Menor que retornaendereços apontando para valores menores que o
valor de varredura. Como Bigger Than, esta opção é útil para encontrar temporizadores
(neste caso, aqueles com contagem regressiva em vez de crescente).
Valor entre endereços de retorno que apontam para valores em uma varredura
faixa de valor. Esta opção combina Bigger Than e Smaller Than,
exibindo uma caixa de valor de varredura secundária que permite que você insira um valor
intervalo menor de valores.
Valor inicial desconhecido Retorna todos os endereços na memória de um programa,
permitindo novas varreduras para examinar todo o intervalo de endereços em relação ao seu
valores iniciais. Esta opção é útil para encontrar tipos de itens ou criaturas,
já que você nem sempre saberá os valores internos que os desenvolvedores de jogos
usado para representar esses objetos.
A diretiva Value Type diz ao scanner do Cheat Engine que tipo de
variável que está procurando.
Executando sua primeira varredura
Assim que as duas diretivas de varredura forem definidas, clique em Primeira Varredura ➋ para executar uma
verifique os valores e o scanner preencherá a lista de resultados ❺. Qualquer verde
endereços nesta lista são estáticos , o que significa que devem permanecer persistentes
entre reinicializações do programa. Os endereços listados em preto residem em alo-
memória designada , memória que é alocada em tempo de execução.
Quando a lista de resultados é preenchida pela primeira vez, mostra o endereço e
valor de tempo de cada resultado. Cada nova varredura também mostrará o valor de cada resultado
durante a verificação anterior. (Quaisquer valores em tempo real exibidos são atualizados em
um intervalo que você pode definir em Editar> Configurações> Configurações gerais> Atualizar
intervalo.)
Página 32
https://translate.google.com/translate?hl=pt-BR&prev=_t&sl=en&tl=pt&u=http://www.allitebooks.org
03/07/2021 Hacking de jogos
https://translate.googleusercontent.com/translate_f 19/187
Verificando a memória usando o Cheat Engine 7
Próximas varreduras
Uma vez que a lista de resultados é preenchida, o scanner habilita o Next Scan ➋ but-
ton, que oferece seis novos tipos de digitalização. Esses tipos de verificação adicionais permitem que você
para comparar os endereços na lista de resultados com seus valores na anterior
scan, o que o ajudará a restringir o endereço que contém o estado do jogo
valor que você está procurando. Eles são os seguintes:
Aumento de valor Retorna endereços apontando para valores que têm
aumentou. Isso complementa o tipo de verificação Bigger Than mantendo
o mesmo valor mínimo e removendo qualquer endereço cujo valor tenha
diminuiu.
Valor aumentado por endereços de retorno que apontam para valores que têm
aumentado por um montante definido. Este tipo de varredura geralmente retorna muito menos
falsos positivos, mas você só pode usá-los quando sabe exatamente quanto
um valor aumentou.
Valor diminuído Esta opção é o oposto de valor aumentado.
Valor diminuído em Esta opção é o oposto de Valor aumentado em.
Valor alterado Retorna endereços apontando para valores que têm
mudado. Este tipo é útil quando você sabe que um valor sofrerá mutação, mas
você não tem certeza de como.
Valor inalterado Retorna endereços apontando para valores que não
mudado. Isso pode ajudá-lo a eliminar falsos positivos, uma vez que você pode facilmente
cria uma grande quantidade de entropia e, ao mesmo tempo, garante o valor desejado
continua o mesmo.
Normalmente, você precisará usar vários tipos de verificação para restringir
uma grande lista de resultados e encontre o endereço correto. Eliminar falsos positivos é
muitas vezes uma questão de criar entropia corretamente (conforme descrito em "Memória Básica
Scanning "na página 4), taticamente mudando suas diretivas de varredura, bravamente
pressionando Próxima digitalização e, em seguida, repetindo o processo até que você tenha um único
endereço restante.
Quando você não consegue obter um único resultado
Às vezes, é impossível apontar um único resultado no Cheat Engine, em
caso em que você deve determinar o endereço correto por meio de experimentos
ção Por exemplo, se você está procurando a saúde do seu personagem e não pode
reduzi-lo a menos de cinco endereços, você pode tentar modificar o
valor de cada endereço (conforme discutido em “Modificação manual com fraude
Motor ”na página 8) até ver a alteração do visor de integridade ou outro
os valores mudam automaticamente para o que você definiu.
Tabelas de trapaça
Depois de encontrar o endereço correto, você pode clicar duas vezes nele para adicioná-lo ao
o painel da mesa de trapaça ➏; endereços no painel da tabela de cheat podem ser modificados,
assistidos e salvos em arquivos de tabela de trapaça para uso futuro.
Página 33
Para cada endereço no painel da tabela de cheat, você pode adicionar uma descrição por
clicando duas vezes na coluna Descrição, e você pode adicionar uma cor com o botão direito
clicando e selecionando Alterar cor. Você também pode exibir os valores de cada
endereço em formato hexadecimal ou decimal clicando com o botão direito e selecionando
Mostrar como hexadecimal ou Mostrar como decimal, respectivamente. Por último, você pode
altere o tipo de dados de cada valor clicando duas vezes na coluna Tipo,
ou você pode alterar o próprio valor clicando duas vezes na coluna Valor.
Uma vez que o objetivo principal do painel da tabela de truques é permitir um jogo
hacker para rastrear endereços ordenadamente, ele pode ser salvo e carregado dinamicamente.
Vá para Arquivo > Salvar ou Arquivo > Salvar como para salvar o painel da tabela de truques atual para
um arquivo de documento .ct contendo cada endereço com seu tipo de valor, descrição,
cor de exibição e formato de exibição. Para carregar os documentos .ct salvos , vá para
Arquivo > Carregar . (Você encontrará muitas tabelas de truques prontas para jogos populares
em http://cheatengine.org/tables.php .)
Agora que descrevi como procurar um valor de estado do jogo, discutirei
como você pode mudar esse valor quando você sabe onde ele mora na memória.
modificação de memória em jogos
Os bots enganam um sistema de jogo, modificando os valores da memória no estado do jogo
para lhe dar muito dinheiro no jogo, modifique a saúde do seu personagem,
mude a posição do seu personagem e assim por diante. Na maioria dos jogos online, um char-
os sinais vitais do ator (como saúde, mana, habilidades e posição) são mantidos na memória
mas são controlados pelo servidor de jogo e retransmitidos para seu cliente de jogo local
pela Internet, portanto, modificar esses valores durante o jogo online é apenas
cosmético e não afeta os valores reais. (Qualquer modificação de memória útil
para um jogo online requer um hack muito mais avançado que está além
Recursos do Cheat Engine.) Em jogos locais sem servidor remoto, no entanto,
você pode manipular todos esses valores à vontade.
Modificação manual com Cheat Engine
03/07/2021 Hacking de jogos
https://translate.googleusercontent.com/translate_f 20/187
8 Capítulo 1
Usaremos o Cheat Engine para entender como a mágica da modificação de memória
trabalho.
Para modificar a memória manualmente, faça o seguinte:
1. Anexe o Cheat Engine a um jogo.
2. Procure o endereço que deseja modificar ou carregue uma tabela de truques que
contém.
3. Clique duas vezes na coluna Valor do endereço para abrir uma entrada
prompt onde você pode inserir um novo valor.
4. Se você quiser ter certeza de que o novo valor não pode ser substituído, selecione o
caixa sob a coluna Ativo para congelar o endereço, o que tornará
O Cheat Engine continua escrevendo o mesmo valor de volta para ele toda vez que
alterar.
Página 34
Verificando a memória usando o Cheat Engine 9
Este método faz maravilhas para hacks rápidos e sujos, mas constantemente
alterar os valores manualmente é complicado; uma solução automatizada seria
muito mais atraente.
Trainer Generator
O gerador de treinamento do Cheat Engine permite automatizar toda a memória
processo de modificação sem escrever nenhum código.Para criar um treinador (um bot simples que vincula ações de modificação de memória
para as teclas de atalho do teclado), vá para Arquivo > Criar script Lua de treinador genérico de
mesa . Isso abre uma caixa de diálogo do gerador do Trainer semelhante à mostrada em
Figura 1-2.
Figura 1-2: caixa de diálogo do gerador do Cheat Engine Trainer
Existem vários campos a serem modificados aqui:
Nome do processo O nome do executável que o treinador deve anexar
para. Este é o nome mostrado na lista de processos quando você anexa com
Cheat Engine, e deve ser preenchido automaticamente com o nome do pro
cess Cheat Engine está conectado.
Treinador de pop-up ao pressionar a tecla Opcionalmente, habilita uma tecla de atalho
definido inserindo uma combinação de teclas na caixa abaixo da caixa de seleção - para
exibir a janela principal do treinador.
Título O nome do seu treinador, que será exibido em seu inter-
Rosto. Isso é opcional.
Sobre o texto A descrição do seu treinador, a ser exibida no
interface; isso também é opcional.
Intervalo de congelamento (em milissegundos) O intervalo durante o qual um congelamento
operação substitui o valor. Você geralmente deve deixar isso em 250, como
intervalos mais baixos podem esgotar recursos e valores mais altos podem ser muito lentos.
Página 35
Depois que esses valores forem configurados, clique em Adicionar tecla de atalho para configurar uma chave
sequência para ativar seu treinador. Você será solicitado a selecionar um valor
da sua tabela de truques. Insira um valor e você será levado a um Conjunto / Alteração
tela de tecla de atalho semelhante à Figura 1-3.
03/07/2021 Hacking de jogos
https://translate.googleusercontent.com/translate_f 21/187
10 Capítulo 1
О
θ
θ
Θ
Figura 1-3: Tela de tecla de atalho de configuração / alteração do mecanismo de cheat
Nesta tela, coloque o cursor na caixa chamada Digite as teclas que você
deseja definir a tecla de atalho para ❶ e insira a combinação de teclas desejada. Próximo,
escolha a ação desejada no menu suspenso ➋; suas opções
deve aparecer na seguinte ordem:
Alternar congelamento Alterna o estado de congelamento do endereço.
Alternar congelar e permitir aumento Alterna o estado de congelamento do
endereço, mas permite que o valor aumente. Sempre que o valor diminui,
o treinador o substitui com seu valor anterior. Valores aumentados irão
não ser sobrescrito.
Alternar congelar e permitir diminuição O oposto de Alternar congelar
e permitir o aumento.
Congelar Define o endereço como congelado se ainda não estiver congelado.
Descongelar Descongela o endereço se ele estiver congelado.
Definir valor para Define o valor para o que você especificar na caixa de valor ➌.
Diminuir o valor com Diminui o valor na quantidade que você especificar em
a caixa de valor ➌.
Aumentar o valor com Faz o oposto de Diminuir o valor com.
Finalmente, você pode definir uma descrição para a ação ➍. Clique em Aplicar e depois
OK , e sua ação aparecerá na lista no gerador do Trainer
tela. Neste ponto, o Cheat Engine executa o treinador em segundo plano,
e você pode simplesmente pressionar as teclas de atalho que configurou para executar o mem-
ory ações.
Página 36
Para salvar seu treinador em um executável portátil, clique em Gerar treinador .
Executar este executável após o jogo ser iniciado irá anexar o seu treinador
para o jogo para que você possa usá-lo sem iniciar o Cheat Engine.
Agora que você conhece o scanner de memória do Cheat Engine
e gerador de treinador, tente modificar alguma memória você mesmo.
Varredura de ponteiro
Como mencionei, os jogos online geralmente armazenam valores em alocados dinamicamente
memória. Embora os endereços que fazem referência à memória dinâmica sejam inúteis para nós em
e por si mesmos, algum endereço estático sempre apontará para outro endereço,
que por sua vez aponta para outro, e assim por diante, até que a cauda da corrente aponte
para a memória dinâmica em que estamos interessados. O Cheat Engine pode localizar esses
cadeias usando um método chamado varredura de ponteiro .
Nesta seção, vou apresentá-lo às cadeias de ponteiros e, em seguida, descrever
como a varredura de ponteiro funciona no Cheat Engine. Quando você tem um bom domínio
da interface do usuário, você pode obter alguma experiência prática em “Ponteiro
Digitalizando ”na página 18.
Cadeias de Ponteiros
A cadeia de deslocamentos que acabei de descrever é chamada de cadeia de ponteiros e parece
como isso:
lista <int> cadeia = { início , deslocamento1 , deslocamento2 [ , ... ]}
EDIÇÃO DE MEMÓRIA BÁSICA
Baixe os arquivos deste livro em https://www.nostarch.com/gamehacking/ ,
e execute o arquivo BasicMemory.exe . Em seguida, inicie o Cheat Engine e conecte-o ao
o binário. Então, usando apenas Cheat Engine, encontre os endereços para x- e
Coordenadas y da bola cinza. (Dica: use o tipo de valor 4 bytes.)
Depois de encontrar os valores, modifique-os para colocar a bola em cima do
quadrado preto. O jogo irá informá-lo assim que obtiver sucesso no display-
com o texto “Bom trabalho!” (Dica: Cada vez que a bola é movida, sua posição - armazenada
como um inteiro de 4 bytes - nesse plano é alterado por 1. Além disso, tente procurar apenas por
resultados estáticos [verdes].)
03/07/2021 Hacking de jogos
https://translate.googleusercontent.com/translate_f 22/187
Verificando a memória usando o Cheat Engine 11
O primeiro valor nesta cadeia de ponteiros ( início ) é chamado de ponteiro de memória . Seu
um endereço que inicia a cadeia. Os valores restantes ( deslocamento1 , deslocamento2 e
assim por diante) crie a rota para o valor desejado, chamado de caminho de ponteiro .
Página 37
12 Capítulo 1
Este pseudocódigo mostra como uma cadeia de ponteiro pode ser lida:
int readPointerChain (cadeia) {
❶ ret = lido (corrente [0])
para i = 1, chain.len - 1, 1 {
deslocamento = cadeia [i]
ret = lido (ret + deslocamento)
}
retornar ret
}
Este código cria a função readPointerPath () , que recebe um ponteiro
cadeia chamada cadeia como um parâmetro. A função readPointerPath () trata o
caminho do ponteiro na cadeia como uma lista de deslocamentos de memória do endereço ret , que
é inicialmente definido para o ponteiro de memória em ❶. Em seguida, ele faz um loop através desses
conjuntos, atualizando o valor de ret para o resultado da leitura (ret + deslocamento) em cada
iteração e retornando ret quando estiver concluída. Este pseudocódigo mostra o que
readPointerPath () se parece com quando o loop é desenrolado:
list <int> cadeia = {0xDEADBEEF, 0xAB, 0x10, 0xCC}
valor = readPointerPath (cadeia)
// a chamada de função se desdobra para este
ret = ler (0xDEADBEEF) // corrente [0]
ret = lido (ret + 0xAB)
ret = lido (ret + 0x10)
ret = lido (ret + 0xCC)
valor int = ret
A função, em última análise, chama lida quatro vezes, em quatro diferentes
endereços - um para cada elemento da cadeia .
Nota Muitos hackers de jogos preferem codificar suas leituras em cadeia no lugar, em vez de encapsular
-los em funções como readPointerPath () .
Noções básicas de varredura de ponteiro
Cadeias de ponteiros existem porque cada pedaço de memória alocada dinamicamente
deve ter um endereço estático correspondente que o código do jogo pode usar para
referenciá-lo. Os hackers de jogos podem acessar esses blocos localizando o ponteiro
cadeias que fazem referência a eles. Por causa de sua estrutura multicamadas, no entanto,
cadeias de ponteiro não podem ser localizadas através da abordagem linear que a memória
scanners usam, então os hackers de jogos desenvolveram novas maneiras de encontrá-los.
De uma perspectiva de engenharia reversa, você pode localizar e analisar
o código de montagem, a fim de deduzir qual caminho do ponteiro ele usou para acessar o
valor, mas fazer isso consome muito tempo e requer ferramentas avançadas.
Os scanners de ponteiro resolvem este problema usando força bruta para iterar recursivamente
sobre cada cadeia de ponteiros possível até encontrarem um que resolva para o alvo
obter endereço de memória.
Página 38
O pseudocódigo daListagem 1-1 deve dar uma ideia geral de como um
scanner de ponteiro funciona.
list <int> pointerScan (target, maxAdd, maxDepth) {
❶ para endereço = BASE, 0x7FFFFFF, 4 {
ret = rScan (endereço, destino, maxAdd, maxDepth, 1)
if (ret.len> 0) {
ret.pushFront (endereço)
retornar ret
}
}
Retorna {}
}
list <int> rScan (address, target, maxAdd, maxDepth, curDepth) {
➋ para deslocamento = 0, maxAdd, 4 {
valor = ler (endereço + deslocamento)
➌ if (value == target)
lista de retorno <int> (deslocamento)
03/07/2021 Hacking de jogos
https://translate.googleusercontent.com/translate_f 23/187
Verificando a memória usando o Cheat Engine 13
}
➍ if (curDepth <maxDepth) {
curDepth ++
❺ para deslocamento = 0, maxAdd, 4 {
ret = rScan (endereço + deslocamento, destino, maxAdd, maxDepth, curDepth)
➏ if (ret.len> 0) {
ret.pushFront (deslocamento)
➐ retornar ret
}
}
}
Retorna {}
}
Listagem 1-1: Pseudocódigo para um scanner de ponteiro
Este código cria as funções pointerScan () e rScan () .
pointerScan ()
A função pointerScan () é o ponto de entrada para a varredura. É preciso o parâmetro
eters target (o endereço de memória dinâmica a ser encontrado), maxAdd (o máximo
valor de qualquer deslocamento) e maxDepth (o comprimento máximo do caminho do ponteiro).
Em seguida, ele faz um loop por cada endereço alinhado de 4 bytes ❶ no jogo, chamando
rScan () com o endereço dos parâmetros (o endereço na iteração atual),
target , maxAdd , maxDepth e curDepth (a profundidade do caminho, que é sempre 1
nesse caso).
rScan ()
A função rScan () lê a memória de cada deslocamento alinhado de 4 bytes entre
0 e maxAdd ➋, e retorna se o resultado for igual ao destino ➌. Se rScan () não
retorna no primeiro loop e a recursão não é muito profunda ➍, ela aumenta
curDepth e novamente faz um loop sobre cada deslocamento ❺, chamando a si mesmo para cada iteração.
Página 39
Se uma auto chamada retornar um caminho de ponteiro parcial ➏, rScan () irá preceder o
deslocamento atual para o caminho e retornar para cima na cadeia de recursão ➐ até que
atinge o pointerScan () . Quando uma chamada para rScan () de pointerScan () retorna um
caminho do ponteiro, o ponteiroScan () empurra o endereço atual para a frente do
caminho e o retorna como uma cadeia completa.
Varredura de ponteiro com Cheat Engine
O exemplo anterior mostrou o processo básico de varredura do ponteiro, mas
a implementação que mostrei é primitiva. Além de ser insanamente
lento para executar, geraria inúmeros falsos positivos. Cheat Engine's
scanner de ponteiro usa uma série de interpolações avançadas para acelerar o
digitalizar e torná-lo mais preciso e, nesta seção, apresentarei a você
a miscelânea de opções de digitalização disponíveis.
Para iniciar uma varredura de ponteiro no Cheat Engine, clique com o botão direito em uma página dinâmica
endereço de memória em sua tabela de cheat e clique em Pointer scan para este endereço .
Quando você inicia uma varredura de ponteiro, Cheat Engine irá perguntar onde armazenar
os resultados da verificação como um arquivo .ptr . Depois de inserir um local, um Pointerscanner
A caixa de diálogo scanoptions semelhante à mostrada na Figura 1-4 aparecerá.
Figura 1-4: Caixa de diálogo de opções de varredura do Cheat Engine Pointerscanner
03/07/2021 Hacking de jogos
https://translate.googleusercontent.com/translate_f 24/187
14 Capítulo 1
Página 40
Verificando a memória usando o Cheat Engine 15
O campo de entrada Endereço para encontrar na parte superior exibe sua memória dinâmica
endereço eletrônico. Agora selecione cuidadosamente entre as muitas varreduras do Cheat Engine
opções.
Opções de chave
Várias das opções de varredura do Cheat Engine normalmente mantêm seus valores padrão.
Essas opções são as seguintes:
Os endereços devem ser alinhados a 32 bits. Diz ao Cheat Engine para fazer a varredura apenas
endereços que são múltiplos de 4, o que aumenta muito a varredura
Rapidez. Como você aprenderá no Capítulo 4, os compiladores alinham os dados para que a maioria
os endereços serão múltiplos de 4 por padrão. Você raramente precisará
desative esta opção.
Apenas encontre caminhos com um endereço estático. Acelera a varredura, evitando
ing Cheat Engine de procurar caminhos com um ponteiro de início dinâmico.
Esta opção deve estar sempre habilitada porque a varredura de um caminho começa
entrar em outro endereço dinâmico pode ser contraproducente.
Não inclua ponteiros com nós somente leitura. Também deve ser sempre
ativado. Memória alocada dinamicamente que armazena dados voláteis deve
nunca seja somente leitura.
Pare de percorrer um caminho quando uma estática for encontrada Encerra o
faz a varredura quando encontra um caminho de ponteiro com um endereço inicial estático. Isto deveria
ser habilitado para reduzir falsos positivos e acelerar a varredura.
O caminho do ponteiro pode estar apenas dentro desta região. Normalmente, pode ser deixado como está.
As outras opções disponíveis para você compensam esta grande variedade por
estreitando de forma inteligente o escopo da varredura.
O primeiro elemento do pointerstruct deve apontar para o módulo Tells Cheat
O mecanismo não deve procurar por blocos de heap em que as tabelas de funções virtuais são
não encontrado, partindo do pressuposto de que o jogo foi codificado usando o objeto
orientação. Embora essa configuração possa acelerar imensamente as varreduras, é altamente
não confiável e você deve quase sempre deixá-lo desativado.
Sem ponteiros de loop Invalida todos os caminhos que apontam para eles mesmos,
eliminando caminhos ineficientes, mas retardando ligeiramente a varredura. Esta
geralmente deve ser ativado.
Nível máximo Determina o comprimento máximo do caminho do ponteiro.
(Lembra-se da variável maxDepth no código de exemplo na Listagem 1-1?)
Isso deve ser mantido em torno de 6 ou 7.
Claro, haverá momentos em que você precisará alterar essas opções
das configurações descritas. Por exemplo, não obter resultados confiáveis
com os ponteiros sem loop ou configurações de nível máximo normalmente significa que o
o valor que você está procurando existe em uma estrutura de dados dinâmica, como uma lista vinculada,
árvore binária ou vetor. Outro exemplo é a parada de atravessar um caminho quando um
opção estática foi encontrada, o que em casos raros pode impedi-lo de obter
resultados confiáveis.
Página 41
Opções Situacionais
Ao contrário das opções anteriores, suas configurações para as restantes dependerão
em sua situação. Veja como determinar a melhor configuração para cada um:
Melhorar a varredura de ponteiros com dados de heap coletados Permite Cheat Engine
para usar o registro de alocação de heap para determinar os limites de deslocamento, efetivamente
acelerando a varredura eliminando muitos falsos positivos. Se você correr
em um jogo usando um alocador de memória personalizado (que está se tornando
cada vez mais comum), esta opção pode realmente fazer exatamente o oposto
do que deve fazer. Você pode deixar esta configuração habilitada na inicial
varreduras, mas deve ser o primeiro a ir quando você não consegue encontrar
caminhos capazes.
Permitir apenas endereços estáticos e de heap no caminho Invalida todos os caminhos
que não pode ser otimizado com dados de heap, tornando esta abordagem ainda
mais agressivo.
Máximo de deslocamentos diferentes por nó Limita o número de mesmo valor
apontadores que o scanner verifica. Ou seja, se n endereços diferentes apontam para
0x0BADF00D , esta opção diz ao Cheat Engine para considerar apenas o primeiro m
endereços. Isso pode ser extremamente útil quando você não consegue restringir
abaixo seu conjunto de resultados. Em outros casos, você pode querer desativá-lo, pois irá
perca muitos caminhos válidos.
Permitir que endereços de pilha do (s) primeiro (s) thread (s) sejam tratados como estáticos
Verifica as pilhas de chamadas dos threads m mais antigos do jogo, considerando o
03/07/2021 Hacking de jogos
https://translate.googleusercontent.com/translate_f 25/187
16 Capítulo 1
primeiros n bytes em cada um. Isso permite