Merges original ESPProvisioning new commits

.gitignore

@@ -70,3 +70,5 @@ fastlane/screenshots/**/*.png
 fastlane/test_output
 
 EspressifProvision/EspressifProvision/proto/*.swift
+Package.resolved
+Example/ESPProvisionSPMSample/ESPProvisionSPMSample.xcworkspace/xcshareddata/swiftpm/Package.resolved

ESPProvision.podspec

@@ -1,7 +1,7 @@
 Pod::Spec.new do |spec|
 
   spec.name         = "ESPProvision"
-  spec.version      = "2.1.0"
+  spec.version      = "3.1.0"
   spec.summary      = "ESP-IDF provisioning in Swift"
   spec.description  = "It provides mechanism to provide network credentials and/or custom data to an ESP32, ESP32-S2 or ESP8266 devices"
   spec.homepage     = "https://github.com/espressif/esp-idf-provisioning-ios"
@@ -23,14 +23,13 @@ Pod::Spec.new do |spec|
 
   spec.author = "Espressif Systems"
   spec.platform = :ios, "13.0"
-  spec.source = { :git => "https://github.com/espressif/esp-idf-provisioning-ios.git", :tag => "lib-#{spec.version}" }
+  spec.source = { :git => "https://github.com/espressif/esp-idf-provisioning-ios.git", :tag => "#{spec.version}" }
 
-  spec.source_files  = "ESPProvision", "ESPProvision/**/*.{h,m,swift}"
+  spec.source_files  = "ESPProvision", "ESPProvision/**/*.{swift}"
 
 
   spec.subspec 'Core' do |cs|
-      cs.dependency "SwiftProtobuf", "~> 1.5.0"
-      cs.dependency "Curve25519", "~> 1.1.0"
+      cs.dependency "SwiftProtobuf", "~> 1.22.0"
   end
 
   spec.swift_versions = ['5.1', '5.2']

ESPProvision/Crypto/AESDecryptor.swift

@@ -0,0 +1,123 @@
+// Copyright 2023 Espressif Systems
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//  AppDelegate.swift
+//  ESPProvisionSample
+//
+
+import CommonCrypto
+import Foundation
+
+class AESDecryptor {
+    var cryptor: CCCryptorRef?
+    var ccStatus: CCCryptorStatus = 0
+
+    init(key: Data, iv: Data) {
+        cryptor = nil
+
+        ccStatus = CCCryptorCreateWithMode(
+            CCOperation(kCCEncrypt),
+            CCMode(kCCModeCTR),
+            CCAlgorithm(kCCAlgorithmAES),
+            CCPadding(ccNoPadding),
+            iv.bytes, key.bytes,
+            key.count,
+            nil, 0, 0, // tweak XTS mode, numRounds
+            CCModeOptions(kCCModeOptionCTR_BE),
+            &cryptor)
+    }
+
+
+    func cryptData(dataIn: Data,
+                   operation: CCOperation,  // kCC Encrypt, Decrypt
+                   mode: CCMode,            // kCCMode ECB, CBC, CFB, CTR, OFB, RC4, CFB8
+                   algorithm: CCAlgorithm,  // CCAlgorithm AES DES, 3DES, CAST, RC4, RC2, Blowfish
+                   padding: CCPadding,      // cc NoPadding, PKCS7Padding
+                   keyLength: size_t,       // kCCKeySizeAES 128, 192, 256
+                   iv: Data,            // CBC, CFB, CFB8, OFB, CTR
+                   key: Data,
+                   error: inout NSError?) -> Data?
+    {
+        // Check that the key length is correct
+        if (key.count != keyLength) {
+            if (error != nil) {
+                error = NSError(domain: "kArgumentError key length", code: key.count, userInfo: nil)
+            }
+            return nil
+        }
+
+        var dataOutMoved: size_t = 0
+        var dataOutMovedTotal: size_t = 0
+        var ccStatus: CCCryptorStatus = 0
+
+        // Get the output buffer size
+        let dataOutLength = CCCryptorGetOutputLength(cryptor, dataIn.count, true)
+        // Allocate the output buffer
+        var dataOut = NSMutableData(length: dataOutLength)!
+        let dataOutPointer = dataOut.mutableBytes.assumingMemoryBound(to: CChar.self)
+
+        // Encrypt or decrypt the input data
+        ccStatus = CCCryptorUpdate(
+            cryptor!,
+            dataIn.bytes, dataIn.count,
+            dataOutPointer, dataOutLength,
+            &dataOutMoved)
+        dataOutMovedTotal += dataOutMoved
+
+        if ccStatus != kCCSuccess {
+            if error != nil {
+                error = NSError(domain: "kUpdateError", code: Int(ccStatus), userInfo: nil)
+            }
+            CCCryptorRelease(cryptor!)
+            return nil
+        }
+
+        // Finalize the encryption or decryption
+        ccStatus = CCCryptorFinal(
+            cryptor!,
+            dataOutPointer + dataOutMoved, dataOutLength - dataOutMoved,
+            &dataOutMoved)
+        if ccStatus != kCCSuccess {
+            if error != nil {
+                error = NSError(domain: "kFinalError", code: Int(ccStatus), userInfo: nil)
+            }
+            CCCryptorRelease(cryptor!)
+            return nil
+        }
+
+        dataOutMovedTotal += dataOutMoved
+        dataOut.length = dataOutMovedTotal
+
+        return (dataOut as Data)
+    }
+
+    /**
+     Copies the contents of an array of elements starting at a specified index to an UnsafeMutableRawPointer.
+
+     - Parameters:
+        - to: An UnsafeMutableRawPointer to which the elements will be copied.
+        - from: An array of elements to copy.
+        - startIndexAtPointer: The starting index in bytes at which to copy the elements to the destination pointer.
+     */
+    func copyMemoryStartingAtIndex<T>(to umrp: UnsafeMutableRawPointer, from arr: [T], startIndexAtPointer toIndex: Int) {
+        // Calculate the byte offset from the destination pointer based on the starting index.
+        let byteOffset = MemoryLayout<T>.stride * toIndex
+        // Calculate the total number of bytes that need to be copied based on the size of each element in the array.
+        let byteCount = MemoryLayout<T>.stride * arr.count
+
+        // Use the `copyMemory` method of the destination pointer to copy the bytes from the source array to the destination pointer.
+        // The `advanced(by:)` method is used to move the pointer to the correct starting index before copying.
+        umrp.advanced(by: byteOffset).copyMemory(from: arr, byteCount: byteCount)
+    }
+}

