138% fler rapporterade CVE:er per dag 2026 än förra året.Nytt: alltid aktiva Fixboxes. Sårbara beroenden, åtgärdade och verifierade.

CI/CD-säkerhet

Säkerhet i GitHub Actions: en checklista för att härda dina arbetsflöden

Ett arbetsflöde i GitHub Actions kör kod från många upphovspersoner med ditt repos token, dina hemligheter och en väg till produktion. De flesta kontroller som håller det säkert är inbyggda i GitHub, men som standard är de avstängda, för generösa eller lätta att göra fel. Den här checklistan går igenom var och en: vad du ska ställa in, varför det spelar roll och incidenten som visar vad som händer utan den.

Uppdaterad

Checklistan i korthet

Punkt Vad den stoppar
GITHUB_TOKEN med minsta behörighet Att ett kapat steg pushar kod, publicerar releaser eller startar andra arbetsflöden
Lås actions från tredje part till en commit eller i en lockfile Att en flyttad tagg kör en angripares kod i ditt jobb
Behandla pull_request_target och workflow_run som privilegierade Pwn requests: kod från en fork som körs med dina hemligheter
Håll händelsedata borta från run-skript Skriptinjektion via titlar, branchnamn och kommentarer
OIDC i stället för lagrade molnnycklar Långlivade inloggningsuppgifter som fungerar i åratal efter att de läckt
Miljöer med obligatoriska granskare Att vilken branch eller vilket arbetsflöde som helst läser produktionshemligheter
Kodägare för .github/workflows Ogranskade ändringar av vad pipelinen kör
Policy för tillåtna actions Okända eller olåsta actions var som helst i organisationen
Inga egenhostade runners på publika repon Att främlingar kör kod på dina maskiner
Hygien för cachar och artefakter Förgiftade cachar och tokens som läcker via uppladdningar
Egress-kontroll på runners Att stulna hemligheter skickas till en angripares server
En registrering av varje körning Att inte veta vilka byggen som körde en komprometterad action eller ett komprometterat paket

Arbetsflödeskod

1. Ge GITHUB_TOKEN minsta möjliga behörighet

Varje jobb får en GITHUB_TOKEN, och vilket steg som helst i jobbet kan använda den. Repon och organisationer som skapades före februari 2023 kan fortfarande ha läs- och skrivrätt på varje behörighet som standard. Sätt standarden till skrivskyddad under Settings → Actions → General → Workflow permissions och ge sedan skrivrätt per jobb:

permissions:
  contents: read

jobs:
  release:
    runs-on: ubuntu-latest
    permissions:
      contents: write
    steps:
      - uses: actions/checkout@<full-commit-sha>

Allt du inte listar blir none. För varje behörighet och vad vanliga uppgifter behöver, se GITHUB_TOKEN-behörigheter: minsta behörighet för varje arbetsflöde.

2. Lås actions från tredje part till en commit, eller i en lockfile

En tagg som @v4 är en pekare som actionens ägare, eller vem som helst som stjäl deras åtkomst, kan flytta. Två incidenter visar vad det innebär:

  • tj-actions/changed-files, mars 2025. En angripare ändrade befintliga versionstaggar så att de pekade på en skadlig commit (CVE-2025-30066). Actionen användes av fler än 23 000 repon, och nyttolasten skrev ut hemligheter från runnerns minne i arbetsflödesloggarna, som vem som helst kan läsa i ett publikt repo.
  • aquasecurity/trivy-action, mars 2026. Aqua Securitys säkerhetsmeddelande (CVE-2026-33634) anger att 76 av actionens 77 versionstaggar force-pushades till skadliga commits. Den injicerade koden kördes före den riktiga skanningen, läste hemligheter från runnerns minne och skickade dem, krypterade, till angriparens infrastruktur.

Arbetsflöden som refererade till en fullständig commit-SHA fortsatte att köra samma kod som tidigare. Behåll versionen som en kommentar:

steps:
  # Mutable: whoever controls the tag decides what runs
  - uses: tj-actions/changed-files@v45
  # Immutable: a full commit SHA, with the version as a comment
  - uses: tj-actions/changed-files@<full-commit-sha> # v46.0.1

Kontrollera att SHA:n kommer från actionens eget repo, inte från en fork. GitHub erbjuder nu något starkare: lockfiler för arbetsflödesberoenden, allmänt tillgängliga sedan den 28 oktober 2026. CLI-tillägget gh actions-lock skriver .github/workflows/actions.lock, som registrerar exakt commit för varje action som dina arbetsflöden använder, inklusive de actions som de i sin tur anropar, och GitHub kontrollerar vid körning att varje källrepo fortfarande är det du låste. Anrop till återanvändbara arbetsflöden omfattas inte, så lås dem med SHA. Administratörer kan kräva en lockfile via policy. Varken SHA-låsning eller en lockfile gör en action säker: granska det du låser.

