@trustchex/react-native-sdk 1.161.0

package/src/Shared/EIDReader/smartcards/responseAPDU.ts

@@ -0,0 +1,44 @@
+import { Buffer } from 'buffer';
+
+export class ResponseAPDU {
+  private apdu: number[];
+
+  constructor(apdu: number[]) {
+    this.apdu = [...apdu];
+    this.check(this.apdu);
+  }
+
+  private check(apdu: number[]): void {
+    if (apdu.length < 2) {
+      throw new Error('ResponseAPDU must be at least 2 bytes long');
+    }
+  }
+
+  public getNr(): number {
+    return this.apdu.length - 2;
+  }
+
+  public getData(): number[] {
+    return this.apdu.slice(0, this.apdu.length - 2);
+  }
+
+  public getSW1(): number {
+    return this.apdu[this.apdu.length - 2] & 0xff;
+  }
+
+  public getSW2(): number {
+    return this.apdu[this.apdu.length - 1] & 0xff;
+  }
+
+  public getSW(): number {
+    return (this.getSW1() << 8) | this.getSW2();
+  }
+
+  public getBytes(): number[] {
+    return [...this.apdu];
+  }
+
+  public toString(): string {
+    return `ResponseAPDU: ${Buffer.from(this.apdu).toString('hex').toUpperCase()} bytes, SW=${this.getSW().toString(16)}`;
+  }
+}

package/src/Shared/EIDReader/tlv/asn1Constants.ts

@@ -0,0 +1,46 @@
+export abstract class ASN1Constants {
+  /** Universal tag class. */
+  public static UNIVERSAL_CLASS = 0; /* 00 x xxxxx */
+
+  /** Application tag class. */
+  public static APPLICATION_CLASS = 1; /* 01 x xxxxx */
+
+  /** Context specific tag class. */
+  public static CONTEXT_SPECIFIC_CLASS = 2; /* 10 x xxxxx */
+
+  /** Private tag class. */
+  public static PRIVATE_CLASS = 3; /* 11 x xxxxx */
+
+  /*
+   * Universal tag type (tag number).
+   * Rightmost 5 bits, should be prefixed
+   * with class indicator (2 bits) and
+   * primitive/constructed indicator (1 bit).
+   */
+
+  public static BOOLEAN_TYPE_TAG = 0x01; /* 00 0 00001, Section 8.2 of X.690. */
+  public static INTEGER_TYPE_TAG = 0x02; /* 00 0 00010, Section 8.3 of X.690. */
+  public static BIT_STRING_TYPE_TAG = 0x03; /* 00 x 00011, Section 8.6 of X.690. */
+  public static OCTET_STRING_TYPE_TAG = 0x04; /* xx x 00100 */
+  public static NULL_TYPE_TAG = 0x05; /* xx x 00101 */
+  public static OBJECT_IDENTIFIER_TYPE_TAG = 0x06; /* xx x 00110 */
+  public static OBJECT_DESCRIPTOR_TYPE_TAG = 0x07; /* xx x 00111 */
+  public static EXTERNAL_TYPE_TAG = 0x08; /* xx x 01000 */
+  public static REAL_TYPE_TAG = 0x09; /* xx x 01001 */
+  public static ENUMERATED_TYPE_TAG = 0x0a; /* xx x 01010 */
+  public static EMBEDDED_PDV_TYPE_TAG = 0x0b; /* xx x 01011 */
+  public static UTF8_STRING_TYPE_TAG = 0x0c; /* xx x 01100 */
+  public static SEQUENCE_TYPE_TAG = 0x10; /* 00 1 10000, Section 8.10 of X.690. */
+  public static SET_TYPE_TAG = 0x11; /* 00 1 10001 */
+  public static NUMERIC_STRING_TYPE_TAG = 0x12; /* xx x 10010 */
+  public static PRINTABLE_STRING_TYPE_TAG = 0x13; /* xx x 10011 */
+  public static T61_STRING_TYPE_TAG = 0x14; /* xx x 10100 */
+  public static IA5_STRING_TYPE_TAG = 0x16; /* xx x 10110 */
+  public static UTC_TIME_TYPE_TAG = 0x17; /* xx x 10111 */
+  public static GENERALIZED_TIME_TYPE_TAG = 0x18; /* xx x 11000 */
+  public static GRAPHIC_STRING_TYPE_TAG = 0x19; /* xx x 11001 */
+  public static VISIBLE_STRING_TYPE_TAG = 0x1a; /* xx x 11010 */
+  public static GENERAL_STRING_TYPE_TAG = 0x1b; /* xx x 11011 */
+  public static UNIVERSAL_STRING_TYPE_TAG = 0x1c; /* xx x 11100 */
+  public static BMP_STRING_TYPE_TAG = 0x1e; /* xx x 11110 */
+}

