Feat/eid reclaim

infrastructure/eid-wallet/src-tauri/gen/apple/eid-wallet.xcodeproj/project.pbxproj

@@ -416,7 +416,7 @@
  "$(TOOLCHAIN_DIR)/usr/lib/swift-5.0/$(PLATFORM_NAME)",
  );
  MARKETING_VERSION = 0.2.1;
- PRODUCT_BUNDLE_IDENTIFIER = "foundation.metastate.eid-wallet";
+ PRODUCT_BUNDLE_IDENTIFIER = foundation.metastate.eid-wallet;
  PRODUCT_NAME = "eID for W3DS";
  SDKROOT = iphoneos;
  SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";
@@ -464,7 +464,7 @@
  "$(TOOLCHAIN_DIR)/usr/lib/swift-5.0/$(PLATFORM_NAME)",
  );
  MARKETING_VERSION = 0.2.1;
- PRODUCT_BUNDLE_IDENTIFIER = "foundation.metastate.eid-wallet";
+ PRODUCT_BUNDLE_IDENTIFIER = foundation.metastate.eid-wallet;
  PRODUCT_NAME = "eID for W3DS";
  SDKROOT = iphoneos;
  SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";

infrastructure/eid-wallet/src-tauri/gen/apple/eid-wallet_iOS/Info.plist

@@ -61,4 +61,4 @@
  <string>UIInterfaceOrientationLandscapeRight</string>
 	</array>
 </dict>
-</plist>
+</plist>

infrastructure/eid-wallet/src/lib/crypto/HardwareKeyManager.ts

@@ -0,0 +1,91 @@
+import type { KeyManager } from './types';
+import { KeyManagerError, KeyManagerErrorCodes } from './types';
+import {
+ exists as hwExists,
+ generate as hwGenerate,
+ getPublicKey as hwGetPublicKey,
+ signPayload as hwSignPayload,
+ verifySignature as hwVerifySignature,
+} from '@auvo/tauri-plugin-crypto-hw-api';
+
+/**
+ * Hardware key manager implementation using Tauri crypto hardware API
+ */
+export class HardwareKeyManager implements KeyManager {
+ getType(): 'hardware' | 'software' {
+ return 'hardware';
+ }
+
+ async exists(keyId: string): Promise<boolean> {
+ try {
+ return await hwExists(keyId);
+ } catch (error) {
+ console.error('Hardware key exists check failed:', error);
+ throw new KeyManagerError(
+ 'Failed to check if hardware key exists',
+ KeyManagerErrorCodes.HARDWARE_UNAVAILABLE,
+ keyId
+ );
+ }
+ }
+
+ async generate(keyId: string): Promise<string | undefined> {
+ try {
+ const result = await hwGenerate(keyId);
+ console.log(`Hardware key generated for ${keyId}:`, result);
+ return result;
+ } catch (error) {
+ console.error('Hardware key generation failed:', error);
+ throw new KeyManagerError(
+ 'Failed to generate hardware key',
+ KeyManagerErrorCodes.KEY_GENERATION_FAILED,
+ keyId
+ );
+ }
+ }
+
+ async getPublicKey(keyId: string): Promise<string | undefined> {
+ try {
+ const publicKey = await hwGetPublicKey(keyId);
+ console.log(`Hardware public key retrieved for ${keyId}:`, publicKey);
+ return publicKey;
+ } catch (error) {
+ console.error('Hardware public key retrieval failed:', error);
+ throw new KeyManagerError(
+ 'Failed to get hardware public key',
+ KeyManagerErrorCodes.KEY_NOT_FOUND,
+ keyId
+ );
+ }
+ }
+
+ async signPayload(keyId: string, payload: string): Promise<string> {
+ try {
+ const signature = await hwSignPayload(keyId, payload);
+ console.log(`Hardware signature created for ${keyId}`);
+ return signature;
+ } catch (error) {
+ console.error('Hardware signing failed:', error);
+ throw new KeyManagerError(
+ 'Failed to sign payload with hardware key',
+ KeyManagerErrorCodes.SIGNING_FAILED,
+ keyId
+ );
+ }
+ }
+
+ async verifySignature(keyId: string, payload: string, signature: string): Promise<boolean> {
+ try {
+ const isValid = await hwVerifySignature(keyId, payload, signature);
+ console.log(`Hardware signature verification for ${keyId}:`, isValid);
+ return isValid;
+ } catch (error) {
+ console.error('Hardware signature verification failed:', error);
+ throw new KeyManagerError(
+ 'Failed to verify signature with hardware key',
+ KeyManagerErrorCodes.VERIFICATION_FAILED,
+ keyId
+ );
+ }
+ }
+}

infrastructure/eid-wallet/src/lib/crypto/KeyManagerFactory.ts

@@ -0,0 +1,99 @@
+import type { KeyManager, KeyManagerConfig } from './types';
+import { HardwareKeyManager } from './HardwareKeyManager';
+import { SoftwareKeyManager } from './SoftwareKeyManager';
+import { KeyManagerError, KeyManagerErrorCodes } from './types';
+
+/**
+ * Factory class to create appropriate key managers based on context
+ */
+export class KeyManagerFactory {
+ private static hardwareKeyManager: HardwareKeyManager | null = null;
+ private static softwareKeyManager: SoftwareKeyManager | null = null;
+
+ /**
+ * Get a key manager instance based on the configuration
+ */
+ static async getKeyManager(config: KeyManagerConfig): Promise<KeyManager> {
+ // If explicitly requesting hardware and not in pre-verification mode
+ if (config.useHardware && !config.preVerificationMode) {
+ return this.getHardwareKeyManager();
+ }
+
+ // If in pre-verification mode, always use software keys
+ if (config.preVerificationMode) {
+ console.log('Using software key manager for pre-verification mode');
+ return this.getSoftwareKeyManager();
+ }
+
+ // Default behavior: try hardware first, fallback to software
+ try {
+ const hardwareManager = this.getHardwareKeyManager();
+ // Test if hardware is available by checking if we can call exists
+ await hardwareManager.exists(config.keyId);
+ console.log('Using hardware key manager');
+ return hardwareManager;
+ } catch (error) {
+ console.log('Hardware key manager not available, falling back to software');
+ return this.getSoftwareKeyManager();
+ }
+ }
+
+ /**
+ * Get hardware key manager instance (singleton)
+ */
+ private static getHardwareKeyManager(): HardwareKeyManager {
+ if (!this.hardwareKeyManager) {
+ this.hardwareKeyManager = new HardwareKeyManager();
+ }
+ return this.hardwareKeyManager;
+ }
+
+ /**
+ * Get software key manager instance (singleton)
+ */
+ private static getSoftwareKeyManager(): SoftwareKeyManager {
+ if (!this.softwareKeyManager) {
+ this.softwareKeyManager = new SoftwareKeyManager();
+ }
+ return this.softwareKeyManager;
+ }
+
+ /**
+ * Check if hardware key manager is available
+ */
+ static async isHardwareAvailable(): Promise<boolean> {
+ try {
+ const hardwareManager = this.getHardwareKeyManager();
+ // Try to check if a test key exists to verify hardware availability
+ await hardwareManager.exists('test-hardware-check');
+ return true;
+ } catch (error) {
+ console.log('Hardware key manager not available:', error);
+ return false;
+ }
+ }
+
+ /**
+ * Get the appropriate key manager for a specific use case
+ */
+ static async getKeyManagerForContext(
+ keyId: string,
+ context: 'onboarding' | 'signing' | 'verification' | 'pre-verification'
+ ): Promise<KeyManager> {
+ const config: KeyManagerConfig = {
+ keyId,
+ useHardware: context !== 'pre-verification',
+ preVerificationMode: context === 'pre-verification',
+ };
+
+ return this.getKeyManager(config);
+ }
+
+ /**
+ * Reset singleton instances (useful for testing)
+ */
+ static reset(): void {
+ this.hardwareKeyManager = null;
+ this.softwareKeyManager = null;
+ }
+}

