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

2024-04-07 19:54:06

本文实例讲述了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.jb51.net/password/my_password_safe

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

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

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

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

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

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

利用JAVA实现DES加密算法

DES加密介绍DES是一种对称加密算法,所谓对称加密算法即:加密和解密使用相同密钥的算法.DES加密算法出自IBM的研究,后来被美国政府正式采用,之后开始广泛流传,但是近些年使用越来越少,因为DES使用56位密钥,以现代计算能力,24小时内即可被破解.虽然如此,在某些简单应用中,我们还是可以使用DES加密算法,本文简单讲解DES的JAVA实现. JAVA实现加密代码有详细解释,不多废话.注意:DES加密和解密过程中,密钥长度都必须是8的倍数复制代码代码如下: public byte[] de
Java使用Hutool实现AES、DES加密解密的方法

在Java世界中,AES.DES加密解密需要使用Cipher对象构建加密解密系统,Hutool中对这一对象做再包装,简化了加密解密过程. 介绍 AES和DES同属对称加密算法,数据发信方将明文(原始数据)和加密密钥一起经过特殊加密算法处理后,使其变成复杂的加密密文发送出去.收信方收到密文后,若想解读原文,则需要使用加密用过的密钥及相同算法的逆算法对密文进行解密,才能使其恢复成可读明文.在对称加密算法中,使用的密钥只有一个,发收信双方都使用这个密钥对数据进行加密和解密,这就要求解密方事先必须知道加
PHP、Java des加密解密实例

des加密是对称加密中在互联网应用的比较多的一种加密方式,php 通过mcrypt扩展库来支持des加密,要在Php中使用des加密,需要先安装mcrypt扩展库下面是加密解密的实例复制代码代码如下: $iv_size = mcrypt_get_iv_size(MCRYPT_RIJNDAEL_256, MCRYPT_MODE_ECB); $iv = mcrypt_create_iv($iv_size, MCRYPT_RAND); $key = "This is a very secre
Java实现与JS相同的Des加解密算法完整实例

本文实例讲述了Java实现与JS相同的Des加解密算法.分享给大家供大家参考,具体如下: 这里演示java与js实现相同的des加解密算法,不多说,不废话,直接上代码一.java实现 package com.lyz.base.des; import java.util.ArrayList; import java.util.List; /** * DES加密/解密 * * @Copyright Copyright (c) 2015 * @author liuyazhuang * @see DE
兼容PHP和Java的des加密解密代码分享

php代码: <?php class DES { var $key; var $iv; //偏移量 function DES($key, $iv=0) { $this->key = $key; if($iv == 0) { $this->iv = $key; } else { $this->iv = $iv; } } //加密 function encrypt($str) { $size = mcrypt_get_block_size ( MCRYPT_DES, MCRYPT_MO
java使用des加密解密示例分享

复制代码代码如下: import java.security.Key;import java.security.SecureRandom;import java.security.spec.AlgorithmParameterSpec; import javax.crypto.Cipher;import javax.crypto.SecretKeyFactory;import javax.crypto.spec.DESKeySpec;import javax.crypto.spec.IvPar
使用java自带des加密算法实现文件加密和字符串加密

复制代码代码如下: import java.io.ByteArrayInputStream;import java.io.ByteArrayOutputStream;import java.io.File;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.InputStream;import java.io.OutputStream;import java.security.SecureR
java中使用DES加密解密实例

在前面介绍了一些加密解密类的使用,这里综合起来做一个简单的测试,代码如下: MainActivity: 复制代码代码如下: package com.home.testdes; import android.os.Bundle;import android.util.Log;import android.app.Activity; public class MainActivity extends Activity { @Override protected void onCreate(Bund
java常用工具类之DES和Base64加密解密类

一.DES加密和解密 package com.itjh.javaUtil; import java.io.UnsupportedEncodingException; import java.security.InvalidKeyException; import java.security.NoSuchAlgorithmException; import java.security.SecureRandom; import java.security.spec.InvalidKeySpecExc
Java实现DES加密与解密，md5加密以及Java实现MD5加密解密类

很多时候要对秘要进行持久化加密,此时的加密采用md5.采用对称加密的时候就采用DES方法了 import java.io.IOException; import java.security.MessageDigest; import java.security.SecureRandom; import javax.crypto.Cipher; import javax.crypto.SecretKey; import javax.crypto.SecretKeyFactory; import j
详解Java利用实现对称加密（DES、3DES、AES）

有两句话是这么说的: 1)算法和数据结构就是编程的一个重要部分,你若失掉了算法和数据结构,你就把一切都失掉了. 2)编程就是算法和数据结构,算法和数据结构是编程的灵魂. 注意,这可不是我说的,是无数程序员总结的,话说的很实在也很精辟,若想长久可持续发展,多研究算法还是很有必要的,今天我给大家说说加密算法中的对称加密算法,并且这里将教会大家对称加密算法的编程使用.包含DES.3DES和AES三种对称加密算法的编程使用,干货满满. 1.对称密码算法对称密码算法是当今应用范围最广,使用频率最高的加密

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

相关推荐

随机推荐