des加密解密算法详解及源码分享

　　DES全称为Data Encryption Standard，即数据加密标准，是一种使用密钥加密的块算法，1977年被美国联邦政府的国家标准局确定为联邦资料处理标准（FIPS），并授权在非密级政府通信中使用，随后该算法在国际上广泛流传开来。需要注意的是，在某些文献中，作为算法的DES称为数据加密算法（Data Encryption Algorithm，DEA），已与作为标准的DES区分开来。

     DES算法

　　DES算法的入口参数有三个：Key、Data、Mode。其中Key为7个字节共56位，是DES算法的工作密钥；Data为8个字节64位，是要被加密或被解密的数据；Mode为DES的工作方式，有两种：加密或解密。

　　

　　DES加密算法详解

　　DES算法的入口参数有三个：

　　Key， Data， Mode

　　Key 为64bit密钥， Data为64bit数据，Mode为加密还是解密。

　　DES算法的过程：

　　1. 对输入的密钥进行变换。

　　用户的64bit密钥，其中第8， 16， 24， 32， 40， 48， 56， 64位是校验位， 使得每个密钥都有奇数个1。所以密钥事实上是56位。对这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，

　　表的意思是第57位移到第1位，第49位移到第2位，。。。。。。 以此类推。变换后得到56bit数据，将它分成两部分，C［0］［28］， D［0］［28］。

　　2. 计算16个子密钥，计算方法C［i］［28］ D［i］［28］为对前一个C［i-1］［28］， D［i-1］［28］做循环左移操作。16次的左移位数如下表：

　　1， 2， 3， 4， 5， 6， 7， 8， 9， 10， 11， 12， 13， 14， 15， 16 （第i次）

　　1， 1， 2， 2， 2， 2， 2， 2， 1， 2， 2， 2， 2， 2， 2， 1 （左移位数）

　　3. 串联计算出来的C［i］［28］ D［i］［28］ 得到56位，然后对它进行如下变换得到48位子密钥K［i］［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，

　　表的意思是第14位移到第1位，第17位移到第2位，以此类推。在此过程中，发现第9，18，22，25， 35，38，43，54位丢弃。

　　4. 对64bit的明文输入进行换位变换。换位表如下：

　　58， 50， 12， 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

　　表的意思就是第一次变换时，第58位移到第1位，第50位移到第2位，。。。。。。 依此类推。得到64位数据，将这数据前后分成两块L［0］［32］， R［0］［32］。

　　5. 加密过程，对R［i］［32］进行扩展变换成48位数，方法如下， 记为E（R［i］［32］）

　　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，

　　6. 将E（R［i］［32］）与K［i］［48］作异或运算，得到48位数，将48位数顺序分成8份，6位一份，B［8］［6］。

　　7. 使用S［i］替换B［i］［6］。过程如下： 取出B［i］［6］的第1位和第6位连成一个2位数m， m就是S［i］中对应的行数（0-3），取出B［i］［6］的第2到第5位连成一个4位数n（0-15），n就是S［i］中对应的列数，用S［i］［m］［n］代替B［i］［6］。S是4行16列的对应表，里面是4位的数，一共有8个S，定义如下：

　　S［1］：

　　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，

　　S［2］：

　　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，

　　S［3］：

　　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，

　　S［4］：

　　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，

　　S［5］：

　　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，

　　S［6］：

　　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，

　　S［7］：

　　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，

　　S［8］：

　　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，

　　8. 将从B［i］［6］经过S得到的8个4位数连起来得到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，

　　得到的结果与L［i］［32］作异或运算，把结果赋给R［i］［32］。

　　9. 把R［i-1］［32］的值赋给L［i］，从5开始循环。直到K［16］［48］结束。

　　10. 将最后的L，R合并成64位，然后进行如下转化得到最后的结果。这是对第4步的一个逆变化。

　　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

　　以上是Des的加密过程，解密过程同样，只需要把16个子密钥K［i］［48］的顺序颠倒过来就行了。


       Des的解密过程

　　代码：

　　/* filename： gy_des.cpp

　　*/

　　/*

　　* Some of codes are copyed from des.lib which is written by Eric Young （[e-mail]）

　　* You can get the lib from ftp://ftp.psy.uq.oz.au/pub/Crypto/DES/，

　　*/

　　#include “stdafx.h”

　　#include 《 bitset 》

　　#include 《 vector 》

　　#include 《 string 》

　　#include 《 iostream 》

　　using namespace std;

　　//using namespace gy;

　　typedef bitset《 4 》 _b4;

　　typedef bitset《 6 》 _b6;

　　typedef bitset《 8 》 _b8;

