Alamofire-安全策略

时间 2019-11-17

原文原文链接

在web服务器和服务器通讯的时候，使用https链接是很是重要的，可以对数据加密传输、身份认证。https协议须要到ca申请证书，部署到服务器，应用端链接都是对该连接受信任的。证书可申请也能够自签，自签证书须要客户端验证经过才能访问。php

1、HTTP协议

HTTP是互联网的基础协议，默认端口80，为知足应用需求HTTP也在不断的版本升级改进，从0.9版本到1.1版本功能不断的强大起来。HTTP演变可参考：www.ruanyifeng.com/blog/2016/0…html

HTTP的特色：nginx

HTTP客户端请求只须要肯定请求方法和路径。经常使用方法有GET、POST、HEAD，因为对参数封装形式不同，通常获取数据使用GET，上传数据使用POST，GET参数暴露在连接中，POST则封装在请求体中
使用灵活，可传输任意类型的数据，经过Content-Type标记传输的数据类型
HTTP协议是无状态协议，对处理过的事务无记忆能力，为了客户端服务端更好的交互，引用了Cookie和Session来存储请求中产生的状态

工做流程：web

不须要任何处理，客户端要服务端就给。swift

2、HTTPS协议

HTTPS协议为超文本传输安全协议，默认端口443，HTTPS=HTTP+SSL，对数据进行加密，保护数据在交互时不被窃取，提升了对服务器恶意攻击及数据假装的成本。使用该协议要求服务器申请证书并配置协议环境。api

HTTPS的工做流程：安全

http、https请求都须要创建TCP三次握手链接，略《Socket》
ca颁发的证书加密为非对称加密，公钥加密，私钥解密，私钥加密，公钥解密。加密原理参考《RSA加密》

须要申请证书，绑定域名，服务器中配置证书。通常我的会使用阿里的免费证书，虽然加密性通常，至少证书是受信任的。也能够本身建立证书，自建证书可使用，但不会被信任，既然有免费的咱们就走正规路线😁。bash

分别发起http和https请求：服务器

www.yahibo.top www.yahibo.top网络

经过Charles抓包观察数据以下：

未加密请求直接抓取服务器响应的全部数据
加密请求抓取到的是未知数据

固然开启SSL代理仍是能够抓到的：

所以在作APP的时候，为了防止APP被抓包，咱们须要作反代理设置抓包，判断应用代理设置或证书验证。

3、HTTP和HTTPS主要区别

HTTPS协议须要到ca申请证书，我的颁发证书是不受信任的；
HTTP是超文本传输协议，明文传输，HTTPS则是在HTTP上加了一层SSL（安全套接层），对数据加密传输；
HTTP在服务器上的默认端为80，HTTPS为443端口；
HTTP链接是无状态的，HTTPS协议等价于HTTP+SSL/TLS，可进行加密传输、身份认证的网络协议。

二者的优缺点很明显，HTTP不存在加密，明文传输，不安全，但传输速度快，HTTPS密文传输，传输中须要肯定应用端和服务端的保密性和数据完整性。

证书长什么样？

在ca申请的证书，包括两个文件.key文件和.pem文件，通常在nginx配置文件中配置便可。.key是证书的私钥文件，.pem为证书文件。

4、安全策略

一、ServerTrustPolicyManager

在初始化SessionManager中能够看到，有一个初始化类型设置了ServerTrustPolicyManager类对象，该对象就是安全策略的管理者。在实际开发中，APP可能会用到不一样的主机地址host，根据业务不一样须要要给不一样的host设置不一样的安全策略。所以管理者的实现以下：

open class ServerTrustPolicyManager {
    public let policies: [String: ServerTrustPolicy]
    public init(policies: [String: ServerTrustPolicy]) {
        self.policies = policies
    }
    open func serverTrustPolicy(forHost host: String) -> ServerTrustPolicy? {
        return policies[host]
    }
}
复制代码

初始化了一个policies字典，key为host，值为选择的响应的策略
初始化方法中设置安全策略及ServerTrustPolicy
经过serverTrustPolicy方法经过host获取ServerTrustPolicy对象

不要问为何分离一个manager来管理ServerTrustPolicy，不直接使用，由于这是大厂分工要明确，责任到每一层。

一、ServerTrustPolicy

ServerTrustPolicy是一个枚举类：

public enum ServerTrustPolicy {
    case performDefaultEvaluation(validateHost: Bool)
    case performRevokedEvaluation(validateHost: Bool, revocationFlags: CFOptionFlags)
    case pinCertificates(certificates: [SecCertificate], validateCertificateChain: Bool, validateHost: Bool)
    case pinPublicKeys(publicKeys: [SecKey], validateCertificateChain: Bool, validateHost: Bool)
    case disableEvaluation
    case customEvaluation((_ serverTrust: SecTrust, _ host: String) -> Bool)
     //代码省略若干
}
复制代码

以上是类型关联，根据不一样类型作处理。

