Java应用DES加密

最新推荐文章于 2024-05-29 17:47:58 发布
最新推荐文章于 2024-05-29 17:47:58 发布
阅读量1.5k 收藏 4
点赞数 2
分类专栏： # 加密/解密 文章标签： java c# 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39960529/article/details/105817612
版权

Java应用DES加密

DES加密

之前没了解过这方面，这次由于公司需要，要求Java和C#对加密做一个互通加密。在这里做一个小结。

概念

DES(Data Encryption Standard)是一种对称加密算法，对称加密本质就是加密和解密都使用的是同一个密钥，因此密钥一定要保存好，如果泄露，可想而知后果是什么。

算法原理

这里我附上我在网上学习的链接如下：

  1. DES算法原理完整版
  2. 数据加密算法–详解DES加密算法原理与实现

Java代码实现

/**
     * DES加密
     *
     * @param strIn -- 待加密明文
     * @param secretkey -- 密钥
     * @return
     * @throws Exception
     * IvParameterSpec对象————初始化向量，使用DES进行加/解密时字节长度必须为8的倍数，
     * 否则会报错（java.security.InvalidAlgorithmParameterException: Wrong IV length: must be 8 bytes long）
     *
     * 实例化Cipher加密对象，参数为加密方式，使用IvParameterSpec时，Cipher参数要使用CBC模式。
     * 加密方式为【DES】加密（JAVA封装的DES算法的默认模式————ECB模式）
     * 加密方式为【DES/CBC/PKCS5Padding】加密（密文分组链接方式————CBC模式）
     */
    public static String encrypt(String strIn, String secretkey) throws Exception {
        Key key = getKey(secretkey.getBytes("UTF-8")); // 不足8的倍数位，则填充/截取（密钥）
        Cipher cipher = Cipher.getInstance("DES");
        cipher.init(1, key);
        byte[] strInByte =  strIn.getBytes("UTF-8"); // 待加密明文字符串转字节数组
        byte[] arrB = cipher.doFinal(strInByte); // 加密明文字节数组，并返回加密后的字节数组
        System.out.println("待加密明文字符串转字节数组strInByte: " + strInByte);
        System.out.println("返回加密后的字节数组arrB: " + arrB);
        return byteArr2HexStr(arrB); // 字节数组转16进制字符串
    }

    /**
     * DES解密
     * @param strIn -- 待解密密文
     * @param secretkey -- 密钥
     * @return
     * @throws Exception
     */
    public static String decrypt(String strIn, String secretkey) throws Exception {
        Key key = getKey(secretkey.getBytes("UTF-8"));
        Cipher cipher = Cipher.getInstance("DES");
        cipher.init(2, key);
        byte[] param = cipher.doFinal(hexStr2ByteArr(strIn));
        return new String(param, "UTF-8");
    }

DESUtils工具类

自己整理的DESUtils工具类都贴下，大家可以练习练习，有问题欢迎留言哦，，代码如下：

import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.security.Key;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 *
 * DES加密/解密工具类
 * <a href = "https://www.cnblogs.com/Lawson/archive/2012/05/20/2510781.html">JAVA和.NET使用DES对称加密的区别</a>
 *
 * @author zhang
 * @date 2020-04-28 16:09:10
 */
public class DESUtils {

    /**
     * 密钥算法
     * JAVA封装的DES算法的默认模式————ECB模式（电子密本方式）
     */
    private static final String KEY_ALGORITHM = "DES";
    /**
     * 加密方式(算法/模式/补码方式)
     * DES/CBC/PKCS5Padding————CBC模式（密文分组链接方式）
     */
    private static final String ENCRYPTION  = "DES/CBC/PKCS5Padding";
    /**
     * 编码格式
     */
    private static final String CHARSET  = "UTF-8";
    /**
     * 此类指定一个初始化向量zeroIv（使用 byteIV 中的字节作为 IV 来构造一个 IvParameterSpec 对象）(指定数组大小为8)
     * // 使用CBC模式，需要一个向量iv，可增加加密算法的强度
     * <a href="https://download.oracle.com/technetwork/java/javase/6/docs/zh/api/javax/crypto/spec/IvParameterSpec.html">javax.crypto.spec.IvParameterSpec</a>
     * <a href= "https://blog.csdn.net/qq_25816185/article/details/81626499">java使用AES算法的CBC模式加密</a>
     */
    private static final IvParameterSpec zeroIv = new IvParameterSpec(new byte[8]);

    /**
     * 设置指定初始化向量值(指定值)
     */
    private static byte[] IV  = { 0x13, 0x24, 0x56, 0x78, (byte) 0x90, (byte) 0xAB, (byte) 0xCD, (byte) 0xEF };

