Mengapa kode ini rentan terhadap serangan buffer overflow?

int func(char* str)
{
   char buffer[100];
   unsigned short len = strlen(str);

   if(len >= 100)
   {
        return (-1);
   }

   strncpy(buffer,str,strlen(str));
   return 0;
}

Kode ini rentan terhadap serangan buffer overflow, dan saya mencoba mencari tahu alasannya. Saya pikir ini ada hubungannya dengan lendinyatakan sebagai shortpengganti int, tapi saya tidak begitu yakin.

Ada ide?

Pada kebanyakan penyusun nilai maksimum suatu unsigned shortadalah 65535.

Nilai apa pun di atas yang dililit, jadi 65536 menjadi 0, dan 65600 menjadi 65.

Ini berarti bahwa string panjang dengan panjang yang tepat (misalnya 65600) akan melewati pemeriksaan, dan meluap buffer.

Gunakan size_tuntuk menyimpan hasil strlen(), bukan unsigned short, dan membandingkan lendengan ekspresi yang secara langsung menyandikan ukuran buffer. Jadi misalnya:

char buffer[100];
size_t len = strlen(str);
if (len >= sizeof(buffer) / sizeof(buffer[0]))  return -1;
memcpy(buffer, str, len + 1);

Masalahnya ada di sini:

strncpy(buffer,str,strlen(str));
                   ^^^^^^^^^^^

Jika string lebih besar dari panjang buffer target, strncpy akan tetap menyalinnya. Anda mendasarkan jumlah karakter string sebagai angka yang akan disalin, bukan ukuran buffer. Cara yang benar untuk melakukan ini adalah sebagai berikut:

strncpy(buffer,str, sizeof(buff) - 1);
buffer[sizeof(buff) - 1] = '\0';

Apa yang dilakukan adalah membatasi jumlah data yang disalin ke ukuran aktual buffer dikurangi satu untuk karakter terminasi nol. Kemudian kita mengatur byte terakhir dalam buffer ke karakter nol sebagai perlindungan tambahan. Alasan untuk ini adalah karena strncpy akan menyalin hingga n byte, termasuk null terminating, jika strlen (str) <len - 1. Jika tidak, maka null tidak disalin dan Anda memiliki skenario macet karena sekarang buffer Anda memiliki underminated tali.

Semoga ini membantu.

EDIT: Setelah pemeriksaan lebih lanjut dan masukan dari orang lain, kemungkinan pengkodean untuk fungsi ini adalah sebagai berikut:

int func (char *str)
  {
    char buffer[100];
    unsigned short size = sizeof(buffer);
    unsigned short len = strlen(str);

    if (len > size - 1) return(-1);
    memcpy(buffer, str, len + 1);
    buffer[size - 1] = '\0';
    return(0);
  }

Karena kita sudah mengetahui panjang string, kita bisa menggunakan memcpy untuk menyalin string dari lokasi yang dirujuk oleh str ke buffer. Perhatikan bahwa per halaman manual untuk strlen (3) (pada sistem FreeBSD 9.3), berikut ini dinyatakan:

 The strlen() function returns the number of characters that precede the
 terminating NUL character.  The strnlen() function returns either the
 same result as strlen() or maxlen, whichever is smaller.

Yang saya menafsirkan bahwa panjang string tidak termasuk nol. Itu sebabnya saya menyalin len +1 byte untuk memasukkan nol, dan tes memeriksa untuk memastikan bahwa panjang <ukuran buffer - 2. Minus satu karena buffer dimulai pada posisi 0, dan minus satu lagi untuk memastikan ada ruang untuk nol.

EDIT: Ternyata, ukuran sesuatu dimulai dengan 1 sementara akses dimulai dengan 0, jadi -2 sebelumnya salah karena akan mengembalikan kesalahan untuk apa pun> 98 byte tetapi seharusnya> 99 byte.

EDIT: Meskipun jawaban tentang unsigned short umumnya benar karena panjang maksimum yang dapat diwakili adalah 65.535 karakter, itu tidak terlalu penting karena jika string lebih panjang dari itu, nilainya akan membungkus. Ini seperti mengambil 75.231 (yang merupakan 0x000125DF) dan menutupi 16 bit teratas memberi Anda 9695 (0x000025DD). Satu-satunya masalah yang saya lihat dengan ini adalah 100 karakter pertama melewati 65.535 karena pemeriksaan panjang akan memperbolehkan penyalinan, tetapi hanya akan menyalin hingga 100 karakter pertama dari string dalam semua kasus dan null mengakhiri string . Begitu pun dengan masalah sampulnya, buffer masih tidak akan meluap.

