精华内容
下载资源
问答
  • DES算法S盒学习

    千次阅读 2020-08-20 04:25:07
    DES算法中替代由8个不同的S盒完成,每个S盒有6位输入4位输出。 一个S盒就是一个4行16列的表,盒中的每一项都是一个4位二进制数表示的十进制数。 输入的高低两位做为行数H,中间四位做为列数L,在S-BOX中查找...

    在密码学中,S盒(Substitution-box)是对称密钥算法执行置换计算的基本结构。
    S盒用在分组密码算法中,是唯一的非线性结构。

     

    S盒是将48比特压缩成32比特,S盒接受特定数量的输入48比特,经过8个盒将其转换为32比特输出。

    在DES算法中替代由8个不同的S盒完成,每个S盒有6位输入4位输出。

    一个S盒就是一个4行16列的表,盒中的每一项都是一个4位二进制数表示的十进制数。
    输入的高低两位做为行数H,中间四位做为列数L,在S-BOX中查找第H行L列对应的数据。
    S盒的行列计数都是从0开始。

    例如,S1盒如下;
    S1盒
    0    1    2    3    4    5    6    7    8    9    10    11    12    13    14    15
    0    14    4    13    1    2    15    11    8    3    10    6    12    5    9    0    7
    1    0    15    7    4    14    2    13    1    10    6    12    11    9    5    3    8
    2    4    1    14    8    13    6    2    11    15    12    9    7    3    10    5    0
    3    15    12    8    2    4    9    1    7    5    11    3    14    10    0    6    13


    以s8盒为例,输入110011,
    第一位和第六位(最高位和最低位)组合为11(二进制),转换为十进制为3,则在s8盒中行号为3;
    接下来计算列,原始数据第二位到第五位为1001(二进制),转换为十进制为9,则在s8盒中列号为9;
    s盒8的03行09列的数字为12,转换为二进制为1100,因此用二进制1100来代替110011;

     

    S盒代替是DES算法的关键步骤,所有的其他的运算都是线性的,易于分析,而S盒是非线性的,相比于其他步骤,提供了更好安全性。

    展开全文
  • DES密码算法 S盒P盒

    2012-03-21 14:46:30
    C语言自编DES加密算法S盒与P盒,原理简单明了,注释全面,需要的同学拿去吧!
  • 本文档是从维普上下下来的
  • 其最具代表意义的当然属于DES密码体制了。 1、DES的设计背景 ...2、DES加密算法 迭代型分组算法  分组长度/密钥长度:64bit有效密钥长度:56bit(8bit奇偶校验位)迭代圈数:16圈圈密钥长度:48.

    加密密钥等于脱密密钥,或者由一个可以轻易的计算出另一个的密码体制,称为单密钥密码体制,亦或称为对称密码体制或传统密码体制。其最具代表意义的当然属于DES密码体制了。

    1、DES的设计背景

    • 1973年5月 NBS(美国国家标准局)发布通告,征集一种加密算法
    • 1974年8月 收到了IBM公司提交的算法
    • 1976年11月 被推荐为联邦标准
    • 1977年1月 发布
    • 服役了20年

    2、DES加密算法

      /64bit56bit(8bit)1648bit(16(bit))\color{red}迭代型分组算法\\\;\\\color{brown}分组长度/密钥长度:\color{red}64bit\\ \color{brown}有效密钥长度:\color{red}56bit(8bit奇偶校验位)\\ \color{brown}迭代圈数:\color{red}16圈\\ \color{brown}圈密钥长度:\color{red}48bit(即16圈中每一圈所要用到的密钥位数(bit))

    形式化表达为:DES(M)=IP1T(16)T(15)...T(1)IP(m)DES(M)=IP^{-1}\circ T(16)\circ T(15)\circ...\circ T(1)\circ IP(m)(由后向前运算)
    IP是初始置换,IP-1是初始逆置换,T表示16组迭代圈函数。

    图形化表达:

    64bit
    64bit
    64bit
    64bit
    明文m
    初始置换<IP>
    圈1
    圈2
    圈3
    ....
    圈16
    初始逆置换
    密文c

    1516\color{gray}前15圈的算法结构相同,16圈中每一圈都有不同的密钥值

    在这里插入图片描述
    1521664bit232bitL0LeftR0Right由上图可知,前15圈模2加(亦或)后,左右进行了互换,而在第16圈则没有。\\ 初始置换后,将64bit数据等分为2份32bit 分别给予了L_0(Left) 和 R_0(Right)

    2.1  IPIP12.1\;初始置换IP与逆初始置换IP^{-1}

    若某一位经过初始置换又经过了逆初始置换,则其位置并没有发生改变。即,IP和IP-1互逆
    在这里插入图片描述
    如IP转换表中,第8位对应了数字2,即表示对应着第2位;
    而在IP-1转换表中,第二位对应了数字8,即表示对应着第8位;
    此时正好又将位置转换了回去。\color{gray}之前有提到过置换是一种古典密码 置换密码.
    所以在设计置换表时可以参照此原则。

    2.2  2.2\;圈函数

    前15圈

    在这里插入图片描述
    右上角的Li1L_{i-1}应该是Ri1R_{i-1}

    • 本一圈的右部Ri1R_{i-1} 直接作为下一圈的左部LiL_{i} 进行后续的运算
    • 本一圈的(左部Li1L_{i-1}) 要与(经过 ff函数Ri1R_{i-1} 和本圈密钥kik_{i} 所得到的结果,f(Ri1,ki)f(R_{i-1},k_{i}))进行模二加(亦或)运算之后作为下一圈的右部RiR_{i} 进行后续的运算

    ()=(Li,Ri)=(Ri,Li1f(Ri1,ki))  20+0=00+1=1+0=11+1=0f(Ri1,ki):kiRi1\:\\\color {red}表达式为:(左部,右部)=(L_{i},R_{i})=(R_{i},L_{i-1} \bigoplus f(R_{i-1},k_{i}))\\\;\\\color{blue}\bigoplus 模2加:0+0=0;0+1=1+0=1;1+1=0\\f(R_{i-1},k_{i}):表示在密钥k_i的影响下R_{i-1}的值。

    第16圈

    在这里插入图片描述
    ()=(L16,R16)=(L151f(k16,R151),R15)\color{red}(左部,右部)=(L_{16},R_{16})=(L_{15-1} \bigoplus f(k_{16},R_{15-1}),R_{15})
      \;
    同前15圈相比,其左右部,一定意义上讲,没有发生交换。

    • ki64bitki48bitDESf(Ri1,ki)f32bit32bitki232bit\color{gray}这里的k_i是由64bit密钥产生的子密钥,k_i是48bit。\\ {\color{red}DES的核心在于f(R_{i-1},k_{i})函数的功能。}f函数是将32bit的输入转化为32bit的输出。\\ 其中涉及到了扩展和压缩。扩展是为了能和k_i进行模2加,压缩是为了最后要输出32bit

    2.3f2.3\:f函数的构造

    f:  EEk2  S8  P\color{gray}f函数的内部构造:\\\color{blue}\;E盒扩展;\\E盒扩展后的值与圈密钥k进行模2加;(亦或运算)\\\;S盒转换;(分为8个部分)\\\;P盒变换;
    图形化表示:

    32bit
    48bit
    48bit
    6bit
    6bit
    6bit
    6bit
    6bit
    6bit
    6bit
    6bit
    4bit
    4bit
    4bit
    4bit
    4bit
    4bit
    4bit
    4bit
    R<32bit>
    E
    +
    圈密钥k
    S1
    S2
    S3
    S4
    S5
    S6
    S7
    S8
    P
    最后得到的32bit数据

    E\color{blue}E盒扩展:

    将32bit扩展到48bit,先将32bit的字符分为8组,每一组的前后,分别添加上一个字符和下一个字符:
    12345678910111213141516......29303132    32123454567898910111213121314151617............28293031321将 \begin{matrix} 1 & 2 & 3 & 4 \\ 5 & 6 & 7 & 8 \\ 9 & 10 &11 & 12 \\ 13 & 14 &15 & 16 \\ &...... \\ 29 & 30 &31 & 32 \\ \end{matrix} \implies \begin{matrix} {\color{red}32} & 1 & 2 & 3 & 4 & {\color{red}5}\\ {\color{red}4} & 5 & 6 & 7 & 8 & {\color{red}9} \\ {\color{red}8} & 9 & 10 &11 & 12 & {\color{red}13} \\ {\color{red}12} & 13 & 14 &15 & 16 & {\color{red}17} \\ {\color{red}...} & &...... & &&{\color{red}...}\\ {\color{red}28} & 29 & 30 &31 & 32 & {\color{red}1} \\ \end{matrix}
    1324532116bit如,\\\color{blue}在下标为1的字符前插入上一个字符。即,下标为32的字符;\\在下标为4的字符后插入下一个字符。即,下标为5的字符;\\在下标为32的字符后插入下一个字符。即,下标为1的字符;\\按照此规律扩展16bit。

    2\color{blue}模2加

    就令经过E盒扩展后的48个2进制位逐一与密钥的48bit进行亦或运算。

    S\color{blue}S盒代替

    将48bit转换为32bit

    S线DESfSS盒是唯一的非线性变换(非数学变换),其是DES中f函数的核心,S盒的好坏决定了该算法。

    S88(Si)4166bit4bit该S盒分为了8个子盒,对应着8张表(S_i),每个表是4行16列,每个子盒的输入为6bit,输出为4bit

    先将输入的48bit分为8组6bit的数据对应于8个子盒,
    Si6bitb1b2b3b4b5b6bb1b6nb2b3b4b5mnm2si假定输入S_i盒的6个bit为b_1b_2b_3b_4b_5b_6(这里每一个b都是一个二进制位)\\另b_1b_6为十进制的n,令b_2b_3b_4b_5为十进制的m,\\在设计的表中找出对应的n行m列对应的数字,并转换为2进制作为本s_i盒的输出\\{\color{red}下面有栗子:}
    在这里插入图片描述
    s16bit101101b1b6113b2b3b4b501106s1361000184bit32bit{\color{red}栗子:}如,向s_1盒中输入的6bit数为:101101\\b_1b_6为11,即十进制的3\\b_2b_3b_4b_5为0110,即十进制的6\\在s_1中,第3行6列对应着数字1\\所以最后的输出为0001\\{\color{gray}8组中每一个都会得到4bit的数据,最终会得到32bit的数据}
    SDESDES线\color{red}S盒作为DES的心脏,DES靠它实现非线性变换

    P:\color{blue}P盒转换:

    其本质是一种置换
      \; 在这里插入图片描述
    如原来的第1个bit被置换到第16个bit
    该表格满足分组扩散与混乱原则。

    3、密钥生成算法

    加密的基本流程已经介绍完毕,那么如何将64bit的初始密钥生成16组48bit的圈密钥(子密钥)供每一圈使用呢?

    图形化表达为:

    在这里插入图片描述
    PC116456\color{blue}{\color{red}PC-1}为,置换选择算法1(由64位筛选出56位);
    CD\color{blue}{\color{red}C和D}是两个寄存器;
    LS\color{blue}{\color{red}LS}为移位运算(循环左移)
    PC225848\color{blue}{\color{red}PC-2}为,置换选择算法2(由58位选出48位的圈密钥)

    1PC1\color{blue}置换选择1(PC-1)

    1. 抛去每个字节的最高位,即,第8,16,24,32,40,48,56,64位,只选择剩余的56位,被抛去的字节本来就是奇偶校验位。(用于验证完整性)
    2. 将剩余的比特数,按照一定的规则,进行相应的置换。
    3. 置换后,分别放在两个寄存器C和D中

    置换规则:
    在这里插入图片描述
    如,将原来的第57bit换到第1位。置换后的前28bit放在C寄存器中,其余的放在D寄存器中。

    LS28\color{blue}移位(LS)【两个28位密钥的寄存器循环左移】

    1291612{\color{red}规则:}\\第1,2,9,16圈左移1位;\\其余都左移2位。

    LS1LS2LS9LS161LSi2LS_1、LS_2、LS_9、LS_{16} 左移1位,其余LS_i左移2位

    1628\color{gray}最后16圈左移结束后,移位数正好等于28

    PC25648\color{blue}置换选择(PC-2)【由56位得到48位】

    在这里插入图片描述
    按照此规则进行置换,同时去除了8位

    在这里插入图片描述

    4、脱密算法

    DES的解密过程和DES加密完全类似,只不过将16圈的子密钥序列颠倒了一下,即,第一圈用k16k_{16} 最后一圈用k1k_{1}
    DES1=IP1T(1)T(2)...T(16)IP(c)形式化表达为:\\\color{red}DES^{-1}=IP^{-1}\circ T(1)\circ T(2)\circ...\circ T(16)\circ IP(c) (由后向前运算)

    所以脱密的算法就在于圈密钥如何进行计算的

    \color{blue}圈函数的分解:

    一般地,圈函数可以表达为:()=(x,y)=(y,xf(y,k))(左,右)=(x,y)=(y,x\bigoplus f(y,k)),第16圈显然不能用这个表示。
    可将其看作两部分,

    1. (x,y)(xf(y,k)y)(x,y)\to(x\bigoplus f(y,k),y),称为对合交换1。(Fesihel函数)
    2. (xf(y,k)y)(y,xf(y,k))(x\bigoplus f(y,k),y)\to(y,x\bigoplus f(y,k)),称为对合变换2。(左右块交换)【显然,第16圈并没有进行这一步骤】

    便316,1\color{gray}步骤一样,为了方便表示,我们将圈迭代看成3圈,最后一圈同第16圈一样,仅有对合变换1

    明文
    对合变换1
    对合变换2
    对合变换1
    对合变换2
    对合变换1
    密文
    密文
    对合变换1
    对合变换2
    对合变换1
    对合变换2
    对合变换1
    明文

    CMMC\color{gray}可知,将C解密为M的过程为M加密为C的逆过程

    316DES\color{blue}将此3圈扩展为16圈即为DES的脱密过程

    总结

    \color{red}最后附带一张手绘总结图
    在这里插入图片描述

    展开全文
  • DES算法设计

    2021-03-21 15:16:07
    文章目录一、DES算法介绍1、历史背景2、算法描述3、具体实现3.1、密钥处理3.2、明文加密过程3.2.1、IP置换3.2.2、16轮迭代运算3.2.2.1、E扩展置换函数表和与子密钥异或3.2.2.2、S盒变换3.2.2.3、P盒变换3.2.3、IP-1...

    DES算法设计与问题解决

    山东大学网络空间安全学院

    一、DES算法介绍

    1、历史背景

       数据加密标准DES( data encryption standard)是美国国家标准局(现美国国家标准和技术协会NST)为了满足计算机通信网络的发展对安全保密的要求,实现同一水平的安全性和兼容性,降低数据加密产品的生产成本,推广使用密码算法而公开征集的一种用于政府部门及民间进行计算机数据加密的密码算法。
      NBS最初于1973年5月13日向社会公开发起征集,IBM公司提出的一种称为Lucifer的加密算法,被选为数据加密标准。1977年1月15日DES被正式批准作为美国联邦信息处理标准,即FIP-46,同年7月15日生效。1994年1月NSA(美国国家保密局)对DS进行评估后,決定1998年12月以后将不再使用DES,同时征集新的加密标准AES。

    2、算法描述

       DES是一个16轮的Feistel型结构密码,它的分组长度为64比特,用一个56比特的密钥来加密一个64比特的明文串,输出一个64比特的密文串。其中,使用密钥为64比特,实用56比特,另8位用作奇偶校验。加密的过程是先对64位明文分组进行初始置换,然后分左、右两部分分别经过16轮迭代,然后再进行循环移位与变换,最后进行逆变换得出密文。加密与解密使用相同的密钥,因而它属于对称密码体制。

      图1-1给出了DES过程框图。假设输入的明文数据是64比特。首先经过初始置换IP后把其左半部分32比特记为L0,右半部分32比特记为R0,即成了置换后的输入;然后把R0与密钥产生器产生的子密钥k1进行运算,其结果计为f (R0,k1);再与L0进行摸2加得到L0 \bigoplusf (R0 , k1), 把R0记为L1放在左边,而把L0 \bigoplusf (R0 , k1)记为R1放在右边,从而完成了第一轮迭代运算。在此基础上,重复上述的迭代过程,一直迭代至第16轮。所得的第16轮迭代结果左右不交换,即L15 \bigoplusf (R15 , k16)记为R16,放在左边,而R15记为L16放在右边,成为预输出,最后经过初始置换的逆置换IP-1运算后得到密文。

    在这里插入图片描述

    1-1

    3、具体实现

    3.1、密钥处理

       DES算法共需进行16轮迭代运算,每轮迭代运算使用一个子密钥,共需要16个子密钥。
      首先输入的密码K为64位,但有8位是校验位(8,16,24,32,40,48,56,64),故实际的有效位为56位。
      其次根据PC_1置换表进行第一次的变换生成新的56位比特串,变换表如下所示代码:

    PC_1=[
        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
    ]
    

       然后再将新得到的比特串分为左右两部分(C1和D1),C1左移k1位,C2左移k2位,其余根据left表的值一次左移相应的位数,同理Di也依次进行相同的变换,得到Ci和Di两组值。

    left = [1, 1, 2, 2, 2, 2, 2, 
            2, 1, 2, 2, 2, 2, 2, 2, 1]
    

      最后将得到的Ci和Di拼接成CDi,然后再将CDi经过PC_2置换表置换得到F函数中使用的16个轮密钥Ki

    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
        ]
    

      密钥生成代码如下:

    ef Subkey(key):    #生成子密钥
        keyresult = []
        key0 = [0 for i in range(56)]
        for i in range(len(key_table1)):
        for i in range(MaxTime):
            key1 = [0 for i in range(48)]
            #确定每次左移的步数
            if (i == 0 or i == 1 or i == 8 or i == 15):
               step = 1
            else:
           key0[i] = key[key_table1[i]-1]
    
       #生成16个密钥
                step = 2
            #分成两组
            tmp1 = key0[0:28]
            tmp2 = key0[28:56]
             #循环左移
            tmp1 = Listmove(tmp1, step)
            tmp2 = Listmove(tmp2, step)
            #左右连接
            key0 = tmp1 + tmp2
           #置换选择
            for i in range(len(key_table2)):
                key1[i] = key0[key_table2[i]-1]
            #生成密钥
            keyresult.append(key1)
        #返回的是一个集合包含了每次的密钥
        return keyresult
    

      生成密钥结果:

    Ki = ['7833C320DA70', '2B1A74CA48D8', 
     '8C78D881D31D', '1667789316A0', 
     'CE5D01D80B25', '4BAB4D126A9C', 
     '09F48B713191', '710DEAA3202B', 
     '129AB83347C3', '9C38661E8103', 
     'A26E4CC66544', '48772468A3C8', 
     'C09D79F0D40B', 'C5E2634E162A',
     'A3DF829C7968', 'A6120B4D4C25']
    

    3.2、明文加密过程

    3.2.1、IP置换

      IP置换又称初始置换,在迭代运算之前,需要将输入的64位明文数据进行初始置换,将次序打乱。

    IP = [
            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
    ]
    

    3.2.2、16轮迭代运算

       在每一迭代中,每个64位的中结果被分成左右两部分,而且左右两部分作为相互独立的32位数据进行处理。每轮迭代的输入是上轮的结果Li-1和Ri-1
       Ri-1先由32位扩展到48位,扩展后的48位结果与48位的密钥位的Ki进行异或,得到的结果经过一个S盒替代产生32位的输出,然后再经过一个P盒置换再将得到的结果与Li-1进行简单异或,最后的输出结果作为Ri,而是不经过变换的Ri-1直接得到的。
       Li = Ri -1
       Ri = Li -1\bigoplusF(Ri-1,ki)
       下面将具体介绍迭代运算的各个部分。

    3.2.2.1、E扩展置换函数表和与子密钥异或

      扩展置换将前一轮迭代的结果Ri-1作为输入,根据扩展函数E将32位扩展到48位,扩展函数E将32位的明文每4位分成组,共有8组。每个分组由4位扩展为6位,扩展方法为:每个分组的4位作为6位输出分组的中间4位,6位输出分组中的第1位和第6位分别由相邻的两个4位小分组的最外面两位散进入到本分组产生,其中第1个小分组的左侧相邻分组位最后一个小分组。如E扩展置换表所示

    E = [	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,
         ]
    

      随机经过E盒扩展置换得到的48位输出与子密钥Ki-1进行异或运算。

    3.2.2.2、S盒变换

      S盒变换是将与子密钥异或得到的结果作为S盒变换的输入,经过变换得到32位的输出,DES加密函数中共有8个S盒每个S盒有4行16列。
      S盒变换的过程为:将与子密钥异或得到48位,每6比特一组,共分成8组,分别作为8个S盒的输入;每一个分组将对应于一个S盒进行变换运算:分组1由S盒1进行变换操作,分组2由盒2操作。。。。。。而且8个S盒所表示的变换运算各不相同。
      如果第i个盒的输入为:Bi=b1b2b3b4b5b6,则S盒变换得到4位输出的过程为:将b1b6和b2b3b4b5作为二进制数,令r=b1b6和c=b2b3b4b5,设第i个S盒中的第r行、c列对应的整数为N,则N的二进制表示就是该s盒在输入为Bi=b1b2b3b4b5b6时对应的4位输出。

    S=[
        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
    ]
    
    3.2.2.3、P盒变换

      P盒变换是将输出的32位比特串根据固定的置换p置换到相应的位置。P盒变换运算后得到的输出即为函数F(Ri-1,Ki)的最终结果。

    P=[
        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
    ]
    

    3.2.3、IP-1置换

      IP-1置换又称为逆初始置换,结果这一步骤的置换过程即为DES加密算法的密文输出。

    IP_1=[
            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
    ]
    

    3.2.4、DES代码以及测试运行时间

      IP置换与IP-1置换:

    def IP(text, op):   ##打乱顺序,op=0时为正,op=1时为逆
         tmp = [0 for i in range(64)]
         if op == 0:
             for i in range(64):
                 tmp[i] = text[IP_table[i]-1]
             return tmp
         if op == 1:
             for i in range(64):
                 tmp[i] = text[Inv_IP_table[i]-1]
             return tmp
    

      E扩展:

    def Extend(text):   ##将32位扩展成48位
         extend = [0 for i in range(48)]
         for i in range(48):
             extend[i] = text[extend_table[i] - 1]
         return extend
    

      异或运算:

    def XOR(bit1, bit2):    ##异或运算
         XORresult = [0 for i in range(len(bit1))]
         for i in range(len(bit1)):
             XORresult[i] = str(int(bit1[i]) ^ int(bit2[i]))
         return XORresult
    

      S盒变换:

    def S_replace(text):       ##根据表将48bit->32bit   S盒变换
         Sresult = [0 for k in range(32)]
         for k in range(8):
             row = 2*int(text[k*6]) + int(text[k*6+5])
             column = 8*int(text[k*6+1]) + 4*int(text[k*6+2]) + 2*int(text[k*6+3]) + int(text[k*6+4])
             tmp = S[k][row*16+column]
             for i in range(4):
                 Sresult[4*k + i] = int2bit(tmp)[i]
         return Sresult
    

      P盒变换:

    def P_replace(text):
         Presult = [0 for i in range(32)]
         for i in range(32):
             Presult[i] = text[P_table[i]-1]
         return Presult
    

      经过多次运行代码,得到平均运行速度为0.00606536865234375s,对比之下,加密效率较高。

    4、体会混乱、扩散的概念

    4.1、问题1:DES原轮函数

    在这里插入图片描述
      在原轮函数下,明文1bit的变化,在6轮加密之后,导致了密文将近32位的变化(这无疑是最好的可以隐藏改变的位数的我们所期待的数据),并且这些变化基本上都是均匀分布的,所以DES加密的扩散和混淆是很好的。
      注:为了更加清晰展示32为变化的来源,附加代码如下:

    def bchange(a):
        if(a==1):
            a=0
        else:
            a=1
        return a
    def randomchange(st): #随机更改
        b=bin(int(st,16))[2:]
        slist=list(b)
        le=len(slist)
        x=int(random.random()*le)
        slist[x]=bchange(slist[x])
        fst=" ".join('%s' %i for i in slist)
        fst = ''.join(fst.split())
        return fst
    def count(b1,b2):
        list1=list(b1)
        list2=list(b2)
        num=0
        l=min(len(list2),len(list1))
        for i in range(l):
          if(list1[i]!=list2[i]):
            num=num+1
        return (num)
    ptext=input('请输入明文:')
    x1=bin(int(DES(ptext),16))[2:]
    sumnum=0
    for i in range (10000):
        chtext=randomchange(ptext)
        ctext=bin(int(DES(chtext),16))[2:]
        sumnum=sumnum+count(x1,ctext)
    print(sumnum/10000)
    
    

    4.2、问题2:删除E扩散

    在这里插入图片描述

      在删除E扩散的情况下,明文1bit的变化,在6轮加密之后,导致了密文将近32位的变化,但是这些变化看上去像是均匀分布的,所以在删除E扩散的情况下,扩散效应保持的不错,混淆做的也不差,但是有了E扩散,虽然扩散和混淆的作用并没有显著的提高,但是这加强了我们加密过程的安全性。

    4.3、问题3:删除S-box

    在这里插入图片描述

      在删除S盒之后,明文1bit的变化,在6轮加密之后,导致了密文很少位数的变化,很明显,在删除了S盒之后,DES加密的扩散功能受到了很大的削弱,由于变化的位数过少,我们也不能很容易地判断混淆的作用是否有所影响。换而言之,S盒在DES加密中,对于扩散有着必不可少的作用。

    4.4、问题4:删除P置换

    在这里插入图片描述
      在删除P置换之后,明文1bit的变化,在6轮加密之后,导致了密文将近32位的变化,但是我们通过图可以发现变化的密文位数集中在了明文改变的位数的附近,这样就代表了在删除P置换之后,DES加密混淆效果并不好。换而言之,P置换在DES加密中能够起到很大的混淆作用。

    展开全文
  • 在介绍了数据加密标准DES加密算法的基础上,对其唯一非线性组件-S盒的设计进行分析,得出输入的某一位(这里只分析了最高位和最低位)改变,对输出位的改变是成对出现的这一结论。
  • 最近导师让仔细看看DES算法,尤其是S盒;实在找不到这个逻辑电路图,希望哪位有的麻烦一下给我发一张,谢谢!
  • 介绍了DES算法原理,详细分析了子密钥生成、S盒和轮函数的设计。将DES算法采用资源优先方案,在轮函数内部设置流水线架构,提高了整体处理速度;简化子密钥与原始密钥的生成关系,实现子密钥在迭代过程的动态分发;...
  • DES算法总结

    2019-05-13 17:14:12
    文章目录DES算法总结1.将M写成二进制的形式2.对二进制M进行初始IP变换3.迭代运算4. 将初始密钥K写成二进制的形式5.换位选择1得56位密钥6.分别对C(0)和D(0)进行左移位7.对拼接之后的C(1)D(1)进行换位选择2得到k18....

    DES算法总结

    下文中所指的教材均指:清华大学李辉老师的《计算机安全与保密》
    在这里插入图片描述

    题目中的M即为明文,K为初始密钥。

    要求L1和R1

    1.将M写成二进制的形式

    M一共包含16个十六进制位,写成二进制一行肯定写不下,

    所以我们分8行写,每一行只对应两个十六进制位。

    2.对二进制M进行初始IP变换

    这就是个换位变换,具体查阅教材31 表2.4 是个8x8矩阵。

    索引是从1开始的。

    ip变换表跟我们的二进制矩阵的形式是类似的,都是8x8矩阵。

    第一个数58,意思就是将明文中的第58个二进制位放到该位置来。

    第二个数50,意思就是将明文中的第50个二进制位放到该位置来。

    这样一来,我们就得到了一个新的二进制矩阵。这就是初始变换后的明文

    我们记为x0

    x0=L0R0x_0 = L_0R_0

    所以这个二进制矩阵的前半部分(即上半部分)就是L0L_0

    下半部分就是R0R_0

    3.迭代运算

    L1=R0L_1 = R_0

    这样L1就求出来了。

    R1=L0f(R0,k1)R_1 = L_0 \bigoplus f(R_{0},k_1)

    L0已知,R0已知 ,现在就是k1未知。但是我们知道初始密钥k

    下面我们要根据密钥生成算法求出k1才行。

    4. 将初始密钥K写成二进制的形式

    跟M一样,我们也将k写成8x8的二进制矩阵形式,主要是为了便于后续的运算。

    5.换位选择1得56位密钥

    初始密钥K一共64位,现在我们要将他变成56位。

    具体查教材34页 表2.11

    换位选择1的表一共56位,是8x7的矩阵。

    第一个元素57的意思是:将初始密钥二进制串的第56位放到这个位置。

    第二个元素49的意思是:将初始密钥二进制传的第49位放到这个位置。

    看这个表是在是太累了,你直接按照这个顺序从初始密钥二进制矩阵中抄就好了。

    在这里插入图片描述

    先从左下角开始抄,每行抄8位,抄完之后就抄了28位了,这就是C(0)

    然后再从右下角开始抄,接着之前的28位写,每行8位。这就是D(0)

    接下来的操作就是分别对C(0)和D(0)进行操作了。

    这样就得到了一个7行,8列的矩阵。

    6.分别对C(0)和D(0)进行左移位

    C(1)=λσ(1)C(0)C(1) = \lambda \sigma (1) C(0)

    D(1)=λσ(1)D(0)D(1) = \lambda \sigma (1) D(0)

    λσ(i)\lambda\sigma(i)是个移动位置的函数

    查教材34页表2.1可知(不用查了)λσ(1)=1\lambda\sigma(1) = 1

    所以分别将C(0)和C(1)向左移动一位就可以了。

    C(0)循环左移得到C(1)

    D(0)循环左移得到D(1)

    C(1)和D(1)拼接起来,接着做下面的操作

    7.对拼接之后的C(1)D(1)进行换位选择2得到k1

    查教材34页表2.13,换位选择2的表是8x6的矩阵,所以我们最终的k1也是8x6的。

    换位选择2没有什么规律,一个一个慢慢抄吧,

    结果就是K1,

    8.根据第3步的迭代运算

    R1=L0f(R0,k1)R_1 = L_0 \bigoplus f(R_{0},k_1)

    需要计算f(R0,k1)f(R_0,k_1)

    R0R_0是8x4 = 32位的,k1k_1是8x6= 48位的。

    8.1 先对R0R_0进行扩展得E(R0R_0)

    查阅32页表2.6

    原来的R0R_0不动,直接在两边扩展。

    左边扩展一位,右边扩展一位。

    得到一个8x6的矩阵E(R0)E(R_0)。和k1相同

    8.2 将E(R0)E(R_0)和k1异或

    两个矩阵做异或你会吧。

    得到一个8x6的矩阵。

    8.3 进行S盒代替

    查阅32页表2.7

    每一行对应一个s盒子

    第1行对应s(1)

    第2行对应s(2)

    每一行从6位变成了4位。

    所以得到一个8x4的矩阵

    8.4 经过一个换位变换

    查阅教材33页表2.8

    注意这个表是先看左半边,再看右半边。

    注意第2行开头的29是第5位。

    表示新二进制位的第5位是原来二进制串的第29位


    至此就得到了$ f(R_{0},k_1)$

    L0是个4x8的矩阵。所以我们要做异或的话需要将刚刚得到的8x4

    矩阵也写成4x8矩阵,两行并成一行就好了,OK!得到的就是R1

    R1=L0f(R0,k1)R_1 = L_0 \bigoplus f(R_{0},k_1)

    展开全文
  • DES算法概述

    2020-07-31 15:03:21
    1.整体框架 密钥长度:64 bits 奇偶...而后并行送入8个S一盒,每个S盒为一非线性代换网络,有4个输出,输出一共32 bit。 - 置换运算P盒 功能:对S1至S8盒输出的32 bit数据进行坐标置换。 3.安全性分析 密钥长度太
  • DES加密算法原理

    千次阅读 2019-10-07 17:29:36
    目录: ...2.3 S-盒代替(功能表S盒) 2.4P-盒置换: 3、逆置换: 4、DES解密: 一、DES算法: 1、DES算法简介: DES算法为密码体制中的对称密码体制。需要加密的明文按64位进行分组,加密...
  • 本文主要介绍了DES算法的步骤,包括IP置换、密钥置换、E扩展置换、S盒代替、P盒置换和末置换。  安全体系(零)—— 加解密算法、消息摘要、消息认证技术、数字签名与公钥证书  安全体系(二)——RSA算法详解 ...
  • DES算法差分和线性分析 SDU网络空间安全学院 目录 文章目录摘要DES攻击方法时间存储权衡攻击:预计算在线阶段DES差分分析差分分析原理一轮加密二轮加密DES差分分析具体实现题目题解python实现求S盒异或分布表函数...
  • 咨询中心网站建设方案书 目录 1....未指定书签 3.1.1AES 的 S 错误 !未指定书签 3.1.2AES 的逆 S 错误 !未指定书签 3.1.3 轮常量 错误 !未指定书签 3.1.4 密钥移位函数 错误 !未指定书签 3.1.
  • 工程实践——DES算法的C语言实现

    万次阅读 多人点赞 2014-07-20 09:08:51
    本次工程实践的题目是DES算法的C语言实现: 菜单为:  (1)加密,输入明文得到密文  1) 输入格式:明文8个ASCII字符,密钥8个ASCII字符(例如“abcdef,78”,“20121100”)  2) 将输入密钥和明文的8个...
  • S盒是构成分组密码算法重要的非线性部件,其密码学性质直接影响整个密码算法的安全性,因此对s盒的安全性检测十分重要。以往对s盒的安全性评估大多数集中在检测分量...对DES和AES的S盒分别进行了实验,给出了测试结果。
  • DES加密算法的实现

    2020-05-10 23:01:13
    DES加密算法是一种对称密钥算法 加密和解密时所用的密钥是一样的 利用64位的明文和64位的密钥进行加密,得到64位的密文 ...最终得到48位,之后进行s盒压缩,得到32位,并且与一直没有进行运算的左边32位明文进行交换,
  • des加密算法的源代码

    2009-04-11 09:21:00
    这是一段编译好的DES加密的算法,有完整的S盒的变换
  • 写在前面:   1、本文中DES加解密基本流程及S盒等参数参照...1. DES算法理论介绍   具体可参见杨波《现代密码学(第四版)》。本文只做简要介绍。 1.1 DES介绍   DES全称为Data Encryption Standard,即数据加密标
  • DES AES RC4算法比较 根据密钥类型的不同,加密算法分为对称和非对称两种。对称加密系统是指加密和...密钥调度算法用于初始化数组S盒中的置换。“keylength”被定义为密钥中的字节数,并且可以在1≤keylength≤256的范
  • 目录 一、简要描述 二、名词解释 数据填充 ...算法特点 ... E-扩展 ​ ... S-替代 ​ P-置换 ​ 左右交换 5、逆置换 四、解密流程 五、代码实现 六、总结 一、简要描述 DES ...
  • 在分析DES算法和SM4算法原理的基础上归纳了这两种算法的共同特点,采用可重构技术将两者融合,DES算法和SM4算法共用一个S盒,通过对S盒的配置可满足DES算法的6 bit输入、4 bit输出和SM4算法8 bit输入、8 bit输出的...
  • 本文针对基于FPGA硬件设计方法的特点,对DES(data encryption standard)加密算法进行了深入分析,提出了一种基于现场可编程阵列(FPGA)的DES改进算法.该算法采用3级流水线生成子密钥,提高了子密钥的生成速度;采用...
  • #include <iostream> #include "置换表.cpp" //根据置换表p,将数组src的元素放进数组des。 template<std::size_t N>...void Permutation(const std::array<... p, const int* src, int* ...void S盒(int*

空空如也

空空如也

1 2 3 4 5
收藏数 89
精华内容 35
关键字:

des算法s盒