@trustchex/react-native-sdk 1.161.0

package/src/Shared/EIDReader/cbeff/iso781611Decoder.ts

@@ -0,0 +1,242 @@
+import { ByteArrayInputStream } from '../java/byteArrayInputStream';
+import { InputStream } from '../java/inputStream';
+import TLVUtil from '../tlv/tlv.utils';
+import { TLVInputStream } from '../tlv/tlvInputStream';
+import type { BiometricDataBlock } from './biometricDataBlock';
+import type { BiometricDataBlockDecoder } from './biometricDataBlockDecoder';
+import { CBEFFInfo } from './cbeffInfo';
+import { ComplexCBEFFInfo } from './complexCBEFFInfo';
+import { ISO781611 } from './iso781611';
+import { SimpleCBEFFInfo } from './simpleCBEFFInfo';
+import { StandardBiometricHeader } from './standardBiometricHeader';
+import { Buffer } from 'buffer';
+
+export class ISO781611Decoder<T extends BiometricDataBlock>
+  implements ISO781611
+{
+  private bdbDecoder: BiometricDataBlockDecoder<T>;
+
+  constructor(bdbDecoder: BiometricDataBlockDecoder<T>) {
+    this.bdbDecoder = bdbDecoder;
+  }
+
+  decode(inputStream: InputStream) {
+    return this.readBITGroup(inputStream);
+  }
+
+  private async readBITGroup(
+    inputStream: InputStream
+  ): Promise<ComplexCBEFFInfo | null> {
+    const tlvIn =
+      inputStream instanceof TLVInputStream
+        ? (inputStream as TLVInputStream)
+        : new TLVInputStream(inputStream);
+    const tag = await tlvIn.readTag();
+    if (tag !== ISO781611.BIOMETRIC_INFORMATION_GROUP_TEMPLATE_TAG) {
+      throw new Error(
+        `Expected tag ${ISO781611.BIOMETRIC_INFORMATION_GROUP_TEMPLATE_TAG.toString(16)}, found ${tag.toString(16)}`
+      );
+    }
+
+    const length = await tlvIn.readLength();
+    return await this.readBITGroupByTag(tag, length, inputStream);
+  }
+
+  private async readBITGroupByTag(
+    tag: number,
+    length: number,
+    inputStream: InputStream
+  ): Promise<ComplexCBEFFInfo | null> {
+    const tlvIn =
+      inputStream instanceof TLVInputStream
+        ? (inputStream as TLVInputStream)
+        : new TLVInputStream(inputStream);
+    const result = new ComplexCBEFFInfo();
+    if (tag !== ISO781611.BIOMETRIC_INFORMATION_GROUP_TEMPLATE_TAG) {
+      throw new Error(
+        `Expected tag ${ISO781611.BIOMETRIC_INFORMATION_GROUP_TEMPLATE_TAG.toString(16)}, found ${tag.toString(16)}`
+      );
+    }
+    const bitCountTag = await tlvIn.readTag();
+    if (bitCountTag !== ISO781611.BIOMETRIC_INFO_COUNT_TAG) {
+      throw new Error(
+        `Expected tag BIOMETRIC_INFO_COUNT_TAG (${ISO781611.BIOMETRIC_INFO_COUNT_TAG.toString(16)}) in CBEFF structure, found ${bitCountTag.toString(16)}`
+      );
+    }
+    const bitCountLength = await tlvIn.readLength();
+    if (bitCountLength !== 1) {
+      throw new Error(
+        `BIOMETRIC_INFO_COUNT should have length 1, found length ${bitCountLength}`
+      );
+    }
+    const bitCount = (await tlvIn.readValue())[0] & 0xff;
+    for (let i = 0; i < bitCount; i++) {
+      const bit = await this.readBIT(inputStream, i);
+      if (bit !== null) {
+        result.add(bit);
+      }
+    }
+
+    return result;
+  }
+
+  private async readBIT(
+    inputStream: InputStream,
+    index: number
+  ): Promise<CBEFFInfo | null> {
+    const tlvIn =
+      inputStream instanceof TLVInputStream
+        ? (inputStream as TLVInputStream)
+        : new TLVInputStream(inputStream);
+    const tag = await tlvIn.readTag();
+    const length = await tlvIn.readLength();
+    return await this.readBITByTag(tag, length, inputStream, index);
+  }
+
+  private async readBITByTag(
+    tag: number,
+    length: number,
+    inputStream: InputStream,
+    index: number
+  ): Promise<CBEFFInfo | null> {
+    const tlvIn =
+      inputStream instanceof TLVInputStream
+        ? (inputStream as TLVInputStream)
+        : new TLVInputStream(inputStream);
+    if (tag !== ISO781611.BIOMETRIC_INFORMATION_TEMPLATE_TAG) {
+      throw new Error(
+        `Expected tag BIOMETRIC_INFORMATION_TEMPLATE_TAG (${ISO781611.BIOMETRIC_INFORMATION_TEMPLATE_TAG.toString(16)}), found ${tag.toString(16)}, index is ${index}`
+      );
+    }
+
+    const bhtTag = await tlvIn.readTag();
+    const bhtLength = await tlvIn.readLength();
+
+    if (bhtTag === ISO781611.SMT_TAG) {
+      this.readStaticallyProtectedBIT(inputStream, bhtTag, bhtLength, index);
+    } else if ((bhtTag & 0xa0) === 0xa0) {
+      const sbh = await this.readBHT(inputStream, bhtTag, bhtLength, index);
+      const bdb = await this.readBiometricDataBlock(inputStream, sbh, index);
+      return new SimpleCBEFFInfo<BiometricDataBlock>(bdb);
+    } else {
+      throw new Error(`Unsupported template tag: ${bhtTag.toString(16)}`);
+    }
+
+    return null;
+  }
+
+  private async readBHT(
+    inputStream: InputStream,
+    bhtTag: number,
+    bhtLength: number,
+    index: number
+  ): Promise<StandardBiometricHeader> {
+    const tlvIn =
+      inputStream instanceof TLVInputStream
+        ? (inputStream as TLVInputStream)
+        : new TLVInputStream(inputStream);
+    const expectedBHTTag =
+      (ISO781611.BIOMETRIC_HEADER_TEMPLATE_BASE_TAG + index) & 0xff;
+    if (bhtTag !== expectedBHTTag) {
+      console.debug(
+        `Expected tag ${expectedBHTTag.toString(16)}, found ${bhtTag.toString(16)}`
+      );
+    }
+    const elements: Map<number, Uint8Array> = new Map<number, Uint8Array>();
+    let bytesRead = 0;
+    while (bytesRead < bhtLength) {
+      const tag = await tlvIn.readTag();
+      bytesRead += TLVUtil.getTagLength(tag);
+      const length = await tlvIn.readLength();
+      bytesRead += TLVUtil.getLengthLength(length);
+      const value = new Uint8Array(await tlvIn.readValue());
+      bytesRead += value.length;
+      elements.set(tag, value);
+    }
+    return new StandardBiometricHeader(elements);
+  }
+
+  private async readStaticallyProtectedBIT(
+    inputStream: InputStream,
+    tag: number,
+    length: number,
+    index: number
+  ): Promise<void> {
+    const decodedSMTValue = Buffer.from(
+      (await this.decodeSMTValue(inputStream)) || new Uint8Array()
+    );
+    const tlvBHTIn = new TLVInputStream(
+      new ByteArrayInputStream(decodedSMTValue)
+    );
+    try {
+      const headerTemplateTag = await tlvBHTIn.readTag();
+      const headerTemplateLength = await tlvBHTIn.readLength();
+      const sbh = await this.readBHT(
+        tlvBHTIn,
+        headerTemplateTag,
+        headerTemplateLength,
+        index
+      );
+      const biometricDataBlockIn = new ByteArrayInputStream(decodedSMTValue);
+      await this.readBiometricDataBlock(biometricDataBlockIn, sbh, index);
+    } finally {
+      tlvBHTIn.close();
+    }
+  }
+
+  private async decodeSMTValue(
+    inputStream: InputStream
+  ): Promise<Uint8Array | null> {
+    const tlvIn =
+      inputStream instanceof TLVInputStream
+        ? (inputStream as TLVInputStream)
+        : new TLVInputStream(inputStream);
+    const doTag = await tlvIn.readTag();
+    const doLength = await tlvIn.readLength();
+    switch (doTag) {
+      case ISO781611.SMT_DO_PV:
+        return Uint8Array.from(await tlvIn.readValue());
+      case ISO781611.SMT_DO_CG:
+        throw new Error(
+          'Access denied. Biometric Information Template is statically protected.'
+        );
+      case ISO781611.SMT_DO_CC:
+        let skippedBytes = 0;
+        while (skippedBytes < doLength) {
+          skippedBytes += await tlvIn.skip(doLength);
+        }
+        return null;
+      case ISO781611.SMT_DO_DS:
+        skippedBytes = 0;
+        while (skippedBytes < doLength) {
+          skippedBytes += await tlvIn.skip(doLength);
+        }
+        return null;
+      default:
+        console.info(`Unsupported data object tag ${doTag.toString(16)}`);
+        return null;
+    }
+  }
+
+  private async readBiometricDataBlock(
+    inputStream: InputStream,
+    sbh: StandardBiometricHeader,
+    index: number
+  ): Promise<BiometricDataBlock> {
+    const tlvIn =
+      inputStream instanceof TLVInputStream
+        ? (inputStream as TLVInputStream)
+        : new TLVInputStream(inputStream);
+    const bioDataBlockTag = await tlvIn.readTag();
+    if (
+      bioDataBlockTag !== ISO781611.BIOMETRIC_DATA_BLOCK_TAG &&
+      bioDataBlockTag !== ISO781611.BIOMETRIC_DATA_BLOCK_CONSTRUCTED_TAG
+    ) {
+      throw new Error(
+        `Expected tag BIOMETRIC_DATA_BLOCK_TAG (${ISO781611.BIOMETRIC_DATA_BLOCK_TAG.toString(16)}) or BIOMETRIC_DATA_BLOCK_TAG_ALT (${ISO781611.BIOMETRIC_DATA_BLOCK_CONSTRUCTED_TAG.toString(16)}), found ${bioDataBlockTag.toString(16)}`
+      );
+    }
+    const length = await tlvIn.readLength();
+    return await this.bdbDecoder.decode(inputStream, sbh, index, length);
+  }
+}

