DES加密算法详解
DES算法详细介绍

DES算法详细介绍DES(Data Encryption Standard),即数据加密标准,是一种对称密钥加密算法,由IBM公司于1975年研制。
DES算法的设计思想是通过使用56位的密钥对64位的明文进行加密,得到64位的密文。
同时,利用相同的密钥可以对密文进行解密,得到原始的明文。
1.首先,将64位的明文分割成左右两个32位的部分,分别称为L0和R0。
2.接着,重复进行16轮的加密操作。
在每一轮中,右边的32位部分Rn会作为下一轮的左边部分Ln+1的输入。
3. 在每一轮中,Rn经过扩展变换(Expansion Permutation)和异或运算,与轮密钥Kn进行异或运算,得到48位的输出。
然后,将这48位的输出经过S盒(Substitution Box)代替(Substitution)和P盒(Permutation Box)置换,得到32位的输出。
将这32位的输出与左边的32位部分Ln进行异或运算,得到右边的32位部分Rn+14.最后一轮结束后,将最后的输出L16和R16进行交换,并将它们合并成一个64位的输出,即密文。
DES算法中的核心组件是S盒,其作用是将输入的6位转换为4位的输出。
S盒是由8个不同的4x16的盒子组成,每个盒子完成从输入到输出的映射。
每个S盒通过6位输入中的前后两位选定对应的盒子行号和中间4位选定的盒子列号,然后将该行和列对应的值输出,将其转换为4位输出。
这样,每个S盒都可以通过4位选择的索引实现16种可能的映射。
在DES算法中,密钥长度为64位,但由于其中的8个位作为奇偶校验位而被忽略,因此实际有效的密钥长度为56位。
在加密过程中,使用密钥生成16个48位的子密钥,每个子密钥仅使用56位密钥中的不同的48位。
为了增加安全性,DES中的每个子密钥都通过将一部分密钥以及一部分已生成的子密钥作为输入,经过置换、循环左移、选择等操作生成。
然而,由于DES算法的密钥长度较短,易受到密码分析方法的攻击。
DES加密算法详解

DES加密算法详解DES(Data Encryption Standard)是一种对称加密算法,也就是加密和解密使用的是同一个密钥。
DES的密钥长度为56位,被认为安全性较低,现已逐渐被AES(Advanced Encryption Standard)所取代。
但是,了解DES的加密算法原理仍然有助于理解其他加密算法的工作原理。
DES的加密算法主要分为四个步骤:初始置换、轮函数、密钥生成和逆初始置换。
下面对每个步骤进行详细介绍。
1. 初始置换(Initial Permutation):将输入的64位明文按照预定的IP表进行置换,将明文的顺序打乱。
这样可以打破明文的顺序规律,增加加密的随机性。
2. 轮函数(Round Function):DES算法通过16个相同的轮函数来加密数据。
轮函数主要包含四个步骤:扩展置换、异或运算、S盒代替和P置换。
- 扩展置换(Expansion Permutation):将32位的R部分进行扩展变换,得到48位的数据。
这样做是为了增加数据的混合程度,增加加密强度。
-异或运算(XOR):将扩展数据与48位的轮密钥进行异或运算,得到的结果作为S盒代替的输入。
异或运算的目的是为了对数据进行混淆,增加加密的随机性。
- S盒代替(Substitution Boxes):DES算法中包含了8个S盒,每个S盒为4x16的矩阵。
将上一步得到的48位数据分成8组,每组6位。
根据S盒中的索引,将每组数据转换成4位的数据。
S盒的目的是为了进行数据的替换和混淆,增加加密的随机性。
- P置换(Permutation):将上一步得到的32位数据按照P表进行置换。
P表是一个固定的置换表,目的是为了进一步增加加密的随机性。
3. 密钥生成(Key Generation):DES算法使用56位的密钥,但是每一轮只使用48位。
因此,需要根据原始密钥生成16组48位的轮密钥。
密钥生成主要包含两个步骤:置换选择1(PC-1)和置换选择2(PC-2)。
DES算法