infrastructure/eid-wallet/src-tauri/gen/apple/eid-wallet.xcodeproj/project.pbxproj

@@ -416,7 +416,7 @@
  "$(TOOLCHAIN_DIR)/usr/lib/swift-5.0/$(PLATFORM_NAME)",
  );
  MARKETING_VERSION = 0.2.1;
- PRODUCT_BUNDLE_IDENTIFIER = "foundation.metastate.eid-wallet";
+ PRODUCT_BUNDLE_IDENTIFIER = foundation.metastate.eid-wallet;
  PRODUCT_NAME = "eID for W3DS";
  SDKROOT = iphoneos;
  SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";
@@ -464,7 +464,7 @@
  "$(TOOLCHAIN_DIR)/usr/lib/swift-5.0/$(PLATFORM_NAME)",
  );
  MARKETING_VERSION = 0.2.1;
- PRODUCT_BUNDLE_IDENTIFIER = "foundation.metastate.eid-wallet";
+ PRODUCT_BUNDLE_IDENTIFIER = foundation.metastate.eid-wallet;
  PRODUCT_NAME = "eID for W3DS";
  SDKROOT = iphoneos;
  SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";

infrastructure/eid-wallet/src-tauri/gen/apple/eid-wallet_iOS/Info.plist

@@ -61,4 +61,4 @@
  <string>UIInterfaceOrientationLandscapeRight</string>
 	</array>
 </dict>
-</plist>
+</plist>

infrastructure/eid-wallet/src/lib/crypto/HardwareKeyManager.ts

@@ -0,0 +1,91 @@
+import type { KeyManager } from './types';
+import { KeyManagerError, KeyManagerErrorCodes } from './types';
+import {
+ exists as hwExists,
+ generate as hwGenerate,
+ getPublicKey as hwGetPublicKey,
+ signPayload as hwSignPayload,
+ verifySignature as hwVerifySignature,
+} from '@auvo/tauri-plugin-crypto-hw-api';
+
+/**
+ * Hardware key manager implementation using Tauri crypto hardware API
+ */
+export class HardwareKeyManager implements KeyManager {
+ getType(): 'hardware' | 'software' {
+ return 'hardware';
+ }
+
+ async exists(keyId: string): Promise<boolean> {
+ try {
+ return await hwExists(keyId);
+ } catch (error) {
+ console.error('Hardware key exists check failed:', error);
+ throw new KeyManagerError(
+ 'Failed to check if hardware key exists',
+ KeyManagerErrorCodes.HARDWARE_UNAVAILABLE,
+ keyId
+ );
+ }
+ }
+
+ async generate(keyId: string): Promise<string | undefined> {
+ try {
+ const result = await hwGenerate(keyId);
+ console.log(`Hardware key generated for ${keyId}:`, result);
+ return result;
+ } catch (error) {
+ console.error('Hardware key generation failed:', error);
+ throw new KeyManagerError(
+ 'Failed to generate hardware key',
+ KeyManagerErrorCodes.KEY_GENERATION_FAILED,
+ keyId
+ );
+ }
+ }
+
+ async getPublicKey(keyId: string): Promise<string | undefined> {
+ try {
+ const publicKey = await hwGetPublicKey(keyId);
+ console.log(`Hardware public key retrieved for ${keyId}:`, publicKey);
+ return publicKey;
+ } catch (error) {
+ console.error('Hardware public key retrieval failed:', error);
+ throw new KeyManagerError(
+ 'Failed to get hardware public key',
+ KeyManagerErrorCodes.KEY_NOT_FOUND,
+ keyId
+ );
+ }
+ }
+
+ async signPayload(keyId: string, payload: string): Promise<string> {
+ try {
+ const signature = await hwSignPayload(keyId, payload);
+ console.log(`Hardware signature created for ${keyId}`);
+ return signature;
+ } catch (error) {
+ console.error('Hardware signing failed:', error);
+ throw new KeyManagerError(
+ 'Failed to sign payload with hardware key',
+ KeyManagerErrorCodes.SIGNING_FAILED,
+ keyId
+ );
+ }
+ }
+
+ async verifySignature(keyId: string, payload: string, signature: string): Promise<boolean> {
+ try {
+ const isValid = await hwVerifySignature(keyId, payload, signature);
+ console.log(`Hardware signature verification for ${keyId}:`, isValid);
+ return isValid;
+ } catch (error) {
+ console.error('Hardware signature verification failed:', error);
+ throw new KeyManagerError(
+ 'Failed to verify signature with hardware key',
+ KeyManagerErrorCodes.VERIFICATION_FAILED,
+ keyId
+ );
+ }
+ }
+}

infrastructure/eid-wallet/src/lib/crypto/KeyManagerFactory.ts

@@ -0,0 +1,99 @@
+import type { KeyManager, KeyManagerConfig } from './types';
+import { HardwareKeyManager } from './HardwareKeyManager';
+import { SoftwareKeyManager } from './SoftwareKeyManager';
+import { KeyManagerError, KeyManagerErrorCodes } from './types';
+
+/**
+ * Factory class to create appropriate key managers based on context
+ */
+export class KeyManagerFactory {
+ private static hardwareKeyManager: HardwareKeyManager | null = null;
+ private static softwareKeyManager: SoftwareKeyManager | null = null;
+
+ /**
+ * Get a key manager instance based on the configuration
+ */
+ static async getKeyManager(config: KeyManagerConfig): Promise<KeyManager> {
+ // If explicitly requesting hardware and not in pre-verification mode
+ if (config.useHardware && !config.preVerificationMode) {
+ return this.getHardwareKeyManager();
+ }
+
+ // If in pre-verification mode, always use software keys
+ if (config.preVerificationMode) {
+ console.log('Using software key manager for pre-verification mode');
+ return this.getSoftwareKeyManager();
+ }
+
+ // Default behavior: try hardware first, fallback to software
+ try {
+ const hardwareManager = this.getHardwareKeyManager();
+ // Test if hardware is available by checking if we can call exists
+ await hardwareManager.exists(config.keyId);
+ console.log('Using hardware key manager');
+ return hardwareManager;
+ } catch (error) {
+ console.log('Hardware key manager not available, falling back to software');
+ return this.getSoftwareKeyManager();
+ }
+ }
+
+ /**
+ * Get hardware key manager instance (singleton)
+ */
+ private static getHardwareKeyManager(): HardwareKeyManager {
+ if (!this.hardwareKeyManager) {
+ this.hardwareKeyManager = new HardwareKeyManager();
+ }
+ return this.hardwareKeyManager;
+ }
+
+ /**
+ * Get software key manager instance (singleton)
+ */
+ private static getSoftwareKeyManager(): SoftwareKeyManager {
+ if (!this.softwareKeyManager) {
+ this.softwareKeyManager = new SoftwareKeyManager();
+ }
+ return this.softwareKeyManager;
+ }
+
+ /**
+ * Check if hardware key manager is available
+ */
+ static async isHardwareAvailable(): Promise<boolean> {
+ try {
+ const hardwareManager = this.getHardwareKeyManager();
+ // Try to check if a test key exists to verify hardware availability
+ await hardwareManager.exists('test-hardware-check');
+ return true;
+ } catch (error) {
+ console.log('Hardware key manager not available:', error);
+ return false;
+ }
+ }
+
+ /**
+ * Get the appropriate key manager for a specific use case
+ */
+ static async getKeyManagerForContext(
+ keyId: string,
+ context: 'onboarding' | 'signing' | 'verification' | 'pre-verification'
+ ): Promise<KeyManager> {
+ const config: KeyManagerConfig = {
+ keyId,
+ useHardware: context !== 'pre-verification',
+ preVerificationMode: context === 'pre-verification',
+ };
+
+ return this.getKeyManager(config);
+ }
+
+ /**
+ * Reset singleton instances (useful for testing)
+ */
+ static reset(): void {
+ this.hardwareKeyManager = null;
+ this.softwareKeyManager = null;
+ }
+}

