Hutool加密解密的使用

素颜马尾好姑娘i 2024-03-17 20:00 70阅读 0赞

<dependency>
        <groupId>cn.hutool</groupId>
        <artifactId>hutool-crypto</artifactId>
        <version>5.7.15</version>
    </dependency>

[Hutool加密解密的使用 - 码农教程][Hutool_ -]

*  采用单钥密码系统的加密方法，同一个密钥可以同时用作信息的加密和解密，这种加密方法称为对称加密，也称为单密钥加密。
 *  常见加密算法
    
     *  `DES(Data Encryption Standard)`：即数据加密标准，是一种使用密钥加密的块算法，1977年被美国联邦政府的国家标准局确定为联邦资料处理标准（FIPS），并授权在非密级政府通信中使用，随后该算法在国际上广泛流传开来。
     *  `AES(Advanced Encryption Standard)`：高级加密标准.在密码学中又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。
 *  特点
    
     *  加密速度快, 可以加密大文件
     *  密文可逆, 一旦密钥文件泄漏，就会导致数据暴露
     *  加密后编码表找不到对应字符，出现乱码，一般结合Base64使用

### 加密模式 ###

*  `ECB(Electronic codebook)`：电子密码本。需要加密的消息按照块密码的块大小被分为数个块，并对每个块进行独立加密<br>
    
     *  优点：可以并行处理数据
     *  缺点：同样的原文生成同样的密文，不能很好的保护数据
     *  同时加密，原文是一样的，加密出来的密文也是一样的
 *  `CBC(Cipher-block chaining)`：密码块链接。每个明文块先与前一个密文块进行异或后，再进行加密，每个密文块都依赖于它前面的所有明文块<br>
    
     *  优点：同样的原文生成的密文不一样
     *  缺点：串行处理数据

### 填充模式 ###

当需要按块处理的数据, 数据长度不符合块处理需求时, 按照一定的方法填充满块长的规则

*  `NoPadding`不填充
    
     *  在`DES`加密算法下, 要求原文长度必须是`8byte`的整数倍
     *  在`AES`加密算法下, 要求原文长度必须是`16byte`的整数倍
 *  `PKCS5Padding`
    
     *  数据块的大小为8位, 不够就补足

> Tips：默认情况下, 加密模式和填充模式为：`ECB/PKCS5Padding`。如果使用`CBC`模式，需要增加参数初始化向量`IV`

public class SymmetricCryptoTest {
        @Test
        public void des() {
            String text = "HelloWorld";
     
            // key：DES模式下，key必须为8位
            String key = "12345678";
            // iv：偏移量，ECB模式不需要，CBC模式下必须为8位
            String iv = "12345678";
     
            // DES des = new DES(Mode.ECB, Padding.PKCS5Padding, key.getBytes());
            DES des = new DES(Mode.CBC, Padding.PKCS5Padding, key.getBytes(), iv.getBytes());
     
            String encrypt = des.encryptBase64(text);
            System.out.println(encrypt);
     
            String decrypt = des.decryptStr(encrypt);
            System.out.println(decrypt);
        }
     
        @Test
        public void aes() {
            String text = "HelloWorld";
     
            // key：AES模式下，key必须为16位
            String key = "1234567812345678";
            // iv：偏移量，ECB模式不需要，CBC模式下必须为16位
            String iv = "1234567812345678";
     
            // AES aes = new AES(Mode.ECB, Padding.PKCS5Padding, key.getBytes());
            AES aes = new AES(Mode.CBC, Padding.PKCS5Padding, key.getBytes(), iv.getBytes());
     
            // 加密并进行Base转码
            String encrypt = aes.encryptBase64(text);
            System.out.println(encrypt);
     
            // 解密为字符串
            String decrypt = aes.decryptStr(encrypt);
            System.out.println(decrypt);
        }
    }

