Archivo

Archive for the ‘Windows’ Category

Dev-C++: IDE y compilador de C/C++ para Windows

Bloodshed Dev-C++ es un entorno de desarrollo integrado (IDE por sus siglas en inglés) para programar en lenguaje C/C++. Usa MinGW que es una versión de GCC (GNU Compiler Collection) como su compilador. Dev-C++ puede además ser usado en combinación con Cygwin y cualquier compilador basado en GCC.

El Entorno está desarrollado en el lenguaje Delphi de Borland. Tiene una página de paquetes opcionales para instalar, con diferentes bibliotecas de código abierto.

Instalación

1. Descargar la versión Dev-C++ 5 Beta 9 (versión 4.9.9.2) (8,89 MB).

2. Ejecutar el archivo devcpp-4.9.9.2_setup.exe y seguir las instrucciones en pantalla.

3. Tras la instalación Dev-C++ se ejecuta automáticamente para configurarlo.

4. Elegir Idioma (Español (Castellano)) y tema (New Look + Xp Theme) y aceptar.

5. Decirle que quereis crear la cache de ficheros de cabecera (se lleva un ratete).

6. Al fin arrancará Dev-C++. Ahora hay que tocar las opciones de configuración:

  1. Herramientas -> Opciones del compilador -> Configuración -> Linker -> Generar información de debug -> YES
  2. Herramientas -> Opciones del entorno -> Principal: Activar Crear archivo de respaldo
  3. Herramientas -> Opciones del editor -> Principal: Activar Resaltar llaves y parentesis concordantes.
  4. Herramientas -> Opciones del editor -> Visualización: Activar Número de línea.
  5. Herramientas -> Opciones del editor -> Sintaxis: Seleccionar en Pre-configuracicones: Classic

7. Descargar el manual de la biblioteca estándar de C para Dev-C++ 5 (1,29 MB).

8. Abrir el Manejador de Paquetes de Dev-C++ (Herramientas -> Package Manager).

9. Pulsar Install y seleccionar GlibcHelp.DevPak

10. Seleccionar Ayuda -> Configurar el Menú de ayuda

  1. Pulsar Añadir y seleccionar Libc.hlp (posiblemente en Cev-CppHelp).
  2. Editar el texto del menú para que ponga “Manual de Ayuda de la biblioteca estándar de C”
  3. Activar Busca en el archivo…

11. Descargar el manual de la biblioteca estándar de C++ (2,78 MB).

12. Copiarlo en Cev-CppHelp (o el directorio correspondiente)

13. Seleccionar Ayuda -> Configurar el Menú de ayuda

  1. Pulsar Añadir y seleccionar libstdc++-3.3.2.chm (posiblemente en Cev-CppHelp).
  2. Editar el texto del menú para que ponga “Manual de Ayuda de la biblioteca estándar de C++”
  3. Activar Busca en el archivo…

14. Ya está, ¡a trabajar!

Videotutorial para aprender a programar en Dev-C++

Aquí les dejo el primer tutorial de una colección que enseña cómo dar los primeros pasos para programar con Dev-C++:

Aprender a programar con Dev-C++

Inyección DLL en C

Introducción

Inyectar una DLL en un proceso corriendo, es insertar una DLL en el espacio de direcciones de un proceso.. como todos ustedes -deben- saber esto es: cuando ustedes cargan una libreria esta va a su espacio de direcciones, esto quiere decir, sus variables/memoria en general son todas accesibles con punteros normales por la DLL misma

Explicaré cómo funciona esto en win95/98/ME/XP/2k/NT. Hice todo esto en VC++6 por que asi lo preferi.

Este compilador también trabaja en .NET, probablemente en versiones cercanas, no lo se.

Esto es util cuando nesesitas hacer un APISpy por ejemplo, un programa que salve en un archivo las funciones API que fueron llamadas en el programa.

Yo hice un WSOCK32.DLL espia para mirc.exe. Es muy divertido 🙂

Basicamente esto te da control total sobre una aplicacion.

Algunos de ustedes, Script Kiddies deben pensar: “esto es bueno para Hackear” pero una ves tienes el control de esto obtendras mucha mas divercion que hackear.

Hay cosas que debes saber antes de leer este articulo (Lo siento, no podia ser solamente, “Enseñame todo”, hay mucho mas que eso)

msdn.microsoft.com: Puede ser usado para aprender “todo” de él.

Conocimientos básicos

  1. Administracion de memoria… Nesesitas saber como Winodws administra su memoria
  2. Cabeceras PE ß Lo mas importante, si estas haciendo esto en win9x/ME
  3. API’s basicas de depuracion… Hay algunas API’s que te permiten depurar una cierta aplicacion.
  4. Bastantes conocimientos de Ensamblador… y OPCODES de instrucciones.