infrastructure/eid-wallet/src-tauri/gen/apple/eid-wallet.xcodeproj/project.pbxproj

@@ -416,7 +416,7 @@
  "$(TOOLCHAIN_DIR)/usr/lib/swift-5.0/$(PLATFORM_NAME)",
  );
  MARKETING_VERSION = 0.2.1;
- PRODUCT_BUNDLE_IDENTIFIER = "foundation.metastate.eid-wallet";
+ PRODUCT_BUNDLE_IDENTIFIER = foundation.metastate.eid-wallet;
  PRODUCT_NAME = "eID for W3DS";
  SDKROOT = iphoneos;
  SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";
@@ -464,7 +464,7 @@
  "$(TOOLCHAIN_DIR)/usr/lib/swift-5.0/$(PLATFORM_NAME)",
  );
  MARKETING_VERSION = 0.2.1;
- PRODUCT_BUNDLE_IDENTIFIER = "foundation.metastate.eid-wallet";
+ PRODUCT_BUNDLE_IDENTIFIER = foundation.metastate.eid-wallet;
  PRODUCT_NAME = "eID for W3DS";
  SDKROOT = iphoneos;
  SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";

infrastructure/eid-wallet/src-tauri/gen/apple/eid-wallet_iOS/Info.plist

@@ -61,4 +61,4 @@
  <string>UIInterfaceOrientationLandscapeRight</string>
 	</array>
 </dict>
-</plist>
+</plist>

infrastructure/eid-wallet/src/lib/crypto/HardwareKeyManager.ts

@@ -0,0 +1,91 @@
+import type { KeyManager } from './types';
+import { KeyManagerError, KeyManagerErrorCodes } from './types';
+import {
+ exists as hwExists,
+ generate as hwGenerate,
+ getPublicKey as hwGetPublicKey,
+ signPayload as hwSignPayload,
+ verifySignature as hwVerifySignature,
+} from '@auvo/tauri-plugin-crypto-hw-api';
+
+/**
+ * Hardware key manager implementation using Tauri crypto hardware API
+ */
+export class HardwareKeyManager implements KeyManager {
+ getType(): 'hardware' | 'software' {
+ return 'hardware';
+ }
+
+ async exists(keyId: string): Promise<boolean> {
+ try {
+ return await hwExists(keyId);
+ } catch (error) {
+ console.error('Hardware key exists check failed:', error);
+ throw new KeyManagerError(
+ 'Failed to check if hardware key exists',
+ KeyManagerErrorCodes.HARDWARE_UNAVAILABLE,
+ keyId
+ );
+ }
+ }
+
+ async generate(keyId: string): Promise<string | undefined> {
+ try {
+ const result = await hwGenerate(keyId);
+ console.log(`Hardware key generated for ${keyId}:`, result);
+ return result;
+ } catch (error) {
+ console.error('Hardware key generation failed:', error);
+ throw new KeyManagerError(
+ 'Failed to generate hardware key',
+ KeyManagerErrorCodes.KEY_GENERATION_FAILED,
+ keyId
+ );
+ }
+ }
+
+ async getPublicKey(keyId: string): Promise<string | undefined> {
+ try {
+ const publicKey = await hwGetPublicKey(keyId);
+ console.log(`Hardware public key retrieved for ${keyId}:`, publicKey);
+ return publicKey;
+ } catch (error) {
+ console.error('Hardware public key retrieval failed:', error);
+ throw new KeyManagerError(
+ 'Failed to get hardware public key',
+ KeyManagerErrorCodes.KEY_NOT_FOUND,
+ keyId
+ );
+ }
+ }
+
+ async signPayload(keyId: string, payload: string): Promise<string> {
+ try {
+ const signature = await hwSignPayload(keyId, payload);
+ console.log(`Hardware signature created for ${keyId}`);
+ return signature;
+ } catch (error) {
+ console.error('Hardware signing failed:', error);
+ throw new KeyManagerError(
+ 'Failed to sign payload with hardware key',
+ KeyManagerErrorCodes.SIGNING_FAILED,
+ keyId
+ );
+ }
+ }
+
+ async verifySignature(keyId: string, payload: string, signature: string): Promise<boolean> {
+ try {
+ const isValid = await hwVerifySignature(keyId, payload, signature);
+ console.log(`Hardware signature verification for ${keyId}:`, isValid);
+ return isValid;
+ } catch (error) {
+ console.error('Hardware signature verification failed:', error);
+ throw new KeyManagerError(
+ 'Failed to verify signature with hardware key',
+ KeyManagerErrorCodes.VERIFICATION_FAILED,
+ keyId
+ );
+ }
+ }
+}

infrastructure/eid-wallet/src/lib/crypto/KeyManagerFactory.ts

@@ -0,0 +1,99 @@
+import type { KeyManager, KeyManagerConfig } from './types';
+import { HardwareKeyManager } from './HardwareKeyManager';
+import { SoftwareKeyManager } from './SoftwareKeyManager';
+import { KeyManagerError, KeyManagerErrorCodes } from './types';
+
+/**
+ * Factory class to create appropriate key managers based on context
+ */
+export class KeyManagerFactory {
+ private static hardwareKeyManager: HardwareKeyManager | null = null;
+ private static softwareKeyManager: SoftwareKeyManager | null = null;
+
+ /**
+ * Get a key manager instance based on the configuration
+ */
+ static async getKeyManager(config: KeyManagerConfig): Promise<KeyManager> {
+ // If explicitly requesting hardware and not in pre-verification mode
+ if (config.useHardware && !config.preVerificationMode) {
+ return this.getHardwareKeyManager();
+ }
+
+ // If in pre-verification mode, always use software keys
+ if (config.preVerificationMode) {
+ console.log('Using software key manager for pre-verification mode');
+ return this.getSoftwareKeyManager();
+ }
+
+ // Default behavior: try hardware first, fallback to software
+ try {
+ const hardwareManager = this.getHardwareKeyManager();
+ // Test if hardware is available by checking if we can call exists
+ await hardwareManager.exists(config.keyId);
+ console.log('Using hardware key manager');
+ return hardwareManager;
+ } catch (error) {
+ console.log('Hardware key manager not available, falling back to software');
+ return this.getSoftwareKeyManager();
+ }
+ }
+
+ /**
+ * Get hardware key manager instance (singleton)
+ */
+ private static getHardwareKeyManager(): HardwareKeyManager {
+ if (!this.hardwareKeyManager) {
+ this.hardwareKeyManager = new HardwareKeyManager();
+ }
+ return this.hardwareKeyManager;
+ }
+
+ /**
+ * Get software key manager instance (singleton)
+ */
+ private static getSoftwareKeyManager(): SoftwareKeyManager {
+ if (!this.softwareKeyManager) {
+ this.softwareKeyManager = new SoftwareKeyManager();
+ }
+ return this.softwareKeyManager;
+ }
+
+ /**
+ * Check if hardware key manager is available
+ */
+ static async isHardwareAvailable(): Promise<boolean> {
+ try {
+ const hardwareManager = this.getHardwareKeyManager();
+ // Try to check if a test key exists to verify hardware availability
+ await hardwareManager.exists('test-hardware-check');
+ return true;
+ } catch (error) {
+ console.log('Hardware key manager not available:', error);
+ return false;
+ }
+ }
+
+ /**
+ * Get the appropriate key manager for a specific use case
+ */
+ static async getKeyManagerForContext(
+ keyId: string,
+ context: 'onboarding' | 'signing' | 'verification' | 'pre-verification'
+ ): Promise<KeyManager> {
+ const config: KeyManagerConfig = {
+ keyId,
+ useHardware: context !== 'pre-verification',
+ preVerificationMode: context === 'pre-verification',
+ };
+
+ return this.getKeyManager(config);
+ }
+
+ /**
+ * Reset singleton instances (useful for testing)
+ */
+ static reset(): void {
+ this.hardwareKeyManager = null;
+ this.softwareKeyManager = null;
+ }
+}

