传输加密本应该是服务端端与服务端之间,或者服务端与客户端之间的产生的关系,本文只讲述了如何在iOS端使用加密的一些相关事宜,其实在服务端使用的套路也是一样的,只不过存在语言上的差异,还有需要注意的是传输数据字符编码必须保持一致,数据的接收方是否支持解压缩数据包等。

随着信息技术的发展越来越壮大,信息安全这一词也不是只存在银行,金融等机构中,很多公司对自己的信息都期望任何人都无法去破解它们。

这里不得不说的是关于对称加密与非对称加密

对称加密算法

前面有两篇文章说到过对称加密算法AES和DES

DES

AES

这里两种加密算法都是对称加密,或者称之为传统加密,在足够的条件下它们是可以被反推出密匙的。

非对称加密

而非对称加密算法需要两个密钥来进行加密和解密,这两个秘钥是公开密钥(public key,简称公钥)和私有密钥(private key,简称私钥)。它们是两个文件,在window或者linux系统上面,可以使用openssl工具进行生成 OpenSSl官网,在mac上面可以直接使用terminal(终端)来生成,具体如下:

1)生成采用des3算法保护的私钥

命令执行过程中的提示信息Enter pass phrase 的含义是输入用来保护私钥文件的密码(密码不要超过6位)输入命令:


openssl genrsa -des3 -out private-rsa.key 1024
2)生成公钥证书

输入命令:


openssl req -new -x509 -key private-rsa.key -days 750 -out public-rsa.cer

该过程除了最开始时需要输入私钥文件的保护密码之外,其他需要的输入均可直接回车忽略,不影响正常使用。

3)生成PKCS12 格式Keystore

输入命令:


    openssl pkcs12 -export -name test-alias -in public-rsa.cer -inkey private-rsa.key -out user-rsa.pfx

最后得到三个文件:
image
其中.pfx为私钥,.cer为公钥,在RSA非对称加密算法中,私钥只能用于解密,公钥只能用于加密,并且无法反推出密匙。
关于它们的安全性可以参考这篇文章:

40年前他们就奠定了今天苹果不妥协的底气

非对称加密的使用

与对称加密算法不同,非对称加密算法需要两个密钥:公开密钥(publickey)和私有密钥(privatekey)。公开密钥与私有密钥是一对,如果用公开密钥对数据进行加密,只有用对应的私有密钥才能解密,并且无法反推出密钥。通常我们在信息通信的过程中:

A,B两方,A和B会各回生成一对publickey和privatekey

A(公) A(私)
B(公) B(私)
A方将会将A(公)给B方,B方将会将B(公)给A方,这样A方需要给B方发信息的时候,将使用B(公)对信息加密,只有拥有B(私)的B方才能对信息进行解密,而B方对B方发信息的时候则反之。

下面看一则第三方网银支付的数据传输加密解密流程图
pkg
这其中包括:

随机key
公钥加密随机key
私钥解密随机获取随机key
MD5数据完整性校验
指纹校验

四大步骤来保证数据的安全性,并且可以看出通常我们都不会直接使用RSA对数据进行加密,我们会对AES的密匙进行加密,数据传输的JSON结构如下:


{
encryptkey:(使用RSA算法进行加密随机key)
id:(身份标识明文)
data:(真实数据,用key的明文作为密匙使用AES算法加密)
}

关于RSA的加密算法在iOS中应用如下:




//=================RSAEncryptor.h文件================
#import 

@interface RSAEncryptor : NSObject
#pragma mark - Instance Methods
/**
 *  通过文件路径加载公钥
 *
 *  @param derFilePath 公钥文件路径
 */
-(void) loadPublicKeyFromFile: (NSString*) derFilePath;
/**
 *  通过NSData加载公钥
 *  (此方法可用于将公钥配置在服务端,以Base64字符串传到移动端来加载)
 *  @param derData 公钥data
 */
