// 
// By 85
// elhacker.net
// etalking.com.ar
// 2013
//
 
#include<windows.h>
#include<stdio.h>
 
//
 
char objetivos[] = "ABEGLOST\0";
char reemplazos[]= "48361057\0";
 
//
void ModificadorDeNombresConSTR(char* str){
 
	// Detección de doble whitespace
	if(strstr(str,"  ")!=NULL)
        {
        strcpy(strstr(str,"  "),strstr(str,"  ")+1);
        return;
        }
 
	// Detección de whitespace
	if(strstr(str," ")!=NULL)
       {
        char buf[256];
        strcpy(buf,str);
        strcpy(strstr(buf," ")+1,strstr(str," "));
        strcpy(str,buf);
        return;
       }
 
	// Char inicial y final iguales
       if(str[0]==str[strlen(str)-1])
       {
        char buf[256];
        char sbuf[2]="X";// Al asignarle valor se le agrega el 0 automáticamente.
        sbuf[0]=str[0];
        strcpy(buf,sbuf);
        strcat(buf,str);
        strcpy(str,buf);
        return;
       }
 
	// Reemplazo de ocurrencias (para escritura 1337 XD)
	if(strstr(str,"A")!=NULL)
        {
        *strstr(str,"A")='4';
        return;
        }
 
	if(strstr(str,"B")!=NULL)
       {
        *strstr(str,"B")='5';
        return;
       }
 
	if(strstr(str,"E")!=NULL)
        {
        *strstr(str,"E")='3';
        return;
        }
 
	if(strstr(str,"G")!=NULL)
       {
        *strstr(str,"G")='6';
        return;
       }
 
	if(strstr(str,"L")!=NULL)
        {
        *strstr(str,"L")='1';
        return;
        }
 
	if(strstr(str,"O")!=NULL)
        {
        *strstr(str,"O")='0';
        return;
       }
 
	if(strstr(str,"S")!=NULL)
        {
        *strstr(str,"S")='5';
        return;
       }
 
	if(strstr(str,"T")!=NULL)
        {
        *strstr(str,"T")='7';
        return;
        }
 
	// Char final y prefinal iguales
	if(str[strlen(str)-1]==str[strlen(str)-2])
        {
        str[strlen(str)-1]=0;
        return;
        }
 
	// Reducción de longitud
	if(strlen(str)>16)
        {
        str[strlen(str)-1]=0;
        return;
        }
 
	// Agrega un punto al final
	strcat(str,".");
}
 
//
 
void ModificadorDeNombresSinSTR(char* str){
 
#define current (i-1)
	int len=0;
	for(;*str++;len++);// Obtener largo de cadena
	str-=(len+1);// Arreglar el puntero que se ha desplazado!!!
	{
		int i=0;
		while(str[i++]){
 
			// Detección de doble whitespace
			if((str[current] == ' ' && str[i] == ' ')){
 
				printf("DOBLE ESPACIO\n");
				system("pause");
 
				char buf[256];
				int pos=current;
				while(str[pos++]!='\0'){// Reemplazo de STRCPY+STRSTR ;D
 
					int bufcur = (pos-current)-1;
					int strcur = (pos-1);
					buf[bufcur]=str[strcur+1];
					buf[bufcur+1]=str[strcur+2];
					str[strcur]=buf[bufcur];
					str[strcur+1]=buf[bufcur+1];
				}
				str[pos-1]=0;
				return;
			}}}
 
	{
		int i=0;
		while(str[i++]){
 
			// Detección whitespace
			if(str[current] == ' '){
 
				printf("ESPACIO\n");
				system("pause");
 
				str[len+1]=0;
				int pos=len+1;
				while(pos--){
					if(pos==current) break;
					str[pos]=str[pos-1];
				}
				return;
			}}}
 
 
	{
		int i=0;
		while(str[i++]){
 
			// Char inicial y final iguales
			if(str[0] == str[len-1]){
 
				printf("INICIAL y FINAL IGUALES\n");
				system("pause");
 
				str[len+1]=0;
				int pos=len+1;
				while(pos--){// Reemplazo de STRCPY ;D
					if(pos<1) break;
					str[pos]=str[pos-1];
				}
				return;
			}}}
 
	{
		int i=0;
		while(str[i++]){
 
			// Reemplazo de ocurrencias (para escritura 1337 XD)
			if(str[current] == 'A') {str[current]='4'; return;}
			else if(str[current] == 'B') {str[current]='8'; return;}
			else if(str[current] == 'E') {str[current]='3'; return;}
			else if(str[current] == 'G') {str[current]='6'; return;}
			else if(str[current] == 'L') {str[current]='1'; return;}
			else if(str[current] == 'O') {str[current]='0'; return;}
			else if(str[current] == 'S') {str[current]='5'; return;}
			else if(str[current] == 'T') {str[current]='7'; return;}
		}}
 
 
	// Char final y prefinal iguales
	if(str[len-1] == str[len-2]){
 
		printf("FINAL y PREFINAL IGUALES\n");
		system("pause");
		str[len-1]=0;
		return;
	}
 
	// Reducción de longitud
	if(len>16){
 
		printf("LONGITUD\n");
		system("pause");
 
		str[len-1] =0;
		return;
	}
 
 
	// Agrega un punto al final
	str[len] ='.';
	str[len+1] =0;
}
 
