Tại sao strncpy không null chấm dứt?

Question 1

strncpy()được cho là bảo vệ khỏi sự cố tràn bộ đệm. Nhưng nếu nó ngăn tràn mà không kết thúc null, thì rất có thể một hoạt động chuỗi tiếp theo sẽ bị tràn. Vì vậy, để bảo vệ khỏi điều này, tôi thấy mình phải:

strncpy( dest, src, LEN );
dest[LEN - 1] = '\0';

man strncpy cho:

Các strncpy()chức năng cũng tương tự, ngoại trừ việc không quá nbyte srcđược sao chép. Do đó, nếu không có byte nào trong số các nbyte đầu tiên của src, kết quả sẽ không được kết thúc bằng null.

Nếu không có null chấm dứt một cái gì đó dường như vô tội như:

   printf( "FOO: %s\n", dest );

... có thể bị rơi.

Có lựa chọn thay thế tốt hơn, an toàn hơn strncpy()không?

Question 2

strncpy()không nhằm mục đích sử dụng an toàn hơn strcpy(), nó được sử dụng để chèn một chuỗi vào giữa chuỗi khác.

Tất cả các chức năng xử lý chuỗi "an toàn" đó như snprintf()và vsnprintf()là các bản sửa lỗi đã được thêm vào trong các tiêu chuẩn sau này để giảm thiểu khai thác tràn bộ đệm, v.v.

Wikipedia đề cập đến strncat()việc thay thế cho việc viết két sắt của riêng bạn strncpy():

*dst = '\0';
strncat(dst, src, LEN);

BIÊN TẬP

Tôi đã bỏ lỡ strncat()vượt quá ký tự LEN khi null kết thúc chuỗi nếu nó dài hơn hoặc bằng ký tự LEN.

Dù sao, điểm của việc sử dụng strncat()thay vì bất kỳ giải pháp cây nhà lá vườn nào chẳng hạn như memcpy(..., strlen(...))/ bất cứ điều gì là việc triển khai strncat()có thể được tối ưu hóa mục tiêu / nền tảng trong thư viện.

Tất nhiên, bạn cần phải kiểm tra xem dst có giữ ít nhất nullchar không, vì vậy cách sử dụng đúng strncat()sẽ là:

if (LEN) {
    *dst = '\0'; strncat(dst, src, LEN-1);
}

Tôi cũng thừa nhận rằng điều đó strncpy()không hữu ích lắm cho việc sao chép một chuỗi con thành một chuỗi khác, nếu src ngắn hơn n char, chuỗi đích sẽ bị cắt bớt.

Question 3

Ban đầu, hệ thống tệp UNIX Phiên bản thứ 7 (xem DIR (5)) có các mục nhập thư mục giới hạn tên tệp ở 14 byte; mỗi mục nhập trong một thư mục bao gồm 2 byte cho số inode cộng với 14 byte cho tên, đệm null thành 14 ký tự, nhưng không nhất thiết phải kết thúc bằng rỗng. Tôi tin rằng nó strncpy()được thiết kế để hoạt động với các cấu trúc thư mục đó - hoặc, ít nhất, nó hoạt động hoàn hảo cho cấu trúc đó.

Xem xét:

Tên tệp 14 ký tự không được kết thúc bằng rỗng.
Nếu tên ngắn hơn 14 byte, nó sẽ được đệm bằng rỗng đến độ dài đầy đủ (14 byte).

Đây chính xác là những gì sẽ đạt được bằng cách:

strncpy(inode->d_name, filename, 14);

Vì vậy, nó strncpy()được trang bị lý tưởng cho ứng dụng thích hợp ban đầu của nó. Nó chỉ ngẫu nhiên về việc ngăn chặn tràn các chuỗi bị kết thúc bằng null.

(Lưu ý rằng phần đệm null lên đến độ dài 14 không phải là chi phí nghiêm trọng - nếu độ dài của bộ đệm là 4 KB và tất cả những gì bạn muốn là sao chép an toàn 20 ký tự vào đó, thì 4075 null bổ sung là quá mức cần thiết nghiêm trọng và có thể dễ dàng dẫn đến hành vi bậc hai nếu bạn liên tục thêm vật liệu vào bộ đệm dài.)

Question 4

Đã có các triển khai mã nguồn mở như strlcpy thực hiện sao chép an toàn.

http://en.wikipedia.org/wiki/Strlcpy

Trong các tài liệu tham khảo có các liên kết đến các nguồn.

Question 5

Strncpy an toàn hơn trước các cuộc tấn công tràn ngăn xếp bởi người dùng chương trình của bạn, nó không bảo vệ bạn khỏi các lỗi mà lập trình viên thực hiện, chẳng hạn như in một chuỗi không kết thúc bằng null, theo cách bạn đã mô tả.

Bạn có thể tránh gặp sự cố do sự cố mà bạn đã mô tả bằng cách giới hạn số ký tự được printf in ra:

char my_string[10];
//other code here
printf("%.9s",my_string); //limit the number of chars to be printed to 9

Question 6

