详解DES-CBC加密算法

合集下载

des加密算法流程

des加密算法流程

des加密算法流程DES加密算法流程DES(Data Encryption Standard)是一种对称加密算法,是美国联邦政府采用的加密标准,也是目前应用最广泛的加密算法之一。

DES加密算法流程包括密钥生成、初始置换、16轮迭代、逆置换和输出。

下面将详细介绍DES加密算法的流程。

一、密钥生成DES加密算法使用56位的密钥,但是由于每个字节的最高位都是奇偶校验位,因此实际上只有48位是有效的。

密钥生成的过程如下:1. 将56位密钥分成左右两个28位的部分,分别称为C0和D0。

2. 对C0和D0进行16次循环左移,得到C1~C16和D1~D16。

3. 将C16和D16合并成一个56位的密钥K。

4. 对K进行PC-2置换,得到48位的子密钥K1~K16。

二、初始置换明文经过初始置换IP后,变成了一个64位的二进制数。

初始置换的过程如下:1. 将明文分成左右两个32位的部分,分别称为L0和R0。

2. 对L0和R0进行初始置换IP,得到一个64位的二进制数。

三、16轮迭代DES加密算法共进行16轮迭代,每轮迭代包括扩展置换、S盒代替、P盒置换和异或运算四个步骤。

具体过程如下:1. 将Ri-1进行扩展置换,得到48位的扩展结果E(Ri-1)。

2. 将E(Ri-1)和Ki进行异或运算,得到48位的结果。

3. 将异或运算的结果分成8个6位的部分,分别称为B1~B8。

4. 对B1~B8分别进行S盒代替,得到8个4位的结果。

5. 将8个4位的结果合并成一个32位的结果。

6. 对32位的结果进行P盒置换,得到32位的结果。

7. 将P盒置换的结果和Li-1进行异或运算,得到Ri。

8. 将Ri和Li-1合并成一个64位的结果,作为下一轮迭代的输入。

四、逆置换经过16轮迭代后,得到的结果分成左右两个32位的部分,分别称为L16和R16。

将L16和R16交换位置,得到R16L16。

对R16L16进行逆置换IP-1,得到加密后的结果。

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算法及其工作模式分析褚慧丽中南财经政法大学信息管理与信息系统专业2009级[摘要] 现代密码学的发展经过了一个漫长而复杂的过程,在这过程中出现了一系列经典而高效的加密体制。

DES作为分组密码的典型代表,对密码学的发展做出了重要的贡献。

本文主要介绍了DES的概况,并对它的算法进行描述,找出它的设计思想和特点,分析它的安全性。

在此基础上,进一步介绍了DES的工作模式。

[关键词] 分组密码信息安全 DES 演化密码对称密码1.概况1.1DES简介DES算法是由IBM公司在20世纪70年代发展起来的,于1976年11月被美国政府采用,随后被美国国家标准局和美国国家标准协会承认,同时也成为全球范围内事实上的工业标准。

DES算法作为分组密码的代表,已成为金融界及其他各种行业广泛应用的对称密钥密码系统。

它以feistel网络结构理论为基础,采用迭代分组形式,在提高算法的运行速度,改善了密码的实用性的同时,也大大的提高了密码的安全性,对于我们研究密码学以及展望密码学的发展方向有重要意义。

1.2算法描述DES使用56位密钥对64位的数据块进行加密,并对64位的数据块进行16轮编码。

在每轮编码中,一个48位的密钥值由56位的“种子”密钥得出来。

DES算法把64位的明文输入快变成64位的密文输出块,整个算法的变换过程如图1.1所示。

图1.1 DES算法框图图中描述的是DES的加密过程。

而解密和加密过程大致相同,不同之处仅在于右边的16个子密钥的使用顺序不同,加密的子密钥的顺序为K1,K2,…,K16,而解密的子密钥的使用顺序则为K16,K15,…,K1。

IP即初始换位的功能是把输入的64位明文数据块按位重新组合,并把输出分为L0,R0两部分,每部分各长32位。

其置换规则如表1.1所示。

表1.1 DES算法初始换位规则表即将输入的64位数据的第58位换到第1位,第50位换到第2位......依此类推。

