SRA秘钥生成与解密

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.security.InvalidKeyException;

import java.security.KeyFactory;

import java.security.KeyPair;

import java.security.KeyPairGenerator;

import java.security.NoSuchAlgorithmException;

import java.security.SecureRandom;

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 java.util.Base64;

import javax.crypto.BadPaddingException;

import javax.crypto.Cipher;

import javax.crypto.IllegalBlockSizeException;

import javax.crypto.NoSuchPaddingException;

public class RSAEncrypt {

    /**

     * 字节数据转字符串专用集合

     */

    private static final char[] HEX_CHAR = { '', '', '', '', '', '', '',

            '', '', '', 'a', 'b', 'c', 'd', 'e', 'f' };

    /**

     * 随机生成密钥对

     */

    public static void genKeyPair(String filePath) {

        // KeyPairGenerator类用于生成公钥和私钥对，基于RSA算法生成对象

        KeyPairGenerator keyPairGen = null;

        try {

            keyPairGen = KeyPairGenerator.getInstance("RSA");

        } catch (NoSuchAlgorithmException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

        // 初始化密钥对生成器，密钥大小为96-1024位

        keyPairGen.initialize(,new SecureRandom());

        // 生成一个密钥对，保存在keyPair中

        KeyPair keyPair = keyPairGen.generateKeyPair();

        // 得到私钥

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

        // 得到公钥

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

        try {

            // 得到公钥字符串

            String publicKeyString =RSAEncrypt.encode(publicKey.getEncoded());

//            // 得到私钥字符串

            String privateKeyString = RSAEncrypt.encode(privateKey.getEncoded());

            // 将密钥对写入到文件

            FileWriter pubfw = new FileWriter(filePath + "/publicKey.keystore");

            FileWriter prifw = new FileWriter(filePath + "/privateKey.keystore");

            BufferedWriter pubbw = new BufferedWriter(pubfw);

            BufferedWriter pribw = new BufferedWriter(prifw);

            pubbw.write(publicKeyString);

            pribw.write(privateKeyString);

            pubbw.flush();

            pubbw.close();

            pubfw.close();

            pribw.flush();

            pribw.close();

            prifw.close();

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

    /**

     * 从文件中输入流中加载公钥

     *

     * @param in

     *            公钥输入流

     * @throws Exception

     *             加载公钥时产生的异常

     */

    public static String loadPublicKeyByFile(String path) throws Exception {

        try {

            BufferedReader br = new BufferedReader(new FileReader(path

                    + "/publicKey.keystore"));

            String readLine = null;

            StringBuilder sb = new StringBuilder();

            while ((readLine = br.readLine()) != null) {

                sb.append(readLine);

            }

            br.close();

            return sb.toString();

        } catch (IOException e) {

            throw new Exception("公钥数据流读取错误");

        } catch (NullPointerException e) {

            throw new Exception("公钥输入流为空");

        }

    }

    /**

     * 从字符串中加载公钥

     *

     * @param publicKeyStr

     *            公钥数据字符串

     * @throws Exception

     *             加载公钥时产生的异常

     */

    public static RSAPublicKey loadPublicKeyByStr(String publicKeyStr)

            throws Exception {

        try {

            byte[] buffer = RSAEncrypt.decode(publicKeyStr);

            KeyFactory keyFactory = KeyFactory.getInstance("RSA");

            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);

            return (RSAPublicKey) keyFactory.generatePublic(keySpec);

        } catch (NoSuchAlgorithmException e) {

            throw new Exception("无此算法");

        } catch (InvalidKeySpecException e) {

            throw new Exception("公钥非法");

        } catch (NullPointerException e) {

            throw new Exception("公钥数据为空");

        }

    }

    /**

     * 从文件中加载私钥

     *

     * @param keyFileName

     *            私钥文件名

     * @return 是否成功

     * @throws Exception

     */

    public static String loadPrivateKeyByFile(String path) throws Exception {

        try {

            BufferedReader br = new BufferedReader(new FileReader(path

                    + "/privateKey.keystore"));

            String readLine = null;

            StringBuilder sb = new StringBuilder();

            while ((readLine = br.readLine()) != null) {

                sb.append(readLine);

            }

            br.close();

            return sb.toString();

        } catch (IOException e) {

            throw new Exception("私钥数据读取错误");

        } catch (NullPointerException e) {

            throw new Exception("私钥输入流为空");

        }

    }

    public static RSAPrivateKey loadPrivateKeyByStr(String privateKeyStr)

            throws Exception {

        try {

            byte[] buffer = RSAEncrypt.decode(privateKeyStr);

            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer);

            KeyFactory keyFactory = KeyFactory.getInstance("RSA");

            return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);

        } catch (NoSuchAlgorithmException e) {

            throw new Exception("无此算法");

        } catch (InvalidKeySpecException e) {

            throw new Exception("私钥非法");

        } catch (NullPointerException e) {

            throw new Exception("私钥数据为空");

        }

    }

