
# Unveränderliche Versionierung synthetischer Daten und prüfbare Herkunft mit blockchain‑gestützten Datenverträgen

Synthetische Daten sind zu einem Grundpfeiler moderner KI‑Entwicklung geworden, da sie datenschutzfreundliches Modell‑Training, schnelles Prototyping und Bias‑Minderung ermöglichen. Doch während synthetische Daten‑Pipelines an Komplexität gewinnen – über mehrere Teams, Cloud‑Regionen und Edge‑Geräte hinweg – kämpfen Organisationen damit, zwei grundlegende Fragen zu beantworten:

1. **Welche Version eines synthetischen Datensatzes wurde zum Training eines bestimmten Modells verwendet?**  
2. **Können wir nachweisen, dass der Daten‑Generierungsprozess regulatorischen und ethischen Richtlinien entsprach?**

Traditionelle Daten‑Katalog‑Lösungen basieren auf veränderbaren Metadaten‑Stores, die anfällig für versehentliche Überschreibungen, Insider‑Manipulationen und fragmentierte Prüfpfade sind. In diesem Artikel stellen wir eine **blockchain‑gestützte Datenvertrags‑Architektur** vor, die **unveränderliche Versionierung**, **kryptografisch verifizierbare Herkunft** und **automatisierte Compliance‑Berichterstattung** für synthetische Daten liefert. Der Ansatz beruht auf drei Säulen:

* **Unveränderliches Ledger** – Eine permissioned Blockchain protokolliert jede Daten‑Vertrags‑Transaktion und garantiert Manipulationsnachweis.  
* **Smart‑Contract‑gesteuerte Datenverträge** – Selbstausführende Verträge kodieren Generierungsparameter, Einwilligungsnachweise und Richtlinien‑Constraints.  
* **Automatisierte Herkunftsextraktion** – Ereignisgesteuerte Agenten übersetzen den Vertragszustand in einen einheitlichen Herkunfts‑Graphen, der von MLOps‑Tools abgefragt werden kann.

Am Ende dieses Leitfadens verstehen Sie den End‑to‑End‑Flow, sehen eine konkrete Implementierung mit Hyperledger Fabric und Formize und lernen, wie Sie die Lösung in CI/CD‑Pipelines für kontinuierliche Compliance integrieren.

---

## 1. Warum unveränderliche Versionierung für synthetische Daten wichtig ist

Synthetische Daten‑Pipelines umfassen typischerweise die folgenden Phasen:

1. **Quell‑Daten‑Ingestion** – Real‑World‑Daten werden unter Einwilligungs‑ und Datenschutz‑Richtlinien gesammelt.  
2. **Privacy‑Transformation** – Differential‑Privacy, GANs oder Diffusions‑Modelle erzeugen synthetische Datensätze.  
3. **Qualitätssicherung** – Statistische Tests, Bias‑Erkennung und Nutzen‑Scoring validieren das Ergebnis.  
4. **Distribution** – Datensätze werden in Data‑Lakes gespeichert, über APIs geteilt oder direkt an Trainings‑Jobs übergeben.

Jede Phase kann mehrere **Iterationen** erzeugen (z. B. Hyper‑Parameter‑Sweeps, Modell‑Updates). Ohne unveränderliche Versionierung:

* **Modell‑Reproduzierbarkeit leidet** – Teams können ein Modell, das auf „Datensatz v3.2“ trainiert wurde, nicht zuverlässig reproduzieren.  
* **Regulatorisches Risiko steigt** – Prüfer können nicht verifizieren, dass ein Datensatz zum Zeitpunkt der Nutzung GDPR‑ oder HIPAA‑Konform war.  
* **Lücken in der Daten‑Provenienz** – Wenn ein Bias‑Problem auftaucht, ist das Zurückverfolgen zu den genauen Generierungsparametern zeitaufwendig.

Ein unveränderliches Ledger löst diese Probleme, indem es eine **einzige Quelle der Wahrheit** bereitstellt, die nachträglich nicht geändert werden kann.

