withUnsafeMutableBytes' 已弃用 xcode 警告

Question

I have 3 places (in total 7 warnings) in the project where XCode shows the next warning:

withUnsafeMutableBytes' is deprecated

I tried on my own to resolves these warnings, but with no luck. Can someone help me?

1. let status = cryptData.withUnsafeMutableBytes {ivBytes in
        SecRandomCopyBytes(kSecRandomDefault, kCCBlockSizeAES128, ivBytes)
    }

2. let cryptStatus = cryptData.withUnsafeMutableBytes {cryptBytes in
        data.withUnsafeBytes {dataBytes in
            keyData.withUnsafeBytes {keyBytes in
                CCCrypt(CCOperation(kCCEncrypt),
                        CCAlgorithm(kCCAlgorithmAES),
                        options,
                        keyBytes,
                        keyLength,
                        cryptBytes,
                        dataBytes,
                        data.count,
                        cryptBytes + kCCBlockSizeAES128,
                        cryptLength,
                        &numBytesEncrypted)
            }
        }
    }

3. 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)
            }
        }
    }

Answer 1

As @Enricoza points out, the now-deprecated parameter given to the withUnsafeMutableBytes closure is of type UnsafeMutablePointer , and the new one is UnsafeMutableRawBufferPointer . In order to get the UnsafeMutablePointer or UnsafeMutableRawPointer that CommonCrypto can accept, then you need to get the .baseAddress optional property on the *Bytes objects you get from your closures.

Here's a library that uses the new closure parameters: https://github.com/backslash-f/aescryptable/blob/master/Sources/AESCryptable/AESCryptable.swift

You'll note that the main difference is that it unwraps the baseAddress es in a guard clause, throws an error if any fail, then uses those baseAddress es in place of the old parameters to CommonCrypto functions.

Answer 2

If you command+click on your method's call you'll see that you are using a deprecated method that unfortunately has the same name of the new method, but has different param types:

    /// Mutate the bytes in the data.
    ///
    /// This function assumes that you are mutating the contents.
    /// - warning: The byte pointer argument should not be stored and used outside of the lifetime of the call to the closure.
    @available(swift, deprecated: 5, message: "use `withUnsafeMutableBytes<R>(_: (UnsafeMutableRawBufferPointer) throws -> R) rethrows -> R` instead")
    public mutating func withUnsafeMutableBytes<ResultType, ContentType>(_ body: (UnsafeMutablePointer<ContentType>) throws -> ResultType) rethrows -> ResultType

    @inlinable public mutating func withUnsafeMutableBytes<ResultType>(_ body: (UnsafeMutableRawBufferPointer) throws -> ResultType) rethrows -> ResultType

To avoid the warning you should use the second method and (of course) change the implementation of the closure (since it now has another type of parameter).

To enforce the calling of the non-deprecated method you could simply force the type of the parameter in the closure like this:

let status = cryptData.withUnsafeMutableBytes { (ivBufferPointer: UnsafeMutableRawBufferPointer) in
        // Do your logic here with the UnsafeMutableRawBufferPointer
    }