Revisión 1.3 del tutorial "Como empezar con Delphi, Orientado a Troyanos" de Sr_Sombrero.
Si vas a copiar este tutorial en todo o en parte no olvides mencionar al autor y a [Tienes que estar registrado y conectado para ver este vínculo]

Hola! Esta guía es para los que quieren aprender a programar y como me ocurrió a mi no saben por donde empezar. Voy a explicarles brevemente lo básico para no aburrirlos y luego pasar a explicarles como programar unos sencillos troyanos.

¿Que es Delphi?
Es un lenguaje de programación visual basado en Pascal. Ofrece buen balance entre sencillez y potencia y es ideal para iniciarse en programación ya que está bien estructurado. Debido a que es multipropósito se usa para programar casi cualquier tipo de aplicaciones. Entre las aplicaciones más populares programadas en Delphi está Skype.

Entre los Troyanos programados en Delphi encontramos:
Poison Ivy
Institution 2004
Beast
Sub7
NetBus
Optix Pro
Assasin 2
TequilaBandita
Bandook
Nuclear Rat
Coolvibes

Con esta lista (inconclusa) queda demostrado que es un lenguaje idóneo para nuestro propósito. Además se pueden hacer Binders y cualquier otro programa.

Para más información ver la wikipedia [Tienes que estar registrado y conectado para ver este vínculo]

¿Con que versión empezar?
No es necesario tener la última versión. Te recomiendo que como mínimo instales la versión 6 (que es la que usaba al tiempo de escribir este tutorial). Otras versiones más nuevas que han tenido mucha aceptación fueron la 7 y la 2007.

Cuanto más nueva sea la versión consumirá más recursos así que para la elección tienes que tener en cuenta la PC con la que cuentas, pero para que te quedes tranquilo te cuento que la versión 7 para abajo funciona en cualquier computadora de este milenio :-D y que los programas hechos en una versión vieja pueden compilarse en las más nuevas y en la mayoría de los casos en las anteriores con pocos o ningún cambio.

Las distintas versiones se pueden bajar para probarlas de redes P2P, rapidshareware o versiones reducidas gratuitas en la página de Borland o CodeGear.

Para los ansiosos que han querido compilar algo

Probablemente en el primer contacto que han tenido con Delphi hayan querido compilar alguna fuente que encontraron por la red. Si les compiló, bien por ustedes, pero si les dio error no se desilusionen. Les voy a explicar la causa más común de que alguna fuente bajada no les compile.

Observen que en la pantalla de Delphi hay una zona con etiquetas que dicen "Standard", "additional", etc. y abajo tiene dibujitos de botones, menúes, etc. Es la "Paleta de Componentes".
A veces pasa que nos faltan componentes y por eso da error al abrir o compilar fuentes de otros.
Esta paleta (o barra) es personalizable y cada versión de Delphi trae ligeras diferencias en los componentes incluidos y también se pueden instalar componentes hechos por terceros.
Que un componente no esté en la barra no quiere decir que no lo tengamos porque si venía en una versión anterior suele estar en la carpeta de Delphi y lo tenemo que instalar nosotros.

Esta explicación fue para los que no han podido compilar algo no tiren todo pensando que es muy difícil.
El tema de instalar componentes hay que verlo más adelante, ahora vamos a seguir desde el principio, porque es la forma más rápida de aprender.

El Primer Manual

Antes que nada una recomendación: "Impriman los manuales" encuadernenlos o enganchelos en una carpeta para poder subrayarlos y hacer apuntes. En papel se lee mucho más rápido que en la pantalla y se fija más. No quiero decir que haga falta imprimir cualquier boludés, pero si los manuales básicos.

Para dar los primeros pasos hay un manual muy ameno en español y con ejercicios prácticos desde el principio, aunque es algo viejito, igual sirve. Les recomiendo que lo lean hasta el Capítulo "Bases de Datos 1" ya que el tema no nos interesa para nuestro propósito.