//
int main(){
 
	// Nota: si STRCPY recibe el segundo argumento de mayor size que el primero
	// no importa mientras la cadena sea igual o menor. Y terminada en 0.
	// Aparte de que STRCPY recibe sus argumentos en forma de punteros.
	// http://www.cplusplus.com/reference/cstring/strcpy/
 
	char nombrelargo[256];
 
//	char ingreso[512] = "RRRRRRRRRRRRRRRRX\0";
//	char ingreso[512] = "LEE TL\0";
//	char ingreso[512] = "LEETL \0";
//	char ingreso[512] = "LEET";
//	char ingreso[512] = "azucarada";
//	char ingreso[512] = "azuc arada";
//	char ingreso[512] = "hazuc  aradah";
//	char ingreso[512] = "hazucaradahh";
//	char ingreso[512] = "1azucaradahh";
//	char ingreso[512] = "1  azucaradahh";
//	char ingreso[512] = "1azucaradahhaaaa  ";
	char ingreso[512] = "1azucaradahhaaaa ";
 
 
	strcpy(nombrelargo, ingreso);
//	ModificadorDeNombresConSTR(nombrelargo);
	ModificadorDeNombresSinSTR(ingreso);
	//printf("%s\n", nombrelargo);
	printf("%s\n", ingreso);
	system("pause");
	return (0);
}
 
//
 

push ebp
mov ebp, esp
...

 
int glBegin_saved_ebp;
 
///////////////////////////////////////////////////////////////////////////////////////////////////////////
 
void __stdcall HOOK_glBegin(GLenum mode)
{
	//--------------------------------------
	__asm mov eax, [esp+0xc] // calculado en esta posición
	__asm mov glBegin_saved_ebp, eax // guardamos el ebp anterior
	//--------------------------------------
 
	if(!once){
 
		printf("\n");
		printf("DLL -> HOOK_glBegin: ebp guardado!\n");
		system("pause");
		once=true;
	}
 
	if (mode==GL_POLYGON)
	{
	    glClearColor(1.0, 1.0, 1.0, 1.0);
	    glColor3f(0, 0, 0);
	}
 
	//--------------------------------------
	__asm mov ebp,glBegin_saved_ebp // restauramos el ebp
        __asm add esp,0x10 // limpiamos stack (calculado como 4 * 4 bytes = 0x10)
        __asm jmp pOrig_glBegin // saltamos a la original
	//--------------------------------------
	//(*pOrig_glBegin)(mode);
}
 

#pragma comment (lib, "opengl32.lib")
#pragma comment (lib, "GLUT32/glut32.lib")
#include <windows.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
 
#include "GLUT32/glut.h"
#include <gl\gl.h>
#include <gl\glu.h>
 
#include "texture.h"
 

// Opengl32 es APIENTRY
typedef void(__stdcall* t_glBegin)(GLenum);
typedef void(__stdcall* t_glBlendFunc)(GLenum, GLenum);
typedef void(__stdcall* t_glViewport)(GLint,GLint,GLsizei,GLsizei);
 
// Declaramos unos punteros que van a contener la dirección de las funciones OGL32 que usemos.
t_glBegin pOrig_glBegin = NULL;
t_glBlendFunc pOrig_glBlendFunc = NULL;
t_glViewport pOrig_glViewport = NULL;
 

