让C++支持内存加密

此Code支持Cocos2d-x, 防止那些垃圾的八门神器等内存挂修改：）

内存破解无非就是通过各种方法定位到数据存到内存的位置，然后修改内存，主要方式是正常通过多次修改数据，多次筛选来定位内存地址。

所以我们保证内存里面存的是加工过的数据，并能正常存取就行了。假如我们有个数据A需要加密，我们产生一个0~0xFF的随机数R，存取时我们对A的每个字节和R进行异或操作，解密时对每个字节再进行一次异或就可以得到原来的数据了。
因此我们定一个数据结构，保存的是加密后的A和随机数R。

为了方便程序使用，我们可以定义一个模板类，然后重载其常用的运算符，这样原有的程序只需要将数据类型（int,float,double）改为加密的数据类型就可以了。

如果你觉得还不安全，你可以定期修改下内存位置。。。。

#include <iostream>
using namespace std;
 
namespace CryptType
{
    //////////////////////////////////////////////////////////////////////////
    
    class CEncrypt
    {
    public:
        bool Decode( unsigned char *pbyBuf, size_t dwSize);
        bool Encode(unsigned char* pbyBuf, size_t dwSize);
        CEncrypt();
    protected:
        unsigned char m_pbyKey;
    };
    
    
    template <class T>
    class TCryptType
    {
    public:
        TCryptType(void)
        {
            memset( &m_Data, 0, sizeof(T));
        };
        
        TCryptType(T val)
        {
            m_Data = val;
            m_cEncrypt.Encode( (unsigned char*)&m_Data, sizeof( m_Data));
        };
        
        //virtual ~TCryptType(void){};
        
        inline T operator =( const T src)
        {
            m_Data = src;
            m_cEncrypt.Encode( (unsigned char*)&m_Data, sizeof( m_Data));
            return src;
        };
        
        inline operator T()
        {
            T tTmp = m_Data;
            m_cEncrypt.Decode( (unsigned char*)&tTmp, sizeof( tTmp));
            return tTmp;
        };
        
        inline const T operator -()
        {
            T tTmp = this->m_Data;
            m_cEncrypt.Decode( (unsigned char*)&tTmp, sizeof( tTmp));
            return -tTmp;
        };
        
        inline const T operator ~()
        {
            T tTmp = this->m_Data;
            m_cEncrypt.Decode( (unsigned char*)&tTmp, sizeof( tTmp));
            return ~tTmp;
        };
        
        inline bool operator !()
        {
            T tTmp = this->m_Data;
            m_cEncrypt.Decode( (unsigned char*)&tTmp, sizeof( tTmp));
            return !tTmp;
        };
        
        inline TCryptType<T>& operator ++()
        {
            (*this) += 1;
            return *this;
        };
        
        inline T operator ++(int)
        {
            T oldValue = (T)*this;
            ++(*this);
            return oldValue;
        };
        
        inline TCryptType<T> operator --()
        {
            (*this) -= 1;
            return *this;
        };
        
        inline T operator --(int)
        {
            T oldValue = (T)*this;
            --(*this);
            return oldValue;
        };
        
        inline TCryptType<T>& operator +=(const T other)
        {
            T tTmp = this->m_Data;
            m_cEncrypt.Decode( (unsigned char*)&tTmp, sizeof( tTmp));
            tTmp += other;
            m_Data = tTmp;
            m_cEncrypt.Encode( (unsigned char*)&m_Data, sizeof( m_Data));
            return *this;
        };
        
        inline TCryptType<T>& operator -=(const T other)
        {
            T tTmp = this->m_Data;
            m_cEncrypt.Decode( (unsigned char*)&tTmp, sizeof( tTmp));
            tTmp -= other;
            m_Data = tTmp;
            m_cEncrypt.Encode( (unsigned char*)&m_Data, sizeof( m_Data));
            return *this;
        };
        
