@trustchex/react-native-sdk 1.161.0

package/src/Shared/EIDReader/protocol/readBinaryAPDUSender.ts

@@ -0,0 +1,251 @@
+import type { APDULevelReadBinaryCapable } from '../apduLevelReadBinaryCapable';
+import { CardService } from '../cardService';
+import type { APDUWrapper } from '../smartcards/apduWrapper';
+import { CommandAPDU } from '../smartcards/commandAPDU';
+import { ISO7816_CLA, ISO7816_INS, ISO7816_SW } from '../smartcards/iso7816';
+import { ResponseAPDU } from '../smartcards/responseAPDU';
+import { SecureMessagingAPDUSender } from './secureMessagingAPDUSender';
+import { Buffer } from 'buffer';
+
+export class ReadBinaryAPDUSender implements APDULevelReadBinaryCapable {
+  private secureMessagingSender: SecureMessagingAPDUSender;
+  private service: CardService;
+
+  constructor(service: CardService) {
+    this.service = service;
+    this.secureMessagingSender = new SecureMessagingAPDUSender(service);
+  }
+
+  public async sendSelectApplet(wrapper: APDUWrapper | null, aid: Uint8Array) {
+    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
+    );
+  }
+
+  public 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
+    );
+  }
+
+  public async sendSelectFile(
+    wrapper: APDUWrapper,
+    fid: number
+  ): Promise<void> {
+    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
+    );
+  }
+
+  public async sendReadBinary(
+    wrapper: APDUWrapper,
+    sfi: number,
+    offset: number,
+    le: number,
+    isSFIEnabled: boolean,
+    isTLVEncodedOffsetNeeded: boolean
+  ): Promise<Uint8Array | null> {
+    let commandAPDU: CommandAPDU | null = null;
+    let responseAPDU: ResponseAPDU | null = 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 as Error)) {
+        throw error;
+      }
+
+      console.debug('Exception during READ BINARY', error);
+    }
+
+    const responseData = ReadBinaryAPDUSender.getResponseData(
+      responseAPDU,
+      isTLVEncodedOffsetNeeded
+    );
+
+    ReadBinaryAPDUSender.checkStatusWordAfterFileOperation(
+      commandAPDU,
+      responseAPDU
+    );
+
+    return Uint8Array.from(responseData || []);
+  }
+
+  private static getResponseData(
+    responseAPDU: ResponseAPDU | null,
+    isTLVEncodedOffsetNeeded: boolean
+  ) {
+    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;
+  }
+
+  private static checkStatusWordAfterFileOperation(
+    commandAPDU: CommandAPDU,
+    responseAPDU: ResponseAPDU | null
+  ): void {
+    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/src/Shared/EIDReader/protocol/secureMessagingAPDUSender.ts

@@ -0,0 +1,170 @@
+import { CardService } from '../cardService';
+import { ByteArrayOutputStream } from '../java/byteArrayOutputStream';
+import { APDUEvent } from '../smartcards/apduEvent';
+import type { APDUListener } from '../smartcards/apduListener';
+import type { APDUWrapper } from '../smartcards/apduWrapper';
+import { CommandAPDU } from '../smartcards/commandAPDU';
+import { ISO7816_CLA, ISO7816_INS, ISO7816_SW } from '../smartcards/iso7816';
+import { ResponseAPDU } from '../smartcards/responseAPDU';
+import cryptoUtils from '../utils/crypto.utils';
+import { WrappedAPDUEvent } from '../wrappedAPDUEvent';
+import { Buffer } from 'buffer';
+
+export class SecureMessagingAPDUSender {
+  private service: CardService;
+  private apduCount: number;
+
+  constructor(service: CardService) {
+    this.service = service;
+    this.apduCount = 0;
+  }
+
+  public async transmit(
+    wrapper: APDUWrapper | null,
+    commandAPDU: CommandAPDU
+  ): Promise<ResponseAPDU> {
+    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;
+  }
+
+  public isExtendedAPDULengthSupported(): boolean {
+    return this.service.getIsExtendedAPDULengthSupported();
+  }
+
+  public addAPDUListener(listener: APDUListener): void {
+    this.service.addAPDUListener(listener);
+  }
+
+  public removeAPDUListener(listener: APDUListener): void {
+    this.service.removeAPDUListener(listener);
+  }
+
+  protected notifyExchangedAPDU(event: APDUEvent): void {
+    let apduListeners = this.service.getAPDUListeners();
+    if (apduListeners == null || apduListeners.size === 0) {
+      return;
+    }
+
+    for (let listener of apduListeners) {
+      listener.exchangedAPDU(event);
+    }
+  }
+
+  private async sendUsingCommandChaining(
+    commandAPDU: CommandAPDU,
+    chunkSize: number
+  ): Promise<ResponseAPDU[]> {
+    let data = commandAPDU.getData();
+    let segments = cryptoUtils.partition(chunkSize, Array.from(data));
+    let responseAPDUs: ResponseAPDU[] = [];
+    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;
+  }
+
+  private async continueSendingUsingResponseChaining(
+    wrapper: APDUWrapper,
+    sw: number,
+    data: number[]
+  ) {
+    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);
+      }
+    }
+  }
+}