Guía de Instalación: Sistema Anti-Cheat y Anti-Crack

Introducción a la Seguridad en Servidores de Mu Online

La seguridad en servidores de MuEmu Season 6 y SSEMu Season 6 es fundamental para garantizar una experiencia de juego justa y divertida. Con la proliferación de herramientas de depuración y trampas, mantener la integridad del juego se convierte en una prioridad. Implementar un sistema sólido de seguridad es crucial para proteger tanto a los jugadores como al servidor. En esta guía, exploraremos cómo integrar un sistema anti-cheat y anti-crack que detecte y responda a la presencia de depuradores como OllyDbg, HxD e IDA Pro, así como a otras técnicas de ingeniería inversa que amenazan la estabilidad del juego.

¿Por Qué es Vital un Sistema Anti-Crack en MuEmu/SSEMu?

Los servidores de Mu Online, especialmente en sus temporadas más populares como la Season 6, son frecuentemente atacados por intentos de manipulación. Los jugadores o terceros malintencionados pueden intentar:

Alterar el cliente del juego: Para obtener ventajas injustas, como hacks de velocidad, teletransporte o daño modificado.
Depurar el servidor: Para entender su funcionamiento interno y explotar vulnerabilidades.
Ingeniería inversa: Para crear bots o programas que automatizan tareas, desbalanceando la economía del juego y la experiencia de los demás.

Este sistema anti-crack, cuyo código analizaremos y aprenderemos a implementar, actúa como una primera línea de defensa, detectando estas herramientas y respondiendo de forma drástica para proteger tu servidor y tu comunidad de jugadores.

Puedes Descargar los Archivos .cpp y .h

Descargar AntiCrack.cpp

Descargar AntiCrack.h

Comprendiendo el Código: La Base de Tu Defensa

El corazón de nuestro sistema anti-crack reside en un conjunto de funciones en C++ diseñadas para realizar comprobaciones específicas en el entorno de ejecución. A continuación, detallaremos cómo cada parte del código contribuye a la seguridad de tu servidor de MuEmu o SSEMu.

Funciones de Detección de Ventanas (`SystemOut1`, `SystemOut2`, `SystemOut3`)

Estas funciones son tu primera barrera. Actúan como «centinelas» que buscan activamente ventanas de herramientas de depuración y edición hexadecimal bien conocidas:

SystemOut1(): Busca activamente la ventana de OllyDbg, un popular depurador de ensamblador utilizado para analizar y modificar ejecutables.
SystemOut2(): Detecta la ventana de HxD, un editor hexadecimal que permite ver y modificar el código binario de archivos, a menudo usado en conjunto con depuradores.
SystemOut3(): Diseñada para encontrar las ventanas de IDA Pro (tanto ida64 para 64-bits como idaq para 32-bits), una de las herramientas de desensamblado y depuración más potentes y utilizadas en ingeniería inversa.

Si alguna de estas herramientas es detectada, el sistema no solo intentará reiniciar la máquina (shutdown -r -f -t 00) para interrumpir la operación maliciosa, sino que también forzará un crasheo del proceso (MOV EAX, 00000000; CALL EAX;) para asegurar que la ejecución se detenga inmediatamente.

Detección por Manejo de Excepciones (`CheckDbgPresentCloseHandle`)

Esta función es un truco inteligente. Intenta cerrar un identificador de memoria inválido (0x8000). En un sistema normal, esta operación no debería generar una excepción crítica. Sin embargo, muchos depuradores están diseñados para interceptar y notificar al usuario sobre tales «errores» en la memoria. Si se produce una excepción al intentar esta acción, el código interpreta que un depurador está presente.

Técnicas Anti-Depuración con Instrucciones de Ensamblador (`Int2DCheck`, `IsDbgPresentPrefixCheck`)

Estas son las técnicas más avanzadas y «sigilosas» del sistema. Utilizan instrucciones específicas de ensamblador (int 0x2d e 0xF3 0x64 0xF1) que se comportan de manera diferente cuando hay un depurador adjunto.

Código Fuente para la Implementación

A continuación, encontrarás el código completo que deberás integrar en tu proyecto. Asegúrate de incluirlo en un archivo .cpp (por ejemplo, AntiCrack.cpp) y de tener las cabeceras necesarias.

