Erste Schritte mit DataSafe: Dateien sicher verschlüsseln, freigeben und versionieren

Organisationen, die sensible Daten verarbeiten, stehen vor einer grundlegenden Herausforderung: Wie lassen sich Dateien sicher speichern, ohne die Such-, Freigabe- und Verwaltungsmöglichkeiten einzuschränken? Traditionelle Verschlüsselungsansätze zwingen Entwickler dazu, komplexe Schlüsselverwaltungssysteme zu entwickeln, sichere Freigabeprotokolle zu implementieren und verschlüsselte Pfadstrukturen von Grund auf neu zu gestalten.

DataSafe ist eine Open-Source-Verschlüsselungsbibliothek, die diese Probleme löst. Sie bietet transparente Dateiverschlüsselung, bei der sowohl Inhalt als auch Dateipfade verschlüsselt werden, sicheres Teilen mittels Public-Key-Kryptografie und Dokumentenversionierung für Audit-Trails – alles über eine einfache API. Die Verschlüsselung erfolgt auf Anwendungsebene, sodass Ihr Speichersystem niemals Klartextdaten erhält.

In diesem Artikel erfahren Sie, wie Sie in nur 5 Minuten eine vollständige DataSafe-Umgebung mit Docker einrichten, verschlüsselte Dateien speichern und abrufen, Dateien sicher zwischen Benutzern austauschen und genau sehen, wie verschlüsselte Daten im Speicher aussehen.

Architekturübersicht

DataSafe bietet eine vollständige Lösung für die Verwaltung verschlüsselter Daten. Die Architektur besteht aus vier Schichten, die zusammenarbeiten, um eine durchgängige Verschlüsselung zu gewährleisten.

Die oberste Clientschicht stellt einen Webbrowser mit einer Angular-Benutzeroberfläche zu Demonstrationszwecken bereit. Dieser verbindet sich mit der API-Schicht, einer Spring-Boot-REST-API mit JWT-Authentifizierung, die DataSafe-Funktionen über HTTP bereitstellt. Kern des Systems ist die DataSafe-Bibliothek selbst, die Verschlüsselungsdienste wie Benutzerprofilverwaltung, privaten Speicher und Posteingangsfunktionen für sicheres Teilen bietet. Die Speicherschicht speichert schließlich verschlüsselte Datenblöcke in S3, Minio oder einem lokalen Dateisystem.

Die REST-API und die Benutzeroberfläche dienen lediglich Demonstrationszwecken. Im Produktivbetrieb integrieren Sie die DataSafe-Bibliothek direkt in Ihre Anwendung. Die Verschlüsselung erfolgt auf Bibliotheksebene; die Speichersysteme erhalten niemals Klartextdaten.

Schnellstart

Voraussetzungen

• Docker und Docker Compose installiert

Option 1: Dateisystemspeicherung (einfachste)

Erstellen Sie eine docker-compose.ymlDatei:

1services:
2  datasafe:
3    image: adorsys/datasafe:latest
4    container_name: datasafe-demo
5    ports:
6      - "8080:8080"
7    environment:
8      - EXPOSE_API_CREDS=true
9      - DEFAULT_USER=admin
10      - DEFAULT_PASSWORD=admin
11      - USE_FILESYSTEM=file:///usr/app/ROOT_BUCKET
12      - JWT_SECRET=ThisIsAVeryLongSecretKeyForJWTTokenGenerationThatMustBeAtLeast64CharactersLong123456
13    volumes:
14      - datasafe-data:/usr/app/ROOT_BUCKET
15
16volumes:
17  datasafe-data:

Starten Sie den Dienst:

1docker compose up -d

Öffnen Sie http://localhost:8080/static/index.html in Ihrem Browser.

Option 2: Minio (S3-kompatibler) Speicher

Um verschlüsselte Daten in einer S3-ähnlichen Oberfläche zu visualisieren, verwenden Sie Folgendes docker-compose.yml:

