@trustchex/react-native-sdk 1.161.0

package/src/Shared/EIDReader/eidService.ts

@@ -0,0 +1,349 @@
+import { AbstractMRTDCardService } from './abstractMRTDCardService';
+import type { AccessKeySpec } from './accessKeySpec';
+import { CardFileInputStream } from './cardFileInputStream';
+import { CardService } from './cardService';
+import { DefaultFileSystem } from './defaultFileSystem';
+import { ResponseAPDU } from './smartcards/responseAPDU';
+import { SecureMessagingWrapper } from './secureMessagingWrapper';
+import { BACAPDUSender } from './protocol/bacAPDUSender';
+import { ReadBinaryAPDUSender } from './protocol/readBinaryAPDUSender';
+import { BACResult } from './protocol/bacResult';
+import { BACProtocol } from './protocol/bacProtocol';
+import { CommandAPDU } from './smartcards/commandAPDU';
+import type { APDUListener } from './smartcards/apduListener';
+import { APDUEvent } from './smartcards/apduEvent';
+
+export class EIDService extends AbstractMRTDCardService {
+  /** Shared secret type for non-PACE key. */
+  public static NO_PACE_KEY_REFERENCE: number = 0x00;
+
+  /** Shared secret type for PACE according to BSI TR-03110 v2.03 B.11.1. */
+  public static MRZ_PACE_KEY_REFERENCE: number = 0x01;
+
+  /** Shared secret type for PACE according to BSI TR-03110 v2.03 B.11.1. */
+  public static CAN_PACE_KEY_REFERENCE: number = 0x02;
+
+  /** Shared secret type for PACE according to BSI TR-03110 v2.03 B.11.1. */
+  public static PIN_PACE_KEY_REFERENCE: number = 0x03;
+
+  /** Shared secret type for PACE according to BSI TR-03110 v2.03 B.11.1. */
+  public static PUK_PACE_KEY_REFERENCE: number = 0x04;
+
+  /** Card Access. */
+  public static EF_CARD_ACCESS: number = 0x011c;
+
+  /** Card Security. */
+  public static EF_CARD_SECURITY: number = 0x011d;
+
+  /** File identifier for data group 1. Data group 1 contains the MRZ. */
+  public static EF_DG1: number = 0x0101;
+
+  /** File identifier for data group 2. Data group 2 contains face image data. */
+  public static EF_DG2: number = 0x0102;
+
+  /** File identifier for data group 3. Data group 3 contains finger print data. */
+  public static EF_DG3: number = 0x0103;
+
+  /** File identifier for data group 4. Data group 4 contains iris data. */
+  public static EF_DG4: number = 0x0104;
+
+  /** File identifier for data group 5. Data group 5 contains displayed portrait. */
+  public static EF_DG5: number = 0x0105;
+
+  /** File identifier for data group 6. Data group 6 is RFU. */
+  public static EF_DG6: number = 0x0106;
+
+  /** File identifier for data group 7. Data group 7 contains displayed signature. */
+  public static EF_DG7: number = 0x0107;
+
+  /** File identifier for data group 8. Data group 8 contains data features. */
+  public static EF_DG8: number = 0x0108;
+
+  /** File identifier for data group 9. Data group 9 contains structure features. */
+  public static EF_DG9: number = 0x0109;
+
+  /** File identifier for data group 10. Data group 10 contains substance features. */
+  public static EF_DG10: number = 0x010a;
+
+  /** File identifier for data group 11. Data group 11 contains additional personal details. */
+  public static EF_DG11: number = 0x010b;
+
+  /** File identifier for data group 12. Data group 12 contains additional document details. */
+  public static EF_DG12: number = 0x010c;
+
+  /** File identifier for data group 13. Data group 13 contains optional details. */
+  public static EF_DG13: number = 0x010d;
+
+  /** File identifier for data group 14. Data group 14 contains security infos. */
+  public static EF_DG14: number = 0x010e;
+
+  /** File identifier for data group 15. Data group 15 contains the public key used for Active Authentication. */
+  public static EF_DG15: number = 0x010f;
+
+  /** File identifier for data group 16. Data group 16 contains person(s) to notify. */
+  public static EF_DG16: number = 0x0110;
+
+  /** The security document. */
+  public static EF_SOD: number = 0x011d;
+
+  /** The data group presence list. */
+  public static EF_COM: number = 0x011e;
+
+  /**
+   * Contains EAC CVA references. Note: this can be overridden by a file
+   * identifier in the DG14 file (in a TerminalAuthenticationInfo). Check DG14
+   * first. Also, this file does not have a header tag, like the others.
+   */
+  public static EF_CVCA: number = 0x011c;
+
+  /** Short file identifier for card access file. */
+  public static SFI_CARD_ACCESS: number = 0x1c;
+
+  /** Short file identifier for card security file. */
+  public static SFI_CARD_SECURITY: number = 0x1d;
+
+  /** Short file identifier for file. */
+  public static SFI_DG1: number = 0x01;
+
+  /** Short file identifier for file. */
+  public static SFI_DG2: number = 0x02;
+
+  /** Short file identifier for file. */
+  public static SFI_DG3: number = 0x03;
+
+  /** Short file identifier for file. */
+  public static SFI_DG4: number = 0x04;
+
+  /** Short file identifier for file. */
+  public static SFI_DG5: number = 0x05;
+
+  /** Short file identifier for file. */
+  public static SFI_DG6: number = 0x06;
+
+  /** Short file identifier for file. */
+  public static SFI_DG7: number = 0x07;
+
+  /** Short file identifier for file. */
+  public static SFI_DG8: number = 0x08;
+
+  /** Short file identifier for file. */
+  public static SFI_DG9: number = 0x09;
+
+  /** Short file identifier for file. */
+  public static SFI_DG10: number = 0x0a;
+
+  /** Short file identifier for file. */
+  public static SFI_DG11: number = 0x0b;
+
+  /** Short file identifier for file. */
+  public static SFI_DG12: number = 0x0c;
+
+  /** Short file identifier for file. */
+  public static SFI_DG13: number = 0x0d;
+
+  /** Short file identifier for file. */
+  public static SFI_DG14: number = 0x0e;
+
+  /** Short file identifier for file. */
+  public static SFI_DG15: number = 0x0f;
+
+  /** Short file identifier for file. */
+  public static SFI_DG16: number = 0x10;
+
+  /** Short file identifier for file. */
+  public static SFI_COM: number = 0x1e;
+
+  /** Short file identifier for file. */
+  public static SFI_SOD: number = 0x1d;
+
+  /** Short file identifier for file. */
+  public static SFI_CVCA: number = 0x1c;
+
+  /** The default maximal blocksize used for unencrypted APDUs. */
+  public static DEFAULT_MAX_BLOCKSIZE: number = 223;
+
+  /** The normal maximal transceive length of APDUs. */
+  public static NORMAL_MAX_TRANSCEIVE_LENGTH: number = 256;
+
+  /** The extended maximal transceive length of APDUs. */
+  public static EXTENDED_MAX_TRANSCEIVE_LENGTH: number = 65536;
+
+  /** The applet we select when we start a session. */
+  public static APPLET_AID: Uint8Array = Uint8Array.from([
+    0xa0, 0x00, 0x00, 0x02, 0x47, 0x10, 0x01,
+  ]);
+
+  private maxBlockSize: number;
+  private isOpen: boolean;
+  private wrapper: SecureMessagingWrapper | null = null;
+  private maxTransceiveLengthForSecureMessaging: number;
+  private shouldCheckMAC: boolean;
+  private isAppletSelected: boolean;
+  private rootFileSystem: DefaultFileSystem;
+  private appletFileSystem: DefaultFileSystem;
+  private bacSender: BACAPDUSender;
+  private readBinarySender: ReadBinaryAPDUSender;
+  private service: CardService;
+
+  constructor(
+    service: CardService,
+    maxTransceiveLengthForSecureMessaging: number = EIDService.NORMAL_MAX_TRANSCEIVE_LENGTH,
+    maxBlockSize: number = EIDService.DEFAULT_MAX_BLOCKSIZE,
+    isSFIEnabled: boolean = false,
+    shouldCheckMAC: boolean = false
+  ) {
+    super();
+    this.service = service;
+    this.bacSender = new BACAPDUSender(service);
+    this.readBinarySender = new ReadBinaryAPDUSender(service);
+    this.maxTransceiveLengthForSecureMessaging =
+      maxTransceiveLengthForSecureMessaging;
+    this.maxBlockSize = maxBlockSize;
+    this.shouldCheckMAC = shouldCheckMAC;
+    this.isAppletSelected = false;
+    this.isOpen = false;
+    this.rootFileSystem = new DefaultFileSystem(this.readBinarySender, false);
+    this.appletFileSystem = new DefaultFileSystem(
+      this.readBinarySender,
+      isSFIEnabled
+    );
+  }
+
+  public async open(): Promise<void> {
+    if (this.getIsOpen()) {
+      return;
+    }
+    await this.service.open();
+    this.isOpen = true;
+  }
+
+  public async sendSelectApplet(hasPACESucceeded: boolean): Promise<void> {
+    if (this.isAppletSelected) {
+      console.debug('Re-selecting ICAO applet');
+    }
+
+    if (hasPACESucceeded) {
+      await this.readBinarySender.sendSelectApplet(
+        this.wrapper,
+        EIDService.APPLET_AID
+      );
+    } else {
+      await this.readBinarySender.sendSelectApplet(null, EIDService.APPLET_AID);
+    }
+
+    this.isAppletSelected = true;
+  }
+
+  public async sendSelectMF(): Promise<void> {
+    await this.readBinarySender.sendSelectMF();
+    this.wrapper = null;
+  }
+
+  public getIsOpen(): boolean {
+    return this.isOpen;
+  }
+
+  public async doBAC(bacKey: AccessKeySpec): Promise<BACResult> {
+    const bacResult: BACResult = await new BACProtocol(
+      this.bacSender,
+      this.maxTransceiveLengthForSecureMessaging,
+      this.shouldCheckMAC
+    ).doBAC(bacKey);
+    this.wrapper = bacResult.getWrapper();
+    this.appletFileSystem.setWrapper(this.wrapper);
+    return bacResult;
+  }
+
+  public async close(): Promise<void> {
+    try {
+      await this.service.close();
+      this.wrapper = null;
+    } finally {
+      this.isOpen = false;
+    }
+  }
+
+  public getMaxTransceiveLength(): number {
+    return this.maxTransceiveLengthForSecureMessaging;
+  }
+
+  public getWrapper(): SecureMessagingWrapper | null {
+    if (this.wrapper == null) {
+      return null;
+    }
+    const ldsSecureMessagingWrapper =
+      this.appletFileSystem.getWrapper() as SecureMessagingWrapper;
+    if (
+      ldsSecureMessagingWrapper != null &&
+      ldsSecureMessagingWrapper.getSendSequenceCounter() >
+        this.wrapper.getSendSequenceCounter()
+    ) {
+      this.wrapper = ldsSecureMessagingWrapper;
+    }
+    return this.wrapper;
+  }
+
+  public transmit(commandAPDU: CommandAPDU): Promise<ResponseAPDU> {
+    return this.service.transmit(commandAPDU);
+  }
+
+  public getATR(): Uint8Array {
+    return this.service.getATR();
+  }
+
+  public getIsConnectionLost(error: Error): boolean {
+    return this.service.getIsConnectionLost(error);
+  }
+
+  public getShouldCheckMAC(): boolean {
+    return this.shouldCheckMAC;
+  }
+
+  public getInputStream(fid: number): CardFileInputStream {
+    return this.getInputStreamWithMaxBlockSize(fid, this.maxBlockSize);
+  }
+
+  public getInputStreamWithMaxBlockSize(
+    fid: number,
+    maxBlockSize: number
+  ): CardFileInputStream {
+    if (!this.isAppletSelected) {
+      this.rootFileSystem.selectFile(fid);
+      return new CardFileInputStream(maxBlockSize, this.rootFileSystem);
+    } else {
+      this.appletFileSystem.selectFile(fid);
+      return new CardFileInputStream(maxBlockSize, this.appletFileSystem);
+    }
+  }
+
+  public getMaxReadBinaryLength(): number {
+    if (this.appletFileSystem == null) {
+      return EIDService.NORMAL_MAX_TRANSCEIVE_LENGTH;
+    }
+
+    return this.appletFileSystem.getMaxReadBinaryLength();
+  }
+
+  public addAPDUListener(listener: APDUListener) {
+    this.service.addAPDUListener(listener);
+  }
+
+  public removeAPDUListener(listener: APDUListener) {
+    this.service.removeAPDUListener(listener);
+  }
+
+  public getAPDUListeners() {
+    return this.service.getAPDUListeners();
+  }
+
+  protected notifyExchangedAPDU(event: APDUEvent) {
+    const apduListeners = this.getAPDUListeners();
+    if (apduListeners == null || apduListeners.size === 0) {
+      return;
+    }
+
+    for (const apduListener of apduListeners) {
+      apduListener.exchangedAPDU(event);
+    }
+  }
+}

