Inicio>Relacionado con la programación>código fuente c#
Descargar

Biblioteca avanzada de piratería de juegos (C/C++/Rust/Python) (Windows/Linux/FreeBSD)

Hecho por rdbo

Servidor de discordia

https://discord.com/invite/Qw8jsPD99X

Licencia

Este proyecto tiene licencia GNU AGPLv3.0 (no hay versiones posteriores)

Lea LICENSE para más información

NOTA: ¡Los submódulos y las dependencias externas pueden tener sus propias licencias! Verifique también sus licencias.

Plataformas

SO x86 x64 BRAZO aarch64
ventanas ✅ ✅ ️ ️
linux ✅ ✅ ️ ️
FreeBSD ✔️ ✔️ ️ ️
Estado Descripción
✅ 100% funcionando
✔️ Principalmente trabajando
️ No probado

Características

  • Interno y Externo
  • Encuentre y enumere procesos, módulos, símbolos, subprocesos y segmentos
  • Memoria de lectura/escritura
  • Asignar/proteger memoria
  • Escanear memoria por patrón/firma
  • Resolver escaneos de puntero/mapas de puntero
  • Funciones de gancho/desenganche
  • Código de montaje/desmontaje (JIT)
  • VMT Enganche/Desenganche
  • Módulos de carga/descarga
  • Enumerar subprocesos de proceso

¡Y mucho más!

Ejemplos

C++ moderno 

 /* C++20 or higher */
# include < libmem/libmem.hpp >
# include < iostream >

using namespace libmem ;

int main ()
{
	Address disas_addr = reinterpret_cast 
(main);

	// Disassemble function 'main' until a 'ret' is found
	for (;;) {
		auto inst = Disassemble (disas_addr). value ();
		std::cout << inst. to_string () << std::endl;
		if (inst. mnemonic == " ret " )
			break ;
		disas_addr += inst. bytes . size ();
	}

	return 0 ;
}

/*
Output:
0x55b1a3259275: push rbp -> [ 55 ]
0x55b1a3259276: mov rbp, rsp -> [ 48 89 e5 ]
...
0x55b1a325941a: leave  -> [ c9 ]
0x55b1a325941b: ret  -> [ c3 ]
*/

C/C++ 

 #include 

void hk_take_damage ( int amount )
{
  printf ( "hooked take_damage! no damage will be takenn" );
  return ;
}

int main ()
{
	lm_module_t game_mod ;
	lm_address_t fn_take_damage ;

	LM_FindModule ( "game.dll" , & game_mod );
	printf ( "[*] Base address of 'game.dll': %pn" , game_mod . base );

	fn_take_damage = LM_FindSymbolAddress ( & game_mod , "take_damage" );
	printf ( "[*] Found 'take_damage' function: %pn" , fn_take_damage );

	LM_HookCode ( fn_take_damage , hk_take_damage , LM_NULLPTR );
	printf ( "[*] 'take_damage' hooked, player will no longer receive damagen" );

	return 0 ;
}

Óxido 

 use libmem :: * ;

fn godmode ( ) -> Option < ( ) > {
    let game_process = find_process ( "game_linux64" ) ? ;
    let client_module = find_module_ex ( & game_process , "libclient.so" ) ? ;

    let fn_update_health = sig_scan_ex (
        & game_process ,
        "55 48 89 E5 66 B8 ?? ?? 48 8B 5D FC" ,
        client_module . base ,
        client_module . size ,
    ) ? ;
    println ! (
        "[*] Signature scan result for 'update_health' function: {}" ,
        fn_update_health
    ) ;

    let shellcode = assemble_ex ( "mov rbx, 1337; mov [rdi], rbx; ret" , Arch :: X64 , 0 ) ? ;
    write_memory_ex ( & game_process , fn_update_health + 8 , & shellcode . as_slice ( ) ) ? ;
    println ! ( "[*] Patched 'update_health' function to always set health to 1337!" ) ;

    Some ( ( ) )
}

fn main ( ) {
    godmode ( ) ;
}

Pitón 

 from libmem import *
import time

process = find_process ( "game.exe" )
game_mod = find_module_ex ( process , process . name )

# Resolve a Cheat Engine pointer scan
health_pointer = deep_pointer_ex ( process , game_mod . base + 0xdeadbeef , [ 0xA0 , 0x04 , 0x10 , 0xF0 , 0x0 ])

# Set player health to 1337 forever
while True :
    write_memory_ex ( process , health_pointer , bytearray ( int ( 1337 ). to_bytes ( 4 )))
    time . sleep ( 0.2 )

Documentación

