精华内容
下载资源
问答
  • 目录 引语 加密 加密算法公式 为什么采用加密-解密-加密的形式 ...注意:3DES是3重DES加解密算法,具体原理同DES,不在赘述。...DES算法是全网公开的,其安全性是依靠秘钥的,但是随着计算机算力的增长...3DES加密流程 .

    目录

    引语

    加密

    加密算法公式

    为什么采用加密-解密-加密的形式

    解密

    代码实现


    注意:3DES是3重DES加解密算法,具体原理同DES,不在赘述。

     

    引语

    DES算法是全网公开的,其安全性是依靠秘钥的,但是随着计算机算力的增长,56位的秘钥容易受到穷举攻击。因此,3DES作为替换升级的方案应运而生。

    加密

    3DES是对称加密的一种,是DES向AES过渡的加密算法。它使用三个秘钥的三重DES加密方法,该算法执行三次DES算法,其加密的过程是加密-解密-加密。

    img
    3DES加密流程

     

    加密算法公式

    3DES使用2个或者3个秘钥,最少112位最多168位。设Ek()和Dk()分别代表DES算法的加密和解密过程,k代表DES算法使用的秘钥,M代表明文,C代表密文,则3DES加密的共识如下:

    C = Ek3(Dk2(Ek2(Dk1(C))))

    在这里,我们可以使秘钥k1 = k3 ,即使用两个有效的秘钥,已降低对计算机算力的要求;但是,我们不允许k1=k2=k3,因为这样设置,3DES的安全性将退化至DES

     

    为什么采用加密-解密-加密的形式

    3DES为了向前兼容DES算法,采用了加密-解密-加密的形式 , 简单解释一下:当k1 = k2 = k3时,前两步的结果会相互抵消,相当于仅实现了一次DES加密,因此可以实现对普通DES加密算法的兼容。

     

    img
    兼容

     

     

    解密

    3DES解密过程,与加密过程相反,即逆序使用秘钥并执行解密-加密-解密的过程

    img
    3DES解密过程

     

     

    代码实现

    使用DES现成类库,实现3DES算法,使用go语言。最近学习go语言,后续有学习笔记。

    package main
    ​
    import (
     "crypto/des"
     "bytes"
     "crypto/cipher"
     "fmt"
    )
    ​
    //DES 和 3DES加密区别
    //前者 加密  密钥必须是8byte
    //后者加密 解密 再加密  密钥必须是24byte
    func main() {
     //定义密钥,必须是24byte
     key := []byte("123456789012345678901234")
     //定义明文
     origData := []byte("hello world")
    ​
     //加密
     en := ThriDESEnCrypt(origData,key)
    ​
     //解密
     de := ThriDESDeCrypt(en,key)
     fmt.Println(string(de))
    }
    //解密
    func ThriDESDeCrypt(crypted,key []byte)[]byte{
     //获取block块
     block,_ :=des.NewTripleDESCipher(key)
     //创建切片
     context := make([]byte,len(crypted))
    ​
     //设置解密方式
     blockMode := cipher.NewCBCDecrypter(block,key[:8])
     //解密密文到数组
     blockMode.CryptBlocks(context,crypted)
    ​
     //去补码
     context = PKCSUnPadding(context)
     return context
    }
    ​
    //去补码
    func PKCSUnPadding(origData []byte)[]byte{
     length := len(origData)
     unpadding := int(origData[length-1])
     return origData[:length-unpadding]
    }
    //加密
    func ThriDESEnCrypt(origData,key []byte)[]byte{
     //获取block块
     block,_ :=des.NewTripleDESCipher(key)
     //补码
     origData = PKCSPadding(origData, block.BlockSize())
     //设置加密方式为 3DES  使用3条56位的密钥对数据进行三次加密
     blockMode := cipher.NewCBCEncrypter(block,key[:8])
    ​
     //创建明文长度的数组
     crypted := make([]byte,len(origData))
    ​
     //加密明文
     blockMode.CryptBlocks(crypted,origData)
    ​
     return crypted
    ​
    ​
    }
    //补码
    func PKCSPadding(origData []byte,blockSize int)[]byte{
     //计算需要补几位数
     padding := blockSize-len(origData)%blockSize
     //在切片后面追加char数量的byte(char)
     padtext := bytes.Repeat([]byte{byte(padding)},padding)
    ​
     return append(origData,padtext...)
    }

     

     

    展开全文
  • 加密流程 ​首先说一下置换的意思,比如说有5678这个字符串,置换表为2143,置换表中的数表示的是位置,所以字符串变成6587。所有的置换表在程序中。(S盒置换不一样,会另外说明) 密钥部分 把8位字符串密钥变成2...
  • 1、加密运算流程图 2、初始置换 ​ 3、生成子秘钥 PC-1置换 ​ PC-2置换 4、迭代的过程(f函数) f函数 E-盒扩展 ​ S-盒替代 ​ P-盒置换 ​ 左右交换 5、逆置换 四、解密流程 五、代码实现 ...

     

    目录

     

    一、简要描述

    二、名词解释

    数据填充

    分组加密

    算法特点

    置换

    三、加密运算

    1、加密运算流程图

    2、初始置换 ​        

    3、生成子秘钥

         PC-1置换 ​        

         PC-2置换

    4、迭代的过程(f函数)

     f函数

    E-盒扩展 ​

    S-盒替代 ​

    P-盒置换 ​

    左右交换

    5、逆置换

    四、解密流程

    五、代码实现

    六、数据填充

    七、总结


     

    一、简要描述

    DES 算法是一种常见的分组加密算法,由IBM公司在1971年提出。DES 算法是分组加密算法的典型代表。其加密运算、解密运算使用相同的秘钥。

    DES 算法利用56+8奇偶校验位(第8,16,24,32,40,48,56,64)=64位的密钥对以64位为单位的块数据进行加解密。

    二、名词解释

    数据填充

    DES算法是以64位为一组分组加密的,所以当输入的明文长度,不满足64的整数倍时,需要涉及到数据的填充

    分组加密

    DES算法将输入明文分为N个64位大小的分组,然后依次根据加密运算,生成N组加密后的密文 ,将生成的N组密文,就是我们要最终的成果——DES密文输出

    算法特点

    使用56位的密钥(一般密钥说是64位,实际上有效位只有56位,其余8位是校验位)

    以64位位单位,对数据分组进行加密和解密(密文与明文长度相同,均为64位)。

    DES加密与解密使用同一密钥(属于对称加密)

    DES的保密性依赖于密钥。(DES的加密算法是公开的,密钥是保密的)

    置换

            可以简单的理解为将 【将明文打乱】 ——将分组后的64位二进制明文重新排序。这个重排序的过程就是移位,不同的置换中,有不同的移位规则。具体的规则我们可以参照置换表。置换表如下图:

    解释一下,置换表的读取顺序是从上到下,由左至右。

    第一位 58 , 意思是 将原明文的第58位移动至第一位

    第二位 50 , 意思是将原明文的第50位之冬至第二位

    依次类推

    三、加密运算

     1、加密运算流程图

        

       
         以下加密流程,明文M是指的输入明文中的一个分组。

    2、初始置换 ​        

    初始置换就是将明文M打乱重排序。并生成L0 , R0。

     

     

    输入64位明文数据M(64位):

    明文M(64位)=

    0110001101101111011011010111000001110101011101000110010101110010

    M经过IP置换后为M'

    M'(64位)=

    1111111110111000011101100101011100000000111111110000011010000011

    取M'的前32位作为L0,则有

    L0(32位)= 11111111101110000111011001010111

    取M'的后32位作为R0,则有

    R0(32位)= 00000000111111110000011010000011

    3、生成子秘钥

    DES加密的过程,明文M共经历了16次运算迭代,每次迭代的数据长度是48 ,因此我们需要16组48位的加密秘钥来进行加密。

            PC-1置换 ​        

                我们知道秘钥的长度是64 (58位真实秘钥 + 8位奇偶校验位) , PC-1置换就是剔除掉奇偶校验位,并打乱用户秘钥的的过程。

    PC-1置换的置换表

     

    PC-1表为8行7列的表,密钥K经PC-1后变为56位数据K'。

    K'(56位)= 11110000110011001010101011110101010101100110011110001111

    取K'的前28位作为C0,则有

    C0(28位)= 1111000011001100101010101111

    取K'的后28位作为D0,则有

    D0(28位)= 0101010101100110011110001111

    下来依次是C1,D1为C0,D0左移一位,C2,D2为C1,D1左移一位,C3,D3为C2,D2左移两位.......

    移动位数表

     

    所以,可以得到C1D1----C16D16的结果为:

    C1 = 1110000 1100110 01010101011111

    D1 = 1010101011001100111100011110

    C2 = 1100001100110010101010111111

    D2 = 0101010110011001111000111101

    C3 = 0000110011001010101011111111

    D3 = 0101011001100111100011110101

    ................

    .................

    C15 = 1111100001100110010101010111

    D15 = 1010101010110011001111000111

    C16 = 1111000011001100101010101111

    D16 = 0101010101100101101110001111


         PC-2置换

    PC-1置换后生成了(CnDn)共16组56位的二进制字符,PC-2置换就是根据公式Kn(48位) = PC-2(CnDn(56位))再次进行置换,生成16组子秘钥

    PC-2置换的置换表

    C1(28位)= 1110000  1100110  0101010  1011111

    D1(28位)= 1010101  0110011  0011110  0011110

    C1和D1合并后为56位,经过PC-2表置换得到密钥K1(48位)

    K1(48位)= 000110110000001011101111111111000111000001110010

    并依次获取K2,K3,K4,K5,K6,K7,K8,K9,K10,K11,K12,K13,K14,K15,K16

     

    4、迭代的过程(f函数)

         f函数

       f函数就是不断计算Li,Ri的过程,此过程包括四个部分:E盒置换、S盒置换、P盒置换、左右校验,我们简要的总结如下:

                     

    加密的F函数

         E-盒扩展 ​

    通过扩展置换E,数据的右半部分Rn从32位扩展到48位。扩展置换改变了位的次序,重复了某些位。

    扩展置换的目的:

    a、产生与秘钥相同长度的数据以进行异或运算,R0是32位,子秘钥是48位,所以R0要先进行扩展置换之后与子秘钥进行异或运算;

    b、提供更长的结果,使得在替代运算时能够进行压缩。

    扩展置换E规则如下:

    E-盒扩展的规则

          例子:

    L0(32位)= 11111111101110000111011001010111

    R0(32位)= 00000000111111110000011010000011

    R0(32位)经过扩展置换后变为48位数据:

    E(R0)(48位)= 100000000001011111111110100000001101010000000110

    将E(R0)(48位)与K1(48位)作异或运算

    100000000001011111111110100000001101010000000110

                                       XOR 

    000110110000001011101111111111000111000001110010

    = 100110110001010100010001011111001010010001110100

    得到:

    E(R0)^K1(48位)= 100110110001010100010001011111001010010001110100

    S-盒替代 ​

    S盒替代简而言之就是“6进4出”的。(传入S盒的是6位数据,从S盒输出的是4位数据),将E盒输出的48位替换压缩为32位。

    S-盒替换示意图

     

    Rn扩展置换之后与子秘钥Kn异或以后的结果En作为输入块进行S盒代替运算功能是把48位数据变为32位数据。代替运算由8个不同的代替盒(S盒)完成。每个S-盒有6位输入,4位输出。所以48位的输入块被分成8个6位的分组,每一个分组对应一个S-盒代替操作。经过S-盒代替,形成8个4位分组结果。

    注意:每一个S-盒的输入数据是6位,输出数据是4位,但是每个S-盒自身是64位!!每个S-和是4行16列的格式,因为二进制4位是0~15。

    S盒的计算规则:

    S1-盒压缩替换表 

    例如:若S-盒1的输入为110111,第一位与最后一位构成11,十进制值为3,则对应第3行,中间4位为1011对应的十进制值为11,则对应第11列。查找S-盒1表的值为14,则S-盒1的输出为1110。8个S盒将输入的48位数据输出为32位数据。

    S-盒1  至 S-盒8不再一一列举

    例子:

    按照S-盒的计算过程,将

    E(R0)^K1(48位)= 100110110001010100010001011111001010010001110100,通过 S- 盒替换得到的S盒输出为10001011110001000110001011101010(32位)。

    P-盒置换 ​

    P盒置换是32位的输入移位转换成32位的输出。其具体过程同IP置换,不再赘述。

    P-盒置换的置换表

    例子:

    将S盒输出10001011110001000110001011101010(32位)

    经过P盒置换,P-盒置换输出 0100 1000 1011 1111 0101 0101 1000  0001

    将此结果与 L0(32位) =     1111   1111 1011 1000 0111 0110  0101 0111

    进行异或运算得到结果为:   1011  0111  0000 0111 0010 0011 1101  0110

    左右交换

    将上述结果赋值给R1

    将R0原封不动的赋值给L1

    5、逆置换

    将f函数的过程使用k1-k16,迭代16次,即经过16次的交换替代,得到L16 、R16,并将此作为输入进行逆置换得到最后的密文,逆置换的过程同初始置换,不再赘述。

    逆置换流程

    例子:

    将L16与R16构成64位数据,经过逆置换表输出密文为:

    密文:0101100000001000001100000000101111001101110101100001100001101000

    四、解密流程

    解密过程同加密过程,只不过是按照反向的次序即可。

    五、代码实现

    package com.general.encryanddecode;
    
    import org.omg.PortableInterceptor.SYSTEM_EXCEPTION;
    
    import java.util.Arrays;
    
    /**
     * @author hee-wong
     *
     * 根据DES算法原理实现DES加密算法,主要是为了更加深入地理解DES算法
     * **/
    public class CustomDES {
        //初始置换
        private int[] 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};
        //逆初始置换
        private int[] 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};//手残,数组数据没写全
        //E扩展
        private int[] 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};
        //P置换
        private int[] 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};
        private static final int[][][] S_Box = {
                {
                        { 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 } },
                { 
                        { 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 },
                        { 11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 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, 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 } },
                { 
                        { 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 } },
                { 
                        { 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 } }
        };
        //PC-1
        private int[] PC1={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};
        //PC-2
        private int[] PC2={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};
        //Schedule of Left Shifts
        private int[] LFT={1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1};
        /**加密轮数**/
        private static final int LOOP_NUM=16;
        private String [] keys=new String[LOOP_NUM];
        private String [] pContent;
        private String [] cContent;
        private int origin_length;
        /**16个子密钥**/
        private int[][] sub_key=new int[16][48];
        private String content;
        private int p_origin_length;
        public CustomDES(String key,String content){
    
            this.content=content;
            p_origin_length=content.getBytes().length;
            generateKeys(key);
    
        }
        public static void main(String[] args){
            String origin="试试能跑通吗";
            System.out.println("原文:\n"+origin);
            CustomDES customDES=new CustomDES("密码学专栏",origin);
            byte[] c=customDES.deal(origin.getBytes(),1);
            System.out.println("密文:\n"+new String(c));
            byte[]p=customDES.deal(c,0);
            byte[] p_d=new byte[origin.getBytes().length];
                    System.arraycopy(p,0,p_d,0,origin.getBytes().length);
            System.out.println("明文:\n"+new String(p));
    
        }
      
    
        /****拆分分组****/
        public byte[] deal(byte[] p ,int flag){
            origin_length=p.length;
            int g_num;
            int r_num;
            g_num=origin_length/8;
            r_num=8-(origin_length-g_num*8);//8不填充
            byte[] p_padding;
            /****填充********/
            if (r_num<8){
                p_padding=new byte[origin_length+r_num];
                System.arraycopy(p,0,p_padding,0,origin_length);
                for(int i=0;i<r_num;i++){
                    p_padding[origin_length+i]=(byte)r_num;
                }
    
            }else{
                p_padding=p;
            }
            g_num=p_padding.length/8;
            byte[] f_p=new byte[8];
            byte[] result_data=new byte[p_padding.length];
            for(int i=0;i<g_num;i++){
                System.arraycopy(p_padding,i*8,f_p,0,8);
                System.arraycopy(descryUnit(f_p,sub_key,flag),0,result_data,i*8,8);
            }
            if (flag==0){//解密
                byte[] p_result_data=new byte[p_origin_length];
                System.arraycopy(result_data,0,p_result_data,0,p_origin_length);
                return  p_result_data;
            }
            return result_data;
    
        }
        /**加密**/
        public byte[] descryUnit(byte[] p,int k[][],int flag){
            int[] p_bit=new int[64];
            StringBuilder stringBuilder=new StringBuilder();
            for(int i=0;i<8;i++){
                String p_b=Integer.toBinaryString(p[i]&0xff);
                while (p_b.length()%8!=0){
                    p_b="0"+p_b;
                }
                stringBuilder.append(p_b);
            }
            String p_str=stringBuilder.toString();
            for(int i=0;i<64;i++){
                int p_t=Integer.valueOf(p_str.charAt(i));
                if(p_t==48){
                    p_t=0;
                }else if(p_t==49){
                    p_t=1;
                }else{
                    System.out.println("To bit error!");
                }
                p_bit[i]=p_t;
            }
            /***IP置换***/
            int [] p_IP=new int[64];
            for (int i=0;i<64;i++){
                p_IP[i]=p_bit[IP[i]-1];
            }
            if (flag == 1) { // 加密
                for (int i = 0; i < 16; i++) {
                    L(p_IP, i, flag, k[i]);
                }
            } else if (flag == 0) { // 解密
                for (int i = 15; i > -1; i--) {
                    L(p_IP, i, flag, k[i]);
                }
            }
            int[] c=new int[64];
            for(int i=0;i<IP_1.length;i++){
                c[i]=p_IP[IP_1[i]-1];
            }
            byte[] c_byte=new byte[8];
            for(int i=0;i<8;i++){
                c_byte[i]=(byte) ((c[8*i]<<7)+(c[8*i+1]<<6)+(c[8*i+2]<<5)+(c[8*i+3]<<4)+(c[8*i+4]<<3)+(c[8*i+5]<<2)+(c[8*i+6]<<1)+(c[8*i+7]));
            }
            return c_byte;
    
    
        }
        public void L(int[] M, int times, int flag, int[] keyarray){
            int[] L0=new int[32];
            int[] R0=new int[32];
            int[] L1=new int[32];
            int[] R1=new int[32];
            int[] f=new int[32];
            System.arraycopy(M,0,L0,0,32);
            System.arraycopy(M,32,R0,0,32);
            L1=R0;
            f=fFuction(R0,keyarray);
            for(int j=0;j<32;j++){
                    R1[j]=L0[j]^f[j];
                    if (((flag == 0) && (times == 0)) || ((flag == 1) && (times == 15))) {
                        M[j] = R1[j];
                        M[j + 32] = L1[j];
                    }
                    else {
                        M[j] = L1[j];
                        M[j + 32] = R1[j];
                    }
            }
    
        }
    
    
    
        public int[] fFuction(int [] r_content,int [] key){
            int[] result=new int[32];
            int[] e_k=new int[48];
            for(int i=0;i<E.length;i++){
                e_k[i]=r_content[E[i]-1]^key[i];
            }
            /********S盒替换:由48位变32位,现分割e_k,然后再进行替换*********/
            int[][] s=new int[8][6];
            int[]s_after=new int[32];
            for(int i=0;i<8;i++){
                System.arraycopy(e_k,i*6,s[i],0,6);
                int r=(s[i][0]<<1)+ s[i][5];//横坐标
                int c=(s[i][1]<<3)+(s[i][2]<<2)+(s[i][3]<<1)+s[i][4];//纵坐标
                String str=Integer.toBinaryString(S_Box[i][r][c]);
                while (str.length()<4){
                    str="0"+str;
                }
                for(int j=0;j<4;j++){
                    int p=Integer.valueOf(str.charAt(j));
                    if(p==48){
                        p=0;
                    }else if(p==49){
                        p=1;
                    }else{
                        System.out.println("To bit error!");
                    }
                    s_after[4*i+j]=p;
                }
    
            }
            /******S盒替换结束*******/
            /****P盒替代****/
            for(int i=0;i<P.length;i++){
                result[i]=s_after[P[i]-1];
            }
            return result;
    
        }
    
        /**生成子密钥**/
        public void generateKeys(String key){
            while (key.length()<8){
                key=key+key;
            }
            key=key.substring(0,8);
            byte[] keys=key.getBytes();
            int[] k_bit=new int[64];
            //取位值
            for(int i=0;i<8;i++){
                String k_str=Integer.toBinaryString(keys[i]&0xff);
                if(k_str.length()<8){
                    for(int t=0;t<8-k_str.length();t++){
                        k_str="0"+k_str;
                    }
                }
                for(int j=0;j<8;j++){
                    int p=Integer.valueOf(k_str.charAt(j));
                    if(p==48){
                        p=0;
                    }else if(p==49){
                        p=1;
                    }else{
                        System.out.println("To bit error!");
                    }
                    k_bit[i*8+j]=p;
                }
            }
            //k_bit是初始的64位长密钥,下一步开始进行替换
            /***********PC-1压缩****************/
            int [] k_new_bit=new int[56];
            for(int i=0;i<PC1.length;i++){
                k_new_bit[i]=k_bit[PC1[i]-1];//这个减1注意点
            }
            /**************************/
            int[] c0=new int[28];
            int[] d0=new int[28];
            System.arraycopy(k_new_bit,0,c0,0,28);
            System.arraycopy(k_new_bit,28,d0,0,28);
            for(int i=0;i<16;i++){
                int[] c1=new int[28];
                int[] d1=new int[28];
                if(LFT[i]==1){
                    System.arraycopy(c0,1,c1,0,27);
                    c1[27]=c0[0];
                    System.arraycopy(d0,1,d1,0,27);
                    d1[27]=d0[0];
                }else if(LFT[i]==2){
                    System.arraycopy(c0,2,c1,0,26);
                    c1[26]=c0[0];
                    c1[27]=c0[1];//这里手残之前写成c1
    
                    System.arraycopy(d0,2,d1,0,26);
                    d1[26]=d0[0];
                    d1[27]=d0[1];
                }else{
                    System.out.println("LFT Error!");
                }
                int[] tmp=new int[56];
                System.arraycopy(c1,0,tmp,0,28);
                System.arraycopy(d1,0,tmp,28,28);
                for (int j=0;j<PC2.length;j++){//PC2压缩置换
                    sub_key[i][j]= tmp[PC2[j]-1];
                }
                c0=c1;
                d0=d1;
            }
    
        }
    
    
    }
    

    六、数据填充

    当明文长度不为分组长度的整数倍时,需要在最后一个分组中填充一些数据使其凑满一个分组长度。

    NoPadding
    API或算法本身不对数据进行处理,加密数据由加密双方约定填补算法。例如若对字符串数据进行加解密,可以补充\0或者空格,然后trim

    PKCS5Padding
    加密前:数据字节长度对8取余,余数为m,若m>0,则补足8-m个字节,字节数值为8-m,即差几个字节就补几个字节,字节数值即为补充的字节数,若为0则补充8个字节的8
    解密后:取最后一个字节,值为m,则从数据尾部删除m个字节,剩余数据即为加密前的原文。
    加密字符串为为AAA,则补位为AAA55555;加密字符串为BBBBBB,则补位为BBBBBB22;加密字符串为CCCCCCCC,则补位为CCCCCCCC88888888。

    PKCS7Padding
    PKCS7Padding 的填充方式和PKCS5Padding 填充方式一样。只是加密块的字节数不同。PKCS5Padding明确定义了加密块是8字节,PKCS7Padding加密快可以是1-255之间。

    七、总结

    DES 加密算法为最为常见的分组加密算法。其主要思想在于数据位的置换与移位过程,通过16次的迭代加密与最终的逆置换得出最终的密文。DES 的解密方式只需按照加密的逆过程求解即可。由于DES 加密过程的算法是公开的,所以密钥K的保密就显得尤为重要,只有发送方与接收方采用相同的密钥进行加密解密才能获取明文数据。

    展开全文
  •   1、本文中DES加解密基本流程及S盒等参数参照自杨波《现代密码学(第四版)》,实现过程均为自编函数。   2、为了说明64bit密钥中,只有56bit真正参与加解密过程,对网上代码中的密钥生成过程做出了修改,详见...

    写在前面:
      1、本文中DES加解密基本流程及S盒等参数参照自杨波《现代密码学(第四版)》,实现过程均为自编函数。
      2、为了说明64bit密钥中,只有56bit真正参与加解密过程,对网上代码中的密钥生成过程做出了修改,详见正文。
      3、本文借鉴了网上部分代码,具体见参考文献,并对部分地方按题主想法进行了优化修改。

    1. DES算法理论介绍

      具体可参见杨波《现代密码学(第四版)》。本文只做简要介绍。

    1.1 DES介绍

      DES全称为Data Encryption Standard,即数据加密标准,是一种使用密钥加密的块算法,1977年被美国联邦政府的国家标准局确定为联邦资料处理标准(FIPS),并授权在非密级政府通信中使用,随后该算法在国际上广泛流传开来。

    1.2 DES加解密算法描述

    图 1.2 DES加密流程框图

      图1.2是DES加密变换框图,其中明文一组为64bit,密钥K长度56bit。加密过程有3个阶段:
      1、初始置换IP,用于重排明文分组的64比特数据。
      2、经过具有相同功能的16轮Feistel变换,每轮中F函数中都有置换和代换运算,第16轮变换的输出分为左右两半,并被交换次序。
      3、经过一个逆初始置换IP-1(为IP的逆)从而产生64比特的密文。

    1.2.1 轮结构

      采用Feistel相同的轮结构,将64bit的轮输入分为32bit的左、右两半,分别记为L和R:
    Li=Ri1 L_i=R_{i-1}
                   Ri=Li1F(Ri1,Ki) \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ R_i=L_{i-1}\oplus F\left( R_{i-1},K_i \right)
      其中,F函数示意图见图1.2.1。

    图1.2.1 F函数示意图

    1.2.2 密钥的生成

    图 1.2.2 16轮密钥生成图

      图1.2.2是使用56比特密钥的方法。密钥首先通过一个置换函数PC_1,然后,对加密过程的每一轮,通过一个左循环移位和一个置换PC_2产生一个子密钥。其中每轮的置换都相同,但由于密钥被重复迭代,所以产生的每轮子密钥不相同。

    1.2.3 DES解密

      和Feistel密码一样,DES的解密和加密使用同一种算法,但子密钥使用的顺序相反。

    2. Python代码实现

    2.1 实现思路

      由于加密与解密算法类似,此处给出加密算法实现思路:
      Step1:从文件中读取明文;
      Step2:将明文利用ASCII换成01比特流;
      Step3:将明文比特流每64位分为一组,最后不足的用0补齐;
      Step4:对64位比特加密操作(进行IP置换,16轮的Feistel变换、交换L、R、IP逆置换,将L、R合并为密文比特流);
      Step5:将每一组密文比特流合并转换成密文字符保存至文件。

    2.2 模块化程序设计

    2.2.1 各个模块调用关系及实现功能设计

    图2.2.1 各个模块调用关系及实现功能设计

      根据2.1中的实现思路,DES加解密算法各个模块调用关系及实现功能设计如图2.2.1所示,2.2.2中将详细介绍各个功能的代码实现。

    2.2.2 模块功能实现

      针对2.2.1的实现思路,分析DES加解密算法流程,可将其具体分成不同的模块分别设计:
    1.)文件读入模块

    def read_file(filename): 
        '''
        filename : 打开文件名
        return : 读取文件中字符串
        '''
        try:
            fp = open(filename,"r",encoding='utf-8')
            message = fp.read()
            fp.close()
            return message
        except:
            print("Open file error!")
    

    2.)文件写入模块
      将字符串写入文件text.txt与文件读入代码类似,只做如下修改:

            fp = open('text.txt','w',encoding='utf-8')
            fp.write(message)
    

      def write_file(message): 输入需要写入字符串,即可生成含有该字符串的text.txt文件。

    3.)字符串转01比特流

    def str_bit( message ):
        '''
        message :字符串
        return :将读入的字符串序列转化成01比特流序列
        '''
        bits = ""
        for i in message:
            asc2i = bin(ord(i))[2:] #bin将十进制数转二进制返回带有0b的01字符串
            '''为了统一每一个字符的01bit串位数相同,将每一个均补齐8位'''
            for j in range(8-len(asc2i)):
                asc2i = '0' + asc2i
            bits += asc2i
        return bits 
    

      每一个字符利用ord( )函数转化成对应ASCII值,利用bin( )将其转换成二进制字符串。
    4.)01比特流转字符
      def bit_str(bits): 输入01比特串(长度要是8的倍数),返回对应的字符,核心代码如下,主要利用int( )和chr( )函数。

        for i in range(len(bits)//8):
            temp += chr(int(bits[i*8:(i+1)*8],2))
    

    5.)密钥字符串转比特流
      本文假定密钥比特流的8、16、24、32、40、48、56、64位采用偶校验方式,分别校验其前面的7位01串。密钥字符串依然采用ASCII编码方式,一个字符占7位,第8位采用偶校验方式,核心代码如下:

    def process_key(key):
        '''
        key : 输入的密钥字符串
        return : 64bit 01序列密钥(采用偶校验的方法) 
        '''
        key_bits = ""
        for i in key:
            count = 0
            asc2i = bin(ord(i))[2:] 
            '''将每一个ascii均补齐7位,第8位作为奇偶效验位''' 
            for j in asc2i:
                count += int(j)
            if count % 2 == 0:
                asc2i += '0'
            else:
                asc2i += '1' 
            for j in range(7-len(asc2i)):
                asc2i = '0' + asc2i
            key_bits += asc2i
        if len(key_bits) > 64:
            return key_bits[0:64]
        else:
            for i in range(64-len(key_bits)):
                key_bits += '0'
            return key_bits 
    

    6.)对比特流分组
      函数定义如下,最后一组位数不足即补0。实现简单,此处不在赘述。

    def divide(bits,bit):
        '''
        bits : 将01bit按bit一组进行分组 
        return : 按bit位分组后得到的列表
        '''
    

    7.)IP置换
      为了实现简单,提前将IP、IP_RE、PC_1、PC_2、E、P、S等盒值写入文件DES_BOX.py,主函数即可直接调用。IP置换实现如下:

    def IP_change(bits):
        '''
        bits:一组64位的01比特字符串   
        return:初始置换IP后64bit01序列
        '''
        ip_str = ""
        for i in IP:
            ip_str = ip_str + bits[i-1]
        return ip_str
    

    8.)PC_1置换
      实现代码同IP置换,此处不在赘述。
    9.)比特串左移
      def key_leftshift(key_str,num): 将输入的01比特流key_str循环左移num位返回,实现过于简单,此处不在赘述。
    10.)PC_2置换
      实现代码同IP置换,此处不在赘述。
    11.)16轮密钥生成

    def generate_key(key):
        '''
        key : 64bit01密钥序列
        return : 16轮的16个48bit01密钥列表按1-16顺序
        '''
        key_list = ["" for i in range(16)]
        key = PC_1_change(key) #1、调用置换PC_1
        key_left = key[0:28] #2、左右28位分开
        key_right = key[28:]
        for i in range(len(SHIFT)): #共16轮即16次左循环移位
            key_left = key_leftshift(key_left, SHIFT[i]) #3、调用比特串左移函数
            key_right = key_leftshift(key_right, SHIFT[i]) 
            key_i = PC_2_change(key_left + key_right) #4、左右合并调用置换PC_2
            key_list[i] = key_i #5、将每一轮的56bit密钥存入列表key_list
        return key_list
    

    12.)E置换
      实现代码同IP置换,此处不在赘述。
    13.)异或运算
      函数实现较为简单,将输入的两个字符串逐位运算即可,仅给出定义如下。

    def xor(bits,ki):
        '''
        bits : 48bit01字符串 / 32bit01 F函数输出
        ki : 48bit01密钥序列 / 32bit01 Li
        return :bits与ki异或运算得到的48bit01 / 32bit01 
        ''' 
    

    14.)单次S盒查找

    def s(bits,i):
        '''
        bits : 6 bit01字符串
        i : 使用第i个s盒
        return : 4 bit01字符串
        '''
        row = int(bits[0]+bits[5],2) 
        col = int(bits[1:5],2)
        num = bin(S[i-1][row*16+col])[2:]  #i-1号S盒的row*16+col号数
        for i in range(4-len(num)):    #补齐4位后输出
            num = '0'+num
        return num
    

    15.)S盒变换
      def S_change(bits): 输入48bit字符串,输出经过S盒之后的32bit字符串。核心代码如下,调用8次单次S盒查找函数:

        for i in range(8):
            temp = bits[i*6:(i+1)*6]
            temp = s(temp,i+1)
            s_change += temp
    

    16.)P置换
      实现代码同IP置换,此处不在赘述。
    17.)F函数
      通过调用12-16模块即可实现第ii轮F函数运算:

    def F(bits,ki):
        '''
        bits : 32bit 01 Ri输入
        ki : 48bit 第i轮密钥
        return : F函数输出32bit 01序列串
        '''
        bits = xor(E_change(bits),ki)
        bits = P_change(S_change(bits))
        return bits
    

    18.)IP逆置换
      实现代码同IP置换,此处不在赘述。
    19.)64bit加密
      调用IP置换、16轮密钥生成、F函数、异或运算、IP逆置换等模块可以实现64bit一组明文的加密:

    def des_encrypt(bits,key):
        '''
        bits : 分组64bit 01明文字符串
        key : 64bit01密钥
        return : 加密得到64bit 01密文序列
        '''
        bits = IP_change(bits)  # IP置换
        L = bits[0:32]          # 切片分成两个32bit
        R = bits[32:]
        key_list = generate_key(key) # 生成16个密钥  
        for i in range(16):       # 16轮迭代变换
            L_next = R
            R = xor(L,F(R,key_list[i]))
            L = L_next
        result = IP_RE_change( R + L)  # IP逆置换
        return result
    
    

    20.)64bit解密
      def des_decrypt(bits,key):该模块与64bit加密模块流程相同,不同在于16个密钥使用顺序相反,16轮代换代码如下,其余代码同加密。

        for i in range(16):
            L_next = R
            R = xor(L,F(R,key_list[15-i]))
            L = L_next
    

    21.)整体加密模块
      def all_des_encrypt(message,key): 读入明文字符串message,以及密钥字符串key,返回加密后01比特流。通过调用字符串转01比特流、密钥字符串转比特流、对比特流分组、64bit加密等模块即可实现:

    def all_des_encrypt(message,key):
        '''
        message : 读入明文字符串
        key : 读入密钥串
        returns : 密文01序列
        '''
        message = str_bit(message)  # 明文转01比特流
        key = process_key(key)      # 64bit初始密钥生成
        mess_div = divide(message, 64)  # 明文按64bit一组进行分组
        result =""
        for i in mess_div:
            result += des_encrypt(i, key)  #对每一组进行加密运算
        return result    
    

    22.)整体解密模块
      def all_des_decrypt(message,key): 读入明文字符串message,以及密钥字符串key,返回解密后01比特流。与加密类似,此处不在赘述。

    2.2.3 主模块

      输出提示语,并与用户交互。通过调用文件读入或写入、字符串转01比特流、比特流转01字符串、加解密等模块实现,伪代码如下:

    2.3 Python源代码

      全部代码及相关注释点这里github

    2.4 关于密钥的说明

      起初按如下方式生成64bit密钥,即将密钥中每一个字符转成8bitASCII码,8个字符共构成64bit密钥。

    def process_key(key):
    	bin_key = str_bit(key)  #调用字符串转01比特流模块
    	return bin_key
    

      结果发现“wuzhenll”和“vt{idomm”这两个密钥加密后的密文相同。
      这是因为表面上这两个密码迥然不同,但是由于它们仅在奇偶校验位上有区别。例如,w的ASCII为01110111,v的ASCII为01110110,仅仅只在最后一位有区别。
      由于64位密钥中的第8位、第16位、第24位、第32位、第40位、第48位、第56位、第64位作为奇偶校验位,在PC_1置换时去掉了这8位。如果输入的密码只是在这8位上有区别的话,那么操作后的结果也将是一样的。所以用这两个密码进行加密解密操作得到的结果是一样的。

    2.5 使用说明

      运行环境: Python 3.7
      使用方法: 将DES_BOX.py、DES.py、以及需要含有明密文的文本文件放置于同一目录下,运行DES.py程序,根据相应提示语即可完成操作。明文加密后乱码会自动保存到text.txt文件中。(注:输入的密钥将转化成对应的ASCII按照偶校验的方式构成64bit初始密钥)

    2.6 结果测试

    测试一:明文:keep early hours! 密钥:password

    测试二: 明文:Have a good day! 密钥:messagee

    参考文献

    DES算法原理完整版

    DES加解密python实现

    DES算法中密钥的校验位

    展开全文
  • Https原理及流程

    千次阅读 2020-09-11 11:27:27
    明文: 明文指的是未被加密过的原始数据。 密文:明文被某种加密算法加密之后,会变成密文,从而确保原始数据的安全。密文也可以被解密,得到原始的明文。 密钥:密钥是一种参数...常见的对称加密算法有DES、3DES、TDE

    密码学基础

    明文: 明文指的是未被加密过的原始数据。
    密文:明文被某种加密算法加密之后,会变成密文,从而确保原始数据的安全。密文也可以被解密,得到原始的明文。
    密钥:密钥是一种参数,它是在明文转换为密文或将密文转换为明文的算法中输入的参数。密钥分为对称密钥与非对称密钥,分别应用在对称加密和非对称加密上。

    对称加密: 对称加密又叫做私钥加密,即信息的发送方和接收方使用同一个密钥去加密和解密数据。对称加密的特点是算法公开、加密和解密速度快,适合于对大数据量进行加密,
    常见的对称加密算法有DES、3DES、TDEA、Blowfish、RC5和IDEA。
    其加密过程如下:明文 + 加密算法 + 私钥 => 密文
    解密过程如下: 密文 + 解密算法 + 私钥 => 明文

    对称加密中用到的密钥叫做私钥,私钥表示个人私有的密钥,即该密钥不能被泄露。
    其加密过程中的私钥与解密过程中用到的私钥是同一个密钥,这也是称加密之所以称之为“对称”的原因。由于对称加密的算法是公开的,所以一旦私钥被泄露,那么密文就很容易被破解,所以对称加密的缺点是密钥安全管理困难。

    **非对称加密:**非对称加密也叫做公钥加密。非对称加密与对称加密相比,其安全性更好。对称加密的通信双方使用相同的密钥,如果一方的密钥遭泄露,那么整个通信就会被破解。而非对称加密使用一对密钥,即公钥和私钥,且二者成对出现。私钥被自己保存,不能对外泄露。公钥指的是公共的密钥,任何人都可以获得该密钥。用公钥或私钥中的任何一个进行加密,用另一个进行解密。
    被公钥加密过的密文只能被私钥解密,过程如下:
    明文 + 加密算法 + 公钥 => 密文, 密文 + 解密算法 + 私钥 => 明文
    被私钥加密过的密文只能被公钥解密,过程如下:
    明文 + 加密算法 + 私钥 => 密文, 密文 + 解密算法 + 公钥 => 明文

    由于加密和解密使用了两个不同的密钥,这就是非对称加密“非对称”的原因。
    非对称加密的缺点是加密和解密花费时间长、速度慢,只适合对少量数据进行加密。
    在非对称加密中使用的主要算法有:RSA、Elgamal、Rabin、D-H、ECC(椭圆曲线加密算法)等。

    Https原理及流程
    让面试官膜拜你的HTTPS运行流程(超详细)
    OkHttp配置HTTPS访问+服务器部署

    展开全文
  • 哈希算法的原理及其 Java 实现一、目的二、运行环境三、基本原理及步骤(I)各种加密算法的原理:① DES 数据加密标准(Data Encryption Standard):算法介绍算法流程优点缺点破解方式适用场景安全性② 3DESDES ...
  • 1、基础知识 1.1 对称加密算法 ...对称加密算法的特点是加密密钥和解密密钥是同一把密钥K,且加解密速度快,典型的对称加密算法有DES、AES等 对称加密算法加密流程和解密流程 1.2 非对称加密算法...
  • LKT4200 32位高端加密IC是目前行业最高端性能的防盗版加密芯片,芯片采用32位CPU...• 提供样片硬件原理图,开发手册; • 提供Demo测试板和开发例程,支持客户下载用户程序和重要数据; • 提供加密流程的设计思路。
  • • 提供样片硬件原理图,开发手册; • 提供Demo测试板和开发例程,支持客户下载用户程序和重要数据; • 提供加密流程的设计思路。  应用领域:  机顶盒、DVR、路由器、交换机、仪器仪表等各种电子产品终端。
  • 密码学复习知识点

    2021-01-15 14:57:19
    密码学密码学1 密码学的基本概念1.1 密码学的基本原理及流程1.2 两类重要密码体制1.3 流密码的基本思想2 分组密码体制2.1 DES2.2 AES2.3 SM42.3 DES、AES、SM4的优缺点及安全强度3 公钥密码体制3.1 公钥密码体系3.2 ...
  • 摘要 描述RKE系统的工作原理及系统在功耗、稳定性、RKE发送和接收范围等性能设计上的独到之处;使用Freescale公司的高性能、小封装微处理器MC9RS08KA2,结合Maxim公司的收发IC设计射频数据处理前端,Microchip公司的...
  • 摘要 描述RKE系统的工作原理及系统在功耗、稳定性、RKE发送和接收范围等性能设计上的独到之处;使用Freescale公司的高性能、小封装微处理器MC9RS08KA2,结合Maxim公司的收发IC设计射频数据处理前端,Microchip公司的...
  • 用Java加密类实现DES、RSASHA的加密算法.rar 用jdom解析xml.rar 电子书店管理系统.rar 编译原理--LR(1)分析表构造(JAVA).rar 网上书店.rar 网络电视源代码TV-Browser.rar 网络蚂蚁Java版.rar 网页浏览器.rar ...
  • java源码包---java 源码 大量 实例

    千次下载 热门讨论 2013-04-18 23:15:26
     Java非对称加密源程序代码实例,本例中使用RSA加密技术,定义加密算法可用 DES,DESede,Blowfish等。  设定字符串为“张三,你好,我是李四”  产生张三的密钥对(keyPairZhang)  张三生成公钥(publicKeyZhang...
  • java源码包2

    千次下载 热门讨论 2013-04-20 11:28:17
     Java非对称加密源程序代码实例,本例中使用RSA加密技术,定义加密算法可用 DES,DESede,Blowfish等。  设定字符串为“张三,你好,我是李四”  产生张三的密钥对(keyPairZhang)  张三生成公钥(publicKeyZhang...
  • java源码包3

    千次下载 热门讨论 2013-04-20 11:30:13
     Java非对称加密源程序代码实例,本例中使用RSA加密技术,定义加密算法可用 DES,DESede,Blowfish等。  设定字符串为“张三,你好,我是李四”  产生张三的密钥对(keyPairZhang)  张三生成公钥(publicKeyZhang...
  • java源码包4

    千次下载 热门讨论 2013-04-20 11:31:44
     Java非对称加密源程序代码实例,本例中使用RSA加密技术,定义加密算法可用 DES,DESede,Blowfish等。  设定字符串为“张三,你好,我是李四”  产生张三的密钥对(keyPairZhang)  张三生成公钥(publicKeyZhang...
  • Calendar万年历 1个目标文件 EJB 模拟银行ATM流程及操作源代码 6个目标文件,EJB来模拟银行ATM机的流程及操作:获取系统属性,初始化JNDI,取得Home对象的引用,创建EJB对象,并将当前的计数器初始化,调用每一个...
  • Calendar万年历 1个目标文件 EJB 模拟银行ATM流程及操作源代码 6个目标文件,EJB来模拟银行ATM机的流程及操作:获取系统属性,初始化JNDI,取得Home对象的引用,创建EJB对象,并将当前的计数器初始化,调用每一个...
  • Calendar万年历 1个目标文件 EJB 模拟银行ATM流程及操作源代码 6个目标文件,EJB来模拟银行ATM机的流程及操作:获取系统属性,初始化JNDI,取得Home对象的引用,创建EJB对象,并将当前的计数器初始化,调用每一个...
  • JAVA上百实例源码以及开源项目

    千次下载 热门讨论 2016-01-03 17:37:40
     Java非对称加密源程序代码实例,本例中使用RSA加密技术,定义加密算法可用 DES,DESede,Blowfish等。  设定字符串为“张三,你好,我是李四”  产生张三的密钥对(keyPairZhang)  张三生成公钥(publicKeyZhang...
  • asp.net知识库

    2015-06-18 08:45:45
    常用编码工具类,支持base64,md5,des,crc32 也谈谈技术面试 在C#里把ArrayList转换为Array 或 把Array转换为ArrayList C# 2.0 在.NET 2.0中,让你的组件也可以绑定 .NET20 一种简单的窗口控件UI状态控制方法 翻译MSDN...
  • 实现了数据加密标准( Data Encryption Standard,DES)和三重数据加密算法( TripleData Encryption Algorithm, TDEA) dsa 实现了FIPS 186-3所定义的数据签名算法( Digital Signature Algorithm) ecdsa ...
  • = 1.2.47 远程命令执行漏洞利用工具方法 SpringBoot_Actuator_RCE jizhicms(极致CMS)v1.7.1代码审计-任意文件上传getshell+sql注入+反射XSS CVE-2020-9484:Apache Tomcat Session 反序列化代码执行漏洞|CVE-2020...

空空如也

空空如也

1 2
收藏数 27
精华内容 10
关键字:

des加密原理及流程