RSAUtil

package com.baoyun.linker.op.admin.controller.finance;



 import java.io.IOException;

 import java.security.InvalidKeyException;

 import java.security.Key;

 import java.security.KeyFactory;

 import java.security.KeyPair;

 import java.security.KeyPairGenerator;

 import java.security.MessageDigest;

 import java.security.NoSuchAlgorithmException;

 import java.security.PrivateKey;

 import java.security.PublicKey;

 import java.security.interfaces.RSAPrivateKey;

 import java.security.interfaces.RSAPublicKey;

 import java.security.spec.InvalidKeySpecException;

 import java.security.spec.PKCS8EncodedKeySpec;

 import java.security.spec.X509EncodedKeySpec;



 import javax.crypto.BadPaddingException;

 import javax.crypto.Cipher;

 import javax.crypto.IllegalBlockSizeException;

 import javax.crypto.NoSuchPaddingException;



 import lombok.extern.slf4j.Slf4j;



 import org.apache.commons.codec.binary.Hex;



 import com.baoyun.linker.op.common.util.StringUtil;



 import sun.misc.BASE64Decoder;

 import sun.misc.BASE64Encoder;



 @Slf4j

 public class RSAUtil {



     public static final String RSA = "RSA";



     /**

      * 生成RSA密钥

      * 

      * @return

      * @throws Exception

      */

     public static RSADTO generateRSA() throws Exception {

         RSADTO rsa = null;



         try {

             KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(RSA);

             keyPairGenerator.initialize(1024);



             KeyPair keyPair = keyPairGenerator.generateKeyPair();

             PublicKey publicKey = (RSAPublicKey) keyPair.getPublic();

             PrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();

             rsa = new RSADTO();

             String publicString = keyToString(publicKey);

             String privateString = keyToString(privateKey);

             rsa.setPublicKey(publicString);

             rsa.setPrivateKey(privateString);



         } catch (NoSuchAlgorithmException e) {

             log.error("--generateRSA exception:{} ", e);

             throw new Exception(e.getMessage());

         }



         return rsa;

     }



     /**

      * BASE64 String 转换为 PublicKey

      * 

      * @param publicKeyString

      * @return

      * @throws Exception

      */

     public static PublicKey getPublicKey(String publicKeyString) throws Exception {

         PublicKey publicKey = null;

         BASE64Decoder base64Decoder = new BASE64Decoder();

         try {

             byte[] keyByteArray = base64Decoder.decodeBuffer(publicKeyString);

             X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyByteArray);

             KeyFactory keyFactory = KeyFactory.getInstance(RSA);

             publicKey = keyFactory.generatePublic(x509KeySpec);

         } catch (IOException e) {

             log.error("--getPublicKey publicKeyString:{} exception:{} ", publicKeyString, e);

             throw new Exception(e.getMessage());

         }



         return publicKey;

     }



     /**

      * BASE64 String 转换为 PrivateKey

      * 

      * @param privateKeyString

      * @return

      * @throws Exception

      */

     public static PrivateKey getPrivateKey(String privateKeyString) throws Exception {

         PrivateKey privateKey = null;

         BASE64Decoder base64Decoder = new BASE64Decoder();



         try {

             byte[] keyByteArray = base64Decoder.decodeBuffer(privateKeyString);

             PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyByteArray);

             KeyFactory keyFactory = KeyFactory.getInstance(RSA);

             privateKey = keyFactory.generatePrivate(pkcs8KeySpec);

         } catch (IOException e) {

             log.error("--getPrivateKey privateKeyString:{} exception:{} ", privateKeyString, e);

             throw new Exception(e.getMessage());

         } catch (NoSuchAlgorithmException e) {

             log.error("--getPrivateKey privateKeyString:{} exception:{} ", privateKeyString, e);

             throw new Exception(e.getMessage());

         } catch (InvalidKeySpecException e) {

             log.error("--getPrivateKey privateKeyString:{} exception:{} ", privateKeyString, e);

             throw new Exception(e.getMessage());

         }



         return privateKey;



     }



     /**

      * RSA 加密返回byte[]

      * 

      * @param content

      * @param privateKey

      * @return

      * @throws Exception

      */

     public static byte[] encodeBytePrivate(byte[] content, PrivateKey privateKey) throws Exception {

         byte[] encodeContent = null;

         try {

             Cipher cipher = Cipher.getInstance(RSA);

             cipher.init(Cipher.ENCRYPT_MODE, privateKey);

             encodeContent = cipher.doFinal(content);

         } catch (NoSuchAlgorithmException e) {

             log.error("--RSA encode content:{} publicKey:{} exception:{} ", content, privateKey, e);

             throw new Exception(e.getMessage());

         } catch (NoSuchPaddingException e) {

             log.error("--RSA encode content:{} publicKey:{} exception:{} ", content, privateKey, e);

             throw new Exception(e.getMessage());

         } catch (InvalidKeyException e) {

             log.error("--RSA encode content:{} publicKey:{} exception:{} ", content, privateKey, e);

             throw new Exception(e.getMessage());

         } catch (IllegalBlockSizeException e) {

             log.error("--RSA encode content:{} publicKey:{} exception:{} ", content, privateKey, e);

             throw new Exception(e.getMessage());

         } catch (BadPaddingException e) {

             log.error("--RSA encode content:{} publicKey:{} exception:{} ", content, privateKey, e);

             throw new Exception(e.getMessage());

         }

         return encodeContent;

     }



     /**

      * RSA 加密返回 Hex

      * 

      * @param content

      * @param privateKey

      * @return

      * @throws Exception

      */

     public static String encodeStringPrivate(byte[] content, PrivateKey privateKey) throws Exception {

         byte[] encodeContent = encodeBytePrivate(content, privateKey);

         String stringContent = Hex.encodeHexString(encodeContent);

         return stringContent;

     }



     /**

      * 解密返回byte[]

      * 

      * @param content

      * @param publicKey

      * @return

      * @throws Exception

      */

     public static byte[] decodeBytePublic(byte[] content, PublicKey publicKey) throws Exception {

         byte[] decodeContent = null;

         try {

             Cipher cipher = Cipher.getInstance(RSA);

             cipher.init(Cipher.DECRYPT_MODE, publicKey);

             decodeContent = cipher.doFinal(content);

         } catch (NoSuchAlgorithmException e) {

             log.error("--RSA decode content:{} PublicKey:{} exception:{} ", content, publicKey, e);

             throw new Exception(e.getMessage());

         } catch (NoSuchPaddingException e) {

             log.error("--RSA decode content:{} PublicKey:{} exception:{} ", content, publicKey, e);

             throw new Exception(e.getMessage());

         } catch (InvalidKeyException e) {

             log.error("--RSA decode content:{} PublicKey:{} exception:{} ", content, publicKey, e);

             throw new Exception(e.getMessage());

         } catch (IllegalBlockSizeException e) {

             log.error("--RSA decode content:{} PublicKey:{} exception:{} ", content, publicKey, e);

             throw new Exception(e.getMessage());

         } catch (BadPaddingException e) {

             log.error("--RSA decode content:{} PublicKey:{} exception:{} ", content, publicKey, e);

             throw new Exception(e.getMessage());

         }

         return decodeContent;

     }



     /**

      * 解密 Hex字符串

      * 

      * @param content

      * @param publicKey

      * @return

      * @throws Exception

      */

     public static byte[] decodeStringPublic(String content, PublicKey publicKey) throws Exception {

         byte[] decodeContent = null;

         try {

             byte[] sourceByteArray = Hex.decodeHex(content.toCharArray());

             decodeContent = decodeBytePublic(sourceByteArray, publicKey);

         } catch (IOException e) {

             log.error("--decodeString content:{} privateKey:{} exception:{} ", content, publicKey, e);

             throw new Exception(e.getMessage());

         }

         return decodeContent;

     }



     /**

      * 将Key转为String

      * 

      * @param key

      * @return

      */

     private static String keyToString(Key key) {

         byte[] keyByteArray = key.getEncoded();

         BASE64Encoder base64 = new BASE64Encoder();

         String keyString = base64.encode(keyByteArray);

         return keyString;

     }

     

     public static class RSADTO {

         /**

          * 公钥

          */

         private String publicKey;



         /**

          * 私钥

          */

         private String privateKey;



public String getPublicKey() {

return publicKey;

}



public void setPublicKey(String publicKey) {

this.publicKey = publicKey;

}

public String getPrivateKey() {

return privateKey;

}



public void setPrivateKey(String privateKey) {

this.privateKey = privateKey;

}

     }

     

     public static class MD5Util {

         /**

          * MD5加密

          *

          * @param s

          * @return

          */

         public static String MD5(String s) {

             char hexDigits[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };

             try {

                 byte[] btInput = s.getBytes(StringUtil.CHARSET);

                 // 获得MD5摘要算法的 MessageDigest 对象

                 MessageDigest mdInst = MessageDigest.getInstance("MD5");

                 // 使用指定的字节更新摘要

                 mdInst.update(btInput);

                 // 获得密文

                 byte[] md = mdInst.digest();

                 // 把密文转换成十六进制的字符串形式

                 int j = md.length;

                 char str[] = new char[j * 2];

                 int k = 0;

                 for (int i = 0; i < j; i++) {

                     byte byte0 = md[i];

                     str[k++] = hexDigits[byte0 >>> 4 & 0xf];

                     str[k++] = hexDigits[byte0 & 0xf];

                 }

                 return new String(str);

             } catch (Exception e) {

                 log.error("--MD5 string:{} exception :{}", s, e);

                 return null;

             }

         }

     }



     

     public static void main(String[] args) throws Exception {

     
RSADTO dto = generateRSA();

System.out.println("私钥 :" + dto.getPrivateKey());

System.out.println("公钥 :" + dto.getPublicKey());



String paramStr = "a=1&b=2";

String privateKey = dto.getPrivateKey();

String sign = RSAUtil.encodeStringPrivate(MD5Util.MD5(paramStr).getBytes(), RSAUtil.getPrivateKey(privateKey));

System.out.println(sign);

}



 }