S-DES算法的实现

S-DES算法的实现

 

介绍

加密算法涉及五个函数:                                                  

(1) 初始置换IP (initial permutation)

(2) 复合函数fk1,它是由子密钥K1确定的,混合了代换和置换的运算。

     (3) 交换函数SW (Switch)

     (4) 复合函数fk2 ,由子密钥K2确定

     (5) 初始置换IP的逆置换IP-1

 

加密算法的数学表示:  IP-1*fk2*SW*fk1*IP

也可写为   密文=IP-1(fk2(SW(fk1(IP(明文)))))                                                其中       K1=P8(移位(P10(密钥K)))                                                                  
           K2=P8(移位(移位(P10(密钥K))))

解密算法的数学表示:  明文=IP-1(fk1(SW(fk2(IP(密文)))))

以下是用C++写的源码

 

#include <iostream>

#include <bitset>

#include <string>

 

using namespace std;

 

const int KEY = 10;                                //密钥长度

const int HALF_KEY = 5;                        //密钥长度的一半

const int SUB_KEY = 8;                         //子密钥长度

const int TEXT = 8;                                //明文或密文的长度

const int HALF_TEXT = 4;                       //明文或密文长度的一半

const int QUARTER_TEXT = 2;                    //明文或密文长度的四分之一

 

const string P10 = "2416390875";          //置换密钥的字符串

const string P8 = "52637498";                  //从位的密钥中抽取位组成子密钥的置换字符串

const string IP = "15203746";                  //置换明文的字符串

const string IP_1 = "30246175";                //逆置换明文的字符串

const string EP = "30121230";                  //扩展置换的字符串

const int S0[4][4] =                           //S0 Box

{

     {1, 0, 3, 2},     

     {3, 2, 1, 0},

     {0, 2, 1, 3},

     {3, 1, 3, 2}

};

 

const int S1[4][4] =                           //S1 Box

{

     {0, 1, 2, 3},

     {2, 0, 1, 3},

     {3, 0, 1, 0},

     {2, 1, 0, 3}

};

 

 

class SDES

{

public:

     //构造函数

     SDES(const char* password)

     {

         key = bitset<KEY>(password);    

         k1 = CreateK1(key);

         k2 = CreateK2(key);

     }

 

     SDES(string password)

     {

         key = bitset<KEY>(password);    

         k1 = CreateK1(key);

         k2 = CreateK2(key);

     }

    

     //加密

     bitset<TEXT> Encrypt(bitset<TEXT> src)

     {

         bitset<TEXT> ipText = ExchangeTextPos(src, IP);

         bitset<HALF_TEXT> leftText = GetTextLeft(ipText);

         bitset<HALF_TEXT> rightText = GetTextRight(ipText);

         bitset<HALF_TEXT> boxOutput, rsOutput;

         boxOutput = EncryptBox(leftText, rightText, k1);

         rsOutput = EncryptBox(rightText, boxOutput, k2);

         bitset<TEXT> ip_1Text = FormText(rsOutput, boxOutput); 

         return ExchangeTextPos(ip_1Text, IP_1);

    

     }

 

     //加密

     bitset<TEXT> Encrypt(string src)

     {

         return Encrypt(bitset<TEXT>(src));

     }

    

     //解密

     bitset<TEXT> Decrypt(bitset<TEXT> src)

     {

         bitset<TEXT> ipText = ExchangeTextPos(src, IP);

         bitset<HALF_TEXT> leftText = GetTextLeft(ipText);

         bitset<HALF_TEXT> rightText = GetTextRight(ipText);

         bitset<HALF_TEXT> boxOutput, rsOutput;

         boxOutput = EncryptBox(leftText, rightText, k2);

         rsOutput = EncryptBox(rightText, boxOutput, k1);

         bitset<TEXT> ip_1Text = FormText(rsOutput, boxOutput);

         return ExchangeTextPos(ip_1Text, IP_1);

     }

 

     //解密

     bitset<TEXT> Decrypt(string src)

     {

         return Decrypt(bitset<TEXT>(src));

     }

    

private:

     bitset<KEY> key;            //密钥

     bitset<SUB_KEY> k1;              //子密钥K1

     bitset<SUB_KEY> k2;              //子密钥K2

    

     //根据参数newPos改变密钥各位的位置

     bitset<KEY> ExchangeKeyPos(bitset<KEY> src, string newPos)

