@onekeyfe/react-native-lite-card 0.1.2

package/android/src/main/java/com/onekeyfe/reactnativelitecard/nfc/broadcast/NfcStatusChangeBroadcastReceiver.kt

@@ -0,0 +1,56 @@
+package so.onekey.app.wallet.lite.nfc.broadcast
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.nfc.NfcAdapter
+import android.util.Log
+
+open class NfcStatusChangeBroadcastReceiver : BroadcastReceiver() {
+
+    override fun onReceive(context: Context, intent: Intent) {
+        val action = intent.action
+        if (NfcAdapter.ACTION_ADAPTER_STATE_CHANGED == action) {
+            val state =
+                    intent.getIntExtra(NfcAdapter.EXTRA_ADAPTER_STATE, NfcAdapter.STATE_OFF)
+
+            Log.e(TAG, "nfc state broadcast receiver, state is $state")
+            when (state) {
+                NfcAdapter.STATE_OFF -> onNfcOff()
+                NfcAdapter.STATE_ON -> onNfcOn()
+                NfcAdapter.STATE_TURNING_OFF -> onNfcTurningOff()
+                NfcAdapter.STATE_TURNING_ON -> onNfcTurningOn()
+                5 -> onCardPayMode() //samsumg return 5 that minds card pay mode
+                else -> onNfcOff()
+            }
+        }
+    }
+
+    protected open fun onNfcTurningOn() {
+
+    }
+
+    protected open fun onNfcTurningOff() {
+
+    }
+
+    protected open fun onNfcOn() {
+
+    }
+
+    protected open fun onNfcOff() {
+
+    }
+
+    protected open fun onCardPayMode() {
+
+    }
+
+    companion object {
+        val TAG: String = NfcStatusChangeBroadcastReceiver::class.java.simpleName
+
+        val nfcBroadcastReceiverIntentFilter: IntentFilter
+            get() = IntentFilter("android.nfc.action.ADAPTER_STATE_CHANGED")
+    }
+}

package/android/src/main/java/com/onekeyfe/reactnativelitecard/nfc/gpchannel/GPChannelNatives.kt

@@ -0,0 +1,32 @@
+package org.haobtc.onekey.card.gpchannel
+
+/** @Date 2020-07-09 16:29 @Author li @Version 1.0
+ */
+object GPChannelNatives {
+    /**
+     * 当native接口的返回值不是int时，需要调用该接口获取错误码
+     *
+     * @return
+     */
+    external fun nativeGetErrorCode(): Int
+    external fun nativeGPCInitialize(json: String?): Int
+    external fun nativeGPCFinalize(): Int
+    external fun nativeGPCBuildMutualAuthData(): String
+    external fun nativeGPCOpenSecureChannel(response: String?): Int
+    external fun nativeGPCBuildAPDU(
+        cla: Long, ins: Long, p1: Long, p2: Long, data: String = ""
+    ): String
+
+    external fun nativeGPCBuildSafeAPDU(
+        cla: Long, ins: Long, p1: Long, p2: Long, data: String = ""
+    ): String
+
+    external fun nativeGPCParseSafeAPDUResponse(response: String?): String
+    external fun nativeGPCParseAPDUResponse(response: String?): String
+    external fun nativeGPCTLVDecode(apdu: String?): String
+    external fun nativeGPCParseCertificate(cert: String?): String
+
+    init {
+        System.loadLibrary("gpchannelNDK")
+    }
+}

package/android/src/main/java/com/onekeyfe/reactnativelitecard/onekeyLite/NfcConstant.kt

