Udforsk analyse af softwaresammensætning

  • 10 minutter

Software Composition Analysis (SCA) er en automatiseret proces til at identificere open source- og tredjepartskomponenter i applikationer, analysere deres sikkerhedssårbarheder, licensoverholdelse og kodekvalitet. I takt med at moderne applikationer i stigende grad er afhængige af eksterne afhængigheder, er SCA blevet afgørende for at håndtere de risici, der er forbundet med softwareforsyningskæder.

Hvad er softwaresammensætningsanalyse?

Software Composition Analysis er praksis med automatisk at opdage, katalogisere og analysere alle open source- og tredjepartskomponenter, der bruges i en applikation. SCA-værktøjer undersøger pakkemanifester, afhængighedslåsefiler, kildekode og kompilerede binære filer for at skabe en omfattende softwarestykliste (SBOM).

Centrale SCA-funktioner

Registrering af afhængighed:

  • Manifest parsing: SCA-værktøjer læser pakkemanifestfiler (package.json, requirements.txt, pom.xml, *.csproj) for at identificere erklærede afhængigheder.
  • Analyse af låsefil: Analyser låsefiler (package-lock.json, Pipfile.lock, Gemfile.lock), der viser nøjagtige installerede versioner, herunder transitive afhængigheder.
  • Binær scanning: Avancerede værktøjer scanner kompilerede artefakter, objektbeholderafbildninger og udrullede programmer for at finde integrerede afhængigheder, der ikke er deklareret i manifester.
  • Understøttelse af flere sprog: Omfattende værktøjer understøtter snesevis af programmeringssprog og pakkeøkosystemer (npm, PyPI, Maven, NuGet, RubyGems, Go-moduler).

Analyse af sårbarheder:

  • CVE-matchning: Sammenlign fundne afhængigheder med CVE-databaser (Common Vulnerabilities and Exposures).
  • Scoring af sværhedsgrad: Beregn CVSS-score (Common Vulnerability Scoring System), der angiver sværhedsgraden af sårbarheder fra 0 (ingen) til 10 (kritisk).
  • Udnyt efterretninger: Identificer, hvilke sårbarheder der har kendte udnyttelser, der aktivt bruges af angribere.
  • Anbefalinger til patch: Foreslå specifikke versionsopgraderinger, der løser sårbarheder, samtidig med at kompatibiliteten opretholdes.

Overholdelse af licens:

  • Registrering af licens: Identificer licenser for alle afhængigheder ved at analysere licensfiler, pakkemetadata og kildekodeoverskrifter.
  • Håndhævelse af politikker: Markér automatisk afhængigheder, der overtræder organisationens licenspolitikker.
  • Analyse af kompatibilitet: Registrer modstridende licenser, der ikke lovligt kan kombineres i det samme program.
  • Sporing af forpligtelser: Krav til dokumentlicenser som f.eks. tilskrivningsmeddelelser, offentliggørelse af kildekode eller begrænsninger for afledte værker.

Vurdering af kvaliteten:

  • Vedligeholdelse status: Evaluer, om afhængigheder opretholdes aktivt eller opgives.
  • Sundhed i Fællesskabet: Vurder bidragyderaktivitet, samfundsstørrelse og projektets bæredygtighed.
  • Sikkerhedspraksis: Bekræft, at projekter har ansvarlige oplysningsprocesser og sikkerhedsrådgivning.
  • Anbefalinger til opdatering: Identificer forældede afhængigheder og foreslå sikrere, mere aktuelle alternativer.

Hvorfor SCA er afgørende for DevOps

Moderne softwareudviklingspraksis gør SCA uundværlig:

Afhængighedseksplosionen

Programmer indeholder hundredvis af afhængigheder:

  • Direkte afhængigheder: Typisk applikation refererer direkte til 20-50 eksterne pakker.
  • Transitive afhængigheder: Hver direkte afhængighed bringer sine egne afhængigheder, hvilket skaber afhængighedstræer med 200-500 pakker i alt.
  • Flere økosystemer: Applikationer kombinerer ofte afhængigheder fra flere sprogøkosystemer (JavaScript-frontend, Python-backend, Java-mikrotjenester).
  • Afhængigheder af objektbeholdere: Containeriserede applikationer omfatter afhængigheder af basisafbildninger plus programafhængigheder.

