C语言中字符串函数后隐藏的危险陷阱

winston

C语言最强大的功能就是它的指针。有一句话说的很好：如果你爱编程，那么就会爱C语言，如果你爱C语言，你一定会爱指针。C语言的指针确实强大，随心所欲的修改内存给程序员提供了自由的发挥空间。但是C语言对缓冲区溢出不做检查，使得这种随心所欲的指针操作变得极度危险。内存泄漏，缓冲区溢出等问题往往是程序员们焦头烂额，深受其害。因为这些问题时隐时现，出现问题的地方也许跟问题一点关系都没有，非常难以调试。有时身经百战的程序员也会被这些内存错误搞的彻夜难免，从而通宵达旦的来找错误的根源。正是因为C指针的这种难以驾驭的性质，所以用C语言编写程序的时候一定要注意指针的应用技巧。
        C语言没有提供字符串类型，字符串以字符数组的形式出现，C标准库提供了一些操作字符串的函数，主要有：strcmp 字符串比较函数，strcpy 字符串拷贝函数， strlen 字符串测长函数， strcat字符串连接函数，sprintf格式化字符串拷贝函数等等。因为字符串就是以‘\0’结束的一段内存，这些函数实质上也就是操作内存的函数，所以避免不了的与指针打交道，使得这些函数充满了陷阱，如果这些函数使用不当，很有可能在程序中埋伏下危险的陷阱，使程序的稳定性遭受重创。下面我就字符串使用中一些常见的问题来进行举例说明。
一. strcpy：极度危险的函数，一不小心就会中招，危险指数：四星
        strcpy的原型是这样的：　char *strcpy(char *dest, const char *src) 作为常见的字符串复制函数，C库中的实现是不安全的，因为它不做字符串的检查，以至于如果参数传入了非法指针，比如：src不是指向字符串的指针。后果就不堪设想，程序会一直复制,直到遇到‘\0’才结束，这样很有可能就会使得dest指向的内存区域缓冲区溢出，使得导致不程序相干的部分出现错误，这种错误也许就是致命的。所以使用这个函数一定确保第二个参数传入合法的指针。
例子:

1. #include <string.h>
2. #include <stdlib.h>
3. #include <stdio.h>
5. char dest[5] = {'D'};
6. char mydata[7] = {'m','y','d','a','t','a','\0'};
8. int main(void)
9. {
10.         char i;
11.         char source[5];
12.         char bound[5] = {'&','&','&','&','&'};
14.         for (i = 0; i < 5; i++)
15.                 source[i] = 'S';
17.         printf("before strcopy, mydata is %s\n", mydata);
18.         strcpy(dest, source);
19.         printf("dest is %s\n", dest);
20.         printf("after strcopy, mydata is %s\n", mydata);
22. }

复制代码

        程序中定义了两个全局数组，我们知道C语言的全局变量要放在DATA段，而dest与mydata因为定义相连，所以其内存地址是相邻的。程序的目的是复制一个字符串到dest数组，而程序中忘了给source数组最后加上'\0'。所以source就不是一个字符串，用它传递给strcpy就会造成意想不到的后果。本程序中strcpy一直复制内存到dest，直到在遇到‘\0’， 这样就会多复制很多数据到dest，从而意外的覆盖mydata，甚至有时还会导致程序崩溃。在拷贝之前, mydata的数据是 "mydata", 而在拷贝之后造成了意外的修改。
二. strcat 造成缓冲区溢出的隐形杀手，危险指数 三星
        strcat 是将一个字符串连接到另外一个字符串上，其函数原型为char *strcat(char *dest,char *src)。这个函数也很危险，因为C语言的实现也是不安全的，传入非法的指针有可能会造成程序的崩溃。首先保证两个指针都应该指向字符串，其次dest指针指向的空间要足以容的下src指向的字符串，否则会造成缓冲区溢出而破坏其他程序数据。
例子1：

1. #include <string.h>
2. #include <stdlib.h>
3. #include <stdio.h>
5. char dest[5] = {'D', '\0'};
6. char mydata[7] = {'m','y','d','a','t','a','\0'};
8. int main(void)
9. {
10.         char i;
11.         char source[5];
12.         char bound[5] = {'&','&','&','&','&'};
14.         for (i = 0; i < 4; i++)
15.                 source[i] = 'S';
16.         source[4] = '\0';
17.         printf("before strcat, mydata is %s\n", mydata);
18.         strcat(dest, source);
19.         printf("dest is %s\n", dest);
20.         printf("after strcat, mydata is %s\n", mydata);
22. }

复制代码

    这个例子因为目标dest只有5个字节大小，并且数据占了一个字节，只剩下四个字节位置，而源数据字符串长度为4个字符加一个‘\0’有五个字节大小，所以会多出一个字节覆盖了mydata的数据，多出的‘\0’成为了mydata的第一个字节，导致调用strcat后输出mydata为空。
