安全

在与服务器和Web服务通信时使用安全的HTTPS连接是保护敏感数据的重要一步。默认情况下，Alamofire将使用Apple的安全框架提供的内置验证来评估服务器提供的证书链。虽然这保证了证书链的有效性，但它不能防止中间人（MITM）攻击或其他潜在漏洞。为了减轻MITM攻击，处理敏感客户数据或财务信息的应用程序应使用ServerTrustPolicy提供的证书或公钥固定。

服务器信任策略

ServerTrustPolicy枚举评估通过安全HTTPS连接连接到服务器时通常由URLAuthenticationChallenge提供的服务器信任。

let serverTrustPolicy = ServerTrustPolicy.pinCertificates(
    certificates: ServerTrustPolicy.certificates(),
    validateCertificateChain: true,
    validateHost: true
)

有许多不同的服务器信任评估情况，使您可以完全控制验证过程：

• performDefaultEvaluation：使用默认的服务器信任评估，同时允许您控制是否验证质询提供的主机。
• pinCertificates：使用固定证书验证服务器信任。如果其中一个固定证书与其中一个服务器证书匹配，则认为服务器信任有效。
• pinPublicKeys：使用固定的公钥验证服务器信任。如果其中一个固定公钥与其中一个服务器证书公钥匹配，则认为服务器信任有效。
• disableEvaluation：禁用所有评估，这反过来将始终将任何服务器信任视为有效。
• customEvaluation：使用关联的闭包来评估服务器信任的有效性，从而使您能够完全控制验证过程。谨慎使用。
  服务器信任策略管理器

ServerTrustPolicyManager负责存储服务器信任策略到特定主机的内部Map。这允许Alamofire根据不同的服务器信任策略评估每个主机。

let serverTrustPolicies: [String: ServerTrustPolicy] = [
    "test.example.com": .pinCertificates(
        certificates: ServerTrustPolicy.certificates(),
        validateCertificateChain: true,
        validateHost: true
    ),
    "insecure.expired-apis.com": .disableEvaluation
]

let sessionManager = SessionManager(
    serverTrustPolicyManager: ServerTrustPolicyManager(policies: serverTrustPolicies)
)

确保保留对新的SessionManager示例的引用，否则当sessionManager被释放时，您的请求将全部取消。这些服务器信任策略将导致以下行为：
test.example.com 将始终使用证书钉扎，并启用证书链和主机验证，因此需要满足以下条件才能成功进行TLS握手：证书链必须有效。证书链必须包含一个固定证书。挑战主机必须与证书链的叶证书中的主机匹配。insecure.expired-apis.com永远不会评估证书链，并且总是允许TLS握手成功。所有其他主机将使用Apple提供的默认评估。子类化服务器信任策略管理器
如果您发现自己需要更灵活的服务器信任策略匹配行为（即通配符域），然后子类化ServerTrustPolicyManager并使用您自己的自定义实现重写serverTrustPolicyForHost方法。

class CustomServerTrustPolicyManager: ServerTrustPolicyManager {
    override func serverTrustPolicy(forHost host: String) -> ServerTrustPolicy? {
        var policy: ServerTrustPolicy?

        // Implement your custom domain matching behavior...

        return policy
    }
}

验证主机
. performDefaultEvaluation、.pinCertificates和.pinPublicKeys服务器信任策略都采用validateHost参数。将该值设置为true将使服务器信任评估验证证书中的主机名是否与质询的主机名匹配。如果它们不匹配，则评估将失败。validateHost值为false仍将评估完整的证书链，但不会验证叶证书的主机名。
建议在生产环境中始终将validateHost设置为true。验证证书链
固定证书和公钥都可以选择使用validateCertificateChain参数验证证书链。通过将此值设置为true，除了对固定的证书或公钥执行字节相等性检查外，还将评估完整的证书链。值为false将跳过证书链验证，但仍将执行字节相等性检查。
在几种情况下，禁用证书链验证可能是有意义的。禁用验证的最常见用例是自签名证书和过期证书。在这两种情况下，评估总是会失败，但字节相等性检查仍将确保您从服务器接收到所需的证书。
建议在生产环境中始终将validateCertificateChain设置为true。应用传输安全