La documentación principal de libmem se puede encontrar en include/libmem.h . Todas las API están documentadas y contienen información muy descriptiva sobre cada función, sus parámetros y valor de retorno. Están ubicados en comentarios cercanos, por lo que deberías poder verlos colocando el cursor sobre tu editor de texto/IDE.

De manera similar, la documentación de enlaces está integrada con sus paquetes, por lo que su editor de texto/IDE debería poder acceder a la documentación de cada API.

Enlaces no oficiales

Estos enlaces los realiza la comunidad/terceros y no están afiliados al proyecto libmem ni a su autor.

Su código también puede tener sus propias licencias, que difieren de las de libmem.

  • Nim_Libmem
  • Crazymem (NodeJS)

Uso de CMake (sin instalar)

Agregue los siguientes comandos a su CMakeLists.txt .

Recuperarán libmem-config.cmake de la raíz de este repositorio, que descargará los binarios de libmem para su sistema e incluirá libmem en su proyecto CMake. 

 include (FetchContent)

# Download and set up libmem
FetchContent_Declare(libmem-config URL "https://raw.githubusercontent.com/rdbo/libmem/config-v1/libmem-config.cmake" DOWNLOAD_NO_EXTRACT TRUE )
FetchContent_MakeAvailable(libmem-config)
set ( CMAKE_PREFIX_PATH "${libmem-config_SOURCE_DIR}" " ${CMAKE_PREFIX_PATH} " )
set (LIBMEM_DOWNLOAD_VERSION "5.0.2" )

# Find libmem package
find_package (libmem CONFIG REQUIRED)

Utilice lo siguiente para vincular con libmem (NOTA: puede ser necesario vincular con otras dependencias; vaya a la sección Dependencies para obtener más información): 

 # Link against libmem
target_link_libraries ( PRIVATE libmem::libmem)

Instalación

ventanas

Nota : si descarga una versión binaria de libmem en las versiones de GitHub, solo necesita instalar el SDK de Windows. No es necesario compilar, simplemente agregue libmem/include a los directorios de inclusión de su proyecto y vincúlelo con el binario que descargó.

  1. Instale el SDK de Windows: Windows 7 - Windows 10/11

  2. Instale Python 3 (Marque la opción para agregar Python a PATH) (Use Python 3.8.9 para Windows 7)

  3. Instale Visual Studio 2022 o posterior (con compatibilidad con C++ y CMake) (las versiones anteriores pueden funcionar, pero no se probaron). NOTA: Puede instalar solo Visual Studio Build Tools si no desea el IDE completo.

  4. Instalar Git Bash

  5. Ejecute un Developer Command Prompt de Visual Studio (o x64 Native Tools Command Prompt for VS 2022 para 64 bits) como administrador

  6. Ejecute el siguiente comando para agregar el directorio de destino de libmem a su variable de usuario %PATH% ( ADVERTENCIA : ¡esté atento al límite de tamaño de %PATH% !): 

     setx PATH "%PATH%;%ProgramFiles%libmeminclude;%ProgramFiles%libmemlib"

  7. Continúe leyendo en Build and Install

linux

Nota : Los siguientes comandos son para distribuciones basadas en Debian/Ubuntu. Asegúrese de encontrar los comandos apropiados para su distribución de Linux.

  1. abrir una terminal

  2. Instale GCC, G++, Git, CMake, Make, Python 3 y los encabezados de Linux: 

     sudo apt install gcc g++ git cmake make python3 linux-headers

  3. Continúe leyendo en Build and Install

FreeBSD

  1. Agregue un punto de montaje para el sistema de archivos procfs en su /etc/fstab agregando la siguiente línea: 

     proc		/proc		procfs	rw	0	0

  2. Monte manualmente los procfs . Esto sólo será necesario si no reinicias. Si reinicia, se montará automáticamente debido a la línea en /etc/fstab . Ejecute el siguiente comando (como root): 

     mount -t procfs proc /proc

  3. Instale Git, CMake y Python3 (ejecútelo como root) (clang, clang++ y make ya deberían estar instalados): 

     pkg install git cmake python3

  4. Continúe leyendo en Build and Install

Construir e instalar

Nota : Ejecute los siguientes comandos en Git Bash (Windows) o una terminal (Linux/FreeBSD).

Clonar el repositorio: 

 git clone --recursive --depth 1 https://github.com/rdbo/libmem

Genere el caché de CMake: 

 mkdir build
cd build
cmake .. -DCMAKE_BUILD_TYPE=Release

Compilar libmem:

Windows : nmake

Tipo Unix : make -j 4

Instale libmem (ejecútelo como root o como administrador):

Windows : nmake install

Tipo Unix : make install

