@trustchex/react-native-sdk 1.161.0

package/src/Shared/EIDReader/lds/abstractImageInfo.ts

@@ -0,0 +1,191 @@
+import { ByteArrayInputStream } from '../java/byteArrayInputStream';
+import { ByteArrayOutputStream } from '../java/byteArrayOutputStream';
+import { DataInputStream } from '../java/dataInputStream';
+import { InputStream } from '../java/inputStream';
+import { OutputStream } from '../java/outputStream';
+import { SplittableInputStream } from '../java/splittableInputStream';
+import type { ImageInfo } from './imageInfo';
+import { Buffer } from 'buffer';
+
+export abstract class AbstractImageInfo implements ImageInfo {
+  /** Mime-type. */
+  static JPEG_MIME_TYPE: string = 'image/jpeg';
+
+  /** Mime-type. */
+  static JPEG2000_MIME_TYPE: string = 'image/jp2';
+
+  /** Mime-type. */
+  static WSQ_MIME_TYPE: string = 'image/x-wsq';
+
+  /** Type of image. */
+  static readonly TYPE_UNKNOWN: number = -1;
+
+  /** Type of image. */
+  static readonly TYPE_PORTRAIT: number = 0;
+
+  /** Type of image. */
+  static readonly TYPE_SIGNATURE_OR_MARK: number = 1;
+
+  /** Type of image. */
+  static readonly TYPE_FINGER: number = 2;
+
+  /** Type of image. */
+  static readonly TYPE_IRIS: number = 3;
+
+  private type: number;
+  private mimeType: string;
+  private imageBytes?: Uint8Array;
+  private splittableInputStream?: SplittableInputStream;
+  private imagePositionInInputStream?: number;
+  private imageLength?: number;
+  private width: number;
+  private height: number;
+
+  constructor(
+    type: number,
+    width: number,
+    height: number,
+    inputStream: InputStream,
+    imageLength: number,
+    mimeType: string
+  ) {
+    this.type = type;
+    this.width = width;
+    this.height = height;
+    this.mimeType = mimeType;
+    this.readImage(inputStream, imageLength);
+  }
+
+  getRecordLength(): number {
+    throw new Error('Method not implemented.');
+  }
+
+  public getType(): number {
+    return this.type;
+  }
+
+  public getMimeType(): string {
+    return this.mimeType;
+  }
+
+  public getWidth(): number {
+    return this.width;
+  }
+
+  public getHeight(): number {
+    return this.height;
+  }
+
+  public getImageLength(): number {
+    if (this.splittableInputStream != null) {
+      return this.imageLength || 0;
+    }
+
+    if (this.imageBytes == null) {
+      throw new Error('Cannot get length of null');
+    }
+
+    return this.imageBytes.length;
+  }
+
+  public getEncoded(): Uint8Array | null {
+    const out = new ByteArrayOutputStream();
+    try {
+      this.writeObject(out);
+    } catch (ioe) {
+      console.debug('Error getting encoded file', ioe);
+      return null;
+    }
+    return out.toByteArray();
+  }
+
+  public async getImageInputStream(): Promise<InputStream> {
+    if (!!this.splittableInputStream && !!this.imagePositionInInputStream) {
+      return await this.splittableInputStream.getInputStream(
+        this.imagePositionInInputStream
+      );
+    } else if (this.imageBytes) {
+      return Promise.resolve(
+        new ByteArrayInputStream(Buffer.from(this.imageBytes))
+      );
+    } else {
+      throw new Error('Both the byte buffer and the stream are null');
+    }
+  }
+
+  protected async readImage(
+    inputStream: InputStream,
+    imageLength: number
+  ): Promise<void> {
+    this.splittableInputStream = undefined;
+    this.imageBytes = new Uint8Array(imageLength);
+    const dataIn = new DataInputStream(inputStream);
+    await dataIn.readFully(this.imageBytes);
+  }
+
+  protected async writeImage(outputStream: OutputStream): Promise<void> {
+    outputStream.writeBytes(await this.getImageBytes());
+  }
+
+  protected setMimeType(mimeType: string): void {
+    this.mimeType = mimeType;
+  }
+
+  protected setType(type: number): void {
+    this.type = type;
+  }
+
+  protected setWidth(width: number): void {
+    this.width = width;
+  }
+
+  protected setHeight(height: number): void {
+    this.height = height;
+  }
+
+  protected async setImageBytes(imageBytes: Uint8Array): Promise<void> {
+    if (imageBytes == null) {
+      throw new Error('Cannot set null image bytes');
+    }
+
+    try {
+      await this.readImage(
+        new ByteArrayInputStream(Buffer.from(imageBytes)),
+        imageBytes.length
+      );
+    } catch (e) {
+      console.debug('Error setting image bytes', e);
+    }
+  }
+
+  protected abstract readObject(inputStream: InputStream): Promise<void>;
+
+  protected abstract writeObject(outputStream: OutputStream): void;
+
+  private async getImageBytes(): Promise<Uint8Array> {
+    let inputStream: InputStream | null = null;
+    const length = this.getImageLength();
+    const imageBytes = new Uint8Array(length);
+    inputStream = await this.getImageInputStream();
+    const imageInputStream = new DataInputStream(inputStream);
+    await imageInputStream.readFully(imageBytes);
+    return imageBytes;
+  }
+
+  private typeToString(type: number): string {
+    switch (type) {
+      case AbstractImageInfo.TYPE_PORTRAIT:
+        return 'Portrait';
+      case AbstractImageInfo.TYPE_SIGNATURE_OR_MARK:
+        return 'Signature or usual mark';
+      case AbstractImageInfo.TYPE_FINGER:
+        return 'Finger';
+      case AbstractImageInfo.TYPE_IRIS:
+        return 'Iris';
+      case AbstractImageInfo.TYPE_UNKNOWN:
+        return 'Unknown';
+      default:
+        throw new Error(`Unknown type: ${type.toString(16)}`);
+    }
+  }
+}

