SUTURE

JAHITAN

Suture adalah poin statis untuk dan alat analisis noda orde tinggi (untuk C) berdasarkan LLVM IR dan dibangun di atas Dr. Checker (terima kasih banyak kepada penciptanya!), Dua sorotan adalah:

• Presisi tinggi : Peningkatan presisi praktis dan/atau inovatif yang dikemas, jahitan adalah antar-prosedur, aliran-, contex-, lapangan, indeks, dan oportunistik-peka, dengan konstruksi SSA memori on-the-fly, pemasangan multi-soal-sink multi-sumber, penangan pointer yang hati-hati dan resolusi linux yang tidak langsung.
• Pesanan Tinggi : Jahitan mampu membangun aliran noda tingkat tinggi dan menemukan kerentanan noda tingkat tinggi (misalnya, input pengguna mengalir ke variabel global dalam doa Syscall ke-1, kemudian variabel global mengalir ke pernyataan sensitif dalam doa Syscall ke-2, membuat kerentanan nakal 2nd-order).

Kami menamainya jahitan dengan harapan bahwa itu bisa tepat pembedahan, sambil dapat menjahit beberapa fungsi syscall/entri bersama-sama untuk membangun aliran data tingkat tinggi. Untuk detail lebih lanjut silakan merujuk ke makalah kami: secara statis menemukan kerentanan gaya noda tingkat tinggi di kernel OS di ACM CCS'21 .

Pengaturan 0x0

Klon pertama repo:
~$ git clone https://github.com/seclab-ucr/SUTURE.git suture

Kemudian siapkan lingkungan LLVM untuk jahitan:
~$ cd suture
~/suture$ python setup_suture.py -o ../suture_deps
Opsi (untuk setup_suture.py ):

• -b Menentukan nama cabang LLVM yang akan diatur untuk Jahitan, itu default untuk "Release_90" (yaitu, LLVM 9.0) di LLVM Mirror Repo ini.
• -o Menentukan folder untuk meng -host semua barang yang dibutuhkan oleh Suture (misalnya, LLVM), gunakan folder apa pun yang Anda sukai.

Bergantung pada perangkat keras Anda, pengaturan LLVM mungkin memakan waktu cukup lama. Setelah selesai, file SRCIPT bernama env.sh akan dihasilkan di bawah folder root Suture, berisi perintah untuk mengatur variabel lingkungan yang digunakan oleh jahitan.
Penting : Pastikan untuk mengaktifkan env.sh ini setiap kali sebelum membangun/menggunakan jahitan (Anda juga dapat menambahkan perintah yang terkandung ke .bashrc untuk aktivasi otomatis pada login shell)!
~/suture$ source env.sh

Selanjutnya kita akan membangun jahitan:
~/suture$ cd llvm_analysis
~/suture/llvm_analysis$ ./build.sh
Setelah membangun yang sukses, jahitan siap digunakan.

0x1 Penemuan kerentanan dengan contoh

Jahitan dapat digunakan untuk menemukan kerentanan noda orde tinggi di luar kotak, di bagian ini kami berjalan melalui proses ini dengan contoh (misalnya, contoh memotivasi seperti yang ditunjukkan pada bagian 2.1 dalam makalah kami).

0x10 Siapkan input

Untuk menemukan kerentanan jahitan memerlukan dua jenis input: (1) modul program yang dikumpulkan ke bitcode LLVM (misalnya, file .bc ), dan (2) file konfigurasi untuk modul yang memanifestasikan fungsi entri dan argumen yang dikendalikan pengguna.

Pertama -tama mari kita siapkan bitcode LLVM untuk contoh memotivasi kami:
~/suture$ cd benchmark
~/suture/benchmark$ ./gen.sh motivating_example
Catatan : Untuk kenyamanan kami menyediakan gen.sh untuk mengkompilasi .c ke .bc dan .ll (bitcode llvm yang dapat dibaca manusia), dengan level optimisasi -O1 .
Sekarang kita harus memiliki motivasi_example.bc di bawah folder patokan yang sama, itulah modul program input untuk jahitan.