Yo creo, si lees toda la sección de “Servicios Base” en la libreria MSDN tu deberas ser capaz de aprender todos esos puntos (incluyendo el formato PE. No te preocupes, te ayudaré bastante a encontrar los articulos que nesesitas. Escepto AMS por su puesto, Nesesitas algunos pequeños tutorials de ASM y despues aprende alguno de ASM32bits (API).

Después, ya estarás listo.

Quieres aprender Inyeccion DLL? Contentate porque postié esta información aquí, me tomo una semana completa preparar este articulo, no estoy dandote toda la matequilla tu debes buscar por ti mismo, solo te estoy dando un inicio.

Si no te gusta buscar, entonces este articulo no es para ti, lo siento…

Empezando

Ya te dije qué es la Inyeccion DLL…

Bueno, te platicaré mas acerca de esto…

Averigüé los siguientes enlaces para que aprendas lo que nesesitas aprender (Dejare la parte de ASM para ti, buscalo ):

1) DLL’s, procesos e hilos: Leer la sección DLL (solo aprendan a hacer una dll que explorte funciones) asi que basicamente mira DllMain() funcion de callback en una DLL, esto debe ser como un curso acelerado de DLL’s :p :p, procesos e hilos no son realmente nesesarios de leer, pero es preferable.

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dllproc/base/dynamic_link_library_creation.asp

2) Depuracion: (Leer solamente la sección basica de depuracion, es facil CREANME y te estare ense~ando un poco)

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dllproc/base/dynamic_link_library_creation.asp

3) Descargen el formato PE… es un poco duro, pero como dije, te ayudaré.

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dllproc/base/dynamic_link_library_creation.asp

 

Todo lo que dije no sera realmente nesesario si me sigues correctamente.

Ok… empecemos lo que voy a hacer es un espia API , lo que este programa hace es: (si la DLL fue cargada en el espacio de direcciones de la aplicacion) monitorear la funcion MessageBoxA() (si esta estubiera en la tabla de importacion de la aplicacion) y mostrarla normalmente (Notar que obtuve mi inspiracion del libro de Matt Pietrek, Secretos de programacion en Windows 95. Dios te vendiga)

Haré tres funciones que grabaran un archivo log:

Código:

HANDLE OpenLog( char *FileName );
BOOL AppendLog( HANDLE hLog, char *buffer, DWORD bufSize );
BOOL  CloseLog( HANDLE hLog );

Leer CreateFile() en MSDN, te ayudare a crear esas tres funciones.;

OpenLog basicamente hace esto:

Código:

return CreateFile( FileName, GENERIC_WRITE|GENERIC_READ, FILE_SHARE_READ, OPEN_ALWAYS, 0, 0 );

GENERIC_*: Abre el archivo para lectura/escritura.

FILE_SHARE_READ: La aplicacion puede leer el archivo mientras el manejador este abierto.

OPEN_ALWAYS: Abrir el archivo o crearlo si no existe.

AppendLog(…): Usa SetFilePointer(hLog,0,0,FILE_END) para pocicionar el puntero al final del archivo despues WriteFile() para escribir en el archivo

CloseLog(…):

Código:

CloseHandle(hLog);

Eso es todo.

Primero nesesitas crear una DLL, esto es lo que debe hacer:

Pon 3 funciones Log en la dll…

Cuando la dll carge (DllMain() ) y fdwReason sea DLL_PROCESS_ATTACH, hacer esto:

Crear el archivo log (OpenLog)

Añadir: “******************\r\nDLL_PROCESS_ATTACH\r\n”; (\r == CR, \n == LF – en windows)

Despues llama la funcion que “enlazara” MessageBox() del proceso.

 

La funcion que “enlazara” MessageBox():

Para enlazar MessageBox, Debes crear una funcion que sera llamada “EN LUGAR” de MessageBox! Por lo tanto la definicion de la funcion debe ser exactamente como la original MessageBox:

Código:

int MessageBox(HWND hWnd, LPCTSTR lpText, LPCTSTR lpCaption, UINT uType); //Asi es como esta declarada en msdn

int WINAPI MyMsgBox(HWND hWnd, LPCTSTR lptext, LPCTSTR lpcaption, UINT utype); //Asi es como tu la declaras

//WINAPI es lo que se le llama “Calling convention”, buscar “CALLING CONVENTIONS” en msdn, esto quiere decir poner los parametros de la funcion en la pila de derecha a izquierda en lugar de izquierda a derecha (aha! Leiste un tutorial de asm?)

 

–Simplemente siempre agrega WINAPI cuando esta sea una funcion API :p

 

