smartcard 1.0.46 → 2.0.1

package/package.json

@@ -1,41 +1,58 @@
 {
-  "name": "smartcard",
-  "version": "1.0.46",
-  "author": "tomkp <tom@tomkp.com>",
-  "keywords": [
-    "pcsc",
-    "smartcard",
-    "smart-card",
-    "iso7816",
-    "iso-7816",
-    "emv",
-    "es6"
-  ],
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/tomkp/smartcard.git"
-  },
-  "bugs": {
-    "url": "https://github.com/tomkp/smartcard/issues"
-  },
-  "homepage": "https://github.com/tomkp/smartcard",
-  "main": "lib/index.js",
-  "scripts": {
-    "compile": "babel -d lib/ src/",
-    "compile:watch": "babel -w -d lib/ src/",
-    "release:patch": "npm run compile && npm version patch && git push && yarn publish",
-    "prettier": "prettier --write \"{src,demo}/**/*.{js,ts}\""
-  },
-  "dependencies": {
-    "@pokusew/pcsclite": "^0.6.0",
-    "hexify": "^1.0.4",
-    "pino": "^6.11.1"
-  },
-  "devDependencies": {
-    "@babel/cli": "^7.12.16",
-    "@babel/core": "^7.12.16",
-    "@babel/preset-env": "^7.12.16",
-    "prettier": "^2.2.1"
-  }
+    "name": "smartcard",
+    "version": "2.0.1",
+    "description": "PC/SC bindings for Node.js using N-API - ABI stable across Node.js versions",
+    "author": "Tom KP",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/tomkp/smartcard.git"
+    },
+    "bugs": {
+        "url": "https://github.com/tomkp/smartcard/issues"
+    },
+    "homepage": "https://github.com/tomkp/smartcard#readme",
+    "main": "lib/index.js",
+    "types": "lib/index.d.ts",
+    "gypfile": true,
+    "scripts": {
+        "install": "node-gyp rebuild",
+        "build": "node-gyp rebuild",
+        "rebuild": "node-gyp rebuild",
+        "test": "node test/test.js"
+    },
+    "files": [
+        "lib/",
+        "src/",
+        "binding.gyp",
+        "README.md",
+        "LICENSE"
+    ],
+    "dependencies": {
+        "node-addon-api": "^7.0.0"
+    },
+    "devDependencies": {
+        "node-gyp": "^10.0.0"
+    },
+    "engines": {
+        "node": ">=12.0.0"
+    },
+    "os": [
+        "darwin",
+        "linux",
+        "win32"
+    ],
+    "keywords": [
+        "pcsc",
+        "pcsclite",
+        "smartcard",
+        "smart-card",
+        "nfc",
+        "rfid",
+        "contactless",
+        "napi",
+        "node-addon-api",
+        "acr122",
+        "card-reader"
+    ]
 }

package/src/addon.cpp