     {

         bitset<KEY> rs;

         int i;

         for (i = 0; i < KEY; i++)

         {

              rs.at(KEY - 1 - i) = src.at(KEY -1 - newPos[i] + '0');

         }

         return rs;

     }

    

     //根据参数newPos改变明文各位的位置

     bitset<TEXT> ExchangeTextPos(bitset<TEXT> src, string newPos)

     {

         bitset<TEXT> rs;

         int i;

         for (i = 0; i < TEXT; i++)

         {

              rs.at(TEXT - 1 - i) = src.at(TEXT -1 - newPos[i] + '0');

         }

         return rs;

     }

    

     //获取密钥的左半边

     bitset<HALF_KEY> GetKeyLeft(bitset<KEY> src)

     {

         bitset<HALF_KEY> leftKey;

         int i;

         for (i = 0; i < HALF_KEY; i++)

         {

              leftKey.at(i) = src.at(HALF_KEY + i);

         }

         return leftKey;

     }

    

     //获取密钥的右半边

     bitset<HALF_KEY> GetKeyRight(bitset<KEY> src)

     {

         bitset<HALF_KEY> rightKey;

         int i;

         for (i = HALF_KEY; i < KEY; i++)

         {

              rightKey.at(i - HALF_KEY) = src.at(i - HALF_KEY);

         }

         return rightKey;

     }

    

     //根据密钥的左右两边形成完整的密钥

     bitset<KEY> FormKey(bitset<HALF_KEY> leftKey, bitset<HALF_KEY> rightKey)

     {

         bitset<KEY> rsKey;

         int i;

         for (i = 0; i < HALF_KEY; i++)

         {

              rsKey.at(i) = rightKey.at(i);

         }

         for (i = HALF_KEY; i < KEY; i++)

         {

              rsKey.at(i) = leftKey.at(i - HALF_KEY);

         }

         return rsKey;

     }

    

     //获取明文的左半边

     bitset<HALF_TEXT> GetTextLeft(bitset<TEXT> src)

     {

         bitset<HALF_TEXT> leftText;

         int i;

         for (i = 0; i < HALF_TEXT; i++)

         {

              leftText.at(i) = src.at(HALF_TEXT + i);

         }

         return leftText;

     }

    

     //获取明文的右半边

     bitset<HALF_TEXT> GetTextRight(bitset<TEXT> src)

     {

         bitset<HALF_TEXT> rightText;

         int i;

         for (i = HALF_TEXT; i < TEXT; i++)

         {

              rightText.at(i - HALF_TEXT) = src.at(i - HALF_TEXT);

         }

         return rightText;

     }

    

     //根据明文的左右两边形成完整的明文

     bitset<TEXT> FormText(bitset<HALF_TEXT> leftText, bitset<HALF_TEXT> rightText)

     {

         bitset<TEXT> rsText;

         int i;

         for (i = 0; i < HALF_TEXT; i++)

         {

              rsText.at(i) = rightText.at(i);

         }

         for (i = HALF_TEXT; i < TEXT; i++)

         {

              rsText.at(i) = leftText.at(i - HALF_TEXT);

         }

         return rsText;

     }

    

     //根据参数newPos从位的密钥中抽取位组成子密钥

     bitset<SUB_KEY> PickSubKey(bitset<KEY> src,string newPos)

     {

         bitset<SUB_KEY> rs;

         int i;

         for (i = 0; i < SUB_KEY; i++)

         {

              rs.at(SUB_KEY -1 -i) = src.at(KEY -1 - newPos[i] + '0');

         }

         return rs;

     }

    

     //根据参数newPos将位明文数据扩展成位

     bitset<TEXT> ExtendText(bitset<HALF_TEXT> src, string newPos)

     {

         bitset<TEXT> rs;

         int i;

         for (i = 0; i < TEXT; i++)

         {

              rs.at(TEXT - 1 - i) = src.at(HALF_TEXT -1 - newPos[i] + '0');

         }

         return rs;

     }

    

     //将一半长的密钥循环左移(有效范围~HALF_KEY位)

     bitset<HALF_KEY> CircleMoveLeft(bitset<HALF_KEY> src, int moveStep)

     {

         bitset<HALF_KEY> tmp1,tmp2,rs;

         tmp1 = src << moveStep;

         tmp2 = src >> HALF_KEY - moveStep;

         rs = tmp1 | tmp2;

         return rs;

     }

    

     //创建子密钥

