@trustchex/react-native-sdk 1.161.0

package/src/Shared/EIDReader/java/byteArrayOutputStream.ts

@@ -0,0 +1,67 @@
+import { OutputStream } from './outputStream';
+import { Buffer } from 'buffer';
+
+export class ByteArrayOutputStream extends OutputStream {
+  private static readonly INITIAL_SIZE = 32;
+
+  protected buf: Buffer;
+  protected count: number;
+
+  constructor(size: number = ByteArrayOutputStream.INITIAL_SIZE) {
+    super();
+    if (size < 0) {
+      throw new Error(`Negative initial size: ${size}`);
+    }
+    this.buf = Buffer.alloc(size);
+    this.count = 0;
+  }
+
+  private ensureCapacity(minCapacity: number): void {
+    const oldCapacity = this.buf.length;
+    if (minCapacity > oldCapacity) {
+      const newCapacity = Math.max(oldCapacity * 2, minCapacity);
+      const newBuf = Buffer.alloc(newCapacity);
+      newBuf.set(this.buf);
+      this.buf = newBuf;
+    }
+  }
+
+  public write(b: number): void {
+    this.ensureCapacity(this.count + 1);
+    this.buf[this.count++] = b & 0xff;
+  }
+
+  public writeBytes(b: Uint8Array): void {
+    this.writeBytesOffset(b, 0, b.length);
+  }
+
+  public writeBytesOffset(b: Uint8Array, off: number, len: number): void {
+    if (off < 0 || len < 0 || off + len > b.length) {
+      throw new RangeError('Index out of bounds');
+    }
+    this.ensureCapacity(this.count + len);
+    this.buf.set(b.subarray(off, off + len), this.count);
+    this.count += len;
+  }
+
+  public writeTo(out: OutputStream) {
+    const chunk = this.buf.slice(0, this.count);
+    return out.writeBytes(chunk);
+  }
+
+  public reset(): void {
+    this.count = 0;
+  }
+
+  public toByteArray(): Uint8Array {
+    return this.buf.subarray(0, this.count);
+  }
+
+  public size(): number {
+    return this.count;
+  }
+
+  public close(): void {
+    // Do nothing
+  }
+}

package/src/Shared/EIDReader/java/dataInput.ts

@@ -0,0 +1,16 @@
+export interface DataInput {
+  readFully(b: Uint8Array): Promise<void>;
+  readFully(b: Uint8Array, off: number, len: number): Promise<void>;
+  skipBytes(n: number): Promise<number>;
+  readBoolean(): Promise<boolean>;
+  readByte(): Promise<number>;
+  readUnsignedByte(): Promise<number>;
+  readShort(): Promise<number>;
+  readUnsignedShort(): Promise<number>;
+  readChar(): Promise<string>;
+  readInt(): Promise<number>;
+  readLong(): Promise<bigint>;
+  readFloat(): Promise<number>;
+  readDouble(): Promise<number>;
+  readUTF(): Promise<string>;
+}

package/src/Shared/EIDReader/java/dataInputStream.ts