    /**

     * 公钥加密过程

     *

     * @param publicKey

     *            公钥

     * @param plainTextData

     *            明文数据

     * @return

     * @throws Exception

     *             加密过程中的异常信息

     */

    public static byte[] encrypt(RSAPublicKey publicKey, byte[] plainTextData)

            throws Exception {

        if (publicKey == null) {

            throw new Exception("加密公钥为空, 请设置");

        }

        Cipher cipher = null;

        try {

            // 使用默认RSA

            cipher = Cipher.getInstance("RSA");

            // cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());

            cipher.init(Cipher.ENCRYPT_MODE, publicKey);

            byte[] output = cipher.doFinal(plainTextData);

            return output;

        } catch (NoSuchAlgorithmException e) {

            throw new Exception("无此加密算法");

        } catch (NoSuchPaddingException e) {

            e.printStackTrace();

            return null;

        } catch (InvalidKeyException e) {

            throw new Exception("加密公钥非法,请检查");

        } catch (IllegalBlockSizeException e) {

            throw new Exception("明文长度非法");

        } catch (BadPaddingException e) {

            throw new Exception("明文数据已损坏");

        }

    }

    /**

     * 私钥加密过程

     *

     * @param privateKey

     *            私钥

     * @param plainTextData

     *            明文数据

     * @return

     * @throws Exception

     *             加密过程中的异常信息

     */

    public static byte[] encrypt(RSAPrivateKey privateKey, byte[] plainTextData)

            throws Exception {

        if (privateKey == null) {

            throw new Exception("加密私钥为空, 请设置");

        }

        Cipher cipher = null;

        try {

            // 使用默认RSA

            cipher = Cipher.getInstance("RSA");

            cipher.init(Cipher.ENCRYPT_MODE, privateKey);

            byte[] output = cipher.doFinal(plainTextData);

            return output;

        } catch (NoSuchAlgorithmException e) {

            throw new Exception("无此加密算法");

        } catch (NoSuchPaddingException e) {

            e.printStackTrace();

            return null;

        } catch (InvalidKeyException e) {

            throw new Exception("加密私钥非法,请检查");

        } catch (IllegalBlockSizeException e) {

            throw new Exception("明文长度非法");

        } catch (BadPaddingException e) {

            throw new Exception("明文数据已损坏");

        }

    }

    /**

     * 私钥解密过程

     *

     * @param privateKey

     *            私钥

     * @param cipherData

     *            密文数据

     * @return 明文

     * @throws Exception

     *             解密过程中的异常信息

     */

    public static byte[] decrypt(RSAPrivateKey privateKey, byte[] cipherData)

            throws Exception {

        if (privateKey == null) {

            throw new Exception("解密私钥为空, 请设置");

        }

        Cipher cipher = null;

        try {

            // 使用默认RSA

            cipher = Cipher.getInstance("RSA");

            // cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());

            cipher.init(Cipher.DECRYPT_MODE, privateKey);

            byte[] output = cipher.doFinal(cipherData);

            return output;

        } catch (NoSuchAlgorithmException e) {

            throw new Exception("无此解密算法");

        } catch (NoSuchPaddingException e) {

            e.printStackTrace();

            return null;

        } catch (InvalidKeyException e) {

            throw new Exception("解密私钥非法,请检查");

        } catch (IllegalBlockSizeException e) {

            throw new Exception("密文长度非法");

        } catch (BadPaddingException e) {

            throw new Exception("密文数据已损坏");

        }

    }

    /**

     * 公钥解密过程

     *

     * @param publicKey

     *            公钥

     * @param cipherData

     *            密文数据

     * @return 明文

     * @throws Exception

     *             解密过程中的异常信息

     */

    public static byte[] decrypt(RSAPublicKey publicKey, byte[] cipherData)

