Tại sao mã này dễ bị tấn công tràn bộ đệm?

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

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

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

Mã này dễ bị tấn công tràn bộ đệm và tôi đang cố gắng tìm hiểu tại sao. Tôi nghĩ rằng nó có liên quan đến việc lenđược tuyên bố shortthay vì một int, nhưng tôi không thực sự chắc chắn.

Có ý kiến ​​gì không?

Trên hầu hết các trình biên dịch, giá trị tối đa của an unsigned shortlà 65535.

Bất kỳ giá trị nào ở trên được bao bọc xung quanh, vì vậy 65536 trở thành 0 và 65600 trở thành 65.

Điều này có nghĩa là các chuỗi dài có độ dài phù hợp (ví dụ 65600) sẽ vượt qua kiểm tra và tràn bộ đệm.

Sử dụng size_tđể lưu trữ kết quả của strlen(), không unsigned shortvà so sánh lenvới biểu thức mã hóa trực tiếp kích thước của buffer. Ví dụ:

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

Vấn đề là ở đây:

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

Nếu chuỗi lớn hơn độ dài của bộ đệm đích, strncpy vẫn sẽ sao chép nó qua. Bạn đang căn cứ số lượng ký tự của chuỗi là số cần sao chép thay vì kích thước của bộ đệm. Cách chính xác để làm điều này là như sau:

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

Điều này làm là giới hạn số lượng dữ liệu được sao chép vào kích thước thực của bộ đệm trừ đi một ký tự cho ký tự kết thúc null. Sau đó, chúng tôi đặt byte cuối cùng trong bộ đệm thành ký tự null dưới dạng bảo vệ được thêm vào. Lý do cho điều này là do strncpy sẽ sao chép tối đa n byte, bao gồm cả null kết thúc, nếu strlen (str) <len - 1. Nếu không, thì null không được sao chép và bạn có một kịch bản sự cố vì bây giờ bộ đệm của bạn đã bị lỗi chuỗi.

Hi vọng điêu nay co ich.

EDIT: Sau khi kiểm tra thêm và nhập từ người khác, mã hóa có thể cho chức năng sau:

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

Vì chúng ta đã biết độ dài của chuỗi, chúng ta có thể sử dụng memcpy để sao chép chuỗi từ vị trí được tham chiếu bởi str vào bộ đệm. Lưu ý rằng trên mỗi trang hướng dẫn cho strlen (3) (trên hệ thống FreeBSD 9.3), nội dung sau được nêu:

 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.

Điều tôi giải thích là độ dài của chuỗi không bao gồm null. Đó là lý do tại sao tôi sao chép len + 1 byte để bao gồm null và kiểm tra kiểm tra để đảm bảo rằng độ dài <kích thước của bộ đệm - 2. Trừ đi một vì bộ đệm bắt đầu ở vị trí 0 và trừ đi một bộ đệm khác để đảm bảo có chỗ trống cho null

EDIT: Hóa ra, kích thước của một cái gì đó bắt đầu bằng 1 trong khi truy cập bắt đầu bằng 0, vì vậy -2 trước đó không chính xác vì nó sẽ trả về lỗi cho bất cứ điều gì> 98 byte nhưng nó phải> 99 byte.

EDIT: Mặc dù câu trả lời về một ký hiệu không dấu thường nói chung là chính xác vì độ dài tối đa có thể được biểu thị là 65.535 ký tự, nhưng điều đó không thực sự quan trọng bởi vì nếu chuỗi dài hơn đó, giá trị sẽ bao quanh. Giống như lấy 75.231 (là 0x000125DF) và che giấu 16 bit hàng đầu mang lại cho bạn 9695 (0x000025DF). Vấn đề duy nhất mà tôi thấy với điều này là 100 ký tự đầu tiên vượt qua 65.535 vì kiểm tra độ dài sẽ cho phép sao chép, nhưng nó sẽ chỉ sao chép tối đa 100 ký tự đầu tiên của chuỗi trong mọi trường hợp và vô hiệu hóa chuỗi . Vì vậy, ngay cả với vấn đề xoay vòng, bộ đệm vẫn sẽ không bị tràn.