Manuel sporing er umulig:

  • Skæl: Manuel sporing af hundredvis af afhængigheder på tværs af snesevis af applikationer er upraktisk.
  • Hastighed: Nye sårbarheder afsløres dagligt, hvilket gør enhver manuel beholdning straks forældet.
  • Kompleksitet: Forståelse af transitive afhængighedskæder og deres interaktioner kræver automatiseret analyse.
  • Distribueret ejerskab: Afhængigheder, der vedligeholdes af tusindvis af uafhængige open source-projekter over hele verden.

Sikkerhedskravet

Sårbarheder i afhængigheder udnyttes aktivt:

  • Højt profilerede brud: Større sikkerhedshændelser involverer regelmæssigt udnyttelse af kendte sårbarheder i populære open source-pakker.
  • Angreb i forsyningskæden: Angribere kompromitterer legitime pakker for at distribuere malware til downstream-forbrugere.
  • Zero-day sårbarheder: Tidligere ukendte sårbarheder i udbredte pakker kan påvirke tusindvis af organisationer samtidigt.
  • Patch haster: Kritiske sårbarheder kræver hurtig identifikation og afhjælpning på tværs af alle berørte applikationer.

Traditionelle sikkerhedsværktøjer overser sårbarheder i forbindelse med afhængighed:

  • Statisk analyse: Kildekodescanningsværktøjer analyserer din kode, men ikke afhængighedskode.
  • Dynamisk test: Penetrationstest kan overse sårbarheder i afhængigheder, der ikke udløses under test.
  • Manuel gennemgang: Sikkerhedsteams kan ikke gennemgå kildekoden til hundredvis af tredjepartspakker.
  • Specialiseret detektion: SCA-værktøjer, der er specielt designet til at identificere afhængighedssårbarheder, er påkrævet.

Kravet om overholdelse

Licensovertrædelser indebærer betydelige risici:

  • Juridisk ansvar: Brug af afhængigheder uden at overholde licensvilkårene kan resultere i retssager og erstatning.
  • Tvungen open-sourcing: Stærke copyleft-licenser (GPL, AGPL) kan kræve open-sourcing af hele applikationer.
  • Begrænsninger for distribution: Nogle licenser forbyder kommerciel distribution eller pålægger brugsbegrænsninger.
  • Krav til revision: Lovgivningsmæssige rammer kræver i stigende grad, at organisationer opretholder nøjagtige softwarestyklister.

Licensens kompleksitet:

  • Hundredvis af licenstyper: Open source-økosystemet omfatter hundredvis af forskellige licenser med forskellige forpligtelser.
  • Kompatibilitetsproblemer: Forskellige licenser har modstridende vilkår, der forbyder deres brug sammen.
  • Transitiv licens: Licensforpligtelser fra transitive afhængigheder skal spores og opfyldes.
  • Ændringer af licens: Projekter skifter nogle gange licenser mellem versioner, hvilket kræver løbende overvågning.

Sådan fungerer SCA-værktøjer

SCA-værktøjer anvender flere teknikker til at opdage og analysere afhængigheder:

Opdagelsesmekanismer

Parsing af manifestfiler:

  • Sprogspecifikke formater: Værktøjer forstår pakkemanifestformater for hvert sprog (package.json for npm, requirements.txt for Python pom.xml for Maven).
  • Afhængighedsløsning: Parse specifikationer for afhængighedsversioner, herunder områder, begrænsninger og løsningsregler.
  • Scanning af arbejdsområde: Scan projektmapper rekursivt for at finde alle manifestfiler i monorepos og arbejdsområder med flere projekter.
  • Konfiguration bevidsthed: Overvej miljøspecifikke afhængigheder (udvikling, test, produktion) separat.