package/src/Shared/EIDReader/cbeff/iso781611Encoder.ts

@@ -0,0 +1,91 @@
+import { OutputStream } from '../java/outputStream';
+import { TLVOutputStream } from '../tlv/tlvOutputStream';
+import type { BiometricDataBlock } from './biometricDataBlock';
+import type { BiometricDataBlockEncoder } from './biometricDataBlockEncoder';
+import { CBEFFInfo } from './cbeffInfo';
+import { ComplexCBEFFInfo } from './complexCBEFFInfo';
+import { ISO781611 } from './iso781611';
+import { SimpleCBEFFInfo } from './simpleCBEFFInfo';
+
+export class ISO781611Encoder<B extends BiometricDataBlock>
+  implements ISO781611
+{
+  private bdbEncoder: BiometricDataBlockEncoder<B>;
+
+  constructor(bdbEncoder: BiometricDataBlockEncoder<B>) {
+    this.bdbEncoder = bdbEncoder;
+  }
+
+  public encode(cbeffInfo: CBEFFInfo, outputStream: OutputStream): void {
+    if (cbeffInfo instanceof SimpleCBEFFInfo) {
+      this.writeBITGroup([cbeffInfo], outputStream);
+    } else if (cbeffInfo instanceof ComplexCBEFFInfo) {
+      const complexCBEFFInfo = cbeffInfo as ComplexCBEFFInfo;
+      this.writeBITGroup(complexCBEFFInfo.getSubRecords(), outputStream);
+    }
+  }
+
+  private writeBITGroup(
+    records: CBEFFInfo[],
+    outputStream: OutputStream
+  ): void {
+    const tlvOut =
+      outputStream instanceof TLVOutputStream
+        ? outputStream
+        : new TLVOutputStream(outputStream);
+    tlvOut.writeTag(ISO781611.BIOMETRIC_INFORMATION_GROUP_TEMPLATE_TAG);
+    tlvOut.writeTag(ISO781611.BIOMETRIC_INFO_COUNT_TAG);
+    const count = records.length;
+    tlvOut.writeValue(Uint8Array.from([count]));
+
+    for (let index = 0; index < count; index++) {
+      const simpleCBEFFInfo = records[index] as SimpleCBEFFInfo<B>;
+      this.writeBIT(tlvOut, index, simpleCBEFFInfo);
+    }
+    tlvOut.writeValueEnd();
+  }
+
+  private writeBIT(
+    tlvOutputStream: TLVOutputStream,
+    index: number,
+    cbeffInfo: SimpleCBEFFInfo<B>
+  ): void {
+    tlvOutputStream.writeTag(ISO781611.BIOMETRIC_INFORMATION_TEMPLATE_TAG);
+    this.writeBHT(tlvOutputStream, index, cbeffInfo);
+    this.writeBiometricDataBlock(
+      tlvOutputStream,
+      cbeffInfo.getBiometricDataBlock()
+    );
+    tlvOutputStream.writeValueEnd();
+  }
+
+  private writeBHT(
+    tlvOutputStream: TLVOutputStream,
+    index: number,
+    cbeffInfo: SimpleCBEFFInfo<B>
+  ): void {
+    tlvOutputStream.writeTag(
+      (ISO781611.BIOMETRIC_HEADER_TEMPLATE_BASE_TAG + index) & 0xff
+    );
+
+    const bdb = cbeffInfo.getBiometricDataBlock();
+
+    const sbh = bdb.getStandardBiometricHeader();
+    const elements = sbh.getElements();
+    for (const [key, value] of elements) {
+      tlvOutputStream.writeTag(key);
+      tlvOutputStream.writeValue(value);
+    }
+    tlvOutputStream.writeValueEnd();
+  }
+
+  private writeBiometricDataBlock(
+    tlvOutputStream: TLVOutputStream,
+    bdb: B
+  ): void {
+    tlvOutputStream.writeTag(ISO781611.BIOMETRIC_DATA_BLOCK_TAG);
+
+    this.bdbEncoder.encode(bdb, tlvOutputStream);
+    tlvOutputStream.writeValueEnd();
+  }
+}

