0
0

安全函数与非安全函数

C++ 安全函数使用指南

在C++编程中，处理用户输入是一个常见的任务。然而，不安全的输入处理可能导致缓冲区溢出等安全问题。为了解决这些问题，C++引入了安全函数，如

  1. scanf_s()

、

  1. sscanf_s()

、

  1. fgets_s()

、

  1. strcpy_s()

、

  1. strncpy_s()

、

  1. sprintf_s()

、

  1. snprintf_s()

、

  1. fopen_s()

、

  1. strcat_s()

、

  1. strncat_s()

等。本文将详细介绍这些安全函数的使用，包括安全和非安全函数的比较、具体代码示例及其参数含义。

使用环境

  1. Visual Studio: 至少VS 2005或更高版本。
  2. GCC: 至少4.9版本或更高。
  3. Clang: 3.5版本或更高。
  4. 操作系统: Windows XP SP2及以上，较新的Linux发行版，macOS with Xcode 6及以上。

**

  1. _countof()

**

在以下代码示例中，我们使用了

  1. _countof()

宏来获取数组的大小。这个宏定义在头文件

  1. cstddef

中，返回数组的元素个数。此宏在计算数组大小时返回 

  1. size_t

类型的值，而 

  1. size_t

是一个无符号整数类型。

  1. #define _countof(array) (sizeof(array) / sizeof(array[0]))

**

  1. unsigned

**

在以下代码示例中，我们使用

  1. unsigned

将缓冲区大小强制转换为

  1. unsigned

类型，因为

1. 类型匹配

安全函数，如 

  1. scanf_s

、

  1. sscanf_s

等，要求传递的缓冲区大小参数是 

  1. unsigned

类型。如果不进行强制转换，可能会导致编译器警告或错误，因为 

  1. size_t

类型和 

  1. unsigned

类型虽然都表示无符号整数，但它们可能并不完全相同，尤其是在不同的编译器或平台上。

2. 避免编译器警告

在某些编译器中，如果传递的参数类型不匹配，会产生警告或错误。通过强制转换，可以确保参数类型正确，从而避免编译器警告。

优点

  1. 提高安全性：安全函数要求提供缓冲区大小，有效防止缓冲区溢出。
  2. 标准化：遵循安全编码的最佳实践，有助于编写更可靠的代码。
  3. 防止未定义行为：减少了由于输入数据过长而引起的程序崩溃和其他未定义行为的风险。

缺点

  1. 兼容性问题：并非所有编译器都支持安全函数，可能需要特定的编译器或库支持。
  2. 代码冗长：相比非安全函数，使用安全函数时需要额外指定缓冲区大小，代码可能会显得更冗长。
  3. 学习成本：对习惯了使用非安全函数的开发者来说，需要一定的时间来学习和适应安全函数的用法。

安全函数与非安全函数的比较

1.
  1. scanf()

vs 

  1. scanf_s()
  1. scanf()

用于从标准输入（通常是键盘）读取格式化输入数据，并将其存储到指定的变量中。

参数含义：

  • const char *format：格式化字符串，用于指定要读取的数据类型和格式。
  • ...：可变参数，用于传递要存储读取数据的变量的地址。

**非安全函数示例

  1. scanf()

**

  1. # int scanf(const char *format, ...);
  2. # format：格式化字符串，用于指定要读取的数据类型和格式。
  3. # ...：可变参数，用于传递要存储读取数据的变量的地址。
  4. char buffer[10];
  5. scanf("%s", buffer); // 不安全，可能导致缓冲区溢出

在上面的示例中，如果用户输入超过10个字符，就会导致缓冲区溢出，从而可能引发程序崩溃或其他未定义行为。

**安全函数示例

  1. scanf_s()

**

参数含义：

  • const char *format：格式化字符串，用于指定要读取的数据类型和格式。
  • ...：可变参数，除了要存储读取数据的变量的地址外，还包括这些变量的大小。
  1. # int scanf_s(const char *format, ...);
  2. # format：格式化字符串，用于指定要读取的数据类型和格式。
  3. # ...：可变参数，用于传递要存储读取数据的变量的地址。
  4. char buffer[10];
  5. scanf_s("%9s", buffer, (unsigned)_countof(buffer)); // 安全，指定了缓冲区大小

