Umgang mit Nutzerdaten in Capacitor Apps

Der Umgang mit Nutzerdaten in Capacitor Apps erfordert sichere Speicherung, klare Aufbewahrungsrichtlinien und die Einhaltung von Datenschutzgesetzen wie DSGVO und CCPA. Dieser Guide zeigt dir, wie du die Datenerfassung minimierst, sensible Infos sicherst und Berechtigungen effektiv verwaltest. Hier ein kurzer Überblick:

• Datenminimierung: Erhebe nur das, was für spezifische App-Features nötig ist.
• Sichere Speicherung: Nutze Tools wie das @capacitor/secure-storage Plugin für die Verschlüsselung.
• Datenaufbewahrung: Automatisiere das Löschen nach festgelegten Zeitlimits.
• Nutzerrechte: Benutzern den Zugriff, die Löschung oder den Export ihrer Daten ermöglichen.
• Berechtigungsverwaltung: Berechtigungen kontextbezogen anfordern und Alternativen für abgelehnte Anfragen bereitstellen.
• OTA-Updates: Sichere Over-the-Air-Updates mit Tools wie Capgo.

Ionic verwenden Capacitor Sichere Speicherung

Datenerfassung reduzieren

Ein strukturierter Ansatz zur Überprüfung, Planung und Verwaltung der Datenerhebung ist der Schlüssel zur Einhaltung der Datenschutzvorschriften. Mit den integrierten Tools von Capacitor zur Minimierung der Datenerhebung können Sie praktische Schritte unternehmen, um die Datenpraktiken Ihrer App zu verbessern.

Überprüfung der Datenerhebung

Beginnen Sie damit, den Datenfluss durch Ihre App zu kartieren. Verwenden Sie Tools wie Data-Lineage-Visualizer, um Bereiche zu identifizieren, in denen unnötige Daten erhoben werden könnten. Software für Privacy Impact Assessments (PIA) kann Sie dabei leiten, zu bewerten, ob jedes Datenelement wirklich benötigt wird. Hier ist eine Übersicht der Bereiche, auf die Sie sich konzentrieren sollten:

Ziele der Datenerhebung

Seien Sie klar darüber, warum Sie jeden Datenpunkt erheben. 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 Ihre App eine Wetterfunktion hat, genügt möglicherweise eine Postleitzahl code statt einer vollständigen Adresse. So stellen Sie sicher, dass Sie nur die für die Kernfunktionen der App notwendigen Informationen sammeln.[1][5].

Steuerung der Dateneingabe

Verwenden Sie Validierungstools, um die Menge der über Formulare und API-Aufrufe gesammelten Daten zu begrenzen. Kombinieren Sie Client-seitige Validierung mit Server-seitiger Verifizierung, um diese Grenzen wirksam durchzusetzen.

Integrieren Sie die Sicherheitsfunktionen von Capacitor, um diese Kontrollen zu verstärken:

• Verwenden Sie nach Möglichkeit Dropdown-Menüs anstelle von Freitextfeldern.
• Legen Sie Zeichengrenzen für Texteingabefelder fest.

Planen Sie quartalsweise Audits mit automatisierten Discovery-Tools, um sicherzustellen, dass Ihre Datenerfassungspraktiken effizient bleiben und zur beabsichtigten Funktionalität Ihrer App passen.

Datensicherheit und -speicherung

Sobald Sie die Grenzen Ihrer Datenerfassung definiert haben, ist es entscheidend, Maßnahmen zum Schutz der Nutzerdaten umzusetzen und dabei die Prinzipien der Datenminimierung einzuhalten.

Einrichtung einer sicheren Speicherung

Der @capacitor/secure-storage Das Plugin nutzt integrierte Sicherheitsfunktionen wie iOS Keychain und 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 Kontozustand über Neuinstallationen hinweg erhalten. @capgo/capacitor-privacy-screen verdeckt vertrauliche UI-Inhalte im App Switcher und in der Vorschau zuletzt verwendeter 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

Clientseitige Verschlüsselung bietet eine zusätzliche Schutzschicht. Bibliotheken wie CryptoJS können bei der Verschlüsselung sensibler Daten helfen:

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

Ein regelmäßiger Wechsel der Verschlüsselungsschlüssel erhöht die Sicherheit. So bleibt der Rest der Daten geschützt, selbst wenn ein Schlüssel kompromittiert wird. [2].

Vergleich der Speicheroptionen

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

Der Secure Storage API ist eine solide Wahl, um kritische Informationen wie Authentifizierungs-Tokens und persönliche Nutzerdaten zu speichern [1][4]. Sein Verschlüsselungsfunktionen sollten auch mit Aufbewahrungsrichtlinien übereinstimmen und einen kontrollierten Zugriff auf Daten innerhalb definierter Zeiträume ermöglichen [2].

sbb-itb-f9944d2

Zeiträume für die Datenspeicherung

Klare Richtlinien zur Datenaufbewahrung helfen, die Prinzipien der Datenminimierung einzuhalten und sicherzustellen, dass Informationen nicht länger aufbewahrt werden, als nötig.

Regeln für die Speicherdauer

Verschiedene Arten von Nutzerdaten sollten definierte Aufbewahrungszeiträume haben, die auf ihrem Zweck und ihrem Sensibilitätsgrad basieren. Nachfolgend ist ein Vorschlag für die Verwaltung der Datenaufbewahrung in Capacitor Apps:

Hier ist ein Beispiel, wie man Daten programmatisch mit Ablaufdatum 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, die Compliance zu gewährleisten und manuellen Aufwand zu reduzieren. Die Background-Fetch-Funktion von Capacitor ist dafür ein nützliches Werkzeug:

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 kannst du 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 zur Löschung von Nutzerdaten

Es ist essenziell, Nutzern Tools zur Verwaltung ihrer Daten bereitzustellen. Hier sind zwei wichtige Funktionen, die du implementieren kannst:

• Bestimmte 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 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]Dies ist besonders relevant für Capacitor App-Entwickler und sollte Ihre Strategie zur Datenspeicherung leiten.

App-Berechtigungen verwalten

Sorgfältiges Verwalten von App-Berechtigungen ist entscheidend, um Nutzerdaten zu schützen und sicherzustellen, dass Ihre App wie vorgesehen funktioniert. Durch die richtige Verwaltung der Berechtigungen können Sie den Zugriff auf Gerätefunktionen auf das Nötigste beschränken. Capacitor’s Permissions API bietet einen einheitlichen Ansatz zum Verwalten von Berechtigungen auf iOS und Android.

Schritte zur Berechtigungsanfrage

Stellen Sie sicher, dass die angeforderten Berechtigungen mit den Zielen Ihrer Datenerhebung übereinstimmen. Hier ist eine Beispielimplementierung für die Behandlung von Berechtigungsanfragen 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;
};

Verwalten abgelehnter Berechtigungen

Wenn ein Nutzer eine Berechtigungsanfrage ablehnt, bieten Sie klare Alternativen und Anleitungen 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();
    }
  }
};

Zeitpunkt der Berechtigungsanfragen

Wann Sie um Berechtigungen bitten, ist entscheidend. Ein strategisch guter Zeitpunkt kann die Akzeptanzrate der Nutzer deutlich steigern. Hier eine kurze Übersicht der Timing-Strategien:

Zum Beispiel kannst du die Kameraberechtigung nur anfordern, wenn der Nutzer eine Aktion wie das Aufnehmen eines Fotos auslöst:

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 vorab gestellten Anfragen um 50 % steigern [2]. Um ein reibungsloses Erlebnis zu gewährleisten, pflege einen Berechtigungsstatus-Tracker, der die Entscheidungen des Nutzers über Sitzungen hinweg speichert.

Sobald die Berechtigungen geregelt sind, kann der Fokus auf der Absicherung von Updates liegen, insbesondere bei Over-the-Air- (OTA-)Deployments.

Sicherheit von OTA-Updates

Um die Datenintegrität während App-Updateszu gewährleisten, ist es entscheidend, sichere OTA- (Over-The-Air-)Update-Prozesse zu verwenden. Diese Updates helfen, unbefugte Änderungen an der App-code zu verhindern, die sonst Beschränkungen zur Datenerfassung umgehen könnten.

Signierung von Update-Paketen

Das Signieren von Update-Paketen ist ein entscheidender Schritt zum Schutz vor unbefugten code-Änderungen. Hier sind einige wichtige Maßnahmen zur Absicherung von OTA-Updates:

Capgo Update-System

Capgo vereinfacht sichere OTA-Updates für Capacitor-Apps durch automatisierte Sicherheitsfunktionen. Hier ist ein Beispiel, wie Sie das Update-System von Capgo in Ihrer App verwenden:

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 abgesichert sind, mit Rollback-Optionen im Fehlerfall.

Einhaltung der Store-Richtlinien

Die Einhaltung der App-Store-Richtlinien ist für OTA-Updates erforderlich[1][6][7]. Jede Plattform hat spezifische Anforderungen, um sicherzustellen, dass Updates mit ihren Richtlinien zur Datenspeicherung und Sicherheit übereinstimmen:

Nachfolgend ein Beispiel für die Implementierung storekonformer 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

Die effektive Verarbeitung von Nutzerdaten erfordert die Kombination dieser Kernstrategien:

• Nur die erforderlichen Daten erfassen.
• Plattformnative Verschlüsselung zum Schutz der Daten nutzen.
• Fristen für die Datenhaltung automatisieren.
• Detaillierte Berechtigungssteuerung einrichten.

Diese Schritte greifen ineinander, um die Compliance sicherzustellen – von der Datenerfassung bis zur automatischen Löschung.

Umsetzungsschritte

So setzen Sie diese Strategien um:

• Prüfen Sie Ihre Datenflüsse mit den in Abschnitt 2 besprochenen Methoden.
• Stärken Sie die Speichersicherheit wie in Abschnitt 3 beschrieben.
• Richten Sie automatisierte Löschprozesse gemäß Abschnitt 4 ein.
• Establish and enforce permission controls detailed in section 5.

Nutzung von Capgo

Für Teams, die OTA-Updates verwalten, bietet Capgo integrierte Sicherheitstools, die mit diesen Maßnahmen übereinstimmen:

• Ende-zu-Ende-Verschlüsselung zur Absicherung von Update-Paketen.
• Echtzeit-Monitoring zur schnellen Behandlung potenzieller Sicherheitsbedrohungen.

Weiter geht's: So verwalten Sie Benutzerdaten in Capacitor-Apps

Wenn du es nutzt Umgang mit Nutzerdaten in Capacitor Apps um Sicherheit und Compliance zu planen, verbinden Sie es mit Verschlüsselung für die Implementierungsdetails in Encryption, Konformität für das Implementierungsdetail 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.