Swift AES通用加密-AES解密过程中的前16个字符被省略

尝试在swift中使用AES（公共加密）执行加密和解密时，由于某些原因，前16个字符的解密将被删除。任何人都可以看看下面的操场代码，并提出这里可能出现的问题吗？。decodedString变量在解密期间修剪原始payloadString的初始16个字符

游乐场守则

import UIKit
import CommonCrypto

class AESNew {

    enum MyError: LocalizedError {
        case first(message: String)
        case second(message: String)

        var errorDescription: String? { return "Some description here!" }
    }
    
    func encrypt(plainText: String, keyData:Data, iv: Data, options:Int = kCCOptionPKCS7Padding) -> Result<Data, Error> {
        let plainData = Data(plainText.utf8)
            
        if let cryptData = NSMutableData(length: Int((plainData.count)) + kCCBlockSizeAES128) {

            let keyLength              = size_t(kCCKeySizeAES128)
            let operation: CCOperation = UInt32(kCCEncrypt)
            let algoritm:  CCAlgorithm = UInt32(kCCAlgorithmAES128)
            let options:   CCOptions   = UInt32(options)
            
            var numBytesEncrypted :size_t = 0
            
            //let value = iv.withUnsafeBytes { $0.load(as: UInt32.self) }
            
            let cryptResult = iv.withUnsafeBytes { (dataBytes : UnsafePointer<UInt8>) -> Result<Data, Error> in
                
                print(dataBytes)
                
                print(UnsafeRawPointer(dataBytes))
                
                let cryptStatus = CCCrypt(operation,
                                          algoritm,
                                          options,
                                          (keyData as NSData).bytes,
                                          keyLength,
                                          UnsafeRawPointer(dataBytes),
                                          (plainData as NSData).bytes, plainData.count,
                                          cryptData.mutableBytes, cryptData.length,
                                          &numBytesEncrypted)
                
                if UInt32(cryptStatus) == UInt32(kCCSuccess) {
                    cryptData.length = Int(numBytesEncrypted)
                    let base64cryptString = cryptData.base64EncodedString(options: .lineLength64Characters)
                    print("base64cryptString: \(base64cryptString)")
                    return .success(cryptData as Data)
                } else {
                    print("failure")
                    return .failure(MyError.first(message: "crypt failed"))
                }
            }
            
            return cryptResult
        
        }
        return .failure(MyError.second(message: "no value failure"))
    }

    // The iv is prefixed to the encrypted data
    func decrypt(data: Data, keyData: Data) throws -> Data? {
        let keyLength = keyData.count
        let validKeyLengths = [kCCKeySizeAES128, kCCKeySizeAES192, kCCKeySizeAES256]
        if validKeyLengths.contains(keyLength) == false {
            print("validKeyLengths does not match")
        }

        let ivSize = kCCBlockSizeAES128
        let clearLength = size_t(data.count - ivSize)
        var clearData = Data(count: clearLength)

        var numBytesDecrypted: size_t = 0
        let options   = CCOptions(kCCOptionPKCS7Padding)

        let cryptStatus = clearData.withUnsafeMutableBytes {cryptBytes in
            data.withUnsafeBytes {dataBytes in
                keyData.withUnsafeBytes {keyBytes in
                    CCCrypt(CCOperation(kCCDecrypt),
                            CCAlgorithm(kCCAlgorithmAES128),
                            options,
                            keyBytes,
                            keyLength,
                            dataBytes,
                            dataBytes+kCCBlockSizeAES128,
                            clearLength,
                            cryptBytes,
                            clearLength,
                            &numBytesDecrypted)
                }
            }
        }
        
        if UInt32(cryptStatus) == UInt32(kCCSuccess) {
            clearData.count = numBytesDecrypted
        } else {
            print("Decryption failed")
        }
        return clearData
    }
}

func randomGenerateBytes(count: Int) -> Data? {
    let bytes = UnsafeMutableRawPointer.allocate(byteCount: count, alignment: 1)
    defer { bytes.deallocate() }
    let status = CCRandomGenerateBytes(bytes, count)
    guard status == kCCSuccess else { return nil }
    return Data(bytes: bytes, count: count)
}

var ivBytesNew = Data()

if let ivBytes = randomGenerateBytes(count: 16) {
    ivBytesNew = ivBytes
} else {
    print("randomGenerateBytes failed")
}

let keyString   = "keyData890123456"
let keyData   = "keyData890123456".data(using:String.Encoding.utf8)!

let payloadString = "asdflkasfdkaslfd12345"

let aesObject = AESNew()

let encrytedObject = aesObject.encrypt(plainText: payloadString, keyData: keyData, iv: ivBytesNew, options: kCCOptionPKCS7Padding)

var encryptedData = Data()

switch encrytedObject {
case .success(let encData):
    print(encData)
    encryptedData = encData
case .failure(let error):
    print(error)
default:
    print("enc failed")
}