package/src/Shared/EIDReader/cbeff/simpleCBEFFInfo.ts

@@ -0,0 +1,26 @@
+import type { BiometricDataBlock } from './biometricDataBlock';
+import { CBEFFInfo } from './cbeffInfo';
+
+export class SimpleCBEFFInfo<B extends BiometricDataBlock>
+  implements CBEFFInfo
+{
+  private bdb: B;
+
+  /**
+   * Constructs a simple CBEFF info from the given BDB.
+   *
+   * @param bdb a biometric data block
+   */
+  constructor(bdb: B) {
+    this.bdb = bdb;
+  }
+
+  /**
+   * Returns the biometric data block from this simple CBEFF info.
+   *
+   * @return a biometric data block
+   */
+  getBiometricDataBlock(): B {
+    return this.bdb;
+  }
+}

package/src/Shared/EIDReader/cbeff/standardBiometricHeader.ts

@@ -0,0 +1,116 @@
+export class StandardBiometricHeader {
+  private elements: Map<number, Uint8Array>;
+
+  /**
+   * Constructs a standard biometric header.
+   *
+   * @param elements the elements, consisting of a tag and value
+   */
+  constructor(elements: Map<number, Uint8Array>) {
+    this.elements = new Map<number, Uint8Array>(elements);
+  }
+
+  /**
+   * Returns the elements of this standard biometric header.
+   *
+   * @return the elements, each consisting of a tag and value
+   */
+  getElements(): Map<number, Uint8Array> {
+    return new Map<number, Uint8Array>(this.elements);
+  }
+
+  /**
+   * Determines whether the two maps have equal entry sets.
+   *
+   * @param elements1 the first map
+   * @param elements2 the second map
+   *
+   * @return a boolean indicating equality
+   */
+  private static equals(
+    elements1: Map<number, Uint8Array>,
+    elements2: Map<number, Uint8Array>
+  ): boolean {
+    if (elements1 == null && elements2 != null) {
+      return false;
+    }
+    if (elements1 != null && elements2 == null) {
+      return false;
+    }
+
+    if (elements1 === elements2) {
+      return true;
+    }
+
+    if (!this.areMapsEqual(elements1, elements2)) {
+      return false;
+    }
+
+    for (const [key, bytes] of elements1.entries()) {
+      const otherBytes = elements2.get(key);
+      if (!this.areArraysEqual(bytes, otherBytes)) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  /**
+   * Determines whether two maps are equal.
+   *
+   * @param map1 the first map
+   * @param map2 the second map
+   *
+   * @return a boolean indicating equality
+   */
+  private static areMapsEqual(
+    map1: Map<number, Uint8Array>,
+    map2: Map<number, Uint8Array>
+  ): boolean {
+    if (map1.size !== map2.size) {
+      return false;
+    }
+
+    for (const [key, value] of map1.entries()) {
+      if (!map2.has(key) || !this.areArraysEqual(value, map2.get(key))) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  /**
+   * Determines whether two arrays are equal.
+   *
+   * @param array1 the first array
+   * @param array2 the second array
+   *
+   * @return a boolean indicating equality
+   */
+  private static areArraysEqual(
+    array1?: Uint8Array,
+    array2?: Uint8Array
+  ): boolean {
+    if (!array1 || !array2) {
+      return false;
+    }
+
+    if (array1 === array2) {
+      return true;
+    }
+
+    if (array1.length !== array2.length) {
+      return false;
+    }
+
+    for (let i = 0; i < array1.length; i++) {
+      if (array1[i] !== array2[i]) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+}

package/src/Shared/EIDReader/cert/cvcPrincipal.ts

@@ -0,0 +1,63 @@
+import { Country } from '../data/country';
+import { ICAOCountry } from '../lds/icao/icaoCountry';
+
+export class CVCPrincipal {
+  private country: Country;
+  private mnemonic: string;
+  private seqNumber: string;
+
+  constructor(name: string);
+  constructor(country: Country, mnemonic: string, seqNumber: string);
+  constructor(arg1: string | Country, mnemonic?: string, seqNumber?: string) {
+    if (typeof arg1 === 'string') {
+      const name = arg1;
+      if (name === null || name.length < 7 || name.length > 16) {
+        throw new Error(
+          `Name should be <Country (2F)><Mnemonic (9V)><SeqNum (5F)> formatted, found "${name}"`
+        );
+      }
+
+      const alpha2Code = name.substring(0, 2).toUpperCase();
+      try {
+        this.country = Country.getInstance(alpha2Code);
+      } catch (iae) {
+        console.error(`Could not find country for ${alpha2Code}`, iae);
+        this.country = new ICAOCountry(alpha2Code, 'Unknown', 'Unknown');
+      }
+
+      this.mnemonic = name.substring(2, name.length - 5);
+      this.seqNumber = name.substring(name.length - 5);
+    } else {
+      if (!mnemonic || mnemonic.length > 9) {
+        throw new Error('Wrong length mnemonic');
+      }
+      if (!seqNumber || seqNumber.length !== 5) {
+        throw new Error('Wrong length seqNumber');
+      }
+
+      this.country = arg1;
+      this.mnemonic = mnemonic;
+      this.seqNumber = seqNumber;
+    }
+  }
+
+  public getName(): string {
+    return `${this.country.toAlpha2Code()}${this.mnemonic}${this.seqNumber}`;
+  }
+
+  public toString(): string {
+    return `${this.country.toAlpha2Code()}/${this.mnemonic}/${this.seqNumber}`;
+  }
+
+  public getCountry(): Country {
+    return this.country;
+  }
+
+  public getMnemonic(): string {
+    return this.mnemonic;
+  }
+
+  public getSeqNumber(): string {
+    return this.seqNumber;
+  }
+}

package/src/Shared/EIDReader/data/country.ts

@@ -0,0 +1,76 @@
+import { ISOCountry } from './isoCountry';
+import { UnicodeCountry } from './unicodeCountry';
+
+export abstract class Country {
+  private static readonly SUB_CLASSES: any[] = [ISOCountry, UnicodeCountry];
+
+  public abstract valueOf(): number;
+  public abstract getName(): string;
+  public abstract getNationality(): string;
+  public abstract toAlpha2Code(): string;
+  public abstract toAlpha3Code(): string;
+
+  public static getInstance(code: number | string): Country {
+    if (typeof code === 'number') {
+      const values = Country.values();
+      for (const country of values) {
+        if (country.valueOf() === code) {
+          return country;
+        }
+      }
+      throw new Error('Illegal country code ' + code.toString(16));
+    } else if (typeof code === 'string') {
+      code = code.trim();
+      switch (code.length) {
+        case 2:
+          return Country.fromAlpha2(code);
+        case 3:
+          return Country.fromAlpha3(code);
+        default:
+          throw new Error('Illegal country code ' + code);
+      }
+    } else {
+      throw new Error('Illegal country code');
+    }
+  }
+
+  public static values(): Country[] {
+    const result: Country[] = [];
+    for (const subClass of Country.SUB_CLASSES) {
+      if (Country.isAssignable(subClass)) {
+        try {
+          const method = subClass.values;
+          const subClassValues = method.call(null);
+          result.push(...subClassValues);
+        } catch (e) {
+          console.debug(`Exception: ${e}`);
+        }
+      }
+    }
+    return result;
+  }
+
+  private static fromAlpha2(code: string): Country {
+    const values = Country.values();
+    for (const country of values) {
+      if (country.toAlpha2Code() === code) {
+        return country;
+      }
+    }
+    throw new Error('Unknown country code ' + code);
+  }
+
+  private static fromAlpha3(code: string): Country {
+    const values = Country.values();
+    for (const country of values) {
+      if (country.toAlpha3Code() === code) {
+        return country;
+      }
+    }
+    throw new Error('Unknown country code ' + code);
+  }
+
+  private static isAssignable(subClass: typeof Country): boolean {
+    return subClass.prototype instanceof Country;
+  }
+}

package/src/Shared/EIDReader/data/gender.ts

@@ -0,0 +1,36 @@
+export class Gender {
+  public static MALE = new Gender(1, 'M');
+  public static FEMALE = new Gender(2, 'F');
+  public static UNKNOWN = new Gender(255, 'U');
+  public static UNSPECIFIED = new Gender(0, 'X');
+
+  private code: number;
+  private strCode: string;
+
+  constructor(code: number, strCode: string) {
+    this.code = code;
+    this.strCode = strCode;
+  }
+
+  getCode(): number {
+    return this.code;
+  }
+
+  getStrCode(): string {
+    return this.strCode;
+  }
+
+  static toGender(code: number) {
+    for (const value of Gender.values()) {
+      if (value.getCode() === code) {
+        return value;
+      }
+    }
+
+    return Gender.UNKNOWN;
+  }
+
+  static values() {
+    return [Gender.MALE, Gender.FEMALE, Gender.UNKNOWN, Gender.UNSPECIFIED];
+  }
+}