DES算法一、DES算法DES算法为密码体制中的对称密码体制,又被成为美国数据加密标准,是1972年美国IBM 公司研制的对称密码体制加密算法。
明文按64位进行分组, 密钥长64位,密钥事实上是56位参与DES运算(第8、16、24、32、40、48、56、64位是校验位,使得每个密钥都有奇数个1)分组后的明文组和56位的密钥按位替代或交换的方法形成密文组的加密方法。
DES加密算法特点:分组比较短、密钥太短、密码生命周期短、运算速度较慢。
DES工作的基本原理是,其入口参数有三个:key、data、mode。
key为加密解密使用的密钥,data为加密解密的数据,mode为其工作模式。
当模式为加密模式时,明文按照64位进行分组,形成明文组,key用于对数据加密,当模式为解密模式时,key用于对数据解密。
实际运用中,密钥只用到了64位中的56位,这样才具有高的安全性。
DES算法把64位的明文输入块变为64位的密文输出块,它所使用的密钥也是64位,整个算法的主流程图如下:其功能是把输入的64位数据块按位重新组合,并把输出分为L0、R0两部分,每部分各长32位,其置换规则见下表: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,即将输入的第58位换到第一位,第50位换到第2位,...,依此类推,最后一位是原来的第7位。
L0、R0则是换位输出后的两部分,L0是输出的左32位,R0 是右32位,例:设置换前的输入值为D1D2D3......D64,则经过初始置换后的结果为:L0=D58D50...D8;R0=D57D49 (7)经过16次迭代运算后。
DES例题详解

DES例题详解摘要:一、DES加密算法简介1.DES加密原理2.DES算法结构二、DES例题详解1.实例一:DES加密过程解析2.实例二:DES解密过程解析3.实例三:DES加密解密实战应用三、DES加密算法的优缺点1.优点2.缺点四、DES算法的改进与延伸1.三重DES算法2.AES加密算法正文:一、DES加密算法简介1.DES加密原理DES加密算法是一种对称加密算法,其加密过程是将明文经过16轮的加密操作,最终生成密文。
DES算法依赖于密钥,相同的明文使用相同的密钥加密后,得到的密文相同。
2.DES算法结构DES算法的主要结构包括:置换、替换、S盒替换和置换。
其中,置换操作是将明文分成左右两部分,分别进行加密;替换操作是将置换后的明文部分进行替换;S盒替换是将替换后的明文部分通过S盒进行替换;最后再进行置换操作,得到密文。
二、DES例题详解1.实例一:DES加密过程解析假设明文为:ABCDEF,密钥为:123456。
(1)置换:将明文分成左右两部分,分别为ABC和DEF。
(2)替换:将左右两部分分别进行替换操作,得到:TFEC和ADCB。
(3)S盒替换:将替换后的左右两部分分别进行S盒替换,得到:XYZAB和MPQST。
(4)再置换:将替换后的两部分进行置换,得到密文:MPQSTXYZAB。
2.实例二:DES解密过程解析假设密文为:MPQSTXYZAB,密钥为:123456。
(1)解密置换:将密文进行解密置换,得到:ABCDEF。
(2)解密替换:将解密后的密文部分进行解密替换,得到:TFECB和ADCB。
(3)解密S盒替换:将解密后的左右两部分分别进行解密S盒替换,得到:XYZAB和MPQST。
(4)再解密置换:将解密后的两部分进行解密置换,得到明文:ABCDEF。
3.实例三:DES加密解密实战应用在实际应用中,DES加密解密算法广泛应用于数据保护、网络安全等领域。
以下是一个简单的DES加密解密实战应用示例:明文:Hello, World!密钥:1234561.使用DES加密算法加密明文:- 置换:将明文分成左右两部分,分别为Hello和World。
DES算法的详细分析

