Java加密算法：MD5加密，对称加密，非对称加密

电玩女神 2024-03-26 13:11 157阅读 0赞

**目录**

Java：密码算法

1、base64加密方式

2、jdk原生api实现MD5

3、使用codec依赖实现MD5加密

4、SHA加密

5、MAC算法加密

6、对称加密

7、非对称加密

--------------------

### Java：密码算法 ###

#### 1、base64算法 ####

public class demo {
        //设置编码格式
        private static final String UTF8 = StandardCharsets.UTF_8.name();
    
        public static void main(String[] args) throws UnsupportedEncodingException {
            String str = "张三写java";
            //编码
            String encodedStr = Base64.getEncoder().encodeToString(str.getBytes(UTF8));
            System.out.println("encodedStr:" + encodedStr);
    
            //解码
            byte[] decode = Base64.getDecoder().decode(encodedStr.getBytes(UTF8));
            System.out.println("decode:"+ new String(decode,UTF8));
    
        }
    }

结果：

![de50de37fbf048289f5939cf6fa5687d.png][]

注意：Base64 不是加密算法，而是一种编码方式。Base64 主要用于将二进制数据编码成文本格式，以便在文本协议中传输，如在电子邮件、XML、JSON 等中。它并不是为了提供加密或安全性而设计的。

**URL编码**

public class URLTest {
        //设置编码格式
        private static final String UTF8 = StandardCharsets.UTF_8.name();
    
        public static void main(String[] args) throws UnsupportedEncodingException {
            String str = "张三写java";
            //编码
            String encodedStr = URLEncoder.encode(str,UTF8);
            System.out.println("编码:"+encodedStr);
            //解码
            String decode = URLDecoder.decode(encodedStr,UTF8);
            System.out.println("解码后："+decode);
    
        }
    }

结果：

![38e6219cd69845b6927d9671945c79f4.png][]

MD5: Message-Digest Algorithm,结果占128位==>16个byte=>转成16进制字符后是32个

11111111--->ff

#### **2、jdk原生api实现MD5** ####

public class MD5Test {
        //设置编码格式
        private static final String UTF8 = StandardCharsets.UTF_8.name();
    
        public static void main(String[] args) throws Exception {
            String str = "张三写java";
            String algorithm = "MD5";
            //获取消息摘要算法对象
            MessageDigest md = MessageDigest.getInstance(algorithm);
            //  获取原始内容的字节数组
            byte[] originalBytes = str.getBytes(UTF8);
            //获取到摘要结果
            byte[] digestBytes = md.digest(originalBytes);
            //当originalBytes比较大的时候,循环的进行update()
            //md.update(originalBytes);
            //md.digest();
            //把每一个字节转为16进制字符，最终再拼接起来这些16进制字符
           String hexStr = converBytes(digestBytes);
            System.out.println("hexStr:" + hexStr);
        }
    
        private static String converBytes(byte[] digestBytes) {
            StringBuilder sb = new StringBuilder();
            for (byte b : digestBytes) {
                //获取b的补码的后8位
                String hex = Integer.toHexString(((int)b)&0xff);
                // 15-->Integer.toHexString (15&Oxff)-->f-->0f
                // 16-- >Integer.toHexString(16&0xff)->10
                if (hex.length() == 1){
                    hex = "0" + hex;
                }
                sb.append(hex);
            }
            return sb.toString();
        }
    }

![4a07f101c57d4988871dafa723ccdffe.png][]

代码封装，把上面公共部分提取出来

public class HexUtils {
        