Lo pueden bajar desde acá Curso Delphi - Por Jorge
[Tienes que estar registrado y conectado para ver este vínculo] ... delphi.htm

-------------------------------------------------------------------------------------------

Un poco de Pascal

Si siguieron los pasos del manual que les recomendé ya tendrán una idea bastante práctica de Delphi. Habrán creado sus primeras aplicaciones, pero les deben quedar varias cosas en el aire.
Es hora de ver algo de teoría para entender mejor lo que hicimos. Dijimos que Delphi está basado en Pascal, así que tenemos que ver lo básico de este lenguaje.

Curso de pascal (por Comac)
[Tienes que estar registrado y conectado para ver este vínculo]

Este manual resulta útil aun desde la perspectiva de alguien que no sabe nada de programación. Explica todo lo necesario para empezar a programar en Pascal.
Está en español y el único inconveniente es que es de la época del "Turbo Pascal", sin embargo la mayor parte le es aplicable a Delphi.
Les recomiendo leerlo hasta el capítulo 6 (incluido), y no olviden que si lo imprimen es mejor.

Otro Manual Alternativo
Essential Pascal (Marcos Cantú)

Es una introducción a Pascal orientada a Delphi. Fue escrito por el autor más conocido de Delphi. Como en sus libros no trata los aspectos más básicos, pone a disposición (en forma gratuita) este PDF en su web. Enlace a la versión 1 en español [Tienes que estar registrado y conectado para ver este vínculo]

También pueden ver del mismo autor [Tienes que estar registrado y conectado para ver este vínculo] (inglés).

-------------------------------------------------------------------------------------------

Formas de programar un Troyano en Delphi

A la hora de hacer un troyano o aplicación similar en Delphi básicamente podemos seguir 2 caminos:

1) Crear un form en el cual ponemos los componentes que trae Delphi.
Ventaja: Sencillez.
Desventaja: Utilizar un form repercute en el tamaño del server (aproximadamente 220 Kb comprimido con UPX).

2) Crear un Aplicacion de tipo consola (console aplication) y utilizar units livianas o directamente llamadas a la API de Windows.
Ventaja: Si no usamos units que engorden el proyecto podremos obtener aplicaciones mucho más pequeñas (de unos 30 Kb).
Desventaja: Mayor complejidad.

En un troyano de última generación, lo usual sería hacer el cliente con el primer método y el server con el segundo.
Como somos novatos tendremos que usar el primer método tanto para el cliente como para el servidor. Bueno... no se desilusionen, los servers de Optix, Sub7 y Theft están hechos con este método y nadie va a decir que sean malos. El único problema, como ya dije, es el tamaño pero dada la velocidad de las conexiones de hoy ya no es tan importante.

Aplicaciones cliente servidor usando componentes

Delphi trae distintos componentes para este fin, se destacan:
1) TServerSocket/TClientSocket los más usados para troyanos, simples y efectivos.
2) Los Componentes INDY más completos y de mayor tamaño. No he visto ningún troyano programado usando estos componentes aunque si vi que se usan mucho para otro tipo de aplicaciones cliente/servidor.

Entonces vamos a usar los TServerSocket/TClientSocket
(están en la "sección Internet" de la "Paleta de Componentes" en la IDE de Delphi, si no están hay que instalarlos).

Acá tienen las fuentes sobre las que vamos a trabajar. Para poder compilarlas deben pegar el código de cada archivo en el bloc de notas y guardarlo con el nombre correspondiente. Luego meten todo los archivos en la misma carpeta y ya lo pueden abrir con Delphi.

Ejemplo 1
[Tienes que estar registrado y conectado para ver este vínculo]

Ejemplo 2
[Tienes que estar registrado y conectado para ver este vínculo]

Estos ejemplos simples son más útiles que ver las fuentes completas de un troyano ya que podemos ver lo esencial sin enredarnos en una maraña de código. Ahora los voy a explicar un poco:

