AFNetWorking 源码学习笔记 ☞ Security

AFNetWorking 源码学习笔记.png

前言

本文是 AFNetWorking 源码学习笔记的第三篇,本篇将介绍第二部分 – Security 目录下的类,其实只有一个就是 AFSecurityPolicy。

AFNetWorking-Security.png

正文

依照惯例,先从声明文件开始,打开 AFSecurityPolicy.h 文件,我们发现内容非常少,只有 4 个属性和 5 个方法。

首先来看看这几个属性,各自的作用见代码注释。

1
2
3
4
5
6
7
8
9
10
11
// 根据 SSL 证书验证 server trust 的标准,默认为不验证。
@property (readonly, nonatomic, assign) AFSSLPinningMode SSLPinningMode;

// 根据 SSL pinning mode 验证 server trust 的证书
@property (nonatomic, strong, nullable) NSSet <NSData *> *pinnedCertificates;

// 是否允许无效或已经过期的 SSL 证书。
@property (nonatomic, assign) BOOL allowInvalidCertificates;

// 是否验证证书中的域名,默认为 YES。
@property (nonatomic, assign) BOOL validatesDomainName;

然后再来看看它提供的 5 个代理方法,

1
+ (NSSet <NSData *> *)certificatesInBundle:(NSBundle *)bundle;

此类方法的作用是获取 Bundle 中的所有证书文件(xxx.cer)存放在 set 里边。

1
2
3
+ (instancetype)defaultPolicy;
+ (instancetype)policyWithPinningMode:(AFSSLPinningMode)pinningMode;
+ (instancetype)policyWithPinningMode:(AFSSLPinningMode)pinningMode withPinnedCertificates:(NSSet *)pinnedCertificates;

这 3 个方法都在创建 AFSecurityPolicy 对象,第一个默认将属性 SSLPinningMode 设置为 AFSSLPinningModeNone,即不做验证;第二个可以指定 SSLPinningMode,最后一个还可以指定 pinnedCertificates。

下边这个实例方法负责基于当前安全策略评估传入的 serverTrust 是否可以接受,也就是我们在上一篇中接受认证挑战时掉那个的方法。

1
2
- (BOOL)evaluateServerTrust:(SecTrustRef)serverTrust
forDomain:(nullable NSString *)domain;

接下来,我们看看 .m 文件,这里就只介绍其中的两个主要方法实现。第一个是 - (void)setPinnedCertificates:(NSSet *)pinnedCertificates,这里不仅给 _pinnedCertificates 赋值,而且取出了所有证书中的公钥(public key),存放到集合 self.pinnedPublicKeys 里边。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
- (void)setPinnedCertificates:(NSSet *)pinnedCertificates {
// 1.给 _pinnedCertificates 赋值
_pinnedCertificates = pinnedCertificates;

// 2.给 self.pinnedPublicKeys 赋值,值是从 Certificates 中提取的 publicKeys
if (self.pinnedCertificates) {

NSMutableSet *mutablePinnedPublicKeys = [NSMutableSet setWithCapacity:[self.pinnedCertificates count]];
for (NSData *certificate in self.pinnedCertificates) {
id publicKey = AFPublicKeyForCertificate(certificate);
if (!publicKey) {
continue;
}
[mutablePinnedPublicKeys addObject:publicKey];
}
self.pinnedPublicKeys = [NSSet setWithSet:mutablePinnedPublicKeys];
} else {
self.pinnedPublicKeys = nil;
}
}

提取 Certificate 中的 public key 时,利用了 AFPublicKeyForCertificate() 这个静态函数,下面来看看它的具体实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
static id AFPublicKeyForCertificate(NSData *certificate) {
// 1.初始化会用到的局部变量
id allowedPublicKey = nil;
SecCertificateRef allowedCertificate;
SecPolicyRef policy = nil;
SecTrustRef allowedTrust = nil;
SecTrustResultType result;

// 2.提取公钥
// ① 根据传入的二进制证书数据生成一个 SecCertificateRef 类型的证书,并验证结果
allowedCertificate = SecCertificateCreateWithData(NULL, (__bridge CFDataRef)certificate);
__Require_Quiet(allowedCertificate != NULL, _out);

// ② 生成一个默认 X.509 policy 的实例
policy = SecPolicyCreateBasicX509();

// ③ 基于证书 (allowedCertificate) 和安全策略 (policy) 创建一个信任管理对象 (a trust management object)
__Require_noErr_Quiet(SecTrustCreateWithCertificates(allowedCertificate, policy, &allowedTrust), _out);
// ④ 利用步骤 ③ 创建的 allowedTrust 校验证书,并将结果写入 result,不过后边好像没有用到它
__Require_noErr_Quiet(SecTrustEvaluate(allowedTrust, &result), _out);

// ⑤ 验证通过后,从 allowedTrust 中获取公钥
allowedPublicKey = (__bridge_transfer id)SecTrustCopyPublicKey(allowedTrust);

_out:
// 3.释放内存
if (allowedTrust) {
CFRelease(allowedTrust);
}

if (policy) {
CFRelease(policy);
}

if (allowedCertificate) {
CFRelease(allowedCertificate);
}

return allowedPublicKey;
}