-(void) loadPublicKeyFromData: (NSData*) derData;
/**
 *  通过文件路径加载私钥
 *
 *  @param p12FilePath 私钥文件路径
 *  @param p12Password 私钥密码
 */
-(void) loadPrivateKeyFromFile: (NSString*) p12FilePath password:(NSString*)p12Password;
/**
 *  通过NSData加载私钥
 *
 *  @param p12Data     私钥data
 *  @param p12Password 私钥密码
 */
-(void) loadPrivateKeyFromData: (NSData*) p12Data password:(NSString*)p12Password;

/**
 *  RSA加密字符串
 *
 *  @param string  要加密的明文字符串
 *
 *  @return 加密后的密文字符串
 */
-(NSString*) rsaEncryptString:(NSString*)string;

/**
 *  RSA加密NSData
 *
 *  @param data 要加密的明文data
 *
 *  @return 加密后的密文data
 */
-(NSData*) rsaEncryptData:(NSData*)data ;

/**
 *  RSA解密字符串
 *
 *  @param string  要解密的密文字符串
 *
 *  @return 解密后的明文字符串
 */
-(NSString*) rsaDecryptString:(NSString*)string;

/**
 *  RSA解密NSData
 *
 *  @param data 要解密的密文data
 *
 *  @return 解密后的明文data
 */
-(NSData*) rsaDecryptData:(NSData*)data;


/**
 *  融宝RSA解密
 *
 *  @param str
 *
 *  @return
 */
+(NSString *)rsaRBDecryptString:(NSString *)str;

/**
 *  融宝RSA加密
 *
 *  @param str
 *
 *  @return
 */
+(NSString *)rsaRBEncryptString:(NSString *)str;

/**
 *  获取16位随机数字密匙
 *
 *  @return 随机16为数字密匙
 */
+(NSString *)getRandomd16;

@end


//=================RSAEncryptor.m文件================

#import "RSAEncryptor.h"
#import 
#import "NSData+Base64.h"
#import 


@implementation RSAEncryptor
{
    /**
     *  公钥
     */
    SecKeyRef publicKey;
    /**
     *  私钥
     */
    SecKeyRef privateKey;
}

/**
 *  释放公钥私钥
 */
-(void)dealloc
{
    if (nil != publicKey) {
        CFRelease(publicKey);
    }
    if (nil != privateKey) {
        CFRelease(privateKey);
    }
}


/**
 *  获取公钥
 *
 *  @return
 */
-(SecKeyRef) getPublicKey {
    return publicKey;
}

/**
 *  获取私钥
 *
 *  @return
 */
-(SecKeyRef) getPrivateKey {
    return privateKey;
}


/**
 *  通过文件路径加载公钥
 *
 *  @param derFilePath 公钥文件路径
 */
-(void) loadPublicKeyFromFile: (NSString*) derFilePath
{
    NSData *derData = [[NSData alloc] initWithContentsOfFile:derFilePath];
    [self loadPublicKeyFromData: derData];
}

/**
 *  通过NSData加载公钥
 *  (此方法可用于将公钥配置在服务端,以Base64字符串传到移动端来加载)
 *  @param derData 公钥data
 */
-(void) loadPublicKeyFromData: (NSData*) derData
{
    publicKey = [self getPublicKeyRefrenceFromeData: derData];
}


/**
 *  通过文件路径加载私钥
 *
 *  @param p12FilePath 私钥文件路径
 *  @param p12Password 私钥密码
 */
-(void) loadPrivateKeyFromFile: (NSString*) p12FilePath password:(NSString*)p12Password
{
    NSData *p12Data = [NSData dataWithContentsOfFile:p12FilePath];
    [self loadPrivateKeyFromData: p12Data password:p12Password];
}

/**
 *  通过NSData加载私钥
 *
 *  @param p12Data     私钥data
 *  @param p12Password 私钥密码
 */
