/**
    * Copyright By Grandsoft Company Limited.  
    * 2014年3月18日 上午10:29:13
    * RSA加密算法虽然不分平台，标准都是一样的，但是各个平台的实现方式都不尽相同，下面来我来说说java与.net平台之间该如何进行RSA加密验证，
    * 即java端加密-》.net端验证和.net端加密-》java端验证。
    * 参考资料：http://www.blogjava.net/orangehf/archive/2011/02/26/345243.html
    */
   package gboat2.base.bridge.util.security;
   
  import java.io.ByteArrayOutputStream;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileNotFoundException;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.OutputStream;
  import java.math.BigInteger;
  import java.security.InvalidKeyException;
  import java.security.Key;
  import java.security.KeyFactory;
  import java.security.KeyPair;
  import java.security.NoSuchAlgorithmException;
  import java.security.PrivateKey;
  import java.security.PublicKey;
  import java.security.interfaces.RSAPrivateCrtKey;
  import java.security.interfaces.RSAPublicKey;
  import java.security.spec.EncodedKeySpec;
  import java.security.spec.KeySpec;
  import java.security.spec.PKCS8EncodedKeySpec;
  import java.security.spec.RSAPrivateCrtKeySpec;
  import java.security.spec.RSAPrivateKeySpec;
  import java.security.spec.RSAPublicKeySpec;
  import java.security.spec.X509EncodedKeySpec;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  import javax.crypto.Cipher;
  
  import org.apache.commons.codec.binary.Base64;
  import org.apache.commons.io.FileUtils;
  import org.apache.commons.io.IOUtils;
  import org.apache.commons.lang3.StringUtils;
  
  /**
   * <p>
   * RSA 加密、解密的工具类。如果需要与 .NET 平台进行 RSA 加密解密交互，请将加解密的 transformation 参数使用
   * {@value #DOTNET_RSA_TRANSFORMATION}。
   * </p>
   * <p>
   * 进行加解密操作时需要使用的 transformation 参数的格式为
   * "Algorithm/Modes/Paddings"，如：RSA/ECB/PKCS1Padding。RSA 加解密 Algorithm 为
   * {@code RSA}，Modes 的值只能是 {@code ECB}，Paddings 的可选值有：
   * <code>
   * NOPADDING, PKCS1PADDING,
   * OAEPWITHMD5ANDMGF1PADDING, OAEPWITHSHA1ANDMGF1PADDING,
   * OAEPWITHSHA-1ANDMGF1PADDING, OAEPWITHSHA-256ANDMGF1PADDING,
   * OAEPWITHSHA-384ANDMGF1PADDING, OAEPWITHSHA-512ANDMGF1PADDING
   * <!-- OAEPPadding later --></code>。<br>
   * 更多关于 transformation 参数的资料请参考
   * <a target="_blank" href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
   * Java Cryptography Architecture Reference Guide</a> 页面中的附录 A。
   * 
   * <pre>
   * 进行加密和解密操作的示例代码：
   *  <code>
   * String privateKey = "MIICeQIBADANBgkqhkiG9w0BAQEFAASCAmMwggJfAgEAAoGBAL6VJN4ZkfZA3aPPgKC3xaqT/yZT5FOl"
   *         + "Q5TGg6heVqDVEHHVLH1E+HEEmWmuTv2ngz9pZbzy9KWkJpV59W1dgNHSSk575VjUAv0BhZXFSH0lng2m"
   *         + "Z2Q5/2dVxKsASjJ2bQiEGUD8LO5KpaLlfQpo3ANovBZvUtHw5exegnyXyZbDAgMBAAECgYEAr7YEWr1K"
   *         + "hLcDYg9jMUqd9QokOSspnTEGoPlx016/EeO/GKSJMynOwSyTYQszisvRxzoecdmyU7GHXVMnQ2Ds7Wvb"
   *         + "cuNkIRWmxFa4nTkk2zNF6KByvvFwLiW4LQXF6B+uV7+ZNqvfhCoD/j2wki8jfWkuuAaKnTda/axHMi+z"
   *         + "RYECQQD73iC2GjZyur4amJQPK6d+kDlJ0dYyyUvQa0vd6mfoPnQDOIqayBaueSwWIpLI/L7eUuP9CDFr"
   *         + "yQtdBvWqD/dBAkEAwbWcrybn0eaxiPZacZLZXzXO8g12hYoXT1h0DTLvy1rnVUOspNfKZcBZMjPxT4+Q"
   *         + "EknoTShSnSbJ5sHitfZxAwJBANMlU2z2KqEh1k77jFvvb9oVVEGDbTtkL2+JE6/1W6iB+sXcd63sgb9A"
   *         + "i+n+j+l4oRZGjSTJ4oyGnUUemYI5IkECQQCA9JNrcv4PGYIFCOPrCfTV0m+Dan0Fp4mfE+amRsumWEz6"
   *         + "0UOktdeS53s51aSG767czgDtJLPi1MjCaz6vHnHbAkEA4NxLLg6UCAoCpXMgqqZHWMgbMwNNFr9diCWP"
   *         + "/tZ5OJmWYHgn7zfqMXa/RNaethjdG1biIkj5h7qm6XDBBqGuxw==";
   * String publicKey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC+lSTeGZH2QN2jz4Cgt8Wqk/8mU+RTpUOUxoOoXlag"
   *         + "1RBx1Sx9RPhxBJlprk79p4M/aWW88vSlpCaVefVtXYDR0kpOe+VY1AL9AYWVxUh9JZ4NpmdkOf9nVcSr"
   *         + "AEoydm0IhBlA/CzuSqWi5X0KaNwDaLwWb1LR8OXsXoJ8l8mWwwIDAQAB";
   * 
   * String data = "this is a test 中文";
   * System.out.println("原文：" + data);
   * System.out.println("--------------------------------------");
   * 
   * String encrypted = encryptBase64ByPrivateKey(data, privateKey);
   * System.out.println("用私钥加密：" + encrypted);
   * String decrypted = new String(decryptByPublicKey(encrypted, publicKey));
   * System.out.println("用公钥解密：：" + decrypted);
   * 
   * System.out.println("--------------------------------------");
   * encrypted = encryptBase64ByPublicKey(data, publicKey);
   * System.out.println("用公钥加密：" + encrypted);
   * decrypted = new String(decryptByPrivateKey(encrypted, privateKey));
   * System.out.println("用私钥解密：：" + decrypted);
   *  </code>
   * </pre>
   * @author <a href="mailto:[email protected]">何明旺</a>
   * @since 3.0
   * @date 2014年3月18日
  * @see Base64Util
  * @see CertificateUtil
  * @see RSASignUtil
  */
 public class RSAUtil {
 
     public static final String RSA = "RSA";
     
     public static final String DOTNET_RSA_TRANSFORMATION  = "RSA/ECB/PKCS1Padding";
 
     /** 最大文件加密块 */
     private static final int MAX_ENCRYPT_BLOCK = 117;
     
     /** 最大文件解密块 */
     private static final int MAX_DECRYPT_BLOCK = 128;
     
     /**
      * 获取密钥对
      * @return
      */
     public static KeyPair getKeyPair() {
         return Encryptor.getKeyPair(RSA, 1024);
     }
 
     /**
      * Generates the keys for given size.
      * 
      * @param size Key Size [512|1024]
      */
     public static KeyPair getKeyPair(int size) {
         return Encryptor.getKeyPair(RSA, size);
     }
 
     private static RSAPrivateCrtKey getRSAPrivateCrtKey(byte[] encodedPrivateKey) {
         try {
             EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(encodedPrivateKey);
             KeyFactory keyFactory = KeyFactory.getInstance(RSA);
             return (RSAPrivateCrtKey) keyFactory.generatePrivate(keySpec);
         } catch (Exception e) {
             throw new GboatSecurityException("获取 RSA 私钥实例失败。encodedPrivateKey=" + Base64.encodeBase64String(encodedPrivateKey), e);
         }
     }
     
     /**
      * 根据私钥字符串，获取对应的私钥实例对象
      * @param privateKeyStr  经过  BASE64 编码后的私钥字符串
      * @return
      */
     public static PrivateKey getPrivateKey(String privateKeyStr) {
         byte[] privateKeyBytes = Base64.decodeBase64(privateKeyStr);
         return getRSAPrivateCrtKey(privateKeyBytes);
     }
     
     /**
      * 获取私钥
      * @param privateKeySpec RSA 专用私钥
      * @return
      */
     public static PrivateKey getPrivateKey(RSAPrivateKeySpec privateKeySpec) {
         try {
             KeyFactory keyFactory = KeyFactory.getInstance(RSA);
             return keyFactory.generatePrivate(privateKeySpec);
         } catch (Exception e) {
             throw new GboatSecurityException("获取 RSA 私钥实例失败。privateKeySpec=" + privateKeySpec, e);
         }
     }
     
     /**
      * 获取私钥
      * @param base64Modulus the modulus n
      * @param base64PublicExponent the public exponent e
      * @param base64PrivateExponent the private exponent d
      * @param base64PrimeP the prime factor p of n
      * @param base64PrimeQ the prime factor q of n
      * @param base64PrimeExponentP this is d mod (p-1)
      * @param base64PrimeExponentQ this is d mod (q-1)
      * @param base64CrtCoefficient the Chinese Remainder Theorem coefficient q-1 mod p
      * @return
      */
     public static PrivateKey getPrivateKey(String base64Modulus,
             String base64PublicExponent, String base64PrivateExponent,
             String base64PrimeP, String base64PrimeQ,
             String base64PrimeExponentP, String base64PrimeExponentQ,
             String base64CrtCoefficient) {
         BigInteger modulus = new BigInteger(1, Base64.decodeBase64(base64Modulus));
         BigInteger publicExponent = new BigInteger(1, Base64.decodeBase64(base64PublicExponent));
         BigInteger privateExponent = new BigInteger(1, Base64.decodeBase64(base64PrivateExponent));
         BigInteger primeP = new BigInteger(1, Base64.decodeBase64(base64PrimeP));
         BigInteger primeQ = new BigInteger(1, Base64.decodeBase64(base64PrimeQ));
         BigInteger primeExponentP = new BigInteger(1, Base64.decodeBase64(base64PrimeExponentP));
         BigInteger primeExponentQ = new BigInteger(1, Base64.decodeBase64(base64PrimeExponentQ));
         BigInteger crtCoefficient = new BigInteger(1, Base64.decodeBase64(base64CrtCoefficient));
         RSAPrivateCrtKeySpec privateKeySpec = new RSAPrivateCrtKeySpec(modulus,
                 publicExponent, privateExponent, primeP, primeQ,
                 primeExponentP, primeExponentQ, crtCoefficient);
         return getPrivateKey(privateKeySpec);
     }
 
     /**
      * 根据 .NET 的私钥字符串，获取对应的私钥实例对象
      * @param dotnetRsaParameters  .NET 平台 <a href=
      *            "http://msdn.microsoft.com/zh-cn/library/system.security.cryptography.rsaparameters(v=vs.110).aspx"
      *            target="_blank">RSAParameters</a> 相对应的 XML，格式为：
      * <pre>
      * <code>
      * &lt;RSAKeyValue&gt;
      *   &lt;Modulus&gt;n -&gt; modulus&lt;/Modulus&gt;
      *   &lt;Exponent&gt;e，公钥指数 -&gt; publicExponent&lt;/Exponent&gt;
      *   &lt;P&gt;p -&gt; prime1&lt;/P&gt;
      *   &lt;Q&gt;q -&gt; prime2&lt;/Q&gt;
      *   &lt;DP&gt;d mod (p - 1) -&gt; exponent1&lt;/DP&gt;
      *   &lt;DQ&gt;d mod (q - 1) -&gt; exponent2&lt;/DQ&gt;
      *   &lt;InverseQ&gt;(InverseQ)(q) = 1 mod p -&gt; coefficient&lt;/InverseQ&gt;
      *   &lt;D&gt;d，私钥指数 -&gt; privateExponent&lt;/D&gt;
      * &lt;/RSAKeyValue&gt;
      * </code>
      * </pre>
      * @return 么钥实例
      */
     public static PrivateKey getPrivateKeyFromDotNetRSAParameters(String dotnetRsaParameters) {
         if(StringUtils.isBlank(dotnetRsaParameters))
             throw new IllegalArgumentException("传入的参数为空");
         
         Matcher modulusMatcher = Pattern.compile("<Modulus>(.+)</Modulus>").matcher(dotnetRsaParameters);
         if(!modulusMatcher.find())
             throw new IllegalArgumentException("没有发现 <Modulus> 节点，dotnetRsaParameters=" + dotnetRsaParameters);
         
         Matcher publicExponentMatcher = Pattern.compile("<Exponent>(.+)</Exponent>").matcher(dotnetRsaParameters);
         if(!publicExponentMatcher.find())
             throw new IllegalArgumentException("没有发现 <Exponent> 节点，dotnetRsaParameters=" + dotnetRsaParameters);
         
         Matcher privateExponentMatcher = Pattern.compile("<D>(.+)</D>").matcher(dotnetRsaParameters);
         if(!privateExponentMatcher.find())
             throw new IllegalArgumentException("没有发现 <D> 节点，dotnetRsaParameters=" + dotnetRsaParameters);
         
         Matcher primePMatcher = Pattern.compile("<P>(.+)</P>").matcher(dotnetRsaParameters);
         if(!primePMatcher.find())
             throw new IllegalArgumentException("没有发现 <P> 节点，dotnetRsaParameters=" + dotnetRsaParameters);
      
         Matcher primeQMatcher = Pattern.compile("<Q>(.+)</Q>").matcher(dotnetRsaParameters);
         if(!primeQMatcher.find())
             throw new IllegalArgumentException("没有发现 <Q> 节点，dotnetRsaParameters=" + dotnetRsaParameters);
         
         Matcher primeExponentPMatcher = Pattern.compile("<DP>(.+)</DP>").matcher(dotnetRsaParameters);
         if(!primeExponentPMatcher.find())
             throw new IllegalArgumentException("没有发现 <DP> 节点，dotnetRsaParameters=" + dotnetRsaParameters);
         
         Matcher primeExponentQMatcher = Pattern.compile("<DQ>(.+)</DQ>").matcher(dotnetRsaParameters);
         if(!primeExponentQMatcher.find())
             throw new IllegalArgumentException("没有发现 <DQ> 节点，dotnetRsaParameters=" + dotnetRsaParameters);
         
         Matcher crtCoefficientMatcher = Pattern.compile("<InverseQ>(.+)</InverseQ>").matcher(dotnetRsaParameters);
         if(!crtCoefficientMatcher.find())
             throw new IllegalArgumentException("没有发现 <InverseQ> 节点，dotnetRsaParameters=" + dotnetRsaParameters);
 
         return getPrivateKey(modulusMatcher.group(1),
                 publicExponentMatcher.group(1),
                 privateExponentMatcher.group(1), primePMatcher.group(1),
                 primeQMatcher.group(1), primeExponentPMatcher.group(1),
                 primeExponentQMatcher.group(1), crtCoefficientMatcher.group(1));
     }
 
     /**
      * Returns XML encoded RSA private key string suitable for .NET：CryptoServiceProvider.FromXmlString(true)。
      * Leading zero bytes (most significant) must be removed for XML encoding for .NET; otherwise format error
      * @param privateKey 私钥
      * @return
      */
     public static String getDotNetRSAParametersWithPrivateKey(PrivateKey privateKey) {
         RSAPrivateCrtKey privateCrtKey = (privateKey instanceof RSAPrivateCrtKey) ? (RSAPrivateCrtKey) privateKey
                 : getRSAPrivateCrtKey(privateKey.getEncoded());
         StringBuffer buff = new StringBuffer(1024);
         buff.append("<RSAKeyValue>");
         buff.append("<Modulus>" + Base64.encodeBase64String(removeMSZero(privateCrtKey.getModulus().toByteArray())) + "</Modulus>");
         buff.append("<Exponent>" + Base64.encodeBase64String(removeMSZero(privateCrtKey.getPublicExponent().toByteArray())) + "</Exponent>");
         buff.append("<P>" + Base64.encodeBase64String(removeMSZero(privateCrtKey.getPrimeP().toByteArray())) + "</P>");
         buff.append("<Q>" + Base64.encodeBase64String(removeMSZero(privateCrtKey.getPrimeQ().toByteArray())) + "</Q>");
         buff.append("<DP>" + Base64.encodeBase64String(removeMSZero(privateCrtKey.getPrimeExponentP().toByteArray())) + "</DP>");
         buff.append("<DQ>" + Base64.encodeBase64String(removeMSZero(privateCrtKey.getPrimeExponentQ().toByteArray())) + "</DQ>");
         buff.append("<InverseQ>" + Base64.encodeBase64String(removeMSZero(privateCrtKey.getCrtCoefficient().toByteArray())) + "</InverseQ>");
         buff.append("<D>" + Base64.encodeBase64String(removeMSZero(privateCrtKey.getPrivateExponent().toByteArray())) + "</D>");
         buff.append("</RSAKeyValue>");
         return buff.toString().replaceAll("[ \t\n\r]", "");
     }
 
     /**
      * 根据公钥字符串，获取对应的公钥实例对象
      * @param publicKeyStr  经过  BASE64 编码后的公钥字符串
      */
     public static PublicKey getPublicKey(String publicKeyStr) {
         try {
             byte[] publicKeyBytes = Base64.decodeBase64(publicKeyStr);
             KeyFactory keyFactory = KeyFactory.getInstance(RSA);
             EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(publicKeyBytes);
             return keyFactory.generatePublic(publicKeySpec);
         } catch (Exception e) {
             throw new GboatSecurityException("获取 RSA 公钥实例失败。publicKeyStr=" + publicKeyStr, e);
         }
     }
     
     /**
      * 根据公钥 n、e 生成公钥
      * 
      * @param base64Modulus 经过 BASE64 编码的公钥 n 串
      * @param base64PublicExponent 经过 BASE64 编码的公钥 e 串
      * @return 公钥实例
      */
     public static PublicKey getPublicKey(String base64Modulus, String base64PublicExponent) {
         BigInteger modulus=new BigInteger(1, Base64.decodeBase64(base64Modulus));
         BigInteger publicExponent = new BigInteger(1, Base64.decodeBase64(base64PublicExponent));
         RSAPublicKeySpec publicKeySpec = new RSAPublicKeySpec(modulus, publicExponent);
         return getPublicKey(publicKeySpec);
     }
 
     /**
      * 获取公钥
      * @param publicKeySpec
      * @return
      */
     public static PublicKey getPublicKey(RSAPublicKeySpec publicKeySpec) {
         try {
             KeyFactory keyFactory = KeyFactory.getInstance(RSA);
             return keyFactory.generatePublic(publicKeySpec);
         } catch (Exception e) {
             throw new GboatSecurityException("获取 RSA 私钥实例失败。privateKeySpec=" + publicKeySpec, e);
         }
     }
 
     /**
      * 根据 .NET 的私钥字符串，获取对应的私钥实例对象
      * 
      * @param dotnetRsaParameters .NET 平台 <a href=
      *            "http://msdn.microsoft.com/zh-cn/library/system.security.cryptography.rsaparameters(v=vs.110).aspx"
      *            target="_blank">RSAParameters</a> 相对应的 XML，格式为：
      * <pre>
      * <code>
      * &lt;RSAKeyValue&gt;
      *     &lt;Modulus&gt;经过 BASE64 编码后的 Modulus&lt;/Modulus&gt;
      *     &lt;Exponent&gt;经过 BASE64 编码后的 Exponent&lt;/Exponent&gt;
      * &lt;/RSAKeyValue&gt;
      * </code>
      * </pre>
      * @return
      */
     public static PublicKey getPublicKeyFromDotNetRSAParameters(String dotnetRsaParameters) {
         if(StringUtils.isBlank(dotnetRsaParameters))
             throw new IllegalArgumentException("传入的参数为空");
         
         Matcher modulusMatcher = Pattern.compile("<Modulus>(.+)</Modulus>").matcher(dotnetRsaParameters);
         if(!modulusMatcher.find())
             throw new IllegalArgumentException("没有发现 <Modulus> 节点，dotnetRsaParameters=" + dotnetRsaParameters);
         
         Matcher exponentMatcher = Pattern.compile("<Exponent>(.+)</Exponent>").matcher(dotnetRsaParameters);
         if(!exponentMatcher.find())
             throw new IllegalArgumentException("没有发现 <Exponent> 节点，dotnetRsaParameters=" + dotnetRsaParameters);
         
         return getPublicKey(modulusMatcher.group(1), exponentMatcher.group(1));
     }
 
     /**
      * Returns XML encoded RSA public key string suitable for
      * .NET：CryptoServiceProvider.FromXmlString(true) Leading zero bytes (most
      * significant) must be removed for XML encoding for .NET; otherwise format
      * error
      * 
      * @param privateCrtKey
      * @return 返回结果的格式：
      * <pre><code>
      * &lt;RSAKeyValue&gt;
      *     &lt;Modulus&gt;经过 BASE64 编码后的 Modulus&lt;/Modulus&gt;
      *     &lt;Exponent&gt;经过 BASE64 编码后的 Exponent&lt;/Exponent&gt;
      * &lt;/RSAKeyValue&gt;
      * </code></pre>
      */
     public static String getDotNetRSAParametersWithPublicKey(PrivateKey privateKey) {
         RSAPrivateCrtKey privateCrtKey = (privateKey instanceof RSAPrivateCrtKey) ? (RSAPrivateCrtKey) privateKey
                 : getRSAPrivateCrtKey(privateKey.getEncoded());
         byte[] msModulus = removeMSZero(privateCrtKey.getModulus().toByteArray());
         byte[] msPublicExponent = removeMSZero(privateCrtKey.getPublicExponent().toByteArray());
         StringBuffer buff = new StringBuffer(1024);
         buff.append("<RSAKeyValue>");
         buff.append("<Modulus>" + Base64.encodeBase64String(msModulus) + "</Modulus>");
         buff.append("<Exponent>" + Base64.encodeBase64String(msPublicExponent) + "</Exponent>");
         buff.append("</RSAKeyValue>");
         return buff.toString().replaceAll("[ \t\n\r]", "");
     }
 
     /**
      * Gets the RSA Public Key. The key idea is to make the key readable for
      * .Net platform.
      * 
      * @param publicKey RSAPublicKey
      * @return String the public key that .Net platform can read. return format is:
      * <pre><code>
      * modules : xxx
      * exponent : xxx
      * </code></pre>
      */
     public static String getRSAPublicKeyAsNetFormat(RSAPublicKey publicKey) {
         byte[] msModulus = stripLeadingZeros(publicKey.getModulus().toByteArray());
         byte[] msPublicExponent = publicKey.getPublicExponent().toByteArray();
         return "modules : " + Base64.encodeBase64String(msModulus) + "\r\n" + "exponent : " + Base64.encodeBase64String(msPublicExponent);
     }
     
     /**
      * 对数据进行加密
      * 
      * @param data 要进行加密的明文数据
      * @param key 密钥
      * @return 加密后的密文
      */
     public static byte[] encrypt(byte[] data, Key key) {
         return encrypt(data, key, key.getAlgorithm());
     }
     
     /**
      * 对数据进行加密
      * 
      * @param data 要进行加密的明文数据
      * @param key 密钥
      * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
      *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
      *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
      *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
      * @return 加密后的密文
      */
     public static byte[] encrypt(byte[] data, Key key, String transformation){
         ByteArrayOutputStream out = null;
         try {
             Cipher cipher = Cipher.getInstance(transformation);
             cipher.init(Cipher.ENCRYPT_MODE, key);
             out = new ByteArrayOutputStream();
             int offSet = 0;
             byte[] cache;
             while (offSet < data.length) {  // 对数据分段加密
                 cache = cipher.doFinal(data, offSet, Math.min(data.length - offSet, MAX_ENCRYPT_BLOCK));
                 out.write(cache);
                 offSet += MAX_ENCRYPT_BLOCK;
             }
             return out.toByteArray();
         } catch (Exception e) {
             throw new GboatSecurityException("使用密钥 [" + key + "] 对数据进行加密失败。transformation=" + transformation, e);
         }finally {
             IOUtils.closeQuietly(out);
         }
     } 
     
     /**
      * 对字符串进行加密
      * 
      * @param data 要进行加密的明文字符串
      * @param key 密钥
      * @return 加密后的密文
      */
     public static byte[] encrypt(String data, Key key) {  
         return encrypt(data, key, key.getAlgorithm());
     }
     
     /**
      * 对字符串进行加密
      * 
      * @param data 要进行加密的明文字符串
      * @param key 密钥
      * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
      *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
      *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
      *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
      * @return 加密后的密文
      */
     public static byte[] encrypt(String data, Key key, String transformation) {
         return encrypt(data.getBytes(), key, transformation);
     }
 
     /**
      * 对文件内容进行加密，文件太大可能会导致内存溢出
      * 
      * @param data 要进行加密的文件
      * @param key 密钥
      * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
      *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
      *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
      *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
      * @return 加密后的密文
      * @see #encrypt(File, File, Key)
      */
     public static byte[] encrypt(File file, Key key) {
         return encrypt(file, key, key.getAlgorithm());
     }
     
     /**
      * 对文件内容进行加密，文件太大可能会导致内存溢出
      * 
      * @param data 要进行加密的文件
      * @param key 密钥
      * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
      *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
      *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
      *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
      * @return 加密后的密文
      * @see #encrypt(File, File, Key, String)
      */
     public static byte[] encrypt(File file, Key key, String transformation) {
         try {
             return encrypt(FileUtils.readFileToByteArray(file), key, transformation);
         } catch (IOException e) {
             throw new GboatSecurityException("对文件加密失败。file=[" + file + "], key=["
                     + key + "], transformation=[" + transformation + "]", e);
         }
     }
     
     /**
      * 对文件进行加密
      * @param src 源文件
      * @param dest 加密后文件
      * @param key 密钥
      */
     public static void encrypt(File src, File dest, Key key){
         encrypt(src, dest, key, key.getAlgorithm());
     }
     
     /**
      * 对文件进行加密
      * @param src 源文件
      * @param dest 加密后文件
      * @param key 密钥
      * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
      *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
      *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
      *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
      */
     public static void encrypt(File src, File dest, Key key, String transformation) {
         FileInputStream in = null;
         OutputStream out = null;
         try {
             in = new FileInputStream(src);
      
             if (!dest.getParentFile().exists()) {
                 dest.getParentFile().mkdirs();
             }
             // dest.createNewFile();
             out = new FileOutputStream(dest);
 
             Cipher cipher = Cipher.getInstance(transformation);
             cipher.init(Cipher.ENCRYPT_MODE, key);
             byte[] data = new byte[MAX_ENCRYPT_BLOCK];
             int len = 0;
             while ((len = in.read(data)) != -1) {
                 out.write(cipher.doFinal(data, 0, len));
                 // out.flush();
             }
         } catch (InvalidKeyException e) {
             throw new GboatSecurityException("对文件加密失败：密钥无效。src=[" + src + "], dest=[" + dest
                     + "], key=[" + key + "], transformation=[" + transformation + "]", e);
         } catch (NoSuchAlgorithmException e) {
             throw new GboatSecurityException("对文件加密失败：算法 不存在，或当前  JDK 不支持该算法。src=[" + src + "], dest=[" + dest
                     + "], key=[" + key + "], transformation=[" + transformation + "]", e);
         } catch (FileNotFoundException e) {
             throw new GboatSecurityException("对文件加密失败：文件不存在。src=[" + src + "], dest=[" + dest
                     + "], key=[" + key + "], transformation=[" + transformation + "]", e);
         } catch (Exception e) {
             throw new GboatSecurityException("对文件加密失败。src=[" + src + "], dest=[" + dest
                     + "], key=[" + key + "], transformation=[" + transformation + "]", e);
         } finally {
             IOUtils.closeQuietly(out);
             IOUtils.closeQuietly(in);
         }
     }
     
     private static Key getKeyByKeySpec(KeySpec keySpec) {
         if (keySpec == null)
             throw new IllegalArgumentException("传入的 keySpec 为空");
 
         if (keySpec instanceof RSAPrivateKeySpec)
             return getPrivateKey((RSAPrivateKeySpec) keySpec);
         
         if (keySpec instanceof RSAPublicKeySpec)
             return getPublicKey((RSAPublicKeySpec) keySpec);
         
         throw new GboatSecurityException("不支持的密钥规范类型：" + keySpec.getClass().getName() + "。本方法只支持 "
                 + RSAPrivateKeySpec.class.getName() + " 和 " + RSAPublicKeySpec.class.getName());
     }
     
     /**
     * 对数据进行加密
     * 
     * @param data 要进行加密的明文数据
     * @param keySpec RSA 专用密钥规范，类型必须是 {@link RSAPrivateKeySpec} 或  {@link RSAPublicKeySpec} 
     * @return 加密后的密文
     */
    public static byte[] encrypt(byte[] data, KeySpec keySpec) {
        return encrypt(data, keySpec, RSA);
    }
    
    /**
     * 对数据进行加密
     * 
     * @param data 要进行加密的明文数据
     * @param keySpec RSA 专用密钥规范，类型必须是 {@link RSAPrivateKeySpec} 或  {@link RSAPublicKeySpec} 
     * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
     *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
     *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
     *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
     * @return 加密后的密文
     */
    public static byte[] encrypt(byte[] data, KeySpec keySpec, String transformation){
        return encrypt(data, getKeyByKeySpec(keySpec), transformation);
    } 
    
    /**
     * 对字符串进行加密
     * 
     * @param data 要进行加密的明文字符串
     * @param keySpec RSA 专用密钥规范，类型必须是 {@link RSAPrivateKeySpec} 或  {@link RSAPublicKeySpec} 
     * @return 加密后的密文
     */
    public static byte[] encrypt(String data, KeySpec keySpec) {  
        return encrypt(data, keySpec, RSA);
    }
    
    /**
     * 对字符串进行加密
     * 
     * @param data 要进行加密的明文字符串
     * @param keySpec RSA 专用密钥规范，类型必须是 {@link RSAPrivateKeySpec} 或  {@link RSAPublicKeySpec} 
     * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
     *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
     *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
     *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
     * @return 加密后的密文
     */
    public static byte[] encrypt(String data, KeySpec keySpec, String transformation) {
        return encrypt(data, getKeyByKeySpec(keySpec), transformation);
    }
 
    /**
     * 对文件内容进行加密，文件太大可能会导致内存溢出
     * 
     * @param data 要进行加密的文件
     * @param keySpec RSA 专用密钥规范，类型必须是 {@link RSAPrivateKeySpec} 或  {@link RSAPublicKeySpec} 
     * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
     *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
     *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
     *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
     * @return 加密后的密文
     * @see #encrypt(File, File, String)
     */
    public static byte[] encrypt(File file, KeySpec keySpec) {
        return encrypt(file, keySpec, RSA);
    }
    
    /**
     * 对文件内容进行加密，文件太大可能会导致内存溢出
     * 
     * @param data 要进行加密的文件
     * @param keySpec RSA 专用密钥规范，类型必须是 {@link RSAPrivateKeySpec} 或  {@link RSAPublicKeySpec} 
     * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
     *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
     *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
     *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
     * @return 加密后的密文
     * @see #encrypt(File, File, String, String)
     */
    public static byte[] encrypt(File file, KeySpec keySpec, String transformation) {
        return encrypt(file, getKeyByKeySpec(keySpec), transformation);
    }
    
    /**
     * 对文件进行加密
     * @param src 源文件
     * @param dest 加密后文件
     * @param keySpec RSA 专用密钥规范，类型必须是 {@link RSAPrivateKeySpec} 或  {@link RSAPublicKeySpec} 
     */
    public static void encrypt(File src, File dest, KeySpec keySpec){
        encrypt(src, dest, keySpec, RSA);
    }
    
    /**
     * 对文件进行加密
     * @param src 源文件
     * @param dest 加密后文件
     * @param keySpec RSA 专用密钥规范，类型必须是 {@link RSAPrivateKeySpec} 或  {@link RSAPublicKeySpec} 
     * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
     *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
     *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
     *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
     */
    public static void encrypt(File src, File dest, KeySpec keySpec, String transformation) {
        encrypt(src, dest, getKeyByKeySpec(keySpec), transformation);
    }
    
    /**
    * 使用私钥对数据进行加密
    * 
    * @param data 要进行加密的明文数据
    * @param privateKey 私钥
    * @return 加密后的密文
    */
   public static byte[] encryptByPrivateKey(byte[] data, String privateKey) {
       return encryptByPrivateKey(data, privateKey, RSA);
   }
   
   /**
    * 使用私钥对数据进行加密
    * 
    * @param data 要进行加密的明文数据
    * @param privateKey 私钥
    * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
    *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
    *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
    *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
    * @return 加密后的密文
    */
   public static byte[] encryptByPrivateKey(byte[] data, String privateKey, String transformation) {
       return encrypt(data, getPrivateKey(privateKey), transformation);
   }
   
   /**
    * 对字符串进行加密
    * 
    * @param data 要进行加密的明文字符串
    * @param privateKey 私钥
    * @return 加密后的密文
    */
   public static byte[] encryptByPrivateKey(String data, String privateKey) {  
       return encryptByPrivateKey(data, privateKey, RSA);
   }
   
   /**
    * 对字符串进行加密
    * 
    * @param data 要进行加密的明文字符串
    * @param privateKey 私钥
    * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
    *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
    *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
    *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
    * @return 加密后的密文
    */
   public static byte[] encryptByPrivateKey(String data, String privateKey, String transformation) {
       return encrypt(data, getPrivateKey(privateKey), transformation);
   }
 
   /**
    * 对文件内容进行加密，文件太大可能会导致内存溢出
    * 
    * @param data 要进行加密的文件
    * @param privateKey 私钥
    * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
    *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
    *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
    *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
    * @return 加密后的密文
    * @see #encryptByPrivateKey(File, File, String)
    */
   public static byte[] encryptByPrivateKey(File file, String privateKey) {
       return encryptByPrivateKey(file, privateKey, RSA);
   }
   
   /**
    * 对文件内容进行加密，文件太大可能会导致内存溢出
    * 
    * @param data 要进行加密的文件
    * @param privateKey 私钥
    * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
    *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
    *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
    *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
    * @return 加密后的密文
    * @see #encryptByPrivateKey(File, File, String, String)
    */
   public static byte[] encryptByPrivateKey(File file, String privateKey, String transformation) {
       return encrypt(file, getPrivateKey(privateKey), transformation);
   }
   
   /**
    * 对文件进行加密
    * @param src 源文件
    * @param dest 加密后文件
    * @param privateKey 私钥
    */
   public static void encryptByPrivateKey(File src, File dest, String privateKey){
       encryptByPrivateKey(src, dest, privateKey, RSA);
   }
   
   /**
    * 对文件进行加密
    * @param src 源文件
    * @param dest 加密后文件
    * @param privateKey 私钥
    * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
    *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
    *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
    *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
    */
   public static void encryptByPrivateKey(File src, File dest, String privateKey, String transformation) {
       encrypt(src, dest, getPrivateKey(privateKey), transformation);
   }
 
   /**
   * 使用公钥对数据进行加密
   * 
   * @param data 要进行加密的明文数据
   * @param publicKey 公钥
   * @return 加密后的密文
   */
   public static byte[] encryptByPublicKey(byte[] data, String publicKey) {
       return encryptByPublicKey(data, publicKey, RSA);
   }
  
  /**
   * 使用公钥对数据进行加密
   * 
   * @param data 要进行加密的明文数据
   * @param publicKey 公钥
   * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
   *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
   *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
   *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
   * @return 加密后的密文
   */
   public static byte[] encryptByPublicKey(byte[] data, String publicKey, String transformation){
       return encrypt(data, getPublicKey(publicKey), transformation);
   }
  
  /**
   * 对字符串进行加密
   * 
   * @param data 要进行加密的明文字符串
   * @param publicKey 公钥
   * @return 加密后的密文
   */
   public static byte[] encryptByPublicKey(String data, String publicKey) {  
       return encryptByPublicKey(data, publicKey, RSA);
   }
  
  /**
   * 对字符串进行加密
   * 
   * @param data 要进行加密的明文字符串
   * @param publicKey 公钥
   * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
   *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
   *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
   *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
   * @return 加密后的密文
   */
   public static byte[] encryptByPublicKey(String data, String publicKey, String transformation) {
       return encrypt(data, getPublicKey(publicKey), transformation);
   }
 
  /**
   * 对文件内容进行加密，文件太大可能会导致内存溢出
   * 
   * @param data 要进行加密的文件
   * @param publicKey 公钥
   * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
   *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
   *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
   *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
   * @return 加密后的密文
   * @see #encryptByPublicKey(File, File, String)
   */
   public static byte[] encryptByPublicKey(File file, String publicKey) {
       return encryptByPublicKey(file, publicKey, RSA);
   }
  
  /**
   * 对文件内容进行加密，文件太大可能会导致内存溢出
   * 
   * @param data 要进行加密的文件
   * @param publicKey 公钥
   * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
   *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
   *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
   *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
   * @return 加密后的密文
   * @see #encryptByPublicKey(File, File, String, String)
   */
   public static byte[] encryptByPublicKey(File file, String publicKey, String transformation) {
       return encrypt(file, getPublicKey(publicKey), transformation);
   }
  
  /**
   * 对文件进行加密
   * @param src 源文件
   * @param dest 加密后文件
   * @param publicKey 公钥
   */
   public static void encryptByPublicKey(File src, File dest, String publicKey){
       encryptByPublicKey(src, dest, publicKey, RSA);
   }
  
  /**
   * 对文件进行加密
   * @param src 源文件
   * @param dest 加密后文件
   * @param publicKey 公钥
   * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
   *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
   *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
   *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
   */
   public static void encryptByPublicKey(File src, File dest, String publicKey, String transformation) {
       encrypt(src, dest, getPublicKey(publicKey), transformation);
   }
 
  /**
    * 对数据进行加密
    * 
    * @param data 要进行加密的明文数据
    * @param key 密钥
    * @return 加密后的密文
    */
   public static String encryptBase64(byte[] data, Key key) {
       return encryptBase64(data, key, key.getAlgorithm());
   }
   
   /**
    * 对数据进行加密
    * 
    * @param data 要进行加密的明文数据
    * @param key 密钥
    * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
    *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
    *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
    *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
    * @return 加密后的密文
    */
   public static String encryptBase64(byte[] data, Key key, String transformation){
       byte[] result = encrypt(data, key, transformation);
       return Base64.encodeBase64String(result);
   } 
   
   /**
    * 对字符串进行加密
    * 
    * @param data 要进行加密的明文字符串
    * @param key 密钥
    * @return 加密后的密文
    */
   public static String encryptBase64(String data, Key key) {  
       return encryptBase64(data, key, key.getAlgorithm());
   }
   
   /**
    * 对字符串进行加密
    * 
    * @param data 要进行加密的明文字符串
    * @param key 密钥
    * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
    *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
    *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
    *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
    * @return 加密后的密文
    */
   public static String encryptBase64(String data, Key key, String transformation) {
       return encryptBase64(data.getBytes(), key, transformation);
   }
   /**
   * 对数据进行加密
   * 
   * @param data 要进行加密的明文数据
   * @param keySpec RSA 专用密钥规范，类型必须是 {@link RSAPrivateKeySpec} 或  {@link RSAPublicKeySpec} 
   * @return 加密后的密文
   */
   public static String encryptBase64(byte[] data, KeySpec keySpec) {
       return encryptBase64(data, keySpec, RSA);
   }
  
  /**
   * 对数据进行加密
   * 
   * @param data 要进行加密的明文数据
   * @param keySpec RSA 专用密钥规范，类型必须是 {@link RSAPrivateKeySpec} 或  {@link RSAPublicKeySpec} 
   * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
   *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
   *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
   *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
   * @return 加密后的密文
   */
   public static String encryptBase64(byte[] data, KeySpec keySpec, String transformation){
       return encryptBase64(data, getKeyByKeySpec(keySpec), RSA);
   } 
  
  /**
   * 对字符串进行加密
   * 
   * @param data 要进行加密的明文字符串
   * @param keySpec RSA 专用密钥规范，类型必须是 {@link RSAPrivateKeySpec} 或  {@link RSAPublicKeySpec} 
   * @return 加密后的密文
   */
   public static String encryptBase64(String data, KeySpec keySpec) {  
       return encryptBase64(data, keySpec, RSA);
   }
  
  /**
   * 对字符串进行加密
   * 
   * @param data 要进行加密的明文字符串
   * @param keySpec RSA 专用密钥规范，类型必须是 {@link RSAPrivateKeySpec} 或  {@link RSAPublicKeySpec} 
   * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
   *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
   *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
   *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
   * @return 加密后的密文
   */
   public static String encryptBase64(String data, KeySpec keySpec, String transformation) {
       return encryptBase64(data, getKeyByKeySpec(keySpec), RSA);
   }
 
  /**
  * 使用私钥对数据进行加密
  * 
  * @param data 要进行加密的明文数据
  * @param privateKey 私钥
  * @return 加密后的密文
  */
   public static String encryptBase64ByPrivateKey(byte[] data, String privateKey) {
       return encryptBase64ByPrivateKey(data, privateKey, RSA);
   }
 
   /**
    * 使用私钥对数据进行加密
    * 
    * @param data 要进行加密的明文数据
    * @param privateKey 私钥
    * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
    *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
    *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
    *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
    * @return 加密后的密文
    */
   public static String encryptBase64ByPrivateKey(byte[] data, String privateKey, String transformation){
       return encryptBase64(data, getPrivateKey(privateKey), RSA);
   } 
 
   /**
    * 使用私钥对字符串进行加密
    * 
    * @param data 要进行加密的明文字符串
    * @param privateKey 私钥
    * @return 加密后的密文
    */
   public static String encryptBase64ByPrivateKey(String data, String privateKey) {  
       return encryptBase64ByPrivateKey(data, privateKey, RSA);
   }
 
   /**
    * 使用私钥对字符串进行加密
    * 
    * @param data 要进行加密的明文字符串
    * @param privateKey 私钥
    * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
    *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
    *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
    *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
    * @return 加密后的密文
    */
   public static String encryptBase64ByPrivateKey(String data, String privateKey, String transformation) {
       return encryptBase64(data, getPrivateKey(privateKey), RSA);
   }
 
   /**
   * 使用公钥对数据进行加密
   * 
   * @param data 要进行加密的明文数据
   * @param publicKey 公钥
   * @return 加密后的密文
   */
   public static String encryptBase64ByPublicKey(byte[] data, String publicKey) {
      return encryptBase64ByPublicKey(data, publicKey, RSA);
   }
 
   /**
   * 使用公钥对数据进行加密
   * 
   * @param data 要进行加密的明文数据
   * @param publicKey 公钥
   * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
   *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
   *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
   *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
   * @return 加密后的密文
   */
   public static String encryptBase64ByPublicKey(byte[] data, String publicKey, String transformation){
       return encryptBase64(data, getPublicKey(publicKey), RSA);
   } 
 
   /**
   * 使用公钥对字符串进行加密
   * 
   * @param data 要进行加密的明文字符串
   * @param publicKey 公钥
   * @return 加密后的密文
   */
   public static String encryptBase64ByPublicKey(String data, String publicKey) {  
      return encryptBase64ByPublicKey(data, publicKey, RSA);
   }
 
   /**
   * 使用公钥对字符串进行加密
   * 
   * @param data 要进行加密的明文字符串
   * @param publicKey 公钥
   * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
   *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
   *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
   *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
   * @return 加密后的密文
   */
   public static String encryptBase64ByPublicKey(String data, String publicKey, String transformation) {
       return encryptBase64(data, getPublicKey(publicKey), RSA);
   }
 
 
 
   /**
    * 对数据进行解密
    * 
    * @param data 要进行解密的密文数据
    * @param key 密钥
    * @return 解密后的密文
    */
   public static byte[] decrypt(byte[] data, Key key) {
       return decrypt(data, key, key.getAlgorithm());
   }
 
     /**
      * 对数据进行解密
      * 
      * @param data 要进行解密的密文
      * @param key 密钥
      * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
      *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
      *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
      *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
      * @return 解密后的明文
      */
       public static byte[] decrypt(byte[] encryptedData, Key key, String transformation) {
           ByteArrayOutputStream out = null;
           try {
               Cipher cipher = Cipher.getInstance(transformation);
               cipher.init(Cipher.DECRYPT_MODE, key);
               out = new ByteArrayOutputStream();
               int offSet = 0;
               byte[] cache;
               // 对数据分段解密
               while (offSet < encryptedData.length) {
                   cache = cipher.doFinal(encryptedData, offSet, Math.min(MAX_DECRYPT_BLOCK,
                           encryptedData.length - offSet));
                   out.write(cache);
                   offSet += MAX_DECRYPT_BLOCK;
               }
               return out.toByteArray();
           } catch (Exception e) {
               throw new GboatSecurityException("使用密钥 [" + key
                       + "] 对数据进行加密失败。transformation=" + transformation, e);
           } finally {
               IOUtils.closeQuietly(out);
           }
       }
       
     /**
      * 对字符串进行解密
      * 
      * @param data 经过 BASE64 编码的的密文字符串
      * @param key 密钥
      * @return 解密后的密文
      */
     public static byte[] decrypt(String data, Key key) {  
         return decrypt(data, key, key.getAlgorithm());
     }
     
     /**
      * 对字符串进行解密
      * 
      * @param data 经过 BASE64 编码的的密文字符串
      * @param key 密钥
      * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
      *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
      *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
      *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
      * @return 解密后的密文
      */
     public static byte[] decrypt(String data, Key key, String transformation) {
         return decrypt(Base64.decodeBase64(data), key, transformation);
     }
 
     /**
      * 对文件内容进行解密，文件太大可能会导致内存溢出
      * 
      * @param data 要进行解密的文件
      * @param key 密钥
      * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
      *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
      *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
      *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
      * @return 解密后的密文
      * @see #decrypt(File, File, Key)
      */
     public static byte[] decrypt(File file, Key key) {
         return decrypt(file, key, key.getAlgorithm());
     }
     
     /**
      * 对文件内容进行解密，文件太大可能会导致内存溢出
      * 
      * @param data 要进行解密的文件
      * @param key 密钥
      * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
      *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
      *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
      *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
      * @return 解密后的密文
      * @see #decrypt(File, File, Key, String)
      */
     public static byte[] decrypt(File file, Key key, String transformation) {
         try {
             return decrypt(FileUtils.readFileToByteArray(file), key, transformation);
         } catch (IOException e) {
             throw new GboatSecurityException("对文件解密失败。file=[" + file + "], key=["
                     + key + "], transformation=[" + transformation + "]", e);
         }
     }
     
     /**
      * 对文件进行解密
      * @param src 源文件
      * @param dest 解密后文件
      * @param key 密钥
      */
     public static void decrypt(File src, File dest, Key key){
         decrypt(src, dest, key, key.getAlgorithm());
     }
 
     /**
      * 对文件进行解密
      * @param src 加密后的文件
      * @param dest 解密后的文件
      * @param key 密钥
      * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
      *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
      *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
      *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
      */
     public static void decrypt(File src, File dest, Key key, String transformation) {
         if (!dest.getParentFile().exists()) {
             dest.getParentFile().mkdirs();
         }
 //        dest.createNewFile();
         
         FileInputStream in = null;
         OutputStream out = null;
         try {
             Cipher cipher = Cipher.getInstance(transformation);
             cipher.init(Cipher.DECRYPT_MODE, key);
           
             in = new FileInputStream(src);
             out = new FileOutputStream(dest);
             byte[] data = new byte[MAX_DECRYPT_BLOCK];
             int len = 0; // 解密块
             while ((len = in.read(data)) != -1) {
                 out.write(cipher.doFinal(data), 0, len);
 //                out.flush();
             }
         } catch (InvalidKeyException e) {
             throw new GboatSecurityException("对文件加密失败：密钥无效。src=[" + src + "], dest=[" + dest
                     + "], key=[" + key + "], transformation=[" + transformation + "]", e);
         } catch (NoSuchAlgorithmException e) {
             throw new GboatSecurityException("对文件加密失败：算法 不存在，或当前  JDK 不支持该算法。src=[" + src + "], dest=[" + dest
                     + "], key=[" + key + "], transformation=[" + transformation + "]", e);
         } catch (FileNotFoundException e) {
             throw new GboatSecurityException("对文件加密失败：文件不存在。src=[" + src + "], dest=[" + dest
                     + "], key=[" + key + "], transformation=[" + transformation + "]", e);
         } catch (Exception e) {
             throw new GboatSecurityException("对文件加密失败。src=[" + src + "], dest=[" + dest
                     + "], key=[" + key + "], transformation=[" + transformation + "]", e);
         } finally {
             IOUtils.closeQuietly(out);
             IOUtils.closeQuietly(in);
         }
     }
     
     /**
     * 对数据进行解密
     * 
     * @param data 要进行解密的密文数据
     * @param keySpec RSA 专用密钥规范，类型必须是 {@link RSAPrivateKeySpec} 或  {@link RSAPublicKeySpec} 
     * @return 解密后的密文
     */
    public static byte[] decrypt(byte[] data, KeySpec keySpec) {
        return decrypt(data, keySpec, RSA);
    }
    
    /**
     * 对数据进行解密
     * 
     * @param data 要进行解密的密文数据
     * @param keySpec RSA 专用密钥规范，类型必须是 {@link RSAPrivateKeySpec} 或  {@link RSAPublicKeySpec} 
     * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
     *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
     *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
     *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
     * @return 解密后的密文
     */
    public static byte[] decrypt(byte[] data, KeySpec keySpec, String transformation){
        return decrypt(data, getKeyByKeySpec(keySpec), transformation);
    } 
    
    /**
     * 对字符串进行解密
     * 
     * @param data 经过 BASE64 编码的的密文字符串
     * @param keySpec RSA 专用密钥规范，类型必须是 {@link RSAPrivateKeySpec} 或  {@link RSAPublicKeySpec} 
     * @return 解密后的密文
     */
    public static byte[] decrypt(String data, KeySpec keySpec) {  
        return decrypt(data, keySpec, RSA);
    }
    
    /**
     * 对字符串进行解密
     * 
     * @param data 经过 BASE64 编码的的密文字符串
     * @param keySpec RSA 专用密钥规范，类型必须是 {@link RSAPrivateKeySpec} 或  {@link RSAPublicKeySpec} 
     * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
     *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
     *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
     *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
     * @return 解密后的密文
     */
    public static byte[] decrypt(String data, KeySpec keySpec, String transformation) {
        return decrypt(data, getKeyByKeySpec(keySpec), transformation);
    }
 
    /**
     * 对文件内容进行解密，文件太大可能会导致内存溢出
     * 
     * @param data 要进行解密的文件
     * @param keySpec RSA 专用密钥规范，类型必须是 {@link RSAPrivateKeySpec} 或  {@link RSAPublicKeySpec} 
     * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
     *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
     *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
     *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
     * @return 解密后的密文
     * @see #decrypt(File, File, String)
     */
    public static byte[] decrypt(File file, KeySpec keySpec) {
        return decrypt(file, keySpec, RSA);
    }
    
    /**
     * 对文件内容进行解密，文件太大可能会导致内存溢出
     * 
     * @param data 要进行解密的文件
     * @param keySpec RSA 专用密钥规范，类型必须是 {@link RSAPrivateKeySpec} 或  {@link RSAPublicKeySpec} 
     * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
     *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
     *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
     *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
     * @return 解密后的密文
     * @see #decrypt(File, File, String, String)
     */
    public static byte[] decrypt(File file, KeySpec keySpec, String transformation) {
        return decrypt(file, getKeyByKeySpec(keySpec), transformation);
    }
    
    /**
     * 对文件进行解密
     * @param src 源文件
     * @param dest 解密后文件
     * @param keySpec RSA 专用密钥规范，类型必须是 {@link RSAPrivateKeySpec} 或  {@link RSAPublicKeySpec} 
     */
    public static void decrypt(File src, File dest, KeySpec keySpec){
        decrypt(src, dest, keySpec, RSA);
    }
    
    /**
     * 对文件进行解密
     * @param src 源文件
     * @param dest 解密后文件
     * @param keySpec RSA 专用密钥规范，类型必须是 {@link RSAPrivateKeySpec} 或  {@link RSAPublicKeySpec} 
     * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
     *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
     *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
     *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
     */
    public static void decrypt(File src, File dest, KeySpec keySpec, String transformation) {
        decrypt(src, dest, getKeyByKeySpec(keySpec), transformation);
    }
    
    /**
    * 使用私钥对数据进行解密
    * 
    * @param data 要进行解密的密文数据
    * @param privateKey 私钥
    * @return 解密后的密文
    */
   public static byte[] decryptByPrivateKey(byte[] data, String privateKey) {
       return decryptByPrivateKey(data, privateKey, RSA);
   }
   
   /**
    * 使用私钥对数据进行解密
    * 
    * @param data 要进行解密的密文数据
    * @param privateKey 私钥
    * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
    *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
    *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
    *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
    * @return 解密后的密文
    */
   public static byte[] decryptByPrivateKey(byte[] data, String privateKey, String transformation) {
       return decrypt(data, getPrivateKey(privateKey), transformation);
   }
   
   /**
    * 对字符串进行解密
    * 
    * @param data 经过 BASE64 编码的的密文字符串
    * @param privateKey 私钥
    * @return 解密后的密文
    */
   public static byte[] decryptByPrivateKey(String data, String privateKey) {  
       return decryptByPrivateKey(data, privateKey, RSA);
   }
   
   /**
    * 对字符串进行解密
    * 
    * @param data 经过 BASE64 编码的的密文字符串
    * @param privateKey 私钥
    * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
    *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
    *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
    *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
    * @return 解密后的密文
    */
   public static byte[] decryptByPrivateKey(String data, String privateKey, String transformation) {
       return decrypt(data, getPrivateKey(privateKey), transformation);
   }
 
   /**
    * 对文件内容进行解密，文件太大可能会导致内存溢出
    * 
    * @param data 要进行解密的文件
    * @param privateKey 私钥
    * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
    *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
    *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
    *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
    * @return 解密后的密文
    * @see #decryptByPrivateKey(File, File, String)
    */
   public static byte[] decryptByPrivateKey(File file, String privateKey) {
       return decryptByPrivateKey(file, privateKey, RSA);
   }
   
   /**
    * 对文件内容进行解密，文件太大可能会导致内存溢出
    * 
    * @param data 要进行解密的文件
    * @param privateKey 私钥
    * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
    *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
    *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
    *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
    * @return 解密后的密文
    * @see #decryptByPrivateKey(File, File, String, String)
    */
   public static byte[] decryptByPrivateKey(File file, String privateKey, String transformation) {
       return decrypt(file, getPrivateKey(privateKey), transformation);
   }
   
   /**
    * 对文件进行解密
    * @param src 源文件
    * @param dest 解密后文件
    * @param privateKey 私钥
    */
   public static void decryptByPrivateKey(File src, File dest, String privateKey){
       decryptByPrivateKey(src, dest, privateKey, RSA);
   }
   
   /**
    * 对文件进行解密
    * @param src 源文件
    * @param dest 解密后文件
    * @param privateKey 私钥
    * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
    *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
    *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
    *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
    */
   public static void decryptByPrivateKey(File src, File dest, String privateKey, String transformation) {
       decrypt(src, dest, getPrivateKey(privateKey), transformation);
   }
 
   /**
   * 使用公钥对数据进行解密
   * 
   * @param data 要进行解密的密文数据
   * @param publicKey 公钥
   * @return 解密后的密文
   */
   public static byte[] decryptByPublicKey(byte[] data, String publicKey) {
       return decryptByPublicKey(data, publicKey, RSA);
   }
  
  /**
   * 使用公钥对数据进行解密
   * 
   * @param data 要进行解密的密文数据
   * @param publicKey 公钥
   * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
   *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
   *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
   *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
   * @return 解密后的密文
   */
   public static byte[] decryptByPublicKey(byte[] data, String publicKey, String transformation){
       return decrypt(data, getPublicKey(publicKey), transformation);
   }
  
  /**
   * 对字符串进行解密
   * 
   * @param data 经过 BASE64 编码的的密文字符串
   * @param publicKey 公钥
   * @return 解密后的密文
   */
   public static byte[] decryptByPublicKey(String data, String publicKey) {  
       return decryptByPublicKey(data, publicKey, RSA);
   }
  
  /**
   * 对字符串进行解密
   * 
   * @param data 经过 BASE64 编码的的密文字符串
   * @param publicKey 公钥
   * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
   *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
   *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
   *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
   * @return 解密后的密文
   */
   public static byte[] decryptByPublicKey(String data, String publicKey, String transformation) {
       return decrypt(data, getPublicKey(publicKey), transformation);
   }
 
  /**
   * 对文件内容进行解密，文件太大可能会导致内存溢出
   * 
   * @param data 要进行解密的文件
   * @param publicKey 公钥
   * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
   *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
   *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
   *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
   * @return 解密后的密文
   * @see #decryptByPublicKey(File, File, String)
   */
   public static byte[] decryptByPublicKey(File file, String publicKey) {
       return decryptByPublicKey(file, publicKey, RSA);
   }
  
  /**
   * 对文件内容进行解密，文件太大可能会导致内存溢出
   * 
   * @param data 要进行解密的文件
   * @param publicKey 公钥
   * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
   *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
   *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
   *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
   * @return 解密后的密文
   * @see #decryptByPublicKey(File, File, String, String)
   */
   public static byte[] decryptByPublicKey(File file, String publicKey, String transformation) {
       return decrypt(file, getPublicKey(publicKey), transformation);
   }
  
     /**
      * 对文件进行解密
      * @param src 源文件
      * @param dest 解密后文件
      * @param publicKey 公钥
      */
     public static void decryptByPublicKey(File src, File dest, String publicKey) {
         decryptByPublicKey(src, dest, publicKey, RSA);
     }
  
     /**
      * 对文件进行解密
      * @param src 源文件
      * @param dest 解密后文件
      * @param publicKey 公钥
      * @param transformation  the name of the transformation, format is "Algorithm/Modes/Paddings", e.g.,
      *            DES/CBC/PKCS5Padding. See Appendix A in the <a target="_blank"
      *            href="http://docs.oracle.com/javase/6/docs/technotes/guides/security/crypto/CryptoSpec.html#AppA">
      *            Java Cryptography Architecture Reference Guide</a> for information about standard transformation names.
      */
     public static void decryptByPublicKey(File src, File dest, String publicKey, String transformation) {
         decrypt(src, dest, getPublicKey(publicKey), transformation);
     }
 
     /**
      * remove leading (Most Significant) zero byte if present
      * 
      * @param data
      * @return
      */
     private static byte[] removeMSZero(byte[] data) {
         byte[] data1;
         int len = data.length;
         if (data[0] == 0) {
             data1 = new byte[data.length - 1];
             System.arraycopy(data, 1, data1, 0, len - 1);
         } else
             data1 = data;
 
         return data1;
     }
 
     /**
      * Utility method to delete the leading zeros from the modulus.
      * 
      * @param modulus
      * @return
      */
     private static byte[] stripLeadingZeros(byte[] modulus) {
         int lastZero = -1;
         for (int i = 0; i < modulus.length; i++) {
             if (modulus[i] == 0) {
                 lastZero = i;
             } else {
                 break;
             }
         }
         lastZero++;
         byte[] result = new byte[modulus.length - lastZero];
         System.arraycopy(modulus, lastZero, result, 0, result.length);
         return result;
     }
 
 }