如何清理（用随机字节覆盖）std::string 内部缓冲区？

Question

考虑一个场景，其中std::string 用于存储秘密。一旦它被消耗并且不再需要，最好清理它，即覆盖包含它的内存，从而隐藏 secret。

std::string 提供了一个函数 const char* data() 返回指向（C++11 起）连续内存的指针。

现在，由于内存是连续的并且由于范围结束，变量将在清理后立即销毁，是否安全：

char* modifiable = const_cast<char*>(secretString.data());
OpenSSL_cleanse(modifiable, secretString.size());

根据此处引用的标准：

$5.2.11/7 - 注意：根据对象的类型，通过指针、左值或指向数据成员的指针的写操作由 const_cast 产生，它丢弃了 const-qualifier^{68 可能会产生未定义的行为 (7.1.5.1)。}

这会建议其他情况，但上述条件（连续、即将删除）是否使其安全？

Answer 1

在 CentOS 6、Debian 8 和 Ubuntu 16.04（g++/clang++、O0、O1、O2、O3）上测试的解决方案：

secretString.resize(secretString.capacity(), '\0');
OPENSSL_cleanse(&secretString[0], secretString.size());
secretString.clear();

如果你真的很偏执，你可以将清理后的字符串中的数据随机化，以免泄露字符串的长度或包含敏感数据的位置：

#include <string>

#include <stdlib.h>
#include <string.h>

typedef void* (*memset_t)(void*, int, size_t);

static volatile memset_t memset_func = memset;

void cleanse(std::string& to_cleanse) {
  to_cleanse.resize(to_cleanse.capacity(), '\0');
  for (int i = 0; i < to_cleanse.size(); ++i) {
    memset_func(&to_cleanse[i], rand(), 1);
  }
  to_cleanse.clear();
}

如果你愿意，也可以播种 rand()。

您也可以在不依赖 openssl 的情况下进行类似的字符串清理，方法是使用 explicit_bzero 将内容设为空：

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

int main() {
  std::string secretString = "ajaja";
  secretString.resize(secretString.capacity(), '\0');
  explicit_bzero(&secretString[0], secretString.size());
  secretString.clear();

  return 0;
}

Answer 2

有一个更好的答案：不要！

std::string 是一个设计为用户友好和高效的类。它在设计时并未考虑到密码学，因此几乎没有任何保证可以帮助您。例如，不能保证您的数据没有被复制到其他地方。充其量，您可能希望特定编译器的实现为您提供您想要的行为。

如果您确实想将秘密视为秘密，则应使用专为处理秘密而设计的工具来处理它。事实上，您应该针对攻击者的能力开发威胁模型，并相应地选择您的工具。

Answer 3

标准明确规定你不能写信给data()返回的const char*，所以不要那样做。

有一些非常安全的方法来获取可修改的指针：

if (secretString.size())
  OpenSSL_cleanse(&secretString.front(), secretString.size());

或者如果字符串可能已经被缩小并且您想确保它的全部容量被擦除：

if (secretString.capacity()) {
  secretString.resize(secretString.capacity());
  OpenSSL_cleanse(&secretString.front(), secretString.size());
}

Answer 4

您可以使用std::fill 用垃圾填充字符串：

std::fill(str.begin(),str.end(), 0);

请注意，简单地清除或缩小字符串（使用clear 或shrink_to_fit 等方法）并不能保证字符串数据将从进程内存中删除。如果字符串没有被正确覆盖，恶意进程可能会转储进程内存并提取秘密。

奖励：有趣的是，出于安全原因丢弃字符串数据的能力迫使某些编程语言（如 Java）返回密码为 char[] 而不是 String。在 Java 中，String 是不可变的，因此“丢弃”它会生成字符串的新副本。因此，您需要像char[] 这样不使用写时复制的可修改对象。

编辑：如果你的编译器确实优化了这个调用，你可以使用特定的编译器标志来确保垃圾函数不会被优化：

#ifdef WIN32

#pragma optimize("",off)
void trashString(std::string& str){
   std::fill(str.begin(),str.end(),0);
}
#pragma optimize("",on)

#endif

#ifdef __GCC__

void __attribute__((optimize("O0"))) trashString(std::string& str) {
       std::fill(str.begin(),str.end(),0);
}


#endif

#ifdef __clang__

void __attribute__ ((optnone))  trashString(std::string& str) {
       std::fill(str.begin(),str.end(),0);
}

#endif

Answer 5

这可能是安全的。但不能保证。

但是，由于C++11，std::string 必须实现为连续数据，这样您就可以使用其第一个元素 &secretString[0] 的地址安全地访问其内部数组。

if(!secretString.empty()) // avoid UB
{
    char* modifiable = &secretString[0];
    OpenSSL_cleanse(modifiable, secretString.size());
}

Answer 6

std::string 是存储机密的糟糕选择。由于字符串是可复制的，并且有时副本会被忽视，因此您的秘密可能会“得到支持”。此外，字符串扩展技术可能会导致您的秘密片段（或全部）的多个副本。

经验决定了一个可移动的、不可复制的、在销毁时擦干净、不智能（在引擎盖下没有棘手的副本）类。