　　typedef bitset《 28 》 _b28;

　　typedef bitset《 32 》 _b32;

　　typedef bitset《 48 》 _b48;

　　typedef bitset《 56 》 _b56;

　　typedef bitset《 64 》 _b64;

　　typedef vector《 _b8 》 _vb8;

　　typedef vector《 _b48 》 _vb48;

　　typedef vector《 _b64 》 _vb64;

　　namespace {

　　const unsigned char odd_parity［256］={

　　1， 1， 2， 2， 4， 4， 7， 7， 8， 8， 11， 11， 13， 13， 14， 14，

　　16， 16， 19， 19， 21， 21， 22， 22， 25， 25， 26， 26， 28， 28， 31， 31，

　　32， 32， 35， 35， 37， 37， 38， 38， 41， 41， 42， 42， 44， 44， 47， 47，

　　49， 49， 50， 50， 52， 52， 55， 55， 56， 56， 59， 59， 61， 61， 62， 62，

　　64， 64， 67， 67， 69， 69， 70， 70， 73， 73， 74， 74， 76， 76， 79， 79，

　　81， 81， 82， 82， 84， 84， 87， 87， 88， 88， 91， 91， 93， 93， 94， 94，

　　97， 97， 98， 98，100，100，103，103，104，104，107，107，109，109，110，110，

　　112，112，115，115，117，117，118，118，121，121，122，122，124，124，127，127，

　　128，128，131，131，133，133，134，134，137，137，138，138，140，140，143，143，

　　145，145，146，146，148，148，151，151，152，152，155，155，157，157，158，158，

　　161，161，162，162，164，164，167，167，168，168，171，171，173，173，174，174，

　　176，176，179，179，181，181，182，182，185，185，186，186，188，188，191，191，

　　193，193，194，194，196，196，199，199，200，200，203，203，205，205，206，206，

　　208，208，211，211，213，213，214，214，217，217，218，218，220，220，223，223，

　　224，224，227，227，229，229，230，230，233，233，234，234，236，236，239，239，

　　241，241，242，242，244，244，247，247，248，248，251，251，253，253，254，254

　　};

　　const int keyperm_table56［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

　　};

　　const int keycompperm_table［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

　　};

　　const int keyshift_table［16］ = {

　　1， 1， 2， 2， 2， 2， 2， 2， 1， 2， 2， 2， 2， 2， 2， 1

　　};

　　const int datainitperm_table［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

　　};

　　const int dataexpperm_table［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

　　};

　　const int datasbox_table［8］［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}，

　　}

　　};

　　const int datapperm_table［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

　　};

　　const int datafp_table［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

　　};

　　template 《 size_t _NB 》

　　void rotateleft_bitset（bitset《 _NB 》& input， size_t step）

　　{

　　bitset《 _NB 》 tmp = input;

　　input 《《= step;

　　tmp 》》= _NB - step;

　　input |= tmp;

　　}

　　template 《 size_t _NB 》

　　void rotateright_bitset（bitset《 _NB 》& input， size_t step）

　　{

　　bitset《 _NB 》 tmp = input;

　　input 》》= step;

　　tmp 《《= _NB - step;

　　input |= tmp;

　　}

　　template 《 class Input， class Output， class Table》

　　void Des_Permutation（ const Input& input， Output& output， const Table& table， size_t TableSize）

　　{

　　for （size_t i = 0; i 《 TableSize; ++i） {

　　output［i］ = input［ table［i］-1 ］;

　　}

　　}

　　void Des_Key_Permutation1（const _b64& input， _b56& output）

　　{

　　Des_Permutation（input， output， keyperm_table56， sizeof（keyperm_table56）/sizeof（int））;

　　}

　　void Des_Key_CompPerm（const _b56& input， _b48& output）

　　{

　　Des_Permutation（input， output， keycompperm_table， sizeof（keycompperm_table）/sizeof（int））;

　　}

　　void Des_Key_Shift（_b56& key56， size_t step）

　　{

　　_b28 l28， r28;

　　int i;

　　for （i = 0; i 《 28; ++i） {

　　r28［i］ = key56［i］;

　　l28［i］ = key56［28+i］;

　　}

　　rotateleft_bitset（l28， step）;

　　rotateleft_bitset（r28， step）;

　　for （i = 0; i 《 28; ++i） {

　　key56［i］ = r28［i］;

　　key56［28+i］ = l28［i］;

　　}

　　}

　　void Des_Key_Generate（const _b64& key， _vb48& subkey）

