Archivo

Archive for the ‘Hacking y Cracking’ Category

Videotutoriales sobre Packet Injection (inyección de paquetes)

Vagando por el mundo HTTP llegué a un sitio donde se encuentran una serie de videotutoriales muy interesantes sobre Packet Injection. Explican desde el concepto, pasando por la estructura de los paquetes, hasta cómo armar nuestro propio inyector.

Muy interantes, aunque lamentablemente están en inglés.

La URL del sitio: www.security-freak.net/packet-injection/packet-injection.html.

Además en la sección videos de esa web pueden encontrar videos sobre seguridad informática bastantes interesantes.

Introducción a shellcodes en Linux

Aquí les traigo un videotutorial muy interesante sobre programación de shellcodes sobre Linux. Da una introducción muy buena para explicar los conceptos que abrcan este campo.

Mu Online: protocolo. Algoritmo de encriptación.

Como vimos en el artículo anterior, los videojuegos online que constan de un cliente y un servidor se comunican mediante un protocolo.

Dependiendo de la importancia del juego y el nivel de este, resulta más o menos difícil aplicarle ingeniería inversa para conocer su funcionamiento y descubrir cómo se comunica el cliente con el servidor.

En este caso voy a hablar de Mu Online.

Este MMORPG (Massive Multiplayer Online Role Playing Game) posee muchas versiones oficiales  y no oficiales.

Este juego es tan famoso debido a la gran cantidad de servidores que hay. Estos servidores no son oficiales. O sea, este juego no es de código ni licencia abierta, pero su servidor fue robado (gracias a algún gran hacker) y fue sometido a ingeniería inversa para conocer su funcionamiento, y a lo largo de los años las diferentes versiones del servidor han ido evolucionando, al igual que el cliente. Es por esto que hay tantos servidores de diferentes versiones de MuOnline.

Nuestra meta es conocer cómo el cliente se conecta al servidor, y el principal problema es que no podemos simplemente sniffear la conexión ya que veríamos los paquetes que el cliente envía al servidor, pero no entenderíamos nada ya que estos paquetes se envían encriptados.

La criptografía (“escritura oculta”) es la técnica, bien sea aplicada al arte o la ciencia, que altera las representaciones lingüísticas de un mensaje.

En esencia la criptografía trata de enmascarar las representaciones caligráficas de una lengua, de forma discreta.

Y esta encriptación se produce gracias a un algoritmo de encriptación que posee el cliente. Por este algoritmo pasan los datos antes de ser enviados para ser encriptados de tal forma que no sean legibles para la visión humana.

Luego, al llegar al servidor, los datos son desencriptados por el mismo para que los pueda entender, pero eso es una historia aparte.

Mu Online: protocolo y algoritmo de encriptación

Un hacker llamado MiKiOnE encontró el algoritmo que encripta los mensajes dentro del cliente, luego de debuggearlo.

Algoritmo de encriptación

//code
unsigned char T1; //temp
unsigned char package[]; //uncrypt
unsigned char crypt[]; //crypt
unsigned char key[]={
        0xe7,0x6D,0x3a,0x89,
        0xbc,0xb2,0x9f,0x73,
        0x23,0xa8,0xfe,0xb6,
        0x49,0x5d,0x39,0x5d,
        0x8a,0xcb,0x63,0x8d,
        0xea,0x7d,0x2b,0x5f,
        0xc3,0xb1,0xe9,0x83,
        0x29,0x51,0xe8,0x56};
int a;
for(int b=0;b<=2;b++) {
  crypt[b]=package[b]; // copy first 3 bits
}
int a=4;
int size; // size of package
for(int i=0;i<=size;i++,a++) {
  if (a == 32)a=0;
  T1=crypt[i+2]^key[a];
  package[i+3]=crypt[i+3]^T1;
}

//end code