        /**
         * @description 把字节数组转为16进制字符串，如果一个字节转为16进制字符后不足两位，则前面补0
         * @author
         * @date 2023-02-23 21:02:13
         * @param digestBytes
         * @return {@link String}
         */
        public static String converBytes(byte[] digestBytes) {
            StringBuilder sb = new StringBuilder();
            for (byte b : digestBytes) {
                //获取b的补码的后8位
                String hex = Integer.toHexString(((int)b)&0xff);
                // 15-->Integer.toHexString (15&Oxff)-->f-->0f
                // 16-- >Integer.toHexString(16&0xff)->10
                if (hex.length() == 1){
                    hex = "0" + hex;
                }
                sb.append(hex);
            }
            return sb.toString();
        }
         /**
         * 把16进制字符串(一定是偶数位的，因为converBytes已经处理过)转为字节数组
         * @param hexStr 16进制字符串
         * @return
         */
        public static byte[] converHex2Bytes(String hexStr) {
            //一个字节可以转为2个16进制字符
            int length = hexStr.length() / 2;
    
            byte[] reault = new byte[length];
    
            for (int i = 0; i < length; i++) {
                //hexStr : abcd
                //Integer.parseInt :把s转为10进制数，radix指定s是什么进制的数
                //获取每个字节的高4位, hexStr.substring(2,3)=>c
                int high4 = Integer.parseInt(hexStr.substring(i * 2,i * 2 + 1),16);
                //获取每个字节的低4位，hexStr.substring( 3,4)=>d
                int low4 = Integer.parseInt(hexStr.substring(i * 2 + 1,i * 2 + 2),16);
                reault[i] = (byte) (high4* 16 + low4);
            }
       return reault;
    }

public class MessageDigestUtils {
        //设置编码格式
        private static final String UTF8 = StandardCharsets.UTF_8.name();
        /**
         * @description 执行信息再要
         * @author
         * @date 2023-02-23 21:09:55
         * @param originContent 原始字符串
         * @param algorithm 算法名字，如MD5
         * @return {@link String}
         */
        public static String doDigest(String originContent,String algorithm){
    
            try {
                //获取消息摘要算法对象
                MessageDigest md = MessageDigest.getInstance(algorithm);
                //  获取原始内容的字节数组
                byte[] originalBytes = originContent.getBytes(UTF8);
                //获取到摘要结果
                byte[] digestBytes = md.digest(originalBytes);
                //当originalBytes比较大的时候,循环的进行update()
                //md.update(originalBytes);
                //md.digest();
                //把每一个字节转为16进制字符，最终再拼接起来这些16进制字符
                String hexStr = HexUtils.converBytes(digestBytes);
                return hexStr;
            }catch (Exception e){
                e.printStackTrace();
            }
            return null;
        }
    }

#### 3、使用codec依赖实现MD5加密 ####

<dependency>
                <groupId>commons-codec</groupId>
                <artifactId>commons-codec</artifactId>
                <version>1.15</version>
            </dependency>

结果：

![290e4db98562486380f48d7c1faf2ad7.png][]

#### 4、SHA加密 ####

SHA(Secure Hash Algorithm) :安全散列算法

sha-256=>转成16进制字符后是64个

其他如sha-0,sha-1, sha-512

SHA-256加密：

public class Sha256Test {
        //设置编码格式
        private static final String UTF8 = StandardCharsets.UTF_8.name();
        public static void main(String[] args) throws Exception {
            String str = "张三写java";
            String algorithm = "SHA-256";
            //封装的类进行编码
            String hexStr = MessageDigestUtils.doDigest(str,algorithm);
            System.out.println("自己封装的str：" + hexStr);
    
            System.out.println("codec的str:" + DigestUtils.sha256Hex(str.getBytes(UTF8)));
        }
    }

结果：

![781a2e9ea3184f0482e6568fade2d3d2.png][]

**SHA-512**

public class SHA512Test {
        //设置编码格式
        private static final String UTF8 = StandardCharsets.UTF_8.name();
        public static void main(String[] args) throws Exception {
            String str = "张三写java";
            String algorithm = "SHA-512";
            //封装的类进行编码
            String hexStr = MessageDigestUtils.doDigest(str,algorithm);
            System.out.println("自己封装的str：" + hexStr);
    
            System.out.println("codec的str:" + DigestUtils.sha512Hex(str.getBytes(UTF8)));
        }
    }

![f10898c1c1314c418cc92e1d3357c03a.png][]

#### 5、MAC算法加密 ####

MAC(Message Authentication Code):消息认证码，是一种带有秘钥的hash函数

使用jdk实现在添加一个方法

/**
         * @description 获取mac的消息摘要
         * @author
         * @date 2023-02-23 21:37:36
         * @param originContent 原始内容
         * @param algorithm mac算法的key
         * @param key 算法名字，例如HmacMD5
         * @return {@link String}
         */
        public static String doMacDigest(String originContent,String algorithm,String key){
    
            try {
                //获取消息摘要算法对象
                Mac mac = Mac.getInstance(algorithm);
                //
                SecretKey secretKey = new SecretKeySpec(key.getBytes(UTF8),algorithm);
                mac.init(secretKey);
                //  获取原始内容的字节数组
                byte[] originalBytes = originContent.getBytes(UTF8);
                //获取到摘要结果
                byte[] digestBytes = mac.doFinal(originalBytes);
                //当originalBytes比较大的时候,循环的进行update()
                //md.update(originalBytes);
                //md.digest();
                //把每一个字节转为16进制字符，最终再拼接起来这些16进制字符
                String hexStr = HexUtils.converBytes(digestBytes);
                return hexStr;
            }catch (Exception e){
                e.printStackTrace();
            }
            return null;
        }

使用自己封装的方法及使用codec实现mac加密

public class MACTest {
        //设置编码格式
        private static final String UTF8 = StandardCharsets.UTF_8.name();
        public static void main(String[] args) throws Exception {
            String str = "张三写java";
            String algorithm1 = "HmacMD5";
            String algorithm2 = "HmacSHA256";
            String algorithm3 = "HmacSHA512";
            //指定秘钥, mac摘要和digest算法( md5 , sha)不同的地方就是加了盐
            String key = "123";
            //封装的类进行编码
            String hexStr1 = MessageDigestUtils.doMacDigest(str,algorithm1,key);
            String hexStr2 = MessageDigestUtils.doMacDigest(str,algorithm2,key);
            String hexStr3 = MessageDigestUtils.doMacDigest(str,algorithm3,key);
            System.out.println("HmacMD5：" + hexStr1);
            System.out.println("HmacMD5：" + hexStr2);
            System.out.println("HmacMD5：" + hexStr3);
    
            String hmacMD5HexStr = new HmacUtils(HmacAlgorithms.HMAC_MD5,key.getBytes(UTF8)).hmacHex(str.getBytes(UTF8));
            String hmacSHA256HexStr = new HmacUtils(HmacAlgorithms.HMAC_SHA_256,key.getBytes(UTF8)).hmacHex(str.getBytes(UTF8));
            String hmacSHA512HexStr = new HmacUtils(HmacAlgorithms.HMAC_SHA_512,key.getBytes(UTF8)).hmacHex(str.getBytes(UTF8));
            System.out.println("hmacMD5HexStr:"+ hmacMD5HexStr);
            System.out.println("hmacSHA256HexStr:"+ hmacSHA256HexStr);
            System.out.println("hmacSHA512HexStr:"+ hmacSHA512HexStr);
        }
    }

结果：

![f747795942f9484d81c10df0af92c0ad.png][]

#### 6、对称加密 ####

也叫单秘钥加密。所谓单秘钥，指的是加密和解密的过程使用相同的密钥,相比非对称加密，因只有一把钥匙，因而速度更快，更适合加解密大文件。

DES : data encryption standard，已经过时

AES : advanced encryption standard,替代des。

**DES：使用Base64加密**

public class DesTest {
        //设置编码格式
        private static final String UTF8 = StandardCharsets.UTF_8.name();
        private static final String KEY = "12345678";
        //加密模式
        private static final String ALGORITHM = "DES";
    
