@trustchex/react-native-sdk 1.161.0

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

@@ -0,0 +1,112 @@
+import { EIDService } from '../eidService';
+import { CVCPrincipal } from '../cert/cvcPrincipal';
+import { InputStream } from '../java/inputStream';
+import { OutputStream } from '../java/outputStream';
+import { DataInputStream } from '../java/dataInputStream';
+
+export class CVCAFile {
+  public static readonly CAR_TAG = 0x42;
+  public static readonly LENGTH = 36;
+
+  private fid: number;
+  private caReference: string | null = null;
+  private altCAReference: string | null = null;
+
+  constructor(
+    fidOrInputStream: number | InputStream,
+    caReference?: string,
+    altCAReference?: string
+  ) {
+    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);
+    }
+  }
+
+  public getFID(): number {
+    return this.fid;
+  }
+
+  private async readObject(inputStream: InputStream): Promise<void> {
+    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();
+    }
+  }
+
+  public writeObject(outputStream: OutputStream): void {
+    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);
+  }
+
+  public getCAReference(): CVCPrincipal | null {
+    return this.caReference ? new CVCPrincipal(this.caReference) : null;
+  }
+
+  public getAltCAReference(): CVCPrincipal | null {
+    return this.altCAReference ? new CVCPrincipal(this.altCAReference) : null;
+  }
+
+  public toString(): string {
+    return `CA reference: "${this.caReference}"${this.altCAReference ? `, Alternative CA reference: ${this.altCAReference}` : ''}`;
+  }
+
+  public getLength(): number {
+    return CVCAFile.LENGTH;
+  }
+}

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

@@ -0,0 +1,11 @@
+import { InputStream } from '../java/inputStream';
+import { AbstractTaggedLDSFile } from './abstractTaggedLDSFile';
+
+export abstract class DataGroup extends AbstractTaggedLDSFile {
+  constructor(
+    protected dataGroupTag: number,
+    protected inputStream: InputStream
+  ) {
+    super(dataGroupTag, inputStream);
+  }
+}

package/src/Shared/EIDReader/lds/icao/comFile.ts