infrastructure/eid-wallet/src-tauri/gen/apple/eid-wallet.xcodeproj/project.pbxproj

@@ -416,7 +416,7 @@
  "$(TOOLCHAIN_DIR)/usr/lib/swift-5.0/$(PLATFORM_NAME)",
  );
  MARKETING_VERSION = 0.2.1;
- PRODUCT_BUNDLE_IDENTIFIER = "foundation.metastate.eid-wallet";
+ PRODUCT_BUNDLE_IDENTIFIER = foundation.metastate.eid-wallet;
  PRODUCT_NAME = "eID for W3DS";
  SDKROOT = iphoneos;
  SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";
@@ -464,7 +464,7 @@
  "$(TOOLCHAIN_DIR)/usr/lib/swift-5.0/$(PLATFORM_NAME)",
  );
  MARKETING_VERSION = 0.2.1;
- PRODUCT_BUNDLE_IDENTIFIER = "foundation.metastate.eid-wallet";
+ PRODUCT_BUNDLE_IDENTIFIER = foundation.metastate.eid-wallet;
  PRODUCT_NAME = "eID for W3DS";
  SDKROOT = iphoneos;
  SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";

infrastructure/eid-wallet/src-tauri/gen/apple/eid-wallet_iOS/Info.plist

@@ -61,4 +61,4 @@
  <string>UIInterfaceOrientationLandscapeRight</string>
 	</array>
 </dict>
-</plist>
+</plist>

infrastructure/eid-wallet/src/lib/crypto/HardwareKeyManager.ts

@@ -0,0 +1,91 @@
+import type { KeyManager } from './types';
+import { KeyManagerError, KeyManagerErrorCodes } from './types';
+import {
+ exists as hwExists,
+ generate as hwGenerate,
+ getPublicKey as hwGetPublicKey,
+ signPayload as hwSignPayload,
+ verifySignature as hwVerifySignature,
+} from '@auvo/tauri-plugin-crypto-hw-api';
+
+/**
+ * Hardware key manager implementation using Tauri crypto hardware API
+ */
+export class HardwareKeyManager implements KeyManager {
+ getType(): 'hardware' | 'software' {
+ return 'hardware';
+ }
+
+ async exists(keyId: string): Promise<boolean> {
+ try {
+ return await hwExists(keyId);
+ } catch (error) {
+ console.error('Hardware key exists check failed:', error);
+ throw new KeyManagerError(
+ 'Failed to check if hardware key exists',
+ KeyManagerErrorCodes.HARDWARE_UNAVAILABLE,
+ keyId
+ );
+ }
+ }
+
+ async generate(keyId: string): Promise<string | undefined> {
+ try {
+ const result = await hwGenerate(keyId);
+ console.log(`Hardware key generated for ${keyId}:`, result);
+ return result;
+ } catch (error) {
+ console.error('Hardware key generation failed:', error);
+ throw new KeyManagerError(
+ 'Failed to generate hardware key',
+ KeyManagerErrorCodes.KEY_GENERATION_FAILED,
+ keyId
+ );
+ }
+ }
+
+ async getPublicKey(keyId: string): Promise<string | undefined> {
+ try {
+ const publicKey = await hwGetPublicKey(keyId);
+ console.log(`Hardware public key retrieved for ${keyId}:`, publicKey);
+ return publicKey;
+ } catch (error) {
+ console.error('Hardware public key retrieval failed:', error);
+ throw new KeyManagerError(
+ 'Failed to get hardware public key',
+ KeyManagerErrorCodes.KEY_NOT_FOUND,
+ keyId
+ );
+ }
+ }
+
+ async signPayload(keyId: string, payload: string): Promise<string> {
+ try {
+ const signature = await hwSignPayload(keyId, payload);
+ console.log(`Hardware signature created for ${keyId}`);
+ return signature;
+ } catch (error) {
+ console.error('Hardware signing failed:', error);
+ throw new KeyManagerError(
+ 'Failed to sign payload with hardware key',
+ KeyManagerErrorCodes.SIGNING_FAILED,
+ keyId
+ );
+ }
+ }
+
+ async verifySignature(keyId: string, payload: string, signature: string): Promise<boolean> {
+ try {
+ const isValid = await hwVerifySignature(keyId, payload, signature);
+ console.log(`Hardware signature verification for ${keyId}:`, isValid);
+ return isValid;
+ } catch (error) {
+ console.error('Hardware signature verification failed:', error);
+ throw new KeyManagerError(
+ 'Failed to verify signature with hardware key',
+ KeyManagerErrorCodes.VERIFICATION_FAILED,
+ keyId
+ );
+ }
+ }
+}

infrastructure/eid-wallet/src/lib/crypto/KeyManagerFactory.ts

@@ -0,0 +1,99 @@
+import type { KeyManager, KeyManagerConfig } from './types';
+import { HardwareKeyManager } from './HardwareKeyManager';
+import { SoftwareKeyManager } from './SoftwareKeyManager';
+import { KeyManagerError, KeyManagerErrorCodes } from './types';
+
+/**
+ * Factory class to create appropriate key managers based on context
+ */
+export class KeyManagerFactory {
+ private static hardwareKeyManager: HardwareKeyManager | null = null;
+ private static softwareKeyManager: SoftwareKeyManager | null = null;
+
+ /**
+ * Get a key manager instance based on the configuration
+ */
+ static async getKeyManager(config: KeyManagerConfig): Promise<KeyManager> {
+ // If explicitly requesting hardware and not in pre-verification mode
+ if (config.useHardware && !config.preVerificationMode) {
+ return this.getHardwareKeyManager();
+ }
+
+ // If in pre-verification mode, always use software keys
+ if (config.preVerificationMode) {
+ console.log('Using software key manager for pre-verification mode');
+ return this.getSoftwareKeyManager();
+ }
+
+ // Default behavior: try hardware first, fallback to software
+ try {
+ const hardwareManager = this.getHardwareKeyManager();
+ // Test if hardware is available by checking if we can call exists
+ await hardwareManager.exists(config.keyId);
+ console.log('Using hardware key manager');
+ return hardwareManager;
+ } catch (error) {
+ console.log('Hardware key manager not available, falling back to software');
+ return this.getSoftwareKeyManager();
+ }
+ }
+
+ /**
+ * Get hardware key manager instance (singleton)
+ */
+ private static getHardwareKeyManager(): HardwareKeyManager {
+ if (!this.hardwareKeyManager) {
+ this.hardwareKeyManager = new HardwareKeyManager();
+ }
+ return this.hardwareKeyManager;
+ }
+
+ /**
+ * Get software key manager instance (singleton)
+ */
+ private static getSoftwareKeyManager(): SoftwareKeyManager {
+ if (!this.softwareKeyManager) {
+ this.softwareKeyManager = new SoftwareKeyManager();
+ }
+ return this.softwareKeyManager;
+ }
+
+ /**
+ * Check if hardware key manager is available
+ */
+ static async isHardwareAvailable(): Promise<boolean> {
+ try {
+ const hardwareManager = this.getHardwareKeyManager();
+ // Try to check if a test key exists to verify hardware availability
+ await hardwareManager.exists('test-hardware-check');
+ return true;
+ } catch (error) {
+ console.log('Hardware key manager not available:', error);
+ return false;
+ }
+ }
+
+ /**
+ * Get the appropriate key manager for a specific use case
+ */
+ static async getKeyManagerForContext(
+ keyId: string,
+ context: 'onboarding' | 'signing' | 'verification' | 'pre-verification'
+ ): Promise<KeyManager> {
+ const config: KeyManagerConfig = {
+ keyId,
+ useHardware: context !== 'pre-verification',
+ preVerificationMode: context === 'pre-verification',
+ };
+
+ return this.getKeyManager(config);
+ }
+
+ /**
+ * Reset singleton instances (useful for testing)
+ */
+ static reset(): void {
+ this.hardwareKeyManager = null;
+ this.softwareKeyManager = null;
+ }
+}

