@trustchex/react-native-sdk 1.161.0

package/lib/module/Shared/EIDReader/lds/iso19794/faceInfo.js

@@ -0,0 +1,116 @@
+"use strict";
+
+import { CBEFFInfo } from "../../cbeff/cbeffInfo.js";
+import { ISO781611 } from "../../cbeff/iso781611.js";
+import { StandardBiometricHeader } from "../../cbeff/standardBiometricHeader.js";
+import { Gender } from "../../data/gender.js";
+import { ByteArrayInputStream } from "../../java/byteArrayInputStream.js";
+import { ByteArrayOutputStream } from "../../java/byteArrayOutputStream.js";
+import { DataInputStream } from "../../java/dataInputStream.js";
+import { DataOutputStream } from "../../java/dataOutputStream.js";
+import { AbstractListInfo } from "../abstractListInfo.js";
+import { Expression, EyeColor, FaceImageInfo, HairColor, ImageColorSpace, ImageDataType, SourceType } from "./faceImageInfo.js";
+import { Buffer } from 'buffer';
+export class FaceInfo extends AbstractListInfo {
+  static FORMAT_IDENTIFIER = 0x46414300;
+  static VERSION_NUMBER = 0x30313000;
+  static FORMAT_OWNER_VALUE = 0x0101;
+  static FORMAT_TYPE_VALUE = 0x0008;
+  constructor() {
+    super();
+    this.sbh = null;
+  }
+  async readObject(inputStream) {
+    const dataInputStream = inputStream instanceof DataInputStream ? inputStream : new DataInputStream(inputStream);
+    const fac0 = await dataInputStream.readInt();
+    if (fac0 !== FaceInfo.FORMAT_IDENTIFIER) {
+      console.debug(`'FAC' marker expected! Found ${fac0.toString(16)}`);
+      if (fac0 === 0x0000000c) {
+        const bOut = new ByteArrayOutputStream();
+        const dataOutputStream = new DataOutputStream(bOut);
+        dataOutputStream.write(fac0);
+        const imageLength = await dataInputStream.readShort();
+        dataOutputStream.write(imageLength);
+        let totalBytesRead = 0;
+        while (totalBytesRead < imageLength) {
+          const buffer = new Uint8Array(2048);
+          const chunkSize = await dataInputStream.readBytes(buffer);
+          if (chunkSize < 0) {
+            break;
+          }
+          bOut.writeBytes(buffer);
+          totalBytesRead += chunkSize;
+        }
+        const imageInfo = new FaceImageInfo(Gender.UNKNOWN, EyeColor.UNSPECIFIED, 0x00, HairColor.UNSPECIFIED.toInt(), Expression.EXPRESSION_UNSPECIFIED, [0, 0, 0], [0, 0, 0], ImageDataType.IMAGE_DATA_TYPE_JPEG2000, ImageColorSpace.IMAGE_COLOR_SPACE_UNSPECIFIED, SourceType.SOURCE_TYPE_UNSPECIFIED, 0x00, 0, [], 0, 0, new ByteArrayInputStream(Buffer.from(bOut.toByteArray())), imageLength, ImageDataType.IMAGE_DATA_TYPE_JPEG2000);
+        this.add(imageInfo);
+        return;
+      }
+    }
+    const version = await dataInputStream.readInt();
+    if (version !== FaceInfo.VERSION_NUMBER) {
+      throw new Error(`'010' version number expected! Found ${version.toString(16)}`);
+    }
+    const recordLength = (await dataInputStream.readInt()) & 0xffffffff;
+    const headerLength = 14;
+    const dataLength = recordLength - headerLength;
+    let constructedDataLength = 0;
+    const count = await dataInputStream.readUnsignedShort();
+    for (let i = 0; i < count; i++) {
+      const imageInfo = await FaceImageInfo.from(inputStream);
+      constructedDataLength += imageInfo.getRecordLength();
+      this.add(imageInfo);
+    }
+    if (dataLength !== constructedDataLength) {
+      console.debug(`ConstructedDataLength and dataLength differ: dataLength = ${dataLength}, constructedDataLength = ${constructedDataLength}`);
+    }
+  }
+  writeObject(outputStream) {
+    const headerLength = 14;
+    let dataLength = 0;
+    const faceImageInfos = this.getSubRecords();
+    for (const faceImageInfo of faceImageInfos) {
+      dataLength += faceImageInfo.getRecordLength();
+    }
+    const recordLength = headerLength + dataLength;
+    const dataOut = outputStream instanceof DataOutputStream ? outputStream : new DataOutputStream(outputStream);
+    dataOut.write(FaceInfo.FORMAT_IDENTIFIER);
+    dataOut.write(FaceInfo.VERSION_NUMBER);
+    dataOut.write(recordLength & 0x00000000ffffffff);
+    dataOut.write(faceImageInfos.length);
+    for (const faceImageInfo of faceImageInfos) {
+      faceImageInfo.writeObject(dataOut);
+    }
+  }
+  getStandardBiometricHeader() {
+    if (!this.sbh) {
+      const biometricType = [CBEFFInfo.BIOMETRIC_TYPE_FACIAL_FEATURES];
+      const biometricSubtype = [CBEFFInfo.BIOMETRIC_SUBTYPE_NONE];
+      const formatOwner = [(FaceInfo.FORMAT_OWNER_VALUE & 0xff00) >> 8, FaceInfo.FORMAT_OWNER_VALUE & 0xff];
+      const formatType = [(FaceInfo.FORMAT_TYPE_VALUE & 0xff00) >> 8, FaceInfo.FORMAT_TYPE_VALUE & 0xff];
+      const elements = new Map();
+      elements.set(ISO781611.BIOMETRIC_TYPE_TAG, Uint8Array.from(biometricType));
+      elements.set(ISO781611.BIOMETRIC_SUBTYPE_TAG, Uint8Array.from(biometricSubtype));
+      elements.set(ISO781611.FORMAT_OWNER_TAG, Uint8Array.from(formatOwner));
+      elements.set(ISO781611.FORMAT_TYPE_TAG, Uint8Array.from(formatType));
+      this.sbh = new StandardBiometricHeader(elements);
+    }
+    return this.sbh;
+  }
+  getFaceImageInfos() {
+    return this.getSubRecords();
+  }
+  addFaceImageInfo(faceImageInfo) {
+    this.add(faceImageInfo);
+  }
+  removeFaceImageInfo(index) {
+    this.remove(index);
+  }
+  static async from(inputStream, sbh) {
+    const faceInfo = new FaceInfo();
+    if (sbh) {
+      faceInfo.sbh = sbh;
+    }
+    await faceInfo.readObject(inputStream);
+    return faceInfo;
+  }
+}

