@trustchex/react-native-sdk 1.161.0

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

@@ -0,0 +1,244 @@
+import tlvUtils from './tlv.utils';
+
+export class TLVOutputState {
+  private state: TLVStruct[];
+  private isAtStartOfTag: boolean;
+  private isAtStartOfLength: boolean;
+  private isReadingValue: boolean;
+
+  constructor() {
+    this.state = [];
+    this.isAtStartOfTag = true;
+    this.isAtStartOfLength = false;
+    this.isReadingValue = false;
+  }
+
+  getIsAtStartOfTag(): boolean {
+    return this.isAtStartOfTag;
+  }
+
+  getIsAtStartOfLength(): boolean {
+    return this.isAtStartOfLength;
+  }
+
+  isProcessingValue(): 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];
+      const length = currentObject.getLength();
+      if (length < 0) {
+        throw new Error('Length not yet known.');
+      } else {
+        return length;
+      }
+    }
+  }
+
+  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): void {
+    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(): void {
+    this.isAtStartOfTag = false;
+    this.isAtStartOfLength = false;
+    this.isReadingValue = true;
+  }
+
+  isDummyLengthSet(): boolean {
+    if (this.state.length === 0) {
+      return false;
+    } else {
+      return !this.state[this.state.length - 1].getIsLengthSet();
+    }
+  }
+
+  setLengthProcessed(length: number): void {
+    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: number): void {
+    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: number[],
+    offset: number,
+    length: number
+  ): void {
+    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(): number[] {
+    if (this.state.length === 0) {
+      throw new Error('Cannot get value yet.');
+    } else {
+      return this.state[this.state.length - 1].getValue();
+    }
+  }
+
+  toString(): string {
+    return this.state.toString();
+  }
+
+  canBeWritten(): boolean {
+    for (const stackFrame of this.state) {
+      if (!stackFrame.getIsLengthSet()) {
+        return false;
+      }
+    }
+    return true;
+  }
+}
+
+class TLVStruct {
+  private tag: number;
+  private length: number;
+  private isLengthSet: boolean;
+  private value: number[];
+
+  constructor(
+    tag: number,
+    length: number = Number.MAX_VALUE,
+    isLengthSet: boolean = false,
+    value: number[] | null = null
+  ) {
+    this.tag = tag;
+    this.length = length;
+    this.isLengthSet = isLengthSet;
+    this.value = value ? [...value] : [];
+  }
+
+  setLength(length: number): void {
+    this.length = length;
+    this.isLengthSet = true;
+  }
+
+  getTag(): number {
+    return this.tag;
+  }
+
+  getLength(): number {
+    return this.length;
+  }
+
+  getIsLengthSet(): boolean {
+    return this.isLengthSet;
+  }
+
+  getValueBytesProcessed(): number {
+    return this.value.length;
+  }
+
+  getValue(): number[] {
+    return [...this.value];
+  }
+
+  write(bytes: number[], offset: number, length: number): void {
+    this.value.push(...bytes.slice(offset, offset + length));
+  }
+}

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

@@ -0,0 +1,112 @@
+import { DataOutputStream } from '../java/dataOutputStream';
+import { OutputStream } from '../java/outputStream';
+import TLVUtil from './tlv.utils';
+import { TLVOutputState } from './tlvOutputState';
+
+export class TLVOutputStream extends OutputStream {
+  private outputStream: DataOutputStream;
+  private state: TLVOutputState;
+
+  constructor(outputStream: OutputStream) {
+    super();
+    this.outputStream =
+      outputStream instanceof DataOutputStream
+        ? outputStream
+        : new DataOutputStream(outputStream);
+    this.state = new TLVOutputState();
+  }
+
+  writeTag(tag: number): void {
+    const tagAsBytes = TLVUtil.getTagAsBytes(tag);
+    if (this.state.canBeWritten()) {
+      this.outputStream.writeBytes(Uint8Array.from(tagAsBytes));
+    }
+
+    this.state.setTagProcessed(tag);
+  }
+
+  writeLength(length: number): void {
+    const lengthAsBytes = TLVUtil.getLengthAsBytes(length);
+    this.state.setLengthProcessed(length);
+    if (this.state.canBeWritten()) {
+      this.outputStream.writeBytes(Uint8Array.from(lengthAsBytes));
+    }
+  }
+
+  writeValue(value: Uint8Array): void {
+    if (value == null) {
+      throw new Error('Cannot write null.');
+    } else if (this.state.getIsAtStartOfTag()) {
+      throw new Error(
+        'Cannot write value bytes yet. Need to write a tag first.'
+      );
+    } else {
+      if (this.state.getIsAtStartOfLength()) {
+        this.writeLength(value.length);
+        this.writeBytes(value);
+      } else {
+        this.writeBytes(value);
+        this.state.updatePreviousLength(value.length);
+      }
+    }
+  }
+
+  write(b: number): void {
+    this.writeBytesWithOffset(new Uint8Array([b]), 0, 1);
+  }
+
+  writeBytes(bytes: Uint8Array): void {
+    this.writeBytesWithOffset(bytes, 0, bytes.length);
+  }
+
+  writeBytesWithOffset(
+    bytes: Uint8Array,
+    offset: number,
+    length: number
+  ): void {
+    if (this.state.getIsAtStartOfTag()) {
+      throw new Error(
+        'Cannot write value bytes yet. Need to write a tag first.'
+      );
+    } else {
+      if (this.state.getIsAtStartOfLength()) {
+        this.state.setDummyLengthProcessed();
+      }
+
+      this.state.updateValueBytesProcessed(Array.from(bytes), offset, length);
+      if (this.state.canBeWritten()) {
+        this.outputStream.writeBytes(bytes.slice(offset, offset + length));
+      }
+    }
+  }
+
+  writeValueEnd(): void {
+    if (this.state.getIsAtStartOfLength()) {
+      throw new Error('Not processing value yet.');
+    } else if (
+      !this.state.getIsAtStartOfTag() ||
+      this.state.isDummyLengthSet()
+    ) {
+      const bufferedValueBytes = this.state.getValue();
+      const length = bufferedValueBytes.length;
+      this.state.updatePreviousLength(length);
+      if (this.state.canBeWritten()) {
+        const lengthAsBytes = TLVUtil.getLengthAsBytes(length);
+        this.outputStream.writeBytes(Uint8Array.from(lengthAsBytes));
+        this.outputStream.writeBytes(Uint8Array.from(bufferedValueBytes));
+      }
+    }
+  }
+
+  flush(): void {
+    this.outputStream.flush();
+  }
+
+  close(): void {
+    if (!this.state.canBeWritten()) {
+      throw new Error('Cannot close stream yet, illegal TLV state.');
+    } else {
+      this.outputStream.close();
+    }
+  }
+}

package/src/Shared/EIDReader/tripleDesSecureMessagingWrapper.ts

@@ -0,0 +1,48 @@
+import { SecureMessagingWrapper } from './secureMessagingWrapper';
+import { ByteArrayOutputStream } from './java/byteArrayOutputStream';
+import { DataOutputStream } from './java/dataOutputStream';
+
+export class TripleDesSecureMessagingWrapper extends SecureMessagingWrapper {
+  public static readonly ZERO_IV_PARAM_SPEC = [0, 0, 0, 0, 0, 0, 0, 0];
+
+  constructor(
+    ksEnc: string,
+    ksMac: string,
+    maxTransceiveLength: number,
+    shouldCheckMAC: boolean,
+    ssc: bigint
+  ) {
+    super(ksEnc, ksMac, maxTransceiveLength, shouldCheckMAC, ssc);
+  }
+
+  public getType(): string {
+    return '3DES';
+  }
+
+  public getPadLength(): number {
+    return 8;
+  }
+
+  public getEncodedSendSequenceCounter(): Uint8Array {
+    const byteArrayOutputStream = new ByteArrayOutputStream();
+    try {
+      const dataOutputStream = new DataOutputStream(byteArrayOutputStream);
+      dataOutputStream.writeLong(this.getSendSequenceCounter());
+    } catch (ioe) {
+      /* Never happens. */
+      console.debug('Error writing to stream', ioe);
+    } finally {
+      try {
+        byteArrayOutputStream.close();
+      } catch (ioe) {
+        console.debug('Error closing stream', ioe);
+      }
+    }
+
+    return byteArrayOutputStream.toByteArray();
+  }
+
+  protected getIV() {
+    return TripleDesSecureMessagingWrapper.ZERO_IV_PARAM_SPEC;
+  }
+}

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

@@ -0,0 +1,273 @@
+import CryptoJS, { enc, SHA1 } from 'crypto-js';
+import { Buffer, type WithImplicitCoercion } from 'buffer';
+import 'react-native-get-random-values';
+
+const pad = (
+  bytes: Buffer,
+  offset: number,
+  length: number,
+  blockSize: number
+) => {
+  const n = length;
+  const padLength = blockSize - (n % blockSize);
+  const out = Buffer.alloc(n + padLength);
+  for (let i = 0; i < n; i++) {
+    out[i] = bytes[offset + i];
+  }
+  out[n] = 0x80;
+  for (let i = n + 1; i < n + padLength; i++) {
+    out[i] = 0x00;
+  }
+  return out;
+};
+
+const unpad = (bytes: number[]) => {
+  let i = bytes.length - 1;
+  while (i >= 0 && bytes[i] === 0x00) {
+    i--;
+  }
+  if ((bytes[i] & 0xff) !== 0x80) {
+    throw new Error(
+      `Expected constant 0x80, found 0x${(bytes[i] & 0x000000ff).toString(16)}`
+    );
+  }
+  const out = bytes.slice(0, i);
+  return out;
+};
+
+// Function to encrypt data using 3DES key KEnc
+const encryptWith3DES = (data: string, KEnc: string) => {
+  const SWordArray = CryptoJS.enc.Hex.parse(data);
+  const KEncWordArray = CryptoJS.enc.Hex.parse(KEnc);
+
+  const encrypted = CryptoJS.algo.TripleDES.createEncryptor(KEncWordArray, {
+    mode: CryptoJS.mode.CBC,
+    padding: CryptoJS.pad.NoPadding,
+    iv: CryptoJS.enc.Hex.parse('0000000000000000'),
+    blockSize: 64,
+  }).finalize(SWordArray);
+
+  return encrypted.toString(CryptoJS.enc.Hex);
+};
+
+// Function to decrypt data using 3DES key KEnc
+const decryptWith3DES = (data: string, KEnc: string) => {
+  const SWordArray = CryptoJS.enc.Hex.parse(data);
+  const KEncWordArray = CryptoJS.enc.Hex.parse(KEnc);
+
+  const decrypted = CryptoJS.algo.TripleDES.createDecryptor(KEncWordArray, {
+    mode: CryptoJS.mode.CBC,
+    padding: CryptoJS.pad.NoPadding,
+    iv: CryptoJS.enc.Hex.parse('0000000000000000'),
+    blockSize: 64,
+  }).finalize(SWordArray);
+
+  return decrypted.toString(CryptoJS.enc.Hex);
+};
+
+// https://en.wikipedia.org/wiki/ISO/IEC_9797-1
+const computeMac = (data: string, key: string, padData = false): string => {
+  // Split the 16 byte MAC key into two keys
+  const key1 = key.substring(0, 16);
+  const key2 = key.substring(16, 32);
+
+  const des1 = CryptoJS.algo.DES.createEncryptor(CryptoJS.enc.Hex.parse(key1), {
+    mode: CryptoJS.mode.CBC,
+    padding: CryptoJS.pad.NoPadding,
+    iv: CryptoJS.enc.Hex.parse('0000000000000000'),
+    blockSize: 64,
+  });
+  const des2 = CryptoJS.algo.DES.createDecryptor(CryptoJS.enc.Hex.parse(key2), {
+    mode: CryptoJS.mode.CBC,
+    padding: CryptoJS.pad.NoPadding,
+    iv: CryptoJS.enc.Hex.parse('0000000000000000'),
+    blockSize: 64,
+  });
+
+  const out = Buffer.from(data, 'hex');
+  const dataBytes = padData
+    ? // Pad the data with Padding Method 2 (Bit Padding)
+      pad(out, 0, out.byteLength, 8)
+    : out;
+  const numberOfBytes = dataBytes.byteLength / 8;
+
+  let d1 = dataBytes.subarray(0, 8);
+  let dN = Buffer.alloc(8);
+  let hN = Buffer.alloc(8);
+  let intN = Buffer.alloc(8);
+
+  // MAC Algorithm 3
+  // Initial Transformation 1
+  hN = Buffer.from(
+    des1
+      .finalize(CryptoJS.enc.Hex.parse(Buffer.from(d1).toString('hex')))
+      .toString(CryptoJS.enc.Hex),
+    'hex'
+  );
+
+  // Split the blocks
+  // Iteration on the rest of blocks
+  for (let j = 1; j < numberOfBytes; j++) {
+    dN = dataBytes.subarray(8 * j, 8 * j + 8);
+
+    // XOR
+    for (let i = 0; i < 8; i++) {
+      intN[i] = hN[i] ^ dN[i];
+    }
+
+    // Encrypt
+    des1.reset();
+    hN = Buffer.from(
+      des1
+        .finalize(CryptoJS.enc.Hex.parse(Buffer.from(intN).toString('hex')))
+        .toString(CryptoJS.enc.Hex),
+      'hex'
+    );
+  }
+
+  // Output Transformation 3
+  des2.reset();
+  const hNdecrypt = des2.finalize(
+    CryptoJS.enc.Hex.parse(Buffer.from(hN).toString('hex'))
+  );
+
+  des1.reset();
+  const mac = des1.finalize(hNdecrypt);
+
+  // Get check Sum CC
+  return mac.toString(CryptoJS.enc.Hex);
+};
+
+// Helper function to adjust parity bits for DES keys
+const adjustParityBits = (
+  key:
+    | WithImplicitCoercion<string>
+    | { [Symbol.toPrimitive](hint: 'string'): string }
+) => {
+  const bytes = Buffer.from(key, 'hex');
+  for (let i = 0; i < bytes.length; i++) {
+    let parity = 0;
+    for (let j = 0; j < 8; j++) {
+      if ((bytes[i] & (1 << j)) !== 0) {
+        parity++;
+      }
+    }
+    if (parity % 2 === 0) {
+      bytes[i] ^= 1;
+    }
+  }
+  return bytes.toString('hex');
+};
+
+// Function to derive 3DES keys from a seed
+const derive3DESKeysFromSeed = (kSeed: string, type: 'ENC' | 'MAC') => {
+  // Concatenate Kseed with '00000001' for ENC and '00000002' for MAC
+  const D = kSeed + (type === 'ENC' ? '00000001' : '00000002');
+
+  // Calculate the SHA-1 hash of D
+  const hash = SHA1(enc.Hex.parse(D)).toString();
+
+  // Form DES keys Ka and Kb
+  let KaPrime = hash.substring(0, 16);
+  let KbPrime = hash.substring(16, 32);
+
+  // Adjust parity bits
+  const Ka = adjustParityBits(KaPrime);
+  const Kb = adjustParityBits(KbPrime);
+
+  return Ka + Kb;
+};
+
+const computeKeySeed = (
+  text: string,
+  digestAlg: 'SHA-1',
+  doTruncate: boolean
+) => {
+  let hash;
+
+  if (digestAlg === 'SHA-1') {
+    hash = SHA1(text).toString();
+  } else {
+    throw new Error('Unsupported digest algorithm');
+  }
+
+  if (!doTruncate) {
+    return hash;
+  }
+
+  return hash.substring(0, 32);
+};
+
+const getRandomValues = (length: number) => {
+  return Buffer.from(crypto.getRandomValues(new Uint8Array(length))).toString(
+    'hex'
+  );
+};
+
+const computeSendSequenceCounter = (rndICC: Buffer, rndIFD: Buffer): number => {
+  if (
+    rndICC == null ||
+    rndICC.length !== 8 ||
+    rndIFD == null ||
+    rndIFD.length !== 8
+  ) {
+    throw new Error('Wrong length input');
+  }
+  let ssc = 0;
+  for (let i = 4; i < 8; i++) {
+    ssc <<= 8;
+    ssc += rndICC[i] & 0x000000ff;
+  }
+  for (let i = 4; i < 8; i++) {
+    ssc <<= 8;
+    ssc += rndIFD[i] & 0x000000ff;
+  }
+  return ssc;
+};
+
+// TODO move to a separate file
+const partition = (segmentSize: number, data: number[]) => {
+  const segments: number[][] = [];
+  if (data == null || segmentSize <= 0) {
+    throw new Error('Cannot partition');
+  }
+
+  /* Check if all data fits in one segment. */
+  segmentSize = Math.min(data.length, segmentSize);
+
+  const segmentCount = Math.floor(data.length / segmentSize); // Excluding the remainder.
+  const lastSegmentSize = data.length % segmentSize;
+
+  let offset = 0;
+  for (let i = 0; i < segmentCount; i++) {
+    const segment = new Array(segmentSize);
+    for (let j = 0; j < segmentSize; j++) {
+      segment[j] = data[offset + j];
+    }
+    segments.push(segment);
+    offset += segmentSize;
+  }
+
+  if (lastSegmentSize !== 0) {
+    const segment = new Array(lastSegmentSize);
+    for (let j = 0; j < lastSegmentSize; j++) {
+      segment[j] = data[offset + j];
+    }
+    segments.push(segment);
+  }
+
+  return segments;
+};
+
+export default {
+  pad,
+  unpad,
+  encryptWith3DES,
+  decryptWith3DES,
+  computeMac,
+  derive3DESKeysFromSeed,
+  getRandomValues,
+  computeSendSequenceCounter,
+  computeKeySeed,
+  partition,
+};