@@ -0,0 +1,38 @@
+package so.onekey.app.wallet.lite.onekeyLite
+
+import android.nfc.tech.IsoDep
+import so.onekey.app.wallet.lite.utils.HexUtils
+import java.io.IOException
+
+
+/**
+ * @Author:         peter Qin
+ */
+object NfcConstant {
+    const val DEBUG = false
+    const val MNEMONIC = "mnemonics"
+    const val MODE = "statusMode"
+    const val SELECT_CARD_ID = "select_card_id"
+    const val VERIFY_SUCCESS = 100
+    const val INTERRUPT_STATUS = 1000
+    const val RESET_INTERRUPT_STATUS = 1001
+    const val GET_RETRY_NUM_INTERRUPT_STATUS = 1002
+    const val RESET_PIN_SUCCESS = -1
+    const val CHANGE_PIN_SUCCESS = -10
+    const val CHANGE_PIN_ERROR = -100
+    const val NEW_PIN = "029000"
+    const val MAX_RETRY_NUM = 10
+    const val NO_RETRY_NUM_RESET_CARD = 0
+    const val NOT_MATCH_DEVICE = "cannot_match_device"
+    const val INIT_CHANNEL_SUCCESS = 104
+    const val INIT_CHANNEL_FAILURE = 105
+    const val STATUS_SUCCESS = "9000"
+    const val STATUS_FAILURE = "FFFF"
+    const val HAS_BACK_UP = "029000"
+
+    const val LITE_VERSION = "01"
+    const val LITE_LANGUAGE = "00"// english
+    const val LITE_TAG = "ffff"
+
+    private const val RESPONSE_STATUS_LENGTH = 4
+}

package/android/src/main/java/com/onekeyfe/reactnativelitecard/onekeyLite/OnekeyLiteCard.kt

