banking_dcb_sdk_react_native 0.1.9

package/src/helpers/network/Encryption.tsx

@@ -0,0 +1,179 @@
+// Encryption.ts
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { v4 as uuidv4 } from 'uuid';
+import * as base64js from 'base64-js';
+import { ServiceNames } from '../ServiceNames';
+
+import crypto from 'react-native-quick-crypto';
+import { Buffer } from '@craftzdog/react-native-buffer';
+
+const {
+  randomBytes,
+  createCipheriv,
+  createDecipheriv,
+  publicEncrypt,
+  constants,
+  createPublicKey,
+} = crypto;
+
+type WebsiteKey = { kid: string; public: string; expiry: string };
+
+const KEY_WEB = 'KEY_WEB';
+const KEY_WEB_EXPIRY = 'KEY_WEB_EXPIRY';
+const GCM_NONCE_LEN = 12; // 12-byte IV
+const GCM_TAG_LEN = 16; // 16-byte tag
+const AES_KEY_LEN_BYTES = 32; // 256 bits
+
+// --- small utils ---
+const bytesToB64 = (u8: Uint8Array) => base64js.fromByteArray(u8);
+const b64ToBytes = (b64: string) => base64js.toByteArray(b64);
+
+// ---------- AES-256-GCM ----------
+
+/** Generate random 32-byte AES key */
+export function generateAESKey(): Uint8Array {
+  return new Uint8Array(randomBytes(AES_KEY_LEN_BYTES));
+}
+
+/** Export AES key bytes -> Base64 (for RSA input) */
+export function exportAESKeyBase64(keyBytes: Uint8Array): string {
+  return bytesToB64(keyBytes);
+}
+
+/** Encrypt plaintext -> Base64( IV || ciphertext || tag ) */
+export function encryptAES(plaintext: string, keyBytes: Uint8Array): string {
+  const iv = new Uint8Array(randomBytes(GCM_NONCE_LEN));
+  const cipher = createCipheriv(
+    'aes-256-gcm',
+    Buffer.from(keyBytes),
+    Buffer.from(iv)
+  );
+
+  const ct1 = cipher.update(plaintext, 'utf8');
+  const ct2 = cipher.final();
+  const ciphertext = Buffer.concat([ct1, ct2]);
+
+  const tag = cipher.getAuthTag(); // 16 bytes
+
+  const out = new Uint8Array(iv.length + ciphertext.length + tag.length);
+  out.set(iv, 0);
+  out.set(ciphertext, iv.length);
+  out.set(tag, iv.length + ciphertext.length);
+
+  return bytesToB64(out);
+}
+
+/** Decrypt Base64( IV || ciphertext || tag ) -> plaintext */
+export function decryptAES(b64Data: string, keyBytes: Uint8Array): string {
+  const data = b64ToBytes(b64Data);
+  if (data.length < GCM_NONCE_LEN + GCM_TAG_LEN + 1) {
+    throw new Error('Invalid GCM payload length');
+  }
+  const iv = data.slice(0, GCM_NONCE_LEN);
+  const tag = data.slice(data.length - GCM_TAG_LEN);
+  const ct = data.slice(GCM_NONCE_LEN, data.length - GCM_TAG_LEN);
+
+  const decipher = createDecipheriv(
+    'aes-256-gcm',
+    Buffer.from(keyBytes),
+    Buffer.from(iv)
+  );
+  decipher.setAuthTag(Buffer.from(tag));
+
+  const pt1 = decipher.update(Buffer.from(ct));
+  const pt2 = decipher.final();
+  return Buffer.concat([pt1, pt2]).toString('utf8');
+}
+
+// ---------- RSA-OAEP (SHA-256) ----------
+
+/** RSA-OAEP(SHA-256) encrypt UTF-8 bytes of Base64(AES key) -> Base64 ciphertext */
+export function encryptAESKeyWithRSA(
+  aesKeyBase64: string,
+  publicKeyPem: string
+): string {
+  const buf = Buffer.from(aesKeyBase64, 'utf8');
+  const enc = publicEncrypt(
+    {
+      key: publicKeyPem,
+      padding: constants.RSA_PKCS1_OAEP_PADDING,
+      oaepHash: 'sha256',
+    },
+    buf
+  );
+  return enc.toString('base64');
+}
+
+// ---------- Website key fetch / cache ----------
+
+export async function getWebsiteKey(): Promise<WebsiteKey> {
+  // const cachedJson = await AsyncStorage.getItem(KEY_WEB);
+  // const cachedExpiry = await AsyncStorage.getItem(KEY_WEB_EXPIRY);
+  // if (cachedJson && cachedExpiry) {
+  //   try {
+  //     if (new Date() < new Date(cachedExpiry)) {
+  //       return JSON.parse(cachedJson) as WebsiteKey;
+  //     }
+  //   } catch {
+  //     /* ignore */
+  //   }
+  // }
+
+  // const txnId = uuidv4();
+  const resp = await fetch(ServiceNames.WEBSITE_KEYS, {
+    method: 'GET',
+    // headers: { 'X-Txn-ID': txnId },
+  });
+  if (!resp.ok) throw new Error(`Website keys fetch failed: ${resp.status}`);
+
+  const raw = await resp.json();
+  console.log('Website keys response:', raw);
+  let obj: any;
+  if (
+    raw &&
+    typeof raw === 'object' &&
+    !(
+      Object.prototype.hasOwnProperty.call(raw, 'kid') &&
+      (Object.prototype.hasOwnProperty.call(raw, 'public') ||
+        Object.prototype.hasOwnProperty.call(raw, 'public_key'))
+    )
+  ) {
+    const values = Object.values(raw);
+    if (!values.length || typeof values[0] !== 'object') {
+      throw new Error('Unexpected keyset response shape');
+    }
+    obj = values[0];
+  } else {
+    obj = raw;
+  }
+
+  const kid: string | undefined = obj.kid ?? obj.KID;
+  const publicKey: string | undefined = obj.public ?? obj.public_key;
+  const expiry: string | undefined = obj.expiry ?? obj.exp ?? obj.expiresAt;
+  if (!kid || !publicKey || !expiry)
+    throw new Error('Missing kid/public/expiry');
+
+  const normalized: WebsiteKey = { kid, public: publicKey, expiry };
+  await AsyncStorage.setItem(KEY_WEB, JSON.stringify(normalized));
+  await AsyncStorage.setItem(KEY_WEB_EXPIRY, expiry);
+  return normalized;
+}
+
+// ---------- Optional: one-liners ----------
+
+export type HybridEnvelope = {
+  kid: string;
+  rsaWrappedAESKey: string; // Base64 RSA(OAEP) of Base64(AES key)
+  cipherData: string; // Base64( IV || ciphertext || tag )
+};
+
+export async function encryptHybrid(
+  plaintext: string
+): Promise<HybridEnvelope> {
+  const { kid, public: publicPem } = await getWebsiteKey();
+  const aesKey = generateAESKey();
+  const cipherData = encryptAES(plaintext, aesKey);
+  const aesKeyB64 = exportAESKeyBase64(aesKey);
+  const rsaWrappedAESKey = encryptAESKeyWithRSA(aesKeyB64, publicPem);
+  return { kid, rsaWrappedAESKey, cipherData };
+}