        /**
         * 加密
         * @param text 加密内容
         * @return
         */
        public static String encrypt(String text) throws Exception {
            //获取示例
            Cipher cipher = Cipher.getInstance(ALGORITHM);
            //创建加密规则
            SecretKey secretKey = new SecretKeySpec(KEY.getBytes(UTF8), ALGORITHM);
            //加密模式规则
            cipher.init(Cipher.ENCRYPT_MODE,secretKey);
            byte[] bytes = cipher.doFinal(text.getBytes(UTF8));
            //1,使用Base64 2,转成16进制
            return Base64.encodeBase64String(bytes);
        }
    
        /**
         *  解密
         * @param encodedText 加密后的字符串
         * @return
         * @throws Exception
         */
        public static String decrypt(String encodedText) throws Exception {
            //获取示例
            Cipher cipher = Cipher.getInstance(ALGORITHM);
            //创建加密规则
            SecretKey secretKey = new SecretKeySpec(KEY.getBytes(UTF8), ALGORITHM);
            //加密模式规则
            cipher.init(Cipher.DECRYPT_MODE,secretKey);
            byte[] bytes = cipher.doFinal(Base64.decodeBase64(encodedText.getBytes(UTF8)));
            //1,使用Base64
            return new String(bytes,UTF8);
        }
    