Después de la instalación, siga la sección Usage adecuada para su lenguaje de programación.

Uso (C/C++)

Agregue #include (C/C++) o #include (C++) a su código fuente. Vincule la biblioteca libmem generada con su binario ( liblibmem.so para Unix o libmem.dll para Windows). Para compiladores tipo GCC : agregue el indicador -llibmem a su compilador y debería vincularlo. 

 #include  /* C/C++ */
#include  /* Force C++ */

Uso (óxido)

NOTA : Ya no es necesario instalar libmem para usarlo con Rust, siempre que la función fetch esté habilitada en la caja de libmem (predeterminada). Si desactiva esa característica, buscará libmem en su sistema y podrá hacer explícita la ruta de libmem utilizando el entorno var LIBMEM_DIR= .

Agregue la siguiente línea a su Cargo.toml en [dependencies] : 

 libmem = " 5 "

Importa libmem en tu código fuente de Rust: 

 use libmem :: * ;

Uso (Python)

NOTA : Ya no es necesario instalar libmem para usarlo con Python. Si no se encuentra ninguna instalación, el paquete buscará y vinculará libmem sin problemas. Puede usar la variable de entorno LIBDIR= para indicarle al paquete libmem dónde buscar su instalación (si la instaló).

Asegúrate de tener Python >= 3.6 activo
Instale el paquete libmem desde PyPi ejecutando el siguiente comando: 

 pip install --upgrade libmem

O compílelo e instálelo usted mismo ejecutando los siguientes comandos: 

 cd libmem-py
python configure.py
python setup.py install

Ahora, para importar libmem, simplemente haga lo siguiente en su código Python: 

 from libmem import *

Dependencias

Todo:

  • piedra angular (incluida en el proyecto raíz)
  • Keystone (incluido en el proyecto raíz)
  • LIEF (incluido en el proyecto raíz)
  • libstdc++ (usado en Keystone, LIEF y LLVM)
  • libmath (usado en Keystone)

Ventanas:

  • SDK de Windows (user32.lib, psapi.lib, ntdll.lib, shell32.lib)

Linux/Android:

  • libdl (-ldl)

BSD:

  • libdl (-ldl)
  • libkvm(-lkvm)
  • libprocstat(-lprocstat)
  • difamación (-lelf)

Descripción general de la API 

 LM_EnumProcesses
LM_GetProcess
LM_GetProcessEx
LM_FindProcess
LM_IsProcessAlive
LM_GetBits
LM_GetSystemBits

LM_EnumThreads
LM_EnumThreadsEx
LM_GetThread
LM_GetThreadEx
LM_GetThreadProcess

LM_EnumModules
LM_EnumModulesEx
LM_FindModule
LM_FindModuleEx
LM_LoadModule
LM_LoadModuleEx
LM_UnloadModule
LM_UnloadModuleEx

LM_EnumSymbols
LM_FindSymbolAddress
LM_DemangleSymbol
LM_FreeDemangledSymbol
LM_EnumSymbolsDemangled
LM_FindSymbolAddressDemangled

LM_EnumSegments
LM_EnumSegmentsEx
LM_FindSegment
LM_FindSegmentEx

LM_ReadMemory
LM_ReadMemoryEx
LM_WriteMemory
LM_WriteMemoryEx
LM_SetMemory
LM_SetMemoryEx
LM_ProtMemory
LM_ProtMemoryEx
LM_AllocMemory
LM_AllocMemoryEx
LM_FreeMemory
LM_FreeMemoryEx
LM_DeepPointer
LM_DeepPointerEx

LM_DataScan
LM_DataScanEx
LM_PatternScan
LM_PatternScanEx
LM_SigScan
LM_SigScanEx

LM_GetArchitecture
LM_Assemble
LM_AssembleEx
LM_FreePayload
LM_Disassemble
LM_DisassembleEx
LM_FreeInstructions
LM_CodeLength
LM_CodeLengthEx

LM_HookCode
LM_HookCodeEx
LM_UnhookCode
LM_UnhookCodeEx

LM_VmtNew
LM_VmtHook
LM_VmtUnhook
LM_VmtGetOriginal
LM_VmtReset
LM_VmtFree

Contribuyendo

Lea el archivo CONTRIBUTING.md en el directorio raíz de este repositorio

Proyectos

Hecho con libmem:

  • Multihack de AssaultCube
  • X-inyectar
  • Enlace base DirectX9
  • Gancho base DirectX11
  • Gancho base OpenGL
  • Gancho base de Counter-Strike 1.6
Expandir
Información adicional
Aplicaciones relacionadas
Recomendado para ti
Información relacionada Todo