从上边的代码中我们发现,重点在第 2 步获取公钥的代码,具体内容建代码注释,这里就不啰嗦了。其中用到了系统提供的 2 个宏:__Require_Quiet__Require_noErr_Quiet,下边来看看他们的定义:

1
2
3
4
5
6
7
8
9
10
#ifndef __Require_Quiet
#define __Require_Quiet(assertion, exceptionLabel) \
do \
{ \
if ( __builtin_expect(!(assertion), 0) ) \
{ \
goto exceptionLabel; \
} \
} while ( 0 )
#endif
1
2
3
4
5
6
7
8
9
10
#ifndef __Require_noErr_Quiet
#define __Require_noErr_Quiet(errorCode, exceptionLabel) \
do \
{ \
if ( __builtin_expect(0 != (errorCode), 0) ) \
{ \
goto exceptionLabel; \
} \
} while ( 0 )
#endif

从定义可以看出,对于 Require_Quiet,当入参 assertion 为空的时候,会跳转到 exceptionLabel 所在位置去继续执行;而 Require_noErr_Quiet,是当入参 errorCode != 0 即出错的时候会跳转至 exceptionLabel 所在行继续执行。

核心方法

下边我们来看看 上一篇 提到过的方法 evaluateServerTrust: forDomain:,该方法是 AFNetWorking 自己提前做的一次 HTTPS 认证,用于验证服务器是否合法,如果验证不通过就不再继续调用系统方法验证了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
- (BOOL)evaluateServerTrust:(SecTrustRef)serverTrust
forDomain:(NSString *)domain
{
// 1.过滤
// 域名存在 && 允许自签名证书 && 需要验证域名 && (要求不做验证 || 没有证书)
if (domain && self.allowInvalidCertificates && self.validatesDomainName && (self.SSLPinningMode == AFSSLPinningModeNone || [self.pinnedCertificates count] == 0)) {
NSLog(@"In order to validate a domain name for self signed certificates, you MUST use pinning.");
return NO;
}

// 2.准备安全策略,并将其设置到 serverTrust 里边,以备后边验证使用
NSMutableArray *policies = [NSMutableArray array];
if (self.validatesDomainName) {
[policies addObject:(__bridge_transfer id)SecPolicyCreateSSL(true, (__bridge CFStringRef)domain)];
} else {
[policies addObject:(__bridge_transfer id)SecPolicyCreateBasicX509()];
}

// Sets the policies to use in an evaluation.
SecTrustSetPolicies(serverTrust, (__bridge CFArrayRef)policies);

// 3.再次过滤
if (self.SSLPinningMode == AFSSLPinningModeNone) {
// 不验证的情况下
// 如果允许自签名证书或者 serverTrust 验证成功时,返回 YES
return self.allowInvalidCertificates || AFServerTrustIsValid(serverTrust);
} else if (!AFServerTrustIsValid(serverTrust) && !self.allowInvalidCertificates) {
// 如果 serverTrust 验证失败 && 不允许自签名证书,则返回 NO
return NO;
}

// 4.验证
switch (self.SSLPinningMode) {
case AFSSLPinningModeNone:
/**
* 1.不验证
*
* 但 紧上边的那个 if-else 语句已经处理了 AFSSLPinningModeNone 的情况,这里还做这个判断有意义吗?难道是是为了看起来完整。
*/
default:
return NO;
case AFSSLPinningModeCertificate: {

/**
* 2.验证证书
*
* 从serverTrust中去获取证书链,然后和我们一开始初始化设置的证书集合self.pinnedCertificates去匹配,如果有一对能匹配成功的,就返回YES,否则NO。
*/
NSMutableArray *pinnedCertificates = [NSMutableArray array];
for (NSData *certificateData in self.pinnedCertificates) {
[pinnedCertificates addObject:(__bridge_transfer id)SecCertificateCreateWithData(NULL, (__bridge CFDataRef)certificateData)];
}
SecTrustSetAnchorCertificates(serverTrust, (__bridge CFArrayRef)pinnedCertificates);

if (!AFServerTrustIsValid(serverTrust)) {
return NO;
}

// obtain the chain after being validated, which *should* contain the pinned certificate in the last position (if it's the Root CA)
NSArray *serverCertificates = AFCertificateTrustChainForServerTrust(serverTrust);

for (NSData *trustChainCertificate in [serverCertificates reverseObjectEnumerator]) {
if ([self.pinnedCertificates containsObject:trustChainCertificate]) {
return YES;
}
}

return NO;
}
case AFSSLPinningModePublicKey: {

/**
* 3.验证公钥
*
* 从serverTrust,获取证书链每一个证书的公钥,放到数组中。和我们的self.pinnedPublicKeys,去配对,如果有一个相同的,就返回YES,否则NO。
*/
NSUInteger trustedPublicKeyCount = 0;
NSArray *publicKeys = AFPublicKeyTrustChainForServerTrust(serverTrust);

for (id trustChainPublicKey in publicKeys) {
for (id pinnedPublicKey in self.pinnedPublicKeys) {
if (AFSecKeyIsEqualToKey((__bridge SecKeyRef)trustChainPublicKey, (__bridge SecKeyRef)pinnedPublicKey)) {
trustedPublicKeyCount += 1;
}
}
}
return trustedPublicKeyCount > 0;
}
}

return NO;
}