---

## 2. Überblick über die Kern‑Architektur

Unten steht ein hoch‑level Diagramm der vorgeschlagenen Architektur. Das Diagramm ist in Mermaid‑Syntax geschrieben, die Hugo automatisch rendern kann.

```mermaid
graph LR
    subgraph Edge
        A["Real‑World‑Daten‑Quelle"]
        B["Einwilligungs‑Management (Formize)"]
    end
    subgraph Core
        C["Synthetic‑Data‑Engine"]
        D["Daten‑Vertrag Smart‑Contract"]
        E["Permissioned Blockchain"]
        F["Lineage‑Service"]
        G["CI/CD‑Pipeline"]
        H["Modell‑Register"]
    end
    subgraph Consumers
        I["Training‑Job"]
        J["Audit‑Dashboard"]
    end

    A --> B
    B --> C
    C --> D
    D --> E
    E --> F
    F --> G
    G --> H
    H --> I
    F --> J
```

**Wichtige Interaktionen**

* **Einwilligungs‑Management (Formize)** sammelt die Nutzer‑Einwilligung und gibt einen signierten Nachweis aus, der on‑chain gespeichert wird.  
* **Synthetic‑Data‑Engine** (z. B. ein GAN oder Diffusions‑Modell) liest den Nachweis, generiert Daten und ruft den **Daten‑Vertrag** mit den Generierungsparametern auf.  
* Der **Daten‑Vertrag** schreibt eine Transaktion in die **Permissioned Blockchain** und erstellt damit einen unveränderlichen Eintrag, der enthält:  
  * Datensatz‑Hash  
  * Versions‑ID des Generierungs‑Algorithmus  
  * Hyper‑Parameter  
  * Referenz zum Einwilligungs‑Nachweis  
  * Compliance‑Flags  
* Der **Lineage‑Service** abonniert Blockchain‑Events, baut einen gerichteten azyklischen Graphen (DAG) der Datensatz‑Versionen und stellt eine GraphQL‑API bereit.  
* **CI/CD‑Pipeline** holt den neuesten Datensatz‑Hash aus dem Ledger, bevor ein Training‑Job gestartet wird, und garantiert so Reproduzierbarkeit.  
* **Audit‑Dashboard** visualisiert den Herkunfts‑Graphen und liefert exportierbare Compliance‑Berichte.

---

## 3. Datenverträge als Smart Contracts

Ein **Daten‑Vertrag** ist ein leichter Smart Contract, der den gesamten Kontext der synthetischen Daten‑Generierung kapselt. Nachfolgend ein vereinfachter Solidity‑ähnlicher Pseudo‑Code, der für Hyperledger Fabric Chaincode kompiliert werden könnte.

```solidity
contract SyntheticDataContract {
    struct GenerationRecord {
        string datasetHash;          // SHA‑256 des generierten Datensatzes
        string algorithmId;          // z. B. "GAN_v2.1"
        string hyperParams;         // JSON‑String der Hyper‑Parameter
        string consentTxId;          // Blockchain‑Tx‑ID des Einwilligungs‑Nachweises
        uint256 timestamp;           // Unix‑Epoch
        bytes32 policyDigest;        // Hash der angewandten Compliance‑Richtlinie
    }

    mapping(string => GenerationRecord) public records; // Schlüssel = datasetHash

    event DataGenerated(string indexed datasetHash, address indexed generator);

    function registerGeneration(
        string memory _datasetHash,
        string memory _algorithmId,
        string memory _hyperParams,
        string memory _consentTxId,
        bytes32 _policyDigest
    ) public {
        require(bytes(_datasetHash).length > 0, "Invalid hash");
        GenerationRecord memory rec = GenerationRecord({
            datasetHash: _datasetHash,
            algorithmId: _algorithmId,
            hyperParams: _hyperParams,
            consentTxId: _consentTxId,
            timestamp: block.timestamp,
            policyDigest: _policyDigest
        });
        records[_datasetHash] = rec;
        emit DataGenerated(_datasetHash, msg.sender);
    }

    function getRecord(string memory _datasetHash) public view returns (GenerationRecord memory) {
        return records[_datasetHash];
    }
}
```