package/src/Shared/EIDReader/tlv/tlv.utils.ts

@@ -0,0 +1,201 @@
+import { ByteArrayInputStream } from '../java/byteArrayInputStream';
+import { ByteArrayOutputStream } from '../java/byteArrayOutputStream';
+import { ASN1Constants } from './asn1Constants';
+import { TLVInputStream } from './tlvInputStream';
+import { TLVOutputStream } from './tlvOutputStream';
+import { Buffer } from 'buffer';
+
+class TLVUtil extends ASN1Constants {
+  public static isPrimitive(tag: number): boolean {
+    let i = 3;
+    for (; i >= 0; i--) {
+      const mask = 0xff << (8 * i);
+      if ((tag & mask) !== 0x00) {
+        break;
+      }
+    }
+    const msByte = ((tag & (0xff << (8 * i))) >> (8 * i)) & 0xff;
+    return (msByte & 0x20) === 0x00;
+  }
+
+  public static getTagLength(tag: number): number {
+    return TLVUtil.getTagAsBytes(tag).length;
+  }
+
+  public static getLengthLength(length: number): number {
+    return TLVUtil.getLengthAsBytes(length).length;
+  }
+
+  /**
+   * The tag bytes of this object.
+   *
+   * @param tag the tag
+   *
+   * @return the tag bytes of this object.
+   */
+  public static getTagAsBytes(tag: number): number[] {
+    const out: number[] = [];
+    const byteCount = Math.floor(Math.log(tag) / Math.log(256)) + 1;
+    for (let i = 0; i < byteCount; i++) {
+      const pos = 8 * (byteCount - i - 1);
+      out.push((tag & (0xff << pos)) >> pos);
+    }
+    const tagBytes = out;
+    switch (TLVUtil.getTagClass(tag)) {
+      case TLVUtil.APPLICATION_CLASS:
+        tagBytes[0] |= 0x40;
+        break;
+      case TLVUtil.CONTEXT_SPECIFIC_CLASS:
+        tagBytes[0] |= 0x80;
+        break;
+      case TLVUtil.PRIVATE_CLASS:
+        tagBytes[0] |= 0xc0;
+        break;
+      default:
+        /* NOTE: Unsupported tag class. Now what? */
+        break;
+    }
+    if (!TLVUtil.isPrimitive(tag)) {
+      tagBytes[0] |= 0x20;
+    }
+    return tagBytes;
+  }
+
+  /**
+   * The length bytes of this object.
+   *
+   * @param length the length
+   *
+   * @return length of encoded value as bytes
+   */
+  public static getLengthAsBytes(length: number): number[] {
+    const out: number[] = [];
+    if (length < 0x80) {
+      /* short form */
+      out.push(length);
+    } else {
+      const byteCount = TLVUtil.log(length, 256);
+      out.push(0x80 | byteCount);
+      for (let i = 0; i < byteCount; i++) {
+        const pos = 8 * (byteCount - i - 1);
+        out.push((length & (0xff << pos)) >> pos);
+      }
+    }
+    return out;
+  }
+
+  /**
+   * TLV encodes an encoded data object with a tag.
+   *
+   * @param tag the tag
+   * @param data the data to encode
+   *
+   * @return the TLV encoded data
+   */
+  public static wrapDO(tag: number, data: number[]): Uint8Array {
+    if (data == null) {
+      throw new Error('Data to wrap is null');
+    }
+
+    const byteArrayOutputStream = new ByteArrayOutputStream();
+    try {
+      const tlvOutputStream = new TLVOutputStream(byteArrayOutputStream);
+      tlvOutputStream.writeTag(tag);
+      tlvOutputStream.writeValue(Uint8Array.from(data));
+      tlvOutputStream.flush();
+      tlvOutputStream.close();
+      return byteArrayOutputStream.toByteArray();
+    } catch (ioe) {
+      // Never happens.
+      throw new Error('Error writing stream');
+    } finally {
+      try {
+        byteArrayOutputStream.close();
+      } catch (ioe) {
+        console.debug('Error closing stream', ioe);
+      }
+    }
+  }
+
+  /**
+   * TLV decodes tagged TLV data object.
+   *
+   * @param expectedTag the tag to expect, an {@code IllegalArgumentException} will be throws if a different tag is read
+   * @param wrappedData the encoded data
+   *
+   * @return the decoded data
+   */
+  public static async unwrapDO(
+    expectedTag: number,
+    wrappedData: number[]
+  ): Promise<number[]> {
+    if (wrappedData == null || wrappedData.length < 2) {
+      throw new Error('Wrapped data is null or length < 2');
+    }
+
+    const byteArrayInputStream = new ByteArrayInputStream(
+      Buffer.from(wrappedData)
+    );
+    const tlvInputStream = new TLVInputStream(byteArrayInputStream);
+
+    try {
+      const actualTag = await tlvInputStream.readTag();
+      if (actualTag !== expectedTag) {
+        throw new Error(
+          `Expected tag ${expectedTag.toString(16)}, found tag ${actualTag.toString(16)}`
+        );
+      }
+
+      const length = await tlvInputStream.readLength();
+      const value = await tlvInputStream.readValue();
+      const result = new Array(length);
+      for (let i = 0; i < length; i++) {
+        result[i] = value[i];
+      }
+      return result;
+    } catch (ioe) {
+      // Never happens.
+      throw new Error('Error reading from stream');
+    } finally {
+      try {
+        tlvInputStream.close();
+        byteArrayInputStream.close();
+      } catch (ioe) {
+        console.debug('Error closing stream', ioe);
+      }
+    }
+  }
+
+  static getTagClass(tag: number): number {
+    let i = 3;
+    for (; i >= 0; i--) {
+      const mask = 0xff << (8 * i);
+      if ((tag & mask) !== 0x00) {
+        break;
+      }
+    }
+    const msByte = ((tag & (0xff << (8 * i))) >> (8 * i)) & 0xff;
+    switch (msByte & 0xc0) {
+      case 0x00:
+        return TLVUtil.UNIVERSAL_CLASS;
+      case 0x40:
+        return TLVUtil.APPLICATION_CLASS;
+      case 0x80:
+        return TLVUtil.CONTEXT_SPECIFIC_CLASS;
+      case 0xc0:
+      default:
+        return TLVUtil.PRIVATE_CLASS;
+    }
+  }
+
+  private static log(n: number, base: number): number {
+    let result = 0;
+    while (n > 0) {
+      n = n / base;
+      result++;
+    }
+    return result;
+  }
+}
+
+export default TLVUtil;

