Wat is GitLab Container Scanning?

Verhoog de beveiliging en compliance van uw onderneming met GitLab Container Scanning, waarmee u kwetsbaarheden en malware in uw containerimages detecteert voordat u deze implementeert. Automatiseer het scannen, verminder risico's en zorg voor een veilige toeleveringsketen met deze krachtige tool.

GitLab Container Scanning is een essentieel hulpmiddel voor het handhaven van de veiligheid en integriteit van gecontaineriseerde applicaties. Het is steeds belangrijker om vertrouwd te raken met deze techniek en deze toe te passen, nu organisaties steeds vaker kiezen voor containerisatie voor de implementatie van software.

In dit artikel wordt GitLab Container Scanning uitgebreid behandeld, evenals de werking ervan, de ondersteunde containerformaten en hoe best practices en praktijkvoorbeelden kunnen helpen bij het opzetten ervan voor projecten. Met best practices die overal worden benadrukt, biedt deze gids inzicht in GitLab Container Scanning, dat zorgt voor veilige ontwikkelingsprocessen met een soepele workflow.

Inzicht in GitLab Container Scanning

Inzicht in GitLab Container Scanning is essentieel voor iedereen die gecontaineriseerde applicaties wil beveiligen met GitLab of dit wil doen met andere containerisatie platforms zoals Docker. GitLab Container Scanning fungeert als een beveiligingscontrole en controleert elk onderdeel van uw software op kwetsbaarheden die aanvallers zouden kunnen misbruiken – het werkt als een antiviruscontrole op de bouwstenen ervan!

De inspectie omvat een grondige controle van de software in containers om eventuele problemen of potentiële risico's op te sporen. Deze stap is cruciaal bij het ontwikkelen van moderne software. Containers bestaan doorgaans uit verschillende componenten uit meerdere bronnen die allemaal moeten voldoen aan beveiligingsnormen om de integriteit van uw applicatie te behouden.

GitLab Container Scanning kan van onschatbare waarde zijn voor softwareontwikkeling en biedt essentiële bescherming voor gecontaineriseerde softwaretoepassingen. Vroegtijdige identificatie van kwetsbaarheden helpt bij het handhaven van veilige systemen, wat zowel ontwikkelaars als belanghebbenden gemoedsrust geeft.

Hoe werkt GitLab Container Scanning?

GitLab Container Scanning kan automatisch kwetsbaarheden in containerimages identificeren en oplossen, waardoor u erop kunt vertrouwen dat eventuele kwetsbaarheden in deze images snel en betrouwbaar worden aangepakt. Hier volgt een overzicht van de werking ervan:

GitLab Container Scanning kan eenvoudig worden geïntegreerd in de Continuous Integration/Continuous Deployment (CI/CD)-pijplijn, waardoor het scanproces een integraal onderdeel wordt van elke build en push, en niet slechts een op zichzelf staande gebeurtenis. Dit zorgt ervoor dat beveiligingscontroles een doorlopend onderdeel van de ontwikkeling worden, in plaats van iets dat slechts eenmalig wordt uitgevoerd.

Gebruik van kwetsbaarheidsdatabases

Deze tool vergelijkt componenten met bekende kwetsbaarheidsdatabases om bekende kwetsbaarheden te detecteren in softwarepakketten of bibliotheken die in containers worden gebruikt. Hierdoor kunnen bekende bedreigingen die daarin aanwezig kunnen zijn, gemakkelijk worden geïdentificeerd.

Een rapport genereren

GitLab Container Scanning genereert na voltooiing een uitgebreid rapport met een overzicht van alle ontdekte kwetsbaarheden en hun ernstcategorieën, en doet waar nodig suggesties voor oplossingen of mitigatiestrategieën.

Automatische reacties

Met GitLab Container Scanning kunnen gebruikers automatische reacties instellen op basis van de configuratie. dit kan bijvoorbeeld het aanmaken van issues zijn voor ontwikkelingsteams om op te lossen, of zelfs het stoppen van de CI/CD-pijplijn als er kritieke kwetsbaarheden worden ontdekt, om ervoor te zorgen dat er geen onveilige code in productie terechtkomt.

Herstel en continue monitoring

Onze tool voor continue monitoring helpt bij voortdurend herstel door containerupdates continu te scannen zodra ze binnenkomen, automatisch te controleren op kwetsbaarheden die kunnen ontstaan wanneer wijzigingen worden doorgevoerd, en te zorgen voor voortdurende bescherming tegen nieuwe kwetsbaarheden die in de loop van de tijd ontstaan.

