1. Estilo de ação, o chamado estilo de ação refere-se ao uso da API para enviar comandos para Windows ou APIs para controlar o mouse, o teclado, etc., para que os caracteres no jogo possam ser movidos ou atacados. Plug-in "de pedra". (Esse tipo de plug-in é completamente lixo, DTM, quem sabe um pouco de API sabe o que fazer, mas esse plug-in também é uma coisa boa de nível básico. Embora não possa melhorar sua eficácia de combate, pode Melhore seu moral ^_ ^)
2. Estilo de modificação local. -Em "留" A dificuldade de escrever o método é encontrar os códigos de endereço. (Esse tipo de plug-in é um pouco mais difícil que o anterior, mas também é difícil usar esse plug-in ~~ Este plug-in pode melhorar rapidamente sua compreensão e aplicação de endereços de memória. É você bom coisas para melhorar a tecnologia de programação)
3. Trojan-estilo. Para falar sobre isso ~~). para o endereço de email especificado. (Eu já escrevi algo assim antes, mas nunca o usei. Eu sei que essa coisa é muito imoral, então não use no futuro! ~~)
4. Tipo de aceleração, este plug-in pode acelerar o jogo ... (me desculpe, eu não fiz esse tipo de coisa, então não posso comentar sobre mim mesmo, tenho vergonha ~~)
5. No estilo de pacotes, este plug-in é um plug-in de alta difusão e requer fortes habilidades de programação a serem escritas. Seu princípio é interceptar o pacote primeiro, modificá -lo e depois encaminhá -lo (kao, é simples dizer, você pode tentar ~~~~). Este plug-in é adequado para a maioria dos jogos online.
Entre esses plug-ins, os três primeiros podem ser facilmente implementados usando idiomas como VB e DeLeps, enquanto os dois últimos devem ser facilmente implementados usando ferramentas de programação como o VC. (Ph, por favor ouça o próximo colapso)
(Eu sou um entusiasta do programa e não um plug-in profissional, então, por favor, perdoe-me se houver algum artigo inadequado. Em futuros artigos, farei o processo de ação de ação, modificação local, trojan e estilo de pacotes. Explicação detalhada )
Na última vez em que analisamos o plug-in de ação.
Até onde eu sei, a aplicação mais típica de plug-ins locais modificados está no jogo "ELF", porque eu tinha quase um ano (o "elfo" ainda está no estágio de teste), e muitos colegas da minha empresa Joguei "ELF", então olhei para o método de processamento de dados do jogo e descobri que as informações enviadas para o servidor existem na memória (meu primeiro sentimento depois de ler é: não há muita diferença entre modificar esse tipo de jogo e modificar Uma versão independente do jogo. O endereço de acordo com minha ideia e deixou o sistema enviá-lo automaticamente, e foi realmente bem-sucedido. fale bobagem aqui ~~~~, ok, vamos dar uma olhada em como esse tipo de plug-in é feito:
Antes de fazer o plug-in, precisamos ter um entendimento específico da memória do Windows. O mesmo. Endereços de memória):
1. Primeiro, precisamos usar o FindWindow para conhecer o identificador da janela do jogo, porque precisamos conhecer o ID do processo depois que o jogo está em execução.
Hwnd FindWindow (
LPCTSTR LPCLASSNAME, // Ponteiro para o nome da classe
LPCTSTR LPWindowname // Ponteiro para o nome da janela
);
2. GetWindowThreadProcessId para obter o ID do processo do processo correspondente da janela do jogo.
Dword getwindowthreadprocessid (
Hwnd hwnd, // maçaneta da janela
Lpdword lpdwprocessid // Endereço da variável para identificador de processo
);
3. Depois de obter o ID do processo do jogo, a próxima coisa é abrir o processo com as mais altas permissões.
Lidar com o OpenProcess (
DWord dwdesiredAccess, // sinalizador de acesso
Bool binherithandle, // manipula a bandeira de herança
Dword dwprocessid // Process Identifier
);
Onde o DWDesiredAccess é o local onde os métodos de acesso são definidos, ele pode definir muitas permissões.
4. Depois de abrir o processo, podemos usar funções para operar na memória. , vamos dar uma olhada no uso do WriteProcessMemory:
Bool writeProcessMemory (
Lidar
Lpvoid lpbaseAddress, // endereço para começar a escrever para
Lpvoid lpbuffer, // ponteiro para buffer para escrever dados para
DWORD NSIZE, // Número de bytes para escrever
Lpdword lpNumberOfbytesWritten // Número real de bytes escritos
);
5. O seguinte é para fechar a alça do processo com o CloseHandle e está concluído.
Este é o método de implementação do programa desse tipo de plug-in de jogo. dos jogos XX vamos estudar o código de acordo com o método acima:
const
ResourceOffset: dword = $ 004219f4;
Recurso: DWORD = 3113226621;
ResourceOffSet1: DWORD = $ 004219F8;
Resource1: dWord = 1940000000;
ResourceOffSet2: DWORD = $ 0043FA50;
Resource2: dWord = 1280185;
ResourceOffSet3: DWORD = $ 0043FA54;
Resource3: DWORD = 3163064576;
ResourceOffSet4: DWORD = $ 0043FA58;
Resource4: DWORD = 2298478592;
var
HW: HWND;
PID: DWORD;
H: Thandle;
tt: cardeal;
Começar
hw: = findWindow ('' xx '', nil);
Se hw = 0 então
Saída;
GetWindowThreadProcessId (hw, @pid);
H: = OpenProcess (process_all_access, false, pid);
Se h = 0 então
Saída;
Se FlatcheckBox1.Checked = true então
Começar
WriteProcessMemory (H, Pointer (ResourceOffSet), @Resource, Sizeof (Resource), TT);
WriteProcessMemory (H, Pointer (ResourceOffSet1), @Resource1, Sizeof (Resource1), TT);
fim;
Se FlatcheckBox2.Checked = true então
Começar
WriteProcessMemory (H, Pointer (ResourceOffSet2), @Resource2, Sizeof (Resource2), TT);
WriteProcessMemory (H, Pointer (ResourceOffSet3), @Resource3, Sizeof (Resource3), TT);
WriteProcessMemory (H, Pointer (ResourceOffSet4), @Resource4, Sizeof (Resource4), TT);
fim;
MessageBeep (0);
CloseHandle (H);
fechar;
Este jogo usa vários endereços para verificar os dados a serem enviados; portanto, não é difícil criar plug-ins desse tipo de jogo, e o mais difícil é encontrar esses endereços.
(Você já viu o método claramente, e a prática específica depende de todos. Tipos de plug-ins em artigos futuros.
Na última vez em que fiz um resumo geral dos cinco tipos de plug-ins
Primeiro de tudo, vamos falar sobre plug-ins em estilo de ação, que também é o mais fácil que fiz quando escrevi plug-ins pela primeira vez.
Lembro-me de quando ainda estava na era "Stone", vi alguém tendo um software (plug-in) e as pessoas podiam passear (eu não sabia o que o plug-in estava acontecendo naquele momento^_^ ), então eu achei esse tipo de software aqui para estudar (ouvi outros chamados de plug-in depois que o fiz) e descobri que esse tipo de coisa não é difícil de implementar. do que clicar no mouse em lugares diferentes.
1. Primeiro de tudo, precisamos conhecer a posição atual do mouse (para restaurar a posição atual do mouse), para que precisemos usar a função API GetCursorPos, que é usada da seguinte maneira:
Bool getCursorpos (
Lppoint lppoint // Endereço da estrutura para a posição do cursor
);
2. Quando movemos a posição do mouse para o local onde o personagem está indo, precisamos usar a função SetCursorpos para mover a posição do mouse.
Bool SetCursorpos (
Int X, // Posição Horizontal
int y // Posição vertical
);
3. Simule o mouse para pressionar e liberar a ação.
Void mouse_event (
Dword dwflags, // sinalizadores especificando várias variantes de movimento/clique
DWord dx, // posição horizontal de mouse ou mudança de posição
DWORD DY, // Posição vertical do mouse ou mudança de posição
Dword dwdata, // quantidade de movimento de roda
Dword dwextrainfo // 32 bits de informações definidas pelo aplicativo
);
Em seus dwflags, existem muitos eventos disponíveis, como mover mouseeventf_move, pressione mouseeventf_leftdown com o botão esquerdo, solte mouseeventf_leftup com o botão esquerdo.
Ok, com o conhecimento anterior, podemos ver como a remoção do personagem é implementada:
getCursorPos (Point);
SetCursorpos (RanSpoint (80, Windowx), Ranpoint (80, Windowy)); // Ranpoint é uma função de coordenada aleatória caseira
mouse_event (mouseeventf_leftdown, 0,0,0,0);
mouse_event (mouseeventf_leftup, 0,0,0,0);
setCursorPos (Point.X, Point.Y);
Depois de ler o código acima, você acha que o perigo dos personagens é muito simples? ~, Eu posso desenhar um e imitar três, e há muitas coisas boas que podem ser implementadas usando essa técnica (eu disse há muito tempo, TMD, esta é um método de plug-in de lixo, acredite ~~~), em seguida, vamos dar uma olhada no método de ataque automático no jogo (deve apoiar as teclas de atalho para ataques no jogo). A API usada é diferente ~~~~, desta vez o que queremos usar é a função keybd_event, que é usada da seguinte maneira:
Void keybd_event (
BYTE BVK, // Código Virtual-Key
Byte bscan, // Código de varredura de hardware
Dword dwflags, // sinalizadores especificando várias opções de função
Dword dwextrainfo // dados adicionais associados ao pressionamento de tecla
);
Também precisamos saber que o código de varredura não pode ser usado diretamente.
Uint mapvirtualKey (
Uint ucode, // código de chave virtual ou código de digitalização
Uint UMAPTYPE // Tradução para executar
);
Ok, digamos que essa chave de conexão rápida é Ctrl+A. a seguir, vamos ver como o código real é escrito:
keybd_event (vk_control, mapvirtualKey (vk_control, 0), 0,0);
keybd_event (65, mapVirtualKey (65,0), 0,0);
keybd_event (65, mapVirtualKey (65,0), keyeventf_keyup, 0);
keybd_event (vk_control, mapvirtualKey (vk_control, 0), keyeventf_keyup, 0);
Primeiro, pressione a tecla Ctrl na simulação, depois pressione a tecla A e, em seguida, solte a tecla A e, finalmente, solte a tecla Ctrl.
(Vendo aqui, quase tenho um certo entendimento de plug-ins simples ~~~~ vamos tentar? Se você conseguir algo melhor se desenhar um ou três, depende da sua capacidade de compreendê-lo. ~~, mas Não seja feliz demais.