Analyse af afhængighedslås fil:

  • Nøjagtige versioner: Låsefiler registrerer præcise versioner af alle afhængigheder, herunder transitive afhængigheder.
  • Installationens tilstand: Repræsentere faktiske installerede afhængigheder i stedet for abstrakte krav.
  • Deterministisk opløsning: Lås filer sikrer ensartede afhængighedsversioner på tværs af miljøer.
  • Komplette afhængighedsgrafer: Medtag et komplet transitivt afhængighedstræ med versionsopløsninger.

Binær scanning og artefaktscanning:

  • Kompilerede artefakter: Scan JAR-filer, hjulfiler, DLL'er og eksekverbare filer for at identificere integrerede afhængigheder.
  • Lag til containerbillede: Analysér objektbeholderbilledlag for at finde basisafbildningskomponenter og programafhængigheder.
  • Scanning af filsystem: Undersøg udrullede programfilsystemer for at finde afhængigheder, der ikke er angivet i manifester.
  • Fingeraftryk: Brug kryptografisk hashing til at identificere specifikke pakkeversioner, selv uden metadata.

Byg integration:

  • Byg værktøj plugins: Integrer med buildsystemer (Maven, Gradle, webpack, pip) for at registrere afhængighedsoplysninger under builds.
  • Opløsning kroge: Tilslut dig til afhængighedsløsningsprocesser for at registrere nøjagtige installerede versioner.
  • Generering af artefakter: Generer SBOM-artefakter (Software Bill of Materials) under builds til downstream-forbrug.
  • Integration af pipeline: Kør som automatiserede trin i CI/CD-pipelines for at analysere hvert build.

Analysemuligheder

Matchning af sårbarheder:

  • Databaseforespørgsler: Forespørg på National Vulnerability Database (NVD), GitHub Advisory Database og proprietære sårbarhedsdatabaser.
  • Matchning af versionsområde: Find ud af, om bestemte pakkeversioner falder inden for sårbare versionsintervaller.
  • Validering af patch: Kontroller, om anvendte programrettelser rent faktisk løser rapporterede sårbarheder.
  • Prioritering: Ranger sårbarheder efter alvorsgrad, udnyttelsesmuligheder og forretningspåvirkning.

Identifikation af licens:

  • Flere kilder: Udtræk licensoplysninger fra pakkemetadata, licensfiler, kildeoverskrifter og vigtige dokumenter.
  • Normalisering af licens: Tilknyt forskellige licensnavne og -id'er (SPDX, OSI) til standardiserede licenstyper.
  • Dobbelt licens: Håndter pakker, der er udgivet under flere alternative licenser.
  • Brugerdefinerede licenser: Identificer ikke-standardiserede licenser, der kræver juridisk gennemgang.

Analyse af tilgængelighed:

  • Konstruktion af opkaldsgrafer: Byg kaldsgrafer, der viser, hvilken afhængighedskode der rent faktisk udføres af dit program.
  • Registrering af død kode: Identificer afhængigheder, der er bundtet, men aldrig brugt.
  • Analyse af udnyttelsesstier: Find ud af, om sårbare kodestier kan nås fra programmets indgangspunkter.
  • Risikoforfining: Reducer støj ved at fokusere på sårbarheder, der kan udnyttes i faktisk brugt kode.

Kontinuerlig overvågning:

  • Advarsel i realtid: Modtag øjeblikkelige meddelelser, når nye sårbarheder, der påvirker dine afhængigheder, afsløres.
  • Planlagt scanning: Scan regelmæssigt programmer igen for at opdage nyopdagede sårbarheder i uændrede afhængigheder.
  • Sammenligning af baseline: Spor ændringer i sårbarhed og overholdelsesstatus over tid.
  • Forebyggelse af regression: Advar, når nye afhængigheder introducerer sårbarheder eller licensovertrædelser.

SCA-integrationsmønstre