DES算法的详细分析DES(Data Encryption Standard)是一种对称加密算法,是在计算机领域最常用的加密算法之一、DES算法是由IBM的Horst Feistel于1973年研究开发的。
DES是一种分组密码,每个64位的明文分组经过一系列的置换和替换运算,最终被加密成一个64位的密文。
DES算法采用分组密码的模式,每个明文分组被分成64位,然后通过一系列的置换和替换操作,最终得到一个64位的密文。
DES算法中最重要的部分是Feistel网络结构,它是一种用于对称加密的结构,包含16轮的加密操作。
在每一轮中,明文分组被分成左右两部分,左半部分和右半部分经过不同的置换和替换操作后再结合在一起,形成下一轮操作的输入。
DES算法的核心是密钥调度算法和轮函数。
密钥调度算法用于生成每一轮的子密钥,通过对原始64位密钥进行置换和替换操作得到16个48位的子密钥。
轮函数是DES算法中的重要部分,它包括扩展、异或、S盒替换和置换操作,通过这些操作对每一轮的输入进行计算,最终得到输出。
DES算法的优点是加密速度快,实现简单,安全性较高。
然而,DES算法也存在一些缺点,主要是密钥长度太短,只有56位,这使得DES算法容易受到暴力破解攻击。
为了增强安全性,人们提出了3DES算法和AES算法。
3DES(Triple Data Encryption Standard)是DES的增强版,它使用了两个密钥对数据进行三次加密,增强了安全性。
3DES算法的密钥长度为112位或168位,比DES算法的56位密钥更加安全。
AES(Advanced Encryption Standard)是一种高级加密标准,目前被广泛应用于电子商务和互联网安全领域。
AES算法使用了更长的密钥长度(128位、192位或256位),并采用了更复杂的置换和替换操作,提高了安全性。
总的来说,DES算法是一种经典的加密算法,虽然在现代网络安全领域已经被3DES和AES算法所取代,但DES算法仍然被广泛应用于传统密码学和网络安全领域。
DES加密算法

DES加密算法1950年代末至1970年代初,密码学家发现了许多消息传递系统被成功入侵的案例。
为了应对这种威胁,美国国家安全局(NSA)与IBM公司合作开发了一种新的加密算法,即数据加密标准(Data Encryption Standard,简称DES)。
DES在20世纪70年代末被正式采纳,并成为许多国家及组织使用的标准加密算法,它不仅安全可靠,而且非常高效。
本文将对DES加密算法进行详细介绍。
一、DES加密算法简介DES加密算法是一种对称密钥算法,使用相同的密钥进行加密和解密。
在加密和解密过程中,DES算法将数据分成64位大小的数据块,并进行一系列置换、替换、混淆和反混淆等操作。
DES算法共有16轮运算,每轮运算都与密钥有关。
最终输出的密文与64位的初始密钥相关联,只有使用正确的密钥才能解密并还原原始数据。
二、DES加密算法的原理DES算法的核心是通过一系列的置换、替换和混淆技术对数据进行加密。
以下是DES算法的主要步骤:1. 初始置换(Initial Permutation)DES算法首先将明文进行初始置换,通过一系列规则将64位明文重新排列。
2. 轮函数(Round Function)DES算法共有16个轮次,每轮都包括以下几个步骤:a) 拓展置换(Expansion Permutation)将32位的数据扩展为48位,并进行重新排列。
b) 密钥混淆(Key Mixing)将48位的数据与轮次对应的子密钥进行异或运算。
c) S盒代替(S-box Substitution)将48位的数据分为8个6位的块,并根据S盒进行替换。
S盒是一个具有固定映射关系的查找表,用于增加加密算法的复杂性和安全性。
d) 置换函数(Permutation Function)经过S盒代替后,将得到的数据再进行一次置换。
3. 左右互换在每轮的运算中,DES算法将右半部分数据与左半部分进行互换,以实现加密算法的迭代。
4. 逆初始置换(Inverse Initial Permutation)最后,DES算法对经过16轮运算后的数据进行逆初始置换,得到最终的密文。
DES算法的详细分析

