@trustchex/react-native-sdk 1.161.0

package/lib/module/Shared/EIDReader/secureMessagingWrapper.js

@@ -0,0 +1,218 @@
+"use strict";
+
+import cryptoUtils from "./utils/crypto.utils.js";
+import TLVUtil from "./tlv/tlv.utils.js";
+import { ResponseAPDU } from "./smartcards/responseAPDU.js";
+import { DataInputStream } from "./java/dataInputStream.js";
+import { CommandAPDU } from "./smartcards/commandAPDU.js";
+import { ByteArrayInputStream } from "./java/byteArrayInputStream.js";
+import { Buffer } from 'buffer';
+import { ISO7816_INS } from "./smartcards/iso7816.js";
+export class SecureMessagingWrapper {
+  constructor(ksEnc, ksMac, maxTransceiveLength, shouldCheckMAC, ssc) {
+    this.ksEnc = ksEnc;
+    this.ksMac = ksMac;
+    this.maxTransceiveLength = maxTransceiveLength;
+    this.shouldCheckMAC = shouldCheckMAC;
+    this.ssc = ssc;
+  }
+  getSendSequenceCounter() {
+    return this.ssc;
+  }
+  getEncryptionKey() {
+    return this.ksEnc;
+  }
+  getMACKey() {
+    return this.ksMac;
+  }
+  getShouldCheckMAC() {
+    return this.shouldCheckMAC;
+  }
+  getMaxTransceiveLength() {
+    return this.maxTransceiveLength;
+  }
+  wrap(commandAPDU) {
+    this.ssc++;
+    try {
+      return this.wrapCommandAPDU(commandAPDU);
+    } catch (error) {
+      throw new Error('Unexpected exception: ' + error);
+    }
+  }
+  async unwrap(responseAPDU) {
+    this.ssc++;
+    try {
+      const data = responseAPDU.getData();
+      if (data == null || data.length <= 0) {
+        throw new Error(`Card indicates SM error, SW = ${Buffer.from([responseAPDU.getSW() & 0xffff]).toString('hex')}`);
+      }
+      return await this.unwrapResponseAPDU(responseAPDU);
+    } catch (error) {
+      throw new Error(`Unexpected exception: ${error}`);
+    }
+  }
+  checkMac(rapdu, cc) {
+    try {
+      const dataOutputStream = Array.from(this.getEncodedSendSequenceCounter());
+      const paddedData = cryptoUtils.pad(Buffer.from(rapdu), 0, rapdu.length - 2 - 8 - 2, this.getPadLength());
+      dataOutputStream.push(...paddedData);
+      let cc2 = Uint8Array.from(Buffer.from(cryptoUtils.computeMac(Buffer.from(dataOutputStream).toString('hex'), this.ksMac), 'hex'));
+      if (cc2.length > 8 && cc.length === 8) {
+        const newCC2 = new Uint8Array(8);
+        for (let i = 0; i < 8; i++) {
+          newCC2[i] = cc2[i];
+        }
+        cc2 = newCC2;
+      }
+      return Buffer.compare(Buffer.from(cc), Buffer.from(cc2)) === 0;
+    } catch (ioe) {
+      console.debug('Error checking MAC', ioe);
+      return false;
+    }
+  }
+  wrapCommandAPDU(commandAPDU) {
+    const cla = commandAPDU.getCLA();
+    const ins = commandAPDU.getINS();
+    const p1 = commandAPDU.getP1();
+    const p2 = commandAPDU.getP2();
+    const lc = commandAPDU.getNc();
+    const le = commandAPDU.getNe();
+    const maskedHeader = [cla | 0x0c, ins, p1, p2];
+    const paddedMaskedHeader = cryptoUtils.pad(Buffer.from(maskedHeader), 0, maskedHeader.length, this.getPadLength());
+    const hasDO85 = commandAPDU.getINS() === ISO7816_INS.READ_BINARY2;
+    let do8587 = [];
+    let do97 = [];
+    let output = [];
+    if (le > 0) {
+      do97 = Array.from(TLVUtil.wrapDO(0x97, this.encodeLe(le)));
+    }
+    if (lc > 0) {
+      const data = cryptoUtils.pad(Buffer.from(commandAPDU.getData()), 0, commandAPDU.getData().length, this.getPadLength());
+      const ciphertext = Buffer.from(cryptoUtils.encryptWith3DES(Buffer.from(data).toString('hex'), this.ksEnc), 'hex');
+      output.push(hasDO85 ? 0x85 : 0x87);
+      output.push(...TLVUtil.getLengthAsBytes(ciphertext.length + (hasDO85 ? 0 : 1)));
+      if (!hasDO85) {
+        output.push(0x01);
+      }
+      output.push(...ciphertext);
+      do8587 = output;
+    }
+    output = [...this.getEncodedSendSequenceCounter(), ...paddedMaskedHeader, ...do8587, ...do97];
+    const n = cryptoUtils.pad(Buffer.from(output), 0, output.length, this.getPadLength());
+    const cc = Buffer.from(cryptoUtils.computeMac(Buffer.from(n).toString('hex'), this.ksMac), 'hex');
+    let ccLength = cc.length;
+    if (ccLength !== 8) {
+      ccLength = 8;
+    }
+    const do8E = [0x8e, ccLength & 0xff, ...cc.subarray(0, ccLength)];
+    const data = Uint8Array.from([...do8587, ...do97, ...do8E]);
+    if (le <= 256 && data.length <= 255) {
+      return new CommandAPDU(maskedHeader[0], maskedHeader[1], maskedHeader[2], maskedHeader[3], data, 0, data.length, 256);
+    } else if (le > 256 || data.length > 255) {
+      return new CommandAPDU(maskedHeader[0], maskedHeader[1], maskedHeader[2], maskedHeader[3], data, 0, data.length, 65536);
+    } else {
+      return new CommandAPDU(maskedHeader[0], maskedHeader[1], maskedHeader[2], maskedHeader[3], data, 0, data.length, this.getMaxTransceiveLength());
+    }
+  }
+  async unwrapResponseAPDU(responseAPDU) {
+    const rapdu = responseAPDU.getBytes();
+    if (rapdu == null || rapdu.length < 2) {
+      throw new Error('Invalid response APDU');
+    }
+    let data = [];
+    let cc = null;
+    let sw = 0;
+    const inputStream = new DataInputStream(new ByteArrayInputStream(Buffer.from(rapdu)));
+    try {
+      let isFinished = false;
+      while (!isFinished) {
+        const tag = await inputStream.readByte();
+        switch (tag) {
+          case 0x87:
+            data = await this.readDO87(inputStream, false);
+            break;
+          case 0x85:
+            data = await this.readDO87(inputStream, true);
+            break;
+          case 0x99:
+            sw = await this.readDO99(inputStream);
+            break;
+          case 0x8e:
+            cc = await this.readDO8E(inputStream);
+            isFinished = true;
+            break;
+          default:
+            console.debug(`Unexpected tag ${Buffer.from([tag]).toString('hex')}`);
+            break;
+        }
+      }
+    } finally {
+      inputStream.close();
+    }
+    if (this.getShouldCheckMAC() && cc && !this.checkMac(rapdu, Array.from(cc))) {
+      throw new Error('Invalid MAC');
+    }
+    const bOut = [];
+    bOut.push(...data);
+    bOut.push((sw & 0xff00) >> 8 & 0xff);
+    bOut.push(sw & 0x00ff);
+    return new ResponseAPDU(bOut);
+  }
+  encodeLe(le) {
+    if (le >= 0 && le <= 256) {
+      /* NOTE: Both 0x00 and 0x100 are mapped to 0x00. */
+      return [le & 0xff];
+    } else {
+      return [(le & 0xff00) >> 8 & 0xff, le & 0xff];
+    }
+  }
+  async readDO87(inputStream, do85) {
+    let length = 0;
+    let buf = await inputStream.readUnsignedByte();
+    if ((buf & 0x00000080) !== 0x00000080) {
+      length = buf;
+      if (!do85) {
+        buf = await inputStream.readUnsignedByte();
+        if (buf !== 0x01) {
+          throw new Error("DO'87 expected 0x01 marker, found " + Buffer.from([buf & 0xff]).toString('hex'));
+        }
+      }
+    } else {
+      const lengthBytesCount = buf & 0x0000007f;
+      for (let i = 0; i < lengthBytesCount; i++) {
+        length = length << 8 | (await inputStream.readUnsignedByte());
+      }
+      if (!do85) {
+        buf = await inputStream.readUnsignedByte();
+        if (buf !== 0x01) {
+          throw new Error("DO'87 expected 0x01 marker");
+        }
+      }
+    }
+    if (!do85) {
+      length--;
+    }
+    const ciphertext = Buffer.alloc(length);
+    inputStream.readFully(ciphertext);
+    const paddedData = Array.from(Buffer.from(cryptoUtils.decryptWith3DES(Buffer.from(ciphertext).toString('hex'), this.ksEnc), 'hex'));
+    return cryptoUtils.unpad(paddedData);
+  }
+  async readDO99(inputStream) {
+    const length = await inputStream.readUnsignedByte();
+    if (length !== 2) {
+      throw new Error("DO'99 wrong length");
+    }
+    const sw1 = await inputStream.readByte();
+    const sw2 = await inputStream.readByte();
+    return (sw1 & 0x000000ff) << 8 | sw2 & 0x000000ff;
+  }
+  async readDO8E(inputStream) {
+    const length = await inputStream.readUnsignedByte();
+    if (length !== 8 && length !== 16) {
+      throw new Error("DO'8E wrong length for MAC: " + length);
+    }
+    const cc = Buffer.alloc(length);
+    inputStream.readFully(cc);
+    return cc;
+  }
+}