@@ -0,0 +1,166 @@
+import { InputStream } from '../../java/inputStream';
+import { OutputStream } from '../../java/outputStream';
+import { TLVInputStream } from '../../tlv/tlvInputStream';
+import { TLVOutputStream } from '../../tlv/tlvOutputStream';
+import { AbstractTaggedLDSFile } from '../abstractTaggedLDSFile';
+
+export class COMFile extends AbstractTaggedLDSFile {
+  private static readonly TAG_LIST_TAG = 0x5c;
+  private static readonly VERSION_UNICODE_TAG = 0x5f36;
+  private static readonly VERSION_LDS_TAG = 0x5f01;
+
+  private versionLDS: string;
+  private updateLevelLDS: string;
+  private majorVersionUnicode: string;
+  private minorVersionUnicode: string;
+  private releaseLevelUnicode: string;
+  private tagList: number[] = [];
+
+  constructor(
+    versionLDS: string,
+    updateLevelLDS: string,
+    majorVersionUnicode: string,
+    minorVersionUnicode: string,
+    releaseLevelUnicode: string,
+    tagList: number[]
+  ) {
+    super(COMFile.EF_COM_TAG, null);
+    if (
+      versionLDS === null ||
+      versionLDS.length !== 2 ||
+      updateLevelLDS === null ||
+      updateLevelLDS.length !== 2 ||
+      majorVersionUnicode === null ||
+      majorVersionUnicode.length !== 2 ||
+      minorVersionUnicode === null ||
+      minorVersionUnicode.length !== 2 ||
+      releaseLevelUnicode === null ||
+      releaseLevelUnicode.length !== 2 ||
+      tagList === null
+    ) {
+      throw new Error('Invalid arguments');
+    }
+    this.versionLDS = versionLDS;
+    this.updateLevelLDS = updateLevelLDS;
+    this.majorVersionUnicode = majorVersionUnicode;
+    this.minorVersionUnicode = minorVersionUnicode;
+    this.releaseLevelUnicode = releaseLevelUnicode;
+    this.tagList = [...tagList];
+  }
+
+  async readContent(is: InputStream): Promise<void> {
+    const tlvIn = is instanceof TLVInputStream ? is : new TLVInputStream(is);
+    const versionLDSTag = await tlvIn.readTag();
+    if (versionLDSTag !== COMFile.VERSION_LDS_TAG) {
+      throw new Error(
+        `Expected VERSION_LDS_TAG (${COMFile.VERSION_LDS_TAG.toString(16)}), found ${versionLDSTag.toString(16)}`
+      );
+    }
+    const versionLDSLength = await tlvIn.readLength();
+    if (versionLDSLength !== 4) {
+      throw new Error('Wrong length of LDS version object');
+    }
+    const versionLDSBytes = await tlvIn.readValue();
+    this.versionLDS = new TextDecoder().decode(
+      new Uint8Array(versionLDSBytes.slice(0, 2)).buffer
+    );
+    this.updateLevelLDS = new TextDecoder().decode(
+      new Uint8Array(versionLDSBytes.slice(2, 4)).buffer
+    );
+
+    const versionUnicodeTag = await tlvIn.readTag();
+    if (versionUnicodeTag !== COMFile.VERSION_UNICODE_TAG) {
+      throw new Error(
+        `Expected VERSION_UNICODE_TAG (${COMFile.VERSION_UNICODE_TAG.toString(16)}), found ${versionUnicodeTag.toString(
+          16
+        )}`
+      );
+    }
+    const versionUnicodeLength = await tlvIn.readLength();
+    if (versionUnicodeLength !== 6) {
+      throw new Error('Wrong length of LDS version object');
+    }
+    const versionUnicodeBytes = await tlvIn.readValue();
+    this.majorVersionUnicode = new TextDecoder().decode(
+      new Uint8Array(versionUnicodeBytes.slice(0, 2)).buffer
+    );
+    this.minorVersionUnicode = new TextDecoder().decode(
+      new Uint8Array(versionUnicodeBytes.slice(2, 4)).buffer
+    );
+    this.releaseLevelUnicode = new TextDecoder().decode(
+      new Uint8Array(versionUnicodeBytes.slice(4, 6)).buffer
+    );
+
+    const tagListTag = await tlvIn.readTag();
+    if (tagListTag !== COMFile.TAG_LIST_TAG) {
+      throw new Error(
+        `Expected TAG_LIST_TAG (${COMFile.TAG_LIST_TAG.toString(16)}), found ${tagListTag.toString(16)}`
+      );
+    }
+    tlvIn.readLength(); // Ignore tagListLength
+    const tagBytes = await tlvIn.readValue();
+    this.tagList = Array.from(tagBytes);
+  }
+
+  getLDSVersion(): string {
+    let ldsVersion = `${this.versionLDS}.${this.updateLevelLDS}`;
+    try {
+      const major = parseInt(this.versionLDS, 10);
+      const minor = parseInt(this.updateLevelLDS, 10);
+      ldsVersion = major + '.' + minor;
+    } catch (error) {
+      // Leave ldsVersion as is
+    }
+    return ldsVersion;
+  }
+
+  getUnicodeVersion(): string {
+    let unicodeVersion = `${this.majorVersionUnicode}.${this.minorVersionUnicode}.${this.releaseLevelUnicode}`;
+
+    try {
+      const major = parseInt(this.majorVersionUnicode, 10);
+      const minor = parseInt(this.minorVersionUnicode, 10);
+      const releaseLevel = parseInt(this.releaseLevelUnicode, 10);
+      unicodeVersion = `${major}.${minor}.${releaseLevel}`;
+    } catch (error) {
+      // Leave unicodeVersion as is
+    }
+
+    return unicodeVersion;
+  }
+
+  getTagList(): number[] {
+    return this.tagList;
+  }
+
+  insertTag(tag: number): void {
+    if (this.tagList.includes(tag)) {
+      return;
+    }
+    this.tagList.push(tag);
+    this.tagList.sort();
+  }
+
+  writeContent(out: OutputStream): void {
+    const tlvOut =
+      out instanceof TLVOutputStream ? out : new TLVOutputStream(out);
+    tlvOut.writeTag(COMFile.VERSION_LDS_TAG);
+    tlvOut.writeValue(
+      new TextEncoder().encode(this.versionLDS + this.updateLevelLDS)
+    );
+    tlvOut.writeTag(COMFile.VERSION_UNICODE_TAG);
+    tlvOut.writeValue(
+      new TextEncoder().encode(
+        this.majorVersionUnicode +
+          this.minorVersionUnicode +
+          this.releaseLevelUnicode
+      )
+    );
+    tlvOut.writeTag(COMFile.TAG_LIST_TAG);
+
+    tlvOut.writeLength(this.tagList.length);
+    for (const tag of this.tagList) {
+      tlvOut.write(tag);
+    }
+  }
+}

