Memahami kelemahan suntikan arahan dalam Go

Pembangun Go mungkin perlu menggunakan perintah sistem untuk pelbagai senario, seperti manipulasi imej, di mana mereka perlu memproses atau mengubah saiz imej atau melaksanakan perintah sistem untuk mengurus sumber atau mengumpulkan metrik atau log.

Pada masa lain, mungkin anda sedang membina sistem baharu dalam Go yang perlu antara muka dengan sistem warisan sedia ada. Antara muka ini bergantung pada melaksanakan perintah sistem dan memproses outputnya.

Dalam mana-mana kes, adalah penting untuk mengikuti konvensyen pengekodan selamat apabila melahirkan perintah sistem, kerana ini boleh membawa kepada kelemahan keselamatan yang dikenali sebagai suntikan arahan.

Apakah suntikan arahan?

Suntikan arahan ialah kelemahan keselamatan apabila aplikasi menghantar data yang dibekalkan pengguna yang tidak selamat (seperti input daripada borang web) ke shell sistem. Kelemahan ini membolehkan penyerang melaksanakan arahan sewenang-wenangnya pada sistem pengendalian hos di bawah pengguna aplikasi yang sama.

Dalam Go, suntikan arahan selalunya melibatkan penggunaan pakej os/exec untuk menghasilkan arahan sistem.

Pertimbangkan contoh kod Go berikut:

func handler(req *http.Request) {
  cmdName := req.URL.Query()["cmd"][0]
  cmd := exec.Command(cmdName)
  cmd.Run()
}

Dalam coretan kod ini, cmdName diekstrak terus daripada parameter pertanyaan permintaan dan digunakan untuk membina arahan yang dilaksanakan pada pelayan. Ini ialah contoh klasik kerentanan suntikan arahan kerana penyerang boleh memanipulasi nilai rentetan pertanyaan cmd untuk melaksanakan sebarang arahan yang mereka pilih, yang berpotensi menjejaskan pelayan.

Penyerang boleh membuat permintaan dengan perintah berniat jahat, seperti:

http://example.com/execute?cmd=rm%20-rf%20/

Mengapa suntikan arahan berbahaya? Suntikan arahan adalah berbahaya kerana ia membenarkan penyerang melaksanakan arahan sewenang-wenangnya pada pelayan, yang boleh membawa kepada akibat yang teruk, termasuk:

• Pelanggaran Data: Penyerang boleh mengakses data sensitif yang disimpan pada pelayan. Bayangkan mereka mengakses fail konfigurasi seperti config.toml dan lain-lain yang menyenaraikan sumber dan bukti kelayakan.
• Kompromi Sistem: Penyerang boleh mendapatkan kawalan ke atas pelayan, yang membawa kepada eksploitasi selanjutnya. Ini selalunya dalam bentuk pergerakan sisi dalam sistem yang terjejas dan tindakan penemuan untuk pelayan lain yang boleh terjejas.
• Gangguan Perkhidmatan: Penyerang boleh melaksanakan arahan yang mengganggu perkhidmatan, menyebabkan masa henti. Secara berkesan ini boleh diterjemahkan secara langsung kepada kerugian kewangan dan risiko perniagaan akibat serangan penafian perkhidmatan.

Impak daripada serangan suntikan arahan yang berjaya boleh memusnahkan, bukan sahaja menjejaskan sistem yang terjejas tetapi juga reputasi organisasi dan kepercayaan pelanggan.

Pelaksanaan proses yang terdedah dan suntikan arahan dalam Go

Pembangun Go, yang terkenal dengan keutamaan mereka untuk kesederhanaan dan prestasi, mungkin memilih untuk menyepadukan perintah sistem untuk memanfaatkan keupayaan utiliti ini. Pendekatan ini membolehkan mereka menumpukan pada membina aplikasi yang mantap tanpa mencipta semula roda. Walau bagaimanapun, penyepaduan ini datang dengan set cabarannya sendiri, terutamanya dari segi keselamatan.

Untuk menggambarkan senario yang lebih realistik, pertimbangkan aplikasi Go yang memproses fail imej menggunakan utiliti baris arahan seperti convert.

Kami meneroka aplikasi Go yang direka untuk mengendalikan permintaan saiz semula imej. Aplikasi ini menggunakan rangka kerja web Gin untuk menentukan titik akhir POST, /cloudpawnery/imej, yang memproses saiz semula imej berdasarkan input pengguna. Titik akhir ini menerima parameter seperti tenantID, fileID dan fileSize daripada rentetan pertanyaan. Parameter fileSize adalah pilihan dan lalai kepada "200" jika tidak disediakan.

