Bu kod neden arabellek taşması saldırılarına karşı savunmasız?

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

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

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

Bu kod bir arabellek taşması saldırısına karşı savunmasız ve ben nedenini anlamaya çalışıyorum. Bunun yerine bir lenilan edilmesi ile ilgili olduğunu düşünüyorum , ama gerçekten emin değilim.shortint

Herhangi bir fikir?

Çoğu derleyicide maksimum değeri unsigned short65535'tir.

Yukarıdaki herhangi bir değer sarılır, böylece 65536 0 olur ve 65600 65 olur.

Bu, doğru uzunlukta uzun dizelerin (örn. 65600) denetimi geçeceği ve arabelleğin taşacağı anlamına gelir.

Kullanım size_tsonucunu depolamak için strlen()değil, unsigned shortve karşılaştırma lenile doğrudan boyutunu kodlayan bir ifade için buffer. Yani mesela:

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

Sorun burada:

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

Dize hedef arabelleğin uzunluğundan büyükse, strncpy yine de kopyalar. Dizenin karakter sayısını, arabellek boyutu yerine kopyalanacak sayı olarak dayandırıyorsunuz. Bunu yapmanın doğru yolu aşağıdaki gibidir:

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

Bunun yaptığı, boş sonlandırma karakteri için tampon eksi gerçek boyutuna kopyalanan veri miktarını sınırlamaktır. Sonra arabellekteki son baytı null karaktere ek bir koruma olarak ayarladık. Bunun nedeni, strrn (str) <len - 1 ise strncpy sonlandırma null değeri de dahil olmak üzere n bayta kadar kopyalayacaktır. Değilse, null kopyalanmaz ve çökme senaryosuna sahip olursunuz çünkü artık ara belleğinizde sonlanmamış dize.

Bu yardımcı olur umarım.

DÜZENLEME: Daha fazla inceleme ve diğer girdilerden sonra, işlev için olası bir kodlama aşağıdaki gibidir:

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);
  }

Dizenin uzunluğunu zaten bildiğimizden, dizeyi str tarafından arabelleğe alınan konumdan kopyalamak için memcpy'yi kullanabiliriz. Strlen (3) için manuel sayfada (FreeBSD 9.3 sisteminde) aşağıdakilerin belirtildiğine dikkat edin:

 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.

Hangi dize uzunluğu null içermediği için yorumlamak. Bu yüzden len + 1 baytları null değerini içerecek şekilde kopyalarım ve test, <tampon boyutu - 2'nin uzunluğundan emin olmak için kontrol eder. null için.

DÜZENLEME: Görünüyor ki, erişim 0 ile başlarken bir şeyin boyutu 1 ile başlar, bu nedenle önceki -2 yanlıştır çünkü 98 bayttan büyük bir şey için bir hata döndürür, ancak> 99 bayt olmalıdır.

EDIT: İmzasız bir kısa hakkında cevap genellikle temsil edilebilir maksimum uzunluğu 65,535 karakter olduğu için doğru olsa da, gerçekten önemli değil, çünkü dize bundan daha uzunsa, değer sarılır. Bu 75.231 (0x000125DF) almak ve size 9695 (0x000025DF) veren ilk 16 bitin maskelenmesi gibi. Bununla ilgili gördüğüm tek sorun, uzunluk kontrolü kopyalamaya izin vereceği için 65,535'i geçen ilk 100 karakterdir, ancak her durumda dizenin yalnızca ilk 100 karakterine kadar kopyalar ve null dizeyi sonlandırır . Bu nedenle, sarma sorunu olsa bile, arabellek yine de taşmaz.

Bu, dizenin içeriğine ve ne için kullandığınıza bağlı olarak kendi başına bir güvenlik riski oluşturabilir veya etmeyebilir. İnsan tarafından okunabilen düz metinse, genellikle sorun yoktur. Sadece kesik bir dize alıyorsunuz. Ancak, URL veya hatta bir SQL komut dizisi gibi bir şey varsa, bir sorununuz olabilir.

Kullansanız bile strncpy, kesmenin uzunluğu hala geçirilen dize işaretçisine bağlıdır. Bu dizenin ne kadar uzun olduğu hakkında hiçbir fikriniz yok (boş göstericinin işaretçiye göre konumu). Bu yüzden strlenyalnız çağırmak sizi savunmasızlığa açar. Daha güvenli olmak istiyorsanız kullanın strnlen(str, 100).

Tam kod düzeltildi:

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;
}

Sargı ile cevap doğru. Ama eğer sanmıyorum bir sorun var (len> = 100)

Len 100 olsaydı, 100 öğeyi kopyalardık ve sondaki \ 0 değerine sahip olmazdık. Bu açıkça, uygun sonlu dizeye bağlı diğer işlevlerin orijinal dizinin ötesine geçeceği anlamına gelir.

C'den gelen sorunlu dize IMHO çözülemez. Aramadan önce bazı sınırlarınız olsa iyi olur, ama bu bile yardımcı olmaz. Kontrol sınır yoktur ve bu nedenle tampon taşmaları her zaman olabilir ve ne yazık ki olacak ....

strlenBir kereden fazla çağırmayla ilgili güvenlik sorunlarının ötesinde, uzunluğu kesin olarak bilinen dizelerde dize yöntemleri kullanılmamalıdır [çoğu dize işlevi için, yalnızca kullanılması gereken çok dar bir durum vardır - maksimum uzunluk garanti edilebilir, ancak kesin uzunluk bilinmemektedir]. Giriş dizesinin uzunluğu ve çıkış arabelleğinin uzunluğu bilindikten sonra, bir bölgenin ne kadar büyük kopyalanması gerektiği ve ardından memcpy()söz konusu kopyayı gerçekte gerçekleştirmek için kullanılması gerekir. Sadece 1-3 baytlık bir dizeyi kopyalarken strcpydaha iyi performans göstermesi mümkün olsa da memcpy(), birçok platformda memcpy()daha büyük dizelerle uğraşırken iki kat daha hızlıdır.

Güvenlik performans maliyetiyle gelirdi bazı durumlar olsa da, bu güvenli yaklaşımdır bir durum da daha hızlı bir. Bazı durumlarda, girişleri besleyen kodun iyi davranacağından emin olabilirse ve kötü niyetli girişlere karşı korunma performansı engelleyecekse, garip davranan girişlere karşı güvenli olmayan kodlar yazmak makul olabilir. Dize uzunluklarının yalnızca bir kez kontrol edildiğinden emin olmak hem performansı hem de güvenliği geliştirir , ancak dize uzunluğunu manuel olarak izlerken bile güvenliği korumak için ek bir şey yapılabilir: sondaki boş olması beklenen her dize için, sondaki boşluğu açıkça yazın kaynak dizeye sahip olmasını beklemektense. Dolayısıyla, eğer bir kişi strdupeşdeğeri yazıyorsa :

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;
}

Memcpy len+1baytları işlediyse son ifadenin genellikle atlanabileceğini , ancak başka bir iş parçacığının kaynak dizgiyi değiştirmesi gerektiğini unutmayın, sonuç NUL sonlandırılmamış bir hedef dize olabilir.