package/src/helpers/network/network_manager.tsx

@@ -0,0 +1,122 @@
+import axios, { type AxiosInstance, type AxiosResponse, type AxiosRequestConfig } from 'axios';
+
+class NetworkManager {
+  private static _instance: NetworkManager = new NetworkManager();
+  private _axios: AxiosInstance;
+
+  constructor() {
+    this._axios = axios.create();
+  }
+
+  static getInstance(): NetworkManager {
+    return NetworkManager._instance;
+  }
+
+  async request({
+    url,
+    method,
+    body,
+    headers,
+    options,
+  }: {
+    url: string;
+    method: string;
+    body?: Record<string, any>;
+    headers?: Record<string, any>;
+    options?: AxiosRequestConfig;
+  }): Promise<AxiosResponse | null> {
+    try {
+      headers = headers || {};
+      options = options || { headers };
+
+      let response: AxiosResponse;
+      const config: AxiosRequestConfig = {
+        ...options,
+        headers,
+      };
+
+      switch (method.toUpperCase()) {
+        case 'POST':
+          response = await this._axios.post(url, body, config);
+          break;
+        case 'GET':
+          response = await this._axios.get(url, config);
+          break;
+        case 'PUT':
+          response = await this._axios.put(url, body, config);
+          break;
+        case 'PATCH':
+          response = await this._axios.patch(url, body, config);
+          break;
+        case 'DELETE':
+          response = await this._axios.delete(url, {
+            ...config,
+            data: body,
+          });
+          break;
+        default:
+          throw new Error(`Method not supported: ${method}`);
+      }
+
+      return response;
+    } catch (error) {
+      if (__DEV__) {
+        if (axios.isAxiosError(error)) {
+          if (!error.response) {
+            console.log("Network error:", error.message);
+          }
+          return error.response || null;
+        } else {
+          console.log("Unexpected error during network request:", error);
+        }
+      }
+      throw error;
+    }
+  }
+
+  async get(
+    url: string,
+    headers?: Record<string, any>,
+    options?: AxiosRequestConfig
+  ): Promise<AxiosResponse | null> {
+    return this.request({ url, method: 'GET', headers, options });
+  }
+
+  async post(
+    url: string,
+    body: Record<string, any>,
+    headers?: Record<string, any>,
+    options?: AxiosRequestConfig
+  ): Promise<AxiosResponse | null> {
+    return this.request({ url, method: 'POST', body, headers, options });
+  }
+
+  async put(
+    url: string,
+    body: Record<string, any>,
+    headers?: Record<string, any>,
+    options?: AxiosRequestConfig
+  ): Promise<AxiosResponse | null> {
+    return this.request({ url, method: 'PUT', body, headers, options });
+  }
+
+  async patch(
+    url: string,
+    body: Record<string, any>,
+    headers?: Record<string, any>,
+    options?: AxiosRequestConfig
+  ): Promise<AxiosResponse | null> {
+    return this.request({ url, method: 'PATCH', body, headers, options });
+  }
+
+  async delete(
+    url: string,
+    headers?: Record<string, any>,
+    body?: Record<string, any>,
+    options?: AxiosRequestConfig
+  ): Promise<AxiosResponse | null> {
+    return this.request({ url, method: 'DELETE', body, headers, options });
+  }
+}
+
+export default NetworkManager;

