@trustchex/react-native-sdk 1.161.0

package/src/Shared/EIDReader/defaultFileInfo.ts

@@ -0,0 +1,41 @@
+import { FileInfo } from './fileInfo';
+import { Fragment } from './fragment';
+import { FragmentBuffer } from './fragmentBuffer';
+
+export class DefaultFileInfo extends FileInfo {
+  private fid: number;
+  private buffer: FragmentBuffer;
+
+  constructor(fid: number, length: number) {
+    super();
+    this.fid = fid;
+    this.buffer = new FragmentBuffer(length);
+  }
+
+  public getBuffer() {
+    return this.buffer.getBuffer();
+  }
+
+  public getFID(): number {
+    return this.fid;
+  }
+
+  public getFileLength(): number {
+    return this.buffer.getLength();
+  }
+
+  public toString(): string {
+    return this.fid.toString(16);
+  }
+
+  public getSmallestUnbufferedFragment(
+    offset: number,
+    length: number
+  ): Fragment {
+    return this.buffer.getSmallestUnbufferedFragment(offset, length);
+  }
+
+  public addFragment(offset: number, bytes: Uint8Array): void {
+    this.buffer.addFragmentBytes(offset, bytes);
+  }
+}

package/src/Shared/EIDReader/defaultFileSystem.ts

