通过RC4加密解密数据

#ifndef CRYPOTRC4_H
#define CRYPOTRC4_H

#include <afxwin.h>
#include <atlcoll.h>
#include <wincrypt.h>

class CCryptoRC4 : CObject
{
public:
	enum CryptoType
	{
		/// <summary>未知类型</summary>
		Unknown = 0,

		/// <summary>加密类型</summary>
		Encrypted = 1,

		/// <summary>解密类型</summary>
		Decrypted = 2
	};
public:
	CCryptoRC4(const TCHAR* szPassword)
	{
		Initialization((BYTE*) szPassword, (DWORD) (_tcslen(szPassword) * sizeof(TCHAR)));
	}

	CCryptoRC4(const BYTE* pbPassword, DWORD cbPassword)
	{
		Initialization(pbPassword, cbPassword);
	}

	~CCryptoRC4()
	{
		if (m_hCryptProv)
			CryptReleaseContext(m_hCryptProv, 0);
		if (m_hCryptHash)
			CryptDestroyHash(m_hCryptHash);
		if (m_hCryptKey)
			CryptDestroyKey(m_hCryptKey);
	}

	/// <summary>通过RC4可逆加密数据</summary>
	/// <param name="szPlaintext">需要加密的密文字符串</param>
	/// <return>加密之后的数据（可转BYTE*）</return>
	const TCHAR* Encrypt(const TCHAR* szPlaintext)
	{
		size_t cbPlaintext = _tcslen(szPlaintext) * sizeof(TCHAR);
		Encrypt((BYTE*) szPlaintext, (DWORD) cbPlaintext);
		for (int i = 0; i < (int) sizeof(TCHAR); i++)
			m_baCiphertext.Add(0);

		return reinterpret_cast<TCHAR*>(m_baCiphertext.GetData());
	}

	/// <summary>通过RC4可逆加密数据</summary>
	/// <param name="pbPlaintext">需要加密的密文</param>
	/// <param name="cbPlaintext">需要加密的密文长度</param>
	/// <return>加密之后的数据（可转TCHAR*）</return>
	void Encrypt(const BYTE* pbPlaintext, DWORD cbPlaintext)
	{
		if (!m_baCiphertext.IsEmpty()) m_baCiphertext.RemoveAll();
		m_baCiphertext.SetCount(cbPlaintext); // 重置密文数据长度

		memcpy_s(m_baCiphertext.GetData(), cbPlaintext, pbPlaintext, cbPlaintext);

		m_lastCryptoType = CryptEncrypt(m_hCryptKey, NULL, TRUE, 0, m_baCiphertext.GetData(),
			&cbPlaintext, cbPlaintext) ? Encrypted : Unknown;
	}

	/// <summary>通过RC4可逆解密数据</summary>
	/// <param name="szCiphertext">需要解密的密文字符串</param>
	/// <return>解密之后的数据（可转BYTE*）</return>
	const TCHAR* Decrypt(const TCHAR* szCiphertext)
	{
		size_t cbCiphertext = _tcslen(szCiphertext) * sizeof(TCHAR);
		Decrypt((BYTE *)szCiphertext, (DWORD)cbCiphertext);
		for (int i = 0; i < (int) sizeof(TCHAR); i++)
			m_baPlaintext.Add(0);

		return reinterpret_cast<TCHAR*>(m_baPlaintext.GetData());
	}

	/// <summary>通过RC4可逆解密数据</summary>
	/// <param name="pbCiphertext">需要解密的密文</param>
	/// <param name="cbCiphertext">需要解密的密文长度</param>
	/// <return>解密之后的数据（可转TCHAR*）</return>
	void Decrypt(const BYTE* szCiphertext, DWORD cbCiphertext)
	{
		if (!m_baPlaintext.IsEmpty()) m_baPlaintext.RemoveAll();
		m_baPlaintext.SetCount(cbCiphertext); // 重置明文数据长度

		memcpy_s(m_baPlaintext.GetData(), cbCiphertext, szCiphertext, cbCiphertext);

		m_lastCryptoType = CryptDecrypt(m_hCryptKey, 0, TRUE, 0, m_baPlaintext.GetData(),
			&cbCiphertext) ? Decrypted : Unknown;
	}

	/// <summary>获取最后一次运算数据</summary>
	/// <return>加密之后数据或解密之后数据</return>
	ATL::CAtlArray<BYTE>& GetCryptoData()
	{
		return GetCryptoData(m_lastCryptoType);
	}

	/// <summary>获取加密或解密运算数据</summary>
	/// <param name="tyCryptoType">加密或解密类型</param>
	/// <return>加密之后数据或解密之后数据</return>
	ATL::CAtlArray<BYTE>& GetCryptoData(CryptoType tyCryptoType)
	{
		if (tyCryptoType == Encrypted) return m_baCiphertext;
		if (tyCryptoType == Decrypted) return m_baPlaintext;

		AfxThrowInvalidArgException();
	}
private:
	/// <summary>禁止复制构造函数</summary>
	CCryptoRC4(const CCryptoRC4&)
	{
	}

	/// <summary>禁止拷贝构造函数</summary>
	void operator =(const CCryptoRC4&)
	{
	}

	/// <summary>RC4可逆加密初始化</summary>
	/// <param name="pbPassword">RC4可逆加密密钥</param>
	/// <param name="cbPassword">RC4可逆加密密钥长度</param>
	void Initialization(const BYTE* pbPassword, DWORD cbPassword)
	{
		m_hCryptProv = NULL, m_hCryptHash = NULL, m_hCryptKey = NULL;
                m_lastCryptoType = Unknown;

		// Get a handle to user default provider.
		CryptAcquireContext(&m_hCryptProv, NULL, NULL, PROV_RSA_SCHANNEL, CRYPT_VERIFYCONTEXT);
		CryptCreateHash(m_hCryptProv, CALG_SHA, 0, 0, &m_hCryptHash);
		CryptHashData(m_hCryptHash, pbPassword, cbPassword, 0);
		CryptDeriveKey(m_hCryptProv, CALG_RC4, m_hCryptHash, CRYPT_EXPORTABLE, &m_hCryptKey);
	}
private:
	/// <summary>解密之后得到的明文</summary>
	ATL::CAtlArray<BYTE> m_baPlaintext;

	/// <summary>加密之后得到的密文</summary>
	ATL::CAtlArray<BYTE> m_baCiphertext;

	/// <summary>最后一次加密类型</summary>
	CryptoType m_lastCryptoType;

	/// <summary>密码系统服务提供句柄</summary>
	HCRYPTPROV m_hCryptProv;

	/// <summary>密码系统哈希对象集句柄</summary>
	HCRYPTHASH m_hCryptHash;

	/// <summary>密码系统密钥集句柄</summary>
	HCRYPTKEY m_hCryptKey;
};

#endif // CRYPOTRC4_H