1services:
2  minio:
3    image: minio/minio
4    container_name: minio
5    ports:
6      - "9000:9000"
7      - "9001:9001"
8    environment:
9      MINIO_ROOT_USER: accessKey
10      MINIO_ROOT_PASSWORD: secretKey
11    command: server /data --console-address ":9001"
12    volumes:
13      - minio-data:/data

createbucket: image: minio/mc depends_on: - minio entrypoint: > /bin/sh -c " sleep 5; /usr/bin/mc alias set myminio http://minio:9000 accessKey secretKey; /usr/bin/mc mb myminio/datasafe --ignore-existing; exit 0; " datasafe: image: adorsys/datasafe:latest container_name: datasafe-demo depends_on: - minio - createbucket ports: - "8080:8080" environment: - EXPOSE_API_CREDS=true - DEFAULT_USER=admin - DEFAULT_PASSWORD=admin - DATASAFE_AMAZON_URL=http://minio:9000 - AWS_ACCESS_KEY_ID=accessKey - AWS_SECRET_ACCESS_KEY=secretKey - AWS_BUCKET=datasafe - AWS_REGION=us-east-1 - DATASAFE_SYSTEM_ROOT=s3://datasafe/ - DATASAFE_S3_STORAGE=true - JWT_SECRET=ThisIsAVeryLongSecretKeyForJWTTokenGenerationThatMustBeAtLeast64CharactersLong123456 volumes: minio-data:

Starten Sie die Dienste:

1docker compose up -d

Dadurch werden drei Dienste gestartet: die DataSafe API unter , die DataSafe UI unter und die Minio Console unter (Anmeldeinformationen: accessKey/ secretKey).

API-Authentifizierung verstehen

Die DataSafe REST-API verfügt über zwei Authentifizierungsebenen. Die erste Ebene ist ein von Spring Security verwaltetes JWT-Token, das die REST-Endpunkte schützt. Die zweite Ebene besteht aus den DataSafe-Benutzerdaten (Benutzername und Passwort), die als Header übermittelt und für Verschlüsselungsvorgänge verwendet werden. Diese Trennung gewährleistet, dass selbst bei einem gültigen JWT-Token niemand ohne die zugehörigen Verschlüsselungsdaten auf verschlüsselte Daten zugreifen kann.

Schritt 1: JWT-Token abrufen

1# Authenticate with the REST API (default: admin/admin)
2curl -i -X POST 'http://localhost:8080/api/authenticate' \
3  -H 'Content-Type: application/json' \
4  -d '{"userName":"admin","password":"admin"}'

Das Token wird im tokenHeader zurückgegeben:

1token: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzUxMiJ9...

Speichern Sie dieses Token für nachfolgende Anfragen:

1TOKEN="Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzUxMiJ9..."

Nutzung von privatem Speicher

Der private Speicher verschlüsselt Dateien, sodass nur der Eigentümer darauf zugreifen kann. Sowohl der Dateiinhalt als auch der Dateipfad werden verschlüsselt.

Schritt 1: Erstellen Sie einen DataSafe-Benutzer

Nutzen Sie die Benutzeroberfläche (klicken Sie auf „Registrieren“) oder die API:

1curl -X PUT 'http://localhost:8080/user' \
2  -H "token: $TOKEN" \
3  -H 'Content-Type: application/json' \
4  -d '{"userName":"alice","password":"aliceSecret"}'

Dadurch wird für Alice ein einzigartiger Schlüsselspeicher erstellt, der Verschlüsselungsschlüssel sowohl für die Pfad- als auch für die Inhaltsverschlüsselung enthält, sowie ein privater Speicherplatz für ihre Dateien und ein Posteingang zum Empfangen von freigegebenen Dateien von anderen Benutzern.

Schritt 2: Speichern einer verschlüsselten Datei

Der Schreibendpunkt verwendet multipart/form-data:

1# Create a test file
2echo "This is highly confidential information." > secret.txt
3
4# Upload the encrypted file
5curl -X PUT 'http://localhost:8080/document/documents/secret-report.txt' \
6  -H "token: $TOKEN" \
7  -H 'user: alice' \
8  -H 'password: aliceSecret' \
9  -F 'file=@secret.txt'

Schritt 3: Private Dateien auflisten

