讓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;
}