devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

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

作者：知新_RL | 2024-07-29 10:15:20

赞

踩

java base64加密

目录

Java：密码算法

1、base64加密方式

2、jdk原生api实现MD5

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

4、SHA加密

5、MAC算法加密

6、对称加密

7、非对称加密

Java：密码算法

1、base64算法

  1. public class demo {
  2.     //设置编码格式
  3.     private static final String UTF8 = StandardCharsets.UTF_8.name();
  4.  
  5.     public static void main(String[] args) throws UnsupportedEncodingException {
  6.         String str = "张三写java";
  7.         //编码
  8.         String encodedStr = Base64.getEncoder().encodeToString(str.getBytes(UTF8));
  9.         System.out.println("encodedStr:" + encodedStr);
  10.  
  11.         //解码
  12.         byte[] decode = Base64.getDecoder().decode(encodedStr.getBytes(UTF8));
  13.         System.out.println("decode:"+ new String(decode,UTF8));
  14.  
  15.     }
  16. }

结果：

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

URL编码

  1. public class URLTest {
  2.     //设置编码格式
  3.     private static final String UTF8 = StandardCharsets.UTF_8.name();
  4.  
  5.     public static void main(String[] args) throws UnsupportedEncodingException {
  6.         String str = "张三写java";
  7.         //编码
  8.         String encodedStr = URLEncoder.encode(str,UTF8);
  9.         System.out.println("编码:"+encodedStr);
  10.         //解码
  11.         String decode = URLDecoder.decode(encodedStr,UTF8);
  12.         System.out.println("解码后："+decode);
  13.  
  14.     }
  15. }

结果：

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

11111111--->ff

