Natuurlijk! Hier zijn best practices en tips voor het veilig opslaan en versleutelen van gevoelige gegevens in je Capacitor-app met gebruik van SQLite, gericht op naleving van GDPR en platformspecifieke beveiligingsmaatregelen voor iOS en Android. **1. Algemene best practices voor veilige gegevensopslag** - **Versleutel alle gevoelige gegevens** voordat je ze opslaat in de database. - **Gebruik veilige opslag voor encryptiesleutels**, zoals de Keychain op iOS en de Android Keystore. - **Beperk toegang** tot gevoelige gegevens, bijvoorbeeld door data alleen te ontsluiten na authenticatie. - **Regelmatige beveiligingsaudits** en code reviews. --- **2. Encryptie van gegevens** Gebruik sterke encryptiestandaarden zoals AES-256. Voor het genereren en beheren van sleutels, maak gebruik van platform-specifieke beveiligingsmodules. --- **3. Beheer van encryptiesleutels** - **iOS:** Gebruik de Keychain via plugins zoals `cordova-plugin-keychain-touch-id` of `react-native-keychain`. - **Android:** Gebruik de Android Keystore systeem via plugins zoals `react-native-sensitive-info` of native code. **4. Implementatie voorbeelden** Hier is een overzicht van implementaties voor beide platforms: --- ### a) Gebruik van `@ionic-native/sqlite` en encryptie Voor het versleutelen van data in SQLite, kun je gebruik maken van de plugin [`cordova-sqlite-storage-advanced`](https://github.com/nolanlawson/cordova-sqlite-storage) met encryptie of een wrapper zoals [`sqlcipher`](https://www.sqlcipher.net/). **Tip:** Gebruik `react-native-sqlcipher-storage` of een vergelijkbare plugin voor encryptie. --- ### b) Encryptie met AES in JavaScript Gebruik bijvoorbeeld de `crypto` API via een library zoals `crypto-js`. ```typescript import CryptoJS from 'crypto-js'; const SECRET_KEY = 'je-sterke-secret-sleutel'; // Vervang door veilige sleutelbeheer // Data encryptie function encryptData(data: string): string { return CryptoJS.AES.encrypt(data, SECRET_KEY).toString(); } // Data decryptie function decryptData(cipherText: string): string { const bytes = CryptoJS.AES.decrypt(cipherText, SECRET_KEY); return bytes.toString(CryptoJS.enc.Utf8); } ``` **Opmerking:** Voor productie, bewaar de `SECRET_KEY` niet hardcoded. Gebruik platform-specifieke beveiligingsoplossingen. --- ### c) Sleutels veilig opslaan **iOS (Keychain):** Gebruik bijvoorbeeld de plugin [cordova-plugin-keychain-touch-id](https://github.com/frida/cordova-plugin-keychain-touch-id). ```typescript import { Keychain } from '@ionic-native/keychain/ngx'; constructor(private keychain: Keychain) { } async saveKey() { await this.keychain.set('encryptionKey', 'jouw-veilige-sleutel'); } async getKey(): Promise<string> { const key = await this.keychain.get('encryptionKey'); return key; } ``` **ii Android (Keystore):** Gebruik een plugin zoals `@ionic-native/android-keystore` of `react-native-sensitive-info`. ```typescript import { Storage } from '@ionic/storage-angular'; async function saveEncryptionKey(key: string) { await storage.set('encryptionKey', key); } async function getEncryptionKey(): Promise<string | null> { return await storage.get('encryptionKey'); } ``` Voor extra beveiliging, maak gebruik van Android Keystore via native code of plugins. --- ### d) Platform-specifieke configuraties - **iOS:** Plaats de app in 'App Transport Security' (ATS) in `Info.plist` om veilige verbindingen te vereisen. - **Android:** Zorg dat je `networkSecurityConfig` gebruikt indien je communicatie beveiligt. --- ### e) Richtlijnen voor GDPR-naleving - **Minimaliseer gegevensverwerking:** Sla alleen noodzakelijke gegevens op. - **Versleutel alle gevoelige gegevens** en beheer sleutels veilig. - **Verwerk gegevens in overeenstemming met de gebruikerstoestemming**. - **Bied gebruikers inzicht en controle** over hun data. - **Bewaar gegevens niet langer dan nodig**. --- ### Samenvatting | Stap | Actie | Technologie / Plugin | Opmerkingen | |-------|--------|------------------------|--------------| | 1 | Kies encryptiestandaard | AES-256 via CryptoJS of native encryptie | Gebruik sterke, goed geteste libraries | | 2 | Beheer sleutels | Keychain (iOS), Keystore (Android) | Gebruik platform-specifieke beveiliging | | 3 | Versleutel data voor opslag | Encrypt vóór het opslaan in SQLite | Implementeer transparante encryptie-layer | | 4 | Beperk toegang en geef gebruikers controle | Authenticatie, toestemming | Volg GDPR-richtlijnen | --- **Conclusie:** Door data te versleutelen met AES-256, sleutels op te slaan in platform-beveiligde opslag, en alleen noodzakelijke gegevens te bewaren, zorg je voor een veel veiligere gegevensopslag. Combineer dit met goede beveiligingspraktijken en naleving van GDPR. Indien je verdere hulp nodig hebt bij specifieke implementaties, laat het gerust weten!