Effektiv SCA-implementering involverer integration på flere punkter i udviklingslivscyklussen:

Arbejdsstation for udviklere

IDE-integration:

  • Feedback i realtid: Scan afhængigheder, når udviklere føjer dem til projekter.
  • Inline-advarsler: Vis advarsler om sårbarhed og licens direkte i IDE'en.
  • Forslag til afhjælpning: Foreslå alternative pakkeversioner eller erstatningspakker.
  • Håndhævelse af politikker: Undgå at tilføje afhængigheder, der overtræder organisationens politikker.

Validering før bekræftelse:

  • Git kroge: Kør SCA-kontroller, før du bekræfter, for at forhindre introduktion af sårbare afhængigheder.
  • Lokal scanning: Analysér ændringer lokalt, før du skubber til fjernlagre.
  • Hurtig feedback: Giv øjeblikkelig feedback til udviklere under aktiv udvikling.
  • Tidlig opdagelse: Fang problemer, før de når delte grene og CI/CD-pipelines.

Kildekontrol

Validering af pull-anmodning:

  • Automatiserede kontroller: Kør SCA-analyse på alle pullanmodninger for at registrere afhængighedsændringer.
  • Gennemgå kommentarer: Offentliggør resultater som pull-anmodningskommentarer for at få korrekturlæserens synlighed.
  • Flet blokering: Undgå fletning af pull-anmodninger, der introducerer kritiske sårbarheder eller licensovertrædelser.
  • Sporing af afhængighedsændringer: Dokumenter tydeligt, hvilke afhængighedsændringer hver pullanmodning introducerer.

GitHub Dependabot-integration:

  • Automatiserede opdateringer: Opret automatisk pullanmodninger, når sikkerhedsopdateringer til afhængighed er tilgængelige.
  • Advarsler om sårbarheder: Modtag GitHub-sikkerhedsbeskeder om sårbare afhængigheder.
  • Afhængighedsgraf: Visualiser afhængighedsrelationer i GitHubs afhængighedsgraffunktion.
  • Gennemse arbejdsgange: Udnyt GitHubs gennemgangs- og godkendelsesprocesser til afhængighedsopdateringer.

CI/CD-pipelines

Scanning i byggetid:

  • Trin i pipelinen: Tilføj SCA-scanning som automatiserede buildtrin i CI/CD-pipelines.
  • Kvalitets porte: Fejlbehæftede builds, der ikke opfylder kravene til sikkerhed og overholdelse af angivne standarder.
  • SBOM-generering: Opret softwarestyklisteartefakter sammen med buildoutput.
  • Revisionsspor: Registrer scanningsresultater med henblik på overholdelse og kriminaltekniske formål.

Implementeringsporte:

  • Validering før implementering: Scan artefakter, før du udruller til produktionsmiljøer.
  • Miljøspecifikke politikker: Anvend strengere politikker for produktionsudrulninger end udviklingsudrulninger.
  • Udløsere for tilbagerulning: Annuller automatisk udrulninger, der indeholder kritiske sårbarheder.
  • Godkendelser af implementering: Kræv manuel godkendelse for installationer med kendte, men accepterede risici.

Overvågning af kørselstid

Scanning af produktionen:

  • Implementeret applikationsanalyse: Scan faktisk implementerede applikationer for at registrere runtime-afhængigheder.
  • Scanning af containerregistreringsdatabasen: Scan løbende containerbilleder, der er gemt i registre.
  • Serveruafhængig funktionsanalyse: Scan implementerede serveruafhængige funktioner og deres afhængigheder.
  • Registrering af drift: Identificer forskelle mellem tilsigtede og faktiske installerede afhængigheder.

Kontinuerlig overvågning af sårbarheder:

  • Løbende overvågning: Overvåg udrullede programmer for nyligt afslørede sårbarheder, der påvirker aktuelle afhængigheder.
  • Reaktion på hændelser: Udløs arbejdsprocesser for hændelsesrespons, når kritiske sårbarheder opdages i produktionen.
  • Planlægning af patch: Generer patch-implementeringsplaner til at løse sårbarheder i implementerede applikationer.
  • SLA-overholdelse: Spor afhjælpningstidsrammer for at sikre overholdelse af sikkerheds-SLA'er.