        public static void main(String[] args) throws Exception {
             String str = "张三写java";
            //加密
            String encodedText = encrypt(str);
            System.out.println("base64编码加密后的结果"+encodedText);
            //解密
            String decrypt = decrypt(encodedText);
            System.out.println("des解密后的结果"+decrypt);
        }
    }

结果：

![80ea42006630486b86cb70f688a7cb77.png][]

**AES：16进制加密模式**

public class AesTest {
        //设置编码格式
        private static final String UTF8 = StandardCharsets.UTF_8.name();
        //aes默认key的长度 16，24，32位
        private static final String KEY = "12345678abcdefgh";
        //加密模式
        private static final String ALGORITHM = "AES";
    
        /**
         * 加密
         * @param text 加密内容
         * @return
         */
        public static String encrypt(String text) throws Exception {
            Cipher cipher = getCipher(Cipher.ENCRYPT_MODE, KEY);
            byte[] bytes = cipher.doFinal(text.getBytes(UTF8));
            //转成16进制
            return HexUtils.converBytes(bytes);
        }
    
        /**
         *  解密
         * @param encodedText 16进制编码后的字符串
         * @return
         * @throws Exception
         */
        public static String decrypt(String encodedText) throws Exception {
            byte[] bytes = HexUtils.converHex2Bytes(encodedText);
            Cipher cipher = getCipher(Cipher.DECRYPT_MODE, KEY);
            byte[] decryptedBytes = cipher.doFinal(bytes);
            //2,转成16进制
            return new String(decryptedBytes,UTF8);
        }
    
        /**
         * 获取Cipher对象
         * @param type 加密解密模式
         * @param seed 密钥
         * @return
         * @throws Exception
         */
        public static Cipher getCipher(int type,String seed) throws Exception{
            //获取示例
            Cipher cipher = Cipher.getInstance(ALGORITHM);
            //创建加密规则
            SecretKey secretKey = new SecretKeySpec(seed.getBytes(UTF8), ALGORITHM);
            //加密模式规则
            cipher.init(type,secretKey);
    
            return cipher;
        }
    
        public static void main(String[] args) throws Exception {
            String str = "张三写java";
            //加密
            String encodedText = encrypt(str);
            System.out.println("16进制编码aes加密后的结果"+encodedText);
            //解密
            String decrypt = decrypt(encodedText);
            System.out.println("aes解密后的结果"+decrypt);
        }
    }

![b7ecadd37566436db568dcd377aec422.png][]

**AES：16进制加密模式代码优化**

public class AesTest {
        //设置编码格式
        private static final String UTF8 = StandardCharsets.UTF_8.name();
        //aes默认key的长度 16，24，32位
        private static final String KEY = "12345678";
        //加密模式
        private static final String ALGORITHM = "AES";
    
        /**
         * 加密
         * @param text 加密内容
         * @return
         */
        public static String encrypt(String text) throws Exception {
            Cipher cipher = getCipher(Cipher.ENCRYPT_MODE, KEY);
            byte[] bytes = cipher.doFinal(text.getBytes(UTF8));
            //转成16进制
            return HexUtils.converBytes(bytes);
        }
    
        /**
         *  解密
         * @param encodedText 16进制编码后的字符串
         * @return
         * @throws Exception
         */
        public static String decrypt(String encodedText) throws Exception {
            byte[] bytes = HexUtils.converHex2Bytes(encodedText);
            Cipher cipher = getCipher(Cipher.DECRYPT_MODE, KEY);
            byte[] decryptedBytes = cipher.doFinal(bytes);
            //2,转成16进制
            return new String(decryptedBytes,UTF8);
        }
    
