In u nostru articulu precedente, Avemu vistu cumu rilevà è prutege contr'à l'avvelenamentu direttu Pipeline Esecuzione (D-PPE). Avemu vistu ancu cumu rilevà sta vulnerabilità aduprendu Scanner Xygeni, è ancu certi meccanismi di prutezzione.
Avvelenatu Pipeline Esecuzione (PPE) hè pruduttu quandu l'attaccante pò mudificà u pipeline logica in unu di i dui modi:
- Mudificendu u schedariu di cunfigurazione CI (u pipeline) -> DPI diretti (D-PPE)
- Mudificendu i fugliali riferiti da u pipeline (per esempiu: scripts referenziati da l'internu di u pipeline schedariu di cunfigurazione) -> DPI indiretti (I-PPE)

In questu articulu, approfondiremu u PPE indirettu. Ma, prima di quessa, è cum'è cumplementu à u mo articulu precedente, vedemu prima cumu GitHub gestisce l'esecuzione di pipelines è quali sò i meccanismi di prutezzione contr'à D-PPE.
Cumu GitHub prutege l'esecuzione di pipelineVene da e PR?
Cumu funziona GitHub per l'esecuzione di mudificazioni pipelines?
mudificatu pipelines ponu vene da Pushes o Pull Requests (RP). Cum'è una bona pratica maiò, hè fortemente cunsigliatu d'evità ogni "push" direttu à una branca prutetta è aduprà Pull Requests cum'è un mecanismu per impone una certa revisione prima di accettà qualsiasi codice cuntribuitu.
Pull Requests pò vene da duie fonti diverse:
- PR chì venenu da furculite
- PR chì venenu da rami
PR da furculite pò vene sia da pùbblicu or privatu repositori.
Siccomu si tratta di PPE (Avvelenati) Pipeline Esecuzione), u nostru puntu principale ùn hè micca l'"accettazione" di una PR ma l'esecuzione di una mudificata pipeline durante u prucessu d'accettazione/approvazione di u PR. À u core di un attaccu PPE, ci hè una esecuzione involuntaria di un "malizioso" mudificatu pipeline.
In poche parole, Avvelenatu Pipeline L'esecuzione (PPE) hè prudutta quandu l'attaccante pò mudificà u pipeline lòggica.
Ci sò dui varianti:
- DPI diretti (D-PPE): In un scenariu D-PPE, L'attaccante mudifica u schedariu di cunfigurazione CI in un repositoriu à u quale anu accessu, sia spinghjendu u cambiamentu direttamente à una branca remota micca prutetta nantu à u repositoriu, sia presentendu un PR cù u cambiamentu da una branca o una bifurcazione. Dapoi u CI pipeline L'esecuzione hè definita da i cumandamenti in u schedariu di cunfigurazione CI mudificatu, i cumandamenti maliziosi di l'attaccante sò infine eseguiti in u nodu di compilazione una volta chì a compilazione hè stata eseguita. pipeline hè attivatu.
- DPI indiretti (I-PPE): In certi casi, a pussibilità di D-PPE ùn hè micca dispunibile per un avversariu cù accessu à un SCM repositoriu (per esempiu, se u pipeline hè cunfiguratu per tirà u schedariu di cunfigurazione CI da una branca separata è prutetta in u listessu repositoriu). In un tale scenariu, invece di avvelenà u pipeline stessu, un attaccante inietta codice maliziosu in i fugliali riferiti da u pipeline (per esempiu: scripts referenziati da l'internu di u pipeline schedariu di cunfigurazione)
In i dui casi, GitHub eseguirà u mudificatu pipeline senza bisognu di una revisione o appruvazione precedente.
PR da e forchette pùbblicu sicretu
GitHub permette di cunfigurà u cumpurtamentu durante u processamentu PR chì venenu da fork in repos publichi.
Quandu una PR vene da una bifurcazione, GitHub forza sempre un certu livellu di "approvazione" prima di eseguisce a pipeline assuciatu à u PRStu livellu d'appruvazione passa da una appruvazione debule à una appruvazione stretta.
At Livellu urganizativu (Org>>Impostazioni>>Azioni>>Generale), pudete sceglie trà parechje opzioni di "approvazione":

U più strettu hè l'ultimu ("Richiede l'approvazione di tutti i collaboratori esterni") perchè GitHub richiederà sempre l'approvazione quandu a PR vene da fork di collaboratori esterni.
Ma ancu in questu casu strettu, ci sò differenze trà i collaboratori cù permessi di lettura è scrittura.
- Quandu u PR vene da un leghje utilizatore, u esicuzzioni di u pipeline hè FERMATU finu à chì ùn ci sia una appruvazione di cambiamenti. Sè l'appruvazione hè bona, allora u mudificatu pipeline hè eseguitu.
- Quandu u PR vene da un scrivemu utilizatore, u l'approvazione ùn hè micca necessaria è a mudificazione pipeline hè sempre eseguitu !!

In cunclusione, i PR chì venenu da i fork nantu à i repositori publichi sò ligeramente prutetti contr'à i PPE. Ci hè una certa prutezzione contr'à l'utilizatori esterni (di lettura), ma nunda in leia cù l'utilizatori interni (di scrittura).
Chì ne dici PR chì venenu da forks da repos privati?
PR da e forchette privatu sicretu
In questu scenariu, GitHub furnisce alcuni paràmetri di cunfigurazione utili.

I paràmetri sopra citati ponu esse cunfigurati sia à urganu o à repo livellu.
quandu nisuna opzione hè marcata, GitHub hà da dumandà l'approvazione e ùn eseguirà micca u mudificatu pipelineQuesta hè a cunfigurazione a più sicura!!
lu cunfigurazione più periculosa hè quandu "Eseguite i flussi di travagliu da a furchetta pull request" hè verificatuIn questu casu, listessu per l'utilizatori di lettura è scrittura, Github eseguirà automaticamente u mudificatu. pipeline!! È sta situazione pò esse ancu peghju si "Mandate gettoni di scrittura à i flussi di travagliu da a fork pull requests"È"Mandà sicreti è variabili à i flussi di travagliu da a fork pull requests"sò verificati. Ùn fate micca questu, salvu chì sia chjaramente ghjustificatu!!"
Se "Richiede l'approvazione per a furchetta pull request Flussi di travagliu" hè verificatu, a situazione sopra hè un pocu migliorata: GitHub dumanderà l'approvazione è ùn eseguirà micca u mudificatu pipeline per l'utilizatore di lettura, ma l'eseguirà sempre per un utilizatore di scrittura.

Furchette viste, chì ne dici PR chì venenu da e filiali?
PR da rami
Per prutege stu scenariu, duvete fidàvi di Regole di Prutezzione di e Filiali.
À u livellu di u repositoriu, pudete creà regule di prutezzione di e branche per qualsiasi branca. Queste regule aghjunghjenu qualchì vincoli à a mudificazione di e branche prutette.
Ancu s'è vo cunfigurate una regula per "Richiede a pull request prima di a fusione"È"Richiede appruvazioni" u mudificatu pipeline serà eseguitu automaticamente dopu a creazione di PRL'"approvazione" s'applicherà solu à l'azione di fusione.

Chì ne dici di l'avvelenamentu indirettu Pipeline esicuzzioni
Cum'è avemu vistu sopra, u D-PPE pò esse mitigatu aduprendu pull_request_target, ma ella ùn s'applica micca à l'I-PPE.
Sè vo aduprate pull_request_target, u checkout predefinitu serà u codice di basa. Ma sè vo vulete validà alcune verifiche nantu à u codice cuntribuitu (codice PR), avete bisognu di verificà esplicitamente u codice PR. Dunque, sè u codice PR hà mudificatu qualsiasi script di shell invucatu da pipeline, a "basa" (sicura) pipeline invucarà u script di shell "mudificatu" → PPE indirettu!!
A suluzione à questu hè un pocu più cumplicata (ùn ci hè micca una palletta magica cum'è pull_request_target).
U nostru pipeline hè avà sicuru per D-PPE perchè usemu pull_request_target. Ma hè sempre vulnerabile à I-PPE.
In u nostru esempiu di prova, avemu bisognu di verificà u codice PR basicamente per fà a custruzzione, ma i testi sò eseguiti nantu à l'artefattu generatu da a custruzzione.
Cusì .. Perchè ùn verificate micca e duie basi di codice?
- Codice PR di checkout perchè hè u codice cuntribuitu ciò chì vulemu custruisce è pruvà
- Codice di basa di checkout per eseguisce a versione originale di u pipeline è i script di compilazione/test
Questu puderia esse fattu da verificendu quelle basi di codice in diverse cartelle: u codice di basa puderia esse estrattu in u cartulare principale, è u PR in un cartulare differente. In questu casu, eseguiremu u script di compilazione è di prova da u cartulare principale contr'à u codice piazzatu in u novu cartulare.
Questa hè una suluzione faciule, benintesa!! Ma, per scopi d'apprendimentu, vogliu presentà una variante abbastanza interessante (…)
GitHub esecuzione_di_flussu_di_flussu avvenimentu scatenante
In più pull_request_target, GitHub furnisce un altru avvenimentu trigger: esecuzione_di_flussu_di_flussuQuestu avvenimentu permette esecuzione di un pipeline cundiziunatu à un altru pipelinel'esecuzione di.
esecuzione_di_flussu_di_flussu e pull_request_target I trigger sò simili in un aspettu: tramindui seranu eseguiti in modu privilegiatu è, malgradu e mudificazioni di e PR, a basa pipeline serà esecutatu !!
Videmu u nostru attuale pipeline:
name: PR TARGET CI
on:
pull_request_target:
branches: [ main ]
env:
MY_SECRET: ${{ secrets.MY_SECRET }}
jobs:
prt_build_test_and_merge:
runs-on: ubuntu-latest
steps:
# checkout PR code
- name: Checkout repository
uses: actions/checkout@v4
with:
# This is to get the PR code instead of the repo code
ref: ${{ github.event.pull_request.head.sha }}
# Simulation of a compilation
- name: Building ...
run: |
mkdir ./bin
touch ./bin/mybin.exe
ls -lR
# Simulation of running tests
- name: Running tests ...
id : run_tests
run: |
echo Running tests..
chmod +x runtests.sh
./runtests.sh
echo Tests executed.
#
# Let’s omit the check conditions at this moment …
#
- name: pr_check_conditions_to_merge
[...]
A sezione di custruzzione hè sicura per D-PPE, ma a sezione di prova hè sempre vulnerabile à I-PPE.
lu pipeline stessu hè sicuru per D-PPE per via di u pull_request_target trigger. Ma u passu di prova hè sempre vulnerabile à I-PPE per via di l'invocazione di un script di shell esternu.
Evità l'I-PPE
U scopu di ciò chì hè statu dettu sopra pipeline hè di custruisce è pruvà u codice cuntribuitu, essendu sicuru per PPE.
Cusì .. Perchè ùn si divide micca pipeline in dui ? Unu per a custruzzione è un altru per a prova..
- U 1u pipeline (Custruisce CI) averia verificate u codice PR (per custruisce lu), fà a custruzzione è generà un artefattu.
- U 2nd pipeline (Test CI) averia verificate u codice di basa (per evità a mudificazione di u script di shell) è eseguisce i scripts originali contr'à l'artefattu.
- Per sincronizà u CI di prova pipeline da eseguisce DOPU a Custruzzione CI pipeline, useremu u esecuzione_di_flussu_di_flussu grillu.

In questu modu:
- pipeline Custruisce CI is sicuru a tramindui D-PPE (à causa di pull_request_target) è I-PPE (perchè ùn esegue più u script di shell).
- pipeline Test CI hè dinù sicuru a tramindui D-PPE (à causa di esecuzione_di_flussu_di_flussu) è I-PPE (perchè verifica u codice di basa per ottene u script di shell originale)
Videmu u codice di tramindui pipelinesecondu ste mudificazioni …
1st pipeline (Custruisce CI):
name: Build CI
on:
pull_request_target:
branches: [ main ]
env:
MY_SECRET: ${{ secrets.MY_SECRET }}
GITHUB_PAT: ${{ secrets.GH_PAT }}
jobs:
prt_build_and_upload:
runs-on: ubuntu-latest
steps:
- name: Checking out PR code
uses: actions/checkout@v4
if: ${{ github.event_name == 'pull_request_target' }}
with:
# This is to get the PR code instead of the repo code
ref: ${{ github.event.pull_request.head.sha }}
- name: Building ...
run: |
mkdir ./bin
touch ./bin/mybin.exe
# Save some PR info for later use by the 2nd pipeline
echo "${{github.event.pull_request.title}}" > ./bin/PR_TITLE.txt
echo "${{github.event.number}}" > ./bin/PR_ID.txt
# Upload the binary as a pipeline artifact
- name: Archive building artifacts
uses: actions/upload-artifact@v3
with:
name: archive-bin
path: |
bin
2nd pipeline (Test CI):
ame: Test CI
on:
workflow_run:
workflows: [ 'PR TARGET CI' ]
types: [completed]
env:
MY_SECRET: ${{ secrets.MY_SECRET }}
GITHUB_PAT: ${{ secrets.GH_PAT }}
jobs:
deploy:
runs-on: ubuntu-latest
if: ${{ github.event.workflow_run.conclusion == 'success' }}
steps:
# By default, checks out base code (not PR code)
- name: Checkout repository
uses: actions/checkout@v4
# Download the artifact
- name: 'Download artifact'
uses: actions/github-script@v6
with:
script: |
let allArtifacts = await github.rest.actions.listWorkflowRunArtifacts({
owner: context.repo.owner,
repo: context.repo.repo,
run_id: context.payload.workflow_run.id,
});
let matchArtifact = allArtifacts.data.artifacts.filter((artifact) => {
return artifact.name == "archive-bin"
})[0];
let download = await github.rest.actions.downloadArtifact({
owner: context.repo.owner,
repo: context.repo.repo,
artifact_id: matchArtifact.id,
archive_format: 'zip',
});
let fs = require('fs');
fs.writeFileSync(`${process.env.GITHUB_WORKSPACE}/myartifact.zip`, Buffer.from(download.data));
# Unzip the artifact
- name: 'Unzip artifact'
run: |
unzip -o myartifact.zip
# Runs tests
- name: Running tests ...
id : run_tests
run: |
echo Running tests..
chmod +x runtests.sh
./runtests.sh
echo Tests executed.
#
# Let’s omit the check conditions at this moment …
#
- name: pr_check_conditions_to_merge
[...]
Wow… bella suluzione!! Ma….. Semu sicuri ? Temu chì innò 😭
Infatti, avemu introduttu una nova vulnerabilità!! Quale? Questu serà u sughjettu di u nostru prossimu post 🙂 … Restate sintonizzati!!
PS: Scusate, ùn possu stà zittu 🤐 ..Avete intesu parlà di Avvelenamentu da artefatti ? 😂