**Warum dieses Design funktioniert**

* **Manipulationsnachweis** – Sobald `registerGeneration` aufgerufen wird, ist der Eintrag auf dem Ledger unveränderlich.  
* **Selbstbeschreibend** – Alle relevanten Metadaten werden in einer einzigen Transaktion gespeichert, wodurch externe Metadaten‑Stores überflüssig werden.  
* **Richtlinien‑Verknüpfung** – Der `policyDigest` bindet den Datensatz an eine bestimmte Version der Compliance‑Richtlinie und ermöglicht automatisierte Erkennung von Richtlinien‑Drift.

---

## 4. Integration von Formize für Einwilligungs‑ und Richtlinien‑Management

Formize glänzt bei **dynamischer Einwilligungs‑Erfassung** und **Richtlinien‑Versionierung**. Der Integrations‑Flow sieht so aus:

1. **Einwilligungs‑Erfassung** – Ein Nutzer füllt ein Formize‑Web‑Formular aus; die Plattform signiert den Nachweis mit einer dezentralen Kennung (DID) und schreibt den Nachweis in die Blockchain.  
2. **Richtlinien‑Abruf** – Vor der Daten‑Generierung fragt die Synthetic‑Engine Formize nach der aktiven Datenschutz‑Richtlinie (z. B. GDPR‑Artikel‑6‑1‑a) und erhält deren Hash.  
3. **Vertrags‑Aufruf** – Die Engine übergibt die Einwilligungs‑Transaktions‑ID und den Richtlinien‑Hash an den Daten‑Vertrag.

Diese enge Kopplung stellt sicher, dass jeder synthetische Datensatz **kryptografisch** mit der genauen Einwilligung und Richtlinie verknüpft ist, die seiner Erstellung zugrunde lagen.

---

## 5. Automatisierter Lineage‑Extraction‑Service

Der **Lineage‑Service** ist ein Microservice in Go (oder Rust), der über das Fabric‑SDK Blockchain‑Events abonniert. Seine Aufgaben:

* **Event‑Listener** – Bei `DataGenerated`‑Events den vollständigen `GenerationRecord` abrufen.  
* **Graph‑Konstruktion** – Einen Knoten in einer Neo4j‑ oder JanusGraph‑Datenbank einfügen und ihn über eine `DERIVED_FROM`‑Kante mit dem Vorgängerdatensatz verbinden.  
* **Version‑Tagging** – Semantische Versionsnummern (`v1.0.0`, `v1.1.0`) basierend auf Änderungen im Algorithmus oder den Hyper‑Parametern zuweisen.  
* **API‑Bereitstellung** – Einen GraphQL‑Endpoint für nachgelagerte Werkzeuge (CI/CD, Audit‑UI) bereitstellen.

Beispiel‑Abfrage, um die komplette Herkunft eines Datensatzes zu erhalten:

```graphql
query Lineage($hash: String!) {
  dataset(hash: $hash) {
    hash
    algorithmId
    generatedAt
    parent {
      hash
      algorithmId
    }
    children {
      hash
      algorithmId
    }
  }
}
```

---

## 6. CI/CD‑Integration für reproduzierbares Modell‑Training

Die Einbindung unveränderlicher Versionierung in CI/CD garantiert, dass **jeder Modell‑Build reproduzierbar** ist. Nachfolgend ein typischer GitHub‑Actions‑Workflow‑Ausschnitt:

```yaml
name: Train Model
on:
  push:
    branches: [ main ]

jobs:
  train:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v3

      - name: Resolve dataset version
        id: dataset
        run: |
          HASH=$(curl -s https://lineage.api.company.com/dataset/latest | jq -r .hash)
          echo "DATASET_HASH=$HASH" >> $GITHUB_ENV

      - name: Pull dataset from storage
        run: |
          aws s3 cp s3://synthetic-data/${{ env.DATASET_HASH }} ./data.csv

      - name: Train model
        run: |
          python train.py --data data.csv --output model.pkl

      - name: Register model artifact
        run: |
          curl -X POST -H "Content-Type: application/json" \
            -d '{"modelHash":"'"$(sha256sum model.pkl | cut -d' ' -f1)"'","datasetHash":"${{ env.DATASET_HASH }}"}' \
            https://model-registry.api.company.com/register
```

Wesentliche Punkte:

* Der Workflow **fragt den Lineage‑Service** nach dem neuesten Datensatz‑Hash ab, sodass die exakt verwendete Version festgehalten wird.  
* Nach dem Training wird das Modell‑Artefakt zusammen mit dem Datensatz‑Hash registriert, wodurch eine **bidirektionale Verknüpfung** zwischen Modell und Daten entsteht.

---

## 7. Prüfbare Compliance‑Berichterstattung

Regulierungsbehörden verlangen zunehmend **Echtzeit‑Nachweise**, dass Pipelines synthetischer Daten Datenschutz‑ und Fairness‑Constraints einhalten. Mit der blockchain‑gestützten Architektur wird das Erzeugen eines Compliance‑Reports zu einer reinen Abfrage des Ledgers.

Beispiel‑Python‑Skript, das einen PDF‑Audit‑Report erzeugt:

```python
import json
from web3 import Web3
from reportlab.lib.pagesizes import letter
from reportlab.pdfgen import canvas

w3 = Web3(Web3.HTTPProvider("https://fabric-node.company.com"))
contract = w3.eth.contract(address="0xABC123...", abi=contract_abi)

def fetch_record(dataset_hash):
    return contract.functions.getRecord(dataset_hash).call()

def generate_report(dataset_hash, filename):
    rec = fetch_record(dataset_hash)
    c = canvas.Canvas(filename, pagesize=letter)
    c.drawString(72, 720, f"Dataset Hash: {rec[0]}")
    c.drawString(72, 700, f"Algorithm ID: {rec[1]}")
    c.drawString(72, 680, f"Hyper‑Parameters: {rec[2]}")
    c.drawString(72, 660, f"Consent Tx ID: {rec[3]}")
    c.drawString(72, 640, f"Policy Digest: {rec[5].hex()}")
    c.save()

generate_report("0xdeadbeef...", "audit_report.pdf")
```

Das erzeugte PDF enthält **kryptografische Referenzen**, die Prüfer gegen das öffentliche Ledger verifizieren können, wodurch der Aufwand für Compliance‑Checks drastisch reduziert wird.

---

## 8. Sicherheits‑ und Leistungs‑Überlegungen

| Aspekt               | Empfehlung                                                                 |
|----------------------|-----------------------------------------------------------------------------|
| **Berechtigungen**   | Verwenden Sie eine **permissioned Blockchain** (Hyperledger Fabric oder Corda), um Schreibrechte auf vertrauenswürdige Services zu beschränken. |
| **Datenschutz**      | Speichern Sie nur **Hashes** und Metadaten on‑chain; die eigentlichen synthetischen Datensätze bleiben in verschlüsseltem Object‑Storage. |
| **Skalierbarkeit**   | Bündeln Sie mehrere `registerGeneration`‑Aufrufe in einem Block, um Transaktions‑Overhead zu reduzieren. |
| **Schlüssel‑Management** | Nutzen Sie Hardware‑Security‑Modules (HSM) für das Signieren von Einwilligungs‑Nachweisen und Vertrags‑Aufrufen. |
| **Disaster Recovery** | Replizieren Sie das Ledger über mehrere Rechenzentren und aktivieren Sie Snapshots der Graph‑Datenbank. |

---