@@ -0,0 +1,236 @@
+package so.onekey.app.wallet.lite.onekeyLite
+
+import android.app.Activity
+import android.nfc.tech.IsoDep
+import android.util.Log
+import androidx.fragment.app.FragmentActivity
+import androidx.lifecycle.Lifecycle
+import com.google.gson.Gson
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import so.onekey.app.wallet.lite.nfc.NFCExceptions
+import so.onekey.app.wallet.lite.nfc.NfcUtils
+import so.onekey.app.wallet.lite.onekeyLite.entitys.CardState
+import so.onekey.app.wallet.lite.onekeyLite.nfc.AppleCardType
+import so.onekey.app.wallet.lite.onekeyLite.nfc.Connection
+import so.onekey.app.wallet.lite.onekeyLite.nfc.CommandGenerator
+import so.onekey.app.wallet.lite.utils.LogUtil.printLog
+import so.onekey.app.wallet.lite.utils.NfcPermissionUtils
+
+object OneKeyLiteCard {
+    const val TAG = "OneKeyLiteCard"
+
+    private val mCommandGenerator by lazy(LazyThreadSafetyMode.NONE) {
+        CommandGenerator()
+    }
+    private var mCardConnection: Connection? = null
+
+    suspend fun startNfc(activity: FragmentActivity, callback: ((Boolean) -> Unit)? = null) =
+        withContext(Dispatchers.Main) {
+            if (NfcUtils.isNfcExits(activity)) {
+                val adapter = NfcUtils.init(activity)
+                if (adapter == null) {
+                    printLog(TAG, "startNfc: NfcAdapter is null")
+                    callback?.invoke(false)
+                    return@withContext
+                }
+            }
+            printLog(TAG, "startNfc: ${NfcUtils.isNfcExits(activity)}")
+
+            NfcPermissionUtils.checkPermission(activity) {
+                printLog(TAG, "startNfc Have permission")
+                if (!activity.lifecycle.currentState.isAtLeast(Lifecycle.State.RESUMED)) {
+                    return@checkPermission
+                }
+
+                NfcUtils.mNfcAdapter?.enableForegroundDispatch(
+                    activity, NfcUtils.mPendingIntent, NfcUtils.mIntentFilter, NfcUtils.mTechList
+                )
+
+                printLog(TAG, "startNfc: enableForegroundDispatch")
+
+                callback?.invoke(true)
+                return@withContext
+            }
+            Log.e(TAG, "startNfc Not NFC permission")
+            callback?.invoke(false)
+        }
+
+    fun stopNfc(activity: Activity) {
+        NfcUtils.mNfcAdapter?.disableForegroundDispatch(activity)
+    }
+
+    // first init channel ,can filter not match device
+    @Throws(NFCExceptions::class)
+    suspend fun initRequest(isoDep: IsoDep?) = withContext(Dispatchers.IO) {
+        if (isoDep == null) {
+            throw NFCExceptions.ConnectionFailException()
+        }
+        mCardConnection = Connection(isoDep, mCommandGenerator)
+        return@withContext mCardConnection?.getCardInfo()
+            ?: throw NFCExceptions.InitChannelException()
+    }
+
+    @Throws(NFCExceptions::class)
+    private fun setupNewPinRequest(isoDep: IsoDep, pin: String?): Boolean {
+        if (pin.isNullOrEmpty()) {
+            throw NFCExceptions.InputPasswordEmptyException()
+        }
+        return mCardConnection?.setupNewPin(pin) ?: false
+    }
+
+    @Throws(NFCExceptions::class)
+    fun changePinRequest(isoDep: IsoDep, oldPwd: String?, newPwd: String?): Int {
+        if (oldPwd.isNullOrEmpty()) {
+            throw NFCExceptions.InputPasswordEmptyException()
+        }
+        return mCardConnection?.changePin(oldPwd, newPwd) ?: 0
+    }
+
+    @Throws(NFCExceptions::class)
+    fun verifyPinBackupRequest(isoDep: IsoDep, verifyPin: String?): Int {
+        if (verifyPin.isNullOrEmpty()) {
+            throw NFCExceptions.InputPasswordEmptyException()
+        }
+        return mCardConnection?.startVerifyPin(verifyPin) ?: 0
+    }
+
+    @Throws(NFCExceptions::class)
+    fun getCardInfo(isoDep: IsoDep): CardState {
+        return mCardConnection?.getCardInfo() ?: throw NFCExceptions.ConnectionFailException()
+    }
+
+    @Throws(NFCExceptions::class)
+    fun setMnemonic(
+      cardState: CardState?,
+      isoDep: IsoDep,
+      mnemonic: String?,
+      pwd: String?,
+      overwrite: Boolean = false
+    ): Boolean {
+        if (cardState == null) throw NFCExceptions.ConnectionFailException()
+
+        printLog(TAG, "--> setMnemonic: cardState:${Gson().toJson(cardState)}")
+
+        if (!overwrite) {
+            // 不是覆写要验证是否已经已经存有备份
+            if (!cardState.isNewCard || cardState.hasBackup) {
+                throw NFCExceptions.InitializedException()
+            }
+        }
+
+        if (overwrite && mCardConnection?.getCardType() == AppleCardType.V2) {
+            // Verify the password before clearing the card
+            val verifyPin = verifyPinBackupRequest(isoDep, pwd)
+            if (verifyPin != NfcConstant.VERIFY_SUCCESS) {
+                handlerVerifyPinError(cardState, verifyPin)
+            }
+
+            // 如果是覆写,并且是V2卡,直接使用 setupNewPinRequest 清空卡片
+            cardState.isNewCard = true
+        }
+
+        if (cardState.isNewCard) {
+            // 如果是新卡设置密码
+            if (!setupNewPinRequest(isoDep, pwd)) {
+                throw NFCExceptions.InitPasswordException()
+            }
+        }
+
+        val verifyPin = verifyPinBackupRequest(isoDep, pwd)
+        if (verifyPin != NfcConstant.VERIFY_SUCCESS) {
+            if (overwrite) {
+                handlerVerifyPinError(cardState, verifyPin)
+            } else {
+                throw NFCExceptions.InitPasswordException()
+            }
+        }
+
+        return mCardConnection?.backupData(mnemonic ?: "") == true
+    }
+
+    @Throws(NFCExceptions::class)
+    fun getMnemonicWithPin(cardState: CardState?, isoDep: IsoDep, pwd: String): String {
+        if (cardState == null) throw NFCExceptions.ConnectionFailException()
+
+        if (cardState.isNewCard || !cardState.hasBackup) {
+            throw NFCExceptions.NotInitializedException()
+        }
+
+        val verifyPin = verifyPinBackupRequest(isoDep, pwd)
+        if (verifyPin != NfcConstant.VERIFY_SUCCESS) {
+            handlerVerifyPinError(cardState, verifyPin)
+        }
+
+        val result = mCardConnection?.exportData()
+
+        if (result.isNullOrEmpty()) {
+            throw NFCExceptions.NotInitializedException()
+        }
+        return result
+    }
+
+    @Throws(NFCExceptions::class)
+    fun changPin(cardState: CardState?, isoDep: IsoDep, oldPwd: String, newPwd: String): Boolean {
+        if (cardState == null) throw NFCExceptions.ConnectionFailException()
+
+        if (cardState.isNewCard || !cardState.hasBackup) {
+            throw NFCExceptions.NotInitializedException()
+        }
+
+        val result = changePinRequest(isoDep, oldPwd, newPwd)
+        handlerVerifyPinError(cardState, result, true)
+
+        return when (result) {
+            NfcConstant.CHANGE_PIN_SUCCESS -> {
+                true
+            }
+            NfcConstant.CHANGE_PIN_ERROR -> {
+                false
+            }
+            else -> {
+                // 密码错误
+                cardState.pinRetryCount = result
+                throw NFCExceptions.PasswordWrongException()
+            }
+        }
+    }
+
+    fun reset(isoDep: IsoDep): Boolean {
+        return mCardConnection?.resetCard() == NfcConstant.RESET_PIN_SUCCESS
+    }
+
+    private fun handlerVerifyPinError(
+        cardState: CardState, status: Int, ignoreDefault: Boolean = false
+    ) {
+        when (status) {
+            NfcConstant.RESET_INTERRUPT_STATUS -> {
+                // Reset 卡片错误,已经锁定
+                throw NFCExceptions.CardLockException()
+            }
+            NfcConstant.GET_RETRY_NUM_INTERRUPT_STATUS -> {
+                // 密码错误
+                cardState.pinRetryCount = cardState.pinRetryCount - 1
+                if (cardState.pinRetryCount <= 0) {
+                    throw NFCExceptions.CardLockException()
+                } else {
+                    throw NFCExceptions.PasswordWrongException()
+                }
+            }
+            NfcConstant.RESET_PIN_SUCCESS -> {
+                // Reset 卡片成功
+                throw NFCExceptions.UpperErrorAutoResetException()
+            }
+            NfcConstant.INTERRUPT_STATUS -> {
+                throw NFCExceptions.ConnectionFailException()
+            }
+            else -> {
+                if (!ignoreDefault) {
+                    // 密码错误
+                    cardState.pinRetryCount = status
+                    throw NFCExceptions.PasswordWrongException()
+                }
+            }
+        }
+    }
+}