ok, ahora nesesitas crear una funcion del tipo:

 

Código:

typedef int(WINAPI *MyMsgBoxProc) (HWND hWnd, LPCTSTR lptext, LPCTSTR lpcaption, UINT utype); //espero que sepas que significa esto

 

ok, leiste acerca de las cabeceras PE?

Aqui esta el codigo de la DLL

 

Código:

#include <windows.h>
#include <iostream>
#include <string>
#include <cstdio>

using namespace std;

#define LogFile "d:\\logs\\LOG.txt"
#define Append(text) AppendLog(hLogFile, text, strlen(text)) //hLogFile es la variable global declarada arriba:

HINSTANCE g_hInst=0;
HANDLE hLogFile=0;
BOOL DoHookProcs();
PROC WINAPI HookImportedFunction(HMODULE,PSTR,PSTR,PROC); //Inspirado por Matt Pietrek

BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID _Reserved)
{
  switch(dwReason)
  {
    case DLL_PROCESS_ATTACH:
      g_hInst = hInstance; //Remember dll instance
      hLogFile = OpenLog( LogFile );
      Append("\r\n************************\r\nDLL_PROCESS_ATTACH\r\n"); //(fijate en #defines arriba
      //El manejador es una variable local en mi caso, asi que no nesesite ponerlo
      DoHookProcs(); //<--Funcion principal
      return true; //si regresas false, en tonses el proceso que llamo a LoadLibrary() regresara 0
      break;

    case DLL_THREAD_ATTACH:
      Append("DLL_THREAD_ATTACH\r\n"); //recuerda que un programa puede tener mas un hilo
      break; //Asi que tu tienes que tratarlos aqui, y en el siguiente caso,,,pero, Este es un programa simple
      //para procesos con un hilo,,Trabaja con esos de multiples hilos, pero no todo el tiempo

    case DLL_THREAD_DETACH:
      Append("DLL_THREAD_DETACH\r\n"); //
      break;

    case DLL_PROCESS_DETACH:
      Append("DLL_PROCESS_DETACH\r\n********************\r\n\r\n"); //append (look at the #define)
      CloseLog(hLogFile); //ummmmmmmmmmmmmm, adivina que hace esto?
      return true;
      break;
  }//fin del switch(dwReason)

  return true;
}

//////// OK espero allas entendido esto, HASTA AHORA,,, ahora todo lo que tenemos que hacer es DoHookProcs(), despues HookImportedFunction()

 

Ahora tenemos que “Enlazar” la funcion MessageBox

Si aprendiste sobre caveseras PE, entonces esto debera ser facil para ti

lo que nesesitas saber es buscar la tabla de importacion de el modulo cargado en memoria

//puedes obtener la direccion base del modulo haciendo esto: GetModuleHandle(0) en la dll — HMODULE == Direccion base del modulo

… yeah, si ves la direccion, veras los primeros bytes de la firma de un archivo DOS “MZ”!!!

————

 

Despues de que encuentres la tabla de importacion enumera las funciones importadas en la dll (Nota que una funcion no estara en la tabla de importacion si esta fue cargada en tiempo de ejecucion) busca la funcion que quieres enlazar, en nuestro caso esta:

DLLFile= USER32.DLL

FUNCTION= MessageBoxA

 

La ‘A’ al final de MessageBox es algo importante es justo como esta declarada en la dll y vc++ (windows.h) hace esto #define MessageBox MessageBoxA

 

OKAY!

Ya que allas encontrado la funcion (recuerda que: en el archivo .exe, encontraras el nombre de la funcion)

pero en memoria no lo encontraras,,, solo el punto de entrada (entry point de ahora en adelante) de MessageBoxA…

asi que, nesesitas obtener el entry point de “MessageBoxA” (en la funcion HookImportedFunction()) haciendo esto

GetProcAddress(GetModuleHandle(“USER32.DLL”), “MessageBoxA”);

Nota que utilise GetModuleHandle,,,por que user32.dll esta “supuestamente” cargada ya que la aplicacion llama a MessageBoxA de user32.dll, verda? asi que debe cargar la dll en su espacio de direcciones.

asi que tu utilisaste GetProcAddress para obtener la direccion del proceso MessageBoxA…

 

y ahora, que encontraste la funcion en la tabla de importacion, ahora lo que nesesitas hacer es justamente guardar ese valor(entry point / punto de entrada) (en caso de que quieras establecerlo de nuevo) y remplasarlo con u nuevo entry point el cual sera el punto entry point de tu funcion MyMsgBox()

chdo he?

 

Asi que siempre que el programa llame a MessageBoxA(),,, MyMsgBox() sera llamada tambien…