        /**
         * 获取Cipher对象
         * @param type 加密解密模式
         * @param seed 密钥
         * @return
         * @throws Exception
         */
        public static Cipher getCipher(int type,String seed) throws Exception{
            //获取示例
            Cipher cipher = Cipher.getInstance(ALGORITHM);
            //创建加密规则
            //创建keyGenerator对象，可以根据传入的key生成一个指定长度的key
            KeyGenerator keyGenerator = KeyGenerator.getInstance(ALGORITHM);
            //初始化secureRandom，并指定生成指定长度key的算法
            SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
            secureRandom.setSeed(seed.getBytes(UTF8));
            keyGenerator.init(128,secureRandom);
            //通过keyGenerator生成新的秘钥
            SecretKey secretKey = keyGenerator.generateKey();
            //获取到新秘钥的字节数组
            byte[] encoded = secretKey.getEncoded();
            SecretKeySpec secretKeySpec = new SecretKeySpec(encoded, ALGORITHM);
    
            //加密模式规则
            cipher.init(type,secretKeySpec);
    
            return cipher;
        }
    
        public static void main(String[] args) throws Exception {
            String str = "张三写java";
            //加密
            String encodedText = encrypt(str);
            System.out.println("16进制编码aes加密后的结果"+encodedText);
            //解密
            String decrypt = decrypt(encodedText);
            System.out.println("aes解密后的结果"+decrypt);
        }
    }

**AES：base64加密模式**

public class AesBase64Test {
        //设置编码格式
        private static final String UTF8 = StandardCharsets.UTF_8.name();
        private static final String KEY = "12345678";
        //加密模式
        private static final String ALGORITHM = "AES";
    
        /**
         * 加密
         * @param text 加密内容
         * @return
         */
        public static String encrypt(String text) throws Exception {
            Cipher cipher = getCipher(Cipher.ENCRYPT_MODE, KEY);
            byte[] bytes = cipher.doFinal(text.getBytes(UTF8));
            //1,使用Base64 2,转成16进制
            return Base64.encodeBase64String(bytes);
        }
    
        /**
         *  解密
         * @param encodedText 加密后的字符串
         * @return
         * @throws Exception
         */
        public static String decrypt(String encodedText) throws Exception {
            Cipher cipher = getCipher(Cipher.DECRYPT_MODE, KEY);
            byte[] bytes = cipher.doFinal(Base64.decodeBase64(encodedText.getBytes(UTF8)));
            //1,使用Base64 2,转成16进制
            return new String(bytes,UTF8);
        }
    
        public static Cipher getCipher(int type,String seed) throws Exception{
            //获取示例
            Cipher cipher = Cipher.getInstance(ALGORITHM);
            //创建加密规则
            //创建keyGenerator对象，可以根据传入的key生成一个指定长度的key
            KeyGenerator keyGenerator = KeyGenerator.getInstance(ALGORITHM);
            //初始化secureRandom，并指定生成指定长度key的算法
            SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
            secureRandom.setSeed(seed.getBytes(UTF8));
            keyGenerator.init(128,secureRandom);
            //通过keyGenerator生成新的秘钥
            SecretKey secretKey = keyGenerator.generateKey();
            //获取到新秘钥的字节数组
            byte[] encoded = secretKey.getEncoded();
            SecretKeySpec secretKeySpec = new SecretKeySpec(encoded, ALGORITHM);
    
            //加密模式规则
            cipher.init(type,secretKeySpec);
    
            return cipher;
        }
    
        /**
         * 测试
         * @param args
         * @throws Exception
         */
        public static void main(String[] args) throws Exception {
            String str = "张三写java";
            //加密
            String encodedText = encrypt(str);
            System.out.println("base64编码aes加密后的结果" + encodedText);
            //解密
            String decrypt = decrypt(encodedText);
            System.out.println("aes解密后的结果" + decrypt);
        }
    }

![90b05fb6d9814f9bacf1b5a3940a22b5.png][]

#### **7、非对称加密** ####

定义：加密和解密使用的是两个不同的密钥(public key和private key).公钥可以给任何人，私钥总

是自己保留。

常见算法：RSA

应用场景：

1、加解密：可以使用公钥加密，对应的就是私钥解密;也可以使用私钥加密，对应的就是公钥解

密。

public class RSATest2 {
        public static final String CHARSET = "UTF-8";
        public static final String RSA_ALGORITHM = "RSA";
    
