iOS 存储对象数组中对象安全存储 AK/SK 的最佳实践指南

在 iOS 应用开发中，存储包含敏感信息（如访问密钥 AK/SK）的对象数组是一项需要谨慎处理的任务。不当的存储方式可能导致密钥泄露，进而引发严重的安全问题。本文将详细介绍如何在 iOS 应用中安全地存储包含 AK/SK 的对象数组，涵盖从基础数据结构到安全存储方案的各个方面。

一、理解 AK/SK 的重要性

AK（Access Key）和 SK（Secret Key）是用于身份验证和访问控制的密钥对。在云服务（如 AWS、阿里云等）中，AK/SK 用于验证用户身份并授权访问特定资源。一旦 AK/SK 泄露，攻击者可能获得对云资源的完全控制权，导致数据泄露、服务中断等严重后果。因此，在 iOS 应用中存储 AK/SK 时，必须采取严格的安全措施。

二、对象数组的存储基础

在 iOS 中，对象数组通常使用 NSArray 或 NSMutableArray 来存储。每个对象可以是一个自定义的类实例，包含多个属性，其中可能包括 AK/SK。以下是一个简单的自定义类示例：

class CloudCredential {
    var accessKey: String
    var secretKey: String
    var serviceName: String
    init(accessKey: String, secretKey: String, serviceName: String) {
        self.accessKey = accessKey
        self.secretKey = secretKey
        self.serviceName = serviceName
    }
}

使用 NSArray 存储多个 CloudCredential 对象的示例：

let credential1 = CloudCredential(accessKey: "AK123", secretKey: "SK123", serviceName: "AWS")
let credential2 = CloudCredential(accessKey: "AK456", secretKey: "SK456", serviceName: "Aliyun")
let credentialsArray: [CloudCredential] = [credential1, credential2]

三、安全存储 AK/SK 的挑战

直接将包含 AK/SK 的对象数组存储在应用的沙盒目录（如 Documents 或 Library）中是不安全的。沙盒目录虽然对其他应用不可见，但设备被盗或越狱后，攻击者可能通过文件系统访问这些敏感信息。因此，必须采取额外的安全措施。

四、安全存储方案

1. 使用 Keychain 存储

Keychain 是 iOS 提供的用于安全存储敏感信息的机制。它使用硬件加密和访问控制来保护数据。以下是使用 Keychain 存储 CloudCredential 对象的步骤：

步骤 1：定义 Keychain 存储的键名

let accessKeyKey = "com.yourapp.accessKey"
let secretKeyKey = "com.yourapp.secretKey"
let serviceNameKey = "com.yourapp.serviceName"

步骤 2：实现 Keychain 存储和检索功能

import Security
class KeychainManager {
    static func save(key: String, data: Data) -> Bool {
        let query = [
            kSecClass as String: kSecClassGenericPassword as String,
            kSecAttrAccount as String: key,
            kSecValueData as String: data
        ] as [String: Any]
        SecItemDelete(query as CFDictionary)
        let status = SecItemAdd(query as CFDictionary, nil)
        return status == errSecSuccess
    }
    static func load(key: String) -> Data? {
        let query = [
            kSecClass as String: kSecClassGenericPassword as String,
            kSecAttrAccount as String: key,
            kSecReturnData as String: true,
            kSecMatchLimit as String: kSecMatchLimitOne
        ] as [String: Any]
        var dataTypeRef: AnyObject?
        let status = SecItemCopyMatching(query as CFDictionary, &dataTypeRef)
        if status == errSecSuccess {
            return dataTypeRef as? Data
        } else {
            return nil
        }
    }
    static func delete(key: String) -> Bool {
        let query = [
            kSecClass as String: kSecClassGenericPassword as String,
            kSecAttrAccount as String: key
        ] as [String: Any]
        let status = SecItemDelete(query as CFDictionary)
        return status == errSecSuccess
    }
}

步骤 3：将 CloudCredential 对象转换为 Data 并存储

