美文网首页iOS开发专题算法iOS
iOS开发加密实现-Base64,MD5,SHA1,ECB,BC

iOS开发加密实现-Base64,MD5,SHA1,ECB,BC

作者: 20b347b28fc9 | 来源:发表于2016-05-15 17:39 被阅读2671次

    iOS加密


    写在前面:记得最初接触加密,也不懂,就根据文档,用的是MD5,在密码后拼接字符串,当时拼接的字符串前后加起来都六七行,当时觉得我去,这密码加密好复杂啊,之后才觉得自己好天真,哈哈!加盐(密码拼接字符串)这种方式很容易破解,文中有描述,也介绍了暴力破解的网站。
    相信很多开发者跟我当初一样,只是根据项目经理或者文档指示进行加密,但并不知道密码机密知识体系和内在原理,于是整理了一份相关资料,并附带了相关实现代码(OC版)。时间有限,知识并未全覆盖,有遗漏或者错误,忘指正。

    1.数据安全介绍


    • 1.最基础的是我们发送网络请求时,使用get和post方式发送请求。两者区别就不做解释了,只是引出相关安全性问题。

    get:将参数暴露在外, (绝对不安全--所以对于一些安全性要求高的请求不会使用)

    post:将参数放到请求体内,不暴露请求头中。但是我们可以很容易的用一些软件截获请求数据。比如说Charles(青花瓷)

    • 2.Charles(公司中一般都使用该工具来抓包,并做网络测试)

    注意:Charles在使用中的乱码问题,可以显示包内容,然后打开info.plist文件,找到java目录下面的VMOptions,在后面添加一项:-Dfile.encoding=UTF-8

    这里提供一个青花瓷破解版下载途径,供大家学习使用,商务需求,也请支持正版。

    • 3.数据安全的原则

    1)在网络上"不允许"传输用户隐私数据的"明文"

    2)在本地"不允许"保存用户隐私数据的"明文"

    2.密码学基础--Base64


    • 1.Base64简单说明

      • 描述:Base64可以成为密码学的基石,非常重要。
      • 特点:可以将任意的二进制数据进行Base64编码
      • 结果:所有的数据都能被编码为并只用65个字符就能表示的文本文件。
      • 65字符:A~Z a~z 0~9 + / =
      • 对文件进行base64编码后文件数据的变化:编码后的数据~=编码前数据的4/3,会大1/3左右。
    • 2.命令行进行Base64编码和解码

      • 编码:base64 123.png -o 123.txt
      • 解码:base64 123.txt -o test.png -D
    • 3.Base64编码原理

      • 1)将所有字符转化为ASCII码;
      • 2)将ASCII码转化为8位二进制;
      • 3)将二进制3个归成一组(不足3个在后边补0)共24位,再拆分成4组,每组6位;
      • 4)统一在6位二进制前补两个0凑足8位;
      • 5)将补0后的二进制转为十进制;
      • 6)从Base64编码表获取十进制对应的Base64编码;
    • 4.处理过程说明:

      • a.转换的时候,将三个byte的数据,先后放入一个24bit的缓冲区中,先来的byte占高位。
      • b.数据不足3byte的话,于缓冲区中剩下的bit用0补足。然后,每次取出6个bit,按照其值选择查表选择对应的字符作为编码后的输出。
      • c.不断进行,直到全部输入数据转换完成。
      • d.如果最后剩下两个输入数据,在编码结果后加1个“=”;
      • e.如果最后剩下一个输入数据,编码结果后加2个“=”;
      • f.如果没有剩下任何数据,就什么都不要加,这样才可以保证资料还原的正确性。
      • 结合下图理解
    Base64编码过程 Base64编码过程--无最后数据用等号补齐

    附件:

    ASCII值对照表
    • 5.实现

      • a.base64的原理如上所述,实现代码也不难,在Base64维基百科介绍中都有具体代码的实现。
      • b.我们在iOS开发中,直接有这样的方法可以返回加密后的数据,这里提供下iOS方法
    //给定一个字符串,对该字符串进行Base64编码,然后返回编码后的结果
    -(NSString *)base64EncodeString:(NSString *)string
    {
        //1.先把字符串转换为二进制数据
        NSData *data = [string dataUsingEncoding:NSUTF8StringEncoding];
    
        //2.对二进制数据进行base64编码,返回编码后的字符串
        //这是苹果已经给我们提供的方法
        return [data base64EncodedStringWithOptions:0];
    }
    
    
    //对base64编码后的字符串进行解码
    -(NSString *)base64DecodeString:(NSString *)string
    {
        //1.将base64编码后的字符串『解码』为二进制数据
        //这是苹果已经给我们提供的方法
        NSData *data = [[NSData alloc]initWithBase64EncodedString:string options:0];
        
        //2.把二进制数据转换为字符串返回
    
        return [[NSString alloc]initWithData:data encoding:NSUTF8StringEncoding];
    }
    
    • 6.终端测试命令
      我们可以直接通过终点对编码进行加密解密
      加密终端命令:$ echo -n 加密字符 | base64
      如: erer -> ZXJlcg==
      解密终端命令:$ echo -n 解密字符 |base64 -D

    ![](file:///Users/erer/Desktop/Snip剪切暂存/Snip20160514_8.png)

    3.常见加密算法

    • 单向散列函数
    • 对称加密
    • 非对称加密
    • 证书等

    4.单向散列函数

    • 1.单向散列函数的特点:

      • ①加密后密文的长度是定长的

      • ②如果明文不一样,那么散列后的结果一定不一样

      • ③如果明文一样,那么加密后的密文一定一样(对相同数据加密,加密后的密文一样)

      • ④所有的加密算法是公开的

      • 不可以逆推反算(最重要的特点)

      • ⑥速度非常快

      • ⑦可以使用文件管理--辨别是否一致

    • 2.经典加密算法

      • 1)MD5加密 (已被中国密码学家王小云破解)
      • 2)SHA1 (已被中国密码学家王小云破解)
      • 3)SHA512
    • 3.MD5加密算法简单说明

      • 1)对字符串进行MD5加密可以得到一个32个字符的密文
      • 2)加密之后不能根据密文逆推出明文
      • 3)MD5已经被破解(暴力破解|碰撞检测)
      • 注意:MD5破解不代表其可逆,而是一段字符串加密后的密文,可以通过强大运算计算出另一端字符串加密后可得到相同密文,证明不唯一而破解。有兴趣可以查看下云姐的业绩。

      这里给大家提供一个密码破解网址:cdm5.com(暴力破解--密码数据库)

      暴力破解是指通过将明文和生成的密文进行配对,生成强大的数据库,在数据库中搜索,在这里就可以破解密码。所以我们单纯使用MD5加密也不安全,下面提供几种措施。

    • 4.MD5加密进阶

      • 1)先加盐,然后再进行MD5
      • 2)先乱序,再进行MD5加密
      • 3)乱序|加盐,多次MD5加密等
      • 4)使用消息认证机制,即HMAC-MD5-先对密钥进行加密,加密之后进行两次MD5散列
      • 5)加密命令行
        • MD5加密-字符串 $ echo -n "erer" |md5
        • MD5加密-文件1 $ md5 erer.png
        • SHA1加密: $ echo -n "erer" |openssl sha -sha1
        • SHA256 $ echo -n "erer" |openssl sha -sha256
        • SHA512 $ echo -n "erer" |openssl sha -sha512
        • hmacMD5加密 $ echo -n "erer" |openssl dgst -md5 -hmac "123"
    • 5.散列函数应用领域

      • 1)搜索 多个关键字,先对每个关键字进行散列,然后多个关键字进行或运算,如果值一致则搜索结果一致
      • 2)版权 对文件进行散列判断该文件是否是正版或原版的
      • 3)文件完整性验证 对整个文件进行散列,比较散列值判断文件是否完整或被篡改
    • 6.消息认证机制(HMAC)简单说明

      • 1)原理
        • ①消息的发送者和接收者有一个共享密钥
        • ②发送者使用共享密钥对消息加密计算得到MAC值(消息认证码)
        • ③消息接收者使用共享密钥对消息加密计算得到MAC值
        • ④比较两个MAC值是否一致
      • 2)使用
        • ①客户端需要在发送的时候把(消息)+(消息·HMAC)一起发送给服务器
        • ②服务器接收到数据后,对拿到的消息用共享的KEY进行HMAC,比较是否一致,如果一致则信任
    • 7.散列函数基础加密代码

    注意散列函数的代码实现直接添加NSString的分离,创建下列方法及实现即可

    // 散列函数--md5对字符串加密
    - (NSString *)md5String {
        const char *str = self.UTF8String;
        uint8_t buffer[CC_MD5_DIGEST_LENGTH];
        
        CC_MD5(str, (CC_LONG)strlen(str), buffer);
        
        return [self stringFromBytes:buffer length:CC_MD5_DIGEST_LENGTH];
    }
    
    
    // 散列函数--sha1对字符串加密
    - (NSString *)sha1String {
        const char *str = self.UTF8String;
        uint8_t buffer[CC_SHA1_DIGEST_LENGTH];
        
        CC_SHA1(str, (CC_LONG)strlen(str), buffer);
        
        return [self stringFromBytes:buffer length:CC_SHA1_DIGEST_LENGTH];
    }
    
    
    // 散列函数--sha256对字符串加密
    - (NSString *)sha256String {
        const char *str = self.UTF8String;
        uint8_t buffer[CC_SHA256_DIGEST_LENGTH];
        
        CC_SHA256(str, (CC_LONG)strlen(str), buffer);
        
        return [self stringFromBytes:buffer length:CC_SHA256_DIGEST_LENGTH];
    }
    
    
    
    // 散列函数--sha512对字符串加密
    - (NSString *)sha512String {
        const char *str = self.UTF8String;
        uint8_t buffer[CC_SHA512_DIGEST_LENGTH];
        
        CC_SHA512(str, (CC_LONG)strlen(str), buffer);
        
        return [self stringFromBytes:buffer length:CC_SHA512_DIGEST_LENGTH];
    }
    
    • 8.散列函数-HMAC加密代码
    // 散列函数--HMAC md5加密
    - (NSString *)md5String {
        const char *keyData = key.UTF8String;
        const char *strData = self.UTF8String;
        uint8_t buffer[CC_MD5_DIGEST_LENGTH];
        
        CCHmac(kCCHmacAlgMD5, keyData, strlen(keyData), strData, strlen(strData), buffer);
        
        return [self stringFromBytes:buffer length:CC_MD5_DIGEST_LENGTH];
    }
    
    
    // 散列函数--HMAC sha1加密
    - (NSString *)sha1String {
        const char *keyData = key.UTF8String;
        const char *strData = self.UTF8String;
        uint8_t buffer[CC_SHA1_DIGEST_LENGTH];
        
        CCHmac(kCCHmacAlgSHA1, keyData, strlen(keyData), strData, strlen(strData), buffer);
        
        return [self stringFromBytes:buffer length:CC_SHA1_DIGEST_LENGTH];
    
    
    // 散列函数--HMAC sha256加密
    - (NSString *)sha256String {
        const char *keyData = key.UTF8String;
        const char *strData = self.UTF8String;
        uint8_t buffer[CC_SHA256_DIGEST_LENGTH];
        
        CCHmac(kCCHmacAlgSHA256, keyData, strlen(keyData), strData, strlen(strData), buffer);
        
        return [self stringFromBytes:buffer length:CC_SHA256_DIGEST_LENGTH];
    }
    
    
    
    // 散列函数--HMAC sha512加密
    - (NSString *)sha512String {
        const char *keyData = key.UTF8String;
        const char *strData = self.UTF8String;
        uint8_t buffer[CC_SHA512_DIGEST_LENGTH];
        
        CCHmac(kCCHmacAlgSHA512, keyData, strlen(keyData), strData, strlen(strData), buffer);
        
        return [self stringFromBytes:buffer length:CC_SHA512_DIGEST_LENGTH];
    }
    
    • 9.散列函数-对文件加密代码
    // 散列函数--md5对文件加密
    //#define FileHashDefaultChunkSizeForReadingData 4096
    
    - (NSString *)fileMD5Hash {
        NSFileHandle *fp = [NSFileHandle fileHandleForReadingAtPath:self];
        if (fp == nil) {
            return nil;
        }
        
        CC_MD5_CTX hashCtx;
        CC_MD5_Init(&hashCtx);
        
        while (YES) {
            @autoreleasepool {
                NSData *data = [fp readDataOfLength:FileHashDefaultChunkSizeForReadingData];
                
                CC_MD5_Update(&hashCtx, data.bytes, (CC_LONG)data.length);
                
                if (data.length == 0) {
                    break;
                }
            }
        }
        [fp closeFile];
        
        uint8_t buffer[CC_MD5_DIGEST_LENGTH];
        CC_MD5_Final(buffer, &hashCtx);
        
        return [self stringFromBytes:buffer length:CC_MD5_DIGEST_LENGTH];
    }
    
    
    /**
     *  返回二进制 Bytes 流的字符串表示形式
     *  @param bytes  二进制 Bytes 数组
     *  @param length 数组长度
     *  @return 字符串表示形式
     */
    - (NSString *)stringFromBytes:(uint8_t *)bytes length:(int)length {
        NSMutableString *strM = [NSMutableString string];
        
        for (int i = 0; i < length; i++) {
            [strM appendFormat:@"%02x", bytes[i]];
        }
        
        return [strM copy];
    }
    
    
    
    // 散列函数--sha1对文件加密
    //#define FileHashDefaultChunkSizeForReadingData 4096
    - (NSString *)fileSHA1Hash {
        NSFileHandle *fp = [NSFileHandle fileHandleForReadingAtPath:self];
        if (fp == nil) {
            return nil;
        }
        
        CC_SHA1_CTX hashCtx;
        CC_SHA1_Init(&hashCtx);
        
        while (YES) {
            @autoreleasepool {
                NSData *data = [fp readDataOfLength:FileHashDefaultChunkSizeForReadingData];
                
                CC_SHA1_Update(&hashCtx, data.bytes, (CC_LONG)data.length);
                
                if (data.length == 0) {
                    break;
                }
            }
        }
        [fp closeFile];
        
        uint8_t buffer[CC_SHA1_DIGEST_LENGTH];
        CC_SHA1_Final(buffer, &hashCtx);
        
        return [self stringFromBytes:buffer length:CC_SHA1_DIGEST_LENGTH];
    }
    
    
    - (NSString *)stringFromBytes:(uint8_t *)bytes length:(int)length {
        NSMutableString *strM = [NSMutableString string];
        
        for (int i = 0; i < length; i++) {
            [strM appendFormat:@"%02x", bytes[i]];
        }
        
        return [strM copy];
    }
    
    
    // 散列函数--sha256对文件加密
    //#define FileHashDefaultChunkSizeForReadingData 4096
    - (NSString *)fileSHA256Hash {
        NSFileHandle *fp = [NSFileHandle fileHandleForReadingAtPath:self];
        if (fp == nil) {
            return nil;
        }
        
        CC_SHA256_CTX hashCtx;
        CC_SHA256_Init(&hashCtx);
        
        while (YES) {
            @autoreleasepool {
                NSData *data = [fp readDataOfLength:FileHashDefaultChunkSizeForReadingData];
                
                CC_SHA256_Update(&hashCtx, data.bytes, (CC_LONG)data.length);
                
                if (data.length == 0) {
                    break;
                }
            }
        }
        [fp closeFile];
        
        uint8_t buffer[CC_SHA256_DIGEST_LENGTH];
        CC_SHA256_Final(buffer, &hashCtx);
        
        return [self stringFromBytes:buffer length:CC_SHA256_DIGEST_LENGTH];
    }
    
    
    - (NSString *)stringFromBytes:(uint8_t *)bytes length:(int)length {
        NSMutableString *strM = [NSMutableString string];
        
        for (int i = 0; i < length; i++) {
            [strM appendFormat:@"%02x", bytes[i]];
        }
        
        return [strM copy];
    }
    
    
    
    // 散列函数--sha512对文件加密
    //#define FileHashDefaultChunkSizeForReadingData 4096
    - (NSString *)fileSHA512Hash {
        NSFileHandle *fp = [NSFileHandle fileHandleForReadingAtPath:self];
        if (fp == nil) {
            return nil;
        }
        
        CC_SHA512_CTX hashCtx;
        CC_SHA512_Init(&hashCtx);
        
        while (YES) {
            @autoreleasepool {
                NSData *data = [fp readDataOfLength:FileHashDefaultChunkSizeForReadingData];
                
                CC_SHA512_Update(&hashCtx, data.bytes, (CC_LONG)data.length);
                
                if (data.length == 0) {
                    break;
                }
            }
        }
        [fp closeFile];
        
        uint8_t buffer[CC_SHA512_DIGEST_LENGTH];
        CC_SHA512_Final(buffer, &hashCtx);
        
        return [self stringFromBytes:buffer length:CC_SHA512_DIGEST_LENGTH];
    }
    
    
    - (NSString *)stringFromBytes:(uint8_t *)bytes length:(int)length {
        NSMutableString *strM = [NSMutableString string];
        
        for (int i = 0; i < length; i++) {
            [strM appendFormat:@"%02x", bytes[i]];
        }
        
        return [strM copy];
    }
    
    

    5.对称加密

    • 1.对称加密的特点

      • 1)加密/解密使用相同的密钥
      • 2)加密和解密的过程是可逆的(明文-》明文-》明文)
    • 2.经典算法

      • 1)DES 数据加密标准
      • 2)3DES 使用3个密钥,对消息进行(密钥1·加密)+(密钥2·解密)+(密钥3·加密)
      • 3)AES 高级加密标准
    • 3.分组密码简单说明

      • 密码算法可以分为分组密码和流密码两种。
        • 分组密码:每次只能处理特定长度的一zu数据的一类密码算法。一个分组的比特数量就称之为分组长度。DES和3DES的分组长度都是64比特。即每次只能加密64比特的明文,并生成64比特的密文。AES的分组长度有128比特、192比特和256比特可以选择。
        • 流密码:对数据流进行连续处理的一类算法。流密码中一般以1比特、8比特或者是32比特等作为单位俩进行加密和解密。
    • 4.ECB分组模式

      • ECB模式的全称为Electronic CodeBook模式。又成为电子密码本模式。
        特点:

        • 1)使用ECB模式加密的时候,相同的明文分组会被转换为相同的密文分组。
        • 2)类似于一个巨大的明文分组-》密文分组的对照表。
      • 终端测试命令:

        • 加密 $ openssl enc -des-ecb -K 616263 -nosalt -in 123.txt -out 123.bin
        • 解密 $ openssl enc -des-ecb -K 616263 -nosalt -in 123.bin -out 1231.txt -d
    • 5.CBC分组模式

      • CBC模式全称为Cipher Block Chainning模式(密文分组链接模式|电子密码链条)

        • 特点:在CBC模式中,首先将明文分组与前一个密文分组进行XOR运算,然后再进行加密。
      • 终端命令:

        • 加密 $ openssl enc -des-cbc -K 616263 -iv 0102030405060708 -nosalt -in a.txt -out a.bin
        • 解密 $ openssl enc -des-cbc -K 616263 -iv 0102030405060708 -nosalt -in a.bin -out a1.txt -d
    • 5.代码实现

    注意一下代码试下可以创建一个工具类,创建以下代码

    //
    //  EncryptionTools.h
    //
    
    (括号只为调节#格式,请忽略)#import <Foundation/Foundation.h>
    (括号只为调节#格式,请忽略)#import <CommonCrypto/CommonCrypto.h>
    
    /**
     *  终端测试指令
     *
     *  DES(ECB)加密
     *  $ echo -n 520it | openssl enc -des-ecb -K 616263 -nosalt | base64
     *
      * DES(CBC)加密
     *  $ echo -n 520it | openssl enc -des-cbc -iv 0102030405060708 -K 616263 -nosalt | base64
     *
     *  AES(ECB)加密
     *  $ echo -n 520it | openssl enc -aes-128-ecb -K 616263 -nosalt | base64
     *
     *  AES(CBC)加密
     *  $ echo -n 520it | openssl enc -aes-128-cbc -iv 0102030405060708 -K 616263 -nosalt | base64
     ***********************************************************************
     *  DES(ECB)解密
     *  $ echo -n VqYjXo2ZlU4= | base64 -D | openssl enc -des-ecb -K 616263 -nosalt -d
     *
     *  DES(CBC)解密
     *  $ echo -n 7MCnAFj6DpQ= | base64 -D | openssl enc -des-cbc -iv 0102030405060708 -K 616263 -nosalt -d
     *
     *  AES(ECB)解密
     *  $ echo -n FqRpCOQG9IL2QrKBHhM+fA== | base64 -D | openssl enc -aes-128-ecb -K 616263 -nosalt -d
     *
     *  AES(CBC)解密
     *  $ echo -n Kd9MN/rNEI40hdLhayPbUw== | base64 -D | openssl enc -aes-128-cbc -iv 0102030405060708 -K 616263 -nosalt -d
     *
     *  提示:
     *      1> 加密过程是先加密,再base64编码
     *      2> 解密过程是先base64解码,再解密
     */
    @interface EncryptionTools : NSObject
    
    + (instancetype)sharedEncryptionTools;
    
    /**
     @constant   kCCAlgorithmAES     高级加密标准,128位(默认)
     @constant   kCCAlgorithmDES     数据加密标准
     */
    @property (nonatomic, assign) uint32_t algorithm;
    
    /**
     *  加密字符串并返回base64编码字符串
     *
     *  @param string    要加密的字符串
     *  @param keyString 加密密钥
     *  @param iv        初始化向量(8个字节)
     *
     *  @return 返回加密后的base64编码字符串
     */
    - (NSString *)encryptString:(NSString *)string keyString:(NSString *)keyString iv:(NSData *)iv;
    
    /**
     *  解密字符串
     *
     *  @param string    加密并base64编码后的字符串
     *  @param keyString 解密密钥
     *  @param iv        初始化向量(8个字节)
     *
     *  @return 返回解密后的字符串
     */
    - (NSString *)decryptString:(NSString *)string keyString:(NSString *)keyString iv:(NSData *)iv;
    
    @end
    
    
    //
    //  EncryptionTools.m
    //
    
    (括号只为调节#格式,请忽略)#import "EncryptionTools.h"
    
    @interface EncryptionTools()
    @property (nonatomic, assign) int keySize;
    @property (nonatomic, assign) int blockSize;
    @end
    
    @implementation EncryptionTools
    
    + (instancetype)sharedEncryptionTools
    {
        static EncryptionTools *instance;
        
        static dispatch_once_t onceToken;
        dispatch_once(&onceToken, ^{
            instance = [[self alloc] init];
            instance.algorithm = kCCAlgorithmAES;
        });
        
        return instance;
    }
    
    - (void)setAlgorithm:(uint32_t)algorithm
    {
        _algorithm = algorithm;
        switch (algorithm) {
            case kCCAlgorithmAES:
                self.keySize = kCCKeySizeAES128;
                self.blockSize = kCCBlockSizeAES128;
                break;
            case kCCAlgorithmDES:
                self.keySize = kCCKeySizeDES;
                self.blockSize = kCCBlockSizeDES;
                break;
            default:
                break;
        }
    }
    
    - (NSString *)encryptString:(NSString *)string keyString:(NSString *)keyString iv:(NSData *)iv
    {
        
        // 设置秘钥
        NSData *keyData = [keyString dataUsingEncoding:NSUTF8StringEncoding];
        uint8_t cKey[self.keySize];
        bzero(cKey, sizeof(cKey));
        [keyData getBytes:cKey length:self.keySize];
        
        // 设置iv
        uint8_t cIv[self.blockSize];
        bzero(cIv, self.blockSize);
        int option = 0;
        /**
         kCCOptionPKCS7Padding                      CBC 的加密
         kCCOptionPKCS7Padding | kCCOptionECBMode   ECB 的加密
         */
        if (iv) {
            [iv getBytes:cIv length:self.blockSize];
            option = kCCOptionPKCS7Padding;
        } else {
            option = kCCOptionPKCS7Padding | kCCOptionECBMode;
        }
        
        // 设置输出缓冲区
        NSData *data = [string dataUsingEncoding:NSUTF8StringEncoding];
        size_t bufferSize = [data length] + self.blockSize;
        void *buffer = malloc(bufferSize);
        
        // 开始加密
        size_t encryptedSize = 0;
    
        /*
         CCCrypt 对称加密算法的核心函数(加密/解密)
         第一个参数:kCCEncrypt 加密/ kCCDecrypt 解密
         第二个参数:加密算法,默认使用的是 AES/DES
         第三个参数:加密选项 ECB/CBC
                    kCCOptionPKCS7Padding                      CBC 的加密
                    kCCOptionPKCS7Padding | kCCOptionECBMode   ECB 的加密
         第四个参数:加密密钥
         第五个参数:密钥的长度
         第六个参数:初始向量
         第七个参数:加密的数据
         第八个参数:加密的数据长度
         第九个参数:密文的内存地址
         第十个参数:密文缓冲区的大小
         第十一个参数:加密结果的大小
         */
        CCCryptorStatus cryptStatus = CCCrypt(kCCEncrypt,
                                              self.algorithm,
                                              option,
                                              cKey,
                                              self.keySize,
                                              cIv,
                                              [data bytes],
                                              [data length],
                                              buffer,
                                              bufferSize,
                                              &encryptedSize);
        
        NSData *result = nil;
        if (cryptStatus == kCCSuccess) {
            result = [NSData dataWithBytesNoCopy:buffer length:encryptedSize];
        } else {    
            free(buffer);
            NSLog(@"[错误] 加密失败|状态编码: %d", cryptStatus);
        }
        
        return [result base64EncodedStringWithOptions:0];
    }
    
    - (NSString *)decryptString:(NSString *)string keyString:(NSString *)keyString iv:(NSData *)iv
    {
        
        // 设置秘钥
        NSData *keyData = [keyString dataUsingEncoding:NSUTF8StringEncoding];
        uint8_t cKey[self.keySize];
        bzero(cKey, sizeof(cKey));
        [keyData getBytes:cKey length:self.keySize];
        
        // 设置iv
        uint8_t cIv[self.blockSize];
        bzero(cIv, self.blockSize);
        int option = 0;
        if (iv) {
            [iv getBytes:cIv length:self.blockSize];
            option = kCCOptionPKCS7Padding;
        } else {
            option = kCCOptionPKCS7Padding | kCCOptionECBMode;
        }
        
        // 设置输出缓冲区
        NSData *data = [[NSData alloc] initWithBase64EncodedString:string options:0];
        size_t bufferSize = [data length] + self.blockSize;
        void *buffer = malloc(bufferSize);
        
        // 开始解密
        size_t decryptedSize = 0;
        CCCryptorStatus cryptStatus = CCCrypt(kCCDecrypt,
                                              self.algorithm,
                                              option,
                                              cKey,
                                              self.keySize,
                                              cIv,
                                              [data bytes],
                                              [data length],
                                              buffer,
                                              bufferSize,
                                              &decryptedSize);
        
        NSData *result = nil;
        if (cryptStatus == kCCSuccess) {
            result = [NSData dataWithBytesNoCopy:buffer length:decryptedSize];
        } else {
            free(buffer);
            NSLog(@"[错误] 解密失败|状态编码: %d", cryptStatus);
        }
        
        return [[NSString alloc] initWithData:result encoding:NSUTF8StringEncoding];
    }
    
    @end
    

    6.非对称加密

    • 1.非对称加密的特点
      • 1)使用公钥加密,使用私钥解密
      • 2)公钥是公开的,私钥保密
      • 3)加密处理安全,但是性能极差
    • 2.经典算法---RSA
      • 1)RSA 原理
        • (1)求N,准备两个质数p和q,N = p x q
        • (2)求L,L是p-1和q-1的最小公倍数。L = lcm(p-1,q-1)
        • (3)求E,E和L的最大公约数为1(E和L互质)
        • (4)求D,E x D mode L = 1
      • 2)RSA加密小实践
        • (1)p = 17,q = 19 =>N = 323
        • (2)lcm(p-1,q-1)=>lcm(16,18)=>L= 144
        • (3)gcd(E,L)=1 =>E=5
        • (4)E乘以几可以mode L =1? D=29可以满足
        • (5)得到公钥为:E=5,N=323
        • (6)得到私钥为:D=29,N=323
        • (7)加密 明文的E次方 mod N = 123的5次方 mod 323 = 225(密文)
        • (8)解密 密文的D次方 mod N = 225的29次方 mod 323 = 123(明文)
    • 3)openssl生成密钥命令
      • 生成强度是 512 的 RSA 私钥:$ openssl genrsa -out private.pem 512
      • 以明文输出私钥内容:$ openssl rsa -in private.pem -text -out private.txt
      • 校验私钥文件:$ openssl rsa -in private.pem -check
      • 从私钥中提取公钥:$ openssl rsa -in private.pem -out public.pem -outform PEM -pubout
      • 以明文输出公钥内容:$ openssl rsa -in public.pem -out public.txt -pubin -pubout -text
      • 使用公钥加密小文件:$ openssl rsautl -encrypt -pubin -inkey public.pem -in msg.txt -out msg.bin
      • 使用私钥解密小文件:$ openssl rsautl -decrypt -inkey private.pem -in msg.bin -out a.txt
      • 将私钥转换成 DER 格式:$ openssl rsa -in private.pem -out private.der -outform der
      • 将公钥转换成 DER 格式:$ openssl rsa -in public.pem -out public.der -pubin -outform der
    • 4.RSA代码实现

    注意:一下方法也是通过创建工具类实现

    //
    //  RSACryptor.h
    //
    
    #import <Foundation/Foundation.h>
    
    @interface RSACryptor : NSObject
    
    + (instancetype)sharedRSACryptor;
    
    /**
     *  生成密钥对
     *
     *  @param keySize 密钥尺寸,可选数值(512/1024/2048)
     */
    - (void)generateKeyPair:(NSUInteger)keySize;
    
    /**
     *  加载公钥
     *
     *  @param publicKeyPath 公钥路径
     *
     @code
     # 生成证书
     $ openssl genrsa -out ca.key 1024
     # 创建证书请求
     $ openssl req -new -key ca.key -out rsacert.csr
     # 生成证书并签名
     $ openssl x509 -req -days 3650 -in rsacert.csr -signkey ca.key -out rsacert.crt
     # 转换格式
     $ openssl x509 -outform der -in rsacert.crt -out rsacert.der
     @endcode
     */
    - (void)loadPublicKey:(NSString *)publicKeyPath;
    
    /**
     *  加载私钥
     *
     *  @param privateKeyPath p12文件路径
     *  @param password       p12文件密码
     *
     @code
     openssl pkcs12 -export -out p.p12 -inkey ca.key -in rsacert.crt
     @endcode
     */
    - (void)loadPrivateKey:(NSString *)privateKeyPath password:(NSString *)password;
    
    /**
     *  加密数据
     *
     *  @param plainData 明文数据
     *
     *  @return 密文数据
     */
    - (NSData *)encryptData:(NSData *)plainData;
    
    /**
     *  解密数据
     *
     *  @param cipherData 密文数据
     *
     *  @return 明文数据
     */
    - (NSData *)decryptData:(NSData *)cipherData;
    
    @end
    
    
    //
    //  RSACryptor.m
    //
    
    (括号只为调节#格式,请忽略)#import "RSACryptor.h"
    
    // 填充模式 kSecPaddingNone 每次加密结果是固定的,kSecPaddingPKCS1是随机变化的
    (括号只为调节#格式,请忽略)#define kTypeOfWrapPadding       kSecPaddingNone
    
    // 公钥/私钥标签
    (括号只为调节#格式,请忽略)define kPublicKeyTag         "com.wendingding.sample.publickey"
    (括号只为调节#格式,请忽略)define kPrivateKeyTag            "com.wendingding.sample.privatekey"
    
    static const uint8_t publicKeyIdentifier[]      = kPublicKeyTag;
    static const uint8_t privateKeyIdentifier[]     = kPrivateKeyTag;
    
    @interface RSACryptor() {
        SecKeyRef publicKeyRef;                             // 公钥引用
        SecKeyRef privateKeyRef;                            // 私钥引用
    }
    
    @property (nonatomic, retain) NSData *publicTag;        // 公钥标签
    @property (nonatomic, retain) NSData *privateTag;       // 私钥标签
    
    @end
    
    @implementation RSACryptor
    
    + (instancetype)sharedRSACryptor {
        static id instance;
        
        static dispatch_once_t onceToken;
        dispatch_once(&onceToken, ^{
            instance = [[self alloc] init];
        });
        return instance;
    }
    
    - (instancetype)init {
        self = [super init];
        if (self) {
            // 查询密钥的标签
            _privateTag = [[NSData alloc] initWithBytes:privateKeyIdentifier length:sizeof(privateKeyIdentifier)];
            _publicTag = [[NSData alloc] initWithBytes:publicKeyIdentifier length:sizeof(publicKeyIdentifier)];
        }
        return self;
    }
    
    // pragma mark - 加密 & 解密数据
    - (NSData *)encryptData:(NSData *)plainData {
        OSStatus sanityCheck = noErr;
        size_t cipherBufferSize = 0;
        size_t keyBufferSize = 0;
        
        NSAssert(plainData != nil, @"明文数据为空");
        NSAssert(publicKeyRef != nil, @"公钥为空");
        
        NSData *cipher = nil;
        uint8_t *cipherBuffer = NULL;
        
        // 计算缓冲区大小
        cipherBufferSize = SecKeyGetBlockSize(publicKeyRef);
        keyBufferSize = [plainData length];
        
        if (kTypeOfWrapPadding == kSecPaddingNone) {
            NSAssert(keyBufferSize <= cipherBufferSize, @"加密内容太大");
        } else {
            NSAssert(keyBufferSize <= (cipherBufferSize - 11), @"加密内容太大");
        }
        
        // 分配缓冲区
        cipherBuffer = malloc(cipherBufferSize * sizeof(uint8_t));
        memset((void *)cipherBuffer, 0x0, cipherBufferSize);
        
        // 使用公钥加密
        sanityCheck = SecKeyEncrypt(publicKeyRef,
                                    kTypeOfWrapPadding,
                                    (const uint8_t *)[plainData bytes],
                                    keyBufferSize,
                                    cipherBuffer,
                                    &cipherBufferSize
                                    );
        
        NSAssert(sanityCheck == noErr, @"加密错误,OSStatus == %d", sanityCheck);
        
        // 生成密文数据
        cipher = [NSData dataWithBytes:(const void *)cipherBuffer length:(NSUInteger)cipherBufferSize];
        
        if (cipherBuffer) free(cipherBuffer);
        
        return cipher;
    }
    
    - (NSData *)decryptData:(NSData *)cipherData {
        OSStatus sanityCheck = noErr;
        size_t cipherBufferSize = 0;
        size_t keyBufferSize = 0;
        
        NSData *key = nil;
        uint8_t *keyBuffer = NULL;
        
        SecKeyRef privateKey = NULL;
        
        privateKey = [self getPrivateKeyRef];
        NSAssert(privateKey != NULL, @"私钥不存在");
        
        // 计算缓冲区大小
        cipherBufferSize = SecKeyGetBlockSize(privateKey);
        keyBufferSize = [cipherData length];
        
        NSAssert(keyBufferSize <= cipherBufferSize, @"解密内容太大");
        
        // 分配缓冲区
        keyBuffer = malloc(keyBufferSize * sizeof(uint8_t));
        memset((void *)keyBuffer, 0x0, keyBufferSize);
        
        // 使用私钥解密
        sanityCheck = SecKeyDecrypt(privateKey,
                                    kTypeOfWrapPadding,
                                    (const uint8_t *)[cipherData bytes],
                                    cipherBufferSize,
                                    keyBuffer,
                                    &keyBufferSize
                                    );
        
        NSAssert1(sanityCheck == noErr, @"解密错误,OSStatus == %d", sanityCheck);
        
        // 生成明文数据
        key = [NSData dataWithBytes:(const void *)keyBuffer length:(NSUInteger)keyBufferSize];
        
        if (keyBuffer) free(keyBuffer);
        
        return key;
    }
    
    // - 密钥处理
    /**
     *  生成密钥对
     */
    - (void)generateKeyPair:(NSUInteger)keySize {
        OSStatus sanityCheck = noErr;
        publicKeyRef = NULL;
        privateKeyRef = NULL;
        
        NSAssert1((keySize == 512 || keySize == 1024 || keySize == 2048), @"密钥尺寸无效 %tu", keySize);
        
        // 删除当前密钥对
        [self deleteAsymmetricKeys];
        
        // 容器字典
        NSMutableDictionary *privateKeyAttr = [[NSMutableDictionary alloc] init];
        NSMutableDictionary *publicKeyAttr = [[NSMutableDictionary alloc] init];
        NSMutableDictionary *keyPairAttr = [[NSMutableDictionary alloc] init];
        
        // 设置密钥对的顶级字典
        [keyPairAttr setObject:(__bridge id)kSecAttrKeyTypeRSA forKey:(__bridge id)kSecAttrKeyType];
        [keyPairAttr setObject:[NSNumber numberWithUnsignedInteger:keySize] forKey:(__bridge id)kSecAttrKeySizeInBits];
        
        // 设置私钥字典
        [privateKeyAttr setObject:[NSNumber numberWithBool:YES] forKey:(__bridge id)kSecAttrIsPermanent];
        [privateKeyAttr setObject:_privateTag forKey:(__bridge id)kSecAttrApplicationTag];
        
        // 设置公钥字典
        [publicKeyAttr setObject:[NSNumber numberWithBool:YES] forKey:(__bridge id)kSecAttrIsPermanent];
        [publicKeyAttr setObject:_publicTag forKey:(__bridge id)kSecAttrApplicationTag];
        
        // 设置顶级字典属性
        [keyPairAttr setObject:privateKeyAttr forKey:(__bridge id)kSecPrivateKeyAttrs];
        [keyPairAttr setObject:publicKeyAttr forKey:(__bridge id)kSecPublicKeyAttrs];
        
        // SecKeyGeneratePair 返回密钥对引用
        sanityCheck = SecKeyGeneratePair((__bridge CFDictionaryRef)keyPairAttr, &publicKeyRef, &privateKeyRef);
        NSAssert((sanityCheck == noErr && publicKeyRef != NULL && privateKeyRef != NULL), @"生成密钥对失败");
    }
    
    /**
     *  加载公钥
     */
    - (void)loadPublicKey:(NSString *)publicKeyPath {
        
        NSAssert(publicKeyPath.length != 0, @"公钥路径为空");
        
        // 删除当前公钥
        if (publicKeyRef) CFRelease(publicKeyRef);
        
        // 从一个 DER 表示的证书创建一个证书对象
        NSData *certificateData = [NSData dataWithContentsOfFile:publicKeyPath];
        SecCertificateRef certificateRef = SecCertificateCreateWithData(kCFAllocatorDefault, (__bridge CFDataRef)certificateData);
        NSAssert(certificateRef != NULL, @"公钥文件错误");
        
        // 返回一个默认 X509 策略的公钥对象,使用之后需要调用 CFRelease 释放
        SecPolicyRef policyRef = SecPolicyCreateBasicX509();
        // 包含信任管理信息的结构体
        SecTrustRef trustRef;
        
        // 基于证书和策略创建一个信任管理对象
        OSStatus status = SecTrustCreateWithCertificates(certificateRef, policyRef, &trustRef);
        NSAssert(status == errSecSuccess, @"创建信任管理对象失败");
        
        // 信任结果
        SecTrustResultType trustResult;
        // 评估指定证书和策略的信任管理是否有效
        status = SecTrustEvaluate(trustRef, &trustResult);
        NSAssert(status == errSecSuccess, @"信任评估失败");
        
        // 评估之后返回公钥子证书
        publicKeyRef = SecTrustCopyPublicKey(trustRef);
        NSAssert(publicKeyRef != NULL, @"公钥创建失败");
        
        if (certificateRef) CFRelease(certificateRef);
        if (policyRef) CFRelease(policyRef);
        if (trustRef) CFRelease(trustRef);
    }
    
    /**
     *  加载私钥
     */
    - (void)loadPrivateKey:(NSString *)privateKeyPath password:(NSString *)password {
        
        NSAssert(privateKeyPath.length != 0, @"私钥路径为空");
        
        // 删除当前私钥
        if (privateKeyRef) CFRelease(privateKeyRef);
        
        NSData *PKCS12Data = [NSData dataWithContentsOfFile:privateKeyPath];
        CFDataRef inPKCS12Data = (__bridge CFDataRef)PKCS12Data;
        CFStringRef passwordRef = (__bridge CFStringRef)password;
        
        // 从 PKCS #12 证书中提取标示和证书
        SecIdentityRef myIdentity;
        SecTrustRef myTrust;
        const void *keys[] =   {kSecImportExportPassphrase};
        const void *values[] = {passwordRef};
        CFDictionaryRef optionsDictionary = CFDictionaryCreate(NULL, keys, values, 1, NULL, NULL);
        CFArrayRef items = CFArrayCreate(NULL, 0, 0, NULL);
        
        // 返回 PKCS #12 格式数据中的标示和证书
        OSStatus status = SecPKCS12Import(inPKCS12Data, optionsDictionary, &items);
        
        if (status == noErr) {
            CFDictionaryRef myIdentityAndTrust = CFArrayGetValueAtIndex(items, 0);
            myIdentity = (SecIdentityRef)CFDictionaryGetValue(myIdentityAndTrust, kSecImportItemIdentity);
            myTrust = (SecTrustRef)CFDictionaryGetValue(myIdentityAndTrust, kSecImportItemTrust);
        }
        
        if (optionsDictionary) CFRelease(optionsDictionary);
        
        NSAssert(status == noErr, @"提取身份和信任失败");
        
        SecTrustResultType trustResult;
        // 评估指定证书和策略的信任管理是否有效
        status = SecTrustEvaluate(myTrust, &trustResult);
        NSAssert(status == errSecSuccess, @"信任评估失败");
        
        // 提取私钥
        status = SecIdentityCopyPrivateKey(myIdentity, &privateKeyRef);
        NSAssert(status == errSecSuccess, @"私钥创建失败");
    }
    
    /**
     *  删除非对称密钥
     */
    - (void)deleteAsymmetricKeys {
        OSStatus sanityCheck = noErr;
        NSMutableDictionary *queryPublicKey = [[NSMutableDictionary alloc] init];
        NSMutableDictionary *queryPrivateKey = [[NSMutableDictionary alloc] init];
        
        // 设置公钥查询字典
        [queryPublicKey setObject:(__bridge id)kSecClassKey forKey:(__bridge id)kSecClass];
        [queryPublicKey setObject:_publicTag forKey:(__bridge id)kSecAttrApplicationTag];
        [queryPublicKey setObject:(__bridge id)kSecAttrKeyTypeRSA forKey:(__bridge id)kSecAttrKeyType];
        
        // 设置私钥查询字典
        [queryPrivateKey setObject:(__bridge id)kSecClassKey forKey:(__bridge id)kSecClass];
        [queryPrivateKey setObject:_privateTag forKey:(__bridge id)kSecAttrApplicationTag];
        [queryPrivateKey setObject:(__bridge id)kSecAttrKeyTypeRSA forKey:(__bridge id)kSecAttrKeyType];
        
        // 删除私钥
        sanityCheck = SecItemDelete((__bridge CFDictionaryRef)queryPrivateKey);
        NSAssert1((sanityCheck == noErr || sanityCheck == errSecItemNotFound), @"删除私钥错误,OSStatus == %d", sanityCheck);
        
        // 删除公钥
        sanityCheck = SecItemDelete((__bridge CFDictionaryRef)queryPublicKey);
        NSAssert1((sanityCheck == noErr || sanityCheck == errSecItemNotFound), @"删除公钥错误,OSStatus == %d", sanityCheck);
        
        if (publicKeyRef) CFRelease(publicKeyRef);
        if (privateKeyRef) CFRelease(privateKeyRef);
    }
    
    /**
     *  获得私钥引用
     */
    - (SecKeyRef)getPrivateKeyRef {
        OSStatus sanityCheck = noErr;
        SecKeyRef privateKeyReference = NULL;
        
        if (privateKeyRef == NULL) {
            NSMutableDictionary * queryPrivateKey = [[NSMutableDictionary alloc] init];
            
            // 设置私钥查询字典
            [queryPrivateKey setObject:(__bridge id)kSecClassKey forKey:(__bridge id)kSecClass];
            [queryPrivateKey setObject:_privateTag forKey:(__bridge id)kSecAttrApplicationTag];
            [queryPrivateKey setObject:(__bridge id)kSecAttrKeyTypeRSA forKey:(__bridge id)kSecAttrKeyType];
            [queryPrivateKey setObject:[NSNumber numberWithBool:YES] forKey:(__bridge id)kSecReturnRef];
            
            // 获得密钥
            sanityCheck = SecItemCopyMatching((__bridge CFDictionaryRef)queryPrivateKey, (CFTypeRef *)&privateKeyReference);
            
            if (sanityCheck != noErr) {
                privateKeyReference = NULL;
            }
        } else {
            privateKeyReference = privateKeyRef;
        }
        
        return privateKeyReference;
    }
    
    @end
    

    7.数字签名

    • 1.数字签名的应用场景
      • 答:需要严格验证发送方身份信息情况
    • 2.数字签名原理
      • 1)客户端处理
        • ①对"消息"进行 HASH 得到 "消息摘要"
        • ②发送方使用自己的私钥对"消息摘要" 加密(数字签名)
        • ③把数字签名附着在"报文"的末尾一起发送给接收方
      • 2)服务端处理
        • ①对"消息" HASH 得到 "报文摘要"
        • ②使用公钥对"数字签名" 解密
        • ③对结果进行匹配

    8.数字证书

    • 1.简单说明
      证书和驾照很相似,里面记有姓名、组织、地址等个人信息,以及属于此人的公钥,并有认证机构施加数字签名,只要看到公钥证书,我们就可以知道认证机构认证该公钥的确属于此人

    • 2.数字证书的内容

      • 1)公钥
      • 2)认证机构的数字签名
    • 3.证书的生成步骤

      • 1)生成私钥 openssl genrsa -out private.pem 1024
      • 2)创建证书请求 openssl req -new -key private.pem -out rsacert.csr
      • 3)生成证书并签名,有效期10年 openssl x509 -req -days 3650 -in rsacert.csr -signkey private.pem -out rsacert.crt
      • 4)将 PEM 格式文件转换成 DER 格式 openssl x509 -outform der -in rsacert.crt -out rsacert.der
      • 5)导出P12文件 openssl pkcs12 -export -out p.p12 -inkey private.pem -in rsacert.crt
    • 4.iOS开发中的注意点

      • 1)在iOS开发中,不能直接使用 PEM 格式的证书,因为其内部进行了Base64编码,应该使用的是DER的证书,是二进制格式的
      • 2)OpenSSL默认生成的都是PEM格式的证书

    9.HTTPS的基本使用

    • 1.https简单说明

      • HTTPS(全称:Hyper Text Transfer Protocol over Secure Socket Layer),是以安全为目标的HTTP通道,简单讲是HTTP的安全版。
      • 即HTTP下加入SSL层,HTTPS的安全基础是SSL,因此加密的详细内容就需要SSL。 它是一个URI scheme(抽象标识符体系),句法类同http:体系。用于安全的HTTP数据传输。
      • https:URL表明它使用了HTTP,但HTTPS存在不同于HTTP的默认端口及一个加密/身份验证层(在HTTP与TCP之间)。
    • 2.HTTPS和HTTP的区别主要为以下四点:

      • 一、https协议需要到ca申请证书,一般免费证书很少,需要交费。
      • 二、http是超文本传输协议,信息是明文传输,https 则是具有安全性的ssl加密传输协议。
      • 三、http和https使用的是完全不同的连接方式,用的端口也不一样,前者是80,后者是443。
      • 四、http的连接很简单,是无状态的;HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议,比http协议安全。
    • 3.简单说明

      • 1)HTTPS的主要思想是在不安全的网络上创建一安全信道,并可在使用适当的加密包和服务器证书可被验证且可被信任时,对窃听和中间人攻击提供合理的保护。
      • 2)HTTPS的信任继承基于预先安装在浏览器中的证书颁发机构(如VeriSign、Microsoft等)(意即“我信任证书颁发机构告诉我应该信任的”)。
      • 3)因此,一个到某网站的HTTPS连接可被信任,如果服务器搭建自己的https 也就是说采用自认证的方式来建立https信道,这样一般在客户端是不被信任的。
      • 4)所以我们一般在浏览器访问一些https站点的时候会有一个提示,问你是否继续。
    • 4.对开发的影响。

      • 4.1 如果是自己使用NSURLSession来封装网络请求,涉及代码如下。
    - (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event
    {
        NSURLSession *session = [NSURLSession sessionWithConfiguration:[NSURLSessionConfiguration defaultSessionConfiguration] delegate:self delegateQueue:[NSOperationQueue mainQueue]];
    
        NSURLSessionDataTask *task =  [session dataTaskWithURL:[NSURL URLWithString:@"https://www.apple.com"] completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
            NSLog(@"%@", [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding]);
        }];
        [task resume];
    }
    
    
    只要请求的地址是HTTPS的, 就会调用这个代理方法
    我们需要在该方法中告诉系统, 是否信任服务器返回的证书
    Challenge: 挑战 质问 (包含了受保护的区域)
    protectionSpace : 受保护区域
    NSURLAuthenticationMethodServerTrust : 证书的类型是 服务器信任
    */
    - (void)URLSession:(NSURLSession *)session didReceiveChallenge:(NSURLAuthenticationChallenge *)challenge completionHandler:(void (^)(NSURLSessionAuthChallengeDisposition, NSURLCredential *))completionHandler
    {
        //    NSLog(@"didReceiveChallenge %@", challenge.protectionSpace);
        NSLog(@"调用了最外层");
        // 1.判断服务器返回的证书类型, 是否是服务器信任
        if ([challenge.protectionSpace.authenticationMethod isEqualToString:NSURLAuthenticationMethodServerTrust]) {
            NSLog(@"调用了里面这一层是服务器信任的证书");
            /*
            NSURLSessionAuthChallengeUseCredential = 0,                    使用证书
            NSURLSessionAuthChallengePerformDefaultHandling = 1,            忽略证书(默认的处理方式)
            NSURLSessionAuthChallengeCancelAuthenticationChallenge = 2,    忽略书证, 并取消这次请求
            NSURLSessionAuthChallengeRejectProtectionSpace = 3,            拒绝当前这一次, 下一次再询问
            */
    //        NSURLCredential *credential = [NSURLCredential credentialForTrust:challenge.protectionSpace.serverTrust];
    
            NSURLCredential *card = [[NSURLCredential alloc]initWithTrust:challenge.protectionSpace.serverTrust];
            completionHandler(NSURLSessionAuthChallengeUseCredential , card);
        }
    }
    
    • 5.ATS
      • 1)iOS9中新增App Transport Security(简称ATS)特性, 让原来请求时候用到的HTTP,全部都转向TLS1.2协议进行传输。
      • 2)这意味着所有的HTTP协议都强制使用了HTTPS协议进行传输。
      • 3)如果我们在iOS9下直接进行HTTP请求是会报错。系统会告诉我们不能直接使用HTTP进行请求,需要在Info.plist中控制ATS的配置。
        "NSAppTransportSecurity"是ATS配置的根节点,配置了节点表示告诉系统要走自定义的ATS设置。
        "NSAllowsAritraryLoads"节点控制是否禁用ATS特性,设置YES就是禁用ATS功能。
      • 4)有两种解决方法,一种是修改配置信息继续使用以前的设置。
        另一种解决方法是所有的请求都基于基于"TLS 1.2"版本协议。(该方法需要严格遵守官方的规定,如选用的加密算法、证书等)
    • 6.ATS默认的条件
      • 1)服务器TLS版本至少是1.2版本
      • 2)连接加密只允许几种先进的加密
      • 3)证书必须使用SHA256或者更好的哈希算法进行签名,要么是2048位或者更长的RSA密钥,要么就是256位或更长的ECC密钥。
    • AFSecurityPolicy,内部有三个重要的属性,如下:

      • AFSSLPinningMode SSLPinningMode; //该属性标明了AFSecurityPolicy是以何种方式来验证
      • BOOL allowInvalidCertificates; //是否允许不信任的证书通过验证,默认为NO
      • BOOL validatesDomainName; //是否验证主机名,默认为YES
    • "AFSSLPinningMode"枚举类型有三个值,分别是AFSSLPinningModeNone、AFSSLPinningModePublicKey、AFSSLPinningModeCertificate。

    • "AFSSLPinningModeNone"代表了AFSecurityPolicy不做更严格的验证,"只要是系统信任的证书"就可以通过验证,不过,它受到allowInvalidCertificates和validatesDomainName的影响;

    • "AFSSLPinningModePublicKey"是通过"比较证书当中公钥(PublicKey)部分"来进行验证,通过SecTrustCopyPublicKey方法获取本地证书和服务器证书,然后进行比较,如果有一个相同,则通过验证,此方式主要适用于自建证书搭建的HTTPS服务器和需要较高安全要求的验证;

    • "AFSSLPinningModeCertificate"则是直接将本地的证书设置为信任的根证书,然后来进行判断,并且比较本地证书的内容和服务器证书内容是否相同,来进行二次判断,此方式适用于较高安全要求的验证。

    • 如果HTTPS服务器满足ATS默认的条件,而且SSL证书是通过权威的CA机构认证过的,那么什么都不用做。如果上面的条件中有任何一个不成立,那么都只能修改ATS配置。

    相关文章

      网友评论

      • Buger123:AES加密,256位秘钥长度的加密方式,密钥长度怎么设置?
      • 不辣先生:我用rsa+aes 在本地能行德通,服务器解不出来?
      • 257f312dccb8:谢谢。如果有源码链接就更好了!
      • 简晰333:有DEMo吗?求具体使用代码
      • 5b3d4ba49ad5:我用非对称加密,用公钥加密,总是提示这个error:

        Terminating app due to uncaught exception 'NSInternalInconsistencyException', reason: '公钥创建失败'

        怎么回事儿啊
      • skyz1126:记得不错

      本文标题:iOS开发加密实现-Base64,MD5,SHA1,ECB,BC

      本文链接:https://www.haomeiwen.com/subject/cxivrttx.html