@doko/react-native-yubikit 0.0.2

package/android/src/main/java/com/yubikit/YubikitPivModule.kt

@@ -0,0 +1,310 @@
+package com.yubikit
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.yubico.yubikit.piv.PivSession
+import com.yubikit.utils.YubikitUtils.base64Decode
+import com.yubikit.utils.YubikitUtils.base64Encode
+import com.yubikit.utils.YubikitUtils.keyTypeFromString
+import com.yubikit.utils.YubikitUtils.managementKeyTypeFromString
+import com.yubikit.utils.YubikitUtils.pinPolicyFromString
+import com.yubikit.utils.YubikitUtils.slotFromString
+import com.yubikit.utils.YubikitUtils.touchPolicyFromString
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+
+@Suppress("unused")
+class YubikitPivModule(reactContext: ReactApplicationContext) :
+  NativeYubikitPivSpec(reactContext) {
+
+  private val moduleScope = CoroutineScope(Dispatchers.IO)
+
+  override fun getName(): String = NAME
+
+  private inline fun <R> withPivSession(
+    deviceHandle: String,
+    promise: Promise,
+    crossinline block: (PivSession) -> R
+  ) {
+    moduleScope.launch {
+      try {
+        val result = YubiKitManagerHolder.withSmartCard(deviceHandle) { connection ->
+          PivSession(connection).use { session ->
+            block(session)
+          }
+        }
+        @Suppress("UNCHECKED_CAST")
+        when (result) {
+          is Unit -> promise.resolve(null)
+          else -> promise.resolve(result)
+        }
+      } catch (e: Exception) {
+        promise.reject("PIV_ERROR", e.message, e)
+      }
+    }
+  }
+
+  override fun reset(deviceHandle: String, promise: Promise) {
+    withPivSession(deviceHandle, promise) { it.reset() }
+  }
+
+  override fun getSerialNumber(deviceHandle: String, promise: Promise) {
+    withPivSession(deviceHandle, promise) { it.serialNumber }
+  }
+
+  override fun authenticate(deviceHandle: String, managementKey: String, promise: Promise) {
+    withPivSession(deviceHandle, promise) {
+      it.authenticate(base64Decode(managementKey) ?: byteArrayOf())
+    }
+  }
+
+  override fun setManagementKey(
+    deviceHandle: String,
+    keyType: String,
+    managementKey: String,
+    requireTouch: Boolean,
+    promise: Promise
+  ) {
+    withPivSession(deviceHandle, promise) {
+      it.setManagementKey(
+        managementKeyTypeFromString(keyType),
+        base64Decode(managementKey) ?: byteArrayOf(),
+        requireTouch
+      )
+    }
+  }
+
+  override fun verifyPin(deviceHandle: String, pin: String, promise: Promise) {
+    withPivSession(deviceHandle, promise) { it.verifyPin(pin.toCharArray()) }
+  }
+
+  override fun getPinAttempts(deviceHandle: String, promise: Promise) {
+    withPivSession(deviceHandle, promise) { it.pinAttempts }
+  }
+
+  override fun changePin(
+    deviceHandle: String,
+    oldPin: String,
+    newPin: String,
+    promise: Promise
+  ) {
+    withPivSession(deviceHandle, promise) {
+      it.changePin(oldPin.toCharArray(), newPin.toCharArray())
+    }
+  }
+
+  override fun changePuk(
+    deviceHandle: String,
+    oldPuk: String,
+    newPuk: String,
+    promise: Promise
+  ) {
+    withPivSession(deviceHandle, promise) {
+      it.changePuk(oldPuk.toCharArray(), newPuk.toCharArray())
+    }
+  }
+
+  override fun unblockPin(
+    deviceHandle: String,
+    puk: String,
+    newPin: String,
+    promise: Promise
+  ) {
+    withPivSession(deviceHandle, promise) {
+      it.unblockPin(puk.toCharArray(), newPin.toCharArray())
+    }
+  }
+
+  override fun setPinAttempts(
+    deviceHandle: String,
+    pinAttempts: Double,
+    pukAttempts: Double,
+    promise: Promise
+  ) {
+    withPivSession(deviceHandle, promise) {
+      it.setPinAttempts(pinAttempts.toInt(), pukAttempts.toInt())
+    }
+  }
+
+  override fun getPinMetadata(deviceHandle: String, promise: Promise) {
+    moduleScope.launch {
+      try {
+        val meta = YubiKitManagerHolder.withSmartCard(deviceHandle) { connection ->
+          PivSession(connection).use { session ->
+            session.pinMetadata
+          }
+        }
+        promise.resolve(Arguments.createMap().apply {
+          putInt("attemptsRemaining", meta.attemptsRemaining)
+        })
+      } catch (e: Exception) {
+        promise.reject("PIV_ERROR", e.message, e)
+      }
+    }
+  }
+
+  override fun getPukMetadata(deviceHandle: String, promise: Promise) {
+    moduleScope.launch {
+      try {
+        val meta = YubiKitManagerHolder.withSmartCard(deviceHandle) { connection ->
+          PivSession(connection).use { session ->
+            session.pukMetadata
+          }
+        }
+        promise.resolve(Arguments.createMap().apply {
+          putInt("attemptsRemaining", meta.attemptsRemaining)
+        })
+      } catch (e: Exception) {
+        promise.reject("PIV_ERROR", e.message, e)
+      }
+    }
+  }
+
+  override fun getManagementKeyMetadata(deviceHandle: String, promise: Promise) {
+    moduleScope.launch {
+      try {
+        val meta = YubiKitManagerHolder.withSmartCard(deviceHandle) { connection ->
+          PivSession(connection).use { session ->
+            session.managementKeyMetadata
+          }
+        }
+        promise.resolve(Arguments.createMap().apply {
+          putString("keyType", com.yubikit.utils.YubikitUtils.managementKeyTypeToString(meta.keyType))
+          putBoolean("defaultValue", meta.isDefaultValue)
+          // The JS-facing type is `touchRequired: boolean`, not the raw TouchPolicy
+          // string used by getSlotMetadata - DEFAULT/NEVER both mean "not required".
+          putBoolean(
+            "touchRequired",
+            meta.touchPolicy != com.yubico.yubikit.piv.TouchPolicy.DEFAULT &&
+              meta.touchPolicy != com.yubico.yubikit.piv.TouchPolicy.NEVER
+          )
+        })
+      } catch (e: Exception) {
+        promise.reject("PIV_ERROR", e.message, e)
+      }
+    }
+  }
+
+  override fun getSlotMetadata(deviceHandle: String, slot: String, promise: Promise) {
+    moduleScope.launch {
+      try {
+        val meta = YubiKitManagerHolder.withSmartCard(deviceHandle) { connection ->
+          PivSession(connection).use { session ->
+            session.getSlotMetadata(slotFromString(slot))
+          }
+        }
+        promise.resolve(Arguments.createMap().apply {
+          putString("keyType", com.yubikit.utils.YubikitUtils.keyTypeToString(meta.keyType))
+          putString("pinPolicy", com.yubikit.utils.YubikitUtils.pinPolicyToString(meta.pinPolicy))
+          putString("touchPolicy", com.yubikit.utils.YubikitUtils.touchPolicyToString(meta.touchPolicy))
+          putBoolean("generated", meta.isGenerated)
+          meta.publicKeyValues?.let { putString("publicKey", base64Encode(it.encoded)) }
+        })
+      } catch (e: Exception) {
+        promise.reject("PIV_ERROR", e.message, e)
+      }
+    }
+  }
+
+  override fun getCertificate(deviceHandle: String, slot: String, promise: Promise) {
+    withPivSession(deviceHandle, promise) {
+      base64Encode(it.getCertificate(slotFromString(slot)).encoded)
+    }
+  }
+
+  override fun putCertificate(
+    deviceHandle: String,
+    slot: String,
+    certificate: String,
+    compress: Boolean?,
+    promise: Promise
+  ) {
+    withPivSession(deviceHandle, promise) {
+      val cert = java.security.cert.CertificateFactory.getInstance("X.509")
+        .generateCertificate(
+          java.io.ByteArrayInputStream(base64Decode(certificate) ?: byteArrayOf())
+        ) as java.security.cert.X509Certificate
+      if (compress == true) {
+        it.putCertificate(slotFromString(slot), cert, true)
+      } else {
+        it.putCertificate(slotFromString(slot), cert)
+      }
+    }
+  }
+
+  override fun deleteCertificate(deviceHandle: String, slot: String, promise: Promise) {
+    withPivSession(deviceHandle, promise) { it.deleteCertificate(slotFromString(slot)) }
+  }
+
+  override fun attestKey(deviceHandle: String, slot: String, promise: Promise) {
+    withPivSession(deviceHandle, promise) {
+      base64Encode(it.attestKey(slotFromString(slot)).encoded)
+    }
+  }
+
+  override fun generateKey(
+    deviceHandle: String,
+    slot: String,
+    keyType: String,
+    pinPolicy: String,
+    touchPolicy: String,
+    promise: Promise
+  ) {
+    withPivSession(deviceHandle, promise) {
+      val publicKey = it.generateKey(
+        slotFromString(slot),
+        keyTypeFromString(keyType),
+        pinPolicyFromString(pinPolicy),
+        touchPolicyFromString(touchPolicy)
+      )
+      base64Encode(publicKey.encoded)
+    }
+  }
+
+  override fun deleteKey(deviceHandle: String, slot: String, promise: Promise) {
+    withPivSession(deviceHandle, promise) { it.deleteKey(slotFromString(slot)) }
+  }
+
+  override fun rawSignOrDecrypt(
+    deviceHandle: String,
+    slot: String,
+    keyType: String,
+    payload: String,
+    promise: Promise
+  ) {
+    withPivSession(deviceHandle, promise) {
+      base64Encode(
+        it.rawSignOrDecrypt(
+          slotFromString(slot),
+          keyTypeFromString(keyType),
+          base64Decode(payload) ?: byteArrayOf()
+        )
+      )
+    }
+  }
+
+  override fun getBioMetadata(deviceHandle: String, promise: Promise) {
+    moduleScope.launch {
+      try {
+        val meta = YubiKitManagerHolder.withSmartCard(deviceHandle) { connection ->
+          PivSession(connection).use { session ->
+            session.bioMetadata
+          }
+        }
+        promise.resolve(Arguments.createMap().apply {
+          putInt("attemptsRemaining", meta.attemptsRemaining)
+          putBoolean("configured", meta.isConfigured)
+          putBoolean("temporaryPin", meta.hasTemporaryPin())
+        })
+      } catch (e: Exception) {
+        promise.reject("PIV_ERROR", e.message, e)
+      }
+    }
+  }
+
+  companion object {
+    const val NAME = "YubikitPiv"
+  }
+}

