@trustchex/react-native-sdk 1.161.0

package/src/Shared/Components/QrCodeScannerCamera.tsx

@@ -0,0 +1,306 @@
+import React, { useEffect } from 'react';
+import {
+  View,
+  StyleSheet,
+  ActivityIndicator,
+  Text as TextView,
+  Text,
+  Linking,
+} from 'react-native';
+import {
+  Camera,
+  useCameraDevice,
+  useCameraFormat,
+  useCameraPermission,
+  useFrameProcessor,
+  type Orientation,
+} from 'react-native-vision-camera';
+import { useRunOnJS, useSharedValue } from 'react-native-worklets-core';
+import { useKeepAwake } from '../Libs/native-keep-awake.utils';
+import { useIsFocused } from '@react-navigation/native';
+import { useTranslation } from 'react-i18next';
+import LottieView from 'lottie-react-native';
+import { type Barcode, scanCodes } from '../VisionCameraPlugins/BarcodeScanner';
+import { Button } from 'react-native-paper';
+
+export interface QrCodeScannerCameraProps {
+  onQrCodeScanned: (data: string) => void;
+}
+
+const QrCodeScannerCamera = ({ onQrCodeScanned }: QrCodeScannerCameraProps) => {
+  useKeepAwake();
+  const cameraPermission = useCameraPermission();
+  const [permissionsRequested, setPermissionsRequested] = React.useState(false);
+  const [isActive, setIsActive] = React.useState(false);
+  const isFocused = useIsFocused();
+  const device = useCameraDevice('back', {
+    physicalDevices: ['wide-angle-camera'],
+  });
+  const format = useCameraFormat(device, [
+    {
+      videoResolution: {
+        width: 1920,
+        height: 1080,
+      },
+      iso: 'max',
+      photoHdr: false,
+      videoHdr: false,
+    },
+  ]);
+  const isCameraInitialized = useSharedValue(false);
+  const { t } = useTranslation();
+
+  const isInScanningFrame = (
+    code: Barcode,
+    width: number,
+    height: number,
+    orientation: Orientation
+  ) => {
+    const scanningFrame = {
+      x: 0.35 * width,
+      y: 0.03 * height,
+      width: 0.3 * width,
+      height: 0.94 * height,
+    };
+
+    if (orientation === 'landscape-right' || orientation === 'landscape-left') {
+      // Adjust scanning frame for landscape orientation
+      scanningFrame.x = 0.03 * height;
+      scanningFrame.y = 0.35 * width;
+      scanningFrame.width = 0.94 * height;
+      scanningFrame.height = 0.3 * width;
+    }
+
+    // Assuming Barcode has a boundingBox property: { x, y, width, height }
+    const boundingBox = code.boundingBox;
+    if (!boundingBox) {
+      return false;
+    }
+    const codeX = boundingBox.origin.x;
+    const codeY = boundingBox.origin.y;
+    const codeWidth = boundingBox.size.width;
+    const codeHeight = boundingBox.size.height;
+    const codeRight = codeX + codeWidth;
+    const codeBottom = codeY + codeHeight;
+    const frameRight = scanningFrame.x + scanningFrame.width;
+    const frameBottom = scanningFrame.y + scanningFrame.height;
+
+    // Check if the code is within the scanning frame
+    if (
+      codeX >= scanningFrame.x &&
+      codeY >= scanningFrame.y &&
+      codeRight <= frameRight &&
+      codeBottom <= frameBottom
+    ) {
+      return true;
+    }
+
+    return false;
+  };
+
+  const handleQrCode = useRunOnJS(
+    (
+      code: Barcode,
+      width: number,
+      height: number,
+      orientation: Orientation
+    ) => {
+      if (isInScanningFrame(code, width, height, orientation) && code.value) {
+        onQrCodeScanned(code.value);
+      }
+    },
+    [onQrCodeScanned]
+  );
+
+  const frameProcessor = useFrameProcessor((frame) => {
+    'worklet';
+
+    if (!isCameraInitialized.value) {
+      return;
+    }
+
+    const codes = scanCodes(frame, { barcodeTypes: ['qr'] });
+
+    if (codes && codes.length === 1) {
+      handleQrCode(codes[0], frame.width, frame.height, frame.orientation);
+    }
+  }, []);
+
+  useEffect(() => {
+    const requestPermissions = async () => {
+      if (!cameraPermission.hasPermission) {
+        await cameraPermission.requestPermission();
+      }
+      setPermissionsRequested(true);
+    };
+    requestPermissions();
+  }, [cameraPermission]);
+
+  useEffect(() => {
+    if (!!device && !!format && isFocused) {
+      setIsActive(true);
+    } else {
+      setIsActive(false);
+    }
+
+    return () => {
+      setIsActive(false);
+    };
+  }, [device, format, isFocused]);
+
+  if (!permissionsRequested) {
+    return (
+      <View style={styles.permissionContainer}>
+        <ActivityIndicator size="large" />
+      </View>
+    );
+  }
+
+  if (!cameraPermission.hasPermission) {
+    return (
+      <View style={styles.permissionContainer}>
+        <Text style={styles.permissionText}>
+          {t('general.noCameraPermissionGiven')}
+        </Text>
+        <Button
+          mode="contained"
+          onPress={() => {
+            Linking.openSettings();
+          }}
+        >
+          {t('general.openSettings')}
+        </Button>
+      </View>
+    );
+  }
+
+  if (device == null) {
+    return (
+      <View style={styles.permissionContainer}>
+        <TextView style={styles.permissionText}>
+          {t('general.noCameraDetected')}
+        </TextView>
+      </View>
+    );
+  }
+
+  return (
+    <View style={StyleSheet.absoluteFill}>
+      <Camera
+        style={StyleSheet.absoluteFill}
+        frameProcessor={frameProcessor}
+        device={device}
+        format={format}
+        isActive={isActive}
+        photo={false}
+        video={false}
+        audio={false}
+        onInitialized={() => {
+          isCameraInitialized.value = true;
+        }}
+        fps={30}
+      />
+      <View style={styles.topZone}>
+        <TextView style={styles.topZoneText}>
+          {t('verificationSessionCheckScreen.scanQRCode')}
+        </TextView>
+      </View>
+      <View style={styles.leftZone} />
+      <View style={styles.rightZone} />
+      <View style={styles.bottomZone} />
+      <View style={styles.scanArea}>
+        <LottieView
+          source={require('../../Shared/Animations/scanning.json')}
+          style={styles.animation}
+          loop={true}
+          autoPlay
+        />
+      </View>
+    </View>
+  );
+};
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+  },
+  permissionContainer: {
+    flex: 1,
+    justifyContent: 'center',
+    alignItems: 'center',
+    gap: 20,
+    padding: 20,
+  },
+  permissionText: {
+    color: 'black',
+    fontSize: 20,
+    textAlign: 'center',
+    fontWeight: 'bold',
+  },
+  scanArea: {
+    position: 'absolute',
+    top: '35%',
+    left: '3%',
+    right: '3%',
+    bottom: '35%',
+    borderWidth: 5,
+    zIndex: 100,
+    display: 'flex',
+    justifyContent: 'center',
+    alignItems: 'center',
+    paddingHorizontal: 5,
+    borderColor: 'white',
+  },
+  animation: {
+    width: '100%',
+    height: '100%',
+  },
+  topZone: {
+    position: 'absolute',
+    top: 0,
+    left: 0,
+    right: 0,
+    bottom: '65%',
+    backgroundColor: '#00000099',
+    justifyContent: 'flex-end',
+    alignItems: 'center',
+  },
+  topZoneText: {
+    color: 'white',
+    fontSize: 20,
+    textAlign: 'center',
+    fontWeight: 'bold',
+    padding: 20,
+  },
+  leftZone: {
+    position: 'absolute',
+    top: '35%',
+    left: 0,
+    right: '97%',
+    bottom: '35%',
+    backgroundColor: '#00000099',
+  },
+  rightZone: {
+    position: 'absolute',
+    top: '35%',
+    left: '97%',
+    right: 0,
+    bottom: '35%',
+    backgroundColor: '#00000099',
+  },
+  bottomZone: {
+    position: 'absolute',
+    top: '65%',
+    left: 0,
+    right: 0,
+    bottom: 0,
+    backgroundColor: '#00000099',
+    padding: 20,
+    display: 'flex',
+    flexDirection: 'row',
+    gap: 20,
+    justifyContent: 'space-between',
+  },
+});
+
+export default QrCodeScannerCamera;