Kemudian datang ke file konfigurasi, kami telah menyiapkan satu untuk contoh memotivasi:

 ~/suture/benchmark$ cat conf_motivating_example  
entry0 MY_IOCTL 1  
entry1 NULL_ARG  
entry2 NULL_ARG  

Penjelasan : Setiap baris dalam file konfigurasi menjelaskan informasi dari satu fungsi entri (misalnya, fungsi tingkat atas dengan penelepon dan biasanya berfungsi sebagai antarmuka eksternal) dalam modul program, berisi hingga 3 token yang dipisahkan ruang:

• [func_name] Nama fungsi entri (mis. "Entry0" adalah salah satu fungsi entri dalam motivasi_example.c )
• [func_type] Jenis fungsi entri, kami sering menggunakan dua tipe: (1) null_arg berarti tidak ada parameter fungsi yang dapat dikendalikan pengguna, dan (2) my_ioctl secara default berarti parameter terakhir dikontrol pengguna (misalnya, untuk mencocokkan semantik yang biasa dari function iOCTL () dari fungsi Linux). Namun, parameter User_Controllable My_ioctl juga dapat ditentukan secara sewenang -wenang oleh argumen tambahan (lihat di bawah).
• [tambahan_args] Untuk saat ini hanya my_ioctl yang menerima argumen tambahan, dalam bentuk d+(_ d+)*, menentukan parameter fungsi mana yang dapat dikendalikan oleh pengguna. Setelah disediakan, argumen ini akan mengesampingkan perilaku default my_ioctl (yaitu, parameter terakhir dikendalikan pengguna). Misalnya, jika entry_x () memiliki 4 parameter (dari kiri ke kanan: parameter 0, 1, 2 dan 3) dan parameter 0 dan 2 disediakan oleh pengguna, kami dapat menentukannya di konfigurasi seperti entry_x MY_IOCTL 0_2 .

Jadi seperti yang ditunjukkan di atas, conf_motivating_example menentukan bahwa ada tiga fungsi entri dalam motivasi_example.c : entri0 (parameter 1 dikendalikan pengguna), entri1 dan entry2 (tidak ada parameter yang dikontrol pengguna). Ini cocok dengan kode contoh yang memotivasi.

0x11 Jalankan analisis

Setelah bitcode program dan file konfigurasi entri siap, kami dapat menjalankan Suture untuk menemukan kerentanan yang ternoda:
~/suture$ ./run_nohup.sh benchmark/motivating_example.bc benchmark/conf_motivating_example
Penjelasan : run_nohup.sh adalah skrip sederhana yang memohon tiket analisis LLVM yang dikompilasi dari jahitan:

 ~/suture$ ./run_nohup.sh [path/to/program.bc] [path/to/entry_func_config]

Setelah dimulai, tergantung pada perangkat keras yang sebenarnya dan kompleksitas program target, waktu yang diperlukan untuk Jahitan untuk menyelesaikan analisis dan penemuan kerentanan sangat bervariasi. Program sederhana seperti contoh memotivasi kami biasanya selesai secara instan.
Putuskan apakah analisis selesai : Selama eksekusi, Jahitan terus masuk ke file di bawah direktori yang sama dari file konfigurasi entri , misalkan jalur file konfigurasi adalah /path/to/conf_program , file log akan /path/to/conf_program.log . Kita dapat memutuskan apakah analisis selesai dengan memantau log:
~/suture$ grep "Bug Detection Phase finished" benchmark/conf_motivating_example.log

0x12 Periksa output