if let decrypedData = try? aesObject.decrypt(data: encryptedData, keyData: keyData) {
    if let decodedString = String(data: decrypedData, encoding: .utf8) {
        print(decodedString) // 1234, first 16 characters are omitted. 
    } else {
        print("conversion from data to string failed")
    }
} else {
    print("decryption failed")
}

导入UIKit
导入通用加密
新类别{
枚举MyError:LocalizedError{
案例优先（消息：String）
第二个案例（消息：String）
var errorDescription:String？{返回“此处的一些描述！”}
}
func encrypt（纯文本：字符串，keyData:Data，iv:Data，选项：Int=kCCOptionPKCS7Padding）->Result{
让明文数据=数据（明文.utf8）
如果let cryptData=NSMutableData（长度：Int（（plainData.count））+kCCBlockSizeAES128）{
let keyLength=大小（kCCKeySizeAES128）
let操作：cOperation=UInt32（kCCEncrypt）
let算法：CCAlgorithm=UInt32（kCCAlgorithmAES128）
let选项：cOptions=UInt32（选项）
var numBytesEncrypted:size\u t=0
//让value=iv.withUnsafeBytes{$0.load（as:UInt32.self）}
让cryptResult=iv.withUnsafeBytes{（数据字节：UnsafePointer）->生成
打印（数据字节）
打印（非空指针（数据字节））
让cryptStatus=CCCrypt（操作，
算法，
选项，
（keyData作为NSData）。字节，
键长，
不安全指针（数据字节），
（作为NSData的plainData）。字节，plainData.count，
cryptData.mutableBytes，cryptData.length，
&（未加密）
如果UInt32（加密状态）=UInt32（kCCSuccess）{
cryptData.length=Int（numBytesEncrypted）
让base64cryptString=cryptData.base64EncodedString（选项：.LineLength64个字符）
打印（“base64cryptString:\（base64cryptString）”）
return.success（cryptData作为数据）
}否则{
打印（“失败”）
return.failure（MyError.first（消息：“crypt失败”））
}
}
返回加密结果
}
return.failure（MyError.second（消息：“无值失败”））
}
//iv是加密数据的前缀
func解密（数据：数据，密钥数据：数据）抛出->数据{
让keydlength=keyData.count
设validKeyLength=[kCCKeySizeAES128，kCCKeySizeAES192，kCCKeySizeAES256]
如果ValidKeyLength.contains（keyLength）=false{
打印（“有效长度不匹配”）
}
设ivSize=KCCBLOCKSIZEA128
让clearLength=size\u t（data.count-ivSize）
var clearData=数据（计数：clearLength）
var numbytes已加密：大小\u t=0
let options=CCOptions（kCCOptionPKCS7Padding）
让cryptStatus=clearData.withUnsafeMutableBytes{cryptBytes in
data.withUnsafeBytes中的{dataBytes
keyData.withUnsafeBytes{keyBytes in
CCCrypt（CCOperation（kCCDecrypt），
C算法（KCcalGorithmaes 128），
选项，
密钥字节，
键长，
数据字节，
数据字节+KCCBlocksizeeAes128，
净长，
密码字节，
净长，
&numbytes（已加密）
}
}
}
如果UInt32（加密状态）=UInt32（kCCSuccess）{
clearData.count=numbytes已加密
}否则{
打印（“解密失败”）
}
返回clearData
}
}
func randomGenerateBytes（计数：Int）->数据？{
let bytes=unsafemtablerawpointer.allocate（字节计数：计数，对齐：1）
延迟{bytes.deallocate（）}
let status=CCRandomGenerateBytes（字节，计数）
保护状态==kCCSuccess else{return nil}
返回数据（字节：字节，计数：计数）
}
var ivBytesNew=Data（）
如果let ivBytes=randomGenerateBytes（计数：16）{
ivBytesNew=ivBytes
}否则{
打印（“随机生成字节失败”）
}
让keyString=“keyData890123456”
让keyData=“keyData890123456”。数据（使用：String.Encoding.utf8）！
让payloadString=“asdflkasfdkaslfd12345”
让aesObject=AESNew（）
让encrytedObject=aesObject.encrypt（明文：payloadString，keyData:keyData，iv:ivBytesNew，选项：kCCOptionPKCS7Padding）
var encryptedData=Data（）
开关镶嵌对象{
案例.成功（让我们看看数据）：
打印（加密数据）
encryptedData=encData
案例。失败（let错误）：
打印（错误）
违约：
打印（“enc失败”）
}
如果让decrypedData=try？解密（数据：encryptedData，keyData:keyData）{
如果let decodedString=String（数据：decrypedData，编码：.utf8）{
打印（解码字符串）//1234，省略前16个字符。
}否则{
打印（“从数据到字符串的转换失败”）
}
}否则{
打印（“解密失败”）
}

您似乎学会了两种不同的加密和解密

您是否看到您的

decrypt

没有AES解密所需的参数

iv

您的

decrypt

需要

da的前16个字节
if let decrypedData = try? aesObject.decrypt(data: ivBytesNew + encryptedData, keyData: keyData) {