1curl -X GET 'http://localhost:8080/documents/' \
2  -H "token: $TOKEN" \
3  -H 'user: alice' \
4  -H 'password: aliceSecret'

Antwort:

1["documents/secret-report.txt"]

Schritt 4: Lesen Sie die Datei erneut ein

1curl -X GET 'http://localhost:8080/document/documents/secret-report.txt' \
2  -H "token: $TOKEN" \
3  -H 'user: alice' \
4  -H 'password: aliceSecret' \
5  -H 'Accept: application/octet-stream'

Antwort:

1This is highly confidential information.

Was geschah hinter den Kulissen?

Als Alice ihre Datei speicherte, verschlüsselte DataSafe zunächst den Pfad documents/secret-report.txtin etwas wie aX9kL.../mN2pQ.../Zr7tY..., dann den Inhalt mit AES-256-GCM und einem eindeutigen Schlüssel und speicherte schließlich sowohl den verschlüsselten Pfad als auch den Inhalt im konfigurierten Speichersystem (Minio S3 oder Dateisystem).

Sehen Sie es in Aktion

Was Alice in der DataSafe-Benutzeroberfläche sieht:

Der Benutzer sieht vertraute, lesbare Dateinamen, genau wie bei jedem anderen Dateimanager.

Was tatsächlich in Minio (S3) gespeichert ist:

Das Speichersystem erkennt nur verschlüsselte Blobs mit Namen wie PBJs3F98q8f63jip4WHB8IdUiHE4KmiMiLA=. Selbst der Pfad users/alice/private/files/SIVgibt keinerlei Aufschluss über die tatsächliche Dateistruktur.

Das ist die Stärke von DataSafe : Selbst wenn jemand Zugriff auf Ihren Speicher erlangt, sieht er nur verschlüsselte Daten. Die Verschlüsselung erfolgt in der Anwendungsschicht; der Speicher empfängt niemals Klartext.

Sichere Freigabe nutzen (Posteingang)

Der Posteingang ermöglicht es Nutzern, Dateien sicher auszutauschen. Die Dateien werden mit dem öffentlichen Schlüssel des Empfängers verschlüsselt – nur dieser kann sie entschlüsseln.

Schritt 1: Einen weiteren Benutzer erstellen (Bob)

Registrieren Sie Bob über die Benutzeroberfläche oder über die API:

1curl -X PUT 'http://localhost:8080/user' \
2  -H "token: $TOKEN" \
3  -H 'Content-Type: application/json' \
4  -d '{"userName":"bob","password":"bobSecret"}'

Schritt 2: Alice teilt eine Datei mit Bob

1# Create a file to share
2echo "Hello Bob, this is a shared file from Alice!" > report.txt
3
4# Share it with Bob
5curl -X PUT 'http://localhost:8080/inbox/document/shared-report.txt' \
6  -H "token: $TOKEN" \
7  -H 'user: alice' \
8  -H 'password: aliceSecret' \
9  -H 'users: bob' \
10  -F 'file=@report.txt'

Wenn Alice die Datei freigibt, ruft DataSafe Bobs öffentlichen Schlüssel aus der Registry ab, verschlüsselt die Datei mit CMS-Envelope-Verschlüsselung (RFC 5652) und speichert den verschlüsselten Blob in Bobs Posteingang.

Schritt 3: Bob liest seinen Posteingang

1# List inbox
2curl -X GET 'http://localhost:8080/inbox/documents/' \
3  -H "token: $TOKEN" \
4  -H 'user: bob' \
5  -H 'password: bobSecret'

Antwort:

1["shared-report.txt"]

1# Read the shared file (decrypted by DataSafe)
2curl -X GET 'http://localhost:8080/inbox/document/shared-report.txt' \
3  -H "token: $TOKEN" \
4  -H 'user: bob' \
5  -H 'password: bobSecret' \
6  -H 'Accept: application/octet-stream'

Antwort:

1Hello Bob, this is a shared file from Alice!

Was wird in Minio gespeichert?