infrastructure/eid-wallet/src-tauri/gen/apple/eid-wallet.xcodeproj/project.pbxproj

@@ -416,7 +416,7 @@
  "$(TOOLCHAIN_DIR)/usr/lib/swift-5.0/$(PLATFORM_NAME)",
  );
  MARKETING_VERSION = 0.2.1;
- PRODUCT_BUNDLE_IDENTIFIER = "foundation.metastate.eid-wallet";
+ PRODUCT_BUNDLE_IDENTIFIER = foundation.metastate.eid-wallet;
  PRODUCT_NAME = "eID for W3DS";
  SDKROOT = iphoneos;
  SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";
@@ -464,7 +464,7 @@
  "$(TOOLCHAIN_DIR)/usr/lib/swift-5.0/$(PLATFORM_NAME)",
  );
  MARKETING_VERSION = 0.2.1;
- PRODUCT_BUNDLE_IDENTIFIER = "foundation.metastate.eid-wallet";
+ PRODUCT_BUNDLE_IDENTIFIER = foundation.metastate.eid-wallet;
  PRODUCT_NAME = "eID for W3DS";
  SDKROOT = iphoneos;
  SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";

infrastructure/eid-wallet/src-tauri/gen/apple/eid-wallet_iOS/Info.plist

@@ -61,4 +61,4 @@
  <string>UIInterfaceOrientationLandscapeRight</string>
 	</array>
 </dict>
-</plist>
+</plist>

infrastructure/eid-wallet/src/lib/crypto/HardwareKeyManager.ts

@@ -0,0 +1,91 @@
+import type { KeyManager } from './types';
+import { KeyManagerError, KeyManagerErrorCodes } from './types';
+import {
+ exists as hwExists,
+ generate as hwGenerate,
+ getPublicKey as hwGetPublicKey,
+ signPayload as hwSignPayload,
+ verifySignature as hwVerifySignature,
+} from '@auvo/tauri-plugin-crypto-hw-api';
+
+/**
+ * Hardware key manager implementation using Tauri crypto hardware API
+ */
+export class HardwareKeyManager implements KeyManager {
+ getType(): 'hardware' | 'software' {
+ return 'hardware';
+ }
+
+ async exists(keyId: string): Promise<boolean> {
+ try {
+ return await hwExists(keyId);
+ } catch (error) {
+ console.error('Hardware key exists check failed:', error);
+ throw new KeyManagerError(
+ 'Failed to check if hardware key exists',
+ KeyManagerErrorCodes.HARDWARE_UNAVAILABLE,
+ keyId
+ );
+ }
+ }
+
+ async generate(keyId: string): Promise<string | undefined> {
+ try {
+ const result = await hwGenerate(keyId);
+ console.log(`Hardware key generated for ${keyId}:`, result);
+ return result;
+ } catch (error) {
+ console.error('Hardware key generation failed:', error);
+ throw new KeyManagerError(
+ 'Failed to generate hardware key',
+ KeyManagerErrorCodes.KEY_GENERATION_FAILED,
+ keyId
+ );
+ }
+ }
+
+ async getPublicKey(keyId: string): Promise<string | undefined> {
+ try {
+ const publicKey = await hwGetPublicKey(keyId);
+ console.log(`Hardware public key retrieved for ${keyId}:`, publicKey);
+ return publicKey;
+ } catch (error) {
+ console.error('Hardware public key retrieval failed:', error);
+ throw new KeyManagerError(
+ 'Failed to get hardware public key',
+ KeyManagerErrorCodes.KEY_NOT_FOUND,
+ keyId
+ );
+ }
+ }
+
+ async signPayload(keyId: string, payload: string): Promise<string> {
+ try {
+ const signature = await hwSignPayload(keyId, payload);
+ console.log(`Hardware signature created for ${keyId}`);
+ return signature;
+ } catch (error) {
+ console.error('Hardware signing failed:', error);
+ throw new KeyManagerError(
+ 'Failed to sign payload with hardware key',
+ KeyManagerErrorCodes.SIGNING_FAILED,
+ keyId
+ );
+ }
+ }
+
+ async verifySignature(keyId: string, payload: string, signature: string): Promise<boolean> {
+ try {
+ const isValid = await hwVerifySignature(keyId, payload, signature);
+ console.log(`Hardware signature verification for ${keyId}:`, isValid);
+ return isValid;
+ } catch (error) {
+ console.error('Hardware signature verification failed:', error);
+ throw new KeyManagerError(
+ 'Failed to verify signature with hardware key',
+ KeyManagerErrorCodes.VERIFICATION_FAILED,
+ keyId
+ );
+ }
+ }
+}

infrastructure/eid-wallet/src/lib/crypto/KeyManagerFactory.ts

@@ -0,0 +1,99 @@
+import type { KeyManager, KeyManagerConfig } from './types';
+import { HardwareKeyManager } from './HardwareKeyManager';
+import { SoftwareKeyManager } from './SoftwareKeyManager';
+import { KeyManagerError, KeyManagerErrorCodes } from './types';
+
+/**
+ * Factory class to create appropriate key managers based on context
+ */
+export class KeyManagerFactory {
+ private static hardwareKeyManager: HardwareKeyManager | null = null;
+ private static softwareKeyManager: SoftwareKeyManager | null = null;
+
+ /**
+ * Get a key manager instance based on the configuration
+ */
+ static async getKeyManager(config: KeyManagerConfig): Promise<KeyManager> {
+ // If explicitly requesting hardware and not in pre-verification mode
+ if (config.useHardware && !config.preVerificationMode) {
+ return this.getHardwareKeyManager();
+ }
+
+ // If in pre-verification mode, always use software keys
+ if (config.preVerificationMode) {
+ console.log('Using software key manager for pre-verification mode');
+ return this.getSoftwareKeyManager();
+ }
+
+ // Default behavior: try hardware first, fallback to software
+ try {
+ const hardwareManager = this.getHardwareKeyManager();
+ // Test if hardware is available by checking if we can call exists
+ await hardwareManager.exists(config.keyId);
+ console.log('Using hardware key manager');
+ return hardwareManager;
+ } catch (error) {
+ console.log('Hardware key manager not available, falling back to software');
+ return this.getSoftwareKeyManager();
+ }
+ }
+
+ /**
+ * Get hardware key manager instance (singleton)
+ */
+ private static getHardwareKeyManager(): HardwareKeyManager {
+ if (!this.hardwareKeyManager) {
+ this.hardwareKeyManager = new HardwareKeyManager();
+ }
+ return this.hardwareKeyManager;
+ }
+
+ /**
+ * Get software key manager instance (singleton)
+ */
+ private static getSoftwareKeyManager(): SoftwareKeyManager {
+ if (!this.softwareKeyManager) {
+ this.softwareKeyManager = new SoftwareKeyManager();
+ }
+ return this.softwareKeyManager;
+ }
+
+ /**
+ * Check if hardware key manager is available
+ */
+ static async isHardwareAvailable(): Promise<boolean> {
+ try {
+ const hardwareManager = this.getHardwareKeyManager();
+ // Try to check if a test key exists to verify hardware availability
+ await hardwareManager.exists('test-hardware-check');
+ return true;
+ } catch (error) {
+ console.log('Hardware key manager not available:', error);
+ return false;
+ }
+ }
+
+ /**
+ * Get the appropriate key manager for a specific use case
+ */
+ static async getKeyManagerForContext(
+ keyId: string,
+ context: 'onboarding' | 'signing' | 'verification' | 'pre-verification'
+ ): Promise<KeyManager> {
+ const config: KeyManagerConfig = {
+ keyId,
+ useHardware: context !== 'pre-verification',
+ preVerificationMode: context === 'pre-verification',
+ };
+
+ return this.getKeyManager(config);
+ }
+
+ /**
+ * Reset singleton instances (useful for testing)
+ */
+ static reset(): void {
+ this.hardwareKeyManager = null;
+ this.softwareKeyManager = null;
+ }
+}