Coretan kod berikut menunjukkan pelaksanaan yang terdedah dalam Go.

func handler(req *http.Request) {
  cmdName := req.URL.Query()["cmd"][0]
  cmd := exec.Command(cmdName)
  cmd.Run()
}

Fungsi muat turunAndResize membina rentetan arahan untuk mengubah saiz imej menggunakan tukar dan melaksanakannya menggunakan exec.CommandContext.

Bagaimanakah fungsi muat turunAndResize membina rentetan arahan? Ia mengambil input ini menggunakan fileSize yang disediakan pengguna. Rentetan ini kemudiannya dilaksanakan, berpotensi membenarkan penyerang untuk menyuntik arahan berniat jahat. Untuk mengurangkan risiko ini, pembangun Go harus mengesahkan dan membersihkan semua input pengguna, menggunakan perintah berparameter dan memanfaatkan amalan keselamatan yang mengendalikan pelaksanaan perintah dengan selamat.

Mengurangkan kelemahan suntikan arahan

Dalam pembangunan Go, sama seperti dalam mana-mana bahasa lain, memastikan kod anda selamat daripada kelemahan suntikan arahan adalah yang paling penting. Suntikan arahan berlaku apabila penyerang boleh melaksanakan arahan sewenang-wenangnya pada hos yang boleh membawa kepada akses tanpa kebenaran, pelanggaran data dan isu keselamatan teruk yang lain.

Mari kita terokai beberapa amalan terbaik untuk mengurangkan risiko ini.

Pengesahan input dan sanitasi

Salah satu langkah asas untuk mencegah suntikan arahan ialah pengesahan input dan sanitasi yang ketat. Dalam contoh yang disediakan, fungsi muat turunAndResize membina rentetan arahan menggunakan input yang dibekalkan pengguna seperti fileSize. Jika input ini tidak disahkan dengan betul, penyerang boleh menyuntik arahan berniat jahat.

Berikut ialah cara anda boleh meningkatkan pengesahan input:

1. Input senarai benarkan: Tentukan satu set nilai yang boleh diterima untuk input seperti Saiz fail. Sebagai contoh, hanya benarkan nilai angka yang berada dalam julat yang munasabah.
2. Sanitasi input: Alih keluar atau larikan sebarang aksara yang berpotensi berbahaya daripada input pengguna. Ini boleh termasuk aksara meta shell seperti ;, |, &, dsb. Sebaik-baiknya anda dinasihatkan supaya anda mengekodkan perintah dengan keras dan tidak membenarkan input pengguna mengawalnya.
3. Gunakan jenis yang ketat: Tukar input kepada jenis data yang dijangkakan secepat mungkin. Contohnya, tukarkan saiz fail kepada integer dan sahkan julatnya.

Berikut ialah contoh cara anda boleh melaksanakan amalan ini:

func handler(req *http.Request) {
  cmdName := req.URL.Query()["cmd"][0]
  cmd := exec.Command(cmdName)
  cmd.Run()
}

 Walaupun begitu, kami boleh melakukan lebih baik untuk mendapatkan kod Go daripada suntikan arahan. Teruskan membaca!

Penggunaan API atau perpustakaan selamat dan bukannya arahan sistem

Satu lagi strategi berkesan adalah untuk mengelak daripada melaksanakan arahan sistem secara terus apabila boleh. Sebaliknya, manfaatkan API atau perpustakaan selamat yang menyediakan fungsi yang diperlukan tanpa mendedahkan aplikasi anda kepada risiko suntikan arahan.

Sebagai contoh, jika aplikasi anda perlu memanipulasi imej, pertimbangkan untuk menggunakan pustaka Go seperti github.com/disintegration/imaging dan bukannya memanggil arahan luaran seperti menukar daripada pustaka perisian ImageMagick. Pendekatan ini merangkumi fungsi dalam persekitaran selamat jenis Go, mengurangkan permukaan serangan.

http://example.com/execute?cmd=rm%20-rf%20/

Dengan menggunakan perpustakaan seperti pengimejan dalam Go, anda menghapuskan keperluan untuk membina dan melaksanakan arahan shell, dengan itu mengurangkan risiko suntikan arahan. Namun, dalam sesetengah pustaka dan ekosistem bahasa, ada kemungkinan pakej pihak ketiga adalah pembalut mudah di sekitar pelaksanaan perintah jadi wajib untuk menyemak kod untuk operasi sensitif tersebut.

Faktorkan semula fungsi muat turunAndResize yang terdedah untuk mengelakkan suntikan

