Umgang mit Nutzerdaten in Capacitor Apps

Der Umgang mit Nutzerdaten in Capacitor Apps erfordert sichere Speicherung, klare Löschfristen und die Einhaltung von Datenschutzgesetzen wie DSGVO und CCPA. In diesem Guide erfährst du, wie du die Datenerfassung minimierst, sensible Informationen sicherst und Berechtigungen effektiv verwaltest. Hier ist ein kurzer Überblick:

• Datenminimierung: Erfasse nur das, was für spezifische App-Features notwendig ist.
• Sichere Speicherung: Nutze Tools wie das @capacitor/secure-storage Plugin für die Verschlüsselung.
• Datenaufbewahrung: Automatisiere das Löschen basierend auf festgelegten Zeitlimits.
• Nutzerrechte: Ermögliche es Nutzern, ihre Daten einzusehen, zu löschen oder zu exportieren.
• Berechtigungsmanagement: Fordere Berechtigungen kontextbezogen an und biete Alternativen für abgelehnte Anfragen an.
• OTA-Updates: Gewährleisten Sie sichere Over-the-Air-Updates mit Tools wie Capgo.

So nutzen Sie Ionic Capacitor Sichere Speicherung

Datenerhebung reduzieren

Ein strukturierter Ansatz bei der Überprüfung, Planung und Verwaltung der Datenerhebung ist entscheidend, um die Datenschutzbestimmungen einzuhalten. Mit den integrierten Tools von Capacitor zur Minimierung der Datenerhebung können Sie praktische Schritte zur Verbesserung der Datenpraktiken Ihrer App unternehmen.

Überprüfung der Datenerhebung

Beginnen Sie damit, den Datenfluss in Ihrer App zu kartieren. Nutzen Sie Tools wie Data-Lineage-Visualisierer, um Bereiche zu identifizieren, in denen unnötige Daten gesammelt werden könnten. Eine Privacy Impact Assessment (PIA) Software kann Sie dabei unterstützen, zu bewerten, ob jeder Datenpunkt wirklich benötigt wird. Hier ist eine Übersicht der Schwerpunkte:

Ziele der Datenerhebung

Sei transparent darüber, warum du jedes einzelne Datum erhebst. Jeder Datenpunkt sollte einem spezifischen Zweck dienen. Zum Beispiel:

// Purpose-driven data collection example
const userPreferences = {
  location: "Used for local weather updates",
  notification: "Needed for sending alerts"
};

Wenn deine App eine Wetterfunktion hat, reicht eventuell eine code statt einer vollständigen Adresse. So stellst du sicher, dass du nur Informationen sammelst, die für die Kernfunktionen nötig sind.[1][5].

Kontrolle der Dateneingabe

Nutze Validierungstools, um die Datenmenge bei Formularen und API Aufrufen zu begrenzen. Kombiniere Client-seitige Validierung mit Server-seitiger Verifizierung, um diese Limits effektiv durchzusetzen.

Nutze die Sicherheitsfeatures von Capacitor, um diese Kontrollen zu verstärken:

• Verwende nach Möglichkeit Dropdown-Menüs statt Freitextfeldern.
• Setze Zeichenlimits für Textfelder.

Plane vierteljährliche Audits mit automatisierten Discovery-Tools, um sicherzustellen, dass deine Datenerhebung effizient bleibt und zur Funktionalität deiner App passt.

Datensicherheit und Speicherung

Sobald die Grenzen der Datenerhebung festgelegt sind, müssen Maßnahmen zum Schutz der Nutzerdaten implementiert werden, wobei das Prinzip der Datenminimierung strikt einzuhalten ist.

Sichere Speicherung einrichten