Despues, es tu trabajo hacer lo que quieras…

y despues de que lo allas echo deja que se muestre la funcion MessageBox (si tu quieres y es preferible)

perooooooooooo, no por la funcion MessageBox(…) sino por la direccion regresada por GetProcAddres() que te dije que llamaras arriba ^^

 

asi, tu hisiste esto:

OriginalMessageBoxProc = (MyMsgBoxProc)GetProcAddress(GetModuleHandle(“USER32.DLL”), “MessageBoxA”);

y lo que tienes que hacer es esto:

OriginalMessageBoxProc( hWnd, lptext, lpcaption, utype ); //simple

ok ahora vallamos al codigo

//declaremos algunas cosas:

Código:

typedef int(WINAPI *MyMsgBoxProc)(HWND hWnd, LPCTSTR lptext, LPCTSTR lpcaption, UINT utype);//recuerdas esto?

MyMsgBoxProc OriginalMessageBoxProc; //<————–aqui es donde almacenamos el original MessageBox()

 

// Macro para agregar punteros DWORDs juntas, sin aritmetica — obtube esto del libro de Matt Pietrek

#define MakePtr( cast, ptr, addValue ) (cast)( (DWORD)(ptr)+(DWORD)(addValue))

 

 

//Este codigo es muy similar al de Matt Pietrek, exepto que este esta escrito deacuerdo a mi entendimiento…

Código:

PROC WINAPI HookImportedFunction(HMODULE hModule,     // Modulo donde se interseptaran las llamdas

PSTR FunctionModule, //La dll que contiene la funcion que quieres enlazar

PSTR FunctionName,   //lLa funcion que quieres enlazar ("MessageBoxA" en nuestro caso)

PROC pfnNewProc)     //Nueva funcion, esta sera llamada en su lugar