　　{

　　_b56 tmp56;

　　Des_Key_Permutation1（key， tmp56）;

　　for （int i = 0; i 《 16; ++i） {

　　_b48 tmp48;

　　Des_Key_Shift（tmp56， keyshift_table［i］）;

　　Des_Key_CompPerm（tmp56， tmp48）;

　　cout 《《 “Key： ” 《《 tmp48 《《 endl;

　　subkey.push_back（tmp48）;

　　}

　　}

　　void Des_Char_To_Binary（char c， string& binary）

　　{

　　unsigned char tmp = odd_parity［c］;

　　binary.append（ （tmp & 0x80） ？ “1” ： “0” ）;

　　binary.append（ （tmp & 0x40） ？ “1” ： “0” ）;

　　binary.append（ （tmp & 0x20） ？ “1” ： “0” ）;

　　binary.append（ （tmp & 0x10） ？ “1” ： “0” ）;

　　binary.append（ （tmp & 0x08） ？ “1” ： “0” ）;

　　binary.append（ （tmp & 0x04） ？ “1” ： “0” ）;

　　binary.append（ （tmp & 0x02） ？ “1” ： “0” ）;

　　binary.append（ （tmp & 0x01） ？ “1” ： “0” ）;

　　}

　　void Des_String_To_Binary（const string& input， _b64& output）

　　{

　　string binary;

　　for （int i = 0; i 《 input.length（）; ++i ） {

　　Des_Char_To_Binary（input［i］， binary）;

　　}

　　_b64 tmp64（binary）;

　　output = tmp64;

　　}

　　void Des_String_To_Key（const string& key， _vb48& subkey）

　　{

　　_b64 tmp64;

　　Des_String_To_Binary（key， tmp64）;

　　Des_Key_Generate（tmp64， subkey）;

　　}

　　void Des_Data_ExpPerm（const _b32& input， _b48& output）

　　{

　　Des_Permutation（input， output， dataexpperm_table， sizeof（dataexpperm_table）/sizeof（int））;

　　}

　　void Des_Data_IP（const _b64& input， _b64& output）

　　{

　　Des_Permutation（input， output， datainitperm_table， sizeof（datainitperm_table）/sizeof（int））;

　　}

　　void Des_Data_S（const _b6& input， _b4& output， int step）

　　{

　　bitset《 2 》 tmp2;

　　_b4 tmp4;

　　tmp2［0］ = input［5］;

　　tmp2［1］ = input［0］;

　　tmp4［0］ = input［1］;

　　tmp4［1］ = input［2］;

　　tmp4［2］ = input［3］;

　　tmp4［3］ = input［4］;

　　_b8 t8（datasbox_table［step］［tmp2.to_ulong（）］［tmp4.to_ulong（）］）;

　　for （int i = 0; i 《 4; ++i） {

　　output［i］ = t8［i］;

　　}

　　}

　　void Des_Data_S（const _b48& input， _b32& output）

　　{

　　_b6 tmp6;

　　_b4 tmp4;

　　int i， j;

　　for （i = 0; i 《 8; ++i） {

　　for （j = 6; j 《 0; --j） {

　　tmp6［j］ = input［ 47 - i*6 - j］;

　　}

　　Des_Data_S（tmp6， tmp4， i）;

　　for （j = 0; j 《 4; ++j） {

　　output［ 31 - （i 《《 2） - j］ = tmp4［j］;

　　}

　　}

　　}

　　void Des_Data_P（const _b32& input， _b32& output）

　　{

　　Des_Permutation（input， output， datapperm_table， sizeof（datapperm_table）/sizeof（int））;

　　}

　　void Des_Data_F（_b64& input， const _b48& key）

　　{

　　_b32 l32， r32， tmp32， t32;

　　_b48 exp48;

　　int i;

　　for （i = 0; i 《 32; ++i ） {

　　r32［i］ = input［i］;

　　l32［i］ = input［32+i］;

　　}

　　//cout 《《 “r32** ” 《《 r32 《《 endl;

　　Des_Data_ExpPerm（r32， exp48）;

　　//cout 《《 “exp** ” 《《 exp48 《《 endl;

　　//cout 《《 “key** ” 《《 key 《《 endl;

　　exp48 ^= key;

　　//cout 《《 “exp** ” 《《 exp48 《《 endl;

　　Des_Data_S（exp48， tmp32）;

　　//cout 《《 “tmp** ” 《《 tmp32 《《 endl;

　　Des_Data_P（tmp32， t32）;

　　//cout 《《 “t32** ” 《《 t32 《《 endl;

　　t32 ^= l32;

　　l32 = r32;

　　r32 = t32;

　　for （i = 0; i 《 32; ++i ） {

　　input［i］ = r32［i］;

　　input［32+i］ = l32［i］;

　　}

　　}

