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

package/README.md

@@ -10,12 +10,17 @@ npm install @pagopa/io-react-native-iso18013
 
 ## Usage
 
-Each module is documented in its own README file:
+This library includes two native modules for both iOS and Android:
 
-- [ISO18013-5](src/iso18013/iso18013-5/README.md): Proximity presentation according to the ISO 18013-5 standard;
-- [ISO18013-7](src/iso18013/iso18013-7/README.md): Remote presentation according to the ISO 18013-7 standard;
-- [CBOR](src/cbor/cbor/README.md): Decoding of CBOR data into readable objects;
-- [COSE](src/cbor/cose/README.md): Management of COSE verify and sign operations.
+- [IoReactNativeIso18013](src/iso18013/iso18013-5/proximity.ts) for ISO 18013-5 and ISO 18013-7 implementations;
+- [IoReactNativeCbor](src/cbor/cbor.ts) for CBOR and COSE implementations.
+
+On the javascript side, the library exposes the following modules:
+
+- [ISO18013-5](src/iso18013/iso18013-5/README.md): Proximity presentation according to the ISO 18013-5 standard which is part of the `IoReactNativeIso18013` module;
+- [ISO18013-7](src/iso18013/iso18013-7/README.md): Remote presentation according to the ISO 18013-7 standard which is part of the `IoReactNativeIso18013` module;
+- [CBOR](src/cbor/cbor/README.md): Decoding of CBOR data into readable objects which is part of the `IoReactNativeCbor` module;
+- [COSE](src/cbor/cose/README.md): Management of COSE verify and sign operations which is part of the `IoReactNativeCbor` module.
 
 ## Contributing
 

package/android/build.gradle

@@ -65,6 +65,12 @@ android {
     sourceCompatibility JavaVersion.VERSION_1_8
     targetCompatibility JavaVersion.VERSION_1_8
   }
+
+   testOptions {
+      unitTests.all {
+          useJUnit()
+      }
+    }
 }
 
 repositories {
@@ -79,5 +85,5 @@ dependencies {
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
   implementation "it.pagopa.io.wallet.proximity:proximity:2.1.0"
   implementation "it.pagopa.io.wallet.cbor:cbor:1.3.0"
+  testImplementation('junit:junit:4.13.2')
 }
-

package/android/src/main/java/com/ioreactnativeiso18013/IoReactNativeCborModule.kt

@@ -5,10 +5,7 @@ import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReadableMap
-import com.facebook.react.bridge.WritableMap
-import com.facebook.react.bridge.WritableNativeMap
 import it.pagopa.io.wallet.cbor.cose.COSEManager
-import it.pagopa.io.wallet.cbor.cose.FailureReason
 import it.pagopa.io.wallet.cbor.cose.SignWithCOSEResult
 import it.pagopa.io.wallet.cbor.parser.CBorParser
 
@@ -19,125 +16,87 @@ class IoReactNativeCborModule(reactContext: ReactApplicationContext) :
     return NAME
   }
 
+  /**
+   * 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.
+   * @param data the base64 or base64url encoded CBOR string
+   */
   @ReactMethod
   fun decode(data: String, promise: Promise) {
-    val buffer = try {
-      Base64Utils.decodeBase64AndBase64Url(data)
-    } catch (e: Exception) {
-      ModuleException.INVALID_ENCODING.reject(
-        promise,
-        Pair(ERROR_USER_INFO_KEY, e.message.orEmpty())
-      )
-      return;
-    }
-
     try {
-      CBorParser(buffer).toJson()?.let {
-        promise.resolve(it)
-      } ?: run {
-        ModuleException.UNABLE_TO_DECODE.reject(promise)
-      }
+      val buffer = Base64Utils.decodeBase64AndBase64Url(data)
+      val result = CBorParser(buffer).toJson()
+      promise.resolve(result)
     } catch (e: Exception) {
-      ModuleException.UNKNOWN_EXCEPTION.reject(
-        promise,
-        Pair(ERROR_USER_INFO_KEY, e.message.orEmpty())
-      )
+      promise.reject(ModuleErrorCodes.DECODE_ERROR, e.message, e)
     }
   }
 