{

PROC pfnOriginalProc;

IMAGE_DOS_HEADER *pDosHeader;

IMAGE_NT_HEADERS *pNTHeader;

IMAGE_IMPORT_DESCRIPTOR *pImportDesc;

IMAGE_THUNK_DATA *pThunk;

if ( IsBadCodePtr(pfnNewProc) ) return 0; //Verifica que el pfn pasado sea valido --ver msdn--

pfnOriginalProc = GetProcAddress(GetModuleHandle(FunctionModule), FunctionName); //Recuerdas esto?

if(!pfnOriginalProc) return 0;

pDosHeader = (PIMAGE_DOS_HEADER)hModule; //ve la referencia de las funciones ImgHelp en la sección "Image Help Library" en msdn

////////////////// Para hacer esto de una forma facil, deacuerdo a tu imaginacion

////////////////////////////////// Yo lo estoy haciendo de esta forma, pero tu deberias aprender esactamente que pasa

//hModule es la direccion base del proceso, recuerdas? (GetModuleHandle(0)) <-- incluso si se lamara en la dll, sigue

//									 devolbiendo el hModule de el proceso de llamado

//--- por eso guarde hInstance de la dll, h-hInst, por que es la unica manera para obtenerlo (creo)

// verifiquemos para estar seguros que estamos viendo a un modulo de imagen (la cavesera 'MZ')

if ( IsBadReadPtr(pDosHeader, sizeof(IMAGE_DOS_HEADER)) )

return 0;

if ( pDosHeader->e_magic != IMAGE_DOS_SIGNATURE ) //Image_DOS_SIGNATURE es un WORD (2bytes, con los valores 'M', 'Z' )

return 0;

// La cavesera MZ tiene un puntero a la cavesera PE

pNTHeader = MakePtr(PIMAGE_NT_HEADERS, pDosHeader, pDosHeader->e_lfanew);  //esto hace pDosHeader + pDosHeader->e_lfanew

//////e_lfanew contiene una RVA (Direccion Virtual Relativa "Relative Virtual Address") hacia la cavesera 'PE'...una RVA quiere decir, "offset", relativo a la direccion base del modulo

//----pDosHeader es la direccion base..y e_lfanew es la RVA,,, y sumandolas, te daran

//La Direccion Vrtual :D

// Mas pruebas para estar seguros que estamos viendo a la imagen "PE"

if ( IsBadReadPtr(pNTHeader, sizeof(IMAGE_NT_HEADERS)) )

return 0;

if ( pNTHeader->Signature != IMAGE_NT_SIGNATURE ) //IMAGE_NT_SIGNATURE is a DWORD (4bytes, 'P', 'E', '', '' 's values)

return 0;

// Ahora sabemos que tenemos un puntero valido a la cavesera 'PE' del modulo. Ahora obtendremos un puntero a su secion de importacion

// Aqui es donde la accion comiensa

pImportDesc = MakePtr(PIMAGE_IMPORT_DESCRIPTOR, pDosHeader,          //IMAGE_IMPORT_DESCRIPTOR *pImportDesc;

pNTHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress);

//Lo unico que hice fue obtener la sección de importacion obteniendo su RVA (como dije arriba), despues solo agregue la direccion base

//////////// pNTHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress

///////////////IMAGE_DIRECTORY_ENTRY_IMPORT==1 -- Ver la documentacion del formato PE te di un enlace en la sección enlaces

//////////////Son los unicos buenos que encontre en internet,,,Tambien los articulos de Pietrek en MSJ y MSDN seran

//////////////realmente de ayuda

//Salimos si la tabla de importacion no existe

if ( pImportDesc == (PIMAGE_IMPORT_DESCRIPTOR)pNTHeader )

return 0; //pImportDesc sera ==pNTHeader,, si la RVA==0,,, por que pNTHeader+0==pNTHeader -> se almacena en pImportDesc

//Por lo tanto, pImportDesc==pNTHeader

// Realizar mientras el array del modulo de importacion no devuelva 0

// Buscar el modulo que iguale el nombre del parametro FunctionModule

while ( pImportDesc->Name ) //Name es un DWORD (RVA, a un nombre de DLL)

{

PSTR pszModName = MakePtr(PSTR, pDosHeader, pImportDesc->Name);

if ( stricmp(pszModName, FunctionModule) == 0 ) //str"i"cmp,,, Deberias ignorar casos de comparacion, en nuestro caso

break; //o strcmpi() in algunos compiladores

pImportDesc++;  // Avansamos al sigueinte descriptor del modulo importado

}

// Salimos si no encontramos en nombre de la dll

// pImportDesc->Name Sera diferente de cero si la encontramos

if ( pImportDesc->Name == 0 )

return 0;

// Se obtiene un puntero a la tabla de direcciones del modulo de importacion encontrado (IAT)   =====IMAGE_THUNK_DATA *pThunk;

pThunk = MakePtr(PIMAGE_THUNK_DATA, pDosHeader, pImportDesc->FirstThunk);

//Esto es de lo que estaba hablando antes...

//en pThunk, Si este fuera una imagen cargada en memoria, tendrias la direccion del entry point de la funcion.

//Pero en un archivo de disco, esto es un nombre de funcion

// Examina las direcciones de la tabla de importacion, de la DLL encontrada, buscando el entry point de la funcion

// Esto es igual a la direccion que debolberemos de GetProcAddress arriba (recuerdas?

while ( pThunk->u1.Function )

{

if ( (DWORD)pThunk->u1.Function == (DWORD)pfnOriginalProc )

{

// la encontramos!  Sobreescrivimos la direccion original con la

// direccion de la funcion de intercepcion.  Regresamos la direccion

// original

pThunk->u1.Function = (PDWORD)pfnNewProc;  // pfnNewProc Esta en los parametros de esta funcion

//pfnOriginalProc = (PROC)(DWORD)pdw1;

return pfnOriginalProc;

}

pThunk++;   // Avansamos a la siguiente direccion de funcion

}

return 0; //Funcion no encotrada!!!!!

}

———————————

 

Eso es todo!!!!!!!!!!!!!!

Estoy contento, terminamos esta funcion! :p

 

recuerdas las declaraciones?

{

//Declaremos algunas cosas:

 

typedef int(WINAPI *MyMsgBoxProc)(HWND hWnd, LPCTSTR lptext, LPCTSTR lpcaption, UINT utype);//remember this?

 

MyMsgBoxProc OriginalMessageBoxProc; //<————–This is where we store the original MessageBox()

}

 

Asi es como llamamos a la funcion de arriba.

 

OriginalMessageBoxProc = (MyMsgBoxProc)HookImportedFunction( GetModuleHandle(0), “USER32.DLL”, “MessageBoxA”, (PROC)MyMsgBox)

 

^^^^^ Insertalo en la funcion DoHookProcs()

 

ok,,,, esto es la dll terminada

Código:

BOOL WINAPI DllMain(...)

{
.
case DLL_PROCESS_ATTACH:
g_hInst = hInstance; //Instancia de la dll

hLogFile = OpenLog( LogFile );

Append("\r\n************************\r\nDLL_PROCESS_ATTACH\r\n"); //(Ver los #defines arriba

//El manejador es una variable local en mi caso, asi que no nesesite ponerlo

DoHookProcs(); //<--Funcion principal

return true; //si regresas false, en tonses el proceso que llamo a LoadLibrary() regresara 0

break;

}

y

Código:


BOOL DoHookProcs()

