Bindings over PC/SC to access Smart Cards
npm install @ap-mitch/pcsclite
Bindings over pcsclite to access Smart Cards. It works in Linux, macOS and Windows.
> Looking for library to work easy with NFC tags?
take a look at nfc-pcsc which offers easy to use high level API for detecting / reading and writing NFC tags and cards
- Installation
- Example
- Behavior on different OS
- API
- Class: PCSCLite
- Event: 'error'
- Event: 'reader'
- pcsclite.close()
- Class: CardReader
- Event: 'error'
- Event: 'end'
- Event: 'status'
- [reader.connect([options], callback)](#readerconnectoptions-callback)
- reader.disconnect(disposition, callback)
- reader.transmit(input, res_len, protocol, callback)
- reader.control(input, control_code, res_len, callback)
- reader.close()
- FAQ
- Can I use this library in my Electron app?
- License
In order to install the package you need to **have installed in the system the
pcsclite libraries**.
In macOS and Windows you don't have to install anything.
> For example, in Debian/Ubuntu:
> ``bash`
> apt-get install libpcsclite1 libpcsclite-dev
>
> To run any code you will also need to have installed the pcsc daemon:
> bash`
> apt-get install pcscd
>
Once you have all needed libraries, you can install using npm:
`bash`
npm install @pokusew/pcsclite --save
`javascript
const pcsclite = require('@pokusew/pcsclite');
const pcsc = pcsclite();
pcsc.on('reader', (reader) => {
console.log('New reader detected', reader.name);
reader.on('error', err => {
console.log('Error(', reader.name, '):', err.message);
});
reader.on('status', (status) => {
console.log('Status(', reader.name, '):', status);
// check what has changed
const changes = reader.state ^ status.state;
if (!changes) {
return;
}
// noinspection JSBitwiseOperatorUsage
if ((changes & reader.SCARD_STATE_EMPTY) && (status.state & reader.SCARD_STATE_EMPTY)) {
console.log("card removed");
reader.disconnect(reader.SCARD_LEAVE_CARD, err => {
if (err) {
console.log(err);
return;
}
console.log('Disconnected');
});
return;
}
// noinspection JSBitwiseOperatorUsage
if ((changes & reader.SCARD_STATE_EMPTY) && (status.state & reader.SCARD_STATE_EMPTY)) {
console.log("card inserted");
reader.connect({ share_mode: reader.SCARD_SHARE_SHARED }, (err, protocol) => {
if (err) {
console.log(err);
return;
}
console.log('Protocol(', reader.name, '):', protocol);
reader.transmit(Buffer.from([0x00, 0xB0, 0x00, 0x00, 0x20]), 40, protocol, (err, data) => {
if (err) {
console.log(err);
return;
}
console.log('Data received', data);
reader.close();
pcsc.close();
});
});
// noinspection UnnecessaryReturnStatementJS
return;
}
});
reader.on('end', () => {
console.log('Reader', reader.name, 'removed');
});
});
pcsc.on('error', err => {
console.log('PCSC error', err.message);
});
`
TODO document
The PCSCLite object is an EventEmitter that notifies the existence of Card Readers.
#### Event: 'error'
err* Error Object. The error.
#### Event: 'reader'
reader* CardReader. A CardReader object associated to the card reader detected
Emitted whenever a new card reader is detected.
#### pcsclite.close()
It frees the resources associated with this PCSCLite instance. At a low level it calls SCardCancel so it stops watching for new readers.
#### pcsclite.readers
An object containing all detected readers by name. Updated as readers are attached and removed.
The CardReader object is an EventEmitter that allows to manipulate a card reader.
#### Event: 'error'
err* Error Object. The error.
#### Event: 'end'
Emitted when the card reader has been removed.
#### Event: 'status'
status* Object.SCardGetStatusChange
state* The current status of the card reader as returned by
atr* ATR of the card inserted (if any)
Emitted whenever the status of the reader changes.
#### reader.connect([options], callback)
options* Object OptionalNumber
share_mode* Shared mode. Defaults to SCARD_SHARE_EXCLUSIVE
protocol* Preferred protocol. Defaults to SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1
callback* called when connection operation endsError
error*
protocol* Established protocol to this connection.
Wrapper around SCardConnect.
Establishes a connection to the reader.
#### reader.disconnect(disposition, callback)
disposition* Number. Reader function to execute. Defaults to SCARD_UNPOWER_CARD
callback* called when disconnection operation endsError
error*
Wrapper around SCardDisconnect.
Terminates a connection to the reader.
#### reader.transmit(input, res_len, protocol, callback)
input* Buffer input data to be transmittedNumber
res_len* . Max. expected length of the responseNumber
protocol* . Protocol to be used in the transmissionFunction
callback* called when transmit operation endsError
error*
output*
Wrapper around SCardTransmit.
Sends an APDU to the smart card contained in the reader connected to.
#### reader.control(input, control_code, res_len, callback)
input* Buffer input data to be transmittedNumber
control_code* . Control code for the operationNumber
res_len* . Max. expected length of the responseFunction
callback* called when control operation endsError
error*
output*
Wrapper around SCardControl.
Sends a command directly to the IFD Handler (reader driver) to be processed by the reader.
#### reader.close()
It frees the resources associated with this CardReader instance.
At a low level it calls SCardCancel` so it stops watching for the reader status changes.
Yes, you can! It works well.
But please read carefully Using Native Node Modules guide in Electron documentation to fully understand the problematic.
Note, that because of Node Native Modules, you must build your app on target platform (you must run Windows build on Windows machine, etc.).
You can use CI/CD server to build your app for certain platforms.
For Windows, I recommend you to use AppVeyor.
For macOS and Linux build, there are plenty of services to choose from, for example CircleCI, Travis CI CodeShip.