package/android/src/main/java/com/onekeyfe/reactnativelitecard/onekeyLite/entitys/APDUParam.kt

@@ -0,0 +1,17 @@
+package so.onekey.app.wallet.lite.onekeyLite.entitys
+
+data class APDUParam(
+    val cla: Long,
+    val ins: Long,
+    val p1: Long,
+    val p2: Long,
+    val data: String = ""
+) {
+    constructor(command: LongArray, data: String) : this(
+        command[0],
+        command[1],
+        command[2],
+        command[3],
+        data
+    )
+}

package/android/src/main/java/com/onekeyfe/reactnativelitecard/onekeyLite/entitys/CardInfo.java

@@ -0,0 +1,84 @@
+package so.onekey.app.wallet.lite.onekeyLite.entitys;
+
+
+import com.google.gson.Gson;
+import com.google.gson.annotations.SerializedName;
+
+
+public class CardInfo {
+
+    /**
+     * bleVersion :
+     * firmwareVersion :
+     * label :
+     * pinMaxRetry : 10
+     * pinRetry : 10
+     * sn : BXNFC20052500001
+     */
+
+    @SerializedName("bleVersion")
+    private String bleVersion;
+    @SerializedName("firmwareVersion")
+    private String firmwareVersion;
+    @SerializedName("label")
+    private String label;
+    @SerializedName("pinMaxRetry")
+    private int pinMaxRetry;
+    @SerializedName("pinRetry")
+    private int pinRetry;
+    @SerializedName("sn")
+    private String sn;
+
+    public static CardInfo objectFromData(String str) {
+
+        return new Gson().fromJson(str, CardInfo.class);
+    }
+
+    public String getBleVersion() {
+        return bleVersion;
+    }
+
+    public void setBleVersion(String bleVersion) {
+        this.bleVersion = bleVersion;
+    }
+
+    public String getFirmwareVersion() {
+        return firmwareVersion;
+    }
+
+    public void setFirmwareVersion(String firmwareVersion) {
+        this.firmwareVersion = firmwareVersion;
+    }
+
+    public String getLabel() {
+        return label;
+    }
+
+    public void setLabel(String label) {
+        this.label = label;
+    }
+
+    public int getPinMaxRetry() {
+        return pinMaxRetry;
+    }
+
+    public void setPinMaxRetry(int pinMaxRetry) {
+        this.pinMaxRetry = pinMaxRetry;
+    }
+
+    public int getPinRetry() {
+        return pinRetry;
+    }
+
+    public void setPinRetry(int pinRetry) {
+        this.pinRetry = pinRetry;
+    }
+
+    public String getSn() {
+        return sn;
+    }
+
+    public void setSn(String sn) {
+        this.sn = sn;
+    }
+}