DES算法的详细分析DES(Data Encryption Standard)是一种对称加密算法,是美国联邦政府使用的加密标准。
它采用了分组密码的方式对数据进行加密和解密处理。
本文将对DES算法进行详细分析,涵盖算法原理、加密过程、密钥生成、弱点以及DES的安全性评估等方面。
1.算法原理:-将明文数据分成64位的分组,使用64位密钥进行加密。
-密钥通过密钥生成算法进行处理,生成16个48位的子密钥。
-明文分为左右两半部分,每轮加密时,右半部分与子密钥进行逻辑运算,并与左半部分进行异或操作。
-运算结果作为下一轮的右半部分,左半部分不变。
循环16轮后得到密文。
2.加密过程:-初始置换(IP):将64位明文按照预定的规则进行位重排。
-分为左右两半部分L0,R0。
-通过16轮的迭代过程,每轮使用不同的48位子密钥对右半部分进行扩展置换(E盒扩展),与子密钥进行异或操作,再通过S盒代换和P 盒置换输出。
-将经过迭代的左右两半部分进行交换。
-最后经过逆初始置换(IP^-1)后输出64位密文。
3.密钥生成:-密钥生成算法从初始64位密钥中减小奇偶校验位,然后使用置换选择1(PC-1)表对密钥进行位重排,得到56位密钥。
-将56位密钥分为两部分,每部分28位,并进行循环左移操作,得到16个48位的子密钥。
4.弱点:-DES算法的密钥长度较短,只有56位有效位,容易受到穷举攻击。
-由于DES算法设计时的数据量较小,运算速度较快,使得密码破解更加容易。
-DES算法对明文的局部统计特性没有进行充分的打乱,可能导致部分明文模式的加密结果不够随机。
5.DES的安全性评估:-DES算法的弱点导致了它在现代密码学中的安全性问题,已经不再适用于高强度加密要求的场景。
- 美国国家标准与技术研究所(NIST)发布了Advanced Encryption Standard(AES)来替代DES作为加密标准。
-DES算法可以用于低安全性需求的领域,或作为加密算法的组成部分。
DES加密算法详解

