Java中的调皮的AES实例

Java中实现AES加解密实例

首先带大家了解下java中一些加密的方式（在此不做详细介绍喽–亲们–我将看过的一些文章链接给大家推荐一下吧！）

1. BASE64加密~~~~https://blog.csdn.net/jiahao1186/article/details/83661862
2. MD5加密~~~https://www.cnblogs.com/Marydon20170307/p/9116924.html
3. 对称加密~~~推荐本文章–哈哈哈
4. 非对称加密~~~https://www.cnblogs.com/aotemanzhifu/p/9192369.html
5. 数字签名~~~https://www.cnblogs.com/nongzihong/p/12133324.html
6. 数字证书~~~https://blog.csdn.net/jianggujin/article/details/53486725

友情提示：本人之前一直在看博客，但从未写过它！这是我的第一次，我将奉献给大家~~~同样呢开始写博客，也是想记录我工作中的一些知识和问题，不断的提示自己有什么写的不好的地方欢迎大家提出来纠正我的错误以免被别人看到在去实行。可以互相关注一起学习哦！ 2020年8月23日

AES（对称加密）概念：

1.对称加密概念：相对来说它是一种简单，速度快的一种加密方式，即加密与解密用的都是同一个密钥（secret key）

AES（对称加密）流程:

2.对称加密流程：其实整个流程很好理解~~发送方使用密钥将明文数据加密成密文，然后发送出去，接收方收到密文后，使用同一个密钥将密文解密成明文读取。给大家找到了一个流程图，图中很文字已经很直观的表达了整个流程

我：小二附上流程图~~~别耽误大家阅读
小二：好嘞！装模作样的爷！

AES（对称加密）优点与不足：

3.对称加密优点与不足：先来说说优点吧！

1. 其实已有优点来说，在第一点概念的时候就说了一点，对称加密因为使用单钥（同个秘钥）所以它的速度上快，简单易用，计算量小。
2. 已单钥来说更为方便简单记忆，只需要一个秘钥好记也不会乱。
3. 同时呢，看过很多文章 对称加密呢 都是对海量数据加密时帮助最大。

3.对称加密优点与不足：其次咱们说不足！

1. 密钥传输问题：由于对称加密的加密和解密使用的是同一个密钥，所以对称加密的安全性就不仅仅取决于加密算法本身的强度，更取决于密钥是否被安全的保管，因此加密者如何把密钥安全的传递到解密者手里，就成了对称加密面临的关键问题。

上面所说只是冰山一角还有好多知识~

下面进入主题吧，奉上代码与链接

Java代码方式1

/**
     * AES加密字符串
     * 
     * @param content
     *            需要被加密的字符串
     * @param password
     *            加密需要的密码
     * @return 密文
     */
    public static byte[] encrypt(String content, String password) {
        try {
            KeyGenerator kgen = KeyGenerator.getInstance("AES");// 创建AES的Key生产者

            kgen.init(128, new SecureRandom(password.getBytes()));// 利用用户密码作为随机数初始化出
                                                                    // 128位的key生产者
            //加密没关系，SecureRandom是生成安全随机数序列，password.getBytes()是种子，只要种子相同，序列就一样，所以解密只要有password就行

            SecretKey secretKey = kgen.generateKey();// 根据用户密码，生成一个密钥

            byte[] enCodeFormat = secretKey.getEncoded();// 返回基本编码格式的密钥，如果此密钥不支持编码，则返回
                                                            // null。

            SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");// 转换为AES专用密钥

            Cipher cipher = Cipher.getInstance("AES");// 创建密码器

            byte[] byteContent = content.getBytes("utf-8");

            cipher.init(Cipher.ENCRYPT_MODE, key);// 初始化为加密模式的密码器

            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();
        }
        return null;
    }

