DES 文件加密， RSA 給密碼加密

DES算法已經很經典了，因此用它來文件加密，也是簡單不過。

-------------------------------------------------------------------------------------------------------

C_DesEncryptFile::EncryptFile(LPCTSTR lpSourceFile, LPCTSTR lpszDestFile, const BYTE key[8], bool bFlag)

--------------------------------------------------------------------------------------------------------

lpSourceFile ---源文件名

lpszDestFile ---目標文件名

key[8]---密碼，不能超過64bit

bFlag--加密解密標誌

// C_DesEncryptFile.h: interface for the C_DesEncryptFile class.
//
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_C_DESENCRYPTFILE_H__3667F854_C709_40B4_AFD3_265D4B1B0618__INCLUDED_)
#define AFX_C_DESENCRYPTFILE_H__3667F854_C709_40B4_AFD3_265D4B1B0618__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include <tchar.h>
namespace  Encrypt {
class C_DesEncryptFile  
{
    typedef unsigned char BYTE;
    typedef  BYTE*         LPBYTE;
    typedef  const BYTE*  LPCBYTE;
    typedef  const TCHAR  *LPCSTR;
public:
    C_DesEncryptFile();
    virtual ~C_DesEncryptFile();
public:
     bool EncryptFile(LPCBYTE lpSource, LPBYTE lpDest, unsigned int nSize, const BYTE key[8], bool bFlag);
     bool EncryptFile(LPCTSTR lpSourceFile, LPCTSTR lpszDestFile, const BYTE key[8], bool bFlag);
private:
    HANDLE OpenFile(LPCTSTR lpSourceFile, bool bReadMode);    
    LPBYTE GetFileBuffer(HANDLE &hFile, DWORD &dwFileSize);
};
};
#endif // !defined(AFX_C_DESENCRYPTFILE_H__3667F854_C709_40B4_AFD3_265D4B1B0618__INCLUDED_)

下面是實現代碼：

// C_DesEncryptFile.cpp: implementation of the C_DesEncryptFile class.
//
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "RSA.h"
#include "C_DesEncryptFile.h"
#include "C_Des.h"
#include <io.h>
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
namespace  Encrypt {
C_DesEncryptFile::C_DesEncryptFile()
{
}
C_DesEncryptFile::~C_DesEncryptFile()
{
}
bool C_DesEncryptFile::EncryptFile(LPCTSTR lpSourceFile, LPCTSTR lpszDestFile, const BYTE key[8], bool bFlag)
{
    HANDLE hSHandle;
    HANDLE hDHandle;
    hSHandle = OpenFile(lpSourceFile, true);
    if (INVALID_HANDLE_VALUE == hSHandle)
    {
        return false;
    }
    DWORD dwFileSize = 0;
    LPBYTE lpSource = GetFileBuffer(hSHandle, dwFileSize);
    if (NULL == lpSource)
    {
        return false;
    }
    hDHandle = OpenFile(lpszDestFile, false);
    if (INVALID_HANDLE_VALUE == hSHandle)
    {
        delete [] lpSource;
        return false;
    }
    LPBYTE lpDest = new BYTE [dwFileSize];
   bool bret = EncryptFile(lpSource, lpDest, dwFileSize, key, bFlag);
   DWORD dwWriteNum = 0;
   WriteFile(hDHandle, lpDest, dwFileSize, &dwWriteNum, NULL);
   CloseHandle(hDHandle); 
   delete [] lpSource;
   delete [] lpDest;
   return bret;
}
bool C_DesEncryptFile::EncryptFile(LPCBYTE lpSource, LPBYTE lpDest, unsigned int nSize, const BYTE key[8], bool bFlag)
{
    C_Des DesEncrpty;
    BOOLEAN bRet = DesEncrpty.CDesEnter(lpSource, lpDest, nSize, key, bFlag);
    if (bRet)
    {
        return true;
    }
    return false;
}
HANDLE C_DesEncryptFile::OpenFile(LPCTSTR lpSourceFile, bool bReadMode)
{
    
    DWORD dwMode = GENERIC_READ ;
    DWORD dwShared = FILE_SHARE_READ;
    DWORD dwCreate = OPEN_EXISTING;
    if (!bReadMode)
    {
        dwMode |= GENERIC_WRITE;
        dwShared |= FILE_SHARE_WRITE;
        dwCreate = CREATE_ALWAYS;
    }
    HANDLE hTemplateFile = NULL;
    hTemplateFile = ::CreateFile(lpSourceFile, dwMode, dwShared, NULL, 
        dwCreate, FILE_ATTRIBUTE_NORMAL, hTemplateFile);
    return hTemplateFile;
}
LPBYTE C_DesEncryptFile::GetFileBuffer(HANDLE &hFile, DWORD &dwFileSize)
{
    DWORD dwFileHigh = 0;;
    
    DWORD dwRealSize = dwFileSize = GetFileSize(hFile, &dwFileHigh); 
    if (dwFileSize % 8 != 0)
    {
        DWORD dwRatio = dwFileSize / 8;
        dwFileSize = (dwRatio + 1) * 8;
    }
    LPBYTE pSourBuffer = new BYTE [dwFileSize];
    DWORD dwReadNum = 0;
    ReadFile(hFile, pSourBuffer, dwRealSize, &dwReadNum, NULL);
    CloseHandle(hFile);
    DWORD dwOffset = dwFileSize - dwRealSize;
    ZeroMemory(pSourBuffer + dwRealSize, dwOffset);
    return pSourBuffer;
}
};

