1      Einführung Luca unterstützt Veranstaltungs- und Restaurantbetreiber bei der verpflichtenden Aufnahme der personenbezogenen Daten ihrer Gäste im Rahmen der Bekämpfung der Covid-19-Pandemie. Dabei legt Luca besonderen Wert auf den Schutz dieser Daten: Die Daten können weder vom Betreiber noch vom Luca-System gelesen wer- den, sondern nur von den Gesundheitsämtern, um die Kontakte von Infizierten zu identifizieren mit dem Ziel, diese zu kontaktieren. Grundidee ist, dass die personenbezogenen Daten von der Luca-App der Nutzer*innen mit einem Gesundheitsamt-Schlüssel verschlüsselt und im Rahmen des Checkins an den Betreiber geschickt werden. Der Betreiber verschlüsselt diese verschlüsselten Da- ten erneut und sendet sie, zusammen mit der Checkin-Zeit, an das Luca-System. Hier- durch kann weder der Betreiber, noch das Luca-System oder die Gesundheitsämter die personenbezogenen Daten der Nutzer*innen lesen. Wird bei einer Nutzerin eine Infektion festgestellt, sendet die Luca-App alle Checkin- Zeiten zusammen mit der ID der Betreiber an das Luca-System. Luca fordert von allen diesen Betreibern eine Entschlüsselung der Daten der Gäste an, die sich in der betreffenden Zeit ebenfalls eingecheckt haben, d.h. Luca erhält die mit dem Schlüssel des Gesundheitsmates verschlüsselten Daten der Nutzer*innen. Diese Daten werden dann von Luca an das zuständige Gesundheitsamt übermittelt, das hieraus die Daten entschlüsseln und damit die Nutzer*innen kontaktieren kann. Da die App mittels QR-Code mit dem Betreibersystem kommuniziert und hier nur beschränkt Speicherplatz zur Verfügung steht, wurde die obige Idee leicht angepasst. Die personenbezogenen Daten werden mittels eines nutzerindividuellen Schlüssels von der Luca-App verschlüsselt und im Luca-System gespeichert. Im Rahmen des Checkins verschlüsselt die Luca-App diesen Nutzerschlüssel mit dem Schlüssel des Gesundheitsamtes. Der Betreiber erhält diesen verschlüsselten Nutzerschlüssel, ver- schlüsselt diesen mit seinem Schlüssel und sendet dies zusammen mit der Checkin- Zeit an das Luca-System. Der Prozess bei einer Infektion ist dann wie oben: Das Luca-System fordert die Entschlüsselung von den Betreibern für die relevanten Zeiten ein (erhält also die mit dem Schlüssel des Gesundheitsamt überschlüsselten Nutzer- schlüssel), sendet die überschlüsselten Schlüssel zusammen mit verschlüsselten Daten an das zuständige Gesundheitsamt, das jetzt die Daten entschlüsseln kann. Dieses Verfahren wird im Folgenden detailliert beschrieben. 1

2     Übersicht Infrastruktur Komponente               Beschreibung [extern] E-Mail-Service  Dient dazu, Betreiber und Gesundheitsämter zu kontaktie- ren, sowie um eingegebene Kontaktinformationen zu vali- dieren. [extern] SMS Service     Dient dazu, die Telefonnummer bei der Eingabe der Kon- taktinformationen zu verifizieren. [Person] Gast            Eine Person, die ihre Kontaktinformationen sicher hinter- legt und später (im Falle der Nachverfolgung) ihre Aufent- haltshistorie dem Gesundheitsamt verfügbar macht. [Person] Mitarbeiter ei- MitarbeiterIn des lokalen Gesundheitsamtes, zuständig für nes Gesundheitsamtes     die Identifikation von Kontaktpersonen. [Person] Betreiber       Private oder geschäftsmäßige LeiterIn einer Veranstaltung, die die Kontaktinformationen ihrer Gäste erfassen soll. Gast-App (Android App,   Die Luca Gast-App, auch Luca App, dient als Interface für iOS App, Web-App)        Gäste. Gäste geben ihre Kontaktinformationen in die App ein und nutzen die App zum Checkin bei verschiedenen Veranstaltungen. Gesundheitsamt-          Dient dem Gesundheitsamt zur Nachverfolgung von Infek- Frontend                 tionsfällen, sowie zur Kontaktierung potenzieller Kontakt- personen. Betreiber-Frontend       Dient Betreibern dazu, neue Veranstaltungen anzulegen und im Infektionsfall die Daten der betroffenen Nutzer zu empfangen und zu entschlüsseln. Luca-Backend             Speichert die verschlüsselten Checkin- und Kontaktinfor- mationen und dient als zentrale Steuerung der anderen technischen Komponenten. Scanner-App              Die Scanner-App wird von Betreibern und ihren Angestell- ten genutzt um die QR-Codes von Gästen beim Checkin zu scannen. Selbstauskunft-Frontend  Ein Interface in dem Gäste direkt ihre Kontaktinformatio- nen hinterlegen können. Betreiber können so Gästen einen Checkin ermöglichen, die nicht über ein Smartphone oder die Luca App verfügen. Die einzelnen Komponenten sind in Abbildung 1 zusammengefasst. 2

