/*  RSA.h

 @author: ideawu

 @link: https://github.com/ideawu/Objective-C-RSA

*/

#import <Foundation/Foundation.h>

@interface RSA : NSObject

// return base64 encoded string

+ (NSString *)encryptString:(NSString *)str publicKey:(NSString *)pubKey;

// return raw data

+ (NSData *)encryptData:(NSData *)data publicKey:(NSString *)pubKey;

// return base64 encoded string

// enc with private key NOT working YET!

//+ (NSString *)encryptString:(NSString *)str privateKey:(NSString *)privKey;

// return raw data

//+ (NSData *)encryptData:(NSData *)data privateKey:(NSString *)privKey;

// decrypt base64 encoded string, convert result to string(not base64 encoded)

+ (NSString *)decryptString:(NSString *)str publicKey:(NSString *)pubKey;

+ (NSData *)decryptData:(NSData *)data publicKey:(NSString *)pubKey;

+ (NSString *)decryptString:(NSString *)str privateKey:(NSString *)privKey;

+ (NSData *)decryptData:(NSData *)data privateKey:(NSString *)privKey;

@end
/* RSA.m

 @author: ideawu

 @link: https://github.com/ideawu/Objective-C-RSA

*/

#import "RSA.h"

#import <Security/Security.h>

@implementation RSA

/*

static NSString *base64_encode(NSString *str){

    NSData* data = [str dataUsingEncoding:NSUTF8StringEncoding];

    if(!data){

        return nil;

    }

    return base64_encode_data(data);

}

*/

static NSString *base64_encode_data(NSData *data){

    data = [data base64EncodedDataWithOptions:];

    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;

}

+ (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     = ;

    if (c_key[idx++] != 0x30) return(nil);

    if (c_key[idx] > 0x80) idx += c_key[idx] - 0x80 + ;

    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, )) return(nil);

    idx += ;

    if (c_key[idx++] != 0x03) return(nil);

    if (c_key[idx] > 0x80) idx += c_key[idx] - 0x80 + ;

    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]);

}

//credit: http://hg.mozilla.org/services/fx-home/file/tip/Sources/NetworkAndStorage/CryptoUtils.m#l1036

+ (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     = ; //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 = ;

        unsigned char *ptr = &c_key[idx];

        idx += byteCount;

        while (byteCount) {

            accum = (accum << ) + *ptr;

            ptr++;

            byteCount--;

        }

        c_len = accum;

    }

    // Now make a new NSData from this buffer

    return [d_key subdataWithRange:NSMakeRange(idx, c_len)];

}

+ (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 = [RSA 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;

}

+ (SecKeyRef)addPrivateKey:(NSString *)key{

    NSRange spos;

    NSRange epos;

    spos = [key rangeOfString:@"-----BEGIN RSA PRIVATE KEY-----"];

    if(spos.length > ){

        epos = [key rangeOfString:@"-----END RSA PRIVATE KEY-----"];

    }else{

        spos = [key rangeOfString:@"-----BEGIN PRIVATE KEY-----"];

        epos = [key rangeOfString:@"-----END 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 = [RSA 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;

}

/* START: Encryption & Decryption with RSA private key */

+ (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 - ;

    NSMutableData *ret = [[NSMutableData alloc] init];

    for(int idx=; 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 != ) {

            NSLog(@"SecKeyEncrypt fail. Error Code: %d", (int)status);

            ret = nil;

            break;

        }else{

            [ret appendBytes:outbuf length:outlen];

        }

    }

    free(outbuf);

    CFRelease(keyRef);

    return ret;

}

+ (NSString *)encryptString:(NSString *)str privateKey:(NSString *)privKey{

    NSData *data = [RSA encryptData:[str dataUsingEncoding:NSUTF8StringEncoding] privateKey:privKey];

    NSString *ret = base64_encode_data(data);

    return ret;

}

+ (NSData *)encryptData:(NSData *)data privateKey:(NSString *)privKey{

    if(!data || !privKey){

        return nil;

    }

    SecKeyRef keyRef = [RSA addPrivateKey:privKey];

    if(!keyRef){

        return nil;

    }

    return [RSA encryptData:data withKeyRef:keyRef];

}

+ (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=; 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 != ) {

            NSLog(@"SecKeyEncrypt fail. Error Code: %d", (int)status);

            ret = nil;

            break;

        }else{

            //the actual decrypted data is in the middle, locate it!

            int idxFirstZero = -;

            int idxNextZero = (int)outlen;

            for ( int i = ; i < outlen; i++ ) {

                if ( outbuf[i] ==  ) {

                    if ( idxFirstZero <  ) {

                        idxFirstZero = i;

                    } else {

                        idxNextZero = i;

                        break;

                    }

                }

            }

            [ret appendBytes:&outbuf[idxFirstZero+] length:idxNextZero-idxFirstZero-];

        }

    }

    free(outbuf);

    CFRelease(keyRef);

    return ret;

}

