安美资源网

安美资源网

C语言不安全字符串函数导致缓冲区溢出详解 (strcpy, strcat等)

meianmei 0 11 次浏览 未分类

引言

在C语言中，字符串操作函数如 strcpy、strcat、sprintf 以及输入函数 gets 因其简洁性而被广泛使用。然而，这些函数在设计上存在一个共同的缺陷：它们不执行边界检查。这意味着如果目标缓冲区的大小不足以容纳源字符串（对于复制和连接操作）或输入数据（对于输入操作），就会发生缓冲区溢出。缓冲区溢出是一种严重的内存错误，可能导致程序崩溃、数据损坏，甚至成为安全漏洞的入口点。

本文将详细分析这些不安全函数如何导致缓冲区溢出，探讨相关的风险，并通过案例进行说明，最后介绍更安全的替代方案。

1. strcpy导致的缓冲区溢出

strcpy(char *dest, const char *src) 函数用于将源字符串 src（包括末尾的空字符 \0）复制到目标缓冲区 dest。

原理与风险

strcpy 不会检查 dest 指向的缓冲区是否有足够的空间来容纳 src 的全部内容。如果 src 的长度（包括 \0）大于 dest 的容量，strcpy 会继续写入，覆盖 dest 缓冲区之外的相邻内存区域。这可能破坏栈上的其他局部变量、返回地址，或者堆上的其他数据结构。

代码示例

 #include <stdio.h>
 #include <string.h>
 
 int main() {
     char src[] = "This is a very long string that will cause an overflow.";
     char dest[20]; // 目标缓冲区大小为20
 
     printf("Source string: %s\n", src);
     printf("Destination buffer size: %zu\n", sizeof(dest));
 
     // 潜在的缓冲区溢出
     strcpy(dest, src);
     // 此时，dest 缓冲区已经被溢出，src 的内容超出了 dest 的边界
     // 后续行为不可预测
 
     printf("Destination (after strcpy, potentially corrupted): %s\n", dest);
     // 打印 dest 可能会显示完整字符串，但这并不意味着操作安全
     // 它可能已经覆盖了栈上的其他数据
 
     int important_variable = 123;
     printf("An important variable (before potential corruption by overflow): %d\n", important_variable);
     // 如果 dest 和 important_variable 在栈上相邻且溢出影响到它，其值可能已改变
 
     // 模拟溢出后，important_variable 可能被修改的情况
     // (实际效果取决于编译器、操作系统和内存布局)
     // strcpy(dest, src); // 再次执行，确保溢出发生
     // printf("An important variable (after potential corruption by overflow): %d\n", important_variable);
 
     return 0;
 }

在这个例子中，src 字符串的长度远大于 dest 缓冲区的容量。strcpy(dest, src) 会导致 dest 溢出，数据会写入到栈上 dest 相邻的内存区域，可能会覆盖 main 函数栈帧中的其他变量（如 important_variable，尽管在这个简单示例中编译器优化和布局可能使其不直接可见）或返回地址。

2. strcat导致的缓冲区溢出

strcat(char *dest, const char *src) 函数用于将源字符串 src（包括末尾的空字符 \0）追加到目标字符串 dest 的末尾。dest 必须已经包含一个以 \0 结尾的字符串，并且有足够的剩余空间来容纳 src。

原理与风险

与 strcpy 类似，strcat 也不检查 dest 缓冲区是否有足够的剩余空间来追加 src。它首先在 dest 中找到 \0，然后从该位置开始复制 src。如果 dest 中现有字符串的长度加上 src 的长度（包括 \0）超过了 dest 的总容量，就会发生缓冲区溢出。