package/src/Shared/EIDReader/lds/icao/dg1File.ts

@@ -0,0 +1,45 @@
+import { InputStream } from '../../java/inputStream';
+import { OutputStream } from '../../java/outputStream';
+import { TLVInputStream } from '../../tlv/tlvInputStream';
+import { TLVOutputStream } from '../../tlv/tlvOutputStream';
+import { DataGroup } from '../dataGroup';
+import { MRZInfo } from './mrzInfo';
+
+export class DG1File extends DataGroup {
+  private static readonly MRZ_INFO_TAG = 0x5f1f;
+  private mrzInfo?: MRZInfo;
+
+  constructor(mrzInfo?: MRZInfo, is?: InputStream) {
+    super(DG1File.EF_DG1_TAG, is);
+    if (this.mrzInfo) {
+      this.mrzInfo = mrzInfo;
+    }
+  }
+
+  async getMRZInfo(): Promise<MRZInfo | undefined> {
+    await super.readObject();
+    return this.mrzInfo;
+  }
+
+  protected async readContent(inputStream: InputStream): Promise<void> {
+    const tlvIn: TLVInputStream =
+      inputStream instanceof TLVInputStream
+        ? (inputStream as TLVInputStream)
+        : new TLVInputStream(inputStream);
+    await tlvIn.skipToTag(DG1File.MRZ_INFO_TAG);
+    const length = await tlvIn.readLength();
+    this.mrzInfo = await MRZInfo.fromStream(tlvIn, length);
+  }
+
+  protected writeContent(out: OutputStream): void {
+    const tlvOut: TLVOutputStream =
+      out instanceof TLVOutputStream
+        ? (out as TLVOutputStream)
+        : new TLVOutputStream(out);
+    tlvOut.writeTag(DG1File.MRZ_INFO_TAG);
+    const value = this.mrzInfo?.getEncoded();
+    if (value) {
+      tlvOut.writeValue(value);
+    }
+  }
+}

package/src/Shared/EIDReader/lds/icao/dg2File.ts

@@ -0,0 +1,54 @@
+import type { BiometricDataBlock } from '../../cbeff/biometricDataBlock';
+import { FaceDataBlockDecoder } from '../../cbeff/faceDataBlockDecoder';
+import { ISO781611Decoder } from '../../cbeff/iso781611Decoder';
+import { SimpleCBEFFInfo } from '../../cbeff/simpleCBEFFInfo';
+import { InputStream } from '../../java/inputStream';
+import { OutputStream } from '../../java/outputStream';
+import { CBEFFDataGroup } from '../cbeffDataGroup';
+import { FaceInfo } from '../iso19794/faceInfo';
+
+export class DG2File extends CBEFFDataGroup<FaceInfo> {
+  private static DECODER = new ISO781611Decoder(new FaceDataBlockDecoder());
+
+  constructor(faceInfos: Array<FaceInfo>, is: InputStream) {
+    super(DG2File.EF_DG2_TAG, faceInfos, is);
+  }
+
+  protected async readContent(inputStream: InputStream): Promise<void> {
+    const complexCBEFFInfo = await DG2File.DECODER.decode(inputStream);
+    const records = complexCBEFFInfo?.getSubRecords() ?? [];
+    for (const cbeffInfo of records) {
+      if (!(cbeffInfo instanceof SimpleCBEFFInfo)) {
+        throw new Error(
+          `Was expecting a SimpleCBEFFInfo, found ${cbeffInfo.constructor.name}`
+        );
+      }
+      const simpleCBEFFInfo = cbeffInfo as SimpleCBEFFInfo<FaceInfo>;
+      const bdb: BiometricDataBlock = simpleCBEFFInfo.getBiometricDataBlock();
+      if (!(bdb instanceof FaceInfo)) {
+        throw new Error(
+          `Was expecting a FaceInfo, found ${bdb.constructor.name}`
+        );
+      }
+      const faceInfo: FaceInfo = bdb as FaceInfo;
+      this.add(faceInfo);
+    }
+  }
+
+  public async getFaceInfos(): Promise<Array<FaceInfo>> {
+    await this.readObject();
+    return this.getSubRecords();
+  }
+
+  public addFaceInfo(faceInfo: FaceInfo): void {
+    this.add(faceInfo);
+  }
+
+  public removeFaceInfo(index: number): void {
+    this.remove(index);
+  }
+
+  protected writeContent(_outputStream: OutputStream): void {
+    throw new Error('Method not implemented.');
+  }
+}