@@ -0,0 +1,54 @@
+#include <napi.h>
+#include "pcsc_context.h"
+#include "pcsc_reader.h"
+#include "pcsc_card.h"
+#include "reader_monitor.h"
+#include "platform/pcsc.h"
+
+// Export PC/SC constants
+void ExportConstants(Napi::Env env, Napi::Object exports) {
+    // Share modes
+    exports.Set("SCARD_SHARE_EXCLUSIVE", Napi::Number::New(env, SCARD_SHARE_EXCLUSIVE));
+    exports.Set("SCARD_SHARE_SHARED", Napi::Number::New(env, SCARD_SHARE_SHARED));
+    exports.Set("SCARD_SHARE_DIRECT", Napi::Number::New(env, SCARD_SHARE_DIRECT));
+
+    // Protocols
+    exports.Set("SCARD_PROTOCOL_T0", Napi::Number::New(env, SCARD_PROTOCOL_T0));
+    exports.Set("SCARD_PROTOCOL_T1", Napi::Number::New(env, SCARD_PROTOCOL_T1));
+    exports.Set("SCARD_PROTOCOL_RAW", Napi::Number::New(env, SCARD_PROTOCOL_RAW));
+    exports.Set("SCARD_PROTOCOL_UNDEFINED", Napi::Number::New(env, SCARD_PROTOCOL_UNDEFINED));
+
+    // Disposition
+    exports.Set("SCARD_LEAVE_CARD", Napi::Number::New(env, SCARD_LEAVE_CARD));
+    exports.Set("SCARD_RESET_CARD", Napi::Number::New(env, SCARD_RESET_CARD));
+    exports.Set("SCARD_UNPOWER_CARD", Napi::Number::New(env, SCARD_UNPOWER_CARD));
+    exports.Set("SCARD_EJECT_CARD", Napi::Number::New(env, SCARD_EJECT_CARD));
+
+    // State flags
+    exports.Set("SCARD_STATE_UNAWARE", Napi::Number::New(env, SCARD_STATE_UNAWARE));
+    exports.Set("SCARD_STATE_IGNORE", Napi::Number::New(env, SCARD_STATE_IGNORE));
+    exports.Set("SCARD_STATE_CHANGED", Napi::Number::New(env, SCARD_STATE_CHANGED));
+    exports.Set("SCARD_STATE_UNKNOWN", Napi::Number::New(env, SCARD_STATE_UNKNOWN));
+    exports.Set("SCARD_STATE_UNAVAILABLE", Napi::Number::New(env, SCARD_STATE_UNAVAILABLE));
+    exports.Set("SCARD_STATE_EMPTY", Napi::Number::New(env, SCARD_STATE_EMPTY));
+    exports.Set("SCARD_STATE_PRESENT", Napi::Number::New(env, SCARD_STATE_PRESENT));
+    exports.Set("SCARD_STATE_ATRMATCH", Napi::Number::New(env, SCARD_STATE_ATRMATCH));
+    exports.Set("SCARD_STATE_EXCLUSIVE", Napi::Number::New(env, SCARD_STATE_EXCLUSIVE));
+    exports.Set("SCARD_STATE_INUSE", Napi::Number::New(env, SCARD_STATE_INUSE));
+    exports.Set("SCARD_STATE_MUTE", Napi::Number::New(env, SCARD_STATE_MUTE));
+}
+
+Napi::Object Init(Napi::Env env, Napi::Object exports) {
+    // Initialize wrapper classes
+    PCSCContext::Init(env, exports);
+    PCSCReader::Init(env, exports);
+    PCSCCard::Init(env, exports);
+    ReaderMonitor::Init(env, exports);
+
+    // Export constants
+    ExportConstants(env, exports);
+
+    return exports;
+}
+
+NODE_API_MODULE(smartcard_napi, Init)

package/src/async_workers.cpp

