| /* * Copyright (c) 2020 Ubique Innovation AG <https://www.ubique.ch> * * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at https://mozilla.org/MPL/2.0/. * * SPDX-License-Identifier: MPL-2.0 */package org.dpppt.backend.sdk.ws.controller;import com.fasterxml.jackson.core.JsonProcessingException;import io.jsonwebtoken.Jwts;import io.swagger.v3.oas.annotations.Operation;import io.swagger.v3.oas.annotations.Parameter;import io.swagger.v3.oas.annotations.responses.ApiResponse;import io.swagger.v3.oas.annotations.responses.ApiResponses;import io.swagger.v3.oas.annotations.tags.Tag;import org.dpppt.backend.sdk.data.gaen.FakeKeyService;import org.dpppt.backend.sdk.data.gaen.GAENDataService;import org.dpppt.backend.sdk.model.gaen.*;import org.dpppt.backend.sdk.ws.radarcovid.annotation.Loggable;import org.dpppt.backend.sdk.ws.radarcovid.annotation.ResponseRetention;import org.dpppt.backend.sdk.ws.security.ValidateRequest;import org.dpppt.backend.sdk.ws.security.ValidateRequest.InvalidDateException;import org.dpppt.backend.sdk.ws.security.signature.ProtoSignature;import org.dpppt.backend.sdk.ws.security.signature.ProtoSignature.ProtoSignatureWrapper;import org.dpppt.backend.sdk.ws.util.ValidationUtils;import org.dpppt.backend.sdk.ws.util.ValidationUtils.BadBatchReleaseTimeException;import org.joda.time.DateTime;import org.joda.time.DateTimeZone;import org.joda.time.format.DateTimeFormat;import org.joda.time.format.DateTimeFormatter;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import org.springframework.http.HttpStatus;import org.springframework.http.ResponseEntity;import org.springframework.security.core.annotation.AuthenticationPrincipal;import org.springframework.security.oauth2.jwt.Jwt;import org.springframework.stereotype.Controller;import org.springframework.transaction.annotation.Transactional;import org.springframework.web.bind.MethodArgumentNotValidException;import org.springframework.web.bind.annotation.*;import javax.validation.Valid;import java.io.IOException;import java.security.InvalidKeyException;import java.security.NoSuchAlgorithmException;import java.security.PrivateKey;import java.security.SignatureException;import java.time.Duration;import java.time.Instant;import java.time.LocalDate;import java.time.ZoneOffset;import java.time.format.DateTimeParseException;import java.util.*;import java.util.concurrent.Callable;@Controller@RequestMapping("/v1/gaen")@Tag(name = "GAEN", description = "The GAEN endpoint for the mobile clients")/** * The GaenController defines the API endpoints for the mobile clients to access the GAEN functionality of the * red backend. * Clients can send new Exposed Keys, or request the existing Exposed Keys. */public class GaenController { private static final Logger logger = LoggerFactory.getLogger(GaenController.class); private static final String FAKE_CODE = "112358132134"; private static final DateTimeFormatter RFC1123_DATE_TIME_FORMATTER = DateTimeFormat.forPattern("EEE, dd MMM yyyy HH:mm:ss 'GMT'") .withZoneUTC().withLocale(Locale.ENGLISH); // releaseBucketDuration is used to delay the publishing of Exposed Keys by splitting the database up into batches of keys // in releaseBucketDuration duration. The current batch is never published, only previous batches are published. private final Duration releaseBucketDuration; private final Duration requestTime; private final ValidateRequest validateRequest; private final ValidationUtils validationUtils; private final GAENDataService dataService; private final FakeKeyService fakeKeyService; private final Duration exposedListCacheControl; private final PrivateKey secondDayKey; private final ProtoSignature gaenSigner; public GaenController(GAENDataService dataService, FakeKeyService fakeKeyService, ValidateRequest validateRequest, ProtoSignature gaenSigner, ValidationUtils validationUtils, Duration releaseBucketDuration, Duration requestTime, Duration exposedListCacheControl, PrivateKey secondDayKey) { this.dataService = dataService; this.fakeKeyService = fakeKeyService; this.releaseBucketDuration = releaseBucketDuration; this.validateRequest = validateRequest; this.requestTime = requestTime; this.validationUtils = validationUtils; this.exposedListCacheControl = exposedListCacheControl; this.secondDayKey = secondDayKey; this.gaenSigner = gaenSigner; } @PostMapping(value = "/exposed") @Loggable @ResponseRetention(time = "application.response.retention.time.exposed") @Transactional @Operation(description = "Send exposed keys to server - includes a fix for the fact that GAEN doesn't give access to the current day's exposed key") @ApiResponses(value = { @ApiResponse(responseCode = "200", description = "The exposed keys have been stored in the database"), @ApiResponse(responseCode = "400", description = "- Invalid base64 encoding in GaenRequest" + "- negative rolling period" + "- fake claim with non-fake keys"), @ApiResponse(responseCode = "403", description = "Authentication failed") }) public @ResponseBody Callable<ResponseEntity<String>> addExposed( @Valid @RequestBody @Parameter(description = "The GaenRequest contains the SecretKey from the guessed infection date, the infection date itself, and some authentication data to verify the test result") GaenRequest gaenRequest, @RequestHeader(value = "User-Agent") @Parameter(description = "App Identifier (PackageName/BundleIdentifier) + App-Version + OS (Android/iOS) + OS-Version", example = "ch.ubique.android.starsdk;1.0;iOS;13.3") String userAgent, @AuthenticationPrincipal @Parameter(description = "JWT token that can be verified by the backend server") Object principal) { var now = Instant.now().toEpochMilli(); if (!this.validateRequest.isValid(principal)) { return () -> ResponseEntity.status(HttpStatus.FORBIDDEN).build(); } List<GaenKey> nonFakeKeys = new ArrayList<>(); for (var key : gaenRequest.getGaenKeys()) { if (!validationUtils.isValidBase64Key(key.getKeyData())) { return () -> new ResponseEntity<>("No valid base64 key", HttpStatus.BAD_REQUEST); } if (this.validateRequest.isFakeRequest(principal, key) || hasNegativeRollingPeriod(key) || hasInvalidKeyDate(principal, key)) { continue; } if (key.getRollingPeriod().equals(0)) { //currently only android seems to send 0 which can never be valid, since a non used key should not be submitted //default value according to EN is 144, so just set it to that. If we ever get 0 from iOS we should log it, since //this should not happen key.setRollingPeriod(GaenKey.GaenKeyDefaultRollingPeriod); if (userAgent.toLowerCase().contains("ios")) { logger.error("Received a rolling period of 0 for an iOS User-Agent"); } } nonFakeKeys.add(key); } if (principal instanceof Jwt && ((Jwt) principal).containsClaim("fake") && ((Jwt) principal).getClaimAsString("fake").equals("1")) { Jwt token = (Jwt) principal; if (FAKE_CODE.equals(token.getSubject())) { logger.info("Claim is fake - subject: {}", token.getSubject()); } else if (!nonFakeKeys.isEmpty()) { return () -> ResponseEntity.badRequest().body("Claim is fake but list contains non fake keys"); } } if (!nonFakeKeys.isEmpty()) { dataService.upsertExposees(nonFakeKeys); } var delayedKeyDateDuration = Duration.of(gaenRequest.getDelayedKeyDate(), GaenUnit.TenMinutes); var delayedKeyDate = LocalDate.ofInstant(Instant.ofEpochMilli(delayedKeyDateDuration.toMillis()), ZoneOffset.UTC); var nowDay = LocalDate.now(ZoneOffset.UTC); if (delayedKeyDate.isBefore(nowDay.minusDays(1)) || delayedKeyDate.isAfter(nowDay.plusDays(1))) { return () -> ResponseEntity.badRequest().body("delayedKeyDate date must be between yesterday and tomorrow"); } var responseBuilder = ResponseEntity.ok(); if (principal instanceof Jwt) { var originalJWT = (Jwt) principal; var jwtBuilder = Jwts.builder().setId(UUID.randomUUID().toString()).setIssuedAt(Date.from(Instant.now())) .setIssuer("dpppt-sdk-backend").setSubject(originalJWT.getSubject()) .setExpiration(Date .from(delayedKeyDate.atStartOfDay().toInstant(ZoneOffset.UTC).plus(Duration.ofHours(48)))) .claim("scope", "currentDayExposed").claim("delayedKeyDate", gaenRequest.getDelayedKeyDate()); if (originalJWT.containsClaim("fake")) { jwtBuilder.claim("fake", originalJWT.getClaim("fake")); } String jwt = jwtBuilder.signWith(secondDayKey).compact(); responseBuilder.header("Authorization", "Bearer " + jwt); responseBuilder.header("X-Exposed-Token", "Bearer " + jwt); } Callable<ResponseEntity<String>> cb = () -> { normalizeRequestTime(now); return responseBuilder.body("OK"); }; return cb; } @PostMapping(value = "/exposednextday") @Loggable // BUG: CWE-200 Exposure of Sensitive Information to an Unauthorized Actor // // FIXED: @ResponseRetention(time = "application.response.retention.time.exposednextday") @Transactional @Operation(description = "Allows the client to send the last exposed key of the infection to the backend server. The JWT must come from a previous call to /exposed") @ApiResponses(value = { @ApiResponse(responseCode = "200", description = "The exposed key has been stored in the backend"), @ApiResponse(responseCode = "400", description = "- Ivnalid base64 encoded Temporary Exposure Key" + "- TEK-date does not match delayedKeyDAte claim in Jwt" + "- TEK has negative rolling period"), @ApiResponse(responseCode = "403", description = "No delayedKeyDate claim in authentication") }) public @ResponseBody Callable<ResponseEntity<String>> addExposedSecond( @Valid @RequestBody @Parameter(description = "The last exposed key of the user") GaenSecondDay gaenSecondDay, @RequestHeader(value = "User-Agent") @Parameter(description = "App Identifier (PackageName/BundleIdentifier) + App-Version + OS (Android/iOS) + OS-Version", example = "ch.ubique.android.starsdk;1.0;iOS;13.3") String userAgent, @AuthenticationPrincipal @Parameter(description = "JWT token that can be verified by the backend server, must have been created by /v1/gaen/exposed and contain the delayedKeyDate") Object principal) { var now = Instant.now().toEpochMilli(); if (!validationUtils.isValidBase64Key(gaenSecondDay.getDelayedKey().getKeyData())) { return () -> new ResponseEntity<>("No valid base64 key", HttpStatus.BAD_REQUEST); } if (principal instanceof Jwt && !((Jwt) principal).containsClaim("delayedKeyDate")) { return () -> ResponseEntity.status(HttpStatus.FORBIDDEN).body("claim does not contain delayedKeyDate"); } if (principal instanceof Jwt) { var jwt = (Jwt) principal; var claimKeyDate = Integer.parseInt(jwt.getClaimAsString("delayedKeyDate")); if (!gaenSecondDay.getDelayedKey().getRollingStartNumber().equals(claimKeyDate)) { return () -> ResponseEntity.badRequest().body("keyDate does not match claim keyDate"); } } if (!this.validateRequest.isFakeRequest(principal, gaenSecondDay.getDelayedKey())) { if (gaenSecondDay.getDelayedKey().getRollingPeriod().equals(0)) { // currently only android seems to send 0 which can never be valid, since a non used key should not be submitted // default value according to EN is 144, so just set it to that. If we ever get 0 from iOS we should log it, since // this should not happen gaenSecondDay.getDelayedKey().setRollingPeriod(GaenKey.GaenKeyDefaultRollingPeriod); if(userAgent.toLowerCase().contains("ios")) { logger.error("Received a rolling period of 0 for an iOS User-Agent"); } } else if(gaenSecondDay.getDelayedKey().getRollingPeriod() < 0) { return () -> ResponseEntity.status(HttpStatus.BAD_REQUEST).body("Rolling Period MUST NOT be negative."); } List<GaenKey> keys = new ArrayList<>(); keys.add(gaenSecondDay.getDelayedKey()); dataService.upsertExposees(keys); } return () -> { normalizeRequestTime(now); return ResponseEntity.ok().body("OK"); }; } @GetMapping(value = "/exposed/{keyDate}", produces = "application/zip") @Loggable @Operation(description = "Request the exposed key from a given date") @ApiResponses(value = { @ApiResponse(responseCode = "200", description = "zipped export.bin and export.sig of all keys in that interval"), @ApiResponse(responseCode = "400", description = "- invalid starting key date, doesn't point to midnight UTC" + "- _publishedAfter_ is not at the beginning of a batch release time, currently 2h")}) public @ResponseBody ResponseEntity<byte[]> getExposedKeys( @PathVariable @Parameter(description = "Requested date for Exposed Keys retrieval, in milliseconds since Unix epoch (1970-01-01). It must indicate the beginning of a TEKRollingPeriod, currently midnight UTC.", example = "1593043200000") long keyDate, @RequestParam(required = false) @Parameter(description = "Restrict returned Exposed Keys to dates after this parameter. Given in milliseconds since Unix epoch (1970-01-01).", example = "1593043200000") Long publishedafter) throws BadBatchReleaseTimeException, IOException, InvalidKeyException, SignatureException, NoSuchAlgorithmException { if (!validationUtils.isValidKeyDate(keyDate)) { return ResponseEntity.notFound().build(); } if (publishedafter != null && !validationUtils.isValidBatchReleaseTime(publishedafter)) { return ResponseEntity.notFound().build(); } long now = System.currentTimeMillis(); // calculate exposed until bucket long publishedUntil = now - (now % releaseBucketDuration.toMillis()); DateTime dateTime = new DateTime(publishedUntil + releaseBucketDuration.toMillis() - 1, DateTimeZone.UTC); var exposedKeys = dataService.getSortedExposedForKeyDate(keyDate, publishedafter, publishedUntil); exposedKeys = fakeKeyService.fillUpKeys(exposedKeys, publishedafter, keyDate); if (exposedKeys.isEmpty()) { return ResponseEntity.noContent()//.cacheControl(CacheControl.maxAge(exposedListCacheControl)) .header("X-PUBLISHED-UNTIL", Long.toString(publishedUntil)) .header("Expires", RFC1123_DATE_TIME_FORMATTER.print(dateTime)) .build(); } ProtoSignatureWrapper payload = gaenSigner.getPayload(exposedKeys); return ResponseEntity.ok()//.cacheControl(CacheControl.maxAge(exposedListCacheControl)) .header("X-PUBLISHED-UNTIL", Long.toString(publishedUntil)) .header("Expires", RFC1123_DATE_TIME_FORMATTER.print(dateTime)) .body(payload.getZip()); } @GetMapping(value = "/buckets/{dayDateStr}") @Loggable @Operation(description = "Request the available release batch times for a given day") @ApiResponses(value = { @ApiResponse(responseCode = "200", description = "zipped export.bin and export.sig of all keys in that interval"), @ApiResponse(responseCode = "400", description = "invalid starting key date, points outside of the retention range")}) public @ResponseBody ResponseEntity<DayBuckets> getBuckets( @PathVariable @Parameter(description = "Starting date for exposed key retrieval, as ISO-8601 format", example = "2020-06-27") String dayDateStr) { var atStartOfDay = LocalDate.parse(dayDateStr).atStartOfDay().toInstant(ZoneOffset.UTC) .atOffset(ZoneOffset.UTC); var end = atStartOfDay.plusDays(1); var now = Instant.now().atOffset(ZoneOffset.UTC); if (!validationUtils.isDateInRange(atStartOfDay)) { return ResponseEntity.notFound().build(); } var relativeUrls = new ArrayList<String>(); var dayBuckets = new DayBuckets(); String controllerMapping = this.getClass().getAnnotation(RequestMapping.class).value()[0]; dayBuckets.setDay(dayDateStr).setRelativeUrls(relativeUrls).setDayTimestamp(atStartOfDay.toInstant().toEpochMilli()); while (atStartOfDay.toInstant().toEpochMilli() < Math.min(now.toInstant().toEpochMilli(), end.toInstant().toEpochMilli())) { relativeUrls.add(controllerMapping + "/exposed" + "/" + atStartOfDay.toInstant().toEpochMilli()); atStartOfDay = atStartOfDay.plus(this.releaseBucketDuration); } return ResponseEntity.ok(dayBuckets); } private void normalizeRequestTime(long now) { long after = Instant.now().toEpochMilli(); long duration = after - now; try { Thread.sleep(Math.max(requestTime.minusMillis(duration).toMillis(), 0)); } catch (Exception ex) { logger.error("Couldn't equalize request time: {}", ex.toString()); } } private boolean hasNegativeRollingPeriod(GaenKey key) { Integer rollingPeriod = key.getRollingPeriod(); if (key.getRollingPeriod() < 0) { logger.error("Detected key with negative rolling period {}", rollingPeriod); return true; } else { return false; } } private boolean hasInvalidKeyDate(Object principal, GaenKey key) { try { this.validateRequest.getKeyDate(principal, key); } catch (InvalidDateException invalidDate) { logger.error(invalidDate.getLocalizedMessage()); return true; } return false; } @ExceptionHandler({IllegalArgumentException.class, InvalidDateException.class, JsonProcessingException.class, MethodArgumentNotValidException.class, BadBatchReleaseTimeException.class, DateTimeParseException.class}) @ResponseStatus(HttpStatus.BAD_REQUEST) public ResponseEntity<Object> invalidArguments(Exception ex) { logger.error("Exception ({}): {}", ex.getClass().getSimpleName(), ex.getMessage(), ex); return ResponseEntity.badRequest().build(); }} |