{

OriginalMessageBoxProc = (MyMsgBoxProc)

HookImportedFunction( GetModuleHandle(0), "USER32.DLL", "MessageBoxA", (PROC)MyMsgBox);

//Checamos que no alla error, regresamos false si hubo error o true si no lo hubo

if(!OriginalMessageBoxProc) return false;

return true;

}

 

okkkkkkk

 

asi que la funcion MyMsgBox() sera llamada en lugar que MessageBox()...

Veamos como luce la funcion , esto debe ser simple:

 

Código:

int WINAPI MyMsgBox(HWND hWnd, LPCTSTR lptext, LPCTSTR lpcaption, UINT utype)

{

int ret; //Nesesitas guardar el valor de retorno porsupuesto

char bufText[1024], bufCaption;

strcpy(bufText, "Nassoooooor sez: ");

strcat(bufText, lptext);

strcat(bufText, "\n\n\n SAVED TO LOG FILE!!");

strcpy(bufCaption, "Caption==");

strcat(bufCaption, lpcaption);

/////Has cualquier ***** que quieras

ret = OriginalMessageBoxProc( hWnd, bufText, bufCaption, utype );

//Si tu llamas MessageBox(,,,

// pasara una de 2:

//       1)  Redireccionar de nuevo a esta funcion, asi que esto llegara a ser como una recurcion infinita

//       2)  MessageBox() de la dll sera llamada. Esto no tiene nada que ver con el proceso...

// --Piensa, cual de estas 2 cosas pasara? si hiciste lo que te dije, y leiste los enlaces que te di, y los entendiste

//   entonces no deberas tener problema para resolver esta pregunta :D :D :D

// Talves algun material aqui

Append("MessageBoxA Called!\r\n\tText=\"")

Append(lptext);

Append("\"\r\n\tCaption=\"");

Append(lpcation);

Append("\"\r\n\treturn value=...);

.

.

.................

return ret;

}

Eso es todo, terminamos!!

 

estabien,,,

 

cuando ya que pongas estas funciones en la dll, crea este programa:

 

Código:

WinMain(..)
{
HMODULE hModule;

MessageBox(0, "Function not intercepted!", "NazSoft INFO BOX", 0);

if(! (hModule=LoadLibrary("MyDll.dll")) )
  MessageBox(0, "Function could not be intercepted!", "NazSoft INFO BOX", 0);
else
  MessageBox(0, "Function intercepted!", "NazSoft INFO BOX", 0);

  FreeLibrary(hModule);
  MessageBox(0, "Function called after freeing library,,, A program crash will occur here, because we didn't restore the import table as it was :D :D", "NazSoft INFO BOX", 0);

return 0;

}

MyDll.dll es esa libreria de arriba compilada

Bueno. Espero lo que entiendan. Está todo medio desordenado, ya que este tutorial no es mío, sino de Nasser Rowhani, y lo copié de su web. Y como no dispongo de mucho tiempo no pude corregirlo completamente, igual espero que les sirva.

Extras

Tutorial escrito por MazarD, que explica detalladamente todo lo relacionado con inyecciones DLL. Excelente tutorial: DESCARGAR

Programando un Trainer para el Buscaminas (Windows)

Un trainer es un cheat que permite editar un valor específico dentro de la memoria de un videojuegos, como puede ser la salud, las balas, el tiempo, étc. Este nos permitiría, por ejemplo, aumentar la salud de nuestro personaje o congelar el valor que contiene el número de balas que disponemos, entonces tendríamos balas infinitas.

Cheat-Egnine es la aplicación que nos permite encontrar estos valores dentro de los videojuegos y editarlos. También tiene otras utilidades que veremos más adelante.

Antes que nada, si no tienes conocimientos sobre las direcciones de memoria y los valores te recomiendo que leas las entradas anteriores publicadas en la sección de Game-Hacking.

Requisitos:

  • Un compilador de C++ y un IDE. Podría ser Dev-C++ que viene con el compilador “gcc”(descargar de aquí ) o Code::Block con la implementaciónn de MinGW.
  • Haber leído las publicaciones anteriores sobre Game-Hacking
  • Saber programar en C++ o ganas de aprender a programar.

Código

Abrimos el Dev-C++ o el IDE que estén usando para programar y vamos a crear un proyecto nuevo. Una vez que tenemos el proyecto, sólo nos falta comenzar a escribir las líneas de código que darán origen a nuestro programa, el trainer.
Okey! Todo bien hasta acá. Para programar la aplicación que nosotros queremos vamos a hacer uso de las famosas APIs de Windows, es decir, las funciones de las DLLs de Windows.

#include 
#include 

int main()
{
int n = 24;
DWORD pid;
HANDLE process;
HWND wnd = FindWindow(0, "Buscaminas");

GetWindowThreadProcessId(wnd, &pid);
process = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);

WriteProcessMemory(process, (LPVOID)0x0100579C, &n, 8, NULL);

CloseHandle(process);

return 0;
}

