精华内容
下载资源
问答
  • desjava实现
    2021-01-26 11:34:40

    该文章包含3DES和DES加密解密示例

    注意3DES密钥长度必须是8的倍数,而DES密钥长度必须是8字节

    下面是使用3DES加密解密的过程示例

    import java.util.Base64;
    import  javax.crypto.Cipher;  
    import  javax.crypto.SecretKey;
    import javax.crypto.SecretKeyFactory;
    import javax.crypto.spec.DESKeySpec; 
    /**
     * @author token AES算法
     * @date 2021年1月26日
     */
    public class Encryp3DES {
    	// 密钥(3DES加密和解密过程中,密钥长度都必须是8的倍数)
        private final static String secretKey = "zdy12345";
        // 加解密统一使用的编码方式
        private final static String encoding = "utf-8";
        public static void main(String[] args) throws Exception {
        	String input="巅峰小苏";
        	String en=encode(input);
        	System.out.println("加密:"+en);
        	String de=decode(en);
        	System.out.println("解密:"+de);
    	}
        /**
         * 3DES加密
         * @param plainText 普通文本
         * @return
         * @throws Exception
         */
        public static String encode(String plainText) throws Exception {
            // 从原始密钥数据创建DESKeySpec对象
            DESKeySpec dks = new DESKeySpec(secretKey.getBytes());
            // 创建一个密匙工厂,然后用它把DESKeySpec转换成
            // 一个SecretKey对象
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");//DES加密和解密过程中,密钥长度都必须是8的倍数
            SecretKey secretKey = keyFactory.generateSecret(dks);
            // using DES in ECB mode
            Cipher cipher = Cipher.getInstance("DES/ECB/pkcs5padding");
            // 用密匙初始化Cipher对象
            //cipher.init(Cipher.ENCRYPT_MODE, secretKey, sr);
            cipher.init(Cipher.ENCRYPT_MODE, secretKey);
            // 执行加密操作
            byte[] encryptData = cipher.doFinal(plainText.getBytes(encoding));
            return Base64.getEncoder().encodeToString(encryptData);
        }
        /**
         * 3DES解密
         * @param encryptText 加密文本
         * @return
         * @throws Exception
         */
        public static String decode(String encryptText) throws Exception {
            // DES算法要求有一个可信任的随机数源
            //SecureRandom sr = new SecureRandom();
            // 从原始密匙数据创建一个DESKeySpec对象
            DESKeySpec dks = new DESKeySpec(secretKey.getBytes());
            // 创建一个密匙工厂,然后用它把DESKeySpec对象转换成
            // 一个SecretKey对象
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
            SecretKey secretKey = keyFactory.generateSecret(dks);
            // using DES in ECB mode
            Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
            // 用密匙初始化Cipher对象
            cipher.init(Cipher.DECRYPT_MODE, secretKey);
            // 正式执行解密操作
            byte[] decryptData = cipher.doFinal(Base64.getDecoder().decode(encryptText));
            return new String(decryptData, encoding);
        }
    }
    

    下面是使用DES加密解密的过程示例

    import javax.crypto.Cipher;
    import javax.crypto.spec.SecretKeySpec;
    import org.apache.commons.codec.binary.Base64;
    public class DES {
    	public static void main(String[] args)throws Exception {
    		String input="巅峰小苏";//明文
    		String key="zdy12345";//密钥
    		String transformation="DES";//算法
    		String algorithm="DES";//加密类型
    		String encode=encryptDES(input, key, transformation, algorithm);
    		System.out.println("加密:"+encode);
    		String ret=decryptDES(encode, key, transformation, algorithm);
    		System.out.println("解密:"+ret);
    	}
    	/**
    	 * 加密
    	 * @param input 原文
    	 * @param key 密钥
    	 * @param transformation 算法
    	 * @param algorithm 加密类型
    	 * @return
    	 * @throws Exception
    	 */
    	private static String encryptDES(String input,String key,String transformation,String algorithm)throws Exception {
    		//创建加密对象
    		Cipher cipher=Cipher.getInstance(transformation);
    		//创建加密规则
    		SecretKeySpec secretKeySpec=new SecretKeySpec(key.getBytes(), algorithm);
    		//第一个参数是加密模式,解密模式
    		//第二个参数表示加密规则
    		cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);
    		//调用加密方法,参数表示原文的字节数组
    		byte[] bytes=cipher.doFinal(input.getBytes());
    		//字节数组转换成base64编码
    		String encode=Base64.encodeBase64String(bytes);
    		return encode;
    	}
    	/**
    	 * 解密
    	 * @param encryptDES 密文
    	 * @param key
    	 * @param transformation
    	 * @param algorithm
    	 * @return
    	 * @throws Exception
    	 */
    	private static String decryptDES(String encryptDES,String key,String transformation,String algorithm)throws Exception {
    		Cipher cipher=Cipher.getInstance(transformation);
    		SecretKeySpec secretKeySpec=new SecretKeySpec(key.getBytes(),algorithm);
    		//Cipher.DECRYPT_MODE表示解密
    		cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);
    		byte[] bytes=cipher.doFinal(Base64.decodeBase64(encryptDES));
    		return new String(bytes);
    	}
    }
    

    欢迎大家阅读,本人见识有限,写的博客难免有错误或者疏忽的地方,还望各位大佬指点,在此表示感谢。如果觉得本文章有帮助到的,点个赞呗,让更多的阅读者看到

    更多相关内容
  • 这是一个用Java实现DES高级加密算法的源代码
  • DESjava实现 因为是课程作业所以只是写的一个简单的 对string的 加解密
  • DES算法Java实现

    2018-01-17 09:45:05
    DES算法,可扩展成3DES算法,Java实现,Eclipse中可直接运行
  • Java实现Des加密(不用加载包),有完整S盒子。 部分代码如下: ackage desJava; import java.util.*; public class Des { byte[] bytekey; public Des(String strKey) { this.bytekey = strKey.getBytes();...
  • 2011年本科课程设计的中用到的这个源码,用java实现了下,有兴趣的可以下载看看。
  • DES算法Java实现(完善版)

    千次阅读 2022-02-24 09:35:33
    实现了小于8 bytes的密钥都可以进行测试,原理其实很简单,只需要在密钥生成的时候对密钥的长度进行判断,不够的进行补0操作。 //密钥生成 public StringBuffer[] getSubkey() { StringBuffer keyBinary = new ...

    一、密钥长度处理

    实现了小于8 bytes的密钥都可以进行测试,原理其实很简单,只需要在密钥生成的时候对密钥的长度进行判断,不够的进行补0操作。

    //密钥生成
        public StringBuffer[] getSubkey() {
            StringBuffer keyBinary = new StringBuffer(stringBufferToBinary(key)); //把密钥转成二进制
            StringBuffer subkey[] = new StringBuffer[16];  //subkey数组用来存储子密钥
            StringBuffer C0 = new StringBuffer(); //左密钥
            StringBuffer D0 = new StringBuffer(); //右密钥
            //判断密钥长度
            while (keyBinary.length() < 64) {
                keyBinary.append("0");
            }
            //PC1置换(64 bits --> 56 bits)
            for (int i = 0; i < 28; i++) {
                C0.append(keyBinary.charAt(PC1[i] - 1));
                D0.append(keyBinary.charAt(PC1[i + 28] - 1));
            }
            //16轮循环生成子密钥
            //16轮移位操作,每轮左移一位,特殊情况左移两位(查看密钥移位表)
            for (int i = 0; i < 16; i++) {
                //把第一位删了添加到最后一位
                char tmp;
                tmp = C0.charAt(0);
                C0.deleteCharAt(0);
                C0.append(tmp);
                tmp = D0.charAt(0);
                D0.deleteCharAt(0);
                D0.append(tmp);
                //特殊位置左移两位
                if (i != 0 && i != 1 && i != 8 && i != 15) {
                    tmp = C0.charAt(0);
                    C0.deleteCharAt(0);
                    C0.append(tmp);
                    tmp = D0.charAt(0);
                    D0.deleteCharAt(0);
                    D0.append(tmp);
                }
                //左右合并
                StringBuffer CODO = new StringBuffer(C0.toString() + D0.toString());
                //PC2置换
                StringBuffer C0D0tmp = new StringBuffer();
                for (int j = 0; j < 48; j++) {
                    C0D0tmp.append(CODO.charAt(PC2[j] - 1));
                }
                subkey[i] = C0D0tmp;
                //  System.out.println(i + "轮密钥:" + subkey[i]);
            }
            return subkey;
        }

    二、分组加密 

    实现了对任意长度的明文进行加密,实现这个功能需要引入一个分组数变量,用来记录分几组。

    整个源代码如下:

    package DES;
    
    import java.util.Scanner;
    
    public class Demo {
        private StringBuffer plaintext;  //明文字符串64 bits----8 bytes
        private StringBuffer ciphertext;  //密文字符串64 bits----8 bytes
        private StringBuffer key;  //密钥字符串64 bits ----8 bytes
        private int group;  //分组
    
        public int getGroup() {
            return group;
        }
    
        //设置分组数
        public void setGroup() {
            group = plaintext.length() / 8;
        }
    
        public StringBuffer getPlaintext() {
            return plaintext;
        }
    
        public void setPlaintext(StringBuffer plaintext) {
            this.plaintext = plaintext;
        }
    
        public StringBuffer getCiphertext() {
            return ciphertext;
        }
    
        public void setCiphertext(StringBuffer ciphertext) {
            this.ciphertext = ciphertext;
        }
    
        public StringBuffer getKey() {
            return key;
        }
    
        public void setKey(StringBuffer key) {
            this.key = key;
        }
    
        //IP置换
        private static final 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
        };
        //IP逆置换
        private static final int[] IPReverse = {
                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 static final 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 static final 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};
        //PC1
        private static final 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};
        // PC2
        private static final 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};
        // SBox
        private static final int[][] SBox = {
                // S1
                {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},
                // S2
                {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},
                // S3
                {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},
                // S4
                {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},
                // S5
                {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},
                // S6
                {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},
                // S7
                {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},
                // S8
                {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}};
    
        //StringBuffer转成二进制
        public StringBuffer stringBufferToBinary(StringBuffer s) {
            StringBuffer res = new StringBuffer();
            StringBuffer stmp = new StringBuffer();
            for (int i = 0; i < s.length(); i++) {
                stmp = new StringBuffer(Integer.toBinaryString(s.charAt(i)));
                while (stmp.length() < 8) {  //转成8位二进制
                    stmp.insert(0, 0);
                }
                //System.out.println(stmp);
                res.append(stmp);
            }
            return res;
        }
    
        //二进制字符串转成字符64->8
        //int column = Integer.parseInt(Sinput.substring(1, 5), 2);
        public StringBuffer BinaryTostringBuffer(StringBuffer s) {
            StringBuffer res = new StringBuffer();
            for (int i = 0; i < 8; i++) {
                int t = Integer.parseInt(s.substring(i * 8, (i + 1) * 8), 2);
                res.append((char) t);
            }
            return res;
        }
    
        //初始置换IP
        public StringBuffer Initial(StringBuffer r) {
            StringBuffer res = new StringBuffer();
            for (int i = 0; i < 64; i++) {
                res.append(r.charAt(IP[i] - 1)); //数组的索引是从0开始的
            }
            return res;
        }
    
        //终止置换IP
        public StringBuffer Final(StringBuffer r) {
            StringBuffer res = new StringBuffer();
            for (int i = 0; i < 64; i++) {
                res.append(r.charAt(IPReverse[i] - 1)); //数组的索引是从0开始的
            }
            return res;
        }
    
        //P置换
        public StringBuffer P(StringBuffer r) {
            StringBuffer res = new StringBuffer();
            for (int i = 0; i < 32; i++) {
                res.append(r.charAt(P[i] - 1)); //数组的索引是从0开始的
            }
            return res;
        }
    
        //扩展置换(E表)
        public StringBuffer Extent(StringBuffer r) {
            StringBuffer res = new StringBuffer();
            for (int i = 0; i < 48; i++) {
                res.append(r.charAt(E[i] - 1)); //数组的索引是从0开始的
            }
            return res;
        }
    
        //密钥生成
        public StringBuffer[] getSubkey() {
            StringBuffer keyBinary = new StringBuffer(stringBufferToBinary(key)); //把密钥转成二进制
            StringBuffer subkey[] = new StringBuffer[16];  //subkey数组用来存储子密钥
            StringBuffer C0 = new StringBuffer(); //左密钥
            StringBuffer D0 = new StringBuffer(); //右密钥
            //判断密钥长度
            while (keyBinary.length() < 64) {
                keyBinary.append("0");
            }
            //PC1置换(64 bits --> 56 bits)
            for (int i = 0; i < 28; i++) {
                C0.append(keyBinary.charAt(PC1[i] - 1));
                D0.append(keyBinary.charAt(PC1[i + 28] - 1));
            }
            //16轮循环生成子密钥
            //16轮移位操作,每轮左移一位,特殊情况左移两位(查看密钥移位表)
            for (int i = 0; i < 16; i++) {
                //把第一位删了添加到最后一位
                char tmp;
                tmp = C0.charAt(0);
                C0.deleteCharAt(0);
                C0.append(tmp);
                tmp = D0.charAt(0);
                D0.deleteCharAt(0);
                D0.append(tmp);
                //特殊位置左移两位
                if (i != 0 && i != 1 && i != 8 && i != 15) {
                    tmp = C0.charAt(0);
                    C0.deleteCharAt(0);
                    C0.append(tmp);
                    tmp = D0.charAt(0);
                    D0.deleteCharAt(0);
                    D0.append(tmp);
                }
                //左右合并
                StringBuffer CODO = new StringBuffer(C0.toString() + D0.toString());
                //PC2置换
                StringBuffer C0D0tmp = new StringBuffer();
                for (int j = 0; j < 48; j++) {
                    C0D0tmp.append(CODO.charAt(PC2[j] - 1));
                }
                subkey[i] = C0D0tmp;
                //  System.out.println(i + "轮密钥:" + subkey[i]);
            }
            return subkey;
        }
    
        //f轮函数
        public StringBuffer F(StringBuffer R, StringBuffer subkey) {
            StringBuffer res = new StringBuffer();
            //E盒扩展
            res = Extent(R);
            //异或运算
            for (int i = 0; i < 48; i++) {
                res.replace(i, i + 1, (res.charAt(i) == subkey.charAt(i) ? "0" : "1"));
            }
            //S盒压缩
            StringBuffer sBox = new StringBuffer();  //sBox用来接收压缩后的32 bits
            for (int i = 0; i < 8; i++) {
                String Sinput = res.substring(i * 6, (i + 1) * 6);
                //首尾两位转化为行,中间四位转化为列
                //parseInt(String s,int radix)---把字符串s根据radix(进制)转成对应的整数
                int row = Integer.parseInt(Character.toString(Sinput.charAt(0)) + Sinput.charAt(5), 2);
                int column = Integer.parseInt(Sinput.substring(1, 5), 2);
                StringBuffer Soutput = new StringBuffer(Integer.toBinaryString(SBox[i][row * 16 + column]));
                while (Soutput.length() < 4) {//小于四位要添0
                    Soutput.insert(0, 0);
                }
                sBox.append(Soutput);
            }
            //P置换
            sBox = P(sBox);
            return sBox;
        }
    
        //16轮迭代
        public StringBuffer iteration(StringBuffer L, StringBuffer R, int mode) {
            StringBuffer res = new StringBuffer();
            StringBuffer[] subkey = getSubkey(); //获取子密钥
            //mode == 1 解密  密钥反转
            if (mode == 1) {
                StringBuffer[] tmp = getSubkey();  //mode ==1
                for (int i = 0; i < 16; i++) {
                    subkey[i] = tmp[15 - i];
                    //  System.out.println(i+"轮密钥:"+subkey[i]);
                }
            }
    
            //查看密钥
    //        for (int i =0;i<16;i++){
    //            System.out.println(i+"轮密钥:"+subkey[i]);
    //        }
    
            //16轮循环
            for (int i = 0; i < 16; i++) {
                StringBuffer Ltmp = new StringBuffer(L);
                StringBuffer Rtmp = new StringBuffer(R);
    
                //右边的赋给左边
                L.replace(0, 32, R.toString());
                //F轮函数
                StringBuffer Fstring = F(Rtmp, subkey[i]);
    
                //Fstring异或R
                for (int j = 0; j < 32; j++) {
                    R.replace(j, j + 1, (Fstring.charAt(j) == Ltmp.charAt(j) ? "0" : "1"));
                }
            }
    
            //循环结束后左右交换
            StringBuffer RL = new StringBuffer(R.toString() + L.toString());
    
            //终止置换
            RL = Final(RL);
            return RL;
        }
    
        public static void main(String[] args) {
            System.out.println("----DES----");
            Demo instance = new Demo();//创建实例
    
            StringBuffer plain = new StringBuffer(); //录入明文
            String tmp = ""; //用来临时录入明文密文
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入明文:");
            tmp = sc.next();
            plain.append(tmp);
            int length = plain.length(); //保存明文的长度
            instance.setPlaintext(plain);
            System.out.println("明文:" + instance.getPlaintext());
    
            //密钥产生
            System.out.println("输入密钥:");
            tmp = sc.next();
            StringBuffer mykey = new StringBuffer();
            mykey.append(tmp);
            instance.setKey(mykey);
            System.out.println("密钥:" + instance.getKey());
    
            //设置分组数
            instance.setGroup();
    
            //测试加密
            System.out.println("-----DES加密-----");
            plain = instance.stringBufferToBinary(instance.getPlaintext()); //明文转成二进制
            StringBuffer L = new StringBuffer();//左明文
            StringBuffer R = new StringBuffer();//右明文
            StringBuffer plainBackup = new StringBuffer(plain);  //二进制明文备份
            StringBuffer cipherBackup = new StringBuffer();  //二进制密文备份
            StringBuffer descipher = new StringBuffer(); //解密后的明文
            //扩充明文
            while (plainBackup.length() < 64 * (instance.group + 1)) {
                plainBackup.append("0");
            }
            //分组加密
            for (int i = 0; i <= instance.group; i++) {
                //明文分组处理
                for (int j = 0; j < 64; j++) {
                    plain.replace(j, j + 1, plainBackup.substring(j + i * 64, j + 64 * i + 1));
                }
    
                //初始置换
                plain = instance.Initial(plain);
    
                L.replace(0, 32, plain.substring(0, 32));
                R.replace(0, 32, plain.substring(32, 64));
    
                //16轮迭代
                plain = instance.iteration(L, R, 0);//plain是加密后的二进制密文
                System.out.println(i + "轮迭代后:" + plain);
    
                //备份二进制密文
                cipherBackup.append(plain);
                System.out.println(i + "轮密文:" + instance.BinaryTostringBuffer(plain));
            }
    
            //测试解密
            System.out.println("-----DES解密-----");
            //分组解密
            for (int i = 0; i <= instance.group; i++) {
                //密文分组处理
                for (int j = 0; j < 64; j++) {
                    plain.replace(j, j + 1, cipherBackup.substring(j + i * 64, j + 64 * i + 1));
                }
    
                //初始置换
                plain = instance.Initial(plain);
    
                L.replace(0, 32, plain.substring(0, 32));
                R.replace(0, 32, plain.substring(32, 64));
                plain = instance.iteration(L, R, 1);//plain是解密后的二进制密文
                System.out.println(i + "轮迭代后:" + plain);
                System.out.println(i + "明文:" + instance.BinaryTostringBuffer(plain));
                descipher.append(instance.BinaryTostringBuffer(plain));
            }
            //输出解密后的明文
            System.out.println("最终解密后的明文:"+descipher.substring(0,length));
        }
    }
    /*
    aaaaaaaa
    -----------
    abcdef
    abcdabcd:
    abcdabcd:
    ----------
    abcdefgh
    abcdefghijkabcdefghijk
     */

    三、运行结果 

    明文长度小于8比特,密钥长度小于8。

     明文长度大于8比特。

    DES实现的粗略版链接DES算法的Java实现(粗略版)_争取不划水的博客-CSDN博客 

    展开全文
  • DES算法Java实现源代码

    2019-04-08 17:36:47
    DES算法Java实现源代码;网络安全技术及应用;java图形界面实现
  • 项目中需要用到这个,后来到网上找了不少,但算出来结果不对.这个是经过个人验证的.有类似需要的可以考虑
  • DES算法为密码体制中的对称密码体制,是一个分组加密算法,典型的DES以64位为分组对数据加密,加密和解密用的是同一个算法。 这里以Java代码实现DES算法。
  • DES java实现

    2011-07-29 15:29:15
    DES加密算法 java版本的实现类 采用64bit的密钥实现传统的DES算法,有加密和解密两种方法
  • Java实现DES算法

    2020-12-03 20:07:30
    自己写的一个算法实现,一个.java文件,直接运行就行,能够任意给定密钥,给任意64位明文加密、解密。已经检验没问题,内含示例,稳的一批。
  • Triple-DES java实现

    2011-05-24 09:55:10
    Triple-DES 加密解密算法的java实现
  • 使用java实现DES算法加密,带有界面。DES加密算法JAVA实现(带简单界面)
  • 主要介绍了java实现DES加密算法,结合实例形式详细分析了java实现DES加密操作的原理、实现技巧与相关注意事项,需要的朋友可以参考下
  • 虽然如此,在某些简单应用中,我们还是可以使用DES加密算法,本文简单讲解DESJAVA实现JAVA实现加密代码有详细解释,不多废话。注意:DES加密和解密过程中,密钥长度都必须是8的倍数 代码如下: public byte[] ...
  • 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)
  • 主要介绍了Java实现DES加解密算法解析,结合完整实例形式分析了DES加密的相关原理,需要的朋友可以参考下。
  • DES密码算法Java实现 有简单的界面使用彭长根老师的现代密码学趣味之旅
  • des加密算法java实现

    2016-04-17 10:12:41
    DES加解密算法,java实现,可运行!
  • DES数据加密算法,网络安全中较为基础的算法之一,用于学习交流使用
  • 主要介绍了Java实现DES加密解密工具类,结合具体实例形式分析了Java实现DES加密解密工具类定义与使用方法,需要的朋友可以参考下
  • 主要介绍了Java实现的3des加密解密工具类,结合完整实例形式分析了3des加密解密的具体步骤与相关操作技巧,需要的朋友可以参考下
  • 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));
        }
    }
    展开全文
  • DES算法实现Java

    2017-05-01 23:46:57
    密码学基础之DES算法的详细过程 体会加密算法的置乱和混沌
  • 此资源为des算法加解密的java完美实现,可导入环境直接运行。适合初学者对于des加密的学习和理解。资源分享出来,赚赚积分!感谢大家
  • java实现DES对称加密

    2018-06-11 17:26:40
    JAVA代码实现DES对称加密,同时加密后的数据为字符串类型,方便数据传输。
  • 主要介绍了Java实现DES加密与解密,md5加密以及Java实现MD5加密解密类 ,需要的朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 27,023
精华内容 10,809
关键字:

desjava实现