iOS 에서 RSA 암호 화 사용

iOS 에서 RSA 암호 화 복호화 를 사용 하려 면.der 와.p12 접미사 형식의 파일 을 사용 해 야 합 니 다.그 중에서.der 형식의 파일 은 암호 화 에 사용 되 는 공개 키(Public key)를 저장 합 니 다.p12 형식의 파일 은 암호 화 에 사용 되 는 비밀 키(Private key)를 저장 합 니 다.먼저 이 파일 들 을 생 성 한 다음 에 파일 을 프로젝트 에 가 져 와 서 사용 해 야 합 니 다.더 이상 말 하지 않 고 시작 해 야 합 니 다!
1.openssl 을 사용 하여 필요 한 비밀 키 파일 생 성
생 성 환경 은 mac 시스템 에서 openssl 을 사용 하여 생 성 됩 니 다.먼저 단말 기 를 열 고 다음 절 차 를 따라 순서대로 합 니 다.
1.모드 길이 1024 bit 의 비밀 키 파일 private 생 성key.pemopenssl genrsa -out private_key.pem 10242.인증서 요청 파일 생 성 rsaCertReq.csropenssl req -new -key private_key.pem -out rsaCerReq.csr주의:이 단 계 는 국가,성,mail 등 정 보 를 입력 하 는 것 을 알려 줄 것 입 니 다.실제 상황 에 따라 작성 하거나 모두 작성 하지 않 고 바로 차 를 두 드 릴 수 있 습 니 다.
3.인증서 rsa Cert.crt 를 생 성하 고 유효 시간 을 1 년 으로 설정 합 니 다.openssl x509 -req -days 3650 -in rsaCerReq.csr -signkey private_key.pem -out rsaCert.crt4.iOS 에서 사용 할 공개 키 파일 생 성 publickey.deropenssl x509 -outform der -in rsaCert.crt -out public_key.der5.iOS 에서 사용 할 비밀 키 파일 생 성 privatekey.p12openssl pkcs12 -export -out private_key.p12 -inkey private_key.pem -in rsaCert.crt메모:이 단 계 는 비밀 키 파일 에 비밀 번 호 를 설정 하 는 것 을 알려 줍 니 다.비밀 번 호 를 설정 하려 면 직접 입력 한 다음 에 차 를 두 드 린 다음 에 방금 설정 한 비밀 번 호 를 확인 하고 비밀 번 호 를 다시 입력 한 다음 에 차 를 두 드 리 면 됩 니 다.완료!
복호화 시 privatekey.p12 파일 은 여기에 설 정 된 암호 와 함께 사용 해 야 하기 때문에 이 암 호 를 기억 해 야 합 니 다.
6.자바 에 사용 할 공개 키 rsa 생 성public_key.pemopenssl rsa -in private_key.pem -out rsa_public_key.pem -pubout7.자바 에 사용 할 비밀 키 생 성 pkcs 8private_key.pemopenssl pkcs8 -topk8 -in private_key.pem -out pkcs8_private_key.pem -nocrypt모두 실행 에 성공 하면 다음 파일 이 생 성 됩 니 다.그 중 Publickey.der 와 privatekey.p12 는 iOS 에 필요 한 파일 입 니 다.다음 그림:

생 성 된 파일
2.파일 가 져 오기 프로젝트 사용
1.새 프로젝트 를 만 들 고 Security.framework 프레임 워 크 를 가 져 옵 니 다.다음 그림:

새 프로젝트 와 프레임 워 크 추가
2.비밀 키 파일 가 져 오기
.der 와.p12 형식의 비밀 키 파일 을 가 져 옵 니 다.다음 그림:

비밀 키 파일 가 져 오기
3.암호 화,복호화 에 사용 할 클래스 RSAEncryptor 를 새로 만 들 고 관련 방법 을 실현 합 니 다.
새 RSAEncryptor 클래스 는 다음 과 같 습 니 다.

암호 화 복호화 에 사용 할 새 클래스
다음 코드 를 시작 하면 직접 복사 해서 사용 할 수 있 습 니 다.
RSAEncryptor.h 코드 는 다음 과 같 습 니 다.

#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
RSAEncryptor.m    :
#import "RSAEncryptor.h"
#import <Security/Security.h>
@implementation RSAEncryptor
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;
}
#pragma mark -   '.der'      
//  
+ (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:@"
" 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:@"
" 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;
}
/* END: Decryption with RSA private key */
@end

4.암호 화,복호화 테스트
먼저.der 와.p12 비밀 키 파일 을 사용 하여 암호 화,복호화 하 는 것 을 테스트 하고 ViewController.m 에서 테스트 합 니 다.코드 는 다음 과 같 습 니 다.