DES 的代碼：

// C_Des.h: interface for the C_Des class.
//
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_C_DES_H__387D4F78_8819_43DC_BCC9_CB6C6BFB5A2D__INCLUDED_)
#define AFX_C_DES_H__387D4F78_8819_43DC_BCC9_CB6C6BFB5A2D__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
namespace  Encrypt {
    typedef  unsigned char   BYTE;
    typedef  BYTE*         LPBYTE;
    typedef  const BYTE*  LPCBYTE;
    typedef  int             BOOLEAN;
    
    
    class C_Des 
    { 
        
    public:
        C_Des();
        ~C_Des();
    public: 
        BOOLEAN CDesEnter(LPCBYTE in, LPBYTE out, int datalen, const BYTE key[8], BOOL type); 
        BOOLEAN CDesMac(LPCBYTE mac_data, LPBYTE mac_code, int datalen, const BYTE key[8]); 
    private: 
        void XOR(const BYTE in1[8], const BYTE in2[8], BYTE out[8]); 
        LPBYTE Bin2ASCII(const BYTE byte[64], BYTE bit[8]); 
        LPBYTE ASCII2Bin(const BYTE bit[8], BYTE byte[64]); 
        void GenSubKey(const BYTE oldkey[8], BYTE newkey[16][8]); 
        void endes(const BYTE m_bit[8], const BYTE k_bit[8], BYTE e_bit[8]); 
        void undes(const BYTE m_bit[8], const BYTE k_bit[8], BYTE e_bit[8]); 
        void SReplace(BYTE s_bit[8]); 
    }; 
};
#endif // !defined(AFX_C_DES_H__387D4F78_8819_43DC_BCC9_CB6C6BFB5A2D__INCLUDED_)

DES 實現：（是網上找到的）

