AES加密算法实现，超实用

 

问题

AES加密模式和填充方式？

AES五种加密模式？

java中的Cipher类

BadPaddingException异常解决办法

 

常用加密方式及应用场景

DES 对称加密 56位秘钥 （备注： 对称加密就是加密和解密使用秘钥相同）

由于秘钥端随着计算机性能提升变成可破解

 

AES 对称加密 128位 256位或者512位秘钥

 

 

RSA 非对称加密 （备注： 非对称加密就是加密和解密使用秘钥不同）

主要应用在数据量安全性要求高且数据量有限

 

MD5 不可逆加密 

SHA256 不可逆加密

不可逆加密主要用于网络数据传输时数据完整性的校验，当然密码有效性校验有时候也可以用

 

 

AES 常用加密模式

模式：将数据分组串起来的一种方法，只要是【分组加密】都可以用

填充： 加密数据前，讲普通文本长度拓展到需要的长度 16字节 ，注意在进行数据解密时需要去掉，具体去掉java中已经实现了具体方法，不需要开发者额外实现

 

ECB 电密码本模式 

将明文分成若干段相同的小段，然后对每一小段进行加密。

 

CBC 密码分组链接模式 

这种模式是先将明文切分成若干小段，然后每一小段与初始块（或称为初始化向量 VI）或者上一段的密文段进行异或运算后，再与密钥进行加密。

 

CTR 计算器模式

CFB 密码反馈模式（复杂）

OFB 输出反馈模式（复杂）

备注 IOS系统默认使用AES加密为   AES/CBC/ PKCS7Padding 国内jdk受技术出口限制不能提供 该填充模式，如果需要使用可以映入第三方jar包

< dependency >

      < groupId > org.bouncycastle </ groupId >

      < artifactId > bcprov-jdk16 </ artifactId >

      < version > 1.46 </ version >

</ dependency >

 

AES/CBC/PKCS5Padding 加密算法具体实现如下

 

package com.***.***.common.utils;


import javax.crypto.*;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.io.UnsupportedEncodingException;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;




/**
* @Description
* @Author: ***
* @Date: 2019-05-17
*/
public class AESUtil {
    private static final String DES_ALGORITHM = "AES";
    private static final String SECREAT_PASSWORD = "abcdefg";
    private static String IVPARAMETER="1234567890123456";
    private static String ENCRYPTION_MODE="AES/CBC/PKCS5Padding";

    public static String encrypt(String content) {
        byte[] encrypt = encrypt(content, SECREAT_PASSWORD);
        //如果想要加密内容不显示乱码，可以先将密文转换为16进制
        String hexStrResult = parseByte2HexStr(encrypt);
        return  hexStrResult;
    }
    public static String decrypt(String hexStrResult) {
        //如果的到的是16进制密文，别忘了先转为2进制再解密
        byte[] twoStrResult = parseHexStr2Byte(hexStrResult);
        byte[] decrypt = decrypt(twoStrResult, SECREAT_PASSWORD);
        String content=new String(decrypt);
        return  content;
    }


