C 安全函数

在 C 语言中，为了提高代码的安全性，尤其是防止缓冲区溢出等常见的安全问题，C11 标准引入了一些 "安全函数"，也称为 "Annex K" 标准库函数。这些安全函数主要是标准字符串和内存操作函数的增强版本，通过增加参数（如缓冲区大小）来提供更好的错误检测和处理。

安全函数的特点：

  • 缓冲区大小检查：所有的安全函数都要求传入目标缓冲区的大小参数，以防止缓冲区溢出。
  • 返回值检查：大多数函数返回 errno_t 类型的错误代码，可以检查函数是否成功执行。
  • 更好的错误处理：当缓冲区大小不够或出现其他问题时，这些函数会返回错误码，并尝试清空或初始化输出缓冲区。

安全函数在 Visual Studio 等编译器中得到较好的支持，但在一些较老版本的编译器中可能不可用，需要注意兼容性。

以下是 C 中常见的安全函数及其对应的传统函数对比：

1、字符串操作安全函数

strcpy_s：安全版本的 strcpy，复制字符串并检查目标缓冲区大小。

errno_t strcpy_s(char *dest, rsize_t destsz, const char *src);

strcat_s：安全版本的 strcat，将源字符串追加到目标字符串末尾，并检查缓冲区大小。

errno_t strcat_s(char *dest, rsize_t destsz, const char *src);

strncpy_s：安全版本的 strncpy，复制最多 n 个字符，并检查缓冲区大小。

errno_t strncpy_s(char *dest, rsize_t destsz, const char *src, rsize_t count);

strncat_s：安全版本的 strncat，追加最多 n 个字符到目标字符串末尾，并检查缓冲区大小。

errno_t strncat_s(char *dest, rsize_t destsz, const char *src, rsize_t count);

strtok_s：安全版本的 strtok，引入上下文参数，解决线程安全问题。

char *strtok_s(char *str, const char *delim, char **context);

2、格式化输出安全函数

sprintf_s：安全版本的 sprintf，格式化输出到字符串时检查缓冲区大小。

int sprintf_s(char *buffer, rsize_t sizeOfBuffer, const char *format, ...);

snprintf_s：安全版本的 snprintf，格式化输出时限制字符数并检查缓冲区大小。

int snprintf_s(char *buffer, rsize_t sizeOfBuffer, const char *format, ...);

vsprintf_s：安全版本的 vsprintf，接收 va_list 参数列表，并检查缓冲区大小。

int vsprintf_s(char *buffer, rsize_t sizeOfBuffer, const char *format, va_list argptr);

3、内存操作安全函数

memcpy_s：安全版本的 memcpy，复制内存区域时检查目标缓冲区大小。

errno_t memcpy_s(void *dest, rsize_t destsz, const void *src, rsize_t count);

memmove_s：安全版本的 memmove，复制内存区域，允许重叠，并检查目标缓冲区大小。

errno_t memmove_s(void *dest, rsize_t destsz, const void *src, rsize_t count);

memset_s：安全版本的 memset，将指定的字符填充到内存块中，并检查缓冲区大小。

errno_t memset_s(void *dest, rsize_t destsz, int ch, rsize_t count);

4、其他常用安全函数

_itoa_s 和 _ultoa_s：安全版本的整数转换函数，将整数转换为字符串时检查目标缓冲区大小。

errno_t _itoa_s(int value, char *buffer, size_t sizeOfBuffer, int radix);
errno_t _ultoa_s(unsigned long value, char *buffer, size_t sizeOfBuffer, int radix);

_strlwr_s 和 _strupr_s：将字符串转换为小写或大写的安全版本。

errno_t _strlwr_s(char *str, size_t numberOfElements);
errno_t _strupr_s(char *str, size_t numberOfElements);

实例

以下是使用 C 安全函数进行字符串操作和内存操作的示例，展示它们如何避免常见的缓冲区溢出问题并提供更安全的编程方式。

示例 1：strcpy_s 和 strcat_s

实例

#include <stdio.h>
#include <string.h>

int main() {
    char dest[20]; // 目标缓冲区大小为 20
    const char *src = "Hello, World!";

    // 使用 strcpy_s 将 src 复制到 dest
    if (strcpy_s(dest, sizeof(dest), src) != 0) {
        printf("strcpy_s failed!\n");
        return 1; // 返回错误代码
    } else {
        printf("After strcpy_s: %s\n", dest);
    }

    // 使用 strcat_s 将 " C Language" 追加到 dest
    const char *appendStr = " C Language";
    if (strcat_s(dest, sizeof(dest), appendStr) != 0) {
        printf("strcat_s failed!\n");
        return 1; // 返回错误代码
    } else {
        printf("After strcat_s: %s\n", dest);
    }

    return 0;
}

输出:

After strcpy_s: Hello, World!
strcat_s failed!

在上述代码中，strcpy_s 成功复制了字符串 "Hello, World!" 到 dest，但由于 dest 的大小为 20，不足以容纳 "Hello, World! C Language"，所以 strcat_s 会检测到缓冲区不足，并返回错误代码。

示例 2：memcpy_s

实例

#include <stdio.h>
#include <string.h>

int main() {
    char src[] = "Sensitive Data";
    char dest[15]; // 目标缓冲区大小为 15

    // 使用 memcpy_s 将数据复制到 dest
    if (memcpy_s(dest, sizeof(dest), src, strlen(src) + 1) != 0) {
        printf("memcpy_s failed!\n");
        return 1; // 返回错误代码
    } else {
        printf("After memcpy_s: %s\n", dest);
    }

    return 0;
}

输出:

After memcpy_s: Sensitive Data

此示例中，memcpy_s 检查了目标缓冲区 dest 是否足够大来容纳 src 的数据，包括字符串末尾的空字符。如果 destsz 小于 strlen(src) + 1，则函数会返回错误并不会执行内存复制。

示例 3：strtok_s

实例

#include <stdio.h>
#include <string.h>

int main() {
    char str[] = "apple,orange,banana";
    char *token;
    char *context = NULL;

    // 使用 strtok_s 分割字符串
    token = strtok_s(str, ",", &context);
    while (token != NULL) {
        printf("Token: %s\n", token);
        token = strtok_s(NULL, ",", &context);
    }

    return 0;
}

输出:

Token: apple
Token: orange
Token: banana

在这个示例中，strtok_s 分割字符串时使用 context 参数来保存上下文信息，从而避免了 strtok 线程不安全的问题。

示例 4：sprintf_s

实例

#include <stdio.h>

int main() {
    char buffer[50];
    int num = 42;
    const char *str = "Hello";

    // 使用 sprintf_s 格式化字符串并检查缓冲区大小
    if (sprintf_s(buffer, sizeof(buffer), "Number: %d, String: %s", num, str) < 0) {
        printf("sprintf_s failed!\n");
        return 1; // 返回错误代码
    } else {
        printf("Formatted String: %s\n", buffer);
    }

    return 0;
}

输出:

Formatted String: Number: 42, String: Hello

在这里，sprintf_s 格式化字符串时，接受缓冲区大小作为参数。如果格式化后的字符串超过了 buffer 的大小，函数会返回错误，从而避免缓冲区溢出。

以上例子展示了使用 C 安全函数进行字符串复制、拼接、内存复制、字符串分割和格式化输出的方式。这些函数提供了对缓冲区大小的检查，显著提高了代码的安全性。