Esto nos facilitará entender los paquetes que el cliente envía al servidor, para modificarlos o para crear un cliente falso que imite hacer alguna tarea, como levelear un personaje o sumar puntos, étc.

En el próximo artículo explicaré cómo hacer para utilizar esto para aprovecharnos del servidor del Mu Online.

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

Manual de Cheat-Engine: hackeando el Pinball

Qué es Cheat Engine?

Cheat Engine es una herramienta de código abierto diseñado para ayudar con en la modificación de los juegos que se ejecutan sobre Windows, también contiene otras herramientas útiles para ayudar a la depuración de los juegos e incluso las aplicaciones normales.

Viene con un escáner de memoria para explorar rápidamente las variables utilizadas en un juego y permitir cambiarlas, también viene con un depurador, desensamblador, ensamblador, Speedhack, máquina de entrenamiento, herramientas de manipulación directa en 3D, herramientas de inspeccion del sistema.

Es decir, el Cheat Engine es un desensamblador en “tiempo real”. Permite acceder a la memoria ocupada por CUALQUIER proceso y modificarla, no solo la de los juegos.
En este paper nos centraremo en la funcion de : Escanear la memoria RAM reservada por un juego y modificarla posteriormente

Muchos de las trampas que encuentras para juegos tan complejos como World Of Warcraft, Dragon Age I y II son hechas con el CheatEngine.

Instalación

Obviamente nos bajamos (6.2 MB) el Cheat Engine desde aqui: http://cheatengine.org/download/CheatEngine61.exe

Pero no solo podemos bajarlo, tenemos la opcion de bajar el codigo fuente por si acaso alguien quiere hacerle unos arreglitos.

Hay que saber que CE no es un virus, ni un spyware, ni nada por el estilo pero al ser un hacking tool los antivirus pueden jodernos la instalacion, por lo que yo recomiendo que desactiven sus antivirus antes de proceder a la instalacion.

No explicare paso a paso la instalacion porque ufffff todos los usuarios de guindows saben eso (doble click, acepto, instalacion tipica, siguiente, siguiente, instalar, etc…) Despues de instalado nos saltara un muy buen manual de como usarlo pero esta en ingles.

Usando Cheat Engine

Aqui viene la parte interesante del asunto, despues de instalado damos un doble click sobre el icono de nuestro escritorio,  icono que seria muy parecido a este:

Lo cual nos abrira una interfaz grafica con todas las opciones que podremos usar de este maravilloso programa, como dije anteriormente solo me enfocare en el escaneo de memoria para modificar una variable prederminada. Explico a continuacion para que sirve cada boton:

Debido a que estoy haciendo este paper desde mi portatil que solo tiene ubuntu se habran dado cuenta que tengo XP corriendo desde una maquina virtual y es desde hare todo, por tanto esta vez tomaremos como juego de muestra el famoso Pinball de guindows y lo modificaremos para tener una puntuacion altamente ridicula.

Primero abrimos el CE (Abreviaturas de Cheat Engine, para no escribirlo siempre ufff)… dando doble click sobre el icono del escritorio.

Posteriormente buscamos y abrimos normalmente nuestro pinball de guindows, OJO aun no debemos jugar. Una vez tenemos ambos abiertos damos click en el selector de procesos (el que esta señalado con una flechita roja) y seleccionamos el proceso del pinball, se veria algo como esto:

Una vez seleccionado el proceso la pantalla nos quedaria asi:

A continuacion modificaremos el valor de los puntos (Score), pero como saber cual variable modificar?  Como nos damos cuenta cual es? Sencillo, como aun no hemos jugado nada nuestro puntaje esta en cero por lo que en la casilla de escanear escribiremos el numero cero 0, y activamos el filtro de buscar valor exacto, para finalmente dar a “first scan”, tendriamos algo como esto:

Ustedes diran ufff… 442,342 resultados para este valor en la memoria asignada al proceso pinball.exe, chanfleee… Pues nunca dije que fuera facil asi que paciensia chicos. Ahora jugamos un poco para conseguir algunos puntos..

