Home
Abo
Beiträge
Digital Democracy Hub Schweiz
Beiträge
Verifier auf der swiyu Public Beta Trust ...

Verifier auf der swiyu Public Beta Trust Infrastructure

Sep 08, 2025

imagePhoto by Claudio Schwarz on Unsplash

Das ist der zweite Teil zum Thema Verifier. Den ersten Teil findest du hier.

Nach der erfolgreichen Registrierung der eigenen DID im Vertrauensregister geht es nun ans Eingemachte: die praktische Einrichtung eines Verifiers. Während der erste Teil meines Leitfadens den Onboarding-Prozess erklärt hat, zeige ich dir hier Schritt für Schritt, wie du deinen eigenen Verifier-Service installierst, konfigurierst und produktionsreif machst.

Damit kannst du erstmals selbst erleben, wie eine Anwendung digitale Nachweise aus der schweizerischen Beta-E-ID prüft und verarbeitet. Das ist nicht nur ein wichtiger technischer Meilenstein, sondern auch ein praktischer Einblick in die Zukunft des E-Collecting und der digitalen Demokratie.

Wie immer gilt: Lies zuerst die offizielle Dokumentation und halte dich an die Vorgaben des Bundes. Dieser Artikel ergänzt die offiziellen Unterlagen mit praktischen Beispielen, erprobten Konfigurationen und kleinen Workarounds, die mir beim Aufbau meines eigenen Piloten geholfen haben.

image

Bestätigung für Eintrag in Trust Registry

Schritt 1: Generic Verifier installieren

Lade den Generic Verifier vom GitHub Repository herunter:

git clone https://github.com/swiyu-admin-ch/eidch-issuer-agent-management

⚠️ Hinweis: Aktuell findet gerade die Umstellung auf eine neue Version statt. Die neue Version funktioniert bei mir noch nicht wunschgemäss, daher findest du hier das Tutorial für die “alte” Version. 
 
Deprecated — Generic issuer management service
This repository will be no longer maintained. We put together the generic issuer management service and the generic issuer signing service in a new repository swiyu-issuer.

Anschliessend musst du nur sicherstellen, dass du Docker und JAVA Version 21 installiert hast.

macOS nutzt den Pfad /Library/Java/JavaVirtualMachines für installierte JDKs. Du kannst sehen, welche Versionen installiert sind:

/usr/libexec/java_home -V

Beispielausgabe:

Matching Java Virtual Machines (2):
    22, x86_64: "Oracle JDK 22"    /Library/Java/JavaVirtualMachines/jdk-22.jdk/Contents/Home
    21, x86_64: "Oracle JDK 21"    /Library/Java/JavaVirtualMachines/jdk-21.jdk/Contents/Home

Dann kannst du temporär Java 21 aktivieren mit:

export JAVA_HOME=$(/usr/libexec/java_home -v21)

Oder dauerhaft in deiner Shell-Konfig (z. B. ~/.zshrc oder ~/.bash_profile):

export JAVA_HOME=$(/usr/libexec/java_home -v21)
export PATH=$JAVA_HOME/bin:$PATH

Danach:

source ~/.zshrc   # oder source ~/.bash_profile
java -version

Schritt 2: Konfiguration (.env & compose.yaml)

Jetzt musst du nur noch die .env Datei, sowie die Docker Compose Datei compose.yaml bearbeiten und mit den richtigen Werten ergänzen und du hast deinen Verifier. Passe die Datei .env mit deinen Zugangsdaten an (Customer Key, Secret, Tokens aus Teil 1).

In der Docker Compose Datei kannst du neben Ports und den zu verwendeten Images die Namen und Übersetzungen deines Verifiers anpassen. Du findest diese am Schluss der Datei:

image

Weiter kannst du auch noch ein Logo für deinen Verifier erstellen, welches in der swiyu Wallet angezeigt wird. Die Spezifikation findest du im Offiziellen Cookbook:

Designing the visualization for Issuer, Verifier and Credential
Learn how to define the visual layout for issuer, verifier and credentialsswiyu-admin-ch.github.io

