Menjelajahi analisis komposisi perangkat lunak

  • 10 menit

Analisis Komposisi Perangkat Lunak (SCA) adalah proses otomatis untuk mengidentifikasi komponen sumber terbuka dan pihak ketiga dalam aplikasi, menganalisis kerentanan keamanan, kepatuhan lisensi, dan kualitas kode mereka. Karena aplikasi modern semakin mengandalkan dependensi eksternal, SCA telah menjadi penting untuk mengelola risiko yang terkait dengan rantai pasokan perangkat lunak.

Apa itu Analisis Komposisi Perangkat Lunak?

Analisis Komposisi Perangkat Lunak adalah praktik penemuan, katalog, dan analisis otomatis semua komponen sumber terbuka dan pihak ketiga yang digunakan dalam aplikasi. Alat SCA memeriksa manifes paket, file kunci dependensi, kode sumber, dan biner yang dikompilasi untuk membuat tagihan materi perangkat lunak (SBOM) yang komprehensif.

Kemampuan SCA inti

Penemuan dependensi:

  • Penguraian manifes: Alat SCA membaca file manifes paket (package.json, requirements.txt, pom.xml, *.csproj) untuk mengidentifikasi dependensi yang dideklarasikan.
  • Analisis file kunci: Melakukan analisis file kunci (package-lock.json, Pipfile.lock, Gemfile.lock) menunjukkan versi yang diinstal secara tepat, termasuk dependensi tidak langsung.
  • Pemindaian biner: Alat tingkat lanjut memindai artefak yang dikompilasi, gambar kontainer, dan aplikasi yang disebarkan untuk menemukan dependensi yang disematkan yang tidak dideklarasikan dalam manifes.
  • Dukungan multi-bahasa: Alat komprehensif mendukung puluhan bahasa pemrograman dan ekosistem paket (modul npm, PyPI, Maven, NuGet, RubyGems, Go).

Analisis kerentanan:

  • Pencocokan CVE: Bandingkan dependensi yang ditemukan dengan database Common Vulnerabilities and Exposures (CVE).
  • Penilaian tingkat keparahan: Menghitung skor Common Vulnerability Scoring System (CVSS) yang menunjukkan tingkat keparahan kerentanan dari 0 (tidak ada) hingga 10 (kritis).
  • Intelijen eksploitasi: Identifikasi kerentanan mana yang memiliki eksploitasi yang diketahui secara aktif digunakan oleh penyerang.
  • Rekomendasi patch: Sarankan peningkatan versi tertentu yang mengatasi kerentanan sambil mempertahankan kompatibilitas.

Kepatuhan lisensi:

  • Deteksi lisensi: Identifikasi lisensi untuk semua dependensi dengan menganalisis file lisensi, metadata paket, dan header kode sumber.
  • Penegakan kebijakan: Menandai dependensi secara otomatis yang melanggar kebijakan lisensi organisasi.
  • Analisis kompatibilitas: Mendeteksi lisensi yang bertentangan yang tidak dapat digabungkan secara hukum dalam aplikasi yang sama.
  • Pelacakan kewajiban: Persyaratan lisensi dokumen seperti pemberitahuan atribusi, pengungkapan kode sumber, atau pembatasan kerja turunan.

Penilaian kualitas:

  • Status pemeliharaan: Evaluasi apakah dependensi secara aktif dipertahankan atau ditinggalkan.
  • Kesehatan masyarakat: Menilai aktivitas kontributor, ukuran komunitas, dan keberlanjutan proyek.
  • Praktik keamanan: Verifikasi bahwa proyek memiliki proses pengungkapan yang bertanggung jawab dan penasehat keamanan.
  • Rekomendasi pembaruan: Identifikasi dependensi yang kedaluarsa dan sarankan alternatif yang lebih aman dan lebih terkini.

Mengapa SCA sangat penting untuk DevOps

Praktik pengembangan perangkat lunak modern membuat SCA sangat diperlukan:

Ledakan dependensi

