@hexar/biometric-identity-sdk-core 1.0.0

package/src/encryption/index.ts

@@ -0,0 +1,108 @@
+/**
+ * Encryption utilities for secure data transmission
+ */
+
+import crypto from 'crypto';
+import { EncryptedData } from '../types';
+
+export class EncryptionService {
+  private algorithm = 'aes-256-gcm' as const;
+  private keyLength = 32; // 256 bits
+
+  constructor(private encryptionKey?: string) {
+    if (!encryptionKey) {
+      // Generate a random key if not provided
+      this.encryptionKey = crypto.randomBytes(this.keyLength).toString('hex');
+    }
+  }
+
+  /**
+   * Encrypt data using AES-256-GCM
+   */
+  async encrypt(data: string): Promise<EncryptedData> {
+    try {
+      const key = Buffer.from(this.encryptionKey!, 'hex').slice(0, this.keyLength);
+      const iv = crypto.randomBytes(16);
+      
+      const cipher = crypto.createCipheriv(this.algorithm, key, iv) as crypto.CipherGCM;
+      
+      let encrypted = cipher.update(data, 'utf8', 'base64');
+      encrypted += cipher.final('base64');
+      
+      const authTag = cipher.getAuthTag();
+      
+      return {
+        data: encrypted,
+        iv: iv.toString('base64'),
+        tag: authTag.toString('base64'),
+        algorithm: this.algorithm,
+      };
+    } catch (error) {
+      throw new Error(`Encryption failed: ${error}`);
+    }
+  }
+
+  /**
+   * Decrypt data using AES-256-GCM
+   */
+  async decrypt(encryptedData: EncryptedData): Promise<string> {
+    try {
+      const key = Buffer.from(this.encryptionKey!, 'hex').slice(0, this.keyLength);
+      const iv = Buffer.from(encryptedData.iv, 'base64');
+      const authTag = Buffer.from(encryptedData.tag || '', 'base64');
+      
+      const decipher = crypto.createDecipheriv(this.algorithm, key, iv) as crypto.DecipherGCM;
+      decipher.setAuthTag(authTag);
+      
+      let decrypted = decipher.update(encryptedData.data, 'base64', 'utf8');
+      decrypted += decipher.final('utf8');
+      
+      return decrypted;
+    } catch (error) {
+      throw new Error(`Decryption failed: ${error}`);
+    }
+  }
+
+  /**
+   * Encrypt image data (base64)
+   */
+  async encryptImage(base64Image: string): Promise<EncryptedData> {
+    return this.encrypt(base64Image);
+  }
+
+  /**
+   * Hash data using SHA-256
+   */
+  hash(data: string): string {
+    return crypto.createHash('sha256').update(data).digest('hex');
+  }
+
+  /**
+   * Generate secure random token
+   */
+  generateToken(length: number = 32): string {
+    return crypto.randomBytes(length).toString('hex');
+  }
+}
+
+/**
+ * Encrypt multiple images for batch processing
+ */
+export async function encryptImages(
+  images: string[],
+  encryptionKey?: string
+): Promise<EncryptedData[]> {
+  const service = new EncryptionService(encryptionKey);
+  return Promise.all(images.map(img => service.encryptImage(img)));
+}
+
+/**
+ * Create integrity signature for data
+ */
+export function createIntegritySignature(data: any): string {
+  const dataString = JSON.stringify(data);
+  return crypto
+    .createHmac('sha256', 'biometric-identity-sdk')
+    .update(dataString)
+    .digest('hex');
+}

package/src/i18n/index.ts

@@ -0,0 +1,35 @@
+import { SupportedLanguage, LanguageStrings } from './types';
+import { en } from './languages/en';
+import { es } from './languages/es';
+import { esAR } from './languages/es-AR';
+import { ptBR } from './languages/pt-BR';
+
+const languages: Record<SupportedLanguage, LanguageStrings> = {
+  'en': en,
+  'es': es,
+  'es-AR': esAR,
+  'pt-BR': ptBR,
+};
+
+let currentLanguage: SupportedLanguage = 'en';
+
+export const setLanguage = (lang: SupportedLanguage): void => {
+  if (languages[lang]) {
+    currentLanguage = lang;
+  } else {
+    console.warn(`Language ${lang} not supported, falling back to English`);
+    currentLanguage = 'en';
+  }
+};
+
+export const getStrings = (): LanguageStrings => {
+  return languages[currentLanguage];
+};
+
+export const getCurrentLanguage = (): SupportedLanguage => {
+  return currentLanguage;
+};
+
+export { SupportedLanguage, LanguageStrings };
+export * from './types';
+

