精华内容
下载资源
问答
  • 1. 简介 DES是一种对称加密 (Data Encryption Standard) 算法。...ECB 模式: ECB(电子密本方式)其实非常简单,就是将数据按照8个字节一段进行DES加密或解密得到一段段的8个字节的密文或者明文,最后一段不足8个

    1. 简介

    DES是一种对称加密 (Data Encryption Standard) 算法。于1977年得到美国政府的正式许可,是一种用56位密钥来加密64位数据的方法。一般密码长度为8个字节,其中56位加密密钥,每个第8位都用作奇偶校验。
    DES算法一般有两个关键点,第一个是加密算法,第二个是数据补位。加密算法常见的有 ECB 模式和 CBC 模式。

    ECB 模式: ECB(电子密本方式)其实非常简单,就是将数据按照8个字节一段进行DES加密或解密得到一段段的8个字节的密文或者明文,最后一段不足8个字节(一般补0或者F),按照需求补足8个字节进行计算(并行计算),之后按照顺序将计算所得的数据连在一起即可,各段数据之间互不影响。

    优点:简单、有利于并行计算、误差不会被传递;
    缺点:不能隐藏明文的模式、可能对明文进行主动攻击;

    CBC 模式: 密文分组链接方式,它比较麻烦,加密步骤如下:

    1. 首先将数据按照8个字节一组进行分组得到 D1D2…Dn(若数据不是8的整数倍,就涉及到数据补位了);
    2. 第一组数据 D1 与向量I异或后的结果进行 DES 加密得到第一组密文C1(注意:这里有向量I的说法,ECB模式下没有使用向量I);
    3. 第二组数据 D2 与第一组的加密结果 C1 异或以后的结果进行 DES 加密,得到第二组密文 C2;
    4. 之后的数据以此类推,得到 Cn
    5. 按顺序连为 C1C2C3…Cn 即为加密结果;

    优点:不容易主动攻击,安全性好于 ECB,是 SSL、IPSec 的标准;
    缺点:不利于并行计算、误差传递、需要初始化向量 IV;

    2. Vue中 实现 DES 加密和解密

    安装 crypto-js
    crypto-js npm地址

    npm install crypto-js
    

    2.1 ECB 模式

    2.1.1 封装方法

    // utils/des.js
    
    import cryptoJs from 'crypto-js';
    
    // 随机生成指定数量的16进制key(该方法非必须,也可自己指定key)
    const generatekey = (num) => {
      let library = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
      let key = "";
      for (var i = 0; i < num; i++) {
        let randomPoz = Math.floor(Math.random() * library.length);
        key += library.substring(randomPoz, randomPoz + 1);
      }
      return key;
    }
    /*
    * message:需要解密的字符串,
    * key: 密钥(加密解密密钥同一个)
    */
    //DES加密
    const encryptDes = (message, key = 'abcd@1234') => {
      var keyHex = cryptoJs.enc.Utf8.parse(key)
      var option = { mode: cryptoJs.mode.ECB, padding: cryptoJs.pad.Pkcs7 }
      var encrypted = cryptoJs.DES.encrypt(message, keyHex, option)
      return encrypted.ciphertext.toString(); // 返回hex格式密文,如需返回base64格式:encrypted.toString()
    }
    
    
    //DES解密
    const decryptDes = (message, key = 'abcd@1234') => {
      var keyHex = cryptoJs.enc.Utf8.parse(key)
      var decrypted = cryptoJs.DES.decrypt(
        {
          ciphertext: cryptoJs.enc.Hex.parse(message)
        }, // 若 message 是 base64 格式,则无需转16进制hex,直接传入 message 即可
        keyHex,
        {
          mode: cryptoJs.mode.ECB,
          padding: cryptoJs.pad.Pkcs7
        }
      )
      return decrypted.toString(cryptoJs.enc.Utf8)
    }
    
    export {
      generatekey,
      encryptDes,
      decryptDes,
    }
    

    2.1.2 引入使用

    <script>
    import { encryptDes, decryptDes,generatekey } from '@/utils/des.js'
    
    export default {
      data() {
        return {
          info:{
            userName:'test',
            passWord:'Hi@123'
          }
        };
      },
      methods: {
        test(){
          const key = generatekey(8); // 也可直接指定key let key = 'des';
          
          //如果是对象/数组的话,需要先JSON.stringify转换成字符串
          const encrypts = encryptDes(JSON.stringify(this.info), key);
          const dess = JSON.parse(decryptDes(encrypts, key));
    
          console.log(encrypts, dess)
        }
      },
      mounted() {
        this.test();
      },
    };
    </script>
    

    2.2 CBC 模式

    2.2.1 封装方法

    // utils/des.js
    
    import cryptoJs from 'crypto-js';
    
    
    // 随机生成指定数量的16进制key(该方法非必须,也可直接指定固定key值)
    const generatekey = (num) => {
      let library = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
      let key = "";
      for (var i = 0; i < num; i++) {
        let randomPoz = Math.floor(Math.random() * library.length);
        key += library.substring(randomPoz, randomPoz + 1);
      }
      return key;
    }
    
    /*
    * message: 需要加解密的文本
      key: 加解密的秘钥
      iv: 偏移量,最短8位数,ecb模式不需要此参数
    */
    
    // 加密
    const encrypt =  (message, key = 'abcd@1234', iv = 'hello world') => {
      const keyHex = cryptoJs.enc.Utf8.parse(key); // 秘钥
      const ivHex = cryptoJs.enc.Utf8.parse(iv); // 偏移量
      const option = { iv: ivHex, mode: cryptoJs.mode.CBC, padding: cryptoJs.pad.Pkcs7 }; // Pkcs7填充方式
      const encrypted = cryptoJs.DES.encrypt(message, keyHex, option);
      return encrypted.ciphertext.toString() //  加密出来为 hex格式密文
    }
    
    // 解密
    const decrypt = (message, key = 'abcd@1234', iv = 'hello world') => {
      const keyHex = cryptoJs.enc.Utf8.parse(key)
      const ivHex = cryptoJs.enc.Utf8.parse(iv)
      const decrypted = cryptoJs.DES.decrypt({
        ciphertext: cryptoJs.enc.Hex.parse(message)
      }, keyHex, {
        iv: ivHex,
        mode: cryptoJs.mode.CBC,
        padding: cryptoJs.pad.Pkcs7
      })
      return decrypted.toString(cryptoJs.enc.Utf8)
    }
    
    export {
      generatekey,
      encrypt,
      decrypt,
    }
    

    2.2.2 引入使用

    <script>
    import { encrypt, decrypt, generatekey } from '@/utils/des.js'
    
    export default {
      data() {
        return {
          info:{
            userName:'test',
            passWord:'Hi@123'
          }
        };
      },
      methods: {
        test(){
          const key = generatekey(8); // 也可直接指定固定key值 let key = 'des';
          
          //如果是对象/数组的话,需要先JSON.stringify转换成字符串
          const encrypts = encrypt(JSON.stringify(this.info), key, '12345678');
          const dess = JSON.parse(decrypt(encrypts, key, '12345678'));
    
          console.log(encrypts, dess)
        }
      },
      mounted() {
        this.test();
      },
    };
    </script>
    
    展开全文
  • DES分组加密算法

    千次阅读 2019-03-17 13:10:10
    (1)混乱原则:使得密文和对应明文和密钥之间的关系足够复杂,以至于密码分析者无法利用这种关系。 (2)扩散原则:使得每一个明文bit和密钥bit影响尽可能多的密文bit,用来隐藏明文的统计特性和结构规律...

    一:分组加密算法

    1.1.概念

         分组密码是将明文数字序列按照固定长度分组,并且用同一个密钥和同一个加密算法逐组加密,从而将各个明文分组变换成为密文分组的密码。

    1.2.安全原则

    (1)混乱原则:使得密文和对应明文和密钥之间的关系足够复杂,以至于密码分析者无法利用这种关系。

    (2)扩散原则:使得每一个明文bit和密钥bit影响尽可能多的密文bit,用来隐藏明文的统计特性和结构规律。

    二:DES设计背景(百度百科)

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

    三:DES算法特点总结

    • DES为对称加密算法,使用同一个密钥来加密与解密
    • 要求手法双方在加密和解密前约定密钥
    • DES属于分组加密算法,该算法每次处理固定长度的数据段,称之为分组,其长度为分组长度
    • DES分组大小为64bit,若加密数据长度不足64bit ,可以按照某种具体的规则填充
    • DES采用56位密钥加密64位的明文数据块
    • 当n个64bit数据块都经过DES加密后,所得的n个64bit密文快,串在一起就是密文输出

    四:DES加密算法一般结构图

    备注:DES加密算法大致包含初始(终止)置换+扩展置换+S盒压缩三个部分,下面将从详细讲解这三个部分。

    4.1 初始置换和终止置换

    先看看一下初始置换过程图

    首先看一下初始置换表(8*8  64bit),第一位是58,,58表示输入的第58位换到第一位,第二位是50,50表示输入的第50位换到第二位,以此类推。原始数据经过初始置换表的置换,就会得到置换后的表格。

    终止置换和初始置换是互逆的过程,即经过一次初始置换和一次终止置换,64位的二进制数据会别还原。

    下面我们来做个例题巩固一下:

    题目:当输入一个十六进制数,写出其终止置换输出

    0x 0000 0080 0000 0002(十六进制)

    解答:

    先将输入的十六进制转化为二进制数及终止置换表如下图所示

    我们可以看到,输入表中第25位和第63位是1,其余为0,所以重点考虑这两个位置即可,看终止置换表 第一个数字40表示,输入的第40个二进制数换在第一个位置,同理,第15个数字是63表示输入的第63个二进制数换在第15个位置,第64个位置是25,表示第25个输入的二进制数换在第64个位置。则可以得到经终止置换表置换后的64位数据为

    转化为16进制为  0x 0002 0000 0000 0001 即为终止置换最后输出。

    4.2 扩展置换过程(E盒)

    经过初始置换的64bit数据分成两个部分,左侧32bit,右侧32bit 。其中一边32bit扩展为48bit数据,其实就是在某些位置添位操作。

    同初始(终止)置换表一样,扩展置换也有一个扩展置换表,首先看一下扩展置换表

    我们假设原始数据就是上面1101 0001 0011 0100 0010 0011 0011 1011的32bit数据,我们需要将其分为8组,每一组有4个元素,我们扩展就是将4个元素组扩展成为6个元素组,这样就完成了32到48位的转换。

    经过一下步骤:

    1. 旧组的第一位复制到前一个新组的最后一位
    2. 旧组的最后一位复制到下一个新组的第一位
    3. 最后复制每个组中间的4个元素到新的表里面

    这样就完成了从32bit到48bit的扩展置换过程。

    4.3 S盒压缩处理

    (1)经过扩展的48bit明文和48位密钥进行异或运算

    (2)再使用8个S盒压缩处理得到32位数据,实际上将48个输入分成了8块,每一块都有6位,我们需要将这6位压缩成4位即可,在具体的处理过程中使用的是8张4行16列的表来进行压缩

    例如:假设48位数据输入,分成8组,每组有6位

    111111  100101  110011  001100  011001  010111  111011  011000

    以第一组为例子 111111

    原始数据:111111

    1. 取头尾两个数据组成一个组得到一个新的二进制数 11 ,转化为十进制  3  ,即为行数
    2. 取中间4个数据组成一个组得到一个新的二进制数 1111 ,转化为十进制 15 ,即为列数
    3. 查表   第 3行第15列查找得到  13
    4. 再把该S盒压缩处理压缩数转换为二进制输出   13--->1101

    以上过程完成了从6位数据转化为4位数据的压缩,其他各组方法一致。

    4.4 P盒置换

    P盒置换是对S盒置换后的32bit数据的位置进行移动。

    原理同初始置换,经过这个P盒置换之后,就会得到一轮运算中的最后输出。

    撒花✿✿ヽ(°▽°)ノ✿!!!

     

     

    展开全文
  • DES

    2020-09-07 09:14:26
    明文和密文分组长度为64bit 算法包含两部分:迭代加解密秘钥编排 加密解密除密钥编排不同外,完全相同(Feistel结构) 密钥长度:56bit,每7bit后为奇偶校验位,共64bit 轮函数采用混乱扩散的组合,共16轮 ...

    DES算法的整体结构

    • 明文和密文分组长度为64bit
    • 算法包含两部分:迭代加解密和秘钥编排
    • 加密和解密除密钥编排不同外,完全相同(Feistel结构)
    • 密钥长度:56bit,每7bit后为奇偶校验位,共64bit
    • 轮函数采用混乱和扩散的组合,共16轮

    DES的加密阶段

    • 首先是一个初始置换IP,用于重排明文分组的64比特数据。
    • 然后是具有相同功能的16轮变换,每轮中都有置换和代换运算,第16轮变换的输出分为左右两半,并被交换次序。
    • 最后再经过一个逆初始置换IP-1(为IP的逆)从而产生64比特的密文。
      初始置换IP
      加密流程图
      在这里插入图片描述

    DES轮函数

    流程

    • E扩展:Ri-1根据扩展规则扩展为48比特长度的串
      在这里插入图片描述
    • S盒代换:使用8个S盒S1……S8. 每个Si是一个固定的4*16阶矩阵,其元素取0~15之间的整数.
      给定长度为6的比特串,如Bj=b1b2b3b4b5b6,Sj(Bj)计算如下:
      1) b1b6两个比特确定了Sj的行r的二进制表示 (0≤r≤3)
      2) b2b3b4b5四个比特确定了Sj的列c的二进制表示 (0≤c≤15)
      3) Sj(Bj)定义成长度为4的比特串的值Sj(r,c)
      在这里插入图片描述
    • P置换:长度为32比特串根据固定置换P进行置换
      在这里插入图片描述

    DES算法的密钥编排算法

    密钥编排流程

    • 给定64bit的密钥K,去掉奇偶校验位,根据固定的置换PC-1来处理K得到PC-1(K)=C0D0
      在这里插入图片描述
    • 计算Ci=LSi(Ci1)C_i=LS_i(C_{i-1})Di=LSi(Di1)D_i=LS_i(D_{i-1})LSiLS_i表示循环左移两个或者一个位置,具体地, 如果i=1,2,9,16就移一个位置,否则就移两个位置。
      在这里插入图片描述
    • Ki=PC2(CiDi)K_i=PC-2(C_iD_i)
      在这里插入图片描述

    最终代码如下

    # S盒 的置换矩阵
    S_MATRIX = [(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)]
    # P置换的置换矩阵
    P_MATRIX = [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]
    # IP置换的 置换矩阵
    IP_MATRIX = [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]
    
    # 压缩置换矩阵  从56位里选48位
    COMPRESS_MATRIXS = [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]
    # E扩展置换矩阵
    
    E_MATRIX = [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]
    # IP逆置换矩阵
    IP_INVERSE_MATRIX = [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]
    
    
    
    # IP置换
    def IP(Mingwen):
        #如果长度不是64 就退出
        assert len(Mingwen) == 64
    
        ret = ""
        #通过循环 进行IP置换
        for i in IP_MATRIX:
            ret = ret + Mingwen[i - 1]
        return ret
    
    
    # 循环左移位数
    def shift(str, shift_count):
        try:
            if len(str) > 28:
                raise NameError
        except TypeError:
            pass
    
        str = str[shift_count:] + str[0:shift_count]
        return str
    
    #由密钥 得到子密钥
    
    def createSubkey(key):
        # 如果key长度不是64 就退出
        assert len(key) == 64
    
        #DES的密钥由64位减至56位,每个字节的第8位作为奇偶校验位
        #把56位 变成 2个28位
    
        Llist = [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]
        Rlist = [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]
    
        # 初试生成 左右两组28位密钥
        L0 = ""
        R0 = ""
    
        for i in Llist:
            L0 += key[i - 1]
        for i in Rlist:
            R0 += key[i - 1]
    
        assert len(L0) == 28
        assert len(R0) == 28
    
        #轮函数生成 48位密钥
    
        #定义轮数
        Movetimes = [1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1]
        #定义返回的subKey
        retkey = []
        #开始轮置换
        for i in range(0, 16):
            #获取左半边 和 右半边  shift函数用来左移生成轮数
            L0 = shift(L0, Movetimes[i])
            R0 = shift(R0, Movetimes[i])
            #合并左右部分
            mergedKey = L0 + R0
    
            tempkey = ""
            # 压缩置换矩阵  从56位里选48位
            #选出48位子密钥
            for i in COMPRESS_MATRIXS:
                tempkey += mergedKey[i - 1]
            assert len(tempkey) == 48
            #加入生成子密钥
            retkey.append(tempkey)
    
        return retkey
    
    # E扩展置换  把右边32位扩展为48位
    def E_expend(Rn):
    
        retRn = ""
        for i in E_MATRIX:
            retRn += Rn[i - 1]
        assert len(retRn) == 48
        return retRn
    
    
    
    # S盒替代运算
    def S_sub(S_Input):
        #从第二位开始的子串  去掉0X
        S_Input = bin(S_Input)[2:]
    
        while len(S_Input) < 48:
            S_Input = "0" + S_Input
    
        index = 0
        retstr = ""
    
        for Slist in S_MATRIX:
            # 输入的高低两位做为行数row
            row = int(S_Input[index] + S_Input[index + 5], base=2)
            # 中间四位做为列数L
            col = int(S_Input[index + 1:index + 5], base=2)
            # 得到 result的 单个四位输出
            ret_single = bin(Slist[row * 16 + col])[2:]
    
            while len(ret_single) < 4:
                ret_single = "0" + ret_single
    
            # 合并单个输出
            retstr += ret_single
            # index + 6 进入下一个六位输入
            index += 6
    
        assert len(retstr) == 32
    
        return retstr
    
    
    def P(Ln, S_sub_str, oldRn):
        # P 盒置换
        tmp = ""
        for i in P_MATRIX:
            tmp += S_sub_str[i - 1]
        # P盒置换的结果与最初的64位分组左半部分L0异或
        LnNew = int(tmp, base=2) ^ int(Ln, base=2)
        LnNew = bin(LnNew)[2:]
        while len(LnNew) < 32:
            LnNew = "0" + LnNew
        assert len(LnNew) == 32
        # 左、右半部分交换,接着开始另一轮
        (Ln, Rn) = (oldRn, LnNew)
    
        return (Ln, Rn)
    
    def IP_inverse(L16, R16):
        tmp = L16 + R16
        retstr = ""
        for i in IP_INVERSE_MATRIX:
            retstr += tmp[i - 1]
        assert len(retstr) == 64
        return retstr
    
    
    # DES 算法实现 flag是标志位 当为-1时, 是DES解密, flag默认为0
    def DES (text, key, flag = "0"):
        # 初始字段
        # IP置换
        InitKeyCode = IP(text)
        # 产生子密钥 集合
        subkeylist = createSubkey(key)
        # 获得Ln 和 Rn
        Ln = InitKeyCode[0:32]
        Rn = InitKeyCode[32:]
    
        if (flag == "-1") :
            subkeylist = subkeylist[::-1]
    
    
        for subkey in subkeylist:
            while len(Rn) < 32:
                Rn = "0" + Rn
            while len(Ln) < 32:
                Ln = "0" + Ln
    
            # 对右边进行E-扩展
            Rn_expand = E_expend(Rn)
            # 压缩后的密钥与扩展分组异或以后得到48位的数据,将这个数据送入S盒
            S_Input = int(Rn_expand, base=2) ^ int(subkey, base=2)
    
            # 进行S盒替代
            S_sub_str = S_sub(S_Input)
    
            #P盒置换  并且
            #  左、右半部分交换,接着开始另一轮
            (Ln, Rn) = P(Ln, S_sub_str, Rn)
    
            #进行下一轮轮置换
    
        # 最后一轮之后  左、右两半部分并未进行交换
        # 而是两部分合并形成一个分组做为末置换的输入。
        # 所以要重新置换 一次
    
        (Ln, Rn) = (Rn, Ln)
        # 末置换得到密文
        re_text = IP_inverse(Ln, Rn)
    
        return re_text
    
    
    
    
    if __name__ == "__main__":
        key = "0001001000110100010101100111100010010001001000110100010101100111"
        Mingwen = "1001100001110110010101000011001000010001010001110010010110000011"
    
        #打印明文的16进制形式
        print("明文的16进制形式:         " + hex(int(Mingwen, base=2)).upper())
    
        ciphertext = DES(Mingwen, key)
    
        #打印加密后的密文
        print("加密后的密文:             " + hex(int(ciphertext, base=2)).upper())
    
        falseKey = "1001001000110100010101100111100010010001001000110100010101100110"
    
        decode_ciphertext = DES(ciphertext, key, "-1")
        #打印解密后的明文  看是否相同
        print("解密后的明文:             " + hex(int(decode_ciphertext, base=2)).upper())
    
        decode_ciphertext = DES(ciphertext, falseKey, "-1")
        # 打印给定错误的key 解密后的明文  看是否不同
        print("给定错误的key 解密后的明文:" + hex(int(decode_ciphertext, base=2)).upper())
    

    代码引自https://blog.csdn.net/qq874455953/article/details/83187145

    展开全文
  • des和3Des加密算法实现

    2011-04-24 15:57:53
    其密钥长度为56位,明文按64位进行分组,将分组后的明文56位的密钥按位替代或交换的方法形成密文组的加密方法。DES加密算法特点:分组比较短、密钥太短、密码生命周期短、运算速度较慢。DES工作的基本原理是,其...

    DES简介:

          DES算法为密码体制中的对称密码体制,又被成为美国数据加密标准,是1972年美国IBM公司研制的对称密码体制加密算法。其密钥长度为56位,明文按64位进行分组,将分组后的明文组和56位的密钥按位替代或交换的方法形成密文组的加密方法。DES加密算法特点:分组比较短、密钥太短、密码生命周期短、运算速度较慢。DES工作的基本原理是,其入口参数有三个:key、data、mode。 key为加密解密使用的密钥,data为加密解密的数据,mode为其工作模式。当模式为加密模式时,明文按照64位进行分组,形成明文组,key用于对数据加密,当模式为解密模式时,key用于对数据解密。实际运用中,密钥只用到了64位中的56位,这样才具有高的安全性。DES( Data Encryption Standard)算法,于1977年得到美国政府的正式许可,是一种用56位密钥来加密64位数据的方法。虽然56位密钥的DES算法已经风光不在,而且常有用Des加密的明文被破译的报道,但是了解一下昔日美国的标准加密算法总是有益的,而且目前DES算法得到了广泛的应用,在某些场合,仍然发挥着余热。

     

    DES加密算法代码如下:

     

     

    public class DesEncrypt { 
    /*static final是表示了只读,切能在同一个进程空间内的多个 
    Instance间共享*/ 
    //	private static String strDefaultKey = "87654321";
    public String digestHexStr; 
    //28
    static final int pc_1_cp[]={
    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};
    //28
    static final int pc_1_dp[]={
    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};
    //48
    static final int pc_2p[]={
    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};
    //16
    static final int ls_countp[]={1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1};
    //64
    static final int iip_tab_p[]={
    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};
    //64
    static final int _iip_tab_p[]={
    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};
    //48
    static final int e_r_p[]={
    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};
    //32
    static final int local_PP[]={
    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};
    //[8][4][16]
    static final int ccom_SSS_p[][][]={
    {{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}}, /* err on */
    
    {{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}, /* err on */
    {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}}};
    
    byte[][] C=new byte[17][28];
    byte[][] D=new byte[17][28];
    byte[][] K=new byte[17][48];
    public DesEncrypt() { 
    return; 
    } 
    /*iu2b把int转换成byte
    */ 
    private static byte iu2b ( int  input) { 
    byte output1;
    output1 = (byte)(input & 0xff); 
    return output1;
    } 
    
    /* 
    b2iu把byte按照不考虑正负号的原则的"升位"成int程序,
    因为java没有unsigned运算 
    */ 
    private static int b2iu(byte b) { 
    return b < 0 ? b & 0x7F + 128 : b; 
    } 
    
    /*byteHEX(),用来把一个byte类型的数转换成十六进制的ASCII表示, 
     因为java中的byte的toString无法实现这一点,我们又没有C语言中的 
    sprintf(outbuf,"%02X",ib) 
    */ 
    public static String byteHEX(byte ib) { 
    char[] Digit = { '0','1','2','3','4','5','6','7','8','9', 'A','B','C','D','E','F' }; 
    char[] ob = new char[2]; 
    ob[0] = Digit[(ib >>> 4) & 0X0F]; 
    ob[1] = Digit[ib & 0X0F]; 
    String s = new String(ob); 
    return s; 
    } 
    /* desMemcpy是一个内部使用的byte数组的块拷贝函数,
    从input的inpos开始把len长度的 
    字节拷贝到output的outpos位置开始  
    */ 
    private void desMemcpy (byte[] output, byte[] input, int outpos, int inpos, int len) { 
    int i; 
    for (i = 0; i < len; i++) 
    output[outpos + i] = input[inpos + i]; 
    } 
    private void Fexpand0(byte[] in,byte[] out) {
    int divide;
    int i,j;
    byte temp1;
    
    for (i=0;i<8;i++)
    {
    divide=7;
    for (j=0;j<8;j++)
    {
    temp1=in[i];
    out[8*i+j]=iu2b((b2iu(temp1)>>>divide)&1);
    divide--;
    }
    }
    }
    private void FLS(byte[] bits,byte[] buffer,int count) {
    int i,j;
    for (i=0;i<28;i++)
    {
    buffer[i]=bits[(i+count)%28];
    }
    }
    private void Fson(byte[] cc,byte[] dd,byte[] kk) {
    int i,j;
    byte[] buffer=new byte[56];
    for (i=0;i<28;i++)
    buffer[i]=cc[i];
    
    for (i=28;i<56;i++)
    buffer[i]=dd[i-28];
    
    for (i=0;i<48;i++)
    kk[i]=buffer[pc_2p[i]-1];
    }
    private void Fsetkeystar(byte[] bits) {
    int i,j;
    
    for (i=0;i<28;i++)
    C[0][i]=bits[pc_1_cp[i]-1];
    for (i=0;i<28;i++)
    D[0][i]=bits[pc_1_dp[i]-1];
    for (j=0;j<16;j++)
    {
    FLS(C[j],C[j+1],ls_countp[j]);
    FLS(D[j],D[j+1],ls_countp[j]);
    Fson(C[j+1],D[j+1],K[j+1]);
    }
    }
    private void Fiip(byte[] text,byte[] ll,byte[] rr) {
    int i,j;
    byte[] buffer=new byte[64];
    byte[] tmp=new byte[64];
    Fexpand0(text,buffer);
    
    for (i=0;i<32;i++)
    ll[i]=buffer[iip_tab_p[i]-1];
    
    for (i=0;i<32;i++)
    rr[i]=buffer[iip_tab_p[i+32]-1];
    }
    private void Fs_box(byte[] aa,byte[] bb) {
    int i,j,k,m;
    int y,z;
    byte[]  ss=new byte[8];
    m=0;
    for (i=0;i<8;i++)
    {
    j=6*i;
    y=b2iu(aa[j])*2+b2iu(aa[j+5]);
    z=b2iu(aa[j+1])*8+b2iu(aa[j+2])*4+b2iu(aa[j+3])*2+b2iu(aa[j+4]);
    ss[i]=iu2b(ccom_SSS_p[i][y][z]);
    y=3;
    for (k=0;k<4;k++)
    {
    bb[m++]=iu2b((b2iu(ss[i])>>>y)&1);
    y--;
    }
    
    }
    }
    private void FF(int n,byte[] ll,byte[] rr,byte[] LL,byte[] RR) {
    int i,j;
    byte[] buffer=new byte[64],tmp=new byte[64];
    for (i=0;i<48;i++)
    buffer[i]=rr[e_r_p[i]-1];
    for (i=0;i<48;i++)
    buffer[i]=iu2b((b2iu(buffer[i])+b2iu(K[n][i]))&1);
    
    Fs_box(buffer,tmp);
    
    for (i=0;i<32;i++)
    buffer[i]=tmp[local_PP[i]-1];
    
    for (i=0;i<32;i++)
    RR[i]=iu2b((b2iu(buffer[i])+b2iu(ll[i]))&1);
    
    for (i=0;i<32;i++)
    LL[i]=rr[i];
    }
    private void _Fiip(byte[] text,byte[] ll,byte[] rr) {
    int i,j;
    byte[] tmp=new byte[64];
    for (i=0;i<32;i++)
    tmp[i]=ll[i];
    for (i=32;i<64;i++)
    tmp[i]=rr[i-32];
    for (i=0;i<64;i++)
    text[i]=tmp[_iip_tab_p[i]-1];
    }
    private void Fcompress016(byte[] out,byte[] in) {
    int times;
    int i,j;
    
    for (i=0;i<16;i++)
    {
    times=3;
    in[i]='0';
    for (j=0;j<4;j++)
    {
    in[i]=iu2b(b2iu(in[i])+(b2iu(out[i*16+j])<<times));
    times--;
    }
    }
    }
    void Fcompress0(byte[] out,byte[] in) {
    int times;
    int i,j;
    
    for (i=0;i<8;i++)
    {
    times=7;
    in[i]=0;
    for (j=0;j<8;j++)
    {
    in[i]=iu2b(b2iu(in[i])+(b2iu(out[i*8+j])<<times));
    times--;
    }
    }
    }
    private void Fencrypt0(byte[] text,byte[] mtext) {
    byte[]  ll=new byte[64],rr=new byte[64],LL=new byte[64],RR=new byte[64];
    byte[]  tmp=new byte[64];
    int i,j;
    Fiip(text,ll,rr);
    
    for (i=1;i<17;i++)
    {
    FF(i,ll,rr,LL,RR);
    for (j=0;j<32;j++)
    {
    ll[j]=LL[j];
    rr[j]=RR[j];
    }
    }
    
    _Fiip(tmp,rr,ll);
    
    Fcompress0(tmp,mtext);
    }
    private void FDES(byte[] key,byte[] text,byte[] mtext) {
    byte[] tmp=new byte[64];
    Fexpand0(key,tmp);
    Fsetkeystar(tmp);
    Fencrypt0(text,mtext);
    }
    
    /*加密*/
    public int ENCRYPT(byte[] key, byte[] s,byte[] d,int  len ) {
    int i,j;
    byte[] cData=new byte[8];
    byte[] cEncryptData=new byte[8];
    for (i=0;i<len;i+=8) {
    if ((i+8)>len) {
    desMemcpy(cData,s,0,i,len-i);
    for (j = len-i; j < 8; j++) 
    cData[j] = 0; 
    } else
    desMemcpy(cData,s,0,i,8);
    FDES(key,cData,cEncryptData);
    desMemcpy(d,cEncryptData,i,0,8);
    
    }
    return i;
    }
    private void Fdiscrypt0(byte[] mtext,byte[] text) {
    byte[]  ll=new byte[64],rr=new byte[64],LL=new byte[64],RR=new byte[64];
    byte[]  tmp=new byte[64];
    int i,j;
    Fiip(mtext,ll,rr);
    
    for (i=16;i>0;i--)
    {
    FF(i,ll,rr,LL,RR);
    for (j=0;j<32;j++)
    {
    ll[j]=LL[j];
    rr[j]=RR[j];
    }
    }
    
    _Fiip(tmp,rr,ll);
    
    Fcompress0(tmp,text);
    }
    /*****************************************************************************
    * function:	DES
    * parameter:	u_char * key	; key for encrypt
    *	 u_char * mtext	; encipher data 
    *	 u_char * text	; plain data
    * return:	none
    *****************************************************************************/
    private void _FDES(byte[] key,byte[] mtext,byte[] text) {
    byte[] tmp=new byte[64];
    Fexpand0(key,tmp);
    Fsetkeystar(tmp);
    Fdiscrypt0(mtext,text);
    }
    /*解密*/
    public int DECRYPT(byte[] key, byte[] s,byte[] d,int  len ) {
    int i;
    byte[] cData=new byte[8];
    byte[] cEncryptData=new byte[8];
    for(i=0;i<len;i+=8) {
    desMemcpy(cEncryptData,d,0,i,8);
    _FDES(key,cEncryptData,cData);
    desMemcpy(s,cData,i,0,8);
    }
    return i;
    }
    public static byte[] hexStr2ByteArr(String strIn)  {
    byte[] arrB = strIn.getBytes();
    int iLen = arrB.length;
    
    //两个字符表示一个字节,所以字节数组长度是字符串长度除以2
    byte[] arrOut = new byte[iLen / 2];
    for (int i = 0; i < iLen; i = i + 2) {
    String strTmp = new String(arrB, i, 2);
    arrOut[i / 2] = (byte) Integer.parseInt(strTmp, 16);
    }
    return arrOut;
    }
    
    }
     

     

     

    3DES简介


    密码学中,3DES(或称为Triple DES)是三重数据加密算法(TDEA,Triple Data Encryption Algorithm)块密码的通称。它相当于是对每个数据块应用三次DES加密算法。由于计算机运算能力的增强,原版DES密码的密钥长度变得容易被暴力破解;3DES即是设计用来提供一种相对简单的方法,即通过增加DES的密钥长度来避免类似的攻击,而不是设计一种全新的块密码算法。

     

    3DES加密算法:
    package com.star.sms.business.provision.send.util.encrypt;
    import java.security.Key;
    import java.security.NoSuchAlgorithmException;
    import java.security.SecureRandom;
    import java.security.Security;
    import javax.crypto.Cipher;
    import javax.crypto.KeyGenerator;
    import javax.crypto.SecretKey;
    import javax.crypto.spec.SecretKeySpec;
    import com.sun.crypto.provider.SunJCE;
    /**
     * @author xuefc
     * @version 1.0
     */
    public class Des_3DesUtils {
    // ----------------------------3DES----------------------------
    /**
    * 生成3DES密钥.
    * 
    * @param key_byte
    *            seed key
    * @throws Exception
    * @return javax.crypto.SecretKey Generated DES key
    */
    public static SecretKey genTripleDesKey(byte[] byteKey) {
    if (byteKey == null) {
    return null;
    }
    return new SecretKeySpec(byteKey, "DESede");
    }
    public static SecretKey genTripleDesKey(String strKey) {
    if (strKey == null) {
    return null;
    }
    return genTripleDesKey(strKey.getBytes());
    }
    /**
    * 3DES 解密(byte[]).
    * 
    * @param key
    *            SecretKey
    * @param crypt
    *            byte[]
    * @throws Exception
    * @return byte[]
    */
    public static byte[] tripleDesDecrypt(SecretKey key, byte[] data) {
    try {
    Cipher cipher = Cipher.getInstance("DESede/ECB/NoPadding");
    cipher.init(Cipher.DECRYPT_MODE, key);
    return cipher.doFinal(data);
    } catch (Exception e) {
    throw new EncryptException(e);
    }
    }
    /**
    * 3DES 解密.
    * 因为3DES是对称加密算法,key是24位,当只有16位时,后8位取key的前8位
    * @param key
    *            SecretKey
    * @param crypt
    *            byte[]
    * @throws Exception
    * @return byte[]
    */
    public static byte[] tripleDesDecrypt(byte[] byteKey, byte[] data) {
    byte[] keys = null;
    if (byteKey.length == 16) {
    keys = new byte[24];
    System.arraycopy(byteKey, 0,keys , 0, 16);
    System.arraycopy(byteKey, 0,keys , 16, 8);
    } else {
    keys = byteKey;
    }
    return tripleDesDecrypt(genTripleDesKey(keys), data);
    }
    /**
    * 3DES加密(byte[]).
    * 
    * @param key
    *            SecretKey
    * @param src
    *            byte[]
    * @throws Exception
    * @return byte[]
    */
    public static byte[] tripleDesEncrypt(SecretKey key, byte[] data) {
    try {
    Cipher cipher = Cipher.getInstance("DESede/ECB/NoPadding");
    cipher.init(Cipher.ENCRYPT_MODE, key);
    return cipher.doFinal(data);
    } catch (Exception e) {
    throw new EncryptException(e);
    }
    }
    /**
    * 3DES加密(byte[]).
    * 因为3DES是对称加密算法,key是24位,当只有16位时,后8位取key的前8位
    * @param key
    *            SecretKey
    * @param src
    *            byte[]
    * @throws Exception
    * @return byte[]
    */
    public static byte[] tripleDesEncrypt(byte[] byteKey, byte[] data) {
    byte[] keys = null;
    if (byteKey.length == 16) {
    keys = new byte[24];
    System.arraycopy(byteKey, 0,keys , 0, 16);
    System.arraycopy(byteKey, 0,keys , 16, 8);
    } else {
    keys = byteKey;
    }
    return tripleDesEncrypt(genTripleDesKey(keys), data);
    }
    // ----------------------------DES----------------------------
    /**
    * 获得DES加密的密钥。需要JCE的支持,如果jdk版本低于1.4,则需要 安装jce-1_2_2才能正常使用。
    * 
    * @return Key 返回对称密钥
    * @throws java.security.NoSuchAlgorithmException
    * @see util.EncryptUtil 其中包括加密和解密的方法
    */
    public static Key getDesKey(byte[] key) {
    if (key == null) {
    return null;
    }
    try {
    Security.insertProviderAt(new SunJCE(), 1);
    KeyGenerator generator = KeyGenerator.getInstance("DES");
    generator.init(new SecureRandom(key));
    return generator.generateKey();
    } catch (NoSuchAlgorithmException e) {
    throw new EncryptException(e);
    }
    }
    public static Key getDesKey(String key) {
    if (key == null) {
    return null;
    }
    return getDesKey(key.getBytes());
    }
    /**
    * DES加密
    * 
    * @param key
    *            密钥
    * @param data
    *            需要加密的数据
    * @return byte[] 加密后的数据
    * @throws util.EncryptException
    */
    public static byte[] desEncrypt(byte[] byteKey, byte[] data) {
    // return desEncrypt(getDesKey(byteKey), data);
    try {
    byte[] encryptData = new byte[data.length];
    DesEncrypt de = new DesEncrypt();
    de.ENCRYPT(byteKey, data, encryptData, data.length);
    return encryptData;
    }
    catch (Exception e) {
    throw new EncryptException(e);
    }
    }
    /**
    * DES解密
    * 
    * @param key
    *            密钥
    * @param raw
    *            待解密的数据
    * @return byte[] 解密后的数据
    * @throws util.EncryptException
    */
    public static byte[] desDecrypt(byte[] byteKey, byte[] data) {
    //	 return desDecrypt(getDesKey(byteKey), data);
    try {
    byte[] plainData = new byte[data.length];
    DesEncrypt de = new DesEncrypt();
    de.DECRYPT(byteKey, plainData, data, data.length);
    return plainData;
    } 
    catch (Exception e) {
    throw new EncryptException(e);
    }
    }
    public static String getHexStr(byte[] data) {
    if (data == null) {
    return "";
    }
    StringBuffer str = new StringBuffer();
    for (byte b : data) {
    String temp = Integer.toHexString(b & 0xFF);
    //	 str.append("0x");
    if (temp.length() == 1) {
    str.append("0" + temp);
    } else {
    str.append(temp);
    }
    str.append(",");
    }
    return str.substring(0,str.length()-1).toString();
    }
    }
    class EncryptException extends RuntimeException {
    private static final long serialVersionUID = 1L;
    public EncryptException(String msg) {
    }
    public EncryptException(Throwable e) {
    super(e);
    }
    }
    
     
    展开全文
  • JAVA DES

    2013-01-31 16:43:27
    其密钥长度为56位,明文按64位进行分组,将分组后的明文56位的密钥按位替代或交换的方法形成密文组的加密方法。 DES加密算法特点:分组比较短、密钥太短、密码生命周期短、运算速度较慢。 DES工作的基本...
  • c# Des 加密解密算法

    千次阅读 2018-06-14 09:11:31
    private void desTest() { //明文 string val = "金衡电子科"; Console.WriteLine(val + ",长度:" + val.Length); //密文 string encrypt = DESHelper.DesEncr...
  • 对于DES,密钥长度为56位,双重DES的密钥长度为112位,加密解密过程如图 如果将这个加密过程简化一下,对所有的56位密钥,给定可能存在密钥使得。如果这个假设成立,那么不管用DES进行多少次加密运算,都是没有...
  • /// &lt;summary&gt; /// DES(56位) ... /// 其密钥长度为56位,明文按64位进行分组,将分组后的明文56位的密钥按位替代或交换的方法形成密文组的加密方法。 /// &lt;/summary&gt; ...
  • DES是以64比特的明文为一个单位来进行加密,并生成64比特的密文。由于它每次只能处理特定长度的一块数据,所以DES属于分组密码算法。cypto/des包提供了有关des加密的功能。 模式 由于分组密码算法只能加密固定长度...
  • 明文密文和密钥的分组长度都是64位。 DES算法是一种对称加密,通过同一组秘钥进行加密和解密。利用64位秘钥对64位数据进行加密生成一组新的64位数据,其中的转换都是利用统一的表格数组对秘钥和数据转换 ...
  • DES对称密码设计

    2021-04-22 18:00:27
    如果明文长度不足64位,则将其扩展为64位(如补零等方法)。   具体加密过程首先是将输入的数据进行初始换位(IP),即将明文M中数据的排列顺序按一定的规则重新排列,生成新的数据序列,以打乱原来的次序。然后将变换...
  • 明文密文,密钥的分组长度都是64位。 DES是面向二进制的密码算法。因而能够加解密任何形式的计算机数据。 DES是对合运算,因而加密解密共用同一算法,从而使工程实现的工作量减半 DES的密码结构属于Feistel结构 ...
  • DES算法C++程序设计实现

    千次阅读 2019-03-02 11:36:42
    Data Encryption Standard (DES) 是一种典型的对称密钥算法,采用块加密方法,它以64位为分组长度,64位一组的明文作为算法的输入,通过与密钥运算一系列复杂的操作,输出同样64位长度密文,用同一密钥可以解密...
  • 加密算法DES中加密模式ECBCBC的坑

    千次阅读 2018-05-18 13:18:41
    如果加密模式transformation是使用 “ DES / ECB / NOPadding “那么就得注意了:根据DES算法,可以得知,DES每次读取8个字节明文数据进行算法加密,然后再输入8个字节的密文,所以我们必须保证加密数据的长度是8...
  • DES加密算法

    2021-05-04 15:38:14
    DES加密算法 小伙伴约定一个密钥。 打开DES Tool,使用约定好的密钥对明文加密。 将密文发送给小伙伴,由小伙伴进行解密,读取明文信息。... 输入字符重复但长度不同的明文,观察加密结果,体会分组
  • DES加密

    2016-06-17 17:47:00
     DES的理论进化主线是 1945年Shannon大神提出的交替使用混淆(使密文与密钥的统计关系变复杂)扩散(使明文密文的统计关系变复杂)的乘积密码(DES加密的核心思想)-->1960s的Feistel结构-->DES。实践...
  • 图解DES加密算法

    2021-03-30 00:51:10
    分组加密:将明文分成固定长度的组,每一组都采用同一密钥算法进行加密,输出也是固定长度密文。 密钥:密钥是一种参数,它是在明文转换为密文或将密文转换为明文的算法中输入的参数。 DES加密算法导图 第一步...
  • 从网上下载的算法经常会同一组密匙和明文,加密后得到的密文却不相同,甚至连密文长度都不同。这其实并不是算法本身的问题,而是DES也存在不同的模式、配置。这里列举可以配对使用的C和C#的DES算法。希望对大家有所
  • DES加密算法原理简介

    2020-03-16 22:19:21
    一知半解,有误欢迎提醒。...DES的加密思想是对密钥和明文都进行一系列复杂变换处理,中间分为多个小段单独异或加密,最后再合成变换得到最终密文。符合所谓的混淆原则和扩散原则。 混淆原则:...
  • DES与3DES 加解密实例(c++)

    万次阅读 2017-11-18 00:38:44
    DES与3DES 加解密实例(c++)DES原理:DES...32、40、48、56、64位是校验位,使得每个密钥都有奇数个1),分组后的明文 56位的密钥按位替代或交换的方法形成密文组。 DES算法的主要流程如下图所示 。 1、 IP置
  • Java使用DES加密解密

    千次阅读 2020-03-12 09:17:09
    一、DES算法 DES(Data Encryption Standard):数据加密标准,它是由IBM公司研制的一种对称密码算法。...秘钥是一种参数(它是在明文转换为密文或将密文转换为明文的算法中输入的数据) 加密算法...
  • 分组密码之DES

    千次阅读 2019-01-11 20:20:31
    DES是一个分组密码算法,明文分组和密文分组长度均为64比特。 DES使用Feistel结果,具有加密相似特性,加解密算法相同,只是解密子密钥与加密子密钥的使用顺序相反。 DES由初始置换,16轮迭代,逆初始置换组成。 ...
  • 分组密码——DES

    2019-03-08 21:18:43
    明文密文和密钥的分组长度都是64位。 DES是面向二进制的密码算法。因而能加解密任何形式的计算机数据。 DES是对合运算,因而加解密共用同一算法,从而使工程实现的工作量减半。 DES的密码结构属于Feistal结构 ...
  • 初识3DES

    2016-09-22 09:50:18
    3DES是三重数据加密算法块密码的通称,它相当于是对每个数据块应用三次... 设Ek()Dk()代表DES算法的加密解密过程,K代表DES算法使用的密钥,M代表明文,C代表密文 这样:  3DES的加密过程为:  C=Ek3(Dk2(Ek1
  • DES原理及代码实现

    2020-04-19 11:37:17
    DES采取了分组加密算法:明文和密文为64位分组长度 DES采取了对称算法:加密解密除密钥编排不同外,使用同一算法 DES的安全性不依赖于算法的保密,安全性仅以加密密钥的保密为基础; 密钥可为任意的56位数,...
  • java DES 加密

    2011-11-03 17:18:38
    java DESjar包 + 源码 DES算法为密码体制中的对称密码体制,又被成为美国数据加密标准,是1972年...其密钥长度为56位,明文按64位进行分组,将分组后的明文56位的密钥按位替代或交换的方法形成密文组的加密方法。
  • 详细解析DES系列加密技术(一)

    千次阅读 2018-07-25 11:29:45
    一提到对称加密,大家首先想到的可能就是DES(Data Encryption Standard)技术了.DES技术是一种将64比特的明文加密成64比特的密文的对称密码算法,因此理论上来讲,他的密钥长度也是64位,但因为在DES的密钥中每隔7比特,就...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 151
精华内容 60
关键字:

des密文和明文长度