int main(int argc, char **argv)
{
  SetConsoleTitle("glTest");
 
  int opc=0;
  while( 1){
 
		system("cls");
		printf("Bienvenido!\n");
		printf("1: Interceptar OPENGL32\n");
		printf("2: NO Interceptar OPENGL32\n");
		printf("3: Salir\n");
		scanf("%d",&opc);
 
		if(opc == 1||opc == 2||opc == 3) break;
  }
 
  if(opc==3) ExitProcess(45);
 
  if(opc==1) //Al cargar la DLL, esta instala el hook a GPA para poder interceptar OGL32
  {
	  if(!LoadLibrary("glhack1.dll")){
 
		  MessageBox(0,0,0,0);
		  ExitProcess(0);
	  }
  }
 
  printf("\n");
  printf("EXE: GPA 0x%X\n", GetProcAddress);
  printf("EXE: glBegin 0x%X\n", glBegin);
  if(GetModuleHandle("opengl32.dll"))
  {
	  pOrig_glBegin = (t_glBegin)GetProcAddress(GetModuleHandle("opengl32.dll"), "glBegin");
	  pOrig_glBlendFunc = (t_glBlendFunc)GetProcAddress(GetModuleHandle("opengl32.dll"), "glBlendFunc");
	  pOrig_glViewport = (t_glViewport)GetProcAddress(GetModuleHandle("opengl32.dll"), "glViewport");
	  printf("EXE: glBegin 0x%X\n", pOrig_glBegin);
	  printf("EXE: glBlendFunc 0x%X\n", pOrig_glBlendFunc);
	  printf("EXE: glViewport 0x%X\n", pOrig_glViewport);
  }
  else
  {
	  MessageBox(0,0,0,0);
	  ExitProcess(0);
	  return 0;
  }
 
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
  glutInitWindowSize(450, 450);
  glutCreateWindow("glTest");
  // glutFullScreen();
  init(argv[1]);
  glutDisplayFunc(display);
  glutKeyboardFunc(key);
  glutReshapeFunc(reshape);
  glutIdleFunc(tick);
  glutMainLoop();
  return 0;             /* ANSI C requires main to return int. */
}
 
//
 

void bfunc(void)
{
  static int state;
  if (state ^= 1) 
  {
    pOrig_glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glEnable(GL_BLEND);
  } else {
    glDisable(GL_BLEND);
  }
}
 

void bfunc(void)
{
  static int state;
  if (state ^= 1) 
  {
    pOrig_glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glEnable(GL_BLEND);
  } else {
    glDisable(GL_BLEND);
  }
}
 

void display(void)
{
  glClear(GL_COLOR_BUFFER_BIT);
  glPushMatrix();
  glTranslatef(transx, transy, 0.f);
  glRotatef(rotx, 0., 1., 0.);
  glRotatef(roty, 1., 0., 0.);
  glScalef(scale, scale, 0.);
  pOrig_glBegin(GL_POLYGON);
  glTexCoord2f(0.0, 0.0);
  glVertex2f(-1.0, -1.0);
  glTexCoord2f(1.0, 0.0);
  glVertex2f(1.0, -1.0);
  glTexCoord2f(1.0, 1.0);
  glVertex2f(1.0, 1.0);
  glTexCoord2f(0.0, 1.0);
  glVertex2f(-1.0, 1.0);
  glEnd();
  glPopMatrix();
  glutSwapBuffers();
}
 

void reshape(int w, int h)
{
  pOrig_glViewport(-50, -50, w+120, h+120);
}
 