            throws Exception {

        if (publicKey == null) {

            throw new Exception("解密公钥为空, 请设置");

        }

        Cipher cipher = null;

        try {

            // 使用默认RSA

            cipher = Cipher.getInstance("RSA");

            // cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());

            cipher.init(Cipher.DECRYPT_MODE, publicKey);

            byte[] output = cipher.doFinal(cipherData);

            return output;

        } catch (NoSuchAlgorithmException e) {

            throw new Exception("无此解密算法");

        } catch (NoSuchPaddingException e) {

            e.printStackTrace();

            return null;

        } catch (InvalidKeyException e) {

            throw new Exception("解密公钥非法,请检查");

        } catch (IllegalBlockSizeException e) {

            throw new Exception("密文长度非法");

        } catch (BadPaddingException e) {

            throw new Exception("密文数据已损坏");

        }

    }

     /**

     * 公钥加密

     * @param publicKeyStr

     * @param data 加密字符串

     * @return String 密文数据

     * @throws Exception

     */

    public static String encryptForPuKey(String publicKeyStr, String data) throws Exception{

         RSAPublicKey publicKey=RSAEncrypt.loadPublicKeyByStr(publicKeyStr);

         byte[] cipherData=encrypt(publicKey,data.getBytes());

         String cipher=RSAEncrypt.encode(cipherData);

         return cipher;

     }

    /**

     * 私钥加密

     * @param privateKeyStr 私钥

     * @param data 加密字符串

     * @return String 密文数据

     * @throws Exception

     */

    public static String encryptForPrKey(String privateKeyStr, String data) throws Exception{

        RSAPrivateKey privateKey=RSAEncrypt.loadPrivateKeyByStr(privateKeyStr);

         byte[] cipherData=encrypt(privateKey,data.getBytes());

         String cipher=RSAEncrypt.encode(cipherData);

         return cipher;

     }

    /**

     * 私钥解密方法

     * @param privateKey 私钥

     * @param plainTextData 密文

     * @return String 明文

     * @throws Exception

     */

    public static String decryptForPrKey(String privateKey, String plainTextData) throws Exception{

        byte[] res=RSAEncrypt.decrypt(RSAEncrypt.loadPrivateKeyByStr(privateKey), RSAEncrypt.decode(plainTextData));

        String restr=new String(res);

        return restr;

    }

    /**

     * 公钥解密方法

     * @param publicKey

     * @param plainTextData 密文

     * @return 明文

     * @throws Exception

     */

    public static String decryptForPuKey(String publicKey, String plainTextData) throws Exception{

        byte[]    res=RSAEncrypt.decrypt(RSAEncrypt.loadPublicKeyByStr(publicKey), RSAEncrypt.decode(plainTextData));

        String restr=new String(res);

        return restr;

    }

    /**

     * base64编码

     */

    public static String encode(byte[]     str) {

        String encStr=null;

        try {

            encStr = Base64.getEncoder().encodeToString(str);

        } catch (Exception e) {

            e.printStackTrace();

        }

        return encStr;

    }

    public static String getEncoder(String str) {

        String encStr=null;

        try {

            encStr = Base64.getEncoder().encodeToString(str.getBytes("utf-8"));

        } catch (Exception e) {

            e.printStackTrace();

        }

        return encStr;

    }

    /**

      * base64解码

      */

    public static String getDecoder(String str) {

         byte[] asBytes = Base64.getDecoder().decode(str);

         String sr=null;

         try {

         sr=new String(asBytes, "utf-8");

        } catch (Exception e) {

            e.printStackTrace();

        }

        return sr;

    }

    /**

      * base64解码

      */

    public static  byte[]  decode(String str) {

         byte[] asBytes = Base64.getDecoder().decode(str);

         String sr=null;

         try {

        } catch (Exception e) {

            e.printStackTrace();

        }

        return  asBytes;

    }

    /**

     * 字节数据转十六进制字符串

     *

     * @param data

     *            输入数据

     * @return 十六进制内容

     */

    public static String byteArrayToString(byte[] data) {

        StringBuilder stringBuilder = new StringBuilder();

        for (int i = ; i < data.length; i++) {

            // 取出字节的高四位 作为索引得到相应的十六进制标识符 注意无符号右移

            stringBuilder.append(HEX_CHAR[(data[i] & 0xf0) >>> ]);

            // 取出字节的低四位 作为索引得到相应的十六进制标识符

            stringBuilder.append(HEX_CHAR[(data[i] & 0x0f)]);

            if (i < data.length - ) {

                stringBuilder.append(' ');

            }

        }

        return stringBuilder.toString();

    }