-(void) loadPrivateKeyFromData: (NSData*) p12Data password:(NSString*)p12Password
{
    privateKey = [self getPrivateKeyRefrenceFromData: p12Data password: p12Password];
}




#pragma mark - Private Methods

/**
 *  (私有方法)从data获取公钥
 *
 *  @param derData data
 *
 *  @return 公钥
 */
-(SecKeyRef) getPublicKeyRefrenceFromeData: (NSData*)derData
{
    SecCertificateRef myCertificate = SecCertificateCreateWithData(kCFAllocatorDefault, (__bridge CFDataRef)derData);
    SecPolicyRef myPolicy = SecPolicyCreateBasicX509();
    SecTrustRef myTrust;
    OSStatus status = SecTrustCreateWithCertificates(myCertificate,myPolicy,&myTrust);
    SecTrustResultType trustResult;
    if (status == noErr) {
        status = SecTrustEvaluate(myTrust, &trustResult);
    }
    SecKeyRef securityKey = SecTrustCopyPublicKey(myTrust);
    CFRelease(myCertificate);
    CFRelease(myPolicy);
    CFRelease(myTrust);
    
    return securityKey;
}


/**
 *  (私有方法)从data获取私钥
 *
 *  @param derData data
 *
 *  @return 私钥
 */
-(SecKeyRef) getPrivateKeyRefrenceFromData: (NSData*)p12Data password:(NSString*)password
{
    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;
}



#pragma mark - Encrypt

/**
 *  字符串加密
 *
 *  @param string 明文
 *
 *  @return 密文(base64防止乱码)
 */
-(NSString*) rsaEncryptString:(NSString*)string
{
    NSData* data = [string dataUsingEncoding:NSUTF8StringEncoding];
    NSData* encryptedData = [self rsaEncryptData: data];
    NSString* base64EncryptedString = [encryptedData base64EncodedStringWithOptions:NSDataBase64Encoding64CharacterLineLength];
    return base64EncryptedString;
}

// 加密的大小受限于SecKeyEncrypt函数,SecKeyEncrypt要求明文和密钥的长度一致,如果要加密更长的内容,需要把内容按密钥长度分成多份,然后多次调用SecKeyEncrypt来实现
-(NSData*) rsaEncryptData:(NSData*)data
{
    SecKeyRef key = [self getPublicKey];
    
    const uint8_t *srcbuf = (const uint8_t *)[data bytes];
    size_t srclen = (size_t)data.length;
    
    size_t block_size = SecKeyGetBlockSize(key) * 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 src_block_size){
            data_len = src_block_size;
        }
        
        size_t outlen = block_size;
        OSStatus status = noErr;
        status = SecKeyEncrypt(key,
                               kSecPaddingPKCS1,
                               srcbuf + idx,
                               data_len,
                               outbuf,
                               &outlen
                               );
        if (status != 0) {//0为成功
            NSLog(@"SecKeyEncrypt fail. Error Code: %d", (int)status);
            ret = nil;
            break;
        }else{
            [ret appendBytes:outbuf length:outlen];
        }
    }
    
    free(outbuf);
    return ret;
}




#pragma mark - Decrypt

/**
 *  解密字符串
 *
 *  @param string 密文
 *
 *  @return 明文
 */
-(NSString*) rsaDecryptString:(NSString*)string {
    
    NSData* data = [[NSData alloc] initWithBase64EncodedString:string options:NSDataBase64DecodingIgnoreUnknownCharacters];
    NSData* decryptData = [self rsaDecryptData: data];
    NSString* result = [[NSString alloc] initWithData: decryptData encoding:NSUTF8StringEncoding];
    return result;
}

/**
 *  解密
 *
 *  @param data 密文data
 *
 *  @return  明文data
 */
