传统的C字符串函数（如 strcpy, strcat, sprintf）由于不进行边界检查，很容易导致缓冲区溢出，这是C程序中常见的安全漏洞来源。为了解决这些问题，C11标准的可选附录K（Annex K, "Bounds-checking interfaces"）引入了一系列更安全的函数，通常带有 _s 后缀，例如 strcpy_s, strcat_s, sprintf_s 等。这些函数强制进行边界检查，并在发生错误时有明确定义的行为。

注意：附录K的函数并非所有C编译器都完全支持或默认启用。例如，GCC 和 Clang 通常不提供这些函数，而微软的MSVC编译器则积极支持它们（并可能在编译时对不安全的传统函数发出警告）。如果你的目标平台或编译器不支持这些 _s 函数，你可能需要寻找其他替代方案（如使用 strncpy, strncat 并手动确保空字符结尾，或者使用第三方安全字符串库）。

本节主要介绍这些安全函数的概念和用法，假设在支持的环境中（如MSVC）。

1. 通用设计原则

这些安全的 _s 函数通常遵循以下设计原则：

0. 目标缓冲区大小参数：函数会接受一个额外的参数，明确指定目标缓冲区的大小。
1. 运行时约束处理：如果发生运行时约束违规（如目标缓冲区太小、源或目标指针为NULL等），函数会采取明确的错误处理行为。这通常包括：
2. 将目标缓冲区的第一个字符设置为空字符 \0 (如果目标指针和大小有效)。
3. 返回一个非零的错误码 (通常是 errno_t 类型)。
4. 调用当前已注册的约束处理函数（handler）。默认的约束处理函数可能会终止程序。
5. 确保空字符结尾：成功操作后，目标字符串总是以空字符 \0 结尾（除非目标缓冲区大小为0或发生错误）。

2. strcpy_s()- 安全的字符串复制

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

• dest: 指向目标缓冲区的指针。
• destsz: 目标缓冲区 dest 的大小（以字节为单位）。
• src: 指向源字符串的指针。

行为：

• 从 src 复制字符串（包括结尾的 \0）到 dest。
• 运行时约束检查：
• dest 或 src 不能是 NULL 指针。
• destsz 不能为0，且必须足够大以容纳 src 字符串（包括 \0）。具体来说，strlen(src) + 1 必须小于或等于 destsz。
• 如果发生约束违规：
• 如果 dest 非 NULL 且 destsz 大于0，则 dest[0] 被设置为 \0。
• 返回一个非零错误码。
• 如果成功，返回0。

示例 (MSVC环境)：

 #define __STDC_WANT_LIB_EXT1__ 1 // 需要定义这个宏来启用 _s 函数 (在某些编译器中)
 #include <stdio.h>
 #include <string.h>
 #include <errno.h> // For errno_t
 
 int main() {
     char source[] = "Hello";
     char destination[10];
     char small_destination[3];
     errno_t err;
 
     // 成功复制
     err = strcpy_s(destination, sizeof(destination), source);
     if (err == 0) {
         printf("strcpy_s successful: %s\n", destination);
     } else {
         printf("strcpy_s failed, error: %d\n", err);
     }
 
     // 目标缓冲区太小
     printf("\nAttempting to copy '%s' into a buffer of size %zu\n", source, sizeof(small_destination));
     err = strcpy_s(small_destination, sizeof(small_destination), source);
     if (err == 0) {
         printf("strcpy_s successful (small): %s\n", small_destination);
     } else {
         printf("strcpy_s failed for small_destination, error: %d\n", err);
         // small_destination[0] 应该被设置为 '\0'
         if (sizeof(small_destination) > 0 && small_destination[0] == '\0') {
             printf("small_destination[0] is null as expected.\n");
         }
     }
 
     // 源指针为NULL (运行时约束违规)
     // err = strcpy_s(destination, sizeof(destination), NULL);
     // if (err != 0) { printf("strcpy_s with NULL source failed, error: %d\n", err); }
 
     return 0;
 }

3. strncpy_s()- 安全的定长字符串复制

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

• dest: 目标缓冲区。
• destsz: 目标缓冲区 dest 的大小。
• src: 源字符串。
• count: 最多从 src 复制的字符数。

行为：

• 从 src 最多复制 count 个字符到 dest。
• 与 strncpy 的关键区别：
• strncpy_s 总是会在成功时（且 destsz > 0）以空字符结尾 dest，即使 count 个字符已复制且 src 中没有 \0。
• 如果 src 的长度（不包括 \0）小于 count，则复制整个 src (包括 \0)，然后 dest 的剩余部分（直到 destsz）不会像 strncpy 那样用 \0 填充。
• 运行时约束检查：
• dest 或 src 不能是 NULL (除非 count 为0，此时允许 src 为 NULL)。
• destsz 不能为0。
• 如果 count 不是 _TRUNCATE，则 count 必须小于 destsz，并且 dest 必须能容纳 count 个字符加上一个 \0。
• 如果 count 是 _TRUNCATE，则 src 的内容会被复制到 dest，最多复制 destsz - 1 个字符，并始终以 \0 结尾。如果发生了截断，返回 STRUNCATE。
• 成功时返回0，或在截断时返回 STRUNCATE。发生其他约束违规时返回非零错误码。

