@pagopa/io-react-native-iso18013 0.3.0 → 0.5.0

package/ios/IoReactNativeCbor.swift

@@ -4,185 +4,163 @@ import CryptoKit
 
 @objc(IoReactNativeCbor)
 class IoReactNativeCbor: NSObject {
-  private typealias ME = ModuleException
-  private let keyConfig: KeyConfig = .ec
   
-  @objc func decode(
-    _ cbor: String,
+  /**
+   Decode base64 or base64url encoded CBOR data to JSON object.
+   Resolves with a string containing the parsed data or rejects with an error code defined in ``ModuleErrorCodes``.
+   This method does not handle nested CBOR data, which will need additional parsing.
+   - Parameters:
+      - data: The base64 or base64url encoded CBOR string.
+      - resolve: The promise to be resolved.
+      - reject: The promise to be rejected.
+   */
+  @objc(decode:withResolver:withRejecter:)
+  func decode(
+    data: String,
     resolver resolve: RCTPromiseResolveBlock,
     rejecter reject: RCTPromiseRejectBlock
   ) {
-    guard let data = try? Base64Utils.decodeBase64OrBase64URL(base: cbor) else {
-      ME.invalidEncoding.reject(reject: reject)
-      return
-    }
-    
-    guard let json = CborCose.jsonFromCBOR(data: data) else {
-      ME.unableToDecode.reject(reject: reject)
-      return
+    do{
+      let buffer = try Base64Utils.decodeBase64OrBase64URL(base: data)
+      guard let json = CborCose.jsonFromCBOR(data: buffer) else {
+        // We don't have the exact error here as this method returns nil upon failure
+        reject(ModuleErrorCodes.decodeError.rawValue, "Unable to decode CBOR", nil)
+        return
+      }
+      resolve(json);
+      
+    }catch{
+      reject(ModuleErrorCodes.decodeError.rawValue, error.localizedDescription, error)
     }
-    
-    resolve(json);
   }
   
-  
-  @objc func decodeDocuments(
-    _ mdoc: String,
+  /**
+   Decode base64 or base64url encoded mDOC-CBOR data to a JSON object.
+   Resolves with a string containing the parsed data or rejects with an error code defined in ``ModuleErrorCodes``.
+   - Parameters:
+      - data: The base64 or base64url encoded mDOC-CBOR string.
+      - resolve: The promise to be resolved.
+      - reject: The promise to be rejected.
+   */
+  @objc(decodeDocuments:withResolver:withRejecter:)
+  func decodeDocuments(
+    data: String,
     resolver resolve: RCTPromiseResolveBlock,
     rejecter reject: RCTPromiseRejectBlock
   ) {
-    guard let data = try? Base64Utils.decodeBase64OrBase64URL(base: mdoc) else {
-        ME.invalidEncoding.reject(reject: reject)
+    do{
+      let buffer = try Base64Utils.decodeBase64OrBase64URL(base: data)
+      guard let json = CborCose.decodeCBOR(data: buffer, true, true) else {
+        // We don't have the exact error here as this method returns nil upon failure
+        reject(ModuleErrorCodes.decodeDocumentsError.rawValue, "Unable to decode document CBOR", nil)
         return
+      }
+      resolve(json);
+    }catch{
+      reject(ModuleErrorCodes.decodeDocumentsError.rawValue, error.localizedDescription, error)
     }
-    
-    guard let json = CborCose.decodeCBOR(data: data, true, true) else {
-      ME.unableToDecode.reject(reject: reject)
-      return
-    }
-    
-    resolve(json);
   }
   
-  @objc func decodeIssuerSigned(
-    _ issuerSigned: String,
+  /**
+   Decode base64 or base64url encoded issuerSigned attribute part of an mDOC-CBOR.
+   Resolves with a string containing the parsed data or rejects with an error code defined in ``ModuleErrorCodes``.
+   - Parameters:
+      - data: The base64 or base64url encoded mDOC-CBOR containing the issuerSigned data string.
+      - resolve: The promise to be resolved.
+      - reject: The promise to be rejected.
+   */
+  @objc(decodeIssuerSigned:withResolver:withRejecter:)
+  func decodeIssuerSigned(
+    data: String,
     resolver resolve: RCTPromiseResolveBlock,
     rejecter reject: RCTPromiseRejectBlock
   ) {
-    guard let data = try? Base64Utils.decodeBase64OrBase64URL(base: issuerSigned) else {
-        ME.invalidEncoding.reject(reject: reject)
+    do{
+      let buffer = try Base64Utils.decodeBase64OrBase64URL(base: data)
+      guard let json = CborCose.issuerSignedCborToJson(data: buffer) else {
+        // We don't have the exact error here as this method returns nil upon failure
+        reject(ModuleErrorCodes.decodeIssuerSignedError.rawValue, "Unable to decode Issuer Signed CBOR", nil)
         return
+      }
+      resolve(json);
+    }catch{
+      reject(ModuleErrorCodes.decodeIssuerSignedError.rawValue, error.localizedDescription, error)
     }
-    
-    guard let json = CborCose.issuerSignedCborToJson(data: data) else {
-      ME.unableToDecode.reject(reject: reject)
-      return
-    }
-    
-    resolve(json);
   }
   
-  @objc func sign(
-    _ payloadData: String,
+  /**
+   Sign base64 encoded data with COSE and return the COSE-Sign1 object in base64 encoding.
+   Resolves with a string containing the COSE-Sign1 object in base64 encoding or rejects with an error code defined in ``ModuleErrorCodes``.
+   - Parameters:
+     - data: The base64 or base64url encoded payload to sign.
+     - keyTag: The alias of the key to use for signing.
+     - resolve: The promise to be resolved.
+     - reject: The promise to be rejected.
+   */
+  @objc(sign:withKeyTag:withResolver:withRejecter:)
+  func sign(
+    data: String,
     keyTag: String,
     resolver resolve: @escaping RCTPromiseResolveBlock,
     rejecter reject: @escaping RCTPromiseRejectBlock
   ) {
-    DispatchQueue.global().async { [weak self] in
-      guard self != nil else {
-        ME.threadingError.reject(reject: reject)
-        return
+      DispatchQueue.global().async { [weak self] in
+        guard self != nil else {
+          reject(ModuleErrorCodes.threadingError.rawValue, "Failed to perform background operation, self was deallocated", nil)
+          return
+        }
+        
+        do{
+          let buffer = try Base64Utils.decodeBase64OrBase64URL(base: data)
+          guard let coseKey = CoseKeyPrivate(crv: .p256, keyTag: keyTag) else {
+            // We don't have the exact error here as this method returns nil upon failure
+            reject(ModuleErrorCodes.signError.rawValue, "Unable to create a private key with the given keytag: \(keyTag)", nil)
+            return
+          }
+          let signedPayload = CborCose.sign(data: buffer, privateKey: coseKey)
+          resolve(signedPayload.base64EncodedString())
       }
-      
-      guard let data = try? Base64Utils.decodeBase64OrBase64URL(base: payloadData) else {
-        ME.invalidEncoding.reject(reject: reject)
-        return
+      catch{
+        reject(ModuleErrorCodes.signError.rawValue, error.localizedDescription, error)
       }
-      
-      guard let coseKey = CoseKeyPrivate(crv: .p256, keyTag: keyTag) else {
-        ME.publicKeyNotFound.reject(reject: reject)
-        return
-      }
-      
-      let signedPayload = CborCose.sign(data: data, privateKey: coseKey)
-      resolve(signedPayload.base64EncodedString())
     }
   }
   
-  @objc func verify(
-    _ sign1Data: String,
-    jwk: NSDictionary,
+  /**
+   Verifies a COSE-Sign1 object with the provided public key.
+   Resolves with boolean indicating whether or not the verification succeeded or not or rejects with an error code defined in ``ModuleErrorCodes``.
+   - Parameters:
+      - data: The COSE-Sign1 object in base64 or base64url encoding.
+      - publicKey: The public key in JWK format.
+      - resolve: The promise to be resolved
+      - reject: The promise to be rejected..
+   */
+  @objc(verify:withJwk:withResolver:withRejecter:)
+  func verify(
+    data: String,
+    publicKey: NSDictionary,
     resolver resolve: RCTPromiseResolveBlock,
     rejecter reject: RCTPromiseRejectBlock
   ) {
     do {
-      guard let data = try? Base64Utils.decodeBase64OrBase64URL(base: sign1Data) else {
-        ME.invalidEncoding.reject(reject: reject)
-        return
-      }
-      
-      let publicKeyJson = try JSONSerialization.data(withJSONObject: jwk, options:[] )
+      let buffer = try Base64Utils.decodeBase64OrBase64URL(base: data)
+      let publicKeyJson = try JSONSerialization.data(withJSONObject: publicKey, options:[] )
       let publicKeyString = String(data: publicKeyJson, encoding: .utf8)!
       let publicKey = CoseKey(jwk: publicKeyString)!
-      
-      let verified = CborCose.verify(data: data, publicKey: publicKey)
-      
+      let verified = CborCose.verify(data: buffer, publicKey: publicKey)
       resolve(verified)
     } catch {
-      ME.unknownException.reject(reject: reject)
+      reject(ModuleErrorCodes.verifyError.rawValue, error.localizedDescription, error)
     }
   }
-    
-  private func keyExists(keyTag: String) -> (key: SecKey?, status: OSStatus) {
-    let getQuery = privateKeyKeychainQuery(keyTag: keyTag)
-    var item: CFTypeRef?
-    let status = SecItemCopyMatching(getQuery as CFDictionary, &item)
-    return (status == errSecSuccess ? (item as! SecKey) : nil, status)
-  }
   
-  private func privateKeyKeychainQuery(
-    keyTag: String
-  ) -> [String : Any] {
-    return [
-      kSecClass as String: kSecClassKey,
-      kSecAttrApplicationTag as String: keyTag,
-      kSecAttrKeyType as String: keyConfig.keyType(),
-      kSecReturnRef as String: true
-    ]
-  }
-  
-  private enum KeyConfig: Int, CaseIterable {
-    case ec
-    
-    func keyType() -> CFString {
-      switch self {
-      case .ec:
-        return kSecAttrKeyTypeECSECPrimeRandom
-      }
-    }
-    
-    func keySizeInBits() -> Int {
-      switch self {
-      case .ec:
-        return 256
-      }
-    }
-    
-    func keySignAlgorithm() -> SecKeyAlgorithm {
-      switch self {
-      case .ec:
-        return .ecdsaSignatureMessageX962SHA256
-      }
-    }
-  }
-  
-  private enum ModuleException: String, CaseIterable {
-    case unableToDecode = "UNABLE_TO_DECODE"
-    case publicKeyNotFound = "PUBLIC_KEY_NOT_FOUND"
-    case invalidEncoding = "INVALID_ENCODING"
+  // Errors which this module uses to reject a promise
+  private enum ModuleErrorCodes: String, CaseIterable {
+    case decodeError = "DECODE_ERROR"
+    case decodeDocumentsError = "DECODE_DOCUMENTS_ERROR"
+    case decodeIssuerSignedError = "DECODE_ISSUER_SIGNED_ERROR"
+    case signError = "SIGN_ERROR"
+    case verifyError = "VERIFY_ERROR"
     case threadingError = "THREADING_ERROR"
-    case unknownException = "UNKNOWN_EXCEPTION"
-    
-    func error(userInfo: [String : Any]? = nil) -> NSError {
-      switch self {
-      case .unableToDecode:
-        return NSError(domain: self.rawValue, code: -1, userInfo: userInfo)
-      case .publicKeyNotFound:
-        return NSError(domain: self.rawValue, code: -1, userInfo: userInfo)
-      case .invalidEncoding:
-        return NSError(domain: self.rawValue, code: -1, userInfo: userInfo)
-      case .threadingError:
-        return NSError(domain: self.rawValue, code: -1, userInfo: userInfo)
-      case .unknownException:
-        return NSError(domain: self.rawValue, code: -1, userInfo: userInfo)
-      }
-    }
-    
-    func reject(reject: RCTPromiseRejectBlock, _ moreUserInfo: (String, Any)...) {
-      var userInfo = [String : Any]()
-      moreUserInfo.forEach { userInfo[$0.0] = $0.1 }
-      let error = error(userInfo: userInfo)
-      reject("\(error.code)", error.domain, error)
-    }
   }
 }

package/ios/IoReactNativeIso18013.mm

@@ -18,22 +18,22 @@ RCT_EXTERN_METHOD(generateResponse:(NSArray *)documents
                  withResolver:(RCTPromiseResolveBlock)resolve
                  withRejecter:(RCTPromiseRejectBlock)reject)
 
-RCT_EXTERN_METHOD(sendResponse:(NSString)response
+RCT_EXTERN_METHOD(sendResponse:(NSString *)response
                  withResolver:(RCTPromiseResolveBlock)resolve
                  withRejecter:(RCTPromiseRejectBlock)reject)
 
-RCT_EXTERN_METHOD(sendErrorResponse:(NSInteger)status
+RCT_EXTERN_METHOD(sendErrorResponse:(NSInteger *)code
                   withResolver:(RCTPromiseResolveBlock)resolve
                   withRejecter:(RCTPromiseRejectBlock)reject)
 
-RCT_EXTERN_METHOD(generateOID4VPDeviceResponse: (NSString)clientId
-                  responseUri: (NSString*)responseUri
-                  authorizationRequestNonce: (NSString*)authorizationRequestNonce
-                  mdocGeneratedNonce: (NSString*)mdocGeneratedNonce
-                  documents: (NSArray*)documents
-                  fieldRequestedAndAccepted: (NSString*)fieldRequestedAndAccepted
-                  resolver: (RCTPromiseResolveBlock)resolve
-                  rejecter: (RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(generateOID4VPDeviceResponse: (NSString *)clientId
+                  withResponseUri: (NSString *)responseUri
+                  withAuthorizationRequestNonce: (NSString *)authorizationRequestNonce
+                  withMdocGeneratedNonce: (NSString *)mdocGeneratedNonce
+                  withDocuments: (NSArray *)documents
+                  withAcceptedFields: (NSDictionary *)acceptedFields
+                  withResolver: (RCTPromiseResolveBlock)resolve
+                  withRejecter: (RCTPromiseRejectBlock)reject)
 
 + (BOOL)requiresMainQueueSetup
 {