// C_Des.cpp: implementation of the C_Des class.
//
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "RSA.h"
#include "C_Des.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
namespace Encrypt {
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
C_Des::C_Des()
{
}
C_Des::~C_Des()
{
}
 
/* 
*   CDesEnter 函數說明： 
*     des加密/解密入口 
*   返回： 
*     1則成功,0失敗 
*   參數： 
*     in 需要加密或解密的數據  
*         注意：in緩衝區的大小必須和datalen相同. 
*     out 加密後或解密後輸出。 
*         注意：out緩衝區大小必須是8的倍數而且比datalen大或者相等。 
*         如datalen=7，out緩衝區的大小應該是8，datalen=8,out緩衝區的大小應該是8, 
*         datalen=9,out緩衝區的大小應該是16，依此類推。 
*     datalen 數據長度(字節)。  
*         注意:datalen 必須是8的倍數。 
*     key 8個字節的加密或解密的密碼。 
*     type 是對數據進行加密還是解密 
*         0 表示加密 1 表示解密 
*/ 
BOOLEAN C_Des::CDesEnter(LPCBYTE in, LPBYTE out, int datalen, const BYTE key[8], BOOL type) 
{ 
  //判斷輸入參數是否正確，失敗的情況爲： 
  //!in： in指針（輸入緩衝）無效 
  //!out： out指針（輸出緩衝）無效 
  //datalen<1： 數據長度不正確 
  //!key： 加/解密密碼無效 
  //type && ((datalen % 8) !=0：選擇解密方式但是輸入密文不爲8的倍數 
  if((!in) || (!out) || (datalen<1) || (!key) || (type && ((datalen % 8) !=0))) 
    return FALSE; 
 
     
  if(type==0) //選擇的模式是加密 
  { 
    // 用於存儲待加密字串最後的若干字節 
    // DES算法是以8個字節爲單位進行加密，如果待加密字串以8爲單位分段加密時，最後一段不足 
    //8字節，則在後面補0，使其最後一段的長度爲8字節 
    // te8bit是作爲存儲待加密字串最後一段（不足8字節）的變量 
    BYTE te8bit[8]={0,0,0,0,0,0,0,0}; 
 
    // 這是待加密字串的調整長度 
    // 如果原始長度是8的整數倍，則調整長度的值和原來的長度一樣 
    // 如果原始長度不是8的整數倍，則調整長度的值是能被8整除且不大於原來長度的最大整數。 
    //也就是不需要補齊的塊的總長度。 
    int te_fixlen = datalen - (datalen % 8); 
 
    // 將待加密密文以8爲單位分段，把最後長度不足8的一段存儲到te8bit中。 
    for(int i = 0; i < (datalen % 8); i++) 
        te8bit[i] = in[te_fixlen + i]; 
 
    // 將待加密字串分以8字節爲單位分段加密 
    for(i = 0; i < te_fixlen; i += 8) 
        endes(in + i, key, out + i); 
 
    // 如果待加密字串不是8的整數倍，則將最後一段補齊（補0）後加密 
    if(datalen % 8 != 0) 
        endes(te8bit, key, out + datalen / 8 * 8); 
  } 
  else   //選擇的模式是解密 
  { 
    // 將密文以8字節爲單位分段解密 
    for(int i = 0; i < datalen; i += 8) 
        undes(in + i, key, out + i); 
  } 
  return TRUE; 
} 
 
/* 
*   CDesMAC 函數說明： 
*     DESMAC 數據驗校 
*   返回： 
*     1則成功,0失敗 
*   參數： 
*     mac_data MAC驗校數據 
*         注意：Mac_data緩衝區的大小(16字節以上)必須和datalen相同,而且應是8的倍數。 
*     out_mac MAC驗校輸出(8字節) 
*     dadalen 數據長度(字節)。  
*         注意:datalen 必須是16以上而且是8的倍數。 
*     key 8個字節的驗校密碼。      
*/ 
BOOLEAN C_Des::CDesMac(LPCBYTE mac_data, LPBYTE mac_code, int datalen, const BYTE key[8]) 
{ 
  //判斷輸入參數是否正確，失敗的情況爲： 
  //!mac_data： mac_data指針（輸入緩衝）無效 
  //!mac_code： mac_code指針（輸出緩衝）無效 
  //datalen<16： 數據長度不正確 
  //datalen % 8 != 0： 數據長度不爲8的整數倍 
  //!key：密碼不符合要求 
  if((!mac_data) || (!mac_code) || (datalen < 16) || (datalen % 8 != 0) || (!key)) 
    return FALSE; 
  endes(mac_data, key, mac_code); 
  for(int i = 8; i < datalen; i += 8) 
  { 
    XOR(mac_code, mac_data + i, mac_code); 
    endes(mac_code, key, mac_code); 
  } 
  return TRUE; 
} 
 
/* 
*   XOR 函數說明： 
*     將輸入的兩個8字節字符串異或 
*   返回： 
*     無 
*   參數： 
*     const BYTE in1[8] 輸入字符串1 
*     const BYTE in2[8] 輸入字符串2 
*     BYTE out[8] 輸出的結果字符串      
*/ 
void C_Des::XOR(const BYTE in1[8], const BYTE in2[8], BYTE out[8]) 
{ 
  for(int i = 0; i < 8; i++) 
    out[i] = in1[i] ^ in2[i];  
} 
 
/* 
*   Bin2ASCII 函數說明： 
*     將64字節的01字符串轉換成對應的8個字節 
*   返回： 
*     轉換後結果的指針 
*   參數： 
*     const BYTE byte[64] 輸入字符串 
*     BYTE bit[8] 輸出的轉換結果      
*/ 
LPBYTE C_Des::Bin2ASCII(const BYTE byte[64], BYTE bit[8]) 
{ 
  for(int i = 0; i < 8; i++) 
  { 
    bit[i] = byte[i * 8] * 128 + byte[i * 8 + 1] * 64 +  
          byte[i * 8 + 2] * 32 + byte[i * 8 + 3] * 16 +  
          byte[i * 8 + 4] * 8 + byte[i * 8 + 5] * 4 +  
          byte[i * 8 + 6] * 2 + byte[i * 8 + 7];  
  } 
  return bit; 
} 
 
/* 
*   ASCII2Bin 函數說明： 
*     將8個字節輸入轉換成對應的64字節的01字符串 
*   返回： 
*     轉換後結果的指針 
*   參數： 
*     const BYTE bit[8] 輸入字符串 
*     BYTE byte[64] 輸出的轉換結果      
*/ 
LPBYTE C_Des::ASCII2Bin(const BYTE bit[8], BYTE byte[64]) 
{ 
  for(int i=0; i < 8; i++) 
    for(int j = 0; j < 8; j++) 
        byte[i * 8 + j] = ( bit[i] >> (7 - j) ) & 0x01; 
  return byte; 
} 
 
/* 
*   GenSubKey 函數說明： 
*     由輸入的密鑰得到16個子密鑰 
*   返回： 
*     無 
*   參數： 
*     const BYTE oldkey[8] 輸入密鑰 
*     BYTE newkey[16][8] 輸出的子密鑰      
*/ 
void C_Des::GenSubKey(const BYTE oldkey[8], BYTE newkey[16][8]) 
{ 
  int i, k, rol = 0; 
 
  //縮小換位表1 
  int pc_1[56] = {57,49,41,33,25,17,9, 
          1,58,50,42,34,26,18, 
          10,2,59,51,43,35,27, 
          19,11,3,60,52,44,36, 
          63,55,47,39,31,23,15, 
          7,62,54,46,38,30,22, 
          14,6,61,53,45,37,29, 
          21,13,5,28,20,12,4}; 
  //縮小換位表2 
  int pc_2[48] = {14,17,11,24,1,5, 
          3,28,15,6,21,10, 
          23,19,12,4,26,8, 
          16,7,27,20,13,2, 
          41,52,31,37,47,55, 
          30,40,51,45,33,48, 
          44,49,39,56,34,53, 
          46,42,50,36,29,32}; 
  //16次循環左移對應的左移位數 
  int ccmovebit[16] = {1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1}; 
 
  BYTE oldkey_byte[64]; 
  BYTE oldkey_byte1[64]; 
  BYTE oldkey_byte2[64]; 
  BYTE oldkey_c[56]; 
  BYTE oldkey_d[56]; 
  BYTE newkey_byte[16][64]; 
 
  ASCII2Bin(oldkey, oldkey_byte); 
 
  //位變換 
  for(i = 0; i < 56; i++) 
    oldkey_byte1[i] = oldkey_byte[pc_1[i] - 1]; 
  //分爲左右兩部分，複製一遍以便於循環左移 
  for(i = 0; i < 28; i++) 
    oldkey_c[i] = oldkey_byte1[i], oldkey_c[i + 28] = oldkey_byte1[i], 
    oldkey_d[i] = oldkey_byte1[i + 28], oldkey_d[i + 28] = oldkey_byte1[i + 28]; 
 
  //分別生成16個子密鑰 
  for(i = 0; i < 16; i++) 
  { 
    //循環左移 
    rol += ccmovebit[i]; 
    //合併左移後的結果 
    for(k = 0; k < 28; k++)  
        oldkey_byte2[k] = oldkey_c[k + rol], oldkey_byte2[k + 28] = oldkey_d[k + rol]; 
    //位變換 
    for(k = 0; k < 48; k++) 
        newkey_byte[i][k] = oldkey_byte2[pc_2[k] - 1]; 
 
  } 
  //生成最終結果 
  for(i = 0; i < 16; i++) 
    Bin2ASCII(newkey_byte[i], newkey[i]); 
} 
 
/* 
*   endes 函數說明： 
*     DES加密 
*   返回： 
*     無 
*   參數： 
*     const BYTE m_bit[8] 輸入的原文 
*     const BYTE k_bit[8] 輸入的密鑰 
*     BYTE e_bit[8] 輸出的密文 
*/ 
void C_Des::endes(const BYTE m_bit[8], const BYTE k_bit[8], BYTE e_bit[8]) 
{ 
  //換位表IP 
  int ip[64] = { 
        58,50,42,34,26,18,10,2, 
        60,52,44,36,28,20,12,4, 
        62,54,46,38,30,22,14,6, 
        64,56,48,40,32,24,16,8, 
        57,49,41,33,25,17,9,1, 
        59,51,43,35,27,19,11,3, 
        61,53,45,37,29,21,13,5, 
        63,55,47,39,31,23,15,7 
        }; 
  //換位表IP_1 
  int ip_1[64] = { 
        40,8,48,16,56,24,64,32, 
        39,7,47,15,55,23,63,31, 
        38,6,46,14,54,22,62,30, 
        37,5,45,13,53,21,61,29, 
        36,4,44,12,52,20,60,28, 
        35,3,43,11,51,19,59,27, 
        34,2,42,10,50,18,58,26, 
        33,1,41,9,49,17,57,25 
        }; 
  //放大換位表 
  int e[48] = { 
        32,1, 2, 3, 4, 5, 
        4, 5, 6, 7, 8, 9, 
        8, 9, 10,11,12,13, 
        12,13,14,15,16,17, 
        16,17,18,19,20,21, 
        20,21,22,23,24,25, 
        24,25,26,27,28,29, 
        28,29,30,31,32,1 
        }; 
  BYTE m_bit1[8] = {0}; 
  BYTE m_byte[64] = {0}; 
  BYTE m_byte1[64] = {0}; 
  BYTE key_n[16][8] = {0}; 
  BYTE l_bit[17][8] = {0}; 
  BYTE r_bit[17][8] = {0}; 
  BYTE e_byte[64] = {0}; 
  BYTE e_byte1[64] = {0}; 
  BYTE r_byte[64] = {0}; 
  BYTE r_byte1[64] = {0}; 
  int i, j; 
 
  //根據密鑰生成16個子密鑰 
  GenSubKey(k_bit, key_n); 
  //將待加密字串變換成01串 
  ASCII2Bin(m_bit, m_byte); 
  //按照ip表對待加密字串進行位變換 
  for(i = 0; i < 64; i++) 
    m_byte1[i] = m_byte[ip[i] - 1]; 
  //位變換後的待加密字串 
  Bin2ASCII(m_byte1, m_bit1); 
  //將位變換後的待加密字串分成兩組，分別爲前4字節L和後4字節R，作爲迭代的基礎（第0次迭代） 
  for(i = 0; i < 4; i++) 
    l_bit[0][i] = m_bit1[i], r_bit[0][i] = m_bit1[i + 4]; 
 
  //16次迭代運算 
  for(i = 1; i <= 16; i++) 
  { 
    //R的上一次的迭代結果作爲L的當前次迭代結果 
    for(j = 0; j < 4; j++) 
        l_bit[i][j] = r_bit[i-1][j]; 
 
    ASCII2Bin(r_bit[i-1], r_byte); 
    //將R的上一次迭代結果按E表進行位擴展得到48位中間結果 
    for(j = 0; j < 48; j++) 
        r_byte1[j] = r_byte[e[j] - 1]; 
    Bin2ASCII(r_byte1, r_bit[i-1]); 
 
    //與第I-1個子密鑰進行異或運算 
    for(j = 0; j < 6; j++) 
        r_bit[i-1][j] = r_bit[i-1][j] ^ key_n[i-1][j]; 
 
    //進行S選擇，得到32位中間結果 
    SReplace(r_bit[i - 1]); 
     
    //結果與L的上次迭代結果異或得到R的此次迭代結果 
    for(j = 0; j < 4; j++) 
    { 
        r_bit[i][j] = l_bit[i-1][j] ^ r_bit[i-1][j]; 
    } 
  } 
  //組合最終迭代結果 
  for(i = 0; i < 4; i++) 
    e_bit[i] = r_bit[16][i], e_bit[i + 4] = l_bit[16][i]; 
   
  ASCII2Bin(e_bit, e_byte); 
  //按照表IP-1進行位變換 
  for(i = 0; i < 64; i++) 
    e_byte1[i] = e_byte[ip_1[i] - 1]; 
  //得到最後的加密結果 
  Bin2ASCII(e_byte1, e_bit); 
} 
 
/* 
*   undes 函數說明： 
*     DES解密，與加密步驟完全相同，只是迭代順序是從16到1 
*   返回： 
*     無 
*   參數： 
*     const BYTE m_bit[8] 輸入的密文 
*     const BYTE k_bit[8] 輸入的密鑰 
*     BYTE e_bit[8] 輸出解密後的原文 
*/ 
void C_Des::undes(const BYTE m_bit[8], const BYTE k_bit[8], BYTE e_bit[8]) 
{ 
  //換位表IP 
  int ip[64] = { 
        58,50,42,34,26,18,10,2, 
        60,52,44,36,28,20,12,4, 
        62,54,46,38,30,22,14,6, 
        64,56,48,40,32,24,16,8, 
        57,49,41,33,25,17,9,1, 
        59,51,43,35,27,19,11,3, 
        61,53,45,37,29,21,13,5, 
        63,55,47,39,31,23,15,7 
        }; 
  //換位表IP_1 
  int ip_1[64] = { 
        40,8,48,16,56,24,64,32, 
        39,7,47,15,55,23,63,31, 
        38,6,46,14,54,22,62,30, 
        37,5,45,13,53,21,61,29, 
        36,4,44,12,52,20,60,28, 
        35,3,43,11,51,19,59,27, 
        34,2,42,10,50,18,58,26, 
        33,1,41,9,49,17,57,25 
        }; 
  //放大換位表 
  int e[48] = { 
        32,1, 2, 3, 4, 5, 
        4, 5, 6, 7, 8, 9, 
        8, 9, 10,11,12,13, 
        12,13,14,15,16,17, 
        16,17,18,19,20,21, 
        20,21,22,23,24,25, 
        24,25,26,27,28,29, 
        28,29,30,31,32,1 
        }; 
  BYTE m_bit1[8] = {0}; 
  BYTE m_byte[64] = {0}; 
  BYTE m_byte1[64] = {0}; 
  BYTE key_n[16][8] = {0}; 
  BYTE l_bit[17][8] = {0}; 
  BYTE r_bit[17][8] = {0}; 
  BYTE e_byte[64] = {0}; 
  BYTE e_byte1[64] = {0}; 
  BYTE l_byte[64] = {0}; 
  BYTE l_byte1[64] = {0}; 
  int i = 0, j = 0; 
 
  //根據密鑰生成16個子密鑰 
  GenSubKey(k_bit, key_n); 
  //將待加密字串變換成01串 
  ASCII2Bin(m_bit, m_byte); 
  //按照ip表對待加密字串進行位變換 
  for(i = 0; i < 64; i++) 
    m_byte1[i] = m_byte[ip[i] - 1]; 
  //位變換後的待加密字串 
  Bin2ASCII(m_byte1, m_bit1); 
  //將位變換後的待加密字串分成兩組，分別爲前4字節R和後4字節L，作爲迭代的基礎（第16次迭代） 
  for(i = 0; i < 4; i++) 
    r_bit[16][i] = m_bit1[i], l_bit[16][i] = m_bit1[i + 4]; 
 
  //16次迭代運算 
  for(i = 16; i > 0; i--) 
  { 
    //L的上一次的迭代結果作爲R的當前次迭代結果 
    for(j = 0; j < 4; j++) 
        r_bit[i-1][j] = l_bit[i][j]; 
 
    ASCII2Bin(l_bit[i], l_byte); 
    //將L的上一次迭代結果按E表進行位擴展得到48位中間結果 
    for(j = 0; j < 48; j++) 
        l_byte1[j] = l_byte[e[j] - 1]; 
    Bin2ASCII(l_byte1, l_bit[i]); 
 
    //與第I-1個子密鑰進行異或運算 
    for(j = 0; j < 6; j++) 
        l_bit[i][j] = l_bit[i][j] ^ key_n[i-1][j]; 
 
    //進行S選擇，得到32位中間結果 
    SReplace(l_bit[i]); 
     
    //結果與R的上次迭代結果異或得到L的此次迭代結果 
    for(j = 0; j < 4; j++) 
    { 
        l_bit[i-1][j] = r_bit[i][j] ^ l_bit[i][j]; 
    } 
  } 
  //組合最終迭代結果 
  for(i = 0; i < 4; i++) 
    e_bit[i] = l_bit[0][i], e_bit[i + 4] = r_bit[0][i]; 
   
  ASCII2Bin(e_bit, e_byte); 
  //按照表IP-1進行位變換 
  for(i = 0; i < 64; i++) 
    e_byte1[i] = e_byte[ip_1[i] - 1]; 
  //得到最後的結果 
  Bin2ASCII(e_byte1, e_bit); 
} 
 
/* 
*   SReplace 函數說明： 
*     S選擇 
*   返回： 
*     無 
*   參數： 
*     BYTE s_bit[8] 輸入暨選擇後的輸出 
*/ 
void C_Des::SReplace(BYTE s_bit[8]) 
{ 
  int p[32] = { 
        16,7,20,21, 
        29,12,28,17, 
        1,15,23,26, 
        5,18,31,10, 
        2,8,24,14, 
        32,27,3,9, 
        19,13,30,6, 
        22,11,4,25 
        }; 
  BYTE s[][4][16] ={  
                { 
                14,4,13,1,2,15,11,8,3,10,6,12,5,9,0,7, 
                0,15,7,4,14,2,13,1,10,6,12,11,9,5,3,8, 
                4,1,14,8,13,6,2,11,15,12,9,7,3,10,5,0, 
                15,12,8,2,4,9,1,7,5,11,3,14,10,0,6,13 
                }, 
                { 
                15,1,8,14,6,11,3,4,9,7,2,13,12,0,5,10, 
                3,13,4,7,15,2,8,14,12,0,1,10,6,9,11,5, 
                0,14,7,11,10,4,13,1,5,8,12,6,9,3,2,15, 
                13,8,10,1,3,15,4,2,11,6,7,12,0,5,14,9 
                }, 
                { 
                10,0,9,14,6,3,15,5,1,13,12,7,11,4,2,8, 
                13,7,0,9,3,4,6,10,2,8,5,14,12,11,15,1, 
                13,6,4,9,8,15,3,0,11,1,2,12,5,10,14,7, 
                1,10,13,0,6,9,8,7,4,15,14,3,11,5,2,12 
                }, 
                { 
                7,13,14,3,0,6,9,10,1,2,8,5,11,12,4,15, 
                13,8,11,5,6,15,0,3,4,7,2,12,1,10,14,9, 
                10,6,9,0,12,11,7,13,15,1,3,14,5,2,8,4, 
                3,15,0,6,10,1,13,8,9,4,5,11,12,7,2,14 
                }, 
                { 
                2,12,4,1,7,10,11,6,8,5,3,15,13,0,14,9, 
                14,11,2,12,4,7,13,1,5,0,15,10,3,9,8,6, 
                4,2,1,11,10,13,7,8,15,9,12,5,6,3,0,14, 
                11,8,12,7,1,14,2,13,6,15,0,9,10,4,5,3, 
                }, 
                { 
                12,1,10,15,9,2,6,8,0,13,3,4,14,7,5,11, 
                10,15,4,2,7,12,9,5,6,1,13,14,0,11,3,8, 
                9,14,15,5,2,8,12,3,7,0,4,10,1,13,11,6, 
                4,3,2,12,9,5,15,10,11,14,1,7,6,0,8,13 
                }, 
                { 
                4,11,2,14,15,0,8,13,3,12,9,7,5,10,6,1, 
                13,0,11,7,4,9,1,10,14,3,5,12,2,15,8,6, 
                1,4,11,13,12,3,7,14,10,15,6,8,0,5,9,2, 
                6,11,13,8,1,4,10,7,9,5,0,15,14,2,3,12 
                }, 
                { 
                13,2,8,4,6,15,11,1,10,9,3,14,5,0,12,7, 
                1,15,13,8,10,3,7,4,12,5,6,11,0,14,9,2, 
                7,11,4,1,9,12,14,2,0,6,10,13,15,3,5,8, 
                2,1,14,7,4,10,8,13,15,12,9,0,3,5,6,11 
                } 
            }; 
  BYTE s_byte[64] = {0}; 
  BYTE s_byte1[64] = {0}; 
  BYTE row = 0, col = 0; 
  BYTE s_out_bit[8] = {0}; 
 
  //轉成二進制字符串處理 
  ASCII2Bin(s_bit, s_byte); 
  for(int i = 0; i < 8; i++) 
  { 
    //0、5位爲row，1、2、3、4位爲col，在S表中選擇一個八位的數 
    row = s_byte[i * 6] * 2 + s_byte[i * 6 + 5]; 
    col = s_byte[i * 6 + 1] * 8 + s_byte[i * 6 + 2] * 4 + s_byte[i * 6 + 3] * 2 + s_byte[i * 6 + 4]; 
    s_out_bit[i] = s[i][row][col]; 
  } 
  //將八個選擇的八位數據壓縮表示 
  s_out_bit[0] = (s_out_bit[0] << 4) + s_out_bit[1]; 
  s_out_bit[1] = (s_out_bit[2] << 4) + s_out_bit[3]; 
  s_out_bit[2] = (s_out_bit[4] << 4) + s_out_bit[5]; 
  s_out_bit[3] = (s_out_bit[6] << 4) + s_out_bit[7]; 
  //轉成二進制字符串處理 
  ASCII2Bin(s_out_bit, s_byte); 
  //換位 
  for(i = 0; i < 32; i++) 
    s_byte1[i] = s_byte[p[i] - 1]; 
  //生成最後結果 
  Bin2ASCII(s_byte1, s_bit); 
} 
 
};