在iOS 9中添加了应用传输安全性（ATS）后，使用带有多个ServerTrustPolicy对象的自定义ServerTrustPolicyManager可能不会产生任何效果。如果您连续看到CFNetwork SSL Handshake failed（-9806）错误，则可能遇到了此问题。Apple的ATS系统会覆盖整个挑战系统，除非您在应用的plist中配置ATS设置，以禁用足够的ATS设置，以允许您的应用评估服务器信任。
如果您遇到此问题（自签名证书的可能性很高），您可以通过将以下内容添加到Info. plist来解决此问题。

<dict>
    <key>NSAppTransportSecurity</key>
    <dict>
        <key>NSExceptionDomains</key>
        <dict>
            <key>example.com</key>
            <dict>
                <key>NSExceptionAllowsInsecureHTTPLoads</key>
                <true/>
                <key>NSExceptionRequiresForwardSecrecy</key>
                <false/>
                <key>NSIncludesSubdomains</key>
                <true/>
                <!-- Optional: Specify minimum TLS version -->
                <key>NSTemporaryExceptionMinimumTLSVersion</key>
                <string>TLSv1.2</string>
            </dict>
        </dict>
    </dict>
</dict>

是否需要将NSCepceptionResForwardSecret设置为NO取决于TLS连接是否使用允许的密码套件。在某些情况下，需要将其设置为NO。必须将NSExceptionAllowsInsecureHTTPLools设置为YES，以便允许SessionDelegate接收质询回调。一旦挑战回调被调用，ServerTrustPolicyManager将接管服务器信任评估。如果您尝试连接到仅支持低于1.2的TLS版本的主机，则可能还需要指定NSTEmporaryExceptionMinimumTLSVersion。
建议在生产环境中始终使用有效的证书。在本地网络中使用自签名证书
如果您尝试连接到本地主机上运行的服务器，并且使用自签名证书，则需要将以下内容添加到Info. plist中。

<dict>
    <key>NSAppTransportSecurity</key>
    <dict>
        <key>NSAllowsLocalNetworking</key>
        <true/>
    </dict>
</dict>

根据Apple文档，将NSAlowsLocalNetworking设置为YES允许加载本地资源，而无需为应用的其余部分禁用ATS。
参考：-https://github.com/Alamofire/Alamofire/blob/master/Documentation/AdvancedUsage.md
有关实现细节，请参阅测试。https://github.com/Alamofire/Alamofire/blob/master/Tests/TLSEvaluationTests.swift#L290-L450

使用TrustKit和Alamofire进行SSL固定。在这里，我包含了API Manager类。这将帮助您解决使用Alamofire和TrustKit的问题。

class ApiManager: SessionDelegate{

  var sessionManager: SessionManager? 
  
  override init(){
        super.init()
        initReachibility()
        sessionManager = SessionManager.init(configuration: URLSessionConfiguration.ephemeral, delegate: self)
    }
  
  override func urlSession(_ session: URLSession, task: URLSessionTask, didReceive challenge: URLAuthenticationChallenge, completionHandler: @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void) {
        // Call into TrustKit here to do pinning validation
        if TrustKit.sharedInstance().pinningValidator.handle(challenge, completionHandler: completionHandler) == false {
            // TrustKit did not handle this challenge: perhaps it was not for server trust
            // or the domain was not pinned. Fall back to the default behavior
            completionHandler(.cancelAuthenticationChallenge, nil)
        }
    }
  
  func makeRequestAlamofire(route:URL, method:HTTPMethod, autherized:Bool, parameter:Parameters,header:[String:String], callback: @escaping (APIResult<Data>) -> Void){
        
        sessionManager?.request(route,method: method,parameters:parameter, encoding: JSONEncoding.default,headers:headers ).validate(statusCode: 200..<300)
            .validate(contentType: ["application/json"]).responseData { response in
                //Pin Validtion returner
                guard response.error == nil else {
                    // Display Error Alert
                    print("Result Pinning validation failed for \(route.absoluteString)\n\n\(response.error.debugDescription)")
                    return
                }
                switch response.result {
                  case .success(let val):
                    print("Success")
                  case .failure(let error):
                    print("Faild")
                }
        }
    }
}