package/src/Shared/EIDReader/tlv/tlvInputState.ts

@@ -0,0 +1,186 @@
+export class TLVInputState {
+  private state: TLStruct[];
+  private isAtStartOfTag: boolean;
+  private isAtStartOfLength: boolean;
+  private isReadingValue: boolean;
+
+  constructor(
+    state: TLStruct[] = [],
+    isAtStartOfTag: boolean = true,
+    isAtStartOfLength: boolean = false,
+    isReadingValue: boolean = false
+  ) {
+    this.state = state;
+    this.isAtStartOfTag = isAtStartOfTag;
+    this.isAtStartOfLength = isAtStartOfLength;
+    this.isReadingValue = isReadingValue;
+  }
+
+  getState(): TLStruct[] {
+    return this.state;
+  }
+
+  getIsAtStartOfTag(): boolean {
+    return this.isAtStartOfTag;
+  }
+
+  getIsAtStartOfLength(): boolean {
+    return this.isAtStartOfLength;
+  }
+
+  getIsReadingValue(): boolean {
+    return this.isReadingValue;
+  }
+
+  getTag(): number {
+    if (this.state.length === 0) {
+      throw new Error('Tag not yet read.');
+    } else {
+      const currentObject = this.state[this.state.length - 1];
+      return currentObject.getTag();
+    }
+  }
+
+  getLength(): number {
+    if (this.state.length === 0) {
+      throw new Error('Length not yet known.');
+    } else {
+      const currentObject = this.state[this.state.length - 1];
+      return currentObject.getLength();
+    }
+  }
+
+  getValueBytesProcessed(): number {
+    const currentObject = this.state[this.state.length - 1];
+    return currentObject.getValueBytesProcessed();
+  }
+
+  getValueBytesLeft(): number {
+    if (this.state.length === 0) {
+      throw new Error('Length of value is unknown.');
+    } else {
+      const currentObject = this.state[this.state.length - 1];
+      const currentLength = currentObject.getLength();
+      const valueBytesRead = currentObject.getValueBytesProcessed();
+      return currentLength - valueBytesRead;
+    }
+  }
+
+  setTagProcessed(tag: number, byteCount: number): void {
+    const obj = new TLStruct(tag);
+    if (this.state.length > 0) {
+      const parent = this.state[this.state.length - 1];
+      parent.updateValueBytesProcessed(byteCount);
+    }
+
+    this.state.push(obj);
+    this.isAtStartOfTag = false;
+    this.isAtStartOfLength = true;
+    this.isReadingValue = false;
+  }
+
+  setDummyLengthProcessed(): void {
+    this.isAtStartOfTag = false;
+    this.isAtStartOfLength = false;
+    this.isReadingValue = true;
+  }
+
+  setLengthProcessed(length: number, byteCount: number): void {
+    if (length < 0) {
+      throw new Error(
+        `Cannot set negative length (length = ${length}, 0x${length.toString(16)} for tag ${this.getTag().toString(16)}).`
+      );
+    } else {
+      const obj = this.state.pop();
+      if (this.state.length > 0) {
+        const parent = this.state[this.state.length - 1];
+        parent.updateValueBytesProcessed(byteCount);
+      }
+
+      if (obj) {
+        obj.setLength(length);
+        this.state.push(obj);
+      }
+      this.isAtStartOfTag = false;
+      this.isAtStartOfLength = false;
+      this.isReadingValue = true;
+    }
+  }
+
+  updateValueBytesProcessed(byteCount: number): void {
+    if (this.state.length > 0) {
+      const currentObject = this.state[this.state.length - 1];
+      const bytesLeft =
+        currentObject.getLength() - currentObject.getValueBytesProcessed();
+      if (byteCount > bytesLeft) {
+        throw new Error(
+          `Cannot process ${byteCount} bytes! Only ${bytesLeft} bytes left in this TLV object ${currentObject}`
+        );
+      } else {
+        currentObject.updateValueBytesProcessed(byteCount);
+        const currentLength = currentObject.getLength();
+        if (currentObject.getValueBytesProcessed() === currentLength) {
+          this.state.pop();
+          this.updateValueBytesProcessed(currentLength);
+          this.isAtStartOfTag = true;
+          this.isAtStartOfLength = false;
+          this.isReadingValue = false;
+        } else {
+          this.isAtStartOfTag = false;
+          this.isAtStartOfLength = false;
+          this.isReadingValue = true;
+        }
+      }
+    }
+  }
+
+  public getDeepCopyOfState(): TLStruct[] {
+    const newStack: TLStruct[] = [];
+    for (const tlStruct of this.state) {
+      newStack.push(
+        new TLStruct(
+          tlStruct.getTag(),
+          tlStruct.getLength(),
+          tlStruct.getValueBytesProcessed()
+        )
+      );
+    }
+    return newStack;
+  }
+}
+
+class TLStruct {
+  private tag: number;
+  private length: number;
+  private valueBytesRead: number;
+
+  constructor(tag: number, length = Infinity, valueBytesRead = 0) {
+    this.tag = tag;
+    this.length = length;
+    this.valueBytesRead = valueBytesRead;
+  }
+
+  setLength(length: number): void {
+    this.length = length;
+  }
+
+  getTag(): number {
+    return this.tag;
+  }
+
+  getLength(): number {
+    return this.length;
+  }
+
+  getValueBytesProcessed(): number {
+    return this.valueBytesRead;
+  }
+
+  updateValueBytesProcessed(n: number): void {
+    this.valueBytesRead += n;
+  }
+
+  toString(): string {
+    return `[TLStruct ${this.tag.toString(16)}, ${this.length}, ${this.valueBytesRead}]`;
+  }
+}