#include "stdafx.h"
#include "AntiCrack.h" // Asegúrate de que este archivo exista y contenga las declaraciones de estas funciones

#if(ANTI_CRACK_MAIN == 1) // Define ANTI_CRACK_MAIN en 1 para activar la protección
void MainProtection() {
    SystemOut1();
    SystemOut2();
    SystemOut3();
    CheckDbgPresentCloseHandle();
    Int2DCheck();
    IsDbgPresentPrefixCheck();
}

// will read if OllyDbg debugger is active
void SystemOut1() {
    HANDLE holly = FindWindow(TEXT("OllyDbg"), NULL);
    if (holly) {
        system("@echo Off");
        system("shutdown -r -f -t 00");
        __asm { MOV EAX, 00000000; CALL EAX; }
    }
}

// will read if the HxD debugger is active
void SystemOut2() {
    HANDLE hxd = FindWindow(TEXT("HxD"), NULL);
    if (hxd) {
        system("@echo Off");
        system("shutdown -r -f -t 00");
        __asm { MOV EAX, 00000000; CALL EAX; }
    }
}

// will read if the ida pro debugger is active
void SystemOut3() {
    HANDLE ida = FindWindow(TEXT("ida64"), NULL);
    if (ida) {
        system("@echo Off");
        system("shutdown -r -f -t 00");
        __asm { MOV EAX, 00000000; CALL EAX; }
    }
    HANDLE idaq = FindWindow(TEXT("idaq"), NULL);
    if (idaq) {
        system("@echo Off");
        system("shutdown -r -f -t 00");
        __asm { MOV EAX, 00000000; CALL EAX; }
    }
}

// CheckCloseHandle will call CloseHandle on an invalid
// DWORD aligned value and if a debugger is running an exception
// will occur and the function will return true otherwise it'll return false
inline bool CheckDbgPresentCloseHandle() {
    HANDLE Handle = (HANDLE)0x8000;
    __try {
        CloseHandle(Handle);
    } __except (EXCEPTION_EXECUTE_HANDLER) {
        return true;
    }
    return false;
}

// The Int2DCheck function will check to see if a debugger
// is attached to the current process. It does this by setting up
// SEH and using the Int 2D instruction which will only cause an
// exception if there is no debugger. Also when used in OllyDBG
// it will skip a byte in the disassembly and will create some havoc.
inline bool Int2DCheck() {
    __try {
        __asm {
            int 0x2d
            xor eax, eax
            add eax, 2
        }
    } __except (EXCEPTION_EXECUTE_HANDLER) {
        return false;
    }
    return true;
}

inline bool IsDbgPresentPrefixCheck() {
    __try {
        __asm __emit 0xF3 // 0xF3 0x64 disassembles as PREFIX REP:
        __asm __emit 0x64
        __asm __emit 0xF1 // One byte INT 1
    } __except (EXCEPTION_EXECUTE_HANDLER) {
        return false;
    }
    return true;
}
#endif

Pasos para la Implementación en Tu Proyecto de MuEmu/SSEMu

Integrar los archivos:
- Crea un nuevo archivo .cpp (por ejemplo, AntiCrack.cpp) en la solución de tu proyecto de servidor o cliente de MuEmu Season 6 o SSEMu Season 6.
- Pega el código proporcionado en este nuevo archivo.
- Asegúrate de que haya un archivo de encabezado AntiCrack.h que declare las funciones como void MainProtection();, void SystemOut1();, etc., para que el compilador las reconozca.
Configurar la Macro ANTI_CRACK_MAIN:
- Dentro de la configuración de tu proyecto (o en un archivo de encabezado global como stdafx.h o un archivo de configuración del proyecto), define la macro ANTI_CRACK_MAIN con el valor 1. Esto asegura que el código de protección se compile. Por ejemplo, puedes añadir #define ANTI_CRACK_MAIN 1 en algún lugar accesible por el compilador.
Llamar a MainProtection():
- Identifica el punto de entrada principal de tu servidor o cliente de juego (por ejemplo, en la función main o en el hilo principal de ejecución).
- Inserta una llamada a la función MainProtection() al inicio de tu aplicación. Es crucial que esta llamada se haga lo antes posible para que las comprobaciones se activen desde el primer momento.
```
// Ejemplo de dónde podrías llamar a MainProtection()
int main() {
    // ... otras inicializaciones del servidor/cliente
```