RSA数据加密解密（各种语言）
Posted RockyPeng3
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了RSA数据加密解密（各种语言）相关的知识，希望对你有一定的参考价值。
RSA数据加密解密文档
增强数据传输与本地日志的数据安全数据加密方式
使用rsa加密算法，客户端公钥加密，服务端私钥解密
(若单次传输数据量过大，之后可引入aes rsa只加密iv部分)
数据加密步骤
示例代码为python
1.使用zlib压缩目标数据
eg:
import zlib
m = zlib.compress(message)2.rsa 私钥为1024bit，需将被密数据做分割处理
eg:
def format_str(string, width):
format_list = [string[x:x+width] for x in range(0,len(string),width)]
return format_list
str_list = format_str(m,117)3.使用私钥加密,base64 encode数据并将\\n替换为约定字符串(#dmp#),最后将list按约定分隔符(#fp#)合并为字符串
eg:
data_list = []
for _str in str_list:
data_list.append(base64.encodestring(rsa.encrypt(_str, pubkey)).replace('\\n','#dmp#'))
encrypt_str = "#fp#".join(data_list)数据解密步骤
示例代码为python
1.将加密的最终结果按照约定分隔符(#xxd#)拆解为list,将约定字符串(#dmp#)还原为\\n,base64 decode数据,最后使用私钥解密
eg:
data_list = encrypt_str.split("#fp#")
for data in data_list:
_data_list.append(rsa.decrypt(base64.decodestring(data.replace('#dmp#','\\n')), privkey))
2.合并list，使用zlib解压数据
eg:
d = zlib.decompress("".join(_rsa_list))
print d
跨平台方案
使用预先生成各平台key的方式，规避跨平台问题
生成模长为1024bit的私钥文件private_key.pem
openssl genrsa -out private_key.pem 1024生成ios证书
生成证书请求文件rsaCertReq.csr
openssl req -new -key private_key.pem -out rsaCerReq.csr生成证书rsaCert.crt，并设置有效时间为10年
openssl x509 -req -days 36500 -in rsaCerReq.csr -signkey private_key.pem -out rsaCert.crt生成供iOS使用的公钥文件public_key.der
openssl x509 -outform der -in rsaCert.crt -out public_key.der生成供iOS使用的私钥文件private_key.p12
openssl pkcs12 -export -out private_key.p12 -inkey private_key.pem -in rsaCert.crt生成供Java使用的私钥pkcs8_private_key.pem
openssl pkcs8 -topk8 -in private_key.pem -out pkcs8_private_key.pem -nocrypt生成通用公钥rsa_public_key.pem
openssl rsa -in private_key.pem -out rsa_public_key.pem -pubout生成rsa公钥 供python等使用 py_public_key.pem
openssl rsa -in private_key.pem -RSAPublicKey_out -out py_public_key.pem IOS RSA代码
#import <Foundation/Foundation.h>
@interface RSAEncryptor : NSObject
/**
* 加密方法
*
* @param str 需要加密的字符串
* @param path '.der'格式的公钥文件路径
*/
+ (NSString *)encryptString:(NSString *)str publicKeyWithContentsOfFile:(NSString *)path;
/**
* 解密方法
*
* @param str 需要解密的字符串
* @param path '.p12'格式的私钥文件路径
* @param password 私钥文件密码
*/
+ (NSString *)decryptString:(NSString *)str privateKeyWithContentsOfFile:(NSString *)path password:(NSString *)password;
/**
* 加密方法
*
* @param str 需要加密的字符串
* @param pubKey 公钥字符串
*/
+ (NSString *)encryptString:(NSString *)str publicKey:(NSString *)pubKey;
/**
* 解密方法
*
* @param str 需要解密的字符串
* @param privKey 私钥字符串
*/
+ (NSString *)decryptString:(NSString *)str privateKey:(NSString *)privKey;
@end
#import "RSAEncryptor.h"
#import <Security/Security.h>
static NSString *base64_encode_data(NSData *data)
data = [data base64EncodedDataWithOptions:0];
NSString *ret = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
return ret;
static NSData *base64_decode(NSString *str)
NSData *data = [[NSData alloc] initWithBase64EncodedString:str options:NSDataBase64DecodingIgnoreUnknownCharacters];
return data;
@implementation RSAEncryptor
//加密
+ (NSString *)encryptString:(NSString *)str publicKeyWithContentsOfFile:(NSString *)path
if (!str || !path) return nil;
return [self encryptString:str publicKeyRef:[self getPublicKeyRefWithContentsOfFile:path]];
//获取公钥
+ (SecKeyRef)getPublicKeyRefWithContentsOfFile:(NSString *)filePath
NSData *certData = [NSData dataWithContentsOfFile:filePath];
if (!certData)
return nil;
SecCertificateRef cert = SecCertificateCreateWithData(NULL, (CFDataRef)certData);
SecKeyRef key = NULL;
SecTrustRef trust = NULL;
SecPolicyRef policy = NULL;
if (cert != NULL)
policy = SecPolicyCreateBasicX509();
if (policy)
if (SecTrustCreateWithCertificates((CFTypeRef)cert, policy, &trust) == noErr)
SecTrustResultType result;
if (SecTrustEvaluate(trust, &result) == noErr)
key = SecTrustCopyPublicKey(trust);
if (policy) CFRelease(policy);
if (trust) CFRelease(trust);
if (cert) CFRelease(cert);
return key;
+ (NSString *)encryptString:(NSString *)str publicKeyRef:(SecKeyRef)publicKeyRef
if(![str dataUsingEncoding:NSUTF8StringEncoding])
return nil;
if(!publicKeyRef)
return nil;
NSData *data = [self encryptData:[str dataUsingEncoding:NSUTF8StringEncoding] withKeyRef:publicKeyRef];
NSString *ret = base64_encode_data(data);
return ret;
#pragma mark - 使用'.12'私钥文件解密
//解密
+ (NSString *)decryptString:(NSString *)str privateKeyWithContentsOfFile:(NSString *)path password:(NSString *)password
if (!str || !path) return nil;
if (!password) password = @"";
return [self decryptString:str privateKeyRef:[self getPrivateKeyRefWithContentsOfFile:path password:password]];
//获取私钥
+ (SecKeyRef)getPrivateKeyRefWithContentsOfFile:(NSString *)filePath password:(NSString*)password
NSData *p12Data = [NSData dataWithContentsOfFile:filePath];
if (!p12Data)
return nil;
SecKeyRef privateKeyRef = NULL;
NSMutableDictionary * options = [[NSMutableDictionary alloc] init];
[options setObject: password forKey:(__bridge id)kSecImportExportPassphrase];
CFArrayRef items = CFArrayCreate(NULL, 0, 0, NULL);
OSStatus securityError = SecPKCS12Import((__bridge CFDataRef) p12Data, (__bridge CFDictionaryRef)options, &items);
if (securityError == noErr && CFArrayGetCount(items) > 0)
CFDictionaryRef identityDict = CFArrayGetValueAtIndex(items, 0);
SecIdentityRef identityApp = (SecIdentityRef)CFDictionaryGetValue(identityDict, kSecImportItemIdentity);
securityError = SecIdentityCopyPrivateKey(identityApp, &privateKeyRef);
if (securityError != noErr)
privateKeyRef = NULL;
CFRelease(items);
return privateKeyRef;
+ (NSString *)decryptString:(NSString *)str privateKeyRef:(SecKeyRef)privKeyRef
NSData *data = [[NSData alloc] initWithBase64EncodedString:str options:NSDataBase64DecodingIgnoreUnknownCharacters];
if (!privKeyRef)
return nil;
data = [self decryptData:data withKeyRef:privKeyRef];
NSString *ret = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
return ret;
#pragma mark - 使用公钥字符串加密
/* START: Encryption with RSA public key */
//使用公钥字符串加密
+ (NSString *)encryptString:(NSString *)str publicKey:(NSString *)pubKey
NSData *data = [self encryptData:[str dataUsingEncoding:NSUTF8StringEncoding] publicKey:pubKey];
NSString *ret = base64_encode_data(data);
return ret;
+ (NSData *)encryptData:(NSData *)data publicKey:(NSString *)pubKey
if(!data || !pubKey)
return nil;
SecKeyRef keyRef = [self addPublicKey:pubKey];
if(!keyRef)
return nil;
return [self encryptData:data withKeyRef:keyRef];
+ (SecKeyRef)addPublicKey:(NSString *)key
NSRange spos = [key rangeOfString:@"-----BEGIN PUBLIC KEY-----"];
NSRange epos = [key rangeOfString:@"-----END PUBLIC KEY-----"];
if(spos.location != NSNotFound && epos.location != NSNotFound)
NSUInteger s = spos.location + spos.length;
NSUInteger e = epos.location;
NSRange range = NSMakeRange(s, e-s);
key = [key substringWithRange:range];
key = [key stringByReplacingOccurrencesOfString:@"\\r" withString:@""];
key = [key stringByReplacingOccurrencesOfString:@"\\n" withString:@""];
key = [key stringByReplacingOccurrencesOfString:@"\\t" withString:@""];
key = [key stringByReplacingOccurrencesOfString:@" " withString:@""];
// This will be base64 encoded, decode it.
NSData *data = base64_decode(key);
data = [self stripPublicKeyHeader:data];
if(!data)
return nil;
//a tag to read/write keychain storage
NSString *tag = @"RSAUtil_PubKey";
NSData *d_tag = [NSData dataWithBytes:[tag UTF8String] length:[tag length]];
// Delete any old lingering key with the same tag
NSMutableDictionary *publicKey = [[NSMutableDictionary alloc] init];
[publicKey setObject:(__bridge id) kSecClassKey forKey:(__bridge id)kSecClass];
[publicKey setObject:(__bridge id) kSecAttrKeyTypeRSA forKey:(__bridge id)kSecAttrKeyType];
[publicKey setObject:d_tag forKey:(__bridge id)kSecAttrApplicationTag];
SecItemDelete((__bridge CFDictionaryRef)publicKey);
// Add persistent version of the key to system keychain
[publicKey setObject:data forKey:(__bridge id)kSecValueData];
[publicKey setObject:(__bridge id) kSecAttrKeyClassPublic forKey:(__bridge id)
kSecAttrKeyClass];
[publicKey setObject:[NSNumber numberWithBool:YES] forKey:(__bridge id)
kSecReturnPersistentRef];
CFTypeRef persistKey = nil;
OSStatus status = SecItemAdd((__bridge CFDictionaryRef)publicKey, &persistKey);
if (persistKey != nil)
CFRelease(persistKey);
if ((status != noErr) && (status != errSecDuplicateItem))
return nil;
[publicKey removeObjectForKey:(__bridge id)kSecValueData];
[publicKey removeObjectForKey:(__bridge id)kSecReturnPersistentRef];
[publicKey setObject:[NSNumber numberWithBool:YES] forKey:(__bridge id)kSecReturnRef];
[publicKey setObject:(__bridge id) kSecAttrKeyTypeRSA forKey:(__bridge id)kSecAttrKeyType];
// Now fetch the SecKeyRef version of the key
SecKeyRef keyRef = nil;
status = SecItemCopyMatching((__bridge CFDictionaryRef)publicKey, (CFTypeRef *)&keyRef);
if(status != noErr)
return nil;
return keyRef;
+ (NSData *)stripPublicKeyHeader:(NSData *)d_key
// Skip ASN.1 public key header
if (d_key == nil) return(nil);
unsigned long len = [d_key length];
if (!len) return(nil);
unsigned char *c_key = (unsigned char *)[d_key bytes];
unsigned int idx = 0;
if (c_key[idx++] != 0x30) return(nil);
if (c_key[idx] > 0x80) idx += c_key[idx] - 0x80 + 1;
else idx++;
// PKCS #1 rsaEncryption szOID_RSA_RSA
static unsigned char seqiod[] =
0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01,
0x01, 0x05, 0x00 ;
if (memcmp(&c_key[idx], seqiod, 15)) return(nil);
idx += 15;
if (c_key[idx++] != 0x03) return(nil);
if (c_key[idx] > 0x80) idx += c_key[idx] - 0x80 + 1;
else idx++;
if (c_key[idx++] != '\\0') return(nil);
// Now make a new NSData from this buffer
return ([NSData dataWithBytes:&c_key[idx] length:len - idx]);
+ (NSData *)encryptData:(NSData *)data withKeyRef:(SecKeyRef) keyRef
const uint8_t *srcbuf = (const uint8_t *)[data bytes];
size_t srclen = (size_t)data.length;
size_t block_size = SecKeyGetBlockSize(keyRef) * sizeof(uint8_t);
void *outbuf = malloc(block_size);
size_t src_block_size = block_size - 11;
NSMutableData *ret = [[NSMutableData alloc] init];
for(int idx=0; idx<srclen; idx+=src_block_size)
//NSLog(@"%d/%d block_size: %d", idx, (int)srclen, (int)block_size);
size_t data_len = srclen - idx;
if(data_len > src_block_size)
data_len = src_block_size;
size_t outlen = block_size;
OSStatus status = noErr;
status = SecKeyEncrypt(keyRef,
kSecPaddingPKCS1,
srcbuf + idx,
data_len,
outbuf,
&outlen
);
if (status != 0)
NSLog(@"SecKeyEncrypt fail. Error Code: %d", status);
ret = nil;
break;
else
[ret appendBytes:outbuf length:outlen];
free(outbuf);
CFRelease(keyRef);
return ret;
/* END: Encryption with RSA public key */
#pragma mark - 使用私钥字符串解密
/* START: Decryption with RSA private key */
//使用私钥字符串解密
+ (NSString *)decryptString:(NSString *)str privateKey:(NSString *)privKey
if (!str) return nil;
NSData *data = [[NSData alloc] initWithBase64EncodedString:str options:NSDataBase64DecodingIgnoreUnknownCharacters];
data = [self decryptData:data privateKey:privKey];
NSString *ret = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
return ret;
+ (NSData *)decryptData:(NSData *)data privateKey:(NSString *)privKey
if(!data || !privKey)
return nil;
SecKeyRef keyRef = [self addPrivateKey:privKey];
if(!keyRef)
return nil;
return [self decryptData:data withKeyRef:keyRef];
+ (SecKeyRef)addPrivateKey:(NSString *)key
NSRange spos = [key rangeOfString:@"-----BEGIN RSA PRIVATE KEY-----"];
NSRange epos = [key rangeOfString:@"-----END RSA PRIVATE KEY-----"];
if(spos.location != NSNotFound && epos.location != NSNotFound)
NSUInteger s = spos.location + spos.length;
NSUInteger e = epos.location;
NSRange range = NSMakeRange(s, e-s);
key = [key substringWithRange:range];
key = [key stringByReplacingOccurrencesOfString:@"\\r" withString:@""];
key = [key stringByReplacingOccurrencesOfString:@"\\n" withString:@""];
key = [key stringByReplacingOccurrencesOfString:@"\\t" withString:@""];
key = [key stringByReplacingOccurrencesOfString:@" " withString:@""];
// This will be base64 encoded, decode it.
NSData *data = base64_decode(key);
data = [self stripPrivateKeyHeader:data];
if(!data)
return nil;
//a tag to read/write keychain storage
NSString *tag = @"RSAUtil_PrivKey";
NSData *d_tag = [NSData dataWithBytes:[tag UTF8String] length:[tag length]];
// Delete any old lingering key with the same tag
NSMutableDictionary *privateKey = [[NSMutableDictionary alloc] init];
[privateKey setObject:(__bridge id) kSecClassKey forKey:(__bridge id)kSecClass];
[privateKey setObject:(__bridge id) kSecAttrKeyTypeRSA forKey:(__bridge id)kSecAttrKeyType];
[privateKey setObject:d_tag forKey:(__bridge id)kSecAttrApplicationTag];
SecItemDelete((__bridge CFDictionaryRef)privateKey);
// Add persistent version of the key to system keychain
[privateKey setObject:data forKey:(__bridge id)kSecValueData];
[privateKey setObject:(__bridge id) kSecAttrKeyClassPrivate forKey:(__bridge id)
kSecAttrKeyClass];
[privateKey setObject:[NSNumber numberWithBool:YES] forKey:(__bridge id)
kSecReturnPersistentRef];
CFTypeRef persistKey = nil;
OSStatus status = SecItemAdd((__bridge CFDictionaryRef)privateKey, &persistKey);
if (persistKey != nil)
CFRelease(persistKey);
if ((status != noErr) && (status != errSecDuplicateItem))
return nil;
[privateKey removeObjectForKey:(__bridge id)kSecValueData];
[privateKey removeObjectForKey:(__bridge id)kSecReturnPersistentRef];
[privateKey setObject:[NSNumber numberWithBool:YES] forKey:(__bridge id)kSecReturnRef];
[privateKey setObject:(__bridge id) kSecAttrKeyTypeRSA forKey:(__bridge id)kSecAttrKeyType];
// Now fetch the SecKeyRef version of the key
SecKeyRef keyRef = nil;
status = SecItemCopyMatching((__bridge CFDictionaryRef)privateKey, (CFTypeRef *)&keyRef);
if(status != noErr)
return nil;
return keyRef;
+ (NSData *)stripPrivateKeyHeader:(NSData *)d_key
// Skip ASN.1 private key header
if (d_key == nil) return(nil);
unsigned long len = [d_key length];
if (!len) return(nil);
unsigned char *c_key = (unsigned char *)[d_key bytes];
unsigned int idx = 22; //magic byte at offset 22
if (0x04 != c_key[idx++]) return nil;
//calculate length of the key
unsigned int c_len = c_key[idx++];
int det = c_len & 0x80;
if (!det)
c_len = c_len & 0x7f;
else
int byteCount = c_len & 0x7f;
if (byteCount + idx > len)
//rsa length field longer than buffer
return nil;
unsigned int accum = 0;
unsigned char *ptr = &c_key[idx];
idx += byteCount;
while (byteCount)
accum = (accum << 8) + *ptr;
ptr++;
byteCount--;
c_len = accum;
// Now make a new NSData from this buffer
return [d_key subdataWithRange:NSMakeRange(idx, c_len)];
+ (NSData *)decryptData:(NSData *)data withKeyRef:(SecKeyRef) keyRef
const uint8_t *srcbuf = (const uint8_t *)[data bytes];
size_t srclen = (size_t)data.length;
size_t block_size = SecKeyGetBlockSize(keyRef) * sizeof(uint8_t);
UInt8 *outbuf = malloc(block_size);
size_t src_block_size = block_size;
NSMutableData *ret = [[NSMutableData alloc] init];
for(int idx=0; idx<srclen; idx+=src_block_size)
//NSLog(@"%d/%d block_size: %d", idx, (int)srclen, (int)block_size);
size_t data_len = srclen - idx;
if(data_len > src_block_size)
data_len = src_block_size;
size_t outlen = block_size;
OSStatus status = noErr;
status = SecKeyDecrypt(keyRef,
kSecPaddingNone,
srcbuf + idx,
data_len,
outbuf,
&outlen
);
if (status != 0)
NSLog(@"SecKeyEncrypt fail. Error Code: %d", status);
ret = nil;
break;
else
//the actual decrypted data is in the middle, locate it!
int idxFirstZero = -1;
int idxNextZero = (int)outlen;
for ( int i = 0; i < outlen; i++ )
if ( outbuf[i] == 0 )
if ( idxFirstZero < 0 )
idxFirstZero = i;
else
idxNextZero = i;
break;
[ret appendBytes:&outbuf[idxFirstZero+1] length:idxNextZero-idxFirstZero-1];
free(outbuf);
CFRelease(keyRef);
return ret;
Python RSA代码
import rsa
import base64
# 导入key
with open('py_public_key.pem') as publickfile:
p = publickfile.read()
pubkey = rsa.PublicKey.load_pkcs1(p)
with open('private_key.pem') as privatefile:
p = privatefile.read()
privkey = rsa.PrivateKey.load_pkcs1(p)
bob_pub = pubkey
bob_priv = privkey
message = """"id": "49187f817657ecd9d472562b16c0ec7c","ip": "180.168.161.194","user-agent": "iOS8.1 iPhone 5s","ts": "1478879016008","channel": "iOS""""
# 数据分割函数
def format_str(string, width):
format_list = [string[x:x+width] for x in range(0,len(string),width)]
return format_list
# 按大小分割数据
str_list = format_str(message,117)
# 加密
data_list = []
for _str in str_list:
data_list.append(base64.encodestring(rsa.encrypt(_str, bob_pub)))
# 解密
_data_list = []
for data in data_list.append:
_data_list.append(rsa.decrypt(base64.decodestring(data), bob_priv))
_message = "".join(_data_list.append)
print _messageJAVA RSA代码
RSA数据加密解密文档
增强数据传输与本地日志的数据安全数据加密方式
使用rsa加密算法，客户端公钥加密，服务端私钥解密
(若单次传输数据量过大，之后可引入aes rsa只加密iv部分)
数据加密步骤
示例代码为python
1.使用zlib压缩目标数据
eg:
import zlib
m = zlib.compress(message)2.rsa 私钥为1024bit，需将被密数据做分割处理
eg:
def format_str(string, width):
format_list = [string[x:x+width] for x in range(0,len(string),width)]
return format_list
str_list = format_str(m,117)3.使用私钥加密,base64 encode数据并将\\n替换为约定字符串(#dmp#),最后将list按约定分隔符(#fp#)合并为字符串
eg:
data_list = []
for _str in str_list:
data_list.append(base64.encodestring(rsa.encrypt(_str, pubkey)).replace('\\n','#dmp#'))
encrypt_str = "#fp#".join(data_list)数据解密步骤
示例代码为python
1.将加密的最终结果按照约定分隔符(#xxd#)拆解为list,将约定字符串(#dmp#)还原为\\n,base64 decode数据,最后使用私钥解密
eg:
data_list = encrypt_str.split("#fp#")
for data in data_list:
_data_list.append(rsa.decrypt(base64.decodestring(data.replace('#dmp#','\\n')), privkey))
2.合并list，使用zlib解压数据
eg:
d = zlib.decompress("".join(_rsa_list))
print d
跨平台方案
使用预先生成各平台key的方式，规避跨平台问题
生成模长为1024bit的私钥文件private_key.pem
openssl genrsa -out private_key.pem 1024生成IOS证书
生成证书请求文件rsaCertReq.csr
openssl req -new -key private_key.pem -out rsaCerReq.csr生成证书rsaCert.crt，并设置有效时间为10年
openssl x509 -req -days 36500 -in rsaCerReq.csr -signkey private_key.pem -out rsaCert.crt生成供iOS使用的公钥文件public_key.der
openssl x509 -outform der -in rsaCert.crt -out public_key.der生成供iOS使用的私钥文件private_key.p12
openssl pkcs12 -export -out private_key.p12 -inkey private_key.pem -in rsaCert.crt生成供Java使用的私钥pkcs8_private_key.pem
openssl pkcs8 -topk8 -in private_key.pem -out pkcs8_private_key.pem -nocrypt生成通用公钥rsa_public_key.pem
openssl rsa -in private_key.pem -out rsa_public_key.pem -pubout生成rsa公钥 供python等使用 py_public_key.pem
openssl rsa -in private_key.pem -RSAPublicKey_out -out py_public_key.pem IOS RSA代码
#import <Foundation/Foundation.h>
@interface RSAEncryptor : NSObject
/**
* 加密方法
*
* @param str 需要加密的字符串
* @param path '.der'格式的公钥文件路径
*/
+ (NSString *)encryptString:(NSString *)str publicKeyWithContentsOfFile:(NSString *)path;
/**
* 解密方法
*
* @param str 需要解密的字符串
* @param path '.p12'格式的私钥文件路径
* @param password 私钥文件密码
*/
+ (NSString *)decryptString:(NSString *)str privateKeyWithContentsOfFile:(NSString *)path password:(NSString *)password;
/**
* 加密方法
*
* @param str 需要加密的字符串
* @param pubKey 公钥字符串
*/
+ (NSString *)encryptString:(NSString *)str publicKey:(NSString *)pubKey;
/**
* 解密方法
*
* @param str 需要解密的字符串
* @param privKey 私钥字符串
*/
+ (NSString *)decryptString:(NSString *)str privateKey:(NSString *)privKey;
@end
#import "RSAEncryptor.h"
#import <Security/Security.h>
static NSString *base64_encode_data(NSData *data)
data = [data base64EncodedDataWithOptions:0];
NSString *ret = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
return ret;
static NSData *base64_decode(NSString *str)
NSData *data = [[NSData alloc] initWithBase64EncodedString:str options:NSDataBase64DecodingIgnoreUnknownCharacters];
return data;
@implementation RSAEncryptor
//加密
+ (NSString *)encryptString:(NSString *)str publicKeyWithContentsOfFile:(NSString *)path
if (!str || !path) return nil;
return [self encryptString:str publicKeyRef:[self getPublicKeyRefWithContentsOfFile:path]];
//获取公钥
+ (SecKeyRef)getPublicKeyRefWithContentsOfFile:(NSString *)filePath
NSData *certData = [NSData dataWithContentsOfFile:filePath];
if (!certData)
return nil;
SecCertificateRef cert = SecCertificateCreateWithData(NULL, (CFDataRef)certData);
SecKeyRef key = NULL;
SecTrustRef trust = NULL;
SecPolicyRef policy = NULL;
if (cert != NULL)
policy = SecPolicyCreateBasicX509();
if (policy)
if (SecTrustCreateWithCertificates((CFTypeRef)cert, policy, &trust) == noErr)
SecTrustResultType result;
if (SecTrustEvaluate(trust, &result) == noErr)
key = SecTrustCopyPublicKey(trust);
if (policy) CFRelease(policy);
if (trust) CFRelease(trust);
if (cert) CFRelease(cert);
return key;
+ (NSString *)encryptString:(NSString *)str publicKeyRef:(SecKeyRef)publicKeyRef
if(![str dataUsingEncoding:NSUTF8StringEncoding])
return nil;
if(!publicKeyRef)
return nil;
NSData *data = [self encryptData:[str dataUsingEncoding:NSUTF8StringEncoding] withKeyRef:publicKeyRef];
NSString *ret = base64_encode_data(data);
return ret;
#pragma mark - 使用'.12'私钥文件解密
//解密
+ (NSString *)decryptString:(NSString *)str privateKeyWithContentsOfFile:(NSString *)path password:(NSString *)password
if (!str || !path) return nil;
if (!password) password = @"";
return [self decryptString:str privateKeyRef:[self getPrivateKeyRefWithContentsOfFile:path password:password]];
//获取私钥
+ (SecKeyRef)getPrivateKeyRefWithContentsOfFile:(NSString *)filePath password:(NSString*)password
NSData *p12Data = [NSData dataWithContentsOfFile:filePath];
if (!p12Data)
return nil;
SecKeyRef privateKeyRef = NULL;
NSMutableDictionary * options = [[NSMutableDictionary alloc] init];
[options setObject: password forKey:(__bridge id)kSecImportExportPassphrase];
CFArrayRef items = CFArrayCreate(NULL, 0, 0, NULL);
OSStatus securityError = SecPKCS12Import((__bridge CFDataRef) p12Data, (__bridge CFDictionaryRef)options, &items);
if (securityError == noErr && CFArrayGetCount(items) > 0)
CFDictionaryRef identityDict = CFArrayGetValueAtIndex(items, 0);
SecIdentityRef identityApp = (SecIdentityRef)CFDictionaryGetValue(identityDict, kSecImportItemIdentity);
securityError = SecIdentityCopyPrivateKey(identityApp, &privateKeyRef);
if (securityError != noErr)
privateKeyRef = NULL;
CFRelease(items);
return privateKeyRef;
+ (NSString *)decryptString:(NSString *)str privateKeyRef:(SecKeyRef)privKeyRef
NSData *data = [[NSData alloc] initWithBase64EncodedString:str options:NSDataBase64DecodingIgnoreUnknownCharacters];
if (!privKeyRef)
return nil;
data = [self decryptData:data withKeyRef:privKeyRef];
NSString *ret = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
return ret;
#pragma mark - 使用公钥字符串加密
/* START: Encryption with RSA public key */
//使用公钥字符串加密
+ (NSString *)encryptString:(NSString *)str publicKey:(NSString *)pubKey
NSData *data = [self encryptData:[str dataUsingEncoding:NSUTF8StringEncoding] publicKey:pubKey];
NSString *ret = base64_encode_data(data);
return ret;
+ (NSData *)encryptData:(NSData *)data publicKey:(NSString *)pubKey
if(!data || !pubKey)
return nil;
SecKeyRef keyRef = [self addPublicKey:pubKey];
if(!keyRef)
return nil;
return [self encryptData:data withKeyRef:keyRef];
+ (SecKeyRef)addPublicKey:(NSString *)key
NSRange spos = [key rangeOfString:@"-----BEGIN PUBLIC KEY-----"];
NSRange epos = [key rangeOfString:@"-----END PUBLIC KEY-----"];
if(spos.location != NSNotFound && epos.location != NSNotFound)
NSUInteger s = spos.location + spos.length;
NSUInteger e = epos.location;
NSRange range = NSMakeRange(s, e-s);
key = [key substringWithRange:range];
key = [key stringByReplacingOccurrencesOfString:@"\\r" withString:@""];
key = [key stringByReplacingOccurrencesOfString:@"\\n" withString:@""];
key = [key stringByReplacingOccurrencesOfString:@"\\t" withString:@""];
key = [key stringByReplacingOccurrencesOfString:@" " withString:@""];
// This will be base64 encoded, decode it.
NSData *data = base64_decode(key);
data = [self stripPublicKeyHeader:data];
if(!data)
return nil;
//a tag to read/write keychain storage
NSString *tag = @"RSAUtil_PubKey";
NSData *d_tag = [NSData dataWithBytes:[tag UTF8String] length:[tag length]];
// Delete any old lingering key with the same tag
NSMutableDictionary *publicKey = [[NSMutableDictionary alloc] init];
[publicKey setObject:(__bridge id) kSecClassKey forKey:(__bridge id)kSecClass];
[publicKey setObject:(__bridge id) kSecAttrKeyTypeRSA forKey:(__bridge id)kSecAttrKeyType];
[publicKey setObject:d_tag forKey:(__bridge id)kSecAttrApplicationTag];
SecItemDelete((__bridge CFDictionaryRef)publicKey);
// Add persistent version of the key to system keychain
[publicKey setObject:data forKey:(__bridge id)kSecValueData];
[publicKey setObject:(__bridge id) kSecAttrKeyClassPublic forKey:(__bridge id)
kSecAttrKeyClass];
[publicKey setObject:[NSNumber numberWithBool:YES] forKey:(__bridge id)
kSecReturnPersistentRef];
CFTypeRef persistKey = nil;
OSStatus status = SecItemAdd((__bridge CFDictionaryRef)publicKey, &persistKey);
if (persistKey != nil)
CFRelease(persistKey);
if ((status != noErr) && (status != errSecDuplicateItem))
return nil;
[publicKey removeObjectForKey:(__bridge id)kSecValueData];
[publicKey removeObjectForKey:(__bridge id)kSecReturnPersistentRef];
[publicKey setObject:[NSNumber numberWithBool:YES] forKey:(__bridge id)kSecReturnRef];
[publicKey setObject:(__bridge id) kSecAttrKeyTypeRSA forKey:(__bridge id)kSecAttrKeyType];
// Now fetch the SecKeyRef version of the key
SecKeyRef keyRef = nil;
status = SecItemCopyMatching((__bridge CFDictionaryRef)publicKey, (CFTypeRef *)&keyRef);
if(status != noErr)
return nil;
return keyRef;
+ (NSData *)stripPublicKeyHeader:(NSData *)d_key
// Skip ASN.1 public key header
if (d_key == nil) return(nil);
unsigned long len = [d_key length];
if (!len) return(nil);
unsigned char *c_key = (unsigned char *)[d_key bytes];
unsigned int idx = 0;
if (c_key[idx++] != 0x30) return(nil);
if (c_key[idx] > 0x80) idx += c_key[idx] - 0x80 + 1;
else idx++;
// PKCS #1 rsaEncryption szOID_RSA_RSA
static unsigned char seqiod[] =
0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01,
0x01, 0x05, 0x00 ;
if (memcmp(&c_key[idx], seqiod, 15)) return(nil);
idx += 15;
if (c_key[idx++] != 0x03) return(nil);
if (c_key[idx] > 0x80) idx += c_key[idx] - 0x80 + 1;
else idx++;
if (c_key[idx++] != '\\0') return(nil);
// Now make a new NSData from this buffer
return ([NSData dataWithBytes:&c_key[idx] length:len - idx]);
+ (NSData *)encryptData:(NSData *)data withKeyRef:(SecKeyRef) keyRef
const uint8_t *srcbuf = (const uint8_t *)[data bytes];
size_t srclen = (size_t)data.length;
size_t block_size = SecKeyGetBlockSize(keyRef) * sizeof(uint8_t);
void *outbuf = malloc(block_size);
size_t src_block_size = block_size - 11;
NSMutableData *ret = [[NSMutableData alloc] init];
for(int idx=0; idx<srclen; idx+=src_block_size)
//NSLog(@"%d/%d block_size: %d", idx, (int)srclen, (int)block_size);
size_t data_len = srclen - idx;
if(data_len > src_block_size)
data_len = src_block_size;
size_t outlen = block_size;
OSStatus status = noErr;
status = SecKeyEncrypt(keyRef,
kSecPaddingPKCS1,
srcbuf + idx,
data_len,
outbuf,
&outlen
);
if (status != 0)
NSLog(@"SecKeyEncrypt fail. Error Code: %d", status);
ret = nil;
break;
else
[ret appendBytes:outbuf length:outlen];
free(outbuf);
CFRelease(keyRef);
return ret;
/* END: Encryption with RSA public key */
#pragma mark - 使用私钥字符串解密
/* START: Decryption with RSA private key */
//使用私钥字符串解密
+ (NSString *)decryptString:(NSString *)str privateKey:(NSString *)privKey
if (!str) return nil;
NSData *data = [[NSData alloc] initWithBase64EncodedString:str options:NSDataBase64DecodingIgnoreUnknownCharacters];
data = [self decryptData:data privateKey:privKey];
NSString *ret = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
return ret;
+ (NSData *)decryptData:(NSData *)data privateKey:(NSString *)privKey
if(!data || !privKey)
return nil;
SecKeyRef keyRef = [self addPrivateKey:privKey];
if(!keyRef)
return nil;
return [self decryptData:data withKeyRef:keyRef];
+ (SecKeyRef)addPrivateKey:(NSString *)key
NSRange spos = [key rangeOfString:@"-----BEGIN RSA PRIVATE KEY-----"];
NSRange epos = [key rangeOfString:@"-----END RSA PRIVATE KEY-----"];
if(spos.location != NSNotFound && epos.location != NSNotFound)
NSUInteger s = spos.location + spos.length;
NSUInteger e = epos.location;
NSRange range = NSMakeRange(s, e-s);
key = [key substringWithRange:range];
key = [key stringByReplacingOccurrencesOfString:@"\\r" withString:@""];
key = [key stringByReplacingOccurrencesOfString:@"\\n" withString:@""];
key = [key stringByReplacingOccurrencesOfString:@"\\t" withString:@""];
key = [key stringByReplacingOccurrencesOfString:@" " withString:@""];
// This will be base64 encoded, decode it.
NSData *data = base64_decode(key);
data = [self stripPrivateKeyHeader:data];
if(!data)
return nil;
//a tag to read/write keychain storage
NSString *tag = @"RSAUtil_PrivKey";
NSData *d_tag = [NSData dataWithBytes:[tag UTF8String] length:[tag length]];
// Delete any old lingering key with the same tag
NSMutableDictionary *privateKey = [[NSMutableDictionary alloc] init];
[privateKey setObject:(__bridge id) kSecClassKey forKey:(__bridge id)kSecClass];
[privateKey setObject:(__bridge id) kSecAttrKeyTypeRSA forKey:(__bridge id)kSecAttrKeyType];
[privateKey setObject:d_tag forKey:(__bridge id)kSecAttrApplicationTag];
SecItemDelete((__bridge CFDictionaryRef)privateKey);
// Add persistent version of the key to system keychain
[privateKey setObject:data forKey:(__bridge id)kSecValueData];
[privateKey setObject:(__bridge id) kSecAttrKeyClassPrivate forKey:(__bridge id)
kSecAttrKeyClass];
[privateKey setObject:[NSNumber numberWithBool:YES] forKey:(__bridge id)
kSecReturnPersistentRef];
CFTypeRef persistKey = nil;
OSStatus status = SecItemAdd((__bridge CFDictionaryRef)privateKey, &persistKey);
if (persistKey != nil)
CFRelease(persistKey);
if ((status != noErr) && (status != errSecDuplicateItem))
return nil;
[privateKey removeObjectForKey:(__bridge id)kSecValueData];
[privateKey removeObjectForKey:(__bridge id)kSecReturnPersistentRef];
[privateKey setObject:[NSNumber numberWithBool:YES] forKey:(__bridge id)kSecReturnRef];
[privateKey setObject:(__bridge id) kSecAttrKeyTypeRSA forKey:(__bridge id)kSecAttrKeyType];
// Now fetch the SecKeyRef version of the key
SecKeyRef keyRef = nil;
status = SecItemCopyMatching((__bridge CFDictionaryRef)privateKey, (CFTypeRef *)&keyRef);
if(status != noErr)
return nil;
return keyRef;
+ (NSData *)stripPrivateKeyHeader:(NSData *)d_key
// Skip ASN.1 private key header
if (d_key == nil) return(nil);
unsigned long len = [d_key length];
if (!len) return(nil);
unsigned char *c_key = (unsigned char *)[d_key bytes];
unsigned int idx = 22; //magic byte at offset 22
if (0x04 != c_key[idx++]) return nil;
//calculate length of the key
unsigned int c_len = c_key[idx++];
int det = c_len & 0x80;
if (!det)
c_len = c_len & 0x7f;
else
int byteCount = c_len & 0x7f;
if (byteCount + idx > len)
//rsa length field longer than buffer
return nil;
unsigned int accum = 0;
unsigned char *ptr = &c_key[idx];
idx += byteCount;
while (byteCount)
accum = (accum << 8) + *ptr;
ptr++;
byteCount--;
c_len = accum;
// Now make a new NSData from this buffer
return [d_key subdataWithRange:NSMakeRange(idx, c_len)];
+ (NSData *)decryptData:(NSData *)data withKeyRef:(SecKeyRef) keyRef
const uint8_t *srcbuf = (const uint8_t *)[data bytes];
size_t srclen = (size_t)data.length;
size_t block_size = SecKeyGetBlockSize(keyRef) * sizeof(uint8_t);
UInt8 *outbuf = malloc(block_size);
size_t src_block_size = block_size;
NSMutableData *ret = [[NSMutableData alloc] init];
for(int idx=0; idx<srclen; idx+=src_block_size)
//NSLog(@"%d/%d block_size: %d", idx, (int)srclen, (int)block_size);
size_t data_len = srclen - idx;
if(data_len > src_block_size)
data_len = src_block_size;
size_t outlen = block_size;
OSStatus status = noErr;
status = SecKeyDecrypt(keyRef,
kSecPaddingNone,
srcbuf + idx,
data_len,
outbuf,
&outlen
);
if (status != 0)
NSLog(@"SecKeyEncrypt fail. Error Code: %d", status);
ret = nil;
break;
else
//the actual decrypted data is in the middle, locate it!
int idxFirstZero = -1;
int idxNextZero = (int)outlen;
for ( int i = 0; i < outlen; i++ )
if ( outbuf[i] == 0 )
if ( idxFirstZero < 0 )
idxFirstZero = i;
else
idxNextZero = i;
break;
[ret appendBytes:&outbuf[idxFirstZero+1] length:idxNextZero-idxFirstZero-1];
free(outbuf);
CFRelease(keyRef);
return ret;
Python RSA代码
import rsa
import base64
# 导入key
with open('py_public_key.pem') as publickfile:
p = publickfile.read()
pubkey = rsa.PublicKey.load_pkcs1(p)
with open('private_key.pem') as privatefile:
p = privatefile.read()
privkey = rsa.PrivateKey.load_pkcs1(p)
bob_pub = pubkey
bob_priv = privkey
message = """"id": "49187f817657ecd9d472562b16c0ec7c","ip": "180.168.161.194","user-agent": "iOS8.1 iPhone 5s","ts": "1478879016008","channel": "iOS""""
# 数据分割函数
def format_str(string, width):
format_list = [string[x:x+width] for x in range(0,len(string),width)]
return format_list
# 按大小分割数据
str_list = format_str(message,117)
# 加密
data_list = []
for _str in str_list:
data_list.append(base64.encodestring(rsa.encrypt(_str, bob_pub)))
# 解密
_data_list = []
for data in data_list.append:
_data_list.append(rsa.decrypt(base64.decodestring(data), bob_priv))
_message = "".join(_data_list.append)
print _messageJAVA RSA代码
package rsa;
import org.bouncycastle.asn1.ASN1Sequence;
import org.bouncycastle.asn1.pkcs.RSAPrivateKeyStructure;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import java.io.*;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.RSAPrivateKeySpec;
import java.security.spec.X509EncodedKeySpec;
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("公钥数据为空");
/**
* 从文件中加载私钥
*
* @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
//pkcs8
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 (Exception ex)
//pkcs1
try
RSAPrivateKeyStructure asn1PrivKey = new RSAPrivateKeyStructure((ASN1Sequence) ASN1Sequence.fromByteArray(new BASE64Decoder().decodeBuffer(privateKeyStr)));
RSAPrivateKeySpec rsaPrivKeySpec = new RSAPrivateKeySpec(asn1PrivKey.getModulus(), asn1PrivKey.getPrivateExponent());
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
this.privateKey = (RSAPrivateKey) keyFactory.generatePrivate(rsaPrivKeySpec);
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 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 = Cipher.getInstance("RSA/ECB/PKCS1Padding", 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 = Cipher.getInstance("RSA/ECB/PKCS1Padding", 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 < data.length; i++)
//取出字节的高四位 作为索引得到相应的十六进制标识符 注意无符号右移
stringBuilder.append(HEX_CHAR[(data[i] & 0xf0) >>> 4]);
//取出字节的低四位 作为索引得到相应的十六进制标识符
stringBuilder.append(HEX_CHAR[(data[i] & 0x0f)]);
if (i < data.length - 1)
stringBuilder.append(' ');
return stringBuilder.toString();
public static void main(String[] args)
RSAEncrypt rsaEncrypt = new RSAEncrypt();
//rsaEncrypt.genKeyPair();
//加载公钥
try
rsaEncrypt.loadPublicKey(new FileInputStream(new File("rsa/rsa_public_key.pem")));
System.out.println("加载公钥成功");
catch (Exception e)
System.err.println(e.getMessage());
System.err.println("加载公钥失败");
System.exit(0);
//加载私钥
try
// rsaEncrypt.loadPrivateKey(new FileInputStream(new File("rsa/private_key.pem")));
rsaEncrypt.loadPrivateKey(new FileInputStream("rsa/pkcs8_private_key.pem"));
System.out.println("加载私钥成功");
catch (Exception e)
e.printStackTrace();
System.err.println("加载私钥失败");
System.exit(0);
//测试字符串
String encryptStr = "aabbcc123我的";
try
//加密
byte[] cipher = rsaEncrypt.encrypt(rsaEncrypt.getPublicKey(), encryptStr.getBytes());
System.out.println(new BASE64Encoder().encode(cipher));
cipher = (new BASE64Decoder().decodeBuffer("OiQjf0zW+1eMRZ4L5MK32dcNuK6Xjb1Lm5QMgFVliz3Ak5pLiPY0hCwwLLaoGQ68p/1N8vMqdcl3xPwoZ7W8jSCYj3qadRyF7r4TGsOokAaCush+IPcuoEAkAClz5KcjWixg8feLC4GdXZEmrp7pXHsqr3MjYxg1YW1vPXuXxIg="));
//解密
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());
以上是关于RSA数据加密解密（各种语言）的主要内容，如果未能解决你的问题，请参考以下文章