infrastructure/eid-wallet/src-tauri/gen/apple/eid-wallet.xcodeproj/project.pbxproj

@@ -416,7 +416,7 @@
  "$(TOOLCHAIN_DIR)/usr/lib/swift-5.0/$(PLATFORM_NAME)",
  );
  MARKETING_VERSION = 0.2.1;
- PRODUCT_BUNDLE_IDENTIFIER = "foundation.metastate.eid-wallet";
+ PRODUCT_BUNDLE_IDENTIFIER = foundation.metastate.eid-wallet;
  PRODUCT_NAME = "eID for W3DS";
  SDKROOT = iphoneos;
  SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";
@@ -464,7 +464,7 @@
  "$(TOOLCHAIN_DIR)/usr/lib/swift-5.0/$(PLATFORM_NAME)",
  );
  MARKETING_VERSION = 0.2.1;
- PRODUCT_BUNDLE_IDENTIFIER = "foundation.metastate.eid-wallet";
+ PRODUCT_BUNDLE_IDENTIFIER = foundation.metastate.eid-wallet;
  PRODUCT_NAME = "eID for W3DS";
  SDKROOT = iphoneos;
  SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";

infrastructure/eid-wallet/src-tauri/gen/apple/eid-wallet_iOS/Info.plist

@@ -61,4 +61,4 @@
  <string>UIInterfaceOrientationLandscapeRight</string>
 	</array>
 </dict>
-</plist>
+</plist>

infrastructure/eid-wallet/src/lib/crypto/HardwareKeyManager.ts

@@ -0,0 +1,91 @@
+import type { KeyManager } from './types';
+import { KeyManagerError, KeyManagerErrorCodes } from './types';
+import {
+ exists as hwExists,
+ generate as hwGenerate,
+ getPublicKey as hwGetPublicKey,
+ signPayload as hwSignPayload,
+ verifySignature as hwVerifySignature,
+} from '@auvo/tauri-plugin-crypto-hw-api';
+
+/**
+ * Hardware key manager implementation using Tauri crypto hardware API
+ */
+export class HardwareKeyManager implements KeyManager {
+ getType(): 'hardware' | 'software' {
+ return 'hardware';
+ }
+
+ async exists(keyId: string): Promise<boolean> {
+ try {
+ return await hwExists(keyId);
+ } catch (error) {
+ console.error('Hardware key exists check failed:', error);
+ throw new KeyManagerError(
+ 'Failed to check if hardware key exists',
+ KeyManagerErrorCodes.HARDWARE_UNAVAILABLE,
+ keyId
+ );
+ }
+ }
+
+ async generate(keyId: string): Promise<string | undefined> {
+ try {
+ const result = await hwGenerate(keyId);
+ console.log(`Hardware key generated for ${keyId}:`, result);
+ return result;
+ } catch (error) {
+ console.error('Hardware key generation failed:', error);
+ throw new KeyManagerError(
+ 'Failed to generate hardware key',
+ KeyManagerErrorCodes.KEY_GENERATION_FAILED,
+ keyId
+ );
+ }
+ }
+
+ async getPublicKey(keyId: string): Promise<string | undefined> {
+ try {
+ const publicKey = await hwGetPublicKey(keyId);
+ console.log(`Hardware public key retrieved for ${keyId}:`, publicKey);
+ return publicKey;
+ } catch (error) {
+ console.error('Hardware public key retrieval failed:', error);
+ throw new KeyManagerError(
+ 'Failed to get hardware public key',
+ KeyManagerErrorCodes.KEY_NOT_FOUND,
+ keyId
+ );
+ }
+ }
+
+ async signPayload(keyId: string, payload: string): Promise<string> {
+ try {
+ const signature = await hwSignPayload(keyId, payload);
+ console.log(`Hardware signature created for ${keyId}`);
+ return signature;
+ } catch (error) {
+ console.error('Hardware signing failed:', error);
+ throw new KeyManagerError(
+ 'Failed to sign payload with hardware key',
+ KeyManagerErrorCodes.SIGNING_FAILED,
+ keyId
+ );
+ }
+ }
+
+ async verifySignature(keyId: string, payload: string, signature: string): Promise<boolean> {
+ try {
+ const isValid = await hwVerifySignature(keyId, payload, signature);
+ console.log(`Hardware signature verification for ${keyId}:`, isValid);
+ return isValid;
+ } catch (error) {
+ console.error('Hardware signature verification failed:', error);
+ throw new KeyManagerError(
+ 'Failed to verify signature with hardware key',
+ KeyManagerErrorCodes.VERIFICATION_FAILED,
+ keyId
+ );
+ }
+ }
+}

infrastructure/eid-wallet/src/lib/crypto/KeyManagerFactory.ts

@@ -0,0 +1,99 @@
+import type { KeyManager, KeyManagerConfig } from './types';
+import { HardwareKeyManager } from './HardwareKeyManager';
+import { SoftwareKeyManager } from './SoftwareKeyManager';
+import { KeyManagerError, KeyManagerErrorCodes } from './types';
+
+/**
+ * Factory class to create appropriate key managers based on context
+ */
+export class KeyManagerFactory {
+ private static hardwareKeyManager: HardwareKeyManager | null = null;
+ private static softwareKeyManager: SoftwareKeyManager | null = null;
+
+ /**
+ * Get a key manager instance based on the configuration
+ */
+ static async getKeyManager(config: KeyManagerConfig): Promise<KeyManager> {
+ // If explicitly requesting hardware and not in pre-verification mode
+ if (config.useHardware && !config.preVerificationMode) {
+ return this.getHardwareKeyManager();
+ }
+
+ // If in pre-verification mode, always use software keys
+ if (config.preVerificationMode) {
+ console.log('Using software key manager for pre-verification mode');
+ return this.getSoftwareKeyManager();
+ }
+
+ // Default behavior: try hardware first, fallback to software
+ try {
+ const hardwareManager = this.getHardwareKeyManager();
+ // Test if hardware is available by checking if we can call exists
+ await hardwareManager.exists(config.keyId);
+ console.log('Using hardware key manager');
+ return hardwareManager;
+ } catch (error) {
+ console.log('Hardware key manager not available, falling back to software');
+ return this.getSoftwareKeyManager();
+ }
+ }
+
+ /**
+ * Get hardware key manager instance (singleton)
+ */
+ private static getHardwareKeyManager(): HardwareKeyManager {
+ if (!this.hardwareKeyManager) {
+ this.hardwareKeyManager = new HardwareKeyManager();
+ }
+ return this.hardwareKeyManager;
+ }
+
+ /**
+ * Get software key manager instance (singleton)
+ */
+ private static getSoftwareKeyManager(): SoftwareKeyManager {
+ if (!this.softwareKeyManager) {
+ this.softwareKeyManager = new SoftwareKeyManager();
+ }
+ return this.softwareKeyManager;
+ }
+
+ /**
+ * Check if hardware key manager is available
+ */
+ static async isHardwareAvailable(): Promise<boolean> {
+ try {
+ const hardwareManager = this.getHardwareKeyManager();
+ // Try to check if a test key exists to verify hardware availability
+ await hardwareManager.exists('test-hardware-check');
+ return true;
+ } catch (error) {
+ console.log('Hardware key manager not available:', error);
+ return false;
+ }
+ }
+
+ /**
+ * Get the appropriate key manager for a specific use case
+ */
+ static async getKeyManagerForContext(
+ keyId: string,
+ context: 'onboarding' | 'signing' | 'verification' | 'pre-verification'
+ ): Promise<KeyManager> {
+ const config: KeyManagerConfig = {
+ keyId,
+ useHardware: context !== 'pre-verification',
+ preVerificationMode: context === 'pre-verification',
+ };
+
+ return this.getKeyManager(config);
+ }
+
+ /**
+ * Reset singleton instances (useful for testing)
+ */
+ static reset(): void {
+ this.hardwareKeyManager = null;
+ this.softwareKeyManager = null;
+ }
+}

