Expandir Sección y Encriptar Server by HD_Breaker

Bueno dado que descubri un mundo que realmente me encanto, algo que realmente desconocia, que es la edicion de binarios
he decidido hacer este tutorial para ayudar a todo aquel que desee o necesite incurcionar en este mundo, tanto sea para
hacerlo manualmente o para llevarlo a la programacion de cripters.

Este tutorial consiste en hacer mas espacio en la seccion Ejecutable del binario con el fin de poder agregar nuestra
rutina de des/encriptacion y que esta se cargue directamente con el PE original del binario y no se necesario programar un RUN PE

Por que realizar esto si puedo agregar una nueva seccion y almacenar mi codigo de des/encriptacion en ese espacio?

Primero que nada, hay binarios que no nos permiten agregar nuevas secciones.
Segundo y mas importante: No alteramos la estructura principal del binario por lo que aumentamos las posibilidades de no ser detectados por algunos avs


Decidi hacer esto bajo Lord PE ya que no encontre documentacion de como utilizarlo.

Requisitos Previos:
Conocer el Formato PE: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta

SpyNet-2.6:   No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
Lord-PE:      No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
Hex Workshop: No tienes permitido ver los links. Registrarse o Entrar a mi cuenta
OllyDBG

Tabla LordPE:

ROffset = PointToRawData
Rsize    = SizeOfRawData
Vsize   = VirtualSize
VOffset = VirtualAdrress
Flags   = Characteristics

Comencemos:

Primer Paso: Recopilar Datos Importantes:

Abrimos Lord-PE damos click en PE-Editor y abrimos nuestro Server.exe
Anotamos estos 2 datos:


FileAlignament: 200
SectionAlignament:1000


Hacemos click en Sections:

Aqui se pueden ver todas las secciones del binario


Nosotros vamos a Expandir la seccion donde se encuentra el codigo ejecutable, en este caso es la seccion CODE (por lo general es la seccion .text)

Anotamos el PointerToRawData y SizeOfRawData

ROffset:400
Rsize:B200

La suma de estos 2 campos nos va a dar el final de la seccion CODE (400 donde Empiesa y B200 donde termina)

ROffset + Rsize = B600

Hacemos Click Derecho sobre la seccion CODE y hacemos click en "Edit Section Header" clickeamos donde dice Flags y daremos permisos de Escritura sobre esta seccion
Ya que Aqui Agregaremos posteriormente nuestra Seccion de Des/Encriptacion para lo cual esta seccion debe indispenzablemente tener permisos de lectura y escritura

Seleccionamos la Opcion Writeable



Cerramos Lord-PE y editamos el Server con Hex Workshop:

Nos vamos a la seccion B600 esto lo hacemos colocando sobre la barra superior de GoTo 0xB600


Como vemos en la imagen justo donde esta marcado el 00 es el final de la seccion CODE, si vemos un poco mas arriba
vemos una seccion de 00, en la cual podriamos situar un des/cifrador ASM pero si el algoritmo es complejo estariamos cortos de espacio:
(Devemos Recordar que se deben dejar bytes de contencion al principio y al final de la seccion donde injectaremos nuestro ASM)

Este es el espacio que nos queda dejando tan solo 3 bytes de contencion al inicio y al final del espacion de esta seccion:


Es por esto que expandiremos esta seccion:

Para hacer esto debemos decidir cuantos bytes queremos agregar y alinearlos con multiplos de FileAlignament:

Por Ej:

Si queremos agregar 150 bytes y nuestro FileAlignament es 200, deberiamos Agregar 200 bytes (FileAlignament*1), de los cuales consumiremos solo 150
Si queremos agregar 250 bytes y nuestro FileAlignament es 200, deberiamos alinear a 400 bytes (FileAlignament*2)

En este Tutorial Agregaremos 200 bytes con esto estamos sobrados bajo mi criterio.

Situados en 0xb600:

Boton Derecho -> Inserts

Number of Bytes = 200 Hex
Fill with NOPS (90)


Como podemos ver hemos agregado 200 bytes de NOPS aqui esta nuestro espacio para agregar nuestra funcion Des/Encriptadora


Al Agregar este espacio el HEAD PE ya no contendra los datos correctos para la ejecucion del Archivo en memoria, por lo que
el archivo rompera automaticamente despues de guardar la Edicion.


Cerramos Hex Workshop y vamos a pasar a la etapa de reparar el binario.


Primero que nada Abrimos Lord-PE y nos Vamos al Apartado PE-Editor (Abrimos nuestro Server Crash) y click en Sections:

Ahora comienza lo interezante, nosotros hemos agregado 200 bytes a la seccion CODE.

por lo que debemos avisarle al PE de estos cambios para que mapee los datos correctamente en Memoria, para esto vamos a editar:

VirtualSize y RawSize (Size_Of_Raw_Data)

Click derecho sobre la seccion CODE y click en Edit Section Header:


Entramos a este Menu:



Tanto VirtualSize como RawSize deben incrementarce la cantidad de bytes alineados que expandimos la seccion.
En nuestro caso 200 bytes:

Sumamos 200 a los valores de VirtualSize y RawSize quedando:

VirtualSize =  B1C8 + 200 = B3C8
RawSize       =  B200 + 200 = B400   



Los que se Tomaron el tiempo de leer el PDF de The Swash sobre como funcionan los ejecutables de Windows (PE)
Sabra que el PointerToRawData de cada seccion varia como la sumatoria de ROffset (PointToRawData) y RSize de la seccion anterior

Entonces hay que modificar 2 cosas de todas las secciones posteriores:

Primero que nada: VirtualAdress: Unicamente si la sumatoria de VirtualAdress (VOffset) y RSize (SizeOfRawData) de la seccion Ampliada (CODE) es mayor
que la VirtualAdress de la seccion Actual (es un poco dificil de entender esta Parte simplemente calculamos la sumatoria entre VOffset y RSize de Code y lo comparamos con Voffset de DATA y asi sucesivamente con todas las secciones)

En nuestro caso esto no se cumple para ninguna Seccion.

Segundo: Debemos Actualizar el PointerToRawData (ROffset) de todas las secciones posteriores como la sumatoria de ROffset y RSize de su Seccion anterior Directa.

Entonces:

DATA.ROffset = Code.ROffset+Code.RSize
BSS.ROffset  = DATA.ROffset+DATA.RSize

.idata.ROffset  =  BSS.ROffset+BSS.RSize
.tls.ROffset    = .idata.ROffset+.idata.RSize
.rdata.ROffset  = .tls.ROffset+.tls.RSize
.reloc.ROffset  = .rdata.ROffset+.rdata.RSize
.rsrc.ROffset   = .rsrc.ROffset+Code.RSize

Quedando:
DATA.ROffset = 400+B400=B800
BSS.ROffset  = B800+400=BC00

.idata.ROffset  =  BC00+0000=BC00
.tls.ROffset    =  BC00+0C00=C800
.rdata.ROffset  =  C800+0000=C800
.reloc.ROffset  =  C800+0200=CA00
.rsrc.ROffset   =  CA00+0C00=D600

Editamos ROffset de todas las secciones con los valores calculados, guardamos los cambios y cerramos LORD-PE
En este al contrario de otros Tutoriales de Edicion Manual no tendremos que editar el SizeOfImage ya que Lord-PE lo calcula Automaticamente

Actualizamos nuestra Carpeta y vemos ya como el icono vuelve a la normalidad y se puede ejecutar el archivo Correctamente:



Bien Ahora tenemos Nuestro ejecutable con la Seccion Code Ampliada y con permisos de ejecucion, lectura y escritura.

Ahora pasaremos a Crear nuestra Rutina de Encriptacion sobre el espacio que nos hicimos en la Seccion Code:


Ejecutamos OllyDBG y abrimos nuestro Servidor:

Damos Click Derecho --> View --> Executable File


Vamos a buscar el espacion que nos hicimos, si recordamos nosotros agregamos 200 bytes a partir de 0xb600
por lo q buscaremos esa direccion con OllyDBG

Ctrl+G y cologamos B600


Como vemos nos encontramos todos nuestros NOPS clickeamos sobre el primero, Boton Derecho --> View Image on Dissambler


Aqui Comenzaremos a ingresar nuestra rutina de Encriptacion:

Rutina Xor Simple (Code By [Zero]):

;Movemos a eax la dirección de inicio del código cifrado
mov eax,402000h
;Movemos a ebx la dirección de fin del código cifrado
mov ebx,403000h
;Movemos a ecx la dir del Entry Point Original
mov ecx,401038h
xor byte ptr ds:[eax],0FFh     	      ;Hacemos el xor al byte con la clave 0FF (se puede cambiar por otro byte)
inc eax                                           ;Nos desplazamos al siguiente byte
cmp eax,ebx                                  ;Comprobamos si es el último
jne 401234h                                  ;Si no lo es, continuamos con el siguiente
ret                                                 ;Salimos del programa (cambiar ret por nop despues de cifrar)
jmp ecx                               ;Si lo es, saltamos el Entry Point Original

