Dieses Dokument ist Teil der Anfrage „Unterlagen zur Prüfung der luca-App“
Luca Security Concept Goal The Luca System is designed to enable anonymous and secure contact information transfer. Visitors and guests of public or private events should be able to anonymously share their contact data with the organizer. Only in case of an infection, shall the local health authorities be enabled to access the collected personal contact information. Both the consent of the infected guest and the organizer are required. The following data is processed during the identification of possible contact persons. Types of data contact details of guests check-in information of guests location information name location name of the location street, street number, city, postal check-in time name and email of the contact code check-out time person of the location phone number address of the location email coordinates of the location check-in radius private event tracing code health authority information name of the authority name, email, certificates of legitimate employees The personal information of guests is the most valuable asset processed in the Luca system. System Overview Component Description [external] Email Is used to contact organizers and health departments, also to validate given contact information Service
[external] Is used to validate phone number used while entering contact details SMS Service [user] Guest A person that is required to securely provide their personal information before entering a location and later (on infection) submit their location history to the health department [user] Heath employee of the local health department responsible for identification of contact persons Department Employee [user] Location private person, or business owner/manager of a location that has guests and is obliged to trace contact information Owner shall be able to manage events / locations and scan guests Guest App The Luca guest app, also described as Luca app, is the interface for the guests. (Android, App, Guests enter the contact information in the app and use the app to checkin at several locations without re-entering their Webapp) contact details. Health Department Enables the health department to trace infection cases and contact potential contact persons. Frontend Location Frontend The frontend of the managers/organizers of locations/venues/restaurants. Here, a professional or private user can create locations or events which will enable the manager to checkin guests Luca Backend Stores encrypted check-in and contact information (never in possession of personal information in plain text) Centrally orchestrates the other technical components Scanner Frontend / The scanner app is used by the organizer or its employees to scan the anonymous Luca codes and check-in guests App Self-registration The self-registration frontend enables locations to also let guests enter their information manually on-site on an iPad or Frontend something similar. Static Code Generates printable QR codes to be used by people without smartphones to allow check-ins at Luca locations Generator Core processes Luca's primary goal is to automate the identification of contact persons for venues, restaurants and locations and ease the health department's identification of possible contact persons of infected persons. The table below provides a high-level overview of the involved processes to achieve this goal. Process Purpose Involved parties Input Output name Location Register an event or a venue with the Luca professional location email, password, venuePrivKey registration system and enable it to check-in guests via owner location information venuePubKey Luca. OR (name, address, ...) private event organizer Scanner Links Health Collect the check-in history of infected users Health department authentication Certified "health department encryption department and trace/ potential contact persons from manager certificate, name of the key pair" (HDEKP) and "... signing key registration those locations health department pair" (HDSKP) User Set up a smartphone user to check-in at some citizen willing to personal contact details userPrivKey registration venues using Luca user Luca userPubKey (via Luca additional local secrets App) anonymous userID Static QR Set up a static QR code badge allowing Static Code Generator, anonymous QR Code code check-in at venues to people without a some citizen willing to generation smartphone use Luca User checkin Transmit anonymous contact information to Luca user, venue anonymous QR Code uploaded tracing data /out location owner owner (or employee) 1) Scanner checkin 2) self-registration 3) table checkin 4) self/automated checkout
Identification Retrieve contact information in case of an Health department user TAN affected locations of infection employee, Luca user, HDEKP contact data of affected users contact 1) Reveal contact information to health venue owner persons department (Infection) 2) Reveal location history to health department 3) Venue approval for identification of contact persons 4) Reveal contact information of possible contact persons Asymmetric Encryption The underlying security used during the core processes relies on our asymmetric encryption scheme that shall be presented in the following section. We define our asymmetric encryption similar to DLIES (BSI TR-02102-1 3.5) according to the technical guideline of the BSI . Components asymmetric key parameters secp256r1 (NIST P-256) symmetric encryption EK AES-128-CTR message authentication code MACKM HMAC-SHA256 key derivation function H SHA256 Encryption Decryption function signature: AsymEnc(data, publicKey, [iv]) The inputs for the decryption are encryptedData, receiverPrivateKey, IV, ephemeralPublicKey and an (optional) MAC The inputs for encryption are data and a receiverPublicKey. The encryption procedure: The decryption procedure: 1. generate ephemeral ECC keyPair: ephemeralPrivateKey and ephemeralPublicKey 1. calculate DHKey = ECDH(receiverPrivateKey, 2. generate IV = random bytes (16 bytes) (if not given as input) ephemeralPublicKey) 3. calculate DHKey = ECDH(ephemeralPrivateKey, 2. calculate encryptionKey = SHA256(DHKey || 0x01) (truncate to receiverPublicKey) 16 bytes) 4. calculate encryptionKey = SHA256(DHKey || 0x01) (truncate to 3. calculate authenticationKey = SHA256(DHKey || 0x02) 16 bytes) 4. verify MAC (if available) = HMAC-SHA256(encryptedData, 5. calculate authenticationKey = SHA256(DHKey || 0x02) authenticationKey) 6. calculate encryptedData with AES-128-CTR(data, 5. calculate decryptedData = AES-128-CTR(encryptedData, encryptionKey, IV) encryptionKey, IV) 7. calculate MAC = HMAC-SHA256(encryptedData, authenticationKey) Output: decryptedData Output: encrypted data, MAC, IV, ephemeralPublicKey Notes: the MAC might be skipped/ignored and the IV might be given as an input Processes Daily Public Key Rotation Luca uses a daily key rotation system to reduce the impact of a any single compromised key. The keys are identified by a keyId (integer), which is incremented with each rotation. The rotation will be triggered by any health department employee that logins after the last daily public key expired. The daily public key is owned and kept secret by the health authorities. It is used to encrypt the user's personal data on checkins and registration, as described in the following processes. Rotation Process The life time of a daily key pair is 24 hours. If a daily public key has expired, any one health department employee automatically generates a new dailyLucaKeyPair. The newly generated daily private key is then shared with all other health departments by encrypting it for each HealthDepartmentEncryptionPublicKey and uploading it to the luca system. This effectively replaces the old daily key. Measures are taken to solve race conditions if multiple health department employees try to rotate the daily public key simultaneously. Stepwise process health department employee logins via client certificate
check for current expiration of daily key pair; continue only if key is expired locally generate a new daily key pair (NIST P-256) fetch all HealthDepartmentEncryptionPublicKeys (in the form of encryption certificates) from the luca system validate each encryption certificate against the configured CA and check their revocation status via OCSP encrypt dailyPrivateKey with all HealthDepartmentEncryptionPublicKeys and upload the encryptedDailyPrivateKeys sign the dailyPublicKey, the ID of the signing health department and the current timestamp with the local HealthDepartmentSigningPrivateKey upload the signed dailyPublicKey to luca system luca system validates the utilized HealthDepartmentSigningPrivateKey against the configured CA and checks its revocation status via OCSP luca system validates the signature of the uploaded dailyPublicKey, checks the signed timestamp for plausibility and concludes the rotation process result: daily key pair is exchanged, all new operations will be performed using the new key pair Key Destruction Daily private keys that are older than roughly two weeks (epidemiologically relevant time span) can be destroyed as no infection-relevant contacts happen beyond this time. The luca system can delete all such encryptedDailyPrivateKeys for all health departments. Furthermore, the health department frontend app might need to remove locally stored copies of such daily private keys. User registration 1) App Registration Upon first launch the user provides their contact information (see on top) to the app. The app then verifies the user's phone number via the luca system. For that, the plaintext phone number is sent to the backend, forw arded to the SMS service that creates a challenge. The SMS service sends a verificationTAN as SMS or voice call to the provided phone number. After entering the verificationTAN in the Luca app, it is verified via the backend with the SMS service provider. After that, the user's phone number is no longer stored on the luca backend. The app generates an EC secp256r1 keypair, a user tracing secret (16 bytes entropy), a user verification secret (16 bytes entropy) and a userDataKey (16 bytes random data). The app then encrypts the personal information and the user verification secret using AES-CTR- 128 with the userDataKey and signs it with the user's private key. The user's publicKey, the encrypted data and signature are transferred to the luca system which returns a unique userID for the app to store. The App stores the following: user id (uuid) user public key (ec secp256r1) user private key (ec secp256r1) user data key (16 bytes random data) user tracing secret (16 bytes random data) user verification secret (16 bytes random data) The Luca system stores the following: user id User Registration.txt user public key encrypted personal information (including verificationSecret) encrypted data iv 2) Static QR Code Generation The static QR code generation workflow is meant to be usable by users without access to a smartphone. The user will register through a purchase onboarding process. The generated code will then be printed and sent to the user via postal service. This process is subject of active discussion. See here for more details. These static QR codes cannot give the same security and privacy guarantees as the app-based checkin, though. Location Registration Both professional location owners and private event organisers can register with the luca system via a web application. The registration process involves the generation of a venueKeyPair whose private key is then stored either locally or encrypted by a password in the luca system. 1) Professional Location Owner A professional location owner (e.g. concert venue, museum, restaurant, etc.) can register a long-term location in the luca system. Each location can be managed by a web interface to set up individual QR code scanners and configure other venue-specific parameters (e.g. auto checkout behaviour). Process
location owner registers with email and password locally generate a venue key pair (NIST P-256) in the web application store the venuePrivKey to local file system upload the venuePubKey to the luca system 2) Private Event A private event is a one-time event organised by an individual user that is identified via its email address. Private organiser may be contacted by the health department for identification of contact persons similarly to professional venue owners. For simplicity we don't require private users to download and keep the private key for their event locally. Instead, they are asked to provide a password that is used to encrypt the locally generated private key. In case identification of contact persons becomes necessary, they can retrieve their encrypted private key from the luca system and decrypt it with their event password. Process create a one-time event by providing a valid email address via a web interface generate a venueKeyPair (NIST P-256) provide a sufficiently strong password for the event derive encryption and authentication keys from the password using PBKDF2 encrypt venuePrivKey like: AES-128-CTR(venuePrivKey, encKey, IV) authenticate the encryptedVenuePrivKey via HMAC-SHA256 under authKey upload encryptedVenuePrivKey, PBKDF2-salt, IV, venuePubKey and MAC to the luca system Health Department (HD) Registration A new health department receives an authentication certificate to authenticate to Luca. This certificate does not need to be signed by the external CA, as it only needs to be trusted by Luca. It is used to login to the Luca frontend. The health department creates an encryption certificate (HealthDepartmentEncryptionKeyPair HDEKP) and a signing certificate (HealthDepartmentSigningKeyPair HDSKP) on first login. Both of these certificates must be issued by the external CA via a manual process to ensure authenticity of the requesting HD admin. They are used to authenticate to (a) the app on checkins and (b) other health departments on key rotation /distribution. HDEKP is the key pair that needs to be accessible by any HD employee when performing Identification of contact persons, as it decrypts the daily health department private key. The HDSKP is highly sensitive, as it authenticates the daily health department public key. The signed public key of the HDEKP is uploaded to the Luca system, where it is available when distributing a new daily key. Both keypairs' private keys are securely stored locally. For use cases where the keypairs need to be accessible from multiple workstations the HD frontend provides secure export and import functionalities. Future Improvement: Employee Management Tools In a future version the HD frontend will provide facilities to simplify distributing access to the keypairs among health department employees. To this end, the HDEKP will be stored encrypted on the Luca backend. Each administrator and employee will receive an Offline Keypair that can be used to access the HDEKP. This will avoid the process of exporting and importing copies of the HDEKP and make it easier to revoke access for specific employees' keypairs, when needed. Overview of secrets and their location of the health department Secret Use Location HDEKP Public Key: Encrypt the daily health department key (one per HD) Public Key: Luca backend HealthDepartmentEncryptionKeyPair Private Key: Decrypt the daily health department key Private Key: Local devices HDSKP Sign the daily health department key for key rotation in the morning Admin local device HealthDepartmentSigningKeyPair Admin Auth Cert Authenticate to Luca System to manage employees Admin local device Employee Auth Cert Authenticate to Luca to trigger identification of possible contact persons Employee local device (Planned) Admin Offline Key Pair Decrypt the HDEKP Admin local device (Planned) Employee Offline Key Pair Decrypt the HDEKP (transport HDEKP from Admin to Employee) Employee local device User Check-in/out In this process the Luca system creates and persists a trace object that can be used (a) to trace an infected user's check-in at a specific location, and (b) to trace potential contact persons, that were at the same location at the same point of time.
There are multiple possibilities how the check-in can be done. The basic use case is for a venue to use the Luca Scanner App to scan a QR code generated by the Luca Guest App. Alternatively, users can self-check-in using a printed QR code (for example at a restaurant table). In both cases the general flow of the process is the same: The Guest App generates a trace ID, that can be used to trace the user if and only if the tracing party (the heath department) know the user's tracing secret (see Identification of contact persons). Scanner Check-in When check-in is activated, the Guest App will continuously generate new traceIDs. Each trace created as HMAC-SHA256 of the user id and the current timestamp (down-sampled to the minute) as data and the user tracing secret as key. The resulting value is truncated to the first 16 bytes. Subsequently, the App asymmetrically encrypts the userID and the userDataKey for the current daily health department key. The IV is defined as the first 16 bytes of the ephemeral public key used in the encryption scheme. The App then calculates a verification tag as HMAC- SHA256 of the timestamp and the encrypted data as data and the user verification secret as key, truncated to the first 8 bytes. In this process, the App fetches the current dailyPublicKey along with its generation time stamp from the Luca backend. The dailyPublicKey and the timestamp are signed by a specific HealthDepartmentSigningKeyPair certificate so that the Luca App can verify the authenticity of the provided data. For that, the HDSKP- certificate must be downloaded, validated against the issuing CA and checked for its revocation status via OCSP. Only then will the Luca App Scanner Check-in.txt trust the downloaded dailyPublicKey. Furthermore, the app checks the signed generation time stamp for plausibility and reject the usage of outdated dailyPublicKeys. The App then displays a QR code, updated every minute with the current timestamp and a new traceID. The QR code contains: QR code version device type keyID (specifies which daily health department key was used) timestamp traceID encrypted data (userDataKey and user id encrypted as described above) ephemeral public key verification tag checksum (SHA256 of all data above, truncated to 4 bytes) The payload is concatenated and encoded with ASCII85 to be displayed as a QR code. Upon scanning the QR code, the Scanner App in turn must asymmetrically encrypt the encrypted data and the verification tag using the venue public key. The IV is randomly generated. The Scanner App uploads the following data to the Luca backend: traceID scannerID timestamp (doubly) encrypted data IV, MAC, and ephemeral public key from the encryption device type (indicating the Scanner App) When storing this information the Luca backend associates it with the venueID (which it determines using the scannerID) and the check-in time. Self-Check-in In this variation the Guest App assumes the role of the Scanner App in order for the user to check-in at the venue autonomously. To enable this process, the venue needs to provide a QR code that encodes the required information: a valid scannerID for this venue, the venueID, and the venue public key used for the asymmetric encryption. The Guest App can use the scannerID in order to retrieve additional information about the venue from the Luca backend and display it to the user. Once the user scans the QR code using the Guest App, the App generates the same information as in the Scanner Check-in variation. Note that this involves the same validation of the dailyPublicKey signature as detailed above. Then, instead of displaying it as a QR code, it also performs the steps normally done by the Scanner App (i.e. add second encryption layer, associate with scannerID and device type) and uploads it to the Luca system.
Additional Data Luca provides the functionality to associate a check-in with additional data. This can be done by either the Guest App or by the Scanner App. Additional Data is designed to be non-sensitive data that can be used in the identification of possible contact persons. An example is the table number a user was placed at in a restaurant. Regardless of which App creates and uploads the additional data, the data is asymmetrically encrypted using the venue public key before being uploaded. Checkout When a user leaves a venue, they can be marked as checked out. This can be done (1) manually on the Guest App, (2) automatically by the Guest App, or (3) manually by the venue owner. In case of the automatic checkout the App can use the user's geo-coordinates in combination with the venues geo-coordinates and a geofencing radius. To perform the checkout the respective traceID to be checked out and the current timestamp are sent to the Luca backend. Security Considerations When encrypting the (encrypted) user data and the additional data with the venue public key the authenticity of that public key is crucial. In the Scanner Check-in scenario, this is guaranteed because the scanner app is already provisioned with the correct public key. In the Self Check-in scenario, users and the venue owners need to access the authenticity of printed QR codes, in order to avoid scanning forged QR codes that have been printed and placed at the venue by an attacker. The scannerID sent as part of the check-in data is the only indicator Luca can use in order to infer the associated venue. Forging a non-existent scannerID could potentially allow an attacker to send bogus data to the Luca system. However, this does not reveal any information to the attacker in any scenario. On a similar note, knowing the scannerID of a venue basically allows the impersonation of the venue's Scanner App. This is accepted; more specifically, this is specifically desired in the Self Check-in scenario. Notably, the physical equivalent of this would be for an attacker to "steal" the Self Check-in QR code and place it in another venue. The Luca system cannot avoid such mischief. Caused by the limited capacity of QR codes, the Guest App directly interacts with the Luca backend in the processes listed above. The Luca backend could associate the user's current IP address with the checked-in traceID, thus there is no storing of the associated IP addresses. In addition it is not possible to infer future or past traceIDs without having access to the user-owned traceSecret. Identification of contact persons The Identification of contact persons consists of two major parts: (1) tracing the location history of the known infected person and (2) finding and informing potential contact persons. Tracing the Location History of an Infected Person In the beginning of this process, an infected person is directly contacted by a local health department. The health department needs to acquire the secrets stored locally within that person's Guest App. Therefore, the health department will ask the person to reveal their personal information and location history via a functionality in the App. Step 1: Accessing the Infected User's Tracing Secret When this functionality is activated, the Guest App creates a User Transfer Object that holds the relevant information. The app will encrypt the secrets for sharing like follows: serialize userId, userDataKey and userTracingSecret in a JSON asymmetrically encrypt the serialized JSON for the current daily health department key Infection 20201122.txt upload the encryption results to Luca Luca will return a TAN The TAN serves as an identifier for the Transfer Object within Luca and does not carry any further security relevance. The Luca user can now communicate the TAN to the health department, in order for the health department to retrieve the encrypted package from Luca. In order to retrieve the encrypted Transfer Object from Luca the health department employee needs to login using their login certificate. To decrypt the encrypted Transfer Object, they further need access to the relevant daily health department keys, which they can retrieve from the Luca backend and decrypt using they HealthDepartmentEncryptionKeyPair. Step 2: Recovering the Infected User's Location History In this step, the health department finds all venues where the infected user has checked in within the relevant recent timespan (e.g. 14 days).
To start the tracing process, the health department sends the infected user's tracing secret to the Luca backend. Based on the secret and the affected userID, the backend will generate all possible traceIDs for the affected time frame. These traceIDs are used to find all trace objects checked in by the user. Luca can use the trace objects to contact all venues the infected user has attended. They will be contacted via Email and asked to reveal the potential contact persons. Step 3: Finding Potential Contact Persons The venue downloads all trace objects in the Location Frontend and validates which guests might be contact persons (for example using Additional Data attached to the trace objects). Both the Additional Data and the outer layer of encryption in the trace object can be decrypted using the Location's private key. The decrypted data is still encrypted with some daily health department key and thus is only accessible to the health departments. The encrypted data contains the userID and the userDataKey (see User Check-in). This data is then uploaded back to Luca in order to be shared with the health department. After each affected location responded, the health department can download and decrypt the traces using the relevant daily health department key. The health department now has access to the personal data of the contact persons. The authenticity of each trace can be validated using the verification secret. Security Properties User tracking It is impossible for the LUCA system to track users as they generate trace ids that can only be correlated when having the user trace secret, which will only be transmitted in an infection case and even then only readable for the health department. Users that only had contact with an infected user will not reveal their user trace secret and therefore can not be tracked. Data safety The users personal information is encrypted at all times and will only ever be readable by persons that have knowledge of the userDataKey. The userDataKey can only be obtained from the user himself or in an encrypted form from a venue that scanned his QR code. All decryption is handled locally by the respective actors. Data integrity All data stored in the luca system is in some way signed/mac'ed by the owner of the data, so no employee can alter data. Security Considerations Static Badges Badges with static content can be copied and misused. A future protection could be One-Time Badges or TAN lists with one-time use, so a QR code can only be used with a valid unused TAN. Data Analysis The LUCA system can potentially infer from the data how many users were at a venue at any given time. This could be mitigated by sending dummy checkins as noise to obfuscate the real usage. Checkin Data verification The LUCA system can not verify data integrity at certain levels. Example: The LUCA System can not verify that data was not modified by the venue. Th e venue can not verify that the provided data by the user is valid. A venue can submit arbitrary data as no verification is done by the LUCA system. But the data can and will be validated when the health department decrypts the users personal information and can then verify the authenticity and integrity of the data. Internet connection If we want to disallow venues uploading checkins for timestamps that are different to the current time, they will need to have constant internet connection while doing checkins. If we don't disallow this, they can upload checkins for scanned badges at arbitrary times as we have no way of verifying this (this only applies to badges not app users). Rogue Venues A rogue venue could invalidate users data or just not upload checkins. They could also loose, forget or destroy their venueKeyPair. Rogue User
A user can submit invalid data, which will only be detected at the decryption stage of the health department. This is mitigated by validating the phone number via SMS verification. A user can loose, forget or destroy his app and his secrets when infected. Rogue Service An employee can't alter data but they still can remove and invalidate data when having direct access to the database. Glossar Description Owner / Who has access? authentication certificates X509 certificates used to login as an health department employee himself employee healthDepartmentEncryptionKeyPair Generated once for each health department on the first login of the admin healthDepartmentEncryptionPrivKey used to decrypt the encryptedDailyPublicKey stored encrypted at luca, key is owned by every employee and the admin of the corresponding health department employeeKeyPair generated once on the first login of each health department employee employeePrivKey used to decrypt the healthDepartmentEncryptionKeyPair stored encrypted at Luca, key is owned by Health Department and it's employees dailyPublicKey used to encrypt personal information and traces during publicly stored at Luca the identification of contact persons encryptedDailyPrivateKey used to decrypt personal information and traces during stored encrypted with the the identification of contact persons healthDepartmentEncryptionPublicKey for each healthDepartment tan / user tan human readable code, generated on upload of transfer generated by App, given to Health object, transmitted via phone between guest and health Department department employee traceId derived ID of the checkin, obfuscated to only allow publicly stored at Luca tracking on infection case userDataKey randomly generated on user-side, used to encrypt stored in App in secure key storage personal information encrypted in QR code stored encrypted (twice) at Luca on checkin userId unique identifier of the user in the luca system, ex. used to identify personal information userKeyPair generated on user registration userPrivKey randomly generated store in guest app, used to sign stored in App in secure key storage transfer objects userPubKey public key of the user, uploaded to luca system on publicly stored at Luca registration userTracingSecret randomly generated on user-side, used to secure tracing stored in App in secure key storage information only given to healthDepartment when user infected userVerificationSecret used to authenticate information of the user, and to verify stored in App in secure key storage traces by the health department stored encrypted at Luca, key is the userDataKey venueKeyPair generated pub/priv key pair owned by the location owner / venue; generated on registration of the location owner
venuePrivKey private key of the venue, generate on venue/location stored encrypted at Luca, key is owned by registration venue operator a) downloaded by the location owner, and securely stored by the user or b) (private events) for one-time events, generated on stored locally at venue operator event registration, encrypted with 10-digit alphanumeric ; encrypted stored in the luca backend venuePubKey public key of venue, used on checkin to secure the stored publicly at Luca check-in /trace information Used implementations of cryptographic operations function web/node iOS Android ecc keyPair generation indutny/elliptic Apple native Security library with SecKeyCreateRandomKey Bouncy Castle ECDSA-SHA256 indutny/elliptic Apple native Security library with ecdsaSignatureMessageX962SHA256 algorithm Bouncy Castle ECDH indutny/elliptic Apple native Security library with ecdhKeyExchangeStandard Bouncy Castle AES-128-CTR digitalbazaar/forge CryptoSwift Bouncy Castle HMAC-SHA256 digitalbazaar/forge CryptoSwift Bouncy Castle SHA256 digitalbazaar/forge CryptoSwift Android MessageDigest