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

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

对称加密

更多相关内容

DES_DES加密算法JAVA实现_
2021-10-03 10:11:33

这是一个用Java实现的DES高级加密算法的源代码

收起
DES java实现 只是简单的对string的加解密
2015-12-02 21:08:45

DES 的java实现 因为是课程作业所以只是写的一个简单的对string的加解密

收起
DES算法Java实现
2018-01-17 09:45:05

DES算法，可扩展成3DES算法，Java实现，Eclipse中可直接运行

收起
Java实现Des加密（不用加载包）
2016-12-13 16:56:53

Java实现Des加密（不用加载包），有完整S盒子。部分代码如下： ackage desJava; import java.util.*; public class Des { byte[] bytekey; public Des(String strKey) { this.bytekey = strKey.getBytes();...

收起
DESjava实现源码(the5fire.net)
2012-12-19 22:35:16

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图形界面实现

收起
JAVA实现des加密算法实例
2018-06-01 22:36:39

项目中需要用到这个，后来到网上找了不少，但算出来结果不对．这个是经过个人验证的．有类似需要的可以考虑

收起
DES对称加密算法Java实现
2018-01-06 23:31:16

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实现

收起
DES加密算法JAVA实现（带简单界面）
2019-06-09 15:34:58

使用java实现的DES算法加密，带有界面。DES加密算法JAVA实现（带简单界面）

收起
java实现的DES加密算法详解
2020-08-30 03:34:45

主要介绍了java实现的DES加密算法,结合实例形式详细分析了java实现DES加密操作的原理、实现技巧与相关注意事项,需要的朋友可以参考下

收起
利用JAVA实现DES加密算法
2021-01-19 22:33:11

虽然如此，在某些简单应用中，我们还是可以使用DES加密算法，本文简单讲解DES的JAVA实现。 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加解密算法解析
2020-09-01 10:30:45

主要介绍了Java实现DES加解密算法解析,结合完整实例形式分析了DES加密的相关原理,需要的朋友可以参考下。

收起
DES密码算法使用Java实现
2019-03-26 11:05:00

DES密码算法Java实现 有简单的界面使用彭长根老师的现代密码学趣味之旅

收起
des加密算法java实现
2016-04-17 10:12:41

DES加解密算法，java实现，可运行！

收起
DES数据加密算法Java实现
2014-09-20 22:41:32

DES数据加密算法，网络安全中较为基础的算法之一，用于学习交流使用

收起
Java实现的DES加密解密工具类实例
2020-08-29 06:38:05

主要介绍了Java实现的DES加密解密工具类,结合具体实例形式分析了Java实现的DES加密解密工具类定义与使用方法,需要的朋友可以参考下

收起
Java实现的3des加密解密工具类示例
2020-08-29 01:03:22

主要介绍了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的完美实现源码
2018-06-20 11:14:47

此资源为des算法加解密的java完美实现，可导入环境直接运行。适合初学者对于des加密的学习和理解。资源分享出来，赚赚积分！感谢大家

收起
java实现DES对称加密
2018-06-11 17:26:40

JAVA代码实现DES对称加密，同时加密后的数据为字符串类型，方便数据传输。

收起
Java实现DES加密与解密，md5加密以及Java实现MD5加密解密类
2020-09-03 04:38:46

主要介绍了Java实现DES加密与解密，md5加密以及Java实现MD5加密解密类 ,需要的朋友可以参考下

收起

DES_DES加密算法JAVA实现_

DES java实现只是简单的对string的加解密

DES算法Java实现

Java实现Des加密（不用加载包）

DESjava实现源码(the5fire.net)

DES算法Java实现（完善版）

一、密钥长度处理

二、分组加密

三、运行结果

DES算法Java实现源代码

JAVA实现des加密算法实例

DES对称加密算法Java实现

DES java实现类

Java实现DES算法

Triple-DES java实现

DES加密算法JAVA实现（带简单界面）

java实现的DES加密算法详解

利用JAVA实现DES加密算法

DES加密算法的JAVA实现

Java实现DES加解密算法解析

DES密码算法使用Java实现

des加密算法java实现

DES数据加密算法Java实现

Java实现的DES加密解密工具类实例

Java实现的3des加密解密工具类示例

3DES加解密java实现

DES算法实现Java

DES加密java的完美实现源码

java实现DES对称加密

Java实现DES加密与解密，md5加密以及Java实现MD5加密解密类

desjava实现

DES_DES加密算法JAVA实现_

DES java实现 只是简单的对string的加解密

DES算法Java实现

Java实现Des加密（不用加载包）

DESjava实现源码(the5fire.net)

DES算法Java实现（完善版）

一、密钥长度处理

二、分组加密

三、运行结果

DES算法Java实现源代码

JAVA实现des加密算法 实例

DES对称加密算法Java实现

DES java实现类

Java实现DES算法

Triple-DES java实现

DES加密算法JAVA实现（带简单界面）

java实现的DES加密算法详解

利用JAVA实现DES加密算法

DES加密算法的JAVA实现

Java实现DES加解密算法解析

DES密码算法使用Java实现

des加密算法java实现

DES数据加密算法Java实现

Java实现的DES加密解密工具类实例

Java实现的3des加密解密工具类示例

3DES加解密java实现

DES算法实现Java

DES加密java的完美实现源码

java实现DES对称加密

Java实现DES加密与解密，md5加密以及Java实现MD5加密解密类

desjava实现

DES java实现只是简单的对string的加解密

JAVA实现des加密算法实例