+ (NSString *)decryptString:(NSString *)str privateKey:(NSString *)privKey{

    NSData *data = [[NSData alloc] initWithBase64EncodedString:str options:NSDataBase64DecodingIgnoreUnknownCharacters];

    data = [RSA 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 = [RSA addPrivateKey:privKey];

    if(!keyRef){

        return nil;

    }

    return [RSA decryptData:data withKeyRef:keyRef];

}

/* END: Encryption & Decryption with RSA private key */

/* START: Encryption & Decryption with RSA public key */

+ (NSString *)encryptString:(NSString *)str publicKey:(NSString *)pubKey{

    NSData *data = [RSA 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 = [RSA addPublicKey:pubKey];

    if(!keyRef){

        return nil;

    }

    return [RSA encryptData:data withKeyRef:keyRef];

}

+ (NSString *)decryptString:(NSString *)str publicKey:(NSString *)pubKey{

    NSData *data = [[NSData alloc] initWithBase64EncodedString:str options:NSDataBase64DecodingIgnoreUnknownCharacters];

    data = [RSA decryptData:data publicKey:pubKey];

    NSString *ret = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];

    return ret;

}

+ (NSData *)decryptData:(NSData *)data publicKey:(NSString *)pubKey{

    if(!data || !pubKey){

        return nil;

    }

    SecKeyRef keyRef = [RSA addPublicKey:pubKey];

    if(!keyRef){

        return nil;

    }

    return [RSA decryptData:data withKeyRef:keyRef];

}

/* END: Encryption & Decryption with RSA public key */

@end

转载请注明出处：http://www.cnblogs.com/ficow/p/7132266.html

最新文章

  1. xv6课本翻译之——第0章 操作系统接口
  2. html5 选择元素
  3. css的margin
  4. Exception异常
  5. BZOJ-1927 星际竞速 最小费用最大流+拆点+不坑建图
  6. Ubuntu Linux启用root用户登录
  7. json转String 和 String转json 和判断对象类型
  8. Servlet中文乱码处理
  9. Java IO之File和IO
  10. springMVC中数据流解析与装载
  11. 京东618：Docker扛大旗，弹性伸缩成重点 (2015-06-23)
  12. [原][OSG]OSG例子程序简介
  13. CPU与内存互联的架构演变
  14. 设计模式之模板方法模式（TemplateMethod）
  15. oracle 12cR2 smart flash cache实测
  16. 解决SecureCRT超时自动断开的问题
  17. [leetcode]Spiral Matrix II @ Python
  18. sql 基础练习 计算7天各个时间点的总和 group by order mysql一次查询多个表
  19. 【Unity】2.0 第2章 Unity编辑器和基本操作
  20. 你可能不知道的 10 条 SQL 技巧，涨知识了！

热门文章

  1. Serial attached SCSI
  2. 依据iPhone6设计稿动态计算rem值
  3. dubbo配置指南
  4. adb常用命令整理
  5. 两篇C++和VC++字符串的文章
  6. stm8 停机模式与外部中断唤醒中一个小问题
  7. HDU 6109 数据分割 【并查集+set】 （2017&quot;百度之星&quot;程序设计大赛 - 初赛（A））
  8. bzoj4105: [Thu Summer Camp 2015]平方运算
  9. HDU 1257：最少拦截系统
  10. eclipse本地覆盖版本库