package/src/i18n/languages/en.ts

@@ -0,0 +1,121 @@
+import { LanguageStrings } from '../types';
+
+export const en: LanguageStrings = {
+  common: {
+    loading: 'Loading...',
+    error: 'Error',
+    retry: 'Retry',
+    cancel: 'Cancel',
+    continue: 'Continue',
+    close: 'Close',
+    done: 'Done',
+  },
+  
+  initialization: {
+    initializing: 'Initializing...',
+    connectingToServer: 'Connecting to server...',
+    loadingModels: 'Loading AI models...',
+  },
+  
+  instructions: {
+    title: 'Identity Verification',
+    subtitle: 'Follow these steps to verify your identity',
+    step1: 'Capture front of ID',
+    step2: 'Capture back of ID',
+    step3: 'Record face video',
+    startButton: 'Start Verification',
+    requirements: {
+      goodLighting: 'Good lighting',
+      clearDocument: 'Clear document',
+      stableHand: 'Stable hand',
+      followInstructions: 'Follow instructions',
+    },
+  },
+  
+  capture: {
+    frontId: {
+      title: 'Front of ID',
+      instruction: 'Position the front of your ID within the frame',
+      button: 'Capture Front ID',
+    },
+    backId: {
+      title: 'Back of ID',
+      instruction: 'Position the back of your ID within the frame',
+      button: 'Capture Back ID',
+    },
+    selfie: {
+      title: 'Face Photo',
+      instruction: 'Position your face within the frame',
+      button: 'Take Photo',
+    },
+  },
+  
+  liveness: {
+    title: 'Face Verification',
+    preparing: 'Preparing verification...',
+    instructions: {
+      lookLeft: 'Look to the left',
+      lookRight: 'Look to the right',
+      lookUp: 'Look up',
+      lookDown: 'Look down',
+      smile: 'Smile',
+      blink: 'Blink naturally',
+      turnHeadLeft: 'Turn your head to the left',
+      turnHeadRight: 'Turn your head to the right',
+      stayStill: 'Stay still',
+    },
+    recording: 'Recording...',
+    processing: 'Processing video...',
+  },
+  
+  validation: {
+    title: 'Validating',
+    validating: 'Validating your identity...',
+    checkingDocument: 'Checking document authenticity...',
+    checkingLiveness: 'Verifying liveness...',
+    matchingFaces: 'Matching faces...',
+    almostDone: 'Almost done...',
+  },
+  
+  result: {
+    success: {
+      title: 'Verification Successful',
+      message: 'Your identity has been verified successfully',
+      verificationComplete: 'Verification Complete',
+    },
+    failure: {
+      title: 'Verification Failed',
+      message: 'We could not verify your identity',
+      tryAgain: 'Please try again',
+    },
+  },
+  
+  errors: {
+    cameraPermissionDenied: 'Camera permission denied. Please enable camera access in settings.',
+    cameraNotAvailable: 'Camera not available.',
+    faceNotDetected: 'Face not detected. Please position your face clearly.',
+    multipleFacesDetected: 'Multiple faces detected. Only one person should be in frame.',
+    documentNotDetected: 'Document not detected. Please position your ID clearly.',
+    poorImageQuality: 'Image quality too low. Please ensure good lighting.',
+    livenessCheckFailed: 'Liveness check failed. Please try again.',
+    faceMatchFailed: 'Face does not match document photo.',
+    documentTampered: 'Document appears to be tampered or fraudulent.',
+    networkError: 'Network error. Please check your connection.',
+    timeout: 'Request timeout. Please try again.',
+    unknownError: 'An unexpected error occurred.',
+  },
+  
+  badges: {
+    secureVerification: 'Secure AI Verification',
+    aiPowered: 'AI-Powered',
+    verified: 'Verified',
+  },
+  
+  steps: {
+    frontId: 'Front ID',
+    backId: 'Back ID',
+    faceVideo: 'Face Video',
+    validation: 'Validation',
+  },
+};
+

package/src/i18n/languages/es-AR.ts