Explicación del Código

int n = 24; -> Declara una variable “Integer”, es decir, que contiene un número decimal. Llama a la variable como “n” y coloca el valor “24” dentro de la misma. Ese valor será el que colocaremos, por medio de las APIs, dentro de la dirección de memoria del tiempo del Buscaminas.

DWORD pid; -> Declara una variable característica de Windows. La variable pasa a llamarse “pid” que hace referencia a “Process ID”, es decir, el ID del procesos del Buscaminas que será abierto para guardar en “pid” el ID del proceso.

HANDLE process; -> Otra variable característica de Windows que declara a “process”, que guardará la dirección del proceso del Buscaminas.

HWND wnd; -> Igual que la anterior. Pero guarda la “dirección” de una ventana que es obtenida con “FindWindow()”.

FindWindow() -> Es una API de Windows que permite encontrar ventanas colocando el título de la misma. Ej.: FindWindow(0, “Título de ventana”). Luego esta dirección se pasa a wnd para poder manejarla.

GetWindowThreadProcessId(wnd, &pid); -> API que encuentra el PID de un proceso a través de la búsqueda de una ventana del mismo.

OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid) -> Abre el procesos para escribir y leer sobre él.

WriteProcessMemory(process, (LPVOID)0x0100579c, &n, 8, NULL); -> API más importante para esta implementación. Escribe en la memoria del proceso cambiando un valor. Recuerdan la dirección de memoria que nos salió en Cheat Engine, la dirección de memoria del tiempo del Buscaminas, esa dirección que costo buscarla?. Bueno, en esa dirección de memoria vamos a escribir para cambiar el valor del tiempo. Esa dirección era: 0x0100579c. Y ahí la tenemos, junto a ella está la variable “n”, o sea, el nuevo valor que pasará a tener dicha dirección para cambiar el tiempo. Sencillo.

CloseHandle(process); -> Cerramos proceso.

 

Bueno, después de que tenemos el código, compilamos con Dev-C++ (Ctrl+F9 para compilar el proyecto), ahora tendremos un “.exe”. Bien, ahora abrimos el Buscaminas y ejecutamos el programa que acabamos de crear con este código, gracias al Dev-C++ y su compilador. Y así el valor del tiempo cambiará.

Investiga más sobre esta técnica y sobre el código.

Cheat-Engine: Hackeando videojuegos

Este es el primer tutorial. En este explicaremos como editar un valor en memoria de un juego, en este caso, el buscaminas de Windows. Okey, comencemos! Programas que utilizaremos:
·Cheat Engine que lo pueden descargar desde aquí.
·Buscaminas (winmine.exe) de Windows. Viene por defecto con Windows.

Cheat-Engine

Es una aplicación programada en Delphi, muy útil, que permite la edición de un valor de la memoria de un programa que se está ejecutando. Por ejemplo, estamos jugando Counter-Strike(espero que todos lo conozcan) y nos quedamos sin balas, con esta maravilla podemos editar el valor de una dirección de memoria. Como algunos sabrán, el número de balas que tenemos es un valor, y este valor se guarda en la memoria, concretamente en una dirección de memoria, donde el programa puede acceder a la misma para leer o escribir dicho valor. Con Cheat Engine podemos acceder desde afuera para cambiar el valor de esta dirección de memoria.

Comenzando

Intentaremos congelar el tiempo en el Buscaminas de Windows…
1- Primero exploraremos el buscaminas. Vamos a Inicio>Todos los programas>Juegos>Buscaminas, o sea, ejecutaremos el Buscaminas. Ahora que tenemos el Buscaminas corriendo en nuestra PC podemos ver que al empezar a jugar el tiempo empieza a correr. La pregunta es…Donde se guarda el tiempo que va transcurriendo? La respuesta es…Es un valor, por lo tanto, en una dirección de memoria.
Lo que haremos será acceder a esta dirección con el Cheat Engine y cambiar o congelar el valor!!! No te asustes, es muy sencilo.
2- Instalamos el Cheat Engine. Luego lo ejecutamos y vemos un cartel que habla acerca de un tutorial, hacemos un click en “No”. El programa se ve así:

Ahora sí, a jugar con esos valores!!!! xD. Cerramos el buscaminas y el Cheat Engine que habíamos abierto anteriormente.

Editándonos dentro del juego