extension CloudCredential {
    func toData() -> Data? {
        let dictionary = [
            "accessKey": accessKey,
            "secretKey": secretKey,
            "serviceName": serviceName
        ] as [String: Any]
        do {
            return try JSONSerialization.data(withJSONObject: dictionary, options: [])
        } catch {
            print("Error converting CloudCredential to Data: \(error)")
            return nil
        }
    }
    static func fromData(_ data: Data) -> CloudCredential? {
        do {
            if let dictionary = try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any] {
                if let accessKey = dictionary["accessKey"] as? String,
                   let secretKey = dictionary["secretKey"] as? String,
                   let serviceName = dictionary["serviceName"] as? String {
                    return CloudCredential(accessKey: accessKey, secretKey: secretKey, serviceName: serviceName)
                }
            }
        } catch {
            print("Error converting Data to CloudCredential: \(error)")
        }
        return nil
    }
}
// 存储示例
if let credentialData = credential1.toData() {
    KeychainManager.save(key: accessKeyKey, data: credentialData)
}
// 检索示例
if let retrievedData = KeychainManager.load(key: accessKeyKey),
   let retrievedCredential = CloudCredential.fromData(retrievedData) {
    print("Retrieved Credential: \(retrievedCredential.accessKey), \(retrievedCredential.secretKey)")
}

2. 使用加密存储

如果 Keychain 无法满足需求（例如需要存储大量数据），可以考虑使用加密存储。iOS 提供了 CryptoKit 框架，可以用于加密和解密数据。

步骤 1：生成加密密钥

import CryptoKit
let symmetricKey = SymmetricKey(size: .bits256)

步骤 2：加密和解密数据

extension Data {
    func encrypted(with key: SymmetricKey) -> Data? {
        do {
            let sealedBox = try AES.GCM.seal(self, using: key)
            return sealedBox.combined
        } catch {
            print("Encryption error: \(error)")
            return nil
        }
    }
    static func decrypted(_ data: Data, using key: SymmetricKey) -> Data? {
        do {
            let sealedBox = try AES.GCM.SealedBox(combined: data)
            let decryptedData = try AES.GCM.open(sealedBox, using: key)
            return decryptedData
        } catch {
            print("Decryption error: \(error)")
            return nil
        }
    }
}
// 加密示例
if let credentialData = credential1.toData(),
   let encryptedData = credentialData.encrypted(with: symmetricKey) {
    // 存储 encryptedData 到文件或数据库
}
// 解密示例
if let encryptedData = // 从文件或数据库加载的 encryptedData,
   let decryptedData = Data.decrypted(encryptedData, using: symmetricKey),
   let decryptedCredential = CloudCredential.fromData(decryptedData) {
    print("Decrypted Credential: \(decryptedCredential.accessKey), \(decryptedCredential.secretKey)")
}

3. 使用第三方安全存储库

一些第三方库（如 Locksmith、Valet）提供了更高级的 Keychain 封装，简化了安全存储的操作。这些库通常提供了更友好的 API 和更好的错误处理。

使用 Valet 示例

import Valet
let valet = Valet.valet(with: Identifier(nonEmpty: "com.yourapp.credentials")!,
                        accessibility: .whenUnlockedThisDeviceOnly)
// 存储示例
if let credentialData = credential1.toData() {
    valet.set(object: credentialData, forKey: "credential1")
}
// 检索示例
if let retrievedData = valet.object(forKey: "credential1"),
   let retrievedCredential = CloudCredential.fromData(retrievedData) {
    print("Retrieved Credential: \(retrievedCredential.accessKey), \(retrievedCredential.secretKey)")
}

五、最佳实践

1. 最小权限原则：只存储必要的 AK/SK，避免存储过多敏感信息。
2. 定期轮换密钥：定期更换 AK/SK，减少泄露后的风险。
3. 访问控制：限制对存储 AK/SK 的代码和文件的访问权限。
4. 日志和监控：记录对 AK/SK 的访问和使用情况，及时发现异常行为。
5. 安全审计：定期进行安全审计，检查存储方案的安全性。

六、结论

在 iOS 应用中存储包含 AK/SK 的对象数组需要谨慎处理。通过使用 Keychain、加密存储或第三方安全存储库，可以有效地保护敏感信息。同时，遵循最佳实践，如最小权限原则、定期轮换密钥等，可以进一步提高应用的安全性。