package/src/Shared/EIDReader/tlv/tlvInputStream.ts

@@ -0,0 +1,207 @@
+import { ByteArrayInputStream } from '../java/byteArrayInputStream';
+import { DataInputStream } from '../java/dataInputStream';
+import { InputStream } from '../java/inputStream';
+import TLVUtil from './tlv.utils';
+import { TLVInputState } from './tlvInputState';
+
+export class TLVInputStream extends InputStream {
+  private static readonly MAX_BUFFER_LENGTH = 65535;
+
+  private readonly originalInputStream?: InputStream;
+  private inputStream: DataInputStream;
+  private bufferSize: number;
+  private state: TLVInputState;
+  private markedState: TLVInputState;
+
+  constructor(inputStream: InputStream) {
+    super();
+    this.bufferSize = 0;
+    try {
+      if (inputStream instanceof ByteArrayInputStream) {
+        this.bufferSize = inputStream.available();
+      }
+    } catch (ioe) {
+      console.debug('Exception reading from stream', ioe);
+    }
+    this.originalInputStream = inputStream;
+    this.inputStream =
+      inputStream instanceof DataInputStream
+        ? (inputStream as DataInputStream)
+        : new DataInputStream(inputStream);
+    this.state = new TLVInputState();
+    this.markedState = new TLVInputState();
+  }
+
+  public async readTag(): Promise<number> {
+    if (!this.state.getIsAtStartOfTag() && !this.state.getIsReadingValue()) {
+      throw new Error('Not at start of tag');
+    }
+    let tag = -1;
+    let bytesRead = 0;
+    try {
+      let b = await this.inputStream.readUnsignedByte();
+      bytesRead++;
+      while (b === 0x00 || b === 0xff) {
+        b = await this.inputStream.readUnsignedByte();
+        bytesRead++;
+      }
+      switch (b & 0x1f) {
+        case 0x1f:
+          tag = b;
+          b = await this.inputStream.readUnsignedByte();
+          bytesRead++;
+          while ((b & 0x80) === 0x80) {
+            tag <<= 8;
+            tag |= b & 0x7f;
+            b = await this.inputStream.readUnsignedByte();
+            bytesRead++;
+          }
+          tag <<= 8;
+          tag |= b & 0x7f;
+          break;
+        default:
+          tag = b;
+          break;
+      }
+      this.state.setTagProcessed(tag, bytesRead);
+      return tag;
+    } catch (e) {
+      throw e;
+    }
+  }
+
+  public async readLength(): Promise<number> {
+    try {
+      if (!this.state.getIsAtStartOfLength()) {
+        throw new Error('Not at start of length');
+      }
+      let bytesRead = 0;
+      let length = 0;
+      let b = await this.inputStream.readUnsignedByte();
+      bytesRead++;
+      if ((b & 0x80) === 0x00) {
+        length = b;
+      } else {
+        const count = b & 0x7f;
+        length = 0;
+        for (let i = 0; i < count; i++) {
+          b = await this.inputStream.readUnsignedByte();
+          bytesRead++;
+          length <<= 8;
+          length |= b;
+        }
+      }
+      this.state.setLengthProcessed(length, bytesRead);
+      return length;
+    } catch (e) {
+      throw e;
+    }
+  }
+
+  public async readValue(): Promise<number[]> {
+    try {
+      if (!this.state.getIsReadingValue()) {
+        throw new Error('Not yet processing value!');
+      }
+      const length = this.state.getLength();
+      const value: number[] = [];
+      for (let i = 0; i < length; i++) {
+        value.push(await this.inputStream.readUnsignedByte());
+      }
+      this.state.updateValueBytesProcessed(length);
+      return value;
+    } catch (e) {
+      throw e;
+    }
+  }
+
+  private async skipValue(): Promise<number> {
+    if (this.state.getIsAtStartOfTag()) {
+      return 0;
+    }
+    if (this.state.getIsAtStartOfLength()) {
+      return 0;
+    }
+    const bytesLeft = this.state.getValueBytesLeft();
+    return await this.skip(bytesLeft);
+  }
+
+  public async skipToTag(searchTag: number): Promise<void> {
+    while (true) {
+      let tag = -1;
+      if (this.state.getIsAtStartOfTag()) {
+      } else if (this.state.getIsAtStartOfLength()) {
+        await this.readLength();
+        if (TLVUtil.isPrimitive(this.state.getTag())) {
+          await this.skipValue();
+        }
+      } else {
+        if (TLVUtil.isPrimitive(this.state.getTag())) {
+          await this.skipValue();
+        }
+      }
+      tag = await this.readTag();
+      if (tag === searchTag) {
+        return;
+      }
+      if (TLVUtil.isPrimitive(tag)) {
+        const length = await this.readLength();
+        const skippedBytes = await this.skipValue();
+        if (skippedBytes >= length) {
+          continue;
+        } else {
+          break;
+        }
+      }
+    }
+  }
+
+  public available(): number {
+    return this.inputStream.available();
+  }
+
+  public async read(): Promise<number> {
+    const result = await this.inputStream.read();
+    if (result < 0) {
+      return -1;
+    }
+    this.state.updateValueBytesProcessed(1);
+    return result;
+  }
+
+  public async skip(n: number): Promise<number> {
+    if (n <= 0) {
+      return 0;
+    }
+    const result = await this.inputStream.skip(n);
+    this.state.updateValueBytesProcessed(result);
+    return result;
+  }
+
+  public mark(readLimit: number): void {
+    this.inputStream.mark(readLimit);
+    this.markedState = new TLVInputState(
+      this.state.getDeepCopyOfState(),
+      this.state.getIsAtStartOfTag(),
+      this.state.getIsAtStartOfLength(),
+      this.state.getIsReadingValue()
+    );
+  }
+
+  public markSupported(): boolean {
+    return this.inputStream.markSupported();
+  }
+
+  public reset(): void {
+    if (!this.markSupported()) {
+      throw new Error('mark/reset not supported');
+    }
+    this.inputStream.reset();
+    this.state = this.markedState;
+    this.markedState = new TLVInputState();
+  }
+
+  public close(): void {
+    this.inputStream.close();
+  }
+}