package/lib/module/Shared/EIDReader/smartcards/apduEvent.js

@@ -0,0 +1,23 @@
+"use strict";
+
+export class APDUEvent {
+  constructor(source, type, sequenceNumber, capdu, rapdu) {
+    this.source = source;
+    this.type = type;
+    this.sequenceNumber = sequenceNumber;
+    this.capdu = capdu;
+    this.rapdu = rapdu;
+  }
+  getType() {
+    return this.type;
+  }
+  getSequenceNumber() {
+    return this.sequenceNumber;
+  }
+  getCommandAPDU() {
+    return this.capdu;
+  }
+  getResponseAPDU() {
+    return this.rapdu;
+  }
+}

package/lib/module/Shared/EIDReader/smartcards/apduListener.js

@@ -0,0 +1,3 @@
+"use strict";
+
+export {};

package/lib/module/Shared/EIDReader/smartcards/apduWrapper.js

@@ -0,0 +1,3 @@
+"use strict";
+
+export {};

package/lib/module/Shared/EIDReader/smartcards/commandAPDU.js

@@ -0,0 +1,124 @@
+"use strict";
+
+import { Buffer } from 'buffer';
+export class CommandAPDU {
+  static MAX_APDU_SIZE = 65544;
+  nc = 0;
+  ne = 0;
+  dataOffset = 0;
+  constructor(cla, ins, p1, p2, data, dataOffset, dataLength, ne) {
+    this.nc = dataLength || 0;
+    this.ne = ne || 0;
+    this.apdu = this.buildAPDU(cla, ins, p1, p2, data, dataOffset || 0, this.nc, this.ne);
+  }
+  buildAPDU(cla, ins, p1, p2, data, dataOffset = 0, dataLength = 0, ne = 0) {
+    let apdu;
+    if (dataLength > 65535) {
+      throw new Error('dataLength is too large');
+    }
+    if (ne < 0) {
+      throw new Error('ne must not be negative');
+    }
+    if (ne > 65536) {
+      throw new Error('ne is too large');
+    }
+    if (dataLength === 0) {
+      if (ne === 0) {
+        apdu = new Uint8Array(4);
+        this.setHeader(apdu, cla, ins, p1, p2);
+      } else if (ne <= 256) {
+        apdu = new Uint8Array(5);
+        this.setHeader(apdu, cla, ins, p1, p2);
+        apdu[4] = (ne !== 256 ? ne : 0) & 0xff;
+      } else {
+        apdu = new Uint8Array(7);
+        this.setHeader(apdu, cla, ins, p1, p2);
+        if (ne === 65536) {
+          apdu[5] = 0 & 0xff;
+          apdu[6] = 0 & 0xff;
+        } else {
+          apdu[5] = ne >> 8 & 0xff;
+          apdu[6] = ne & 0xff;
+        }
+      }
+    } else if (ne === 0) {
+      if (dataLength <= 255) {
+        apdu = new Uint8Array(5 + dataLength);
+        this.setHeader(apdu, cla, ins, p1, p2);
+        apdu[4] = dataLength & 0xff;
+        this.dataOffset = 5;
+        if (data) {
+          apdu.set(data.slice(dataOffset, dataOffset + dataLength), 5);
+        }
+      } else {
+        apdu = new Uint8Array(7 + dataLength);
+        this.setHeader(apdu, cla, ins, p1, p2);
+        apdu[4] = 0 & 0xff;
+        apdu[5] = dataLength >> 8 & 0xff;
+        apdu[6] = dataLength & 0xff;
+        this.dataOffset = 7;
+        if (data) {
+          apdu.set(data.slice(dataOffset, dataOffset + dataLength), 7);
+        }
+      }
+    } else if (dataLength <= 255 && ne <= 256) {
+      apdu = new Uint8Array(6 + dataLength);
+      this.setHeader(apdu, cla, ins, p1, p2);
+      apdu[4] = dataLength & 0xff;
+      this.dataOffset = 5;
+      if (data) {
+        apdu.set(data.slice(dataOffset, dataOffset + dataLength), 5);
+      }
+      apdu[apdu.length - 1] = (ne !== 256 ? ne : 0) & 0xff;
+    } else {
+      apdu = new Uint8Array(9 + dataLength);
+      this.setHeader(apdu, cla, ins, p1, p2);
+      apdu[4] = 0 & 0xff;
+      apdu[5] = dataLength >> 8 & 0xff;
+      apdu[6] = dataLength & 0xff;
+      this.dataOffset = 7;
+      if (data) {
+        apdu.set(data.slice(dataOffset, dataOffset + dataLength), 7);
+      }
+      if (ne !== 65536) {
+        const l1 = apdu.length - 2;
+        apdu[l1] = ne >> 8 & 0xff;
+        apdu[l1 + 1] = ne & 0xff;
+      }
+    }
+    return apdu;
+  }
+  setHeader(apdu, cla, ins, p1, p2) {
+    apdu[0] = cla & 0xff;
+    apdu[1] = ins & 0xff;
+    apdu[2] = p1 & 0xff;
+    apdu[3] = p2 & 0xff;
+  }
+  getCLA() {
+    return this.apdu[0] & 0xff;
+  }
+  getINS() {
+    return this.apdu[1] & 0xff;
+  }
+  getP1() {
+    return this.apdu[2] & 0xff;
+  }
+  getP2() {
+    return this.apdu[3] & 0xff;
+  }
+  getNc() {
+    return this.nc;
+  }
+  getData() {
+    return this.apdu.slice(this.dataOffset, this.dataOffset + this.nc);
+  }
+  getNe() {
+    return this.ne;
+  }
+  getBytes() {
+    return Uint8Array.from(this.apdu);
+  }
+  toString() {
+    return `CommandAPDU: ${Buffer.from(this.apdu).toString('hex').toUpperCase()} bytes, nc=${this.nc}, ne=${this.ne}`;
+  }
+}

