///////////////////////////////////////////////////////////
///        Hacer un proceso inmortal by E0N             ///
///                                                     ///
///   Estes el ejecutable que haremos incerrable        ///
///                                                     ///
///   by E0N - 2007
///////////////////////////////////////////////////////////


#include "stdafx.h"
#include <windows.h>
#include <Tlhelp32.h>


// FUNCIONES
void CrearMutex     ();             // Crea el mutex
DWORD WINAPI Vigilar(void* nada);   // Vigila que el otro proceso esté activo
void Inyectar       ();             // Inyecta la dll
int  Pid            ();             // Función que nos devuelve el pid de un proceso


// LA FUNCIÓN MAIN
int APIENTRY WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR     lpCmdLine,int       nCmdShow)
{
  // Creamos nuestro mutex de nombre ExeMutex
CrearMutex();

// Creamos un hilo que se encargará de vigilar si la dll está inyectada
DWORD ID;
HANDLE hilo = CreateThread(0,0,Vigilar,0,0, &ID);

MessageBox (0, "Acepta para cerrarme", "", 0);

///////////////////////////////////////////
// Aqui ya podríais poner vuestro código //
///////////////////////////////////////////
return 0;
}



// LA FUNCIÓN QUE CREA EL MUTEX
void CrearMutex()
{
// Creamos un mutex de nombre ExeMutex. Si nos devuelve NULL significa
// que la función a fallado, así que seguimos intentándolo.
HANDLE mutex;
do
{
mutex = CreateMutex(NULL, 0, "ExeMutex");
} while (mutex == NULL);
}



// LA FUNCIÓN QUE VIGILA QUE LA DLL ESTÉ INYRECTADA
DWORD WINAPI Vigilar(void* nada)
{
HANDLE proc;   // El handle que obtenemos con OpenProcess
HANDLE mutex;  // Manejador para saber si el mutex existe o no

// Entramos en un bucle eterno
while (1<2)
{
mutex = OpenMutex(SYNCHRONIZE, false, "DllMutex");

if (mutex == NULL) // Si el mutex no existe quiere decir que el proceso a sido matado asi que...
{

// Abrimos en modo oculto el notepad para inyectar la dll
WinExec ("notepad.exe", SW_HIDE);
Sleep(2000);

// Inyectamos la dll
Inyectar();
}
else
{
int pid = Pid();

if (pid != 0)
{
// Abrimos el proceso para obtener su handle
proc = OpenProcess(PROCESS_ALL_ACCESS, false, pid);

// Esperamos a que cierren el proceso para volver a ejecutarlo
WaitForSingleObject(proc, INFINITE);
CloseHandle(proc);
}
}

CloseHandle (mutex);

}
}



// LA FUNCIÓN INYECTORA
void Inyectar()
{
int pid = Pid();
HANDLE proceso;
LPVOID RemoteString;
LPVOID nLoadLibrary;

proceso = OpenProcess(PROCESS_ALL_ACCESS, false, pid);
nLoadLibrary = (LPVOID)GetProcAddress(GetModuleHandle("kernel32.dll"),"LoadLibraryA");
RemoteString = (LPVOID)VirtualAllocEx(proceso,NULL,strlen("H:\\Dll.dll"),MEM_COMMIT|MEM_RESERVE,PAGE_READWRITE);
WriteProcessMemory(proceso,(LPVOID)RemoteString,"H:\\Dll.dll",strlen("H:\\Dll.dll"),NULL);
CreateRemoteThread(proceso,NULL,NULL,(LPTHREAD_START_ROUTINE)nLoadLibrary,(LPVOID)RemoteString,NULL,NULL);
CloseHandle(proceso);
}



// LA FUNCIÓN QUE NOS DEVUELVE EL PID DE UN PROCESO
int Pid()
{
// Obtenemos el PID del notepad
int pid;
HANDLE handle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
PROCESSENTRY32 procinfo = { sizeof(PROCESSENTRY32) };
while(Process32Next(handle, &procinfo))
{
if(!strcmp(procinfo.szExeFile, "notepad.exe"))
{
CloseHandle(handle);
pid = procinfo.th32ProcessID;
}
}
CloseHandle(handle);

return pid;
}

///////////////////////////////////////////////////////////
///        Hacer un proceso inmortal by E0N             ///
///                                                     ///
///   Esta es la dll que inyectaremos en el notepad     ///
///                                                     ///
///   by E0N - 2007
///////////////////////////////////////////////////////////                      



#include "stdafx.h"
#include <windows.h>
#include <Tlhelp32.h>


// FUNCIONES
void CrearMutex(); // Crea el mutex
void Vigilar   (); // Vigila que el otro proceso esté activo



// LA FUNCIÓN DLLMAIN
BOOL APIENTRY DllMain( HANDLE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved)
{
// Si nos cargan
if (ul_reason_for_call == DLL_PROCESS_ATTACH)
{
//Creamos nuestro mutex de nombre DllMutex
CrearMutex();

// Vigilamos que el otro proceso esté corriendo
Vigilar();
}

    return TRUE;
}



// LA FUNCIÓN QUE CREA EL MUTEX
void CrearMutex()
{
// Creamos un mutex de nombre DllMutex. Si nos devuelve NULL significa
// que la función a fallado, así que seguimos intentándolo.
HANDLE mutex;
do
{
mutex = CreateMutex(NULL, 0, "DllMutex");
} while (mutex == NULL);
}



// LA FUNCIÓN QUE VIGILA QUE EL OTRO PROCESO ESTÉ CORRIENDO
void Vigilar ()
{
int pid;       // El PID del proceso ejecutado
HANDLE handle; // El handle del proceso (usado para obtener el pid)
HANDLE proc;   // El handle que obtenemos con OpenProcess
HANDLE mutex;  // Manejador para saber si el mutex existe o no

// Entramos en un bucle eterno
while (1<2)
{

mutex = OpenMutex(SYNCHRONIZE, false, "ExeMutex");


if (mutex == NULL) // Si el mutex no existe quiere decir que el proceso a sido matado asi que...
{
// Ejecutamos el archivo
WinExec("H:\\Ejecutable.exe",SW_SHOW);
}
else
{
// Obtenemos el PID del proceso
handle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
PROCESSENTRY32 procinfo = { sizeof(PROCESSENTRY32) };
while(Process32Next(handle, &procinfo))
{
if(!strcmp(procinfo.szExeFile, "Ejecutable.exe"))
{
CloseHandle(handle);
pid = procinfo.th32ProcessID;
}
}
CloseHandle(handle);

if (pid != 0)
{
// Abrimos el proceso para obtener su handle
proc = OpenProcess(PROCESS_ALL_ACCESS, false, pid);

// Esperamos a que cierren el proceso para volver a ejecutarlo
WaitForSingleObject(proc, INFINITE);
CloseHandle(proc);
}
}

CloseHandle (mutex);

}
}

///////////////////////////////////////////
// Aqui ya podríais poner vuestro código //
///////////////////////////////////////////