Bueno mas que conseguir algunos puntos me quede un rato jugandolo.. jejej (es entretenido la verdad…) Ahora que tenemos un nuevo Score buscamos ese valor en CE y tendremos una pantalla como esta:

Ya con un nuevo valor buscamos la direccion de memoria y solo nos saldra una..

La cual modificaremos dandole un doble click a la direccion que nos aparecera y posteriormente un click derecho, asi:

Aquí modificamos el valor…

y listo…  pinball se actualizara tras un rato de que sigamos jugando(no seguí poniendo imágenes porque me llego la hora de irme a trabajar).

P.D Recuerden pausar el juego mientras modificamos la variable en la memoria asignada, recuerden que debemos ser usuarios Administradores para modificar segmentos de memoria.

Saludos.

 

Fuente: foro.elhacker.net. Por CloudswX

Debuggers, Decompiladores y Desensambladores

Conceptos

Para entender los conceptos de las principales herramientas usadas para realizar ingeniería inversa sobre diferentes aplicaciones, será mejor que lean en Wikipedia la información que hay sobre estas:

Aplicaciones

Aquí les dejo las herramientas más reconocidas para realizar ingeniería inversa (Cracking en inglés):

OllyDbg: es un depurador de código ensamblador de 32 bits para sistemas operativos Microsoft Windows. Pone especial énfasis en el análisis del código binario, esto lo hace muy útil cuando no está dispone el código fuente del programa.1 Traza registros, reconoce procedimientos, llamadas a las API, swiches, tablas, constantes y strings, así como localiza rutinas de archivos objeto y de bibliotecas. DESCARGA | TUTORIAL

IDA Pro: En informática, Interactive Disassembler (Desensamblador Interactivo), más conocido por su acrónimo IDA, es un desensamblador empleado para ingeniería inversa. Soporta una variedad de formatos ejecutables para diferentes procesadores y sistemas operativos. También puede ser usado como un depurador para executables Windows PE, Mac OS X, Mach-O y Linux ELF. Un plugin de decompilador para programas compilados con C/C++ está disponible a un costo extra. Además, para IDA existen gran cantidad de plugins que facilitan el uso de este desensamblador. DESCARGA

Java Decompiler: Existen diversos decompiladores para aplicaciones programadas en Java que nos permiten extraer el código fuente de las clases (class) de la aplicación. LISTA de decompiladores para Java.

Flash Decompiler: Free Flash Decompiler Gold es un potente y fiable extractor de flash. Que permite exportar todos los recursos tales como imágenes, formas, sonidos, fuentes, textos dinámicos, botones, sprites, scripts y marcos desde cualquier archivo SWF. DESCARGA

GNU Debugger: GDB o GNU Debugger es el depurador estándar para el sistema operativo GNU/Linux. Es un depurador portable que se puede utilizar en varias plataformas Unix y funciona para varios lenguajes de programación como C, C++ y Fortran. Viene en la mayoría de las distribuciones Linux instalado por defecto.

Cheat-Engine: Ya hemos hablado sobre este programa en la sección de Game-Hacking. Cheat Engine es un escáner de memoria, editor hexadecimal y depurador de software creado por Dark Byte y M.A.B.L para el sistema operativo Windows. Cheat Engine se utiliza para hacer trampas (cheat) en los videojuegos. DESCARGA | MINITUTORIAL.

W32Dasm: El W32Dasm es un decompilador de ejecutables de Windows, que nos permite traducir estos ejecutables a código ensamblador para entenderlo mejor. DESCARGA.

Resource Hacker: Resource Hacker (también conocido como ResHacker o ResHack) es una utilidad de extracción de recursos desarrollada por Angus Johnson para Windows. Se utiliza para modificar programas o elementos del sistema operativo, como los iconos de recursos de programas ejecutable (. Exe), programas de extensión (. Dll), y de archivos de recursos (. Res). DESCARGA

 