Hier is een uitgebreide handleiding voor het implementeren van veilige gegevensopslag in je Capacitor-app met SQLite, GDPR-conformiteit en platform-specifieke configuratie. ## 1. Basis SQLite Setup met Capacitor Eerst installeer je de benodigde packages: ```bash npm install @capacitor-community/sqlite npm install crypto-js @types/crypto-js ``` ## 2. Geavanceerde Encryptie Service ```typescript // encryption.service.ts import { Injectable } from '@angular/core'; import * as CryptoJS from 'crypto-js'; @Injectable({ providedIn: 'root' }) export class EncryptionService { private encryptionKey: string; constructor() { this.initializeEncryptionKey(); } private async initializeEncryptionKey(): Promise<void> { // Gebruik een combinatie van device-specifieke ID en gebruikerswachtwoord this.encryptionKey = await this.generateSecureKey(); } private async generateSecureKey(): Promise<string> { // Genereer een veilige sleutel met device ID en gebruikersinput const deviceId = await this.getDeviceId(); const userPin = await this.getUserPin(); // Implementeer veilige PIN opslag return CryptoJS.PBKDF2(userPin, deviceId, { keySize: 256/32, iterations: 10000 }).toString(); } encryptData(data: string): string { try { return CryptoJS.AES.encrypt(data, this.encryptionKey).toString(); } catch (error) { console.error('Encryption error:', error); throw new Error('Data encryption failed'); } } decryptData(encryptedData: string): string { try { const bytes = CryptoJS.AES.decrypt(encryptedData, this.encryptionKey); return bytes.toString(CryptoJS.enc.Utf8); } catch (error) { console.error('Decryption error:', error); throw new Error('Data decryption failed'); } } private async getDeviceId(): Promise<string> { // Implementeer device ID ophalen (bijv. via Device plugin) return 'unique-device-identifier'; } private async getUserPin(): Promise<string> { // Implementeer veilige PIN opslag (bijv. via Secure Storage) return 'user-provided-pin'; } } ``` ## 3. Veilige Database Service ```typescript // database.service.ts import { Injectable } from '@angular/core'; import { CapacitorSQLite, SQLiteConnection, SQLiteDBConnection } from '@capacitor-community/sqlite'; import { EncryptionService } from './encryption.service'; @Injectable({ providedIn: 'root' }) export class DatabaseService { private sqlite: SQLiteConnection; private db: SQLiteDBConnection; private dbName = 'secure_app_db'; private encryptedFields = ['email', 'phone', 'personal_data', 'password']; constructor(private encryptionService: EncryptionService) { this.sqlite = new SQLiteConnection(CapacitorSQLite); } async initializeDatabase(): Promise<void> { try { // Check of SQLite beschikbaar is const isAvailable = await this.sqlite.isAvailable(); if (!isAvailable) { throw new Error('SQLite not available'); } // Open of maak database this.db = await this.sqlite.createConnection( this.dbName, false, 'no-encryption', 1, false ); await this.db.open(); // Creëer beveiligde tabellen await this.createTables(); } catch (error) { console.error('Database initialization failed:', error); throw error; } } private async createTables(): Promise<void> { const userTable = ` CREATE TABLE IF NOT EXISTS users ( id INTEGER PRIMARY KEY AUTOINCREMENT, email TEXT NOT NULL, phone TEXT, personal_data TEXT, created_at DATETIME DEFAULT CURRENT_TIMESTAMP, updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ); `; const sessionTable = ` CREATE TABLE IF NOT EXISTS sessions ( id INTEGER PRIMARY KEY AUTOINCREMENT, token TEXT NOT NULL, user_id INTEGER, expires_at DATETIME, created_at DATETIME DEFAULT CURRENT_TIMESTAMP, FOREIGN KEY (user_id) REFERENCES users (id) ); `; await this.db.execute(userTable); await this.db.execute(sessionTable); } async insertUser(userData: any): Promise<any> { // Versleutel gevoelige data voor opslag const encryptedData = { ...userData }; this.encryptedFields.forEach(field => { if (encryptedData[field]) { encryptedData[field] = this.encryptionService.encryptData(encryptedData[field]); } }); const query = ` INSERT INTO users (email, phone, personal_data) VALUES (?, ?, ?) `; const result = await this.db.run(query, [ encryptedData.email, encryptedData.phone, encryptedData.personal_data ]); return result; } async getUser(userId: number): Promise<any> { const query = `SELECT * FROM users WHERE id = ?`; const result = await this.db.query(query, [userId]); if (result.values && result.values.length > 0) { const user = result.values[0]; // Decrypt gevoelige data this.encryptedFields.forEach(field => { if (user[field]) { user[field] = this.encryptionService.decryptData(user[field]); } }); return user; } return null; } async closeDatabase(): Promise<void> { if (this.db) { await this.sqlite.closeConnection(this.dbName, false); } } async deleteAllData(): Promise<void> { // GDPR: Right to be forgotten await this.db.execute('DELETE FROM users'); await this.db.execute('DELETE FROM sessions'); } } ``` ## 4. Secure Storage voor Sleutelbeheer ```typescript // secure-storage.service.ts import { Injectable } from '@angular/core'; import { SecureStoragePlugin } from 'capacitor-secure-storage-plugin'; @Injectable({ providedIn: 'root' }) export class SecureStorageService { async set(key: string, value: string): Promise<void> { try { await SecureStoragePlugin.set({ key, value }); } catch (error) { console.error('Secure storage set error:', error); throw error; } } async get(key: string): Promise<string> { try { const result = await SecureStoragePlugin.get({ key }); return result.value; } catch (error) { console.error('Secure storage get error:', error); throw error; } } async remove(key: string): Promise<void> { try { await SecureStoragePlugin.remove({ key }); } catch (error) { console.error('Secure storage remove error:', error); throw error; } } async clear(): Promise<void> { try { await SecureStoragePlugin.clear(); } catch (error) { console.error('Secure storage clear error:', error); throw error; } } } ``` ## 5. Platform-specifieke Configuratie ### iOS Configuratie (capacitor.config.ts) ```typescript const config: CapacitorConfig = { appId: 'com.jouwapp.secure', appName: 'Secure App', webDir: 'www', plugins: { SecureStoragePlugin: { key: 'secure_storage', iosKeychainAccessibility: 'kSecAttrAccessibleWhenUnlockedThisDeviceOnly' }, PrivacyScreen: { enable: true } }, ios: { scheme: 'SecureApp', privacyManifests: { NSPrivacyAccessedAPITypes: [ { NSPrivacyAccessedAPIType: "NSPrivacyAccessedAPICategoryFileTimestamp", NSPrivacyAccessedAPITypeReasons: ["C617.1"] } ] } } }; ``` ### Android Configuratie (android/app/src/main/AndroidManifest.xml) ```xml <application android:allowBackup="false" android:usesCleartextTraffic="false" android:requestLegacyExternalStorage="false"> <meta-data android:name="android.max_aspect" android:value="2.1" /> <activity android:exported="true" android:launchMode="singleTask" android:screenOrientation="portrait" android:configChanges="orientation|keyboardHidden|keyboard|screenSize|locale|smallestScreenSize|screenLayout|uiMode" android:windowSoftInputMode="adjustResize"> <intent-filter android:autoVerify="true"> <action android:name="android.intent.action.VIEW" /> <category android:name="android.intent.category.DEFAULT" /> <category android:name="android.intent.category.BROWSABLE" /> <data android:scheme="https" /> <data android:host="jouwdomein.com" /> </intent-filter> </activity> </application> ``` ## 6. GDPR Compliance Maatregelen ```typescript // gdpr.service.ts import { Injectable } from '@angular/core'; @Injectable({ providedIn: 'root' }) export class GdprService { async getUserConsent(): Promise<boolean> { // Implementeer GDPR consent management return await this.checkConsentStatus(); } async exportUserData(userId: number): Promise<any> { // GDPR: Right to data portability const userData = await this.getUserDataForExport(userId); return this.formatExportData(userData); } async anonymizeUserData(userId: number): Promise<void> { // GDPR: Right to be forgotten (pseudonimisatie) await this.anonymizeUserRecords(userId); } async recordDataProcessingActivity(activity: string): Promise<void> { // Log verwerkingsactiviteiten voor accountability await this.logProcessingActivity(activity); } private async checkConsentStatus(): Promise<boolean> { // Controleer of gebruiker toestemming heeft gegeven return true; // Implementeer daadwerkelijke logica } } ``` ## 7. Beveiligings Best Practices ### Aanvullende Beveiligingsmaatregelen: 1. **Certificate Pinning** (voor API calls) 2. **Biometrische authenticatie** voor sleuteltoegang 3. **Automatische data vernietiging** bij herhaalde mislukte pogingen 4. **Tijdsgebonden sessies** 5. **Device binding** voor encryptiesleutels ### Dependency Configuratie (package.json): ```json { "dependencies": { "@capacitor-community/sqlite": "^5.0.0", "capacitor-secure-storage-plugin": "^0.7.0", "crypto-js": "^4.1.1" } } ``` ## 8. Test Procedures ```typescript // security.test.ts describe('Security Implementation', () => { it('should encrypt sensitive data', async () => { const testData = 'gevoelige_informatie'; const encrypted = encryptionService.encryptData(testData); expect(encrypted).not.toEqual(testData); }); it('should decrypt data correctly', async () => { const testData = 'gevoelige_informatie'; const encrypted = encryptionService.encryptData(testData); const decrypted = encryptionService.decryptData(encrypted); expect(decrypted).toEqual(testData); }); }); ``` Deze implementatie voldoet aan GDPR-vereisten door: - Data minimalisatie - Toestemmingsbeheer - Recht op vergetelheid - Data portability - Encryptie van gevoelige gegevens - Veilig sleutelbeheer Zorg ervoor dat je de beveiliging regelmatig test en updates uitvoert volgens de laatste beveiligingsstandaarden.