@trustchex/react-native-sdk 1.161.0

package/src/Shared/EIDReader/secureMessagingWrapper.ts

@@ -0,0 +1,361 @@
+import cryptoUtils from './utils/crypto.utils';
+import TLVUtil from './tlv/tlv.utils';
+import { ResponseAPDU } from './smartcards/responseAPDU';
+import { DataInputStream } from './java/dataInputStream';
+import type { APDUWrapper } from './smartcards/apduWrapper';
+import { CommandAPDU } from './smartcards/commandAPDU';
+import { ByteArrayInputStream } from './java/byteArrayInputStream';
+import { Buffer } from 'buffer';
+import { ISO7816_INS } from './smartcards/iso7816';
+
+export abstract class SecureMessagingWrapper implements APDUWrapper {
+  private ksEnc: string;
+  private ksMac: string;
+  private maxTransceiveLength: number;
+  private shouldCheckMAC: boolean;
+  private ssc: bigint;
+
+  constructor(
+    ksEnc: string,
+    ksMac: string,
+    maxTransceiveLength: number,
+    shouldCheckMAC: boolean,
+    ssc: bigint
+  ) {
+    this.ksEnc = ksEnc;
+    this.ksMac = ksMac;
+    this.maxTransceiveLength = maxTransceiveLength;
+    this.shouldCheckMAC = shouldCheckMAC;
+    this.ssc = ssc;
+  }
+
+  public getSendSequenceCounter() {
+    return this.ssc;
+  }
+
+  public getEncryptionKey() {
+    return this.ksEnc;
+  }
+
+  public getMACKey() {
+    return this.ksMac;
+  }
+
+  public getShouldCheckMAC(): boolean {
+    return this.shouldCheckMAC;
+  }
+
+  public getMaxTransceiveLength(): number {
+    return this.maxTransceiveLength;
+  }
+
+  public abstract getType(): string;
+
+  public wrap(commandAPDU: CommandAPDU): CommandAPDU {
+    this.ssc++;
+    try {
+      return this.wrapCommandAPDU(commandAPDU);
+    } catch (error) {
+      throw new Error('Unexpected exception: ' + error);
+    }
+  }
+
+  public async unwrap(responseAPDU: ResponseAPDU): Promise<ResponseAPDU> {
+    this.ssc++;
+    try {
+      const data = responseAPDU.getData();
+      if (data == null || data.length <= 0) {
+        throw new Error(
+          `Card indicates SM error, SW = ${Buffer.from([responseAPDU.getSW() & 0xffff]).toString('hex')}`
+        );
+      }
+      return await this.unwrapResponseAPDU(responseAPDU);
+    } catch (error) {
+      throw new Error(`Unexpected exception: ${error}`);
+    }
+  }
+
+  protected checkMac(rapdu: number[], cc: number[]): boolean {
+    try {
+      const dataOutputStream = Array.from(this.getEncodedSendSequenceCounter());
+      const paddedData = cryptoUtils.pad(
+        Buffer.from(rapdu),
+        0,
+        rapdu.length - 2 - 8 - 2,
+        this.getPadLength()
+      );
+      dataOutputStream.push(...paddedData);
+      let cc2 = Uint8Array.from(
+        Buffer.from(
+          cryptoUtils.computeMac(
+            Buffer.from(dataOutputStream).toString('hex'),
+            this.ksMac
+          ),
+          'hex'
+        )
+      );
+
+      if (cc2.length > 8 && cc.length === 8) {
+        const newCC2 = new Uint8Array(8);
+        for (let i = 0; i < 8; i++) {
+          newCC2[i] = cc2[i];
+        }
+        cc2 = newCC2;
+      }
+
+      return Buffer.compare(Buffer.from(cc), Buffer.from(cc2)) === 0;
+    } catch (ioe) {
+      console.debug('Error checking MAC', ioe);
+      return false;
+    }
+  }
+
+  protected abstract getPadLength(): number;
+
+  protected abstract getIV(): number[];
+
+  protected abstract getEncodedSendSequenceCounter(): Uint8Array;
+
+  private wrapCommandAPDU(commandAPDU: CommandAPDU): CommandAPDU {
+    const cla = commandAPDU.getCLA();
+    const ins = commandAPDU.getINS();
+    const p1 = commandAPDU.getP1();
+    const p2 = commandAPDU.getP2();
+    const lc = commandAPDU.getNc();
+    const le = commandAPDU.getNe();
+
+    const maskedHeader = [cla | 0x0c, ins, p1, p2];
+    const paddedMaskedHeader = cryptoUtils.pad(
+      Buffer.from(maskedHeader),
+      0,
+      maskedHeader.length,
+      this.getPadLength()
+    );
+    const hasDO85 = commandAPDU.getINS() === ISO7816_INS.READ_BINARY2;
+
+    let do8587: number[] = [];
+    let do97: number[] = [];
+    let output: number[] = [];
+
+    if (le > 0) {
+      do97 = Array.from(TLVUtil.wrapDO(0x97, this.encodeLe(le)));
+    }
+
+    if (lc > 0) {
+      const data = cryptoUtils.pad(
+        Buffer.from(commandAPDU.getData()),
+        0,
+        commandAPDU.getData().length,
+        this.getPadLength()
+      );
+      const ciphertext = Buffer.from(
+        cryptoUtils.encryptWith3DES(
+          Buffer.from(data).toString('hex'),
+          this.ksEnc
+        ),
+        'hex'
+      );
+      output.push(hasDO85 ? 0x85 : 0x87);
+      output.push(
+        ...TLVUtil.getLengthAsBytes(ciphertext.length + (hasDO85 ? 0 : 1))
+      );
+      if (!hasDO85) {
+        output.push(0x01);
+      }
+      output.push(...ciphertext);
+      do8587 = output;
+    }
+
+    output = [
+      ...this.getEncodedSendSequenceCounter(),
+      ...paddedMaskedHeader,
+      ...do8587,
+      ...do97,
+    ];
+    const n = cryptoUtils.pad(
+      Buffer.from(output),
+      0,
+      output.length,
+      this.getPadLength()
+    );
+
+    const cc = Buffer.from(
+      cryptoUtils.computeMac(Buffer.from(n).toString('hex'), this.ksMac),
+      'hex'
+    );
+    let ccLength = cc.length;
+    if (ccLength !== 8) {
+      ccLength = 8;
+    }
+
+    const do8E = [0x8e, ccLength & 0xff, ...cc.subarray(0, ccLength)];
+
+    const data = Uint8Array.from([...do8587, ...do97, ...do8E]);
+
+    if (le <= 256 && data.length <= 255) {
+      return new CommandAPDU(
+        maskedHeader[0],
+        maskedHeader[1],
+        maskedHeader[2],
+        maskedHeader[3],
+        data,
+        0,
+        data.length,
+        256
+      );
+    } else if (le > 256 || data.length > 255) {
+      return new CommandAPDU(
+        maskedHeader[0],
+        maskedHeader[1],
+        maskedHeader[2],
+        maskedHeader[3],
+        data,
+        0,
+        data.length,
+        65536
+      );
+    } else {
+      return new CommandAPDU(
+        maskedHeader[0],
+        maskedHeader[1],
+        maskedHeader[2],
+        maskedHeader[3],
+        data,
+        0,
+        data.length,
+        this.getMaxTransceiveLength()
+      );
+    }
+  }
+
+  private async unwrapResponseAPDU(
+    responseAPDU: ResponseAPDU
+  ): Promise<ResponseAPDU> {
+    const rapdu = responseAPDU.getBytes();
+    if (rapdu == null || rapdu.length < 2) {
+      throw new Error('Invalid response APDU');
+    }
+
+    let data: number[] = [];
+    let cc = null;
+    let sw = 0;
+    const inputStream = new DataInputStream(
+      new ByteArrayInputStream(Buffer.from(rapdu))
+    );
+    try {
+      let isFinished = false;
+      while (!isFinished) {
+        const tag = await inputStream.readByte();
+        switch (tag) {
+          case 0x87:
+            data = await this.readDO87(inputStream, false);
+            break;
+          case 0x85:
+            data = await this.readDO87(inputStream, true);
+            break;
+          case 0x99:
+            sw = await this.readDO99(inputStream);
+            break;
+          case 0x8e:
+            cc = await this.readDO8E(inputStream);
+            isFinished = true;
+            break;
+          default:
+            console.debug(
+              `Unexpected tag ${Buffer.from([tag]).toString('hex')}`
+            );
+            break;
+        }
+      }
+    } finally {
+      inputStream.close();
+    }
+    if (
+      this.getShouldCheckMAC() &&
+      cc &&
+      !this.checkMac(rapdu, Array.from(cc))
+    ) {
+      throw new Error('Invalid MAC');
+    }
+    const bOut: number[] = [];
+    bOut.push(...data);
+    bOut.push(((sw & 0xff00) >> 8) & 0xff);
+    bOut.push(sw & 0x00ff);
+    return new ResponseAPDU(bOut);
+  }
+
+  private encodeLe(le: number) {
+    if (le >= 0 && le <= 256) {
+      /* NOTE: Both 0x00 and 0x100 are mapped to 0x00. */
+      return [le & 0xff];
+    } else {
+      return [((le & 0xff00) >> 8) & 0xff, le & 0xff];
+    }
+  }
+
+  private async readDO87(
+    inputStream: DataInputStream,
+    do85: boolean
+  ): Promise<number[]> {
+    let length = 0;
+    let buf = await inputStream.readUnsignedByte();
+    if ((buf & 0x00000080) !== 0x00000080) {
+      length = buf;
+      if (!do85) {
+        buf = await inputStream.readUnsignedByte();
+        if (buf !== 0x01) {
+          throw new Error(
+            "DO'87 expected 0x01 marker, found " +
+              Buffer.from([buf & 0xff]).toString('hex')
+          );
+        }
+      }
+    } else {
+      const lengthBytesCount = buf & 0x0000007f;
+      for (let i = 0; i < lengthBytesCount; i++) {
+        length = (length << 8) | (await inputStream.readUnsignedByte());
+      }
+      if (!do85) {
+        buf = await inputStream.readUnsignedByte();
+        if (buf !== 0x01) {
+          throw new Error("DO'87 expected 0x01 marker");
+        }
+      }
+    }
+    if (!do85) {
+      length--;
+    }
+    const ciphertext = Buffer.alloc(length);
+    inputStream.readFully(ciphertext);
+    const paddedData = Array.from(
+      Buffer.from(
+        cryptoUtils.decryptWith3DES(
+          Buffer.from(ciphertext).toString('hex'),
+          this.ksEnc
+        ),
+        'hex'
+      )
+    );
+    return cryptoUtils.unpad(paddedData);
+  }
+
+  private async readDO99(inputStream: DataInputStream): Promise<number> {
+    const length = await inputStream.readUnsignedByte();
+    if (length !== 2) {
+      throw new Error("DO'99 wrong length");
+    }
+    const sw1 = await inputStream.readByte();
+    const sw2 = await inputStream.readByte();
+    return ((sw1 & 0x000000ff) << 8) | (sw2 & 0x000000ff);
+  }
+
+  private async readDO8E(inputStream: DataInputStream) {
+    const length = await inputStream.readUnsignedByte();
+    if (length !== 8 && length !== 16) {
+      throw new Error("DO'8E wrong length for MAC: " + length);
+    }
+    const cc = Buffer.alloc(length);
+    inputStream.readFully(cc);
+    return cc;
+  }
+}

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