     bitset<SUB_KEY> CreateSubKey(bitset<KEY> src, int moveLeft)

     {

         bitset<KEY> p10Key = ExchangeKeyPos(src, P10);

         //将密钥拆分成两半

         bitset<HALF_KEY> hKey1, hKey2;

         hKey1 = GetKeyLeft(p10Key);

         hKey2 = GetKeyRight(p10Key);

         //循环左移

         hKey1 = CircleMoveLeft(hKey1, moveLeft);

         hKey2 = CircleMoveLeft(hKey2, moveLeft);

         //将已拆成的两半重新组合成密钥

         bitset<KEY> tmpKey = FormKey(hKey1,hKey2);

         //从位的密钥中抽取位组成子密钥

         return PickSubKey(tmpKey, P8);

     }

    

     //创建子密钥K1

     bitset<SUB_KEY> CreateK1(bitset<KEY> src)

     {

         return CreateSubKey(src, 1);

     }

    

     //创建子密钥K2

     bitset<SUB_KEY> CreateK2(bitset<KEY> src)

     {

         //由于K2是在K1循环左移位的基础上循环左移位,因此总共循环左移位

         return CreateSubKey(src, 3);

     }

    

     //返回二进制数据的十进制形式(有效位数位)

     int ReturnDecimal(string binary)

     {

         if (binary == "11")

         {

              return 3;

         }

         else if (binary == "10")

         {

              return 2;

         }

         else if (binary == "01")

         {

              return 1;

         }

         else if (binary == "00")

         {

              return 0;

         }

         else

         {

              return -1;

         }

     }

    

     //SBox

     bitset<QUARTER_TEXT> SBox(bitset<HALF_TEXT> src, const int sbox[4][4])

     {

         string row = "00", col = "00";

         row[0] = src[3] + '0';

         row[1] = src[0] + '0';

         col[0] = src[2] + '0';

         col[1] = src[1] + '0';

         int decimal = sbox[ReturnDecimal(row)][ReturnDecimal(col)];

         return bitset<QUARTER_TEXT>(decimal);

     }

    

     //P4

     bitset<HALF_TEXT> P4(bitset<QUARTER_TEXT> src1, bitset<QUARTER_TEXT> src2)

     {

         bitset<HALF_TEXT> rs;

         rs[3] = src1[0];

         rs[2] = src2[0];

         rs[1] = src2[1];

         rs[0] = src1[1];

         return rs;

     }

    

     //一次加密

     bitset<HALF_TEXT> EncryptBox(bitset<HALF_TEXT> leftText, bitset<HALF_TEXT> rightText,

         bitset<SUB_KEY> subKey)

     {

         bitset<TEXT> epText = ExtendText(rightText, EP);

         bitset<TEXT> xorText1 = epText ^ subKey;

         bitset<HALF_TEXT> s0Input, s1Input;

         bitset<QUARTER_TEXT> s0Output, s1Output;

         s0Input = GetTextLeft(xorText1);

         s1Input = GetTextRight(xorText1);

         s0Output = SBox(s0Input, S0);

         s1Output = SBox(s1Input, S1);

         bitset<HALF_TEXT> p4 = P4(s0Output, s1Output);

         bitset<HALF_TEXT> boxOutput = p4 ^ leftText;

         return boxOutput;

     }   

    

};

 

 

int main(int argc, char *argv[])

{

     //验证输入参数并显示用法

     bool isValid=true;

     if (argc == 4)

     {

         isValid &= (strcmp(argv[1], "e")==0 || strcmp(argv[1], "d")==0

              || strcmp(argv[1], "E")==0 || strcmp(argv[1], "D")==0);

         isValid &= (strlen(argv[2])==10);

         isValid &= (strlen(argv[3])==8);

     }

     else

     {

         isValid = false;

     }

     if (isValid == false)

     {

         cout << endl;

         cout << "Usage: S-DES <E|D> <Key> <Text>" << endl ;

         cout << endl;

         return 0;

     }

 

     //加密或解密

     string key(argv[2]), text(argv[3]);

     SDES des(key);

     if (strcmp(argv[1], "e") == 0 || strcmp(argv[1], "E") ==0 )

     {

         cout << des.Encrypt(text) << endl;

     }

     else

     {

         cout << des.Decrypt(text) << endl;

     }

     return 0;

}

 

 

 

阅读更多
上一篇C语言编写的简单的学生成绩管理系统
下一篇怎样使Windows启动时播放长时间的音乐
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