你的隐私数据真的安全吗之memset（）使用分析

我们在实际编程中，需要保存许多私有数据，例如：密码、密钥等等。所以，我们需要经常在使用完这些私有数据后，清除内存使用踪迹，以防止被潜在的入侵者获得这些数据。这篇文章中，我们讨论使用memset()函数来清除私有数据是，可能发生的一系列问题。

1.在stack上分配的隐私数据

首先，我们给出一个代码片段示例，关于如何处理栈上分配变量：

#include <string>
#include <functional>
#include <oistream>

// 隐私数据类型
struct PrivateData
{
	size_t m_hash;
	char m_pswd[100];
};

// 操作在password上的函数
void doSmth(PrivateData& data)
{
	std::string s(data.m_pswd);
	std::hash<std::string> hash_fn;

	data.m_hash = hash_fn(s);
}

// 输入和处理password的函数
int funcPswd()
{
	PrivateData data;
	std::cin >> data.m_pswd;

	doSmth(data);
	memset(&data, 0, sizeof(PrivateData));
	return 1;
}

int main()
{
	funcPswd();
	return 0;
}

上面示例完全是一个虚假例子。如果我们使用编译器（这里以Visual Studio 2015）编译一个调试版本的代码，那么这个代码可以很完善的运行，包括\(memset()\)函数的操作，也就是隐私数据用完之后，会得到清除。

但是让我们直接编译成一个运行版本，并且反编译出来结果如下：

......
    doSmth(data);
000000013f3072BF   lea						rcx, [data]
000000013F3072C3   call						doSmth  (013F30153Ch)
  memset(&data, 0, sizeof(PrivateData));
000000013F3072C8   mov						r8d, 70h
000000013F3072CE   xor						edx, edx
000000013F3072D0   lea						rcx, [data]
000000013F3072D4   call						memset  (013F301352h)
  return 1;
000000013F3072D9   mov						eax, 1
......

上面反编译代码可见当我们调用\(memset()\)函数，这就在使用隐私数据后清除。

我们进一步编译一个优化版本的发布代码，并且反编译之后，如下：

......
000000013F7A1035  call
        std::operator>><><char> > (013F7A18B0h)
000000013F7A103A  lea         rcx,[rsp+20h]
000000013F7A103F  call        doSmth (013F7A1170h)
    return 0;
000000013F7A1044  xor         eax,eax
......

可知，所有关系到函数\(memset()\)代码都被删除了。从编译器优化角度来看，不再使用的数据没必要被清除掉，这对于编译器来说是合法的。从语言角度来看，函数内使用后的隐私数据不会被其他函数调用，所以不用\(memset()\)进行清除也不会影响程序的操作。但是，从安全角度来看，我们的隐私数据没有被清除是非常危险的。

2.在heap上分配的隐私数据

现在，让我们进一步研究，假设我们在堆上使用\(malloc\)函数或者\(new\)操作符分配隐私数据，下面是使用\(malloc\)函数的代码：

#include <string>
#include <functional>
#include <iostream>

// 隐私数据类型
struct PrivateData
{
	size_t m_hash;
	char m_pswd[100];
};

// 操作在password上的函数
void doSmth(PrivateData& data)
{
	std::string s(data.m_pswd);
	std::hash<std::string> hash_fn;

	data.m_hash = hash_fn(s);
}

// 输入和处理password的函数
int funcPswd()
{
	PrivateData data = (PrivateData*)malloc(size0f(PrivateData));
	std::cin >> data.m_pswd;

	doSmth(data);
	memset(&data, 0, sizeof(PrivateData));
	free(data);
	return 1;
}

int main()
{
	funcPswd();
	return 0;
}

对于上述代码，我们使用Visual Studio 2015编译一个发行版本，然后反编译出结果如下：

......
000000013FBB1021  mov         rcx,
        qword ptr [__imp_std::cin (013FBB30D8h)]
000000013FBB1028  mov         rbx,rax
000000013FBB102B  lea         rdx,[rax+8]
000000013FBB102F  call
        std::operator>><><char> > (013FBB18B0h)
000000013FBB1034  mov         rcx,rbx
000000013FBB1037  call        doSmth (013FBB1170h)
000000013FBB103C  xor         edx,edx
000000013FBB103E  mov         rcx,rbx
000000013FBB1041  lea         r8d,[rdx+70h]
000000013FBB1045  call        memset (013FBB2A2Eh)
000000013FBB104A  mov         rcx,rbx
000000013FBB104D  call        qword ptr [__imp_free (013FBB3170h)]
    return 0;
000000013FBB1053  xor         eax,eax
......

