DES加密算法详解
- 格式:doc
- 大小:94.50 KB
- 文档页数:25
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(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算法为密码体制中的对称密码体制,又被成为美国数据加密标准,是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加密算法简介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(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加密算法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(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(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加密算法采用对称密钥体制,使用相同的密钥进行加密和解密。
RSA和DES加密算法详解RSA加密算法:RSA是一种非对称加密算法,它的安全性基于大数的因数分解难题。
RSA算法的原理如下:1.选择两个不同的质数p和q,并计算它们的乘积n=p*q。
n被称为RSA算法的模数。
2.计算n的欧拉函数φ(n)=(p-1)*(q-1)。
3.选择一个整数e,使得1<e<φ(n),且e和φ(n)互质。
e被称为RSA算法的公钥指数。
4. 计算整数d,使得d*e ≡ 1 (mod φ(n))。
d被称为RSA算法的私钥指数。
5.公钥为(n,e),私钥为(n,d)。
6. 加密消息m时,将m的整数表示x,计算密文c ≡ x^e (mod n)。
7. 解密密文c时,计算明文m ≡ c^d (mod n)。
RSA算法的优点是加密速度较快,且在典型情况下很难被破解。
其主要应用领域包括数据传输中的身份认证、数字签名、数字证书等。
DES加密算法:DES(Data Encryption Standard)是一种对称加密算法,它采用64位的分组长度和56位的密钥长度。
DES算法的原理如下:1.初始置换(IP):将输入的64位明文分为左右两个32位部分。
2.迭代运算:通过16次的迭代运算,先对右半部分进行扩展和异或运算,然后经过S盒置换和P盒置换,最后与左半部分进行异或运算。
3.逆初始置换(IP-1):将得到的64位结果进行逆初始置换得到密文。
4.这里的迭代运算中,用到了轮密钥生成算法。
DES算法的密钥扩展过程中,通过对56位密钥进行位移、选择和置换操作生成各轮所使用的子密钥。
DES算法的缺点是安全性较低,主要是由于其算法密钥长度较短,易受到穷举攻击。
因此在实际应用中,通常采用3DES算法,即对DES算法进行三次加密。
1.对称加密算法DES的加密速度较快,而非对称加密算法RSA的加密速度较慢。
这是因为RSA算法涉及大数的运算,而DES算法仅涉及位运算。
2.DES算法的密钥长度较短,容易受到穷举攻击,安全性较低。
DES算法详解简介 DES(Data Encryption Standard)数据加密标准。
DES是有IBM公司研制的⼀种对称加密算法,美国国家标准局于1977年公布把它作为⾮机要部门使⽤的数据加密标准。
DES是⼀个分组加密算法,就是将明⽂分组进⾏加密,每次按顺序取明⽂⼀部分,⼀个典型的DES以64位为分组,加密解密⽤算法相同。
它的密钥长度为56位,因为每组第8位是⽤来做奇偶校验,密钥可以是任意56位的数,保密性依赖于密钥。
概念 1、密钥:8个字节共64位的⼯作密钥(决定保密性能) 2、明⽂:8个字节共64位的需要被加密的数据 3、密⽂:8个字节共64位的需要被解密的数据加解密过程加密 1、明⽂数据分组,64位⼀组。
2、对每组数据进⾏初始置换。
即将输⼊的64位明⽂的第1位置换到第40位,第2位置换到第8位,第3位置换到第48位。
以此类推,最后⼀位是原来的第7位。
置换规则是规定的。
L0(Left)是置换后的数据的前32位,R0(Right)是置换后的数据的后32位; 具体置换规则有四步: 第⼀步:将明⽂数据转换为16*4的⼆维数组,形成⼀个数据空间。
第⼆步:数据左右对分,变成两个16*2的⼆维数组,然后每个数组各⾃都需要这样操作:从下往上,每两⾏形成⼀⾏数据。
分别得到两个8*4的⼆维数组。
第三步:新建⼀个16*4的⼆维数组(strNew1[16][4]),数组上半部分空间的数据存储左边数据块置换的结果,下半部分存储右边数据库置换的结果。
最后⼀步:把整个(strNew1[16][4])16*4的⼆维数组数据空间的按列进⾏置换到新的⼆维数组(strNew2[16][4]): 数组strNew1第2列放到数组strNew2第1列的位置; 数组strNew1第4列放到数组strNew2第2列的位置; 数组strNew1第1列放到数组strNew2第3列的位置; 数组strNew1第3列放到数组strNew2第4列的位置; 数组strNew2就是我们初始置换的结果。
加密算法之DES算法DES算法(Data Encryption Standard,数据加密标准)是一种对称加密算法,由IBM公司于1970年代开发,1977年被美国国家标准局(NIST)采纳为联邦信息处理标准(FIPS),并作为加密通信的标准算法使用。
DES算法采用分组密码(Block Cipher)的形式,将明文数据分成64位的数据块进行加密和解密操作。
DES算法的核心是Feistel结构,该结构由两个相同的数据块进行操作,每一轮加密过程包括分组加密、轮密钥生成和异或运算三个步骤。
下面将详细介绍DES算法的加密过程。
1.密钥生成:DES算法使用56位的密钥进行加密,其中有8位用于奇偶校验,因此实际有效密钥长度为48位。
首先,将56位密钥进行置换和分割,得到两个28位的子密钥,分别为左子密钥和右子密钥。
接着,根据子密钥生成算法对左右子密钥进行16轮循环左移操作,每轮循环左移的位数由一个预定义的位移表决定,最终得到16个48位的轮密钥。
2.分组加密:将64位明文数据分成左右两个32位的数据块,分别为左数据块L0和右数据块R0。
接下来,采用16轮的迭代过程,每轮过程包括以下四个步骤:-迭代函数扩展:将32位的右数据块扩展为48位,通过一个预定义的扩展换位表进行操作,得到扩展后的数据块。
-轮密钥混合:将扩展后的数据块和对应的轮密钥进行异或运算,得到48位的中间结果。
-S盒代替:将中间结果进行分组,每个6位作为一个输入,通过一系列预定义的S盒进行替代操作,得到32位的输出。
-P盒置换:对S盒代替的输出进行置换操作,通过一个预定义的置换表得到32位的最终结果。
在每轮迭代过程中,将左右数据块交换位置,即Li=Ri-1,Ri=Li-1⊕F(Ri-1,Ki),其中F表示迭代函数,Ki表示对应的轮密钥。
3.逆置换:经过16轮迭代后,得到的最终结果为L16和R16,将其交换位置,即L16为右数据块,R16为左数据块。
des加密算法例题详解DES加密算法例题详解什么是DES加密算法?DES(Data Encryption Standard)是一种对称加密算法,由美国联邦政府于1977年确定为非机密政府通信的标准。
DES是一种块密码,以64位为块长度,使用56位的密钥对数据进行加密和解密。
DES加密算法的流程1.首先,将输入数据分组为64位的块。
2.然后,根据规定的密钥生成16个48位的子密钥。
3.接下来,使用生成的子密钥对数据进行16轮的加密和解密操作。
4.最后,将加密或解密后的数据进行合并,得到最终的结果。
DES加密算法的例题下面通过一个例题来详细解释DES加密算法的过程。
假设输入数据为:“Hello World!”,密钥为:“SecretKey”。
1. 数据分组将输入数据“Hello World!” 分组为 64 位块:•第一个块:“Hello Wo”)•第二个块:“rld!”)2. 生成子密钥根据密钥“SecretKey”,使用DES算法生成 16 个 48 位的子密钥。
3. 加密操作对每个数据块进行 16 轮的加密操作。
•第一轮加密:–输入数据块:““(”Hello Wo”)–扩展置换(E-Box):–密钥:“SubKey1”–异或运算:–S 盒代替:–P 盒置换:–交换左右:–加密结果:“11”•第二轮加密:–输入数据块:““(”rld!“)–扩展置换(E-Box):–密钥:“SubKey2”–异或运算:–S 盒代替:–P 盒置换:–交换左右:–加密结果:“10”…4. 合并结果将加密后的数据块进行合并,得到最终的加密结果。
•加密结果:“”总结DES加密算法是一种经典的对称加密算法,通过对输入数据进行分组、生成子密钥、多轮加密操作和结果合并,实现数据的加密和解密。
它在信息安全领域有着广泛的应用,但由于密钥长度较短,已被认为不够安全。
DES加密算法的安全性问题尽管DES加密算法在过去是被广泛采用的标准算法,但是它的密钥长度较短,只有56位,容易受到穷举攻击。
DES加密算法的原理DES加密算法(Data Encryption Standard)是一种对称密钥加密算法,由IBM研发,并在1977年被美国国家标准局(NIST)作为联邦标准。
DES加密算法使用固定长度的密钥对数据进行加密和解密,其原理主要包括初始置换(IP)、Feistel结构、S盒代替置换、轮密钥生成和最终置换(FP)。
下面将详细介绍这些原理。
1.初始置换(IP):DES算法对输入数据进行分块加密,每个分块长度为64位(8字节)。
首先,对输入数据进行一个初始的置换,将其置换为一个新的64位的数据块,这个置换是固定的,并不依赖于密钥。
2. Feistel结构:DES算法采用了Feistel结构,将输入数据块分为左半部分L和右半部分R。
接下来的加密过程主要涉及一系列迭代运算,每次迭代都对L和R进行处理。
3.S盒代替置换:每次迭代开始时,右半部分R会被扩展为48位,接着与密钥进行异或运算。
然后,将得到的结果分成8个6位的分组,并将每个分组作为输入,经过S盒代替置换得到一个4位的输出。
S盒是一种置换表,用于将输入的6位映射为4位输出,它通过混淆和扩散的方式增强了加密的安全性。
4.轮密钥生成:DES算法中使用的密钥长度为56位,但每轮加密需要48位的子密钥。
因此,DES算法的关键步骤之一是生成16轮的子密钥。
密钥经过初始置换之后,通过将前28位和后28位进行循环左移,得到每轮的子密钥。
5.最终置换(FP):经过16轮迭代之后,得到的左半部分L和右半部分R被交换,并重新组合为一个64位的数据块,这个过程称为最终置换。
最后,进行一次逆置换,将数据块还原为加密前的格式。
DES加密算法的安全性取决于密钥的长度和初始密钥的选取,因为DES密钥长度较短,容易受到暴力破解攻击。
为了增强DES算法的安全性,通常使用多重加密模式,如3DES算法,对同一个数据块进行多次DES加密。
虽然DES加密算法在过去是一种广泛使用的加密方法,但由于发展的计算能力和安全需求的提高,如今已被更强大的加密算法所取代。
简要说明des加密算法的关键步骤Des加密算法是一种广泛应用于数据加密领域的对称加密算法。
它的设计主要基于置换和代换操作,通过多轮的迭代运算,将明文转换为密文。
本文将简要说明Des加密算法的关键步骤,包括初始置换、轮函数、Feistel结构和逆置换。
一、初始置换Des加密算法的第一步是初始置换。
这一步骤通过将输入的64位明文按照特定的规则进行位重排,得到一个新的64位数据块。
初始置换的目的是增加密文的随机性,使得加密后的结果更难被破解。
二、轮函数Des算法的核心是轮函数。
在每一轮加密中,轮函数接受32位的数据作为输入,经过一系列的操作后,输出32位的数据。
轮函数的操作包括扩展置换、密钥混合和代换操作。
1. 扩展置换扩展置换是轮函数的第一步。
它将输入的32位数据扩展为48位,并将数据的不同位置进行混合。
扩展置换的目的是引入更多的数据位,增加密文的复杂性。
2. 密钥混合Des算法使用的是56位的密钥,而扩展置换后的数据长度为48位。
密钥混合的目的是将56位的密钥转换为48位,并与扩展置换后的数据进行异或操作,产生新的48位数据。
3. 代换操作代换操作是轮函数的最后一步。
它将48位的数据分为8个6位的块,并通过查找代换表进行替换。
代换操作的目的是将输入的48位数据转换为32位的数据,以增加加密的强度。
三、Feistel结构Des加密算法采用了Feistel结构,它将明文分为两个相等的部分,并进行多轮的加密操作。
每一轮加密中,Feistel结构通过轮函数对其中一个部分进行加密,并将加密结果与另一个部分进行异或操作。
经过多轮的迭代运算后,最终得到加密后的密文。
四、逆置换Des加密算法的最后一步是逆置换。
逆置换是初始置换的逆操作,它通过将加密后的64位密文按照特定的规则进行位重排,恢复为原始的64位数据块。
总结:Des加密算法的关键步骤包括初始置换、轮函数、Feistel结构和逆置换。
初始置换通过位重排增加密文的随机性,轮函数通过扩展置换、密钥混合和代换操作对数据进行变换,Feistel结构通过多轮的加密操作将明文转换为密文,逆置换是初始置换的逆操作。
des加密算法例题详解(一)DES加密算法例题详解什么是DES加密算法•DES加密算法是一种对称加密算法,全称为Data Encryption Standard(数据加密标准)。
•DES算法使用相同的密钥进行加密和解密操作,且加密和解密的过程是可逆的。
•DES算法是最早广泛应用的加密算法之一,已经被AES加密算法取代。
DES加密算法步骤1.密钥生成–由用户选择一个64位的密钥,DES算法将根据这个密钥生成16个子密钥用于加密。
2.数据分组–将明文数据按照每组64位进行分组,不足的部分需要进行填充。
3.初始置换–对每个分组的64位明文进行初始置换,改变其顺序以增加加密的混淆度。
4.16轮迭代–将初始置换后的明文分成左右两部分,左边32位和右边32位。
–通过16轮迭代运算,每轮都会对这两个部分进行置换、替换和异或等操作,产生不同的结果。
5.逆初始置换–经过16轮迭代后的结果进行最后一次逆初始置换。
6.密文输出–密文输出为逆初始置换的结果,即加密后的64位密文。
加密例题示例明文输入:0110密钥输入:详细示意图[](步骤解析1. 密钥生成•根据提供的密钥,生成16个子密钥用于加密操作。
2. 数据分组•将明文数据按照每组64位进行分组:3. 初始置换•对每个分组的64位明文进行初始置换:4. 16轮迭代•将初始置换后的明文分成左右两部分,左边32位(L0)和右边32位(R0):L0:R0:•对L0和R0进行16轮迭代操作,每轮都会对这两个部分进行置换、替换和异或等操作,产生不同的结果。
5. 逆初始置换•经过16轮迭代后的结果进行最后一次逆初始置换:6. 密文输出•密文输出为逆初始置换的结果,即加密后的64位密文:总结•DES加密算法通过密钥生成、数据分组、初始置换、16轮迭代、逆初始置换等步骤,将明文加密为密文。
•DES算法是一种可逆的对称加密算法,但由于其密钥长度较短,安全性不足,已经被AES加密算法取代。
DES算法详细介绍DES(Data Encryption Standard)即数据加密标准,是一种对称加密算法,于1977年成为美国联邦政府的标准加密算法。
DES算法主要用于保护计算机网络和数据的机密性。
DES算法使用一个称为“密钥”的64位的输入来对输入的64位数据进行加密或解密。
密钥在加密和解密过程中是相同的,这是DES的对称性质。
DES算法工作在分组密码模式下,将64位输入数据分为两个32位的数据块,然后分别进行加密和解密操作,最后再将两个数据块合并。
简单来说,DES加密算法可以分为四个主要步骤:初始置换、加密轮函数、密钥生成和反置置换。
初始置换:首先,将64位的输入数据按照一个特定的排列顺序进行置换,将原始的数据乱序,生成一个新的64位数据。
这个置换的目的是使输入数据更难以被破解,增加了密码的强度。
加密轮函数:接下来,将初始置换得到的数据分割成两个32位的数据块,分别称为左半部分L0和右半部分R0。
然后,通过一系列的加密轮函数对L0和R0进行加密,每个加密轮函数输入32位的左半部分和48位的子密钥,输出32位的结果。
加密轮函数包括扩展置换、异或操作、S 盒代替和P盒置换。
扩展置换:将32位的数据R0按照一种特定的排列扩展成48位,使得每个数据位的重要度更加均衡。
异或操作:将扩展得到的48位数据与子密钥进行按位异或操作,增加密码的复杂度。
S盒代替:将得到的异或结果按照8个6位的分组进行代替操作,也就是将每个6位的分组通过8个不同的S盒进行代替,即将6位的输入映射成4位的输出。
P盒置换:将S盒代替后得到的32位数据做一次置换,打乱数据的顺序。
密钥生成:在加密轮函数中需要使用子密钥进行异或操作。
DES算法通过对64位的密钥进行置换和选择操作,生成16个48位的子密钥。
子密钥的生成是DES算法中一个关键的步骤,也是加密过程中最耗时的步骤之一反置置换:最后,将经过加密轮函数后的数据进行反置置换,得到最终的加密结果。
DES加密与解密过程原理解析DES(Data Encryption Standard)是一种对称加密算法,采用相同的秘钥进行加密和解密过程。
该算法由IBM的Horst Feistel设计,于1977年被美国联邦政府采用为标准。
DES算法的加密和解密过程如下:1.密钥生成:DES算法采用56位的密钥作为输入。
首先,将输入的密钥进行奇偶校验,然后每个位的第8、16、24、32、40、48、56位在末尾添加一个奇偶校验位,得到64位密钥。
2.初始置换(IP):明文输入64位数据块,首先进行初始置换操作。
初始置换将数据块中的每一位按照指定的位置进行重新排列。
3.分组操作:初始置换后的数据块分为左右两部分,每部分各为32位。
并对左右两部分进行16轮迭代操作。
4.迭代操作:在每一轮迭代中,将右半部分作为下一轮的左半部分,而右半部分经过两个操作:F函数和异或运算。
5.F函数:F函数接受两个输入,一部分是右半部分32位数据,另一部分是48位的子密钥。
首先,将右半部分进行扩展置换,将32位扩展为48位。
然后,将扩展后的数据与子密钥进行异或运算。
接下来,将结果分为8个6位的块,并将每一块作为S盒(代替盒)的输入。
S盒是8个不同的4x16的置换表,每个输入块选取相应的S盒进行替换,得到新的6位输出。
最后,将8个6位的输出组合成32位的输出。
6.子密钥生成:DES算法使用16个48位的子密钥,并且这些子密钥都是从64位的密钥中生成的。
首先,将64位的密钥进行PC-1置换,得到56位的数据。
然后,将密钥分为两部分,每部分28位,并且对每部分进行左移操作。
左移的位数根据不同的轮数确定,生成循环的子密钥。
最后,对每个循环生成的子密钥进行PC-2置换,得到48位的子密钥。
7.最终置换(IP-1)和输出:经过16轮迭代后,经过F函数和异或运算的结果将再次合并,并且进行最终置换。
最终置换是初始置换的逆置换,将合并的结果按照指定的位置进行重新排列。
DES算法详解 本⽂主要介绍了DES算法的步骤,包括IP置换、密钥置换、E扩展置换、S盒代替、P盒置换和末置换。
1.DES算法简介 DES算法为密码体制中的对称密码体制,⼜被称为美国数据加密标准。
DES是⼀个分组加密算法,典型的DES以64位为分组对数据加密,加密和解密⽤的是同⼀个算法。
密钥长64位,密钥事实上是56位参与DES运算(第8、16、24、32、40、48、56、64位是校验位,使得每个密钥都有奇数个1),分组后的明⽂组和56位的密钥按位替代或交换的⽅法形成密⽂组。
DES算法的主要流程如下图所⽰,本⽂按照流程依次介绍每个模块。
2.IP置换 IP置换⽬的是将输⼊的64位数据块按位重新组合,并把输出分为L0、R0两部分,每部分各长32位。
置换规则如下表所⽰:58504234261810260524436282012462544638302214664564840322416857494133251791595143352719113615345372921135635547393123157 表中的数字代表新数据中此位置的数据在原数据中的位置,即原数据块的第58位放到新数据的第1位,第50位放到第2位,……依此类推,第7位放到第64位。
置换后的数据分为L0和R0两部分,L0为新数据的左32位,R0为新数据的右32位。
要注意⼀点,位数是从左边开始数的,即最0x0000 0080 0000 0002最左边的位为1,最右边的位为64。
3.密钥置换 不考虑每个字节的第8位,DES的密钥由64位减⾄56位,每个字节的第8位作为奇偶校验位。
产⽣的56位密钥由下表⽣成(注意表中没有8,16,24,32,40,48,56和64这8位):57494133251791585042342618102595143352719113605244366355473931231576254463830221466153453729211352820124 在DES的每⼀轮中,从56位密钥产⽣出不同的48位⼦密钥,确定这些⼦密钥的⽅式如下: 1).将56位的密钥分成两部分,每部分28位。
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);}}}。