Bad chars y encoders/decoders en payloads

En la lista de la ekoparty 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.

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:

#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 < size_payload; i++){
        printf("0\\x%x", (char *)payload[i] ^ xor_code);
    }
}

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

    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.

Autor: snf