    public static void main(String[] args) {

        //1生成公私钥

        RSAEncrypt.genKeyPair("D:\\");

    }

}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.security.InvalidKeyException;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
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 java.util.Base64;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;

public class RSAEncrypt {
   /**
    * 字节数据转字符串专用集合
*/
private static final char[] HEX_CHAR = { '0', '1', '2', '3', '4', '5', '6',
         '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };

   /**
    * 随机生成密钥对
*/
public static void genKeyPair(String filePath) {
      // KeyPairGenerator类用于生成公钥和私钥对，基于RSA算法生成对象
KeyPairGenerator keyPairGen = null;
      try {
         keyPairGen = KeyPairGenerator.getInstance("RSA");
      } catch (NoSuchAlgorithmException e) {
         // TODO Auto-generated catch block
e.printStackTrace();
      }
      // 初始化密钥对生成器，密钥大小为96-1024位
keyPairGen.initialize(,new SecureRandom());
      // 生成一个密钥对，保存在keyPair中
KeyPair keyPair = keyPairGen.generateKeyPair();
      // 得到私钥
RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
      // 得到公钥
RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
      try {
         // 得到公钥字符串
String publicKeyString =RSAEncrypt.encode(publicKey.getEncoded());
//       // 得到私钥字符串
String privateKeyString = RSAEncrypt.encode(privateKey.getEncoded());
         // 将密钥对写入到文件
FileWriter pubfw = new FileWriter(filePath + "/publicKey.keystore");
         FileWriter prifw = new FileWriter(filePath + "/privateKey.keystore");
         BufferedWriter pubbw = new BufferedWriter(pubfw);
         BufferedWriter pribw = new BufferedWriter(prifw);
         pubbw.write(publicKeyString);
         pribw.write(privateKeyString);
         pubbw.flush();
         pubbw.close();
         pubfw.close();
         pribw.flush();
         pribw.close();
         prifw.close();
      } catch (Exception e) {
         e.printStackTrace();
      }
   }

   /**
    * 从文件中输入流中加载公钥
* 
    * @param in
*            公钥输入流
* @throws Exception
    *             加载公钥时产生的异常
*/
public static String loadPublicKeyByFile(String path) throws Exception {
      try {
         BufferedReader br = new BufferedReader(new FileReader(path
               + "/publicKey.keystore"));
         String readLine = null;
         StringBuilder sb = new StringBuilder();
         while ((readLine = br.readLine()) != null) {
            sb.append(readLine);
         }
         br.close();
         return sb.toString();
      } catch (IOException e) {
         throw new Exception("公钥数据流读取错误");
      } catch (NullPointerException e) {
         throw new Exception("公钥输入流为空");
      }
   }

   /**
    * 从字符串中加载公钥
* 
    * @param publicKeyStr
*            公钥数据字符串
* @throws Exception
    *             加载公钥时产生的异常
*/
public static RSAPublicKey loadPublicKeyByStr(String publicKeyStr)
         throws Exception {
      try {
         byte[] buffer = RSAEncrypt.decode(publicKeyStr);
         KeyFactory keyFactory = KeyFactory.getInstance("RSA");
         X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);
         return (RSAPublicKey) keyFactory.generatePublic(keySpec);
      } catch (NoSuchAlgorithmException e) {
         throw new Exception("无此算法");
      } catch (InvalidKeySpecException e) {
         throw new Exception("公钥非法");
      } catch (NullPointerException e) {
         throw new Exception("公钥数据为空");
      }
   }

   /**
    * 从文件中加载私钥
* 
    * @param keyFileName
*            私钥文件名
* @return 是否成功
* @throws Exception
    */
public static String loadPrivateKeyByFile(String path) throws Exception {
      try {
         BufferedReader br = new BufferedReader(new FileReader(path
               + "/privateKey.keystore"));
         String readLine = null;
         StringBuilder sb = new StringBuilder();
         while ((readLine = br.readLine()) != null) {
            sb.append(readLine);
         }
         br.close();
         return sb.toString();
      } catch (IOException e) {
         throw new Exception("私钥数据读取错误");
      } catch (NullPointerException e) {
         throw new Exception("私钥输入流为空");
      }
   }