package/android/src/main/java/com/onekeyfe/reactnativelitecard/onekeyLite/entitys/CardResponse.java

@@ -0,0 +1,37 @@
+package so.onekey.app.wallet.lite.onekeyLite.entitys;
+
+import com.google.gson.Gson;
+import com.google.gson.annotations.SerializedName;
+
+/**
+ * @author  liyan
+ * @date 2020/7/15
+ */
+//
+public class CardResponse {
+
+    @SerializedName(value = "response", alternate = "value")
+    private String response;
+    @SerializedName(value = "wRet", alternate = "tag")
+    private int wRet;
+
+    public static CardResponse objectFromData(String str) {
+        return new Gson().fromJson(str, CardResponse.class);
+    }
+
+    public String getResponse() {
+        return response;
+    }
+
+    public void setResponse(String response) {
+        this.response = response;
+    }
+
+    public int getWRet() {
+        return wRet;
+    }
+
+    public void setWRet(int wRet) {
+        this.wRet = wRet;
+    }
+}

package/android/src/main/java/com/onekeyfe/reactnativelitecard/onekeyLite/entitys/CardState.kt

@@ -0,0 +1,10 @@
+package so.onekey.app.wallet.lite.onekeyLite.entitys
+
+import android.nfc.tech.IsoDep
+
+data class CardState(
+        var hasBackup: Boolean = false,
+        var isNewCard: Boolean = true,
+        var serialNum: String = "",
+        var pinRetryCount: Int = 0
+)

package/android/src/main/java/com/onekeyfe/reactnativelitecard/onekeyLite/entitys/ParsedCertInfo.java

@@ -0,0 +1,39 @@
+package so.onekey.app.wallet.lite.onekeyLite.entitys;
+
+/**
+ * @author liyan
+ * @date 2/23/21
+ */
+//
+
+import com.google.gson.Gson;
+import com.google.gson.annotations.SerializedName;
+
+/** sn : subjectID： */
+public class ParsedCertInfo {
+    @SerializedName("sn")
+    public String sn;
+
+    @SerializedName("subjectID")
+    public String subjectID;
+
+    public static ParsedCertInfo objectFromData(String str) {
+        return new Gson().fromJson(str, ParsedCertInfo.class);
+    }
+
+    public String getSn() {
+        return sn;
+    }
+
+    public void setSn(String sn) {
+        this.sn = sn;
+    }
+
+    public String getSubjectID() {
+        return subjectID;
+    }
+
+    public void setSubjectID(String subjectID) {
+        this.subjectID = subjectID;
+    }
+}