        inline TCryptType<T>& operator *=(const T other)
        {
            T tTmp = this->m_Data;
            m_cEncrypt.Decode( (unsigned char*)&tTmp, sizeof( tTmp));
            tTmp *= other;
            m_Data = tTmp;
            m_cEncrypt.Encode( (unsigned char*)&m_Data, sizeof( m_Data));
            return *this;
        };
        
        inline TCryptType<T>& operator /=(const T other)
        {
            T tTmp = this->m_Data;
            m_cEncrypt.Decode( (unsigned char*)&tTmp, sizeof( tTmp));
            tTmp /= other;
            m_Data = tTmp;
            m_cEncrypt.Encode( (unsigned char*)&m_Data, sizeof( m_Data));
            return *this;
        };
        
        inline TCryptType<T>& operator >>=( int rhs)
        {
            T tTmp = this->m_Data;
            m_cEncrypt.Decode( (unsigned char*)&tTmp, sizeof( tTmp));
            tTmp >>= rhs;
            m_Data = tTmp;
            m_cEncrypt.Encode( (unsigned char*)&m_Data, sizeof( m_Data));
            return *this;
        };
        
        inline TCryptType<T>& operator <<=( int rhs)
        {
            T tTmp = this->m_Data;
            m_cEncrypt.Decode( (unsigned char*)&tTmp, sizeof( tTmp));
            tTmp <<= rhs;
            m_Data = tTmp;
            m_cEncrypt.Encode( (unsigned char*)&m_Data, sizeof( m_Data));
            return *this;
        };
        
        inline TCryptType<T>& operator %=( int rhs)
        {
            T tTmp = this->m_Data;
            m_cEncrypt.Decode( (unsigned char*)&tTmp, sizeof( tTmp));
            tTmp %= rhs;
            m_Data = tTmp;
            m_cEncrypt.Encode( (unsigned char*)&m_Data, sizeof( m_Data));
            return *this;
        };
        
        inline TCryptType<T>& operator ^=( int rhs) 
        {
            T tTmp = this->m_Data;
            m_cEncrypt.Decode( (unsigned char*)&tTmp, sizeof( tTmp));
            tTmp ^= rhs;
            m_Data = tTmp;
            m_cEncrypt.Encode( (unsigned char*)&m_Data, sizeof( m_Data));
            return *this;
        };
        
        inline TCryptType<T>& operator &=( int rhs) 
        {
            T tTmp = this->m_Data;
            m_cEncrypt.Decode( (unsigned char*)&tTmp, sizeof( tTmp));
            tTmp &= rhs;
            m_Data = tTmp;
            m_cEncrypt.Encode( (unsigned char*)&m_Data, sizeof( m_Data));
            return *this;
        };
        
        inline TCryptType<T>& operator |=( int rhs) 
        {
            T tTmp = this->m_Data;
            m_cEncrypt.Decode( (unsigned char*)&tTmp, sizeof( tTmp));
            tTmp |= rhs;
            m_Data = tTmp;
            m_cEncrypt.Encode( (unsigned char*)&m_Data, sizeof( m_Data));
            return *this;
        };
        
    protected:
        CEncrypt m_cEncrypt;
        T m_Data;
    };
    //////////////////////////////////////////////////////////////////////////
}
 
using namespace CryptType;
 
typedef TCryptType<unsigned char> CryptByte;
//typedef TCryptType<WORD> CryptInt16;
typedef TCryptType<int> CryptInt32;
typedef TCryptType<float> CryptFloat;
typedef TCryptType<double> CryptDouble;
 
 
/************** Source File **************/
using namespace CryptType;
 
CEncrypt::CEncrypt()
{
	this->m_pbyKey = ((double)rand()/((double)RAND_MAX+1))*256;
}
 
bool CEncrypt::Encode(unsigned char *pbyBuf, size_t dwSize)
{
	for( int i = 0; i < dwSize; ++i)
	{
		pbyBuf[i] ^= m_pbyKey;
	}
	return true;
}
 
bool CEncrypt::Decode(unsigned char *pbyBuf, size_t dwSize)
{
	for( int i = 0; i < dwSize; ++i)
	{
		pbyBuf[i] ^= m_pbyKey;
	}
	return true;
}