   public static RSAPrivateKey loadPrivateKeyByStr(String privateKeyStr)
         throws Exception {
      try {
         byte[] buffer = RSAEncrypt.decode(privateKeyStr);
         PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer);
         KeyFactory keyFactory = KeyFactory.getInstance("RSA");
         return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
      } catch (NoSuchAlgorithmException e) {
         throw new Exception("无此算法");
      } catch (InvalidKeySpecException e) {
         throw new Exception("私钥非法");
      } catch (NullPointerException e) {
         throw new Exception("私钥数据为空");
      }
   }

   /**
    * 公钥加密过程
* 
    * @param publicKey
*            公钥
* @param plainTextData
*            明文数据
* @return
* @throws Exception
    *             加密过程中的异常信息
*/
public static byte[] encrypt(RSAPublicKey publicKey, byte[] plainTextData)
         throws Exception {
      if (publicKey == null) {
         throw new Exception("加密公钥为空, 请设置");
      }
      Cipher cipher = null;
      try {
         // 使用默认RSA
cipher = Cipher.getInstance("RSA");
         // cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
         byte[] output = cipher.doFinal(plainTextData);
         return output;
      } catch (NoSuchAlgorithmException e) {
         throw new Exception("无此加密算法");
      } catch (NoSuchPaddingException e) {
         e.printStackTrace();
         return null;
      } catch (InvalidKeyException e) {
         throw new Exception("加密公钥非法,请检查");
      } catch (IllegalBlockSizeException e) {
         throw new Exception("明文长度非法");
      } catch (BadPaddingException e) {
         throw new Exception("明文数据已损坏");
      }
   }

   /**
    * 私钥加密过程
* 
    * @param privateKey
*            私钥
* @param plainTextData
*            明文数据
* @return
* @throws Exception
    *             加密过程中的异常信息
*/
public static byte[] encrypt(RSAPrivateKey privateKey, byte[] plainTextData)
         throws Exception {
      if (privateKey == null) {
         throw new Exception("加密私钥为空, 请设置");
      }
      Cipher cipher = null;
      try {
         // 使用默认RSA
cipher = Cipher.getInstance("RSA");
         cipher.init(Cipher.ENCRYPT_MODE, privateKey);
         byte[] output = cipher.doFinal(plainTextData);
         return output;
      } catch (NoSuchAlgorithmException e) {
         throw new Exception("无此加密算法");
      } catch (NoSuchPaddingException e) {
         e.printStackTrace();
         return null;
      } catch (InvalidKeyException e) {
         throw new Exception("加密私钥非法,请检查");
      } catch (IllegalBlockSizeException e) {
         throw new Exception("明文长度非法");
      } catch (BadPaddingException e) {
         throw new Exception("明文数据已损坏");
      }
   }

   /**
    * 私钥解密过程
* 
    * @param privateKey
*            私钥
* @param cipherData
*            密文数据
* @return 明文
* @throws Exception
    *             解密过程中的异常信息
*/
public static byte[] decrypt(RSAPrivateKey privateKey, byte[] cipherData)
         throws Exception {
      if (privateKey == null) {
         throw new Exception("解密私钥为空, 请设置");
      }
      Cipher cipher = null;
      try {
         // 使用默认RSA
cipher = Cipher.getInstance("RSA");
         // cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());
cipher.init(Cipher.DECRYPT_MODE, privateKey);
         byte[] output = cipher.doFinal(cipherData);
         return output;
      } catch (NoSuchAlgorithmException e) {
         throw new Exception("无此解密算法");
      } catch (NoSuchPaddingException e) {
         e.printStackTrace();
         return null;
      } catch (InvalidKeyException e) {
         throw new Exception("解密私钥非法,请检查");
      } catch (IllegalBlockSizeException e) {
         throw new Exception("密文长度非法");
      } catch (BadPaddingException e) {
         throw new Exception("密文数据已损坏");
      }
   }

   /**
    * 公钥解密过程
* 
    * @param publicKey
*            公钥
* @param cipherData
*            密文数据
* @return 明文
* @throws Exception
    *             解密过程中的异常信息
*/
public static byte[] decrypt(RSAPublicKey publicKey, byte[] cipherData)
         throws Exception {
      if (publicKey == null) {
         throw new Exception("解密公钥为空, 请设置");
      }
      Cipher cipher = null;
      try {
         // 使用默认RSA
cipher = Cipher.getInstance("RSA");
         // cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());
cipher.init(Cipher.DECRYPT_MODE, publicKey);
         byte[] output = cipher.doFinal(cipherData);
         return output;
      } catch (NoSuchAlgorithmException e) {
         throw new Exception("无此解密算法");
      } catch (NoSuchPaddingException e) {
         e.printStackTrace();
         return null;
      } catch (InvalidKeyException e) {
         throw new Exception("解密公钥非法,请检查");
      } catch (IllegalBlockSizeException e) {
         throw new Exception("密文长度非法");
      } catch (BadPaddingException e) {
         throw new Exception("密文数据已损坏");
      }
   }

    /**
    * 公钥加密 
* @param publicKeyStr
* @param data 加密字符串
* @return String 密文数据
* @throws Exception
    */