　　void Des_data_FP（const _b64& input， _b64& output）

　　{

　　Des_Permutation（input， output， datafp_table， sizeof（datafp_table）/sizeof（int））;

　　}

　　int Des_encode_64bit（const _vb48& key， const _b64 &data， _b64 &output）

　　{

　　_b64 tmp64;

　　Des_Data_IP（data， tmp64）;

　　for （int i = 0; i 《 16; ++i） {

　　//cout 《《 “ ” 《《 tmp64 《《 endl;

　　Des_Data_F（tmp64， key［i］）;

　　//cout 《《 “ ” 《《 tmp64 《《 endl;

　　}

　　Des_data_FP（tmp64， output）;

　　return 0;

　　}

　　int Des_encode（const string& key， const string& data， _b64 &output）

　　{

　　_vb48 subkey， decodekey;

　　_b64 data64， tmp64;

　　Des_String_To_Key（key， subkey）;

　　for （int i = 0; i 《 16; ++i） {

　　decodekey.push_back（subkey［ 15-i ］）;

　　}

　　Des_String_To_Binary（data， data64）;

　　//cout 《《 “data： ” 《《 data64 《《 endl;

　　Des_encode_64bit（subkey， data64， output）;

　　//cout 《《 “code： ” 《《 output 《《 endl;

　　Des_encode_64bit（decodekey， output， tmp64）;

　　//cout 《《 “reco： ” 《《 tmp64 《《 endl;

　　if （tmp64 == data64） {

　　cout 《《 “Congratulation.$$$$$$$$$$$___FCKpd___1quot; 《《 endl;

　　}else {

　　cout 《《 ”Error. **************************“ 《《 endl;

　　}

　　return 0;

　　}

　　int Des_decode（const string& key， const string& data， _b64 &output）

　　{

　　return 0;

　　}

　　}

　　namespace gy {

　　/* Mode： true for encode， false for decode */

　　int Des（const string& key， const string& data， _b64 &output， bool Mode）

　　{

　　if （Mode） {

　　return Des_encode（key， data， output）;

　　}else {

　　return Des_decode（key， data， output）;

　　}

　　}

　　void Run_Des（void）

　　{

　　int select = 0;

　　string data， key;

　　cout 《《 ”1. encode;“ 《《 endl 《《 ”2. decode;“ 《《 endl 《《 ”Your choise： “;

　　cin 》》 select;

　　cout 《《 endl 《《 ”Please input the data： “;

　　cin 》》 data;

　　cout 《《 endl 《《 ”Please input the key： “;

　　cin 》》 key;

　　_b64 output;

　　if （select == 1） {

　　Des（key， data， output， true）;

　　}else {

　　Des（key， data， output， false）;

　　}

　　}

　　}

　DES算法加密解密C++源代码

　　/* coded by 东方甲乙 QQ:35782964 */

　　#include “stdio.h”

　　#include “memory.h”

　　#include《iostream》

　　using namespace std;

　　/////////////////// DES 加密/解密 /////////////////////////////

　　// pc1选位表

　　static const char des_pc1_table［56］ = {

　　56，48，40，32，24，16， 8，

　　0，57，49，41，33，25，17，

　　9， 1，58，50，42，34，26，

　　18，10， 2，59，51，43，35，

　　62，54，46，38，30，22，14，

　　6，61，53，45，37，29，21，

　　13， 5，60，52，44，36，28，

　　20，12， 4，27，19，11， 3

　　};

　　// pc2选位表

　　static const char des_pc2_table［48］ = {

　　13，16，10，23， 0， 4， 2，27，

　　14， 5，20， 9，22，18，11， 3，

　　25， 7，15， 6，26，19，12， 1，

　　40，51，30，36，46，54，29，39，

　　50，44，32，47，43，48，38，55，

　　33，52，45，41，49，35，28，31

　　};

　　// 左移位数表

　　static const char des_loop_table［16］ = {1，1，2，2，2，2，2，2，1，2，2，2，2，2，2，1};

　　// IP置换表

　　static const char des_ip_table［64］ = {

　　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，

　　56，48，40，32，24，16， 8， 0，

　　58，50，42，34，26，18，10， 2，

　　60，52，44，36，28，20，12， 4，

　　62，54，46，38，30，22，14， 6

　　};

　　// IP-1 逆置换表

　　static const char des_ip_r_table［64］ = {

　　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，

　　32， 0，40， 8，48，16，56，24

　　};

　　// E 选位表