@@ -0,0 +1,121 @@
+import { LanguageStrings } from '../types';
+
+export const esAR: LanguageStrings = {
+  common: {
+    loading: 'Cargando...',
+    error: 'Error',
+    retry: 'Reintentar',
+    cancel: 'Cancelar',
+    continue: 'Continuar',
+    close: 'Cerrar',
+    done: 'Listo',
+  },
+  
+  initialization: {
+    initializing: 'Iniciando...',
+    connectingToServer: 'Conectando al servidor...',
+    loadingModels: 'Cargando modelos de IA...',
+  },
+  
+  instructions: {
+    title: 'Verificación de Identidad',
+    subtitle: 'Seguí estos pasos para verificar tu identidad',
+    step1: 'Capturá el frente de tu documento',
+    step2: 'Capturá el dorso de tu documento',
+    step3: 'Grabá un video de tu rostro',
+    startButton: 'Iniciar Verificación',
+    requirements: {
+      goodLighting: 'Buena iluminación',
+      clearDocument: 'Documento claro',
+      stableHand: 'Mano firme',
+      followInstructions: 'Seguí las instrucciones',
+    },
+  },
+  
+  capture: {
+    frontId: {
+      title: 'Frente del Documento',
+      instruction: 'Posicioná el frente de tu documento dentro del marco',
+      button: 'Capturar Frente',
+    },
+    backId: {
+      title: 'Dorso del Documento',
+      instruction: 'Posicioná el dorso de tu documento dentro del marco',
+      button: 'Capturar Dorso',
+    },
+    selfie: {
+      title: 'Foto de Rostro',
+      instruction: 'Posicioná tu rostro dentro del marco',
+      button: 'Tomar Foto',
+    },
+  },
+  
+  liveness: {
+    title: 'Verificación Facial',
+    preparing: 'Preparando verificación...',
+    instructions: {
+      lookLeft: 'Mirá a la izquierda',
+      lookRight: 'Mirá a la derecha',
+      lookUp: 'Mirá hacia arriba',
+      lookDown: 'Mirá hacia abajo',
+      smile: 'Sonreí',
+      blink: 'Parpadeá naturalmente',
+      turnHeadLeft: 'Girá tu cabeza a la izquierda',
+      turnHeadRight: 'Girá tu cabeza a la derecha',
+      stayStill: 'Quedate quieto',
+    },
+    recording: 'Grabando...',
+    processing: 'Procesando video...',
+  },
+  
+  validation: {
+    title: 'Validando',
+    validating: 'Validando tu identidad...',
+    checkingDocument: 'Verificando autenticidad del documento...',
+    checkingLiveness: 'Verificando prueba de vida...',
+    matchingFaces: 'Comparando rostros...',
+    almostDone: 'Ya casi terminamos...',
+  },
+  
+  result: {
+    success: {
+      title: 'Verificación Exitosa',
+      message: 'Tu identidad fue verificada correctamente',
+      verificationComplete: 'Verificación Completa',
+    },
+    failure: {
+      title: 'Verificación Fallida',
+      message: 'No pudimos verificar tu identidad',
+      tryAgain: 'Por favor, intentá nuevamente',
+    },
+  },
+  
+  errors: {
+    cameraPermissionDenied: 'Permiso de cámara denegado. Habilitá el acceso en configuración.',
+    cameraNotAvailable: 'Cámara no disponible.',
+    faceNotDetected: 'Rostro no detectado. Posicioná tu cara claramente.',
+    multipleFacesDetected: 'Múltiples rostros detectados. Solo debe haber una persona.',
+    documentNotDetected: 'Documento no detectado. Posicioná tu documento claramente.',
+    poorImageQuality: 'Calidad de imagen baja. Asegurate de tener buena iluminación.',
+    livenessCheckFailed: 'Prueba de vida fallida. Intentá nuevamente.',
+    faceMatchFailed: 'El rostro no coincide con la foto del documento.',
+    documentTampered: 'El documento parece estar alterado o ser fraudulento.',
+    networkError: 'Error de red. Verificá tu conexión.',
+    timeout: 'Tiempo de espera agotado. Intentá nuevamente.',
+    unknownError: 'Ocurrió un error inesperado.',
+  },
+  
+  badges: {
+    secureVerification: 'Verificación Segura con IA',
+    aiPowered: 'Impulsado por IA',
+    verified: 'Verificado',
+  },
+  
+  steps: {
+    frontId: 'Frente',
+    backId: 'Dorso',
+    faceVideo: 'Video',
+    validation: 'Validación',
+  },
+};
+

package/src/i18n/languages/es.ts