Ahora volvemos a ejecutar el Buscaminas, pero no comenzamos a jugar. Ejecutamos el Cheat Engine. Ahora lo que vamos a hacer es abrir el proceso del Buscaminas que ya se está ejecutando, desde el Cheat Engine. Asi que vamos a hacer click en el icono de la computadora que aparece en verde.

Nos aparecera la lista de todos los procesos que se estan ejecutando en nuestra Pc (“Process List”). Bajamos la barra hasta abajo hasta encontrar el proceso winmine.exe ,o sea, es el Buscaminas que se esta corriendo. Y le damos a “Open” (abriremos el procesos dentro del Cheat Engine).

Ahora ya podemos ver en la parte superior del programa que hemos abierto el proceso winmine.exe (Buscaminas) desde el CH (abreviacioón que comenzare a utilizar de ahora en adelante para el Cheat Engine xD). Ahora viene lo mas dificil (no tanto :D), tendremos que buscar la dirección de memoria en donde se almacena el valor del tiempo del Buscaminas para editarlo o congelarlo. Volvemos al Buscaminas que tenemos abierto y vemos que todavia no hemos empezado a jugar, por lo tanto, el valor del tiempo es igual a 0. Entonces donde vemos que dice “Value:” (marcado con rojo en la sgte. imagen) hay un cuadro de texto, ahi escribimos 0, es decir, el valor que tiene el tiempo en el juego actualmente. Y luego le damos a “First Scan” (primer escaneo) y CH buscara en el juego todas las direcciones de memoria que contengan el valor 0 (cero).

Pero..Cual de todas esas direcciones de memoria es la del tiempo??? Bueno..calma, buscar una direccion no es nada facil. Sigamos.
Tenemos demasiadas direcciones. Lo que vamos a hacer es empezar a jugar al Buscaminas, es decir, haremos click en uno de los cuadrados para empezar a buscar minas xD. Listo, ahora el tiempo ha empezado a correr, y obviamente alguna de esas direcciones que tenemos ha empezado a correr al igual que el tiempo en el juego. Lo que ahora haremos sera buscar esa direccion a traves de su valor como lo hicimos anteriormente, entonces, donde dice “Value:” hay un cuadro de texto (donde ingresamos anteriormente el 0), alli vamos a colocar el valor del tiempo actual en el Buscaminas, para esto vamos a ver cuanto lleva el tiempo del juego e ingresaremos un numero mas adelantado para esperar que el tiempo llegue a ese valor y pulsaremos rapidamente “Next Scan” (siguiente escaneo).
Por ej.: El tiempo en el juego va por 25 segundos, lo que haremos en CH es colocar 30 en el casillero y esperaremos a que el tiempo del juego llegue a 30 segundo y cuando lo haga rapidamente presionaremos “Next Scan”.

Lo que hace esto es buscar el valor 30 dentro de todas las direcciones que aparecieron cuando colocamos el 0 para comenzar a escanear. Primero el tiempo estaba detenido, en 0, buscamos ese valor con “First Scan”, nos aparecieron miles de direcciones con ese valor, entre ellas estaba la del tiempo. Luego para despejar las demas empezamos a correr el juego y el tiempo comenzo a correr tambien y colocamos el valor 30 para ser escaneado entre todas esas direcciones que anteriormente nos aparecieron y esperamos que el tiempo en el juego llegue a 30. Le dimos a “Next Scan”, lo que hace esto es buscar un valor entre todas las direcciones de memoria que nos aparecieron antes. Y alli despejamos las demas direcciones y nos quedo solo una, la del tiempo, con su respectivo valor.

Encontramos la dirección de memoria del tiempo con su valor!! Lo logramos, ahora solo nos queda jugar con ella. Es decir, podemos cambiarle su valor o congelarla en el valor actual y no seguira corriendo el tiempo. En el caso del Counter-Strike, podriamos congelar el numero de balas y asi nunca se nos acabarian :D.
Hacemos doble click en la direccion de memoria que contiene el valor del tiempo y abajo nos aparecera la misma. Y si hacemos doble click donde dice “Value” (marcado con amarillo en la imagen anterior) podremos cambiar su valor, el valor de tiempo, poner el tiempo que queramos. O congelar el valor haciendo click en el cuadradito que aparece debajo de “Frozen”….
Como veran es algo muy facil!!!
Perdonen el extenso tutorial, pero quiera que entiendan cada punto, lo que es una direccion de memoria, los valores, étc.
Nota: El Cheat Engine se puede utilizar para una gran (por no decir inmenza) cantidad de juegos, cambiando valores en el juego…Ojo! Algunos valores corresponden a la luminosidad del juegos, la transparencia de las paredes, etc. Podraan hasta crear un cheat para ver a traves de las paredes en el Counter-Strike, o agregarse vida.