代码示例

 #include <stdio.h>
 #include <string.h>
 
 int main() {
     char src[] = " World!";
     char dest[20] = "Hello"; // 目标缓冲区大小为20，已包含 "Hello\0"
 
     printf("Destination (before strcat): %s (length: %zu, capacity: %zu)\n", dest, strlen(dest), sizeof(dest));
     printf("Source string: %s (length: %zu)\n", src, strlen(src));
 
     // 目标缓冲区剩余空间: sizeof(dest) - strlen(dest) - 1 (为src的\0)
     // 20 - 5 - 1 = 14
     // 源字符串长度 (包括\0): strlen(src) + 1 = 7 + 1 = 8
     // 14 >= 8，此例中是安全的
 
     strcat(dest, src);
     printf("Destination (after strcat): %s\n", dest);
 
     // 示例：导致溢出的情况
     char small_dest[10] = "Data"; // 容量10, "Data\0" 占5字节, 剩余5字节
     char long_src[] = "is too long"; // 长度11 + 1 = 12字节
                                     // 5 < 12, 会溢出
 
     printf("\nSmall_dest (before strcat): %s (length: %zu, capacity: %zu)\n", small_dest, strlen(small_dest), sizeof(small_dest));
     printf("Long_src string: %s (length: %zu)\n", long_src, strlen(long_src));
 
     // strcat(small_dest, long_src); // 这将导致缓冲区溢出
     // printf("Small_dest (after overflow): %s\n", small_dest);
     // 取消注释上面两行会导致未定义行为
 
     printf("Demonstrating a controlled overflow (for illustration, very unsafe):
 ");
     char buffer_to_overflow[5] = "AAA"; // Capacity 5. "AAA\0" is 4 bytes. 1 byte left.
     char overflow_data[] = "BBBB"; // "BBBB\0" is 5 bytes. Needs 5, has 1. Overflows by 4.
     // strcat(buffer_to_overflow, overflow_data); // This will overflow.
     // printf("Buffer after overflow: %s\n", buffer_to_overflow);
 
     return 0;
 }

3. 其他不安全函数

sprintf

sprintf(char *str, const char *format, ...) 函数根据 format 格式化后续参数，并将结果写入字符串 str。与 strcpy 类似，sprintf 不会检查 str 缓冲区的大小，如果格式化后的字符串长度超过 str 的容量，就会导致溢出。

 char buffer[50];
 int user_id = 12345;
 char user_name[] = "AReallyLongUserNameThatWillCauseAnIssue";
 // 如果 user_name 很长，这里可能溢出 buffer
 // sprintf(buffer, "User ID: %d, Name: %s", user_id, user_name);

gets

gets(char *s) 函数从标准输入读取一行文本，并将其存储到 s 指向的缓冲区中。gets 无法知道缓冲区 s 的大小，因此它会一直读取直到遇到换行符或文件结束符。如果用户输入的行长度超过缓冲区大小，就会发生缓冲区溢出。gets 函数非常危险，已从 C11 标准中移除，并且在许多现代编译器中会产生警告或错误。绝对不应使用。

 // char input_buffer[10];
 // printf("Enter your name: ");
 // gets(input_buffer); // 极度危险！如果输入超过9个字符就会溢出
 // printf("Hello, %s\n", input_buffer);

4. 缓冲区溢出的危害

  1. 程序崩溃：最常见的情况是，溢出覆盖了关键数据（如函数返回地址或栈保护金丝雀值），导致程序在后续操作中访问非法内存或检测到栈损坏，从而触发段错误 (Segmentation Fault) 或其他致命错误而终止。
  2. 数据损坏：溢出的数据可能覆盖程序中的其他变量，导致这些变量的值被意外修改，从而引发逻辑错误和不可预测的程序行为。
  3. 安全漏洞：这是最严重的危害。攻击者可以精心构造输入数据，利用缓冲区溢出向程序的内存中写入恶意代码（shellcode），并覆盖函数返回地址，使其指向这段恶意代码。当函数返回时，程序就会执行攻击者注入的代码，从而可能导致远程代码执行、权限提升等严重安全问题。

5. 如何避免？安全的替代方案

关键在于使用那些能够进行边界检查或允许程序员指定缓冲区大小的函数。

strncpy

strncpy(char *dest, const char *src, size_t n) 最多从 src 复制 n 个字符到 dest。 注意事项：

  • 如果 src 的长度小于 n，dest 的剩余部分会用空字符 \0 填充。
  • 重要：如果 src 的长度（不包括 \0）大于或等于 n，则复制到 dest 的 n 个字符中将不包含空终止符 \0。这意味着你需要手动在 dest[n-1]（如果 n 是缓冲区大小）或 dest 的适当位置添加 \0，前提是 n 小于 dest 的实际容量以留出空间给 \0。
 char dest[20];
 char src[] = "This is a long source.";
 strncpy(dest, src, sizeof(dest) - 1); // 复制最多 sizeof(dest)-1 个字符
 dest[sizeof(dest) - 1] = '\0';       // 确保空终止

strncat

strncat(char *dest, const char *src, size_t n) 最多从 src 追加 n 个字符到 dest 的末尾，然后添加一个空终止符 \0。 注意事项：

  • n 参数指的是从 src 中复制的最大字符数，不包括 src 的空终止符。
  • strncat 总会添加一个空终止符，但你需要确保 dest 的总容量足以容纳 strlen(dest) + n + 1 个字节。
 char dest[20] = "Hello";
 char src[] = ", World!";
 // 剩余空间: sizeof(dest) - strlen(dest) - 1
 size_t remaining_space = sizeof(dest) - strlen(dest) - 1;
 if (remaining_space > 0) {
     strncat(dest, src, remaining_space);
 }
 // dest 现在是 "Hello, World!" (如果空间足够)

snprintf

snprintf(char *str, size_t size, const char *format, ...) 的行为与 sprintf 类似，但它最多向 str 写入 size 个字节（包括空终止符 \0）。如果格式化输出的长度（包括 \0）超过 size，输出会被截断，但 str 仍然会以 \0 正确终止（前提是 size > 0）。这是 sprintf 的安全替代品。

 char buffer[50];
 int user_id = 12345;
 char user_name[] = "AReallyLongUserNameThatWillCauseAnIssue";
 snprintf(buffer, sizeof(buffer), "User ID: %d, Name: %s", user_id, user_name);
 // buffer 现在是安全的，即使 user_name 很长，也不会溢出

fgets

fgets(char *s, int size, FILE *stream) 从指定的 stream 读取最多 size-1 个字符到缓冲区 s 中。它会在读取的字符串末尾自动添加 \0。如果读取的行中包含换行符 \n 且缓冲区足够大，\n 也会被存入 s 中。这是 gets 的安全替代品。

 char input_buffer[20];
 printf("Enter your name (max %zu chars): ", sizeof(input_buffer) - 1);
 if (fgets(input_buffer, sizeof(input_buffer), stdin)) {
     // fgets 可能包含换行符，如果需要可以移除
     input_buffer[strcspn(input_buffer, "\n")] = 0; 
     printf("Hello, %s\n", input_buffer);
 }

C11 Annex K (可选的安全函数)

C11 标准引入了一系列可选的“边界检查”函数，如 strcpy_s、strcat_s、sprintf_s 等。这些函数通常需要提供目标缓冲区的大小作为参数，并在发生错误（如缓冲区不足）时有明确定义的行为（例如返回错误码）。 然而，这些函数是可选的，并非所有编译器都支持它们（例如，GCC/Clang 默认不提供，而 MSVC 支持）。在使用前需要检查编译器的兼容性。

// 示例 (MSVC)
// #define __STDC_WANT_LIB_EXT1__ 1 // 可能需要定义这个宏
// #include <string.h>
// #include <stdio.h>
// 
// char dest_s[20];
// errno_t err = strcpy_s(dest_s, sizeof(dest_s), "Hello");
// if (err == 0) {
//     printf("strcpy_s successful: %s\n", dest_s);
// }

其他策略

  • 动态计算和分配足够大的缓冲区：在使用 malloc 等分配内存时，确保根据源数据的大小计算准确的所需空间。
  • 使用更高级的字符串库：在 C++ 中，应优先使用 std::string，它会自动管理内存并避免许多C风格字符串的陷阱。对于C语言，可以考虑使用经过验证的第三方安全字符串库。

总结

strcpy、strcat、sprintf（无大小限制）和 gets 等C标准库函数由于缺乏边界检查，是导致缓冲区溢出的常见根源。缓冲区溢出不仅会导致程序不稳定，更是严重的安全隐患。

开发者必须时刻警惕这些不安全函数带来的风险，并积极采用更安全的替代方案，如 strncpy、strncat、snprintf 和 fgets，同时要仔细理解这些安全版本函数的行为特性（尤其是关于空终止符和参数含义）。在可能的情况下，考虑使用C11的边界检查接口或更安全的语言/库特性，是编写健壮和安全C代码的关键实践。

原文链接：，转发请注明来源！
安美资源网 › 未分类 › C语言不安全字符串函数导致缓冲区溢出详解 (strcpy, strcat等)