Låsta actions uppdaterar sig inte själva. Låt Dependabot föreslå uppdateringar, med en cooldown så att en ny release hinner upptäckas under några dagar innan den når dig:

# .github/dependabot.yml
version: 2
updates:
  - package-ecosystem: "github-actions"
    directory: "/"
    schedule:
      interval: "weekly"
    cooldown:
      default-days: 7

3. Behandla pull_request_target och workflow_run som privilegierade

Ett pull_request-arbetsflöde från en fork får en skrivskyddad token och inga hemligheter. Ett pull_request_target-arbetsflöde körs i basrepots kontext, med dess hemligheter och en token som kan skriva, även när pull requesten kommer från en fork. Det är säkert bara så länge arbetsflödet aldrig kör kod från pull requesten. Checka ut pull requestens head och bygg den, så körs varje installationsskript och test i den pull requesten med dina hemligheter. GitHub Security Lab kallar dem pwn requests.

  • Använd pull_request för allt som bygger eller testar bidragen kod.
  • Om ett privilegierat steg måste följa, till exempel en kommentar på pull requesten, dela upp det: ett oprivilegierat pull_request-arbetsflöde laddar upp sina resultat som en artefakt, och ett workflow_run-arbetsflöde agerar på dem. Behandla de artefakterna som opålitlig indata, aldrig som kod att köra.
  • I publika repon utan en händelsepolicy blockerar GitHub pull_request_target som standard från den 2 december 2026. Om du tillåter det igen, tillåt bara de arbetsflöden som behöver det.

Intrånget hos TanStack i maj 2026 började just så: ett pull_request_target-arbetsflöde körde kod från en fork, som förgiftade cachen som ett release-arbetsflöde senare återställde, och en OIDC-token som lästes från runnerns minne användes för att publicera 84 skadliga versioner av 42 paket.

4. Håll händelsedata borta från run-skript

Uttryck expanderas innan skalet körs, så en pull request-titel, ett branchnamn, en issue-text eller ett commit-meddelande i run blir en del av skriptet. Vem som helst som kan öppna en pull request eller ett issue kan då köra kommandon i ditt jobb. Skicka värdet via en miljövariabel, så behandlar skalet det som data:

# Vulnerable: the title is pasted into the script before the shell runs
- run: echo "Checking ${{ github.event.pull_request.title }}"

# Safe: the shell reads the title as data
- env:
    PR_TITLE: ${{ github.event.pull_request.title }}
  run: echo "Checking $PR_TITLE"

Detsamma gäller actions/github-script och värden som skrivs till GITHUB_ENV. AI-agenter i arbetsflöden tillför en ny form av samma problem: text i ett issue kan styra agenten i stället för skalet. Se prompt injection.

Hemligheter och driftsättningar

5. Använd OIDC i stället för långlivade molnnycklar

En åtkomstnyckel till molnet som lagras som hemlighet fungerar tills någon roterar den, vilket efter en läcka ofta är för sent. Med OpenID Connect ber jobbet GitHub om en kortlivad token och byter den hos AWS, Azure eller Google Cloud, vars förtroendepolicy avgör vilket repo, vilken branch eller vilken miljö som får anta rollen:

jobs:
  deploy:
    runs-on: ubuntu-latest
    environment: production
    permissions:
      contents: read
      id-token: write
    steps:
      - uses: aws-actions/configure-aws-credentials@<full-commit-sha>
        with:
          role-to-assume: arn:aws:iam::123456789012:role/deploy
          aws-region: us-east-1

En kortlivad token kan fortfarande stjälas från ett jobb som körs, som TanStack visade, men den är värd mycket mindre än en nyckel som aldrig går ut. Skicka de hemligheter du ändå behåller till det steg som behöver dem i stället för till hela jobbet, så att andra actions i jobbet inte kan läsa dem. Hur hemligheter läcker och resten av kontrollerna finns i hemligheter i GitHub Actions: hur de läcker och hur du låser in dem.

6. Lägg produktion bakom miljöer med obligatoriska granskare

En miljö har sina egna hemligheter, och ett jobb som anger den kan inte läsa dem förrän en obligatorisk granskare godkänner körningen. Regler för driftsättningsbrancher begränsar vilka brancher som över huvud taget får använda den. Ett arbetsflöde på en feature-branch, eller ett som startas av en pull request, har då ingen väg till produktionens inloggningsuppgifter.

