java基于Des对称加密算法实现的加密与解密功能详解

本文实例讲述了java基于Des对称加密算法实现的加密与解密功能。分享给大家供大家参考，具体如下：

Des 加密相关类介绍：

SecureRandom  这个类是继承自java.util.Random 这个类

SecureRandom 这个类的构造器有三种，下面例举两种：

SecureRandom()构造一个实现默认随机数算法的安全随机数生成器 (RNG)。

SecureRandom(byte[] seed)构造一个实现默认随机数算法的安全随机数生成器 (RNG)。

DESKeySpec 这个类是用来使用原始秘钥来生成秘钥的秘钥内容

DESKeySpec 有两个构造函数：

DESKeySpec(byte[] key) 创建一个 DESKeySpec 对象，使用 key 中的前 8 个字节作为 DES 密钥的密钥内容。

DESKeySpec(byte[] key, int offset) 创建一个 DESKeySpec 对象，使用 key 中始于且包含 offset 的前 8 个字节作为 DES-EDE 密钥的密钥内容。

SecretKeyFactory ， 密钥工厂用来将密钥（类型 Key 的不透明加密密钥）转换为密钥规范（底层密钥材料的透明表示形式），反之亦然。秘密密钥工厂只对秘密（对称）密钥进行操作。

SecretKey对象，秘钥对象，通过调用秘钥工厂的generateSecret（DESKeySpec deskeyspace） 方法来生成秘钥

Cipher 类为加密和解密提供密码功能，通过调用Cipher的getInstance("des") 来获取实例

Cipher 对象调用init（） 方法进行对象的初始化，init() 方法的具体参数按照具体情况而定，有加密的也有解密的常量

最后调用Cipher的doFinal() 方法进行加密解密。

在这里请教大家一个问题，不管是第一种使用BASE64Encoder编码还是第二种org.apache.commons.codec.binary.Base64编码，在将String 转化为byte以及将byte转化为String 时需要 UTF-8/GBK 等编码来编码，解码吗？

一、使用了 sun.misc.BASE64Decoder 和BASE64Encoder 进行解码，编码

package com.soufun.com;
import java.io.IOException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Date;
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
// 导入sun的64位编码
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
/**
 *@author WHD
 *
 *即使导入sun.misc这个架包也会报错，这时首先把你的JRE架包移除再导入一次就可以了
 */