Điều này có thể hoặc không tự nó gây ra rủi ro bảo mật tùy thuộc vào nội dung của chuỗi và bạn đang sử dụng nó để làm gì. Nếu đó chỉ là văn bản thẳng mà con người có thể đọc được thì nhìn chung không có vấn đề gì. Bạn chỉ cần có được một chuỗi cắt ngắn. Tuy nhiên, nếu đó là một cái gì đó như một URL hoặc thậm chí là một chuỗi lệnh SQL, bạn có thể gặp vấn đề.

Mặc dù bạn đang sử dụng strncpy, độ dài của điểm cắt vẫn phụ thuộc vào con trỏ chuỗi đã qua. Bạn không biết chuỗi đó dài bao nhiêu (vị trí của bộ kết thúc null so với con trỏ, nghĩa là). Vì vậy, gọi strlenmột mình mở ra cho bạn dễ bị tổn thương. Nếu bạn muốn an toàn hơn, hãy sử dụng strnlen(str, 100).

Mã đầy đủ được sửa sẽ là:

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

Câu trả lời với gói là đúng. Nhưng có một vấn đề tôi nghĩ đã không được đề cập nếu (len> = 100)

Chà, nếu Len sẽ là 100, chúng tôi sẽ sao chép 100 phần tử mà chúng tôi không có dấu \ 0. Điều đó rõ ràng có nghĩa là bất kỳ chức năng nào khác tùy thuộc vào chuỗi kết thúc thích hợp sẽ đi xa hơn mảng ban đầu.

Chuỗi có vấn đề từ C là IMHO không thể giải quyết được. Dù sao bạn cũng có một số giới hạn trước cuộc gọi, nhưng thậm chí điều đó sẽ không giúp ích gì. Không có giới hạn kiểm tra và vì vậy tràn bộ đệm luôn có thể và không may sẽ xảy ra ....

Ngoài các vấn đề bảo mật liên quan đến việc gọi strlennhiều lần, người ta thường không nên sử dụng các phương thức chuỗi trên các chuỗi có độ dài được biết chính xác [đối với hầu hết các hàm chuỗi, chỉ có một trường hợp thực sự hẹp mà chúng nên được sử dụng - trên các chuỗi có tối đa chiều dài có thể được đảm bảo, nhưng độ dài chính xác không được biết]. Khi đã biết độ dài của chuỗi đầu vào và độ dài của bộ đệm đầu ra, người ta sẽ tìm ra mức độ lớn của một vùng sẽ được sao chép và sau đó sử dụng memcpy()để thực sự sao chép trong câu hỏi. Mặc dù có thể có khả năng strcpyvượt trội hơn memcpy()khi sao chép một chuỗi chỉ 1-3 byte hoặc hơn, nhưng trên nhiều nền tảng memcpy()có thể sẽ nhanh hơn gấp đôi khi xử lý các chuỗi lớn hơn.

Mặc dù có một số tình huống mà bảo mật sẽ phải trả giá bằng hiệu năng, nhưng đây là tình huống mà cách tiếp cận an toàn cũng nhanh hơn. Trong một số trường hợp, có thể hợp lý khi viết mã không an toàn trước các đầu vào có hành vi kỳ quặc, nếu mã cung cấp đầu vào có thể đảm bảo chúng sẽ hoạt động tốt và nếu bảo vệ chống lại các đầu vào có hành vi xấu sẽ cản trở hiệu suất. Đảm bảo rằng độ dài chuỗi chỉ được kiểm tra một lần giúp cải thiện cả hiệu suất và bảo mật, mặc dù có thể thực hiện thêm một điều nữa để giúp bảo vệ an ninh ngay cả khi theo dõi độ dài chuỗi theo cách thủ công: đối với mọi chuỗi được dự kiến ​​là null, hãy viết rõ ràng theo dõi null hơn mong đợi chuỗi nguồn có nó. Vì vậy, nếu một người đang viết strduptương đương:

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

Lưu ý rằng câu lệnh cuối cùng thường có thể được bỏ qua nếu memcpy đã xử lý len+1byte, nhưng một luồng khác là sửa đổi chuỗi nguồn, kết quả có thể là chuỗi đích không kết thúc NUL.