package/src/Shared/EIDReader/fileInfo.ts

@@ -0,0 +1,5 @@
+export abstract class FileInfo {
+  public abstract getFID(): number;
+
+  public abstract getFileLength(): number;
+}

package/src/Shared/EIDReader/fileSystemCardService.ts

@@ -0,0 +1,32 @@
+import { CardFileInputStream } from './cardFileInputStream';
+import { CardService } from './cardService';
+
+export abstract class FileSystemCardService extends CardService {
+  /**
+   * Returns an input stream to access the file indicated by the file identifier.
+   *
+   * @param fid the file identifier
+   *
+   * @return a stream to read from
+   *
+   * @throws CardServiceException on error creating the stream
+   *
+   * @deprecated Use the other method with explicit max block size
+   */
+  public abstract getInputStream(fid: number): CardFileInputStream;
+
+  /**
+   * Returns an input stream to access the file indicated by the file identifier.
+   *
+   * @param fid the file identifier
+   * @param maxBlockSize maximum block size to use for read binaries
+   *
+   * @return a stream to read from
+   *
+   * @throws CardServiceException on error creating the stream
+   */
+  public abstract getInputStreamWithMaxBlockSize(
+    fid: number,
+    maxBlockSize: number
+  ): CardFileInputStream;
+}