public class DesUtil {
  // 定义加密方式
   private final static String DES = "DES";
   private final static String UTF8="GBK";
   static SecretKeyFactory keyFactory = null;
  static {
    try {
      keyFactory=SecretKeyFactory.getInstance("DES");
    } catch (NoSuchAlgorithmException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }
    public static void main(String[] args) throws Exception {
      long begin=new Date().getTime();
      String data = "aaades加密测试";
      // 注意：DES加密和解密过程中，密钥长度都必须是8的倍数
      String key = "qazwsxed";
      System.err.println(encrypt(data, key));
      System.err.println(decrypt(encrypt(data, key), key));
      long end =new Date().getTime();
      System.out.println(end-begin);
    }
    /**
     * Description 根据键值进行加密
     * @param data
     * @param key 加密键byte数组
     * @return
     * @throws Exception
     */
    public static String encrypt(String data, String key) throws Exception {
      // 使用指定的编码获取要加密的内容，一般秘钥都是字母或数字不用指定编码，但指定也可以
      byte[] bt = encrypt(data.getBytes(UTF8), key.getBytes(UTF8));
      //注意：在加密和解密的时候使用sun的BASE64Encoder（）进行编码和解码不然会有乱码
      //网上查看了很多实例，都没有编码和解码，也说没有乱码问题，而我这里出现了乱码，所以使用BASE64Encoder（）进行了编码解码
      String strs = new BASE64Encoder().encode(bt);
      return strs;
    }
    /**
     * Description 根据键值进行解密
     * @param data
     * @param key 加密键byte数组
     * @return
     * @throws IOException
     * @throws Exception
     */
    public static String decrypt(String data, String key) throws IOException,
        Exception {
      if (data == null)
        return null;
      //注意：在加密和解密的时候使用sun的BASE64Encoder（）进行编码和解码不然会有乱码
      BASE64Decoder decoder = new BASE64Decoder();
      byte[] buf = decoder.decodeBuffer(data);
      byte[] bt = decrypt(buf,key.getBytes());
      return new String(bt,UTF8);
    }
    /**
     * Description 根据键值进行加密
     * @param data
     * @param key 加密键byte数组
     * @return
     * @throws Exception
     */
    private static byte[] encrypt(byte[] data, byte[] key) throws Exception {
      // 生成一个可信任的随机数源
      SecureRandom sr = new SecureRandom();
      // 从原始密钥数据创建DESKeySpec对象，也就是创建秘钥的秘钥内容
      DESKeySpec dks = new DESKeySpec(key);
      // 密钥工厂用来将密钥（类型 Key 的不透明加密密钥）转换为密钥规范（底层密钥材料的透明表示形式），反之亦然。秘密密钥工厂只对秘密（对称）密钥进行操作。
      // 这里改为使用单例模式
      //SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);
      //根据提供的密钥规范（密钥材料）生成 SecretKey(秘钥) 对象。
      SecretKey securekey = keyFactory.generateSecret(dks);
      // Cipher对象实际完成加密操作,此类为加密和解密提供密码功能
      Cipher cipher = Cipher.getInstance(DES);
      // 用密钥和随机源初始化此 Cipher。ENCRYPT_MODE用于将 Cipher 初始化为加密模式的常量。
      cipher.init(Cipher.ENCRYPT_MODE, securekey, sr);
      //正式执行加密操作
      return cipher.doFinal(data);
    }
    /**
     * Description 根据键值进行解密
     * @param data
     * @param key 加密键byte数组
     * @return
     * @throws Exception
     */
    private static byte[] decrypt(byte[] data, byte[] key) throws Exception {
      // 生成一个可信任的随机数源
      SecureRandom sr = new SecureRandom();
      // 从原始密钥数据创建DESKeySpec对象，也就是创建秘钥的秘钥内容
      DESKeySpec dks = new DESKeySpec(key);
      // 密钥工厂用来将密钥（类型 Key 的不透明加密密钥）转换为密钥规范（底层密钥材料的透明表示形式），反之亦然。秘密密钥工厂只对秘密（对称）密钥进行操作。
      // 这里改为使用单例模式
      //SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);
      //根据提供的密钥规范（密钥材料）生成 SecretKey(秘钥)对象。
      SecretKey securekey = keyFactory.generateSecret(dks);
      // Cipher类为加密和解密提供密码功能
      Cipher cipher = Cipher.getInstance(DES);
      // DECRYPT_MODE用于将 Cipher 初始化为解密模式的常量。
      cipher.init(Cipher.DECRYPT_MODE, securekey, sr);
      // 正式进行解密操作
      return cipher.doFinal(data);
    }
}

二、使用org.apache.commons.codec.binary.Base64 进行解码，编码

package com.soufun.com;
import java.io.IOException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Date;
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import org.apache.commons.codec.binary.Base64;
/**
 *@author WHD
 *
 */
public class DesUtil {
  // 定义加密方式
   private final static String DES = "DES";
   private final static String UTF8="GBK";
   static SecretKeyFactory keyFactory = null;
  static {
    try {
      keyFactory=SecretKeyFactory.getInstance("DES");
    } catch (NoSuchAlgorithmException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }
    public static void main(String[] args) throws Exception {
      long begin=new Date().getTime();
      String data = "aaades加密测试";
      // 注意：DES加密和解密过程中，密钥长度都必须是8的倍数
      String key = "qazwsxed";
      System.err.println(encrypt(data, key));
      System.err.println(decrypt(encrypt(data, key), key));
      long end =new Date().getTime();
      System.out.println(end-begin);
    }
    /**
     * Description 根据键值进行加密
     * @param data
     * @param key 加密键byte数组
     * @return
     * @throws Exception
     */
    public static String encrypt(String data, String key) throws Exception {
      // 使用指定的编码获取要加密的内容，一般秘钥都是字母或数字不用指定编码，但指定也可以
      byte[] bt = encrypt(data.getBytes(UTF8), key.getBytes());
      // 第一个使用了sun.misc.BASE64Encoder;进行了编码，但网上说使用org.apache.commons.codec.binary.Base64比较好所以拿来试试
      String strs = Base64.encodeBase64String(bt);
      return strs;
    }
    /**
     * Description 根据键值进行解密
     * @param data
     * @param key 加密键byte数组
     * @return
     * @throws IOException
     * @throws Exception
     */
    public static String decrypt(String data, String key) throws IOException,
        Exception {
      if (data == null)
        return null;
      // 使用org.apache.commons.codec.binary.Base64解码
      byte [] buf=Base64.decodeBase64(data);
      byte[] bt = decrypt(buf,key.getBytes());
      return new String(bt,UTF8);
    }
    /**
     * Description 根据键值进行加密
     * @param data
     * @param key 加密键byte数组
     * @return
     * @throws Exception
     */
    private static byte[] encrypt(byte[] data, byte[] key) throws Exception {
      // 生成一个可信任的随机数源
      SecureRandom sr = new SecureRandom();
      // 从原始密钥数据创建DESKeySpec对象，也就是创建秘钥的秘钥内容
      DESKeySpec dks = new DESKeySpec(key);
      // 密钥工厂用来将密钥（类型 Key 的不透明加密密钥）转换为密钥规范（底层密钥材料的透明表示形式），反之亦然。秘密密钥工厂只对秘密（对称）密钥进行操作。
      // 这里改为使用单例模式
      //SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);
      //根据提供的密钥规范（密钥材料）生成 SecretKey(秘钥) 对象。
      SecretKey securekey = keyFactory.generateSecret(dks);
      // Cipher对象实际完成加密操作,此类为加密和解密提供密码功能
      Cipher cipher = Cipher.getInstance(DES);
      // 用密钥和随机源初始化此 Cipher。ENCRYPT_MODE用于将 Cipher 初始化为加密模式的常量。
      cipher.init(Cipher.ENCRYPT_MODE, securekey, sr);
      //正式执行加密操作
      return cipher.doFinal(data);
    }
    /**
     * Description 根据键值进行解密
     * @param data
     * @param key 加密键byte数组
     * @return
     * @throws Exception
     */
    private static byte[] decrypt(byte[] data, byte[] key) throws Exception {
      // 生成一个可信任的随机数源
      SecureRandom sr = new SecureRandom();
      // 从原始密钥数据创建DESKeySpec对象，也就是创建秘钥的秘钥内容
      DESKeySpec dks = new DESKeySpec(key);
      // 密钥工厂用来将密钥（类型 Key 的不透明加密密钥）转换为密钥规范（底层密钥材料的透明表示形式），反之亦然。秘密密钥工厂只对秘密（对称）密钥进行操作。
      // 这里改为使用单例模式
      //SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);
      //根据提供的密钥规范（密钥材料）生成 SecretKey(秘钥)对象。
      SecretKey securekey = keyFactory.generateSecret(dks);
      // Cipher类为加密和解密提供密码功能
      Cipher cipher = Cipher.getInstance(DES);
      // DECRYPT_MODE用于将 Cipher 初始化为解密模式的常量。
      cipher.init(Cipher.DECRYPT_MODE, securekey, sr);
      // 正式进行解密操作
      return cipher.doFinal(data);
    }
}

一、二中使用到的架包下载地址：

下载： sun.misc.BASE64Decoder 。
下载：apache的Base64编码、解码器 。

三、未使用任何编码，解码架包

package com.soufun.com;
import java.io.IOException;
import java.security.NoSuchAlgorithmException;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.IvParameterSpec;
/**
 *@author WHD
 *
 */
public class DESCrypt {
  static SecretKeyFactory secretKeyFactory = null;
  //Cipher 的“算法/模式/填充”
  static final String CIPHER = "DES/CBC/PKCS5Padding";
  static {
    try {
      // 在静态代码块中获取秘钥工程
      secretKeyFactory = SecretKeyFactory.getInstance("DES");
    } catch (NoSuchAlgorithmException e) {
      e.printStackTrace();
    }
  }
  // 定义常量 ，编码格式
  private static final String UTF8 = "GBK";
  /*
   * 对象缓存的容器
   */
  static abstract class Cache {
    private final Map innerCache = new HashMap();
    protected abstract Object createValue(Object key) throws Exception;
    public Object get(Object key) throws Exception {
      Object value;
      synchronized (innerCache) {
        value = innerCache.get(key);
        if (value == null) {
          value = new CreationPlaceholder();
          innerCache.put(key, value);
        }
      }
      if (value instanceof CreationPlaceholder) {
        synchronized (value) {
          CreationPlaceholder progress = (CreationPlaceholder) value;
          if (progress.value == null) {
            progress.value = createValue(key);
            synchronized (innerCache) {
              innerCache.put(key, progress.value);
            }
          }
          return progress.value;
        }
      }
      return value;
    }
    static final class CreationPlaceholder {
      Object value;
    }
  }
  /*
   * hex->str & str->hex
   */
  public static byte[] stringToHex(String ss) {
    // 字符串转化we
    byte digest[] = new byte[ss.length() / 2];
    for (int i = 0; i < digest.length; i++) {
      String byteString = ss.substring(2 * i, 2 * i + 2);
      int byteValue = Integer.parseInt(byteString, 16);
      digest[i] = (byte) byteValue;
    }
    return digest;
  }
  public static String hexToString(byte b[]) {
    StringBuffer hexString = new StringBuffer();
    for (int i = 0; i < b.length; i++) {
      String plainText = Integer.toHexString(0xff & b[i]);
      if (plainText.length() < 2) {
        hexString.append("0");
      }
      hexString.append(plainText);
    }
    return hexString.toString();
  }
  private static byte[] _convertKeyIv(String text) throws IOException {
    if (text.length() == 8) {
      return text.getBytes(UTF8);
    }
    if (text.startsWith("0x") && text.length() == 32) {
      byte[] result = new byte[8];
      for (int i = 0; i < text.length(); i += 2) {
        if (text.charAt(i++) == '0' && text.charAt(i++) == 'x') {
          try {
            result[i / 4] = (byte) Integer.parseInt(
                text.substring(i, i + 2), 16);
          } catch (Exception e) {
            throw new IOException("TXT '" + text + "' is invalid!");
          }
        }
      }
      return result;
    }
    throw new IOException("TXT '" + text + "' is invalid!");
  }
  /*
   * SecretKey & IvParameterSpec的缓存
   */
  private static Cache SecretKeySpecs = new Cache() {
    protected Object createValue(Object key) throws Exception {
      SecretKey secretKeyObj = null;
      try {
        secretKeyObj = secretKeyFactory.generateSecret(new DESKeySpec(
            _convertKeyIv((String) key)));
      } catch (Exception e) {
        e.printStackTrace();
      }
      return secretKeyObj;
    }
  };
  private static Cache IvParamSpecs = new Cache() {
    protected Object createValue(Object key) throws Exception {
      IvParameterSpec ivObj = null;
      ivObj = new IvParameterSpec(_convertKeyIv((String) key));
      return ivObj;
    }
  };
  /*
   * 加密&解密
   */
  public static String encrypt(String text, String authKey, String authIv) {
    SecretKey secretKeyObj = null;
    IvParameterSpec ivObj = null;
    try {
      secretKeyObj = (SecretKey) SecretKeySpecs.get(authKey);
      ivObj = (IvParameterSpec) IvParamSpecs.get(authIv);
    } catch (Exception e) {
      e.printStackTrace();
    }
    byte[] data = null;
    try {
      data = text.getBytes(UTF8);
    } catch (Exception e) {
      e.printStackTrace();
    }
    byte[] authToken = null;
    try {
      authToken = encrypt(data, secretKeyObj, ivObj);
    } catch (Exception e) {
      e.printStackTrace();
    }
    return hexToString(authToken);
  }
  public static byte[] encrypt(byte[] data, SecretKey secretKey,
      IvParameterSpec iv) throws Exception {
    Cipher cipher = Cipher.getInstance(CIPHER);
    cipher.init(Cipher.ENCRYPT_MODE, secretKey, iv);
    return cipher.doFinal(data);
  }
  public static String decrypt(String hexString, String authKey, String authIv)
      throws Exception {
    SecretKey secretKeyObj = null;
    IvParameterSpec ivObj = null;
    try {
      secretKeyObj = (SecretKey) SecretKeySpecs.get(authKey);
      ivObj = (IvParameterSpec) IvParamSpecs.get(authIv);
    } catch (Exception e) {
      e.printStackTrace();
    }
    String text = decrypt(hexString, secretKeyObj, ivObj);
    return text;
  }
  public static String decrypt(String message, SecretKey secretKey,
      IvParameterSpec iv) throws Exception {
    byte[] data = stringToHex(message);
    return decrypt(data, secretKey, iv);
  }
  public static String decrypt(byte[] data, SecretKey secretKey,
      IvParameterSpec iv) throws Exception {
    Cipher cipher = Cipher.getInstance(CIPHER);
    cipher.init(Cipher.DECRYPT_MODE, secretKey, iv);
    byte[] retByte = cipher.doFinal(data);
    return new String(retByte);
  }
  public static void main(String[] args) throws Exception {
    long begin= new Date().getTime();
    String authKey = "w8f3k9c2";
    String authIv = "w8f3k9c2";
    String text = "aaades加密测试";
    // 140CB412BA03869F
    // 140cb412ba03869f
    // 对原文进行加密
    String encryptedText = encrypt(text, authKey, authIv);
    System.out.println("encryptedText:" + encryptedText);
    // 对密文进行还原
    String plainText = decrypt(encryptedText, authKey, authIv);
    System.out.println("plainText:" + plainText);
    //2a329740ce15f549be64190b183a5be2
    long end =new Date().getTime();
    System.out.println(end-begin);
  }
}

PS：关于加密解密感兴趣的朋友还可以参考本站在线工具：

密码安全性在线检测：
http://tools./password/my_password_safe

高强度密码生成器：
http://tools./password/CreateStrongPassword

迅雷、快车、旋风URL加密/解密工具：
http://tools./password/urlrethunder

在线散列/哈希算法加密工具：
http://tools./password/hash_encrypt

在线MD5/hash/SHA-1/SHA-2/SHA-256/SHA-512/SHA-3/RIPEMD-160加密工具：
http://tools./password/hash_md5_sha

在线sha1/sha224/sha256/sha384/sha512加密工具：
http://tools./password/sha_encode

希望本文所述对大家java程序设计有所帮助。

# java  # Des  # 对称  # 加密算法  # 加密  # 解密  # java 实现DES 加密解密的示例  # Python和Java进行DES加密和解密的实例  # Java实现的3des加密解密工具类示例  # Java实现的DES加密解密工具类实例  # Java使用Hutool实现AES、DES加密解密的方法  # Java实现DES加密与解密  # md5加密以及Java实现MD5加密解密类  # PHP、Java des加密解密实例  # java中DES加密解密  # java使用des加密解密示例分享  # [J2SE]Java中3DES加密解密调用示例  # plsql实现DES对称加密 Java解密  # 键值  # 随机数  # 转换为  # 只对  # 不透明  # 都是  # 数源  # 会有  # 可信任  # 加密工具  # 此类  # 转化为  # 创建一个  # 进行了  # 过程中  # 加密解密  # 使用了  # 在这里  # 也有  # 都必须 

相关文章： 香港服务器网站推广：SEO优化与外贸独立站搭建策略  微信小程序 五星评分(包括半颗星评分)实例代码  如何快速查询网址的建站时间与历史轨迹？  高端建站如何打造兼具美学与转化的品牌官网？  东莞专业网站制作公司有哪些,东莞招聘网站哪个好？  ,石家庄四十八中学官网？  英语简历制作免费网站推荐,如何将简历翻译成英文？  ,网页ppt怎么弄成自己的ppt？  文字头像制作网站推荐软件,醒图能自动配文字吗？  详解ASP.NET 生成二维码实例（采用ThoughtWorks.QRCode和QrCode.Net两种方式）  建站之星安装步骤有哪些常见问题？  Avalonia如何实现跨窗口通信 Avalonia窗口间数据传递  建站之星体验版：智能建站系统+响应式设计，多端适配快速建站  潍坊网站制作公司有哪些,潍坊哪家招聘网站好？  Android自定义listview布局实现上拉加载下拉刷新功能  Android使用GridView实现日历的简单功能  专业网站设计制作公司,如何制作一个企业网站，建设网站的基本步骤有哪些？  车管所网站制作流程,交警当场开简易程序处罚决定书，在交警网站查询不到怎么办？  建站主机默认首页配置指南：核心功能与访问路径优化  北京营销型网站制作公司,可以用python做一个营销推广网站吗？  移民网站制作流程,怎么看加拿大移民官网？  重庆网站制作公司哪家好,重庆中考招生办官方网站？  深圳网站制作平台,深圳市做网站好的公司有哪些？  Python lxml的etree和ElementTree有什么区别  建站之星后台搭建步骤解析：模板选择与产品管理实操指南  如何解决ASP生成WAP建站中文乱码问题？  阿里云网站制作公司,阿里云快速搭建网站好用吗？  合肥制作网站的公司有哪些,合肥聚美网络科技有限公司介绍？  非常酷的网站设计制作软件,酷培ai教育官方网站？  建站与域名管理如何高效结合？  定制建站模板如何实现SEO优化与智能系统配置？18字教程  音乐网站服务器如何优化API响应速度？  如何选择适合PHP云建站的开源框架？  建站主机与虚拟主机有何区别？如何选择最优方案？  整蛊网站制作软件,手机不停的收到各种网站的验证码短信,是手机病毒还是人为恶搞?有这种手机病毒吗？  如何通过虚拟主机快速完成网站搭建？  如何选择高效可靠的多用户建站源码资源？  如何安全更换建站之星模板并保留数据？  如何选择PHP开源工具快速搭建网站？  北京网页设计制作网站有哪些,继续教育自动播放怎么设置？  建站之星在线版空间：自助建站+智能模板一键生成方案  建站之星下载版如何获取与安装？  如何制作公司的网站链接,公司想做一个网站，一般需要花多少钱？  矢量图网站制作软件,用千图网的一张矢量图做公司app首页，该网站并未说明版权等问题，这样做算不算侵权？应该如何解决？  如何在自有机房高效搭建专业网站？  为什么Go需要go mod文件_Go go mod文件作用说明  深圳网站制作费用多少钱,读秀，深圳文献港这样的网站很多只提供网上试读，但有些人只要提供试读的文章就能全篇下载，这个是怎么弄的？  网站制作模板下载什么软件,ppt模板免费下载网站？  如何破解联通资金短缺导致的基站建设难题？  手机钓鱼网站怎么制作视频,怎样拦截钓鱼网站。怎么办？