package/android/src/main/java/com/yubikit/YubikitSupportModule.kt

@@ -0,0 +1,108 @@
+package com.yubikit
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.yubico.yubikit.android.transport.usb.UsbYubiKeyDevice
+import com.yubico.yubikit.core.Transport
+import com.yubico.yubikit.core.UsbPid
+import com.yubico.yubikit.core.YubiKeyType
+import com.yubico.yubikit.core.fido.FidoConnection
+import com.yubico.yubikit.core.otp.OtpConnection
+import com.yubico.yubikit.core.smartcard.SmartCardConnection
+import com.yubico.yubikit.support.DeviceUtil
+import com.yubikit.utils.YubikitUtils.deviceInfoToMap
+import com.yubikit.utils.YubikitUtils.formFactorToString
+import com.yubikit.utils.YubikitUtils.versionToMap
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+
+@Suppress("unused")
+class YubikitSupportModule(reactContext: ReactApplicationContext) :
+  NativeYubikitSupportSpec(reactContext) {
+
+  private val moduleScope = CoroutineScope(Dispatchers.IO)
+
+  override fun getName(): String = NAME
+
+  override fun readInfo(deviceHandle: String, pid: Double?, promise: Promise) {
+    moduleScope.launch {
+      try {
+        val device = YubiKitManagerHolder.getDevice(deviceHandle)
+        // The USB PID is required by DeviceUtil.readInfo whenever the connection is
+        // over USB. Prefer an explicitly supplied pid, but fall back to the one the
+        // Android USB device itself already knows, since callers shouldn't need to
+        // plumb this Android-specific detail through the JS API.
+        val usbPid = pid?.toInt()?.let { UsbPid.fromValue(it) }
+          ?: (device as? UsbYubiKeyDevice)?.pid
+        val info = when {
+          device.supportsConnection(SmartCardConnection::class.java) ->
+            YubiKitManagerHolder.withSmartCard(deviceHandle) { connection ->
+              DeviceUtil.readInfo(connection, usbPid)
+            }
+          device.supportsConnection(OtpConnection::class.java) ->
+            YubiKitManagerHolder.withOtp(deviceHandle) { connection ->
+              DeviceUtil.readInfo(connection, usbPid)
+            }
+          device.supportsConnection(FidoConnection::class.java) ->
+            YubiKitManagerHolder.withFido(deviceHandle) { connection ->
+              DeviceUtil.readInfo(connection, usbPid)
+            }
+          else -> throw IllegalArgumentException("Device does not support any known connection type")
+        }
+        promise.resolve(deviceInfoToMap(info))
+      } catch (e: Exception) {
+        promise.reject("SUPPORT_ERROR", e.message, e)
+      }
+    }
+  }
+
+  override fun getName(info: com.facebook.react.bridge.ReadableMap, keyType: String?): String {
+    val deviceInfo = parseDeviceInfo(info)
+    val ykType = keyType?.let { YubiKeyType.valueOf(it) }
+    return DeviceUtil.getName(deviceInfo, ykType)
+  }
+
+  private fun parseDeviceInfo(map: com.facebook.react.bridge.ReadableMap): com.yubico.yubikit.management.DeviceInfo {
+    val builder = com.yubico.yubikit.management.DeviceInfo.Builder()
+    builder.version(com.yubico.yubikit.core.Version(
+      map.getMap("version")!!.getInt("major"),
+      map.getMap("version")!!.getInt("minor"),
+      map.getMap("version")!!.getInt("micro")
+    ))
+    map.getString("formFactor")?.let {
+      builder.formFactor(com.yubico.yubikit.management.FormFactor.valueOf(it))
+    }
+    if (map.hasKey("serialNumber") && !map.isNull("serialNumber")) {
+      builder.serialNumber(map.getInt("serialNumber"))
+    }
+    builder.isLocked(map.getBoolean("isLocked"))
+    builder.isFips(map.getBoolean("isFips"))
+    if (map.hasKey("isSky") && !map.isNull("isSky")) {
+      builder.isSky(map.getBoolean("isSky"))
+    }
+    if (map.hasKey("pinComplexity") && !map.isNull("pinComplexity")) {
+      builder.pinComplexity(map.getBoolean("pinComplexity"))
+    }
+    // getName() relies on hasTransport(Transport.NFC)/(USB), which in turn is just
+    // "does the map below contain this key" - if this isn't reconstructed here,
+    // hasTransport() is always false for every transport and getName() can never
+    // report NFC-capable devices correctly, regardless of the real hardware.
+    val supportedCapabilities = mutableMapOf<Transport, Int>()
+    map.getMap("supportedCapabilities")?.let { caps ->
+      if (caps.hasKey("usb") && !caps.isNull("usb")) {
+        supportedCapabilities[Transport.USB] = caps.getInt("usb")
+      }
+      if (caps.hasKey("nfc") && !caps.isNull("nfc")) {
+        supportedCapabilities[Transport.NFC] = caps.getInt("nfc")
+      }
+    }
+    builder.supportedCapabilities(supportedCapabilities)
+    // DeviceInfo.Builder may not expose all setters; this is a best-effort reconstruction.
+    return builder.build()
+  }
+
+  companion object {
+    const val NAME = "YubikitSupport"
+  }
+}