Ondersteunde containerindeling voor GitLab

Wanneer we verwijzen naar GitLab's ondersteuning voor het scannen van bepaalde containerformaten, bedoelen we het onderzoeken van hun specifieke structuur en de indeling van de gegevens daarin. De scantools Trivy en Grype bieden uitgebreide ondersteuning voor verschillende Linux-distributies, zodat kwetsbaarheden snel in verschillende omgevingen kunnen worden geïdentificeerd.

Open-source scantools:

• Trivy (een open-source kwetsbaarheidsscanner voor containers en besturingssystemen): Trivy is een gevestigde open-source kwetsbaarheidsscanner die speciaal is afgestemd op containers en besturingssystemen. Het biedt lichtgewicht maar grondige scanmogelijkheden om kwetsbaarheden in veel Linux-distributies te identificeren.

• Grype: Grype biedt nauwkeurige kwetsbaarheidsgegevens over containerimages. Als analysetool vult Grype Trivy aan door beveiligingsrisico's grondig te onderzoeken met nauwkeurige maar bruikbare kwetsbaarheidsgegevens.

Ondersteunde Linux-distributies

Het is van het grootste belang om het verschil tussen containerformaat en distributies te begrijpen. Containers slaan gegevens op in containers, terwijl distributies verwijzen naar verschillende varianten van het Linux-besturingssysteem die door de Trivy- en Grype-services van GitLab worden ondersteund. GitLab ondersteunt een indrukwekkende lijst van distributies; hier volgt een kort overzicht:

• Alma Linux: gescand met Trivy
• Alpine Linux: ondersteund door zowel Grype als Trivy
• Amazon Linux: ondersteund door zowel Grype als Trivy
• BusyBox: gescand door Grype
• CentOS: ondersteund door zowel Grype als Trivy
• CBL-Mariner: gescand met Trivy
• Debian: ondersteund door zowel Grype als Trivy
• Distroless: ondersteund door zowel Grype als Trivy
• Oracle Linux: Ondersteund door zowel Grype als Trivy
• Photon OS: Gescand door Trivy
• Red Hat (RHEL): Ondersteund door zowel Grype als Trivy
• Rocky Linux: gescand met Trivy
• SUSE: gescand door Trivy
• Ubuntu: ondersteund door zowel Grype als Trivy

Het belang van brede distributieondersteuning

Bij GitLab Container Scanning begrijpen we dat brede distributieondersteuning steeds belangrijker wordt naarmate gecontaineriseerde applicaties populairder worden bij ontwikkelaars, die vaak verschillende Linux-distributies kiezen op basis van prestaties, beveiliging, compatibiliteit of persoonlijke voorkeur. Door meerdere distributies tegelijkertijd te ondersteunen, zorgt GitLab Container Scanning ervoor dat ontwikkelaars de applicatiebeveiliging kunnen blijven handhaven, ongeacht de gekozen omgeving. Dit versterkt onze toewijding om holistische beveiliging te bieden voor gecontaineriseerde workloads.

Hoe stel je GitLab in voor containerscanning?

Het implementeren van GitLab voor containerscanning is een efficiënt proces dat automatische kwetsbaarheidsscans voor je gecontaineriseerde applicaties mogelijk maakt. Hier volgt een algemeen overzicht van hoe je dit kunt bereiken:

1. Containerscanning inschakelen via een automatisch samenvoegingsverzoek

Met GitLab 14.9 kunt u containerscanning eenvoudig en snel inschakelen via een automatisch samenvoegingsverzoek. zo gaat u te werk:

• Navigeer naar het gewenste project.
• Ga naar Beveiliging > Beveiligingsconfiguratie.
• Selecteer in de rij Containerscannen de optie Configureren met een samenvoegverzoek.

Zodra dit proces is geactiveerd, wordt er automatisch een samenvoegverzoek gegenereerd met alle wijzigingen die nodig zijn om containerscannen in te schakelen. Controleer dit verzoek voordat u het samenvoegt om de configuratie van containerscannen te voltooien.

2. Configuratie via het bestand .gitlab-ci.yml:

Voor handmatige configuratie van containerscanning moet u de relevante sjabloon toevoegen aan uw bestand .gitlab-ci.yml:

include:   - template: Security/Container-Scanning.gitlab-ci.yml