　　static const char des_e_table［48］ = {

　　31， 0， 1， 2， 3， 4，

　　3， 4， 5， 6， 7， 8，

　　7， 8， 9，10，11，12，

　　11，12，13，14，15，16，

　　15，16，17，18，19，20，

　　19，20，21，22，23，24，

　　23，24，25，26，27，28，

　　27，28，29，30，31， 0

　　};

　　// S盒

　　static const char des_s_box［8］［4］［16］ = {

　　//S1

　　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，

　　//S2

　　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，

　　//S3

　　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，

　　//S4

　　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，

　　//S5

　　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，

　　//S6

　　12， 1，10，15， 9， 2， 6， 8， 0，12， 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，

　　//S7

　　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，

　　//S8

　　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

　　};

　　// p选位表

　　static const char des_p_table［32］ = {

　　15， 6，19，20，28，11，27，16，

　　0，14，22，25， 4，17，30， 9，

　　1， 7，23，13，31，26， 2， 8，

　　18，12，29， 5，21，10， 3，24

　　};

　　static char subkeys［16］［48］;

　　// 字节组转成位组

　　void byte_to_bit（char *out， const char *in， int bits）

　　{

　　int i;

　　for（i=0; i《bits; i++）

　　*out++ = （in［（i&~7）》》3］》》（i&7）） & 1;

　　}

　　// 位组转成字节组

　　void bit_to_byte（char *out， const char *in， int bits）

　　{

　　int i;

　　memset（out，0，（（bits+7）&~7）》》3）;

　　for（i=0; i《bits; i++）

　　out［（i&~7）》》3］ |= （*in++） 《《 （i&7）;

　　}

　　// 置换

　　void des_transform（char *out， char *in， const char *table， int len）

　　{

　　static char tmp［64］;

　　int i;

　　char *p = tmp;

　　for （i=0; i《len; i++）

　　*p++ = in［*table++］;

　　memcpy（out， tmp， len）;

　　}

　　void xor（char *a， const char *b， int len）

　　{

　　while （len--）

　　*a++ ^= *b++;

　　}

　　// S盒

　　void des_s_transform（char out［32］， const char in［48］）

　　{

　　int b，r，c;

　　for （b=0; b《8; out+=4，in+=6，b++）

　　{

　　r = （in［0］《《1） | in［5］;

　　c = （in［1］《《3） | （in［2］《《2） | （in［3］《《1） | in［4］;

　　byte_to_bit（out， &des_s_box［b］［r］［c］， 4）;

　　}

　　}

　　// 循环左移

　　void des_left_loop（char *in， int loop）

　　{

　　static bool tmp［2］;

　　memcpy（tmp，in，loop）;

　　memcpy（in，in+loop，28-loop）;

　　memcpy（in+28-loop，tmp，loop）;

　　}

　　// 16个子密钥

　　void des_make_subkeys（const char key［8］， char subkeys［16］［48］）

　　{

　　char bits［64］;

　　char *r=bits+28;

　　int i;

　　byte_to_bit（bits， key， 64）;

　　des_transform（bits，bits，des_pc1_table， 56）;

　　for （i=0; i《16; i++）

　　{

　　des_left_loop（bits， des_loop_table［i］）;

　　des_left_loop（r， des_loop_table［i］）;

　　des_transform（subkeys［i］，bits，des_pc2_table，48）;

　　}

　　}

　　// 混合数据和密钥

　　void des_mix（char in［32］， const char key［48］）

　　{

　　static char r［48］;

　　des_transform（r，in，des_e_table，48）;

　　xor（r，key，48）;

　　des_s_transform（in，r）;

　　des_transform（in，in，des_p_table，32）;

　　}

　　// 加密/解密

　　void des_go（char out［8］， const char in［8］， bool encrypt）

　　{

　　static char data［64］;

　　static char tmp［32］;

　　static char *r=data + 32;

　　int i;

　　byte_to_bit（data， in， 64）;

　　des_transform（data， data， des_ip_table， 64）;

　　if （encrypt） // 加密

　　{

　　for （i=0; i《16; i++）

　　{

　　memcpy（tmp， r， 32）;

　　des_mix（r， subkeys［i］）;

　　xor（r， data， 32）;

　　memcpy（data， tmp， 32）;

　　}

　　}

　　else // 解密

　　{

　　for （i=15; i》=0; i--）

　　{

　　memcpy（tmp， data， 32）;

　　des_mix（data， subkeys［i］）;

　　xor（data， r， 32）;

　　memcpy（r， tmp， 32）;

　　}

　　}

　　des_transform（data， data， des_ip_r_table， 64）;

　　bit_to_byte（out， data， 64）;

　　}