DES加密算法详解DES(Data Encryption Standard)是一种对称加密算法,是最早被广泛使用的加密算法之一、它于1977年被美国国家标准局(NIST)作为联邦信息处理标准(FIPS)发布,并在接下来的几十年内被广泛应用于数据加密领域。
下面将对DES加密算法进行详细解释。
DES算法使用一个56位的密钥来加密64位的数据块。
密钥经过一系列的处理后生成16个48位的子密钥,然后对数据块进行16轮的加密处理。
每轮加密又包括初始置换、扩展置换、与子密钥异或、S盒置换、P置换等步骤。
初始置换(IP)是DES算法的第一步,通过将输入的64位数据块按照特定的规则重新排列来改变其位的位置。
这样可以提高后续处理的随机性和复杂性。
扩展置换(E)是DES算法的第二步,将32位的数据块扩展成48位,并重新排列其位的位置。
这样可以增加密钥和数据的混淆度。
与子密钥异或(XOR)是DES算法的第三步,将扩展后的数据块与生成的子密钥进行异或操作。
这样可以将密钥的信息混合到数据中。
S盒置换是DES算法的核心部分,利用8个不同的4x16位置换表(S 盒)进行16次S盒置换。
S盒将6位输入映射为4位输出,通过混淆和代替的方式增加了加密的随机性。
P置换是DES算法的最后一步,在经过S盒置换后,对输出的32位数据块进行一次最终的置换。
这样可以使得密文在传输过程中更难以破解。
DES算法的解密过程与加密过程相似,只是在16轮中使用的子密钥的顺序是相反的。
解密过程中同样包括初始置换、扩展置换、与子密钥异或、S盒置换、P置换等步骤,最后经过逆初始置换得到明文。
虽然DES算法曾经是数据安全领域的标准算法,但是随着计算机计算能力的提高,DES算法的密钥长度过短(56位)容易被暴力破解,安全性逐渐变弱。
因此,在2001年,DES被高级加密标准(AES)取代,并成为新的数据加密标准。
总结来说,DES加密算法采用对称密钥体制,使用相同的密钥进行加密和解密。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
DES加密算法详解- -对加密解密一直挺喜欢的,可还是没有怎么好好学习过,希望这是一个好的开始。
在网上搜了一下关于DES的说明,发现有些杂乱,所以还是有必要整合一下。
写了一点代码,还没有完成,不过,还不能编译通过,^_^刚看了一下,发现还是说得够模糊的,有机会再整理一下。
昏倒,一直运行不对,今天才仔细查出来,原来问题是出在Des_Data_P(const _b32& input, _b32 output),我的output用了传值调用,失败呀。
应该是Des_Data_P(const _b32& input, _b32 & output)DES算法的入口参数有三个:Key, Data, ModeKey 为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位,...... 以此类推。
变换后得到56b it数据,将它分成两部分,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, 1 6, 7, 27, 20, 13, 2,41, 52, 31, 37, 47, 55, 30, 40, 51, 45, 33, 48, 44, 49, 39, 56, 34, 53, 4 6, 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]的顺序颠倒过来就行了。
对应于第1-3的key生成过程:/wikipedia/en/thumb/ 3/3f/220px-DES-key-schedule.png-DES-main-network.png1/1b/270px-DES-f-function.png代码:/* filename: gy_des.cpp*//** Some of codes are copyed from des.lib which is written by Eri cYoung(*************.au)* 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, 2 8, 31, 31,32, 32, 35, 35, 37, 37, 38, 38, 41, 41, 42, 42, 44, 4 4, 47, 47,49, 49, 50, 50, 52, 52, 55, 55, 56, 56, 59, 59, 61, 6 1, 62, 62,64, 64, 67, 67, 69, 69, 70, 70, 73, 73, 74, 74, 76, 7 6, 79, 79,81, 81, 82, 82, 84, 84, 87, 87, 88, 88, 91, 91, 93, 9 3, 94, 94,97, 97, 98, 98,100,100,103,103,104,104,107,107,109,10 9,110,110,112,112,115,115,117,117,118,118,121,121,122,122,124,1 24,127,127,128,128,131,131,133,133,134,134,137,137,138,138,140,1 40,143,143,145,145,146,146,148,148,151,151,152,152,155,155,157,1 57,158,158,161,161,162,162,164,164,167,167,168,168,171,171,173,1 73,174,174,176,176,179,179,181,181,182,182,185,185,186,186,188,1 88,191,191,193,193,194,194,196,196,199,199,200,200,203,203,205,2 05,206,206,208,208,211,211,213,213,214,214,217,217,218,218,220,2 20,223,223,224,224,227,227,229,229,230,230,233,233,234,234,236,2 36,239,239,241,241,242,242,244,244,247,247,248,248,251,251,253,2 53,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, 1 0, 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},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, 1 1, 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, 1 0, 6, 1},{13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 1 5, 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, 1 4, 9, 2},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, con st 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, sizeo f(keyperm_table56)/sizeof(int));}void Des_Key_CompPerm(const _b56& input, _b48& output){Des_Permutation(input, output, keycompperm_table, siz eof(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, siz eof(dataexpperm_table)/sizeof(int));}void Des_Data_IP(const _b64& input, _b64& output){Des_Permutation(input, output, datainitperm_table, si zeof(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, sizeo f(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(d atafp_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 &o utput){_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. $$$$$$$$$$$$$$$$$$$$$$$" << endl;}else {cout << "Error. **************************" << endl;}return 0;}int Des_decode(const string& key, const string& data, _b64 &o utput){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);}}}。