为什么此代码容易受到缓冲区溢出攻击？

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

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

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

这段代码很容易受到缓冲区溢出攻击，因此我试图找出原因。我认为这与len被声明为a short而不是a 有关int，但我不确定。

有任何想法吗？

在大多数编译器上，an的最大值unsigned short为65535。

高于该值的任何值都会被环绕，因此65536变为0，而65600变为65。

这意味着正确长度的长字符串（例如65600）将通过检查，并溢出缓冲区。

使用size_t存储的结果strlen()，而不是unsigned short，并比较len以直接编码的大小的表达buffer。因此，例如：

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

问题在这里：

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

如果字符串大于目标缓冲区的长度，strncpy仍将其复制过来。您将字符串的字符数作为要复制的数字而不是缓冲区的大小。正确的方法如下：

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

这是将复制的数据量限制为缓冲区的实际大小减去空终止符的数量。然后，我们将缓冲区中的最后一个字节设置为空字符，以此作为附加保护措施。原因是因为strncpy将复制最多n个字节，包括终止空值，如果strlen（str）<len-1。串。

希望这可以帮助。

编辑：经过进一步检查并从其他人输入，该函数的可能编码如下：

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

由于我们已经知道了字符串的长度，因此可以使用memcpy将字符串从str引用的位置复制到缓冲区中。请注意，在strlen（3）的手册页上（在FreeBSD 9.3系统上），声明如下：

 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.

我将其解释为字符串的长度不包含null。这就是为什么我复制len + 1个字节以包含null的原因，并且测试检查以确保长度<缓冲区的大小-2。减去1，因为缓冲区从位置0开始，然后减去另一个，以确保有空间为空。

编辑：事实证明，某些东西的大小以1开头，而访问以0开头，所以之前的-2是不正确的，因为它对于大于98字节的任何内容都会返回错误，但应该大于99字节。

编辑：尽管关于无符号短路的答案通常是正确的，因为可以表示的最大长度为65,535个字符，但这并不重要，因为如果字符串长于该长度，则该值将环绕。就像拿了75,231（即0x000125DF）并屏蔽掉了前16位一样，您得到了9695（0x000025DF）。我看到的唯一问题是长度超过65,535的前100个字符，因为长度检查将允许复制，但是在所有情况下，它最多只能复制字符串的前100个字符，并且null终止字符串。因此，即使存在环绕问题，缓冲区仍然不会溢出。

这本身可能会或可能不会带来安全风险，具体取决于字符串的内容及其用途。如果只是可读的纯文本，那么通常就没有问题。您只会得到一个截断的字符串。但是，如果它是URL或SQL命令序列之类的内容，则可能会出现问题。

即使使用strncpy，截止的长度仍取决于传递的字符串指针。您不知道该字符串有多长（即空终止符相对于指针的位置）。因此，strlen独自打电话给您带来了漏洞。如果要更安全，请使用strnlen(str, 100)。

更正的完整代码为：

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

包装的答案是正确的。但是有一个问题，我想如果if（len> = 100）

好吧，如果Len为100，我们将复制100个元素，而我们将没有尾随\ 0。显然，这意味着依赖于正确的结尾字符串的任何其他函数都将超出原始数组。

来自C的有问题的字符串是恕我直言无法解决的。您最好在通话之前设置一些限制，但即使那样也无济于事。没有边界检查，因此缓冲区溢出总是会发生，不幸的是会发生...。

除了涉及strlen多次调用的安全性问题外，通常不应该在长度确切知道的字符串上使用字符串方法[对于大多数字符串函数，只有非常狭窄的情况下才应使用它们-在最大长度的字符串上长度可以保证，但确切的长度未知]。一旦知道了输入字符串的长度并且知道了输出缓冲区的长度，就应该弄清楚应该复制多大的区域，然后memcpy()实际使用它进行复制。尽管仅复制1-3个字节左右的字符串时，strcpy性能可能会表现不佳memcpy()，但在许多平台memcpy()上，处理较大的字符串时，速度可能会快两倍以上。

尽管在某些情况下安全性是以性能为代价的，但是在这种情况下，安全方法也是一种更快的方法。在某些情况下，如果提供输入的代码可以确保它们表现良好，并且防范不良行为的输入会妨碍性能，那么编写一些对行为异常的输入并不安全的代码可能是合理的。确保字符串长度只检查一次提高都性能和安全性，但一个额外的东西可以手动跟踪字符串长度，即使做帮助守卫安全：每预计将尾随的空字符串，写结尾的空明确而比期望源字符串有它。因此，如果有人在写一篇strdup等效的书：

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+1字节，则通常可以省略最后一条语句，但是另一个线程将修改源字符串，结果可能是非NUL终止的目标字符串。