package/lib/module/Shared/EIDReader/lds/ldsElement.js

@@ -0,0 +1 @@
+"use strict";

package/lib/module/Shared/EIDReader/lds/ldsFile.js

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

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

@@ -0,0 +1,44 @@
+"use strict";
+
+import NFCManager, { NfcTech } from 'react-native-nfc-manager';
+import { CardService } from "./cardService.js";
+import { ResponseAPDU } from "./smartcards/responseAPDU.js";
+import { Platform } from 'react-native';
+export class NFCManagerCardService extends CardService {
+  isOpened = false;
+  async open() {
+    await NFCManager.start();
+    await NFCManager.requestTechnology([NfcTech.IsoDep, NfcTech.NfcA, NfcTech.NfcB]);
+    // await NFCManager.setTimeout(5000);
+    this.isOpened = true;
+  }
+  getIsOpen() {
+    return this.isOpened;
+  }
+  async transmit(commandAPDU) {
+    // console.debug(
+    //   `T[${ISO7816_INS[commandAPDU.getINS()]}]:`,
+    //   Buffer.from(commandAPDU.getBytes()).toString('hex').toUpperCase(),
+    // );
+    let response;
+    if (Platform.OS === 'ios') {
+      const iosResponse = await NFCManager.sendCommandAPDUIOS(Array.from(commandAPDU.getBytes()));
+      response = [...iosResponse.response, iosResponse.sw1, iosResponse.sw2];
+    } else {
+      response = await NFCManager.transceive(Array.from(commandAPDU.getBytes()));
+    }
+    // console.debug('R:', Buffer.from(response).toString('hex').toUpperCase());
+
+    return new ResponseAPDU(response);
+  }
+  getATR() {
+    throw new Error('Method not implemented.');
+  }
+  getIsConnectionLost(_error) {
+    return !this.isOpened;
+  }
+  async close() {
+    await NFCManager.cancelTechnologyRequest();
+    this.isOpened = false;
+  }
+}