Abbildung 1: Übersicht über die Komponenten in Luca 3     Initialisierung Die Initialisierung beschreibt den Prozess Inbetriebnahme des Systems. 3.1     Certification Authority Die Certification Authority (im Folgenden Luca-CA) zertifiziert die im Luca-System benötigten öffentlichen Schlüssel. Hierzu wird ein Schlüsselpaar •      sig     sig (pkLCA , skLCA ) 3

generiert. Der öffentliche Schlüssel erhält ein Zertifikat CLCA (selbstsigniert). 3.2     Luca-System Das Luca-System generiert ein Schlüsselpaar •       auth (pkL , skL )auth für die Server-Authentisierung Der öffentliche Schlüssel erhält ein Zertifikat CL von der Certification Authority D- Trust. 3.3     Gesundheitsamt Jedes Gesundheitsamt generiert zwei Schlüsselpaare •       enc   enc (pkG , skG )      für die Verschlüsselung asymmetrischer Schlüssel     enc (skGG ) •       sig  sig (pkG , skG )   zur Erzeugung von Signaturen und erhält eine healthofficeIDG . Beide öffentlichen Schlüssel erhalten ein Zertifikat enc    sig (CG , CG ) von der Luca-CA. Jeder Mitarbeiter generiert ein Schlüsselpaar •       auth (pkG , skG )auth für die Authentisierung (Anmeldung am Luca-System) auth Der öffentliche Schlüssel erhält ein Zertifikat  CG    von der Luca-CA. 3.4     Betreiber Jeder Betreiber generiert ein Schlüsselpaar •       enc   enc (pkB , skB )     für die Verschlüsselung symmetrischer Schlüssel (für die Check- In-Daten) und erhält eine venueIDB . 4