Die @capacitor/secure-storage Das Plugin nutzt integrierte Sicherheitsfunktionen wie den iOS Keychain und den Android Keystore, um sensible Daten zu schützen [1]. Für größere, strukturierte Datensätze @capgo/capacitor-data-storage-sqlite bietet verschlüsselte SQLite-Speicherung, und @capgo/capacitor-persistent-account kann den Account-Status auch nach Neuinstallationen beibehalten. @capgo/capacitor-privacy-screen verdeckt sensible UI-Elemente im App-Switcher und in der Übersicht der zuletzt verwendeten Apps.

import { SecureStorage } from '@capacitor/secure-storage';

// Store sensitive data
await SecureStorage.set({
  key: 'authToken',
  value: 'user-specific-token'
});

// Retrieve stored data
const { value } = await SecureStorage.get({ key: 'authToken' });

Methoden zur Datenverschlüsselung

Eine clientseitige Verschlüsselung bietet eine zusätzliche Schutzschicht. Libraries wie CryptoJS can help encrypt sensitive information:

// Basic encryption/decryption implementation
const encryptData = (data: string, key: string): string => {
  return CryptoJS.AES.encrypt(data, key).toString();
};

Ein regelmäßiger Wechsel der Encryption Keys ist ein smarter Weg, die Sicherheit zu erhöhen. So bleibt der Rest der Daten geschützt, selbst wenn ein Key kompromittiert wird. [2].

Vergleich der Storage-Optionen

Die Wahl der richtigen Storage-Lösung hängt von der Sensibilität der Daten ab. Hier ein kurzer Vergleich:

Der Secure Storage API ist eine gute Wahl, um kritische Informationen wie Authentifizierungs-Tokens und persönliche Nutzerdaten zu speichern [1][4]. Sein Verschlüsselungs-Feature entspricht zudem den Retention-Policies und ermöglicht so den kontrollierten Zugriff auf Daten innerhalb festgelegter Zeiträume [2].

sbb-itb-f9944d2

Speicherdauer von Daten

Klare Richtlinien zur Datenaufbewahrung helfen dabei, das Prinzip der Datenminimierung einzuhalten und sicherzustellen, dass Informationen nicht länger als nötig gespeichert werden.

Regeln zur Speicherdauer

Verschiedene Arten von Nutzerdaten sollten basierend auf ihrem Zweck und ihrer Sensibilität festgelegte Aufbewahrungsfristen haben. Hier ist ein Vorschlag für das Datenmanagement in Capacitor Apps:

Hier ist ein Beispiel, wie man Daten mit einem Ablaufdatum programmatisch speichert:

async function storeDataWithExpiration(key: string, value: any, retentionDays: number) {
  const item = {
    value: value,
    expiration: Date.now() + (retentionDays * 24 * 60 * 60 * 1000)
  };
  await Preferences.set({ key, value: JSON.stringify(item) });
}

Automatische Datenlöschung

Die Automatisierung der Datenbereinigung hilft dabei, die Compliance einzuhalten und manuellen Aufwand zu reduzieren. Die Background-Fetch-Funktion von Capacitor ist dafür ein hilfreiches Tool:

import { BackgroundFetch } from '@capacitor/background-fetch';

BackgroundFetch.registerTask({
  taskId: 'data-cleanup',
  delay: 3600000,
  periodic: true,
  requiresNetworkConnectivity: false
}, async () => {
  await cleanExpiredData();
  return BackgroundFetch.Result.NewData;
});

If you’re using SQLite für die Speicherung. Du kannst Trigger einrichten, um abgelaufene Datensätze automatisch zu löschen:

CREATE TRIGGER remove_expired_data
AFTER INSERT ON user_data
BEGIN
  DELETE FROM user_data 
  WHERE expiration_date < CURRENT_TIMESTAMP;
END;

Optionen zum Löschen von Nutzerdaten

Nutzern Tools zur Datenverwaltung bereitzustellen, ist essenziell. Hier sind zwei wichtige Funktionen, die du implementieren kannst:

• Spezifische Daten löschen: Erlaube Nutzern, bestimmte Datentypen zu entfernen, die mit ihrem Account verknüpft sind.