package/src/Shared/EIDReader/fragment.ts

@@ -0,0 +1,21 @@
+export class Fragment {
+  private offset: number;
+  private length: number;
+
+  constructor(offset: number, length: number) {
+    this.offset = offset;
+    this.length = length;
+  }
+
+  public static getInstance(offset: number, length: number): Fragment {
+    return new Fragment(offset, length);
+  }
+
+  public getOffset(): number {
+    return this.offset;
+  }
+
+  public getLength(): number {
+    return this.length;
+  }
+}

package/src/Shared/EIDReader/fragmentBuffer.ts

@@ -0,0 +1,191 @@
+import { Fragment } from './fragment';
+
+export class FragmentBuffer {
+  private static readonly DEFAULT_SIZE = 2000;
+
+  private buffer: Uint8Array;
+  private fragments: Set<Fragment>;
+
+  constructor(length: number = FragmentBuffer.DEFAULT_SIZE) {
+    this.buffer = new Uint8Array(length);
+    this.fragments = new Set<Fragment>();
+  }
+
+  public updateFrom(other: FragmentBuffer): void {
+    for (const otherFragment of other.fragments) {
+      this.addFragmentBytesWithOffset(
+        otherFragment.getOffset(),
+        other.buffer,
+        otherFragment.getOffset(),
+        otherFragment.getLength()
+      );
+    }
+  }
+
+  public addFragment(offset: number, b: number): void {
+    this.addFragmentBytes(offset, new Uint8Array([b]));
+  }
+
+  public addFragmentBytes(offset: number, bytes: Uint8Array): void {
+    this.addFragmentBytesWithOffset(offset, bytes, 0, bytes.length);
+  }
+
+  public addFragmentBytesWithOffset(
+    offset: number,
+    bytes: Uint8Array,
+    srcOffset: number,
+    srcLength: number
+  ): void {
+    if (offset + srcLength > this.buffer.length) {
+      this.setLength(Math.max(2 * (offset + srcLength), this.buffer.length));
+    }
+
+    this.buffer.set(bytes.slice(srcOffset, srcOffset + srcLength), offset);
+    let thisOffset = offset;
+    let thisLength = srcLength;
+
+    const otherFragments = Array.from(this.fragments);
+    for (const other of otherFragments) {
+      if (
+        other.getOffset() <= thisOffset &&
+        thisOffset + thisLength <= other.getOffset() + other.getLength()
+      ) {
+        return;
+      } else if (
+        other.getOffset() <= thisOffset &&
+        thisOffset <= other.getOffset() + other.getLength()
+      ) {
+        thisLength = thisOffset + thisLength - other.getOffset();
+        thisOffset = other.getOffset();
+        this.fragments.delete(other);
+      } else if (
+        thisOffset <= other.getOffset() &&
+        other.getOffset() + other.getLength() <= thisOffset + thisLength
+      ) {
+        this.fragments.delete(other);
+      } else if (
+        thisOffset <= other.getOffset() &&
+        other.getOffset() <= thisOffset + thisLength
+      ) {
+        thisLength = other.getOffset() + other.getLength() - thisOffset;
+        this.fragments.delete(other);
+      }
+    }
+    this.fragments.add(new Fragment(thisOffset, thisLength));
+  }
+
+  public getPosition(): number {
+    let result = 0;
+    for (let i = 0; i < this.buffer.length; i++) {
+      if (this.isCoveredByFragment(i)) {
+        result = i + 1;
+      }
+    }
+    return result;
+  }
+
+  public getBytesBuffered(): number {
+    let result = 0;
+    for (let i = 0; i < this.buffer.length; i++) {
+      if (this.isCoveredByFragment(i)) {
+        result++;
+      }
+    }
+    return result;
+  }
+
+  public isCoveredByFragment(offset: number): boolean {
+    return this.isCoveredByFragmentWithLength(offset, 1);
+  }
+
+  public isCoveredByFragmentWithLength(
+    offset: number,
+    length: number
+  ): boolean {
+    for (const fragment of this.fragments) {
+      const left = fragment.getOffset();
+      const right = fragment.getOffset() + fragment.getLength();
+      if (left <= offset && offset + length <= right) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  public getBufferedLength(index: number): number {
+    if (index >= this.buffer.length) {
+      return 0;
+    }
+
+    let result = 0;
+    for (const fragment of this.fragments) {
+      const left = fragment.getOffset();
+      const right = fragment.getOffset() + fragment.getLength();
+      if (left <= index && index < right) {
+        const newResult = right - index;
+        if (newResult > result) {
+          result = newResult;
+        }
+      }
+    }
+    return result;
+  }
+
+  public getFragments(): Set<Fragment> {
+    return this.fragments;
+  }
+
+  public getBuffer(): Uint8Array {
+    return this.buffer;
+  }
+
+  public getLength(): number {
+    return this.buffer.length;
+  }
+
+  public getSmallestUnbufferedFragment(
+    offset: number,
+    length: number
+  ): Fragment {
+    let thisOffset = offset;
+    let thisLength = length;
+    for (const other of this.fragments) {
+      if (
+        other.getOffset() <= thisOffset &&
+        thisOffset + thisLength <= other.getOffset() + other.getLength()
+      ) {
+        thisLength = 0;
+        break;
+      } else if (
+        other.getOffset() <= thisOffset &&
+        thisOffset < other.getOffset() + other.getLength()
+      ) {
+        const newOffset = other.getOffset() + other.getLength();
+        const newLength = thisOffset + thisLength - newOffset;
+        thisOffset = newOffset;
+        thisLength = newLength;
+      } else if (
+        thisOffset <= other.getOffset() &&
+        other.getOffset() + other.getOffset() <= thisOffset + thisLength
+      ) {
+        continue;
+      } else if (
+        offset <= other.getOffset() &&
+        other.getOffset() < thisOffset + thisLength
+      ) {
+        thisLength = other.getOffset() - thisOffset;
+      }
+    }
+    return new Fragment(thisOffset, thisLength);
+  }
+
+  private setLength(length: number): void {
+    if (length <= this.buffer.length) {
+      return;
+    }
+
+    const newBuffer = new Uint8Array(length);
+    newBuffer.set(this.buffer);
+    this.buffer = newBuffer;
+  }
+}

package/src/Shared/EIDReader/java/byteArrayInputStream.ts

@@ -0,0 +1,103 @@
+import { InputStream } from './inputStream';
+import { OutputStream } from './outputStream';
+import { Buffer } from 'buffer';
+
+export class ByteArrayInputStream extends InputStream {
+  private static readonly MAX_TRANSFER_SIZE = 128 * 1024;
+
+  protected buf: Buffer;
+  protected pos: number;
+  protected _mark: number;
+  protected count: number;
+
+  constructor(buf: Buffer, offset: number = 0, length: number = buf.length) {
+    super();
+    this.buf = buf;
+    this.pos = offset;
+    this.count = Math.min(offset + length, buf.length);
+    this._mark = offset;
+  }
+
+  public read(): Promise<number> {
+    if (this.pos < this.count) {
+      return Promise.resolve(this.buf[this.pos++]);
+    }
+    return Promise.resolve(-1); // End of stream
+  }
+
+  public readBytesWithOffset(
+    b: Uint8Array,
+    off: number,
+    len: number
+  ): Promise<number> {
+    if (this.pos >= this.count) {
+      return Promise.resolve(-1); // End of stream
+    }
+
+    const avail = this.count - this.pos;
+    const toRead = Math.min(len, avail);
+    if (toRead <= 0) {
+      return Promise.resolve(0); // Nothing to read
+    }
+
+    b.set(this.buf.subarray(this.pos, this.pos + toRead), off);
+    this.pos += toRead;
+    return Promise.resolve(toRead);
+  }
+
+  public readAllBytes(): Promise<Uint8Array> {
+    const result = this.buf.subarray(this.pos, this.count);
+    this.pos = this.count;
+    return Promise.resolve(result);
+  }
+
+  public async readNBytes(
+    b: Uint8Array,
+    off: number,
+    len: number
+  ): Promise<number> {
+    const n = await this.readBytesWithOffset(b, off, len);
+    return n === -1 ? 0 : n;
+  }
+
+  public async transferTo(out: OutputStream): Promise<number> {
+    const len = this.count - this.pos;
+    if (len > 0) {
+      let nWritten = 0;
+      while (nWritten < len) {
+        const nByte = Math.min(
+          len - nWritten,
+          ByteArrayInputStream.MAX_TRANSFER_SIZE
+        );
+        const chunk = this.buf.slice(this.pos, this.pos + nByte);
+        out.writeBytes(chunk);
+        this.pos += nByte;
+        nWritten += nByte;
+      }
+      return len;
+    }
+    return 0;
+  }
+
+  public skip(n: number): Promise<number> {
+    const k = Math.min(n, this.count - this.pos);
+    this.pos += k;
+    return Promise.resolve(k);
+  }
+
+  public available(): number {
+    return this.count - this.pos;
+  }
+
+  public markSupported(): boolean {
+    return true;
+  }
+
+  public mark(_readAheadLimit: number): void {
+    this._mark = this.pos;
+  }
+
+  public reset(): void {
+    this.pos = this._mark;
+  }
+}