Skip to content
KitploitKITPLOIT
ToolsExploitsBlog
Log in
Einreichen
ToolsExploitsBlog
Einreichen

Hacking-, PenTest- und Cybersicherheits-Tools für Ihr Sicherheitsarsenal!

Kitploit ist ein Verzeichnis von Hacking-, Cybersicherheits- und Pentesting-Tools. Entdecken Sie die neuesten Projekt-Updates, um Schwachstellen zu finden, Systeme zu analysieren, Tests zu automatisieren und Ihre Sicherheit zu stärken.

FeedsKontaktDatenschutz© 2026 Kitploit

Tool-Verzeichnis

Kategorien

Alle Kategorien anzeigen
Loading categories
CVE-2012-0056 — linux Privilege Escalation | Kitploit
Tools/GitHubGitHub/pythonone/cve-2012-0056
Privilege EscalationSchwachstellenanalyseExploitationShellcodeLernen & BildungBinary-Exploitation
GitHubpythonone/cve-2012-0056

CVE-2012-0056

linux Privilege Escalation

Repository anzeigen
1628vor 10 JahrenNoch nicht geprüft
Teilen

Linux Lokale Privilegienausweitung via SUID /proc/pid/mem Write

Mempodipper

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?

Tool herunterladen

Beliebteste

Alle anzeigen →

Entdecken Sie die meistgenutzten Tools unserer Community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 Das ultimative OSINT-Toolkit: Untersuchungsgraph, Konfidenzbewertung, Alias-Familien, Karte, Zeitleiste und Berichte. 49 Module, 400+ Websites, keine API-Schlüssel erforderlich.

    871
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    GhostLock One-Tap Execution App (CVE-2026-43499)

    548
  • 3

    ARTEX

    baarai/artex

    LLM-basierte Multi-Agenten-Plattform für autonome Penetrationstests mit Planer-/Worker-Agenten, Asset- und Explorationsgraphen, MITM-Verkehrsaufzeichnung und Schwachstellen-Retesting.

    383
  • 4

    redforge

    cybersecurity91/redforge

    Browser-seitiges Red-Team-Toolkit mit 102 Offline-Tools für Recon, Payload-Generierung, Credential-Angriffe, Krypto, Encoding und Engagement-Reporting.

    361
  • 5

    looking-glass

    anonghosty/looking-glass

    CSIRT-Plattform, die Shadowserver-Berichte in MongoDB einliest und sie als interaktive Karten, Analysen, Findings, Advisories und Executive-Dashboards wiedergibt.

    305
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Das System der Handlung für KI-native Cybersicherheit – wo Absicht zu gesteuerter Ausführung wird, Beweise zu operativem Gedächtnis werden und jeder Einsatz den nächsten verbessert.

    280

Alle Tools erkunden

Durchsuchen Sie unsere Tool-Sammlung

Alle Tools anzeigen →