很简单的一个需求，ipad端给密码RSA加密，传到java后台，解密。RSA加密算法是基于一个密钥对的，分为公钥和私钥，一般情况公钥加密，私钥解密，但也可私钥加密，公钥解密。还可以验签，就是先用私钥对数据进行加密，然后对加密后的数据进行签名，得到一个签名值。然后再用公钥先验签，证明是对应私钥加密过的数据才解密。主要是为了防止来源不确定的数据。 根据上面的介绍，大家也都知道，RSA算法的关键就是密钥对，我和IOS的同事各自找了RSA的算法实现代码，都能正常根据密钥对加解密。问题是我们各自使用对方的密钥对就不能加解密成功。IOS同事也是一个新手。连RSA算法是个什么概念都没搞清楚，我也懂点IOS。所以就陪着他一起看代码，找资料。看到底什么原因引起的密钥对不能共用。后来找到下面这篇文章： Java中使用OpenSSL生成的RSA公私钥进行数据加解密
原来在用mac 系统中自带的openssl生成的密钥对文件是X509编码格式的。而我们JAVA所需的私钥文件是PKCS#8编码格式的。。所以要将在mac 系统中生成的私钥文件转下码就行了。转码方式参考上面链接。附下java代码：
Java代码
importjava.io.BufferedReader;
importjava.io.IOException;
importjava.io.InputStream;
importjava.io.InputStreamReader;
importjava.security.InvalidKeyException;
importjava.security.KeyFactory;
importjava.security.KeyPair;
importjava.security.KeyPairGenerator;
importjava.security.NoSuchAlgorithmException;
importjava.security.SecureRandom;
importjava.security.interfaces.RSAPrivateKey;
importjava.security.interfaces.RSAPublicKey;
importjava.security.spec.InvalidKeySpecException;
importjava.security.spec.PKCS8EncodedKeySpec;
importjava.security.spec.X509EncodedKeySpec;
importjavax.crypto.BadPaddingException;
importjavax.crypto.Cipher;
importjavax.crypto.IllegalBlockSizeException;
importjavax.crypto.NoSuchPaddingException;
importsun.misc.BASE64Decoder;
importsun.misc.BASE64Encoder;
publicclassRSAEncrypt{
privatestaticfinalStringDEFAULT_PUBLIC_KEY=
"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQChDzcjw/rWgFwnxunbKp7/4e8w"+"\r"+
"/UmXx2jk6qEEn69t6N2R1i/LmcyDT1xr/T2AHGOiXNQ5V8W4iCaaeNawi7aJaRht"+"\r"+
"Vx1uOH/2U378fscEESEG8XDqll0GCfB1/TjKI2aitVSzXOtRs8kYgGU78f7VmDNg"+"\r"+
"XIlk3gdhnzh+uoEQywIDAQAB"+"\r";
privatestaticfinalStringDEFAULT_PRIVATE_KEY=
"MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAKEPNyPD+taAXCfG"+"\r"+
"6dsqnv/h7zD9SZfHaOTqoQSfr23o3ZHWL8uZzINPXGv9PYAcY6Jc1DlXxbiIJpp4"+"\r"+
"1rCLtolpGG1XHW44f/ZTfvx+xwQRIQbxcOqWXQYJ8HX9OMojZqK1VLNc61GzyRiA"+"\r"+
"ZTvx/tWYM2BciWTeB2GfOH66gRDLAgMBAAECgYBp4qTvoJKynuT3SbDJY/XwaEtm"+"\r"+
"u768SF9P0GlXrtwYuDWjAVue0VhBI9WxMWZTaVafkcP8hxX4QZqPh84td0zjcq3j"+"\r"+
"DLOegAFJkIorGzq5FyK7ydBoU1TLjFV459c8dTZMTu+LgsOTD11/V/Jr4NJxIudo"+"\r"+
"MBQ3c4cHmOoYv4uzkQJBANR+7Fc3e6oZgqTOesqPSPqljbsdF9E4x4eDFuOecCkJ"+"\r"+
"DvVLOOoAzvtHfAiUp+H3fk4hXRpALiNBEHiIdhIuX2UCQQDCCHiPHFd4gC58yyCM"+"\r"+
"6Leqkmoa+6YpfRb3oxykLBXcWx7DtbX+ayKy5OQmnkEG+MW8XB8wAdiUl0/tb6cQ"+"\r"+
"FaRvAkBhvP94Hk0DMDinFVHlWYJ3xy4pongSA8vCyMj+aSGtvjzjFnZXK4gIjBjA"+"\r"+
"2Z9ekDfIOBBawqp2DLdGuX2VXz8BAkByMuIh+KBSv76cnEDwLhfLQJlKgEnvqTvX"+"\r"+
"TB0TUw8avlaBAXW34/5sI+NUB1hmbgyTK/T/IFcEPXpBWLGO+e3pAkAGWLpnH0Zh"+"\r"+
"Fae7oAqkMAd3xCNY6ec180tAe57hZ6kS+SYLKwb4gGzYaCxc22vMtYksXHtUeamo"+"\r"+
"1NMLzI2ZfUoX"+"\r";
/**
*私钥
*/
privateRSAPrivateKeyprivateKey;
/**
*公钥
*/
privateRSAPublicKeypublicKey;
/**
*字节数据转字符串专用集合
*/
privatestaticfinalchar[]HEX_CHAR={'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
/**
*获取私钥
*@return当前的私钥对象
*/
publicRSAPrivateKeygetPrivateKey(){
returnprivateKey;
}
/**
*获取公钥
*@return当前的公钥对象
*/
publicRSAPublicKeygetPublicKey(){
returnpublicKey;
}
/**
*随机生成密钥对
*/
publicvoidgenKeyPair(){
KeyPairGeneratorkeyPairGen=null;
try{
keyPairGen=KeyPairGenerator.getInstance("RSA");
}catch(NoSuchAlgorithmExceptione){
e.printStackTrace();
}
keyPairGen.initialize(1024,newSecureRandom());
KeyPairkeyPair=keyPairGen.generateKeyPair();
this.privateKey=(RSAPrivateKey)keyPair.getPrivate();
this.publicKey=(RSAPublicKey)keyPair.getPublic();
}
/**
*从文件中输入流中加载公钥
*@paramin公钥输入流
*@throwsException加载公钥时产生的异常
*/
publicvoidloadPublicKey(InputStreamin)throwsException{
try{
BufferedReaderbr=newBufferedReader(newInputStreamReader(in));
StringreadLine=null;
StringBuildersb=newStringBuilder();
while((readLine=br.readLine())!=null){
if(readLine.charAt(0)=='-'){
continue;
}else{
sb.append(readLine);
sb.append('\r');
}
}
loadPublicKey(sb.toString());
}catch(IOExceptione){
thrownewException("公钥数据流读取错误");
}catch(NullPointerExceptione){
thrownewException("公钥输入流为空");
}
}
/**
*从字符串中加载公钥
*@parampublicKeyStr公钥数据字符串
*@throwsException加载公钥时产生的异常
*/
publicvoidloadPublicKey(StringpublicKeyStr)throwsException{
try{
BASE64Decoderbase64Decoder=newBASE64Decoder();
byte[]buffer=base64Decoder.decodeBuffer(publicKeyStr);
KeyFactorykeyFactory=KeyFactory.getInstance("RSA");
X509EncodedKeySpeckeySpec=newX509EncodedKeySpec(buffer);
this.publicKey=(RSAPublicKey)keyFactory.generatePublic(keySpec);
}catch(NoSuchAlgorithmExceptione){
thrownewException("无此算法");
}catch(InvalidKeySpecExceptione){
thrownewException("公钥非法");
}catch(IOExceptione){
thrownewException("公钥数据内容读取错误");
}catch(NullPointerExceptione){
thrownewException("公钥数据为空");
}
}
/**
*从文件中加载私钥
*@paramkeyFileName私钥文件名
*@return是否成功
*@throwsException
*/
publicvoidloadPrivateKey(InputStreamin)throwsException{
try{
BufferedReaderbr=newBufferedReader(newInputStreamReader(in));
StringreadLine=null;
StringBuildersb=newStringBuilder();
while((readLine=br.readLine())!=null){
if(readLine.charAt(0)=='-'){
continue;
}else{
sb.append(readLine);
sb.append('\r');
}
}
loadPrivateKey(sb.toString());
}catch(IOExceptione){
thrownewException("私钥数据读取错误");
}catch(NullPointerExceptione){
thrownewException("私钥输入流为空");
}
}
publicvoidloadPrivateKey(StringprivateKeyStr)throwsException{
try{
BASE64Decoderbase64Decoder=newBASE64Decoder();
byte[]buffer=base64Decoder.decodeBuffer(privateKeyStr);
PKCS8EncodedKeySpeckeySpec=newPKCS8EncodedKeySpec(buffer);
KeyFactorykeyFactory=KeyFactory.getInstance("RSA");
this.privateKey=(RSAPrivateKey)keyFactory.generatePrivate(keySpec);
}catch(NoSuchAlgorithmExceptione){
thrownewException("无此算法");
}catch(InvalidKeySpecExceptione){
e.printStackTrace();
thrownewException("私钥非法");
}catch(IOExceptione){
thrownewException("私钥数据内容读取错误");
}catch(NullPointerExceptione){
thrownewException("私钥数据为空");
}
}
/**
*加密过程
*@parampublicKey公钥
*@paramplainTextData明文数据
*@return
*@throwsException加密过程中的异常信息
*/
publicbyte[]encrypt(RSAPublicKeypublicKey,byte[]plainTextData)throwsException{
if(publicKey==null){
thrownewException("加密公钥为空,请设置");
}
Ciphercipher=null;
try{
cipher=Cipher.getInstance("RSA");//,newBouncyCastleProvider());
cipher.init(Cipher.ENCRYPT_MODE,publicKey);
byte[]output=cipher.doFinal(plainTextData);
returnoutput;
}catch(NoSuchAlgorithmExceptione){
thrownewException("无此加密算法");
}catch(NoSuchPaddingExceptione){
e.printStackTrace();
returnnull;
}catch(InvalidKeyExceptione){
thrownewException("加密公钥非法,请检查");
}catch(IllegalBlockSizeExceptione){
thrownewException("明文长度非法");
}catch(BadPaddingExceptione){
thrownewException("明文数据已损坏");
}
}
/**
*解密过程
*@paramprivateKey私钥
*@paramcipherData密文数据
*@return明文
*@throwsException解密过程中的异常信息
*/
publicbyte[]decrypt(RSAPrivateKeyprivateKey,byte[]cipherData)throwsException{
if(privateKey==null){
thrownewException("解密私钥为空,请设置");
}
Ciphercipher=null;
try{
cipher=Cipher.getInstance("RSA");//,newBouncyCastleProvider());
cipher.init(Cipher.DECRYPT_MODE,privateKey);
byte[]output=cipher.doFinal(cipherData);
returnoutput;
}catch(NoSuchAlgorithmExceptione){
thrownewException("无此解密算法");
}catch(NoSuchPaddingExceptione){
e.printStackTrace();
returnnull;
}catch(InvalidKeyExceptione){
thrownewException("解密私钥非法,请检查");
}catch(IllegalBlockSizeExceptione){
thrownewException("密文长度非法");
}catch(BadPaddingExceptione){
thrownewException("密文数据已损坏");
}
}
/**
*字节数据转十六进制字符串
*@paramdata输入数据
*@return十六进制内容
*/
publicstaticStringbyteArrayToString(byte[]data){
StringBuilderstringBuilder=newStringBuilder();
for(inti=0;i
//取出字节的高四位作为索引得到相应的十六进制标识符注意无符号右移
stringBuilder.append(HEX_CHAR[(data[i]&0xf0)>>>4]);
//取出字节的低四位作为索引得到相应的十六进制标识符
stringBuilder.append(HEX_CHAR[(data[i]&0x0f)]);
if(i
stringBuilder.append('');
}
}
returnstringBuilder.toString();
}
publicstaticvoidmain(String[]args){
RSAEncryptrsaEncrypt=newRSAEncrypt();
//rsaEncrypt.genKeyPair();
//加载公钥
try{
rsaEncrypt.loadPublicKey(RSAEncrypt.DEFAULT_PUBLIC_KEY);
System.out.println("加载公钥成功");
}catch(Exceptione){
System.err.println(e.getMessage());
System.err.println("加载公钥失败");
}
//加载私钥
try{
rsaEncrypt.loadPrivateKey(RSAEncrypt.DEFAULT_PRIVATE_KEY);
System.out.println("加载私钥成功");
}catch(Exceptione){
System.err.println(e.getMessage());
System.err.println("加载私钥失败");
}
//测试字符串
StringencryptStr="abc";
System.out.println("私钥长度："+rsaEncrypt.getPrivateKey().toString().length());
System.out.println("公钥长度："+rsaEncrypt.getPublicKey().toString().length());
try{
//加密
byte[]cipher=rsaEncrypt.encrypt(rsaEncrypt.getPublicKey(),encryptStr.getBytes());
//解密
byte[]plainText=rsaEncrypt.decrypt(rsaEncrypt.getPrivateKey(),cipher);
System.out.println("密文长度:"+cipher.length);
System.out.println(RSAEncrypt.byteArrayToString(cipher));
System.out.println("明文长度:"+plainText.length);
System.out.println(RSAEncrypt.byteArrayToString(plainText));
System.out.println(newString(plainText));
}catch(Exceptione){
System.err.println(e.getMessage());
}
}
}
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
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 javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
public class RSAEncrypt {
private static final String DEFAULT_PUBLIC_KEY=
"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQChDzcjw/rWgFwnxunbKp7/4e8w" + "\r" +
"/UmXx2jk6qEEn69t6N2R1i/LmcyDT1xr/T2AHGOiXNQ5V8W4iCaaeNawi7aJaRht" + "\r" +
"Vx1uOH/2U378fscEESEG8XDqll0GCfB1/TjKI2aitVSzXOtRs8kYgGU78f7VmDNg" + "\r" +
"XIlk3gdhnzh+uoEQywIDAQAB" + "\r";
private static final String DEFAULT_PRIVATE_KEY=
"MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAKEPNyPD+taAXCfG" + "\r" +
"6dsqnv/h7zD9SZfHaOTqoQSfr23o3ZHWL8uZzINPXGv9PYAcY6Jc1DlXxbiIJpp4" + "\r" +
"1rCLtolpGG1XHW44f/ZTfvx+xwQRIQbxcOqWXQYJ8HX9OMojZqK1VLNc61GzyRiA" + "\r" +
"ZTvx/tWYM2BciWTeB2GfOH66gRDLAgMBAAECgYBp4qTvoJKynuT3SbDJY/XwaEtm" + "\r" +
"u768SF9P0GlXrtwYuDWjAVue0VhBI9WxMWZTaVafkcP8hxX4QZqPh84td0zjcq3j" + "\r" +
"DLOegAFJkIorGzq5FyK7ydBoU1TLjFV459c8dTZMTu+LgsOTD11/V/Jr4NJxIudo" + "\r" +
"MBQ3c4cHmOoYv4uzkQJBANR+7Fc3e6oZgqTOesqPSPqljbsdF9E4x4eDFuOecCkJ" + "\r" +
"DvVLOOoAzvtHfAiUp+H3fk4hXRpALiNBEHiIdhIuX2UCQQDCCHiPHFd4gC58yyCM" + "\r" +
"6Leqkmoa+6YpfRb3oxykLBXcWx7DtbX+ayKy5OQmnkEG+MW8XB8wAdiUl0/tb6cQ" + "\r" +
"FaRvAkBhvP94Hk0DMDinFVHlWYJ3xy4pongSA8vCyMj+aSGtvjzjFnZXK4gIjBjA" + "\r" +
"2Z9ekDfIOBBawqp2DLdGuX2VXz8BAkByMuIh+KBSv76cnEDwLhfLQJlKgEnvqTvX" + "\r" +
"TB0TUw8avlaBAXW34/5sI+NUB1hmbgyTK/T/IFcEPXpBWLGO+e3pAkAGWLpnH0Zh" + "\r" +
"Fae7oAqkMAd3xCNY6ec180tAe57hZ6kS+SYLKwb4gGzYaCxc22vMtYksXHtUeamo" + "\r" +
"1NMLzI2ZfUoX" + "\r";
/**
* 私钥
*/
private RSAPrivateKey privateKey;
/**
* 公钥
*/
private RSAPublicKey publicKey;
/**
* 字节数据转字符串专用集合
*/
private static final char[] HEX_CHAR= {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
/**
* 获取私钥
* @return 当前的私钥对象
*/
public RSAPrivateKey getPrivateKey() {
return privateKey;
}
/**
* 获取公钥
* @return 当前的公钥对象
*/
public RSAPublicKey getPublicKey() {
return publicKey;
}
/**
* 随机生成密钥对
*/
public void genKeyPair(){
KeyPairGenerator keyPairGen= null;
try {
keyPairGen= KeyPairGenerator.getInstance("RSA");
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
keyPairGen.initialize(1024, new SecureRandom());
KeyPair keyPair= keyPairGen.generateKeyPair();
this.privateKey= (RSAPrivateKey) keyPair.getPrivate();
this.publicKey= (RSAPublicKey) keyPair.getPublic();
}
/**
* 从文件中输入流中加载公钥
* @param in 公钥输入流
* @throws Exception 加载公钥时产生的异常
*/
public void loadPublicKey(InputStream in) throws Exception{
try {
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');
}
}
loadPublicKey(sb.toString());
} catch (IOException e) {
throw new Exception("公钥数据流读取错误");
} catch (NullPointerException e) {
throw new Exception("公钥输入流为空");
}
}
/**
* 从字符串中加载公钥
* @param publicKeyStr 公钥数据字符串
* @throws Exception 加载公钥时产生的异常
*/
public void loadPublicKey(String publicKeyStr) throws Exception{
try {
BASE64Decoder base64Decoder= new BASE64Decoder();
byte[] buffer= base64Decoder.decodeBuffer(publicKeyStr);
KeyFactory keyFactory= KeyFactory.getInstance("RSA");
X509EncodedKeySpec keySpec= new X509EncodedKeySpec(buffer);
this.publicKey= (RSAPublicKey) keyFactory.generatePublic(keySpec);
} catch (NoSuchAlgorithmException e) {
throw new Exception("无此算法");
} catch (InvalidKeySpecException e) {
throw new Exception("公钥非法");
} catch (IOException e) {
throw new Exception("公钥数据内容读取错误");
} catch (NullPointerException e) {
throw new Exception("公钥数据为空");
}
}
/**
* 从文件中加载私钥
* @param keyFileName 私钥文件名
* @return 是否成功
* @throws Exception
*/
public void loadPrivateKey(InputStream in) throws Exception{
try {
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');
}
}
loadPrivateKey(sb.toString());
} catch (IOException e) {
throw new Exception("私钥数据读取错误");
} catch (NullPointerException e) {
throw new Exception("私钥输入流为空");
}
}
public void loadPrivateKey(String privateKeyStr) throws Exception{
try {
BASE64Decoder base64Decoder= new BASE64Decoder();
byte[] buffer= base64Decoder.decodeBuffer(privateKeyStr);
PKCS8EncodedKeySpec keySpec= new PKCS8EncodedKeySpec(buffer);
KeyFactory keyFactory= KeyFactory.getInstance("RSA");
this.privateKey= (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
} catch (NoSuchAlgorithmException e) {
throw new Exception("无此算法");
} catch (InvalidKeySpecException e) {
e.printStackTrace();
throw new Exception("私钥非法");
} catch (IOException e) {
throw new Exception("私钥数据内容读取错误");
} catch (NullPointerException e) {
throw new Exception("私钥数据为空");
}
}
/**
* 加密过程
* @param publicKey 公钥
* @param plainTextData 明文数据
* @return
* @throws Exception 加密过程中的异常信息
*/
public byte[] encrypt(RSAPublicKey publicKey, byte[] plainTextData) throws Exception{
if(publicKey== null){
throw new Exception("加密公钥为空, 请设置");
}
Cipher cipher= null;
try {
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 cipherData 密文数据
* @return 明文
* @throws Exception 解密过程中的异常信息
*/
public byte[] decrypt(RSAPrivateKey privateKey, byte[] cipherData) throws Exception{
if (privateKey== null){
throw new Exception("解密私钥为空, 请设置");
}
Cipher cipher= null;
try {
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 data 输入数据
* @return 十六进制内容
*/
public static String byteArrayToString(byte[] data){
StringBuilder stringBuilder= new StringBuilder();
for (int i=0; i
//取出字节的高四位 作为索引得到相应的十六进制标识符 注意无符号右移
stringBuilder.append(HEX_CHAR[(data[i] & 0xf0)>>> 4]);
//取出字节的低四位 作为索引得到相应的十六进制标识符
stringBuilder.append(HEX_CHAR[(data[i] & 0x0f)]);
if (i
stringBuilder.append(' ');
}
}
return stringBuilder.toString();
}
public static void main(String[] args){
RSAEncrypt rsaEncrypt= new RSAEncrypt();
//rsaEncrypt.genKeyPair();
//加载公钥
try {
rsaEncrypt.loadPublicKey(RSAEncrypt.DEFAULT_PUBLIC_KEY);
System.out.println("加载公钥成功");
} catch (Exception e) {
System.err.println(e.getMessage());
System.err.println("加载公钥失败");
}
//加载私钥
try {
rsaEncrypt.loadPrivateKey(RSAEncrypt.DEFAULT_PRIVATE_KEY);
System.out.println("加载私钥成功");
} catch (Exception e) {
System.err.println(e.getMessage());
System.err.println("加载私钥失败");
}
//测试字符串
String encryptStr= "abc";
System.out.println("私钥长度："+rsaEncrypt.getPrivateKey().toString().length());
System.out.println("公钥长度："+rsaEncrypt.getPublicKey().toString().length());
try {
//加密
byte[] cipher = rsaEncrypt.encrypt(rsaEncrypt.getPublicKey(), encryptStr.getBytes());
//解密
byte[] plainText = rsaEncrypt.decrypt(rsaEncrypt.getPrivateKey(), cipher);
System.out.println("密文长度:"+ cipher.length);
System.out.println(RSAEncrypt.byteArrayToString(cipher));
System.out.println("明文长度:"+ plainText.length);
System.out.println(RSAEncrypt.byteArrayToString(plainText));
System.out.println(new String(plainText));
} catch (Exception e) {
System.err.println(e.getMessage());
}
}
}
提供两种方式加载密钥对，可通过字符串或者文件流，文件是指生成的.pem文件才可以哦。 另外附一份IOS中加密方法，不过这里要求的文件是der。 http://blog.yorkgu.me//10/27/rsa-in-ios-using-publick-key-generated-by-openssl/ IOS中加密后返回的NSdata对象，可以对NSdata对象进行base64编码转换成字符串，然后java用BASE64Decoder解码之后，就转换成了byte[]，可直接用上面方法解密。。。