Styrning

7. Kräv granskning av kodägare för arbetsflödesfiler

En arbetsflödesfil avgör vad som körs med dina hemligheter, så en ändring i den förtjänar samma granskning som en ändring av åtkomst till produktion. Lägg till mappen i CODEOWNERS och kräv granskning av kodägare i en branch ruleset:

/.github/workflows/ @example-org/platform-security
/.github/actions/ @example-org/platform-security

8. Begränsa vilka actions som får köras

På enterprise-, organisations- eller repo-nivå kan policyn för tillåtna actions begränsa actions till dem från GitHub, verifierade skapare eller en lista som du underhåller. Sedan augusti 2025 kan den också kräva SHA-låsning, så att ett arbetsflöde som använder en olåst action misslyckas, och blockera en specifik action eller version med en !-post, vilket hjälper den dag en action du använder rapporteras som komprometterad.

Runners, cachar och artefakter

9. Håll egenhostade runners borta från publika repon

GitHubs referens för säker användning säger att egenhostade runners nästan aldrig bör användas för publika repon, eftersom vem som helst kan öppna en pull request och köra kod på dem. På privata repon, använd runners som startar på nytt för varje jobb: en långlivad runner behåller det ett jobb lämnar efter sig till nästa, inklusive en bakdörr. npm-masken Shai-Hulud registrerade infekterade maskiner som egenhostade runners av just det skälet. Se hanterade vs egenhostade runners.

10. Skydda cachar mot förgiftning

Cachar avgränsas per branch, och cachar som sparas på standardbranchen kan återställas av alla andra brancher. Kod som körs i vilket arbetsflöde som helst på standardbranchen kan därför skriva cacheposter som ett release-arbetsflöde senare återställer, utan att behöva en token med skrivrätt. Håll opålitlig kod borta från arbetsflöden på standardbranchen, undvik att återställa cachar i release- och publiceringsjobb och bygg i stället från en lockfile där. Se hur cachen i GitHub Actions fungerar.

11. Hantera artefakter som opålitliga

actions/checkout behåller token på disk för senare git-kommandon om du inte stänger av det. Att ladda upp arbetskatalogen som en artefakt har läckt den token tidigare. Sätt persist-credentials: false på utcheckningar som inte pushar, ladda bara upp de sökvägar du behöver och kör aldrig en artefakt från en pull request i ett privilegierat arbetsflöde:

- uses: actions/checkout@<full-commit-sha>
  with:
    persist-credentials: false

Nätverk och registreringar

12. Styr vart jobb kan ansluta

GitHub-hostade runners begränsar inte utgående trafik, så kod i ett jobb kan skicka det den läser vart som helst. De flesta jobb behöver en kort lista med destinationer: paketregister, containerregister, källvärdar och några API:er. Tillåt dem och blockera resten, så har en stulen hemlighet ingenstans att ta vägen, även vid en attack som ingen har sett tidigare. En egress-policy stoppar inte hemligheter som skrivs ut i loggar, som i fallet tj-actions, och därför hör den hemma bredvid SHA-låsning, inte i stället för den. Se hur en egress-policy stoppar exfiltrering från GitHub Actions.

13. Registrera vilka actions och paket varje körning använde

När nästa komprometterade action eller paket tillkännages är den första frågan vilka av dina körningar som använde det. En arbetsflödesfil säger vad en körning var tänkt att använda. En tagg, ett versionsintervall eller en cacheträff kan göra svaret annorlunda, och den registrering som avgör saken är den som togs medan jobbet kördes: commiten för varje action, varje paket som hämtades eller återställdes från en cache och de anslutningar som jobbet gjorde. Se SBOM:er i GitHub Actions.

Gratis verktyg som granskar dina arbetsflöden

De flesta av arbetsflödespunkterna ovan kan kontrolleras automatiskt. De här verktygen läser arbetsflödesfiler; de bevakar inte ett jobb medan det körs.

Verktyg Vad det kontrollerar
zizmor Statisk analys av konfigurationen för GitHub Actions, Dependabot och pre-commit: mallinjektion, farliga triggers, för breda behörigheter, olåsta actions, falska commits, cacheförgiftning och inloggningsuppgifter som lämnats kvar av checkout
actionlint En linter för arbetsflödessyntax och uttryck som också flaggar opålitliga värden i inline-skript och kör shellcheck på run-steg
OpenSSF Scorecard Repokontroller, bland annat Dangerous-Workflow (opålitliga utcheckningar och skriptinjektion), Token-Permissions och Pinned-Dependencies
poutine BoostSecuritys skanner med öppen källkod för byggpipelines, som täcker GitHub Actions, GitLab, Azure DevOps och Tekton och kan skanna alla repon i en organisation
CodeQL GitHubs kodskanning, som har analyserat arbetsflöden efter injektion och pwn request-mönster sedan 2025

