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

Question

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

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

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

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

根据这里引用的标准：

$ 5.2.11 / 7 - 注意：根据对象的类型，通过指针，左值或指向数据成员的指针的写操作会导致const_cast68的const-qualifier产生未定义的行为（7.1.5.1）。

否则会提出建议，但是上面的条件（连续的，待去除的）是否安全？

Answer 1

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

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

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

Answer 2

std :: string是存储机密的不良选择。由于字符串是可复制的，有时副本不被注意，你的秘密可能“得到腿”。此外，字符串扩展技术可能会导致您的秘密片段（或全部）的多个副本。

经验决定了一个可移动的，不可复制的，擦拭干净的摧毁，非智能（没有棘手的副本）类。

Answer 3

标准明确表示你不得写入const char*返回的data()，所以不要这样做。

有一种非常安全的方法可以获得可修改的指针：

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[]，它不使用copy-on-write。

编辑：如果您的编译器确实优化了此调用，您可以使用特定的编译器标志来确保不会优化废弃函数：

#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

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

std::string是一个旨在用户友好和高效的课程。它的设计并没有考虑密码学，因此很少有保证可以帮助您解决问题。例如，无法保证您的数据未被复制到其他位置。充其量，您可能希望特定编译器的实现为您提供所需的行为。

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

Answer 6

在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（）。

您也可以通过使用explicit_bzero将内容置零来执行类似的字符串清理而不使用openssl依赖项：

#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;
}