双向加密技术方案

双向加密通信，需要综合考虑安全性、性能和用户体验。下面是一个完整的实现方案：

1. 整体架构设计

iOS App ←→ 加密通信层 ←→ 车控云服务 ←→ 车辆T-Box

2. 核心加密方案

方案一：TLS + 应用层双重加密（推荐）

import Foundation
import CryptoKit
import Security

class VehicleControlCryptoManager {
    private var sessionKey: SymmetricKey?
    private var keyExchangeCompleted = false
}

方案二：国密算法（符合国内标准）

import GMObjC // 国密算法库

class SM2CryptoManager {
    private var sm2Cipher: SM2Cipher?
    private var sm4Key: Data?
}

3. 完整的双向加密实现

3.1 密钥交换协议

class VehicleCryptoHandler {
    private let serverPublicKey = "YOUR_SERVER_PUBLIC_KEY"
    private var sessionKey: SymmetricKey?
    private var sequenceNumber: Int64 = 0
    
    // 1. 初始化密钥交换
    func initiateKeyExchange() throws -> [String: Any] {
        // 生成临时密钥对
        let clientPrivateKey = P256.KeyAgreement.PrivateKey()
        let clientPublicKey = clientPrivateKey.publicKey
        
        // 生成会话密钥
        sessionKey = SymmetricKey(size: .bits256)
        
        // 准备密钥交换数据
        let keyExchangeData: [String: Any] = [
            "client_public_key": clientPublicKey.rawRepresentation.base64EncodedString(),
            "timestamp": Int(Date().timeIntervalSince1970 * 1000),
            "device_id": getDeviceIdentifier(),
            "protocol_version": "1.0"
        ]
        
        return keyExchangeData
    }
    
    // 2. 处理服务器密钥响应
    func handleKeyExchangeResponse(_ response: [String: Any]) throws -> Bool {
        guard let encryptedSessionKey = response["encrypted_session_key"] as? String,
              let serverSignature = response["signature"] as? String,
              let timestamp = response["timestamp"] as? Int else {
            throw CryptoError.invalidResponse
        }
        
        // 验证时间戳防重放
        let currentTime = Int(Date().timeIntervalSince1970 * 1000)
        guard abs(currentTime - timestamp) < 30000 else { // 30秒内有效
            throw CryptoError.timestampExpired
        }
        
        // 解密会话密钥
        let sessionKeyData = try decryptWithClientPrivateKey(
            Data(base64Encoded: encryptedSessionKey)!
        )
        
        // 验证服务器签名
        let verifyData = "\(encryptedSessionKey)\(timestamp)".data(using: .utf8)!
        let isValid = verifyServerSignature(verifyData, signature: serverSignature)
        
        guard isValid else {
            throw CryptoError.signatureVerificationFailed
        }
        
        sessionKey = SymmetricKey(data: sessionKeyData)
        return true
    }
}

3.2 请求加密

extension VehicleCryptoHandler {
    
    func encryptRequest(_ command: VehicleCommand) throws -> [String: Any] {
        guard let sessionKey = sessionKey else {
            throw CryptoError.sessionKeyNotEstablished
        }
        
        sequenceNumber += 1
        
        // 准备请求数据
        let requestData: [String: Any] = [
            "command": command.type.rawValue,
            "params": command.parameters,
            "timestamp": Int(Date().timeIntervalSince1970 * 1000),
            "sequence": sequenceNumber
        ]
        
        let jsonData = try JSONSerialization.data(withJSONObject: requestData)
        
        // 加密数据
        let encryptedData = try encryptData(jsonData, using: sessionKey)
        
        // 生成MAC
        let mac = generateMAC(for: encryptedData, sequence: sequenceNumber)
        
        return [
            "encrypted_data": encryptedData.base64EncodedString(),
            "mac": mac,
            "sequence": sequenceNumber,
            "version": "1.0"
        ]
    }
    
    private func encryptData(_ data: Data, using key: SymmetricKey) throws -> Data {
        let sealedBox = try AES.GCM.seal(data, using: key)
        return sealedBox.combined!
    }
    
