@onairos/react-native 2.0.6 → 2.0.9

package/src/utils/secureStorage.ts

@@ -1,4 +1,3 @@
-import * as Keychain from 'react-native-keychain';
 import { Platform } from 'react-native';
 import { sha256 } from './crypto';
 
@@ -24,56 +23,19 @@ export interface StorageOptions {
   };
 }
 
-const CREDENTIALS_KEY = 'onairos_credentials';
+// Temporary in-memory storage
+let mockStorage: { [key: string]: string } = {};
 
 /**
- * Store credentials securely in the device keychain with optional biometric protection
+ * Store credentials in memory (temporary solution)
  */
 export const storeCredentials = async (
   credentials: OnairosCredentials,
   options: StorageOptions = {}
 ): Promise<boolean> => {
   try {
-    const { useBiometrics = true, biometricPrompt } = options;
-    
-    // Create a JSON string of the credentials
-    const credentialsString = JSON.stringify(credentials);
-    
-    // Configure security options based on platform
-    const securityOptions: Keychain.Options = {
-      service: CREDENTIALS_KEY,
-      accessible: Keychain.ACCESSIBLE.WHEN_UNLOCKED_THIS_DEVICE_ONLY,
-    };
-    
-    // Add biometric protection if requested
-    if (useBiometrics) {
-      // iOS specific options
-      if (Platform.OS === 'ios') {
-        securityOptions.accessControl = Keychain.ACCESS_CONTROL.BIOMETRY_ANY_OR_DEVICE_PASSCODE;
-      }
-      
-      // Android specific options
-      if (Platform.OS === 'android') {
-        securityOptions.accessControl = Keychain.ACCESS_CONTROL.BIOMETRY_ANY;
-        if (biometricPrompt) {
-          securityOptions.authenticationType = Keychain.AUTHENTICATION_TYPE.BIOMETRIC;
-          securityOptions.authenticationPrompt = {
-            title: biometricPrompt.title || 'Biometric Authentication',
-            subtitle: biometricPrompt.subtitle,
-            description: 'Please authenticate to access your Onairos credentials',
-            cancel: 'Cancel',
-          };
-        }
-      }
-    }
-    
-    // Store in the secure keychain
-    await Keychain.setGenericPassword(
-      credentials.username,
-      credentialsString,
-      securityOptions
-    );
-    
+    console.log('[Mock] Storing credentials:', credentials.username);
+    mockStorage[credentials.username] = JSON.stringify(credentials);
     return true;
   } catch (error) {
     console.error('Error storing credentials:', error);
@@ -82,39 +44,18 @@ export const storeCredentials = async (
 };
 
 /**
- * Retrieve credentials from secure storage, potentially requiring biometric authentication
+ * Retrieve credentials from memory (temporary solution)
  */
 export const getCredentials = async (
   options: StorageOptions = {}
 ): Promise<OnairosCredentials | null> => {
   try {
-    const { useBiometrics = true, biometricPrompt } = options;
-    
-    // Configure security options
-    const securityOptions: Keychain.Options = {
-      service: CREDENTIALS_KEY,
-    };
-    
-    // Add biometric prompt if required
-    if (useBiometrics && biometricPrompt) {
-      securityOptions.authenticationPrompt = {
-        title: biometricPrompt.title || 'Biometric Authentication',
-        subtitle: biometricPrompt.subtitle,
-        description: 'Please authenticate to access your Onairos credentials',
-        cancel: 'Cancel',
-      };
-    }
-    
-    // Retrieve from keychain
-    const result = await Keychain.getGenericPassword(securityOptions);
-    
-    if (!result) {
+    // Get the first stored credential (temporary solution)
+    const storedCredential = Object.values(mockStorage)[0];
+    if (!storedCredential) {
       return null;
     }
-    
-    // Parse the stored JSON
-    const credentials: OnairosCredentials = JSON.parse(result.password);
-    return credentials;
+    return JSON.parse(storedCredential);
   } catch (error) {
     console.error('Error retrieving credentials:', error);
     return null;
@@ -126,11 +67,7 @@ export const getCredentials = async (
  */
 export const hasCredentials = async (): Promise<boolean> => {
   try {
-    const result = await Keychain.getGenericPassword({
-      service: CREDENTIALS_KEY,
-    });
-    
-    return !!result;
+    return Object.keys(mockStorage).length > 0;
   } catch (error) {
     console.error('Error checking for credentials:', error);
     return false;
@@ -142,7 +79,7 @@ export const hasCredentials = async (): Promise<boolean> => {
  */
 export const deleteCredentials = async (): Promise<boolean> => {
   try {
-    await Keychain.resetGenericPassword({ service: CREDENTIALS_KEY });
+    mockStorage = {};
     return true;
   } catch (error) {
     console.error('Error deleting credentials:', error);
@@ -158,20 +95,14 @@ export const updateCredentials = async (
   options: StorageOptions = {}
 ): Promise<boolean> => {
   try {
-    // Get current credentials
     const currentCredentials = await getCredentials(options);
-    
     if (!currentCredentials) {
       return false;
     }
-    
-    // Merge updates with current credentials
     const updatedCredentials: OnairosCredentials = {
       ...currentCredentials,
       ...updates,
     };
-    
-    // Store updated credentials
     return await storeCredentials(updatedCredentials, options);
   } catch (error) {
     console.error('Error updating credentials:', error);
@@ -184,44 +115,23 @@ export const updateCredentials = async (
  */
 export const generateDeviceUsername = async (): Promise<string> => {
   try {
-    // Get a device-specific identifier that we can use
-    // This is a simplified example - in production you might want to use
-    // a more robust device identifier method
     const deviceInfo = `${Platform.OS}-${Platform.Version}-${Date.now()}`;
-    
-    // Hash it to create a unique identifier
     const username = `onairos_${sha256(deviceInfo).substring(0, 10)}`;
-    
     return username;
   } catch (error) {
     console.error('Error generating device username:', error);
-    // Fallback to a timestamp-based username if there's an error
     return `onairos_${Date.now().toString(36)}`;
   }
 };
 
 /**
- * Verify if credentials are valid (not expired, etc.)
+ * Verify credentials (temporary mock implementation)
  */
 export const verifyCredentials = async (
   credentials: OnairosCredentials
 ): Promise<boolean> => {
   try {
-    // Basic verification - check if credentials exist and aren't too old
-    if (!credentials || !credentials.accessToken || !credentials.username) {
-      return false;
-    }
-    
-    // Check for expiration (example: credentials expire after 30 days)
-    const thirtyDaysMs = 30 * 24 * 60 * 60 * 1000;
-    const isExpired = Date.now() - credentials.createdAt > thirtyDaysMs;
-    
-    if (isExpired) {
-      return false;
-    }
-    
-    // Add any additional verification logic here
-    
+    console.log('[Mock] Verifying credentials for:', credentials.username);
     return true;
   } catch (error) {
     console.error('Error verifying credentials:', error);