设置换前的输入值为D1D2...D64,则经过初始换位后的结果为:L0=D58D50...D8,R0=D57D49 (7)经过初始换位后,将R0与密钥发生器产生的密钥K1进行计算,其结果记为f(R0,K1)再与L0进行异或运算得到L0⊕f(R0,K1),把R0记为L1放在左边,把L0⊕f(R0,K1)记为R1放在右边,从而完成了第一次迭代运算。

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算法的详细分析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加密算法详解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加密算法采用对称密钥体制,使用相同的密钥进行加密和解密。

C语言实现CBC模式DES加密

C语言实现CBC模式DES加密

C语⾔实现CBC模式DES加密#define SECTION_SIZE 8 //每段密⽂字节数,DES为8个字节64位#define GET_BIT(x,y) (x |((BYTE)0xff <<9-y) | ((BYTE)0xff >>y)) //将X的第Y位保留,其余位置1#define FORM_DWORD(p1,p2,p3,p4) ((((DWORD)p1) <<24) | (((DWORD)p2) <<16) | (((DWORD)p3) <<8) | ((DWORD)p4)) //四个字节形成⼀个双字#define FORM_BYTE(x,y) ((BYTE)((x & ((DWORD)0xffffffff << 8*(4-y)) & ((DWORD)0xffffffff >> (y-1)*8)) >>(4-y)*8))//将双字X的第Y个字节提取出来#define GET_BIT_LOW(x,y) ((x & ( (BYTE)0xff<<(8-y)) & (BYTE)0xff >> (y-1)) >> (8-y)) //拿到字节X的第Y位//#define ENCRPT //如果定义则为加密,⽆定义为解密#define CHANGE //未⽤//------------------------------------------------------------------------------------------BYTE DisPlaceIPTable[] = { 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};BYTE DisPlaceRIPTable[] = { 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};BYTE DisPlaceKEYTable[] = { 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, };BYTE MoveCount[] = { 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1 };BYTE PC_2[] = { 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 };BYTE E_Table[] = { 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 };BYTE S1[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};BYTE S2[4][16] = { 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 };BYTE S3[4][16] = { 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 };BYTE S4[4][16] = { 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 };BYTE S5[4][16] = { 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 };BYTE S6[4][16] = { 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 };BYTE S7[4][16] = { 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 };BYTE S8[4][16] = { 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 };BYTE result[] = { 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 };//---------------------------------------------------------------------------------typedef struct _BIT{BYTE a : 1;BYTE b : 1;BYTE c : 1;BYTE d : 1;BYTE e : 1;BYTE f : 1;}BIT,*PBIT;typedef struct _8_BIT{BYTE a : 1;BYTE b : 1;BYTE c : 1;BYTE d : 1;BYTE e : 1;BYTE f : 1;BYTE g : 1;BYTE h : 1;}E_BIT,*P4_BIT;LPVOID getTable(int index);DWORD data_rl(DWORD x, BYTE y, BYTE z);PBYTE SHL_Connect(PBYTE p1, PBYTE p2, int index);void ExchangeDword(PVOID p1, PVOID p2);void DisPlaceItem(PVOID fileVa, PBYTE KEY, int length);// DESEncryption.cpp : Defines the entry point for the console application.//#include "stdafx.h"#include "windows.h"#include "myEncpy.h"int _tmain(int argc, _TCHAR* argv[]){//get plaintextHANDLE hFile = CreateFile(L"d:\\a.txt", GENERIC_ALL, FILE_SHARE_READ, 0, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL); if (hFile == INVALID_HANDLE_VALUE){printf_s("can not create file... d:a.txt");system("pause");return0;}HANDLE hFileMapping = CreateFileMapping(hFile, 0, PAGE_READWRITE, 0, 0, L"myshare");if (hFileMapping == INVALID_HANDLE_VALUE){printf_s("can not create filemapping");system("pause");return0;}LPVOID fileVa = MapViewOfFile(hFileMapping, FILE_MAP_ALL_ACCESS, 0, 0, 0);if (fileVa == NULL){printf_s("can not get mapview");system("pause");return0;}//printf_s("%s\n", fileVa);//使⽤内存映射打开⼤⽂件//---------------------------------------------------------------//get parameter,key,subkeyBYTE KEY[8] = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h' }; //定义密钥DisPlaceItem(KEY, DisPlaceKEYTable,7);PBYTE SubKey[16];BYTE C0[4] = { KEY[0], KEY[1], KEY[2], KEY[3]&0xf0 };BYTE D0[4] = { KEY[3] & 0x0f, KEY[4], KEY[5], KEY[6] };for (int i = 0; i < 16; i++){PBYTE p = SHL_Connect(C0, D0, i);DisPlaceItem(p, PC_2, 6);SubKey[i] = p; //⽣成16个⼦密钥}//-----------------// begain encrypBYTE CBC_IV[] = { 0x11, 0x32, 0x43, 0x54, 0x65, 0x76, 0x87, 0xa8 };//初始化向量未向PBYTE fileOffset =(PBYTE)fileVa; //明⽂起始位置DWORD fileSize = GetFileSize(hFile, 0); //得到明⽂⼤⼩for (DWORD index = 0; index < fileSize / SECTION_SIZE ; index ++) //⽬前只针对凑满8个字节的部分进⾏加密{fileOffset = fileOffset + index *SECTION_SIZE;//for (int i = 0; i < SECTION_SIZE; i++)//{// *(fileOffset + i) ^= CBC_IV[i];//}#ifdef CHANGEDisPlaceItem(fileOffset, DisPlaceIPTable, 8); //IP置换#endif#ifdef ENCRPTfor (int j =0; j <16; j++)#elsefor (int j = 15; j >= 0; j--){#endifBYTE L0[4], R0[6];memcpy(L0, fileOffset, 4);memcpy(R0, fileOffset + 4, 4); //分别拿到左边右边4个字节#ifdef ENCRPTif (j !=15)#elseif (j != 0)#endifmemcpy(fileOffset, R0, 4); //如果不是最后⼀次加密或者解密,则右边直接写回左边elsememcpy(fileOffset + 4, R0, 4);DisPlaceItem(R0, E_Table, 6); //扩展置换PBYTE pbyte1 = SubKey[j];for (int i = 0; i < 6; i++){R0[i] ^= pbyte1[i]; //与右边进⾏异或}//partion----------------------------------------BIT mybit[8] = {0};///////////////////////BYTE t[48]; //把6字节分为6位⼀组共8组int tIndex = 1;int rIdex = 0;for (int i = 0; i < 48; i++){BYTE a = R0[rIdex];t[i] = GET_BIT_LOW(R0[rIdex], tIndex);if (tIndex % 8 == 0){rIdex++;tIndex = 1;}else{tIndex++;}}tIndex = 0;for (int i = 0; i < 48; i+=6){mybit[tIndex].a = t[i];mybit[tIndex].b = t[i+1];mybit[tIndex].c = t[i+2];mybit[tIndex].d = t[i+3];mybit[tIndex].e = t[i+4];mybit[tIndex].f = t[i+5];tIndex++;}//此时mybit⾥⾯放着分组之后的每⼀位////////////////////////BYTE Str[4];int EIndex = 0;BYTE(*tempTable)[16] = 0;for (char i = 0; i < 8; i += 2) //根据mybit拿到表中的数并组合成str{tempTable = (BYTE(*)[16])getTable(i + 1);BYTE sum1 = tempTable[mybit[i].a*2 + mybit[i].f][mybit[i].b*8 + mybit[i].c*4 + mybit[i].d*2 + mybit[i].e];tempTable = (BYTE(*)[16])getTable(i + 2);BYTE sum2 = tempTable[mybit[i + 1].a*2 + mybit[i + 1].f][mybit[i + 1].b*8 + mybit[i + 1].c*4 + mybit[i + 1].d*2 + mybit[i + 1].e]; BYTE sum = sum1 << 4 | sum2;memcpy(Str + EIndex, &sum, 1);EIndex++;}#ifdef CHANGEDisPlaceItem(Str, result, 4); //结果与左边置换#endiffor (int i = 0; i < 4; i++){L0[i] ^= Str[i];}#ifdef ENCRPTif (j != 15)#elseif (j != 0) //将左边写到右边#endifmemcpy(fileOffset + 4, L0, 4);elsememcpy(fileOffset, L0, 4);}#ifdef CHANGEDisPlaceItem(fileOffset, DisPlaceRIPTable, 8);//IP逆置换#endif//memcpy(CBC_IV, fileOffset, 8);//-----------------------------------------------}printf_s("got it");for (int i = 0; i < 16; i++){free(SubKey[i]);}CloseHandle(hFile);CloseHandle(hFileMapping);UnmapViewOfFile(fileVa);system("pause");return0;}void DisPlaceItem(PVOID fileVa,PBYTE KEY,int length) //fileva为需要置换的内容⾸地址 key为置换表,length为输出字节数{PBYTE File = (PBYTE)fileVa;BYTE Result[8] ;memset(Result, 0xff, 8);int DisIndex = 1;for (int i = 0; i < length; i++){int bitofEach = 1;while (true){BYTE temp1 = KEY[DisIndex-1];BYTE ByteIndex = temp1 / 8;ByteIndex = temp1 % 8 == 0 ? ByteIndex -1 : ByteIndex;BYTE BitIndex = temp1- ByteIndex*8;BYTE temptemp = *(File + ByteIndex);if (bitofEach < BitIndex){temptemp = *(File + ByteIndex) << (BitIndex - bitofEach);}else if (bitofEach>BitIndex){temptemp = *(File + ByteIndex) >> (bitofEach - BitIndex);}BYTE t = GET_BIT(temptemp, bitofEach);Result[i] = Result[i] & GET_BIT(temptemp, bitofEach);if (DisIndex % 8 == 0)break;DisIndex++;bitofEach++;}DisIndex++;}memcpy(fileVa, Result, length);}PBYTE SHL_Connect(PBYTE p1, PBYTE p2, int index) //循环移位并连接{PBYTE pbyte = (PBYTE)malloc(7);DWORD d1 = FORM_DWORD(p1[0], p1[1], p1[2], p1[3]);DWORD d2 = FORM_DWORD(p2[0], p2[1], p2[2], p2[3]) <<4;d1 = data_rl(d1, MoveCount[index], 32);d2 = data_rl(d2, MoveCount[index], 32) >>4;for (int i = 0; i < 4; i++){*(p1 + i) = FORM_BYTE(d1, i + 1);*(p2 + i) = FORM_BYTE(d2, i + 1);}memcpy(pbyte, p1, 3);BYTE temp = p1[3] | p2[0];*(pbyte + 3) = temp;memcpy(pbyte + 4, p2, 3);return pbyte;}DWORD data_rl(DWORD x, BYTE y, BYTE z) //移位的实现{DWORD temp;temp = x >> (y - z );temp = temp << 4;x = x << z;x = x | temp;return x;}LPVOID getTable(int index) {switch (index){case1:return S1;break;case2:return S2;break;case3:return S3;break;case4:return S4;break;case5:return S5;break;case6:return S6;break;case7:return S7;break;case8:return S8;break;default:break;}}。