package/lib/module/Shared/EIDReader/protocol/bacAPDUSender.js

@@ -0,0 +1,83 @@
+"use strict";
+
+import { CommandAPDU } from "../smartcards/commandAPDU.js";
+import { ISO7816_CLA, ISO7816_INS, ISO7816_SW } from "../smartcards/iso7816.js";
+import cryptoUtils from "../utils/crypto.utils.js";
+import { Buffer } from 'buffer';
+export class BACAPDUSender {
+  constructor(service) {
+    this.service = service;
+  }
+  async sendGetChallenge() {
+    const commandAPDU = new CommandAPDU(ISO7816_CLA.ISO7816, ISO7816_INS.GET_CHALLENGE, 0x00, 0x00, null, 0, 0, 8);
+    const responseAPDU = await this.service.transmit(commandAPDU);
+    const challenge = responseAPDU.getData();
+    if (challenge === null || challenge.length !== 8) {
+      throw new Error('Get challenge failed');
+    }
+    return Buffer.from(challenge).toString('hex');
+  }
+  async sendMutualAuth(rndIFD, rndICC, kIFD, kEnc, kMac) {
+    if (rndIFD === null || rndIFD.length !== 16) {
+      throw new Error('rndIFD wrong length');
+    }
+    if (rndICC === null || rndICC.length !== 16) {
+      throw new Error('rndICC wrong length');
+    }
+    if (kIFD === null || kIFD.length !== 32) {
+      throw new Error('kIFD wrong length');
+    }
+    if (kEnc === null) {
+      throw new Error('kEnc === null');
+    }
+    if (kMac === null) {
+      throw new Error('kMac === null');
+    }
+    const plaintext = Buffer.alloc(32);
+    plaintext.set(Buffer.from(rndIFD, 'hex'), 0);
+    plaintext.set(Buffer.from(rndICC, 'hex'), 8);
+    plaintext.set(Buffer.from(kIFD, 'hex'), 16);
+    const ciphertext = cryptoUtils.encryptWith3DES(Buffer.from(plaintext).toString('hex'), kEnc);
+    if (ciphertext.length !== 64) {
+      throw new Error(`Cryptogram wrong length ${ciphertext.length}`);
+    }
+    const mactext = cryptoUtils.computeMac(ciphertext, kMac, true);
+    if (mactext.length !== 16) {
+      throw new Error('MAC wrong length');
+    }
+    const data = Buffer.alloc(32 + 8);
+    data.set(Buffer.from(ciphertext, 'hex'), 0);
+    data.set(Buffer.from(mactext, 'hex'), 32);
+    let le = 40; // 40 means max ne is 40 (0x28).
+    let commandAPDU = new CommandAPDU(ISO7816_CLA.ISO7816, ISO7816_INS.EXTERNAL_AUTHENTICATE, 0x00, 0x00, data, 0, data.length, le);
+    let responseAPDU = await this.service.transmit(commandAPDU);
+    if (responseAPDU === null) {
+      throw new Error('Mutual authentication failed, received null response APDU');
+    }
+    let responseAPDUBytes = responseAPDU.getBytes();
+    let sw = responseAPDU.getSW();
+    if (responseAPDUBytes === null) {
+      throw new Error('Mutual authentication failed, received empty data in response APDU');
+    }
+
+    // Some MRTDs apparently don't support 40 here, try again with 0. See R2-p1_v2_sIII_0035 (and other issues).
+    if (sw !== ISO7816_SW.NO_ERROR) {
+      le = 0; // 0 means ne is max 256 (0xFF).
+      commandAPDU = new CommandAPDU(ISO7816_CLA.ISO7816, ISO7816_INS.EXTERNAL_AUTHENTICATE, 0x00, 0x00, data, 0, data.length, le);
+      responseAPDU = await this.service.transmit(commandAPDU);
+      responseAPDUBytes = responseAPDU.getBytes();
+      sw = responseAPDU.getSW();
+    }
+    if (responseAPDUBytes.length !== 42) {
+      throw new Error(`Mutual authentication failed: expected length: 40 + 2, actual length: ${responseAPDUBytes.length}`);
+    }
+
+    // Decrypt the response.
+    const result = cryptoUtils.decryptWith3DES(Buffer.from(responseAPDUBytes.slice(0, responseAPDUBytes.length - 8 - 2)).toString('hex'), kEnc);
+    if (result.length !== 64) {
+      // The PICC allowed access, but probably the resulting secure channel will be wrong.
+      throw new Error(`Cryptogram wrong length, was expecting 64, found ${result.length}`);
+    }
+    return result;
+  }
+}