    /**
     * AES加密字符串
     *
     * @param content 需要被加密的字符串
     * @param password 加密时的密码
     * @return 密文
     */
    private static byte[] encrypt(String content,String password) {
        try {


           SecretKey secretKey = generateKey(password);
            // 返回基本编码格式的密钥，如果此密钥不支持编码，则返回
            byte[] enCodeFormat = secretKey.getEncoded();
            // 转换为AES专用密钥
            SecretKeySpec key = new SecretKeySpec(enCodeFormat, DES_ALGORITHM);
            //使用CBC模式，需要一个向量iv，可增加加密算法的强度
            IvParameterSpec iv = new IvParameterSpec(IVPARAMETER.getBytes());
            //算法/模式/填充   如果只输入算法AES 默认使用ECB/PKCS5Padding作为模式/填充
            Cipher cipher = Cipher.getInstance(ENCRYPTION_MODE);


            byte[] byteContent = content.getBytes("utf-8");
            // 初始化为加密模式的密码器
            cipher.init(Cipher.ENCRYPT_MODE, key,iv);
            // 加密
            byte[] result = cipher.doFinal(byteContent);


            return result;


        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        } catch (InvalidAlgorithmParameterException e) {
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 解密AES加密过的字符串
     *
     * @param content
     *            AES加密过过的内容
     * @param password
     *            加密时的密码
     * @return 明文
     */
    private static byte[] decrypt(byte[] content,String password) {
        try {


            // 根据用户密码，生成一个密钥
            SecretKey secretKey = generateKey(password);
            // 返回基本编码格式的密钥
            byte[] enCodeFormat = secretKey.getEncoded();
            // 转换为AES专用密钥
            SecretKeySpec key = new SecretKeySpec(enCodeFormat, DES_ALGORITHM);
            // 创建密码器
            Cipher cipher = Cipher.getInstance(ENCRYPTION_MODE);
            //使用CBC模式，需要一个向量iv，可增加加密算法的强度
            IvParameterSpec iv = new IvParameterSpec(IVPARAMETER.getBytes());
            // 初始化为解密模式的密码器
            cipher.init(Cipher.DECRYPT_MODE, key,iv);
            byte[] result = cipher.doFinal(content);
            // 明文
            return result;


        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        } catch (InvalidAlgorithmParameterException e) {
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 获得秘密密钥
     *
     * @param secretKey
     * @return
     * @throws NoSuchAlgorithmException
     */
    private static  SecretKey generateKey(String secretKey) throws NoSuchAlgorithmException{


        //防止linux下 随机生成key
        SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
        secureRandom.setSeed(secretKey.getBytes());
        // 为我们选择的DES算法生成一个KeyGenerator对象
        KeyGenerator kg = null;
        try {
            kg = KeyGenerator.getInstance(DES_ALGORITHM);
        } catch (NoSuchAlgorithmException e) {
        }
        kg.init(secureRandom);
        //kg.init(56, secureRandom);


        // 生成密钥
        return kg.generateKey();
    }


    /**将二进制转换成16进制
     * @param buf
     * @return
     */
    public static String parseByte2HexStr(byte buf[]) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < buf.length; i++) {
            String hex = Integer.toHexString(buf[i] & 0xFF);
            if (hex.length() == 1) {
                hex = '0' + hex;
            }
            sb.append(hex.toUpperCase());
        }
        return sb.toString();
    }


    /**将16进制转换为二进制
     * @param hexStr
     * @return
     */
    public static byte[] parseHexStr2Byte(String hexStr) {
        if (hexStr.length() < 1) {
            return null;
        }
        byte[] result = new byte[hexStr.length()/2];
        for (int i = 0;i< hexStr.length()/2; i++) {
            int high = Integer.parseInt(hexStr.substring(i*2, i*2+1), 16);
            int low = Integer.parseInt(hexStr.substring(i*2+1, i*2+2), 16);
            result[i] = (byte) (high * 16 + low);
        }
        return result;
    }


    public static void main(String[] args)
    {
        String content = "美女!@#$%^&*(";
        String password = "123";
        System.out.println("加密之前：" + content);
        // 加密
        byte[] encrypt = encrypt(content, password);
        System.out.println("加密后的内容：" + new String(encrypt));


        //如果想要加密内容不显示乱码，可以先将密文转换为16进制
        String hexStrResult = parseByte2HexStr(encrypt);
        System.out.println("16进制的密文："  + hexStrResult);


        //如果的到的是16进制密文，别忘了先转为2进制再解密
        byte[] twoStrResult = parseHexStr2Byte(hexStrResult);


        // 解密
        byte[] decrypt = decrypt(twoStrResult, password);
        System.out.println("解密后的内容：" + new String(decrypt));
    }


}