可见Visual Studio的编译器没有优化掉相关的\(memset()\)函数代码，我们进一步使用5.2.1版本的gcc和3.7.0版本的clang编译看看结果。

这里需要提出，我们在gcc和clang版本的代码中添加了一些额外的代码，也就是读取被清除后的隐私数据地址上，通过读取被清除的指针，虽然这样的操作在实际编程中是不合理的，但是我们这边为了方便展示，代码如下：

....
#include "string.h"
....
size_t len = strlen(data->m_pswd);
for (int i = 0; i < len;="" ++i)="" printf("%c",="" data-="">m_pswd[i]);
printf("| %zu \n", data->m_hash);
memset(data, 0, sizeof(PrivateData));
free(data);
for (int i = 0; i < len;="" ++i)="" printf("%c",="" data-="">m_pswd[i]);
printf("| %zu \n", data->m_hash);
....

现在，这里给出使用gcc编译器反汇编出来的代码片段：

movq (%r12), %rsi
movl $.LC2, %edi
xorl %eax, %eax
call printf
movq %r12, %rdi
call free

可见，\(printf()\)函数后面直接跟着\(free()\)函数，\(memset()\)函数直接被优化掉。这时，如果我们运行恶意代码，读取隐私数据地址上的信息，依然可以读取到相关数据。

现在让我们查看clang编译器：

movq (%r14), %rsi
movl $.L.str.1, %edi
xorl %eax, %eax
callq printf
movq %r14, %rdi
callq free

同样，\(memset()\)函数直接被优化掉，这样也会导致隐私数据泄露。

通过上述的一系列实验可知，\(memset()\)函数直接被优化掉，不论是栈上数据还是堆上数据。最后，我们进一步探讨使用\(new\)操作的情况，调整代码如下：

#include <string>
#include <functional>
#include <iostream>
#include "string.h"

struct PrivateData
{
  size_t m_hash;
  char m_pswd[100];
};

void doSmth(PrivateData& data)
{
  std::string s(data.m_pswd);
  std::hash<std::string> hash_fn;

  data.m_hash = hash_fn(s);
}

int funcPswd()
{
  PrivateData* data = new PrivateData();
  std::cin >> data->m_pswd;
  doSmth(*data);
  memset(data, 0, sizeof(PrivateData));
  delete data;
  return 1;
}

int main()
{
  funcPswd();
  return 0;
}

使用Visual Studio编译后反编译的代码如下：

000000013FEB1044  call        doSmth (013FEB1180h)
000000013FEB1049  xor         edx,edx
000000013FEB104B  mov         rcx,rbx
000000013FEB104E  lea         r8d,[rdx+70h]
000000013FEB1052  call        memset (013FEB2A3Eh)
000000013FEB1057  mov         edx,70h
000000013FEB105C  mov         rcx,rbx
000000013FEB105F  call        operator delete (013FEB1BA8h)
    return 0;
000000013FEB1064  xor         eax,eax

使用gcc编译后反编译的代码如下：

call printf
movq %r13, %rdi
movq %rbp, %rcx
xorl %eax, %eax
andq $-8, %rdi
movq $0, 0(%rbp)
movq $0, 104(%rbp)
subq %rdi, %rcx
addl $112, %ecx
shrl $3, %ecx
rep stosq
movq %rbp, %rdi
call _ZdlPv

上面，Visual Studio和gcc编译后的代码显示，之前的隐私数据都得到了清除，最后使用clang编译如下：

movq (%r14), %rsi
movl $.L.str.1, %edi
xorl %eax, %eax
callq printf
movq %r14, %rdi
callq _ZdlPv

可知，clang对我们代码做了优化，隐私数据依然存在。

所以，我们应该如何更好的清除掉我们的隐私数据，从而保存我们的安全？

我们应该使用特殊的内存清除函数，它指定编译器不回删除这些函数。例如在Visual Studio中，可以使用\(RtlSecureZeroMemory\)函数。从C++11标准开始，我们可以使用\(memset\_s\)函数。此外，我们也可以实现我们自己需要的安全版本的内存清楚函数，示例1代码如下：

errno_t memset_s(void *v, rsize_t smax, int c, rsize_t n) {
  if (v == NULL) return EINVAL;
  if (smax > RSIZE_MAX) return EINVAL;
  if (n > smax) return EINVAL;
  volatile unsigned char *p = v;
  while (smax-- && n--) {
    *p++ = c;
  }
  return 0;
}

示例2代码：

void secure_zero(void *s, size_t n)
{
    volatile char *p = s;
    while (n--) *p++ = 0;
}