@trustchex/react-native-sdk 1.161.0

package/lib/module/Shared/EIDReader/tlv/tlv.utils.js

@@ -0,0 +1,186 @@
+"use strict";
+
+import { ByteArrayInputStream } from "../java/byteArrayInputStream.js";
+import { ByteArrayOutputStream } from "../java/byteArrayOutputStream.js";
+import { ASN1Constants } from "./asn1Constants.js";
+import { TLVInputStream } from "./tlvInputStream.js";
+import { TLVOutputStream } from "./tlvOutputStream.js";
+import { Buffer } from 'buffer';
+class TLVUtil extends ASN1Constants {
+  static isPrimitive(tag) {
+    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;
+  }
+  static getTagLength(tag) {
+    return TLVUtil.getTagAsBytes(tag).length;
+  }
+  static getLengthLength(length) {
+    return TLVUtil.getLengthAsBytes(length).length;
+  }
+
+  /**
+   * The tag bytes of this object.
+   *
+   * @param tag the tag
+   *
+   * @return the tag bytes of this object.
+   */
+  static getTagAsBytes(tag) {
+    const out = [];
+    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
+   */
+  static getLengthAsBytes(length) {
+    const out = [];
+    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
+   */
+  static wrapDO(tag, data) {
+    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
+   */
+  static async unwrapDO(expectedTag, wrappedData) {
+    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) {
+    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;
+    }
+  }
+  static log(n, base) {
+    let result = 0;
+    while (n > 0) {
+      n = n / base;
+      result++;
+    }
+    return result;
+  }
+}
+export default TLVUtil;

package/lib/module/Shared/EIDReader/tlv/tlvInputState.js

@@ -0,0 +1,141 @@
+"use strict";
+
+export class TLVInputState {
+  constructor(state = [], isAtStartOfTag = true, isAtStartOfLength = false, isReadingValue = false) {
+    this.state = state;
+    this.isAtStartOfTag = isAtStartOfTag;
+    this.isAtStartOfLength = isAtStartOfLength;
+    this.isReadingValue = isReadingValue;
+  }
+  getState() {
+    return this.state;
+  }
+  getIsAtStartOfTag() {
+    return this.isAtStartOfTag;
+  }
+  getIsAtStartOfLength() {
+    return this.isAtStartOfLength;
+  }
+  getIsReadingValue() {
+    return this.isReadingValue;
+  }
+  getTag() {
+    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() {
+    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() {
+    const currentObject = this.state[this.state.length - 1];
+    return currentObject.getValueBytesProcessed();
+  }
+  getValueBytesLeft() {
+    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, byteCount) {
+    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() {
+    this.isAtStartOfTag = false;
+    this.isAtStartOfLength = false;
+    this.isReadingValue = true;
+  }
+  setLengthProcessed(length, byteCount) {
+    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) {
+    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;
+        }
+      }
+    }
+  }
+  getDeepCopyOfState() {
+    const newStack = [];
+    for (const tlStruct of this.state) {
+      newStack.push(new TLStruct(tlStruct.getTag(), tlStruct.getLength(), tlStruct.getValueBytesProcessed()));
+    }
+    return newStack;
+  }
+}
+class TLStruct {
+  constructor(tag, length = Infinity, valueBytesRead = 0) {
+    this.tag = tag;
+    this.length = length;
+    this.valueBytesRead = valueBytesRead;
+  }
+  setLength(length) {
+    this.length = length;
+  }
+  getTag() {
+    return this.tag;
+  }
+  getLength() {
+    return this.length;
+  }
+  getValueBytesProcessed() {
+    return this.valueBytesRead;
+  }
+  updateValueBytesProcessed(n) {
+    this.valueBytesRead += n;
+  }
+  toString() {
+    return `[TLStruct ${this.tag.toString(16)}, ${this.length}, ${this.valueBytesRead}]`;
+  }
+}

package/lib/module/Shared/EIDReader/tlv/tlvInputStream.js

@@ -0,0 +1,180 @@
+"use strict";
+
+import { ByteArrayInputStream } from "../java/byteArrayInputStream.js";
+import { DataInputStream } from "../java/dataInputStream.js";
+import { InputStream } from "../java/inputStream.js";
+import TLVUtil from "./tlv.utils.js";
+import { TLVInputState } from "./tlvInputState.js";
+export class TLVInputStream extends InputStream {
+  static MAX_BUFFER_LENGTH = 65535;
+  constructor(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 : new DataInputStream(inputStream);
+    this.state = new TLVInputState();
+    this.markedState = new TLVInputState();
+  }
+  async readTag() {
+    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;
+    }
+  }
+  async readLength() {
+    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;
+    }
+  }
+  async readValue() {
+    try {
+      if (!this.state.getIsReadingValue()) {
+        throw new Error('Not yet processing value!');
+      }
+      const length = this.state.getLength();
+      const value = [];
+      for (let i = 0; i < length; i++) {
+        value.push(await this.inputStream.readUnsignedByte());
+      }
+      this.state.updateValueBytesProcessed(length);
+      return value;
+    } catch (e) {
+      throw e;
+    }
+  }
+  async skipValue() {
+    if (this.state.getIsAtStartOfTag()) {
+      return 0;
+    }
+    if (this.state.getIsAtStartOfLength()) {
+      return 0;
+    }
+    const bytesLeft = this.state.getValueBytesLeft();
+    return await this.skip(bytesLeft);
+  }
+  async skipToTag(searchTag) {
+    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;
+        }
+      }
+    }
+  }
+  available() {
+    return this.inputStream.available();
+  }
+  async read() {
+    const result = await this.inputStream.read();
+    if (result < 0) {
+      return -1;
+    }
+    this.state.updateValueBytesProcessed(1);
+    return result;
+  }
+  async skip(n) {
+    if (n <= 0) {
+      return 0;
+    }
+    const result = await this.inputStream.skip(n);
+    this.state.updateValueBytesProcessed(result);
+    return result;
+  }
+  mark(readLimit) {
+    this.inputStream.mark(readLimit);
+    this.markedState = new TLVInputState(this.state.getDeepCopyOfState(), this.state.getIsAtStartOfTag(), this.state.getIsAtStartOfLength(), this.state.getIsReadingValue());
+  }
+  markSupported() {
+    return this.inputStream.markSupported();
+  }
+  reset() {
+    if (!this.markSupported()) {
+      throw new Error('mark/reset not supported');
+    }
+    this.inputStream.reset();
+    this.state = this.markedState;
+    this.markedState = new TLVInputState();
+  }
+  close() {
+    this.inputStream.close();
+  }
+}