RAS 算法：

// C_RSA.h: interface for the C_RSA class.
//
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_C_RSA_H__DFA1ACD6_44FD_49A6_BCE5_9EB1A6A6CC1D__INCLUDED_)
#define AFX_C_RSA_H__DFA1ACD6_44FD_49A6_BCE5_9EB1A6A6CC1D__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include <string>
using namespace std;
class C_RSA  
{
public:
    struct S_CODE
    {
        int nEncryptCode;
        int nDecryptCode;
        int nN;
    };
    typedef S_CODE ENCRYPTTYPE;
public:
    C_RSA();
    virtual ~C_RSA();
public:
    /// First produce the encrypt code & decrypt code
    ENCRYPTTYPE & ProduceEncryptInFo(int nP, int nQ);
    /// Encrypt the proclaim 
    bool Encrypt(string &strContent, string & strEncryptContent);
    /// Decrypt the content
    bool Decrypt(string & strEncryptContent, string &strContent,  int nDecryptCode, int nN);
    /// Auto produce encrypt code & decrypt code
    ENCRYPTTYPE & AutoProduceEncryptInFo(void);
private:
    bool IsPrime(int nX);
    int  Gcd(int nA, int nB);
    void Euler(int nE, int nFin);
    void ProduceEncryCode(int nFin);
    int  Power(int nA, int nN, int nM);
    
private:
    int m_nP;   //P factor
    int m_nQ;   //Q factor
    ENCRYPTTYPE m_nEncrytInFo; // information
    
};
#endif // !defined(AFX_C_RSA_H__DFA1ACD6_44FD_49A6_BCE5_9EB1A6A6CC1D__INCLUDED_)

