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

作者: methodname | 来源:发表于2016-11-25 12:18 被阅读160次

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

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

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

对称加密算法

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

DES

AES

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

非对称加密

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

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

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

<pre>
<code class='objectivec hljs'>
openssl genrsa -des3 -out private-rsa.key 1024
</code></pre>

2)生成公钥证书

输入命令：
<pre><code class='objectivec hljs'>
openssl req -new -x509 -key private-rsa.key -days 750 -out public-rsa.cer
</code></pre>
该过程除了最开始时需要输入私钥文件的保护密码之外，其他需要的输入均可直接回车忽略，不影响正常使用。

3)生成PKCS12 格式Keystore

输入命令：
<pre><code class='objectivec hljs'>
openssl pkcs12 -export -name test-alias -in public-rsa.cer -inkey private-rsa.key -out user-rsa.pfx
</code></pre>

最后得到三个文件：

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结构如下：
<pre>
<code class='objectivec hljs'>
{
encryptkey:(使用RSA算法进行加密随机key)
id:(身份标识明文)
data：(真实数据，用key的明文作为密匙使用AES算法加密)
}
</code></pre>

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

//=================RSAEncryptor.h文件================

import <Foundation/Foundation.h>

@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 <Security/Security.h>

import "NSData+Base64.h"

import <CommonCrypto/CommonCrypto.h>

@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<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(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

</code></pre>

使用

import <Foundation/Foundation.h>

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;

}
</code></pre>

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

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

END

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

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

对称加密算法

非对称加密

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

2)生成公钥证书

3)生成PKCS12 格式Keystore

非对称加密的使用

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

随机key

公钥加密随机key

私钥解密随机获取随机key

MD5数据完整性校验

指纹校验

import <Foundation/Foundation.h>

pragma mark - Instance Methods

import "RSAEncryptor.h"

import <Security/Security.h>

import "NSData+Base64.h"

import <CommonCrypto/CommonCrypto.h>

pragma mark - Private Methods

pragma mark - Encrypt

pragma mark - Decrypt

pragma marke - verify file SHA1

使用

import <Foundation/Foundation.h>

import "RSAEncryptor.h"

import "HSDCertificateInfo.h"

import "HSDRBReqeust.h"

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

ios学习积累

iOS程序猿

iOS Developer