Aplikasi berisi ratusan dependensi:

  • Dependensi langsung: Aplikasi umum secara langsung mereferensikan 20-50 paket eksternal.
  • Dependensi transitif: Setiap dependensi langsung memiliki dependensi mereka sendiri, membentuk pohon dependensi dengan total 200-500 paket.
  • Beberapa ekosistem: Aplikasi sering menggabungkan dependensi dari beberapa ekosistem bahasa (frontend JavaScript, backend Python, layanan mikro Java).
  • Dependensi kontainer: Aplikasi kontainer mencakup dependensi gambar dasar ditambah dependensi aplikasi.

Pelacakan manual tidak mungkin:

  • Skala: Melacak ratusan dependensi secara manual di lusinan aplikasi tidak praktis.
  • Kecepatan: Kerentanan baru diungkapkan setiap hari, membuat persediaan manual segera kedaluarsa.
  • Kompleksitas: Memahami rantai dependensi transitif dan interaksinya memerlukan analisis otomatis.
  • Kepemilikan terdistribusi: Dependensi dipertahankan oleh ribuan proyek sumber terbuka independen di seluruh dunia.

Imperatif keamanan

Kerentanan dalam dependensi dieksploitasi secara aktif:

  • Pelanggaran profil tinggi: Insiden keamanan utama secara teratur melibatkan eksploitasi kerentanan yang diketahui dalam paket sumber terbuka populer.
  • Serangan rantai pasokan: Penyerang membahayakan paket yang sah untuk mendistribusikan malware kepada konsumen hilir.
  • Kerentanan nol hari: Kerentanan yang sebelumnya tidak diketahui dalam paket yang banyak digunakan dapat memengaruhi ribuan organisasi secara bersamaan.
  • Urgensi patch: Kerentanan kritis memerlukan identifikasi dan remediasi yang cepat di semua aplikasi yang terpengaruh.

Alat keamanan tradisional melewatkan kerentanan dependensi:

  • Analisis statis: Alat pemindaian kode sumber menganalisis kode Anda tetapi bukan kode dependensi.
  • Pengujian dinamis: Pengujian penetrasi mungkin melewatkan kerentanan dalam dependensi yang tidak dipicu selama pengujian.
  • Tinjauan manual: Tim keamanan tidak dapat meninjau kode sumber ratusan paket pihak ketiga dengan layak.
  • Deteksi khusus: Alat SCA yang dirancang khusus untuk mengidentifikasi kerentanan dependensi diperlukan.

Persyaratan kepatuhan

Pelanggaran lisensi membawa risiko signifikan:

  • Tanggung jawab hukum: Menggunakan dependensi tanpa mematuhi persyaratan lisensi dapat mengakibatkan gugatan dan kerusakan.
  • Sumber terbuka paksa: Lisensi copyleft yang kuat (GPL, AGPL) dapat memerlukan sumber terbuka seluruh aplikasi.
  • Pembatasan distribusi: Beberapa lisensi melarang distribusi komersial atau memberlakukan batasan penggunaan.
  • Persyaratan audit: Kerangka kerja peraturan semakin mengharuskan organisasi untuk mempertahankan tagihan materi perangkat lunak yang akurat.

Kompleksitas lisensi:

  • Ratusan jenis lisensi: Ekosistem sumber terbuka mencakup ratusan lisensi yang berbeda dengan berbagai kewajiban.
  • Masalah kompatibilitas: Lisensi yang berbeda memiliki istilah yang bertentangan yang melarang penggunaannya bersama-sama.
  • Lisensi transitif: Kewajiban lisensi dari dependensi transitif harus dilacak dan dipenuhi.
  • Perubahan lisensi: Proyek terkadang mengubah lisensi antar versi, memerlukan pemantauan berkelanjutan.

Cara kerja alat SCA

Alat SCA menggunakan beberapa teknik untuk menemukan dan menganalisis dependensi:

Mekanisme penemuan

Penguraian file manifes:

  • Format khusus bahasa: Alat memahami format manifes paket untuk setiap bahasa (package.json untuk npm, requirements.txt untuk Python, pom.xml untuk Maven).
  • Resolusi dependensi: Mengurai spesifikasi versi dependensi termasuk rentang, batasan, dan aturan resolusi.
  • Pemindaian ruang kerja: Pindai direktori proyek secara rekursif untuk menemukan semua berkas manifes di ruang kerja monorepos dan multi-proyek.
  • Kesadaran konfigurasi: Pertimbangkan dependensi khusus lingkungan (pengembangan, pengujian, produksi) secara terpisah.