In Minio wird die Datei unter gespeichert, users/bob/public/inbox/shared-report.txtihr Inhalt ist jedoch verschlüsselt (468 Bytes für eine kurze Textnachricht).

Wichtig: Wenn Sie direkt von Minio herunterladen, erhalten Sie einen verschlüsselten CMS-Envelope, der nicht lesbar ist. Nur Bob kann ihn entschlüsseln, indem er die DataSafe-API mit seinen Zugangsdaten aufruft.

Mehrfache Empfängerfreigabe

DataSafe unterstützt die Freigabe an mehrere Empfänger in einem einzigen Vorgang.

1echo "Team update: Project milestone achieved!" > team-update.txt
2
3curl -X PUT 'http://localhost:8080/inbox/document/team-update.txt' \
4  -H "token: $TOKEN" \
5  -H 'user: alice' \
6  -H 'password: aliceSecret' \
7  -H 'users: bob,charlie,david' \
8  -F 'file=@team-update.txt'

Verwendung versionierter Dokumente

DataSafe unterstützt die Versionsverwaltung von Dokumenten, die für Prüfprotokolle und den Schutz vor Ransomware nützlich ist.

Mehrere Versionen speichern

1# Version 1
2echo "Contract v1: Initial terms" > contract.txt
3curl -X PUT 'http://localhost:8080/versioned/contract.txt' \
4  -H "token: $TOKEN" \
5  -H 'user: alice' \
6  -H 'password: aliceSecret' \
7  -F 'file=@contract.txt'
8
9# Version 2
10echo "Contract v2: Updated payment terms" > contract.txt
11curl -X PUT 'http://localhost:8080/versioned/contract.txt' \
12  -H "token: $TOKEN" \
13  -H 'user: alice' \
14  -H 'password: aliceSecret' \
15  -F 'file=@contract.txt'

Liste versionierter Dokumente

1curl -X GET 'http://localhost:8080/versioned/' \
2  -H "token: $TOKEN" \
3  -H 'user: alice' \
4  -H 'password: aliceSecret'

Antwort (zeigt die neueste Version mit UUID an):

1["contract.txt/ed527d70-2179-402d-b391-5f30e5270183"]

Alle Versionen einer Datei auflisten

1curl -X GET 'http://localhost:8080/versions/list/contract.txt' \
2  -H "token: $TOKEN" \
3  -H 'user: alice' \
4  -H 'password: aliceSecret'

Antwort (alle Versionen mit ihren UUIDs):

1["contract.txt/ed527d70-2179-402d-b391-5f30e5270183","contract.txt/58956c6d-cd30-42ce-b045-eaedd6350fd9"]

Lesen Sie die neueste Version

1curl -X GET 'http://localhost:8080/versioned/contract.txt' \
2  -H "token: $TOKEN" \
3  -H 'user: alice' \
4  -H 'password: aliceSecret' \
5  -H 'Accept: application/octet-stream'

Antwort:

1Contract v2: Updated payment terms

Jede Version wird separat mit verschlüsselten Zeitstempeln gespeichert, sodass Sie die Dokumentenhistorie nachverfolgen, sich von Ransomware-Angriffen erholen (da alte Versionen intakt bleiben) und die Compliance-Anforderungen für Audit-Trails erfüllen können.

So funktioniert es

Privater Speicherfluss

Beim Schreiben fordert der Benutzer das Schreiben einer Datei an (z. B. „documents/secret.txt“). DataSafe ruft den Pfadverschlüsselungsschlüssel aus dem Schlüsselspeicher des Benutzers ab und verschlüsselt den Dateipfad segmentweise mit AES-SIV. Anschließend ruft es den Dokumentverschlüsselungsschlüssel aus dem Schlüsselspeicher ab, verschlüsselt den Inhalt mit AES-256-GCM (authentifizierte Verschlüsselung) und speichert den verschlüsselten Datenblock unter dem angegebenen Pfad.

Beim Lesen fordert der Benutzer eine Datei über ihren logischen Pfad an. DataSafe verschlüsselt den Pfad, um die eigentliche Datei im Speicher zu finden, ruft den verschlüsselten Datenblock ab, entschlüsselt den Inhalt mithilfe des Dokumentschlüssels und gibt den Klartext an den Benutzer zurück.