@@ -0,0 +1,203 @@
+import type { DataInput } from './dataInput';
+import { FilterInputStream } from './filterInputStream';
+import { InputStream } from './inputStream';
+import { Buffer } from 'buffer';
+
+export class DataInputStream extends FilterInputStream implements DataInput {
+  private static readonly EMPTY_BYTE_ARRAY: Uint8Array = new Uint8Array(0);
+  private static readonly EMPTY_CHAR_ARRAY: string[] = [];
+
+  private readonly readBuffer = Buffer.alloc(8);
+
+  private bytearr: Uint8Array = DataInputStream.EMPTY_BYTE_ARRAY;
+  private chararr: string[] = DataInputStream.EMPTY_CHAR_ARRAY;
+
+  constructor(is: InputStream) {
+    super(is);
+  }
+
+  public async readBytes(b: Uint8Array): Promise<number> {
+    return this.is.readBytesWithOffset(b, 0, b.length);
+  }
+
+  public async readFully(b: Uint8Array): Promise<void> {
+    await this.readFullyWithOffset(b, 0, b.length);
+  }
+
+  public async readFullyWithOffset(
+    b: Uint8Array,
+    off: number,
+    len: number
+  ): Promise<void> {
+    let n = 0;
+    while (n < len) {
+      const count = await this.is.readBytesWithOffset(b, off + n, len - n);
+      if (count < 0) {
+        throw new Error('readBytesWithOffset: EOFException');
+      }
+      n += count;
+    }
+  }
+
+  public async skipBytes(n: number): Promise<number> {
+    let total = 0;
+    let cur = 0;
+
+    while (total < n && (cur = await this.is.skip(n - total)) > 0) {
+      total += cur;
+    }
+
+    return total;
+  }
+
+  public async readBoolean(): Promise<boolean> {
+    return (await this.readByte()) !== 0;
+  }
+
+  public async readByte(): Promise<number> {
+    const ch = await this.is.read();
+    if (ch < 0) {
+      throw new Error('readByte: EOFException');
+    }
+    return ch;
+  }
+
+  public async readUnsignedByte(): Promise<number> {
+    const ch = await this.is.read();
+    if (ch < 0) {
+      throw new Error('readUnsignedByte: EOFException');
+    }
+    return ch;
+  }
+
+  public async readShort(): Promise<number> {
+    await this.readBytesWithOffset(this.readBuffer, 0, 2);
+
+    return Buffer.from(this.readBuffer).readInt16BE(0);
+  }
+
+  public async readUnsignedShort(): Promise<number> {
+    await this.readBytesWithOffset(this.readBuffer, 0, 2);
+
+    return Buffer.from(this.readBuffer).readUInt16BE(0);
+  }
+
+  public async readChar(): Promise<string> {
+    await this.readBytesWithOffset(this.readBuffer, 0, 2);
+
+    return Buffer.from(this.readBuffer).toString('utf16le');
+  }
+
+  public async readInt(): Promise<number> {
+    await this.readBytesWithOffset(this.readBuffer, 0, 4);
+
+    return Buffer.from(this.readBuffer).readInt32BE(0);
+  }
+
+  public async readLong(): Promise<bigint> {
+    await this.readBytesWithOffset(this.readBuffer, 0, 8);
+
+    return Buffer.from(this.readBuffer).readBigInt64BE(0);
+  }
+
+  public async readFloat(): Promise<number> {
+    return Number(await this.readInt());
+  }
+
+  public async readDouble(): Promise<number> {
+    return Number(await this.readLong());
+  }
+
+  public async readUTF(): Promise<string> {
+    return DataInputStream.readUTF(this);
+  }
+
+  public static async readUTF(dataInput: DataInput): Promise<string> {
+    const utflen = await dataInput.readUnsignedShort();
+    let bytearr: Uint8Array | null = null;
+    let chararr: string[] | null = null;
+    if (dataInput instanceof DataInputStream) {
+      if (dataInput.bytearr.length < utflen) {
+        dataInput.bytearr = new Uint8Array(utflen * 2);
+        dataInput.chararr = new Array(utflen * 2);
+      }
+      chararr = dataInput.chararr;
+      bytearr = dataInput.bytearr;
+    } else {
+      bytearr = new Uint8Array(utflen);
+      chararr = new Array(utflen);
+    }
+
+    let c, char2, char3;
+    let count = 0;
+    let chararr_count = 0;
+
+    await dataInput.readFully(bytearr, 0, utflen);
+
+    while (count < utflen) {
+      c = bytearr[count] & 0xff;
+      if (c > 127) {
+        break;
+      }
+      count++;
+      chararr[chararr_count++] = String.fromCharCode(c);
+    }
+
+    while (count < utflen) {
+      c = bytearr[count] & 0xff;
+      switch (c >> 4) {
+        case 0:
+        case 1:
+        case 2:
+        case 3:
+        case 4:
+        case 5:
+        case 6:
+        case 7: {
+          /* 0xxxxxxx*/
+          count++;
+          chararr[chararr_count++] = String.fromCharCode(c);
+          break;
+        }
+        case 12:
+        case 13: {
+          /* 110x xxxx   10xx xxxx*/
+          count += 2;
+          if (count > utflen) {
+            throw new Error('malformed input: partial character at end');
+          }
+          char2 = bytearr[count - 1];
+          if ((char2 & 0xc0) !== 0x80) {
+            throw new Error('malformed input around byte ' + count);
+          }
+          chararr[chararr_count++] = String.fromCharCode(
+            ((c & 0x1f) << 6) | (char2 & 0x3f)
+          );
+          break;
+        }
+        case 14: {
+          /* 1110 xxxx  10xx xxxx  10xx xxxx */
+          count += 3;
+          if (count > utflen) {
+            throw new Error('malformed input: partial character at end');
+          }
+          char2 = bytearr[count - 2];
+          char3 = bytearr[count - 1];
+          if ((char2 & 0xc0) !== 0x80 || (char3 & 0xc0) !== 0x80) {
+            throw new Error('malformed input around byte ' + count);
+          }
+          chararr[chararr_count++] = String.fromCharCode(
+            ((c & 0x0f) << 12) | ((char2 & 0x3f) << 6) | ((char3 & 0x3f) << 0)
+          );
+          break;
+        }
+        default:
+          /* 10xx xxxx,  1111 xxxx */
+          throw new Error('malformed input around byte ' + count);
+      }
+    }
+
+    // The number of chars produced may be less than utflen
+    return chararr.slice(0, chararr_count).join('');
+  }
+}

