des.txt

偶尔想到数据加密技术,这里顺便提一下双向加密的标准DES。以前在一个宽带流媒体服务器项目中用到了DES加密

    0x00000000L, 0x00400010L, 0x20004010L, 0x00004000L,
    0x00404000L, 0x20004010L, 0x00000010L, 0x20400010L,
    0x20400010L, 0x00000000L, 0x00404010L, 0x20404000L,
    0x00004010L, 0x00404000L, 0x20404000L, 0x20000000L,
    0x20004000L, 0x00000010L, 0x20400010L, 0x00404000L,
    0x20404010L, 0x00400000L, 0x00004010L, 0x20000010L,
    0x00400000L, 0x20004000L, 0x20000000L, 0x00004010L,
    0x20000010L, 0x20404010L, 0x00404000L, 0x20400000L,
    0x00404010L, 0x20404000L, 0x00000000L, 0x20400010L,
    0x00000010L, 0x00004000L, 0x20400000L, 0x00404010L,
    0x00004000L, 0x00400010L, 0x20004010L, 0x00000000L,
    0x20404000L, 0x20000000L, 0x00400010L, 0x20004010L };

unsigned long DES::SP7[64] = {
    0x00200000L, 0x04200002L, 0x04000802L, 0x00000000L, 
    0x00000800L, 0x04000802L, 0x00200802L, 0x04200800L,
    0x04200802L, 0x00200000L, 0x00000000L, 0x04000002L,
    0x00000002L, 0x04000000L, 0x04200002L, 0x00000802L,
    0x04000800L, 0x00200802L, 0x00200002L, 0x04000800L,
    0x04000002L, 0x04200000L, 0x04200800L, 0x00200002L,
    0x04200000L, 0x00000800L, 0x00000802L, 0x04200802L,
    0x00200800L, 0x00000002L, 0x04000000L, 0x00200800L,
    0x04000000L, 0x00200800L, 0x00200000L, 0x04000802L,
    0x04000802L, 0x04200002L, 0x04200002L, 0x00000002L,
    0x00200002L, 0x04000000L, 0x04000800L, 0x00200000L,
    0x04200800L, 0x00000802L, 0x00200802L, 0x04200800L,
    0x00000802L, 0x04000002L, 0x04200802L, 0x04200000L,
    0x00200800L, 0x00000000L, 0x00000002L, 0x04200802L,
    0x00000000L, 0x00200802L, 0x04200000L, 0x00000800L, 


    0x04000002L, 0x04000800L, 0x00000800L, 0x00200002L };

unsigned long DES::SP8[64] = {
    0x10001040L, 0x00001000L, 0x00040000L, 0x10041040L,
    0x10000000L, 0x10001040L, 0x00000040L, 0x10000000L,
    0x00040040L, 0x10040000L, 0x10041040L, 0x00041000L,
    0x10041000L, 0x00041040L, 0x00001000L, 0x00000040L,
    0x10040000L, 0x10000040L, 0x10001000L, 0x00001040L,
    0x00041000L, 0x00040040L, 0x10040040L, 0x10041000L,
    0x00001040L, 0x00000000L, 0x00000000L, 0x10040040L,
    0x10000040L, 0x10001000L, 0x00041040L, 0x00040000L,
    0x00041040L, 0x00040000L, 0x10041000L, 0x00001000L,
    0x00000040L, 0x10040040L, 0x00001000L, 0x00041040L,
    0x10001000L, 0x00000040L, 0x10000040L, 0x10040000L,
    0x10040040L, 0x10000000L, 0x00040000L, 0x10001040L, 
    0x00000000L, 0x10041040L, 0x00040040L, 0x10000040L,
    0x10040000L, 0x10001000L, 0x10001040L, 0x00000000L,
    0x10041040L, 0x00041000L, 0x00041000L, 0x00001040L,
    0x00001040L, 0x00040040L, 0x10000000L, 0x10041000L };


接下来我们举例说明如何使用DES类。首先定义一个Encrypt类：


//Encrypt.h