Dabei solltest du dich an folgende Regeln halten:

  • The logo or icon dimensions must not exceed 512×512 pixels and will be displayed at 24×24 pixels at any zoom level.

  • The logo or icon must be a transparent PNG (excluding the background).

  • No alpha channels or transparency for solid elements.

  • Multi-colored logos and gradients are automatically converted to a monochrome version to foster readability and ease of use.

image

Schritt 3: Verifier starten

Jetzt kannst du mit folgendem Befehl deinen Verifier Service starten:

docker compose up -d

image

Schritt 4: NGINX einrichten

Installiere den Webserver

sudo apt update
sudo apt install nginx -y

Prüfen, ob NGINX läuft:

systemctl status nginx

Falls er nicht läuft:

sudo systemctl enable --now nginx

CORS-Whitelist einrichten

Damit nur deine autorisierten Domains zugreifen dürfen, richte eine Mapping-Datei ein:

sudo nano /etc/nginx/conf.d/cors_map.conf

Beispiel:

image

map $http_origin $cors_origin {
    default "";
    ~^https://beta\.ecollecting\.ch$ $http_origin;
}

HTTP → HTTPS Weiterleitung konfigurieren

Dein Docker-Container läuft auf localhost:80XX. Prüfe in der Docker Compose Datei, welchen Port du verwendest. Bei mir war es Port 8082. NGINX soll alle HTTPS-Anfragen an diesen Port weiterleiten. Dazu erstellen wir einen Virtual Host “Verifier”.

sudo nano /etc/nginx/sites-available/verifier

Jetzt den folgenden Inhalt einfügen:

server {
    listen 80;
    server_name verifier.ecollecting.ch;
#    return 308 https://$host$request_uri;

    # CORS-Header auch auf 80 ausliefern (wichtig für evtl. Preflights)
    add_header Access-Control-Allow-Origin $cors_origin always;
    add_header Access-Control-Allow-Methods "GET, POST, PUT, PATCH, DELETE, OPTIONS" always;
    add_header Access-Control-Allow-Headers "Authorization, Content-Type, X-Requested-With, Accept" always;
    add_header Access-Control-Max-Age 86400 always;
    add_header Vary "Origin" always;

    location / {
        # Preflight auf 80 direkt beantworten, NICHT redirecten
        if ($request_method = OPTIONS) { return 204; }
        return 308 https://$host$request_uri;
    }

}

Und aktivieren:

sudo ln -s /etc/nginx/sites-available/verifier /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload nginx

Schritt 5: HTTPS aktivieren

Damit der Verifier Service auch korrekt funktioniert und in eine Anwendung integriert werden kann, sollte HTTPS eingerichtet werden. Dafür kannst du dir die entsprechenden Pakete herunterladen:

sudo apt install certbot python3-certbot-nginx -y

und für deinen Virtual Host “Verifier” das Zertifikat installieren:

sudo certbot --nginx -d mein-verifier.ecollecting.ch

Tipp: Falls du bereits alte Zertifikate erstellt hast, lösche sie zuerst:

sudo certbot certificates
sudo certbot delete - cert-name <certificate-name>

Jetzt kannst du die HTTPS Einstellungen für den neuen Virtual Host “Verfier” anpassen.

Beispielkonfiguration für HTTPS

server {
    server_name verifier.ecollecting.ch;
    listen 443 ssl; # managed by Certbot

   ssl_certificate /etc/letsencrypt/live/verifier.ecollecting.ch/fullchain.pem; # managed by Certbot
    ssl_certificate_key /etc/letsencrypt/live/verifier.ecollecting.ch/privkey.pem; # managed by Certbot
    include /etc/letsencrypt/options-ssl-nginx.conf; # managed by Certbot
    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; # managed by Certbot

    # >>> CORS-Header für ALLE Antworten (auch 4xx/5xx) <<<
    add_header Access-Control-Allow-Origin $cors_origin always;  # oder '*' wenn du keine Credentials brauchst
    add_header Access-Control-Allow-Methods "GET, POST, PUT, PATCH, DELETE, OPTIONS" always;
    add_header Access-Control-Allow-Headers "Authorization, Content-Type, X-Requested-With, Accept" always;
    add_header Access-Control-Max-Age 86400 always;
    add_header Vary "Origin" always;

    location / {
        proxy_set_header Origin "";   # <— Workaround
        # Preflight direkt beantworten
        if ($request_method = OPTIONS) { return 204; }

        proxy_pass http://localhost:8082;   # <-- YOUR port
        proxy_http_version 1.1;

        proxy_set_header Host              $host;
        proxy_set_header X-Real-IP         $remote_addr;
        proxy_set_header X-Forwarded-For   $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto https;

        proxy_set_header Upgrade           $http_upgrade;
        proxy_set_header Connection        "upgrade";
    }
}

