在 Swift 中使用 AES.GCM.SealedBox 解密数据

Question

我正在尝试使用 AES.GCM 解密数据。加密的数据工作正常，但当我尝试使用相同的密钥解密数据时，会出现身份验证错误。下面是解密代码

func decryptData(decryptToData: Data, key: SymmetricKey) -> String {
    var decryptedString: String!
    let combinedData = decryptToData // Previous sealed bo
    let sealedBoxToOpen = try! AES.GCM.SealedBox(combined: decryptToData)

    if let decryptedData = try? AES.GCM.open(sealedBoxToOpen, using: key) {
        decryptedString = String(data: decryptedData, encoding: .utf8)!
        print(decryptedString)
    } else {
        print("error", CryptoKitError.self)
        // Ouch, doSomething() threw an error.
    }
    return decryptedString
}

以下是我的加密代码

let iv = AES.GCM.Nonce()
var encryptedData: Data!
let key = SymmetricKey(size: .bits128)

func encryptData(encryptString: String, key: SymmetricKey) -> Data {
    var encryptedData: Data?
    do {
        let datatoEncrypt1 = encryptString.data(using: .utf8)!
        let mySealedBox  = try AES.GCM.seal(datatoEncrypt1, using: key, nonce: iv)
        encryptedData = mySealedBox.combined
    } catch {
        print("Error")
    }
    return encryptedData
}

Answer 1

    import XCTest
    import CryptoKit
    import Foundation
    
    class CryptoKitUnitTest: XCTestCase {
    
        func testEncryptandDecrypt(){
            let secret = "my-256-bit-secret-my-secret-my-s"
    
            let key = SymmetricKey(data: secret.data(using: .utf8)!)
    
            let plain = "Say hello to my little friend!"
            let nonce = try! AES.GCM.Nonce(data: Data(base64Encoded: "fv1nixTVoYpSvpdA")!)
    
            // Encrypt
            let sealedBox = try! AES.GCM.seal(plain.data(using: .utf8)!, using: key, nonce: nonce)
    
            let ciphertext = sealedBox.ciphertext.base64EncodedString()
            print("ciphertext: \(ciphertext)") // bWtTZkPAu7oXpQ3QpHvoTvc4NQgDTIycXHFJWvjk
    
            let sealedBoxToDecrypt = try! AES.GCM.SealedBox(nonce: nonce,
                                                            ciphertext: Data(base64Encoded: ciphertext)!,
                                                            tag: sealedBox.tag)
            let decrypted = try! AES.GCM.open(sealedBoxToDecrypt, using: key)
    
            print(String(decoding: decrypted, as: UTF8.self))
    
        }
    
        func testEncryptandDecryptFirstWay() {
            let keyStr = "d5a423f64b607ea7c65b311d855dc48f36114b227bd0c7a3d403f6158a9e4412"
            let key = SymmetricKey(data: Data(hex:keyStr))
            let nonceData = Data(hex: "131348c0987c7eece60fc0bc")
            let nonce: AES.GCM.Nonce = try! AES.GCM.Nonce(data: nonceData)
            let plain = "This is first cypto graphy method"
            var decyptedStr = ""
            if let encyptedData = plain.asData.encrypt(nonce: nonce, key: key) {
                decyptedStr = encyptedData.decrypt(nonce: nonce, key: key)
            }
            XCTAssertEqual(plain, decyptedStr)
        }
    }
      extension Data {
        func encrypt(nonce: AES.GCM.Nonce, key: SymmetricKey) ->Data?{
            // Encrypt
            do {
                let sealedBox = try AES.GCM.seal(self, using: key, nonce: nonce)
                let cipherText = sealedBox.ciphertext.base64EncodedString()
                let tag = sealedBox.tag
                let tagPlusCipherText = tag + cipherText.asData
                return tagPlusCipherText
            }
            catch let exceptionInfo {
                debugPrint("Encrypt exception Info: \(exceptionInfo)")
            }
            return nil
        }
    func decrypt(nonce: AES.GCM.Nonce, key: SymmetricKey) -> String{
            let tag = self.subtract(0, 16)
            let cipherTextData = self.subtract(tag.count, self.count - tag.count)
            let cipherText = cipherTextData.asString
            // Decrypt
            var decodeStr: String = ""
            do {
                let sealedBoxToDecrypt = try AES.GCM.SealedBox(nonce: nonce,
                                                               ciphertext: Data(base64Encoded: cipherText)!,
                                                               tag: tag)
                let decrypted = try AES.GCM.open(sealedBoxToDecrypt, using: key)
    
                decodeStr = String(decoding: decrypted, as: UTF8.self)
            } catch let exceptionInfo {
                debugPrint("Decrypt exception info: \(exceptionInfo)")
            }
    
            return decodeStr
        }
    
  public func subtract(_ start: Int, _ length: Int) ->Data {
        precondition(self.count >=  start + length,
                     "Invalid data range range. trying to find out of bound data")
        let allBytes = Array(Data(bytes: self.bytes, count: self.count))
        let partBytes = Array(allBytes[start..<start + length])
        let dataPart = Data(bytes: partBytes, count: partBytes.count)
        return dataPart
    }
    var asString: String {
        let str = String(decoding: self, as: UTF8.self)
        return str
    }

    }

extension String {
    var asData: Data {
        return self.data(using: .utf8) ?? Data()
    }
}