package/lib/module/Shared/EIDReader/tlv/tlvOutputState.js

@@ -0,0 +1,186 @@
+"use strict";
+
+import tlvUtils from "./tlv.utils.js";
+export class TLVOutputState {
+  constructor() {
+    this.state = [];
+    this.isAtStartOfTag = true;
+    this.isAtStartOfLength = false;
+    this.isReadingValue = false;
+  }
+  getIsAtStartOfTag() {
+    return this.isAtStartOfTag;
+  }
+  getIsAtStartOfLength() {
+    return this.isAtStartOfLength;
+  }
+  isProcessingValue() {
+    return this.isReadingValue;
+  }
+  getTag() {
+    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() {
+    if (this.state.length === 0) {
+      throw new Error('Length not yet known.');
+    } else {
+      const currentObject = this.state[this.state.length - 1];
+      const length = currentObject.getLength();
+      if (length < 0) {
+        throw new Error('Length not yet known.');
+      } else {
+        return length;
+      }
+    }
+  }
+  getValueBytesProcessed() {
+    const currentObject = this.state[this.state.length - 1];
+    return currentObject.getValueBytesProcessed();
+  }
+  getValueBytesLeft() {
+    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) {
+    const obj = new TLVStruct(tag);
+    if (this.state.length !== 0) {
+      const parent = this.state[this.state.length - 1];
+      const tagBytes = tlvUtils.getTagAsBytes(tag);
+      parent.write(tagBytes, 0, tagBytes.length);
+    }
+    this.state.push(obj);
+    this.isAtStartOfTag = false;
+    this.isAtStartOfLength = true;
+    this.isReadingValue = false;
+  }
+  setDummyLengthProcessed() {
+    this.isAtStartOfTag = false;
+    this.isAtStartOfLength = false;
+    this.isReadingValue = true;
+  }
+  isDummyLengthSet() {
+    if (this.state.length === 0) {
+      return false;
+    } else {
+      return !this.state[this.state.length - 1].getIsLengthSet();
+    }
+  }
+  setLengthProcessed(length) {
+    if (length < 0) {
+      throw new Error(`Cannot set negative length (length = ${length}).`);
+    } else {
+      const obj = this.state.pop();
+      if (this.state.length !== 0) {
+        const parent = this.state[this.state.length - 1];
+        const lengthBytes = tlvUtils.getLengthAsBytes(length);
+        parent.write(lengthBytes, 0, lengthBytes.length);
+      }
+      if (obj) {
+        obj.setLength(length);
+        this.state.push(obj);
+      }
+      this.isAtStartOfTag = false;
+      this.isAtStartOfLength = false;
+      this.isReadingValue = true;
+    }
+  }
+  updatePreviousLength(byteCount) {
+    if (this.state.length !== 0) {
+      const currentObject = this.state[this.state.length - 1];
+      if (!currentObject.getIsLengthSet() || currentObject.getLength() !== byteCount) {
+        currentObject.setLength(byteCount);
+        if (currentObject.getValueBytesProcessed() === currentObject.getLength()) {
+          this.state.pop();
+          const lengthBytes = tlvUtils.getLengthAsBytes(byteCount);
+          const value = currentObject.getValue();
+          this.updateValueBytesProcessed(lengthBytes, 0, lengthBytes.length);
+          this.updateValueBytesProcessed(value, 0, value.length);
+          this.isAtStartOfTag = true;
+          this.isAtStartOfLength = false;
+          this.isReadingValue = false;
+        }
+      }
+    }
+  }
+  updateValueBytesProcessed(bytes, offset, length) {
+    if (this.state.length !== 0) {
+      const currentObject = this.state[this.state.length - 1];
+      const bytesLeft = currentObject.getLength() - currentObject.getValueBytesProcessed();
+      if (length > bytesLeft) {
+        throw new Error(`Cannot process ${length} bytes! Only ${bytesLeft} bytes left in this TLV object ${currentObject}`);
+      } else {
+        currentObject.write(bytes, offset, length);
+        if (currentObject.getValueBytesProcessed() === currentObject.getLength()) {
+          this.state.pop();
+          this.updateValueBytesProcessed(currentObject.getValue(), 0, currentObject.getLength());
+          this.isAtStartOfTag = true;
+          this.isAtStartOfLength = false;
+          this.isReadingValue = false;
+        } else {
+          this.isAtStartOfTag = false;
+          this.isAtStartOfLength = false;
+          this.isReadingValue = true;
+        }
+      }
+    }
+  }
+  getValue() {
+    if (this.state.length === 0) {
+      throw new Error('Cannot get value yet.');
+    } else {
+      return this.state[this.state.length - 1].getValue();
+    }
+  }
+  toString() {
+    return this.state.toString();
+  }
+  canBeWritten() {
+    for (const stackFrame of this.state) {
+      if (!stackFrame.getIsLengthSet()) {
+        return false;
+      }
+    }
+    return true;
+  }
+}
+class TLVStruct {
+  constructor(tag, length = Number.MAX_VALUE, isLengthSet = false, value = null) {
+    this.tag = tag;
+    this.length = length;
+    this.isLengthSet = isLengthSet;
+    this.value = value ? [...value] : [];
+  }
+  setLength(length) {
+    this.length = length;
+    this.isLengthSet = true;
+  }
+  getTag() {
+    return this.tag;
+  }
+  getLength() {
+    return this.length;
+  }
+  getIsLengthSet() {
+    return this.isLengthSet;
+  }
+  getValueBytesProcessed() {
+    return this.value.length;
+  }
+  getValue() {
+    return [...this.value];
+  }
+  write(bytes, offset, length) {
+    this.value.push(...bytes.slice(offset, offset + length));
+  }
+}