content: package com.orange.verify.common.rsa;
  
  import org.apache.commons.codec.binary.Base64;
  import sun.misc.BASE64Decoder;
  
  import javax.crypto.Cipher;
  import java.security.*;
  import java.security.interfaces.RSAPrivateKey;
  import java.security.interfaces.RSAPublicKey;
  import java.security.spec.PKCS8EncodedKeySpec;
  import java.security.spec.X509EncodedKeySpec;
  import java.util.HashMap;
  import java.util.Map;
  
  
  /**
   * 非对称加密算法RSA算法组件
   * 非对称算法一般是用来传送对称加密算法的密钥来使用的，相对于DH算法，RSA算法只需要一方构造密钥，不需要
   * 大费周章的构造各自本地的密钥对了。DH算法只能算法非对称算法的底层实现。而RSA算法算法实现起来较为简单
   *
   * @author kongqz
   */
  public class RsaUtil {
  
      //非对称密钥算法
      public static final String KEY_ALGORITHM = "RSA";
  
      /**
       * 密钥长度，DH算法的默认密钥长度是1024
       * 密钥长度必须是64的倍数，在512到65536位之间
       */
      private static final int KEY_SIZE = 1024;
  
      //公钥
      private static final String PUBLIC_KEY = "RSAPublicKey";
  
      //私钥
      private static final String PRIVATE_KEY = "RSAPrivateKey";
  
      /**
       * 初始化密钥对
       *
       * @return Map 甲方密钥的Map
       */
      public static Map<String, Object> initKey() throws Exception {
  
          //实例化密钥生成器
          KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);
          //初始化密钥生成器
          keyPairGenerator.initialize(KEY_SIZE);
          //生成密钥对
          KeyPair keyPair = keyPairGenerator.generateKeyPair();
          //甲方公钥
          RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
          //甲方私钥
          RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
          //将密钥存储在map中
          Map<String, Object> keyMap = new HashMap<String, Object>();
  
          keyMap.put(PUBLIC_KEY, publicKey);
          keyMap.put(PRIVATE_KEY, privateKey);
  
          return keyMap;
      }
  
      /**
       * 私钥加密
       *
       * @param data 待加密数据
       * @param key  密钥
       * @return byte[] 加密数据
       */
      private static byte[] encryptByPrivateKey(byte[] data, byte[] key) throws Exception {
  
          //取得私钥
          PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);
          KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
          //生成私钥
          PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
          //数据加密
          Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
          cipher.init(Cipher.ENCRYPT_MODE, privateKey);
          return cipher.doFinal(data);
      }
  
      /**
       * 公钥加密
       *
       * @param data 待加密数据
       * @param key  密钥
       * @return byte[] 加密数据
       */
      private static byte[] encryptByPublicKey(byte[] data, byte[] key) throws Exception {
  
          //实例化密钥工厂
          KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
          //初始化公钥
          //密钥材料转换
          X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
          //产生公钥
          PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);
  
          //数据加密
          Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
          cipher.init(Cipher.ENCRYPT_MODE, pubKey);
          return cipher.doFinal(data);
      }
  
      /**
       * 私钥解密
       *
       * @param data 待解密数据
       * @param key  密钥
       * @return byte[] 解密数据
       */
      private static byte[] decryptByPrivateKey(byte[] data, byte[] key) throws Exception {
          //取得私钥
          PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);
          KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
          //生成私钥
          PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
          //数据解密
          Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
          cipher.init(Cipher.DECRYPT_MODE, privateKey);
          return cipher.doFinal(data);
      }
  
      /**
       * 公钥解密
       *
       * @param data 待解密数据
       * @param key  密钥
       * @return byte[] 解密数据
       */
      private static byte[] decryptByPublicKey(byte[] data, byte[] key) throws Exception {
  
          //实例化密钥工厂
          KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
          //初始化公钥
          //密钥材料转换
          X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
          //产生公钥
          PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);
          //数据解密
          Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
          cipher.init(Cipher.DECRYPT_MODE, pubKey);
          return cipher.doFinal(data);
      }
  
      /**
       * 取得私钥
       *
       * @param keyMap 密钥map
       * @return byte[] 私钥
       */
      private static byte[] getPrivateKey(Map<String, Object> keyMap) {
          Key key = (Key) keyMap.get(PRIVATE_KEY);
          return key.getEncoded();
      }
  
      /**
       * 取得公钥
       *
       * @param keyMap 密钥map
       * @return byte[] 公钥
       */
      private static byte[] getPublicKey(Map<String, Object> keyMap) throws Exception {
          Key key = (Key) keyMap.get(PUBLIC_KEY);
          return key.getEncoded();
      }
  
      /**
       * 生成公钥 base64加密返回 String
       */
      public static String getPublicKeyToBase64(Map<String, Object> keyMap) throws Exception {
          byte[] publicKey = getPublicKey(keyMap);
          return Base64.encodeBase64String(publicKey);
      }
  
      /**
       * 生成私钥 base64加密返回 String
       */
      public static String getPrivateKeyToBase64(Map<String, Object> keyMap) throws Exception {
          byte[] privateKey = getPrivateKey(keyMap);
          return Base64.encodeBase64String(privateKey);
      }
  
      /**
       * 私钥解密 base64首先解密To byte 再私钥解密
       */
      public static String decodeRsa(String rsa, String privateKey) throws Exception {
  
          BASE64Decoder decoder = new BASE64Decoder();
          byte[] buf = decoder.decodeBuffer(rsa);
          byte[] bytes = decoder.decodeBuffer(privateKey);
          byte[] result = decryptByPrivateKey(buf, bytes);
  
          return new String(result);
      }
  
  }