package/android/src/main/java/com/onekeyfe/reactnativelitecard/onekeyLite/entitys/SecureChanelParam.java

@@ -0,0 +1,113 @@
+package so.onekey.app.wallet.lite.onekeyLite.entitys;
+
+import androidx.annotation.NonNull;
+
+import com.google.gson.Gson;
+import com.google.gson.annotations.SerializedName;
+
+/**
+ * @author liyan
+ * @date 2020/7/18
+ */
+//
+public class SecureChanelParam {
+
+    @SerializedName("scpID")
+    private String scpID;
+
+    @SerializedName("keyUsage")
+    private String keyUsage;
+
+    @SerializedName("keyType")
+    private String keyType;
+
+    @SerializedName("keyLength")
+    private int keyLength;
+
+    @SerializedName("hostID")
+    private String hostID;
+
+    @SerializedName("crt")
+    private String crt;
+
+    @SerializedName("sk")
+    private String sk;
+
+    @SerializedName("cardGroupID")
+    private String cardGroupID;
+
+    public static SecureChanelParam objectFromData(String str) {
+
+        return new Gson().fromJson(str, SecureChanelParam.class);
+    }
+
+    public String getScpID() {
+        return scpID;
+    }
+
+    public void setScpID(String scpID) {
+        this.scpID = scpID;
+    }
+
+    public String getKeyUsage() {
+        return keyUsage;
+    }
+
+    public void setKeyUsage(String keyUsage) {
+        this.keyUsage = keyUsage;
+    }
+
+    public String getKeyType() {
+        return keyType;
+    }
+
+    public void setKeyType(String keyType) {
+        this.keyType = keyType;
+    }
+
+    public int getKeyLength() {
+        return keyLength;
+    }
+
+    public void setKeyLength(int keyLength) {
+        this.keyLength = keyLength;
+    }
+
+    public String getHostID() {
+        return hostID;
+    }
+
+    public void setHostID(String hostID) {
+        this.hostID = hostID;
+    }
+
+    public String getCrt() {
+        return crt;
+    }
+
+    public void setCrt(String crt) {
+        this.crt = crt;
+    }
+
+    public String getSk() {
+        return sk;
+    }
+
+    public void setSk(String sk) {
+        this.sk = sk;
+    }
+
+    public String getCardGroupID() {
+        return cardGroupID;
+    }
+
+    public void setCardGroupID(String cardGroupID) {
+        this.cardGroupID = cardGroupID;
+    }
+
+    @NonNull
+    @Override
+    public String toString() {
+        return new Gson().toJson(this);
+    }
+}

package/android/src/main/java/com/onekeyfe/reactnativelitecard/onekeyLite/entitys/SendResponse.kt

@@ -0,0 +1,26 @@
+package so.onekey.app.wallet.lite.onekeyLite.entitys
+
+import so.onekey.app.wallet.lite.utils.HexUtils
+
+data class SendResponse(
+    // Original return result
+    val rawResponse: String,
+    val sw1: Byte,
+    val sw2: Byte,
+    val data: String? = null,
+    // Processed result
+    var result: String? = null
+) {
+    fun isSuccess() = sw1 == 0x90.toByte() && sw2 == 0x00.toByte()
+
+    fun isConnectFailure() = sw1 == 0x6F.toByte() && sw2 == 0x00.toByte()
+
+    fun isEmptyData() = data.isNullOrEmpty()
+
+    fun getCodeBytes(): ByteArray = byteArrayOf(sw1, sw2)
+
+    fun getCode(): String = HexUtils.byteArr2HexStr(byteArrayOf(sw1, sw2))
+
+    fun getDataBytes(): ByteArray? =
+        if (isEmptyData()) null else HexUtils.hexString2Bytes(data)
+}