@@ -0,0 +1,234 @@
+#include "async_workers.h"
+#include "pcsc_card.h"
+#include "pcsc_errors.h"
+#include <cstring>
+
+// ============================================================================
+// WaitForChangeWorker
+// ============================================================================
+
+WaitForChangeWorker::WaitForChangeWorker(
+    Napi::Env env,
+    SCARDCONTEXT context,
+    std::vector<std::string> readerNames,
+    std::vector<DWORD> currentStates,
+    DWORD timeout,
+    Napi::Promise::Deferred deferred)
+    : Napi::AsyncWorker(env),
+      context_(context),
+      readerNames_(std::move(readerNames)),
+      timeout_(timeout),
+      result_(SCARD_S_SUCCESS),
+      deferred_(deferred) {
+
+    // Initialize reader states
+    states_.resize(readerNames_.size());
+    for (size_t i = 0; i < readerNames_.size(); i++) {
+        memset(&states_[i], 0, sizeof(SCARD_READERSTATE));
+        states_[i].szReader = readerNames_[i].c_str();
+        states_[i].dwCurrentState = (i < currentStates.size()) ? currentStates[i] : SCARD_STATE_UNAWARE;
+    }
+}
+
+void WaitForChangeWorker::Execute() {
+    // This runs on worker thread - safe to block
+    result_ = SCardGetStatusChange(context_, timeout_, states_.data(), states_.size());
+}
+
+void WaitForChangeWorker::OnOK() {
+    Napi::Env env = Env();
+
+    if (result_ == SCARD_S_SUCCESS) {
+        // Build array of reader states
+        Napi::Array changes = Napi::Array::New(env);
+
+        for (size_t i = 0; i < states_.size(); i++) {
+            Napi::Object reader = Napi::Object::New(env);
+            reader.Set("name", Napi::String::New(env, readerNames_[i]));
+            reader.Set("state", Napi::Number::New(env, states_[i].dwEventState));
+            reader.Set("changed", Napi::Boolean::New(env,
+                (states_[i].dwEventState & SCARD_STATE_CHANGED) != 0));
+
+            if (states_[i].cbAtr > 0) {
+                reader.Set("atr", Napi::Buffer<uint8_t>::Copy(
+                    env, states_[i].rgbAtr, states_[i].cbAtr));
+            } else {
+                reader.Set("atr", env.Null());
+            }
+
+            changes.Set(static_cast<uint32_t>(i), reader);
+        }
+
+        deferred_.Resolve(changes);
+    } else if (result_ == SCARD_E_CANCELLED) {
+        // Cancelled - resolve with null
+        deferred_.Resolve(env.Null());
+    } else if (result_ == SCARD_E_TIMEOUT) {
+        // Timeout - resolve with empty array
+        deferred_.Resolve(Napi::Array::New(env, 0));
+    } else {
+        deferred_.Reject(Napi::Error::New(env, GetPCSCErrorString(result_)).Value());
+    }
+}
+
+void WaitForChangeWorker::OnError(const Napi::Error& error) {
+    deferred_.Reject(error.Value());
+}
+
+// ============================================================================
+// TransmitWorker
+// ============================================================================
+
+TransmitWorker::TransmitWorker(
+    Napi::Env env,
+    SCARDHANDLE card,
+    DWORD protocol,
+    std::vector<uint8_t> sendBuffer,
+    Napi::Promise::Deferred deferred)
+    : Napi::AsyncWorker(env),
+      card_(card),
+      protocol_(protocol),
+      sendBuffer_(std::move(sendBuffer)),
+      recvLength_(0),
+      result_(SCARD_S_SUCCESS),
+      deferred_(deferred) {
+    // Pre-allocate receive buffer (max APDU response size)
+    recvBuffer_.resize(258);
+}
+
+void TransmitWorker::Execute() {
+    // Select protocol-specific PCI structure
+    const SCARD_IO_REQUEST* pioSendPci;
+    if (protocol_ == SCARD_PROTOCOL_T0) {
+        pioSendPci = SCARD_PCI_T0;
+    } else if (protocol_ == SCARD_PROTOCOL_T1) {
+        pioSendPci = SCARD_PCI_T1;
+    } else {
+        pioSendPci = SCARD_PCI_RAW;
+    }
+
+    recvLength_ = static_cast<DWORD>(recvBuffer_.size());
+
+    result_ = SCardTransmit(
+        card_,
+        pioSendPci,
+        sendBuffer_.data(),
+        static_cast<DWORD>(sendBuffer_.size()),
+        nullptr,
+        recvBuffer_.data(),
+        &recvLength_
+    );
+}
+
+void TransmitWorker::OnOK() {
+    Napi::Env env = Env();
+
+    if (result_ == SCARD_S_SUCCESS) {
+        Napi::Buffer<uint8_t> buffer = Napi::Buffer<uint8_t>::Copy(
+            env, recvBuffer_.data(), recvLength_);
+        deferred_.Resolve(buffer);
+    } else {
+        deferred_.Reject(Napi::Error::New(env, GetPCSCErrorString(result_)).Value());
+    }
+}
+
+void TransmitWorker::OnError(const Napi::Error& error) {
+    deferred_.Reject(error.Value());
+}
+
+// ============================================================================
+// ControlWorker
+// ============================================================================
+
+ControlWorker::ControlWorker(
+    Napi::Env env,
+    SCARDHANDLE card,
+    DWORD controlCode,
+    std::vector<uint8_t> sendBuffer,
+    Napi::Promise::Deferred deferred)
+    : Napi::AsyncWorker(env),
+      card_(card),
+      controlCode_(controlCode),
+      sendBuffer_(std::move(sendBuffer)),
+      bytesReturned_(0),
+      result_(SCARD_S_SUCCESS),
+      deferred_(deferred) {
+    // Pre-allocate receive buffer
+    recvBuffer_.resize(256);
+}
+
+void ControlWorker::Execute() {
+    result_ = SCardControl(
+        card_,
+        controlCode_,
+        sendBuffer_.empty() ? nullptr : sendBuffer_.data(),
+        static_cast<DWORD>(sendBuffer_.size()),
+        recvBuffer_.data(),
+        static_cast<DWORD>(recvBuffer_.size()),
+        &bytesReturned_
+    );
+}
+
+void ControlWorker::OnOK() {
+    Napi::Env env = Env();
+
+    if (result_ == SCARD_S_SUCCESS) {
+        Napi::Buffer<uint8_t> buffer = Napi::Buffer<uint8_t>::Copy(
+            env, recvBuffer_.data(), bytesReturned_);
+        deferred_.Resolve(buffer);
+    } else {
+        deferred_.Reject(Napi::Error::New(env, GetPCSCErrorString(result_)).Value());
+    }
+}
+
+void ControlWorker::OnError(const Napi::Error& error) {
+    deferred_.Reject(error.Value());
+}
+
+// ============================================================================
+// ConnectWorker
+// ============================================================================
+
+ConnectWorker::ConnectWorker(
+    Napi::Env env,
+    SCARDCONTEXT context,
+    std::string readerName,
+    DWORD shareMode,
+    DWORD preferredProtocols,
+    Napi::Promise::Deferred deferred)
+    : Napi::AsyncWorker(env),
+      context_(context),
+      readerName_(std::move(readerName)),
+      shareMode_(shareMode),
+      preferredProtocols_(preferredProtocols),
+      card_(0),
+      activeProtocol_(0),
+      result_(SCARD_S_SUCCESS),
+      deferred_(deferred) {
+}
+
+void ConnectWorker::Execute() {
+    result_ = SCardConnect(
+        context_,
+        readerName_.c_str(),
+        shareMode_,
+        preferredProtocols_,
+        &card_,
+        &activeProtocol_
+    );
+}
+
+void ConnectWorker::OnOK() {
+    Napi::Env env = Env();
+
+    if (result_ == SCARD_S_SUCCESS) {
+        Napi::Object card = PCSCCard::NewInstance(env, card_, activeProtocol_, readerName_);
+        deferred_.Resolve(card);
+    } else {
+        deferred_.Reject(Napi::Error::New(env, GetPCSCErrorString(result_)).Value());
+    }
+}
+
+void ConnectWorker::OnError(const Napi::Error& error) {
+    deferred_.Reject(error.Value());
+}