/**
     * 解密AES加密过的字符串
     * 
     * @param content
     *            AES加密过过的内容
     * @param password
     *            加密时的密码
     * @return 明文
     */
    public static byte[] decrypt(byte[] content, String password) {
        try {
            KeyGenerator kgen = KeyGenerator.getInstance("AES");// 创建AES的Key生产者
            kgen.init(128, new SecureRandom(password.getBytes()));
            SecretKey secretKey = kgen.generateKey();// 根据用户密码，生成一个密钥
            byte[] enCodeFormat = secretKey.getEncoded();// 返回基本编码格式的密钥
            SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");// 转换为AES专用密钥
            Cipher cipher = Cipher.getInstance("AES");// 创建密码器
            cipher.init(Cipher.DECRYPT_MODE, key);// 初始化为解密模式的密码器
            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();
        }
        return null;
    }

		/**
		 * 进制转换工具类
		 * @author tanjierong
		 *
		 */
		public class ParseSystemUtil {
		
		    /**将二进制转换成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 = AesTest.encrypt(content, password);
        System.out.println("加密后的内容：" + new String(encrypt));
        
        //如果想要加密内容不显示乱码，可以先将密文转换为16进制
        String hexStrResult = ParseSystemUtil.parseByte2HexStr(encrypt);
        System.out.println("16进制的密文："  + hexStrResult);
        
        //如果的到的是16进制密文，别忘了先转为2进制再解密
        byte[] twoStrResult = ParseSystemUtil.parseHexStr2Byte(hexStrResult);
                
        // 解密
        byte[] decrypt = AesTest.decrypt(encrypt, password);
        System.out.println("解密后的内容：" + new String(decrypt));    
    }

	输出内容：
	
	加密之前：美女，约吗？
	加密后的内容：P�d�g�K�3�g�����,Ꝏ?U納�
	16进制的密文：50FE6401E867A34BD533FE67BB85EDABFED62CEA9D8E3F5516E7B48D01F21A5F
	解密后的内容：美女，约吗？

之前在公司做项目，因加急给登录后端增加一个加解密的环节，所以在网上看到最多的方式是这种方式，但这种方式用上之后根据我自己的测试，只能通过代码中加密在解密这个流程走，如果你想单独解密一个从其他地方加密后的 密文 就不行 会一直报一个错！

javax.crypto.IllegalBlockSizeException: Input length must be multiple of 16 when decrypting with padded cipher

这个文章讲了点关于报这个错的大概原因，但我看博主也未解决~~~~~https://www.cnblogs.com/larrylawrence/p/3619693.html

也因为当时项目急。没去太深研究，有哪位大佬知道可以告诉于我谢谢啦！
然后我又看到一个文章 里面包含了有前后端的使用~~~~~~~~

java代码方式2

  //static String data = "123456RWEQR";
    static String key = "1234567891234567";  //16位
    static String iv = "1234567891234567";  //16位

    public static void main(String args[]) throws Exception {
        System.out.println(encryptAES("你好"));
        System.out.println(decryptAES(encryptAES("你好")));
    }

    public static String encryptAES(String data) throws Exception {
        try {
            Cipher cipher = Cipher.getInstance("AES/CBC/NOPadding");   //参数分别代表 算法名称/加密模式/数据填充方式
            int blockSize = cipher.getBlockSize();

            byte[] dataBytes = data.getBytes();
            int plaintextLength = dataBytes.length;
            if (plaintextLength % blockSize != 0) {
                plaintextLength = plaintextLength + (blockSize - (plaintextLength % blockSize));
            }

            byte[] plaintext = new byte[plaintextLength];
            System.arraycopy(dataBytes, 0, plaintext, 0, dataBytes.length);

            SecretKeySpec keyspec = new SecretKeySpec(key.getBytes(), "AES");
            IvParameterSpec ivspec = new IvParameterSpec(iv.getBytes());

            cipher.init(Cipher.ENCRYPT_MODE, keyspec, ivspec);
            byte[] encrypted = cipher.doFinal(plaintext);

            return new sun.misc.BASE64Encoder().encode(encrypted);//System.out.println(new String(Base64.encodeBase64(encrypted)));
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public static String decryptAES(String data) throws Exception {
        try {
            byte[] encrypted1 = new BASE64Decoder().decodeBuffer(data);

            Cipher cipher = Cipher.getInstance("AES/CBC/NOPadding");
            SecretKeySpec keyspec = new SecretKeySpec(key.getBytes(), "AES");
            IvParameterSpec ivspec = new IvParameterSpec(iv.getBytes());

            cipher.init(Cipher.DECRYPT_MODE, keyspec, ivspec);
            byte[] original = cipher.doFinal(encrypted1);

            return new String(original);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

这种方式完全可以单独的去加密解密，其实根据我的理解，大家看第一种方式 生成的key是通过KeyGenerator类去生成，而第二中方式是直接定义的但必须16位，各位记好了必须16位，16位！

大家可以看一下这个文章：https://segmentfault.com/a/1190000015943620?utm_source=tag-newest
里面有说到这些：

这个链接是方式2的链接大家可以学习下，其实加密也包含了很多知识，冰山一角的二分一我觉得都不算哈哈哈 努力学习吧！https://www.jianshu.com/p/34c15b8d025a

最后呢希望吧，希望这篇文档可以帮助到人，总的写下来确实对自己有所帮助哦！