例子2 ：

1. #include <string.h>
2. #include <stdlib.h>
3. #include <stdio.h>
5. char dest[5] = {'D', 'D', 'D', 'D', 'D'};
6. char mydata[7] = {'m','y','d','a','t','a','\0'};
8. int main(void)
9. {
10.         char i;
11.         char source[5];
12.         char bound[5] = {'&','&','&','&','&'};
14.         for (i = 0; i < 4; i++)
15.                 source[i] = 'S';
16.         source[4] = '\0';
17.         printf("before strcat, mydata is %s\n", mydata);
18.         strcat(dest, source);
19.         printf("dest is %s\n", dest);
20.         printf("after strcat, mydata is %s\n", mydata);
22. }

复制代码

        这个例子中，dest不是字符串（没有‘\0’结尾），导致strcat从地址dest处开始找'\0'，找到'\0'后并在此地址上复制source的数据，在本程序中就将source连接到了mydata后面，导致mydata变成了“mydataSSSS”,这样也破坏了程序无关的数据，本程序中还好是破坏的DATA中的数据，如果是其他的数据那么后果不不仅仅是数据改变这么简单了。
三.  strlen 很多malloc函数缓冲区溢出问题的始作俑者 危险指数 二星
        strlen是字符串求长函数，但是它求出的长度不包括‘\0’，所以在用malloc分配内存的时候，很容易少分配一个字节，就这小小的一个字节就会造成缓冲区溢出，我们知道malloc分配的内存区域是有一个头的，这样就有可能破坏其他malloc的头使得内存释放失败，带来一系列连锁反映。因为malloc函数的实现与系统有关，这个不好用程序模拟，但是这种情况确实存在。因此如果用strlen求字符串长度用于malloc一定要记住要加1。
四.  sprintf 同样可以造成缓冲区溢出，危险指数 一星
        sprintf是格式化字符拷贝函数，函数原型是int sprintf( char *buffer, const char *format, … ) 。这个函数的实现也是不安全的，使用这个函数要确保buffer足够大，否则这个函数在不做任何提示的情况下就将buffer溢出，这个函数虽然返回复制的字节数，可以通过这个检查复制了多少个字节，以确定是否缓冲区溢出。但这种亡羊补牢的做法其实没有实际意义。缓冲区溢出的错误已经发生也许会是程序崩溃，检测的时间也许都没有，就算有检测时间，也只是用于提示程序的BUG，在正式的程序中没有多大用处。
例子：

1. #include <string.h>
2. #include <stdlib.h>
3. #include <stdio.h>
5. char dest[2] = {'D'};
6. char mydata[7] = {'m','y','d','a','t','a','\0'};
8. int main(void)
9. {
10.         char i;
11.         char source[5];
12.         char bound[5] = {'&','&','&','&','&'};
14.         for (i = 0; i < 4; i++)
15.                 source[i] = 'S';
16.         source[4] = '\0';
17.         printf("before sprintf, mydata is %s\n", mydata);
18.         sprintf(dest, "%s", source);
19.         printf("dest is %s\n", dest);
20.         printf("after sprintf, mydata is %s\n", mydata);
22. }

复制代码

         这个例子中，目标缓冲区只有两个字节的大小，而源字符串却是五个字节，sprintf在不进行任何提示的情况下，默默的覆盖了mydata的数据。
总结         
        总上所述，C语言字符串操作函数一般都不对参数做检查，需要调用者确保参数的合法性。如果传入不正确的参数，就会造成缓冲区溢出。轻则数据被修改，重则程序崩溃。最郁闷的是影响到程序中不相关的部分。我前面举的例子都很简单，很容易一眼看出问题的所在，但是大型程序就不会这么简单了，这些错误就是致命的。所以使用C语言的字符串函数时一定要养成良好的习惯，自己检查参数的合法性，然后再调用。目前C语言中这些字符串操作函数都有一些安全的版本就是带n的系列，比如：strncpy，strncat，snprintf。这些函数规定了源字符串的大小，对缓冲区溢出的预防有一定的作用，比如：snprintf，其函数原型是int snprintf(char *str, size_t size, const char *format, ...) 第二个参数size，可以保证复制size个字节，如果要复制的字符串大于size就会截短，从而保证str不会溢出。程序中尽量使用这些安全的版本。良好的习惯是一个程序稳定与健壮的保证，而良好的习惯都是使用这些常用的函数养成的，所以一定要主要这些字符串函数的使用。



作者：YAOZHENGUO2006 发表于2012-5-23 15:11:55 原文链接

steven99ca

呵呵，这个俺要严重支持！类似还有memcpy...