package/src/Shared/Contexts/AppContext.ts

@@ -0,0 +1,47 @@
+import { createContext } from 'react';
+import type {
+  IdentificationInfo,
+  WorkflowStep,
+} from '../Types/identificationInfo';
+
+export type AppContextType = {
+  isDemoSession: boolean;
+  baseUrl: string;
+  locale?: string;
+  branding: {
+    logoUrl?: string;
+    primaryColor: string;
+    secondaryColor: string;
+    tertiaryColor: string;
+  };
+  identificationInfo: IdentificationInfo;
+  workflowSteps?: WorkflowStep[];
+  currentWorkflowStep?: WorkflowStep;
+  onCompleted?: () => void;
+  onError?: (error: string) => void;
+};
+
+export default createContext<AppContextType>({
+  isDemoSession: false,
+  baseUrl: '',
+  locale: 'en',
+  branding: {
+    logoUrl: '',
+    primaryColor: '',
+    secondaryColor: '',
+    tertiaryColor: '',
+  },
+  identificationInfo: {
+    sessionId: '',
+    identificationId: '',
+    consent: {
+      contractIds: [],
+      deviceInfo: '',
+    },
+    locale: 'en',
+  },
+  workflowSteps: [],
+  currentWorkflowStep: undefined,
+  onCompleted: undefined,
+  onError: undefined,
+});