在这个例子中，

  1. scanf_s()

通过要求提供缓冲区大小参数，有效地防止了缓冲区溢出，确保输入数据不会超过缓冲区限制。

2.
  1. sscanf()

vs 

  1. sscanf_s()
  1. sscanf()

用于从字符串中读取格式化数据，并将其存储到指定的变量中。

参数含义

  • const char *str：包含要解析的输入字符串。
  • const char *format：格式化字符串，用于指定要读取的数据类型和格式。
  • ...：可变参数，用于传递要存储读取数据的变量的地址。

**非安全函数示例：

  1. sscanf()

**

  1. char buffer[50] = "123 456";
  2. int a, b;
  3. sscanf(buffer, "%d %d", &a, &b); // 不安全

在上面的示例中，

  1. sscanf()

没有提供缓冲区大小参数，如果输入数据格式不符，可能导致未定义行为或缓冲区溢出。

**安全函数示例：

  1. sscanf_s()

**

参数含义

  • const char *str：包含要解析的输入字符串。
  • const char *format：格式化字符串，用于指定要读取的数据类型和格式。
  • ...：可变参数，除了要存储读取数据的变量的地址外，还包括这些变量的大小。
  1.     char buffer[50] = "123 456";
  2.     int a, b;
  3.     sscanf_s(buffer, "%d %d", &a, &b); // 安全

在这个例子中，

  1. sscanf_s()

通过要求提供缓冲区大小参数，防止了缓冲区溢出，确保读取的数据不会超出预期范围。

3.
  1. fgets()

vs 

  1. fgets_s()
  1. fgets()

用于从指定的输入流读取一行数据，并将其存储到缓冲区中。

参数含义

  • char *str：用于存储读取数据的缓冲区。
  • int n：要读取的最大字符数（包括终止字符）。
  • FILE *stream：输入流，通常是文件指针。

**非安全函数示例：

  1. fgets()