3.5    Nutzer Im ersten Schritt lädt der Nutzer N die Luca-App aus dem Play-/App-Store. In der App ist das CA-Zertifikat CLCA enthalten. • Der Nutzer gibt seine personenbezogenen Daten ein: userData = (Name, Vorname, Adresse, E-Mail, Telefonnummer) • Die App erzeugt ein Schlüsselpaar         sig  sig (pkN , skN ) zum Signieren Die Telefonnummer wird verifiziert (SMS-TAN-Verfahren) Die App generiert bzw. berechnet die folgenden Werte: • userTraceSecretN • dataSecretN • Initialisierungsvektor IV • Verschlüsselungsschlüssel kNenc = Hash(dataSecretN ||0x01), auf 16 Bytes gekürzt • Authentisierungsschlüssel   kNauth = Hash(dataSecretN ||0x02) • encDataN =                             enc EncSY M M (userData, kN , IV) • authDataN =     HMAC(encDataN , kN )  auth • signedDataN =                                           sig sign(encDataN || authDataN || IV, skN ) Die App baut eine TLS-Verbindung zum Luca-System auf (Serverauthentisierung von Luca mittels CL und • übermittelt     sig (pkN , IV, encDataN , authDataN , signedDataN )  an Luca • erhält eine uuidN von Luca und • speichert                                               sig (uuidN , dataSecretN , userTraceSecretN , skN ) Das Luca-System 5

user data package Tabelle 1: sig ? • prüft die Signatur  verify(encDataN || authDataN || IV, signedDataN , pkN ) = true • speichert              sig (uuidN , pkN , encDataN , authDataN , IV, signedDataN ) Bemerkungen: • QR-Codes haben eine Beschränkung von etwa 100 Byte um deren Scanbarkeit sicherzustellen. Daher können die Daten userData nicht im QR-Code kodiert werden. Aus diesem Grund werden diese Daten verschlüsselt im Luca-System gespeichert und mit der uuid verknüpft. • Zum Entschlüsseln der personenbezogenen Daten wird der Schlüssel       enc kN   benö- tigt. Dieser wird im Rahmen des Checkin mit dem Tagesschlüssel der Gesund- heitsämter verschlüsselt und zusätzlich vom Betreiber, so dass zu diesem Zeit- enc punkt weder die Gesundheitsämter noch die Betreiber den Schlüssel kN ken- nen und damit auch nicht die personenbezogenen Daten. Das Gesundheitsamt erhält im Infektionsfall erst dann die Daten der betroffenen Gäste, wenn Be- treiber die Daten teilentschlüsselt hat. • Das userTraceSecretN wird benutzt, um im Rahmen des Checkins eine auch von der Zeit abhängige trace id zu erzeugen, die erst im Rahmen der Kontaktverfol- gung bei einem Infektionsgeschehen genutzt wird. Durch die Einwegberechnung der trace id aus Zeit, uuid und userTraceSecretN wird garantiert, dass aus der Kenntnis der trace id keine Informationen über die personenbezogenen Daten des Nutzers abgeleitet werden können. 4     Update personenbezogener Daten Falls ein Nutzer einen Infektionsfall gemeldet hat oder betroffener Gast war, werden alle Schlüssel wie in 3.5 beschrieben neu generiert. 6

5       Verteilung der Verschlüsselungsschlüssel Wie bereits in der Einleitung beschrieben, werden die Daten der Nutzer mit einem öffentlichen Schlüssel eines Gesundheitsamtes verschlüsselt. Dieser Schlüssel, genauer das Schlüsselpaar, wird täglich neu von einem Gesundheitsamt erzeugt, verschlüsselt und an alle Gesundheitsämter verteilt. Der öffentliche Schlüssel wird allen Luca-Apps der Nutzer ebenfalls zur Verfügung gestellt. Der Prozess ist wie folgt: Das Gesundheitsamt G • erzeugt ein Schlüsselpaar          enc    enc (pkGG , skGG ), • signiert sigpkGGenc = enc sign(pkGG || healthofficeIDG        || time, skG ) sig (time ist der aktu- elle Tag) • lädt die Verschlüsselungszertifikate         enc CG 0    aller Gesundheitsämter G aus dem     0 Luca-System • prüft die Zertifikate mittels CLCA • verschlüsselt enc 1        enc skGG  =           enc      enc encEC (skGG , pkG0 )      für alle Gesundheitsämter G und      0 • sendet       enc (pkGG , healthofficeIDG , time, sigpkGG   enc , encsk enc ) GG an das Luca-System Das Luca-System sig ? • prüft             enc verify(pkGG || healthofficeIDG     || time, sigpkGG   enc , pk G ) =     true • speichert        enc (pkGG , healthofficeIDG , time, encskGG     enc , sig    enc ) pkGG 0                                              enc   enc Alle anderen Gesundheitsämter G beziehen das Schlüsselpaar                        (pkGG , skGG )   wie folgt: Hierzu wird zunächst eine TLS-Verbindung zum Luca-System aufgebaut (nur Server- Authentisierung mittels CL ). • Der Gesundheitsamtmitarbeiter loggt sich ein (mittels                          auth skG0 ) • bezieht       enc (pkGG , healthofficeIDG , time, encskGG    enc , sig    enc ) pkGG sig ? • prüft             enc verify(pkGG || healthofficeIDG     || time, sigpkGG   enc , pk G ) =     true 1 das eingesetzte Verfahren (ECIES) authentisiert die Daten auch 7

• entschlüsselt       enc skGG    =   decEC (encskGG         enc enc , sk 0 ) G     und • speichert        enc (skGG , time) enc übermittelt  (pkGG , sigpkGG enc , healthofficeID, time), C sig pkG    an die Luca-Apps der Nutzer, 6     User Checkin/Checkout 6.1     Checkin enc Zum Checkin bezieht die Luca-App zunächst den aktuellen Tagesschlüssel                             pkGG der Gesundheitsämter. Hierzu wird zwischen Luca-System und Luca-App eine TLS- Verbindung aufgebaut(nur Server-Authentisierung mittels CL ). Die Luca-App • bezieht        enc (pkGG , healthofficeIDG , time, sigpkGG       enc , C sig G   ) • prüft CGsig mittels CLCA sig ? • prüft              enc verify(pkGG || healthofficeIDG        || time, sigpkGG   enc , pk G ) =   true Weiter wird von der App aus der uuidN , der aktuellen Zeit timeStamp (Auflösung in Minuten) und userTraceSecretN eine trace id traceIDN wie folgt berechnet: • traceIDN = HMAC(uuidN || timeStamp, userTraceSecretN ), auf 16 Bytes gekürzt enc Der Schlüssel dataSecretN wird mittels           pkGG      verschlüsselt und das Ergebnis zusam- men mit dem timeStamp authentisiert: • encDataN,1 =       encEC (uuidN || dataSecretN , pkGG )       enc • authDataN,1 =        HMAC(timeStamp || encData1 , kN ),            auth auf 8 Bytes gekürzt Die App generiert einen QR-Code mit folgendem Inhalt: 1. QR-Code version 2. deviceType 8

3. keyID 4. timeStamp (Auflösung in Minuten) 5. traceIDN 6. encDataN,1 7. authDataN,1 8. checksum = lsB4 (Werte 1. − 7.)) deviceType       value iOS              00 android          01 static           02 webapp           03 contactform      04 6.2      Weiterverarbeitung der QR-Codes Wie in Abschnitt 2 beschrieben, besteht die Infrastruktur bei Betreibern aus einem zentralen Rechner und mehreren QR-Scannern. Die Scanner des Betreibers B erhal- enc ten den öffentlichen Betreiberschlüssel pkB zu ihrer jeweiligen Scanner ID von Luca. Der zugehörige geheime Schlüssel befindet sich auf dem zentralen Rechner. Der Scanner extrahiert und berechnet aus den von der App über die im Checkin übermittelten Daten (QR-Code) die folgenden Werte: • verifiziert die Checksumme • extrahiert deviceT ype, keyID, timeStamp, traceIDN , encDataN,1 , authDataN,1 • berechnet encDataN,2 =                                                 enc encEC (keyID || authDataN,1 || encDataN,1 , pkB ) Zwischen Scanner und Luca wird eine TLS-Verbindung (nur Server-Authentisierung) aufgebaut. Der Scanner sendet die Daten • timeStamp, traceIDN , encDataN,2 , scannerID, authDataScanner , deviceT ype Luca speichert diese. Die Daten werden nach zwei Wochen gelöscht. 9