async function deleteSpecificData(userId: string, dataType: string) {
  await Preferences.remove({ key: `${userId}_${dataType}` });

  if (db) {
    await db.run(
      'DELETE FROM user_data WHERE user_id = ? AND data_type = ?',
      [userId, dataType]
    );
  }
}

• Nutzerdaten exportieren: Ermögliche es Nutzern, ihre gespeicherten Daten in einem strukturierten Format herunterzuladen.

async function exportUserData(userId: string) {
  // Gathers all user data for export
  const userData = await collectUserData(userId);
  return JSON.stringify(userData);
}

Die französische Datenschutzbehörde CNIL betont, dass Aufbewahrungsfristen mit der Kernfunktionalität der App übereinstimmen müssen [3]. Dieses Prinzip ist besonders relevant für Capacitor App-Entwickler und sollte deine Strategie zur Datenaufbewahrung leiten.

App-Berechtigungen steuern

Ein sorgfältiger Umgang mit App-Berechtigungen ist entscheidend, um Nutzerdaten zu schützen und gleichzeitig die volle Funktionalität Ihrer App zu gewährleisten. Durch ein korrektes Permission-Management können Sie den Zugriff auf genau die Gerätefunktionen beschränken, die Ihre App wirklich benötigt. Die API von Capacitor bietet einen einheitlichen Ansatz zur Verwaltung von Berechtigungen auf iOS und Android.

Schritte zur Berechtigungsanfrage

Stellen Sie sicher, dass die angeforderten Berechtigungen mit den Zielen Ihrer Datenerhebung übereinstimmen. Hier ist ein Beispiel für die Implementierung von Permission-Requests in einer Capacitor App:

import { Permissions } from '@capacitor/core';

const permissionHandler = async (permissionType: string) => {
  const status = await Permissions.query({ name: permissionType });

  if (status.state === 'granted') {
    return true;
  }

  const shouldProceed = await showExplanationDialog(
    `We need ${permissionType} access to provide core functionality`
  );

  if (shouldProceed) {
    const result = await Permissions.request({ name: permissionType });
    return result.state === 'granted';
  }

  return false;
};

Umgang mit abgelehnten Berechtigungen

Wenn ein Nutzer eine Berechtigung ablehnt, bieten Sie klare Alternativen und Hilfestellungen an. Hier ist ein Beispiel:

const handleDeniedPermission = async (permissionType: string) => {
  const status = await Permissions.query({ name: permissionType });

  if (status.state === 'denied') {
    const alternatives = {
      camera: 'manual photo upload',
      location: 'manual address entry',
      notifications: 'in-app message center'
    };

    showAlternativeFeature(alternatives[permissionType]);

    if (status.canOpenSettings) {
      offerSettingsRedirect();
    }
  }
};

Timing von Berechtigungsanfragen

Der Zeitpunkt der Anfrage ist entscheidend. Ein strategisches Timing kann die Akzeptanzrate der Nutzer deutlich erhöhen. Hier ist eine Übersicht der Timing-Strategien:

So können Sie beispielsweise den Kamerazugriff erst anfordern, wenn der Nutzer eine Aktion wie das Aufnehmen eines Fotos startet:

const captureImage = async () => {
  const userStartedCapture = true;

  if (userStartedCapture) {
    const granted = await permissionHandler('camera');

    if (granted) {
      await startCamera();
    } else {
      showUploadOption();
    }
  }
};

Kontextbezogene Anfragen wie diese können die Akzeptanzraten im Vergleich zu sofortigen Anfragen um 50 % steigern [2]. Um eine reibungslose User Experience zu gewährleisten, nutzen Sie einen Permission-State-Tracker, der Nutzerentscheidungen über Sessions hinweg speichert.

Sobald die Berechtigungen geklärt sind, können Sie sich auf die Absicherung von Updates konzentrieren, insbesondere bei Over-the-Air (OTA) Deployments.

OTA Update Sicherheit