package/src/helpers/utils/Constants.tsx

@@ -0,0 +1,10 @@
+export const Constants = {
+
+    MANUFACTURER: "manufacturer",
+    MODEL: "model",
+    OS: "os",
+    OS_VERSION: "os_version",
+    APP_VERSION: "app_version",
+    DEVICE_UUID: "device_uuid",
+    PRIMARY_COLOR: "#3F51B5"
+} as const;

package/src/helpers/utils/LibraryConstants.tsx

@@ -0,0 +1,133 @@
+import { Platform } from 'react-native';
+
+interface Color {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+
+// interface ColorWithValues extends Color {
+//     withValues(params: { red: number; green: number; blue: number; alpha: number }): string;
+// }
+
+// Helper function for color handling
+const hexToRgba = (hex: string): Color => {
+    const match = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+
+    if (match && match[1] && match[2] && match[3]) {
+        return {
+            r: parseInt(match[1], 16),
+            g: parseInt(match[2], 16),
+            b: parseInt(match[3], 16),
+            a: 1,
+        };
+    }
+
+    return { r: 0, g: 0, b: 0, a: 1 };
+};
+
+
+
+// const rgbaToHex = (color: Color): string => {
+//     return `#${color.r.toString(16).padStart(2, '0')}${color.g.toString(16).padStart(2, '0')}${color.b.toString(16).padStart(2, '0')}`;
+// };
+
+const rgbaToString = (color: Color): string => {
+    return `rgba(${color.r}, ${color.g}, ${color.b}, ${color.a})`;
+};
+
+export class LibraryConstants {
+
+
+    static deviceBindingEnabled: boolean = true;
+
+    // Primary color definition
+    private static _primaryColorHex: string = '#037EAB';
+    private static _primaryColorObj: Color = hexToRgba('#037EAB');
+
+    // static get primaryColor(): string {
+    //     return this._primaryColorHex;
+    // }
+
+    static set primaryColor(value: string) {
+        this._primaryColorHex = value;
+        this._primaryColorObj = hexToRgba(value);
+    }
+    private static rgbToHex(r: number, g: number, b: number): string {
+        return `#${[r, g, b]
+            .map(x => {
+                const hex = x.toString(16);
+                return hex.length === 1 ? '0' + hex : hex;
+            })
+            .join('')}`;
+    }
+
+    static setPrimaryColorFromRGB(r: number, g: number, b: number): void {
+        this._primaryColorObj = { r, g, b, a: 1 };
+        this._primaryColorHex = LibraryConstants.rgbToHex(r, g, b);
+    }
+
+
+
+
+    static secondaryColor: string = '#FFFFFF';
+
+    // Calculate disabled primary color (with 50% opacity)
+    static get primaryColorDisabled(): string {
+        return rgbaToString({
+            r: this._primaryColorObj.r,
+            g: this._primaryColorObj.g,
+            b: this._primaryColorObj.b,
+            a: 0.5
+        });
+    }
+
+    static openExternally: string[] = [""];
+    static whitelistedUrlsAndroid: string[] = [];
+    static whitelistedUrlsIos: string[] = [];
+    static hostName: string = "";
+    static whitelistedDomains: string[] = [];
+
+    static init({
+        host,
+        // whitelistedAndroid,
+        // whitelistedIos,
+        whitelistedDomains,
+        deviceBinding,
+    }: {
+        host: string;
+        whitelistedDomains: string[]
+        // whitelistedAndroid?: string[];
+        // whitelistedIos?: string[];
+        deviceBinding?: boolean;
+    }): void {
+        this.hostName = host;
+        // if (whitelistedAndroid) this.whitelistedUrlsAndroid = whitelistedAndroid;
+        // if (whitelistedIos) this.whitelistedUrlsIos = whitelistedIos;
+        this.whitelistedDomains = whitelistedDomains;
+        if (deviceBinding !== undefined) this.deviceBindingEnabled = deviceBinding;
+    }
+
+    // Helper method to get whitelisted URLs based on platform
+    // static getWhitelistedUrls(): string[] {
+    //     return Platform.OS === 'ios' ? this.whitelistedUrlsIos : this.whitelistedUrlsAndroid;
+    // }
+
+    static getWhitelistedDomains(): string[] {
+        return this.whitelistedDomains;
+    }
+
+    static get primaryColor(): string {
+        if (Platform.OS === 'android') {
+            return rgbaToString(this._primaryColorObj);
+        }
+        return this._primaryColorHex;
+    }
+    static getPrimaryColorWithOpacity(opacity: number): string {
+        return rgbaToString({
+            ...this._primaryColorObj,
+            a: opacity
+        });
+    }
+}

package/src/helpers/utils/deviceInfoManager.tsx

@@ -0,0 +1,37 @@
+import { Platform } from 'react-native';
+import DeviceInfo from 'react-native-device-info';
+import { Constants } from './Constants';
+
+export class DeviceInfoManager {
+    static async getDeviceInfo(): Promise<Record<string, string>> {
+        if (Platform.OS === 'android') {
+            let androidId = 'unknown';
+            try {
+                androidId = await DeviceInfo.getAndroidId();
+            } catch (e) {
+                if (__DEV__) {
+                    console.log('Error getting android id:', e);
+                }
+            }
+            return {
+                [Constants.MANUFACTURER]: (await DeviceInfo.getManufacturer()) || 'unknown',
+                [Constants.MODEL]: DeviceInfo.getModel() || 'unknown',
+                [Constants.OS]: 'android',
+                [Constants.OS_VERSION]: DeviceInfo.getSystemVersion() || 'unknown',
+                [Constants.APP_VERSION]: DeviceInfo.getVersion() || 'unknown',
+                [Constants.DEVICE_UUID]: androidId,
+            };
+        } else if (Platform.OS === 'ios') {
+            return {
+                [Constants.MANUFACTURER]: 'Apple',
+                [Constants.MODEL]: DeviceInfo.getModel() || 'unknown',
+                [Constants.OS]: 'ios',
+                [Constants.OS_VERSION]: DeviceInfo.getSystemVersion() || 'unknown',
+                [Constants.APP_VERSION]: DeviceInfo.getVersion() || 'unknown',
+                [Constants.DEVICE_UUID]: (await DeviceInfo.getUniqueId()) || 'unknown',
+            };
+        } else {
+            throw new Error('Unsupported platform');
+        }
+    }
+}

package/src/helpers/utils/headerManager.tsx

@@ -0,0 +1,22 @@
+import { Platform } from 'react-native';
+import DeviceInfo from 'react-native-device-info';
+import { DeviceInfoManager } from './deviceInfoManager';
+
+export class HeaderManager {
+
+    private deviceInfoManager = DeviceInfoManager;
+
+    async generateHeaders(isEncrypted: boolean = true): Promise<Record<string, string>> {
+
+        const deviceInfo = await this.deviceInfoManager.getDeviceInfo();
+
+        return {
+            ...deviceInfo,
+            app_version: DeviceInfo.getVersion() || 'unknown',
+            os: Platform.OS === 'android' ? 'Android' : 'iOS',
+            os_version: DeviceInfo.getSystemVersion() || 'unknown',
+            ...(isEncrypted && { 'Content-Type': 'application/json;charset=utf-8' })
+        };
+
+    }
+}

package/src/helpers/utils/themeManager.tsx

@@ -0,0 +1,51 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { Platform, StatusBar, type StatusBarStyle } from "react-native";
+import { Constants } from "./Constants";
+import { LibraryConstants } from './LibraryConstants';
+
+interface Theme {
+    primaryColor: string;
+}
+
+export class ThemeManager {
+
+
+
+    constructor() {
+    }
+
+    static async savePrimaryColor(color: string): Promise<void> {
+        console.log("Saving primary color:", color);
+        try {
+            await AsyncStorage.setItem(LibraryConstants.primaryColor, color);
+        } catch (error) {
+            console.error("Error saving primary color:", error);
+        }
+    }
+
+    static async loadPrimaryColor(): Promise<string | null> {
+        try {
+            return await AsyncStorage.getItem(LibraryConstants.primaryColor);
+        }
+        catch (error) {
+            console.error("Error loading primary color:", error);
+            return null;
+        }
+    }
+    static getAppTheme(): Theme {
+        return {
+            primaryColor: Constants.PRIMARY_COLOR,
+        };
+    }
+
+    static configureStatusBar(): void {
+        StatusBar.setBackgroundColor(LibraryConstants.primaryColor);
+        StatusBar.setNetworkActivityIndicatorVisible(true);
+        const barStyle: StatusBarStyle = 'light-content';
+        StatusBar.setBarStyle(barStyle);
+
+        if (Platform.OS === 'android') {
+            StatusBar.setTranslucent(false);
+        }
+    }
+}

package/src/helpers/utils/webviewCallback.tsx

@@ -0,0 +1,25 @@
+export enum WebViewCallbackType {
+
+    Logout = "logout",
+    Redirect = "redirect"
+}
+
+export class WebViewCallback {
+    type: WebViewCallbackType;
+    status?: string | null;
+
+    private constructor(type: WebViewCallbackType, status?: string | null) {
+        this.type = type;
+        this.status = status;
+    }
+
+    static logout(): WebViewCallback {
+        return new WebViewCallback(WebViewCallbackType.Logout);
+    }
+
+    static redirect(status?: string | null): WebViewCallback {
+        return new WebViewCallback(WebViewCallbackType.Redirect, status);
+    }
+}
+
+export type WebViewCallbackFunction = (callback: WebViewCallback) => void;