示例 (MSVC环境)：

 #define __STDC_WANT_LIB_EXT1__ 1
 #include <stdio.h>
 #include <string.h>
 #include <errno.h>
 
 int main() {
     char source[] = "ThisIsALongString";
     char dest1[10];
     char dest2[10];
     errno_t err;
 
     // 复制固定数量，确保空间足够
     err = strncpy_s(dest1, sizeof(dest1), source, 5); // Copy "ThisI"
     if (err == 0) {
         printf("strncpy_s (count=5) successful: %s\n", dest1); // Output: ThisI
     } else {
         printf("strncpy_s (count=5) failed, error: %d\n", err);
     }
 
     // 使用 _TRUNCATE 进行截断复制
     printf("\nAttempting to copy '%s' into buffer of size %zu with truncation\n", source, sizeof(dest2));
     err = strncpy_s(dest2, sizeof(dest2), source, _TRUNCATE);
     if (err == 0) {
         printf("strncpy_s (_TRUNCATE) successful (no truncation): %s\n", dest2);
     } else if (err == STRUNCATE) {
         printf("strncpy_s (_TRUNCATE) successful (truncation occurred): %s\n", dest2);
         // Output: ThisIsALo (sizeof(dest2)-1 characters + null)
     } else {
         printf("strncpy_s (_TRUNCATE) failed, error: %d\n", err);
     }
     
     // 目标太小，不使用_TRUNCATE
     char dest3[5];
     // err = strncpy_s(dest3, sizeof(dest3), source, 6); // count (6) >= destsz (5) - constraint violation
     // if (err != 0) { printf("strncpy_s with count >= destsz failed, error: %d\n", err); }
 
     return 0;
 }

4. strcat_s()- 安全的字符串连接

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

• dest: 指向目标字符串缓冲区，它必须已包含一个以 \0 结尾的字符串。
• destsz: 目标缓冲区 dest 的总大小。
• src: 指向要追加的源字符串。

行为：

• 将 src 字符串（包括其 \0）追加到 dest 字符串的末尾。
• 运行时约束检查：
• dest 或 src 不能是 NULL。
• destsz 必须大于0。
• dest 必须在 destsz 范围内以 \0 结尾。
• destsz 必须足够大以容纳原始 dest 内容、src 内容以及一个 \0。即 strlen(dest) + strlen(src) + 1 必须小于或等于 destsz。
• 如果发生约束违规，dest[0] 被设为 \0 (如果 dest 非 NULL 且 destsz > 0)，并返回非零错误码。
• 成功时返回0。

示例 (MSVC环境)：

 #define __STDC_WANT_LIB_EXT1__ 1
 #include <stdio.h>
 #include <string.h>
 #include <errno.h>
 
 int main() {
     char destination[20] = "Hello, ";
     char source[] = "World!";
     errno_t err;
 
     printf("Initial destination: '%s' (size %zu)\n", destination, sizeof(destination));
     printf("Source to append: '%s'\n", source);
 
     err = strcat_s(destination, sizeof(destination), source);
     if (err == 0) {
         printf("strcat_s successful: %s\n", destination);
     } else {
         printf("strcat_s failed, error: %d\n", err);
         if (sizeof(destination) > 0 && destination[0] == '\0') {
             printf("destination[0] is null as expected.\n");
         }
     }
 
     char small_dest[10] = "Hi "; // strlen=3, space for 9 + null
     char long_source[] = "There, how are you?"; // Too long
     printf("\nInitial small_dest: '%s' (size %zu)\n", small_dest, sizeof(small_dest));
     err = strcat_s(small_dest, sizeof(small_dest), long_source);
     if (err == 0) {
         printf("strcat_s successful (small_dest): %s\n", small_dest);
     } else {
         printf("strcat_s failed for small_dest, error: %d\n", err);
          if (sizeof(small_dest) > 0 && small_dest[0] == '\0') {
             printf("small_dest[0] is null as expected.\n");
         }
     }
     return 0;
 }

5. 其他 _s函数

附录K还定义了许多其他安全版本的函数，例如：

• strncat_s(): 安全的定长字符串连接。
• sprintf_s(), vsprintf_s(): 安全的格式化输出到字符串。
• gets_s(): 安全的从 stdin 读取字符串 (替代危险的 gets())。
• memcpy_s(), memmove_s(): 安全的内存复制，增加了运行时约束检查。
• fopen_s(): 安全的文件打开。
• tmpfile_s(), tmpnam_s(): 安全的临时文件/名创建。

它们都遵循类似的设计原则，即增加缓冲区大小参数和强制的运行时约束检查。

6. 何时使用以及替代方案

• 如果你的编译器和目标平台完全支持C11附录K (如MSVC)，使用这些 _s 函数是提高代码安全性的好方法。
• 如果不支持：
• 对于字符串复制和连接，可以使用 snprintf。它是一个广泛支持且相对安全的函数，可以防止缓冲区溢出，并能告诉你需要多大的缓冲区。
• char dest[10];
  const char *src = "VeryLongString";
  int written = snprintf(dest, sizeof(dest), "%s", src);
  if (written >= sizeof(dest)) {
  // Output was truncated or would have overflowed
  }
• 对于 strncpy 和 strncat，使用时必须非常小心：
• strncpy 可能不会以 \0 结尾目标字符串，如果源字符串长度大于或等于指定的最大长度。你需要手动添加 \0。
• strncat 需要目标缓冲区有足够的空间，并且它总是会添加 \0。
• 考虑使用专门为安全设计的第三方字符串库。
• 自己编写包装函数，封装不安全的函数并添加边界检查。

总结

安全的字符串和内存操作函数（如 _s 系列）旨在通过强制边界检查和明确的错误处理来减少缓冲区溢出等安全漏洞。虽然它们的标准化和编译器支持不尽如人意，但其设计理念是值得学习的。在支持的环境中使用它们，或者采用如 snprintf 等更安全的替代方案，是编写健壮C代码的重要实践。