*  非对称加密算法又称现代加密算法。
 *  非对称加密是计算机通信安全的基石，保证了加密数据不会被破解。
 *  与对称加密算法不同，非对称加密算法需要两个密钥：公开密钥`(publickey)`和私有密钥`(privatekey)`
    
     *  公开密钥和私有密钥是一对
     *  如果用公开密钥对数据进行加密，只有用对应的私有密钥才能解密。
     *  如果用私有密钥对数据进行加密，只有用对应的公开密钥才能解密。
 *  因为加密和解密使用的是两个不同的密钥，所以这种算法叫作非对称加密算法。
 *  特点
    
     *  加密和解密使用不同的密钥
     *  处理数据的速度较慢, 因为安全级别高
 *  常见算法
    
     *  RSA
     *  ECC

public class AsymmetricCryptoTest {
        /**
         * 私钥和公钥
         */
        private static String privateKey;
        private static String publicKey;
     
        private static String encryptByPublic;
     
        /**
         * 生成公私钥
         */
        @BeforeAll
        public static void genKey() {
            KeyPair pair = SecureUtil.generateKeyPair("RSA");
            privateKey = Base64.encode(pair.getPrivate().getEncoded());
            System.out.println("私钥\t" + privateKey);
            publicKey = Base64.encode(pair.getPublic().getEncoded());
            System.out.println("公钥\t" + publicKey);
        }
     
        @Test
        public void test() {
            String text = "HelloWorld";
     
            // 初始化对象
            // 第一个参数为加密算法，不传默认为 RSA/ECB/PKCS1Padding
            // 第二个参数为私钥（Base64字符串）
            // 第三个参数为公钥（Base64字符串）
            RSA rsa = new RSA(AsymmetricAlgorithm.RSA_ECB_PKCS1.getValue(), privateKey, publicKey);
     
            // 公钥加密，私钥解密
            String encryptByPublic = rsa.encryptBase64(text, KeyType.PublicKey);
            System.out.println("公钥加密\t" + encryptByPublic);
            String decryptByPrivate = rsa.decryptStr(encryptByPublic, KeyType.PrivateKey);
            System.out.println("私钥解密\t" + decryptByPrivate);
     
            // 私钥加密，公钥解密
            String encryptByPrivate = rsa.encryptBase64(text, KeyType.PrivateKey);
            System.out.println("私钥加密\t" + encryptByPrivate);
            String decryptByPublic = rsa.decryptStr(encryptByPrivate, KeyType.PublicKey);
            System.out.println("公钥解密\t" + decryptByPublic);
     
            // 此处赋值为下一个测试用
            AsymmetricCryptoTest.encryptByPublic = encryptByPublic;
        }
     
        /**
         * 仅使用私钥解密公钥加密后的密文
         */
        @Test
        public void test2() {
            // 传入私钥以及对应的算法
            RSA rsa = new RSA(AsymmetricAlgorithm.RSA_ECB_PKCS1.getValue(), privateKey, null);
     
            // 私钥解密公钥加密后的密文
            String decrypt = rsa.decryptStr(encryptByPublic, KeyType.PrivateKey);
            System.out.println(decrypt);
        }
    }