@@ -0,0 +1,38 @@
+import { CommandAPDU } from './commandAPDU';
+import { ResponseAPDU } from './responseAPDU';
+
+export class APDUEvent {
+  private type: any;
+  private sequenceNumber: number;
+  private capdu: CommandAPDU;
+  private rapdu: ResponseAPDU;
+
+  constructor(
+    private source: any,
+    type: any,
+    sequenceNumber: number,
+    capdu: CommandAPDU,
+    rapdu: ResponseAPDU
+  ) {
+    this.type = type;
+    this.sequenceNumber = sequenceNumber;
+    this.capdu = capdu;
+    this.rapdu = rapdu;
+  }
+
+  getType(): any {
+    return this.type;
+  }
+
+  getSequenceNumber(): number {
+    return this.sequenceNumber;
+  }
+
+  getCommandAPDU(): CommandAPDU {
+    return this.capdu;
+  }
+
+  getResponseAPDU(): ResponseAPDU {
+    return this.rapdu;
+  }
+}

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

@@ -0,0 +1,5 @@
+import { APDUEvent } from './apduEvent';
+
+export interface APDUListener {
+  exchangedAPDU(event: APDUEvent): void;
+}

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

@@ -0,0 +1,10 @@
+import { CommandAPDU } from './commandAPDU';
+import { ResponseAPDU } from './responseAPDU';
+
+export interface APDUWrapper {
+  getType(): string;
+
+  wrap(commandAPDU: CommandAPDU): CommandAPDU;
+
+  unwrap(responseAPDU: ResponseAPDU): Promise<ResponseAPDU>;
+}

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

