Base64公钥转SecKey后再转回不一致，如何解决此问题？

问题根源 #

你遇到的差异是公钥的两种ASN.1编码格式导致的：

• 原始公钥是PKCS#8格式（Base64开头为MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A），包含外层算法标识的完整封装结构
• SecKeyCopyExternalRepresentation返回的是SPKI（SubjectPublicKeyInfo）格式（Base64开头为MIIBCgKCAQEA），仅保留公钥核心数据与精简算法标识结构

两者的核心公钥内容完全一致，仅外层ASN.1包装结构不同，因此Base64字符串呈现差异。

解决方法 #

根据你的需求选择以下两种方案之一：

方案1：将转换后的SPKI格式转回PKCS#8格式 #

如果需要输出与原始输入完全一致的PKCS#8格式Base64，可通过ASN.1编码将SPKI数据封装回PKCS#8结构：

func spkiToPKCS8(spkiData: Data) -> Data? {
    // 构造RSA算法标识符的ASN.1结构
    let rsaOID = Data([0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01])
    let algorithmIdentifier = Data([0x30, 0x0D]) + rsaOID + Data([0x05, 0x00])
    
    // 构造PKCS#8的SEQUENCE结构
    let subjectPublicKey = Data([0x03, UInt8(spkiData.count + 1)]) + Data([0x00]) + spkiData
    let totalLength = algorithmIdentifier.count + subjectPublicKey.count
    let pkcs8Sequence = Data([0x30, UInt8(totalLength)]) + algorithmIdentifier + subjectPublicKey
    
    return pkcs8Sequence
}

替换代码中的输出逻辑：

if let cfdata = SecKeyCopyExternalRepresentation(publicKeySecKey, &error) {
    let spkiData = cfdata as Data
    if let pkcs8Data = spkiToPKCS8(spkiData: spkiData) {
        // 保持64字符换行的格式与原始输入一致
        let b64Key = pkcs8Data.base64EncodedString(options: .lineLength64Characters)
        print("after:")
        print(b64Key)
    }
}

方案2：统一使用SPKI格式处理 #

如果无需保留原始PKCS#8格式，可先将输入的PKCS#8公钥转换为SPKI格式，后续操作基于SPKI执行，转换前后的Base64即可保持一致：

func pkcs8ToSPKI(pkcs8Data: Data) -> Data? {
    guard pkcs8Data.count >= 2, pkcs8Data[0] == 0x30 else { return nil }
    
    var offset = 1
    // 解析SEQUENCE长度字段
    let lengthByte = pkcs8Data[offset]
    if (lengthByte & 0x80) != 0 {
        let lengthLength = Int(lengthByte & 0x7F)
        offset += 1 + lengthLength
    } else {
        offset += 1
    }
    
    // 跳过algorithmIdentifier部分
    guard offset < pkcs8Data.count, pkcs8Data[offset] == 0x30 else { return nil }
    offset += 1
    let algLengthByte = pkcs8Data[offset]
    if (algLengthByte & 0x80) != 0 {
        let algLengthLength = Int(algLengthByte & 0x7F)
        offset += 1 + algLengthLength
    } else {
        offset += 1 + Int(algLengthByte)
    }
    
    // 提取subjectPublicKey（BIT STRING）
    guard offset < pkcs8Data.count, pkcs8Data[offset] == 0x03 else { return nil }
    offset += 1
    let spkLengthByte = pkcs8Data[offset]
    var spkLength: Int
    if (spkLengthByte & 0x80) != 0 {
        let spkLengthLength = Int(spkLengthByte & 0x7F)
        spkLength = 0
        for i in 0..<spkLengthLength {
            spkLength = (spkLength << 8) | Int(pkcs8Data[offset + 1 + i])
        }
        offset += 1 + spkLengthLength
    } else {
        spkLength = Int(spkLengthByte)
        offset += 1
    }
    
    // 跳过BIT STRING的unused bits字段（通常为0x00）
    if offset < pkcs8Data.count, pkcs8Data[offset] == 0x00 {
        offset += 1
        spkLength -= 1
    }
    
    guard offset + spkLength <= pkcs8Data.count else { return nil }
    return pkcs8Data.subdata(in: offset..<offset+spkLength)
}

修改输入处理逻辑：

guard let publicKeyFromDongleData = Data(base64Encoded: publicKeyFromDongle) else {
    print("Invalid Base64 public key")
    return nil
}

// 先将PKCS#8转换为SPKI格式
guard let spkiData = pkcs8ToSPKI(pkcs8Data: publicKeyFromDongleData) else {
    print("Failed to convert PKCS#8 to SPKI")
    return nil
}

// 用SPKI数据创建SecKey
guard let publicKeySecKey = SecKeyCreateWithData(spkiData as CFData, keyDict as CFDictionary, &error) else {
    print("Failed to create public key:", error!.takeRetainedValue())
    return nil
}

// 转换回Base64（与输入转换后的SPKI格式一致）
if let cfdata = SecKeyCopyExternalRepresentation(publicKeySecKey, &error) {
    let data = cfdata as Data
    let b64Key = data.base64EncodedString(options: .lineLength64Characters)
    print("after:")
    print(b64Key)
}

注意事项 #

• 添加.lineLength64Characters选项，确保Base64的换行格式与原始输入完全匹配
• 避免使用强制解包（!），处理所有可能的错误场景，提升代码稳定性

内容的提问来源于stack exchange，提问作者ahad alam