Bueno, con esto tienen para empezar de a poco. Para aprender mejor las técnicas del cracking les recomiendo que busquen en Internet los llamados “crackmes” que son aplicaciones programadas especialmente para ser crackeadas y así mejorar nuestros conocimientos sobre ingeniería inversa.

Si falta alguna herramienta importante o quieren que agregue otras diganme. Hasta ahora estas son las que he utilizado.

Programando un Trainer para el BlackJack (Linux)

Un trainer es una aplicación que modifica un valor en la memoria de un videojuegos, como ya expliqué anteriormente.

En el post anterior vimos un código que utilizaba las APIs de Windows para modificar el tiempo en el buscaminas de Windows, ahora veremos un código que utiliza APIs de Linux para modificar un juego perteneciente a este S.O.: el BlackJack (viene por defecto con Ubuntu).

Para esto utilizaremos ptrace, que es una función que nos proveen las librerías de Linux para programar en C, y que permite “debuggear” o “tracear” cualquier aplicación. Permite tomar el control de un proceso para modificarlo, ver sus resultados y su funcionamiento. En este caso lo utilizamos para “tomar el control de un proceso” y luego escribir en una dirección de memoria un valor, o cambiar un valor ya declarado.

ptrace is a system call found in several Unix and Unix-like operating systems. By using ptrace (the name is an abbreviation of “process trace”) one process can control another, enabling the controller to inspect and manipulate the internal state of its target. ptrace is used bydebuggers and other code-analysis tools, mostly as aids to software development. [Wikipedia]

Sinopsis

#include 

long ptrace(enum __ptrace_request request, pid_t pid, void *addr, void *data);

El código

#include 
#include 
#include 

int main()
{
ptrace(PTRACE_ATTACH, 3895, NULL, NULL);
wait(NULL);
ptrace(PTRACE_POKEDATA, 3895, 0x8070bd4, 1111111111);
ptrace(PTRACE_DETACH, 3895, NULL, NULL);

return 0;
}

Explicación

PTRACE_ATTACH: con esto nos “atachamos” al proceso, es decir, tomamos su control..cabe destacar que el proceso al que nos atachamos ya está en ejecución. Es como si abriera el proceso para modificarlo.

3895: es el PID (Process ID), es decir, un identificador que identifica a cada proceso, es único y diferente para cada proceso. Para poder ver los PIDs de todos los procesos en ejecución ejecutamos “ps aux” (sin las comillas) en una terminal y nos saldrá una lista con todos los procesos que se están ejecutando en nuestro sistema y en la segunda columna llamada “PID” nos sale el PID de cada proceso..cabe destacar que los PIDs son números. Este PID es el que colocamos aquí.

PTRACE_POKEDATA: esto nos permite introducir valores en la memoria del proceso al que nos atachamos anteriormente.

0x8070bd4: esta es la dirección de memoria en donde modificaremos y almacenaremos el valor que especificaremos a continuación. Esta dirección se puede obtener mediante scanmem que es un editor de memoria como Cheat-Engine, pero para Linux.

1111111111: este es el nuevo valor que se introducirá en la dirección de memoria que especificamos anteriormente. Lo pueden cambiar por los nuevos valores que quiera…cabe destacar que es un valor long en este caso, así que intenten probando este número por si el valor que quieren cambiar no cambia…

PTRACE_DETACH: dejamos seguir corriendo al proceso normalmente ya que hicimos las modificaciones que quisimos en el mismo.

 

Este código lo que hace es modificar al “Balance” en el Blackjack (juego que viene por defecto con Ubuntu). Acuerdensen que tienen que introducir el PID correcto del proceso para abrirlo y modificarlo, el PID una vez que finalizan y vuelven a abrir el proceso cambia, así que estén atentos.