精华内容
下载资源
问答
  • DES算法Java实现源代码

    2019-04-08 17:36:47
    DES算法Java实现源代码;网络安全技术及应用;java图形界面实现
  • DES算法Java实现

    2018-01-17 09:45:05
    DES算法,可扩展成3DES算法,Java实现,Eclipse中可直接运行
  • JAVA实现3DES加密解密

    2019-04-07 01:23:28
    NULL 博文链接:https://ping2010.iteye.com/blog/1571517
  • DES数据加密算法,网络安全中较为基础的算法之一,用于学习交流使用
  • DESjava实现 因为是课程作业所以只是写的一个简单的 对string的 加解密
  • Desjava实现代码及原理

    2014-04-23 16:49:16
    Desjava实现代码及原理,过程详细易被理解,适合初学者参考
  • 3DES加密java实现

    热门讨论 2011-12-22 14:43:16
    java实现的3DES加密算法,类中支持多种密钥长度
  • 2011年本科课程设计的中用到的这个源码,用java实现了下,有兴趣的可以下载看看。
  • DES算法为密码体制中的对称密码体制,是一个分组加密算法,典型的DES以64位为分组对数据加密,加密和解密用的是同一个算法。 这里以Java代码实现DES算法。
  • java实现DES

    2017-02-25 18:57:03
    此文档内含有java实现DES加解密算法,自己写的,下载下来可以直接运行,不需更改任何内容。
  • Triple-DES java实现

    2011-05-24 09:55:10
    Triple-DES 加密解密算法的java实现
  • DES算法原理与Java实现

    万次阅读 多人点赞 2018-03-22 15:34:35
    在上一篇的文章中介绍了Feistel密码的原理与Java实现,这篇将带来DES算法的原理与Java实现,对于Java实现这里只给出一份代码(还有其他方式实现,主要是处理二进制位的方式不一样)。 概述 DES是一个分组加密...

    在上一篇的文章中介绍了Feistel密码的原理与Java实现,这篇将带来DES算法的原理与Java实现,对于Java实现这里只给出一份代码(还有其他方式实现,主要是处理二进制位的方式不一样)。

    概述

    DES是一个分组加密算法,它以64位为分组对数据加密。同时DES也是一个对称算法:加密和解密用的是同一个算法。DES是一个包含16个阶段的“替换–置换”的分组加密算法,64位的分组明文序列作为加密算法的输入,经过16轮加密得到64位的密文序列。
    理论的概述总是枯燥的,而且也不好描述,直接上图,算法原理看下图:
    DES算法原理图

    原理浅析

    DES算法主要分为3部分:加解密运算、f函数的处理、轮子密钥的生成,从右往左分别简单介绍一下。

    轮子密钥的生成

    数据表1

     //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};

    16个子密钥的生成主要是利用了数据表1中的数表,首先将64位的初始密钥利用PC1压缩置换位56位的密钥,然后将其一分为二,这里记为C0和D0。这里28位的C0和28位的D0分别根据LET数组相应位置的值进行左移位得到C1和D1。这是将C1和D1合并根据PC2进行压缩置换得到48位的子密钥,而且注意C1和D1作为下轮的输入以用来产生下一个子密钥。

    f函数的运算

    数据表2

    //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 = {//S-盒
                {// S_Box[1]
                        { 14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7 },
                        { 0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8 },
                        { 4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0 },
                        { 15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13 } },
                { // S_Box[2]
                        { 15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10 },
                        { 3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5 },
                        { 0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15 },
                        { 13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9 } },
                { // S_Box[3]
                        { 10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8 },
                        { 13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1 },
                        { 13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7 },
                        { 1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12 } },
                { // S_Box[4]
                        { 7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15 },
                        { 13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9 },
                        { 10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4 },
                        { 3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14 } },
                { // S_Box[5]
                        { 2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9 },
                        { 14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6 },
                        { 4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14 },
                        { 11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3 } },
                { // S_Box[6]
                        { 12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11 },
                        { 10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8 },
                        { 9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6 },
                        { 4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13 } },
                { // S_Box[7]
                        { 4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1 },
                        { 13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6 },
                        { 1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2 },
                        { 6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12 } },
                { // S_Box[8]
                        { 13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7 },
                        { 1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2 },
                        { 7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8 },
                        { 2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11 } }
        };

    从原理图中可以看到,f函数的输入是明文分组的右半分组记为R和子密钥记为K。32位的R首先要利用数据表2中的E进行E盒扩展变换得到48位的数据,这里记为RE。然后将RE与K进行异或运算并将异或结果利用数据表2中的S_BOX进行S盒替换,得到48位的运算结果记为RS。再将RS利用数据表2中的P进行P盒替换,得到32位的最终结果,记为RF。到这里f函数的运算任务就完成了。

    加解密运算
     //初始置换
        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};

    关于IP和IP-1 的置换运算就不说了,我只要说一下一轮的加密过程,在第一轮中将64位的明文分为L0和R0,则加密运算如下:

    L1=R0

    R1=L0⊕f(R0,K0)

    然后按此公式进行16轮的运算。

    代码实现

    package com.general.encryanddecode;
    
    import org.omg.PortableInterceptor.SYSTEM_EXCEPTION;
    
    import java.util.Arrays;
    
    /**
     * @author generalandroid
     *
     * 根据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="Android将军->GeneralAndroid->主博客地址:https://blog.csdn.net/android_jiangjun";
            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));
    
        }
        /***代码运行结果:
         * 
         原文:
         Android将军->GeneralAndroid->主博客地址:https://blog.csdn.net/android_jiangjun
         密文:
         ��Lm����=��� 4�zf4�����zj���}���~Dͪn�B��t���Du��U*e�VxC�̃Ynh\@NH ˙P�Ka�1y~4
         明文:
         Android将军->GeneralAndroid->主博客地址:https://blog.csdn.net/android_jiangjun
         *
         * **/
    
    
        /****拆分分组****/
        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;
            }
    
        }
    
    
    }
    

    总结

    关于DES算法原理要是想弄懂不是一篇文章就可以搞清楚的,首先你要去找一本书看下DES的介绍,然后弄懂每个步骤,然后写代码实现一个简单的DES算法。最后转载请注明出处:DES算法原理与Java 实现
    如果你对这块感兴趣可以关注我的密码学专栏:密码学,可以早一步看到我的更新。

    展开全文
  • 3des,全称为3DESede或TripleDES,中文解释为是三重数据加密,用户可以通过通过对DES算法进行改进,针对每个数据块进行三次DES加密,下面小编为你带来java实现3des加密解密教程!首先我们需要自行安装配置java环境,...

    3des,全称为3DESede或TripleDES,中文解释为是三重数据加密,用户可以通过通过对DES算法进行改进,针对每个数据块进行三次DES加密,下面小编为你带来java实现3des加密解密教程!

    首先我们需要自行安装配置java环境,并安装编写代码软件myeclipse2014。安装完成后,打开软件并点击导航处的File菜单,然后选择New,然后选择Java Project,进入创建java项目窗口。具体操作如下图所示。

    7e14008841f3c6e7426a5fbc559d990e.png

    然后在创建项目窗口,我们输入项目名称:3DESJDKUtil,然后选择JRE环境,本篇我们选择为JDK7,选择完毕后点击Finish,完成java项目的创建。具体操作如下图所示。

    60d60ab21766405fcbe6189fc84ce02a.png

    然后打开项目,在项目src上右击,选择New,然后选择Class,进入实体类创建窗口。具体操作如下图所示。

    980b2e16489dfa6b2108fe50051d884e.png

    在实体类创建窗口,首先我们填写包名称,包名称为:com.util,然后填写类名称,类名称为:ThreeDESUtil,然后勾选自动生成main方法。以上操作完毕后,我们点击Finish完成实体类的创建。具体操作如下图所示。

    0ce05426b6c1b92b8c46bea02bbb0b75.png

    由于本项目内会用到一其他方法,我们首先编写将byte数组转化为16进制字符串的方法,此方法主要便于查看加密后的结果信息。本篇中方法名称为:convertByteToHexString,需要传入参数为byte数组,返回为String类型,具体实现如下图所示。

    cbe95f9e45a5b536047b2b58e7ca66ba.png

    然后我们编写生成密钥的方法,3DES要求字节数组的密钥长度为24位,本篇中我们编写方法名称为:build3DesKey,传入参数为我们设定的密钥字符串,返回信息为长度为24为的字节数组。具体代码实现如下图所示。

    c97552609ff41a15505faa7caf76ff81.png

    然后我们编写加密方法,加密方法主要利用了Cipher类,本篇中方法名称为:ThreeDESEconde,返回结果为加密后的byte数组。具体代码实现如下图代码所示。

    c8aa74e4b4e139d3b56f4033d8fe422f.png

    然后我们编写解密方法,解密方法同加密方法一样同样使用了Cipher类。本篇中方法名称为:ThreeDESDecode,返回结果为解密后的byte数组。

    最后我们在主函数内,编写测试写好的加密/解密方法。我们首先定义原始消息为:hello 3des,定义密钥为:12312312312312312312312312312312。然后分别调用加密/解密方法。并且输出加密后以及解密后的结果信息。具体实现如下图所示。

    ca4a68f0f31ca18f604a7eca90e81780.png

    然后我们运行程度,可以看到原始消息经过加密解密后,仍还原为原始消息,至此3DES加密/解密基本教程完成。

    展开全文
  • des加密算法java实现

    2016-04-17 10:12:41
    DES加解密算法,java实现,可运行!
  • java实现3DES加密解密算法

    千次阅读 2019-10-24 20:56:37
    3DES加密也称三重加密,其底层加密...但是在3DES加密算法中,需要三个这样的密钥长度才能实现三重加密操作,所以3DES的密钥长度是56✖3=168,算上每个字节的奇偶校验位,则应该输入的密钥长度是168+24=192,即24个...

    3DES加密也称三重加密,其底层加密算法与DES相同,只不过它的密钥长度是168位。由于在DES加密算法中,64位密钥中每一个字节的第8位是奇偶校验位,所以每个字节中只有后7位起密钥作用,实际是56位密钥长度。但是在3DES加密算法中,需要三个这样的密钥长度才能实现三重加密操作,所以3DES的密钥长度是56✖3=168,算上每个字节的奇偶校验位,则应该输入的密钥长度是168+24=192,即24个字节长度的密钥。在java中实现3DES加密算法的加密关键词是:DESede。以下是在DES加密解密操作的基础上改进的3DES加密解密算法:

    import com.sun.org.apache.xerces.internal.impl.dv.util.Base64;
    import javax.crypto.BadPaddingException;
    import javax.crypto.Cipher;
    import javax.crypto.IllegalBlockSizeException;
    import javax.crypto.NoSuchPaddingException;
    import javax.crypto.spec.SecretKeySpec;
    import java.security.InvalidKeyException;
    import java.security.Key;
    import java.security.NoSuchAlgorithmException;
    import java.util.Scanner;
    
    public class TripleDES {
        private static final String Algorithm="DESede";
        public static void main(String[] args) throws Exception
        {
            System.out.println("请输入明文:");
            Scanner in=new Scanner(System.in);
            String clearText=in.nextLine();
            System.out.println("请输入24字节的密钥(每输入一个字符代表一个字节):");
            Scanner in1=new Scanner(System.in);
            String originKey=in1.nextLine();
            String cipherText = desEncript(clearText, originKey);
            System.out.println("通过3DES加密后的结果是:");
            System.out.println(cipherText);
            String clearText1=desDecript(cipherText,originKey);
            System.out.println("解密结果是:\n"+clearText1);
        }
        /**
         * 加密算法
         * @param clearText
         * @param originKey
         * @return
         * @throws NoSuchAlgorithmException
         * @throws NoSuchPaddingException
         * @throws InvalidKeyException
         * @throws BadPaddingException
         * @throws IllegalBlockSizeException
         */
        private static String desEncript(String clearText, String originKey) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException
        {
            Cipher cipher=Cipher.getInstance(Algorithm); /*提供加密的方式:DES*/
            SecretKeySpec key=getKey(originKey);  /*对密钥进行操作,产生16个48位长的子密钥*/
            cipher.init(Cipher.ENCRYPT_MODE,key); /*初始化cipher,选定模式,这里为加密模式,并同时传入密钥*/
            byte[] doFinal=cipher.doFinal(clearText.getBytes());   /*开始加密操作*/
            String encode= Base64.encode(doFinal);    /*对加密后的数据按照Base64进行编码*/
            return encode;
        }
        /**
         * 解密算法
         * @param cipherText
         * @param originKey
         * @return
         * @throws BadPaddingException
         * @throws IllegalBlockSizeException
         * @throws NoSuchPaddingException
         * @throws NoSuchAlgorithmException
         * @throws InvalidKeyException
         */
        private static String desDecript(String cipherText, String originKey) throws BadPaddingException, IllegalBlockSizeException, NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException
        {
            Cipher cipher=Cipher.getInstance(Algorithm);   /*初始化加密方式*/
            Key key=getKey(originKey);  /*获取密钥*/
            cipher.init(Cipher.DECRYPT_MODE,key);  /*初始化操作方式*/
            byte[] decode=Base64.decode(cipherText);  /*按照Base64解码*/
            byte[] doFinal=cipher.doFinal(decode);   /*执行解码操作*/
            return new String(doFinal);   /*转换成相应字符串并返回*/
        }
        /**
         * 获取密钥算法
         * @param originKey
         * @return
         */
        private static SecretKeySpec getKey(String originKey)
        {
            byte[] buffer=new byte[24];
            byte[] originBytes=originKey.getBytes();
            /**
             * 防止输入的密钥长度超过192位
             */
            for(int i=0;i<24&&i<originBytes.length;i++)
            {
                buffer[i]=originBytes[i];  /*如果originBytes不足8,buffer剩余的补零*/
            }
            SecretKeySpec key=new SecretKeySpec(buffer,Algorithm); /*第一个参数是密钥字节数组,第二个参数是加密方式*/
            return key;  /*返回操作之后得到的密钥*/
        }
    }
    
    
    

    程序运行结果如下:
    在这里插入图片描述

    展开全文
  • 主要介绍了Java实现的3des加密解密工具类,结合完整实例形式分析了3des加密解密的具体步骤与相关操作技巧,需要的朋友可以参考下
  • 此资源为des算法加解密的java完美实现,可导入环境直接运行。适合初学者对于des加密的学习和理解。资源分享出来,赚赚积分!感谢大家
  • 3DES加解密java实现

    千次阅读 2018-02-01 17:00:02
    最近做手机银行需要加密一些东西,需要用到3DES加密,简单的了解了一下。 涉及的几个概念 原文:需要加密的内容,加密时需要转换成字符数组 密文:加密后的内容,3DES加密后产生的是每8位一个单元的二进制字符...

    最近做手机银行需要加密一些东西,需要用到3DES加密,简单的了解了一下。

    涉及的几个概念
    原文:需要加密的内容,加密时需要转换成字符数组
    密文:加密后的内容,3DES加密后产生的是每8位一个单元的二进制字符数组
    加密算法:加密时使用的算法,3DES加密使用的是DESede算法
    加密秘钥:长度为24字节的字符数组,是否保密就看秘钥保存的是否隐蔽

    前准备:
    3DES加密秘钥如果不是24位会报异常,为了解决这个问题,统一一下秘钥长度

    /*
         * 根据 密钥字符串生成密钥字节数组
         * 
         * @param keyStr 密钥字符串
         * 
         * @return
         * 
         * @throws UnsupportedEncodingException
         */
        public static byte[] build3DesKey(String keyStr) throws UnsupportedEncodingException {
            byte[] key = new byte[24]; // 声明一个24位的字节数组,默认里面都是0
            byte[] temp = keyStr.getBytes("UTF-8"); // 将字符串转成字节数组
    
            /*
             * 执行数组拷贝 System.arraycopy(源数组,从源数组哪里开始拷贝,目标数组,拷贝多少位)
             */
            if (key.length > temp.length) {
                // 如果temp不够24位,则拷贝temp数组整个长度的内容到key数组中
                System.arraycopy(temp, 0, key, 0, temp.length);
            } else {
                // 如果temp大于24位,则拷贝temp数组24个长度的内容到key数组中
                System.arraycopy(temp, 0, key, 0, key.length);
            }
            return key;
        }

    加密

    /**
         * 加密方法
         * 
         * @param originalText 
         *            源数据的字节数组
         * @return
         */
        public static byte[] encryptMode(byte[] originalText) {
            try {
                SecretKey deskey = new SecretKeySpec(build3DesKey(PASSWORD_CRYPT_KEY), Algorithm); // 生成密钥
                Cipher cipher = Cipher.getInstance(Algorithm); // 实例化负责加密/解密的Cipher工具类
                cipher.init(Cipher.ENCRYPT_MODE, deskey); // 初始化为加密模式
                return cipher.doFinal(originalText);
            } catch (java.security.NoSuchAlgorithmException e1) {
                e1.printStackTrace();
            } catch (javax.crypto.NoSuchPaddingException e2) {
                e2.printStackTrace();
            } catch (java.lang.Exception e3) {
                e3.printStackTrace();
            }
            return null;
        }

    解密:

    /**
         * 解密函数
         * 
         * @param cipherText
         *            密文的字节数组
         * @return
         */
        public static byte[] decryptMode(byte[] cipherText) {
            try {
                SecretKey deskey = new SecretKeySpec(build3DesKey(PASSWORD_CRYPT_KEY), Algorithm);
                Cipher cipher = Cipher.getInstance(Algorithm);
                cipher.init(Cipher.DECRYPT_MODE, deskey); // 初始化为解密模式
                return cipher.doFinal(cipherText);
            } catch (java.security.NoSuchAlgorithmException e1) {
                e1.printStackTrace();
            } catch (javax.crypto.NoSuchPaddingException e2) {
                e2.printStackTrace();
            } catch (java.lang.Exception e3) {
                e3.printStackTrace();
            }
            return null;
        }

    定义一下加密算法和加解密秘钥

    // 定义加密算法DESede(即3DES)
        private static final String Algorithm = "DESede";
        //秘钥【这样写在这里是没有任何意义的,应该在某个配置文件里或者其他系统传送过来】
        private static final String PASSWORD_CRYPT_KEY = "PASSWORD_KEY";

    测试

    public static void main(String[] args) {
            String msg = "1213456789";
            System.out.println("【加密前】:" + msg);
    
            // 加密
            byte[] secretArr = Des3Util.encryptMode(msg.getBytes());
    
    
            System.out.println(new String (secretArr));
    
            // 解密
            byte[] myMsgArr = Des3Util.decryptMode(secretArr);
            System.out.println("【解密后】:" + new String(myMsgArr));
        }

    结果:这里写图片描述

    密文看不懂(没必要看懂,本来就不是给你看的),想看就转换一下,转成16进制的

      public static String byte2Hex(byte[] b){                    
          String hs="";                                           
          String stmp="";                                         
          for(int n=0; n<b.length; n++){                          
              stmp = (java.lang.Integer.toHexString(b[n]& 0XFF)); 
              if(stmp.length()==1){                               
                  hs = hs + "0" + stmp;                           
              }else{                                              
                  hs = hs + stmp;                                 
              }                                                   
              if(n<b.length-1);                                   
          }                                                       
          return hs.toUpperCase();                                
    
      }                                                           

    再看结果:

    这里写图片描述

    完整代码:

    package com.adetc.utils;
    
    import java.io.UnsupportedEncodingException;
    
    import javax.crypto.Cipher;
    import javax.crypto.SecretKey;
    import javax.crypto.spec.SecretKeySpec;
    
    public class Des3Util {
    
        // 定义加密算法DESede(即3DES)
        private static final String Algorithm = "DESede";
        //秘钥【这样写在这里是没有任何意义的,应该在某个配置文件里或者其他系统传送过来】
        private static final String PASSWORD_CRYPT_KEY = "PASSWORD_KEY";
    
        /**
         * 加密方法
         * 
         * @param originalText 
         *            源数据的字节数组
         * @return
         */
        public static byte[] encryptMode(byte[] originalText) {
            try {
                SecretKey deskey = new SecretKeySpec(build3DesKey(PASSWORD_CRYPT_KEY), Algorithm); // 生成密钥
                Cipher cipher = Cipher.getInstance(Algorithm); // 实例化负责加密/解密的Cipher工具类
                cipher.init(Cipher.ENCRYPT_MODE, deskey); // 初始化为加密模式
                return cipher.doFinal(originalText);
            } catch (java.security.NoSuchAlgorithmException e1) {
                e1.printStackTrace();
            } catch (javax.crypto.NoSuchPaddingException e2) {
                e2.printStackTrace();
            } catch (java.lang.Exception e3) {
                e3.printStackTrace();
            }
            return null;
        }
    
        /**
         * 解密函数
         * 
         * @param cipherText
         *            密文的字节数组
         * @return
         */
        public static byte[] decryptMode(byte[] cipherText) {
            try {
                SecretKey deskey = new SecretKeySpec(build3DesKey(PASSWORD_CRYPT_KEY), Algorithm);
                Cipher cipher = Cipher.getInstance(Algorithm);
                cipher.init(Cipher.DECRYPT_MODE, deskey); // 初始化为解密模式
                return cipher.doFinal(cipherText);
            } catch (java.security.NoSuchAlgorithmException e1) {
                e1.printStackTrace();
            } catch (javax.crypto.NoSuchPaddingException e2) {
                e2.printStackTrace();
            } catch (java.lang.Exception e3) {
                e3.printStackTrace();
            }
            return null;
        }
    
        /*
         * 根据 密钥字符串生成密钥字节数组
         * 
         * @param keyStr 密钥字符串
         * 
         * @return
         * 
         * @throws UnsupportedEncodingException
         */
        public static byte[] build3DesKey(String keyStr) throws UnsupportedEncodingException {
            byte[] key = new byte[24]; // 声明一个24位的字节数组,默认里面都是0
            byte[] temp = keyStr.getBytes("UTF-8"); // 将字符串转成字节数组
    
            /*
             * 执行数组拷贝 System.arraycopy(源数组,从源数组哪里开始拷贝,目标数组,拷贝多少位)
             */
            if (key.length > temp.length) {
                // 如果temp不够24位,则拷贝temp数组整个长度的内容到key数组中
                System.arraycopy(temp, 0, key, 0, temp.length);
            } else {
                // 如果temp大于24位,则拷贝temp数组24个长度的内容到key数组中
                System.arraycopy(temp, 0, key, 0, key.length);
            }
            return key;
        }
    
        //转换成十六进制字符串  
        public static String byte2Hex(byte[] b){  
            String hs="";  
            String stmp="";  
            for(int n=0; n<b.length; n++){  
                stmp = (java.lang.Integer.toHexString(b[n]& 0XFF));  
                if(stmp.length()==1){  
                    hs = hs + "0" + stmp;                 
                }else{  
                    hs = hs + stmp;  
                }  
                if(n<b.length-1);  
            }  
            return hs.toUpperCase();   
    
        }  
        public static void main(String[] args) {
            String msg = "1213456789";
            System.out.println("【加密前】:" + msg);
    
            // 加密
            byte[] secretArr = Des3Util.encryptMode(msg.getBytes());
            String str = byte2Hex(secretArr);
            System.out.println("【加密后】:" + str);
            //System.out.println(new String (secretArr));
    
            // 解密
            byte[] myMsgArr = Des3Util.decryptMode(secretArr);
            System.out.println("【解密后】:" + new String(myMsgArr));
        }
    }
    展开全文
  • 使用Java实现3DES加密解密

    千次阅读 2019-07-10 23:14:03
    它相当于是对每个数据块应用三次DES加密算法。密钥长度是128位(bit)和192位(bit)。原版DES容易被破解,新的3DES出现,增加了加密安全性,避免被暴力破解。它同样是对称性加密,同样涉及到加密模式和填充方式。加密...
  • 使用java实现DES算法加密,带有界面。DES加密算法JAVA实现(带简单界面)
  • 主要介绍了java实现DES加密算法,结合实例形式详细分析了java实现DES加密操作的原理、实现技巧与相关注意事项,需要的朋友可以参考下
  • DES 有界面,用JAVA实现,是我做的密码学课程设计。
  • DES算法java实现代码

    2013-05-08 14:22:40
    本资源为DES算法java实现代码 数据加密算法(Data Encryption Algorithm,DEA)是一种对称加密算法,很可能是使用最广泛的密钥系统,特别是在保护金融数据的安全中,最初开发的DEA是嵌入硬件中的。通常,自动取款机...
  • DES密码算法Java实现 有简单的界面使用彭长根老师的现代密码学趣味之旅
  • DES算法实现Java

    2017-05-01 23:46:57
    密码学基础之DES算法的详细过程 体会加密算法的置乱和混沌
  • 虽然如此,在某些简单应用中,我们还是可以使用DES加密算法,本文简单讲解DESJAVA实现JAVA实现加密代码有详细解释,不多废话。注意:DES加密和解密过程中,密钥长度都必须是8的倍数 代码如下: public byte[] ...
  • javaDES算法实现,可以加密文字以及图片,引用java加密的包
  • DES加密算法的JAVA实现

    2019-12-27 18:24:17
    运行环境:Windows + eclipse + JAVA DES算法把64位的明文输入块变为64位的密文输出块,它所使用的密钥也是64位(实际用到了56位,第8、16、24、32、40、48、56、64位是校验位, 使得每个密钥都有奇数个1)
  • DES具体算法过程自己去查吧,这里只上代码。直接将DES封装为一个类(定义在名为DES的包下面,实际运行时注意改成自己的包名) package DES; public class DES { private byte[] key=null; private byte[][] ikey...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 25,040
精华内容 10,016
关键字:

desjava实现

java 订阅
友情链接: calendar.rar