package/src/Shared/EIDReader/java/dataOutputStream.ts

@@ -0,0 +1,107 @@
+import { Buffer } from 'buffer';
+import { OutputStream } from './outputStream';
+
+export class DataOutputStream extends OutputStream {
+  protected written: number;
+
+  constructor(private out: OutputStream) {
+    super();
+    this.written = 0;
+  }
+
+  private incCount(value: number): void {
+    let temp = this.written + value;
+    if (temp < 0) {
+      temp = Number.MAX_VALUE;
+    }
+    this.written = temp;
+  }
+
+  public write(b: number): void {
+    this.out.write(b);
+    this.incCount(1);
+  }
+
+  public writeBytes(bytes: Uint8Array): void {
+    this.out.writeBytes(bytes);
+    this.incCount(bytes.length);
+  }
+
+  public writeShort(s: number): void {
+    const buffer = Buffer.alloc(2);
+    buffer.writeInt16BE(s, 0);
+    this.out.writeBytes(Uint8Array.from(buffer));
+    this.incCount(2);
+  }
+
+  public writeInt(i: number): void {
+    const buffer = Buffer.alloc(4);
+    buffer.writeInt32BE(i, 0);
+    this.out.writeBytes(Uint8Array.from(buffer));
+    this.incCount(4);
+  }
+
+  public writeLong(l: bigint): void {
+    const buffer = Buffer.alloc(8);
+    buffer.writeBigUInt64BE(l, 0);
+    this.out.writeBytes(Uint8Array.from(buffer));
+    this.incCount(8);
+  }
+
+  public writeUTF(str: string): void {
+    const strlen = str.length;
+    let utflen = strlen;
+
+    for (let i = 0; i < strlen; i++) {
+      const c = str.charCodeAt(i);
+      if (c >= 0x80 || c === 0) {
+        utflen += c >= 0x800 ? 2 : 1;
+      }
+    }
+
+    if (utflen > 65535 || utflen < strlen) {
+      throw new Error(DataOutputStream.tooLongMsg(str, utflen));
+    }
+
+    const bytearr = new Array(utflen + 2);
+    let count = 0;
+    bytearr[count++] = (utflen >>> 8) & 0xff;
+    bytearr[count++] = utflen & 0xff;
+
+    for (let i = 0; i < strlen; i++) {
+      const c = str.charCodeAt(i);
+      if (c < 0x80 && c !== 0) {
+        bytearr[count++] = c;
+      } else if (c >= 0x800) {
+        bytearr[count++] = 0xe0 | ((c >> 12) & 0x0f);
+        bytearr[count++] = 0x80 | ((c >> 6) & 0x3f);
+        bytearr[count++] = 0x80 | ((c >> 0) & 0x3f);
+      } else {
+        bytearr[count++] = 0xc0 | ((c >> 6) & 0x1f);
+        bytearr[count++] = 0x80 | ((c >> 0) & 0x3f);
+      }
+    }
+
+    this.out.writeBytesWithOffset(Uint8Array.from(bytearr), 0, utflen + 2);
+  }
+
+  public size(): number {
+    return this.written;
+  }
+
+  public flush(): void {
+    this.out.flush();
+  }
+
+  public close(): void {
+    this.out.close();
+  }
+
+  private static tooLongMsg(s: string, bits32: number): string {
+    const sLen = s.length;
+    const head = s.substring(0, 8);
+    const tail = s.substring(sLen - 8, sLen);
+    const actualLength = sLen + (bits32 - sLen);
+    return `encoded string (${head}...${tail}) too long: ${actualLength} bytes`;
+  }
+}