        //生成密钥对，一般来说执行一次就行
        public static Map<String, String> createKeys(int keySize) {
            //为RSA算法创建一个KeyPairGenerator对象（KeyPairGenerator，密钥对生成器，用于生成公钥和私钥对）
            KeyPairGenerator kpg;
            try {
                kpg = KeyPairGenerator.getInstance(RSA_ALGORITHM);
            } catch (NoSuchAlgorithmException e) {
                throw new IllegalArgumentException("No such algorithm-->[" + RSA_ALGORITHM + "]");
            }
    
            //初始化KeyPairGenerator对象,密钥长度
            kpg.initialize(keySize);
            //生成密匙对
            KeyPair keyPair = kpg.generateKeyPair();
            //得到公钥
            Key publicKey = keyPair.getPublic();
            String publicKeyStr = Base64.encodeBase64URLSafeString(publicKey.getEncoded()); //返回一个publicKey经过二次加密后的字符串
            //得到私钥
            Key privateKey = keyPair.getPrivate();
            String privateKeyStr = Base64.encodeBase64URLSafeString(privateKey.getEncoded()); //返回一个privateKey经过二次加密后的字符串
    
            Map<String, String> keyPairMap = new HashMap<String, String>();
            keyPairMap.put("publicKey", publicKeyStr);
            keyPairMap.put("privateKey", privateKeyStr);
    
            return keyPairMap;
        }
    
        /**
         * 得到公钥
         *
         * @param publicKey 密钥字符串（经过base64编码）
         * @throws Exception
         */
        public static RSAPublicKey getPublicKey(String publicKey) throws Exception {
            //通过X509编码的Key指令获得公钥对象
            KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(Base64.decodeBase64(publicKey));
            RSAPublicKey key = (RSAPublicKey) keyFactory.generatePublic(x509KeySpec);
            return key;
        }
    
        /**
         * 得到私钥
         *
         * @param privateKey 密钥字符串（经过base64编码）
         * @throws Exception
         */
        public static RSAPrivateKey getPrivateKey(String privateKey) throws Exception {
            //通过PKCS#8编码的Key指令获得私钥对象
            KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(Base64.decodeBase64(privateKey));
            RSAPrivateKey key = (RSAPrivateKey) keyFactory.generatePrivate(pkcs8KeySpec);
            return key;
        }
    
        /**
         * 公钥加密
         *
         * @param data
         * @param publicKey
         * @return
         */
        public static String publicEncrypt(String data, RSAPublicKey publicKey) {
            try {
                Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
                cipher.init(Cipher.ENCRYPT_MODE, publicKey);
                return Base64.encodeBase64URLSafeString(rsaSplitCodec(cipher, Cipher.ENCRYPT_MODE, data.getBytes(CHARSET), publicKey.getModulus().bitLength()));
            } catch (Exception e) {
                throw new RuntimeException("加密字符串[" + data + "]时遇到异常", e);
            }
        }
    
        /**
         * 私钥解密
         *
         * @param data
         * @param privateKey
         * @return
         */
    
        public static String privateDecrypt(String data, RSAPrivateKey privateKey) {
            try {
                Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
                cipher.init(Cipher.DECRYPT_MODE, privateKey);
                return new String(rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, Base64.decodeBase64(data), privateKey.getModulus().bitLength()), CHARSET);
            } catch (Exception e) {
                throw new RuntimeException("解密字符串[" + data + "]时遇到异常", e);
            }
        }
    
        /**
         * 私钥加密
         *
         * @param data
         * @param privateKey
         * @return
         */
    
        public static String privateEncrypt(String data, RSAPrivateKey privateKey) {
            try {
                Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
                cipher.init(Cipher.ENCRYPT_MODE, privateKey);
                return Base64.encodeBase64URLSafeString(rsaSplitCodec(cipher, Cipher.ENCRYPT_MODE, data.getBytes(CHARSET), privateKey.getModulus().bitLength()));
            } catch (Exception e) {
                throw new RuntimeException("加密字符串[" + data + "]时遇到异常", e);
            }
        }
    
        /**
         * 公钥解密
         *
         * @param data
         * @param publicKey
         * @return
         */
    