@@ -0,0 +1,172 @@
+import { Buffer } from 'buffer';
+
+export class CommandAPDU {
+  private static readonly MAX_APDU_SIZE = 65544;
+  private apdu: Uint8Array;
+  private nc: number = 0;
+  private ne: number = 0;
+  private dataOffset: number = 0;
+
+  constructor(
+    cla: number,
+    ins: number,
+    p1: number,
+    p2: number,
+    data: Uint8Array | null,
+    dataOffset?: number,
+    dataLength?: number,
+    ne?: number
+  ) {
+    this.nc = dataLength || 0;
+    this.ne = ne || 0;
+    this.apdu = this.buildAPDU(
+      cla,
+      ins,
+      p1,
+      p2,
+      data,
+      dataOffset || 0,
+      this.nc,
+      this.ne
+    );
+  }
+
+  private buildAPDU(
+    cla: number,
+    ins: number,
+    p1: number,
+    p2: number,
+    data: Uint8Array | null,
+    dataOffset: number = 0,
+    dataLength: number = 0,
+    ne: number = 0
+  ): Uint8Array {
+    let apdu: Uint8Array;
+
+    if (dataLength > 65535) {
+      throw new Error('dataLength is too large');
+    }
+    if (ne < 0) {
+      throw new Error('ne must not be negative');
+    }
+    if (ne > 65536) {
+      throw new Error('ne is too large');
+    }
+
+    if (dataLength === 0) {
+      if (ne === 0) {
+        apdu = new Uint8Array(4);
+        this.setHeader(apdu, cla, ins, p1, p2);
+      } else if (ne <= 256) {
+        apdu = new Uint8Array(5);
+        this.setHeader(apdu, cla, ins, p1, p2);
+        apdu[4] = (ne !== 256 ? ne : 0) & 0xff;
+      } else {
+        apdu = new Uint8Array(7);
+        this.setHeader(apdu, cla, ins, p1, p2);
+        if (ne === 65536) {
+          apdu[5] = 0 & 0xff;
+          apdu[6] = 0 & 0xff;
+        } else {
+          apdu[5] = (ne >> 8) & 0xff;
+          apdu[6] = ne & 0xff;
+        }
+      }
+    } else if (ne === 0) {
+      if (dataLength <= 255) {
+        apdu = new Uint8Array(5 + dataLength);
+        this.setHeader(apdu, cla, ins, p1, p2);
+        apdu[4] = dataLength & 0xff;
+        this.dataOffset = 5;
+        if (data) {
+          apdu.set(data.slice(dataOffset, dataOffset + dataLength), 5);
+        }
+      } else {
+        apdu = new Uint8Array(7 + dataLength);
+        this.setHeader(apdu, cla, ins, p1, p2);
+        apdu[4] = 0 & 0xff;
+        apdu[5] = (dataLength >> 8) & 0xff;
+        apdu[6] = dataLength & 0xff;
+        this.dataOffset = 7;
+        if (data) {
+          apdu.set(data.slice(dataOffset, dataOffset + dataLength), 7);
+        }
+      }
+    } else if (dataLength <= 255 && ne <= 256) {
+      apdu = new Uint8Array(6 + dataLength);
+      this.setHeader(apdu, cla, ins, p1, p2);
+      apdu[4] = dataLength & 0xff;
+      this.dataOffset = 5;
+      if (data) {
+        apdu.set(data.slice(dataOffset, dataOffset + dataLength), 5);
+      }
+      apdu[apdu.length - 1] = (ne !== 256 ? ne : 0) & 0xff;
+    } else {
+      apdu = new Uint8Array(9 + dataLength);
+      this.setHeader(apdu, cla, ins, p1, p2);
+      apdu[4] = 0 & 0xff;
+      apdu[5] = (dataLength >> 8) & 0xff;
+      apdu[6] = dataLength & 0xff;
+      this.dataOffset = 7;
+      if (data) {
+        apdu.set(data.slice(dataOffset, dataOffset + dataLength), 7);
+      }
+      if (ne !== 65536) {
+        const l1 = apdu.length - 2;
+        apdu[l1] = (ne >> 8) & 0xff;
+        apdu[l1 + 1] = ne & 0xff;
+      }
+    }
+
+    return apdu;
+  }
+
+  private setHeader(
+    apdu: Uint8Array,
+    cla: number,
+    ins: number,
+    p1: number,
+    p2: number
+  ) {
+    apdu[0] = cla & 0xff;
+    apdu[1] = ins & 0xff;
+    apdu[2] = p1 & 0xff;
+    apdu[3] = p2 & 0xff;
+  }
+
+  getCLA(): number {
+    return this.apdu[0] & 0xff;
+  }
+
+  getINS(): number {
+    return this.apdu[1] & 0xff;
+  }
+
+  getP1(): number {
+    return this.apdu[2] & 0xff;
+  }
+
+  getP2(): number {
+    return this.apdu[3] & 0xff;
+  }
+
+  getNc(): number {
+    return this.nc;
+  }
+
+  getData(): Uint8Array {
+    return this.apdu.slice(this.dataOffset, this.dataOffset + this.nc);
+  }
+
+  getNe(): number {
+    return this.ne;
+  }
+
+  getBytes(): Uint8Array {
+    return Uint8Array.from(this.apdu);
+  }
+
+  toString(): string {
+    return `CommandAPDU: ${Buffer.from(this.apdu).toString('hex').toUpperCase()} bytes, nc=${this.nc}, ne=${this.ne}`;
+  }
+}

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