Analisis berkas kunci dependensi:

  • Versi yang tepat: File pengunci merekam versi yang tepat dari semua dependensi termasuk dependensi transitif.
  • Status penginstalan: Mewakili dependensi aktual yang diinstal daripada persyaratan abstrak.
  • Resolusi deterministik: File pengunci memastikan versi dependensi yang konsisten di berbagai lingkungan.
  • Grafik dependensi lengkap: Sertakan pohon dependensi transitif penuh dengan resolusi versi.

Pemindaian biner dan artefak:

  • Artefak yang terkompilasi: Pindai file JAR, file wheel, DLL, dan file eksekusi untuk mengidentifikasi dependensi yang disematkan.
  • Lapisan gambar kontainer: Analisis lapisan gambar kontainer untuk menemukan komponen gambar dasar dan dependensi aplikasi.
  • Pemindaian sistem file: Memindai sistem file aplikasi yang disebarkan untuk menemukan dependensi yang tidak dideklarasikan dalam berkas manifes.
  • Sidik jari: Gunakan hash kriptografi untuk mengidentifikasi versi paket tertentu bahkan tanpa metadata.

Integrasi build:

  • Plugin alat build: Integrasikan dengan sistem build (Maven, Gradle, webpack, pip) untuk menangkap informasi dependensi selama build.
  • Kait resolusi: Kaitkan ke dalam proses resolusi dependensi untuk merekam versi yang tepat yang diinstal.
  • Pembuatan artefak: Hasilkan artefak bill of materials perangkat lunak (SBOM) selama proses build untuk penggunaan di hilir.
  • Integrasi alur: Jalankan sebagai langkah otomatis dalam alur CI/CD untuk menganalisis setiap build.

Kemampuan analisis

Pencocokan kerentanan:

  • Pemanggilan database: Database Kerentanan Nasional (NVD), Database Penasihat GitHub, dan database kerentanan milik sendiri.
  • Pencocokan rentang versi: Tentukan apakah versi paket tertentu termasuk dalam rentang versi yang rentan.
  • Validasi patch: Verifikasi apakah patch yang diterapkan benar-benar menyelesaikan kerentanan yang dilaporkan.
  • Prioritas: Peringkat kerentanan berdasarkan tingkat keparahan, eksploitasi, dan dampak bisnis.

Identifikasi lisensi:

  • Beberapa sumber: Ekstrak informasi lisensi dari metadata paket, file lisensi, header sumber, dan dokumen readme.
  • Normalisasi lisensi: Petakan berbagai nama lisensi dan pengidentifikasi (SPDX, OSI) ke jenis lisensi standar.
  • Lisensi ganda: Menangani paket yang dirilis di bawah beberapa lisensi alternatif.
  • Lisensi kustom: Identifikasi lisensi non-standar yang memerlukan peninjauan hukum.

Analisis keterjangkauan:

  • Konstruksi grafik panggilan: Bangun grafik panggilan yang menunjukkan kode dependensi mana yang benar-benar dijalankan oleh aplikasi Anda.
  • Deteksi kode mati: Identifikasi dependensi yang dibundel tetapi tidak pernah benar-benar digunakan.
  • Analisis jalur eksploitasi: Tentukan apakah jalur kode yang rentan dapat dijangkau dari titik masuk aplikasi.
  • Penyempurnaan risiko: Kurangi kebisingan dengan berfokus pada kerentanan yang dapat dieksploitasi dalam kode yang benar-benar digunakan.

Pemantauan berkelanjutan:

  • Pemberitahuan real time: Terima pemberitahuan langsung ketika kerentanan baru yang memengaruhi dependensi Anda diungkapkan.
  • Pemindaian terjadwal: Pindai ulang aplikasi secara teratur untuk mendeteksi kerentanan baru yang ditemukan dalam dependensi yang tidak mengalami perubahan.
  • Perbandingan garis besar: Lacak perubahan status kerentanan dan kepatuhan dari waktu ke waktu.
  • Pencegahan regresi: Pemberitahuan saat dependensi baru memperkenalkan kerentanan atau pelanggaran lisensi.

Pola integrasi Arsitektur Komponen Layanan (SCA)