package/src/Shared/EIDReader/abstractMRTDCardService.ts

@@ -0,0 +1,195 @@
+import type { AccessKeySpec } from './accessKeySpec';
+import { FileSystemCardService } from './fileSystemCardService';
+import { BACResult } from './protocol/bacResult';
+import { SecureMessagingWrapper } from './secureMessagingWrapper';
+
+export abstract class AbstractMRTDCardService extends FileSystemCardService {
+  /**
+   * Performs the <i>Basic Access Control</i> protocol.
+   *
+   * @param bacKey the key based on the document number,
+   *               the card holder's birth date,
+   *               and the document's expiration date
+   *
+   * @return the BAC result
+   *
+   * @throws CardServiceException if authentication failed
+   */
+  public abstract doBAC(bacKey: AccessKeySpec): Promise<BACResult>;
+
+  //   /**
+  //    * Performs the PACE 2.0 / SAC protocol.
+  //    * A secure messaging channel is set up as a result.
+  //    *
+  //    * @param keySpec the MRZ
+  //    * @param oid as specified in the PACEInfo, indicates GM or IM or CAM, DH or ECDH, cipher, digest, length
+  //    * @param params explicit static domain parameters the domain params for DH or ECDH
+  //    *
+  //    * @return the result
+  //    *
+  //    * @throws CardServiceException if authentication failed or on error
+  //    *
+  //    * @deprecated Use the variant with additional parameter identifier
+  //    */
+  //   public doPACE(
+  //     keySpec: AccessKeySpec,
+  //     oid: string,
+  //     params: AlgorithmParameterSpec,
+  //   ): PACEResult {
+  //     return this.doPACE(keySpec, oid, params, null);
+  //   }
+
+  //   /**
+  //    * Performs the PACE 2.0 / SAC protocol.
+  //    * A secure messaging channel is set up as a result.
+  //    *
+  //    * @param keySpec the MRZ
+  //    * @param oid as specified in the PACEInfo, indicates GM or IM or CAM, DH or ECDH, cipher, digest, length
+  //    * @param params explicit static domain parameters the domain params for DH or ECDH
+  //    * @param parameterId parameter identifier or {@code null}
+  //    *
+  //    * @return the result
+  //    *
+  //    * @throws CardServiceException if authentication failed or on error
+  //    */
+  //   public abstract doPACE(
+  //     keySpec: AccessKeySpec,
+  //     oid: string,
+  //     params: AlgorithmParameterSpec,
+  //     parameterId: BigInteger,
+  //   ): PACEResult;
+
+  /**
+   * Selects the card side applet. If PACE has been executed successfully previously, then the card has authenticated
+   * us and a secure messaging channel has already been established. If not, then the caller should request BAC execution
+   * as a next step.
+   *
+   * @param shouldUseSecureMessaging indicates whether a secure messaging channel has already been established
+   *                                 (which is the case if PACE has been executed)
+   *
+   * @throws CardServiceException on error
+   */
+  public abstract sendSelectApplet(
+    shouldUseSecureMessaging: boolean
+  ): Promise<void>;
+
+  /**
+   * Selects the master file.
+   *
+   * @throws CardServiceException on error
+   */
+  public abstract sendSelectMF(): Promise<void>;
+
+  //   /**
+  //    * Performs the <i>Active Authentication</i> protocol.
+  //    *
+  //    * @param publicKey the public key to use (usually read from the card)
+  //    * @param digestAlgorithm the digest algorithm to use, or null
+  //    * @param signatureAlgorithm signature algorithm
+  //    * @param challenge challenge
+  //    *
+  //    * @return a boolean indicating whether the card was authenticated
+  //    *
+  //    * @throws CardServiceException on error
+  //    */
+  //   public abstract doAA(
+  //     publicKey: PublicKey,
+  //     digestAlgorithm: string,
+  //     signatureAlgorithm: string,
+  //     challenge: Uint8Array,
+  //   ): AAResult;
+
+  //   /**
+  //    * Perform CA (Chip Authentication) part of EAC (version 1). For details see TR-03110
+  //    * ver. 1.11. In short, we authenticate the chip with (EC)DH key agreement
+  //    * protocol and create new secure messaging keys.
+  //    * A new secure messaging channel is set up as a result.
+  //    *
+  //    * @param keyId the chip's public key id (stored in DG14), {@code null} if none
+  //    * @param oid the object identifier indicating the Chip Authentication protocol
+  //    * @param publicKeyOID the object identifier indicating the public key algorithm used
+  //    * @param publicKey passport's public key (stored in DG14)
+  //    *
+  //    * @return the Chip Authentication result
+  //    *
+  //    * @throws CardServiceException if CA failed or some error occurred
+  //    */
+  //   public abstract doEACCA(
+  //     keyId: BigInteger,
+  //     oid: string,
+  //     publicKeyOID: string,
+  //     publicKey: PublicKey,
+  //   ): EACCAResult;
+
+  //   /**
+  //    * Performs <i>Terminal Authentication</i> (TA) part of EAC (version 1). For details see
+  //    * TR-03110 ver. 1.11.
+  //    *
+  //    * In short, we feed the sequence of terminal certificates to the card for verification,
+  //    * get a challenge from the card, sign it with the terminal private key, and send the result
+  //    * back to the card for verification.
+  //    *
+  //    * @param caReference reference issuer
+  //    * @param terminalCertificates terminal certificate chain
+  //    * @param terminalKey terminal private key
+  //    * @param taAlg algorithm
+  //    * @param chipAuthenticationResult the chip authentication result
+  //    * @param documentNumber the document number
+  //    *
+  //    * @return the Terminal Authentication result
+  //    *
+  //    * @throws CardServiceException on error
+  //    */
+  //   public abstract doEACTA(
+  //     caReference: CVCPrincipal,
+  //     terminalCertificates: CardVerifiableCertificate[],
+  //     terminalKey: PrivateKey,
+  //     taAlg: string,
+  //     chipAuthenticationResult: EACCAResult,
+  //     documentNumber: string,
+  //   ): EACTAResult;
+
+  //   /**
+  //    * Performs <i>Terminal Authentication</i> (TA) part of EAC (version 1). For details see
+  //    * TR-03110 ver. 1.11.
+  //    *
+  //    * In short, we feed the sequence of terminal certificates to the card for verification,
+  //    * get a challenge from the card, sign it with the terminal private key, and send the result
+  //    * back to the card for verification.
+  //    *
+  //    * @param caReference reference issuer
+  //    * @param terminalCertificates terminal certificate chain
+  //    * @param terminalKey terminal private key
+  //    * @param taAlg algorithm
+  //    * @param chipAuthenticationResult the chip authentication result
+  //    * @param paceResult the PACE result
+  //    *
+  //    * @return the Terminal Authentication result
+  //    *
+  //    * @throws CardServiceException on error
+  //    */
+  //   public abstract doEACTA(
+  //     caReference: CVCPrincipal,
+  //     terminalCertificates: CardVerifiableCertificate[],
+  //     terminalKey: PrivateKey,
+  //     taAlg: string,
+  //     chipAuthenticationResult: EACCAResult,
+  //     paceResult: PACEResult,
+  //   ): EACTAResult;
+
+  /**
+   * Returns the secure messaging wrapper currently in use.
+   *
+   * @return the secure messaging wrapper
+   */
+  public abstract getWrapper(): SecureMessagingWrapper | null;
+
+  /**
+   * Returns the currently set maximum length to be requested in READ BINARY commands.
+   * If the applet file system has not yet been selected, this will return the normal
+   * length.
+   *
+   * @return the currently set maximum length to be requested in READ BINARY commands
+   */
+  public abstract getMaxReadBinaryLength(): number;
+}