        public static String publicDecrypt(String data, RSAPublicKey publicKey) {
            try {
                Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
                cipher.init(Cipher.DECRYPT_MODE, publicKey);
                return new String(rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, Base64.decodeBase64(data), publicKey.getModulus().bitLength()), CHARSET);
            } catch (Exception e) {
                throw new RuntimeException("解密字符串[" + data + "]时遇到异常", e);
            }
        }
    
        private static byte[] rsaSplitCodec(Cipher cipher, int opmode, byte[] datas, int keySize) {
            int maxBlock = 0;
            if (opmode == Cipher.DECRYPT_MODE) {
                maxBlock = keySize / 8;
            } else {
                maxBlock = keySize / 8 - 11;
            }
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int offSet = 0;
            byte[] buff;
            int i = 0;
            try {
                while (datas.length > offSet) {
                    if (datas.length - offSet > maxBlock) {
                        buff = cipher.doFinal(datas, offSet, maxBlock);
                    } else {
                        buff = cipher.doFinal(datas, offSet, datas.length - offSet);
                    }
                    out.write(buff, 0, buff.length);
                    i++;
                    offSet = i * maxBlock;
                }
            } catch (Exception e) {
                throw new RuntimeException("加解密阀值为[" + maxBlock + "]的数据时发生异常", e);
            }
            byte[] resultDatas = out.toByteArray();
            IOUtils.closeQuietly(out);
            return resultDatas;
        }
    
    
    
        //测试
        public static void main(String[] args) throws Exception {
            //生成公私钥
            Map<String, String> keyMap = RSATest2.createKeys(512);
            //公钥
            String publicKey = keyMap.get("publicKey");
            
            //私钥
            String privateKey = keyMap.get("privateKey");
    
    
            System.out.println("公钥加密——私钥解密");
            String str = "法外狂徒张三";
            System.out.println("明文：" + str);
            System.out.println("明文大小：" + str.getBytes().length);
            //对内容进行公钥加密
            String encodedData = RSATest2.publicEncrypt(str, RSATest2.getPublicKey(publicKey));
            System.out.println("公钥加密密文：" + encodedData);
            //用私钥对密文进行解密
    
            String decodedData = RSATest2.privateDecrypt(encodedData, RSATest2.getPrivateKey(privateKey));
            System.out.println("解密后文字: " + decodedData);
        }
    
    }

2、数字签名

3、数字信封

4、数字证书

参考视频：[密码学-java信息安全,摘要算法,对称加密(AES)/非对称加密(RSA),一应俱全\_哔哩哔哩\_bilibili][-java_AES_RSA_bilibili]

非对称加密参考：[java实现非对称加密（RSA）\_qq\_1473179505的博客-CSDN博客][java_RSA_qq_1473179505_-CSDN]

[de50de37fbf048289f5939cf6fa5687d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/ac4838ed20b94eacaa47401943f7d199.png
[38e6219cd69845b6927d9671945c79f4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/4c6aa8e3f2c9432f8b870abcff47926c.png
[4a07f101c57d4988871dafa723ccdffe.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/36056159dfcc4d24a782696b89d48961.png
[290e4db98562486380f48d7c1faf2ad7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/3029c14a9a924fe98995ee60188d5497.png
[781a2e9ea3184f0482e6568fade2d3d2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/a228f787a253450bb6b93349b7de2a3b.png
[f10898c1c1314c418cc92e1d3357c03a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/613cddc5209a4f2fa65bdb877a46f629.png
[f747795942f9484d81c10df0af92c0ad.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/5a4c07f4c0f84bf7b51ef8acb825ada1.png
[80ea42006630486b86cb70f688a7cb77.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/d8f8bcefe7ea4ba083294e9d5a2dc84d.png
[b7ecadd37566436db568dcd377aec422.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/6146d4c50e094d04a43aadff7e1ab025.png
[90b05fb6d9814f9bacf1b5a3940a22b5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/095dc08d93d94e4ca111f322b44fc296.png
[-java_AES_RSA_bilibili]: https://www.bilibili.com/video/BV1i44y1C7rZ/?spm_id_from=333.337.search-card.all.click&vd_
[java_RSA_qq_1473179505_-CSDN]: https://blog.csdn.net/qq_29042647/article/details/121539436?ops_request_misc=&request_id=&biz_id=102&utm_term=java%E9%9D%9E%E5%AF%B9%E7%A7%B0%E5%8A%A0%E5%AF%86RSA&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-5-121539436.142%5Ev73%5Econtrol_1,201%5Ev4%5Eadd_ask,239%5Ev2%5Einsert_chatgpt&spm=1018.2226.3001.4187