package/src/Shared/EIDReader/lds/abstractLDSFile.ts

@@ -0,0 +1,106 @@
+import { ByteArrayOutputStream } from '../java/byteArrayOutputStream';
+import { InputStream } from '../java/inputStream';
+import { OutputStream } from '../java/outputStream';
+import type { LDSFile } from './ldsFile';
+
+export abstract class AbstractLDSFile implements LDSFile {
+  /* NOTE: In EAC 1.11 documents there is also the CVCA file that has no tag. */
+
+  /** ICAO tag for document index (COM). */
+  public static EF_COM_TAG: number = 0x60;
+
+  /** ICAO data group tag for DG1. */
+  public static EF_DG1_TAG = 0x61;
+
+  /** ICAO data group tag for DG2. */
+  public static EF_DG2_TAG = 0x75;
+
+  /** ICAO data group tag for DG3. */
+  public static EF_DG3_TAG = 0x63;
+
+  /** ICAO data group tag for DG4. */
+  public static EF_DG4_TAG = 0x76;
+
+  /** ICAO data group tag for DG5. */
+  public static EF_DG5_TAG = 0x65;
+
+  /** ICAO data group tag for DG6. */
+  public static EF_DG6_TAG = 0x66;
+
+  /** ICAO data group tag for DG7. */
+  public static EF_DG7_TAG = 0x67;
+
+  /** ICAO data group tag for DG8. */
+  public static EF_DG8_TAG = 0x68;
+
+  /** ICAO data group tag for DG9. */
+  public static EF_DG9_TAG = 0x69;
+
+  /** ICAO data group tag for DG10. */
+  public static EF_DG10_TAG = 0x6a;
+
+  /** ICAO data group tag for DG11. */
+  public static EF_DG11_TAG = 0x6b;
+
+  /** ICAO data group tag for DG12. */
+  public static EF_DG12_TAG = 0x6c;
+
+  /** ICAO data group tag for DG13. */
+  public static EF_DG13_TAG = 0x6d;
+
+  /** ICAO data group tag for DG14. */
+  public static EF_DG14_TAG = 0x6e;
+
+  /** ICAO data group tag for DG15. */
+  public static EF_DG15_TAG = 0x6f;
+
+  /** ICAO data group tag for DG16. */
+  public static EF_DG16_TAG = 0x70;
+
+  /** ICAO tag for document security index (SOd). */
+  public static EF_SOD_TAG = 0x77;
+
+  /**
+   * Returns the contents of this file as byte array,
+   * includes the ICAO tag and length.
+   *
+   * @return a byte array containing the file
+   */
+  public getEncoded() {
+    try {
+      const out = new ByteArrayOutputStream();
+      this.writeObject(out);
+      out.flush();
+      out.close();
+      return out.toByteArray();
+    } catch (ioe) {
+      console.debug('Error getting encoded file', ioe);
+      return null;
+    }
+  }
+
+  /**
+   * Reads the file from an input stream.
+   *
+   * @param inputStream the input stream to read from
+   *
+   * @throws IOException if reading fails
+   */
+  protected abstract readObject(inputStream: InputStream): void;
+
+  /**
+   * Writes the file to an output stream.
+   *
+   * @param outputStream the output stream to write to
+   *
+   * @throws IOException if writing fails
+   */
+  protected abstract writeObject(outputStream: OutputStream): void;
+
+  /**
+   * Returns the length of the encoded file.
+   *
+   * @return the length of the encoded file
+   */
+  public abstract getLength(): number;
+}

