Swift开发

Alamofire 安全认证ServerTrustPolicy

2019-08-28  本文已影响0人  盾子

前言

在互联网迅速发展的年代，基本上天天都在跟网络打交道。那么，在网络的通讯中怎么保证信息的安全性呢？这篇文章，我们就来讲讲，Alamofire作为iOS开发中一个非常优秀的网络请求相关的第三方库，它的安全策略是怎么设计和使用的。

HTTPS简介

在切入正题之前，先来简单的了解一下HTTPS相关知识，方便对后面内容的理解。如果你已经了解了，可以直接跳过这一段。

为什么使用HTTPS

在以前，我们用的更多的是HTTP，那么是什么原因苹果公司也主推我们使用HTTPS这个更安全请求方式的呢？HTTP存在的问题：

  1. 通讯使用明文，内容容易被窃听
  2. 不验证通讯双方的身份，容易被伪装
  3. 无法验证数据完整性，可能会被篡改数据

使用 HTTPS 通信机制可以有效地防止这些问题。HTTPS 并非是应用层的一种新协议，只是HTTP通信接口部分用 SSL 和 TLS 协议代替而已。通常 HTTP 直接跟 TCP 通信，当使用 SSL 时，则变成先和 SSL 通信，再由 SSL 和 TCP 通信了。简言之，HTTPS 就是身披 SSL 协议这层外壳的 HTTP。

HTTP+数据加密+身份认证+数据完整性保护=HTTPS

HTTPS加密方式

HTTPS 采用混合加密机制，就是共享秘钥加密(对称加密)和公开密钥加密(非对称加密)两者并用的混合加密机制。在交换密钥环节使用公开密钥加密的方式，之后建立通讯交换报文阶段则使用共享密钥加密。公开密钥加密比共享密钥加密更加安全，那为什么不全用公开密钥加密？因为与共享秘钥加密相比，处理起来更复杂、处理速度慢。HTTPS结合了两种加密方式的优劣来实现一种混合加密的流程。如图所示：

HTTPS验证和加密流程

HTTPS有单向认证和双向认证，原理基本差不多，这里就讲一下单向认证的整个流程，先看一张图：

  1. 客户端发起HTTPS请求：客户端向服务端发送SSL协议版本号、加密算法种类、随机数等信息。
  2. 服务端的配置：采用HTTPS协议的服务器必须要有一套数字证书，可以自己制作，也可以向组织申请。区别就是自己颁发的证书需要客户端验证通过，才可以继续访问，而使用受信任的公司申请的证书可以直接通过。这套证书其实就是一对公钥和私钥。
  3. 传送证书：这个证书其实就是公钥，只是包含了很多信息，如证书的颁发机构，过期时间等等。同时服务端也会向客户端发送SSL协议版本号、加密算法种类、随机数等信息
  4. 客户端解析证书：这部分工作是由客户端的TLS来完成的，首先会验证公钥是否有效，比如颁发机构，过期时间等等，如果发现异常，则会抛出一个警告，提示证书存在问题。如果证书没有问题，那么就生成一个随机值，然后用证书对该随机值进行加密。
  5. 传送加密信息：这部分传送的是用证书加密后的随机值，目的就是让服务端得到这个随机值，以后客户端和服务端的通信就可以通过这个随机值来进行加密解密了。
  6. 服务段解密信息：服务端用私钥解密后，得到了客户端传过来的随机值(私钥)，然后把内容通过该值进行对称加密。
  7. 传输加密后的信息：这部分信息是服务段用私钥加密后的信息，可以在客户端被还原。
  8. 客户端解密信息：客户端用之前生成的私钥解密服务段传过来的信息，于是获取了解密后的内容。整个过程第三方即使监听到了数据，也束手无策。

Alamofire的安全认证

证书验证模式

如果使用的是自签证书需要我们进行安全认证，如果是CA机构颁发的证书是不需要我们写安全认证的相关代码的。
举个Alamofire发起HTTPS请求的栗子🌰：

let serverTrustPlolicies: [String: ServerTrustPolicy] = [
    hostUrl: .pinCertificates(
        certificates: ServerTrustPolicy.certificates(),
        validateCertificateChain: true,
        validateHost: true)
]
self.sessionManager = SessionManager(serverTrustPolicyManager: ServerTrustPolicyManager(policies: serverTrustPlolicies))
self.sessionManager?.request(urlString).response { (defaultResponse) in
    print(defaultResponse)
}

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)
}

public static func certificates(in bundle: Bundle = Bundle.main) -> [SecCertificate] {
    var certificates: [SecCertificate] = []

    let paths = Set([".cer", ".CER", ".crt", ".CRT", ".der", ".DER"].map { fileExtension in
        bundle.paths(forResourcesOfType: fileExtension, inDirectory: nil)
    }.joined())

    for path in paths {
        if
            let certificateData = try? Data(contentsOf: URL(fileURLWithPath: path)) as CFData,
            let certificate = SecCertificateCreateWithData(nil, certificateData)
        {
            certificates.append(certificate)
        }
    }

    return certificates
}

open func urlSession(
    _ session: URLSession,
    task: URLSessionTask,
    didReceive challenge: URLAuthenticationChallenge,
    completionHandler: @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void)
{
    guard taskDidReceiveChallengeWithCompletion == nil else {
        taskDidReceiveChallengeWithCompletion?(session, task, challenge, completionHandler)
        return
    }

    if let taskDidReceiveChallenge = taskDidReceiveChallenge {
        let result = taskDidReceiveChallenge(session, task, challenge)
        completionHandler(result.0, result.1)
    } else if let delegate = self[task]?.delegate {
        delegate.urlSession(
            session,
            task: task,
            didReceive: challenge,
            completionHandler: completionHandler
        )
    } else {
        urlSession(session, didReceive: challenge, completionHandler: completionHandler)
    }
}

public func evaluate(_ serverTrust: SecTrust, forHost host: String) -> Bool {
    var serverTrustIsValid = false

    switch self {
    // 省略无法代码.....
    case let .pinCertificates(pinnedCertificates, validateCertificateChain, validateHost):
        if validateCertificateChain {
            let policy = SecPolicyCreateSSL(true, validateHost ? host as CFString : nil)
            SecTrustSetPolicies(serverTrust, policy)

            SecTrustSetAnchorCertificates(serverTrust, pinnedCertificates as CFArray)
            SecTrustSetAnchorCertificatesOnly(serverTrust, true)

            serverTrustIsValid = trustIsValid(serverTrust)
        } else {
            let serverCertificatesDataArray = certificateData(for: serverTrust)
            let pinnedCertificatesDataArray = certificateData(for: pinnedCertificates)

            outerLoop: for serverCertificateData in serverCertificatesDataArray {
                for pinnedCertificateData in pinnedCertificatesDataArray {
                    if serverCertificateData == pinnedCertificateData {
                        serverTrustIsValid = true
                        break outerLoop
                    }
                }
            }
        }
    // 省略无法代码.....
    return serverTrustIsValid
}

公钥验证模式

总结

这篇文章大概聊了一下HTTPS的加密流程，以及通过如何Alamofire请求HTTPS的接口和网络挑战流程的分析。当然，如果想彻底明白HTTPS的实现方式，还需继续学习。推荐一本书《图解HTTP》,讲的非常通俗易懂，文章的几张图片也是来源于这本书。

有问题或者建议和意见，欢迎大家评论或者私信。
喜欢的朋友可以点下关注和喜欢，后续会持续更新文章。

上一篇 下一篇

猜你喜欢

热点阅读