@ukeyfe/react-native-nfc-litecard 1.0.2 → 1.0.3

package/dist/writer.d.ts

@@ -10,13 +10,18 @@
  *
  * Based on MIFARE Ultralight AES (MF0AES(H)20) datasheet.
  */
-import { ResultCode, type NfcResult } from './types';
+import { NfcStatusCode, type NfcResult } from './types';
 import { isNfcOperationLocked, releaseNfcOperationLock } from './nfc-core';
-export { ResultCode, type NfcResult, isNfcOperationLocked, releaseNfcOperationLock };
+export { NfcStatusCode, type NfcResult, isNfcOperationLocked, releaseNfcOperationLock };
 /**
- * Initialize a blank card: write mnemonic + set password protection.
+ * Initialize a card: authenticate with the default password, then write
+ * mnemonic and set a new password.
+ *
+ * @param mnemonic       BIP-39 mnemonic to write.
+ * @param newPassword    Password to protect the card with after initialization.
+ * @param defaultPassword Current (factory-default) password on the card.
  */
-export declare function initializeCard(mnemonic: string, password: string, onCardIdentified?: () => void): Promise<NfcResult>;
+export declare function initializeCard(mnemonic: string, newPassword: string, defaultPassword: string, onCardIdentified?: () => void): Promise<NfcResult>;
 /**
  * Update card: authenticate with old password, then write new mnemonic + new password.
  *

package/dist/writer.js

@@ -48,7 +48,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.releaseNfcOperationLock = exports.isNfcOperationLocked = exports.ResultCode = void 0;
+exports.releaseNfcOperationLock = exports.isNfcOperationLocked = exports.NfcStatusCode = void 0;
 exports.initializeCard = initializeCard;
 exports.updateCard = updateCard;
 exports.updatePassword = updatePassword;
@@ -59,7 +59,7 @@ const react_native_1 = require("react-native");
 const bip39 = __importStar(require("bip39"));
 const constants_1 = require("./constants");
 const types_1 = require("./types");
-Object.defineProperty(exports, "ResultCode", { enumerable: true, get: function () { return types_1.ResultCode; } });
+Object.defineProperty(exports, "NfcStatusCode", { enumerable: true, get: function () { return types_1.NfcStatusCode; } });
 const utils_1 = require("./utils");
 const crypto_1 = require("./crypto");
 const nfc_core_1 = require("./nfc-core");
@@ -91,9 +91,9 @@ async function writeUserMemory(data) {
         const pageData = Array.from(buffer.slice(offset, offset + constants_1.PAGE_SIZE));
         await writePage(page, pageData);
         if (react_native_1.Platform.OS === 'ios' && i < totalPages - 1) {
-            await new Promise(r => setTimeout(r, 20));
+            await new Promise(r => setTimeout(r, constants_1.DELAY.IOS_PAGE_WRITE));
             // Keep-alive every 4 pages to prevent iOS session timeout
-            if ((i + 1) % 4 === 0) {
+            if ((i + 1) % constants_1.DELAY.KEEPALIVE_FREQ === 0) {
                 try {
                     await react_native_nfc_manager_1.default.sendMifareCommandIOS([0x30, 0x00]);
                 }
@@ -102,13 +102,6 @@ async function writeUserMemory(data) {
         }
     }
 }
-/** FAST_READ pages 0x08–0x27 (user memory). */
-async function readUserMemory() {
-    const response = await (0, nfc_core_1.transceive)([constants_1.CMD_FAST_READ, constants_1.USER_PAGE_START, constants_1.USER_PAGE_END]);
-    if (!response || response.length < constants_1.USER_MEMORY_SIZE)
-        throw new Error('READ_FAILED');
-    return new Uint8Array(response.slice(0, constants_1.USER_MEMORY_SIZE));
-}
 /**
  * Write a 16-byte AES key to AES_KEY0 (pages 0x30–0x33).
  * Byte order is reversed per the datasheet.
@@ -120,7 +113,7 @@ async function writeAesKey(key) {
         const pageData = [key[off + 3], key[off + 2], key[off + 1], key[off + 0]];
         await writePage(page, pageData);
         if (react_native_1.Platform.OS === 'ios' && i < 3)
-            await new Promise(r => setTimeout(r, 10));
+            await new Promise(r => setTimeout(r, constants_1.DELAY.IOS_KEY_WRITE));
     }
 }
 /** Write a UTF-8 nickname into the last 3 pages of user memory. */