代码稍微有点长,不过主要做了这些事:

  • 过滤一些特殊情况:域名存在 && 允许自签名证书 && 需要验证域名 && (要求不做验证 || 没有证书);
  • 准备安全策略,并将其设置到 serverTrust 里边,以备后边验证使用;
  • 再次过滤:不验证、serverTrust 验证失败 && 不允许自签名证书 的情况;
  • 开始验证,根据 self.SSLPinningMode 分成了几种情况分别验证:
    • 1.不验证
    • 2.验证证书
    • 3.验证公钥

这一步的验证中又用到了几个静态函数,下边来简单看一下。

  • 验证serverTrust 是否有效,调用了系统方法 SecTrustEvaluate() 进行校验。
1
2
3
4
5
6
7
8
9
10
11
static BOOL AFServerTrustIsValid(SecTrustRef serverTrust) {
BOOL isValid = NO;
SecTrustResultType result;
__Require_noErr_Quiet(SecTrustEvaluate(serverTrust, &result), _out);

// 只有当 "用户未指定验证的策略,即使用系统提供的默认策略" 或者 "要求永远信任" 的时候,才会返回 YES,其他时候都是 NO
isValid = (result == kSecTrustResultUnspecified || result == kSecTrustResultProceed);

_out:
return isValid;
}
  • 取出 serverTrust 里边的所有证书,将其二进制文件组成的数组返回。
1
2
3
4
5
6
7
8
9
10
11
static NSArray * AFCertificateTrustChainForServerTrust(SecTrustRef serverTrust) {
CFIndex certificateCount = SecTrustGetCertificateCount(serverTrust);
NSMutableArray *trustChain = [NSMutableArray arrayWithCapacity:(NSUInteger)certificateCount];

for (CFIndex i = 0; i < certificateCount; i++) {
SecCertificateRef certificate = SecTrustGetCertificateAtIndex(serverTrust, i);
[trustChain addObject:(__bridge_transfer NSData *)SecCertificateCopyData(certificate)];
}

return [NSArray arrayWithArray:trustChain];
}
  • 取出 serverTrust 里边的所有证书,然后遍历证书取出其中的 public key,将公钥组成的数组返回。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
static NSArray * AFPublicKeyTrustChainForServerTrust(SecTrustRef serverTrust) {
SecPolicyRef policy = SecPolicyCreateBasicX509();
CFIndex certificateCount = SecTrustGetCertificateCount(serverTrust);
NSMutableArray *trustChain = [NSMutableArray arrayWithCapacity:(NSUInteger)certificateCount];
for (CFIndex i = 0; i < certificateCount; i++) {
SecCertificateRef certificate = SecTrustGetCertificateAtIndex(serverTrust, i);

SecCertificateRef someCertificates[] = {certificate};
CFArrayRef certificates = CFArrayCreate(NULL, (const void **)someCertificates, 1, NULL);

SecTrustRef trust;
__Require_noErr_Quiet(SecTrustCreateWithCertificates(certificates, policy, &trust), _out);

SecTrustResultType result;
__Require_noErr_Quiet(SecTrustEvaluate(trust, &result), _out);

[trustChain addObject:(__bridge_transfer id)SecTrustCopyPublicKey(trust)];

_out:
if (trust) {
CFRelease(trust);
}

if (certificates) {
CFRelease(certificates);
}

continue;
}
CFRelease(policy);

return [NSArray arrayWithArray:trustChain];
}

小结

以上就是安全验证过程中会使用到的类 AFSecurityPolicy 中的主要内容,其他部分本文暂不做过多讨论,以后有时间再更新吧。

0%