package/src/Shared/EIDReader/java/filterInputStream.ts

@@ -0,0 +1,138 @@
+import { InputStream } from './inputStream';
+
+export class FilterInputStream extends InputStream {
+  /**
+   * The input stream to be filtered.
+   */
+  protected is: InputStream;
+
+  /**
+   * Creates a `FilterInputStream`
+   * by assigning the argument `in`
+   * to the field `this.in` so as
+   * to remember it for later use.
+   *
+   * @param   is   the underlying input stream, or `null` if
+   *          this instance is to be created without an underlying stream.
+   */
+  constructor(is: InputStream) {
+    super();
+    this.is = is;
+  }
+
+  /**
+   * This method simply performs `in.read()` and returns the result.
+   *
+   * @return     the next byte of data, or -1 if the end of the stream is reached.
+   * @throws     IOException  if an I/O error occurs.
+   */
+  public async read(): Promise<number> {
+    return this.is.read();
+  }
+
+  /**
+   * Reads up to `b.length` bytes of data from this
+   * input stream into an array of bytes. This method blocks until some
+   * input is available.
+   *
+   * @param      b   the buffer into which the data is read.
+   * @return     the total number of bytes read into the buffer, or -1 if there is no more data because the end of the stream has been reached.
+   * @throws     IOException  if an I/O error occurs.
+   */
+  public async readBytes(b: Uint8Array): Promise<number> {
+    return this.readBytesWithOffset(b, 0, b.length);
+  }
+
+  /**
+   * Reads up to `len` bytes of data from this input stream
+   * into an array of bytes. If `len` is not zero, the method
+   * blocks until some input is available; otherwise, no
+   * bytes are read and `0` is returned.
+   *
+   * @param      b     the buffer into which the data is read.
+   * @param      off   the start offset in the destination array `b`.
+   * @param      len   the maximum number of bytes read.
+   * @return     the total number of bytes read into the buffer, or -1 if there is no more data because the end of the stream has been reached.
+   * @throws     NullPointerException if `b` is `null`.
+   * @throws     IndexOutOfBoundsException if `off` is negative, `len` is negative, or `len` is greater than `b.length - off`.
+   * @throws     IOException  if an I/O error occurs.
+   */
+  public async readBytesWithOffset(
+    b: Uint8Array,
+    off: number,
+    len: number
+  ): Promise<number> {
+    return this.is.readBytesWithOffset(b, off, len);
+  }
+
+  /**
+   * Skips over and discards `n` bytes of data from the
+   * input stream. The `skip` method may, for a variety of
+   * reasons, end up skipping over some smaller number of bytes,
+   * possibly `0`. The actual number of bytes skipped is
+   * returned.
+   *
+   * @param      n   the number of bytes to be skipped.
+   * @return     the actual number of bytes skipped.
+   * @throws     IOException  if an I/O error occurs.
+   */
+  public async skip(n: number): Promise<number> {
+    return this.is.skip(n);
+  }
+
+  /**
+   * Returns an estimate of the number of bytes that can be read (or
+   * skipped over) from this input stream without blocking by the next
+   * caller of a method for this input stream. The next caller might be
+   * the same thread or another thread. A single read or skip of this
+   * many bytes will not block, but may read or skip fewer bytes.
+   *
+   * @return     an estimate of the number of bytes that can be read (or
+   *             skipped over) from this input stream without blocking.
+   * @throws     IOException  if an I/O error occurs.
+   */
+  public available(): number {
+    return this.is.available();
+  }
+
+  /**
+   * Closes this input stream and releases any system resources associated with the stream.
+   *
+   * @throws     IOException  if an I/O error occurs.
+   */
+  public close(): void {
+    this.is.close();
+  }
+
+  /**
+   * Marks the current position in this input stream. A subsequent
+   * call to the `reset` method repositions this stream at
+   * the last marked position so that subsequent reads re-read the same bytes.
+   *
+   * @param   readLimit   the maximum limit of bytes that can be read before the mark position becomes invalid.
+   */
+  public mark(readLimit: number): void {
+    this.is.mark(readLimit);
+  }
+
+  /**
+   * Repositions this stream to the position at the time the
+   * `mark` method was last called on this input stream.
+   *
+   * @throws     IOException  if the stream has not been marked or if the mark has been invalidated.
+   */
+  public reset(): void {
+    this.is.reset();
+  }
+
+  /**
+   * Tests if this input stream supports the `mark`
+   * and `reset` methods.
+   *
+   * @return  `true` if this stream type supports the
+   *          `mark` and `reset` method; `false` otherwise.
+   */
+  public markSupported(): boolean {
+    return this.is.markSupported();
+  }
+}

