如何安全地清除 std::string？

Question

如何在 std::string 中存储敏感数据（例如：密码）？

我有一个应用程序，它提示用户输入密码并在连接设置期间将其传递到下游服务器。我想在建立连接后安全地清除密码值。

如果我将密码存储为 char * 数组，我可以使用 SecureZeroMemory 从进程内存中删除敏感数据。但是，我想在代码中避免使用 char 数组，并且正在寻找与 std::string 类似的内容？

Answer 1

根据此处给出的答案，我编写了一个分配器来安全地归零记忆。

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

namespace secure
{
  template <class T> class allocator : public std::allocator<T>
  {
  public:

    template<class U> struct rebind { typedef allocator<U> other; };
    allocator() throw() {}
    allocator(const allocator &) throw() {}
    template <class U> allocator(const allocator<U>&) throw() {}

    void deallocate(pointer p, size_type num)
    {
      SecureZeroMemory((void *)p, num);
      std::allocator<T>::deallocate(p, num);
    }
  };

  typedef std::basic_string<char, std::char_traits<char>, allocator<char> > string;
}

int main()
{
  {
    secure::string bar("bar");
    secure::string longbar("baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaar");
  }
}

然而，事实证明，根据 std::string 的实现方式，分配器甚至可能不会为小值调用。例如，在我的代码中，甚至不会为字符串 bar 调用 deallocate（在 Visual Studio 上）。

那么答案是我们不能使用 std::string 来存储敏感数据。当然，我们可以选择编写一个处理用例的新类，但我对使用定义的 std::string 特别感兴趣。

感谢大家的帮助！

Answer 2

openssl 经历了几次安全擦除字符串的迭代，直到决定采用这种方法：

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

// Pointer to memset is volatile so that compiler must de-reference
// the pointer and can't assume that it points to any function in
// particular (such as memset, which it then might further "optimize")
typedef void* (*memset_t)(void*, int, size_t);

static volatile memset_t memset_func = memset;

void cleanse(void* ptr, size_t len) {
  memset_func(ptr, 0, len);
}

int main() {
  std::string secret_str = "secret";
  secret_str.resize(secret_str.capacity(), 0);
  cleanse(&secret_str[0], secret_str.size());
  secret_str.clear();

  return 0;
}

Answer 3

这是一个复杂的话题，因为优化编译器会对你不利。像循环字符串和覆盖每个字符这样的直接方法并不可靠，因为编译器可能会优化它。与 memset 相同，但是，C11 添加了 memset_s，它应该是安全的，但可能不适用于所有平台。

因此，我强烈建议使用可信的加密库来完成该任务，并让其作者负责可移植性。安全擦除是一项基本操作（获取 C 数组并安全地覆盖它），所有库都必须在某个时候实现它。请注意，std::string 中的基础数据是连续的（如 C++11 标准所规定的 ，但实际上即使在 C++98/03 中你也可以假设它）。因此，您可以通过将 std::string 作为数组来使用加密库的安全擦除功能。

在 OpenSSL 中，安全擦除由 OPENSSL_cleanse 函数提供。 Crypto++ 有 memset_z：

std::string secret;
// ...

// OpenSSL (#include <openssl/crypto.h> and link -lcrypto)
OPENSSL_cleanse(&secret[0], secret_str.size());

// Crypto++ (#include <crypto++/misc.h> and link -lcrypto++)
CryptoPP::memset_z(&secret[0], 0, secret.size());

顺便说一句，如果您从头开始设计 API，请考虑在存储机密时完全避免使用 std::string。 std::string 的设计目标并不是防止泄露秘密（或在调整大小或复制过程中泄露秘密的一部分）。

Answer 4

为了后代，我曾经决定忽略这个建议并使用 std::string ，并使用 c_str() （并抛弃常量性）和易失性编写一个 Zero() 方法。如果我很小心，没有导致内容的重新分配/移动，并且我在需要清理的地方手动调用了zero()，那么一切似乎都正常运行。唉，我发现了另一个严重的缺陷：std::string也可以是引用计数的对象...在c_str()处爆破内存（或引用对象指向的内存）会在不知不觉中爆破另一个对象。

Answer 5

对于 Windows：

std::string s("ASecret");
const char* const ptr = s.data();
SecureZeroMemory((void*)ptr, s.size());

这将根据 STL 内部结构安全地清除堆栈或堆中的数据。

适用于所有尺寸的琴弦，无论大小。

注意！

请勿使用 ptr 更改字符串的数据，这可能会导致长度增加或减少。

Answer 6

std::string 基于 char*。作为 char* 的所有动态魔法背后的某个地方。因此，当您说不想在代码中使用 char* 时，您仍然在使用 char*，它只是在后台，上面堆满了一大堆其他垃圾。

我对进程内存不太有经验，但您始终可以迭代每个字符（在加密并将密码存储在数据库中之后？），并将其设置为不同的值。

还有一个 std::basic_string，但我不确定这会对您有什么帮助。

Answer 7

std::string mystring;
...
std::fill(mystring.begin(), mystring.end(), 0);

或者更好地编写自己的函数：

void clear(std::string &v)
{
  std::fill(v.begin(), v.end(), 0);
}