#include "des.h"
#include "Base64.h"
class Encrypt{
public :    
    char* encrypt ( unsigned char key[8], char* data);
    char* decrypt ( unsigned char key[8], char* data);
    CBase64 base;
};


而后是具体的实现：

//Encrypt.cpp

#include "Encrypt.h"
#include <stdio.h>

char* Encrypt::encrypt ( unsigned char key[8], char* data)
{
//将字符指针转化为字符数组
    char* datavv = data;
    data =(char *) calloc(100,1); 


    memcpy(data,datavv,strlen(datavv));
    data[strlen(data)] = '\0';
//DES加密    
    DES des ;
    des.encrypt(key,(unsigned char *)data,1);    
//base64编码
    base.Encode(data);
    char* res =(char *) base.EncodedMessage();
    return res;
};
char* Encrypt::decrypt ( unsigned char key[8], char* data)
{
//base64解码
    base.Decode(data);
    char* datares=(char *) base.DecodedMessage();
//将字符指针转化为字符数组
    char* datarea = datares;
    datares = (char *)malloc(256);
    memcpy(datares,datarea,strlen(datarea));
    datares[strlen(datarea)] = '\0';
//DES解密
    DES des ;
    des.decrypt(key,(unsigned char*) datares,1);
    return datares; 

};

注意，这里使用了BASE 64编码。其实现代码如下：

// Base64.h
#include <windows.h>

class CBase64
{
    // Internal bucket class.
    class TempBucket
    {
    public:
        BYTE         nData[4];
        BYTE         nSize;
        void         Clear() { ::ZeroMemory(nData, 4); nSize = 0; };
    };

    PBYTE                       m_pDBuffer;
    PBYTE                       m_pEBuffer; 
    DWORD                       m_nDBufLen;
    DWORD                       m_nEBufLen;
    DWORD                       m_nDDataLen;
    DWORD                       m_nEDataLen;

public:
    CBase64();
    virtual ~CBase64();

public:
    virtual void         Encode(const PBYTE, DWORD);
    virtual void         Decode(const PBYTE, DWORD); 软件开发网 www.mscto.com 
    virtual void         Encode(LPCSTR sMessage);
    virtual void         Decode(LPCSTR sMessage);

    virtual LPCSTR     DecodedMessage() const;
    virtual LPCSTR     EncodedMessage() const;

    virtual void         AllocEncode(DWORD);
    virtual void         AllocDecode(DWORD);
    virtual void         SetEncodeBuffer(const PBYTE pBuffer, DWORD nBufLen);
    virtual void         SetDecodeBuffer(const PBYTE pBuffer, DWORD nBufLen);

protected:
    virtual void         _EncodeToBuffer(const TempBucket &Decode, PBYTE pBuffer); 
    virtual ULONG         _DecodeToBuffer(const TempBucket &Decode, PBYTE pBuffer);
    virtual void         _EncodeRaw(TempBucket &, const TempBucket &);
    virtual void         _DecodeRaw(TempBucket &, const TempBucket &);
    virtual BOOL         _IsBadMimeChar(BYTE);

    static char         m_DecodeTable[256];
    static BOOL         m_Init;
    void                       _Init();
};
////////////////////////////////////

//CBase64.cpp
// CBase64.cpp: implementation of the CBase64 class. 
软件开发网 www.mscto.com

//
//////////////////////////////////////////////////////////////////////

#include "Base64.h"

