Class LockZeroBuffer

libcppcryptfs/util/LockZeroBuffer.h:41–101

template<typename T>
class LockZeroBuffer
{
private:
	BOOL m_IsLocked;
public:
	// disallow copying
	LockZeroBuffer(LockZeroBuffer const&) = delete;
	void operator=(LockZeroBuffer const&) = delete;

	BOOL IsLocked() { return m_IsLocked; };
	T *m_buf;
	DWORD m_len;

	void Clear() 
	{
		if (m_buf)
			SecureZeroMemory(m_buf, sizeof(T)*m_len);
	}

	LockZeroBuffer(DWORD len, bool throw_if_not_locked)
	{
		m_len = len;
		m_buf = new T[m_len];
		m_IsLocked = VirtualLock(m_buf, sizeof(T)*m_len);
		if (!m_IsLocked) {
			// The amount of memory that can be locked is a little bit less than the
			// minimum working set size, which defaults to 200KB.
			//
			// Attempt to increase the minimum working set size to 1MB
			
			const SIZE_T desired_min_ws = 1024 * 1024;

			SIZE_T min_ws, max_ws;

			if (GetProcessWorkingSetSize(GetCurrentProcess(), &min_ws, &max_ws)) {
				if (min_ws < desired_min_ws) {
					max_ws = max(max_ws, desired_min_ws);
					if (SetProcessWorkingSetSize(GetCurrentProcess(), desired_min_ws, max_ws)) {
						m_IsLocked = VirtualLock(m_buf, sizeof(T)*m_len);
					}
				}
			}
		}
		if (!m_IsLocked && throw_if_not_locked) {
			delete[] m_buf;
			string mes = "LockZeroBuffer: unable to lock buffer of " + to_string(sizeof(T) * m_len) + " bytes";
			throw std::exception(mes.c_str());
		}
		memset(m_buf, 0, sizeof(T)*m_len);
	}

	virtual ~LockZeroBuffer()
	{
		if (m_buf) {
			Clear();
			if (m_IsLocked)
				VirtualUnlock(m_buf, sizeof(T)*m_len);
			delete[] m_buf;