public static String encryptForPuKey(String publicKeyStr, String data) throws Exception{
       RSAPublicKey publicKey=RSAEncrypt.loadPublicKeyByStr(publicKeyStr);
       byte[] cipherData=encrypt(publicKey,data.getBytes());
       String cipher=RSAEncrypt.encode(cipherData);
       return cipher;
    }
   /**
    * 私钥加密
* @param privateKeyStr 私钥
* @param data 加密字符串
* @return String 密文数据
* @throws Exception
    */
public static String encryptForPrKey(String privateKeyStr, String data) throws Exception{
      RSAPrivateKey privateKey=RSAEncrypt.loadPrivateKeyByStr(privateKeyStr);
       byte[] cipherData=encrypt(privateKey,data.getBytes());
       String cipher=RSAEncrypt.encode(cipherData);
       return cipher;
    }

   /**
    * 私钥解密方法
* @param privateKey 私钥
* @param plainTextData 密文
* @return String 明文
* @throws Exception
    */
public static String decryptForPrKey(String privateKey, String plainTextData) throws Exception{
      byte[] res=RSAEncrypt.decrypt(RSAEncrypt.loadPrivateKeyByStr(privateKey), RSAEncrypt.decode(plainTextData));
      String restr=new String(res);
      return restr;
   }

   /**
    * 公钥解密方法
* @param publicKey
* @param plainTextData 密文
* @return 明文
* @throws Exception
    */
public static String decryptForPuKey(String publicKey, String plainTextData) throws Exception{
      byte[] res=RSAEncrypt.decrypt(RSAEncrypt.loadPublicKeyByStr(publicKey), RSAEncrypt.decode(plainTextData));
      String restr=new String(res);
      return restr;
   }

   /**
    * base64编码
*/

public static String encode(byte[]  str) {  
      String encStr=null;
      try {
         encStr = Base64.getEncoder().encodeToString(str);
      } catch (Exception e) {
         e.printStackTrace();
      }
      return encStr;

   }

   public static String getEncoder(String str) {  
      String encStr=null;
      try {
         encStr = Base64.getEncoder().encodeToString(str.getBytes("utf-8"));
      } catch (Exception e) {
         e.printStackTrace();
      }
      return encStr;

   }

   /**
     * base64解码
*/
public static String getDecoder(String str) {

       byte[] asBytes = Base64.getDecoder().decode(str);
       String sr=null;
       try {
       sr=new String(asBytes, "utf-8");
      } catch (Exception e) {

         e.printStackTrace();
      }
      return sr;
   }

   /**
     * base64解码
*/
public static  byte[]  decode(String str) {

       byte[] asBytes = Base64.getDecoder().decode(str);
       String sr=null;
       try {
      } catch (Exception e) {

         e.printStackTrace();
      }
      return  asBytes;
   }

   /**
    * 字节数据转十六进制字符串
* 
    * @param data
*            输入数据
* @return 十六进制内容
*/
public static String byteArrayToString(byte[] data) {
      StringBuilder stringBuilder = new StringBuilder();
      for (int i = ; i < data.length; i++) {
         // 取出字节的高四位 作为索引得到相应的十六进制标识符 注意无符号右移
stringBuilder.append(HEX_CHAR[(data[i] & 0xf0) >>> ]);
         // 取出字节的低四位 作为索引得到相应的十六进制标识符
stringBuilder.append(HEX_CHAR[(data[i] & 0x0f)]);
         if (i < data.length - ) {
            stringBuilder.append(' ');
         }
      }
      return stringBuilder.toString();
   }

   public static void main(String[] args) {
      //1生成公私钥
RSAEncrypt.genKeyPair("D:\\");

   } 
}