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 = { '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(1024,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 = 0; i < data.length; i++) {
            // 取出字节的高四位 作为索引得到相应的十六进制标识符 注意无符号右移
            stringBuilder.append(HEX_CHAR[(data[i] & 0xf0) >>> 4]);
            // 取出字节的低四位 作为索引得到相应的十六进制标识符
            stringBuilder.append(HEX_CHAR[(data[i] & 0x0f)]);
            if (i < data.length - 1) {
                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(1024,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 = 0; i < data.length; i++) {
         // 取出字节的高四位 作为索引得到相应的十六进制标识符 注意无符号右移
stringBuilder.append(HEX_CHAR[(data[i] & 0xf0) >>> 4]);
         // 取出字节的低四位 作为索引得到相应的十六进制标识符
stringBuilder.append(HEX_CHAR[(data[i] & 0x0f)]);
         if (i < data.length - 1) {
            stringBuilder.append(' ');
         }
      }
      return stringBuilder.toString();
   }
   
   
   public static void main(String[] args) {
      //1生成公私钥
RSAEncrypt.genKeyPair("D:\");
      
   } 
}