Direct naar de inhoud
Cybersecurity

AI-chips via remote access blokkeren: beter dan pinnen

AI-chips via remote access blokkeren

Veel securityteams zien SHA pinning in GitHub Actions als het sluitstuk tegen software supply chain-aanvallen. Je koppelt een workflow immers aan een exact code-commit, zodat die code tijdens het draaien niet meer “zomaar” verandert. Toch laten recente incidenten zien dat aanvallers die bescherming kunnen omzeilen.

In dit artikel zetten we de belangrijkste inzichten op een rij: wat pinnen wél vastlegt, waar de echte vertrouwens-kloof zit, en hoe je je CI/CD-aanpak concreet verbetert. Daarbij leggen we ook uit waarom het beperken van toegang—zoals AI-chips via remote access blokkeren—een nuttige aanvulling kan zijn op technische hardening in je omgeving.

SHA pinning: waarom het logisch klinkt

Het idee achter SHA pinning is eenvoudig. GitHub Actions kun je vastzetten op een specifieke commit (een SHA). Daardoor zou een workflow niet kunnen wisselen naar andere code als tags later worden verplaatst. In de praktijk is dat een krachtige stap tegen aanvallen waarbij een referentie wordt omgeleid.

Bovendien kan GitHub tegenwoordig org-breed beleid afdwingen, zodat teams minder snel “per ongeluk” terugvallen op minder strikte instellingen. Dat maakt pinning makkelijk schaalbaar.

Maar pinnen bewijst niet wie je code heeft geschreven

De kern van het probleem is dat immutability niet hetzelfde is als provenance—oftewel: vastgelegde code betekent nog niet dat je ook zeker weet van wie die code afkomstig is. Een SHA zegt vooral iets over de inhoud, niet over de identiteit van de auteur of de intentie.

Daarmee wordt duidelijk hoe aanvallers alsnog misbruik kunnen maken. Ze kunnen een commit voorbereiden die er “onschuldig” uitziet, bijvoorbeeld als een zogenoemde security fix, en die vervolgens laten lijken alsof die hoort bij een legitiem GitHub checkout-mechanisme.

In de broncontext wordt beschreven dat aanvallers dit mechanisme al toepasten in verschillende situaties: eerst bij een open-source beveiligingsscanner (Trivy) en later bij een veelgebruikte action voor issues. Het resultaat: workflows die gepinde checks doorstaan, voeren toch schadelijke code uit.

Fork-netwerken maken “nep-legitimiteit” mogelijk

Een belangrijke reden dat dit kan werken, is de manier waarop GitHub repositories en kopieën (forks) met elkaar delen. Doordat code via repository-relaties kan worden gedeeld, kan een commit afkomstig uit een fork in de praktijk toch als referentie worden gebruikt.

Met andere woorden: zelfs als je een SHA vastlegt, kan die SHA nog steeds verwijzen naar een commit die niet afkomstig is van het upstream project—maar wel dezelfde code bevat die aanvallers willen laten draaien.

Drie onbeantwoorde vragen bij pinning

Zelfs als je perfect pinning toepast, blijven er drie vragen open. Die komen terug in het webinar-concept uit de bron.

  • Authorship: een SHA vertelt niet wie de commit heeft gemaakt. Elke fork-variant kan in principe worden gepind.
  • Projectmembership: org-brede handhaving checkt vaak vooral of de referentie een SHA-achtige lengte/format heeft, niet of de commit ook echt binnen de gewenste upstream context valt.
  • Runtime gedrag: een action die gepind is op een SHA kan tijdens het draaien nog steeds een container of dependencies bouwen/halen. Daardoor kan runtime gedrag alsnog variëren, ook als de actie zelf “immutabel” is.

Juist nu er meer “agentic” development en snellere CI/CD cycli bestaan, worden die gaten vaker geactiveerd en minder kritisch beoordeeld.

Workflow lockfiles: vooruitgang, maar geen eindstation

GitHub werkt aan een roadmap waarbij deterministic dependency locking centraal staat. Volgens de bron zijn workflow lockfiles in public preview gekomen op 14 oktober en algemeen beschikbaar geworden op 28 oktober 2026.

De belofte: elke run wordt gekoppeld aan vastgelegde commits voor actions én hun transitive dependencies. Zelfs als een tag later wordt verplaatst, blijft het uitgevoerde pad deterministisch.