ECB与CBC算法

ECB与CBC算法

分组加密模式浅析2008-12-24 | 12:00分类:服务器技术, 桌面应用开发 |作者:pw | 标签:CBC、CFB、DES、ECB、OFB、加密 | 909 views互联网的软件设计一定少不了加密算法,并且大量使用的都会是对称加密,比较常见的对称加密有:DES、3DES、RC4、AES等等;加密算法都有几个共同的要点:1.密钥长度;(关系到密钥的强度)2.加密模式;(ecb、cbc等等)3.块加密算法里的填充方式区分;对于加密模式,很多同学还不清楚,比如DES,也会有ECB、CBC等不同的区分,它们都是标准的;Windows加密库中,默认则是CBC模式,也可以手工设置;Openssl库要更明显一点,它的函数名里面就写明了,比如:DES_ncbc_encrypt,一看就知道是cbc模式;JAVA里面也比较清楚:Cipher c =Cipher.getInstance(”DES/CBC/PKCS5Padding”); 也可以看到是CBC模式各种加密模式有什么不同呢:(为了方便,这里的加密key都取64位)电子密码本模式ECB:最古老,最简单的模式,将加密的数据分成若干组,每组的大小跟加密密钥长度相同;然后每组都用相同的密钥加密, 比如DES算法, 如果最后一个分组长度不够64位,要补齐64位;定义:Enc(X,Y)是加密函数Dec(X,Y)是解密函数Key是加密密钥;Pi ( i = 0,1…n)是明文块,大小为64bit;Ci ( i = 0,1…n)是密文块,大小为64bit;ECB加密算法可表示为:Ci = Enc(Key, Pi)ECB解密算法可以表示为:Pi = Dec(Key,Ci)算法特点:•每次Key、明文、密文的长度都必须是64位;•数据块重复排序不需要检测;•相同的明文块(使用相同的密钥)产生相同的密文块,容易遭受字典攻击;•一个错误仅仅会对一个密文块产生影响;加密块链模式CBC:与ECB模式最大的不同是加入了初始向量定义:Enc(X,Y)是加密函数Dec(X,Y)是解密函数Key是加密密钥;Pi ( i = 0,1…n)是明文块,大小为64bit;Ci ( i = 0,1…n)是密文块,大小为64bit;XOR(X,Y)是异或运算;IV是初始向量(一般为64位);ECB加密算法可表示为:C0 = Enc(Key, XOR(IV, P0)Ci = Enc(Key, XOR(Ci-1, Pi)ECB解密算法可以表示为:P0 = XOR(IV, Dec(Key, C0))Pi = XOR(Ci-1, Dec(Key,Ci))算法特点:•每次加密的密文长度为64位(8个字节);•当相同的明文使用相同的密钥和初始向量的时候CBC模式总是产生相同的密文;•密文块要依赖以前的操作结果,所以,密文块不能进行重新排列;•可以使用不同的初始化向量来避免相同的明文产生相同的密文,一定程度上抵抗字典攻击;•一个错误发生以后,当前和以后的密文都会被影响;加密反馈模式CFB:加密反馈模式克服了需要等待8个字节才能加密的缺点,它采用了分组密码作为流密码的密钥流生成器;定义:Enc(X,Y)是加密函数Dec(X,Y)是解密函数Key是加密密钥;Pi ( i = 0,1…n)是明文块,大小为64bit;Ci ( i = 0,1…n)是密文块,大小为64bit;Si ( i = 0,1…n),大小为8bit,n个连续的Si组成加密位移寄存器,一般n=8;Oi = Enc(Key, Si);Lef(x) 为取数据x的最左8个bit位;A(x,y)为合并x左移8位,空位用y填充CFB加密算法可表示为:S0 = IV;Oi = Enc(Key, Si);Ci = XOR( Ci, Lef(Oi));Si = A(Si-1, Ci);CFB解密算法可表示为:S0 = IV;Oi = Enc(Key, Si);Ci = XOR( Ci, Lef(Oi));Si = A(Si-1, Ci);图示:特点:•每次加密的Pi和Ci不大于64位;•加密算法和解密算法相同,不能适用于公钥算法;•使用相同的密钥和初始向量的时候,相同明文使用CFB模式加密输出相同的密文;•可以使用不同的初始化变量使相同的明文产生不同的密文,防止字典攻击;•加密强度依赖于密钥长度;•加密块长度过小时,会增加循环的数量,导致开销增加;•加密块长度应时8位的整数倍(即字节为单位);•一旦某位数据出错,会影响目前和其后8个块的数据;输出反馈模式OFB:与CFB模式不同之处在于, 加密位移寄存器与密文无关了,仅与加密key和加密算法有关;做法是不再把密文输入到加密移位寄存器,而是把输出的分组密文(Oi)输入到一位寄存器;定义:Enc(X,Y)是加密函数Dec(X,Y)是解密函数Key是加密密钥;Pi ( i = 0,1…n)是明文块,大小为64bit;Ci ( i = 0,1…n)是密文块,大小为64bit;Si ( i = 0,1…n),大小为8bit,n个连续的Si组成加密位移寄存器,一般n=8;Oi = Enc(Key, Si);Lef(x) 为取数据x的最左8个bit位;A(x,y)为合并x左移8位,空位用y填充CFB加密算法可表示为:S0 = IV;Oi = Enc(Key, Si);Ci = XOR( Ci, Lef(Oi));Si = A(Si-1, Oi); 注意这里与CFB 模式的不同CFB解密算法可表示为:S0 = IV;Oi = Enc(Key, Si);Ci = XOR( Ci, Lef(Oi));Si = A(Si-1, Oi);特点:•与CFB类似,以下都是不同之处;•因为密文没有参与链操作,所以使得OFB模式更容易受到攻击;•不会进行错误传播,某位密文发生错误,只会影响该位对应的明文,而不会影响别的位;•不是自同步的,如果加密和解密两个操作失去同步,那么系统需要重新初始化;•每次重新同步时,应使用不同的初始向量。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

详解DES-CBC加密算法如果SA加密组件中数据加密算法的标识符等于0x01,那么将使用CBC模式的DES算法来加密与该SA相关联的业务数据。

使用DES-CBC(Data Encryption Standard-Cipher Block Chaining,密码分组链接模式下的数据加密标准)技术,可以对MACPDU的载荷域进行加密,但无法对通用MAC头(Generic MAC Header,GMH)和循环冗余校验(CRC)数据进行加密。

DES-CBC的加密过程如图7-4所示。

实现密码分组链接(CBC)模式需要一个初始化向量(Initialization Vector IV),该微量是通过将安全关联(Security Association,SA)中的初始化向量(1V)参数与物理层同步域内容进行异或(Exclusive OR,XOR)运算得到的。

CBCIV的计算方法是:在下行链路上,CBC的初始化是通过将TEK密钥信息中的IV参数与最新DL-MAP中的物理层同步域的内容进行异或运算来实现的;在上行链路上,CBC的初始化是通过将TEK密钥信息中的IV参数与DL-MAP中的物理层同步域的内容进行异或运算来实现的,这个DL—MAP在当前UL-MAP被创建或接收到时必须是有效的。

DES加密过程使用连接安全关联中的初始化向量(1V)和传输加密密钥(Traffic Encryption Key,TEK),来对PDU载荷进行加密。

然后,密文载荷代替原始明文载荷。

GMH中的EC(En- cryption Control,加密控制)位为1时,表示对载荷进行加密操作;加密密钥序列(Encryption Key Sequence,EKS)字段只有在EC字段设置成1时才有效,用于表示传输加密密钥和初始向量的序号将被用于载荷加密。

对于新的密文载荷,如果包含了CRC,则需要对其进行更新。

总体而言,DES-CBC加密方案具有较低的安全性,这一方面是由于DES算法本身的脆弱性造成的,另一方面是用于这种加密方法的数据封装没有完整性和抗重放保护机制。

CBC模式下的数据加密和解密编辑文档开发伙伴平台:S60 3rd Edition详细描述Cipher-block chaining(CBC)是一种加密方式,它将纯文本分块和之前加密的密文块进行XOR 操作。

这里每个密文块都取决于纯文本的这种处理。

注意要确保消息独立,并在第一个块中使用初始向量。

Symbian Cryptography library的CModeCBCEncryptor可以用来加密数据,它使用CBlockTransformation子类在它随后拥有的CAESEncryptor中进行初始化。

下列代码演示了对CBC模式下的数据块加密和解密的操作。

解决方案CBC模式下对数据的加密复制到剪贴板C/C++代码1. void CCBCExAppUi::CBCEncryption(TPtr8& aDataPtr) { CAESEncryptor* ae sEncryptor = CAESEncryptor::NewL(iCipherkey); CModeCBCEncryptor* cbcEncryptor = CModeCBCEncryptor::NewLC(aesEncryptor, iIV);<br> for(TInt i = 0; i<3; i++) { TPtr8 tempDataptr = aDataPtr.MidTPtr(16*i,16); cbcEncryptor->Transform(tempDataptr); cbcEncryptor->SetIV(tempDataptr); }<br> CleanupStack::PopAndDestroy(); }CBC模式下对数据的解密:复制到剪贴板C/C++代码1. void CCBCExAppUi::CBCDecryption(TPtr8& aDataPtr) { CAESDecryptor* aes decryptor = CAESDecryptor::NewL(iCipherkey); CModeCBCDecryptor* cbcDecryptor = CModeCBCDecryptor::NewLC(aesdecryptor, iIV);<br> TBuf8<16>tempBuf; for(TInt i = 0; i<3; i++) { TPtr8 tempDataptr = aDataPtr.MidTPtr(16*i,16); tempBuf.Copy(tempDataptr); cbcDecryptor->Transform(tempDataptr); cbcDecryptor->SetIV(tempBuf); }<br> CleanupStack::PopAndDestroy(); }2. //////////////////////////////////////////////This modules is the main()//author:Jing Jiandu//2002-11-25//notes: the block length is 16 bytes////////////////////////////////////////////#include "stdafx.h"#include "windows.h"#include "CAes.h"#include <stdio.h>#pragma comment(lib,"CAes.lib")3. BOOL isEndOfFile(FILE *fp);4. void main(int argc, char* argv[]){CCAes CaesObj(128);int blockLen=CaesObj.BlockByteLen;int keyLen=CaesObj.KeyByteLen;BYTE iv[4][4]={0,1,0,0, //CBC模式的初始向量,长度是加密块长,可以任意设定0,0,2,0,0,0,0,6,0,0,0,0};LPBYTE state=new BYTE[blockLen];LPBYTE midState=newBYTE[blockLen];LPBYTE temp;LPBYTE p_iv=*iv;BYTE w1[16]={"AES-CRYPTION"}; char userKey[100]; int count; int i; FILE *fpr,*fpw; char filename1[20],filename2[20],c; printf("You want to encrypt or decrypt a file?[e/d]"); scanf("%c",&c); 5. if (c=='e'||c=='E') //加密文件过程{ printf(">-----------------------------------------------\nPlease input filename you want to encrypt:\n"); scanf("%s",filename1); if ((fpr=fopen(filename1,"rb"))==NULL) { printf("Sorry! Cannot open this file\n");return; } if ((fpw=fopen(strcat(filename1,".aes"),"wb+"))==NULL) { printf("Cannot open this file\n"); return; } printf("Please input your key no more than %d chars!\n",keyLen); scanf("%s",userKey); CaesObj.keyexpansion(userKey); printf("Encryption is going on, please waiting........\n"); 6. fwrite(w1,1,16,fpw); i=-1; while(1) { ++i%=3; if((count=fread(state,1,blockLen,fpr))<blockLen){ memset(state+count,'\0',blockLen-count); } 7. if(i==0) CaesObj.blockxor(state,p_iv,blockLen); else CaesObj.blockxor(state,midState,blockLen); CaesObj.rijndael(state); memcpy(midState,state,blockLen); fwrite(state,1,blockLen,fpw); 8. if(feof(fpr)) { fseek(fpw,15,0); fputc((BYTE)count,fpw); break; } } 9. fclose(fpr); fclose(fpw); printf("Encryption is over,press anykey to return.\n"); }//加密文件结束else if(c=='d'||c=='D') //解密文件过程{ printf("Please input filename you want to decrypt:\n"); scanf("%s",filename1); printf("Please input filename after decryption:\n"); scanf("%s",filename2);if ((fpr=fopen(filename1,"rb"))==NULL) { printf("Cannot open this file\n"); return; } if ((fpw=fopen(filename2,"wb+"))==NULL) { printf("Cannot open this file\n"); return; } printf("Please input your key no more than %d chars!\n",keyLen); scanf("%s",userKey); CaesObj.keyexpansion(userKey); fread(w1,1,15,fpr); BYTE co; fread(&co,sizeof(BYTE),1,fpr); temp=new BYTE[blockLen]; 10. i=-1; 11. while(1) { ++i%=3; fread(state,1,blockLen,fpr); memcpy(midState,temp,blockLen); memcpy(temp,state,blockLen); CaesObj.invrijndael(state); if(i==0) CaesObj.blockxor(state,p_iv,blockLen); else CaesObj.blockxor(state,midState,blockLen); 12. if(isEndOfFile(fpr)) { fwrite(state,1,co,fpw); break; 13. } else { fwrite(state,1,blockLen,fpw); } } delete []temp; fclose(fpr); fclose(fpw); }//解密文件结束14.delete []state; delete []midState; } //the end of main() 15.BOOL isEndOfFile(FILE *fp) { BOOL res; 16.fgetc(fp); res=feof(fp); fseek(fp,-1,1);17.return res; }。

相关文档
最新文档