• java多种加密和解密方式

    一、java加密和解密方式

    1.BASE64加密/解密

    Base64 编码是我们程序开发中经常使用到的编码方法，它用 64 个可打印字符来表示二进制数据。这 64 个字符是：小写字母 a-z、大写字母 A-Z、数字 0-9、符号"+"、"/"（再加上作为垫字的"="，实际上是 65 个字符），其他所有符号都转换成这个字符集中的字符。Base64 编码通常用作存储、传输一些二进制数据编码方法，所以说它本质上是一种将二进制数据转成文本数据的方案。

    通常用作对二进制数据进行加密，示例：

    1. import sun.misc.BASE64Decoder;
    2. import sun.misc.BASE64Encoder;
    3.  
    4. public class Base64Util {
    5.  
    6.     /***
    7.      * BASE64解密
    8.      * @param key
    9.      * @return
    10.      * @throws Exception
    11.      */
    12.     public static byte[] decryBASE64(String key) throws Exception{
    13.         return (new BASE64Decoder()).decodeBuffer(key);
    14.     }
    15.     
    16.     /***
    17.      * BASE64加密
    18.      * @param key
    19.      * @return
    20.      * @throws Exception
    21.      */
    22.     public static String encryptBASE64(byte[] key) throws Exception{
    23.         return (new BASE64Encoder()).encode(key);
    24.     }
    25.     
    26. }

    2.MD5(Message Digest Algorithm)加密

    MD5 是将任意长度的数据字符串转化成短小的固定长度的值的单向操作，任意两个字符串不应有相同的散列值。因此 MD5 经常用于校验字符串或者文件，因为如果文件的 MD5 不一样，说明文件内容也是不一样的，如果发现下载的文件和给定的 MD5 值不一样，就要慎重使用。

    MD5 主要用做数据一致性验证、数字签名和安全访问认证，而不是用作加密。比如说用户在某个网站注册账户时，输入的密码一般经过 MD5 编码，更安全的做法还会加一层盐（salt），这样密码就具有不可逆性。然后把编码后的密码存入数据库，下次登录的时候把密码 MD5 编码，然后和数据库中的作对比，这样就提升了用户账户的安全性。

    是一种单向加密算法，只能加密不能解密，示例：

    1. import java.security.MessageDigest;
    2.  
    3. public class MD5Util {
    4.  
    5.     public static final String KEY_MD5 = "MD5";  
    6.     
    7.     /***
    8.      * MD5加密（生成唯一的MD5值）
    9.      * @param data
    10.      * @return
    11.      * @throws Exception
    12.      */
    13.     public static byte[] encryMD5(byte[] data) throws Exception {
    14.         MessageDigest md5 = MessageDigest.getInstance(KEY_MD5);
    15.         md5.update(data);
    16.         return md5.digest();
    17.     }
    18.     
    19. }

    3.DES(Data Encryption Standard)对称加密/解密

    DES 是一种对称加密算法，所谓对称加密算法就是：加密和解密使用相同密钥的算法。DES 加密算法出自 IBM 的研究，后来被美国政府正式采用，之后开始广泛流传。但近些年使用越来越少，因为 DES 使用 56 位密钥，以现代的计算能力，24 小时内即可被破解。

    顺便说一下 3DES（Triple DES），它是 DES 向 AES 过渡的加密算法，使用 3 条 56 位的密钥对数据进行三次加密。是 DES 的一个更安全的变形。它以 DES 为基本模块，通过组合分组方法设计出分组加密算法。比起最初的 DES，3DES 更为安全。

    使用 Java 实现 DES 加密解密，注意密码长度要是 8 的倍数。加密和解密的 Cipher 构造参数一定要相同，不然会报错。

    数据加密标准算法,和BASE64最明显的区别就是有一个工作密钥，该密钥既用于加密、也用于解密，并且要求密钥是一个长度至少大于8位的字符串，示例：

    1. import java.security.Key;
    2. import java.security.SecureRandom;
    3.  
    4. import javax.crypto.Cipher;
    5. import javax.crypto.KeyGenerator;
    6.  
    7. import sun.misc.BASE64Decoder;
    8. import sun.misc.BASE64Encoder;
    9.  
    10. public class DesUtil {
    11.  
    12.     private static Key key;
    13.     
    14.     private static String KEY_STR="myKey";
    15.     private static String CHARSETNAME="UTF-8";
    16.     private static String ALGORITHM="DES";
    17.     
    18.     
    19.     static {
    20.         try {
    21.             //生成DES算法对象
    22.             KeyGenerator generator=KeyGenerator.getInstance(ALGORITHM);
    23.             //运用SHA1安全策略
    24.             SecureRandom secureRandom=SecureRandom.getInstance("SHA1PRNG");
    25.             //设置上密钥种子
    26.             secureRandom.setSeed(KEY_STR.getBytes());
    27.             //初始化基于SHA1的算法对象
    28.             generator.init(secureRandom);
    29.             //生成密钥对象
    30.             key=generator.generateKey();
    31.             generator=null;
    32.         } catch (Exception e) {
    33.             throw new RuntimeException(e);
    34.         }
    35.     }
    36.     
    37.     
    38.     /***
    39.      * 获取加密的信息
    40.      * @param str
    41.      * @return
    42.      */
    43.     public static String getEncryptString(String str) {
    44.         //基于BASE64编码，接收byte[]并转换成String
    45.         BASE64Encoder encoder = new BASE64Encoder();
    46.         try {
    47.             //按utf8编码
    48.             byte[] bytes = str.getBytes(CHARSETNAME);
    49.             //获取加密对象
    50.             Cipher cipher = Cipher.getInstance(ALGORITHM);
    51.             //初始化密码信息
    52.             cipher.init(Cipher.ENCRYPT_MODE, key);
    53.             //加密
    54.             byte[] doFinal = cipher.doFinal(bytes);
    55.             //byte[]to encode好的String 并返回
    56.             return encoder.encode(doFinal);
    57.         } catch (Exception e) {
    58.             throw new RuntimeException(e);
    59.         }
    60.     }
    61.     
    62.     
    63.     /***
    64.      * 获取解密之后的信息
    65.      * @param str
    66.      * @return
    67.      */
    68.     public static String getDecryptString(String str) {
    69.         BASE64Decoder decoder = new BASE64Decoder();
    70.         try {
    71.             //将字符串decode成byte[]
    72.             byte[] bytes = decoder.decodeBuffer(str);
    73.             //获取解密对象
    74.             Cipher cipher = Cipher.getInstance(ALGORITHM);
    75.             //初始化解密信息
    76.             cipher.init(Cipher.DECRYPT_MODE, key);
    77.             //解密
    78.             byte[] doFial = cipher.doFinal(bytes);
    79.             
    80.             return new String(doFial, CHARSETNAME);
    81.             
    82.         } catch (Exception e) {
    83.             throw new RuntimeException(e);
    84.         }
    85.     }
    86.     
    87. }

    4.AES（Advanced Encryption Standard） 加密/解密

    高级加密标准（英语：Advanced Encryption Standard，缩写：AES），在密码学中又称 Rijndael 加密法，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的 DES，已经被多方分析且广为全世界所使用。简单说就是 DES 的增强版，比 DES 的加密强度更高。

    AES 与 DES 一样，一共有四种加密模式：电子密码本模式（ECB）、加密分组链接模式（CBC）、加密反馈模式（CFB）和输出反馈模式（OFB）。关于加密模式的介绍，推荐这篇文章：高级加密标准AES的工作模式（ECB、CBC、CFB、OFB）

    示例代码：

    1. import javax.crypto.Cipher;
    2. import javax.crypto.spec.IvParameterSpec;
    3. import javax.crypto.spec.SecretKeySpec;
    4.  
    5. public class AESUtil {
    6.  
    7.     public static final String algorithm = "AES";
    8.     // AES/CBC/NOPaddin
    9.     // AES 默认模式
    10.     // 使用CBC模式, 在初始化Cipher对象时, 需要增加参数, 初始化向量IV : IvParameterSpec iv = new
    11.     // IvParameterSpec(key.getBytes());
    12.     // NOPadding: 使用NOPadding模式时, 原文长度必须是8byte的整数倍
    13.     public static final String transformation = "AES/CBC/NOPadding";
    14.     public static final String key = "1234567812345678";
    15.  
    16.     /***
    17.      * 加密
    18.      * @param original 需要加密的参数（注意必须是16位）
    19.      * @return
    20.      * @throws Exception
    21.      */
    22.     public static String encryptByAES(String original) throws Exception {
    23.         // 获取Cipher
    24.         Cipher cipher = Cipher.getInstance(transformation);
    25.         // 生成密钥
    26.         SecretKeySpec keySpec = new SecretKeySpec(key.getBytes(), algorithm);
    27.         // 指定模式(加密)和密钥
    28.         // 创建初始化向量
    29.         IvParameterSpec iv = new IvParameterSpec(key.getBytes());
    30.         cipher.init(Cipher.ENCRYPT_MODE, keySpec, iv);
    31.         // cipher.init(Cipher.ENCRYPT_MODE, keySpec);
    32.         // 加密
    33.         byte[] bytes = cipher.doFinal(original.getBytes());
    34.  
    35.         return Base64Util.encryptBASE64(bytes);
    36.     }
    37.  
    38.     /**
    39.      * 解密
    40.      * @param encrypted 需要解密的参数
    41.      * @return
    42.      * @throws Exception
    43.      */
    44.     public static String decryptByAES(String encrypted) throws Exception {
    45.         // 获取Cipher
    46.         Cipher cipher = Cipher.getInstance(transformation);
    47.         // 生成密钥
    48.         SecretKeySpec keySpec = new SecretKeySpec(key.getBytes(), algorithm);
    49.         // 指定模式(解密)和密钥
    50.         // 创建初始化向量
    51.         IvParameterSpec iv = new IvParameterSpec(key.getBytes());
    52.         cipher.init(Cipher.DECRYPT_MODE, keySpec, iv);
    53.         // cipher.init(Cipher.DECRYPT_MODE, keySpec);
    54.         // 解密
    55.         byte[] bytes = cipher.doFinal(Base64Util.decryBASE64(encrypted));
    56.  
    57.         return new String(bytes);
    58.     }
    59.  
    60. }

    5.HMAC(Hash Message Authentication Code，散列消息鉴别码)

    使用一个密钥生成一个固定大小的小数据块，即MAC，并将其加入到消息中，然后传输。接收方利用与发送方共享的密钥进行鉴别认证，示例：

    1. import javax.crypto.KeyGenerator;
    2. import javax.crypto.Mac;
    3. import javax.crypto.SecretKey;
    4. import javax.crypto.spec.SecretKeySpec;
    5.  
    6. public class HMACUtil {
    7.  
    8.     public static final String KEY_MAC = "HmacMD5";  
    9.     
    10.     /***
    11.      * 初始化HMAC密钥
    12.      * @return
    13.      * @throws Exception
    14.      */
    15.     public static String initMacKey() throws Exception{
    16.         
    17.         KeyGenerator keyGenerator = KeyGenerator.getInstance(KEY_MAC);
    18.         SecretKey secreKey = keyGenerator.generateKey();
    19.         return Base64Util.encryptBASE64(secreKey.getEncoded());
    20.     }
    21.     
    22.     /**
    23.      * HMAC加密
    24.      * @param data
    25.      * @param key
    26.      * @return
    27.      * @throws Exception
    28.      */
    29.     public static byte[] encryHMAC(byte[] data, String key) throws Exception{
    30.         SecretKey secreKey = new SecretKeySpec(Base64Util.decryBASE64(key), KEY_MAC);
    31.         Mac mac = Mac.getInstance(secreKey.getAlgorithm());
    32.         mac.init(secreKey);
    33.         return mac.doFinal();
    34.     }
    35.     
    36. }

    6.恺撒加密

    在密码学中，恺撒密码是一种最简单并且最广为人知的加密技术。

    它是一种替换加密的技术，明文中的所欲字母都在字母表上向后（或向前）按照一个固定的数目进行偏移后被替换成密文。

    例如：当偏移量是3的时候，所有的字母A将被替换成D，B变成E，以此类推。

    这个加密方法是以恺撒的名字命名的，当年恺撒曾用此方法与其将军们进行联系。

    恺撒密码通常被座位其他更复杂的加密方法中的一个步骤。

    1. public class KaisaUtil {
    2.  
    3.     /***
    4.      * 使用凯撒加密方式加密数据
    5.      * @param orignal 原文
    6.      * @param key 密钥
    7.      * @return 加密后的字符
    8.      */
    9.     private static String encryptKaisa(String orignal, int key) {
    10.         //将字符串转换为数组
    11.         char[] chars = orignal.toCharArray();
    12.         StringBuffer buffer = new StringBuffer();
    13.         //遍历数组
    14.         for(char aChar : chars) {
    15.             //获取字符的ASCII编码
    16.             int asciiCode = aChar;
    17.             //偏移数据
    18.             asciiCode += key;
    19.             //将偏移后的数据转为字符
    20.             char result = (char)asciiCode;
    21.             //拼接数据
    22.             buffer.append(result);
    23.         }
    24.         return buffer.toString();
    25.     }
    26.     
    27.     /**
    28.      * 使用凯撒加密方式解密数据
    29.      *
    30.      * @param encryptedData :密文
    31.      * @param key           :密钥
    32.      * @return : 源数据
    33.      */
    34.     private static String decryptKaiser(String encryptedData, int key) {
    35.         // 将字符串转为字符数组
    36.         char[] chars = encryptedData.toCharArray();
    37.         StringBuilder sb = new StringBuilder();
    38.         // 遍历数组
    39.         for (char aChar : chars) {
    40.             // 获取字符的ASCII编码
    41.             int asciiCode = aChar;
    42.             // 偏移数据
    43.             asciiCode -= key;
    44.             // 将偏移后的数据转为字符
    45.             char result = (char) asciiCode;
    46.             // 拼接数据
    47.             sb.append(result);
    48.         }
    49.  
    50.         return sb.toString();
    51.     }
    52.     
    53.     
    54.     public static void main(String[] args) {
    55.         String str = "open fire";
    56.         String encode = encryptKaisa(str, 3);
    57.         System.out.println("加密后："+encode);
    58.         
    59.         String decode = decryptKaiser(encode, 3);
    60.         System.out.println("解密后："+decode);
    61.         
    62.     }
    63.     
    64. }

     

    7.SHA(Secure Hash Algorithm，安全散列算法)

    SHA全名叫做安全散列算法，是FIPS所认证的安全散列算法。能计算出一个数字消息所对应到的，长度固定的字符串（又称消息摘要）的算法。且若输入的消息不同，它们对应到不同字符串的机率很高。

    数字签名等密码学应用中重要的工具，被广泛地应用于电子商务等信息安全领域，示例：

    1. import java.security.MessageDigest;
    2.  
    3. public class SHAUtil {
    4.  
    5.     public static final String KEY_SHA = "SHA";  
    6.     public static final String ALGORITHM = "SHA-256";
    7.     
    8.     /***
    9.      * SHA加密（比MD5更安全）
    10.      * @param data
    11.      * @return
    12.      * @throws Exception
    13.      */
    14.     public static byte[] encryptSHA(byte[] data) throws Exception{
    15.         MessageDigest sha = MessageDigest.getInstance(KEY_SHA);
    16.         sha.update(data);
    17.         return sha.digest();
    18.     }
    19.     
    20.     
    21.     public static String SHAEncrypt(final String content) {
    22.         try {
    23.             MessageDigest sha = MessageDigest.getInstance(KEY_SHA);
    24.             byte[] sha_byte = sha.digest(content.getBytes());
    25.             StringBuffer hexValue = new StringBuffer();
    26.             for (byte b : sha_byte) {
    27.                 //将其中的每个字节转成十六进制字符串：byte类型的数据最高位是符号位，通过和0xff进行与操作，转换为int类型的正整数。
    28.                 String toHexString = Integer.toHexString(b & 0xff);
    29.                 hexValue.append(toHexString.length() == 1 ? "0" + toHexString : toHexString);
    30.             }
    31.             return hexValue.toString();
    32.         } catch (Exception e) {
    33.             e.printStackTrace();
    34.         }
    35.        return "";
    36.     }
    37.  
    38.  
    39.     
    40.     //SHA-256加密
    41.     public static String SHA256Encrypt(String sourceStr) {
    42.         MessageDigest md = null;
    43.         try {
    44.             md = MessageDigest.getInstance(ALGORITHM);
    45.         } catch (NoSuchAlgorithmException e) {
    46.             e.printStackTrace();
    47.         }
    48.         if (null != md) {
    49.             md.update(sourceStr.getBytes());
    50.             String digestStr = getDigestStr(md.digest());
    51.             return digestStr;
    52.         }
    53.  
    54.         return null;
    55.     }
    56.  
    57.     private static String getDigestStr(byte[] origBytes) {
    58.         String tempStr = null;
    59.         StringBuilder stb = new StringBuilder();
    60.         for (int i = 0; i < origBytes.length; i++) {
    61.             tempStr = Integer.toHexString(origBytes[i] & 0xff);
    62.             if (tempStr.length() == 1) {
    63.                 stb.append("0");
    64.             }
    65.             stb.append(tempStr);
    66.  
    67.         }
    68.         return stb.toString();
    69.     }
    70. }

     

    8.RSA 加密/解密

    RSA算法是一种非对称加密算法，所谓非对称就是该算法需要一对密钥，若使用其中一个加密，则需要用另一个才能解密。目前它是最有影响力和最常用的公钥加密算法，能够抵抗已知的绝大多数密码攻击。从提出到现今的三十多年里，经历了各种攻击的考验，逐渐为人们接受，普遍认为是目前最优秀的公钥方案之一。

    该算法基于一个的数论事实：将两个大质数相乘十分容易，但是想要对其乘积进行因式分解却极其困难，因此可以将乘积公开作为加密密钥。由于进行的都是大数计算，RSA 最快的情况也比 DES 慢上好几倍，比对应同样安全级别的对称密码算法要慢 1000 倍左右。所以 RSA 一般只用于少量数据加密，比如说交换对称加密的密钥。

    使用 RSA 加密主要有这么几步：生成密钥对、公开公钥、公钥加密私钥解密、私钥加密公钥解密。

    示例代码：

    1. import com.sun.org.apache.xml.internal.security.utils.Base64;
    2. import javax.crypto.Cipher;
    3.  
    4. import org.apache.commons.io.FileUtils;
    5.  
    6. import java.io.ByteArrayOutputStream;
    7. import java.io.File;
    8. import java.nio.charset.Charset;
    9. import java.security.*;
    10. import java.security.spec.PKCS8EncodedKeySpec;
    11. import java.security.spec.X509EncodedKeySpec;
    12.  
    13. public class RsaUtil {
    14.  
    15.     /**
    16.      * 生成密钥对并保存在本地文件中
    17.      *
    18.      * @param algorithm : 算法
    19.      * @param pubPath   : 公钥保存路径
    20.      * @param priPath   : 私钥保存路径
    21.      * @throws Exception
    22.      */
    23.     private static void generateKeyToFile(String algorithm, String pubPath, String priPath) throws Exception {
    24.         // 获取密钥对生成器
    25.         KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
    26.         // 获取密钥对
    27.         KeyPair keyPair = keyPairGenerator.generateKeyPair();
    28.         // 获取公钥
    29.         PublicKey publicKey = keyPair.getPublic();
    30.         // 获取私钥
    31.         PrivateKey privateKey = keyPair.getPrivate();
    32.         // 获取byte数组
    33.         byte[] publicKeyEncoded = publicKey.getEncoded();
    34.         byte[] privateKeyEncoded = privateKey.getEncoded();
    35.         // 进行Base64编码
    36.         String publicKeyString = Base64.encode(publicKeyEncoded);
    37.         String privateKeyString = Base64.encode(privateKeyEncoded);
    38.         // 保存文件
    39.         FileUtils.writeStringToFile(new File(pubPath), publicKeyString, Charset.forName("UTF-8"));
    40.         FileUtils.writeStringToFile(new File(priPath), privateKeyString, Charset.forName("UTF-8"));
    41.  
    42.     }
    43.  
    44.     /**
    45.      * 从文件中加载公钥
    46.      *
    47.      * @param algorithm : 算法
    48.      * @param filePath  : 文件路径
    49.      * @return : 公钥
    50.      * @throws Exception
    51.      */
    52.     private static PublicKey loadPublicKeyFromFile(String algorithm, String filePath) throws Exception {
    53.         // 将文件内容转为字符串
    54.         String keyString = FileUtils.readFileToString(new File(filePath), Charset.forName("UTF-8"));
    55.  
    56.         return loadPublicKeyFromString(algorithm, keyString);
    57.  
    58.     }
    59.  
    60.     /**
    61.      * 从字符串中加载公钥
    62.      *
    63.      * @param algorithm : 算法
    64.      * @param keyString : 公钥字符串
    65.      * @return : 公钥
    66.      * @throws Exception
    67.      */
    68.     private static PublicKey loadPublicKeyFromString(String algorithm, String keyString) throws Exception {
    69.         // 进行Base64解码
    70.         byte[] decode = Base64.decode(keyString);
    71.         // 获取密钥工厂
    72.         KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
    73.         // 构建密钥规范
    74.         X509EncodedKeySpec keyspec = new X509EncodedKeySpec(decode);
    75.         // 获取公钥
    76.         return keyFactory.generatePublic(keyspec);
    77.  
    78.     }
    79.  
    80.     /**
    81.      * 从文件中加载私钥
    82.      *
    83.      * @param algorithm : 算法
    84.      * @param filePath  : 文件路径
    85.      * @return : 私钥
    86.      * @throws Exception
    87.      */
    88.     private static PrivateKey loadPrivateKeyFromFile(String algorithm, String filePath) throws Exception {
    89.         // 将文件内容转为字符串
    90.         String keyString = FileUtils.readFileToString(new File(filePath), Charset.forName("UTF-8"));
    91.         return loadPrivateKeyFromString(algorithm, keyString);
    92.  
    93.     }
    94.  
    95.     /**
    96.      * 从字符串中加载私钥
    97.      *
    98.      * @param algorithm : 算法
    99.      * @param keyString : 私钥字符串
    100.      * @return : 私钥
    101.      * @throws Exception
    102.      */
    103.     private static PrivateKey loadPrivateKeyFromString(String algorithm, String keyString) throws Exception {
    104.         // 进行Base64解码
    105.         byte[] decode = Base64.decode(keyString);
    106.         // 获取密钥工厂
    107.         KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
    108.         // 构建密钥规范
    109.         PKCS8EncodedKeySpec keyspec = new PKCS8EncodedKeySpec(decode);
    110.         // 生成私钥
    111.         return keyFactory.generatePrivate(keyspec);
    112.  
    113.     }
    114.  
    115.     /**
    116.      * 使用密钥加密数据
    117.      *
    118.      * @param algorithm      : 算法
    119.      * @param input          : 原文
    120.      * @param key            : 密钥
    121.      * @param maxEncryptSize : 最大加密长度(需要根据实际情况进行调整)
    122.      * @return : 密文
    123.      * @throws Exception
    124.      */
    125.     private static String encrypt(String algorithm, String input, Key key, int maxEncryptSize) throws Exception {
    126.         // 获取Cipher对象
    127.         Cipher cipher = Cipher.getInstance(algorithm);
    128.         // 初始化模式(加密)和密钥
    129.         cipher.init(Cipher.ENCRYPT_MODE, key);
    130.         // 将原文转为byte数组
    131.         byte[] data = input.getBytes();
    132.         // 总数据长度
    133.         int total = data.length;
    134.         // 输出流
    135.         ByteArrayOutputStream baos = new ByteArrayOutputStream();
    136.         decodeByte(maxEncryptSize, cipher, data, total, baos);
    137.         // 对密文进行Base64编码
    138.         return Base64.encode(baos.toByteArray());
    139.  
    140.     }
    141.  
    142.     /**
    143.      * 解密数据
    144.      *
    145.      * @param algorithm      : 算法
    146.      * @param encrypted      : 密文
    147.      * @param key            : 密钥
    148.      * @param maxDecryptSize : 最大解密长度(需要根据实际情况进行调整)
    149.      * @return : 原文
    150.      * @throws Exception
    151.      */
    152.     private static String decrypt(String algorithm, String encrypted, Key key, int maxDecryptSize) throws Exception {
    153.         // 获取Cipher对象
    154.         Cipher cipher = Cipher.getInstance(algorithm);
    155.         // 初始化模式(解密)和密钥
    156.         cipher.init(Cipher.DECRYPT_MODE, key);
    157.         // 由于密文进行了Base64编码, 在这里需要进行解码
    158.         byte[] data = Base64.decode(encrypted);
    159.         // 总数据长度
    160.         int total = data.length;
    161.         // 输出流
    162.         ByteArrayOutputStream baos = new ByteArrayOutputStream();
    163.  
    164.         decodeByte(maxDecryptSize, cipher, data, total, baos);
    165.         // 输出原文
    166.         return baos.toString();
    167.  
    168.     }
    169.  
    170.     /**
    171.      * 分段处理数据
    172.      *
    173.      * @param maxSize : 最大处理能力
    174.      * @param cipher  : Cipher对象
    175.      * @param data    : 要处理的byte数组
    176.      * @param total   : 总数据长度
    177.      * @param baos    : 输出流
    178.      * @throws Exception
    179.      */
    180.     private static void decodeByte(int maxSize, Cipher cipher, byte[] data, int total, ByteArrayOutputStream baos) throws Exception {
    181.         // 偏移量
    182.         int offset = 0;
    183.         // 缓冲区
    184.         byte[] buffer;
    185.         // 如果数据没有处理完, 就一直继续
    186.         while (total - offset > 0) {
    187.             // 如果剩余的数据 >= 最大处理能力, 就按照最大处理能力来加密数据
    188.             if (total - offset >= maxSize) {
    189.                 // 加密数据
    190.                 buffer = cipher.doFinal(data, offset, maxSize);
    191.                 // 偏移量向右侧偏移最大数据能力个
    192.                 offset += maxSize;
    193.             } else {
    194.                 // 如果剩余的数据 < 最大处理能力, 就按照剩余的个数来加密数据
    195.                 buffer = cipher.doFinal(data, offset, total - offset);
    196.                 // 偏移量设置为总数据长度, 这样可以跳出循环
    197.                 offset = total;
    198.             }
    199.             // 向输出流写入数据
    200.             baos.write(buffer);
    201.         }
    202.     }
    203. }

     加密算法的安全级别(Security Level of Cryptographic Algorithms)：

    9.PBE 加密/解密

    PBE是一种基于口令的加密算法，使用口令代替其他对称加密算法中的密钥，其特点在于口令由用户自己掌管，不借助任何物理媒体；采用随机数（这里我们叫做盐）杂凑多重加密等方法保证数据的安全性。

    PBE算法是对称加密算法的综合算法，常见算法PBEWithMD5AndDES,使用MD5和DES算法构建了PBE算法。将盐附加在口令上，通过消息摘要算法经过迭代获得构建密钥的基本材料，构建密钥后使用对称加密算法进行加密解密。

    算法/密钥长度/默认密钥长度：

    1.PBEWithMD5AndDES/56/56
    2.PBEWithMD5AndTripleDES/112,168/168
    3.PBEWithSHA1AndDESede/112,168/168
    4.PBEWithSHA1AndRC2_40/40 to 1024/128

    工作模式：CBC
    填充方式：PKCS5Padding

    示例代码：

    1. import java.security.Key;
    2. import java.security.SecureRandom;
    3.  
    4. import javax.crypto.Cipher;
    5. import javax.crypto.SecretKeyFactory;
    6. import javax.crypto.spec.PBEKeySpec;
    7. import javax.crypto.spec.PBEParameterSpec;
    8.  
    9. public class PBEUtil {
    10.  
    11.     public static final String ALGORITHM = "PBEWITHMD5andDES";
    12.     
    13.     public static final int ITERATION_COUNT = 100;
    14.     
    15.     
    16.     public static byte[] initSalt() throws Exception{
    17.         //实例化安全随机数
    18.         SecureRandom random = new SecureRandom();
    19.         return random.generateSeed(8);
    20.     }
    21.     
    22.     /***
    23.      * 转换密钥
    24.      * @param password 密码
    25.      * @return 密钥
    26.      * @throws Exception
    27.      */
    28.     private static Key toKey(String password) throws Exception{
    29.         //密钥材料
    30.         PBEKeySpec keySpec = new PBEKeySpec(password.toCharArray());
    31.         //实例化
    32.         SecretKeyFactory factory = SecretKeyFactory.getInstance(ALGORITHM);
    33.         //生成密钥
    34.         return factory.generateSecret(keySpec);
    35.     }
    36.     
    37.     /***
    38.      * 加密
    39.      * @param data 待加密数据
    40.      * @param password 密钥
    41.      * @param salt
    42.      * @return
    43.      * @throws Exception
    44.      */
    45.     public static byte[] encrypt(byte[] data, String password, byte[] salt) throws Exception{
    46.         //转换密钥
    47.         Key key = toKey(password);
    48.         //实例化PBE参数材料
    49.         PBEParameterSpec spec = new PBEParameterSpec(salt, ITERATION_COUNT);
    50.         //实例化
    51.         Cipher cipher = Cipher.getInstance(ALGORITHM);
    52.         //初始化
    53.         cipher.init(Cipher.ENCRYPT_MODE, key, spec);
    54.         return cipher.doFinal(data);
    55.     }
    56.     
    57.     
    58.     /***
    59.      * 解密
    60.      * @param data 待解密数据
    61.      * @param password 密钥
    62.      * @param salt
    63.      * @return
    64.      * @throws Exception
    65.      */
    66.     public static byte[] decrypt(byte[] data, String password, byte[] salt) throws Exception{
    67.         //转换密钥
    68.         Key key = toKey(password);
    69.         //实例化PBE参数材料
    70.         PBEParameterSpec spec = new PBEParameterSpec(salt, ITERATION_COUNT);
    71.         //实例化
    72.         Cipher cipher = Cipher.getInstance(ALGORITHM);
    73.         //初始化  
    74.         cipher.init(Cipher.DECRYPT_MODE, key, spec);
    75.         //执行操作  
    76.         return cipher.doFinal(data);  
    77.     }
    78.     
    79.     
    80.     private static String showByteArray(byte[] data) {
    81.         if(null == data) {
    82.             return null;
    83.         }
    84.         StringBuilder sb = new StringBuilder();
    85.         for(byte b : data) {
    86.             sb.append(b).append(",");
    87.         }
    88.         sb.deleteCharAt(sb.length()-1);
    89.         sb.append("");
    90.         return sb.toString();
    91.     }
    92.     
    93.     
    94.     public static void main(String[] args) throws Exception{
    95.         byte[] salt = initSalt();
    96.         System.out.println("salt："+showByteArray(salt));
    97.         String password = "1111";
    98.         System.out.println("口令："+password);
    99.         String data = "PBE数据";
    100.         System.out.println("加密前数据：String:"+data);
    101.         System.out.println("加密前数据：byte[]:"+showByteArray(data.getBytes()));
    102.         
    103.         byte[] encryptData = encrypt(data.getBytes(), password, salt);
    104.         System.out.println("加密后数据：byte[]:"+showByteArray(encryptData));
    105.         
    106.         byte[] decryptData = decrypt(encryptData, password, salt);
    107.         System.out.println("解密后数据: byte[]:"+showByteArray(decryptData));
    108.         System.out.println("解密后数据: string:"+new String(decryptData));
    109.     }
    110. }
  • 相关阅读:
    WSL2 安装、配置 Cuda、pytorch 记录
    OA项目之待开会议&历史会议&所有会议
    为什么创建百科词条？百科营销的作用
    被迫开始学习Typescript —— vue3的 props 与 interface
    Ketlle数据采集和预处理工具的认知和基本应用
    JUC——并发编程—第四部分
    2024年MathorCup数学建模思路D题思路分享
    【Python 实战】---- 实现批量图片的切割
    leetCode 123.买卖股票的最佳时机 III 动态规划 + 状态压缩
    Destoon采集翻译伪原创发布工具
  • 原文地址：https://blog.csdn.net/guanshengg/article/details/126436675