[https://www.cnblogs.com/hdwang/p/16310314.html][https_www.cnblogs.com_hdwang_p_16310314.html]

<dependency>
                <groupId>cn.hutool</groupId>
                <artifactId>hutool-all</artifactId>
                <version>5.7.22</version>
            </dependency>
    
            <dependency>
                <groupId>org.bouncycastle</groupId>
                <artifactId>bcprov-jdk15to18</artifactId>
                <version>1.69</version>
            </dependency>

package com.hdwang.test.hutool;
    
    import cn.hutool.core.util.CharsetUtil;
    import cn.hutool.core.util.StrUtil;
    import cn.hutool.crypto.SecureUtil;
    import cn.hutool.crypto.asymmetric.KeyType;
    import cn.hutool.crypto.asymmetric.RSA;
    import cn.hutool.crypto.asymmetric.Sign;
    import cn.hutool.crypto.asymmetric.SignAlgorithm;
    
    import java.nio.charset.StandardCharsets;
    import java.security.KeyPair;
    import java.security.PrivateKey;
    import java.security.PublicKey;
    import java.util.Base64;
    
    /**
     * @author wanghuidong
     * @date 2022/5/25 21:00
     */
    public class RsaTest {
    
        public static void main(String[] args) {
            String text = "人最宝贵的是生命.生命对每个人只有一次.人的一生应当这样度过：当他回首往事的时候,不会因为虚度年华而悔恨,也不会因为碌碌无为而羞耻.这样,在临死的时候,他能够说：“我已把自己的整个的生命和全部的精力献给了世界上最壮丽的事业---------为人类的解放而斗争.”";
            System.out.println("原文：" + text);
    
            //生成公私钥对
            KeyPair pair = SecureUtil.generateKeyPair("RSA");
            PrivateKey privateKey = pair.getPrivate();
            PublicKey publicKey = pair.getPublic();
            //获得私钥
            String privateKeyStr = bytesToBase64(privateKey.getEncoded());
            System.out.println("私钥：" + privateKeyStr);
            //获得公钥
            String publicKeyStr = bytesToBase64(publicKey.getEncoded());
            System.out.println("公钥：" + publicKeyStr);
    
            RSA rsa = new RSA(privateKeyStr, publicKeyStr);
            System.out.println(rsa);
    
            //公钥加密，私钥解密
            byte[] encrypt = rsa.encrypt(StrUtil.bytes(text, CharsetUtil.CHARSET_UTF_8), KeyType.PublicKey);
            System.out.println("公钥加密：" + bytesToBase64(encrypt));
    
            byte[] decrypt = rsa.decrypt(encrypt, KeyType.PrivateKey);
            System.out.println("私钥解密：" + new String(decrypt,StandardCharsets.UTF_8));
    
    //        //私钥加密，公钥解密
    //        byte[] encrypt2 = rsa.encrypt(StrUtil.bytes(text, CharsetUtil.CHARSET_UTF_8), KeyType.PrivateKey);
    //        System.out.println("私钥加密：" + bytesToBase64(encrypt2));
    //        byte[] decrypt2 = rsa.decrypt(encrypt2, KeyType.PublicKey);
    //        System.out.println("公钥解密：" + bytesToBase64(decrypt2));
    
            Sign sign = SecureUtil.sign(SignAlgorithm.SHA256withRSA, privateKeyStr, publicKeyStr);
            //签名
            byte[] data = text.getBytes(StandardCharsets.UTF_8);
            byte[] signed = sign.sign(data);
            String signedStr = bytesToBase64(signed);
            System.out.println("签名：" + signedStr);
    
            //验证签名
            boolean verify = sign.verify(data, base64ToBytes(signedStr));
            System.out.println("验签：" + verify);
    
        }
    
        /**
         * 字节数组转Base64编码
         *
         * @param bytes 字节数组
         * @return Base64编码
         */
        private static String bytesToBase64(byte[] bytes) {
            byte[] encodedBytes = Base64.getEncoder().encode(bytes);
            return new String(encodedBytes, StandardCharsets.UTF_8);
        }
    
        /**
         * Base64编码转字节数组
         *
         * @param base64Str Base64编码
         * @return 字节数组
         */
        private static byte[] base64ToBytes(String base64Str) {
            byte[] bytes = base64Str.getBytes(StandardCharsets.UTF_8);
            return Base64.getDecoder().decode(bytes);
        }
    }

[RSA加密(Hutool)\_51CTO博客\_rsa 加密][RSA_Hutool_51CTO_rsa]

public static String rsa() {
    //        KeyPair keyPair = SecureUtil.generateKeyPair("RSA");
    //        PublicKey aPublic = keyPair.getPublic();
    //        PrivateKey aPrivate = keyPair.getPrivate();
    //        logger.info("公钥："+ Base64Encoder.encode(aPublic.getEncoded()));
    //        logger.info("私钥："+Base64Encoder.encode(aPrivate.getEncoded()));
            String publicKey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDG03gR1w6i3E6h6+N9F2///BnRrkzPc7RT4qZKKl2b/rolym0EYl3QZTsIV5oQngT93TLtld7EK5svdwUabX6kzqd8yDDChZXS/E7/FrufN6Hwf9S3O3ZzkhEyd45HmRHV4aNRFsS/NviEZx83D6FR94l0SPnomvPkVqM8UnafnQIDAQAB";
            String privateKey = "MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAMbTeBHXDqLcTqHr430Xb//8GdGuTM9ztFPipkoqXZv+uiXKbQRiXdBlOwhXmhCeBP3dMu2V3sQrmy93BRptfqTOp3zIMMKFldL8Tv8Wu583ofB/1Lc7dnOSETJ3jkeZEdXho1EWxL82+IRnHzcPoVH3iXRI+eia8+RWozxSdp+dAgMBAAECgYAJjtfqT6LR/HJBQXQ9qrdFIIrjNBRYMrE8CRzCWvgGDEBJmcoU2F+3KW6lj4SGAPqvc4dDuZ0sZAZBSWDy7MmWL+Zz2z44sulxsOsb3DJqIyBSAr5D6mhrRmu7MJA5AGgDHo/2gn+9Cji2JQBHBFe18BzJdr2tIM4uAYTVB6EW8QJBAPCrnHohSDtgLSmHrbORP/cIS8OOF/M3PsYfHZ3cpdrKk2zs1rXAHJq80GlmhSQx8tezx6wt63Cph0reiHbOMRkCQQDTfYqahFR0NTFFfTBfSJKQEqoiRYMnOrjkkOOgFv6cBwYd16pnqTfNISSYkBsOcDO09qiMILW96MoJONCV458lAkEAmMrqueK9X+zMX0xjK9hwOp5Ks2lXrTKKqO+CNwGpTkFD3WhzW8oOnvJ2giPzLSqE2QqrHpW8nrcSTKcBDiQTqQJABORmjGR7P6TrWtwmfk3Ddim4XcqV2hZ1qHPhkBZ4FUvkTFRs0LENZWVa31yWA6N8zrbV90fabGYyJjx2NsFpMQJARtRflzJjWc/49nzu+om41bz9Ngg07/S8Rxe8AlZbSlCxggmp/KUBcoVgNJCa5qGsX2AvTOCXaHngp+YLtHHPBQ==";
    
            String s = SecureUtil.rsa(privateKey, publicKey).encryptBase64("nishishui".getBytes(), KeyType.PublicKey);
            logger.info(s);
            String sq = SecureUtil.rsa(privateKey, publicKey).decryptStr("D4EpMXfrh3jbL89bBQaDjk0H9ZJFEG7aoMsectUpZciUoSZGUnscexZ4/yP1/bFlyYG5Fei5Wq/OzCkcdHkpHZkdMav3/GBe3zkMzMsNd3B0pD9is/xYzKXLlGERtM5lqrmAkCzXCA5qBHsKZctnG2gLvX1SAnJs43bezaCZ8=", KeyType.PrivateKey);
            logger.info(sq);
            return null;
        }
    
        public static void main(String[] args) {
    //        System.out.println(SMSTemplateType.USER_REGISTER);
            String loginUserId = JwtUtils.getUserId("eyJhbGciOiJIUzUxMiJ9.eyJ1c2VyX2lkIjoiMTAwMTIwMjIwNDE5MDAwMDE2MSIsInVzZXJfa2V5IjoiYTExYWU3YzItYThhNy00NGY4LWExMjMtODdmNTBmYzI4ZDQyIiwidXNlcm5hbWUiOiIxNzc3NDA3MDM2NiJ9.fjyl2VyHp8SY3MGRnUgmDPm_oJXt5tz0JZ2RVuTucl4Xzic9_FVO1pfrVThYT1qvgVLdPJIM7zHx_Di2aWbu4g");
            System.out.println(loginUserId);
        }

[Java使用Hutool工具完成加密解密\_千锋-陈.Mr的博客-CSDN博客][Java_Hutool_-_.Mr_-CSDN]

[Hutool_ -]: http://www.manongjc.com/detail/29-ejikmpeiifpgdrm.html
[https_www.cnblogs.com_hdwang_p_16310314.html]: https://www.cnblogs.com/hdwang/p/16310314.html
[RSA_Hutool_51CTO_rsa]: https://blog.51cto.com/u_15995970/6106569
[Java_Hutool_-_.Mr_-CSDN]: https://blog.csdn.net/qfchenjunbo/article/details/121202219