@@ -0,0 +1,287 @@
+import { EIDService } from './eidService';
+import type { APDULevelReadBinaryCapable } from './apduLevelReadBinaryCapable';
+import { ByteArrayInputStream } from './java/byteArrayInputStream';
+import { DefaultFileInfo } from './defaultFileInfo';
+import { FileInfo } from './fileInfo';
+import { ISO7816_SW } from './smartcards/iso7816';
+import { SecureMessagingWrapper } from './secureMessagingWrapper';
+import { TripleDesSecureMessagingWrapper } from './tripleDesSecureMessagingWrapper';
+import type { APDUWrapper } from './smartcards/apduWrapper';
+import { TLVInputStream } from './tlv/tlvInputStream';
+import { CVCAFile } from './lds/cvcaFile';
+import { Buffer } from 'buffer';
+import type { FileSystemStructured } from './smartcards/fileSystemStructured';
+
+export class DefaultFileSystem implements FileSystemStructured {
+  private static readonly NO_SFI: number = -1;
+  private static readonly READ_AHEAD_LENGTH: number = 8;
+
+  private selectedFID: number;
+  private isSFIEnabled: boolean;
+  private maxReadBinaryLength: number;
+  private isSelected: boolean;
+  private service: APDULevelReadBinaryCapable;
+  private fileInfos: Map<number, DefaultFileInfo>;
+  private fidToSFI: Map<number, number>;
+  private wrapper!: APDUWrapper;
+  private oldWrapper!: APDUWrapper;
+
+  constructor(
+    service: APDULevelReadBinaryCapable,
+    isSFIEnabled: boolean,
+    fidToSFI: Map<number, number> = new Map<number, number>()
+  ) {
+    this.service = service;
+    this.fileInfos = new Map<number, DefaultFileInfo>();
+    this.selectedFID = 0;
+    this.isSelected = false;
+    this.isSFIEnabled = isSFIEnabled;
+    this.fidToSFI = fidToSFI;
+    this.maxReadBinaryLength = EIDService.EXTENDED_MAX_TRANSCEIVE_LENGTH;
+  }
+
+  public setWrapper(wrapper: APDUWrapper): void {
+    this.oldWrapper = this.wrapper;
+    this.wrapper = wrapper;
+  }
+
+  public getWrapper() {
+    return this.wrapper;
+  }
+
+  public getMaxReadBinaryLength(): number {
+    return this.maxReadBinaryLength;
+  }
+
+  public async getSelectedPath(): Promise<FileInfo[] | null> {
+    const fileInfo = await this.getFileInfo();
+    if (fileInfo == null) {
+      return null;
+    } else {
+      return [fileInfo];
+    }
+  }
+
+  public selectFile(fid: number): void {
+    if (this.selectedFID === fid) {
+      return;
+    }
+    this.selectedFID = fid;
+    this.isSelected = false;
+  }
+
+  public async readBinary(offset: number, length: number): Promise<Uint8Array> {
+    let fileInfo: DefaultFileInfo | null = null;
+    try {
+      if (this.selectedFID <= 0) {
+        throw new Error('No file selected');
+      }
+
+      fileInfo = await this.getFileInfo();
+      if (fileInfo == null) {
+        throw new Error('Could not get file info');
+      }
+
+      length = Math.min(length, this.maxReadBinaryLength);
+      const fragment = fileInfo.getSmallestUnbufferedFragment(offset, length);
+
+      let responseLength = length;
+      let bytes: Uint8Array | null = null;
+
+      if (fragment.getLength() > 0) {
+        if (this.isSFIEnabled && offset < 256) {
+          const sfi: number | undefined = this.fidToSFI.get(this.selectedFID);
+          if (sfi == null) {
+            throw new Error(`Unknown FID ${this.selectedFID.toString(16)}`);
+          }
+          bytes = await this.sendReadBinary(
+            0x80 | (sfi & 0xff),
+            fragment.getOffset(),
+            fragment.getLength(),
+            false
+          );
+          this.isSelected = true;
+        } else {
+          if (!this.isSelected) {
+            await this.sendSelectFile(this.selectedFID);
+            this.isSelected = true;
+          }
+          bytes = await this.sendReadBinaryNoSFI(
+            fragment.getOffset(),
+            fragment.getLength(),
+            offset > 32767
+          );
+        }
+
+        if (bytes == null) {
+          throw new Error('Could not read bytes');
+        }
+
+        if (bytes.length > 0) {
+          fileInfo.addFragment(fragment.getOffset(), Uint8Array.from(bytes));
+        }
+
+        if (bytes.length < fragment.getLength()) {
+          responseLength = bytes.length;
+        }
+      }
+
+      const buffer = fileInfo.getBuffer();
+      const result = buffer.slice(offset, offset + responseLength);
+
+      return result;
+    } catch (error) {
+      const sw = (error as any).getSW();
+      if (
+        (sw & ISO7816_SW.WRONG_LENGTH) === ISO7816_SW.WRONG_LENGTH &&
+        this.maxReadBinaryLength > EIDService.DEFAULT_MAX_BLOCKSIZE
+      ) {
+        this.wrapper = this.oldWrapper;
+        this.maxReadBinaryLength = EIDService.DEFAULT_MAX_BLOCKSIZE;
+        return new Uint8Array(0);
+      }
+
+      throw new Error(
+        `Read binary failed on file ${fileInfo == null ? this.selectedFID.toString(16) : fileInfo}`
+      );
+    }
+  }
+
+  private async getFileInfo(): Promise<DefaultFileInfo | null> {
+    if (this.selectedFID <= 0) {
+      throw new Error('No file selected');
+    }
+
+    let fileInfo = this.fileInfos.get(this.selectedFID);
+    if (fileInfo != null) {
+      return fileInfo;
+    }
+
+    let prefix: Uint8Array | null = null;
+    if (this.isSFIEnabled) {
+      const sfi = this.fidToSFI.get(this.selectedFID);
+      if (sfi == null) {
+        throw new Error(`Unknown FID ${this.selectedFID.toString(16)}`);
+      }
+      prefix = await this.sendReadBinary(
+        0x80 | (sfi & 0xff),
+        0,
+        DefaultFileSystem.READ_AHEAD_LENGTH,
+        false
+      );
+      this.isSelected = true;
+    } else {
+      if (!this.isSelected) {
+        await this.sendSelectFile(this.selectedFID);
+        this.isSelected = true;
+      }
+      prefix = await this.sendReadBinaryNoSFI(
+        0,
+        DefaultFileSystem.READ_AHEAD_LENGTH,
+        false
+      );
+    }
+
+    if (prefix == null || prefix.length === 0) {
+      console.debug(
+        `Something is wrong with prefix, prefix = ${prefix ? Buffer.from(prefix).toString('hex') : ''}`
+      );
+      return null;
+    }
+
+    const fileLength = await this.getFileLength(
+      this.selectedFID,
+      DefaultFileSystem.READ_AHEAD_LENGTH,
+      prefix
+    );
+
+    if (fileLength < prefix.length) {
+      /* We got more than the file's length. Ignore trailing bytes. */
+      prefix = prefix.slice(0, fileLength);
+    }
+
+    fileInfo = new DefaultFileInfo(this.selectedFID, fileLength);
+    fileInfo.addFragment(0, Uint8Array.from(prefix));
+    this.fileInfos.set(this.selectedFID, fileInfo);
+
+    return fileInfo;
+  }
+
+  private async sendSelectFile(fid: number): Promise<void> {
+    await this.service.sendSelectFile(this.wrapper, fid);
+  }
+
+  private sendReadBinaryNoSFI(
+    offset: number,
+    le: number,
+    isTLVEncodedOffsetNeeded: boolean
+  ) {
+    this.oldWrapper =
+      this.wrapper instanceof SecureMessagingWrapper
+        ? new TripleDesSecureMessagingWrapper(
+            this.wrapper.getEncryptionKey(),
+            this.wrapper.getMACKey(),
+            this.wrapper.getMaxTransceiveLength(),
+            this.wrapper.getShouldCheckMAC(),
+            this.wrapper.getSendSequenceCounter()
+          )
+        : this.wrapper;
+    return this.service.sendReadBinary(
+      this.wrapper,
+      DefaultFileSystem.NO_SFI,
+      offset,
+      le,
+      false,
+      isTLVEncodedOffsetNeeded
+    );
+  }
+
+  private sendReadBinary(
+    sfi: number,
+    offset: number,
+    le: number,
+    isTLVEncodedOffsetNeeded: boolean
+  ) {
+    return this.service.sendReadBinary(
+      this.wrapper,
+      sfi,
+      offset,
+      le,
+      true,
+      isTLVEncodedOffsetNeeded
+    );
+  }
+
+  private async getFileLength(
+    fid: number,
+    le: number,
+    prefix: Uint8Array
+  ): Promise<number> {
+    if (prefix.length < le) {
+      return prefix.length;
+    }
+
+    const byteArrayInputStream = new ByteArrayInputStream(Buffer.from(prefix));
+    const tlvInputStream = new TLVInputStream(byteArrayInputStream);
+
+    try {
+      const tag = await tlvInputStream.readTag();
+
+      if (tag === CVCAFile.CAR_TAG) {
+        return CVCAFile.LENGTH;
+      }
+
+      const valueLength = await tlvInputStream.readLength();
+      const tlLength = prefix.length - byteArrayInputStream.available();
+      const fileLength = tlLength + valueLength;
+
+      return fileLength;
+    } finally {
+      try {
+        tlvInputStream.close();
+      } catch (ioe) {
+        console.debug('Error closing stream', ioe);
+      }
+    }
+  }
+}