Kör något av dem i pull requests som rör .github/. För hur de passar ihop med runnerkontroller och verktyg för säkerhetsläge, se CI/CD-säkerhetsverktyg i jämförelse och CI/CD-säkerhet. För en checklista som täcker hela pipelinen i stället för inställningar i GitHub Actions, se säkerhetschecklistan för CI/CD-pipelines.

Så hjälper CRACI

CRACI ersätter runnern, inte GitHub Actions: du ändrar runs-on till craci, och arbetsflödena, hemligheterna, tokenbehörigheterna och körningshistoriken stannar i GitHub. Det täcker de sista punkterna på listan, de som sker medan ett jobb körs:

  • Egress-kontroll. En egress-policy avgör vilka paketkällor, register och värdar ett jobb får nå. Den valideras innan jobbet startar, upprätthålls i runnern och blockerar vid fel, och en blockerad anslutning utlöser en varning.
  • En registrering av varje körning. Jobbets SBOM listar de GitHub Actions som det körde som pkg:github-komponenter låsta till den commit som användes, och varje paket det hämtade, inklusive paket som återställts från en cache, med en spårning av dess nätverksanslutningar. När en actions taggar flyttas kan du se vilken commit varje körning faktiskt körde.
  • Policykontroller. Ett bygge som drar in ett paket med en känd sårbarhet, inklusive en specifik CVE, kan stoppas.
  • Isolering. Varje jobb körs i en egen virtuell maskin, så inget följer med till nästa.

CRACI granskar inte dina arbetsflödesfiler, skannar inte källkod och söker inte efter hemligheter, så behåll en linter för arbetsflöden som zizmor, GitHubs hemlighetsskanning och ditt SAST-verktyg för det. CRACI kör GitHub Actions-jobb på Linux, och andra CI-system finns på roadmapen.

Säkerhet i GitHub Actions: vanliga frågor

Hur säkrar jag GitHub Actions?

Sätt GITHUB_TOKEN till skrivskyddad och ge skrivrätt per jobb, lås actions från tredje part till en commit eller i en lockfile, undvik att köra kod från pull requests i pull_request_target-arbetsflöden, skicka händelsedata till skript via miljövariabler, använd OIDC i stället för lagrade molnnycklar, lägg produktionshemligheter bakom miljöer, kräv granskning av arbetsflödesfiler och styr vad jobb kan ansluta till.

Ska jag låsa GitHub Actions till en commit-SHA?

Ja, för actions från tredje part. En tagg kan flyttas till annan kod, som hände med tj-actions/changed-files 2025 och trivy-action 2026, medan en fullständig commit-SHA inte kan det. GitHubs lockfiler för arbetsflöden går längre och låser även de actions som dina actions anropar.

Är pull_request_target farligt?

Det är säkert bara om arbetsflödet aldrig kör kod från pull requesten. Det körs med basrepots hemligheter och en token med skrivrätt även för forks, så att bygga kod från en fork i det ger båda till den som öppnade pull requesten. GitHub blockerar det som standard i publika repon utan en händelsepolicy från den 2 december 2026.

Vad är en pwn request?

GitHub Security Labs namn på ett privilegierat arbetsflöde, oftast startat av pull_request_target, som checkar ut och kör opålitlig kod från en pull request och därmed ger upphovspersonen åtkomst till arbetsflödets hemligheter och token.

Är lockfiler för arbetsflöden bättre än SHA-låsning?

De är starkare. En lockfile registrerar commiten för varje action som ett arbetsflöde använder, även transitiva, och GitHub kontrollerar källrepots identitet vid körning. Anrop till återanvändbara arbetsflöden omfattas inte, så lås dem med SHA.

Vilka gratis verktyg kontrollerar arbetsflöden i GitHub Actions efter säkerhetsproblem?

zizmor, actionlint, OpenSSF Scorecard och poutine är gratis, och CodeQL kan analysera arbetsflöden som en del av GitHubs kodskanning. De läser arbetsflödesfiler; de styr inte vad ett jobb gör medan det körs.

Se vad ett av dina arbetsflöden faktiskt körde

Kör ett GitHub Actions-jobb på CRACI och få commiten för varje action, varje hämtat paket och en egress-policy som blockerar vid fel.

Boka en demo