2、jdk原生api实现MD5

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

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

  1. public class HexUtils {
  2.     
  3.     /**
  4.      * @description 把字节数组转为16进制字符串，如果一个字节转为16进制字符后不足两位，则前面补0
  5.      * @author
  6.      * @date 2023-02-23 21:02:13
  7.      * @param digestBytes
  8.      * @return {@link String}
  9.      */
  10.     public static String converBytes(byte[] digestBytes) {
  11.         StringBuilder sb = new StringBuilder();
  12.         for (byte b : digestBytes) {
  13.             //获取b的补码的后8位
  14.             String hex = Integer.toHexString(((int)b)&0xff);
  15.             // 15-->Integer.toHexString (15&Oxff)-->f-->0f
  16.             // 16-- >Integer.toHexString(16&0xff)->10
  17.             if (hex.length() == 1){
  18.                 hex = "0" + hex;
  19.             }
  20.             sb.append(hex);
  21.         }
  22.         return sb.toString();
  23.     }
  24.      /**
  25.      * 把16进制字符串(一定是偶数位的，因为converBytes已经处理过)转为字节数组
  26.      * @param hexStr 16进制字符串
  27.      * @return
  28.      */
  29.     public static byte[] converHex2Bytes(String hexStr) {
  30.         //一个字节可以转为2个16进制字符
  31.         int length = hexStr.length() / 2;
  32.  
  33.         byte[] reault = new byte[length];
  34.  
  35.         for (int i = 0; i < length; i++) {
  36.             //hexStr : abcd
  37.             //Integer.parseInt :把s转为10进制数，radix指定s是什么进制的数
  38.             //获取每个字节的高4位, hexStr.substring(2,3)=>c
  39.             int high4 = Integer.parseInt(hexStr.substring(i * 2,i * 2 + 1),16);
  40.             //获取每个字节的低4位，hexStr.substring( 3,4)=>d
  41.             int low4 = Integer.parseInt(hexStr.substring(i * 2 + 1,i * 2 + 2),16);
  42.             reault[i] = (byte) (high4* 16 + low4);
  43.         }
  44.    return reault;
  45. }
  1. public class MessageDigestUtils {
  2.     //设置编码格式
  3.     private static final String UTF8 = StandardCharsets.UTF_8.name();
  4.     /**
  5.      * @description 执行信息再要
  6.      * @author
  7.      * @date 2023-02-23 21:09:55
  8.      * @param originContent 原始字符串
  9.      * @param algorithm 算法名字，如MD5
  10.      * @return {@link String}
  11.      */
  12.     public static String doDigest(String originContent,String algorithm){
  13.  
  14.         try {
  15.             //获取消息摘要算法对象
  16.             MessageDigest md = MessageDigest.getInstance(algorithm);
  17.             //  获取原始内容的字节数组
  18.             byte[] originalBytes = originContent.getBytes(UTF8);
  19.             //获取到摘要结果
  20.             byte[] digestBytes = md.digest(originalBytes);
  21.             //当originalBytes比较大的时候,循环的进行update()
  22.             //md.update(originalBytes);
  23.             //md.digest();
  24.             //把每一个字节转为16进制字符，最终再拼接起来这些16进制字符
  25.             String hexStr = HexUtils.converBytes(digestBytes);
  26.             return hexStr;
  27.         }catch (Exception e){
  28.             e.printStackTrace();
  29.         }
  30.         return null;
  31.     }
  32. }

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

  1.         <dependency>
  2.             <groupId>commons-codec</groupId>
  3.             <artifactId>commons-codec</artifactId>
  4.             <version>1.15</version>
  5.         </dependency>
  1. public class MD5Test {
  2.     //设置编码格式
  3.     private static final String UTF8 = StandardCharsets.UTF_8.name();
  4.  
  5.     public static void main(String[] args) throws Exception {
  6.         String str = "张三写java";
  7.         System.out.println( "str:" + DigestUtils.md5Hex(str.getBytes(UTF8)));
  8.     }
  9. }

结果： 

4、SHA加密

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

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

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

SHA-256加密：

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

结果：

SHA-512

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

5、MAC算法加密

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

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

  1. /**
  2.      * @description 获取mac的消息摘要
  3.      * @author
  4.      * @date 2023-02-23 21:37:36
  5.      * @param originContent 原始内容
  6.      * @param algorithm mac算法的key
  7.      * @param key 算法名字，例如HmacMD5
  8.      * @return {@link String}
  9.      */
  10.     public static String doMacDigest(String originContent,String algorithm,String key){
  11.  
  12.         try {
  13.             //获取消息摘要算法对象
  14.             Mac mac = Mac.getInstance(algorithm);
  15.             //
  16.             SecretKey secretKey = new SecretKeySpec(key.getBytes(UTF8),algorithm);
  17.             mac.init(secretKey);
  18.             //  获取原始内容的字节数组
  19.             byte[] originalBytes = originContent.getBytes(UTF8);
  20.             //获取到摘要结果
  21.             byte[] digestBytes = mac.doFinal(originalBytes);
  22.             //当originalBytes比较大的时候,循环的进行update()
  23.             //md.update(originalBytes);
  24.             //md.digest();
  25.             //把每一个字节转为16进制字符，最终再拼接起来这些16进制字符
  26.             String hexStr = HexUtils.converBytes(digestBytes);
  27.             return hexStr;
  28.         }catch (Exception e){
  29.             e.printStackTrace();
  30.         }
  31.         return null;
  32.     }

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

  1. public class MACTest {
  2.     //设置编码格式
  3.     private static final String UTF8 = StandardCharsets.UTF_8.name();
  4.     public static void main(String[] args) throws Exception {
  5.         String str = "张三写java";
  6.         String algorithm1 = "HmacMD5";
  7.         String algorithm2 = "HmacSHA256";
  8.         String algorithm3 = "HmacSHA512";
  9.         //指定秘钥, mac摘要和digest算法( md5 , sha)不同的地方就是加了盐
  10.         String key = "123";
  11.         //封装的类进行编码
  12.         String hexStr1 = MessageDigestUtils.doMacDigest(str,algorithm1,key);
  13.         String hexStr2 = MessageDigestUtils.doMacDigest(str,algorithm2,key);
  14.         String hexStr3 = MessageDigestUtils.doMacDigest(str,algorithm3,key);
  15.         System.out.println("HmacMD5：" + hexStr1);
  16.         System.out.println("HmacMD5：" + hexStr2);
  17.         System.out.println("HmacMD5：" + hexStr3);
  18.  
  19.         String hmacMD5HexStr = new HmacUtils(HmacAlgorithms.HMAC_MD5,key.getBytes(UTF8)).hmacHex(str.getBytes(UTF8));
  20.         String hmacSHA256HexStr = new HmacUtils(HmacAlgorithms.HMAC_SHA_256,key.getBytes(UTF8)).hmacHex(str.getBytes(UTF8));
  21.         String hmacSHA512HexStr = new HmacUtils(HmacAlgorithms.HMAC_SHA_512,key.getBytes(UTF8)).hmacHex(str.getBytes(UTF8));
  22.         System.out.println("hmacMD5HexStr:"+ hmacMD5HexStr);
  23.         System.out.println("hmacSHA256HexStr:"+ hmacSHA256HexStr);
  24.         System.out.println("hmacSHA512HexStr:"+ hmacSHA512HexStr);
  25.     }
  26. }

结果： 

6、对称加密

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

DES : data encryption standard，已经过时

AES : advanced encryption standard,替代des。
 

DES：使用Base64加密

  1. public class DesTest {
  2.     //设置编码格式
  3.     private static final String UTF8 = StandardCharsets.UTF_8.name();
  4.     private static final String KEY = "12345678";
  5.     //加密模式
  6.     private static final String ALGORITHM = "DES";
  7.  
  8.     /**
  9.      * 加密
  10.      * @param text 加密内容
  11.      * @return
  12.      */
  13.     public static String encrypt(String text) throws Exception {
  14.         //获取示例
  15.         Cipher cipher = Cipher.getInstance(ALGORITHM);
  16.         //创建加密规则
  17.         SecretKey secretKey = new SecretKeySpec(KEY.getBytes(UTF8), ALGORITHM);
  18.         //加密模式规则
  19.         cipher.init(Cipher.ENCRYPT_MODE,secretKey);
  20.         byte[] bytes = cipher.doFinal(text.getBytes(UTF8));
  21.         //1,使用Base64 2,转成16进制
  22.         return Base64.encodeBase64String(bytes);
  23.     }
  24.  
  25.     /**
  26.      *  解密
  27.      * @param encodedText 加密后的字符串
  28.      * @return
  29.      * @throws Exception
  30.      */
  31.     public static String decrypt(String encodedText) throws Exception {
  32.         //获取示例
  33.         Cipher cipher = Cipher.getInstance(ALGORITHM);
  34.         //创建加密规则
  35.         SecretKey secretKey = new SecretKeySpec(KEY.getBytes(UTF8), ALGORITHM);
  36.         //加密模式规则
  37.         cipher.init(Cipher.DECRYPT_MODE,secretKey);
  38.         byte[] bytes = cipher.doFinal(Base64.decodeBase64(encodedText.getBytes(UTF8)));
  39.         //1,使用Base64
  40.         return new String(bytes,UTF8);
  41.     }
  42.  
  43.     public static void main(String[] args) throws Exception {
  44.          String str = "张三写java";
  45.         //加密
  46.         String encodedText = encrypt(str);
  47.         System.out.println("base64编码加密后的结果"+encodedText);
  48.         //解密
  49.         String decrypt = decrypt(encodedText);
  50.         System.out.println("des解密后的结果"+decrypt);
  51.     }
  52. }

结果：

 AES：16进制加密模式

  1. public class AesTest {
  2.     //设置编码格式
  3.     private static final String UTF8 = StandardCharsets.UTF_8.name();
  4.     //aes默认key的长度 16，24，32位
  5.     private static final String KEY = "12345678abcdefgh";
  6.     //加密模式
  7.     private static final String ALGORITHM = "AES";
  8.  
  9.     /**
  10.      * 加密
  11.      * @param text 加密内容
  12.      * @return
  13.      */
  14.     public static String encrypt(String text) throws Exception {
  15.         Cipher cipher = getCipher(Cipher.ENCRYPT_MODE, KEY);
  16.         byte[] bytes = cipher.doFinal(text.getBytes(UTF8));
  17.         //转成16进制
  18.         return HexUtils.converBytes(bytes);
  19.     }
  20.  
  21.     /**
  22.      *  解密
  23.      * @param encodedText 16进制编码后的字符串
  24.      * @return
  25.      * @throws Exception
  26.      */
  27.     public static String decrypt(String encodedText) throws Exception {
  28.         byte[] bytes = HexUtils.converHex2Bytes(encodedText);
  29.         Cipher cipher = getCipher(Cipher.DECRYPT_MODE, KEY);
  30.         byte[] decryptedBytes = cipher.doFinal(bytes);
  31.         //2,转成16进制
  32.         return new String(decryptedBytes,UTF8);
  33.     }
  34.  
  35.     /**
  36.      * 获取Cipher对象
  37.      * @param type 加密解密模式
  38.      * @param seed 密钥
  39.      * @return
  40.      * @throws Exception
  41.      */
  42.     public static Cipher getCipher(int type,String seed) throws Exception{
  43.         //获取示例
  44.         Cipher cipher = Cipher.getInstance(ALGORITHM);
  45.         //创建加密规则
  46.         SecretKey secretKey = new SecretKeySpec(seed.getBytes(UTF8), ALGORITHM);
  47.         //加密模式规则
  48.         cipher.init(type,secretKey);
  49.  
  50.         return cipher;
  51.     }
  52.  
  53.     public static void main(String[] args) throws Exception {
  54.         String str = "张三写java";
  55.         //加密
  56.         String encodedText = encrypt(str);
  57.         System.out.println("16进制编码aes加密后的结果"+encodedText);
  58.         //解密
  59.         String decrypt = decrypt(encodedText);
  60.         System.out.println("aes解密后的结果"+decrypt);
  61.     }
  62. }

 

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

  1. public class AesTest {
  2.     //设置编码格式
  3.     private static final String UTF8 = StandardCharsets.UTF_8.name();
  4.     //aes默认key的长度 16，24，32位
  5.     private static final String KEY = "12345678";
  6.     //加密模式
  7.     private static final String ALGORITHM = "AES";
  8.  
  9.     /**
  10.      * 加密
  11.      * @param text 加密内容
  12.      * @return
  13.      */
  14.     public static String encrypt(String text) throws Exception {
  15.         Cipher cipher = getCipher(Cipher.ENCRYPT_MODE, KEY);
  16.         byte[] bytes = cipher.doFinal(text.getBytes(UTF8));
  17.         //转成16进制
  18.         return HexUtils.converBytes(bytes);
  19.     }
  20.  
  21.     /**
  22.      *  解密
  23.      * @param encodedText 16进制编码后的字符串
  24.      * @return
  25.      * @throws Exception
  26.      */
  27.     public static String decrypt(String encodedText) throws Exception {
  28.         byte[] bytes = HexUtils.converHex2Bytes(encodedText);
  29.         Cipher cipher = getCipher(Cipher.DECRYPT_MODE, KEY);
  30.         byte[] decryptedBytes = cipher.doFinal(bytes);
  31.         //2,转成16进制
  32.         return new String(decryptedBytes,UTF8);
  33.     }
  34.  
  35.     /**
  36.      * 获取Cipher对象
  37.      * @param type 加密解密模式
  38.      * @param seed 密钥
  39.      * @return
  40.      * @throws Exception
  41.      */
  42.     public static Cipher getCipher(int type,String seed) throws Exception{
  43.         //获取示例
  44.         Cipher cipher = Cipher.getInstance(ALGORITHM);
  45.         //创建加密规则
  46.         //创建keyGenerator对象，可以根据传入的key生成一个指定长度的key
  47.         KeyGenerator keyGenerator = KeyGenerator.getInstance(ALGORITHM);
  48.         //初始化secureRandom，并指定生成指定长度key的算法
  49.         SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
  50.         secureRandom.setSeed(seed.getBytes(UTF8));
  51.         keyGenerator.init(128,secureRandom);
  52.         //通过keyGenerator生成新的秘钥
  53.         SecretKey secretKey = keyGenerator.generateKey();
  54.         //获取到新秘钥的字节数组
  55.         byte[] encoded = secretKey.getEncoded();
  56.         SecretKeySpec secretKeySpec = new SecretKeySpec(encoded, ALGORITHM);
  57.  
  58.         //加密模式规则
  59.         cipher.init(type,secretKeySpec);
  60.  
  61.         return cipher;
  62.     }
  63.  
  64.     public static void main(String[] args) throws Exception {
  65.         String str = "张三写java";
  66.         //加密
  67.         String encodedText = encrypt(str);
  68.         System.out.println("16进制编码aes加密后的结果"+encodedText);
  69.         //解密
  70.         String decrypt = decrypt(encodedText);
  71.         System.out.println("aes解密后的结果"+decrypt);
  72.     }
  73. }

AES：base64加密模式 

  1. public class AesBase64Test {
  2.     //设置编码格式
  3.     private static final String UTF8 = StandardCharsets.UTF_8.name();
  4.     private static final String KEY = "12345678";
  5.     //加密模式
  6.     private static final String ALGORITHM = "AES";
  7.  
  8.     /**
  9.      * 加密
  10.      * @param text 加密内容
  11.      * @return
  12.      */
  13.     public static String encrypt(String text) throws Exception {
  14.         Cipher cipher = getCipher(Cipher.ENCRYPT_MODE, KEY);
  15.         byte[] bytes = cipher.doFinal(text.getBytes(UTF8));
  16.         //1,使用Base64 2,转成16进制
  17.         return Base64.encodeBase64String(bytes);
  18.     }
  19.  
  20.     /**
  21.      *  解密
  22.      * @param encodedText 加密后的字符串
  23.      * @return
  24.      * @throws Exception
  25.      */
  26.     public static String decrypt(String encodedText) throws Exception {
  27.         Cipher cipher = getCipher(Cipher.DECRYPT_MODE, KEY);
  28.         byte[] bytes = cipher.doFinal(Base64.decodeBase64(encodedText.getBytes(UTF8)));
  29.         //1,使用Base64 2,转成16进制
  30.         return new String(bytes,UTF8);
  31.     }
  32.  
  33.     public static Cipher getCipher(int type,String seed) throws Exception{
  34.         //获取示例
  35.         Cipher cipher = Cipher.getInstance(ALGORITHM);
  36.         //创建加密规则
  37.         //创建keyGenerator对象，可以根据传入的key生成一个指定长度的key
  38.         KeyGenerator keyGenerator = KeyGenerator.getInstance(ALGORITHM);
  39.         //初始化secureRandom，并指定生成指定长度key的算法
  40.         SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
  41.         secureRandom.setSeed(seed.getBytes(UTF8));
  42.         keyGenerator.init(128,secureRandom);
  43.         //通过keyGenerator生成新的秘钥
  44.         SecretKey secretKey = keyGenerator.generateKey();
  45.         //获取到新秘钥的字节数组
  46.         byte[] encoded = secretKey.getEncoded();
  47.         SecretKeySpec secretKeySpec = new SecretKeySpec(encoded, ALGORITHM);
  48.  
  49.         //加密模式规则
  50.         cipher.init(type,secretKeySpec);
  51.  
  52.         return cipher;
  53.     }
  54.  
  55.     /**
  56.      * 测试
  57.      * @param args
  58.      * @throws Exception
  59.      */
  60.     public static void main(String[] args) throws Exception {
  61.         String str = "张三写java";
  62.         //加密
  63.         String encodedText = encrypt(str);
  64.         System.out.println("base64编码aes加密后的结果" + encodedText);
  65.         //解密
  66.         String decrypt = decrypt(encodedText);
  67.         System.out.println("aes解密后的结果" + decrypt);
  68.     }
  69. }

7、非对称加密

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

是自己保留。

常见算法：RSA

应用场景：

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

密。

  1. public class RSATest2 {
  2.     public static final String CHARSET = "UTF-8";
  3.     public static final String RSA_ALGORITHM = "RSA";
  4.  
  5.     //生成密钥对，一般来说执行一次就行
  6.     public static Map<String, String> createKeys(int keySize) {
  7.         //为RSA算法创建一个KeyPairGenerator对象（KeyPairGenerator，密钥对生成器，用于生成公钥和私钥对）
  8.         KeyPairGenerator kpg;
  9.         try {
  10.             kpg = KeyPairGenerator.getInstance(RSA_ALGORITHM);
  11.         } catch (NoSuchAlgorithmException e) {
  12.             throw new IllegalArgumentException("No such algorithm-->[" + RSA_ALGORITHM + "]");
  13.         }
  14.  
  15.         //初始化KeyPairGenerator对象,密钥长度
  16.         kpg.initialize(keySize);
  17.         //生成密匙对
  18.         KeyPair keyPair = kpg.generateKeyPair();
  19.         //得到公钥
  20.         Key publicKey = keyPair.getPublic();
  21.         String publicKeyStr = Base64.encodeBase64URLSafeString(publicKey.getEncoded()); //返回一个publicKey经过二次加密后的字符串
  22.         //得到私钥
  23.         Key privateKey = keyPair.getPrivate();
  24.         String privateKeyStr = Base64.encodeBase64URLSafeString(privateKey.getEncoded()); //返回一个privateKey经过二次加密后的字符串
  25.  
  26.         Map<String, String> keyPairMap = new HashMap<String, String>();
  27.         keyPairMap.put("publicKey", publicKeyStr);
  28.         keyPairMap.put("privateKey", privateKeyStr);
  29.  
  30.         return keyPairMap;
  31.     }
  32.  
  33.     /**
  34.      * 得到公钥
  35.      *
  36.      * @param publicKey 密钥字符串（经过base64编码）
  37.      * @throws Exception
  38.      */
  39.     public static RSAPublicKey getPublicKey(String publicKey) throws Exception {
  40.         //通过X509编码的Key指令获得公钥对象
  41.         KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
  42.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(Base64.decodeBase64(publicKey));
  43.         RSAPublicKey key = (RSAPublicKey) keyFactory.generatePublic(x509KeySpec);
  44.         return key;
  45.     }
  46.  
  47.     /**
  48.      * 得到私钥
  49.      *
  50.      * @param privateKey 密钥字符串（经过base64编码）
  51.      * @throws Exception
  52.      */
  53.     public static RSAPrivateKey getPrivateKey(String privateKey) throws Exception {
  54.         //通过PKCS#8编码的Key指令获得私钥对象
  55.         KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
  56.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(Base64.decodeBase64(privateKey));
  57.         RSAPrivateKey key = (RSAPrivateKey) keyFactory.generatePrivate(pkcs8KeySpec);
  58.         return key;
  59.     }
  60.  
  61.     /**
  62.      * 公钥加密
  63.      *
  64.      * @param data
  65.      * @param publicKey
  66.      * @return
  67.      */
  68.     public static String publicEncrypt(String data, RSAPublicKey publicKey) {
  69.         try {
  70.             Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
  71.             cipher.init(Cipher.ENCRYPT_MODE, publicKey);
  72.             return Base64.encodeBase64URLSafeString(rsaSplitCodec(cipher, Cipher.ENCRYPT_MODE, data.getBytes(CHARSET), publicKey.getModulus().bitLength()));
  73.         } catch (Exception e) {
  74.             throw new RuntimeException("加密字符串[" + data + "]时遇到异常", e);
  75.         }
  76.     }
  77.  
  78.     /**
  79.      * 私钥解密
  80.      *
  81.      * @param data
  82.      * @param privateKey
  83.      * @return
  84.      */
  86.     public static String privateDecrypt(String data, RSAPrivateKey privateKey) {
  87.         try {
  88.             Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
  89.             cipher.init(Cipher.DECRYPT_MODE, privateKey);
  90.             return new String(rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, Base64.decodeBase64(data), privateKey.getModulus().bitLength()), CHARSET);
  91.         } catch (Exception e) {
  92.             throw new RuntimeException("解密字符串[" + data + "]时遇到异常", e);
  93.         }
  94.     }
  95.  
  96.     /**
  97.      * 私钥加密
  98.      *
  99.      * @param data
  100.      * @param privateKey
  101.      * @return
  102.      */
  104.     public static String privateEncrypt(String data, RSAPrivateKey privateKey) {
  105.         try {
  106.             Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
  107.             cipher.init(Cipher.ENCRYPT_MODE, privateKey);
  108.             return Base64.encodeBase64URLSafeString(rsaSplitCodec(cipher, Cipher.ENCRYPT_MODE, data.getBytes(CHARSET), privateKey.getModulus().bitLength()));
  109.         } catch (Exception e) {
  110.             throw new RuntimeException("加密字符串[" + data + "]时遇到异常", e);
  111.         }
  112.     }
  113.  
  114.     /**
  115.      * 公钥解密
  116.      *
  117.      * @param data
  118.      * @param publicKey
  119.      * @return
  120.      */
  122.     public static String publicDecrypt(String data, RSAPublicKey publicKey) {
  123.         try {
  124.             Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
  125.             cipher.init(Cipher.DECRYPT_MODE, publicKey);
  126.             return new String(rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, Base64.decodeBase64(data), publicKey.getModulus().bitLength()), CHARSET);
  127.         } catch (Exception e) {
  128.             throw new RuntimeException("解密字符串[" + data + "]时遇到异常", e);
  129.         }
  130.     }
  131.  
  132.     private static byte[] rsaSplitCodec(Cipher cipher, int opmode, byte[] datas, int keySize) {
  133.         int maxBlock = 0;
  134.         if (opmode == Cipher.DECRYPT_MODE) {
  135.             maxBlock = keySize / 8;
  136.         } else {
  137.             maxBlock = keySize / 8 - 11;
  138.         }
  139.         ByteArrayOutputStream out = new ByteArrayOutputStream();
  140.         int offSet = 0;
  141.         byte[] buff;
  142.         int i = 0;
  143.         try {
  144.             while (datas.length > offSet) {
  145.                 if (datas.length - offSet > maxBlock) {
  146.                     buff = cipher.doFinal(datas, offSet, maxBlock);
  147.                 } else {
  148.                     buff = cipher.doFinal(datas, offSet, datas.length - offSet);
  149.                 }
  150.                 out.write(buff, 0, buff.length);
  151.                 i++;
  152.                 offSet = i * maxBlock;
  153.             }
  154.         } catch (Exception e) {
  155.             throw new RuntimeException("加解密阀值为[" + maxBlock + "]的数据时发生异常", e);
  156.         }
  157.         byte[] resultDatas = out.toByteArray();
  158.         IOUtils.closeQuietly(out);
  159.         return resultDatas;
  160.     }
  161.  
  162.  
  163.  
  164.     //测试
  165.     public static void main(String[] args) throws Exception {
  166.         //生成公私钥
  167.         Map<String, String> keyMap = RSATest2.createKeys(512);
  168.         //公钥
  169.         String publicKey = keyMap.get("publicKey");
  170.         
  171.         //私钥
  172.         String privateKey = keyMap.get("privateKey");
  173.  
  174.  
  175.         System.out.println("公钥加密——私钥解密");
  176.         String str = "法外狂徒张三";
  177.         System.out.println("明文：" + str);
  178.         System.out.println("明文大小：" + str.getBytes().length);
  179.         //对内容进行公钥加密
  180.         String encodedData = RSATest2.publicEncrypt(str, RSATest2.getPublicKey(publicKey));
  181.         System.out.println("公钥加密密文：" + encodedData);
  182.         //用私钥对密文进行解密
  183.  
  184.         String decodedData = RSATest2.privateDecrypt(encodedData, RSATest2.getPrivateKey(privateKey));
  185.         System.out.println("解密后文字: " + decodedData);
  186.     }
  187.  
  188. }

2、数字签名

3、数字信封

4、数字证书

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

非对称加密参考：java实现非对称加密（RSA）_qq_1473179505的博客-CSDN博客

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/898320
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号