S-DES算法的实现

最新推荐文章于 2021-12-02 20:40:30 发布
最新推荐文章于 2021-12-02 20:40:30 发布
阅读量4.3k 收藏 3
点赞数
文章标签： 算法 string output input permutation 加密
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Virlene/article/details/1501064
版权

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;

}

 

 

 
Virlene
关注
s-des和des算法实现
05-31
实现s-des和des，实现控制台对所有文件加解密。 附赠文档一份。可以从控制台输入加解密的文件。并对文件实行相应操作。可以加解密utf-8上的任意字符。
S-DES算法的源代码
11-07
一种简单的加密算法。能实现对简单文件的加密。
一个完整的des算法的c语言实现
03-10
一个完整的des算法的c语言实现 包括解密和加密两部分 稍微做了一个简短的界面 （des 而非 sdes）
S—DES算法分析及实现
06-02
S—DES算法分析及实现论文，精确而细致的秒数了DES算法实现的过程。
s_des8位加密解密算法实现源码+详细注释
12-20
8位的S-DES加密解密系统,通过输入字符,然后经过加密后输出密文字符。同时也可以输入密文解密出明文。这个是我们密码学的作业我自己写的 并且测试了,没有程序模块没有错误
s-des算法分析及实现.rar_DES 密码_des_des算法 报告_s-des_迭代
09-23
:ＤＥＳ体制是ＩＳＯ颁布的数据加密标准,通过对ＤＥＳ算法的分析,提出了用Ｃ语言实现数据加密标准ＤＥＳ算法,通过循环或迭代,将简单的基本运算(例如左移、右移、模2加法等)和变换(选择函数、置换函数)构造成数据流的...
des.rar_S-DES算法_des linux_des变形_linux_linux des
09-21
- "des"：可能是包含DES和S-DES算法实现的源代码文件，可能按照编程语言分类，也可能包含了不同环境下的实现。 综合以上信息，这个压缩包提供了对DES和S-DES算法深入理解的机会，包括它们在不同操作系统上的实现，...
基于Python的S-DES算法信息安全导论作业设计源码
04-14
本项目是基于Python的S-DES算法信息安全导论作业设计源码，共有25个文件，包括19个PNG文件、2个MD文件等。系统实现了S-DES算法，用于演示信息安全导论课程中的加密和解密过程。系统的设计注重代码的可读性和可维护性...
s-des.rar_s-des
09-21
通过阅读`s-des.txt`文件，你可以看到具体的S-DES算法实现，包括代码和可能的测试用例，这将有助于深入理解算法的工作原理。学习S-DES有助于初学者逐步掌握密码学的基础知识，并为进一步研究高级加密算法如AES打下...
S-DES的简单理解和实例
qq_42446422的博客
04-25 4343
S-DES是一个供教学而非安全使用的加密算法，与DES的特性和结构类似，但它参数小，明文分组为8位，主密钥分组为10位，采用两轮选代。 例题： 采用手工方式使用 S-DES用密钥（01111 11101）解密比特串（10100010），写出每个函数(IP, Fk, SW, Fk, IP-1)之后的中间结果。（首先要知道下列一系列的表格） P10 1 2 3 4 5 6 7 8 9 10 3 5 2 7 4 10.
SDES算法实现
10-25
带图形界面的SDES算法实现。 并且加密方式采用CBC模式。
sdes 简化DES用C语言实现
04-25
用C语言实现SDES加密算法 数字:
DES加密算法（c语言实现）
06-03
个人编的DES加密程序，要想了解具体算法说明或者其他加密算法请关注我的博客----适合任何对算法理解不透彻的密码初学者和爱好者。
DES加密算法C语言实现
05-15
一个加密算法的实现，最最重要的关键词是—速度。 举个例子来说明，速度对加密算法的重要：假设我们实现了两个加密算法DES1.0和DES2.0， 其中DES1.0的速度为900KB/S，DES2.0的速度为1000KB/S。假设一个文件有10G，我需要对其进行加密， 那么，用DES1.0所耗费的时间为1111s，DES2.0的速度为1000S。DES2.0比DES1.0快了111秒。 现实生活里我们要加密的数据还可能远远不止10G。不要小看这111S，要知道，让CPU尽可能的为用户服务， 是我们每一个程序员的职责，不论你是用C，C++还是JAVA。因此，为了速度，我们必须舍弃一些东西。
实现S-DES对任意文件的加解密
12-13
实现S-DES对任意文件的加解密（命令行方式） 控制台编程： int main(int argc, char *argv[ ])
S-DES算法java实现（源码下载）
the_fire的技术博客
11-25 2715
<br /><br />今天上午分析了一下S-DES算法的大概流程，因为小区要停电，所以只是简单的分析了一下。实现是今天晚上写出来的。<br />有了DES分析的过程之后，S-DES的分析和实现都简单多了。以至于实现的时候直接看这流程图就开始写了。当时一边和同学聊着天一边敲着代码一边思考着：我也太笨了，到现在才学会看着流程图写程序，我自己很汗颜。<br />言归正传，类结构上和DES基本相同，不过这里把密钥生成部分给单独提取出来了，这样我感觉更直观。<br />S_DES：专门用来被别人直接调用的，也可以说
S-DES算法的C语言实验
hackermengzhi的博客
12-02 1783
#include <bits/stdc++.h> using namespace std; //把矩阵直接置换为二进制 int S1[4][4][2]={{{0,1},{0,0},{1,1},{1,0}}, {{1,1},{1,0},{0,1},{0,0}}, {{0,0},{1,0},{0,1},{1,1}}, {{1,1},{0,1},{0,0},{1,0}}}; int S2[4][4][
DES算法代码
abc
05-04 1043
DES算法代码 https://blog.csdn.net/bengold1979/article/details/2208930这是之前的一篇文章，今天才发现之前没有把内容放进来。真是晕头了。幸好看了看评论，有人指出来了。实在是不好意思。现在把代码补上来；声明，不是我自己完全原创的。也是从网上找到一个别人的东西，然后改造了一下。 #ifndef CDES_H_CAESAR__DEF #defin
S-DES简单介绍
the_fire的技术博客
11-17 2445
       关于DES（Data Encryption Standard）已经有所了解了，不过看题目说的是S-DES，不太理解是什么意思，google查了一下，没有找到解释，百度一下吧，更别说了，果然百度是不擅长技术搜索的。后来一想，中文的找不到应该找英文的，于是把google设置为查询英文内容，果然找到几个，虽然不是专门介绍，但只言片语也就够我了解了。       并且查到的资料也比查询中文内容时多，何故？大家心里都清楚的。其实中文的在期刊论文中也能找得到，不过期刊论文一般都是收费的。       看了