Dat helpt tegen een deel van de supply chain-variatie—met name omdat locked commits moeten bestaan binnen een branch van het bronrepository. Dat kan fork-only impostors afremmen.

Maar: GitHub’s eigen changelog maakt ook duidelijk dat locking niet automatisch “veiligheid” bepaalt. Met andere woorden: je krijgt consistentie, maar nog geen garantie dat de code inhoudelijk veilig is of van de juiste bron komt.

Daarnaast wordt genoemd dat workflow lockfiles (nog) niet worden ondersteund op GitHub Enterprise Server. Dat betekent dat teams die daar draaien, extra moeten kijken naar alternatieve hardening.

Wat je zelf kunt doen om de vertrouwenskloof te dichten

Als pinning niet “het hele verhaal” vertelt, heb je meerdere verdedigingslagen nodig. Denk aan controles die verder gaan dan “de SHA is vast”.

Maak provenance onderdeel van je beleid

Focus op wie iets mag leveren aan je pipeline. Dat kan via het gebruik van een geautoriseerde catalog met vetted actions, gecombineerd met striktere checks op repository-herkomst en permissies.

In de bron wordt ook benadrukt dat authorship en projectmembership niet automatisch gegarandeerd zijn door SHA-formats.

Beperk runtime onzekerheid

Controleer niet alleen de action-artefacten, maar ook wat er tijdens runtime gebeurt. Wordt er tijdens de run nog gebouwd of worden er dependencies opgehaald? Als dat kan, vergroot je de kans dat je alsnog iets binnenhaalt dat je niet eerder hebt gefixeerd.

Hier past ook het bredere securityprincipe: waar je runtime gedrag kunt beperken, doe dat. Dat geldt niet alleen voor GitHub Actions, maar ook voor omgevingsconnectiviteit.

Waarom “AI-chips via remote access blokkeren” kan helpen als aanvullende laag

Veel organisaties koppelen DevOps en security steeds vaker aan AI-werklasten. In zo’n omgeving is het cruciaal om te voorkomen dat systemen die AI kunnen versnellen (bijvoorbeeld via gespecialiseerde hardware of accelerators) ongeautoriseerd remote bereikbaar zijn.

AI-chips via remote access blokkeren is geen vervanging voor supply chain hardening, maar wél een praktische extra laag. Het verkleint het aanvalsvlak wanneer een pipeline of runtime omgeving toch misbruikt wordt: minder externe routes betekent minder mogelijkheden om lateraal te bewegen of data/compute te kapen.

Gebruik dit als onderdeel van je bredere CI/CD security aanpak: beperk netwerktoegang, bewaak administratieve poorten en hanteer least privilege voor systemen die bouw-, scan- of deploystappen uitvoeren.

Wie heeft hier het meeste belang bij?

De bron beschrijft dat het webinar zich richt op platform- en DevOps-teams die CI/CD beheren, AppSec en DevSecOps teams die pipeline policy schrijven, en securityleiders die SHA pinning als “klaar” hebben bestempeld.

Als jouw workflows derdepartij-actions gebruiken of als je platform in hoge mate afhankelijk is van tooling in de pipeline, dan is de kans groot dat je een deel van de vertrouwenskloof (authorship, membership, runtime) nog niet volledig afdekt.

Conclusie: pinnen is een begin, niet de finish

SHA pinning blijft waardevol omdat het codeverandering door omleiding of tag-misbruik kan afremmen. Maar het lost niet automatisch het grootste probleem op: je weet niet zeker wie de code levert, noch hoe runtime gedrag zich gedraagt.

Met workflow lockfiles zet GitHub een belangrijke stap richting deterministische runs, al geldt ook hier: consistentie is geen garantie voor veiligheid. Daarom is een gelaagde aanpak nodig—met beleid dat provenance meeneemt, runtime onzekerheid beperkt en waar mogelijk ook toegang tot kritieke resources, zoals AI-chips via remote access blokkeren.

Wil je verder lezen over hoe supply chain risico’s en pipeline-aanvallen zich in de praktijk manifesteren? Bekijk dan ook eens AI-agenten in exploits: sneller misbruik van patches en Cursor supply chain aanval via Fireworks AI.

Bron: https://thehackernews.com/2026/11/hackers-found-way-around-github-sha.html