ESPProvision/Crypto/CryptoAES.swift

@@ -30,13 +30,13 @@ class CryptoAES {
     public init(key: Data, iv: Data) {
         self.key = key
         self.iv = iv
-        decryptor = AESDecryptor(key: key, andIV: iv)
+        decryptor = AESDecryptor(key: key, iv: iv)
     }
 
     func encrypt(data: Data) -> Data? {
         var returnData: Data?
         var error: NSError?
-        returnData = decryptor.cryptData(data, operation: CCOperation(kCCEncrypt), mode: CCMode(kCCModeCTR), algorithm: CCAlgorithm(kCCAlgorithmAES), padding: CCPadding(ccNoPadding), keyLength: kCCKeySizeAES256, iv: iv, key: key, error: &error)
+        returnData = decryptor.cryptData(dataIn: data, operation: CCOperation(kCCEncrypt), mode: CCMode(kCCModeCTR), algorithm: CCAlgorithm(kCCAlgorithmAES), padding: CCPadding(ccNoPadding), keyLength: kCCKeySizeAES256, iv: iv, key: key, error: &error)
         return returnData
     }
 }

ESPProvision/Crypto/ESPSecurity0.swift

@@ -89,10 +89,10 @@ class ESPSecurity0: ESPCodeable {
         ESPLog.log("Generating Step 0 request data...")
 
         var request: Data?
-        var sessionData = Espressif_SessionData()
+        var sessionData = SessionData()
         sessionData.secVer = .secScheme0
         do {
-            try sessionData.sec0.sc.merge(serializedData: Espressif_S0SessionCmd().serializedData())
+            try sessionData.sec0.sc.merge(serializedData: S0SessionCmd().serializedData())
             request = try? sessionData.serializedData()
         } catch {
             ESPLog.log("Serializing Step0 request throws error.")
@@ -116,7 +116,7 @@ class ESPSecurity0: ESPCodeable {
         }
 
         ESPLog.log("Serializing Step0 response.")
-        let sessionData = try Espressif_SessionData(serializedData: response)
+        let sessionData = try SessionData(serializedData: response)
         if sessionData.secVer != .secScheme0 {
             ESPLog.log("Security version mismatch.")
             throw SecurityError.handshakeError("Security version mismatch")