Deze sjabloon voegt een container_scanning-taak toe aan uw CI/CD-pijplijn die Docker-images scant op kwetsbaarheden en de resultaten opslaat als een container-scanningrapport.

Een voorbeeld van een .gitlab-ci.yml-bestand dat Docker-images bouwt en scant, zou er als volgt uit kunnen zien.

include:   - template: Jobs/Build.gitlab-ci.yml   - template: Security/Container-Scanning.gitlab-ci.yml container_scanning:   variabelen:     CS_DEFAULT_BRANCH_IMAGE: $CI_REGISTRY_IMAGE/$CI_DEFAULT_BRANCH:$CI_COMMIT_SHA

3. Instellingen voor containerscannen aanpassen

Met GitLab kunt u het scannen van containers aanpassen aan uw specifieke behoeften, van verbeterde uitvoer en authenticatie met het specifieke register tot het leveren van meer gedetailleerde resultaten.

Om bijvoorbeeld uitgebreide uitvoer in te schakelen, bewerkt u uw .gitlab-ci.yml als volgt:

include:   - template: Security/Container-Scanning.gitlab-ci.yml variabelen:     SECURE_LOG_LEVEL: 'debug'

4. Een afbeelding in een externe registry scannen:

U kunt ook afbeeldingen scannen die zich in een ander register dan de projecten bevinden door de volgende configuratie te gebruiken:

include:   - template: Security/Container-Scanning.gitlab-ci.yml container_scanning:   variabelen:     CS_IMAGE: example.com/user/image:tag

Het instellen van GitLab Container Scanning is een intuïtieve, gebruiksvriendelijke ervaring, van geautomatiseerde merge-verzoeken tot handmatige configuratie. GitLab maakt beveiligingscontroles onderdeel van de ontwikkelingsworkflow van ontwikkelaars met zijn krachtige scantools, waardoor GitLab een essentieel onderdeel is geworden van moderne, veilige softwareontwikkeling.

Best practices voor GitLab Container Scanning

1. Werk scantools regelmatig bij

Het is van cruciaal belang dat scantools zoals Trivy en Grype up-to-date blijven, zodat ze nieuwe kwetsbaarheden kunnen detecteren zodra deze zich voordoen en tegelijkertijd compatibel blijven met eventuele wijzigingen die door ondersteunde distributies worden aangebracht. Regelmatige updates zorgen ervoor dat dit gebeurt.

2. Integreer scannen vroeg in de ontwikkeling

Hoe eerder containerscannen onderdeel wordt van uw ontwikkelingscyclus, hoe eerder kwetsbaarheden kunnen worden geïdentificeerd en verholpen. Door GitLab Container Scanning op te nemen in uw continue integratie (CI) pijplijn zorgt ervoor dat scans automatisch worden uitgevoerd bij elke code-push – ze worden onderdeel van uw ontwikkelingsworkflow en dragen bij aan een snellere identificatie en oplossing van kwetsbaarheden.

3. Scan op maat om aan uw behoeften te voldoen

Niet elk project vereist identieke scans. Door ze aan te passen aan uw projectvereisten – met betrekking tot de mate van gedetailleerdheid, het richten op bepaalde registers of het instellen van variabelen – kan het scannen veel sneller en efficiënter maken. Gebruik de aanpassingsfuncties in het .gitlab-ci.yml-bestand om scans nauwkeurig af te stemmen.

4. Bekijk scanrapporten regelmatig opnieuw en onderneem actie

Het is niet voldoende om alleen scans uit te voeren – de bevindingen moeten ook worden bekeken en direct worden aangepakt. Door de artefacten van het containerscanrapport regelmatig te bekijken en systematisch te corrigeren, worden kwetsbaarheden snel geïdentificeerd en aangepakt. Het integreren van een correctieworkflow in bestaande ontwikkelingsprocessen kan helpen bij deze essentiële correctietaak.

Remediatieworkflow met GitLab Container Scanning

De herstelworkflow van GitLab Container Scanning omvat verschillende stappen die zijn ontworpen om kwetsbaarheden in containerimages te identificeren en deze efficiënt en systematisch op te lossen. Een typische workflow ziet er ongeveer zo uit:

1. Kwetsbaarheden vaststellen: GitLab biedt de functie Container Scanning en beveiligingsscans met Trivy of Grype. Zodra kwetsbaarheden zijn ontdekt, wordt in deze stap een uitgebreid rapport gegenereerd met alle details.
2. Bevindingen analyseren: In deze stap moeten de bevindingen uit de rapporten van de containerscan grondig worden bekeken om details te verkrijgen over de ernst, het type en de bron van kwetsbaarheden die onmiddellijke aandacht vereisen. Door prioriteit te geven aan urgente kwesties die onmiddellijk moeten worden opgelost.
3. Prioritering van herstelmaatregelen: Op basis van deze beoordeling moeten de problemen dienovereenkomstig worden geprioriteerd. Problemen met hoge prioriteit zijn meestal kwetsbaarheden die een onmiddellijke bedreiging vormen voor applicaties, maar factoren als impact en gemak van misbruik kunnen ook een rol spelen.
4. Stel een herstelplan op: Nadat de kwetsbaarheden zijn geprioriteerd, moet een effectief herstelplan worden opgesteld om elke kwetsbaarheid aan te pakken. Dit plan omvat de maatregelen die nodig zijn om elke kwetsbaarheid effectief te verhelpen. Dit kan het installeren van updates, het aanbrengen van wijzigingen of aanpassingen, of het direct wijzigen van delen van de code inhouden.
5. Implementeer oplossingen: Met een plan in de hand moeten herstelmaatregelen worden uitgevoerd met behulp van GitLab-mergeverzoeken die de code, configuratie-instellingen of afhankelijkheden wijzigen die van invloed zijn op de getroffen codebases. Samenwerking tussen ontwikkelaars, beveiligingsteams en andere belangrijke spelers is vaak essentieel om dit proces succesvol te voltooien.
6. Herstelmaatregelen testen: Na het toepassen van fixes is het van cruciaal belang om aanvullende verificatiecontroles uit te voeren om er zeker van te zijn dat ze de kwetsbaarheden succesvol aanpakken zonder nieuwe problemen te creëren. Het opnieuw scannen van containerimages of het uitvoeren van aanvullende tests kan helpen om te verifiëren of de herstelmaatregelen de kwetsbaarheden met succes hebben geëlimineerd en geen nieuwe beveiligingslekken hebben gecreëerd.
7. Monitoring en continue verbetering: Herstelworkflows gebeuren niet van de ene op de andere dag; continue monitoring, scanning en revisie zorgen voor blijvende levensvatbaarheid. Door een iteratieve aanpak te hanteren, wordt de levensvatbaarheid op lange termijn gewaarborgd.

Praktijkvoorbeelden en use cases

1. Bankwezen

Beveiliging in bankapplicaties is van het grootste belang. Traditionele methoden voor het opsporen van kwetsbaarheden schieten vaak tekort als het gaat om tijdige detectie. Door GitLab Container Scanning toe te voegen aan de Continuous Integration/Continuous Deployment-pijplijn voor bankapps, worden realtime inspectie en herstel mogelijk, wat een veel robuustere oplossing oplevert die niet alleen de algehele beveiliging versterkt, maar ook het vertrouwen en de naleving in de hele sector bevordert.

2. Gezondheidszorg

Gezondheidszorgsystemen verwerken gevoelige gegevens die volgens strenge regelgevende richtlijnen moeten worden beschermd, maar handmatige controles kunnen vaak omslachtig en foutgevoelig zijn. Door GitLab Container Scanning in te zetten voor kwetsbaarheidsbeoordelingen en als onderdeel van continue compliance-rapportageprocessen, kunnen zorginstellingen GitLab Container Scanning stroomlijnen om zichzelf te beschermen tegen inbreuken en tegelijkertijd het rapportageproces veel minder complex maken dan voorheen.

3. Tech-startups

Tech-startups hebben vaak moeite om een evenwicht te vinden tussen snelle ontwikkeling en het handhaven van beveiligingsnormen. GitLab Container Scanning kan bedrijven helpen beide processen op elkaar af te stemmen; door containerized applicaties continu op kwetsbaarheden te scannen, kunnen ontwikkelingscycli worden versneld en tegelijkertijd de beveiliging worden gewaarborgd. Dit geeft startups de flexibiliteit om te innoveren en tegelijkertijd een sterke beveiligingspositie te handhaven.

Conclusie