    private func generateMAC(for data: Data, sequence: Int64) -> String {
        let macData = data + "\(sequence)".data(using: .utf8)!
        let authenticationKey = SymmetricKey(data: "AUTH_KEY".data(using: .utf8)!)
        let mac = HMAC<SHA256>.authenticationCode(for: macData, using: authenticationKey)
        return Data(mac).base64EncodedString()
    }
}

3.3 响应解密

extension VehicleCryptoHandler {
    
    func decryptResponse(_ response: [String: Any]) throws -> VehicleResponse {
        guard let sessionKey = sessionKey else {
            throw CryptoError.sessionKeyNotEstablished
        }
        
        guard let encryptedData = response["encrypted_data"] as? String,
              let responseMac = response["mac"] as? String,
              let sequence = response["sequence"] as? Int64 else {
            throw CryptoError.invalidResponseFormat
        }
        
        let encryptedDataBytes = Data(base64Encoded: encryptedData)!
        
        // 验证MAC
        let expectedMac = generateMAC(for: encryptedDataBytes, sequence: sequence)
        guard expectedMac == responseMac else {
            throw CryptoError.macVerificationFailed
        }
        
        // 解密数据
        let decryptedData = try decryptData(encryptedDataBytes, using: sessionKey)
        
        // 解析响应
        let responseDict = try JSONSerialization.jsonObject(with: decryptedData) as? [String: Any]
        
        guard let status = responseDict?["status"] as? String,
              let result = responseDict?["result"] as? [String: Any] else {
            throw CryptoError.invalidResponseData
        }
        
        return VehicleResponse(status: status, result: result)
    }
    
    private func decryptData(_ data: Data, using key: SymmetricKey) throws -> Data {
        let sealedBox = try AES.GCM.SealedBox(combined: data)
        return try AES.GCM.open(sealedBox, using: key)
    }
}

4. 网络通信层实现

import Alamofire

class VehicleControlService {
    private let cryptoHandler = VehicleCryptoHandler()
    private let baseURL = "https://vehicle-api.example.com"
    private var isKeyExchanged = false
    
    // 初始化连接
    func initializeConnection() async throws {
        let keyExchangeData = try cryptoHandler.initiateKeyExchange()
        
        let response = try await AF.request(
            "\(baseURL)/api/v1/key-exchange",
            method: .post,
            parameters: keyExchangeData,
            encoder: JSONParameterEncoder.default
        ).serializingDecodable([String: Any].self).value
        
        isKeyExchanged = try cryptoHandler.handleKeyExchangeResponse(response)
    }
    
    // 发送车控命令
    func sendCommand(_ command: VehicleCommand) async throws -> VehicleResponse {
        guard isKeyExchanged else {
            throw VehicleControlError.connectionNotEstablished
        }
        
        let encryptedRequest = try cryptoHandler.encryptRequest(command)
        
        let response = try await AF.request(
            "\(baseURL)/api/v1/control",
            method: .post,
            parameters: encryptedRequest,
            encoder: JSONParameterEncoder.default
        ).serializingDecodable([String: Any].self).value
        
        return try cryptoHandler.decryptResponse(response)
    }
    
    // 实时命令（如车门解锁）
    func unlockDoors() async throws -> Bool {
        let command = VehicleCommand(type: .unlockDoors, parameters: [:])
        let response = try await sendCommand(command)
        return response.status == "success"
    }
    
    // 状态查询
    func queryVehicleStatus() async throws -> VehicleStatus {
        let command = VehicleCommand(type: .queryStatus, parameters: [:])
        let response = try await sendCommand(command)
        return try parseStatus(from: response.result)
    }
}

5. 安全增强措施

5.1 证书锁定

class CertificatePinningManager {
    static let shared = CertificatePinningManager()
    