@@ -0,0 +1,7 @@
+import { FileInfo } from '../fileInfo';
+
+export interface FileSystemStructured {
+  selectFile(var1: number): void;
+  readBinary(var1: number, var2: number): Promise<Uint8Array>;
+  getSelectedPath(): Promise<FileInfo[] | null>;
+}

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

@@ -0,0 +1,104 @@
+export enum ISO7816_OFFSET {
+  CLA = 0x00,
+  INS = 0x01,
+  P1 = 0x02,
+  P2 = 0x03,
+  LC = 0x04,
+  CDATA = 0x05,
+}
+
+export enum ISO7816_CLA {
+  ISO7816 = 0x00,
+  COMMAND_CHAINING = 0x10,
+}
+
+export enum ISO7816_INS {
+  INVALIDATE_CHV = 0x04,
+  ERASE_BINARY = 0x0e,
+  VERIFY = 0x20,
+  CHANGE_CHV = 0x24,
+  UNBLOCK_CHV = 0x2c,
+  DECREASE = 0x30,
+  INCREASE = 0x32,
+  DECREASE_STAMPED = 0x34,
+  REHABILITATE_CHV = 0x44,
+  MANAGE_CHANNEL = 0x70,
+  EXTERNAL_AUTHENTICATE = 0x82,
+  MUTUAL_AUTHENTICATE = 0x82,
+  GET_CHALLENGE = 0x84,
+  ASK_RANDOM = 0x84,
+  GIVE_RANDOM = 0x86,
+  INTERNAL_AUTHENTICATE = 0x88,
+  SEEK = 0xa2,
+  SELECT = 0xa4,
+  SELECT_FILE = 0xa4,
+  CLOSE_APPLICATION = 0xac,
+  READ_BINARY = 0xb0,
+  READ_BINARY2 = 0xb1,
+  READ_RECORD = 0xb2,
+  READ_RECORD2 = 0xb3,
+  READ_RECORDS = 0xbb,
+  READ_BINARY_STAMPED = 0xbc,
+  READ_RECORD_STAMPED = 0xbd,
+  GET_RESPONSE = 0xc0,
+  ENVELOPE = 0xc2,
+  GET_DATA = 0xca,
+  WRITE_BINARY = 0xd0,
+  WRITE_RECORD = 0xd2,
+  UPDATE_BINARY = 0xd6,
+  LOAD_KEY_FILE = 0xd8,
+  PUT_DATA = 0xda,
+  UPDATE_RECORD = 0xdc,
+  CREATE_FILE = 0xe0,
+  APPEND_RECORD = 0xe2,
+  DELETE_FILE = 0xe4,
+  PSO = 0xe8,
+  MSE = 0x22,
+}
+
+export enum ISO7816_TAG {
+  SM_ENCRYPTED_DATA = 0x85,
+  SM_ENCRYPTED_DATA_WITH_PADDING_INDICATOR = 0x87,
+  SM_CRYPTOGRAPHIC_CHECKSUM = 0x8e,
+  SM_EXPECTED_LENGTH = 0x97,
+  SM_STATUS_WORD = 0x99,
+}
+
+export enum ISO7816_SW {
+  BYTES_REMAINING_00 = 0x6100,
+  STATE_NON_VOLATILE_MEMORY_UNCHANGED_NO_INFORMATION_GIVEN = 0x6200,
+  END_OF_FILE = 0x6282,
+  LESS_DATA_RESPONDED_THAN_REQUESTED = 0x6287,
+  NON_VOLATILE_MEMORY_CHANGED_NO_INFORMATION_GIVEN = 0x6300,
+  NON_VOLATILE_MEMORY_CHANGED_FILE_FILLED_UP_BY_LAST_WRITE = 0x6381,
+  NON_VOLATILE_MEMORY_CHANGED_COUNTER_0 = 0x63c0,
+  WRONG_LENGTH = 0x6700,
+  LOGICAL_CHANNEL_NOT_SUPPORTED = 0x6881,
+  SECURE_MESSAGING_NOT_SUPPORTED = 0x6882,
+  LAST_COMMAND_EXPECTED = 0x6883,
+  SECURITY_STATUS_NOT_SATISFIED = 0x6982,
+  FILE_INVALID = 0x6983,
+  DATA_INVALID = 0x6984,
+  CONDITIONS_NOT_SATISFIED = 0x6985,
+  COMMAND_NOT_ALLOWED = 0x6986,
+  EXPECTED_SM_DATA_OBJECTS_MISSING = 0x6987,
+  SM_DATA_OBJECTS_INCORRECT = 0x6988,
+  APPLET_SELECT_FAILED = 0x6999,
+  KEY_USAGE_ERROR = 0x69c1,
+  WRONG_DATA = 0x6a80,
+  FILEHEADER_INCONSISTENT = 0x6a80,
+  FUNC_NOT_SUPPORTED = 0x6a81,
+  FILE_NOT_FOUND = 0x6a82,
+  RECORD_NOT_FOUND = 0x6a83,
+  FILE_FULL = 0x6a84,
+  OUT_OF_MEMORY = 0x6a85,
+  INCORRECT_P1P2 = 0x6a86,
+  KEY_NOT_FOUND = 0x6a88,
+  WRONG_P1P2 = 0x6b00,
+  CORRECT_LENGTH_00 = 0x6c00,
+  NOT_SUPPORTED = 0x6d00,
+  CLA_NOT_SUPPORTED = 0x6e00,
+  UNKNOWN = 0x6f00,
+  CARD_TERMINATED = 0x6ffe,
+  NO_ERROR = 0x9000,
+}