package/android/src/main/java/com/yubikit/YubikitYubiOtpModule.kt

@@ -0,0 +1,248 @@
+package com.yubikit
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.yubico.yubikit.yubiotp.ConfigurationState
+import com.yubico.yubikit.yubiotp.HmacSha1SlotConfiguration
+import com.yubico.yubikit.yubiotp.HotpSlotConfiguration
+import com.yubico.yubikit.yubiotp.Slot
+import com.yubico.yubikit.yubiotp.SlotConfiguration
+import com.yubico.yubikit.yubiotp.StaticPasswordSlotConfiguration
+import com.yubico.yubikit.yubiotp.StaticTicketSlotConfiguration
+import com.yubico.yubikit.yubiotp.UpdateConfiguration
+import com.yubico.yubikit.yubiotp.YubiOtpSession
+import com.yubico.yubikit.yubiotp.YubiOtpSlotConfiguration
+import com.yubikit.utils.YubikitUtils.base64Decode
+import com.yubikit.utils.YubikitUtils.base64Encode
+import com.yubikit.utils.YubikitUtils.versionToMap
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+
+@Suppress("unused")
+class YubikitYubiOtpModule(reactContext: ReactApplicationContext) :
+  NativeYubikitYubiOtpSpec(reactContext) {
+
+  private val moduleScope = CoroutineScope(Dispatchers.IO)
+
+  override fun getName(): String = NAME
+
+  private inline fun <R> withYubiOtpSession(
+    deviceHandle: String,
+    promise: Promise,
+    crossinline block: (YubiOtpSession) -> R
+  ) {
+    moduleScope.launch {
+      try {
+        val device = YubiKitManagerHolder.getDevice(deviceHandle)
+        val result = when {
+          device.supportsConnection(com.yubico.yubikit.core.smartcard.SmartCardConnection::class.java) -> {
+            YubiKitManagerHolder.withSmartCard(deviceHandle) { connection ->
+              YubiOtpSession(connection).use { session -> block(session) }
+            }
+          }
+          device.supportsConnection(com.yubico.yubikit.core.otp.OtpConnection::class.java) -> {
+            YubiKitManagerHolder.withOtp(deviceHandle) { connection ->
+              YubiOtpSession(connection).use { session -> block(session) }
+            }
+          }
+          else -> throw IllegalArgumentException("Device does not support OTP")
+        }
+        @Suppress("UNCHECKED_CAST")
+        when (result) {
+          is Unit -> promise.resolve(null)
+          else -> promise.resolve(result)
+        }
+      } catch (e: Exception) {
+        promise.reject("YUBIOTP_ERROR", e.message, e)
+      }
+    }
+  }
+
+  private fun slotFromString(value: String): Slot {
+    return Slot.valueOf(value)
+  }
+
+  private fun configurationStateToMap(state: ConfigurationState): com.facebook.react.bridge.WritableMap {
+    return Arguments.createMap().apply {
+      putBoolean("slot1Configured", state.isConfigured(Slot.ONE))
+      putBoolean("slot2Configured", state.isConfigured(Slot.TWO))
+      putBoolean("slot1TouchTriggered", state.isTouchTriggered(Slot.ONE))
+      putBoolean("slot2TouchTriggered", state.isTouchTriggered(Slot.TWO))
+      putBoolean("ledInverted", state.isLedInverted)
+    }
+  }
+
+  private fun buildSlotConfiguration(map: ReadableMap): SlotConfiguration {
+    val type = map.getString("type") ?: throw IllegalArgumentException("configuration type is required")
+    return when (type) {
+      "HmacSha1" -> {
+        val cfg = HmacSha1SlotConfiguration(base64Decode(map.getString("secret")) ?: byteArrayOf())
+        if (map.hasKey("requireTouch") && !map.isNull("requireTouch")) {
+          cfg.requireTouch(map.getBoolean("requireTouch"))
+        }
+        if (map.hasKey("lt64") && !map.isNull("lt64")) {
+          cfg.lt64(map.getBoolean("lt64"))
+        }
+        cfg
+      }
+      "HOTP" -> {
+        val cfg = HotpSlotConfiguration(base64Decode(map.getString("secret")) ?: byteArrayOf())
+        if (map.hasKey("digits") && !map.isNull("digits")) {
+          if (map.getInt("digits") == 8) cfg.digits8(true)
+        }
+        if (map.hasKey("imf") && !map.isNull("imf")) {
+          cfg.imf(map.getInt("imf"))
+        }
+        cfg
+      }
+      "StaticPassword" -> {
+        StaticPasswordSlotConfiguration(base64Decode(map.getString("scanCodes")) ?: byteArrayOf())
+      }
+      "StaticTicket" -> {
+        StaticTicketSlotConfiguration(
+          base64Decode(map.getString("fixed")) ?: byteArrayOf(),
+          base64Decode(map.getString("uid")) ?: byteArrayOf(),
+          base64Decode(map.getString("key")) ?: byteArrayOf()
+        )
+      }
+      "YubiOtp" -> {
+        YubiOtpSlotConfiguration(
+          base64Decode(map.getString("fixed")) ?: byteArrayOf(),
+          base64Decode(map.getString("uid")) ?: byteArrayOf(),
+          base64Decode(map.getString("key")) ?: byteArrayOf()
+        )
+      }
+      else -> throw IllegalArgumentException("Slot configuration type not supported for putConfiguration: $type")
+    }
+  }
+
+  private fun buildUpdateConfiguration(map: ReadableMap): UpdateConfiguration {
+    val type = map.getString("type") ?: throw IllegalArgumentException("configuration type is required")
+    if (type != "Update") {
+      throw IllegalArgumentException("updateConfiguration only supports Update configuration type")
+    }
+    val cfg = UpdateConfiguration()
+    if (map.hasKey("appendCr") && !map.isNull("appendCr")) {
+      cfg.appendCr(map.getBoolean("appendCr"))
+    }
+    if (map.hasKey("serialApiVisible") && !map.isNull("serialApiVisible")) {
+      cfg.serialApiVisible(map.getBoolean("serialApiVisible"))
+    }
+    if (map.hasKey("serialUsbVisible") && !map.isNull("serialUsbVisible")) {
+      cfg.serialUsbVisible(map.getBoolean("serialUsbVisible"))
+    }
+    if (map.hasKey("allowUpdate") && !map.isNull("allowUpdate")) {
+      cfg.allowUpdate(map.getBoolean("allowUpdate"))
+    }
+    if (map.hasKey("dormant") && !map.isNull("dormant")) {
+      cfg.dormant(map.getBoolean("dormant"))
+    }
+    if (map.hasKey("invertLed") && !map.isNull("invertLed")) {
+      cfg.invertLed(map.getBoolean("invertLed"))
+    }
+    return cfg
+  }
+
+  override fun getConfigurationState(deviceHandle: String, promise: Promise) {
+    withYubiOtpSession(deviceHandle, promise) { configurationStateToMap(it.configurationState) }
+  }
+
+  override fun getVersion(deviceHandle: String, promise: Promise) {
+    withYubiOtpSession(deviceHandle, promise) { versionToMap(it.version) }
+  }
+
+  override fun getSerialNumber(deviceHandle: String, promise: Promise) {
+    withYubiOtpSession(deviceHandle, promise) { it.serialNumber }
+  }
+
+  override fun swapConfigurations(deviceHandle: String, promise: Promise) {
+    withYubiOtpSession(deviceHandle, promise) { it.swapConfigurations() }
+  }
+
+  override fun deleteConfiguration(
+    deviceHandle: String,
+    slot: String,
+    currentAccessCode: String?,
+    promise: Promise
+  ) {
+    withYubiOtpSession(deviceHandle, promise) {
+      it.deleteConfiguration(slotFromString(slot), base64Decode(currentAccessCode))
+    }
+  }
+
+  override fun putConfiguration(
+    deviceHandle: String,
+    slot: String,
+    configuration: ReadableMap,
+    accessCode: String?,
+    currentAccessCode: String?,
+    promise: Promise
+  ) {
+    withYubiOtpSession(deviceHandle, promise) {
+      it.putConfiguration(
+        slotFromString(slot),
+        buildSlotConfiguration(configuration),
+        base64Decode(accessCode),
+        base64Decode(currentAccessCode)
+      )
+    }
+  }
+
+  override fun updateConfiguration(
+    deviceHandle: String,
+    slot: String,
+    configuration: ReadableMap,
+    accessCode: String?,
+    currentAccessCode: String?,
+    promise: Promise
+  ) {
+    withYubiOtpSession(deviceHandle, promise) {
+      it.updateConfiguration(
+        slotFromString(slot),
+        buildUpdateConfiguration(configuration),
+        base64Decode(accessCode),
+        base64Decode(currentAccessCode)
+      )
+    }
+  }
+
+  override fun setNdefConfiguration(
+    deviceHandle: String,
+    slot: String,
+    uri: String?,
+    currentAccessCode: String?,
+    promise: Promise
+  ) {
+    withYubiOtpSession(deviceHandle, promise) {
+      it.setNdefConfiguration(
+        slotFromString(slot),
+        uri,
+        base64Decode(currentAccessCode)
+      )
+    }
+  }
+
+  override fun calculateHmacSha1(
+    deviceHandle: String,
+    slot: String,
+    challenge: String,
+    promise: Promise
+  ) {
+    withYubiOtpSession(deviceHandle, promise) {
+      base64Encode(
+        it.calculateHmacSha1(
+          slotFromString(slot),
+          base64Decode(challenge) ?: byteArrayOf(),
+          null
+        )
+      )
+    }
+  }
+
+  companion object {
+    const val NAME = "YubikitYubiOtp"
+  }
+}