performDefaultEvaluation默认策略类型，始终验证主机证书的有效性
performRevokedEvaluation对吊销过的证书作设置
pinCertificates验证服务器返回的证书的正确性，参数决定是否验证证书链
pinPublicKeys公钥验证
disableEvaluation无需验证，无条件信任
customEvaluation自定义验证，返回一个布尔值

以上方法在项目中并无默认配置，须要咱们配置使用，常常会选择证书验证、公钥验证、不作验证模式。具体设置根据须要选择。

二、发起请求

实践出真知，咱们发送一个https请求看看效果。

let url = "https://www.yahibo.top/project/public/index.php?s=api/test/list"
sessionManager.request(url).response {
    (response) in
    print(response)
}
复制代码

运行以下：

运行一切正常，可以请求到数据，好像也没什么区别，其实上面已经作了数据传输的说明了加密验证。下面看一下抓包，开启Charles，从新发送请求。

http请求一切正常。

https请求运行结果以下：

http可以正常请求，https确报错，这个好像是咱们想要的结果，都尚未配置相关信息😂。在AF中便是https在抓包状态下也是能够获取数据的，而Alamofire好像作了更多的处理，直接避免抓包。

该安全策略其实对自签证书作的验证，既然个人证书是合法的被承认的就不作配置了😂。若是是自签证书须要对域名或证书作验证以下设置：

let policies: [String: ServerTrustPolicy] = [
    "www.yahibo.top": .disableEvaluation
]
let sessionManager = SessionManager(serverTrustPolicyManager: ServerTrustPolicyManager(policies: policies))
return sessionManager
复制代码

不作验证，或者作以上提到的策略

我觉得的被验证错误，打脸😂。后续补充自签证书验证，肯定是否可以经过请求。这是一个失败的实践，不过仍是有收获的。

……

5、网络监测

分别看一下AF和Alamofire的实现。

AFNetworking-AFNetworkReachabilityManager

枚举类型，肯定网络状态：

typedef NS_ENUM(NSInteger, AFNetworkReachabilityStatus) {
    AFNetworkReachabilityStatusUnknown          = -1,
    AFNetworkReachabilityStatusNotReachable     = 0,
    AFNetworkReachabilityStatusReachableViaWWAN = 1,
    AFNetworkReachabilityStatusReachableViaWiFi = 2,
};
复制代码

未链接网络、不可用网络、蜂窝网络、WiFi网络

[[AFNetworkReachabilityManager sharedManager] setReachabilityStatusChangeBlock:^(AFNetworkReachabilityStatus status){
    [weakSelf setNetworkStates:status];
    switch (status) {
        case AFNetworkReachabilityStatusUnknown:
            NSLog(@"未知网络");
            break;
        case AFNetworkReachabilityStatusNotReachable:
            NSLog(@"这是一个不可达网络");
            break;
        case AFNetworkReachabilityStatusReachableViaWWAN:
            NSLog(@"这是一个蜂窝网络");
            break;
        case AFNetworkReachabilityStatusReachableViaWiFi:
            NSLog(@"这是一个WiFi网络");
            break;
        default:
            break;
    }
}];
[[AFNetworkReachabilityManager sharedManager] startMonitoring];
复制代码

网络监测无非就是以上几个状态，设置回调代码块，具体监测行为由AFNetworkReachabilityManager完成。这里就简单看一下，下面看一下Alamofire的网络监测，其实都是同样的调用的底层api不变。

Alamofire-NetworkReachabilityManager

一样提供了这么一个类，来管理网络监测任务。对框架的学习，最大的收获就是可以更快一些的对源码作分析，快速使用框架。

具体使用

枚举类型：

public enum NetworkReachabilityStatus {
    case unknown
    case notReachable
    case reachable(ConnectionType)
}

public enum ConnectionType {
    case ethernetOrWiFi
    case wwan
}
复制代码

使用：