Bueno en este Codigo las direcciones 402000, 403000, y 401234 deben cambiarse por las correspondientes al inicio y al final
de lo que queremos cifrar pero en sus valores de memoria Virtual

Para lograr esto, debemos:

Primer Dato:

Restarle a la direccion fisica donde comienza la seccion .CODE el ROffset (Coinside con el inicio en este caso porq es la primera seccion)
Nuestra seccion Code comenzaba en 0x400 entonces

0x400-0x400 = 0

Le sumamos el VOffset y el ImageBase: (Todos estos datos se obtienen con Lord-PE)

0+1000(Voffset)+400000 = 401000

Segundo Dato:

Este es el HASTA DONDE queremos Sifrar, si vemos el tutorial de zero el trabaja con un valor anterior a donde terminaba
la seccion CODE (B600) ya que no Expandio la Seccion, en nuestro caso al haber expandido la seccion code, podemos trabajar
con mas comodidad y decirle que cifre hasta B600-1 (Donde terminaba la seccion CODE y agregamos nuestros 200 bytes)

entonces el segundo dato es:

(B5FF-400)+1000+400000= 40C1FF

y el tercer valor es:

El EntryPoint + el ImageBase para saber esto abrimos el binario con Lord-PE y sumamos los balores EntryPoint y ImageBase

EntriPoint= BBF4
ImageBase = 400000

Tecer Valor= 40BBF4


Bien queda el Ultimo, este es la direccion donde nuestro codigo hace xor byte ptr ds:[eax],0FFh

Esto es facil de explicar, tenemos una rutina que lee 1 a uno los bytes de un bloque de direcciones
este le aplica XOR a cada uno de los bytes, esto es un bucle para encriptar/desencriptar
con el cual si no hemos llegado al ultimo byte, salta al siguiente y le vuelve a aplicar XOR
y se repite este proceso hasta que llegamos al ultimo byte.

este valor lo obtenemos mirando OllyDBG justo en la line del XOR

El Cuarto Valor es: 40C20F

Entonces nos queda en olly de esta manera:


Ahora tenemos que guardar los cambios y guardar en disco:

Click Derecho -> Copy to Executable/All modifications y guardamos el archivo en el disco (click derecho, backup->save data to file).

Bueno Casi Terminamos, debemos cambiar el EntriPoint del Ejecutable con nuestra rutina ASM para que apunte a nuestro codigo, y luego salte al resto del programa
Esto lo hacemos con LORD-PE

Abrimos el Binario y Cambiamos donde Dice EntryPoint por el valor de memoria de nuestra primera linea ASM sin el ImageBase

en nuestro caso es:

40c200-400000 = c200


Bueno ahora biene la ultima Parte:

Vamos a Establecer un BreakPoint en retn dentro de nuestro codigo ASM en OllyDBG para que cifre todo el codigo:


Precionamos F9 para que se ejecute hasta el BreakPoint y copiaremos todo entre 401000 y 40C1FF (Todo esto estara Encriptado)

Selecionamos todo y realizamos un Binary Copy:


Cerramos OllyDBG y nos aceguramos de no copiar nada para no eliminar el codigo el portapapeles!!!

Ahora Utilizaremos Otro Editor Hexadecimal: HxD

Abrimos HxD y seleccionamos los bytes entre 400 y b5FF y realizamos un Pegar Escribiendo y guardamos los cambios

Solo queda abrir por ultima vez nuestro servidor con OllyDBG y sustituir retn por un NOP:


y como vemos nuestro server conecta:


Bueno espero que mi Aporte pueda ser de ayuda a todo aquel interesado en el tema
Espero como minimo un Gracias ya que son las 6 am y todavia estoy cargando las imagenes del tutorial

PD: Para dejarlo fud solo se deberia aplicar una encriptación mas fuerte y cifrar la IAT

 ;)Nice... Intelligent and Intriguing,keep up the good work!

El método está muy bueno y el tutorial genial, pero tiene ciertas limitaciones.
Sólo se cifra la sección de código y no puedes cifrar la IT, porque el ejecutable petaría cuando el loader lo intentara cargar.

En estos momentos ando intentando programar un crypter en ASM que básicamente funcionará así, sólo que añadiendo una nueva sección. Sección cuya VA servirá para añadir una TLS Callback a ella y así evitar modificar el entry point del programa.
Por supuesto, se cifrarán todas las secciones, incluida la Import Table

El proyecto está en pañales y me veo en innumerables complicaciones... pero espero que pronto se puedan ver los primeros resultados!