Ini mungkin atau tidak dengan sendirinya menimbulkan risiko keamanan tergantung pada konten string dan untuk apa Anda menggunakannya. Jika hanya teks lurus yang dapat dibaca manusia, maka umumnya tidak ada masalah. Anda hanya mendapatkan string terpotong. Namun, jika itu sesuatu seperti URL atau bahkan urutan perintah SQL, Anda bisa memiliki masalah.

Meskipun Anda menggunakan strncpy, panjang cutoff masih tergantung pada pointer string yang lewat. Anda tidak tahu berapa lama string itu (lokasi dari terminator nol relatif terhadap pointer, yaitu). Jadi menelepon strlenseorang diri membuat Anda rentan. Jika Anda ingin lebih aman, gunakan strnlen(str, 100).

Kode lengkap yang diperbaiki adalah:

int func(char *str) {
   char buffer[100];
   unsigned short len = strnlen(str, 100); // sizeof buffer

   if (len >= 100) {
     return -1;
   }

   strcpy(buffer, str); // this is safe since null terminator is less than 100th index
   return 0;
}

Jawaban dengan pembungkusnya benar. Tapi ada masalah yang saya pikir tidak disebutkan jika (len> = 100)

Jika Len 100, kita akan menyalin 100 elemen dan kita tidak akan tertinggal \ 0. Itu jelas akan berarti fungsi lain tergantung pada string akhir yang tepat akan berjalan jauh melampaui array asli.

String yang bermasalah dari C adalah IMHO yang tidak dapat diselesaikan. Anda sebaiknya memiliki beberapa batasan sebelum panggilan, tetapi itu pun tidak akan membantu. Tidak ada batas memeriksa dan buffer overflows selalu dapat dan sayangnya akan terjadi ....

Di luar masalah keamanan yang terlibat dengan pemanggilan strlenlebih dari satu kali, seseorang umumnya tidak boleh menggunakan metode string pada string yang panjangnya diketahui dengan tepat [untuk sebagian besar fungsi string, hanya ada kasus yang sangat sempit di mana mereka harus digunakan - pada string yang maksimum panjang bisa dijamin, tetapi panjang pastinya tidak diketahui]. Setelah panjang string input diketahui dan panjang buffer output diketahui, orang harus mencari tahu seberapa besar suatu wilayah harus disalin dan kemudian digunakan memcpy()untuk benar-benar melakukan salinan yang dimaksud. Meskipun mungkin yang strcpymungkin mengungguli memcpy()ketika menyalin string hanya 1-3 byte atau lebih, pada banyak platform memcpy()cenderung lebih dari dua kali lebih cepat ketika berhadapan dengan string yang lebih besar.

Meskipun ada beberapa situasi di mana keamanan akan mengorbankan kinerja, ini adalah situasi di mana pendekatan yang aman juga lebih cepat. Dalam beberapa kasus, mungkin masuk akal untuk menulis kode yang tidak aman terhadap input berperilaku aneh, jika kode yang memasok input dapat memastikan mereka akan berperilaku baik, dan jika menjaga terhadap input berperilaku buruk akan menghambat kinerja. Memastikan bahwa panjang string hanya diperiksa sekali meningkatkan baik kinerja dan keamanan, meskipun satu hal tambahan yang dapat dilakukan untuk membantu penjaga keamanan bahkan ketika pelacakan panjang string secara manual: untuk setiap string yang yang diharapkan memiliki nol miring, menulis nol Trailing eksplisit lebih daripada mengharapkan string sumber untuk memilikinya. Jadi, jika seseorang menulis yang strdupsetara:

char *strdupe(char const *src)
{
  size_t len = strlen(src);
  char *dest = malloc(len+1);
  // Calculation can't wrap if string is in valid-size memory block
  if (!dest) return (OUT_OF_MEMORY(),(char*)0); 
  // OUT_OF_MEMORY is expected to halt; the return guards if it doesn't
  memcpy(dest, src, len);      
  dest[len]=0;
  return dest;
}

Perhatikan bahwa pernyataan terakhir secara umum dapat dihilangkan jika memcpy telah memproses len+1byte, tetapi utas lainnya adalah untuk memodifikasi string sumber, hasilnya bisa menjadi string tujuan yang tidak diakhiri dengan NUL.