package/src/Shared/EIDReader/eidReader.ts

@@ -0,0 +1,113 @@
+import { BACKey } from './bacKey';
+import { NFCManagerCardService } from './nfcManagerCardService';
+import { EIDService } from './eidService';
+import { DG1File } from './lds/icao/dg1File';
+import { DG2File } from './lds/icao/dg2File';
+import { FaceImageInfo } from './lds/iso19794/faceImageInfo';
+import { Buffer } from 'buffer';
+import { MRZInfo } from './lds/icao/mrzInfo';
+import { InputStream } from './java/inputStream';
+
+const eidReader = async (
+  documentNumber: string,
+  dateOfBirth: string,
+  dateOfExpiry: string,
+  progressCallback?: (progress: number) => void
+): Promise<
+  { mrz?: MRZInfo; faceImage: string; mimeType: string } | undefined
+> => {
+  let progress = 0;
+  const nfcManagerCardService = new NFCManagerCardService();
+  const passportService = new EIDService(
+    nfcManagerCardService,
+    EIDService.NORMAL_MAX_TRANSCEIVE_LENGTH,
+    EIDService.DEFAULT_MAX_BLOCKSIZE,
+    false,
+    true
+  );
+
+  try {
+    await passportService.open();
+
+    // Select Applet for MRTD
+    await passportService.sendSelectApplet(false);
+
+    progress = 10;
+    if (progressCallback) {
+      progressCallback(progress);
+    }
+
+    // Check if EF_COM is available
+    try {
+      const efComStream = passportService.getInputStream(EIDService.EF_COM);
+      await efComStream.init();
+      await efComStream.read();
+    } catch (error) {
+      // EF_COM not available -> try to do BAC
+      const bacKey = new BACKey(documentNumber, dateOfBirth, dateOfExpiry);
+      await passportService.doBAC(bacKey);
+    }
+
+    progress = 20;
+    if (progressCallback) {
+      progressCallback(progress);
+    }
+
+    // Read DG1 (MRZ Info)
+    const dg1InputStream = passportService.getInputStream(EIDService.EF_DG1);
+    await dg1InputStream.init();
+    const dg1File = new DG1File(undefined, dg1InputStream);
+    const mrzInfo = await dg1File.getMRZInfo();
+
+    progress = 30;
+    if (progressCallback) {
+      progressCallback(progress);
+    }
+
+    // Read DG2 (Face Image)
+    const dg2InputStream = passportService.getInputStream(EIDService.EF_DG2);
+    await dg2InputStream.init();
+    InputStream.onRead((totalBytesRead, fileLength) => {
+      progress = 30 + (totalBytesRead / fileLength) * 70;
+      if (progressCallback) {
+        progressCallback(progress);
+      }
+    });
+    const dg2File = new DG2File([], dg2InputStream);
+    let imageAsBase64 = '';
+    let mimeType = '';
+
+    const allFaceImageInfos: FaceImageInfo[] = [];
+    const faceInfos = await dg2File.getFaceInfos();
+    for (let faceInfo of faceInfos) {
+      allFaceImageInfos.push(...faceInfo.getFaceImageInfos());
+    }
+
+    if (allFaceImageInfos?.length > 0) {
+      const faceImageInfo = allFaceImageInfos[0];
+      const imageLength = faceImageInfo.getImageLength();
+      const imageInputStream = await faceImageInfo.getImageInputStream();
+      const buffer = Buffer.alloc(imageLength);
+      await imageInputStream.readBytesWithOffset(buffer, 0, imageLength);
+      imageAsBase64 = buffer.toString('base64');
+      mimeType = faceImageInfo.getMimeType();
+    }
+
+    progress = 100;
+    if (progressCallback) {
+      progressCallback(progress);
+    }
+
+    return {
+      mrz: mrzInfo,
+      faceImage: imageAsBase64,
+      mimeType: mimeType,
+    };
+  } catch (error) {
+    console.debug('Error reading passport data', error);
+  } finally {
+    await passportService.close();
+  }
+};
+
+export { eidReader };