Cuando trabajamos con sockets hay 2 aproximaciones posibles:
1) Leer datos del socket o escribir en él de forma asincrónica, así no se bloquea la ejecución de otro código en la aplicación mientras esto sucede. Esto es llamado "nonblocking connections".
2) La otra alternativa es usar "blocking connections" donde la aplicación espera que la lectura o escritura se complete antes de ejecutar la siguiente línea de código. Con "blocking connections" es necesario usar threads, lo que es más complicado, así que vamos a hacerlo de la primer forma (más común en troyanos).
Esto se elige en la propiedad "Server Type" de los componentes ClientSocket y ServerSocket.

Pasemos a los ejemplos, ambos están hechos con los componentes ClientSocket y ServerSocket usados en modo nonblocking.

PRIMER EJEMPLO (Client1.htm y Server1.htm)

Server

Ver las propiedades del componente ServerSocket1 (no necesita explicación).
Ver también los eventos de este componente.

Todo el código se relaciona con los eventos del socket ya que el programa no provee interacción con el usuario. Sin embargo el server tiene 3 espacios donde se loguea información.

Observen el evento "OnClientConnect", este indica el primer momento en el que el server se entera de la conexión con el cliente. Usando "TCustomWinSocket" el server puede ver quien está tratando de conectarse. Al final de este evento actualizamos la lista de conexiones usando la propiedad "ActiveConnections" del server.

Un código similar se ejecuta cuando el cliente se desconecta del server (OnClientDisconnect).

Vemos que el server puede leer los mensajes (que le envía el cliente) llamando a la función ReciveText. Esta operación se debe realizar solo cuando hay algún dato disponible para leer, o sea, cuando el evento OnClientRead es disparado.
Notar que esta es una lectura destructiva: la información que se extrae del (stream) es removida de ahí.

Cliente

Ver las propiedades del componente ClientSocket1 (no necesita explicación).
Ver también los eventos de este componente.

El cliente es más interactivo. Hay un EditBox donde se pone la dirección del server al que te queréis conectar. Con el CheckBox se activa y desactiva la conexión.
¿Se acuerdan del primer Remote Ziper? tenía un checkbox para conectar porque no sabía hacerlo de otra forma =).

Observen que se puede escribir un mensaje en el otro EditBox y presionando el botón se envía.

Tengan en cuenta que estos programas están lejos de ser perfectos porque no controlan ciertas cosas. Por ej. que el socket está activo antes de enviar el mensaje, por lo que pueden obtener errores si realizan determinadas acciones.


SEGUNDO EJEMPLO (Client2.htm y Server2.htm)

Server

Acá ya vamos viendo la implementación de un protocolo (como los que usan los troyanos).
Un protocolo es un conjunto de reglas (comandos). Básicamente el server puede recibir distintos pedidos y según el pedido ejecutar distintas acciones.

En este ejemplo el server acepta 4 tipos de pedidos:
Listar un directorio.
Enviar un BMP.
Enviar un txt.
Ejecutar un programa.

A su vez, cuando el server contesta debe indicar que tipo de información va a enviar además de la información.

Lo esencial es ver que hace el server cuando lee del socket (OnClientRead).
Primero extrae los primeros 5 caracteres del texto recibido por que estos contienen el comando.
Luego, se ejecuta un código dependiendo del texto (comando) contenido en estos 5 primeros caracteres. Los comandos son:
EXEC!, TEXT!, BITM!, LIST!
En las fuentes pueden ver el código que se ejecuta según el comando.

Cliente

Vimos que el server también manda 5 caracteres que le permiten saber al cliente que tipo de información va a recibir.
En el ejemplo del cliente se ve otra forma de proceder ante la lectura del encabezado. (yo siempre usé la anterior tanto para el cliente como para el servidor).
Acá cuando el cliente lee, fija un estado para saber que tipo de información viene a continuación.