@@ -0,0 +1,121 @@
+import { LanguageStrings } from '../types';
+
+export const es: LanguageStrings = {
+  common: {
+    loading: 'Cargando...',
+    error: 'Error',
+    retry: 'Reintentar',
+    cancel: 'Cancelar',
+    continue: 'Continuar',
+    close: 'Cerrar',
+    done: 'Listo',
+  },
+  
+  initialization: {
+    initializing: 'Iniciando...',
+    connectingToServer: 'Conectando al servidor...',
+    loadingModels: 'Cargando modelos de IA...',
+  },
+  
+  instructions: {
+    title: 'Verificación de Identidad',
+    subtitle: 'Sigue estos pasos para verificar tu identidad',
+    step1: 'Captura el frente de tu documento',
+    step2: 'Captura el reverso de tu documento',
+    step3: 'Graba un video de tu rostro',
+    startButton: 'Iniciar Verificación',
+    requirements: {
+      goodLighting: 'Buena iluminación',
+      clearDocument: 'Documento claro',
+      stableHand: 'Mano estable',
+      followInstructions: 'Sigue las instrucciones',
+    },
+  },
+  
+  capture: {
+    frontId: {
+      title: 'Frente del Documento',
+      instruction: 'Posiciona el frente de tu documento dentro del marco',
+      button: 'Capturar Frente',
+    },
+    backId: {
+      title: 'Reverso del Documento',
+      instruction: 'Posiciona el reverso de tu documento dentro del marco',
+      button: 'Capturar Reverso',
+    },
+    selfie: {
+      title: 'Foto de Rostro',
+      instruction: 'Posiciona tu rostro dentro del marco',
+      button: 'Tomar Foto',
+    },
+  },
+  
+  liveness: {
+    title: 'Verificación Facial',
+    preparing: 'Preparando verificación...',
+    instructions: {
+      lookLeft: 'Mira a la izquierda',
+      lookRight: 'Mira a la derecha',
+      lookUp: 'Mira hacia arriba',
+      lookDown: 'Mira hacia abajo',
+      smile: 'Sonríe',
+      blink: 'Parpadea naturalmente',
+      turnHeadLeft: 'Gira tu cabeza a la izquierda',
+      turnHeadRight: 'Gira tu cabeza a la derecha',
+      stayStill: 'Permanece quieto',
+    },
+    recording: 'Grabando...',
+    processing: 'Procesando video...',
+  },
+  
+  validation: {
+    title: 'Validando',
+    validating: 'Validando tu identidad...',
+    checkingDocument: 'Verificando autenticidad del documento...',
+    checkingLiveness: 'Verificando prueba de vida...',
+    matchingFaces: 'Comparando rostros...',
+    almostDone: 'Casi terminamos...',
+  },
+  
+  result: {
+    success: {
+      title: 'Verificación Exitosa',
+      message: 'Tu identidad ha sido verificada correctamente',
+      verificationComplete: 'Verificación Completa',
+    },
+    failure: {
+      title: 'Verificación Fallida',
+      message: 'No pudimos verificar tu identidad',
+      tryAgain: 'Por favor, intenta nuevamente',
+    },
+  },
+  
+  errors: {
+    cameraPermissionDenied: 'Permiso de cámara denegado. Habilita el acceso en configuración.',
+    cameraNotAvailable: 'Cámara no disponible.',
+    faceNotDetected: 'Rostro no detectado. Posiciona tu cara claramente.',
+    multipleFacesDetected: 'Múltiples rostros detectados. Solo debe haber una persona.',
+    documentNotDetected: 'Documento no detectado. Posiciona tu documento claramente.',
+    poorImageQuality: 'Calidad de imagen baja. Asegura buena iluminación.',
+    livenessCheckFailed: 'Prueba de vida fallida. Intenta nuevamente.',
+    faceMatchFailed: 'El rostro no coincide con la foto del documento.',
+    documentTampered: 'El documento parece estar alterado o ser fraudulento.',
+    networkError: 'Error de red. Verifica tu conexión.',
+    timeout: 'Tiempo de espera agotado. Intenta nuevamente.',
+    unknownError: 'Ocurrió un error inesperado.',
+  },
+  
+  badges: {
+    secureVerification: 'Verificación Segura con IA',
+    aiPowered: 'Impulsado por IA',
+    verified: 'Verificado',
+  },
+  
+  steps: {
+    frontId: 'Frente',
+    backId: 'Reverso',
+    faceVideo: 'Video',
+    validation: 'Validación',
+  },
+};
+

package/src/i18n/languages/pt-BR.ts