#import "ViewController.h"
#import "RSAEncryptor.h"
@interface ViewController ()
@end
@implementation ViewController
- (void)viewDidLoad {
 [super viewDidLoad];
 //    
 NSString *originalString = @"        '.der'        !";
 //  .der .p12          
 NSString *public_key_path = [[NSBundle mainBundle] pathForResource:@"public_key.der" ofType:nil];
 NSString *private_key_path = [[NSBundle mainBundle] pathForResource:@"private_key.p12" ofType:nil];
 NSString *encryptStr = [RSAEncryptor encryptString:originalString publicKeyWithContentsOfFile:public_key_path];
 NSLog(@"   :%@", originalString);
 NSLog(@"   :%@", encryptStr);
 NSLog(@"   :%@", [RSAEncryptor decryptString:encryptStr privateKeyWithContentsOfFile:private_key_path password:@"123456"]);

}
- (void)didReceiveMemoryWarning {
 [super didReceiveMemoryWarning];
 // Dispose of any resources that can be recreated.
}
@end

실행 후 출력 정 보 는 다음 과 같 습 니 다.

출력 결과
암호 화,복호화 에 성공 한 것 을 볼 수 있 습 니 다.
다음은 비밀 키 문자열 을 사용 하여 암호 화,복호화 하 는 것 을 테스트 합 니 다.비밀 키 문자열 은 어디에서 나 옵 니까?여기에 올 수 있다.http://web.chacuo.net/netrsakeypair이것 은 온라인 으로 RSA 비밀 키 를 생 성 하 는 사이트 입 니 다.공개 키 와 비밀 키 를 생 성 한 후 복사 하여 테스트 에 사용 합 니 다.그리고 ViewController.m 에서 RSAEntryptor.h 헤더 파일 에 대응 하 는 암호 화 방법 을 사용 하여 암호 화 합 니 다.ViewController.m 의 코드 는 다음 과 같 습 니 다.

#import "ViewController.h"
#import "RSAEncryptor.h"
@interface ViewController ()
@end
@implementation ViewController
- (void)viewDidLoad {
 [super viewDidLoad];

 //    
 NSString *originalString = @"        '     '        !";

 //                
 NSString *encryptStr = [RSAEncryptor encryptString:originalString publicKey:@"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDTbZ6cNH9PgdF60aQKveLz3FTalyzHQwbp601y77SzmGHX3F5NoVUZbdK7UMdoCLK4FBziTewYD9DWvAErXZo9BFuI96bAop8wfl1VkZyyHTcznxNJFGSQd/B70/ExMgMBpEwkAAdyUqIjIdVGh1FQK/4acwS39YXwbS+IlHsPSQIDAQAB"];
 NSLog(@"   :%@", originalString);
 NSLog(@"   :%@", encryptStr);
 NSLog(@"   :%@", [RSAEncryptor decryptString:encryptStr privateKey:@"MIICeAIBADANBgkqhkiG9w0BAQEFAASCAmIwggJeAgEAAoGBANNtnpw0f0+B0XrRpAq94vPcVNqXLMdDBunrTXLvtLOYYdfcXk2hVRlt0rtQx2gIsrgUHOJN7BgP0Na8AStdmj0EW4j3psCinzB+XVWRnLIdNzOfE0kUZJB38HvT8TEyAwGkTCQAB3JSoiMh1UaHUVAr/hpzBLf1hfBtL4iUew9JAgMBAAECgYA1tGeQmAkqofga8XtwuxEWDoaDS9k0+EKeUoXGxzqoT/GyiihuIafjILFhoUA1ndf/yCQaG973sbTDhtfpMwqFNQq13+JAownslTjWgr7Hwf7qplYW92R7CU0v7wFfjqm1t/2FKU9JkHfaHfb7qqESMIbO/VMjER9o4tEx58uXDQJBAO0O4lnWDVjr1gN02cqvxPOtTY6DgFbQDeaAZF8obb6XqvCqGW/AVms3Bh8nVlUwdQ2K/xte8tHxjW9FtBQTLd8CQQDkUncO35gAqUF9Bhsdzrs7nO1J3VjLrM0ITrepqjqtVEvdXZc+1/UrkWVaIigWAXjQCVfmQzScdbznhYXPz5fXAkEAgB3KMRkhL4yNpmKRjhw+ih+ASeRCCSj6Sjfbhx4XaakYZmbXxnChg+JB+bZNz06YBFC5nLZM7y/n61o1f5/56wJBALw+ZVzE6ly5L34114uG04W9x0HcFgau7MiJphFjgUdAtd/H9xfgE4odMRPUD3q9Me9LlMYK6MiKpfm4c2+3dzcCQQC8y37NPgpNEkd9smMwPpSEjPW41aMlfcKvP4Da3z7G5bGlmuICrva9YDAiaAyDGGCK8LxC8K6HpKrFgYrXkRtt"]);
}
- (void)didReceiveMemoryWarning {
 [super didReceiveMemoryWarning];
 // Dispose of any resources that can be recreated.
}
@end

실행 후 출력 정 보 는 다음 과 같 습 니 다.

출력 결과
보 실 수 있 습 니 다.암호 화,복호화 에 도 성 공 했 습 니 다.
이로써 RSA 암호 화 시연 이 완료 되 었 습 니 다!
이상 은 본 고의 모든 내용 입 니 다.본 고의 내용 이 여러분 의 학습 이나 업무 에 어느 정도 도움 이 되 기 를 바 랍 니 다.또한 저 희 를 많이 지지 해 주시 기 바 랍 니 다!