infrastructure/eid-wallet/src-tauri/gen/apple/eid-wallet.xcodeproj/project.pbxproj

@@ -416,7 +416,7 @@
  "$(TOOLCHAIN_DIR)/usr/lib/swift-5.0/$(PLATFORM_NAME)",
  );
  MARKETING_VERSION = 0.2.1;
- PRODUCT_BUNDLE_IDENTIFIER = "foundation.metastate.eid-wallet";
+ PRODUCT_BUNDLE_IDENTIFIER = foundation.metastate.eid-wallet;
  PRODUCT_NAME = "eID for W3DS";
  SDKROOT = iphoneos;
  SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";
@@ -464,7 +464,7 @@
  "$(TOOLCHAIN_DIR)/usr/lib/swift-5.0/$(PLATFORM_NAME)",
  );
  MARKETING_VERSION = 0.2.1;
- PRODUCT_BUNDLE_IDENTIFIER = "foundation.metastate.eid-wallet";
+ PRODUCT_BUNDLE_IDENTIFIER = foundation.metastate.eid-wallet;
  PRODUCT_NAME = "eID for W3DS";
  SDKROOT = iphoneos;
  SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";

infrastructure/eid-wallet/src-tauri/gen/apple/eid-wallet_iOS/Info.plist

@@ -61,4 +61,4 @@
  <string>UIInterfaceOrientationLandscapeRight</string>
 	</array>
 </dict>
-</plist>
+</plist>

infrastructure/eid-wallet/src/lib/crypto/HardwareKeyManager.ts

@@ -0,0 +1,91 @@
+import type { KeyManager } from './types';
+import { KeyManagerError, KeyManagerErrorCodes } from './types';
+import {
+ exists as hwExists,
+ generate as hwGenerate,
+ getPublicKey as hwGetPublicKey,
+ signPayload as hwSignPayload,
+ verifySignature as hwVerifySignature,
+} from '@auvo/tauri-plugin-crypto-hw-api';
+
+/**
+ * Hardware key manager implementation using Tauri crypto hardware API
+ */
+export class HardwareKeyManager implements KeyManager {
+ getType(): 'hardware' | 'software' {
+ return 'hardware';
+ }
+
+ async exists(keyId: string): Promise<boolean> {
+ try {
+ return await hwExists(keyId);
+ } catch (error) {
+ console.error('Hardware key exists check failed:', error);
+ throw new KeyManagerError(
+ 'Failed to check if hardware key exists',
+ KeyManagerErrorCodes.HARDWARE_UNAVAILABLE,
+ keyId
+ );
+ }
+ }
+
+ async generate(keyId: string): Promise<string | undefined> {
+ try {
+ const result = await hwGenerate(keyId);
+ console.log(`Hardware key generated for ${keyId}:`, result);
+ return result;
+ } catch (error) {
+ console.error('Hardware key generation failed:', error);
+ throw new KeyManagerError(
+ 'Failed to generate hardware key',
+ KeyManagerErrorCodes.KEY_GENERATION_FAILED,
+ keyId
+ );
+ }
+ }
+
+ async getPublicKey(keyId: string): Promise<string | undefined> {
+ try {
+ const publicKey = await hwGetPublicKey(keyId);
+ console.log(`Hardware public key retrieved for ${keyId}:`, publicKey);
+ return publicKey;
+ } catch (error) {
+ console.error('Hardware public key retrieval failed:', error);
+ throw new KeyManagerError(
+ 'Failed to get hardware public key',
+ KeyManagerErrorCodes.KEY_NOT_FOUND,
+ keyId
+ );
+ }
+ }
+
+ async signPayload(keyId: string, payload: string): Promise<string> {
+ try {
+ const signature = await hwSignPayload(keyId, payload);
+ console.log(`Hardware signature created for ${keyId}`);
+ return signature;
+ } catch (error) {
+ console.error('Hardware signing failed:', error);
+ throw new KeyManagerError(
+ 'Failed to sign payload with hardware key',
+ KeyManagerErrorCodes.SIGNING_FAILED,
+ keyId
+ );
+ }
+ }
+
+ async verifySignature(keyId: string, payload: string, signature: string): Promise<boolean> {
+ try {
+ const isValid = await hwVerifySignature(keyId, payload, signature);
+ console.log(`Hardware signature verification for ${keyId}:`, isValid);
+ return isValid;
+ } catch (error) {
+ console.error('Hardware signature verification failed:', error);
+ throw new KeyManagerError(
+ 'Failed to verify signature with hardware key',
+ KeyManagerErrorCodes.VERIFICATION_FAILED,
+ keyId
+ );
+ }
+ }
+}

infrastructure/eid-wallet/src/lib/crypto/KeyManagerFactory.ts

@@ -0,0 +1,99 @@
+import type { KeyManager, KeyManagerConfig } from './types';
+import { HardwareKeyManager } from './HardwareKeyManager';
+import { SoftwareKeyManager } from './SoftwareKeyManager';
+import { KeyManagerError, KeyManagerErrorCodes } from './types';
+
+/**
+ * Factory class to create appropriate key managers based on context
+ */
+export class KeyManagerFactory {
+ private static hardwareKeyManager: HardwareKeyManager | null = null;
+ private static softwareKeyManager: SoftwareKeyManager | null = null;
+
+ /**
+ * Get a key manager instance based on the configuration
+ */
+ static async getKeyManager(config: KeyManagerConfig): Promise<KeyManager> {
+ // If explicitly requesting hardware and not in pre-verification mode
+ if (config.useHardware && !config.preVerificationMode) {
+ return this.getHardwareKeyManager();
+ }
+
+ // If in pre-verification mode, always use software keys
+ if (config.preVerificationMode) {
+ console.log('Using software key manager for pre-verification mode');
+ return this.getSoftwareKeyManager();
+ }
+
+ // Default behavior: try hardware first, fallback to software
+ try {
+ const hardwareManager = this.getHardwareKeyManager();
+ // Test if hardware is available by checking if we can call exists
+ await hardwareManager.exists(config.keyId);
+ console.log('Using hardware key manager');
+ return hardwareManager;
+ } catch (error) {
+ console.log('Hardware key manager not available, falling back to software');
+ return this.getSoftwareKeyManager();
+ }
+ }
+
+ /**
+ * Get hardware key manager instance (singleton)
+ */
+ private static getHardwareKeyManager(): HardwareKeyManager {
+ if (!this.hardwareKeyManager) {
+ this.hardwareKeyManager = new HardwareKeyManager();
+ }
+ return this.hardwareKeyManager;
+ }
+
+ /**
+ * Get software key manager instance (singleton)
+ */
+ private static getSoftwareKeyManager(): SoftwareKeyManager {
+ if (!this.softwareKeyManager) {
+ this.softwareKeyManager = new SoftwareKeyManager();
+ }
+ return this.softwareKeyManager;
+ }
+
+ /**
+ * Check if hardware key manager is available
+ */
+ static async isHardwareAvailable(): Promise<boolean> {
+ try {
+ const hardwareManager = this.getHardwareKeyManager();
+ // Try to check if a test key exists to verify hardware availability
+ await hardwareManager.exists('test-hardware-check');
+ return true;
+ } catch (error) {
+ console.log('Hardware key manager not available:', error);
+ return false;
+ }
+ }
+
+ /**
+ * Get the appropriate key manager for a specific use case
+ */
+ static async getKeyManagerForContext(
+ keyId: string,
+ context: 'onboarding' | 'signing' | 'verification' | 'pre-verification'
+ ): Promise<KeyManager> {
+ const config: KeyManagerConfig = {
+ keyId,
+ useHardware: context !== 'pre-verification',
+ preVerificationMode: context === 'pre-verification',
+ };
+
+ return this.getKeyManager(config);
+ }
+
+ /**
+ * Reset singleton instances (useful for testing)
+ */
+ static reset(): void {
+ this.hardwareKeyManager = null;
+ this.softwareKeyManager = null;
+ }
+}