package/src/Shared/EIDReader/lds/abstractLDSInfo.ts

@@ -0,0 +1,31 @@
+import { ByteArrayOutputStream } from '../java/byteArrayOutputStream';
+import { OutputStream } from '../java/outputStream';
+import type { LDSElement } from './ldsElement';
+
+export abstract class AbstractLDSInfo implements LDSElement {
+  /**
+   * Returns an encoding of this LDS info.
+   *
+   * @return the LDS info encoded as byte array
+   */
+  public getEncoded(): Uint8Array | null {
+    try {
+      const outputStream = new ByteArrayOutputStream();
+      this.writeObject(outputStream);
+      outputStream.flush();
+      return outputStream.toByteArray();
+    } catch (ioe) {
+      console.debug('Exception: ', ioe);
+      return null;
+    }
+  }
+
+  /**
+   * Writes this LDS info to a stream.
+   *
+   * @param outputStream the stream to write to
+   *
+   * @throws IOException on error writing to the stream
+   */
+  public abstract writeObject(outputStream: OutputStream): void;
+}

package/src/Shared/EIDReader/lds/abstractListInfo.ts

@@ -0,0 +1,72 @@
+import { InputStream } from '../java/inputStream';
+import { OutputStream } from '../java/outputStream';
+import { AbstractLDSInfo } from './abstractLDSInfo';
+
+export abstract class AbstractListInfo<R> extends AbstractLDSInfo {
+  private subRecords?: R[];
+
+  /**
+   * Returns the sub-records of this list.
+   *
+   * @return the sub-records
+   */
+  protected getSubRecords(): R[] {
+    if (this.subRecords == null) {
+      this.subRecords = [];
+    }
+
+    return [...this.subRecords];
+  }
+
+  /**
+   * Adds a sub-record to this list.
+   *
+   * @param subRecord the sub-record to add
+   */
+  protected add(subRecord: R): void {
+    if (this.subRecords == null) {
+      this.subRecords = [];
+    }
+    this.subRecords.push(subRecord);
+  }
+
+  /**
+   * Adds all sub-records in a collection.
+   *
+   * @param subRecords the sub-records to add
+   */
+  protected addAll(subRecords: R[]): void {
+    if (this.subRecords == null) {
+      this.subRecords = [];
+    }
+    this.subRecords.push(...subRecords);
+  }
+
+  /**
+   * Removes a sub-record at a given index.
+   *
+   * @param index the index of the sub-record to remove
+   */
+  protected remove(index: number): void {
+    if (this.subRecords == null) {
+      this.subRecords = [];
+    }
+    this.subRecords.splice(index, 1);
+  }
+
+  /**
+   * Writes this value to a stream.
+   *
+   * @param outputStream the stream to write to
+   */
+  abstract writeObject(outputStream: OutputStream): void;
+
+  /**
+   * Reads this value from a stream.
+   *
+   * @param inputStream the stream to read from
+   *
+   * @throws IOException on error reading from the stream
+   */
+  abstract readObject(inputStream: InputStream): void;
+}