package/lib/module/Shared/EIDReader/protocol/bacProtocol.js

@@ -0,0 +1,70 @@
+"use strict";
+
+import { TripleDesSecureMessagingWrapper } from "../tripleDesSecureMessagingWrapper.js";
+import cryptoUtils from "../utils/crypto.utils.js";
+import { BACResult } from "./bacResult.js";
+import { Buffer } from 'buffer';
+export class BACProtocol {
+  constructor(service, maxTransceiveLength, shouldCheckMAC) {
+    this.service = service;
+    this.maxTransceiveLength = maxTransceiveLength;
+    this.shouldCheckMAC = shouldCheckMAC;
+  }
+  async doBAC(bacKey) {
+    const keySeed = bacKey.getKey();
+    const kEnc = cryptoUtils.derive3DESKeysFromSeed(keySeed, 'ENC');
+    const kMac = cryptoUtils.derive3DESKeysFromSeed(keySeed, 'MAC');
+    const wrapper = await this.doBACStep(kEnc, kMac);
+    return new BACResult(bacKey, wrapper);
+  }
+  async doBACStep(kEnc, kMac) {
+    const rndICC = await this.service.sendGetChallenge();
+    const rndIFD = cryptoUtils.getRandomValues(8);
+    const kIFD = cryptoUtils.getRandomValues(16);
+    const response = await this.service.sendMutualAuth(rndIFD, rndICC, kIFD, kEnc, kMac);
+    const kICC = response.substring(32, 64);
+    const keySeed = Buffer.alloc(16);
+    const kIFDBytes = Buffer.from(kIFD, 'hex');
+    const kICCBytes = Buffer.from(kICC, 'hex');
+    for (let i = 0; i < 16; i++) {
+      keySeed[i] = kIFDBytes[i] & 0xff ^ kICCBytes[i] & 0xff;
+    }
+    const keySeedHex = Buffer.from(keySeed).toString('hex');
+    const ksEncHex = cryptoUtils.derive3DESKeysFromSeed(keySeedHex, 'ENC');
+    const ksMacHex = cryptoUtils.derive3DESKeysFromSeed(keySeedHex, 'MAC');
+    const rndICCBytes = Buffer.from(rndICC, 'hex');
+    const rndIFDBytes = Buffer.from(rndIFD, 'hex');
+    const ssc = BACProtocol.computeSendSequenceCounter(rndICCBytes, rndIFDBytes);
+    return new TripleDesSecureMessagingWrapper(ksEncHex, ksMacHex, this.maxTransceiveLength, this.shouldCheckMAC, ssc);
+  }
+  static computeKeySeedForBACWithKey(bacKey) {
+    const documentNumber = bacKey.getDocumentNumber();
+    const dateOfBirth = bacKey.getDateOfBirth();
+    const dateOfExpiry = bacKey.getDateOfExpiry();
+    if (dateOfBirth == null || dateOfBirth.length !== 6) {
+      throw new Error(`Wrong date format used for date of birth. Expected yyMMdd, found ${dateOfBirth}`);
+    }
+    if (dateOfExpiry == null || dateOfExpiry.length !== 6) {
+      throw new Error(`Wrong date format used for date of expiry. Expected yyMMdd, found ${dateOfExpiry}`);
+    }
+    if (documentNumber == null) {
+      throw new Error(`Wrong document number. Found ${documentNumber}`);
+    }
+    return bacKey.getKey();
+  }
+  static computeSendSequenceCounter(rndICC, rndIFD) {
+    if (rndICC.length !== 8 || rndIFD.length !== 8) {
+      throw new Error('Wrong length input');
+    }
+    let ssc = 0n;
+    for (let i = 4; i < 8; i++) {
+      ssc <<= 8n;
+      ssc += BigInt(rndICC[i] & 0x000000ff);
+    }
+    for (let i = 4; i < 8; i++) {
+      ssc <<= 8n;
+      ssc += BigInt(rndIFD[i] & 0x000000ff);
+    }
+    return ssc;
+  }
+}