有关完整教程，请参阅this link。

Alamofire已经改变了新版本（Alamofire 5.0）中剪切的所有固定代码。
您应该像下面一样使用ServerTrustManager，

let configuration = URLSessionConfiguration.default
        configuration.timeoutIntervalForRequest = timeoutIntervalForRequest
        let trustManager = ServerTrustManager(evaluators: [
                     "dev.ehliyetcepte.com": PublicKeysTrustEvaluator(),
                     "uat.ehliyetcepte.com": DisabledEvaluator(),
                     "pilot.ehliyetcepte.com": DisabledEvaluator(),
                     "prod.ehliyetcepte.com": DisabledEvaluator()])

        self.session = Session(startRequestsImmediately: true,
                               configuration: configuration,
                               delegate: self,
                               serverTrustManager: trustManager)

我建议使用TrustKit。它是一个专用的库，可以与基于NSURLSession的所有内容一起工作，包括Alamofire。根据您的用例，它可能很简单，只需向Info.plist添加几个值。
与任何安全措施一样，证书固定不是您应该自己实现的，而是您应该使用经过验证的库。

let serverTrustPolicies: [String: ServerTrustPolicy] = [
     // or `pinPublicKeys`
    "test.example.com": .pinCertificates(
        certificates: ServerTrustPolicy.certificates(),
        validateCertificateChain: true,
        validateHost: true
    ),
    "insecure.expired-apis.com": .disableEvaluation
]

let sessionManager = SessionManager(
    serverTrustPolicyManager: ServerTrustPolicyManager(policies: serverTrustPolicies)
)

我找到了这个解决方案

let session = Session(delegate:CustomSessionDelegate())
session.request.... 

class CustomSessionDelegate: SessionDelegate {
  private static let publicKeyHash = "your_public_key"
  let rsa2048Asn1Header:[UInt8] = [
    0x30, 0x82, 0x01, 0x22, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86,
    0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x82, 0x01, 0x0f, 0x00
]

override func urlSession(_ session: URLSession,
                         task: URLSessionTask,
                         didReceive challenge: URLAuthenticationChallenge,
                         completionHandler: @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void) {
    guard let serverTrust = challenge.protectionSpace.serverTrust else {
        completionHandler(.cancelAuthenticationChallenge, nil);
        return
    }
    if let serverCertificate = SecTrustGetCertificateAtIndex(serverTrust, 0) {
        // Server public key
        guard let serverPublicKey = SecCertificateCopyKey(serverCertificate) else {
            completionHandler(.cancelAuthenticationChallenge, nil)
            return
        }
        guard let serverPublicKeyData = SecKeyCopyExternalRepresentation(serverPublicKey, nil) else {
            completionHandler(.cancelAuthenticationChallenge, nil)
            return
        }
        let data:Data = serverPublicKeyData as Data
        // Server Hash key
        let serverHashKey = sha256(data: data)
        // Local Hash Key
        let publickKeyLocal = type(of: self).publicKeyHash
        if (serverHashKey == publickKeyLocal) {
            // Success! This is our server
            print("Public key pinning is successfully completed")
            completionHandler(.useCredential, URLCredential(trust:serverTrust))
            return
        } else {
            completionHandler(.cancelAuthenticationChallenge, nil)
            return
        }
    }
}

private func sha256(data : Data) -> String {
    var keyWithHeader = Data(rsa2048Asn1Header)
    keyWithHeader.append(data)
    var hash = [UInt8](repeating: 0,  count: Int(CC_SHA256_DIGEST_LENGTH))
    keyWithHeader.withUnsafeBytes {
        _ = CC_SHA256($0, CC_LONG(keyWithHeader.count), &hash)
    }
    
    
    return Data(hash).base64EncodedString()
}