package/src/Shared/EIDReader/lds/abstractTaggedLDSFile.ts

@@ -0,0 +1,85 @@
+import { ByteArrayOutputStream } from '../java/byteArrayOutputStream';
+import { InputStream } from '../java/inputStream';
+import { OutputStream } from '../java/outputStream';
+import { TLVInputStream } from '../tlv/tlvInputStream';
+import { TLVOutputStream } from '../tlv/tlvOutputStream';
+import { AbstractLDSFile } from './abstractLDSFile';
+
+export abstract class AbstractTaggedLDSFile extends AbstractLDSFile {
+  private tag: number;
+  private length: number = 0;
+  private is: InputStream;
+
+  constructor(tag: number, inputStream: InputStream) {
+    super();
+    this.tag = tag;
+    this.is = inputStream;
+  }
+
+  protected async readObject(): Promise<void> {
+    const tlvIn: TLVInputStream =
+      this.is instanceof TLVInputStream ? this.is : new TLVInputStream(this.is);
+    const inputTag: number = await tlvIn.readTag();
+    if (inputTag !== this.tag) {
+      throw new Error(
+        `Was expecting tag ${this.tag.toString(16)}, found ${inputTag.toString(16)}`
+      );
+    }
+    this.length = await tlvIn.readLength();
+    await this.readContent(tlvIn);
+  }
+
+  protected writeObject(outputStream: OutputStream): void {
+    const tlvOut: TLVOutputStream =
+      outputStream instanceof TLVOutputStream
+        ? outputStream
+        : new TLVOutputStream(outputStream);
+    const ourTag: number = this.getTag();
+    if (this.tag !== ourTag) {
+      this.tag = ourTag;
+    }
+    tlvOut.writeTag(ourTag);
+    const value = this.getContent();
+    const ourLength = value === null ? 0 : value.length;
+    if (this.length !== ourLength) {
+      this.length = ourLength;
+    }
+    tlvOut.writeValue(value);
+  }
+
+  protected abstract readContent(inputStream: InputStream): Promise<void>;
+
+  protected abstract writeContent(outputStream: OutputStream): void;
+
+  public toString(): string {
+    return `TaggedLDSFile [${this.getTag().toString(16)} (${this.getLength()})]`;
+  }
+
+  public getTag(): number {
+    return this.tag;
+  }
+
+  public getLength(): number {
+    if (this.length <= 0) {
+      this.length = this.getContent().length;
+    }
+    return this.length;
+  }
+
+  private getContent(): Uint8Array {
+    const outputStream: ByteArrayOutputStream = new ByteArrayOutputStream();
+    try {
+      this.writeContent(outputStream);
+      outputStream.flush();
+      return outputStream.toByteArray();
+    } catch (ioe) {
+      throw new Error('Could not get DG content');
+    } finally {
+      try {
+        outputStream.close();
+      } catch (ioe) {
+        console.debug('Error closing stream', ioe);
+      }
+    }
+  }
+}