Um die Datenintegrität während App-Updates, ist es entscheidend, sichere OTA (Over-The-Air) Update-Prozesse zu nutzen. Diese Updates verhindern unbefugte Änderungen am App-code, die sonst die Limits der Datenerfassung umgehen könnten.

Signierung von Update-Paketen

Das Signieren von Update-Paketen ist ein kritischer Schritt, um sich vor unbefugten code zu schützen. Hier sind wichtige Maßnahmen für sichere OTA-Updates:

Capgo Update-System

Capgo vereinfacht sichere OTA-Updates für Capacitor Apps durch automatisierte Sicherheitsfunktionen. So nutzt du das Update-System von Capgo in deiner App:

import { CapacitorUpdater } from '@capgo/capacitor-updater';

const secureUpdate = async () => {
  try {
    const update = await CapacitorUpdater.download({
      version: 'latest',
      validateSignature: true
    });
    if (update.status === 'success') {
      await CapacitorUpdater.set(update);
    }
  } catch (error) {
    await CapacitorUpdater.rollback();
  }
};

Dieser Ansatz stellt sicher, dass Updates validiert und sicher sind, inklusive Rollback-Optionen im Fehlerfall.

Einhaltung der Store-Richtlinien

Die Einhaltung der App Store Guidelines ist für OTA-Updates zwingend erforderlich[1][6][7]. Jede Plattform hat spezifische Anforderungen, um sicherzustellen, dass Updates mit deren Datenrichtlinien und Sicherheitsstandards übereinstimmen:

Hier ist ein Beispiel für Store-konforme Updates:

const compliantUpdate = async () => {
  const userConsent = await requestUpdateConsent();
  if (userConsent) {
    await CapacitorUpdater.setUpdateConfig({
      type: 'assets-only',
      scope: 'ui-updates' // Updates limited to UI components
    });
  }
};

const preventDowngrade = async (newVersion, currentVersion) => {
  const versions = await CapacitorUpdater.getVersions();
  if (versions.current.buildNumber > newVersion.buildNumber) {
    throw new Error('Downgrade attempt detected');
  }
};

Zusammenfassung

Wichtigste Erkenntnisse

Ein effektiver Umgang mit Nutzerdaten erfordert diese Strategien:

• Erhebe nur die notwendigen Daten.
• Nutze plattformnative Verschlüsselung zum Schutz.
• Automatisiere Löschfristen für Daten.
• Richte detaillierte Berechtigungen ein.

Diese Schritte greifen ineinander, um die Compliance von der Datenerhebung bis zur automatischen Löschung zu gewährleisten.

Implementierungsschritte

So setzt du diese Strategien um:

• Prüfe deine Datenflüsse nach den Methoden aus Abschnitt 2.
• Stärke die Speicher-Sicherheit wie in Abschnitt 3 beschrieben.
• Richte automatisierte Löschprozesse gemäß Abschnitt 4 ein.
• Implementiere die Berechtigungen aus Abschnitt 5.

Nutzung von Capgo

Teams, die OTA-Updates verwalten, nutzen Capgo für integrierte Security-Tools, die diese Prozesse unterstützen:

• Ende-zu-Ende-Verschlüsselung um Update-Pakete abzusichern.
• Echtzeit-Monitoring um potenzielle Sicherheitsrisiken schnell zu beheben.

Weiterlesen: So verwaltest du Nutzerdaten in Capacitor Apps

Wenn Sie ... verwenden Umgang mit Nutzerdaten in Capacitor Apps nutzen, um Security und Compliance zu planen, verbinden Sie es mit Verschlüsselung für die Implementierungsdetails bei der Verschlüsselung, Compliance für die Implementierungsdetails in Compliance, Capgo Security Scanner für den Produkt-Workflow im Capgo Security Scanner, Capgo Sicherheit für den Produkt-Workflow in Capgo Security und Capgo Trust Center für den Produkt-Workflow im Capgo Trust Center.