6.3     Checkout Hier gibt es zwei Verfahren, der Nutzer checkt aus oder der Betreiber checkt den Nutzer aus. Nutzer Checkout Die Luca-App baut eine TLS-Verbindung (nur Server-Authen- tisierung) mit dem Luca-System auf. • Die Luca-App sendet (traceIDN , timeStampout ) an das Luca-System • Luca ergänzt venueID, timeStamp, traceIDN , encDataN,2 um timeStampout (Zuordnung über traceIDN ) Betreiber Checkout Der Betreiber baut eine TLS-Verbindung mit dem Luca- System auf. • Der Betreiber sendet (traceIDN , timeStampout ) an das Luca-System. Das Auschecken durch den Betreiber kann manuell erfolgen oder automatisiert nach einer bestimmten Zeit. Das Auschecken des Nutzers hat Vorrang. 7      Nachverfolgung Bei einer Infektion eines Luca-Nutzers N1 nimmt das zuständige Gesundheitsamt G telefonisch Kontakt auf. G erhält zunächst die personenbezogenen Daten userDataN1 und userTraceSecretN1 wie folgt: 1. Die Luca-App baut eine TLS-Verbindung mit dem Luca-System auf, verschlüsselt enc encN1 = encEC (uuidN1 || dataSecretN1 || userTraceSecretN1 , pkGG ) und übermittelt encN1 an das Luca-System. 2. N1 erhält vom Luca-System eine TAN. 3. N1 gibt die TAN telefonisch an G weiter. 4. G gibt TAN an das Luca-System und erhält encN1 . 10