package/lib/module/Shared/EIDReader/smartcards/fileSystemStructured.js

@@ -0,0 +1,3 @@
+"use strict";
+
+export {};

package/lib/module/Shared/EIDReader/smartcards/iso7816.js

@@ -0,0 +1,107 @@
+"use strict";
+
+export let ISO7816_OFFSET = /*#__PURE__*/function (ISO7816_OFFSET) {
+  ISO7816_OFFSET[ISO7816_OFFSET["CLA"] = 0] = "CLA";
+  ISO7816_OFFSET[ISO7816_OFFSET["INS"] = 1] = "INS";
+  ISO7816_OFFSET[ISO7816_OFFSET["P1"] = 2] = "P1";
+  ISO7816_OFFSET[ISO7816_OFFSET["P2"] = 3] = "P2";
+  ISO7816_OFFSET[ISO7816_OFFSET["LC"] = 4] = "LC";
+  ISO7816_OFFSET[ISO7816_OFFSET["CDATA"] = 5] = "CDATA";
+  return ISO7816_OFFSET;
+}({});
+export let ISO7816_CLA = /*#__PURE__*/function (ISO7816_CLA) {
+  ISO7816_CLA[ISO7816_CLA["ISO7816"] = 0] = "ISO7816";
+  ISO7816_CLA[ISO7816_CLA["COMMAND_CHAINING"] = 16] = "COMMAND_CHAINING";
+  return ISO7816_CLA;
+}({});
+export let ISO7816_INS = /*#__PURE__*/function (ISO7816_INS) {
+  ISO7816_INS[ISO7816_INS["INVALIDATE_CHV"] = 4] = "INVALIDATE_CHV";
+  ISO7816_INS[ISO7816_INS["ERASE_BINARY"] = 14] = "ERASE_BINARY";
+  ISO7816_INS[ISO7816_INS["VERIFY"] = 32] = "VERIFY";
+  ISO7816_INS[ISO7816_INS["CHANGE_CHV"] = 36] = "CHANGE_CHV";
+  ISO7816_INS[ISO7816_INS["UNBLOCK_CHV"] = 44] = "UNBLOCK_CHV";
+  ISO7816_INS[ISO7816_INS["DECREASE"] = 48] = "DECREASE";
+  ISO7816_INS[ISO7816_INS["INCREASE"] = 50] = "INCREASE";
+  ISO7816_INS[ISO7816_INS["DECREASE_STAMPED"] = 52] = "DECREASE_STAMPED";
+  ISO7816_INS[ISO7816_INS["REHABILITATE_CHV"] = 68] = "REHABILITATE_CHV";
+  ISO7816_INS[ISO7816_INS["MANAGE_CHANNEL"] = 112] = "MANAGE_CHANNEL";
+  ISO7816_INS[ISO7816_INS["EXTERNAL_AUTHENTICATE"] = 130] = "EXTERNAL_AUTHENTICATE";
+  ISO7816_INS[ISO7816_INS["MUTUAL_AUTHENTICATE"] = 130] = "MUTUAL_AUTHENTICATE";
+  ISO7816_INS[ISO7816_INS["GET_CHALLENGE"] = 132] = "GET_CHALLENGE";
+  ISO7816_INS[ISO7816_INS["ASK_RANDOM"] = 132] = "ASK_RANDOM";
+  ISO7816_INS[ISO7816_INS["GIVE_RANDOM"] = 134] = "GIVE_RANDOM";
+  ISO7816_INS[ISO7816_INS["INTERNAL_AUTHENTICATE"] = 136] = "INTERNAL_AUTHENTICATE";
+  ISO7816_INS[ISO7816_INS["SEEK"] = 162] = "SEEK";
+  ISO7816_INS[ISO7816_INS["SELECT"] = 164] = "SELECT";
+  ISO7816_INS[ISO7816_INS["SELECT_FILE"] = 164] = "SELECT_FILE";
+  ISO7816_INS[ISO7816_INS["CLOSE_APPLICATION"] = 172] = "CLOSE_APPLICATION";
+  ISO7816_INS[ISO7816_INS["READ_BINARY"] = 176] = "READ_BINARY";
+  ISO7816_INS[ISO7816_INS["READ_BINARY2"] = 177] = "READ_BINARY2";
+  ISO7816_INS[ISO7816_INS["READ_RECORD"] = 178] = "READ_RECORD";
+  ISO7816_INS[ISO7816_INS["READ_RECORD2"] = 179] = "READ_RECORD2";
+  ISO7816_INS[ISO7816_INS["READ_RECORDS"] = 187] = "READ_RECORDS";
+  ISO7816_INS[ISO7816_INS["READ_BINARY_STAMPED"] = 188] = "READ_BINARY_STAMPED";
+  ISO7816_INS[ISO7816_INS["READ_RECORD_STAMPED"] = 189] = "READ_RECORD_STAMPED";
+  ISO7816_INS[ISO7816_INS["GET_RESPONSE"] = 192] = "GET_RESPONSE";
+  ISO7816_INS[ISO7816_INS["ENVELOPE"] = 194] = "ENVELOPE";
+  ISO7816_INS[ISO7816_INS["GET_DATA"] = 202] = "GET_DATA";
+  ISO7816_INS[ISO7816_INS["WRITE_BINARY"] = 208] = "WRITE_BINARY";
+  ISO7816_INS[ISO7816_INS["WRITE_RECORD"] = 210] = "WRITE_RECORD";
+  ISO7816_INS[ISO7816_INS["UPDATE_BINARY"] = 214] = "UPDATE_BINARY";
+  ISO7816_INS[ISO7816_INS["LOAD_KEY_FILE"] = 216] = "LOAD_KEY_FILE";
+  ISO7816_INS[ISO7816_INS["PUT_DATA"] = 218] = "PUT_DATA";
+  ISO7816_INS[ISO7816_INS["UPDATE_RECORD"] = 220] = "UPDATE_RECORD";
+  ISO7816_INS[ISO7816_INS["CREATE_FILE"] = 224] = "CREATE_FILE";
+  ISO7816_INS[ISO7816_INS["APPEND_RECORD"] = 226] = "APPEND_RECORD";
+  ISO7816_INS[ISO7816_INS["DELETE_FILE"] = 228] = "DELETE_FILE";
+  ISO7816_INS[ISO7816_INS["PSO"] = 232] = "PSO";
+  ISO7816_INS[ISO7816_INS["MSE"] = 34] = "MSE";
+  return ISO7816_INS;
+}({});
+export let ISO7816_TAG = /*#__PURE__*/function (ISO7816_TAG) {
+  ISO7816_TAG[ISO7816_TAG["SM_ENCRYPTED_DATA"] = 133] = "SM_ENCRYPTED_DATA";
+  ISO7816_TAG[ISO7816_TAG["SM_ENCRYPTED_DATA_WITH_PADDING_INDICATOR"] = 135] = "SM_ENCRYPTED_DATA_WITH_PADDING_INDICATOR";
+  ISO7816_TAG[ISO7816_TAG["SM_CRYPTOGRAPHIC_CHECKSUM"] = 142] = "SM_CRYPTOGRAPHIC_CHECKSUM";
+  ISO7816_TAG[ISO7816_TAG["SM_EXPECTED_LENGTH"] = 151] = "SM_EXPECTED_LENGTH";
+  ISO7816_TAG[ISO7816_TAG["SM_STATUS_WORD"] = 153] = "SM_STATUS_WORD";
+  return ISO7816_TAG;
+}({});
+export let ISO7816_SW = /*#__PURE__*/function (ISO7816_SW) {
+  ISO7816_SW[ISO7816_SW["BYTES_REMAINING_00"] = 24832] = "BYTES_REMAINING_00";
+  ISO7816_SW[ISO7816_SW["STATE_NON_VOLATILE_MEMORY_UNCHANGED_NO_INFORMATION_GIVEN"] = 25088] = "STATE_NON_VOLATILE_MEMORY_UNCHANGED_NO_INFORMATION_GIVEN";
+  ISO7816_SW[ISO7816_SW["END_OF_FILE"] = 25218] = "END_OF_FILE";
+  ISO7816_SW[ISO7816_SW["LESS_DATA_RESPONDED_THAN_REQUESTED"] = 25223] = "LESS_DATA_RESPONDED_THAN_REQUESTED";
+  ISO7816_SW[ISO7816_SW["NON_VOLATILE_MEMORY_CHANGED_NO_INFORMATION_GIVEN"] = 25344] = "NON_VOLATILE_MEMORY_CHANGED_NO_INFORMATION_GIVEN";
+  ISO7816_SW[ISO7816_SW["NON_VOLATILE_MEMORY_CHANGED_FILE_FILLED_UP_BY_LAST_WRITE"] = 25473] = "NON_VOLATILE_MEMORY_CHANGED_FILE_FILLED_UP_BY_LAST_WRITE";
+  ISO7816_SW[ISO7816_SW["NON_VOLATILE_MEMORY_CHANGED_COUNTER_0"] = 25536] = "NON_VOLATILE_MEMORY_CHANGED_COUNTER_0";
+  ISO7816_SW[ISO7816_SW["WRONG_LENGTH"] = 26368] = "WRONG_LENGTH";
+  ISO7816_SW[ISO7816_SW["LOGICAL_CHANNEL_NOT_SUPPORTED"] = 26753] = "LOGICAL_CHANNEL_NOT_SUPPORTED";
+  ISO7816_SW[ISO7816_SW["SECURE_MESSAGING_NOT_SUPPORTED"] = 26754] = "SECURE_MESSAGING_NOT_SUPPORTED";
+  ISO7816_SW[ISO7816_SW["LAST_COMMAND_EXPECTED"] = 26755] = "LAST_COMMAND_EXPECTED";
+  ISO7816_SW[ISO7816_SW["SECURITY_STATUS_NOT_SATISFIED"] = 27010] = "SECURITY_STATUS_NOT_SATISFIED";
+  ISO7816_SW[ISO7816_SW["FILE_INVALID"] = 27011] = "FILE_INVALID";
+  ISO7816_SW[ISO7816_SW["DATA_INVALID"] = 27012] = "DATA_INVALID";
+  ISO7816_SW[ISO7816_SW["CONDITIONS_NOT_SATISFIED"] = 27013] = "CONDITIONS_NOT_SATISFIED";
+  ISO7816_SW[ISO7816_SW["COMMAND_NOT_ALLOWED"] = 27014] = "COMMAND_NOT_ALLOWED";
+  ISO7816_SW[ISO7816_SW["EXPECTED_SM_DATA_OBJECTS_MISSING"] = 27015] = "EXPECTED_SM_DATA_OBJECTS_MISSING";
+  ISO7816_SW[ISO7816_SW["SM_DATA_OBJECTS_INCORRECT"] = 27016] = "SM_DATA_OBJECTS_INCORRECT";
+  ISO7816_SW[ISO7816_SW["APPLET_SELECT_FAILED"] = 27033] = "APPLET_SELECT_FAILED";
+  ISO7816_SW[ISO7816_SW["KEY_USAGE_ERROR"] = 27073] = "KEY_USAGE_ERROR";
+  ISO7816_SW[ISO7816_SW["WRONG_DATA"] = 27264] = "WRONG_DATA";
+  ISO7816_SW[ISO7816_SW["FILEHEADER_INCONSISTENT"] = 27264] = "FILEHEADER_INCONSISTENT";
+  ISO7816_SW[ISO7816_SW["FUNC_NOT_SUPPORTED"] = 27265] = "FUNC_NOT_SUPPORTED";
+  ISO7816_SW[ISO7816_SW["FILE_NOT_FOUND"] = 27266] = "FILE_NOT_FOUND";
+  ISO7816_SW[ISO7816_SW["RECORD_NOT_FOUND"] = 27267] = "RECORD_NOT_FOUND";
+  ISO7816_SW[ISO7816_SW["FILE_FULL"] = 27268] = "FILE_FULL";
+  ISO7816_SW[ISO7816_SW["OUT_OF_MEMORY"] = 27269] = "OUT_OF_MEMORY";
+  ISO7816_SW[ISO7816_SW["INCORRECT_P1P2"] = 27270] = "INCORRECT_P1P2";
+  ISO7816_SW[ISO7816_SW["KEY_NOT_FOUND"] = 27272] = "KEY_NOT_FOUND";
+  ISO7816_SW[ISO7816_SW["WRONG_P1P2"] = 27392] = "WRONG_P1P2";
+  ISO7816_SW[ISO7816_SW["CORRECT_LENGTH_00"] = 27648] = "CORRECT_LENGTH_00";
+  ISO7816_SW[ISO7816_SW["NOT_SUPPORTED"] = 27904] = "NOT_SUPPORTED";
+  ISO7816_SW[ISO7816_SW["CLA_NOT_SUPPORTED"] = 28160] = "CLA_NOT_SUPPORTED";
+  ISO7816_SW[ISO7816_SW["UNKNOWN"] = 28416] = "UNKNOWN";
+  ISO7816_SW[ISO7816_SW["CARD_TERMINATED"] = 28670] = "CARD_TERMINATED";
+  ISO7816_SW[ISO7816_SW["NO_ERROR"] = 36864] = "NO_ERROR";
+  return ISO7816_SW;
+}({});