Dalam contoh sebelumnya, kami menunjukkan aplikasi Go yang berpotensi terdedah yang menggunakan fungsi exec.CommandContext untuk melaksanakan arahan shell. Pendekatan ini boleh membawa kepada kelemahan suntikan arahan seperti yang kami nyatakan.

Mari cuba memfaktorkan semula fungsi muat turunAndResize untuk memastikan input pengguna tidak membawa kepada pelaksanaan arahan sewenang-wenangnya.

Satu cara berkesan untuk menghalang suntikan arahan adalah untuk mengelakkan membina rentetan arahan shell terus daripada input pengguna. Sebaliknya, kita boleh menggunakan fungsi exec.Command dengan hujah yang berasingan, yang membantu dalam menghantar input pengguna dengan selamat sebagai parameter kepada arahan tanpa menggunakan shell dan tanpa membenarkan pengguna mengawal arahan sebenar.

Berikut ialah versi refactored fungsi muat turunAndResize yang menangani kerentanan suntikan arahan:

func handler(req *http.Request) {
  cmdName := req.URL.Query()["cmd"][0]
  cmd := exec.Command(cmdName)
  cmd.Run()
}

Dalam refactor ini kami memisahkan arahan daripada hujahnya. Dengan menggunakan exec.CommandContext dengan hujah yang berasingan, kami mengelakkan keperluan untuk membina rentetan arahan shell. Kaedah ini memastikan input pengguna dianggap sebagai data dan bukannya kod boleh laku, dengan ketara mengurangkan risiko suntikan arahan.

Kami juga mengalih keluar keperluan untuk invokasi shell. Kod refactored tidak menggunakan shell (sh -c), yang merupakan vektor biasa untuk suntikan arahan. Sebaliknya, ia secara langsung memanggil utiliti tukar dengan hujah yang ditentukan.

Memanfaatkan Snyk untuk keselamatan kod

Snyk Code ialah alat analisis statik yang berkuasa yang membantu pembangun mengenal pasti dan membetulkan kelemahan dalam pangkalan kod mereka. Ia disepadukan dengan lancar ke dalam IDE anda dan aliran kerja pembangunan anda, memberikan maklum balas masa nyata tentang isu keselamatan yang berpotensi.

Bagaimana Snyk boleh membantu mengenal pasti kelemahan suntikan arahan dalam Go

Dalam contoh Go yang disediakan, fungsi muat turunAndResize membina arahan shell menggunakan input yang dibekalkan pengguna:

http://example.com/execute?cmd=rm%20-rf%20/

Kod ini terdedah kepada suntikan arahan kerana ia menggabungkan input pengguna secara langsung ke dalam rentetan arahan.

Bagaimana jika pasukan anda mempunyai pembangun yang tidak mengetahui tentang kelemahan suntikan arahan?

Adakah anda dapat dengan mudah menentukan aliran panggilan analisis statik antara fail dalam semakan kod untuk mencari kelemahan suntikan arahan ini?

Di sinilah Snyk masuk.

Lihat bagaimana keselamatan aplikasi menjadi mudah dengan pelanjutan Snyk Code pencahayaan tinggi dalam kod mudah terjejas masa nyata dalam editor VS Code:

Snyk boleh membantu mengenal pasti kelemahan tersebut dengan mengimbas kod Go anda dan membenderakan keadaan yang input pengguna digunakan secara tidak selamat dalam arahan shell. Snyk menunjukkan kepada anda komitmen sebenar yang dibuat oleh projek sumber terbuka lain yang mengurangkan kerentanan khusus ini supaya anda mendapat beberapa rujukan kod sebagai contoh "kelihatan baik".

Lebih-lebih lagi, jika anda mengklik tab GAMBARAN ISU, anda akan mendapat butiran lanjut dan amalan terbaik untuk pencegahan suntikan arahan. Tab ini memberikan pandangan dan pengesyoran terperinci tentang cara mengurangkan risiko ini dan ia tersedia terus dalam paparan IDE semasa anda mengekod dan boleh mengikuti tindakan ini tanpa suis konteks yang mahal:

Untuk pembelajaran lanjut tentang cara melindungi kod anda daripada kelemahan tersebut, pertimbangkan untuk memasang sambungan IDE Snyk Code dan menyambungkan projek Git anda untuk mengenal pasti dan membetulkan isu keselamatan dalam aplikasi Go anda. Anda boleh melakukannya dengan mudah dan percuma dengan mendaftar untuk mula mengimbas kod anda untuk mencari kelemahan.

Atas ialah kandungan terperinci Memahami kelemahan suntikan arahan dalam Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!