[Dreamhack System Hacking] SROP

Signal 시그널

SROP에 대해서 알아보기 전에 시그널(Signal)을 처리하는 방식을 이해해야 한다.

운영체제는 유저 모드와 커널 모드로 나뉘어지는데, 파일을 생성하고, 프로그램을 실행하는 모든 작업은 이 두 개의 모드가 서로 상호작용하면서 이뤄진다.

 

시그널을 프로세스에 특정 정보를 전달하는 매개체

- 리눅스에서는 다양한 시그널을 제공함

include/linux/signal.h 일부

 *	+--------------------+------------------+
 *	|  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	|
 *	+--------------------+------------------+

 

 

시그널 동작 방식

SIGALRM 예제 코드

// 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_handler 함수를 실행한다.

SIGALRM 시그널이 발생하면 커널 모드로 진입한다.

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

 

=> 즉, 유저 모드의 상태를 모두 기억하고 되돌아올 수 있어야 함

(상태 : 시그널이 발생했을 때 프로세스의 메모리, 레지스터 등)

 

 

 

do_signal

do_signal 함수는 시그널을 처리하기 위해 가장 먼저 호출되는 함수

리눅스 커널 5.10이하 버전에서는 arch_do_signal, 상위 버전에서는 arch_do_signal_or_restart 함수로 그 이름이 변경되었다.

 

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();
}

해당 함수에서는 시그널에 해당하는 핸들러가 등록되어 있는지 확인한다. 

만약 핸들러가 등록되어 있다면 시그널에 대한 정보와 레지스터 정보를 인자로 handle_signal 함수를 호출함

 

 

 

handle_signal

linux/arch/x86/kernel/signal.c 내 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 함수의 일부로, setup_rt_frame 함수를 호출한다.

해당 함수는 시그널에 적용된 핸들러가 존재할 경우, 핸들러의 주소를 다음 실행 주소로 삽입한다.

SIGALRM이 발생할 경우 해당 코드를 통해 sig_handler 함수가 실행된다.

 

* signal handler  호출 과정

regs->si = (unsigned long)&frame->info;
regs->dx = (unsigned long)&frame->uc;
regs->ip = (unsigned long) ksig->ka.sa.sa_handler;
regs->sp = (unsigned long)frame;

 

 

 

 

sigreturn

현재 프로세스가 바뀌는 걸 컨텍스트 스위칭(Context Switching)이라고 한다.

앞서 알아본 바와 같이 커널이 유저가 실행한 프로세스를 관리하기 위해 다양한 코드를 실행한다. 컨텍스트 스튀칭이 일어나면 다시 유저 프로세스로 복귀해야 한다. 따라서 스위칭이 일어날 때 상황을 커널에서 기억하고, 커널 코드의 실행을 마치면 기억한 정보를 되돌려 복귀해야 한다. 

이때 사용되는 시스템 콜이 sigreturn이다.

 

다음은 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, CONTEXT_COPY_SIZE))
		return false;
#ifdef CONFIG_X86_32
	set_user_gs(regs, sc.gs);
	regs->fs = sc.fs;
	regs->es = sc.es;
	regs->ds = sc.ds;
#endif /* CONFIG_X86_32 */
	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;
#ifdef CONFIG_X86_64
	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;
#endif /* CONFIG_X86_64 */
	/* 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;
#ifdef CONFIG_X86_64
	/*
	 * 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);
#endif
	return fpu__restore_sig((void __user *)sc.fpstate,
			       IS_ENABLED(CONFIG_X86_32));
}

sigreturn 시스템 콜을 호출하면 내부적으로 해당 함수를 호출해 스택에 저장한 값을 각각의 레지스터에 복사하여 기존 상황과 실행할 코드를 기억하고 복귀한다.

	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, CONTEXT_COPY_SIZE))
		return false;

코드를 보면, sigcontext 구조체에 존재하는 각 멤버 변수에 값을 삽입하는 걸 확인할 수 있다.

 

 

 

 

sigcontext

다음은 sigcontext 구조체이다.

/* __x86_64__: */
struct sigcontext {
  __u64               r8;
  __u64               r9;
  __u64               r10;
  __u64               r11;
  __u64               r12;
  __u64               r13;
  __u64               r14;
  __u64               r15;
  __u64               rdi;
  __u64               rsi;
  __u64               rbp;
  __u64               rbx;
  __u64               rdx;
  __u64               rax;
  __u64               rcx;
  __u64               rsp;
  __u64               rip;
  __u64               eflags;     /* RFLAGS */
  __u16               cs;
  __u16               gs;
  __u16               fs;
  union {
      __u16           ss; /* If UC_SIGCONTEXT_SS */
      __u16           __pad0; /* Alias name for old (!UC_SIGCONTEXT_SS) user-space */
  };
  __u64               err;
  __u64               trapno;
  __u64               oldmask;
  __u64               cr2;
  struct _fpstate __user      *fpstate;   /* Zero when no FPU context */
#  ifdef __ILP32__
  __u32               __fpstate_pad;
#  endif
  __u64               reserved1[8];
};

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

표에 있는 코드는 x86_64 아키텍처에 해당하는 구조체이다. 따라서 다른 아키텍처의 바이너리를 공격할 땐 대상 아키텍처를 파악하고 해당 구조체와 커널 코드를 분석해서 진행해야 한다.

 

 

 

 

SROP

SigReturn-Oriented Programming(SROP)는 컨텍스트 스위칭을 위해 사용하는 sigreturn 시스템 콜을 이용한 ROP기법이다.

ROP가 코드 조각을 모아서 임의의 코드를 실행하는 공격 기법인 걸 보아, SROP는 sigreturn 시스템 콜을 호출하고, 레지스터에 복사할 값을 미리 스택에 저장해 임의 코드를 실행하는 걸 알 수 있다.

모든 레지스터를 조작할 수 있는 만큼 익스플로잇 활용도가 매우 높다.

 

SROP 예제 코드

// Name: sigrt_call.c
// Compile: gcc -o sigrt_call sigrt_call.c 
#include <string.h>
int main()
{
        char buf[1024];
        memset(buf, 0x41, sizeof(buf));
        asm("mov $15, %rax;"
            "syscall");
}

 

다음 예제를 컴파일하고 디버거에서 실행해보면 다음과 같이 레지스터를 조작할 수 있는 걸 확인할 수 있다.