GitLab Container Scanning is een onmisbaar onderdeel geworden van het moderne ontwikkelingslandschap en biedt organisaties een eenvoudige manier om snel en betrouwbaar kwetsbaarheden in gecontaineriseerde applicaties op te sporen. Door naadloos te integreren in hun ontwikkelingspijplijnen en al in een vroeg stadium van het ontwikkelingsproces inzicht te bieden in kwetsbaarheden, kunnen organisaties beveiliging inbouwen in hun ontwikkelingsproces, waardoor risico's worden beperkt en de algehele beveiliging wordt verbeterd.

GitLab Container Scanning is een integraal onderdeel van een effectieve DevSecOps-strategie en zorgt voor een omgeving waarin de beveiliging voortdurend wordt verbeterd. Deze waardevolle troef zorgt ervoor dat beveiliging voorop blijft staan bij innovatie, van het naleven van regelgeving of het beschermen van klantgegevens tot het handhaven van flexibele ontwikkelingscycli en het voldoen aan diverse beveiligingsbehoeften in verschillende sectoren of gebruikssituaties.

Veelgestelde vragen over GitLab Container Scanning

Wat is GitLab Container Scanning?

GitLab Container Scanning voert tijdens CI/CD een kwetsbaarheidscontrole uit op uw containerimages. Het maakt gebruik van scanners zoals Trivy om elke laag te onderzoeken – van basis-OS-pakketten tot applicatieafhankelijkheden – voordat images in productie gaan. U schakelt het in door de CI-sjabloon voor containerscanning van GitLab toe te voegen of via een merge-verzoek met één klik.

De resultaten worden weergegeven als JSON-artefacten en op het tabblad Beveiliging van uw pijplijn, waarbij risicovolle CVE's en verlopen OS-versies worden gemarkeerd.

Welke soorten kwetsbaarheden detecteert GitLab Container Scanning?

Het detecteert bekende CVE's in uw basisimage en OS-pakketten, en, indien ingeschakeld, taalspecifieke bibliotheekfouten (bijvoorbeeld Java- of Python-pakketten). Het markeert ook verouderde besturingssystemen die geen beveiligingsupdates meer ontvangen. De onderliggende Trivy-scanner put uit adviesbronnen zoals NVD, distro-beveiligingstrackers en GitLab's eigen adviesdatabase om kwetsbaarheden te identificeren en te categoriseren op basis van CVSS-score en exploiteerbaarheid.

Hoe schakel ik containerscannen in een GitLab-pijplijn in?

Voeg de ingebouwde sjabloon van GitLab toe aan uw .gitlab-ci.yml.

include:

- template: Jobs/Container-Scanning.gitlab-ci.yml

Je kunt ook naar Beveiliging > Beveiligingsconfiguratie in je project gaan, klikken op Configureren met een samenvoegverzoek en samenvoegen. Hierdoor worden de benodigde taken in je pijplijn geïnjecteerd. Er is geen extra scripting nodig als u uw Docker-image al bouwt en naar het projectregister pusht

Waar worden de resultaten van containerscans weergegeven in GitLab?

Nadat je pijplijn is uitgevoerd, open je Build > Pipelines, kies je de run en selecteer je het tabblad Beveiliging. Daar zie je de ernst van elke bevinding, de CVSS-score, de kans op misbruik (EPSS) en richtlijnen voor herstel. Het ruwe scanrapport (gl-container-scanning-report.json) en een CycloneDX SBOM (gl-sbom-report.cdx.json) zijn beschikbaar onder Job Artifacts.

In het Ultimate-niveau ziet u ook inline resultaten in samenvoegingsverzoeken en een geconsolideerd kwetsbaarheidsrapport op de standaardtak.

Geeft GitLab herstelmaatregelen voor gedetecteerde kwetsbaarheden?

Ja. Elke kwetsbaarheidspost bevat een beschrijving van het probleem, de impact ervan en aanbevolen herstelmaatregelen, zoals pakketupgrades of configuratiewijzigingen. In het Ultimate-niveau kan GitLab zelfs automatische herstelpatches genereren: merge-verzoeken die uw Dockerfile of pakketmanifest voor u bijwerken naar vaste versies.

Hoe ga ik om met valse positieven in GitLab Container Scanning?

Maak een vulnerability-allowlist.yml aan in de root van uw repo. Vermeld CVE-ID's (globaal of per afbeelding) die u als valse positieven hebt bevestigd. GitLab sluit deze CVE's vervolgens uit van toekomstige scanrapporten en markeert ze als 'Goedgekeurd' in het taaklogboek. Zo blijft uw tabblad Beveiliging gericht op echte risico's zonder dat echte problemen worden verborgen.