@@ -139,19 +132,20 @@ async function writeNicknameToCard(nickname) {
         const offset = i * constants_1.PAGE_SIZE;
         await writePage(page, Array.from(buffer.slice(offset, offset + constants_1.PAGE_SIZE)));
         if (react_native_1.Platform.OS === 'ios' && i < totalPages - 1)
-            await new Promise(r => setTimeout(r, 100));
+            await new Promise(r => setTimeout(r, constants_1.DELAY.IOS_NICKNAME_WRITE));
     }
 }
 // ===========================================================================
 // Auth configuration
 // ===========================================================================
-/** Enable read+write protection starting from USER_PAGE_START. */
+/** Enable read+write protection and secure messaging starting from USER_PAGE_START. */
 async function configureAuth() {
     const cfg0 = await readPage(constants_1.PAGE_CFG0);
+    cfg0[0] = cfg0[0] | constants_1.SEC_MSG_ACT_MASK; // Enable CMAC secure messaging
     cfg0[3] = constants_1.USER_PAGE_START;
     await writePage(constants_1.PAGE_CFG0, cfg0.slice(0, 4));
     if (react_native_1.Platform.OS === 'ios')
-        await new Promise(r => setTimeout(r, 80));
+        await new Promise(r => setTimeout(r, constants_1.DELAY.IOS_CONFIG));
     const cfg1 = await readPage(constants_1.PAGE_CFG1);
     cfg1[0] = cfg1[0] | 0x80; // PROT bit = 1
     await writePage(constants_1.PAGE_CFG1, cfg1.slice(0, 4));
@@ -168,7 +162,7 @@ async function disableAuth() {
     cfg0[3] = 0x3c;
     await writePage(constants_1.PAGE_CFG0, cfg0.slice(0, 4));
     if (react_native_1.Platform.OS === 'ios')
-        await new Promise(r => setTimeout(r, 80));
+        await new Promise(r => setTimeout(r, constants_1.DELAY.IOS_CONFIG));
     const cfg1 = await readPage(constants_1.PAGE_CFG1);
     cfg1[0] = cfg1[0] & 0x7f; // Clear PROT bit
     await writePage(constants_1.PAGE_CFG1, cfg1.slice(0, 4));
@@ -185,31 +179,7 @@ function mnemonicToEntropyWithCRC(mnemonic) {
         throw new Error('INVALID_MNEMONIC');
     const entropyHex = bip39.mnemonicToEntropy(mnemonic);
     const entropyBytes = (0, utils_1.hexToBytes)(entropyHex);
-    let typeId;
-    let typeStr;
-    switch (entropyBytes.length) {
-        case 16:
-            typeId = constants_1.MNEMONIC_TYPE_12;
-            typeStr = '12 words (128-bit)';
-            break;
-        case 20:
-            typeId = constants_1.MNEMONIC_TYPE_15;
-            typeStr = '15 words (160-bit)';
-            break;
-        case 24:
-            typeId = constants_1.MNEMONIC_TYPE_18;
-            typeStr = '18 words (192-bit)';
-            break;
-        case 28:
-            typeId = constants_1.MNEMONIC_TYPE_21;
-            typeStr = '21 words (224-bit)';
-            break;
-        case 32:
-            typeId = constants_1.MNEMONIC_TYPE_24;
-            typeStr = '24 words (256-bit)';
-            break;
-        default: throw new Error('UNSUPPORTED_MNEMONIC_LENGTH');
-    }
+    const { typeId, description: typeStr } = (0, utils_1.getMnemonicTypeByEntropyLength)(entropyBytes.length);
     const dataBlock = new Uint8Array(1 + entropyBytes.length);
     dataBlock[0] = typeId;
     dataBlock.set(entropyBytes, 1);
@@ -223,46 +193,72 @@ function mnemonicToEntropyWithCRC(mnemonic) {
 // Public API
 // ===========================================================================
 /**
- * Initialize a blank card: write mnemonic + set password protection.
+ * Initialize a card: authenticate with the default password, then write
+ * mnemonic and set a new password.
+ *
+ * @param mnemonic       BIP-39 mnemonic to write.
+ * @param newPassword    Password to protect the card with after initialization.
+ * @param defaultPassword Current (factory-default) password on the card.
  */
-async function initializeCard(mnemonic, password, onCardIdentified) {
+async function initializeCard(mnemonic, newPassword, defaultPassword, onCardIdentified) {
     try {
         await (0, nfc_core_1.acquireNfcLock)();
     }
     catch {
-        return { code: types_1.ResultCode.UNKNOWN_ERROR, success: false };
+        return { code: types_1.NfcStatusCode.UNKNOWN_ERROR, success: false };
     }
+    let retryCountAfterPreDecrement;
     try {
         try {
             await (0, nfc_core_1.requestNfcTech)();
         }
         catch {
             (0, nfc_core_1.releaseNfcLock)();
-            return { code: types_1.ResultCode.NFC_CONNECT_FAILED, success: false };
+            return { code: types_1.NfcStatusCode.NFC_CONNECT_FAILED, success: false };
         }
         try {
             const entropyResult = mnemonicToEntropyWithCRC(mnemonic);
-            const aesKey = (0, crypto_1.passwordToAesKey)(password);
-            const aesKeyHex = (0, utils_1.bytesToHex)(aesKey);
-            onCardIdentified?.();
-            await writeUserMemory(entropyResult.data);
-            await writeAesKey(aesKey);
-            await configureAuth();
+            // Decrement retry counter before auth
+            try {
+                const n = await (0, nfc_core_1.decrementRetryCountInSession)();
+                if (typeof n === 'number')
+                    retryCountAfterPreDecrement = n;
+            }
+            catch (error) {
+                const code = (0, types_1.errorToCode)(error);
+                if (code === types_1.NfcStatusCode.RETRY_COUNT_EXHAUSTED) {
+                    await (0, nfc_core_1.releaseNfcTech)();
+                    (0, nfc_core_1.releaseNfcLock)();
+                    return (0, types_1.nfcResultRetryCountExhausted)();
+                }
+            }
+            // Authenticate with factory-default password
+            const oldKey = (0, crypto_1.passwordToAesKey)(defaultPassword);
+            await (0, nfc_core_1.authenticate)(oldKey);
+            // Auth succeeded – reset retry counter
             try {
                 await (0, nfc_core_1.writeRetryCountInSession)(constants_1.DEFAULT_PIN_RETRY_COUNT);
+                retryCountAfterPreDecrement = constants_1.DEFAULT_PIN_RETRY_COUNT;
             }
             catch { /* non-fatal */ }
+            onCardIdentified?.();
+            // Write mnemonic (while still authenticated)
+            await writeUserMemory(entropyResult.data);
+            // Switch to new password
+            const newKey = (0, crypto_1.passwordToAesKey)(newPassword);
+            await disableAuth();
+            await writeAesKey(newKey);
+            await configureAuth();
             await (0, nfc_core_1.releaseNfcTech)();
             (0, nfc_core_1.releaseNfcLock)();
             return {
-                code: types_1.ResultCode.INIT_SUCCESS,
+                code: types_1.NfcStatusCode.INIT_SUCCESS,
                 success: true,
                 data: {
                     type: entropyResult.type,
                     entropyHex: entropyResult.entropyHex,
                     rawBytes: entropyResult.rawBytes,
                     crc16: entropyResult.crc16,
-                    aesKeyHex,
                     retryCount: constants_1.DEFAULT_PIN_RETRY_COUNT,
                 },
             };
@@ -271,7 +267,11 @@ async function initializeCard(mnemonic, password, onCardIdentified) {
             await (0, nfc_core_1.releaseNfcTech)();
             (0, nfc_core_1.releaseNfcLock)();
             const code = (0, types_1.errorToCode)(error);
-            return { code, success: false };
+            return {
+                code,
+                success: false,
+                data: typeof retryCountAfterPreDecrement === 'number' ? { retryCount: retryCountAfterPreDecrement } : undefined,
+            };
         }
     }
     catch (error) {
@@ -292,7 +292,7 @@ async function updateCard(oldPassword, newPassword, newMnemonic, onCardIdentifie
         await (0, nfc_core_1.acquireNfcLock)();
     }
     catch {
-        return { code: types_1.ResultCode.UNKNOWN_ERROR, success: false };
+        return { code: types_1.NfcStatusCode.UNKNOWN_ERROR, success: false };
     }
     let retryCountAfterPreDecrement;
     try {
@@ -301,7 +301,7 @@ async function updateCard(oldPassword, newPassword, newMnemonic, onCardIdentifie
         }
         catch {
             (0, nfc_core_1.releaseNfcLock)();
-            return { code: types_1.ResultCode.NFC_CONNECT_FAILED, success: false };
+            return { code: types_1.NfcStatusCode.NFC_CONNECT_FAILED, success: false };
         }
         try {
             try {
@@ -311,7 +311,7 @@ async function updateCard(oldPassword, newPassword, newMnemonic, onCardIdentifie
             }
             catch (error) {
                 const code = (0, types_1.errorToCode)(error);
-                if (code === types_1.ResultCode.RETRY_COUNT_EXHAUSTED) {
+                if (code === types_1.NfcStatusCode.RETRY_COUNT_EXHAUSTED) {
                     await (0, nfc_core_1.releaseNfcTech)();
                     (0, nfc_core_1.releaseNfcLock)();
                     return (0, types_1.nfcResultRetryCountExhausted)();
@@ -328,21 +328,21 @@ async function updateCard(oldPassword, newPassword, newMnemonic, onCardIdentifie
             onCardIdentified?.();
             if (options?.precheckExistingMnemonic) {
                 try {
-                    const data = await readUserMemory();
+                    const data = await (0, nfc_core_1.readUserMemory)();
                     const decoded = (0, utils_1.validateMnemonicPayload)(data);
                     await (0, nfc_core_1.releaseNfcTech)();
                     (0, nfc_core_1.releaseNfcLock)();
                     return {
-                        code: types_1.ResultCode.PRECHECK_HAS_BACKUP,
+                        code: types_1.NfcStatusCode.PRECHECK_HAS_BACKUP,
                         success: true,
                         data: { type: decoded.type, retryCount: constants_1.DEFAULT_PIN_RETRY_COUNT },
                     };
                 }
                 catch (e) {
                     const c = (0, types_1.errorToCode)(e);
-                    if (c === types_1.ResultCode.CHECK_EMPTY ||
-                        c === types_1.ResultCode.CRC16_CHECK_FAILED ||
-                        c === types_1.ResultCode.INVALID_CARD_DATA) {
+                    if (c === types_1.NfcStatusCode.CHECK_EMPTY ||
+                        c === types_1.NfcStatusCode.CRC16_CHECK_FAILED ||
+                        c === types_1.NfcStatusCode.INVALID_CARD_DATA) {
                         // No valid mnemonic on card — fall through to write
                     }
                     else {
@@ -362,7 +362,7 @@ async function updateCard(oldPassword, newPassword, newMnemonic, onCardIdentifie
             await (0, nfc_core_1.releaseNfcTech)();
             (0, nfc_core_1.releaseNfcLock)();
             return {
-                code: types_1.ResultCode.WRITE_SUCCESS,
+                code: types_1.NfcStatusCode.WRITE_SUCCESS,
                 success: true,
                 data: {
                     type: entropyResult.type,
@@ -397,7 +397,7 @@ async function updatePassword(oldPassword, newPassword, onCardIdentified) {
         await (0, nfc_core_1.acquireNfcLock)();
     }
     catch {
-        return { code: types_1.ResultCode.UNKNOWN_ERROR, success: false };
+        return { code: types_1.NfcStatusCode.UNKNOWN_ERROR, success: false };
     }
     let retryCountAfterPreDecrement;
     try {
@@ -406,7 +406,7 @@ async function updatePassword(oldPassword, newPassword, onCardIdentified) {
         }
         catch {
             (0, nfc_core_1.releaseNfcLock)();
-            return { code: types_1.ResultCode.NFC_CONNECT_FAILED, success: false };
+            return { code: types_1.NfcStatusCode.NFC_CONNECT_FAILED, success: false };
         }
         try {
             try {
@@ -416,7 +416,7 @@ async function updatePassword(oldPassword, newPassword, onCardIdentified) {
             }
             catch (error) {
                 const code = (0, types_1.errorToCode)(error);
-                if (code === types_1.ResultCode.RETRY_COUNT_EXHAUSTED) {
+                if (code === types_1.NfcStatusCode.RETRY_COUNT_EXHAUSTED) {
                     await (0, nfc_core_1.releaseNfcTech)();
                     (0, nfc_core_1.releaseNfcLock)();
                     return (0, types_1.nfcResultRetryCountExhausted)();
@@ -439,7 +439,7 @@ async function updatePassword(oldPassword, newPassword, onCardIdentified) {
             await (0, nfc_core_1.releaseNfcTech)();
             (0, nfc_core_1.releaseNfcLock)();
             return {
-                code: types_1.ResultCode.UPDATE_PASSWORD_SUCCESS,
+                code: types_1.NfcStatusCode.UPDATE_PASSWORD_SUCCESS,
                 success: true,
                 data: { aesKeyHex, retryCount: constants_1.DEFAULT_PIN_RETRY_COUNT },
             };
@@ -466,7 +466,7 @@ async function writeUserNickname(password, nickname, onCardIdentified) {
         await (0, nfc_core_1.acquireNfcLock)();
     }
     catch {
-        return { code: types_1.ResultCode.UNKNOWN_ERROR, success: false };
+        return { code: types_1.NfcStatusCode.UNKNOWN_ERROR, success: false };
     }
     try {
         try {
@@ -474,11 +474,28 @@ async function writeUserNickname(password, nickname, onCardIdentified) {
         }
         catch {
             (0, nfc_core_1.releaseNfcLock)();
-            return { code: types_1.ResultCode.NFC_CONNECT_FAILED, success: false };
+            return { code: types_1.NfcStatusCode.NFC_CONNECT_FAILED, success: false };
         }
         try {
+            // Pre-decrement retry counter before auth
+            try {
+                await (0, nfc_core_1.decrementRetryCountInSession)();
+            }
+            catch (error) {
+                const code = (0, types_1.errorToCode)(error);
+                if (code === types_1.NfcStatusCode.RETRY_COUNT_EXHAUSTED) {
+                    await (0, nfc_core_1.releaseNfcTech)();
+                    (0, nfc_core_1.releaseNfcLock)();
+                    return (0, types_1.nfcResultRetryCountExhausted)();
+                }
+            }
             const aesKey = (0, crypto_1.passwordToAesKey)(password);
             await (0, nfc_core_1.authenticate)(aesKey);
+            // Auth succeeded – reset retry counter
+            try {
+                await (0, nfc_core_1.writeRetryCountInSession)(constants_1.DEFAULT_PIN_RETRY_COUNT);
+            }
+            catch { /* non-fatal */ }
             onCardIdentified?.();
             await disableAuth();
             await writeNicknameToCard(nickname);
@@ -486,7 +503,7 @@ async function writeUserNickname(password, nickname, onCardIdentified) {
             await (0, nfc_core_1.releaseNfcTech)();
             (0, nfc_core_1.releaseNfcLock)();
             return {
-                code: types_1.ResultCode.WRITE_NICKNAME_SUCCESS,
+                code: types_1.NfcStatusCode.WRITE_NICKNAME_SUCCESS,
                 success: true,
             };
         }
@@ -513,7 +530,7 @@ async function resetCard(password, newPassword, onCardIdentified) {
         await (0, nfc_core_1.acquireNfcLock)();
     }
     catch {
-        return { code: types_1.ResultCode.UNKNOWN_ERROR, success: false };
+        return { code: types_1.NfcStatusCode.UNKNOWN_ERROR, success: false };
     }
     let retryCountAfterPreDecrement;
     try {
@@ -522,7 +539,7 @@ async function resetCard(password, newPassword, onCardIdentified) {
         }
         catch {
             (0, nfc_core_1.releaseNfcLock)();
-            return { code: types_1.ResultCode.NFC_CONNECT_FAILED, success: false };
+            return { code: types_1.NfcStatusCode.NFC_CONNECT_FAILED, success: false };
         }
         try {
             if (password) {
@@ -533,7 +550,7 @@ async function resetCard(password, newPassword, onCardIdentified) {
                 }
                 catch (error) {
                     const code = (0, types_1.errorToCode)(error);
-                    if (code === types_1.ResultCode.RETRY_COUNT_EXHAUSTED) {
+                    if (code === types_1.NfcStatusCode.RETRY_COUNT_EXHAUSTED) {
                         await (0, nfc_core_1.releaseNfcTech)();
                         (0, nfc_core_1.releaseNfcLock)();
                         return (0, types_1.nfcResultRetryCountExhausted)();
@@ -565,11 +582,10 @@ async function resetCard(password, newPassword, onCardIdentified) {
                     }
                     catch { /* non-fatal */ }
                 }
-                await disableAuth();
             }
             else {
                 try {
-                    await disableAuth();
+                    await (0, nfc_core_1.authenticate)((0, crypto_1.passwordToAesKey)(newPassword));
                 }
                 catch {
                     throw new Error('AUTH_WRONG_PASSWORD');
@@ -578,18 +594,15 @@ async function resetCard(password, newPassword, onCardIdentified) {
             }
             // Wipe mnemonic data (nickname is preserved)
             await writeUserMemory(new Uint8Array(constants_1.MNEMONIC_MEMORY_SIZE));
-            // Set new password
+            // Set new password and keep protection enabled
             const resetKey = (0, crypto_1.passwordToAesKey)(newPassword);
+            await disableAuth();
             await writeAesKey(resetKey);
-            // Ensure protection is disabled
-            try {
-                await disableAuth();
-            }
-            catch { /* may already be off */ }
+            await configureAuth();
             await (0, nfc_core_1.releaseNfcTech)();
             (0, nfc_core_1.releaseNfcLock)();
             return {
-                code: types_1.ResultCode.RESET_SUCCESS,
+                code: types_1.NfcStatusCode.RESET_SUCCESS,
                 success: true,
                 data: { retryCount: constants_1.DEFAULT_PIN_RETRY_COUNT },
             };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ukeyfe/react-native-nfc-litecard",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "NFC read/write for MIFARE Ultralight AES (LiteCard mnemonic storage)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",