package/src/Shared/EIDReader/java/filterOutputStream.ts

@@ -0,0 +1,126 @@
+import { OutputStream } from './outputStream';
+
+export class FilterOutputStream extends OutputStream {
+  /**
+   * The underlying output stream to be filtered.
+   */
+  protected out: OutputStream;
+
+  /**
+   * Whether the stream is closed; implicitly initialized to false.
+   */
+  private closed: boolean;
+
+  /**
+   * Creates an output stream filter built on top of the specified
+   * underlying output stream.
+   *
+   * @param out the underlying output stream to be assigned to
+   *            the field `this.out` for later use, or
+   *            `null` if this instance is to be
+   *            created without an underlying stream.
+   */
+  constructor(out: OutputStream) {
+    super();
+    this.out = out;
+    this.closed = false;
+  }
+
+  /**
+   * Writes the specified `byte` to this output stream.
+   * <p>
+   * The `write` method of `FilterOutputStream`
+   * calls the `write` method of its underlying output stream,
+   * that is, it performs `out.write(b)`.
+   * <p>
+   * Implements the abstract `write` method of `OutputStream`.
+   *
+   * @param b the byte to be written.
+   * @throws IOException if an I/O error occurs.
+   */
+  write(b: number): void {
+    this.out.write(b);
+  }
+
+  /**
+   * Writes `b.length` bytes to this output stream.
+   *
+   * The `write` method of `FilterOutputStream`
+   * calls its `write` method of three arguments with the
+   * arguments `b`, `0`, and
+   * `b.length`.
+   *
+   * @param b the data to be written.
+   * @throws IOException if an I/O error occurs.
+   */
+  writeBytes(b: Uint8Array): void {
+    this.writeBytesWithOffset(b, 0, b.length);
+  }
+
+  /**
+   * Writes `len` bytes from the specified
+   * byte array starting at offset `off` to
+   * this output stream.
+   *
+   * The `write` method of `FilterOutputStream`
+   * calls the `write` method of one argument on each
+   * byte to output.
+   *
+   * @param b the data to be written.
+   * @param off the start offset in the data.
+   * @param len the number of bytes to write.
+   * @throws IOException if an I/O error occurs.
+   */
+  writeBytesWithOffset(b: Uint8Array, off: number, len: number): void {
+    for (let i = 0; i < len; i++) {
+      this.write(b[off + i]);
+    }
+  }
+
+  /**
+   * Flushes this output stream and forces any buffered output bytes
+   * to be written out to the stream.
+   *
+   * The `flush` method of `FilterOutputStream`
+   * calls the `flush` method of its underlying output stream.
+   *
+   * @throws IOException if an I/O error occurs.
+   */
+  flush(): void {
+    this.out.flush();
+  }
+
+  /**
+   * Closes this output stream and releases any system resources
+   * associated with the stream.
+   *
+   * When not already closed, the `close` method of `FilterOutputStream`
+   * calls its `flush` method, and then
+   * calls the `close` method of its underlying output stream.
+   *
+   * @throws IOException if an I/O error occurs.
+   */
+  close(): void {
+    if (this.closed) {
+      return;
+    }
+
+    let flushException: Error | null = null;
+    try {
+      this.flush();
+    } catch (e) {
+      flushException = e as Error;
+      throw e;
+    } finally {
+      if (flushException === null) {
+        this.out.close();
+      } else {
+        try {
+          this.out.close();
+        } catch (closeException) {
+          throw closeException;
+        }
+      }
+    }
+  }
+}