package/src/Shared/EIDReader/lds/icao/icaoCountry.ts

@@ -0,0 +1,253 @@
+import { Country } from '../../data/country';
+
+export class ICAOCountry extends Country {
+  public static readonly DE = new ICAOCountry('DE', 'D<<', 'Germany', 'German');
+  public static readonly RKS = new ICAOCountry(
+    'KS',
+    'RKS',
+    'Republic of Kosovo',
+    'Kosovar'
+  );
+
+  public static readonly GBD = new ICAOCountry(
+    'GB',
+    'GBD',
+    'British Dependent territories citizen'
+  );
+  public static readonly GBN = new ICAOCountry(
+    'GB',
+    'GBN',
+    'British National (Overseas)'
+  );
+  public static readonly GBO = new ICAOCountry(
+    'GB',
+    'GBO',
+    'British Overseas citizen'
+  );
+  public static readonly GBP = new ICAOCountry(
+    'GB',
+    'GBP',
+    'British Protected person'
+  );
+  public static readonly GBS = new ICAOCountry('GB', 'GBS', 'British Subject');
+
+  public static readonly XXA = new ICAOCountry(
+    'XX',
+    'XXA',
+    'Stateless person',
+    'Stateless'
+  );
+  public static readonly XXB = new ICAOCountry(
+    'XX',
+    'XXB',
+    'Refugee',
+    'Refugee'
+  );
+  public static readonly XXC = new ICAOCountry(
+    'XX',
+    'XXC',
+    'Refugee (other)',
+    'Refugee (other)'
+  );
+  public static readonly XXX = new ICAOCountry(
+    'XX',
+    'XXX',
+    'Unspecified',
+    'Unspecified'
+  );
+
+  /** Part B: Europe. */
+  public static readonly EUE = new ICAOCountry(
+    'EU',
+    'EUE',
+    'Europe',
+    'European'
+  );
+
+  /** Part C: Codes for Use in United Nations Travel Documents. */
+  public static readonly UNO = new ICAOCountry(
+    'UN',
+    'UNO',
+    'United Nations Organization'
+  );
+  public static readonly UNA = new ICAOCountry(
+    'UN',
+    'UNA',
+    'United Nations Agency'
+  );
+  public static readonly UNK = new ICAOCountry(
+    'UN',
+    'UNK',
+    'United Nations Interim Administration Mission in Kosovo'
+  );
+
+  /** Part D: Other issuing authorities. */
+  public static readonly XBA = new ICAOCountry(
+    'XX',
+    'XBA',
+    'African Development Bank (ADB)'
+  );
+  public static readonly XIM = new ICAOCountry(
+    'XX',
+    'XIM',
+    'African Export-Import Bank (AFREXIM bank)'
+  );
+  public static readonly XCC = new ICAOCountry(
+    'XC',
+    'XCC',
+    'Carribean Community or one of its emissaries (CARICOM)'
+  );
+  public static readonly XCE = new ICAOCountry(
+    'XX',
+    'XCE',
+    'Council of Europe'
+  );
+  public static readonly XCO = new ICAOCountry(
+    'XX',
+    'XCO',
+    'Common Market for Eastern an Southern Africa (COMESA)'
+  );
+  public static readonly XEC = new ICAOCountry(
+    'XX',
+    'XEC',
+    'Economic Community of West African States (ECOWAS)'
+  );
+  public static readonly XPO = new ICAOCountry(
+    'XP',
+    'XPO',
+    'International Criminal Police Organization (INTERPOL)'
+  );
+  public static readonly XES = new ICAOCountry(
+    'XX',
+    'XES',
+    'Organization of Eastern Caribbean States (OECS)'
+  );
+  public static readonly XMP = new ICAOCountry(
+    'XX',
+    'XMP',
+    'Parliamentary Assembly of the Mediterranean (PAM)'
+  );
+  public static readonly XOM = new ICAOCountry(
+    'XO',
+    'XOM',
+    'Sovereign Military Order of Malta or one of its emissaries'
+  );
+  public static readonly XDC = new ICAOCountry(
+    'XX',
+    'XDC',
+    'Southern African Development Community'
+  );
+
+  private static readonly VALUES: ICAOCountry[] = [
+    ICAOCountry.DE,
+    ICAOCountry.RKS,
+    ICAOCountry.GBD,
+    ICAOCountry.GBN,
+    ICAOCountry.GBO,
+    ICAOCountry.GBP,
+    ICAOCountry.GBS,
+    ICAOCountry.XXA,
+    ICAOCountry.XXB,
+    ICAOCountry.XXC,
+    ICAOCountry.XXX,
+    ICAOCountry.EUE,
+    ICAOCountry.UNO,
+    ICAOCountry.UNA,
+    ICAOCountry.UNK,
+    ICAOCountry.XBA,
+    ICAOCountry.XIM,
+    ICAOCountry.XCC,
+    ICAOCountry.XCO,
+    ICAOCountry.XEC,
+    ICAOCountry.XPO,
+    ICAOCountry.XOM,
+  ];
+
+  private name: string;
+  private nationality: string;
+  private alpha2Code: string;
+  private alpha3Code: string;
+
+  /**
+   * Constructs a country.
+   *
+   * @param alpha2Code the 2-letter alpha code
+   * @param alpha3Code the 3-letter alpha code
+   * @param name a name for the country
+   * @param nationality a name for nationals of the country
+   */
+  constructor(
+    alpha2Code: string,
+    alpha3Code: string,
+    name: string,
+    nationality?: string
+  ) {
+    super();
+    this.alpha2Code = alpha2Code;
+    this.alpha3Code = alpha3Code;
+    this.name = name;
+    this.nationality = nationality || name;
+  }
+
+  /**
+   * Returns an ICAO country instance.
+   *
+   * @param alpha3Code a three-digit ICAO country code
+   *
+   * @return an ICAO country
+   */
+  public static getInstance(alpha3Code: string): Country {
+    for (const country of ICAOCountry.VALUES) {
+      if (country.alpha3Code === alpha3Code) {
+        return country;
+      }
+    }
+    try {
+      return Country.getInstance(alpha3Code);
+    } catch (e) {
+      /* NOTE: ignore this exception if it's not a legal 3 digit code. */
+      console.debug('Unknown country', e);
+    }
+    throw new Error('Illegal ICAO country alpha 3 code ' + alpha3Code);
+  }
+
+  public valueOf(): number {
+    return -1;
+  }
+
+  /**
+   * Returns the full name of the country.
+   *
+   * @return a country name
+   */
+  public getName(): string {
+    return this.name;
+  }
+
+  /**
+   * Returns the adjectival form corresponding to the country.
+   *
+   * @return the nationality
+   */
+  public getNationality(): string {
+    return this.nationality;
+  }
+
+  /**
+   * Returns the two-digit country code.
+   *
+   * @return a two-digit country code
+   */
+  public toAlpha2Code(): string {
+    return this.alpha2Code;
+  }
+
+  /**
+   * Returns the three-digit country code.
+   *
+   * @return a three-digit country code
+   */
+  public toAlpha3Code(): string {
+    return this.alpha3Code;
+  }
+}