package/lib/module/Shared/EIDReader/smartcards/responseAPDU.js

@@ -0,0 +1,35 @@
+"use strict";
+
+import { Buffer } from 'buffer';
+export class ResponseAPDU {
+  constructor(apdu) {
+    this.apdu = [...apdu];
+    this.check(this.apdu);
+  }
+  check(apdu) {
+    if (apdu.length < 2) {
+      throw new Error('ResponseAPDU must be at least 2 bytes long');
+    }
+  }
+  getNr() {
+    return this.apdu.length - 2;
+  }
+  getData() {
+    return this.apdu.slice(0, this.apdu.length - 2);
+  }
+  getSW1() {
+    return this.apdu[this.apdu.length - 2] & 0xff;
+  }
+  getSW2() {
+    return this.apdu[this.apdu.length - 1] & 0xff;
+  }
+  getSW() {
+    return this.getSW1() << 8 | this.getSW2();
+  }
+  getBytes() {
+    return [...this.apdu];
+  }
+  toString() {
+    return `ResponseAPDU: ${Buffer.from(this.apdu).toString('hex').toUpperCase()} bytes, SW=${this.getSW().toString(16)}`;
+  }
+}

package/lib/module/Shared/EIDReader/tlv/asn1Constants.js

@@ -0,0 +1,48 @@
+"use strict";
+
+export class ASN1Constants {
+  /** Universal tag class. */
+  static UNIVERSAL_CLASS = 0; /* 00 x xxxxx */
+
+  /** Application tag class. */
+  static APPLICATION_CLASS = 1; /* 01 x xxxxx */
+
+  /** Context specific tag class. */
+  static CONTEXT_SPECIFIC_CLASS = 2; /* 10 x xxxxx */
+
+  /** Private tag class. */
+  static PRIVATE_CLASS = 3; /* 11 x xxxxx */
+
+  /*
+   * Universal tag type (tag number).
+   * Rightmost 5 bits, should be prefixed
+   * with class indicator (2 bits) and
+   * primitive/constructed indicator (1 bit).
+   */
+
+  static BOOLEAN_TYPE_TAG = 0x01; /* 00 0 00001, Section 8.2 of X.690. */
+  static INTEGER_TYPE_TAG = 0x02; /* 00 0 00010, Section 8.3 of X.690. */
+  static BIT_STRING_TYPE_TAG = 0x03; /* 00 x 00011, Section 8.6 of X.690. */
+  static OCTET_STRING_TYPE_TAG = 0x04; /* xx x 00100 */
+  static NULL_TYPE_TAG = 0x05; /* xx x 00101 */
+  static OBJECT_IDENTIFIER_TYPE_TAG = 0x06; /* xx x 00110 */
+  static OBJECT_DESCRIPTOR_TYPE_TAG = 0x07; /* xx x 00111 */
+  static EXTERNAL_TYPE_TAG = 0x08; /* xx x 01000 */
+  static REAL_TYPE_TAG = 0x09; /* xx x 01001 */
+  static ENUMERATED_TYPE_TAG = 0x0a; /* xx x 01010 */
+  static EMBEDDED_PDV_TYPE_TAG = 0x0b; /* xx x 01011 */
+  static UTF8_STRING_TYPE_TAG = 0x0c; /* xx x 01100 */
+  static SEQUENCE_TYPE_TAG = 0x10; /* 00 1 10000, Section 8.10 of X.690. */
+  static SET_TYPE_TAG = 0x11; /* 00 1 10001 */
+  static NUMERIC_STRING_TYPE_TAG = 0x12; /* xx x 10010 */
+  static PRINTABLE_STRING_TYPE_TAG = 0x13; /* xx x 10011 */
+  static T61_STRING_TYPE_TAG = 0x14; /* xx x 10100 */
+  static IA5_STRING_TYPE_TAG = 0x16; /* xx x 10110 */
+  static UTC_TIME_TYPE_TAG = 0x17; /* xx x 10111 */
+  static GENERALIZED_TIME_TYPE_TAG = 0x18; /* xx x 11000 */
+  static GRAPHIC_STRING_TYPE_TAG = 0x19; /* xx x 11001 */
+  static VISIBLE_STRING_TYPE_TAG = 0x1a; /* xx x 11010 */
+  static GENERAL_STRING_TYPE_TAG = 0x1b; /* xx x 11011 */
+  static UNIVERSAL_STRING_TYPE_TAG = 0x1c; /* xx x 11100 */
+  static BMP_STRING_TYPE_TAG = 0x1e; /* xx x 11110 */
+}