**

  1. FILE* file = fopen("example.txt", "r");
  2. if (file) {
  3.     char buffer[100];
  4.     fgets(buffer, sizeof(buffer), file); // 可能导致缓冲区溢出
  5.     printf("File content: %s\n", buffer);
  6.     fclose(file);

在上面的示例中，

  1. fgets()

在读取文件内容时，如果输入数据超过缓冲区大小，可能导致缓冲区溢出，尤其在错误处理不当的情况下。

**安全函数示例：

  1. fgets_s()

**

参数含义

  • char *str：用于存储读取数据的缓冲区。
  • rsize_t n：要读取的最大字符数（包括终止字符）。
  • FILE *stream：输入流，通常是文件指针。
  1. FILE* file;
  2. fopen_s(&file, "example.txt", "r");
  3. if (file) {
  4.     char buffer[100];
  5.     fgets_s(buffer, sizeof(buffer), file); // 安全，指定了缓冲区大小
  6.     printf("File content: %s\n", buffer);
  7.     fclose(file);

在这个例子中，

  1. fgets_s()

通过要求提供缓冲区大小参数，有效地防止了缓冲区溢出，确保读取的数据不会超出缓冲区限制。

4.
  1. strcpy()

vs 

  1. strcpy_s()
  1. strcpy()

用于将一个字符串复制到另一个字符串中。

参数含义

  • char *dest：目标缓冲区，用于存储复制的字符串。
  • const char *src：源字符串，要复制的字符串。

**安全函数示例：

  1. fgets_s()

**

  1. char src[] = "Hello, World!";
  2. char dest[10];
  3. strcpy(dest, src); // 可能导致缓冲区溢出

在上面的示例中，

  1. strcpy()

在复制字符串时，如果源字符串长度超过目标缓冲区大小，会导致缓冲区溢出，引发程序崩溃或其他未定义行为。

**安全函数示例：

  1. strcpy_s()

**

参数含义

  • char *dest：目标缓冲区，用于存储复制的字符串。
  • rsize_t destsz：目标缓冲区的大小。
  • const char *src：源字符串，要复制的字符串。
  1. char src[] = "Hello, World!";
  2. char dest[20];
  3. strcpy_s(dest, sizeof(dest), src); // 安全，指定了缓冲区大小

在这个例子中，

  1. strcpy_s()

通过要求提供目标缓冲区大小参数，防止了缓冲区溢出，确保复制操作在安全范围内进行。

5.
  1. strncpy()

vs 

  1. strncpy_s()
  1. strncpy()

用于将指定长度的字符串复制到目标缓冲区。

参数含义

  • char *dest：目标缓冲区，用于存储复制的字符串。
  • const char *src：源字符串，要复制的字符串。
  • size_t n：要复制的最大字符数。

**非安全函数示例：

  1. strncpy()

**

  1. char src[] = "Hello, World!";
  2. char dest[10];
  3. strncpy(dest, src, 5); // 可能导致缓冲区溢出
  4. dest[5] = '\0';

在上面的示例中，

  1. strncpy()

在复制字符串时，如果源字符串长度超过目标缓冲区大小，会导致缓冲区溢出，尤其在未显式添加空终止符的情况下。

**安全函数示例：

  1. strncpy_s()

**

参数含义

  • char *dest：目标缓冲区，用于存储复制的字符串。
  • rsize_t destsz：目标缓冲区的大小。
  • const char *src：源字符串，要复制的字符串。
  • rsize_t n：要复制的最大字符数。
  1. char src[] = "Hello, World!";
  2. char dest[20];
  3. strncpy_s(dest, sizeof(dest), src, 5); // 安全，指定了缓冲区大小
  4. dest[5] = '\0';

在这个例子中，

  1. strncpy_s()

通过要求提供目标缓冲区大小参数，防止了缓冲区溢出，并且确保在目标缓冲区范围内复制数据。

6.
  1. sprintf()

vs 

  1. sprintf_s()
  1. sprintf()

用于将格式化数据写入字符串。

参数含义

  • char *str：目标缓冲区，用于存储格式化的字符串。
  • const char *format：格式化字符串，用于指定要写入的数据类型和格式。
  • ...：可变参数，用于传递要格式化的值。

**非安全函数示例：

  1. sprintf()

**

  1. char buffer[10];
  2. int value = 42;
  3. sprintf(buffer, "Value: %d", value); // 可能导致缓冲区溢出

在上面的示例中，

  1. sprintf()

在格式化字符串时，如果格式化后的字符串长度超过目标缓冲区大小，会导致缓冲区溢出，引发程序崩溃或其他未定义行为。

**安全函数示例：

  1. sprintf_s()

**

参数含义

  • char *str：目标缓冲区，用于存储格式化的字符串。
  • rsize_t strmax：目标缓冲区的大小。
  • const char *format：格式化字符串，用于指定要写入的数据类型和格式。
  • ...：可变参数，用于传递要格式化的值。
  1. char buffer[20];
  2. int value = 42;
  3. sprintf_s(buffer, sizeof(buffer), "Value: %d", value); // 安全，指定了缓冲区大小

在这个例子中，

  1. sprintf_s()

通过要求提供目标缓冲区大小参数，防止了缓冲区溢出，确保格式化操作在安全范围内进行。

7.
  1. snprintf()
  1. snprintf_s()

用于将格式化的字符串写入目标缓冲区，同时提供目标缓冲区大小信息以防止溢出。

  1. snprintf_s()

不存在于标准 C 库中，但 

  1. snprintf()

本身已经是安全的，因为它确保不会写入超过缓冲区大小的数据。

参数含义

  • char *str：目标缓冲区，用于存储格式化的字符串。
  • size_t size：目标缓冲区的大小。
  • const char *format：格式化字符串，用于指定要写入的数据类型和格式。
  • ...：可变参数，用于传递要格式化的值。

**函数示例：

  1. snprintf()

**

  1. char buffer[10];
  2. int value = 42;
  3. snprintf(buffer, sizeof(buffer), "Value: %d", value); // 可能导致缓冲区溢出

在上面的示例中，尽管 

  1. snprintf()

是相对安全的，但如果没有正确计算或检查缓冲区大小，仍可能导致意外行为。

8.
  1. fopen()

vs 

  1. fopen_s()
  1. fopen()

打开一个文件，并返回文件指针。

参数含义

  • const char *filename：要打开的文件的名称。
  • const char *mode：文件打开模式。

**非安全函数示例：

  1. fopen()

**

  1. FILE* file = fopen("example.txt", "r");
  2. if (file) {
  3.     printf("File opened successfully.\n");
  4.     fclose(file);
  5. } else {
  6.     printf("File open error.\n");
  7. }

在上面的示例中，

  1. fopen()

在打开文件失败时，只返回一个空指针，不能提供具体的错误信息，可能会影响调试过程。

**安全函数示例：

  1. fopen_s()

**

参数含义

  • FILE **file：指向文件指针的指针，用于存储打开的文件指针。
  • const char *filename：要打开的文件的名称。
  • const char *mode：文件打开模式。
  1. FILE* file;
  2. errno_t err = fopen_s(&file, "example.txt", "r");
  3. if (err == 0) {
  4.     printf("File opened successfully.\n");
  5.     fclose(file);
  6. } else {
  7.     printf("File open error: %d\n", err);
  8. }

在这个例子中，

  1. fopen_s()

返回错误码，可以提供更多的错误信息，有助于调试和错误处理。

9.
  1. strcat()

vs 

  1. strcat_s()
  1. strcat()

用于将一个字符串连接到另一个字符串的末尾。

参数含义

  • char *dest：目标缓冲区，用于存储连接后的字符串。
  • const char *src：源字符串，要连接的字符串。

**非安全函数示例：

  1. strcat()

**

  1. char dest[10] = "Hello";
  2. char src[] = "World";
  3. strcat(dest, src); // 可能导致缓冲区溢出

在上面的示例中，

  1. strcat()

在连接字符串时，如果源字符串和目标字符串的总长度超过目标缓冲区大小，会导致缓冲区溢出。

**安全函数示例：

  1. strcat_s()

**

参数含义

  • char *dest：目标缓冲区，用于存储连接后的字符串。
  • size_t size：目标缓冲区的大小。
  • const char *src：源字符串，要连接的字符串。
  1. char dest[20] = "Hello";
  2. char src[] = "World";
  3. strcat_s(dest, sizeof(dest), src); // 安全，指定了缓冲区大小

在这个例子中，

  1. strcat_s()

通过要求提供目标缓冲区大小参数，防止了缓冲区溢出，确保连接操作在安全范围内进行。

10.
  1. strncat()

vs 

  1. strncat_s()
  1. strncat()

用于将指定长度的字符串连接到另一个字符串的末尾。

参数含义

  • char *dest：目标缓冲区，用于存储连接后的字符串。
  • const char *src：源字符串，要连接的字符串。
  • rsize_t n：要复制的最大字符数。

**非安全函数示例：

  1. strncat()

**

  1. char dest[10] = "Hello";
  2. char src[] = "World";
  3. strncat(dest, src, 3); // 可能导致缓冲区溢出

在上面的示例中，

  1. strncat()

在连接字符串时，如果源字符串和目标字符串的总长度超过目标缓冲区大小，会导致缓冲区溢出。

**安全函数示例：

  1. strncat_s()

**

参数含义

  • char *dest：目标缓冲区，用于存储连接后的字符串。
  • size_t size：目标缓冲区的大小。
  • const char *src：源字符串，要连接的字符串。
  • rsize_t n：要复制的最大字符数。
  1. char dest[20] = "Hello";
  2. char src[] = "World";
  3. strncat_s(dest, sizeof(dest), src, 3); // 安全，指定了缓冲区大小

在这个例子中，

  1. strncat_s()

通过要求提供目标缓冲区大小参数，防止了缓冲区溢出，确保连接操作在安全范围内进行。

总结

C++标准库提供了多种安全函数来替代传统的不安全函数，这些安全函数通过要求提供缓冲区大小参数，防止了缓冲区溢出和其他未定义行为，提高了程序的安全性。在实际开发中，建议优先使用这些安全函数，以编写更加健壮和可靠的代码。

希望本文对你了解和使用C++安全函数有所帮助。如有疑问或进一步讨论，欢迎在评论区留言。

标签： 开发语言 c++ c语言
本文转载自: https://blog.csdn.net/qq_45947850/article/details/139838762
版权归原作者 疑惑行为指挥官 所有， 如有侵权，请联系我们删除。
登录后发布评论

“安全函数与非安全函数”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？

文章导航
没有找到文章内容分段。。。