Hilfst du mir die Konfiguration für meinen E-Collecting Pilot zu verbessern?

https://github.com/Digital-Democracy-Hub-Schweiz/e-collecting-pilot/blob/main/nginx/verifier-management.txt

Schritt 6: Docker-Dienst für Autostart einrichten

Damit unser Service auch nach einem Reboot automatisch startet, richten wir einen Dienst ein:

 sudo nano /etc/systemd/system/docker-up.service

und fügen folgenden Inhalt hinzu:

image

und wir erstellen im /home directory die Shell Datei mit den beiden Docker Compose Befehlen:

image

und aktivieren den Dienst:

sudo systemctl enable docker-up.service

Schritt 7: Beta-E-ID Credential prüfen

Jetzt kannst du deinen Service aufrufen und mit Postman eine Verifikation der Beta-E-ID starten:

öffne die URL: http://localhost:8082/swagger-ui/index.html

image

Mit diesem Request kannst du den Vorname(n), Nachname und Geburtsdatum abfragen:

curl -X POST 'https://localhost:8082/api/v1/verifications' \
  -H 'accept: */*' \
  -H 'Content-Type: application/json' \
  -d '{
    "accepted_issuer_dids": ["did:example:issuer1"],
    "jwt_secured_authorization_request": false,
    "presentation_definition": {
      "id": "00000000-0000-0000-0000-000000000000",
      "input_descriptors": [
        {
          "id": "11111111-1111-1111-1111-111111111111",
          "format": {
            "vc+sd-jwt": {
              "sd-jwt_alg_values": ["ES256"],
              "kb-jwt_alg_values": ["ES256"]
            }
          },
          "constraints": {
            "fields": [
              { "path": ["$.vct"], "filter": { "type": "string", "const": "betaid-sdjwt" } },
              { "path": ["$.family_name"] },
              { "path": ["$.given_name"] },
              { "path": ["$.birth_date"] }
            ]
          }
        }
      ]
    }
  }'

Hast du dich gefragt, wie der ZKP funktioniert, um abzufragen ob dein Gegenüber älter als 18 Jahre ist? Dazu fügst du einfach dieses Feld in die Abfrage ein:

{ "path": ["$.age_over_18"] }, // über 18 Jahre?
{ "path": ["$.age_over_16"] }, // über 16 Jahre?
{ "path": ["$.age_over_65"] }, // über 65 Jahre?
{ "path": ["$.age_birth_year"] } // nur das Geburtsjahr

Wenn du den Curl Befehl in Postman ausführst, bekommst du in der Response die Verification URL, diese kannst du als QR-Code darstellen und mit der swiyu App scannen.

image

Alternativ kannst du die URL auch via “Deep Link” direkt auf deinem Smartphone öffnen:

swiyu-verify://?client_id=did:tdw:<DEINE_DID>:identifier-reg.trust-infra.swiyu-int.admin.ch:api:v1:did:93f3fb23-f7d3-4754-b35c-3686f69ecb64&request_uri=${encodeURIComponent(verificationUrl)}`}>

Fazit

Mit diesen Schritten hast du deinen Verifier erfolgreich aufgesetzt und über HTTPS abgesichert.

Die Kombination aus Docker, NGINX, CORS-Whitelist und Certbot sorgt dafür, dass dein Service stabil und sicher im E-Collecting-Pilot läuft.

Gefällt dir dieser Beitrag?

Kaufe Digital Democracy Hub Schweiz einen Pizza

Mehr von Digital Democracy Hub Schweiz

    Item 1 of 1
    DatenschutzNutzungsbedingungenMelden
    Starte deine „Kauf mir einen Kaffee“-Seite