package/lib/module/Shared/EIDReader/protocol/bacResult.js

@@ -0,0 +1,32 @@
+"use strict";
+
+export class BACResult {
+  /**
+   * Creates a BAC result.
+   *
+   * @param bacKey the initial access key
+   * @param wrapper the secure messaging wrapper that resulted from the BAC protocol run
+   */
+  constructor(bacKey, wrapper) {
+    this.bacKey = bacKey;
+    this.wrapper = wrapper;
+  }
+
+  /**
+   * Returns the initial access key or {@code null}.
+   *
+   * @return the initial access key or {@code null}
+   */
+  getBACKey() {
+    return this.bacKey;
+  }
+
+  /**
+   * Returns the secure messaging wrapper.
+   *
+   * @return the secure messaging wrapper
+   */
+  getWrapper() {
+    return this.wrapper;
+  }
+}

package/lib/module/Shared/EIDReader/protocol/readBinaryAPDUSender.js

@@ -0,0 +1,126 @@
+"use strict";
+
+import { CommandAPDU } from "../smartcards/commandAPDU.js";
+import { ISO7816_CLA, ISO7816_INS, ISO7816_SW } from "../smartcards/iso7816.js";
+import { SecureMessagingAPDUSender } from "./secureMessagingAPDUSender.js";
+import { Buffer } from 'buffer';
+export class ReadBinaryAPDUSender {
+  constructor(service) {
+    this.service = service;
+    this.secureMessagingSender = new SecureMessagingAPDUSender(service);
+  }
+  async sendSelectApplet(wrapper, aid) {
+    if (aid == null) {
+      throw new Error('AID cannot be null');
+    }
+    const commandAPDU = new CommandAPDU(ISO7816_CLA.ISO7816, ISO7816_INS.SELECT_FILE, 0x04, 0x0c, aid, 0, aid.length);
+    const responseAPDU = await this.secureMessagingSender.transmit(wrapper, commandAPDU);
+    ReadBinaryAPDUSender.checkStatusWordAfterFileOperation(commandAPDU, responseAPDU);
+  }
+  async sendSelectMF() {
+    const mf = Uint8Array.from([0x3f, 0x00]);
+    const commandAPDU = new CommandAPDU(ISO7816_CLA.ISO7816, ISO7816_INS.SELECT_FILE, 0x00, 0x0c, mf, 0, mf.length);
+    const responseAPDU = await this.secureMessagingSender.transmit(null, commandAPDU);
+    ReadBinaryAPDUSender.checkStatusWordAfterFileOperation(commandAPDU, responseAPDU);
+  }
+  async sendSelectFile(wrapper, fid) {
+    const fiddle = Uint8Array.from([fid >> 8 & 0xff, fid & 0xff]);
+    const commandAPDU = new CommandAPDU(ISO7816_CLA.ISO7816, ISO7816_INS.SELECT_FILE, 0x02, 0x0c, fiddle, 0, fiddle.length);
+    const responseAPDU = await this.secureMessagingSender.transmit(wrapper, commandAPDU);
+    if (responseAPDU == null) {
+      return;
+    }
+    ReadBinaryAPDUSender.checkStatusWordAfterFileOperation(commandAPDU, responseAPDU);
+  }
+  async sendReadBinary(wrapper, sfi, offset, le, isSFIEnabled, isTLVEncodedOffsetNeeded) {
+    let commandAPDU = null;
+    let responseAPDU = null;
+    if (le === 0) {
+      return null;
+    }
+    const offsetMSB = (offset & 0xff00) >> 8 & 0xff;
+    const offsetLSB = offset & 0xff;
+    if (isTLVEncodedOffsetNeeded) {
+      if (le < 128) {
+        le += 2;
+      } else if (le < 256) {
+        le += 3;
+      }
+      if (le > 256) {
+        le = 256;
+      }
+      const data = Uint8Array.from([0x54, 0x02, offsetMSB, offsetLSB]);
+      commandAPDU = new CommandAPDU(ISO7816_CLA.ISO7816, ISO7816_INS.READ_BINARY2, 0x00, 0x00, data, 0, data.length, le);
+    } else if (isSFIEnabled) {
+      commandAPDU = new CommandAPDU(ISO7816_CLA.ISO7816, ISO7816_INS.READ_BINARY, sfi & 0xff, offsetLSB, null, 0, 0, le);
+    } else {
+      commandAPDU = new CommandAPDU(ISO7816_CLA.ISO7816, ISO7816_INS.READ_BINARY, offsetMSB, offsetLSB, null, 0, 0, le);
+    }
+    try {
+      responseAPDU = await this.secureMessagingSender.transmit(wrapper, commandAPDU);
+    } catch (error) {
+      if (this.service.getIsConnectionLost(error)) {
+        throw error;
+      }
+      console.debug('Exception during READ BINARY', error);
+    }
+    const responseData = ReadBinaryAPDUSender.getResponseData(responseAPDU, isTLVEncodedOffsetNeeded);
+    ReadBinaryAPDUSender.checkStatusWordAfterFileOperation(commandAPDU, responseAPDU);
+    return Uint8Array.from(responseData || []);
+  }
+  static getResponseData(responseAPDU, isTLVEncodedOffsetNeeded) {
+    if (responseAPDU == null) {
+      return null;
+    }
+    let responseData = responseAPDU.getData();
+    if (responseData == null) {
+      throw new Error('Malformed read binary long response data');
+    }
+    if (!isTLVEncodedOffsetNeeded) {
+      return responseData;
+    }
+    const data = responseData;
+    let index = 0;
+    if (data[index++] !== 0x53) {
+      throw new Error('Malformed read binary long response data');
+    }
+    if ((data[index] & 0x80) === 0x80) {
+      index += data[index] & 0xf;
+    }
+    index++;
+    responseData = new Array(data.length - index);
+    for (let i = 0; i < responseData.length; i++) {
+      responseData[i] = data[index + i];
+    }
+    return responseData;
+  }
+  static checkStatusWordAfterFileOperation(commandAPDU, responseAPDU) {
+    if (responseAPDU == null) {
+      throw new Error('No response APDU');
+    }
+    const data = responseAPDU.getData();
+    const sw = responseAPDU.getSW();
+    const commandResponseMessage = `CAPDU = ${Buffer.from(commandAPDU.getBytes()).toString('hex')}, RAPDU = ${Buffer.from(responseAPDU.getBytes()).toString('hex')}`;
+    if ((sw & ISO7816_SW.WRONG_LENGTH) === ISO7816_SW.WRONG_LENGTH && (data == null || data.length === 0)) {
+      throw new Error(`Wrong length${commandResponseMessage}`);
+    }
+    switch (sw) {
+      case ISO7816_SW.NO_ERROR:
+        return;
+      case ISO7816_SW.END_OF_FILE:
+        if (data == null || data.length === 0) {
+          throw new Error('End of file' + commandResponseMessage);
+        } else {
+          return;
+        }
+      case ISO7816_SW.FILE_NOT_FOUND:
+        throw new Error('File not found' + commandResponseMessage);
+      case ISO7816_SW.SECURITY_STATUS_NOT_SATISFIED:
+      case ISO7816_SW.CONDITIONS_NOT_SATISFIED:
+      case ISO7816_SW.COMMAND_NOT_ALLOWED:
+        throw new Error('Access to file denied' + commandResponseMessage);
+      default:
+        throw new Error('Error occurred' + commandResponseMessage);
+    }
+  }
+}