Implementasi SCA yang efektif melibatkan integrasi di beberapa titik dalam siklus hidup pengembangan:

Stasiun kerja pengembang

Integrasi IDE:

  • Umpan balik real-time: Memindai dependensi ketika pengembang menambahkannya ke dalam proyek.
  • Peringatan terintegrasi: Tampilkan peringatan kerentanan dan lisensi langsung di IDE.
  • Saran remediasi: Sarankan versi paket alternatif atau paket penggantian.
  • Penegakan kebijakan: Mencegah penambahan dependensi yang melanggar kebijakan organisasi.

Validasi pra-penerapan:

  • Kait Git: Jalankan pemeriksaan SCA sebelum penerapan untuk mencegah pengenalan dependensi yang rentan.
  • Pemindaian lokal: Analisis perubahan secara lokal sebelum mengunggah ke repositori jarak jauh.
  • Umpan balik cepat: Berikan umpan balik langsung kepada pengembang selama pengembangan aktif.
  • Deteksi dini: Tangkap masalah sebelum mencapai cabang bersama dan alur CI/CD.

Kontrol sumber

Validasi permintaan pull:

  • Pemeriksaan otomatis: Jalankan analisis SCA pada semua permintaan pull untuk mendeteksi perubahan dependensi.
  • Tinjau komentar: Posting temuan sebagai komentar permintaan penarikan agar dapat dilihat oleh peninjau.
  • Pemblokiran penggabungan: Mencegah penggabungan permintaan pull yang memperkenalkan kerentanan kritis atau pelanggaran lisensi.
  • Pelacakan perubahan dependensi: Dokumentasikan dengan jelas dependensi apa yang mengubah setiap permintaan pull yang diperkenalkan.

Integrasi Dependabot GitHub:

  • Pembaruan otomatis: Buat permintaan pull secara otomatis saat pembaruan keamanan dependensi tersedia.
  • Pemberitahuan kerentanan: Terima pemberitahuan keamanan GitHub untuk dependensi yang rentan.
  • Grafik dependensi: Visualisasikan hubungan dependensi dalam fitur grafik dependensi GitHub.
  • Tinjau alur kerja: Manfaatkan proses peninjauan dan persetujuan GitHub untuk pembaruan dependensi.

Jalur CI/CD

Pemindaian pada waktu pembuatan:

  • Langkah-langkah alur: Tambahkan pemindaian SCA sebagai langkah build otomatis di alur CI/CD.
  • Gerbang kualitas: Bangunan yang gagal tidak memenuhi persyaratan keamanan dan kepatuhan.
  • Generasi SBOM: Buat daftar material perangkat lunak sebagai artefak seiring dengan hasil build.
  • Jejak audit: Rekam hasil pemindaian untuk tujuan kepatuhan dan forensik.

Gerbang penyebaran:

  • Validasi pra-penyebaran: Pindai artefak sebelum menyebarkan ke lingkungan produksi.
  • Kebijakan khusus lingkungan: Terapkan kebijakan yang lebih ketat untuk penyebaran produksi daripada penyebaran pengembangan.
  • Pemicu pemulihan: Secara otomatis mengembalikan penyebaran yang ditemukan mengandung kerentanan penting.
  • Persetujuan penyebaran: Memerlukan persetujuan manual untuk penyebaran dengan risiko yang diketahui tetapi diterima.

Pemantauan waktu eksekusi

Pemindaian produksi:

  • Analisis aplikasi yang sudah disebarkan: Melakukan pemindaian aplikasi yang sudah disebarkan untuk mendeteksi dependensi runtime.
  • Pemindaian registri kontainer: Terus memindai gambar kontainer yang disimpan dalam registri.
  • Analisis fungsi tanpa server: Pindai fungsi tanpa server yang disebarkan dan dependensinya.
  • Deteksi penyimpangan: Identifikasi perbedaan antara dependensi yang dimaksudkan dan yang benar-benar diterapkan.

Pemantauan kerentanan berkelanjutan:

  • Pemantauan berkelanjutan: Pantau aplikasi yang disebarkan untuk kerentanan baru terungkap yang memengaruhi dependensi saat ini.
  • Respons insiden: Memicu alur kerja respons insiden ketika kerentanan kritis ditemukan dalam produksi.
  • Perencanaan patch: Hasilkan rencana penyebaran patch untuk mengatasi kerentanan dalam aplikasi yang disebarkan.
  • Kepatuhan SLA: Lacak kerangka waktu remediasi untuk memastikan kepatuhan terhadap SLA keamanan.