-(NSData*) rsaDecryptData:(NSData*)data
{
    SecKeyRef key = [self getPrivateKey];
    size_t cipherLen = [data length];
    void *cipher = malloc(cipherLen);
    [data getBytes:cipher length:cipherLen];
    size_t plainLen = SecKeyGetBlockSize(key) - 12;
    void *plain = malloc(plainLen);
    OSStatus status = SecKeyDecrypt(key, kSecPaddingPKCS1, cipher, cipherLen, plain, &plainLen);
    
    if (status != noErr) {
        return nil;
    }
    NSData *decryptedData = [[NSData alloc] initWithBytes:(const void *)plain length:plainLen];
    return decryptedData;
}

#pragma marke - verify file SHA1
/**
 *  验证公钥私钥是否被篡改
 *
 *  @param plainData
 *  @param signature
 *
 *  @return 是否被篡改
 */
-(BOOL) rsaSHA1VerifyData:(NSData *) plainData
            withSignature:(NSData *) signature {
    
    size_t signedHashBytesSize = SecKeyGetBlockSize([self getPublicKey]);
    const void* signedHashBytes = [signature bytes];
    
    size_t hashBytesSize = CC_SHA1_DIGEST_LENGTH;
    uint8_t* hashBytes = malloc(hashBytesSize);
    if (!CC_SHA1([plainData bytes], (CC_LONG)[plainData length], hashBytes)) {
        return NO;
    }
    
    OSStatus status = SecKeyRawVerify(publicKey,
                                      kSecPaddingPKCS1SHA1,
                                      hashBytes,
                                      hashBytesSize,
                                      signedHashBytes,
                                      signedHashBytesSize);
    
    return status == errSecSuccess;
}


/**
 *  获取16位随机数字密匙
 *
 *  @return
 */
+(NSString *)getRandomd16
{
    //随机生成16数字
    NSString *strRandom = @"";
    for(int i=0; i<16; i++)
    {
        strRandom = [ strRandom stringByAppendingFormat:@"%i",(arc4random() % 9)];
    }
    return strRandom;
}


@end

使用

#import 
#import "RSAEncryptor.h"
#import "HSDCertificateInfo.h"

@interface HSDRBReqeust : NSObject
/**
 *  身份标识id
 */
@property(nonatomic,copy)NSString *merchant_id;
/**
 *  数据
 */
@property(nonatomic,copy)NSString *data;

/**
 *  密钥
 */
@property(nonatomic,copy)NSString *encryptkey;


/**
 *  根据数据实体获取请求结构对象
 *
 *  @param sigining 数据实体
 *
 *  @return 请求结构实例
 */
-(instancetype)initWithCertificate:(HSDCertificateInfo*)certificate;

@end


#import "HSDRBReqeust.h"
@implementation HSDRBReqeust
/**
 *  根据数据实体获取请求结构对象
 *
 *  @param sigining 数据实体
 *
 *  @return 请求结构实例
 */
-(instancetype)initWithCertificate:(HSDCertificateInfo*)certificate
{
    self = [super init];
    if (self!=nil)
    {
        
        //================================【商户号】================================
        self.merchant_id = certificate.merchant_id;
        
        //================================【随机密匙】================================
        //用融宝公钥对随机生成的秘钥进行加密
        NSString *strRandom =[RSAEncryptor getRandomd16];
        NSString *encryptedString = [RSAEncryptor rsaRBEncryptString:strRandom];
        self.encryptkey = encryptedString;
        //================================【加密数据】================================
        //将对象转JSON
        NSDictionary *dic =[JSonObject getObjectData:certificate];
        NSString * siginingJSON = [dic toJSONString];
        NSLog(@"未加密的数据:=====================》\n%@",siginingJSON);
        //用随机生成的密钥对数据进行AES加密
        HSDSecurity *manage = [HSDSecurity new];
        NSString *decryptData =  [manage AES256EncryptWithString:siginingJSON Key:strRandom];
        self.data = decryptData;
        
    }
    return self;

}

HSDRBReqeust的结构为上面提到的JSON结构,将HSDRBReqeust转化为JSON字符串发送出去即可。

最后贴上一个gitHub上面的地址:
Objective-C-RSA

END