BOOL HookIAT(char* szModule, char* szFunc, DWORD dwOwn, DWORD& dwOrg)
{
    DWORD dwBase = (DWORD)GetModuleHandle(NULL);
    PIMAGE_DOS_HEADER pDosHdr = (PIMAGE_DOS_HEADER)dwBase;
    PIMAGE_NT_HEADERS pNTHdr = (PIMAGE_NT_HEADERS)(dwBase + pDosHdr->e_lfanew);
    DWORD ImportData = (DWORD)pNTHdr->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress;
    PIMAGE_IMPORT_DESCRIPTOR pImportD = (PIMAGE_IMPORT_DESCRIPTOR)(dwBase + ImportData);
    while(pImportD->Name != 0)
    {
		// CUIDADO! En estas estructuras se encuentran strings no terminadas en 0
		// por lo que STRCMP no sirve.
		// Un cambio fácil puede ser usar STRSTR que encuentra una cadena dentro de otra.
		//	if(!strcmp((char*)(dwBase + pImportD->Name), szModule))
        if(!strstr((char*)(dwBase + pImportD->Name), szModule))
            break;
        pImportD++;
    }
 
	//printf("pImportD->Name: %s\n",(char*)(dwBase + pImportD->Name));
	//system("pause");
    if(pImportD->Name == 0) return FALSE;
	//printf("pImportD->Name: 0x%X\n",pImportD->Name);
	//system("pause");
 
    PIMAGE_THUNK_DATA pThunk = (PIMAGE_THUNK_DATA)(dwBase + pImportD->FirstThunk);
    DWORD OrgFunc = (DWORD)GetProcAddress(GetModuleHandle(szModule), szFunc);
    while(pThunk->u1.Function != 0)
    {
        if(pThunk->u1.Function == (DWORD*)OrgFunc)
        {
            dwOrg = OrgFunc;
            DWORD dwOldProt = 0;
            VirtualProtect((void*)&pThunk->u1.Function, 4, PAGE_EXECUTE_READWRITE, &dwOldProt);
            pThunk->u1.Function = (DWORD*)dwOwn;
            VirtualProtect((void*)&pThunk->u1.Function, 4, dwOldProt, &dwOldProt);
            if(pThunk->u1.Function == (DWORD*)dwOwn)
                return TRUE;
            else
                return FALSE;
        }
        pThunk++;
    }
    return FALSE;
}

 
//
// By 85
// HookIAT (h1web, Thanks to Ashkbiz Danehkar)
// elhacker.net
// etalking.com.ar
// 2013
//
 
///////////////////////////////////////////////////////////////////////////////////////////////////////////
 
#define WIN32_LEAN_AND_MEAN
#include<windows.h>
#include<stdio.h>
#include<stdlib.h>
#include"opengl.h"
 
///////////////////////////////////////////////////////////////////////////////////////////////////////////
 
FARPROC (WINAPI* pGetProcAddress) ( HMODULE hModule, LPCSTR lpProcName );
 
//
FARPROC WINAPI newGetProcAddress(HMODULE hModule, LPCSTR lpProcName)
{
	FARPROC nResult;
	nResult=GetProcAddress(hModule, lpProcName);
	if (HIWORD(lpProcName))
	{
		if (!lstrcmp(lpProcName, "GetProcAddress"))
		{
			return (FARPROC) &newGetProcAddress;
		}
		else
		{
			CheckForOpenGlHook(&nResult, lpProcName);
        }
	}
	return nResult;
}
 
//
BOOL HookIAT(char* szModule, char* szFunc, DWORD dwOwn, DWORD& dwOrg)
{
     // Ya mostrado
}
 
//
bool WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpReserved)
{
	if (fdwReason==DLL_PROCESS_ATTACH) 
	{
		//printf("GetProcAddress 0x%X\n", GetProcAddress);// No refenciar GPA antes!
		if(!HookIAT("kernel32.dll","GetProcAddress",(DWORD)newGetProcAddress,
			(DWORD&)pGetProcAddress)){
 
			MessageBox(0,0,0,0);
			return (false);
		}
 
		printf("\n");
		printf("DLL: newGetProcAddress 0x%X\n", newGetProcAddress);
		printf("DLL: GetProcAddress 0x%X\n", GetProcAddress);
		printf("DLL: pGetProcAddress 0x%X\n", pGetProcAddress);
 
	}
	return (true);
}
 

//
// By 85
// elhacker.net
// etalking.com.ar
// 2013
//
 
///////////////////////////////////////////////////////////////////////////////////////////////////////////
 
#pragma comment(lib, "opengl32.lib")
#include<windows.h>
#include<stdio.h>
#include "opengl.h"
 
///////////////////////////////////////////////////////////////////////////////////////////////////////////
 
// Opengl32 es APIENTRY
typedef void(__stdcall* t_glBegin)(GLenum);
typedef void(__stdcall* t_glBlendFunc)(GLenum, GLenum);
typedef void(__stdcall* t_glViewport)(GLint,GLint,GLsizei,GLsizei);
 
t_glBegin pOrig_glBegin = NULL;
t_glBlendFunc pOrig_glBlendFunc = NULL;
t_glViewport pOrig_glViewport = NULL;
 
bool once=false;
bool oglSubtractive = false;
bool NewDimension = true;
 
int posx = 200;
int posy = 200;
int neww = 50;
int newh = 50;
 
//
void __stdcall HOOK_glBegin(GLenum mode)
{
	if(!once){
		once=true;
	}
 
	if (mode==GL_POLYGON)
	{
	    glClearColor(1.0, 1.0, 1.0, 1.0);
	    glColor3f(0, 0, 0);
	}
 
	(*pOrig_glBegin)(mode);
}
 