Sicherer Freigabeprozess (Posteingang)

Wenn Alice eine Datei mit Bob teilt, ruft DataSafe Bobs öffentlichen Schlüssel aus der Registry ab, verschlüsselt die Datei mit einem CMS-Envelope (RFC 5652) unter Verwendung von Bobs öffentlichem Schlüssel und speichert die verschlüsselte Datei in Bobs Posteingang.

Wenn Bob seine E-Mails aus seinem Posteingang liest, wird der verschlüsselte CMS-Umschlag abgerufen, mit Bobs privatem Schlüssel entschlüsselt und der Klartextinhalt an Bob zurückgesendet. Nur Bob kann die Dateien in seinem Posteingang entschlüsseln, da nur er den passenden privaten Schlüssel besitzt.

Verschlüsselungsreferenz

DataSafe verwendet branchenübliche Verschlüsselungsalgorithmen:

Warum diese Auswahl?

AES-GCM bietet authentifizierte Verschlüsselung, die Manipulationen erkennt und nicht nur unbefugtes Lesen verhindert. AES-SIV wird für Pfadverschlüsselung verwendet, da es deterministisch ist – derselbe Pfad wird immer mit demselben Wert verschlüsselt, wodurch Verzeichnisauflistungen möglich sind, ohne alles entschlüsseln zu müssen. ECDH wird gegenüber RSA bevorzugt, da es kleinere Schlüssel (256 Bit vs. 2048 Bit) bei gleicher Sicherheit und besserer Leistung bietet. CMS-Umschläge sind ein Industriestandard (RFC 5652) für verschlüsselte Nachrichten und unterstützen mehrere Empfänger in einem einzigen verschlüsselten Paket.

REST-API-Referenz

Alle Endpunkte (außer /api/authenticate) erfordern den tokenHeader mit dem JWT-Token.

Aufräumen

Einen Benutzer und alle seine Daten löschen

1curl -X DELETE 'http://localhost:8080/user' \
2  -H "token: $TOKEN" \
3  -H 'user: alice' \
4  -H 'password: aliceSecret'

Dadurch werden Alices Keystore, alle privaten Dateien, alle Posteingangsdateien und ihr Benutzerprofil gelöscht.

Hinweis zur DSGVO : Durch das Löschen des Benutzers werden die Verschlüsselungsschlüssel vernichtet. Selbst wenn verschlüsselte Daten in Backups erhalten bleiben, handelt es sich kryptografisch unzugänglich um eine echte Datenlöschung.

Demo stoppen

1# Stop and remove containers
2docker compose down
3# To also remove volumes (deletes all data)
4docker compose down -v

Direkte Verwendung der Java-API

Die REST-API kapselt die DataSafe-Bibliothek zu Demonstrationszwecken. Im Produktivbetrieb würden Sie die Bibliothek direkt verwenden:

1import de.adorsys.datasafe.business.impl.service.DaggerDefaultDatasafeServices;
2import de.adorsys.datasafe.business.impl.service.DefaultDatasafeServices;
3import de.adorsys.datasafe.directory.impl.profile.config.DefaultDFSConfig;
4import de.adorsys.datasafe.encrypiton.api.types.UserIDAuth;
5import de.adorsys.datasafe.storage.impl.fs.FileSystemStorageService;
6import de.adorsys.datasafe.types.api.actions.ReadRequest;
7import de.adorsys.datasafe.types.api.actions.WriteRequest;
8import java.io.InputStream;
9import java.io.OutputStream;
10import java.nio.charset.StandardCharsets;
11import java.nio.file.Path;
12import java.nio.file.Paths;
13public class DatasafeExample {
14    public static void main(String[] args) throws Exception {
15        Path root = Paths.get("./encrypted-data");
16
17        // Initialize DataSafe with filesystem storage
18        DefaultDatasafeServices datasafe = DaggerDefaultDatasafeServices.builder()
19                .config(new DefaultDFSConfig(root.toAbsolutePath().toUri(), "secret"::toCharArray))
20                .storage(new FileSystemStorageService(root))
21                .build();
22        // Create a user
23        UserIDAuth alice = new UserIDAuth("alice", "aliceSecret"::toCharArray);
24        datasafe.userProfile().registerUsingDefaults(alice);
25
26       // Write encrypted file
27        try (OutputStream os = datasafe.privateService()
28                .write(WriteRequest.forDefaultPrivate(alice, "documents/secret.txt"))) {
29            os.write("Confidential data".getBytes(StandardCharsets.UTF_8));
30        }

// Read it back try (InputStream is = datasafe.privateService() .read(ReadRequest.forDefaultPrivate(alice, "documents/secret.txt"))) { String content = new String(is.readAllBytes()); System.out.println(content); // "Confidential data" } } }

Dateien mit einem anderen Benutzer teilen

1import de.adorsys.datasafe.types.api.actions.WriteInboxRequest;
2import de.adorsys.datasafe.encrypiton.api.types.UserID;
3import java.util.Collections;
4// Create Bob
5UserIDAuth bob = new UserIDAuth("bob", "bobSecret"::toCharArray);
6datasafe.userProfile().registerUsingDefaults(bob);
7// Alice shares a file with Bob
8try (OutputStream os = datasafe.inboxService()
9        .write(WriteInboxRequest.forDefaultPublic(
10            alice,
11            Collections.singleton(new UserID("bob")),
12            "shared-report.txt"))) {
13    os.write("Hello Bob!".getBytes(StandardCharsets.UTF_8));
14}
15// Bob reads from his inbox
16try (InputStream is = datasafe.inboxService()
17        .read(ReadRequest.forDefaultPrivate(bob, "shared-report.txt"))) {
18    String content = new String(is.readAllBytes());
19    System.out.println(content); // "Hello Bob!"
20}

Maven-Abhängigkeit

1<dependency>
2    <groupId>de.adorsys</groupId>
3    <artifactId>datasafe-business</artifactId>
4    <version>${datasafe.version}</version>
5</dependency>
6<!-- For filesystem storage -->
7<dependency>
8    <groupId>de.adorsys</groupId>
9    <artifactId>datasafe-storage-impl-fs</artifactId>
10    <version>${datasafe.version}</version>
11</dependency>

Wissenswertes

DataSafe ist Open Source und unter der AGPL v3-Lizenz mit kommerziellen Lizenzoptionen erhältlich.

Die Verschlüsselung in DataSafe ist transparent: Sie speichern und rufen Dateien wie gewohnt ab, während DataSafe die Verschlüsselung automatisch übernimmt. Dies umfasst die Pfadverschlüsselung, d. h. nicht nur der Inhalt, sondern auch Dateinamen und Pfade werden verschlüsselt. Jeder Benutzer verfügt über unabhängige Verschlüsselungsschlüssel, sodass ein Sicherheitsvorfall keine Auswirkungen auf andere hat. Sicheres Teilen wird durch CMS-Envelopes ermöglicht, die verschlüsseltes Teilen ohne Schlüsselaustausch erlauben. Beim Löschen eines Benutzers werden dessen Schlüssel vernichtet, wodurch verschlüsselte Daten kryptografisch unzugänglich werden, selbst wenn sie in Backups erhalten bleiben – eine echte Datenlöschung.

Um mehr zu erfahren und loszulegen, besuchen Sie das . Das Repository enthält vollständige kryptografische Spezifikationen in SECURITY.WHITEPAPER.md, Beispiele für verschiedene Speichersysteme (S3, Minio, Dateisystem) und Integrationsmuster in datasafe-examples/.

Hintergrundinformationen zu den Herausforderungen, mit denen sich DataSafe auseinandersetzt, finden Sie in unseren vorherigen Artikeln: „ Understanding the Problem of Data at Rest“ untersucht, warum die traditionelle Speicherverschlüsselung nicht ausreicht, und „Advanced Data Security: Challenges of Encrypted Database Indexing“ befasst sich eingehend mit den Komplexitäten der Suche und Indizierung verschlüsselter Daten.