+  /**
+   * 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
+   * @param data the base64 or base64url encoded mDOC-CBOR string
+   */
   @ReactMethod
   fun decodeDocuments(data: String, promise: Promise) {
-    val buffer = try {
-      Base64Utils.decodeBase64AndBase64Url(data)
-    } catch (e: Exception) {
-      ModuleException.INVALID_ENCODING.reject(
-        promise,
-        Pair(ERROR_USER_INFO_KEY, e.message.orEmpty())
-      )
-      return;
-    }
     try {
+      val buffer = Base64Utils.decodeBase64AndBase64Url(data)
       CBorParser(buffer).documentsCborToJson(separateElementIdentifier = true, onComplete = {
         promise.resolve(it)
-      }) { ex ->
-        ModuleException.UNABLE_TO_DECODE.reject(
-          promise,
-          Pair(ERROR_USER_INFO_KEY, ex.message.orEmpty())
-        )
-      }
+      }, onError = { e ->
+        promise.reject(ModuleErrorCodes.DECODE_DOCUMENTS_ERROR, e.message, e)
+      })
     } catch (e: Exception) {
-      ModuleException.UNKNOWN_EXCEPTION.reject(
-        promise,
-        Pair(ERROR_USER_INFO_KEY, e.message.orEmpty())
-      )
+      promise.reject(ModuleErrorCodes.DECODE_DOCUMENTS_ERROR, e.message, e)
     }
   }
 
+  /**
+   * Decode base64 or base64url encoded issuerSigned attribute part of an mDOC-CBOR.
+   * @param data the base64 or base64url encoded mDOC-CBOR containing the issuerSigned data string
+   * Resolves with a string containing the parsed data or rejects with an error code
+   * defined in [ModuleErrorCodes].
+   */
   @ReactMethod