Eso es todo por ahora, Si quieren ver más sobre este tema pueden bajarse el libro de Marcos Cantú "Mastering Delphi 6" en PDF de alguna red P2P (está en inglés). El tema está tratado en el capítulo 21.

------------------------------------------------------------------------------------------

Nuestro Primer Troyano


En este ejemplo vamos a ver 2 cosas nuevas: Como activar el ClienteSocket usando un botón en vez de un checkBox y como prevenir que salten errores.

Abre un nuevo proyecto en Delphi y coloca un componente ServerSocket en el Form.
En las propiedades del componente pon Active en True, ServerType en stNonBlocking y elige un puerto (ej. 800) en el cual el server escuchará.

Ahora debemos escribir el evento OnRead.
En el ejemplo cuando se recibe el comando '01' el server hace beep, cuando se recibe el '02' muestra un mensaje del cliente y devuelve una confirmación, esto les va a servir de base para más adelante asociar funciones más divertidas a los comandos.
Código:
procedure TForm1.ServerSocket1ClientRead
(Sender:TObject;Socket:TCustomWinSocket);
var Command:integer;
FullCommand,st:string;
begin
FullCommand:=Socket.ReceiveText;
st:=copy(FullCommand,1,2);
Command:=StrToInt(st);
case Command of
01:beep;
02:
begin
ShowMessage(st);
st:='The message '''+st+''' has been received';
Socket.SendText(st);
end;
//etc.
end;
end;


Ahora pasemos al cliente.

Abre otro nuevo proyecto en Delphi y colócale un componente ClientSocket, tres botones y dos EditBoxes.
En las propiedades del ClientSocket pon Active en False, ClientType en stNonBlocking y pon el mismo puerto que en el server (ej. 800).

A continuación está el código de los eventos OnCreate, OnRead y OnError del ClientSocket1 y los eventos OnClick de los botones Button1, Button2 y Button3:
Código:
procedure TForm1.FormCreate(Sender: TObject);
begin
Button1.Caption:='Connect';
Button2.Caption:='Send Beep';
Button3.Caption:='Send Message';
Edit1.Text:='127.0.0.1';
Edit2.Text:='Hi from client!';
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
if ClientSocket1.Active=False then
try
ClientSocket1.Host:=Edit1.Text;
ClientSocket1.Active:=True;
Button1.Caption:='Disconnect';
except
ClientSocket1.Active:=False;
end
else
begin
ClientSocket1.Close;
Button1.Caption := 'Connect';
end;
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
ClientSocket1.Socket.SendText('01');
end;

procedure TForm1.Button3Click(Sender: TObject);
begin
ClientSocket1.Socket.SendText('02'+Edit2.Text);
end;

procedure TForm1.ClientSocket1Read
(Sender:TObject;Socket:TCustomWinSocket);
var s:string;
begin
s:=Socket.ReceiveText;
ShowMessage(s);
end;

procedure TForm1.ClientSocket1Error
(Sender: TObject;Socket: TCustomWinSocket;
ErrorEvent: TErrorEvent;var ErrorCode: Integer);
begin
ErrorCode:=0;
Button1.Caption:='Connect';
end;

El código casi se explica solo salvo por el evento OnError. Con este evento manejamos los errores que ocurren en el socket, y escribiendo "ErrorCode:=0;" prevenimos de que salte un ESocketError.

Ocultando La Ventana Del Server

Con Application.ShowMainForm:= False; podemos hacer que la aplicacion no aparezca en la solapa "Aplicaciones" del "TaskManager".

procedure TForm1.FormCreate(Sender: TObject);
begin
Application.ShowMainForm:=False;
end;

(este post está siendo revisado y en construcción)

Gran aporte!!!

Un saludo hermano!

Mas alla de que el post siga vigente, esta prohibido Revivir post de mas de 30 días,estos ya se consideran Antiguos.