@trustchex/react-native-sdk 1.161.0

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

@@ -0,0 +1,137 @@
+"use strict";
+
+import { ByteArrayInputStream } from "../java/byteArrayInputStream.js";
+import { ByteArrayOutputStream } from "../java/byteArrayOutputStream.js";
+import { DataInputStream } from "../java/dataInputStream.js";
+import { Buffer } from 'buffer';
+export class AbstractImageInfo {
+  /** Mime-type. */
+  static JPEG_MIME_TYPE = 'image/jpeg';
+
+  /** Mime-type. */
+  static JPEG2000_MIME_TYPE = 'image/jp2';
+
+  /** Mime-type. */
+  static WSQ_MIME_TYPE = 'image/x-wsq';
+
+  /** Type of image. */
+  static TYPE_UNKNOWN = -1;
+
+  /** Type of image. */
+  static TYPE_PORTRAIT = 0;
+
+  /** Type of image. */
+  static TYPE_SIGNATURE_OR_MARK = 1;
+
+  /** Type of image. */
+  static TYPE_FINGER = 2;
+
+  /** Type of image. */
+  static TYPE_IRIS = 3;
+  constructor(type, width, height, inputStream, imageLength, mimeType) {
+    this.type = type;
+    this.width = width;
+    this.height = height;
+    this.mimeType = mimeType;
+    this.readImage(inputStream, imageLength);
+  }
+  getRecordLength() {
+    throw new Error('Method not implemented.');
+  }
+  getType() {
+    return this.type;
+  }
+  getMimeType() {
+    return this.mimeType;
+  }
+  getWidth() {
+    return this.width;
+  }
+  getHeight() {
+    return this.height;
+  }
+  getImageLength() {
+    if (this.splittableInputStream != null) {
+      return this.imageLength || 0;
+    }
+    if (this.imageBytes == null) {
+      throw new Error('Cannot get length of null');
+    }
+    return this.imageBytes.length;
+  }
+  getEncoded() {
+    const out = new ByteArrayOutputStream();
+    try {
+      this.writeObject(out);
+    } catch (ioe) {
+      console.debug('Error getting encoded file', ioe);
+      return null;
+    }
+    return out.toByteArray();
+  }
+  async getImageInputStream() {
+    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');
+    }
+  }
+  async readImage(inputStream, imageLength) {
+    this.splittableInputStream = undefined;
+    this.imageBytes = new Uint8Array(imageLength);
+    const dataIn = new DataInputStream(inputStream);
+    await dataIn.readFully(this.imageBytes);
+  }
+  async writeImage(outputStream) {
+    outputStream.writeBytes(await this.getImageBytes());
+  }
+  setMimeType(mimeType) {
+    this.mimeType = mimeType;
+  }
+  setType(type) {
+    this.type = type;
+  }
+  setWidth(width) {
+    this.width = width;
+  }
+  setHeight(height) {
+    this.height = height;
+  }
+  async setImageBytes(imageBytes) {
+    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);
+    }
+  }
+  async getImageBytes() {
+    let inputStream = 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;
+  }
+  typeToString(type) {
+    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/lib/module/Shared/EIDReader/lds/abstractLDSFile.js

@@ -0,0 +1,101 @@
+"use strict";
+
+import { ByteArrayOutputStream } from "../java/byteArrayOutputStream.js";
+export class AbstractLDSFile {
+  /* NOTE: In EAC 1.11 documents there is also the CVCA file that has no tag. */
+
+  /** ICAO tag for document index (COM). */
+  static EF_COM_TAG = 0x60;
+
+  /** ICAO data group tag for DG1. */
+  static EF_DG1_TAG = 0x61;
+
+  /** ICAO data group tag for DG2. */
+  static EF_DG2_TAG = 0x75;
+
+  /** ICAO data group tag for DG3. */
+  static EF_DG3_TAG = 0x63;
+
+  /** ICAO data group tag for DG4. */
+  static EF_DG4_TAG = 0x76;
+
+  /** ICAO data group tag for DG5. */
+  static EF_DG5_TAG = 0x65;
+
+  /** ICAO data group tag for DG6. */
+  static EF_DG6_TAG = 0x66;
+
+  /** ICAO data group tag for DG7. */
+  static EF_DG7_TAG = 0x67;
+
+  /** ICAO data group tag for DG8. */
+  static EF_DG8_TAG = 0x68;
+
+  /** ICAO data group tag for DG9. */
+  static EF_DG9_TAG = 0x69;
+
+  /** ICAO data group tag for DG10. */
+  static EF_DG10_TAG = 0x6a;
+
+  /** ICAO data group tag for DG11. */
+  static EF_DG11_TAG = 0x6b;
+
+  /** ICAO data group tag for DG12. */
+  static EF_DG12_TAG = 0x6c;
+
+  /** ICAO data group tag for DG13. */
+  static EF_DG13_TAG = 0x6d;
+
+  /** ICAO data group tag for DG14. */
+  static EF_DG14_TAG = 0x6e;
+
+  /** ICAO data group tag for DG15. */
+  static EF_DG15_TAG = 0x6f;
+
+  /** ICAO data group tag for DG16. */
+  static EF_DG16_TAG = 0x70;
+
+  /** ICAO tag for document security index (SOd). */
+  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
+   */
+  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
+   */
+
+  /**
+   * Writes the file to an output stream.
+   *
+   * @param outputStream the output stream to write to
+   *
+   * @throws IOException if writing fails
+   */
+
+  /**
+   * Returns the length of the encoded file.
+   *
+   * @return the length of the encoded file
+   */
+}

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

@@ -0,0 +1,29 @@
+"use strict";
+
+import { ByteArrayOutputStream } from "../java/byteArrayOutputStream.js";
+export class AbstractLDSInfo {
+  /**
+   * Returns an encoding of this LDS info.
+   *
+   * @return the LDS info encoded as byte array
+   */
+  getEncoded() {
+    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
+   */
+}

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

@@ -0,0 +1,66 @@
+"use strict";
+
+import { AbstractLDSInfo } from "./abstractLDSInfo.js";
+export class AbstractListInfo extends AbstractLDSInfo {
+  /**
+   * Returns the sub-records of this list.
+   *
+   * @return the sub-records
+   */
+  getSubRecords() {
+    if (this.subRecords == null) {
+      this.subRecords = [];
+    }
+    return [...this.subRecords];
+  }
+
+  /**
+   * Adds a sub-record to this list.
+   *
+   * @param subRecord the sub-record to add
+   */
+  add(subRecord) {
+    if (this.subRecords == null) {
+      this.subRecords = [];
+    }
+    this.subRecords.push(subRecord);
+  }
+
+  /**
+   * Adds all sub-records in a collection.
+   *
+   * @param subRecords the sub-records to add
+   */
+  addAll(subRecords) {
+    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
+   */
+  remove(index) {
+    if (this.subRecords == null) {
+      this.subRecords = [];
+    }
+    this.subRecords.splice(index, 1);
+  }
+
+  /**
+   * Writes this value to a stream.
+   *
+   * @param outputStream the stream to write to
+   */
+
+  /**
+   * Reads this value from a stream.
+   *
+   * @param inputStream the stream to read from
+   *
+   * @throws IOException on error reading from the stream
+   */
+}

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

@@ -0,0 +1,65 @@
+"use strict";
+
+import { ByteArrayOutputStream } from "../java/byteArrayOutputStream.js";
+import { TLVInputStream } from "../tlv/tlvInputStream.js";
+import { TLVOutputStream } from "../tlv/tlvOutputStream.js";
+import { AbstractLDSFile } from "./abstractLDSFile.js";
+export class AbstractTaggedLDSFile extends AbstractLDSFile {
+  length = 0;
+  constructor(tag, inputStream) {
+    super();
+    this.tag = tag;
+    this.is = inputStream;
+  }
+  async readObject() {
+    const tlvIn = this.is instanceof TLVInputStream ? this.is : new TLVInputStream(this.is);
+    const inputTag = 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);
+  }
+  writeObject(outputStream) {
+    const tlvOut = outputStream instanceof TLVOutputStream ? outputStream : new TLVOutputStream(outputStream);
+    const ourTag = 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);
+  }
+  toString() {
+    return `TaggedLDSFile [${this.getTag().toString(16)} (${this.getLength()})]`;
+  }
+  getTag() {
+    return this.tag;
+  }
+  getLength() {
+    if (this.length <= 0) {
+      this.length = this.getContent().length;
+    }
+    return this.length;
+  }
+  getContent() {
+    const outputStream = 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/lib/module/Shared/EIDReader/lds/cbeffDataGroup.js

@@ -0,0 +1,118 @@
+"use strict";
+
+import { ISO781611 } from "../cbeff/iso781611.js";
+import { TLVOutputStream } from "../tlv/tlvOutputStream.js";
+import { JavaRandom } from "../utils/random.js";
+import { DataGroup } from "./dataGroup.js";
+export class CBEFFDataGroup extends DataGroup {
+  /** For writing the optional random data block. */
+
+  /** Records in the BIT group. Each record represents a single BIT. */
+
+  /**
+   * Creates a CBEFF data group.
+   *
+   * @param dataGroupTag the data group tag
+   * @param subRecords the sub-records contained in this data group
+   */
+  constructor(dataGroupTag, subRecords, is) {
+    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
+   */
+  add(record) {
+    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
+   */
+  addAll(records) {
+    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
+   */
+  remove(index) {
+    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
+   */
+  toString() {
+    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
+   */
+  getSubRecords() {
+    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
+   */
+  writeOptionalRandomData(outputStream) {
+    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);
+  }
+}

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

@@ -0,0 +1,89 @@
+"use strict";
+
+import { EIDService } from "../eidService.js";
+import { CVCPrincipal } from "../cert/cvcPrincipal.js";
+import { DataInputStream } from "../java/dataInputStream.js";
+export class CVCAFile {
+  static CAR_TAG = 0x42;
+  static LENGTH = 36;
+  caReference = null;
+  altCAReference = null;
+  constructor(fidOrInputStream, caReference, altCAReference) {
+    if (typeof fidOrInputStream === 'number') {
+      if (caReference === undefined) {
+        throw new Error('caReference must be defined if fid is provided');
+      }
+      if (caReference.length > 16 || altCAReference && altCAReference.length > 16) {
+        throw new Error('Invalid CA reference length');
+      }
+      this.fid = fidOrInputStream;
+      this.caReference = caReference;
+      this.altCAReference = altCAReference || null;
+    } else {
+      this.fid = EIDService.EF_CVCA;
+      this.readObject(fidOrInputStream);
+    }
+  }
+  getFID() {
+    return this.fid;
+  }
+  async readObject(inputStream) {
+    const dataIn = new DataInputStream(inputStream);
+    let tag = await dataIn.read();
+    if (tag !== CVCAFile.CAR_TAG) {
+      throw new Error(`Wrong tag, expected ${CVCAFile.CAR_TAG.toString(16)}, found ${tag.toString(16)}`);
+    }
+    let length = await dataIn.read();
+    if (length > 16) {
+      throw new Error('Wrong length');
+    }
+    const data = new Uint8Array(length);
+    await dataIn.readFully(data);
+    this.caReference = new TextDecoder().decode(data);
+    tag = await dataIn.read();
+    if (tag !== 0 && tag !== -1) {
+      if (tag !== CVCAFile.CAR_TAG) {
+        throw new Error('Wrong tag');
+      }
+      length = await dataIn.read();
+      if (length > 16) {
+        throw new Error('Wrong length');
+      }
+      const altData = new Uint8Array(length);
+      await dataIn.readFully(altData);
+      this.altCAReference = new TextDecoder().decode(altData);
+      tag = await dataIn.read();
+    }
+    while (tag !== -1) {
+      if (tag !== 0) {
+        throw new Error('Bad file padding');
+      }
+      tag = await dataIn.read();
+    }
+  }
+  writeObject(outputStream) {
+    const result = new Uint8Array(CVCAFile.LENGTH);
+    result[0] = CVCAFile.CAR_TAG;
+    result[1] = this.caReference.length;
+    result.set(new TextEncoder().encode(this.caReference), 2);
+    if (this.altCAReference) {
+      const index = result[1] + 2;
+      result[index] = CVCAFile.CAR_TAG;
+      result[index + 1] = this.altCAReference.length;
+      result.set(new TextEncoder().encode(this.altCAReference), index + 2);
+    }
+    outputStream.writeBytes(result);
+  }
+  getCAReference() {
+    return this.caReference ? new CVCPrincipal(this.caReference) : null;
+  }
+  getAltCAReference() {
+    return this.altCAReference ? new CVCPrincipal(this.altCAReference) : null;
+  }
+  toString() {
+    return `CA reference: "${this.caReference}"${this.altCAReference ? `, Alternative CA reference: ${this.altCAReference}` : ''}`;
+  }
+  getLength() {
+    return CVCAFile.LENGTH;
+  }
+}

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

@@ -0,0 +1,10 @@
+"use strict";
+
+import { AbstractTaggedLDSFile } from "./abstractTaggedLDSFile.js";
+export class DataGroup extends AbstractTaggedLDSFile {
+  constructor(dataGroupTag, inputStream) {
+    super(dataGroupTag, inputStream);
+    this.dataGroupTag = dataGroupTag;
+    this.inputStream = inputStream;
+  }
+}