File log yang disebutkan di atas juga merupakan output jahitan, Jahitan akan menanamkan potensi kerentanan potensial dalam file log, yang dapat diekstraksi dan diatur ke dalam laporan peringatan akhir setelah analisis selesai:
~/suture$ ./ext_warns.sh benchmark/conf_motivating_example.log
Penjelasan : ext_warns.sh akan mengekstrak semua peringatan (dalam JSON) yang tertanam dalam file log yang diberikan, mengatur kembali dan mencetak cukup mereka ke dalam laporan peringatan akhir. Laporan peringatan akan dimasukkan ke dalam folder di bawah jalur file log yang sama, misalkan file log adalah /path/to/conf_program.log , folder laporan peringatan akan /path/to/warns-conf_program-hyyy-mm-dd .

 ~/suture$ ls benchmark/warns-conf_motivating_example-2021-11-10/
all  int_overflow  taint_data_use  taint_loopbound  taint_ptr_def

Di folder ada 5 laporan peringatan, semua berisi semua jenis peringatan yang dikelompokkan bersama sesuai dengan hubungan aliran data mereka, sementara laporan lain hanya berisi jenis peringatan tertentu (misalnya, integer overflow, dereferensi penunjuk yang tercemar, dll.), Rincian lebih lanjut tentang bagaimana kami mengelompokkan peringatan dapat ditemukan dalam makalah kami (Bagian 4). Kami biasanya hanya menggunakan laporan terpadu semua .

 ~/suture$ cat -n benchmark/warns-conf_motivating_example-2021-11-10/all
     1  =========================GROUP 0 (2 - 2)=========================
     2  #####Warned Insts#####
     3  (u'motivating_example.c', 30, [u'IntegerOverflowDetector'])
     4  ######################
     5
     6  ++++++++++++++++WARN 0 (2 - 2)++++++++++++++++
     7  IntegerOverflowDetector says: motivating_example.c@30 (bar :   %add = add i8 %0, -16, !dbg !31)
     8  ********Trace 0(2)********
     9  #####CTX##### entry0
    10  entry0 (motivating_example.c@18)
    11  #####INSTS#####
    12  >>>>>>>>>>>>>>>>>>tag: 0x55b206570420 tf: 0x55b20695b1b0 (2)>>>>>>>>>>>>>>>>>>
    13  motivating_example.c@18 (  %cond = icmp eq i32 %cmd, 0, !dbg !31)
    14  motivating_example.c@21 (  store i8 %user_input, i8* getelementptr inbounds (%struct.data, %struct.data* @d, i64 0, i32 1, i64 0), align 4, !dbg !32, !tbaa !34)
    15  #####CTX##### entry1 -> bar
    16  entry1 (motivating_example.c@35)
    17  ----> (motivating_example.c@35 :   %call = tail call i32 @bar(i8* bitcast (%struct.data* @d to i8*)), !dbg !27)
    18  bar (motivating_example.c@30)
    19  #####INSTS#####
    20  >>>>>>>>>>>>>>>>>>tag: 0x55b2065e7050 tf: 0x55b2068174f0 (1)>>>>>>>>>>>>>>>>>>
    21  motivating_example.c@30 (  %0 = load i8, i8* %add.ptr, align 1, !dbg !31, !tbaa !32)
    22  motivating_example.c@30 (  %add = add i8 %0, -16, !dbg !31)
    23

Penjelasan : Pada tingkat tinggi, laporan peringatan berisi beberapa kelompok peringatan, masing -masing kelompok berisi beberapa peringatan , dan setiap peringatan berisi beberapa jejak nakal yang berasal dari input pengguna dan tenggelam ke pernyataan program sensitif yang sama. Dengan kata lain, satu peringatan diangkat untuk pernyataan program tertentu dan jenis tertentu (misalnya, integer overflow), sementara suatu kelompok berisi beberapa peringatan yang terkait erat dari perspektif aliran data (lihat bagian 4 dalam makalah kami), sehingga suatu kelompok mungkin memiliki banyak pernyataan program yang diperingatkan dan termasuk jenis peringatan yang berbeda.

Ambil laporan peringatan di atas sebagai contoh:

• Baris 1: Baris header dari grup peringatan, formatnya adalah ===GROUP No. (min_order - max_order)=== , di mana min_order adalah urutan minimal (misalnya, sederhananya, pesanan adalah waktu dari fungsi masuk yang diperlukan dalam propagasi noda, lihat bagian 3.2 dalam makalah kami untuk definisi yang lebih formal.) Dari traint di dalam kelompok ini, dan max_order max.
• Baris 2-4: Ringkasan pernyataan program yang diperingatkan dan jenis peringatan grup ini.
• Baris 6: Garis header peringatan, mengikuti format yang sama dengan garis header grup, tetapi perhatikan bahwa No. WARN No. adalah lokal untuk grupnya.
• Baris 7: Pernyataan program yang diperingatkan dan jenis peringatan ini (misalnya, baris 30 di Motivating_example.c ).
• Baris 8: Garis header dari jejak peringatan yang ternoda, mengikuti format ***Trace No. (order)*** , jejak noda selalu memiliki urutan unik yang dapat dihitung (misalnya, bukan rentang).
• Baris 9-22: Pernyataan terperinci/urutan instruksi dari jejak noda ini. Urutan ini disusun dalam beberapa segmen konteks-inst berturut-turut, misalnya, menganggap kami memiliki 10 instruksi dalam urutan dan 6 pertama dari mereka berada di A () , dan 4 sisanya dalam B () , yang merupakan calle dari a () . Dalam situasi ini kita akan memiliki dua segmen konteks-inst: yang pertama berisi 6 instruksi terkemuka di bawah konteks panggilan a () , dan yang kedua berisi 4 sisanya di bawah konteks panggilan a ()-> b () . Coming back to our motivating example warning report, Line 9-14 is the 1st segment in the trace, where we need to invoke entry0() (Line 10) and walk through two instructions (Line 13-14) in entry0() (so that user_input of entry0() is propagated to the global variable db[0] in motivating_example.c ), then Line 15-22 is the second segment, where we need to invoke entry1() first (Baris 16), yang kemudian memanggil bar () (baris 17), dan di dalam bar () (baris 18) kita perlu melalui dua pernyataan program (baris 21-22) untuk menyelesaikan propagasi noda dan memicu kerentanan ( db [0] disebarkan ke situs meluap (1) dalam motivasi_example.c ). Karena kita membutuhkan dua doa fungsi entri (misalnya, entri pertama () kemudian entri1 () ), jejak noda ini adalah urutan ke-2.
• Baris 12, 20: Baris khusus ini digunakan secara internal oleh kami untuk tujuan debugging.

Laporan peringatan menunjukkan kerentanan integer overflow yang valid dalam contoh yang memotivasi, sambil menghindari alarm palsu potensial yang dapat dihasilkan oleh alat analisis statis yang kurang tepat, rincian dapat ditemukan di bagian 2.1 dari makalah kami.

0x2 utilitas bermanfaat lainnya

Repo ini juga berisi beberapa alat/skrip lain yang mungkin Anda temukan berguna.

Pengidentifikasi titik masuk 0x20 (untuk driver perangkat Linux)

~/suture$ python llvm_analysis/AnalysisHelpers/EntryPointIdentifier/entry_point_identifier.py /path/to/prog_module.bc
~/suture$ cat /path/to/prog_module.bc.all_entries
Penjelasan : Skrip ini dapat mengidentifikasi beberapa fungsi entri umum dalam modul driver perangkat Linux (misalnya, ioctl () , baca () , tulis () , dll.), Yang membantu konstruksi file konfigurasi entri sebagai input ke jahitan. Utilitas ini sebagian besar diimplementasikan oleh Dr. Checker asli berdasarkan pada beberapa pengetahuan domain kernel (misalnya, struktur data spesifik seperti file_operations yang digunakan untuk mendefinisikan titik masuk driver), kami kemudian membuat beberapa perbaikan (misalnya, membuat heuristik lebih kuat).

0x21 Filter Alarm Salah

