如下代码:
ublic class RSAUtils {
private static String RSA = "RSA";
* 随机生成RSA密钥对(默认密钥长度为1024)
* @return
public static KeyPair generateRSAKeyPair()
return generateRSAKeyPair(1024);
* 随机生成RSA密钥对
* @param keyLength
* 密钥长度，范围：512～2048<br>
* 一般1024
* @return
public static KeyPair generateRSAKeyPair(int keyLength)
KeyPairGenerator kpg = KeyPairGenerator.getInstance(RSA);
kpg.initialize(keyLength);
return kpg.genKeyPair();
} catch (NoSuchAlgorithmException e)
e.printStackTrace();
return null;
* 用公钥加密 <br>
* 每次加密的字节数，不能超过密钥的长度值减去11
* @param data 需加密数据的byte数据
* @param PublicKey 公钥
* @return 加密后的byte型数据
public static byte[] encryptData(byte[] data, PublicKey publicKey)
Cipher cipher = Cipher.getInstance(RSA);
// 编码前设定编码方式及密钥
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
// 传入编码数据并返回编码结果
return cipher.doFinal(data);
} catch (Exception e)
e.printStackTrace();
return null;
* 用私钥解密
* @param encryptedData
* 经过encryptedData()加密返回的byte数据
* @param privateKey
* 私钥
* @return
public static byte[] decryptData(byte[] encryptedData, PrivateKey privateKey)
Cipher cipher = Cipher.getInstance(RSA);
cipher.init(Cipher.DECRYPT_MODE, privateKey);
return cipher.doFinal(encryptedData);
} catch (Exception e)
return null;
* 通过公钥byte[](publicKey.getEncoded())将公钥还原，适用于RSA算法
* @param keyBytes
* @return
* @throws NoSuchAlgorithmException
* @throws InvalidKeySpecException
public static PublicKey getPublicKey(byte[] keyBytes) throws Exception {
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance(RSA);
PublicKey publicKey = keyFactory.generatePublic(keySpec);
return publicKey;
* 通过私钥byte[]将公钥还原，适用于RSA算法
* @param keyBytes
* @return
* @throws NoSuchAlgorithmException
* @throws InvalidKeySpecException
public static PrivateKey getPrivateKey(byte[] keyBytes) throws NoSuchAlgorithmException,
InvalidKeySpecException
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance(RSA);
PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
return privateKey;
* 使用N、e值还原公钥
* @param modulus
* @param publicExponent
* @return
* @throws NoSuchAlgorithmException
* @throws InvalidKeySpecException
public static PublicKey getPublicKey(String modulus, String publicExponent)
throws NoSuchAlgorithmException, InvalidKeySpecException
BigInteger bigIntModulus = new BigInteger(modulus);
BigInteger bigIntPrivateExponent = new BigInteger(publicExponent);
RSAPublicKeySpec keySpec = new RSAPublicKeySpec(bigIntModulus, bigIntPrivateExponent);
KeyFactory keyFactory = KeyFactory.getInstance(RSA);
PublicKey publicKey = keyFactory.generatePublic(keySpec);
return publicKey;
* 使用N、d值还原私钥
* @param modulus
* @param privateExponent
* @return
* @throws NoSuchAlgorithmException
* @throws InvalidKeySpecException
public static PrivateKey getPrivateKey(String modulus, String privateExponent)
throws NoSuchAlgorithmException, InvalidKeySpecException
BigInteger bigIntModulus = new BigInteger(modulus);
BigInteger bigIntPrivateExponent = new BigInteger(privateExponent);
RSAPublicKeySpec keySpec = new RSAPublicKeySpec(bigIntModulus, bigIntPrivateExponent);
KeyFactory keyFactory = KeyFactory.getInstance(RSA);
PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
return privateKey;
* 从字符串中加载公钥
* @param publicKeyStr
* 公钥数据字符串
* @throws Exception
* 加载公钥时产生的异常
public static PublicKey loadPublicKey(String publicKeyStr) throws Exception
byte[] buffer = Base64Utils.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("公钥数据为空");
* 从字符串中加载私钥<br>
* 加载时使用的是PKCS8EncodedKeySpec（PKCS#8编码的Key指令）。
* @param privateKeyStr
* @return
* @throws Exception
public static PrivateKey loadPrivateKey(String privateKeyStr) throws Exception
byte[] buffer = Base64Utils.decode(privateKeyStr);
// X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);
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 in
* 公钥输入流
* @throws Exception
* 加载公钥时产生的异常
public static PublicKey loadPublicKey(InputStream in) throws Exception
return loadPublicKey(readKey(in));
} catch (IOException e)
throw new Exception("公钥数据流读取错误");
} catch (NullPointerException e)
throw new Exception("公钥输入流为空");
* 从文件中加载私钥
* @return 是否成功
* @throws Exception
public static PrivateKey loadPrivateKey(InputStream in) throws Exception
return loadPrivateKey(readKey(in));
} catch (IOException e)
throw new Exception("私钥数据读取错误");
} catch (NullPointerException e)
throw new Exception("私钥输入流为空");
* 读取密钥信息
* @param in
* @return
* @throws IOException
private static String readKey(InputStream in) throws IOException
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String readLine = null;
StringBuilder sb = new StringBuilder();
while ((readLine = br.readLine()) != null)
if (readLine.charAt(0) == '-')
continue;
} else
sb.append(readLine);
sb.append('\r');
return sb.toString();
* 打印公钥信息
* @param publicKey
public static void printPublicKeyInfo(PublicKey publicKey)
RSAPublicKey rsaPublicKey = (RSAPublicKey) publicKey;
System.out.println("----------RSAPublicKey----------");
System.out.println("Modulus.length=" + rsaPublicKey.getModulus().bitLength());
System.out.println("Modulus=" + rsaPublicKey.getModulus().toString());
System.out.println("PublicExponent.length=" + rsaPublicKey.getPublicExponent().bitLength());
System.out.println("PublicExponent=" + rsaPublicKey.getPublicExponent().toString());
public static void printPrivateKeyInfo(PrivateKey privateKey)
RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) privateKey;
System.out.println("----------RSAPrivateKey ----------");
System.out.println("Modulus.length=" + rsaPrivateKey.getModulus().bitLength());
System.out.println("Modulus=" + rsaPrivateKey.getModulus().toString());
System.out.println("PrivateExponent.length=" + rsaPrivateKey.getPrivateExponent().bitLength());
System.out.println("PrivatecExponent=" + rsaPrivateKey.getPrivateExponent().toString());
* TODO rsa解密
* @param mContext
* @param encryptContent 需要解密的字符
* @return 解密完成的字符
public static String decodeInfo(Context mContext,String encryptContent){
String decodeStr;
// 从字符串中得到私钥
// PrivateKey privateKey = RSAUtils.loadPrivateKey(PRIVATE_KEY);
// 从文件中得到私钥
InputStream inPrivate = mContext.getResources().getAssets().open("pkcs8_rsa_private_key.pem");
PrivateKey privateKey = RSAUtils.loadPrivateKey(inPrivate);
// 因为RSA加密后的内容经Base64再加密转换了一下，所以先Base64解密回来再给RSA解密
byte[] decryptByte = RSAUtils.decryptData(Base64Utils.decode(encryptContent), privateKey);
decodeStr = new String(decryptByte);
} catch (Exception e) {
decodeStr="";
return decodeStr;
public static String encodeInfo(Context mContext,String source){
String encodeStr;
// 从字符串中得到公钥
// PublicKey publicKey = RSAUtils.loadPublicKey(PUCLIC_KEY);
// 从文件中得到公钥
InputStream inPublic = mContext.getResources().getAssets().open("rsa_public_key.pem");
PublicKey publicKey = RSAUtils.loadPublicKey(inPublic);
// 加密
byte[] encryptByte = RSAUtils.encryptData(source.getBytes(), publicKey);
// 为了方便观察吧加密后的数据用base64加密转一下，要不然看起来是乱码,所以解密是也是要用Base64先转换
encodeStr = Base64Utils.encode(encryptByte);
} catch (Exception e) {
encodeStr="";