實現：

// C_RSA.cpp: implementation of the C_RSA class.
//
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "RSA.h"
#include "C_RSA.h"
#include "math.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
C_RSA::C_RSA()
{
}
C_RSA::~C_RSA()
{
}
inline
bool C_RSA::IsPrime(int nX)
{
    int i;
    int nTop = static_cast<int>(sqrt(nX));
    nTop += 1;  // safe
    
    for (i = 2; i <= nTop; i++)
    {
        if (nX % i == 0)
        {
            break;
        }
    }
    if (i > nTop)
    {
        return true;
    }
    return false;
}
inline
int  C_RSA::Power(int nA, int nN, int nM)
{
    int nZ = 1, nTemp;
    for (nTemp = nA; nN > 0; nN >>= 1)
    {
        if (nN % 2 == 1)
        {
            nZ = (nZ * nTemp) % nM;
        }
        nTemp = (nTemp * nTemp) % nM;
    }
    return nZ;
}
int C_RSA::Gcd(int nA, int nB)
{
    
    if (nA == 0)
    {
        return nB;
    }
    else
    {
        return Gcd(nB % nA, nA);
    }   
    
}
inline
void C_RSA::ProduceEncryCode(int nFin)
{
    for (int i = 3; i < nFin; ++i)
    {
        if (IsPrime(i) && 1 == Gcd(nFin, i))
        {
            m_nEncrytInFo.nEncryptCode = i;
            break;
        }
    }
}
C_RSA::ENCRYPTTYPE & C_RSA::AutoProduceEncryptInFo(void)
{
    int nP, nQ;
    while(true)
    {
        srand(time(0));
        nP = rand() % 100;
        nQ = rand() % 100;
        if (IsPrime(nQ) && IsPrime(nP))
            break;
    }
    return ProduceEncryptInFo(nP, nQ);
}
C_RSA::ENCRYPTTYPE& C_RSA::ProduceEncryptInFo(int nP, int nQ)
{
    m_nP = nP;
    m_nQ = nQ;
    m_nEncrytInFo.nN = m_nP * m_nQ;
    int nFin = (m_nP - 1) * (m_nQ - 1);
    
    ProduceEncryCode(nFin);
    Euler(m_nEncrytInFo.nEncryptCode, nFin);
    return m_nEncrytInFo;
}
inline
void C_RSA::Euler(int nE, int nFin)
{
    int u1 = 1;
    int u2 = 0;
    int u3 = nFin;
    int v1 = 0;
    int v2 = 1;
    int v3 = nE;
    int v = 1;
    int t1, t2, t3;
    int q;
    int uu, vv;
    int inverse, z;
    while (v3 != 0)
    {
        q = u3 / v3;
        t1 = u1 - q * v1;
        t2 = u2 - q * v2;
        t3 = u3 - q * v3;
        u1 = v1;
        u2 = v2;
        u3 = v3;
        v1 = t1;
        v2 = t2;
        v3 = t3;
        z =  1;
    }
    uu = u1;
    vv = u2;
    
    if (vv < 0)
    {
        inverse = vv + nFin;
    }
    else
    {
        inverse = vv;
    }
    m_nEncrytInFo.nDecryptCode = inverse;   
}
bool C_RSA::Encrypt(string &strContent, string & strEncryptContent)
{
    if (strContent.empty())
    {
        return false;
    }
    strEncryptContent = "";
    string::size_type nIndex = 0;
    string::size_type nSize = strContent.size();
    for (nIndex = 0;  nIndex < nSize; ++nIndex)
    {
        char szBuffer[1024] = {0};
        int nECode = Power(strContent[nIndex], 
            m_nEncrytInFo.nEncryptCode,
            m_nEncrytInFo.nN);
        sprintf(szBuffer, "%d%s", nECode, "+");
        strEncryptContent += szBuffer;
        
    }
    return true;
}
bool C_RSA::Decrypt(string & strEncryptContent, string &strContent, int nDecryptCode, int nN)
{
    if (strEncryptContent.empty())
    {
        return false;
    }
    strContent = "";
    unsigned size = strEncryptContent.size();
    char *pstrEnCode  =  new char [size];
    CopyMemory(pstrEnCode, strEncryptContent.c_str(), size);
    char seps[]   = "+";
    char *token;
    token = strtok( pstrEnCode, seps );
    while( token != NULL )
    {
        int nCode = atoi(token);
        char nChar = static_cast<char>(Power(nCode, nDecryptCode, nN));
        strContent += nChar;    
        token = strtok( NULL, seps );
    }
    delete[] pstrEnCode;
    return true;
}

結束了，以文記之！

DES 文件加密， RSA 給密碼加密

UTF8 到GB2312 的轉換

Bitmap 任意切割算法

乘除法指令的模擬

MS XML 文檔創建

_stdcall,__cdecl,_cdecl,_stdcall,。__fastcall,_fastcall 區別簡介

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結