Bad chars y encoders/decoders en payloads

Alguien pregunto como podia detectar bad chars en una payload.

Es por eso que voy a introducir un poco estos conceptos:
Una payload como todos sabemos es una combinacion de codigo y datos que se inyectan en un proceso corriendo para explotarlo, puede ser para un buffer overflow, memory corruption, heap overflow, etc.
Esta payload generalmente debe tener unos requisitos para que el programa la acepte, por ejemplo si la payload pasa por strcpy no podemos tener un caracter nulo porque no terminaria de copiar todo el buffer, sino que lo haria hasta donde este el caracter nulo (0).
Ejemplo:

buffer = "\x12\x41\x23\x34\x21\x34\x23\x00\x98\x93\x83\x11";
__________________________________||_______________
strcpy copia hasta aca, el resto no lo copia

A ese byte lo consideramos un bad char y es lo que tenemos que evitar, se puede utilizar un encoder en asm si nuestra payload va a ser ejecutada, sino tenemos que pensar en cambiar la payload.
El caracter nulo es un bad char caracteristico de strcpy y varias funciones mas porque es el caracter que se usa para terminar las cadenas en C (y varios lenguajes mas). Pero si nos encontramos ante un servidor HTTP por ejemplo tendriamos que tener en cuenta otros bad chars como es el caso de '\r' o '\n' que son terminadores de linea en el protocolo y seguramente nos van a interrumpir la payload cuando el server la parsee.
Otros protocolos/programas tendran otros bad chars y es por eso que a veces tendremos que reversear el programa si nuestra payload por alguna razon no llega a provocar la corrupcion que estamos buscando.

Aqui por ejemplo tenemos un pequeno programa en python para buscar bad chars en una payload, solamente ponemos nuestra payload y los bad chars que no acepta el programa que queremos explotar.

Código

Code (python):
payload = "\x12\x41\x23\x34\x21\x34\x23\x00\x98\x93\x83\x11"

bad_chars = "\x00\n"



for offset in range(0, len(payload)):

   if(payload[offset] in bad_chars):

       print "tienes un bad char en el offset %s" % (offset)

 
 

Por otro lado como habia mencionado hay veces que no podemos remover ese bad char porque puede ser una intruccion fundamental en nuestra shellcode como un long jump obligatorio a una direccion que contenga 0.
Aqui entran en juego los encoders, lo que se hace es codificar la payload y agregar un decoder en la misma, que son pequenos stubs en ASM que se ejecutan antes de la payload y decodifican el resto.
Una de las codificaciones mas usadas es la que se hace con XOR, como bien sabemos si nosotros xoreamos un byte con otro podemos volver al estado inicial volviendolo a xorear con el mismo byte.

Ejemplo :
10 XOR 32 = 22
22 XOR 32 = 10

Ahora que tenemos la teoria, sabemos que podemos xorear toda la payload y agregar un header que la vuelva a su estado decodificado.

Un codificador de payload podria ser asi:

Código

Code (c):
#include 



int size_payload = 12;

char *payload = "\x12\x41\x23\x34\x21\x34\x23\x00\x98\x93\x83\x11";

char   xor_code = 0x22; //este byte tiene que ser igual en el stub en asm



int main(int argc, char *argv[])

{

   int i;

   for(i = 0; i < style="color: rgb(102, 204, 102);">){

       printf("0\\x%x", (char *)payload[i] ^ xor_code);

   }

}

 
 

y el stub que se le agregaria a una payload seria algo asi:

Código

Code (asm):
    jmp call_inicio

inicio:

   pop  esi                           ; sacamos la direccion de la payload codificada de la pila y la guardamos en esi

   mov eax, payload_code ; con el byte que xoreamos nuestra payload

   xor   ebx,ebx                   ; 

   mov ecx, payload_size  ; el tamano que tiene nuestra payload

otra_vez:

   xor   dword ptr[esi+ebx], eax ; aqui aplicamos el xor

   inc   eax            ; aumentamos eax, es con el que contamos las posiciones de memoria

   dec  ecx

   jnz   otra_vez    ; si no terminamos de decodificar la payload saltamos a otra_vez

   jmp  comienzo_payload  ; una vez que terminamos saltamos a la payload real

call_inicio:

   call  inicio          ; usamos este truco para guardar la direccion de memoria donde comienza la payload, recordemos que call pone en la pila la 

                             ;siguiente memoria

comienzo_payload:

      ; aqui va nuestra payload codificada.

 
 

Como veran es un codigo de apenas unos bytes y aunque este no esta optimizado pueden conseguir encoders/decoders muy eficientes que pueden hasta comprimir la payload si es muy grande.