c语言实现S-DES算法
最新发布
08-21
S-DES（Substitution-Permutation Network，置换-替换网络）是一种简化版本的DES（Data Encryption Standard，数据加密标准），它通常用于教学和小规模实验，而不是实际生产环境。在C语言中实现S-DES，你需要了解其基本结构，包括代换（Substitution）步骤和排列（Permutation）步骤。 以下是一个简单的S-DES算法的伪代码描述： ```c typedef struct { unsigned char key[8]; // 64位密钥 unsigned char in[8]; // 输入明文块 unsigned char out[8]; // 输出密文块 } SDesContext; void init(SDesContext* context, const unsigned char key[]) { // 初始化S-DES上下文，这里仅示例，真实应用需考虑更多细节 memcpy(context->key, key, 8); } void s_des_round(SDesContext* context) { // 包含16轮替换和置换操作的具体实现 // 这部分需要你自己编写具体的代换表和循环移位操作 } void s_des_encrypt(SDesContext* context, const unsigned char plaintext[]) { for (int i = 0; i < 8; ++i) { context->in[i] = plaintext[i]; s_des_round(context); } memcpy(context->out, context->in, 8); // 将处理后的数据复制到输出 } // 使用示例 int main() { SDesContext ctx; init(&ctx, your_key); // 替换真实的密钥 s_des_encrypt(&ctx, your_plaintext); // 加密明文 return 0; } ``` 请注意，这只是一个非常基础的框架，实际实现会更复杂，并需要你编写详细的代换函数以及安排好循环移位和其他特定的S-DES变换。此外，为了完整实现，还需要包括秘钥扩展和分组过程等。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值