void __stdcall HOOK_glBlendFunc(GLenum sfactor, GLenum dfactor)
{
	if(oglSubtractive){
		glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
 
	} else {
		glBlendFunc(sfactor,dfactor);
	}
}
 
void __stdcall HOOK_glViewport( GLint x,GLint y,GLsizei width,GLsizei height )
{
	if(NewDimension){
 
		(*pOrig_glViewport)(posx,posy,neww,newh);
	}
	else
	{
		(*pOrig_glViewport)(x,y,width,height);
	}
}
 
void CheckForOpenGlHook(FARPROC* pProc,LPCTSTR lpProcName)
{
	if (!strcmp(lpProcName,"glBegin"))
	{
		pOrig_glBegin = (t_glBegin)*pProc;
		*pProc = (FARPROC)&HOOK_glBegin;
	}
	else if(!strcmp(lpProcName,"glBlendFunc"))
	{
			pOrig_glBlendFunc = (t_glBlendFunc)*pProc;
			*pProc = (FARPROC)&HOOK_glBlendFunc;
	}
	else if(!strcmp(lpProcName,"glViewport"))
	{
			pOrig_glViewport = (t_glViewport)*pProc;
			*pProc = (FARPROC)&HOOK_glViewport;
	}
}
 

 
//
// By 85
// elhacker.net
// etalking.com.ar
// 2013
//
 
///////////////////
 
#include<windows.h>
#include<stdio.h>
 
//////////////////////
//////////////////////
 
DWORD dwPatchPlace = 0x00000000;
BYTE Opcode_JZ = 0x74;
 
///////////
////////////////////
 
void Target(){
 
	while(1){
 
 
#define MASTERNUM 85
		int master=0x99999997;
		char* ingreso = new char[256];
 
		system("cls");
		printf("Ingrese la llave maestra\n");
		scanf("%s", ingreso);
 
		if(!strcmpi(ingreso, new char[]= "key85\0")){
 
			master = 85;
		}
 
		delete []ingreso;
		if(master==MASTERNUM)
		{
			printf("FELICITACIONES! USTE HA INGRESADO\n");
			printf("\n");
			system("pause");
			break;
		}
 
		//	if(GetAsyncKeyState(VK_END)) break;// En otro hilo
		if(!strcmpi(ingreso, new char[]= "exit\0")) break;
	}
}
 
//
void Check()//Función que representa un método de seguridad
{
	if(*(PBYTE)dwPatchPlace != Opcode_JZ)
	{
		printf("0x%X\n",*(PBYTE)dwPatchPlace);
		printf("Memoria alterada!, se sale del programa..\n");
		printf("\n");
		system("pause");
		ExitProcess(45);
	}
}
 
/////////
 
int main(){
 
	SetConsoleTitle("Dummy");
 
	dwPatchPlace=(DWORD)GetModuleHandle(NULL);//Retorna la BaseAddress
 
	//Sumamos el offset obtenido del desensamblado
	dwPatchPlace+=0x00001000;
	dwPatchPlace+=0x6C;
 
	//Logs
 
	printf("LOG DE SEGURIDAD PRIMARIO:\n");
	printf("0x%X\n",(DWORD)GetModuleHandle(NULL));
	printf("0x%X\n",dwPatchPlace);
	printf("0x%X\n",*(PBYTE)dwPatchPlace);
	printf("\n");
	system("pause");
 
	//Llamamos a la función
	Target();
 
	printf("LOG DE SEGURIDAD SECUNDARIO:\n");
	printf("0x%X\n",(DWORD)GetModuleHandle(NULL));
	printf("0x%X\n",dwPatchPlace);
	printf("0x%X\n",*(PBYTE)dwPatchPlace);
	printf("\n");
	system("pause");
 
	//Se deja que las comprobaciones de seguridad sigan su curso
	Check();
 
	return 0;
}
 

 
//
// By 85
// GetModuleBase (googleada en 5 segundos XD)
// elhacker.net
// etalking.com.ar
// 2013
//
 
///////////////////
 
#include<windows.h>
#include<stdio.h>
#include<tlhelp32.h>
 
//////////////////////
 
HANDLE hProcess;   
HANDLE hModule;
DWORD dwPatchPlace = 0x00000000;
BYTE Opcode_JZ = 0x74;
BYTE Opcode_JNZ = 0x75;
BYTE pReaden;
 
///////////
 