    func configureCertificatePinning() {
        let serverTrustPolicy = ServerTrustPolicy.pinCertificates(
            certificates: ServerTrustPolicy.certificates(),
            validateCertificateChain: true,
            validateHost: true
        )
        
        let serverTrustPolicies: [String: ServerTrustPolicy] = [
            "vehicle-api.example.com": serverTrustPolicy
        ]
        
        let sessionManager = Session(
            serverTrustManager: ServerTrustManager(policies: serverTrustPolicies)
        )
    }
}

5.2 防重放攻击

class ReplayAttackProtection {
    private var processedSequences = Set<Int64>()
    private let maxSequenceAge: Int64 = 60000 // 1分钟
    
    func validateSequence(_ sequence: Int64, timestamp: Int64) -> Bool {
        let currentTime = Date().timeIntervalSince1970 * 1000
        
        // 检查时间戳
        guard abs(Int64(currentTime) - timestamp) < maxSequenceAge else {
            return false
        }
        
        // 检查序列号是否已处理
        guard !processedSequences.contains(sequence) else {
            return false
        }
        
        processedSequences.insert(sequence)
        
        // 清理过期序列号
        cleanupExpiredSequences()
        
        return true
    }
    
    private func cleanupExpiredSequences() {
        let cutoffTime = Date().timeIntervalSince1970 * 1000 - Double(maxSequenceAge)
        // 清理逻辑...
    }
}

6. 错误处理

enum CryptoError: Error {
    case sessionKeyNotEstablished
    case invalidResponse
    case timestampExpired
    case signatureVerificationFailed
    case macVerificationFailed
    case invalidResponseFormat
    case invalidResponseData
}

enum VehicleControlError: Error {
    case connectionNotEstablished
    case commandTimeout
    case vehicleNotResponding
    case insufficientPermissions
}

extension VehicleControlService {
    func handleControlError(_ error: Error) {
        switch error {
        case CryptoError.sessionKeyNotEstablished:
            // 重新建立加密会话
            Task {
                try? await initializeConnection()
            }
        case CryptoError.macVerificationFailed:
            // 可能的中间人攻击，记录安全事件
            reportSecurityIncident()
        case VehicleControlError.commandTimeout:
            // 显示重试界面
            showRetryDialog()
        default:
            // 通用错误处理
            showErrorMessage("控制命令执行失败")
        }
    }
}

7. 性能优化

class CryptoPerformanceOptimizer {
    
    // 预计算密钥材料
    private var precomputedKeys: [String: SymmetricKey] = [:]
    
    // 使用硬件加速
    func optimizeCryptoOperations() {
        // 使用AES-NI等硬件加速
    }
    
    // 批量操作
    func batchEncryptCommands(_ commands: [VehicleCommand]) throws -> [Data] {
        return try commands.map { command in
            let jsonData = try JSONEncoder().encode(command)
            return try encryptData(jsonData)
        }
    }
}

8. 实际使用示例

class VehicleControlViewController: UIViewController {
    private let vehicleService = VehicleControlService()
    
    @IBAction func unlockDoorsTapped(_ sender: UIButton) {
        Task { @MainActor in
            do {
                showLoadingIndicator()
                let success = try await vehicleService.unlockDoors()
                
                if success {
                    showSuccessMessage("车门已解锁")
                } else {
                    showErrorMessage("解锁失败")
                }
            } catch {
                vehicleService.handleControlError(error)
            }
        }
    }
    
    @IBAction func startEngineTapped(_ sender: UIButton) {
        Task { @MainActor in
            do {
                let command = VehicleCommand(type: .startEngine, parameters: ["duration": 10])
                let response = try await vehicleService.sendCommand(command)
                
                if response.status == "success" {
                    updateVehicleStatus(response.result)
                }
            } catch {
                handleControlError(error)
            }
        }
    }
}

关键安全要点

1. 永远不要硬编码密钥 - 使用安全的密钥分发机制
2. 实现完善的错误处理 - 避免信息泄露
3. 定期更新加密算法 - 跟上安全标准演进
4. 进行安全审计 - 定期检查加密实现
5. 监控异常模式 - 检测潜在攻击

这个方案提供了企业级的远程车控双向加密实现，可以根据具体需求进行调整和扩展。