为什么strcpy和strncpy使用不安全？-yiteyi-C++库

strcpy（）函数

null

这个 strcpy（）函数用于将源字符串复制到目标字符串。如果dest string的缓冲区大小大于src string，则将src string复制到dest string，并以空字符结尾。但如果dest buffer较小，则src将复制内容而不终止空字符。字符串不能重叠，目标字符串必须足够大才能接收副本。

语法：

char *strcpy( char *dest, const char *src )

参数： 该函数接受两个参数，如下所述：

src： 将被复制的字符串。
目的地： 指向要复制内容的目标数组的指针。

返回值： 它返回指向目标字符串的指针。

                     // C Program  to illustrate the                   
                     // strcpy() function in C/C++                   
                     #include <stdio.h>                   
                     #include <string.h>                   
                     int                               main()                   
                     {                   
                                         char                               src[] =                               "geeksforgeeks"                               ;                   
                             
                                         // Here destination is large enough                   
                                         // to store the src with Null                   
                                         // character at the end                   
                                         char                               dest[14];                   
                             
                                         // copying src into dest.                   
                                         strcpy                               (dest, src);                   
                                         printf                               (                               "Copied string: %s"                               , dest);                   
                             
                                         return                               0;                   
                     }                   

输出：

Copied string: geeksforgeeks

strcpy（）有问题： strcpy（）函数没有指定目标数组的大小，因此缓冲区溢出通常是一种风险。使用strcpy（）函数将一个大字符数组复制到一个小字符数组中是危险的，但如果字符串合适，那么就不值得冒险。如果目标字符串不够大，无法存储源字符串，则strcpy（）的行为未指定或未定义。

                     // C Program  to illustrate the problem in                   
                     // strcpy() function in C/C++                   
                     #include <stdio.h>                   
                     #include <string.h>                   
                     int                               main()                   
                     {                   
                                         char                               src[] =                               "geeksforgeeks"                               ;                   
                             
                                         // Here destination is not large                   
                                         // enough to store the src. so the                   
                                         // behaviour of strcpy is unspecified.                   
                                         // program may crashed, but its                   
                                         // printing geeksforgeeks                   
                                         char                               dest[2];                   
                             
                                         // copying src into dest.                   
                                         strcpy                               (dest, src);                   
                                         printf                               (                               "Copied string: %s"                               , dest);                   
                             
                                         return                               0;                   
                     }                   

输出：

Copied string: geeksforgeeks

strncpy（）函数

strncpy（）函数与strcpy（）函数类似，只是最多复制n个字节的src。如果src的前n个字符中没有空字符，则放置在dest中的字符串将不会以空结尾。如果src的长度小于n，strncpy（）会向dest写入额外的空字符，以确保总共写入n个字符。

语法：

char *strncpy( char *dest, const char *src, size_t n )

参数： 该函数接受两个参数，如下所述：

src： 将被复制的字符串。
目的地： 指向要复制内容的目标数组的指针。
n: 从src复制到dest的第一个n字符。

返回值： 它返回指向目标字符串的指针。

例子：

                     // C Program  to illustrate the                   
                     // strcpy() function in C/C++                   
                     #include <stdio.h>                   
                     #include <string.h>                   
                     int                               main()                   
                     {                   
                                         char                               src[] =                               "geeksforgeeks"                               ;                   
                             
                                         // The destination string size is 14.                   
                                         char                               dest[14];                   
                             
                                         // copying n bytes of src into dest.                   
                                         strncpy                               (dest, src, 14);                   
                                         printf                               (                               "Copied string: %s"                               , dest);                   
                             
                                         return                               0;                   
                     }                   

输出：

Copied string: geeksforgeeks

strncpy（）有问题： 如果src的前n个字符中没有空字符，则放置在dest中的字符串将不会以空结尾。因此strncpy（）不能保证目标字符串以NULL结尾。strlen（）非终止字符串可能会导致segfault。换句话说，在C/C++中，一个未终止的字符串是一个正等待销毁代码的定时炸弹。

                     // C Program  to illustrate the problem in                   
                     // strcpy() function in C/C++                   
                     #include <stdio.h>                   
                     #include <string.h>                   
                     int                               main()                   
                     {                   
                                         char                               src[] =                               "geeksforgeeks"                               ;                   
                             
                                         // The destination sting size is 8                   
                                         // which is less than length of src.                   
                                         char                               dest[8];                   
                             
                                         // copying 8 bytes of src into dest.                   
                                         // dest is not NULL terminated.                   
                                         strncpy                               (dest, src, 8);                   
                             
                                         // using strlen function on non terminated.                   
                                         // string which can cause segfault.                   
                                         int                               len =                               strlen                               (dest);                   
                             
                                         printf                               (                               "Copied string: %s"                               , dest);                   
                                         printf                               (                               "Length of destination string: %d"                               , len);                   
                             
                                         return                               0;                   
                     }                   

输出：

Copied string: geeksfor
Length of destination string: 8

现在，下一个问题是，任何保证目标字符串将以NULL结尾且不会出现缓冲区溢出的函数？

因此，上述问题的答案是“是”，在“stdio.h”库中有几个函数可以保证满足上述条件。

snprintf
strlcpy

这两个函数都保证目标字符串以NULL结尾。同样地， snprintf（）函数，strlcpy函数将最多dest_size-1个字符（dest_size是目标字符串缓冲区的大小）从src复制到dst，必要时截断src。结果总是以null结尾。函数返回strlen（src）。缓冲区溢出的检查方法如下：

 if (strlcpy(dst, src, dstsize) >= dest_size)
         return -1;

根据健全程度对功能进行排序：

strcpy < strncpy < snprintf < strlcpy

文章版权归作者所有，未经允许请勿转载。

THE END