// Digits...
static char Base64Digits[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

BOOL CBase64::m_Init   = FALSE;
char CBase64::m_DecodeTable[256];

#ifndef PAGESIZE
#define PAGESIZE       4096
#endif

#ifndef ROUNDTOPAGE
#define ROUNDTOPAGE(a)     (((a/4096)+1)*4096)
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CBase64::CBase64()
: m_pDBuffer(NULL),
m_pEBuffer(NULL),
m_nDBufLen(0),
m_nEBufLen(0)
{

}

CBase64::~CBase64()
{
if(m_pDBuffer != NULL)
  delete [] m_pDBuffer;

if(m_pEBuffer != NULL) 


  delete [] m_pEBuffer;
}

LPCSTR CBase64::DecodedMessage() const
{
return (LPCSTR) m_pDBuffer;
}

LPCSTR CBase64::EncodedMessage() const
{
return (LPCSTR) m_pEBuffer;
}

void CBase64::AllocEncode(DWORD nSize)
{
if(m_nEBufLen < nSize)
{
  if(m_pEBuffer != NULL)
    delete [] m_pEBuffer;
 
  m_nEBufLen = ROUNDTOPAGE(nSize);
  m_pEBuffer = new BYTE[m_nEBufLen];
}

  ::ZeroMemory(m_pEBuffer, m_nEBufLen);
m_nEDataLen = 0;
}

void CBase64::AllocDecode(DWORD nSize)
{
if(m_nDBufLen < nSize)
{
  if(m_pDBuffer != NULL)
    delete [] m_pDBuffer;
 
  m_nDBufLen = ROUNDTOPAGE(nSize);
  m_pDBuffer = new BYTE[m_nDBufLen];
}

::ZeroMemory(m_pDBuffer, m_nDBufLen);
m_nDDataLen = 0;
}

void CBase64::SetEncodeBuffer(const PBYTE pBuffer, DWORD nBufLen) 
{
DWORD ii = 0;

AllocEncode(nBufLen);
while(ii < nBufLen)
{
  if(!_IsBadMimeChar(pBuffer[ii]))
  {
    m_pEBuffer[m_nEDataLen] = pBuffer[ii];
    m_nEDataLen++;
  }
 
  ii++;
}
}

void CBase64::SetDecodeBuffer(const PBYTE pBuffer, DWORD nBufLen)
{
AllocDecode(nBufLen);
::CopyMemory(m_pDBuffer, pBuffer, nBufLen);
m_nDDataLen = nBufLen;
}

void CBase64::Encode(const PBYTE pBuffer, DWORD nBufLen)
{
SetDecodeBuffer(pBuffer, nBufLen);
AllocEncode(nBufLen * 2);

TempBucket     Raw;
DWORD       nIndex = 0;

while((nIndex + 3) <= nBufLen)
{
  Raw.Clear();
  ::CopyMemory(&Raw, m_pDBuffer + nIndex, 3);
  Raw.nSize = 3;
  _EncodeToBuffer(Raw, m_pEBuffer + m_nEDataLen);
  nIndex   += 3; 

  m_nEDataLen += 4;
}

if(nBufLen > nIndex)
{
  Raw.Clear();
  Raw.nSize = (BYTE) (nBufLen - nIndex);
  ::CopyMemory(&Raw, m_pDBuffer + nIndex, nBufLen - nIndex);
  _EncodeToBuffer(Raw, m_pEBuffer + m_nEDataLen);
  m_nEDataLen += 4;
}
}

void CBase64::Encode(LPCSTR szMessage)
{
if(szMessage != NULL)
  CBase64::Encode((const PBYTE)szMessage, lstrlenA(szMessage));
}

void CBase64::Decode(const PBYTE pBuffer, DWORD dwBufLen)
{
if(!CBase64::m_Init)
  _Init();

SetEncodeBuffer(pBuffer, dwBufLen);

AllocDecode(dwBufLen);

TempBucket     Raw;

DWORD   nIndex = 0;

while((nIndex + 4) <= m_nEDataLen)
{
  Raw.Clear();
  Raw.nData[0] = CBase64::m_DecodeTable[m_pEBuffer[nIndex]];
  Raw.nData[1] = CBase64::m_DecodeTable[m_pEBuffer[nIndex + 1]];
  Raw.nData[2] = CBase64::m_DecodeTable[m_pEBuffer[nIndex + 2]]; 

  Raw.nData[3] = CBase64::m_DecodeTable[m_pEBuffer[nIndex + 3]];
 
  if(Raw.nData[2] == 255)
    Raw.nData[2] = 0;
  if(Raw.nData[3] == 255)
    Raw.nData[3] = 0;
 
  Raw.nSize = 4;
  _DecodeToBuffer(Raw, m_pDBuffer + m_nDDataLen);
  nIndex += 4;
  m_nDDataLen += 3;
}

// If nIndex < m_nEDataLen, then we got a decode message without padding.
// We may want to throw some kind of warning here, but we are still required
// to handle the decoding as if it was properly padded.
if(nIndex < m_nEDataLen)
{
  Raw.Clear();
  for(DWORD ii = nIndex; ii < m_nEDataLen; ii++)
  {
    Raw.nData[ii - nIndex] = CBase64::m_DecodeTable[m_pEBuffer[ii]];
    Raw.nSize++;
    if(Raw.nData[ii - nIndex] == 255)
    Raw.nData[ii - nIndex] = 0;
  } 
 
  _DecodeToBuffer(Raw, m_pDBuffer + m_nDDataLen);
  m_nDDataLen += (m_nEDataLen - nIndex);
}
}
void CBase64::Decode(LPCSTR szMessage)
{
if(szMessage != NULL)
  CBase64::Decode((const PBYTE)szMessage, lstrlenA(szMessage));
}

DWORD CBase64::_DecodeToBuffer(const TempBucket &Decode, PBYTE pBuffer)
{
TempBucket Data;
DWORD   nCount = 0;

_DecodeRaw(Data, Decode);

for(int ii = 0; ii < 3; ii++)
{
  pBuffer[ii] = Data.nData[ii];
  if(pBuffer[ii] != 255)
    nCount++;
}

return nCount;
}


void CBase64::_EncodeToBuffer(const TempBucket &Decode, PBYTE pBuffer)
{
TempBucket Data;

_EncodeRaw(Data, Decode);

for(int ii = 0; ii < 4; ii++)
  pBuffer[ii] = Base64Digits[Data.nData[ii]];

switch(Decode.nSize)
{
case 1:
  pBuffer[2] = '='; 

case 2:
  pBuffer[3] = '=';
}
}

void CBase64::_DecodeRaw(TempBucket &Data, const TempBucket &Decode)
{
BYTE   nTemp;

Data.nData[0] = Decode.nData[0];
Data.nData[0] <<= 2;

nTemp = Decode.nData[1];
nTemp >>= 4;
nTemp &= 0x03;
Data.nData[0] |= nTemp;

Data.nData[1] = Decode.nData[1];
Data.nData[1] <<= 4;

nTemp = Decode.nData[2];
nTemp >>= 2;
nTemp &= 0x0F;
Data.nData[1] |= nTemp;

Data.nData[2] = Decode.nData[2];
Data.nData[2] <<= 6;
nTemp = Decode.nData[3];
nTemp &= 0x3F;
Data.nData[2] |= nTemp;
}

void CBase64::_EncodeRaw(TempBucket &Data, const TempBucket &Decode)
{
BYTE   nTemp;

Data.nData[0] = Decode.nData[0];
Data.nData[0] >>= 2;

Data.nData[1] = Decode.nData[0];
Data.nData[1] <<= 4;
nTemp = Decode.nData[1]; 
nTemp >>= 4;
Data.nData[1] |= nTemp;
Data.nData[1] &= 0x3F;

Data.nData[2] = Decode.nData[1];
Data.nData[2] <<= 2;

nTemp = Decode.nData[2];
nTemp >>= 6;

Data.nData[2] |= nTemp;
Data.nData[2] &= 0x3F;

Data.nData[3] = Decode.nData[2];
Data.nData[3] &= 0x3F;
}

BOOL CBase64::_IsBadMimeChar(BYTE nData)
{
switch(nData)
{
case '\r': case '\n': case '\t': case ' ' :
case '\b': case '\a': case '\f': case '\v':
  return TRUE;
default:
  return FALSE;
}
}

void CBase64::_Init()
{ // Initialize Decoding table.

int ii;

for(ii = 0; ii < 256; ii++)
  CBase64::m_DecodeTable[ii] = -2;

for(ii = 0; ii < 64; ii++)
{
  CBase64::m_DecodeTable[Base64Digits[ii]]   = (CHAR)ii;
  CBase64::m_DecodeTable[Base64Digits[ii]|0x80] = (CHAR)ii;
}

CBase64::m_DecodeTable['=']     = -1; 


CBase64::m_DecodeTable['='|0x80]   = -1;

CBase64::m_Init = TRUE;
}