Bedste praksis for SCA-arbejdsgange

En vellykket SCA-implementering følger gennemprøvede arbejdsgange:

Etablere baseline

Indledende opgørelse:

  • Omfattende opdagelse: Kør SCA-værktøjer mod alle applikationer for at oprette komplet afhængighedsopgørelse.
  • Risikovurdering: Forstå den aktuelle eksponering for sårbarheder og problemer med licensoverholdelse.
  • Prioritering: Identificer, hvilke applikationer og sårbarheder der kræver øjeblikkelig opmærksomhed.
  • Grundlæggende dokumentation: Dokumentér den aktuelle tilstand som baseline for måling af forbedringer.

Definere politikker

Sikkerhedspolitikker:

  • Tærskler for sværhedsgrad af sårbarhed: Definer, hvilke sværhedsgrader der er acceptable (f.eks. ingen kritisk, begrænset høj).
  • Tidsrammer for afhjælpning: Opret SLA'er til patching af forskellige sværhedsgrader af sårbarheder (kritisk inden for 7 dage, høj inden for 30 dage).
  • Undtagelsesprocesser: Opret arbejdsprocesser til at acceptere risiko, når øjeblikkelig afhjælpning ikke er mulig.
  • Sporing af undtagelser: Oprethold revisionsspor over accepterede risici med forretningsmæssige begrundelser.

Politikker for overholdelse af angivne standarder:

  • Tilladelseslister for licenser: Angiv, hvilke licenser der altid er acceptable (MIT, Apache 2.0, BSD).
  • Licens denylister: Forbyd specifikke licenser, der er inkompatible med forretningsmodellen (GPL for proprietær software).
  • Arbejdsgange til godkendelse: Kræv juridisk gennemgang for afhængigheder med visse licenser (LGPL, MPL, brugerdefinerede licenser).
  • Krav til tilskrivning: Definer, hvordan licenstilskrivninger skal angives i distribueret software.

Automatiser håndhævelse

Integration af pipeline:

  • Automatiseret scanning: Kør SCA-kontroller automatisk på alle build- og pullanmodninger.
  • Kvalitets porte: Konfigurer pipelineporte, der blokerer builds eller udrulninger, der overtræder politikker.
  • Automatiseret afhjælpning: Brug værktøjer som GitHub Dependabot til automatisk at oprette pullanmodninger om sikkerhedsopdateringer.
  • Rapportering: Generer overholdelsesrapporter til overvågning og ledelsessynlighed.

Løbende forbedring

Sporing af målinger:

  • Gennemsnitlig tid til afhjælpning (MTTR): Mål, hvor hurtigt sårbarheder rettes efter opdagelse.
  • Reduktion af sårbarhed: Spor faldende sårbarhedstal over tid.
  • Overholdelse af reglerne: Overvåg procentdelen af afhængigheder, der overholder licenspolitikker.
  • Dækning: Sørg for, at SCA-værktøjer scanner alle applikationer og afhængigheder.

Finjustering af processen:

  • Falsk positiv ledelse: Juster værktøjer til at reducere falske positiver gennem konfiguration og undtagelser.
  • Udvikleruddannelse: Uddan udviklere i sikker afhængighedsudvælgelse og -administration.
  • Udviklingen i politikken: Opdater politikker baseret på nye trusler og forretningskrav.
  • Evaluering af værktøj: Evaluer regelmæssigt nye SCA-værktøjer og -funktioner.

Software Composition Analysis giver de automatiserede funktioner, der er afgørende for at administrere sikkerheds- og overholdelsesrisici i moderne applikationer, der er stærkt afhængige af open source-komponenter. Den næste enhed undersøger, hvordan man implementerer GitHub Dependabot, et specifikt SCA-værktøj, der er integreret i GitHub.