let networkManager = NetworkReachabilityManager(host: "www.yahibo.top")
networkManager?.listener = { status in
    switch status {
    case .unknown:
        print("未知网络")
        break
    case .notReachable:
        print("这是一个不可达网络")
        break
    case .reachable(.ethernetOrWiFi):
        print("这是一个WiFi网络")
        break
    case .reachable(.wwan):
        print("这是一个蜂窝网络")
        break
}
networkManager?.startListening()
复制代码

注意对象须要声明为全局，在做用域中声明会被销毁

大同小异，编码方式变的更简洁了，这也符合swift的编码风格。以上能够看出在Alamofire中的网络监测将WiFi网络和蜂窝网络归为一类。下面看一下源码。

一、属性

1️⃣、声明一个闭包，在外部实现呢，网络变化时掉用闭包传值

public typealias Listener = (NetworkReachabilityStatus) -> Void
复制代码

2️⃣、网络是否可达，包括蜂窝和WiFi网络

open var isReachable: Bool { return isReachableOnWWAN || isReachableOnEthernetOrWiFi }
复制代码

3️⃣、蜂窝网络是否为可达的

open var isReachableOnWWAN: Bool { return networkReachabilityStatus == .reachable(.wwan) }
复制代码

4️⃣、经过WiFi链接网络

open var isReachableOnEthernetOrWiFi: Bool { return networkReachabilityStatus == .reachable(.ethernetOrWiFi) }
复制代码

5️⃣、获取网络类型

open var networkReachabilityStatus: NetworkReachabilityStatus {
        guard let flags = self.flags else { return .unknown }
        return networkReachabilityStatusForFlags(flags)
}
复制代码

6️⃣、设置监听闭包在哪一个队列中调用你，默认给主队列

open var listenerQueue: DispatchQueue = DispatchQueue.main
复制代码

7️⃣、定一个闭包类型的监听属性

open var listener: Listener?
复制代码

初始化

public convenience init?(host: String) {
    guard let reachability = SCNetworkReachabilityCreateWithName(nil, host) else { return nil }
    self.init(reachability: reachability)
}
复制代码

传入服务器域名或ip，传入其余只要不为空也是能够获取到网络类型，仍是设置为咱们经常使用的服务地址比较好
调用了系统方法来初始化一个网络监测对象，和AF中是同样的
返回一个SCNetworkReachability对象，网络地址或名称的句柄 SCNetworkReachabilityRef

官方文档

该对象能够肯定当前主机的网络状态和目标地址的可达性，提供同步或异步接口，获取当前的网络状态。以上初始化有调用了一个init初始化方法：

private init(reachability: SCNetworkReachability) {
    self.reachability = reachability
    // Set the previous flags to an unreserved value to represent unknown status
    self.previousFlags = SCNetworkReachabilityFlags(rawValue: 1 << 30)
}
复制代码

存储对象，并获取网络可达标识
到此好像就已经初始化完成

二、启动监听网络

networkManager?.startListening()
内部实现：
open func startListening() -> Bool {
    var context = SCNetworkReachabilityContext(version: 0, info: nil, retain: nil, release: nil, copyDescription: nil)
    context.info = Unmanaged.passUnretained(self).toOpaque()
    let callbackEnabled = SCNetworkReachabilitySetCallback(
        reachability,
        { (_, flags, info) in
            let reachability = Unmanaged<NetworkReachabilityManager>.fromOpaque(info!).takeUnretainedValue()
            reachability.notifyListener(flags)
        },
        &context
    )
    let queueEnabled = SCNetworkReachabilitySetDispatchQueue(reachability, listenerQueue)
    listenerQueue.async {
        guard let flags = self.flags else { return }
        self.notifyListener(flags)
    }
    return callbackEnabled && queueEnabled
}
复制代码

SCNetworkReachabilitySetCallback监听网络状态的变化，发生改变即调用该回调方法
listenerQueue在开启监听是调用一次
经过notifyListener通知Listener闭包
将任务添加在主线程中向外回调

func notifyListener(_ flags: SCNetworkReachabilityFlags) {
    guard previousFlags != flags else { return }
    previousFlags = flags
    listener?(networkReachabilityStatusForFlags(flags))
}
复制代码

先判断网络状态是否改变，若是没有变化不通知，有变化记录先前的网络flags
经过listener闭包向外传递当前的网络状态

func networkReachabilityStatusForFlags(_ flags: SCNetworkReachabilityFlags) -> NetworkReachabilityStatus {
    guard isNetworkReachable(with: flags) else { return .notReachable }
    var networkStatus: NetworkReachabilityStatus = .reachable(.ethernetOrWiFi)
#if os(iOS)
    if flags.contains(.isWWAN) { networkStatus = .reachable(.wwan) }
#endif
    return networkStatus
}
复制代码

经过flags来获取当前的网络状态，首先看网络是否为可达网络
经过系统属性对网络状态归类

func isNetworkReachable(with flags: SCNetworkReachabilityFlags) -> Bool {
    let isReachable = flags.contains(.reachable)
    let needsConnection = flags.contains(.connectionRequired)
    let canConnectAutomatically = flags.contains(.connectionOnDemand) || flags.contains(.connectionOnTraffic)
    let canConnectWithoutUserInteraction = canConnectAutomatically && !flags.contains(.interventionRequired)
    return isReachable && (!needsConnection || canConnectWithoutUserInteraction)
}
复制代码

经过属性组合来肯定网络是否可达

三、关闭网络监听

当结束后执行deinit方法来调用stopListening方法：

open func stopListening() {
    SCNetworkReachabilitySetCallback(reachability, nil, nil)
    SCNetworkReachabilitySetDispatchQueue(reachability, nil)
}
复制代码

将回调置空，队列置空便可

其实网络监测并不复杂，只是对系统网络监测类的一个封装，设置枚举对网络状态归类，经过listener闭包向外发送网络监测数据。使用只须要初始化设置主机地址，而后开启监听便可。所谓的监听就是实现对网络状态监听的回调闭包，是框架和系统底层网络层的消息传递。

学习原理及对底层源码探索是颇有必要的，可以帮助咱们快速开发，快速的解决问题。加油⛽️