package/src/async_workers.h

@@ -0,0 +1,100 @@
+#pragma once
+
+#include <napi.h>
+#include <vector>
+#include <string>
+#include "platform/pcsc.h"
+
+// Async worker for SCardGetStatusChange
+class WaitForChangeWorker : public Napi::AsyncWorker {
+public:
+    WaitForChangeWorker(Napi::Env env,
+                        SCARDCONTEXT context,
+                        std::vector<std::string> readerNames,
+                        std::vector<DWORD> currentStates,
+                        DWORD timeout,
+                        Napi::Promise::Deferred deferred);
+
+    void Execute() override;
+    void OnOK() override;
+    void OnError(const Napi::Error& error) override;
+
+private:
+    SCARDCONTEXT context_;
+    std::vector<std::string> readerNames_;
+    std::vector<SCARD_READERSTATE> states_;
+    DWORD timeout_;
+    LONG result_;
+    Napi::Promise::Deferred deferred_;
+};
+
+// Async worker for SCardTransmit
+class TransmitWorker : public Napi::AsyncWorker {
+public:
+    TransmitWorker(Napi::Env env,
+                   SCARDHANDLE card,
+                   DWORD protocol,
+                   std::vector<uint8_t> sendBuffer,
+                   Napi::Promise::Deferred deferred);
+
+    void Execute() override;
+    void OnOK() override;
+    void OnError(const Napi::Error& error) override;
+
+private:
+    SCARDHANDLE card_;
+    DWORD protocol_;
+    std::vector<uint8_t> sendBuffer_;
+    std::vector<uint8_t> recvBuffer_;
+    DWORD recvLength_;
+    LONG result_;
+    Napi::Promise::Deferred deferred_;
+};
+
+// Async worker for SCardControl
+class ControlWorker : public Napi::AsyncWorker {
+public:
+    ControlWorker(Napi::Env env,
+                  SCARDHANDLE card,
+                  DWORD controlCode,
+                  std::vector<uint8_t> sendBuffer,
+                  Napi::Promise::Deferred deferred);
+
+    void Execute() override;
+    void OnOK() override;
+    void OnError(const Napi::Error& error) override;
+
+private:
+    SCARDHANDLE card_;
+    DWORD controlCode_;
+    std::vector<uint8_t> sendBuffer_;
+    std::vector<uint8_t> recvBuffer_;
+    DWORD bytesReturned_;
+    LONG result_;
+    Napi::Promise::Deferred deferred_;
+};
+
+// Async worker for SCardConnect
+class ConnectWorker : public Napi::AsyncWorker {
+public:
+    ConnectWorker(Napi::Env env,
+                  SCARDCONTEXT context,
+                  std::string readerName,
+                  DWORD shareMode,
+                  DWORD preferredProtocols,
+                  Napi::Promise::Deferred deferred);
+
+    void Execute() override;
+    void OnOK() override;
+    void OnError(const Napi::Error& error) override;
+
+private:
+    SCARDCONTEXT context_;
+    std::string readerName_;
+    DWORD shareMode_;
+    DWORD preferredProtocols_;
+    SCARDHANDLE card_;
+    DWORD activeProtocol_;
+    LONG result_;
+    Napi::Promise::Deferred deferred_;
+};