package/src/Shared/EIDReader/accessKeySpec.ts

@@ -0,0 +1,16 @@
+export interface AccessKeySpec {
+  /**
+   * Returns the type of access key.
+   * Typical values are {@code "BAC"}, and {@code "PACE"}.
+   *
+   * @return the type of access key
+   */
+  getAlgorithm(): string;
+
+  /**
+   * Returns the bytes used for deriving the key seed.
+   *
+   * @return the key seed as hex string
+   */
+  getKey(): string;
+}

package/src/Shared/EIDReader/apduLevelBACCapable.ts

@@ -0,0 +1,10 @@
+export interface APDULevelBACCapable {
+  sendGetChallenge(): Promise<string>;
+  sendMutualAuth(
+    rndIFD: string,
+    rndICC: string,
+    kIFD: string,
+    kEnc: string,
+    kMac: string
+  ): Promise<string>;
+}

package/src/Shared/EIDReader/apduLevelReadBinaryCapable.ts

@@ -0,0 +1,15 @@
+import type { APDUWrapper } from './smartcards/apduWrapper';
+
+export interface APDULevelReadBinaryCapable {
+  sendSelectApplet(wrapper: APDUWrapper | null, aid: Uint8Array): Promise<void>;
+  sendSelectMF(): Promise<void>;
+  sendSelectFile(wrapper: APDUWrapper, fid: number): Promise<void>;
+  sendReadBinary(
+    wrapper: APDUWrapper,
+    sfi: number,
+    offset: number,
+    le: number,
+    isSFIEnabled: boolean,
+    isTLVEncodedOffsetNeeded: boolean
+  ): Promise<Uint8Array | null>;
+}