Một số lựa chọn thay thế mới được chỉ định trong ISO / IEC TR 24731 (Kiểm tra https://buildsecurityin.us-cert.gov/daisy/bsi/articles/knowledge/coding/317-BSI.html để biết thông tin). Hầu hết các hàm này nhận một tham số bổ sung chỉ định độ dài tối đa của biến đích, đảm bảo rằng tất cả các chuỗi đều được kết thúc bằng null và có tên kết thúc bằng _s(cho "safe"?) Để phân biệt chúng với các phiên bản "không an toàn" trước đó của chúng . ¹

Rất tiếc, chúng vẫn đang được hỗ trợ và có thể không khả dụng với bộ công cụ cụ thể của bạn. Các phiên bản sau của Visual Studio sẽ đưa ra cảnh báo nếu bạn sử dụng các chức năng cũ không an toàn.

Nếu các công cụ của bạn không hỗ trợ các chức năng mới, thì việc tạo trình bao bọc của riêng bạn cho các chức năng cũ sẽ khá dễ dàng. Đây là một ví dụ:

errCode_t strncpy_safe(char *sDst, size_t lenDst,
                       const char *sSrc, size_t count)
{
    // No NULLs allowed.
    if (sDst == NULL  ||  sSrc == NULL)
        return ERR_INVALID_ARGUMENT;

   // Validate buffer space.
   if (count >= lenDst)
        return ERR_BUFFER_OVERFLOW;

   // Copy and always null-terminate
   memcpy(sDst, sSrc, count);
   *(sDst + count) = '\0';

   return OK;
}

Bạn có thể thay đổi chức năng để phù hợp với nhu cầu của mình, chẳng hạn như luôn sao chép nhiều chuỗi nhất có thể mà không bị tràn. Trên thực tế, việc triển khai VC ++ có thể thực hiện điều này nếu bạn chuyển _TRUNCATEnhư sau count.

¹ Tất nhiên, bạn vẫn cần phải chính xác về kích thước của bộ đệm đích: nếu bạn cung cấp bộ đệm 3 ký tự nhưng nói rằng strcpy_s()nó có khoảng trống cho 25 ký tự, bạn vẫn đang gặp rắc rối.

Question 7

Sử dụng strlcpy(), được chỉ định ở đây:http://www.courtesan.com/todd/papers/strlcpy.html

Nếu libc của bạn không có triển khai, hãy thử cách này:

size_t strlcpy(char* dst, const char* src, size_t bufsize)
{
  size_t srclen =strlen(src);
  size_t result =srclen; /* Result is always the length of the src string */
  if(bufsize>0)
  {
    if(srclen>=bufsize)
       srclen=bufsize-1;
    if(srclen>0)
       memcpy(dst,src,srclen);
    dst[srclen]='\0';
  }
  return result;
}

(Do tôi viết vào năm 2004 - dành riêng cho phạm vi công cộng.)

Question 8

strncpy hoạt động trực tiếp với bộ đệm chuỗi có sẵn, nếu bạn đang làm việc trực tiếp với bộ nhớ của mình, bây giờ bạn PHẢI kích thước bộ đệm và bạn có thể đặt '\ 0' theo cách thủ công.

Tôi tin rằng không có giải pháp thay thế nào tốt hơn ở C đơn giản, nhưng nó không thực sự tệ đến mức nếu bạn cẩn thận như khi chơi với bộ nhớ thô.

Question 9

Thay vì strncpy() , bạn có thể sử dụng

snprintf(buffer, BUFFER_SIZE, "%s", src);

Đây là một chữ lót sao chép nhiều nhất size-1các ký tự không phải là ký tự rỗng từ srcđến destvà thêm một dấu chấm hết rỗng:

static inline void cpystr(char *dest, const char *src, size_t size)
{ if(size) while((*dest++ = --size ? *src++ : 0)); }

Question 10

Tôi luôn thích:

 memset(dest, 0, LEN);
 strncpy(dest, src, LEN - 1);

để khắc phục sự cố sau đó, nhưng đó thực sự chỉ là vấn đề ưu tiên.

Question 11

Các chức năng này đã phát triển nhiều hơn là được thiết kế, vì vậy thực sự không có "tại sao". Bạn chỉ phải học "cách". Thật không may, ít nhất các trang người đàn ông linux không có các ví dụ trường hợp sử dụng phổ biến cho các hàm này và tôi đã nhận thấy rất nhiều trường hợp sử dụng sai trong mã mà tôi đã xem xét. Tôi đã thực hiện một số ghi chú ở đây: http://www.pixelbeat.org/programming/gcc/string_buffers.html

Question 12

Không dựa vào các tiện ích mở rộng mới hơn, trước đây tôi đã làm một việc như thế này:

/* copy N "visible" chars, adding a null in the position just beyond them */
#define MSTRNCPY( dst, src, len) ( strncpy( (dst), (src), (len)), (dst)[ (len) ] = '\0')

và có lẽ thậm chí:

/* pull up to size - 1 "visible" characters into a fixed size buffer of known size */
#define MFBCPY( dst, src) MSTRNCPY( (dst), (src), sizeof( dst) - 1)

Tại sao macro thay vì các hàm "tích hợp sẵn" (?) Mới hơn? Bởi vì đã từng có khá nhiều liên kết khác nhau, cũng như các môi trường không phải đơn nguyên (không phải cửa sổ) khác mà tôi phải chuyển qua lại khi tôi làm C hàng ngày.