des.txt

来自「偶尔想到数据加密技术,这里顺便提一下双向加密的标准DES。以前在一个宽带流媒体服」· 文本 代码 · 共 978 行 · 第 1/2 页

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