## 9. Praxisbeispiel: Gesundheits‑Forschungs‑Konsortium

Ein konsortiumübergreifendes Gesundheits‑Konsortium musste synthetische Patientendaten teilen und gleichzeitig HIPAA‑ und GDPR‑Konformität gewährleisten. Durch die Einführung des blockchain‑gestützten Datenvertrags‑Modells:

* **Versions‑Nachverfolgbarkeit** ermöglichte Forschern, ein veröffentlichtes Modell exakt drei Jahre später zu reproduzieren.  
* **Einwilligungs‑Verknüpfung** stellte sicher, dass jeder Patient, der seine Einwilligung widerrief, automatisch ein Revocation‑Event auslöste, das vom Lineage‑Service an nachgelagerte Datensätze propagiert wurde.  
* **Regulatorisches Audit** wurde in einem Tag abgeschlossen statt in Wochen, weil der Prüfer das unveränderliche Ledger herunterladen und jeden Datensatz‑Version prüfen konnte.

Das Konsortium meldete eine **Reduktion des Compliance‑Aufwands um 40 %** und eine **Beschleunigung der Modell‑Entwicklungszyklen um 30 %**.

---

## 10. Schnellstart – ein Minimal‑Prototyp

1. **Lokales Fabric‑Netzwerk** mit den offiziellen Docker‑Samples aufsetzen.  
2. **`SyntheticDataContract`‑Chaincode** (siehe Abschnitt 3) deployen.  
3. **Formize** installieren und ein Einwilligungs‑Formular konfigurieren, das Nachweise in denselben Fabric‑Channel schreibt.  
4. **Ein einfacher Lineage‑Service** in Go implementieren, der `DataGenerated`‑Events abonniert und Knoten in einer In‑Memory‑Map speichert.  
5. **Einen synthetischen Daten‑Generator** (z. B. ein vortrainiertes CTGAN) ausführen, der nach jedem Lauf `registerGeneration` aufruft.  
6. **Ledger abfragen**, um zu verifizieren, dass jede Datensatz‑Version unveränderlich ist.

Dieses Sandbox‑Setup liefert einen Proof‑of‑Concept, der durch Hinzufügen einer persistenten Graph‑Datenbank, rollenbasierter Zugriffskontrolle und Integration in bestehende MLOps‑Plattformen wie Kubeflow oder MLflow zu einer Produktions‑Lösung ausgebaut werden kann.

---

## 11. Ausblick

* **Zero‑Knowledge‑Proofs** – zk‑SNARKs in den Datenvertrag einbetten, um zu beweisen, dass ein Datensatz ein festgelegtes Privacy‑Budget einhält, ohne die Daten selbst preiszugeben.  
* **Cross‑Chain‑Interoperabilität** – Cosmos‑IBC oder Polkadot‑Bridges nutzen, um Herkunftsinformationen über Organisations‑Grenzen hinweg zu teilen und gleichzeitig Souveränität zu wahren.  
* **KI‑gestützte Richtlinien‑Entwicklung** – LLMs einsetzen, um basierend auf erkannten Drift‑Metriken automatisch Richtlinien‑Updates vorzuschlagen.  

Durch die kontinuierliche Erweiterung des unveränderlichen Datenvertrags‑Frameworks können Organisationen neuen Regulierungen einen Schritt voraus sein und das Vertrauen in KI‑Systeme, die auf synthetischen Daten basieren, stärken.

---

## Siehe auch

- [Hyperledger Fabric Documentation](https://hyperledger-fabric.readthedocs.io) – Offizielles Handbuch zum Aufbau permissioned Blockchains.  
- [Formize Consent Management Platform](https://formize.com/consent) – Wie Formize dezentrale Identitäten und dynamische Einwilligungen handhabt.  
- [Zero‑Knowledge Proofs for Privacy‑Preserving AI](https://zokrates.github.io) – Einführung in zk‑SNARKs und deren Anwendung bei synthetischen Daten.