【安全篇】在iOS中使用MD5+AES+RSA打造坚固通信传输加密

传输加密本应该是服务端端与服务端之间,或者服务端与客户端之间的产生的关系,本文只讲述了如何在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

最后得到三个文件:

【安全篇】在iOS中使用MD5+AES+RSA打造坚固通信传输加密_第1张图片
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方发信息的时候则反之。

下面看一则第三方网银支付的数据传输加密解密流程图


【安全篇】在iOS中使用MD5+AES+RSA打造坚固通信传输加密_第2张图片
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

你可能感兴趣的