~/suture$ python flt_warns.py /path/to/warn_report [Regex] > /path/to/filtered_warn_report
Penjelasan : Dari pengalaman kami, banyak alarm palsu dalam laporan peringatan sering kali berbagi jejak sub-mencela bermasalah yang sama (lihat Bagian 6.3 dalam makalah kami). Selama pengulas peringatan memeriksa satu alarm palsu dan mengenali sub-trace yang menginduksi FP, secara alami, ia dapat mencoba secara otomatis mengecualikan semua alarm palsu serupa lainnya yang berisi sub-trace yang sama, mengurangi tingkat alarm palsu yang dipikirkan oleh pengulas. Untuk tujuan ini, kami memberikan flt_warns.py sederhana ini yang mengambil laporan peringatan asli dan ekspresi reguler Python sebagai input, kemudian akan cocok dengan RE dengan setiap jejak noda dalam laporan, setelah dicocokkan, jejak noda akan diperlakukan sebagai alarm palsu. Script akan menghasilkan laporan peringatan baru yang disaring tidak termasuk semua jejak noda yang cocok.

0x3 Kemungkinan Pertanyaan dan Jawaban

0x30 Gunakan jahitan sebagai analisis statis tujuan umum?

Anda mungkin tertarik untuk menggunakan Jahitan sebagai analisis statis tujuan umum (misalnya, dapatkan poin-ke/noda set variabel di lokasi program tertentu), ini pasti bisa dilakukan, tetapi tidak seperti penemuan kerentanan, Anda perlu membuat tangan kotor dan menyelami kode jahitan untuk dibiasakan dengan struktur data utama yang digunakannya dan beberapa fungsi penting. Saya berharap tips berikut dapat membantu:

• [Baca Paper Dr. Checker asli] Jahitan didasarkan pada Dr. Checker dan mewarisi arsitektur tingkat tinggi, prinsip-prinsip desain dan banyak kode dan struktur data penting, untuk singkatnya kami menghilangkan rincian tentang desain dan implementasi Dr. Checker dalam makalah kami, tetapi mereka sangat penting untuk memahami basis kode. Saya sangat merekomendasikan untuk membaca kertas checker Dr. Found, yang berisi detail -detail penting ini.
• [Fokus pada file sumber penting] Semua catatan titik-ke-noda dari variabel LLVM tingkat atas yang ditemukan dalam llvm_analysis/foratalisis yang ditempelkan/soundyalisanalisis/termasuk/modulestate.h , sedangkan semua informasi untuk objek memori yang digambarkan dalam llvm_analisis/mainani analysis . Saya menyarankan untuk fokus pada dua file ini dan API yang ditentukan di dalamnya untuk mengambil catatan poin-ke/noda. Last but not least, titik awal dari semua analisis LLVM jahitan (misalnya, runonmodule () ) adalah di llvm_analysis/fordaanalysispass/soundyaliaSanalysis/src/soundyaliaSanalysis.cpp .

0x31 Adapt Suture ke versi LLVM yang lebih baru?

LLVM berkembang sangat cepat, tanpa jaminan kompatibelinya ke belakang. Jadi sangat mungkin Anda akan mengalami beberapa kesalahan kompilasi saat mencoba membangun jahitan dengan versi LLVM yang lebih baru (misalnya,> 9.0). Tapi untungnya, kesalahan kompilasi seperti itu biasanya mudah diselesaikan (misalnya, sering kali kita hanya perlu mengganti API LLVM yang sudah ketinggalan zaman dengan yang lebih baru). Jadi pada dasarnya, untuk mengadaptasi jahitan dengan versi LLVM yang lebih baru, pertama -tama kita perlu mengatur LLVM yang lebih baru di 0x0 (misalnya, perlu memodifikasi setup_suture.py untuk mengkloning LLVM repo dari sumber aktif dan menentukan nama cabang yang lebih baru), dan kemudian mencoba untuk membangun jahitan terhadapnya, menyelesaikan komponen yang ditemui.