package/lib/module/Shared/EIDReader/protocol/secureMessagingAPDUSender.js

@@ -0,0 +1,102 @@
+"use strict";
+
+import { ByteArrayOutputStream } from "../java/byteArrayOutputStream.js";
+import { APDUEvent } from "../smartcards/apduEvent.js";
+import { CommandAPDU } from "../smartcards/commandAPDU.js";
+import { ISO7816_CLA, ISO7816_INS, ISO7816_SW } from "../smartcards/iso7816.js";
+import cryptoUtils from "../utils/crypto.utils.js";
+import { WrappedAPDUEvent } from "../wrappedAPDUEvent.js";
+import { Buffer } from 'buffer';
+export class SecureMessagingAPDUSender {
+  constructor(service) {
+    this.service = service;
+    this.apduCount = 0;
+  }
+  async transmit(wrapper, commandAPDU) {
+    let plainCapdu = commandAPDU;
+    if (wrapper != null) {
+      commandAPDU = wrapper.wrap(commandAPDU);
+    }
+    let responseAPDU = await this.service.transmit(commandAPDU);
+    let rawRapdu = responseAPDU;
+    let sw = responseAPDU.getSW();
+    if (wrapper == null) {
+      this.notifyExchangedAPDU(new APDUEvent(this, 'PLAIN', ++this.apduCount, commandAPDU, responseAPDU));
+    } else {
+      try {
+        if ((sw & ISO7816_SW.WRONG_LENGTH) === ISO7816_SW.WRONG_LENGTH) {
+          return responseAPDU;
+        }
+        if (responseAPDU.getBytes().length <= 2) {
+          throw new Error(`Exception during transmission of wrapped APDU, C=${Buffer.from(plainCapdu.getBytes()).toString('hex')}`);
+        }
+        responseAPDU = await wrapper.unwrap(responseAPDU);
+      } catch (error) {
+        throw new Error(`Exception during transmission of wrapped APDU, C=${Buffer.from(plainCapdu.getBytes()).toString('hex')}`);
+      } finally {
+        this.notifyExchangedAPDU(new WrappedAPDUEvent(this, wrapper.getType(), ++this.apduCount, plainCapdu, responseAPDU, commandAPDU, rawRapdu));
+      }
+    }
+    return responseAPDU;
+  }
+  isExtendedAPDULengthSupported() {
+    return this.service.getIsExtendedAPDULengthSupported();
+  }
+  addAPDUListener(listener) {
+    this.service.addAPDUListener(listener);
+  }
+  removeAPDUListener(listener) {
+    this.service.removeAPDUListener(listener);
+  }
+  notifyExchangedAPDU(event) {
+    let apduListeners = this.service.getAPDUListeners();
+    if (apduListeners == null || apduListeners.size === 0) {
+      return;
+    }
+    for (let listener of apduListeners) {
+      listener.exchangedAPDU(event);
+    }
+  }
+  async sendUsingCommandChaining(commandAPDU, chunkSize) {
+    let data = commandAPDU.getData();
+    let segments = cryptoUtils.partition(chunkSize, Array.from(data));
+    let responseAPDUs = [];
+    let index = 0;
+    for (let segment of segments) {
+      let isLast = ++index >= segments.length;
+      let cla = commandAPDU.getCLA();
+      if (!isLast) {
+        cla |= ISO7816_CLA.COMMAND_CHAINING;
+      }
+      let partialCommandAPDU = new CommandAPDU(cla, commandAPDU.getINS(), commandAPDU.getP1(), commandAPDU.getP2(), Uint8Array.from(segment), 0, segment.length, commandAPDU.getNe());
+      let responseAPDU = await this.service.transmit(partialCommandAPDU);
+      responseAPDUs.push(responseAPDU);
+    }
+    return responseAPDUs;
+  }
+  async continueSendingUsingResponseChaining(wrapper, sw, data) {
+    let byteArrayOutputStream = new ByteArrayOutputStream();
+    try {
+      while ((sw & 0xff00) === 0x6100) {
+        byteArrayOutputStream.writeBytes(Uint8Array.from(data));
+        let remainingLength = sw & 0xff;
+        if (remainingLength <= 0) {
+          break;
+        }
+        let capdu = new CommandAPDU(ISO7816_CLA.ISO7816, ISO7816_INS.GET_RESPONSE, 0x00, 0x00, null, 0, remainingLength);
+        let rapdu = await this.transmit(wrapper, capdu);
+        data = rapdu.getData();
+        sw = rapdu.getSW();
+      }
+      return byteArrayOutputStream.toByteArray();
+    } catch (error) {
+      throw new Error('Could not write to stream');
+    } finally {
+      try {
+        byteArrayOutputStream.close();
+      } catch (error) {
+        console.debug('Error closing stream', error);
+      }
+    }
+  }
+}