infrastructure/eid-wallet/src-tauri/gen/apple/eid-wallet.xcodeproj/project.pbxproj

@@ -416,7 +416,7 @@
  "$(TOOLCHAIN_DIR)/usr/lib/swift-5.0/$(PLATFORM_NAME)",
  );
  MARKETING_VERSION = 0.2.1;
- PRODUCT_BUNDLE_IDENTIFIER = "foundation.metastate.eid-wallet";
+ PRODUCT_BUNDLE_IDENTIFIER = foundation.metastate.eid-wallet;
  PRODUCT_NAME = "eID for W3DS";
  SDKROOT = iphoneos;
  SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";
@@ -464,7 +464,7 @@
  "$(TOOLCHAIN_DIR)/usr/lib/swift-5.0/$(PLATFORM_NAME)",
  );
  MARKETING_VERSION = 0.2.1;
- PRODUCT_BUNDLE_IDENTIFIER = "foundation.metastate.eid-wallet";
+ PRODUCT_BUNDLE_IDENTIFIER = foundation.metastate.eid-wallet;
  PRODUCT_NAME = "eID for W3DS";
  SDKROOT = iphoneos;
  SUPPORTED_PLATFORMS = "iphoneos iphonesimulator";

infrastructure/eid-wallet/src-tauri/gen/apple/eid-wallet_iOS/Info.plist

@@ -61,4 +61,4 @@
  <string>UIInterfaceOrientationLandscapeRight</string>
 	</array>
 </dict>
-</plist>
+</plist>

infrastructure/eid-wallet/src/lib/crypto/HardwareKeyManager.ts

@@ -0,0 +1,91 @@
+import type { KeyManager } from './types';
+import { KeyManagerError, KeyManagerErrorCodes } from './types';
+import {
+ exists as hwExists,
+ generate as hwGenerate,
+ getPublicKey as hwGetPublicKey,
+ signPayload as hwSignPayload,
+ verifySignature as hwVerifySignature,
+} from '@auvo/tauri-plugin-crypto-hw-api';
+
+/**
+ * Hardware key manager implementation using Tauri crypto hardware API
+ */
+export class HardwareKeyManager implements KeyManager {
+ getType(): 'hardware' | 'software' {
+ return 'hardware';
+ }
+
+ async exists(keyId: string): Promise<boolean> {
+ try {
+ return await hwExists(keyId);
+ } catch (error) {
+ console.error('Hardware key exists check failed:', error);
+ throw new KeyManagerError(
+ 'Failed to check if hardware key exists',
+ KeyManagerErrorCodes.HARDWARE_UNAVAILABLE,
+ keyId
+ );
+ }
+ }
+
+ async generate(keyId: string): Promise<string | undefined> {
+ try {
+ const result = await hwGenerate(keyId);
+ console.log(`Hardware key generated for ${keyId}:`, result);
+ return result;
+ } catch (error) {
+ console.error('Hardware key generation failed:', error);
+ throw new KeyManagerError(
+ 'Failed to generate hardware key',
+ KeyManagerErrorCodes.KEY_GENERATION_FAILED,
+ keyId
+ );
+ }
+ }
+
+ async getPublicKey(keyId: string): Promise<string | undefined> {
+ try {
+ const publicKey = await hwGetPublicKey(keyId);
+ console.log(`Hardware public key retrieved for ${keyId}:`, publicKey);
+ return publicKey;
+ } catch (error) {
+ console.error('Hardware public key retrieval failed:', error);
+ throw new KeyManagerError(
+ 'Failed to get hardware public key',
+ KeyManagerErrorCodes.KEY_NOT_FOUND,
+ keyId
+ );
+ }
+ }
+
+ async signPayload(keyId: string, payload: string): Promise<string> {
+ try {
+ const signature = await hwSignPayload(keyId, payload);
+ console.log(`Hardware signature created for ${keyId}`);
+ return signature;
+ } catch (error) {
+ console.error('Hardware signing failed:', error);
+ throw new KeyManagerError(
+ 'Failed to sign payload with hardware key',
+ KeyManagerErrorCodes.SIGNING_FAILED,
+ keyId
+ );
+ }
+ }
+
+ async verifySignature(keyId: string, payload: string, signature: string): Promise<boolean> {
+ try {
+ const isValid = await hwVerifySignature(keyId, payload, signature);
+ console.log(`Hardware signature verification for ${keyId}:`, isValid);
+ return isValid;
+ } catch (error) {
+ console.error('Hardware signature verification failed:', error);
+ throw new KeyManagerError(
+ 'Failed to verify signature with hardware key',
+ KeyManagerErrorCodes.VERIFICATION_FAILED,
+ keyId
+ );
+ }
+ }
+}

infrastructure/eid-wallet/src/lib/crypto/KeyManagerFactory.ts

@@ -0,0 +1,99 @@
+import type { KeyManager, KeyManagerConfig } from './types';
+import { HardwareKeyManager } from './HardwareKeyManager';
+import { SoftwareKeyManager } from './SoftwareKeyManager';
+import { KeyManagerError, KeyManagerErrorCodes } from './types';
+
+/**
+ * Factory class to create appropriate key managers based on context
+ */
+export class KeyManagerFactory {
+ private static hardwareKeyManager: HardwareKeyManager | null = null;
+ private static softwareKeyManager: SoftwareKeyManager | null = null;
+
+ /**
+ * Get a key manager instance based on the configuration
+ */
+ static async getKeyManager(config: KeyManagerConfig): Promise<KeyManager> {
+ // If explicitly requesting hardware and not in pre-verification mode
+ if (config.useHardware && !config.preVerificationMode) {
+ return this.getHardwareKeyManager();
+ }
+
+ // If in pre-verification mode, always use software keys
+ if (config.preVerificationMode) {
+ console.log('Using software key manager for pre-verification mode');
+ return this.getSoftwareKeyManager();
+ }
+
+ // Default behavior: try hardware first, fallback to software
+ try {
+ const hardwareManager = this.getHardwareKeyManager();
+ // Test if hardware is available by checking if we can call exists
+ await hardwareManager.exists(config.keyId);
+ console.log('Using hardware key manager');
+ return hardwareManager;
+ } catch (error) {
+ console.log('Hardware key manager not available, falling back to software');
+ return this.getSoftwareKeyManager();
+ }
+ }
+
+ /**
+ * Get hardware key manager instance (singleton)
+ */
+ private static getHardwareKeyManager(): HardwareKeyManager {
+ if (!this.hardwareKeyManager) {
+ this.hardwareKeyManager = new HardwareKeyManager();
+ }
+ return this.hardwareKeyManager;
+ }
+
+ /**
+ * Get software key manager instance (singleton)
+ */
+ private static getSoftwareKeyManager(): SoftwareKeyManager {
+ if (!this.softwareKeyManager) {
+ this.softwareKeyManager = new SoftwareKeyManager();
+ }
+ return this.softwareKeyManager;
+ }
+
+ /**
+ * Check if hardware key manager is available
+ */
+ static async isHardwareAvailable(): Promise<boolean> {
+ try {
+ const hardwareManager = this.getHardwareKeyManager();
+ // Try to check if a test key exists to verify hardware availability
+ await hardwareManager.exists('test-hardware-check');
+ return true;
+ } catch (error) {
+ console.log('Hardware key manager not available:', error);
+ return false;
+ }
+ }
+
+ /**
+ * Get the appropriate key manager for a specific use case
+ */
+ static async getKeyManagerForContext(
+ keyId: string,
+ context: 'onboarding' | 'signing' | 'verification' | 'pre-verification'
+ ): Promise<KeyManager> {
+ const config: KeyManagerConfig = {
+ keyId,
+ useHardware: context !== 'pre-verification',
+ preVerificationMode: context === 'pre-verification',
+ };
+
+ return this.getKeyManager(config);
+ }
+
+ /**
+ * Reset singleton instances (useful for testing)
+ */
+ static reset(): void {
+ this.hardwareKeyManager = null;
+ this.softwareKeyManager = null;
+ }
+}