
linux Privilege Escalation
Vorstellung von Mempodipper, einem Exploit für CVE-2012-0056. /proc/pid/mem ist eine Schnittstelle zum direkten Lesen und Schreiben von Prozessspeicher, indem man mit denselben Adressen wie der virtuelle Adressraum des Prozesses sucht. In 2.6.39 wurden die Schutzmaßnahmen gegen unbefugten Zugriff auf /proc/pid/mem als ausreichend erachtet, und daher wurde die vorherige #ifdef-Direktive, die Schreibunterstützung für das Schreiben in beliebigen Prozessspeicher verhinderte, entfernt. Jeder mit den richtigen Berechtigungen konnte in Prozessspeicher schreiben. Es stellte sich natürlich heraus, dass die Berechtigungsprüfung schlecht gemacht wurde. Das bedeutet, dass alle Linux-Kernel >=2.6.39 anfällig sind, bis zum Fix-Commit vor ein paar Tagen. Lassen Sie uns den alten Kernel-Code Schritt für Schritt durchgehen und herausfinden, was das Problem ist.
Wenn /proc/pid/mem geöffnet wird, wird dieser Kernel-Code aufgerufen:
static int mem_open(struct inode* inode, struct file* file)
{
file->private_data = (void*)((long)current->self_exec_id);
/* OK to pass negative loff_t, we can catch out-of-range */
file->f_mode |= FMODE_UNSIGNED_OFFSET;
return 0;
}
Beim Öffnen gibt es keine Einschränkungen; jeder kann den /proc/pid/mem Dateideskriptor für jeden Prozess öffnen (vorbehaltlich der üblichen VFS-Einschränkungen). Es merkt sich einfach die self_exec_id des ursprünglichen Prozesses, mit der es geöffnet wurde, und speichert diese für spätere Überprüfungen während Lese- und Schreibvorgängen.
Schreibvorgänge (und Lesevorgänge) unterliegen jedoch Berechtigungsprüfungen. Schauen wir uns die Schreibfunktion an:
static ssize_t mem_write(struct file * file, const char __user *buf,
size_t count, loff_t *ppos)
{
/* unimportant code removed for blog post */
struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode);
/* unimportant code removed for blog post */
mm = check_mem_permission(task);
copied = PTR_ERR(mm);
if (IS_ERR(mm))
goto out_free;
/* unimportant code removed for blog post */
if (file->private_data != (void *)((long)current->self_exec_id))
goto out_mm;
/* unimportant code removed for blog post
* (the function here goes onto write the buffer into the memory)
*/
Es gibt also zwei relevante Prüfungen, um unbefugte Schreibvorgänge zu verhindern: check_mem_permission und self_exec_id. Betrachten wir zuerst die erste und dann die zweite.
Der Code von check_mem_permission ruft einfach __check_mem_permission auf, also hier der Code davon:
static struct mm_struct *__check_mem_permission(struct task_struct *task)
{
struct mm_struct *mm;
mm = get_task_mm(task);
if (!mm)
return ERR_PTR(-EINVAL);
/*
* A task can always look at itself, in case it chooses
* to use system calls instead of load instructions.
*/
if (task == current)
return mm;
/*
* If current is actively ptrace'ing, and would also be
* permitted to freshly attach with ptrace now, permit it.
*/
if (task_is_stopped_or_traced(task)) {
int match;
rcu_read_lock();
match = (ptrace_parent(task) == current);
rcu_read_unlock();
if (match && ptrace_may_access(task, PTRACE_MODE_ATTACH))
return mm;
}
/*
* No one else is allowed.
*/
mmput(mm);
return ERR_PTR(-EPERM);
}
Es gibt zwei Möglichkeiten, wie der Speicherschreibvorgang autorisiert wird. Entweder task == current, was bedeutet, dass der zu beschreibende Prozess der schreibende Prozess ist, oder current (der schreibende Prozess) hat esoterische ptrace-Ebene-Berechtigungen, um mit task (dem zu beschreibenden Prozess) zu spielen. Vielleicht denken Sie, Sie könnten den ptrace-Code austricksen? Es ist verlockend. Aber ich weiß nicht. Lassen Sie uns stattdessen herausfinden, wie wir einen Prozess dazu bringen können, beliebigen Speicher in sich selbst zu schreiben, sodass task == current gilt.
Nun wollen wir natürlich in den Speicher von SUID-Prozessen schreiben, da wir dann root werden können. Schauen Sie sich das an:
$ su "yeeeee haw I am a cowboy"
Unknown id: yeeeee haw I am a cowboy
su gibt einen beliebigen Text auf stderr aus, mit dem Präfix "Unknown id:". Also können wir einen Dateideskriptor zu /proc/self/mem öffnen, mit lseek an die richtige Speicherstelle zum Schreiben springen (dazu später mehr), dup2 verwenden, um stderr und den mem-Deskriptor zu verbinden, und dann exec auf su $shellcode ausführen, um einen Shell-Starter in den Prozessspeicher zu schreiben, und dann haben wir root. Wirklich? Nicht so einfach.
Hier kommt die andere Einschränkung ins Spiel. Nachdem es den Test task == current bestanden hat, prüft es, ob die aktuelle self_exec_id mit der self_exec_id übereinstimmt, mit der der Dateideskriptor geöffnet wurde. Was zur Hölle ist self_exec_id? Es wird nur an wenigen Stellen im Kernel referenziert. Die wichtigste befindet sich innerhalb von exec:
void setup_new_exec(struct linux_binprm * bprm)
{
/* massive amounts of code trimmed for the purpose of this blog post */
/* An exec changes our domain. We are no longer part of the thread
group */
current->self_exec_id++;
flush_signal_handlers(current, 0);
flush_old_files(current->files);
}
EXPORT_SYMBOL(setup_new_exec);
self_exec_id wird jedes Mal erhöht, wenn ein Prozess exec ausführt. In diesem Fall funktioniert es also so, dass man den Dateideskriptor nicht in einem nicht-SUID-Prozess öffnen, dup2 durchführen und dann zu einem SUID-Prozess exec kann ... genau das, was wir oben versucht haben. Ziemlich raffinierte Art, unseren Angriff abzuwehren, oder?