-  fun decodeIssuerSigned(issuerSigned: String, promise: Promise) {
-    val buffer = try {
-      Base64Utils.decodeBase64AndBase64Url(issuerSigned)
-    } catch (e: Exception) {
-      ModuleException.INVALID_ENCODING.reject(
-        promise,
-        Pair(ERROR_USER_INFO_KEY, e.message.orEmpty())
-      )
-      return;
-    }
+  fun decodeIssuerSigned(data: String, promise: Promise) {
     try {
-      CBorParser(buffer).issuerSignedCborToJson(separateElementIdentifier = true).let {
-        if (it == null) {
-          ModuleException.UNABLE_TO_DECODE.reject(
-            promise,
-            Pair(ERROR_USER_INFO_KEY, "Unable to decode passed CBOR")
+      val buffer =
+        Base64Utils.decodeBase64AndBase64Url(data)
+      val result =
+        CBorParser(buffer).issuerSignedCborToJson(separateElementIdentifier = true) ?: run {
+          // We don't have the exact error here for some reason
+          promise.reject(
+            ModuleErrorCodes.DECODE_ISSUER_SIGNED_ERROR,
+            "An error occurred while decoding the issuer signed content"
           )
-          return
         }
-        promise.resolve(it)
-      }
+      promise.resolve(result)
     } catch (e: Exception) {
-      ModuleException.UNKNOWN_EXCEPTION.reject(
-        promise,
-        Pair(ERROR_USER_INFO_KEY, e.message.orEmpty())
-      )
+      promise.reject(ModuleErrorCodes.DECODE_ISSUER_SIGNED_ERROR, e.message, e)
     }
   }
 
+  /**
+   * 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].
+   * @param data the base64 or base64url encoded payload to sign
+   * @param keyTag the alias of the key to use for signing.
+   */
   @ReactMethod
-  fun sign(payload: String, keyTag: String, promise: Promise) {
-    val data = try {
-      Base64Utils.decodeBase64AndBase64Url(payload)
-    } catch (e: Exception) {
-      ModuleException.INVALID_ENCODING.reject(
-        promise,
-        Pair(ERROR_USER_INFO_KEY, e.message.orEmpty())
-      )
-      return;
-    }
-
+  fun sign(data: String, keyTag: String, promise: Promise) {
     try {
+      val buffer = Base64Utils.decodeBase64AndBase64Url(data)
       val result = COSEManager().signWithCOSE(
-        data = data,
+        data = buffer,
         alias = keyTag
       )
       when (result) {
         is SignWithCOSEResult.Failure -> {
-          when (result.reason) {
-            FailureReason.NO_KEY -> ModuleException.PUBLIC_KEY_NOT_FOUND.reject(
-              promise,
-              Pair(ERROR_USER_INFO_KEY, result.reason.msg)
-            )
-
-            FailureReason.FAIL_TO_SIGN -> ModuleException.UNABLE_TO_SIGN.reject(
-              promise,
-              Pair(ERROR_USER_INFO_KEY, result.reason.msg)
-            )
-
-            else -> ModuleException.UNKNOWN_EXCEPTION.reject(
-              promise,
-              Pair(ERROR_USER_INFO_KEY, result.reason.msg)
-            )
-          }
+          // We don't have a throwable to pass here from the onError callback
+          promise.reject(ModuleErrorCodes.SIGN_ERROR, result.reason.msg)
         }
 
         is SignWithCOSEResult.Success -> {
@@ -145,65 +104,41 @@ class IoReactNativeCborModule(reactContext: ReactApplicationContext) :
         }
       }
     } catch (e: Exception) {
-      ModuleException.UNKNOWN_EXCEPTION.reject(
-        promise,
-        Pair(ERROR_USER_INFO_KEY, e.message.orEmpty())
-      )
+      promise.reject(ModuleErrorCodes.SIGN_ERROR, e.message, e)
     }
   }
 
+  /**
+   * Verifies a COSE-Sign1 object with the provided public key.
+   * Resolves with a boolean indicating whether or not the verification succeeded or not or rejects
+   * with an error code defined in [ModuleErrorCodes].
+   * @param data the COSE-Sign1 object in base64 or base64url encoding
+   * @param publicKey the public key in JWK format
+   */
   @ReactMethod
-  fun verify(sign1Data: String, publicKey: ReadableMap, promise: Promise) {
-    val data = try {
-      Base64Utils.decodeBase64AndBase64Url(sign1Data)
-    } catch (e: Exception) {
-      ModuleException.INVALID_ENCODING.reject(
-        promise,
-        Pair(ERROR_USER_INFO_KEY, e.message.orEmpty())
-      )
-      return;
-    }
-
+  fun verify(data: String, publicKey: ReadableMap, promise: Promise) {
     try {
+      val buffer = Base64Utils.decodeBase64AndBase64Url(data)
       val result = COSEManager().verifySign1FromJWK(
-        dataSigned = data,
+        dataSigned = buffer,
         jwk = publicKey.toString()
       )
       promise.resolve(result)
     } catch (e: Exception) {
-      ModuleException.UNKNOWN_EXCEPTION.reject(
-        promise,
-        Pair(ERROR_USER_INFO_KEY, e.message.orEmpty())
-      )
+      promise.reject(ModuleErrorCodes.VERIFY_ERROR, e.message, e)
     }
   }
 
   companion object {
     const val NAME = "IoReactNativeCbor"
-    const val ERROR_USER_INFO_KEY = "error"
-
-    private enum class ModuleException(
-      val ex: Exception
-    ) {
-      UNABLE_TO_DECODE(Exception("UNABLE_TO_DECODE")),
-      PUBLIC_KEY_NOT_FOUND(Exception("PUBLIC_KEY_NOT_FOUND")),
-      UNABLE_TO_SIGN(Exception("UNABLE_TO_SIGN")),
-      INVALID_ENCODING(Exception("INVALID_ENCODING")),
-      UNKNOWN_EXCEPTION(Exception("UNKNOWN_EXCEPTION"));
 
-      fun reject(
-        promise: Promise, vararg args: Pair<String, String>
-      ) {
-        exMap(*args).let {
-          promise.reject(it.first, ex.message, it.second)
-        }
-      }
-
-      private fun exMap(vararg args: Pair<String, String>): Pair<String, WritableMap> {
-        val writableMap = WritableNativeMap()
-        args.forEach { writableMap.putString(it.first, it.second) }
-        return Pair(this.ex.message ?: "UNKNOWN", writableMap)
-      }
+    // Errors which this module uses to reject a promise
+    private object ModuleErrorCodes {
+      const val DECODE_ERROR = "DECODE_ERROR"
+      const val DECODE_DOCUMENTS_ERROR = "DECODE_DOCUMENTS_ERROR"
+      const val DECODE_ISSUER_SIGNED_ERROR = "DECODE_ISSUER_SIGNED_ERROR"
+      const val SIGN_ERROR = "SIGN_ERROR"
+      const val VERIFY_ERROR = "VERIFY_ERROR"
     }
   }
 }