VOID Patch() {
 
//	printf("0x%X\n",pReaden);
//	system("pause");
 
	if(!hProcess) return;
	if(pReaden!=Opcode_JZ) return;
 
	DWORD dwOldProtect;
    VirtualProtect( (LPVOID)dwPatchPlace, 
                    1, 
                    PAGE_EXECUTE_WRITECOPY, 
                    &dwOldProtect ); 
 
    WriteProcessMemory( hProcess, 
                        (LPVOID)dwPatchPlace, 
                        &Opcode_JNZ, 
                        1, 
                        NULL );
 
    VirtualProtect( (LPVOID)dwPatchPlace, 
                    1, 
                    dwOldProtect, 
                    &dwOldProtect ); 
} 
 
//
////////////////////
 
DWORD GetModuleBase(LPSTR lpModuleName, DWORD dwProcessId) 
{ 
   MODULEENTRY32 lpModuleEntry = {0}; 
   HANDLE hSnapShot = CreateToolhelp32Snapshot( TH32CS_SNAPMODULE, dwProcessId ); 
 
   if(!hSnapShot) 
      return NULL; 
   lpModuleEntry.dwSize = sizeof(lpModuleEntry); 
   BOOL bModule = Module32First( hSnapShot, &lpModuleEntry ); 
   while(bModule) 
   {
	   //printf("%s\n",lpModuleEntry.szModule);
      if(!strcmp( lpModuleEntry.szModule, lpModuleName ) ) 
      { 
         CloseHandle( hSnapShot ); 
         return (DWORD)lpModuleEntry.modBaseAddr; 
      } 
      bModule = Module32Next( hSnapShot, &lpModuleEntry ); 
   } 
   CloseHandle( hSnapShot ); 
   return NULL; 
} 
 
int main(){
 
	// We have to replace JZ with JNZ.
 
	//TODO: Obtener privilegios
	//
 
	char l_exe[] = {'d','u','m','m','y','.','e','x','e',0};
	char l_window[] = {'D','u','m','m','y',0};
	HWND hwnd;          
	hwnd = FindWindow(0, l_window);     
	if (!hwnd)     
	{         
		printf("Abre %s ahora.\n", l_exe);         
		while (1)       
		{            
			Sleep(1000);             
			hwnd = FindWindow(0, l_window);             
			if (hwnd) break; 
			if (GetAsyncKeyState(VK_END)>0) ExitProcess(45);
		}             
	}
 
	unsigned long pid;     
	GetWindowThreadProcessId( hwnd, &pid);     
//	hProcess=OpenProcess(PROCESS_VM_OPERATION|PROCESS_VM_READ|PROCESS_QUERY_INFORMATION,0,pid);
//	hProcess=OpenProcess(PROCESS_VM_WRITE|PROCESS_VM_OPERATION,0,pid);
	hProcess=OpenProcess(PROCESS_ALL_ACCESS,0,pid);
 
	HANDLE baseAddress = (HANDLE)GetModuleBase(l_exe, pid);
	if(!baseAddress)
	{
		printf("No se obtubo la baseAddress!\n");
		system("pause");
		ExitProcess(45);
	}
 
	//Lugar del parche
	dwPatchPlace=(DWORD)baseAddress;
	dwPatchPlace+=0x00001000;
	dwPatchPlace+=0x6C;
 
	//Logs
	printf("hProcess: 0x%X\n",hProcess);
	printf("pid: %d\n",pid);
	printf("dwPatchPlace: 0x%X\n",dwPatchPlace);
//	printf("0x%X\n",*(PBYTE)dwPatchPlace);//No se puede hacer esto para otro proceso
	if(ReadProcessMemory(hProcess,(void*)(dwPatchPlace),&pReaden,sizeof(pReaden),0))
	{
		printf("Lugar antes de parchear: 0x%X\n",pReaden);
	}
	else
		printf("ReadProcessMemory failed: %d\n",GetLastError());
 
	system("pause");
 
	//Se procede a parchear el proceso objetivo
	Patch();
 
	if(ReadProcessMemory(hProcess,(void*)(dwPatchPlace),&pReaden,sizeof(pReaden),0))
	{
		printf("Lugar luego de parchear: 0x%X\n",pReaden);
	}
	else
		printf("ReadProcessMemory failed: %d\n",GetLastError());
 
 
	CloseHandle(hProcess);
	system("pause");
	return 0;
}
 
//
 

printf("0x%X\n",*(PBYTE)dwPatchPlace);//No se puede hacer esto para otro proceso