    /**
     * DES加密
     *
     * @param strIn -- 待加密明文
     * @param secretkey -- 密钥
     * @return
     * @throws Exception
     * IvParameterSpec对象————初始化向量，使用DES进行加/解密时字节长度必须为8的倍数，
     * 否则会报错（java.security.InvalidAlgorithmParameterException: Wrong IV length: must be 8 bytes long）
     *
     * 实例化Cipher加密对象，参数为加密方式，使用IvParameterSpec时，Cipher参数要使用CBC模式。
     * 加密方式为【DES】加密（JAVA封装的DES算法的默认模式————ECB模式）
     * 加密方式为【DES/CBC/PKCS5Padding】加密（密文分组链接方式————CBC模式）
     */
    public static String encrypt(String strIn, String secretkey) throws Exception {

//        IvParameterSpec zeroIv = new IvParameterSpec(new byte[8]);
//        IvParameterSpec zeroIv = new IvParameterSpec(IV);
        Key key = getKey(secretkey.getBytes(CHARSET)); // 不足8的倍数位，则填充/截取（密钥）
        Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);

//        cipher.init(Cipher.ENCRYPT_MODE, key, zeroIv); // 初始化（第一个参数是工作模式，第二个是密钥key，第三个是初始化向量）
        cipher.init(Cipher.ENCRYPT_MODE, key); // ENCRYPT_MODE = 1; (加密模式)

        byte[] strInByte =  strIn.getBytes(CHARSET); // 待加密明文字符串转字节数组
        byte[] arrB = cipher.doFinal(strInByte); // 加密明文字节数组，并返回加密后的字节数组
        System.out.println("待加密明文字符串转字节数组strInByte: " + strInByte);
        System.out.println("返回加密后的字节数组arrB: " + arrB);
        return byteArr2HexStr(arrB); // 字节数组转16进制字符串
    }

    /**
     * DES解密
     * @param strIn -- 待解密密文
     * @param secretkey -- 密钥
     * @return
     * @throws Exception
     */
    public static String decrypt(String strIn, String secretkey) throws Exception {
//        IvParameterSpec zeroIv = new IvParameterSpec(new byte[8]);
//        IvParameterSpec zeroIv = new IvParameterSpec(IV);
        Key key = getKey(secretkey.getBytes(CHARSET));
        Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, key); // DECRYPT_MODE = 2 (解密模式)
        byte[] param = cipher.doFinal(hexStr2ByteArr(strIn));
        return new String(param, CHARSET);
    }

    /**
     * 填充盐值（密钥），使用DES进行加/解密时字节长度必须为8的倍数，
     * 否则会报错（java.security.InvalidAlgorithmParameterException: Wrong IV length: must be 8 bytes long）
     * @param arrBTmp
     * @return
     */
    private static Key getKey(byte[] arrBTmp) {
        byte[] arrB = new byte[8];
        for(int i = 0; i < arrBTmp.length && i < arrB.length; ++i) {
            arrB[i] = arrBTmp[i];
        }
        Key key = new SecretKeySpec(arrB, KEY_ALGORITHM);
        return key;
    }

    /**
     * 字节数组转换16进制字符串
     * @param arrB
     * @return
     * @throws Exception
     */
    public static String byteArr2HexStr(byte[] arrB) {
        int iLen = arrB.length;
        StringBuffer sb = new StringBuffer(iLen * 2);
        for(int i = 0; i < iLen; ++i) {
            int intTmp;
            for(intTmp = arrB[i]; intTmp < 0; intTmp += 256) {
            }
            if (intTmp < 16) {
                sb.append("0");
            }
            sb.append(Integer.toString(intTmp, 16));
        }
        return sb.toString();
    }

    /**
     * 16进制字符串转换字节数组
     * @param strIn
     * @return
     * @throws Exception
     */
    public static byte[] hexStr2ByteArr(String strIn) throws Exception {
        byte[] arrB = strIn.getBytes();
        int iLen = arrB.length;
        byte[] arrOut = new byte[iLen / 2];

        for(int i = 0; i < iLen; i += 2) {
            String strTmp = new String(arrB, i, 2);
            arrOut[i / 2] = (byte)Integer.parseInt(strTmp, 16);
        }

        return arrOut;
    }

    private static String initReturnData(String key, String data) {
        String str = "";
        try {
            if (!data.equals("")) {
                str = DESUtils.decrypt(replaceBlank(data), key);
            }
        } catch (Exception var4) {
            var4.printStackTrace();
            str = "{\"status\":false,\"msg\":\"请检查密钥或加密方式是否正确！\",\"data\":\"\"}";
        }

        return str;
    }

    /**
     * 检查字符串中是否包含特殊字符（换行符等），并去除
     * @param str
     * @return
     */
    private static String replaceBlank(String str) {
        String dest = "";
        if (str != null) {
            Pattern p = Pattern.compile("\t|\r|\n");
            Matcher m = p.matcher(str);
            dest = m.replaceAll("");
        }

        return dest;
    }


    /**
     * testZhang
     * @param args
     */
    public static void main(String[] args) {
        String strIn = "123456";
        String saltValue = "ZHANG";
        String encryptResult = ""; // 加密结果
        String decryptResult = ""; // 解密结果

        /**加密*/
        try {
            encryptResult = encrypt(strIn, saltValue);
        } catch (Exception e) {
            System.out.println("加密异常");
        }
        System.out.println("密钥: " + saltValue);
        System.out.println("加密result: " + encryptResult);

        /**解密*/
        try {
            decryptResult = decrypt(encryptResult, saltValue);
        } catch (Exception e) {
            System.out.println("解密异常");
        }
        System.out.println("密钥: " + saltValue);
        System.out.println("解密result1: " + decryptResult);


    }

}