Praktik terbaik alur kerja SCA

Implementasi SCA yang berhasil mengikuti alur kerja yang terbukti:

Menetapkan garis besar

Inventarisasi awal:

  • Penemuan komprehensif: Jalankan alat SCA terhadap semua aplikasi untuk membuat inventaris dependensi lengkap.
  • Penilaian risiko: Pahami paparan kerentanan dan masalah kepatuhan lisensi saat ini.
  • Prioritas: Identifikasi aplikasi dan kerentanan mana yang membutuhkan perhatian segera.
  • Dokumentasi garis besar: Dokumentasikan status saat ini sebagai garis besar untuk mengukur peningkatan.

Menentukan kebijakan

Kebijakan keamanan:

  • Ambang keparahan kerentanan: Tentukan tingkat keparahan mana yang dapat diterima (misalnya, tidak ada kritis, tinggi terbatas).
  • Kerangka waktu remediasi: Tetapkan SLA untuk menambal tingkat keparahan kerentanan yang berbeda (kritis dalam waktu 7 hari, tinggi dalam waktu 30 hari).
  • Proses pengecualian: Buat alur kerja untuk menerima risiko ketika remediasi langsung tidak layak.
  • Pelacakan pengecualian: Pertahankan jejak audit atas risiko yang diterima dengan alasan bisnis.

Kebijakan kepatuhan:

  • Daftar izin lisensi: Tentukan lisensi mana yang selalu dapat diterima (MIT, Apache 2.0, BSD).
  • Daftar tolak lisensi: Melarang lisensi tertentu yang tidak kompatibel dengan model bisnis (GPL untuk perangkat lunak kepemilikan).
  • Alur kerja persetujuan: Memerlukan tinjauan hukum untuk dependensi dengan lisensi tertentu (LGPL, MPL, lisensi kustom).
  • Persyaratan atribusi: Tentukan bagaimana atribusi lisensi harus disediakan dalam perangkat lunak terdistribusi.

Mengotomatiskan penegakan

Integrasi alur:

  • Pemindaian otomatis: Jalankan pemeriksaan SCA secara otomatis pada setiap permintaan build dan pull.
  • Gerbang kualitas: Konfigurasikan gerbang pipeline yang memblokir build atau penyebaran yang melanggar kebijakan.
  • Remediasi otomatis: Gunakan alat seperti GitHub Dependabot untuk membuat permintaan pull secara otomatis untuk pembaruan keamanan.
  • Pelaporan: Hasilkan laporan kepatuhan untuk visibilitas audit dan manajemen.

Peningkatan berkelanjutan

Pelacakan metrik:

  • Waktu rata-rata untuk memulihkan (MTTR): Ukur seberapa cepat kerentanan di-patch setelah penemuan.
  • Pengurangan kerentanan: Lacak penurunan jumlah kerentanan dari waktu ke waktu.
  • Tingkat kepatuhan: Pantau persentase dependensi yang memenuhi kebijakan lisensi.
  • Cakupan: Pastikan alat SCA memindai semua aplikasi dan dependensi.

Penyempurnaan proses:

  • Manajemen positif palsu: Sesuaikan alat untuk mengurangi positif palsu melalui konfigurasi dan pengecualian.
  • Pelatihan pengembang: Mendidik pengembang tentang pemilihan dan manajemen dependensi yang aman.
  • Evolusi kebijakan: Perbarui kebijakan berdasarkan ancaman dan persyaratan bisnis yang muncul.
  • Evaluasi alat: Evaluasi alat dan fitur SCA baru secara berkala.

Analisis Komposisi Perangkat Lunak menyediakan kemampuan otomatis yang penting untuk mengelola risiko keamanan dan kepatuhan dalam aplikasi modern yang sangat bergantung pada komponen sumber terbuka. Unit berikutnya mengeksplorasi cara mengimplementasikan GitHub Dependabot, alat SCA tertentu yang terintegrasi ke dalam GitHub.