@@ -0,0 +1,121 @@
+import { LanguageStrings } from '../types';
+
+export const ptBR: LanguageStrings = {
+  common: {
+    loading: 'Carregando...',
+    error: 'Erro',
+    retry: 'Tentar Novamente',
+    cancel: 'Cancelar',
+    continue: 'Continuar',
+    close: 'Fechar',
+    done: 'Pronto',
+  },
+  
+  initialization: {
+    initializing: 'Inicializando...',
+    connectingToServer: 'Conectando ao servidor...',
+    loadingModels: 'Carregando modelos de IA...',
+  },
+  
+  instructions: {
+    title: 'Verificação de Identidade',
+    subtitle: 'Siga estes passos para verificar sua identidade',
+    step1: 'Capture a frente do documento',
+    step2: 'Capture o verso do documento',
+    step3: 'Grave um vídeo do seu rosto',
+    startButton: 'Iniciar Verificação',
+    requirements: {
+      goodLighting: 'Boa iluminação',
+      clearDocument: 'Documento claro',
+      stableHand: 'Mão estável',
+      followInstructions: 'Siga as instruções',
+    },
+  },
+  
+  capture: {
+    frontId: {
+      title: 'Frente do Documento',
+      instruction: 'Posicione a frente do seu documento dentro da moldura',
+      button: 'Capturar Frente',
+    },
+    backId: {
+      title: 'Verso do Documento',
+      instruction: 'Posicione o verso do seu documento dentro da moldura',
+      button: 'Capturar Verso',
+    },
+    selfie: {
+      title: 'Foto do Rosto',
+      instruction: 'Posicione seu rosto dentro da moldura',
+      button: 'Tirar Foto',
+    },
+  },
+  
+  liveness: {
+    title: 'Verificação Facial',
+    preparing: 'Preparando verificação...',
+    instructions: {
+      lookLeft: 'Olhe para a esquerda',
+      lookRight: 'Olhe para a direita',
+      lookUp: 'Olhe para cima',
+      lookDown: 'Olhe para baixo',
+      smile: 'Sorria',
+      blink: 'Pisque naturalmente',
+      turnHeadLeft: 'Vire sua cabeça para a esquerda',
+      turnHeadRight: 'Vire sua cabeça para a direita',
+      stayStill: 'Fique parado',
+    },
+    recording: 'Gravando...',
+    processing: 'Processando vídeo...',
+  },
+  
+  validation: {
+    title: 'Validando',
+    validating: 'Validando sua identidade...',
+    checkingDocument: 'Verificando autenticidade do documento...',
+    checkingLiveness: 'Verificando prova de vida...',
+    matchingFaces: 'Comparando rostos...',
+    almostDone: 'Quase pronto...',
+  },
+  
+  result: {
+    success: {
+      title: 'Verificação Bem-Sucedida',
+      message: 'Sua identidade foi verificada com sucesso',
+      verificationComplete: 'Verificação Completa',
+    },
+    failure: {
+      title: 'Verificação Falhou',
+      message: 'Não conseguimos verificar sua identidade',
+      tryAgain: 'Por favor, tente novamente',
+    },
+  },
+  
+  errors: {
+    cameraPermissionDenied: 'Permissão de câmera negada. Habilite o acesso nas configurações.',
+    cameraNotAvailable: 'Câmera não disponível.',
+    faceNotDetected: 'Rosto não detectado. Posicione seu rosto claramente.',
+    multipleFacesDetected: 'Múltiplos rostos detectados. Apenas uma pessoa deve estar no quadro.',
+    documentNotDetected: 'Documento não detectado. Posicione seu documento claramente.',
+    poorImageQuality: 'Qualidade de imagem baixa. Certifique-se de ter boa iluminação.',
+    livenessCheckFailed: 'Prova de vida falhou. Tente novamente.',
+    faceMatchFailed: 'O rosto não corresponde à foto do documento.',
+    documentTampered: 'O documento parece estar adulterado ou fraudulento.',
+    networkError: 'Erro de rede. Verifique sua conexão.',
+    timeout: 'Tempo esgotado. Tente novamente.',
+    unknownError: 'Ocorreu um erro inesperado.',
+  },
+  
+  badges: {
+    secureVerification: 'Verificação Segura com IA',
+    aiPowered: 'Impulsionado por IA',
+    verified: 'Verificado',
+  },
+  
+  steps: {
+    frontId: 'Frente',
+    backId: 'Verso',
+    faceVideo: 'Vídeo',
+    validation: 'Validação',
+  },
+};
+