总结

  1. 使用DES进行加/解密时字节长度必须为8的倍数，不然会报错
    错误信息如下：
    java.security.InvalidAlgorithmParameterException: Wrong IV length: must be 8 bytes long

  2. JAVA封装的【DES】算法的默认模式——ECB模式(电子密本方式)，而C#不是，这点要特别注意，否则Java和C#加解密无法互通。

  3. 加密方式为【DES/CBC/PKCS5Padding】加密（密文分组链接方式————CBC模式）

  4. 加密方式这块有出现一个问题：实例化Cipher加密对象，参数为加密方式，使用IvParameterSpec对象时，Cipher参数要使用CBC模式(DES/CBC/PKCS5Padding)，不然会报错，错误信息如下：

    java.security.InvalidAlgorithmParameterException: ECB mode cannot use IV
    IvParameterSpec 干什么用的？

参考链接

  1. JAVA和.NET使用DES对称加密的区别
  2. DES加密JAVA与C#通用

java应用相关

  1. cipher加密解密
  2. 安全体系（一）—— DES算法详解
  3. DES算法原理完整版
  4. Java实现DES加密解密

C#应用相关

  1. C#实现DES加密解密
  2. C# 发送Post请求（带参数）
勿忘初心1221
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java使用des加密
huangshikai
11-15 528
DES加密算法是jdk自带的一种采用8位密钥字符加密的对称算法，它既可以正向加密也可以反向解密。 DES算法的入口参数有三个：Key、Data、Mode。其中Key为8个字符共56位，每个字符由7个字节外加1字节的奇偶校验组成，是DES算法的工作密钥；Data为8个字节64位，是要被加密或被解密的数据；Mode为DES的工作方式,有两种:加密（值为1）或解密（值为2）。 注意：加密密钥与解密密...
Java实现DES加密
nanli1234566的博客
06-10 1394
Java实现DES加密
Java实现AES，DES，RSA加密
编写博客，学习交流
05-29 521
这个标准用来替代原先的DES,AES加密过程涉及到4种操作，分别是字节替代、行移位、列混淆和轮密钥加。解密过程分别为对应的逆操作。由于每一步操作都是可逆的，按照相反的顺序进行解密即可恢复明文。加解密中每轮的密钥分别由初始密钥扩展得到。算法中16个字节的明文、密文和轮密钥都以一个4x4的矩阵表示。
用java实现des加密
06-08
用java实现了DES的加密算法 有可视化见面 缺点：输入的密钥最后为5为字符
Java实现DES加密解密算法
无名小卒的博客
05-21 2970
一、DES算法的讲解可以参考以下两篇博文 https://blog.csdn.net/enderman19980125/article/details/89224204 https://www.cnblogs.com/hugboy/p/12974393.html 二、功能实现 1、可以加密任何文件 2、可以加密文件夹并保持文件夹目录层次不变 3、输入的密钥可以为任意长度 三、代码 import java.io.*; import java.nio.MappedByteBuffer; import jav
java DES加密
yanguo110的博客
08-31 289
package net.okdi.o2o.core.util; import java.security.Key; import java.security.SecureRandom; import javax.crypto.Cipher; import javax.crypto.KeyGenerator; import sun.misc.BASE64Decoder; import sun.
PHP、Java des加密解密实例
09-03
以下是一个Java DES加密解密的例子： ```java import javax.crypto.Cipher; import javax.crypto.spec.SecretKeySpec; public class DESUtil { private final static String ALGORITHM = "DES"; public static ...
JAVA实现des加密算法 实例
06-01
在Java中，我们可以使用`javax.crypto`包中的类来实现DES加密。以下将详细介绍如何在Java中实现DES加密，并提供一个实例。 首先，理解DES算法的基本原理： DES是一种块密码，它将明文分为64位的数据块进行加密，...
Python和Java进行DES加密和解密的实例
08-28
"Python和Java进行DES加密和解密的实例" 本文将对Python和Java进行DES加密和解密的实例进行详细的解释和分析。 标题解释 本文的标题为"Python和Java进行DES加密和解密的实例”，该标题说明了本文的主要内容，即使...
des加密解密java实现版本
10-10
在Java中实现DES加密和解密是一项常见的任务，通常涉及到`javax.crypto`包中的类和接口。本篇文章将详细阐述DES加密解密的Java实现过程。 首先，我们需要了解DES算法的基本原理。DES是一种块密码，它将明文数据分成...
DES_DES加密算法JAVA实现_
10-03
这是一个用Java实现的DES高级加密算法的源代码
DES文件加密解密用java实现
10-25
可以实现对txt类等基本文档的加密和解密
java中使用DES加密解密实例
09-04
主要介绍了java中使用DES加密解密实例，需要的朋友可以参考一下
兼容PHP和Java的des加密解密代码分享
12-18
在Java中，我们可以使用`javax.crypto`包来处理DES加密。`Main`类提供了一个静态方法`encode()`，它接受一个密钥字符串和待加密的字节数组。这个方法首先创建一个`DESKeySpec`对象，然后通过`SecretKeyFactory`来...
JAVA实现DES加密
zty
05-30 363
DES(Data Encryption Standard)是一种对称加密算法，所谓对称加密就是加密和解密都是使用同一个密钥。 加密原理： DES 使用一个 56 位的密钥以及附加的 8 位奇偶校验位，产生最大 64 位的分组大小。这是一个迭代的分组密码，使用称为 Feistel 的技术，其中将加密的文本块分成两半。使用子密钥对其中一半应用循环功能，然后将输出与另一半进行"异或"运算;接着交换这两半，这一过程会继续下去，但最后一个循环不交换。DES 使用 16 个循环，使用异或，置换，代换，移位操作四种基本运
java实现DES加密
航行在蓝天的蚂蚱
10-26 440
public class DESUtils { private static String keyStr = "f41087ef"; private static String py = "4cd4bba8"; /** * 加密 * @param data * @return */ public static String encryptString(String data){ try { ..
java写的DES加密
过客璇璇的博客
03-12 540
import java.awt.Container; import javax.swing.*; import java.awt.BorderLayout; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.io.File; import java.io.FileInputS...
基于Java实现的DES加密算法
weixin_44828537的博客
01-31 6661
网络安全基础
java des加密
最新发布
06-14
Java中的DES（Data Encryption Standard）是一种对称加密算法，全称为Data Encryption Standard，它在Java中可以通过`javax.crypto.Cipher`类及其提供的`SecretKey`和`Cipher`对象来实现。DES主要用于加密数据传输，其特点是加密速度快，但安全性相对较低，因为它的密钥长度只有64位。 使用Java DES加密的步骤如下： 1. 密钥生成：你需要创建一个64位的密钥（也可以是128位，但那是DESede，不是标准的DES），通常使用`SecretKeySpec`来表示。 ```java byte[] keyBytes = {0x01, 0x02, 0x03, ...}; // 64位或128位密钥 SecretKeySpec key = new SecretKeySpec(keyBytes, "DES"); // 使用"DES"作为算法标识 ``` 2. 初始化加密器：使用`Cipher.getInstance("DES")`获取`Cipher`对象，并设置为加密模式（ENCRYPT_MODE）。 ```java Cipher cipher = Cipher.getInstance("DES"); cipher.init(Cipher.ENCRYPT_MODE, key); ``` 3. 加密数据：调用`cipher.doFinal(input)`，`input`是要加密的原始数据，返回的是加密后的密文。 ```java byte[] encryptedData = cipher.doFinal(plaintext.getBytes()); ``` 4. 解密过程类似，只是将`Cipher.ENCRYPT_MODE`改为`Cipher.DECRYPT_MODE`。 值得注意的是，DES已经被认为过时，现代应用通常会使用更安全的算法如AES。如果你需要更高级别的加密，可以考虑使用`AES`或者`TLS/SSL`。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值