package/src/Shared/EIDReader/lds/cbeffDataGroup.ts

@@ -0,0 +1,128 @@
+import type { BiometricDataBlock } from '../cbeff/biometricDataBlock';
+import { ISO781611 } from '../cbeff/iso781611';
+import { InputStream } from '../java/inputStream';
+import { OutputStream } from '../java/outputStream';
+import { TLVOutputStream } from '../tlv/tlvOutputStream';
+import { JavaRandom } from '../utils/random';
+import { DataGroup } from './dataGroup';
+
+export abstract class CBEFFDataGroup<
+  R extends BiometricDataBlock,
+> extends DataGroup {
+  /** For writing the optional random data block. */
+  private random: JavaRandom;
+
+  /** Records in the BIT group. Each record represents a single BIT. */
+  private subRecords?: R[];
+
+  /**
+   * Creates a CBEFF data group.
+   *
+   * @param dataGroupTag the data group tag
+   * @param subRecords the sub-records contained in this data group
+   */
+  constructor(dataGroupTag: number, subRecords: R[], is: InputStream) {
+    super(dataGroupTag, is);
+    if (subRecords) {
+      this.subRecords = [...subRecords];
+    }
+    this.random = new JavaRandom();
+  }
+
+  /**
+   * Adds a record to this data group.
+   *
+   * @param record the record to add
+   */
+  public add(record: R): void {
+    if (this.subRecords == null) {
+      this.subRecords = [];
+    }
+    this.subRecords.push(record);
+  }
+
+  /**
+   * Adds all records in a list to this data group.
+   *
+   * @param records the records to add
+   */
+  public addAll(records: R[]): void {
+    if (this.subRecords == null) {
+      this.subRecords = [];
+    }
+    this.subRecords.push(...records);
+  }
+
+  /**
+   * Removes the record at the given index.
+   *
+   * @param index the index of the record to remove
+   */
+  public remove(index: number): void {
+    if (this.subRecords == null) {
+      this.subRecords = [];
+    }
+    this.subRecords.splice(index, 1);
+  }
+
+  /**
+   * Returns a textual representation of this data group.
+   *
+   * @return a textual representation of this data group
+   */
+  public toString(): string {
+    let result = 'CBEFFDataGroup [';
+    if (this.subRecords == null) {
+      result += 'null';
+    } else {
+      let isFirst = true;
+      for (const subRecord of this.subRecords) {
+        if (!isFirst) {
+          result += ', ';
+        } else {
+          isFirst = false;
+        }
+        result += subRecord == null ? 'null' : subRecord.toString();
+      }
+    }
+    result += ']';
+    return result;
+  }
+
+  /**
+   * Returns the records in this data group.
+   *
+   * @return the records in this data group
+   */
+  public getSubRecords(): R[] {
+    if (this.subRecords == null) {
+      this.subRecords = [];
+    }
+    return [...this.subRecords];
+  }
+
+  /**
+   * Concrete implementations of EAC protected CBEFF DataGroups should call this
+   * method at the end of their {@link #writeContent(OutputStream)} method to add
+   * some random data if the record contains zero biometric templates.
+   * See supplement to ICAO Doc 9303 R7-p1_v2_sIII_0057.
+   *
+   * @param outputStream the outputstream
+   *
+   * @throws IOException on I/O errors
+   */
+  protected writeOptionalRandomData(outputStream: OutputStream): void {
+    if (!this.subRecords?.length) {
+      return;
+    }
+
+    const tlvOut =
+      outputStream instanceof TLVOutputStream
+        ? outputStream
+        : new TLVOutputStream(outputStream);
+    tlvOut.writeTag(ISO781611.DISCRETIONARY_DATA_FOR_PAYLOAD_TAG);
+    const value = new Uint8Array(8);
+    this.random.nextBytes(Array.from(value));
+    tlvOut.writeValue(value);
+  }
+}