public bool Validate(ReleaseTeksArgs args, KeyReleaseWorkflowState workflow)
        {
            if (args == null)
            {
                return(false);
            }

            if (workflow.ValidUntil.AddMinutes(_Config.GracePeriodMinutes) <= _DateTimeProvider.Now()) //30 minutes grace period
            {
                _Logger.LogWarning($"Workflow is not valid anymore: {args.BucketId}");
                return(false);
            }

            if (_Config.TemporaryExposureKeyCountMin > args.Keys.Length || args.Keys.Length > _Config.TemporaryExposureKeyCountMax)
            {
                _Logger.LogWarning($"Invalid number of keys: {args.BucketId}");
                return(false);
            }

            if (!args.Keys.All(_TemporaryExposureKeyValidator.Valid))
            {
                _Logger.LogWarning($"One or more keys not valid: {args.BucketId}");
                return(false);
            }

            return(true);
        }
Exemple #2
0
        public async Task <EnrollmentResponse> Execute()
        {
            var validDate = _DateTimeProvider.Now().AddDays(1); //TODO smells like a setting

            var entity = new KeyReleaseWorkflowState
            {
                LabConfirmationId = _NumberGenerator.GenerateToken(),
                Created           = _DateTimeProvider.Now(),
                BucketId          = Convert.ToBase64String(_NumberGenerator.GenerateKey()),
                ConfirmationKey   = Convert.ToBase64String(_NumberGenerator.GenerateKey()),
                ValidUntil        = new DateTime(validDate.Year, validDate.Month, validDate.Day, 4, 0, 0, DateTimeKind.Local) //TODO smells like a setting
            };

            _Logger.LogDebug("Writing.");
            await _DbContextProvider.KeyReleaseWorkflowStates.AddAsync(entity);

            _Logger.LogDebug("Committing.");
            _DbContextProvider.SaveAndCommit();
            _Logger.LogDebug("Committed.");

            return(new EnrollmentResponse
            {
                ConfirmationKey = entity.ConfirmationKey,
                BucketId = entity.BucketId,
                LabConfirmationId = $"{entity.LabConfirmationId.Substring(0, 3)}-{entity.LabConfirmationId.Substring(3, 3)}", //TODO UI concern in DB!
                Validity = (long)(entity.ValidUntil - _DateTimeProvider.Now()).TotalSeconds
            });
        }
Exemple #3
0
        public async Task AddExampleContent()
        {
            var r = new Random();

            await using var tx = await _Provider.Database.BeginTransactionAsync();

            var wfs1 = new KeyReleaseWorkflowState
            {
                LabConfirmationId = "2L2587",
                BucketId          = "2",
                ConfirmationKey   = "3",
                Created           = new DateTime(2020, 5, 1),
            };

            var key1 = new TemporaryExposureKeyEntity
            {
                Owner                 = wfs1,
                PublishingState       = PublishingState.Unpublished,
                RollingPeriod         = 1,
                RollingStartNumber    = 1,
                TransmissionRiskLevel = 0,
                KeyData               = new byte[16],
                Region                = "NL"
            };

            r.NextBytes(key1.KeyData);

            var key2 = new TemporaryExposureKeyEntity
            {
                Owner                 = wfs1,
                PublishingState       = PublishingState.Unpublished,
                RollingPeriod         = 1,
                RollingStartNumber    = 1,
                TransmissionRiskLevel = 0,
                KeyData               = new byte[16],
                Region                = "NL"
            };

            r.NextBytes(key1.KeyData);

            await _Provider.KeyReleaseWorkflowStates.AddAsync(wfs1);

            await _Provider.TemporaryExposureKeys.AddRangeAsync(key1, key2);

            _Provider.SaveAndCommit();
        }
        public bool Valid(byte[] signature, KeyReleaseWorkflowState workflow, byte[] data)
        {
            if (signature == null)
            {
                return(false);
            }

            using var hmac = new HMACSHA256(Convert.FromBase64String(workflow.ConfirmationKey));
            var hash = hmac.ComputeHash(data);

            var result = hash.SequenceEqual(signature);

            if (!result)
            {
                _Logger.LogInformation($"Invalid signature for BucketId: {workflow.BucketId}");
            }

            return(result);
        }
Exemple #5
0
        public bool Valid(byte[] signature, KeyReleaseWorkflowState workflow, byte[] data)
        {
            if (signature == null)
            {
                throw new ArgumentNullException(nameof(signature));
            }
            if (workflow == null)
            {
                throw new ArgumentNullException(nameof(workflow));
            }
            if (data == null)
            {
                throw new ArgumentNullException(nameof(data));
            }

            using var hmac = new HMACSHA256(Convert.FromBase64String(workflow.ConfirmationKey));
            var hash = hmac.ComputeHash(data);

            return(hash.SequenceEqual(signature));
        }
Exemple #6
0
        public async Task <EnrollmentResponse> Execute()
        {
            var entity = new KeyReleaseWorkflowState
            {
                LabConfirmationId = _NumberGenerator.GenerateToken(),
                Created           = _DateTimeProvider.Now(),
                BucketId          = Convert.ToBase64String(_NumberGenerator.GenerateKey()),
                ConfirmationKey   = Convert.ToBase64String(_NumberGenerator.GenerateKey()),
            };

            await _DbContextProvider.KeyReleaseWorkflowStates.AddAsync(entity);

            _DbContextProvider.SaveAndCommit();

            var validDate = DateTime.Now.AddDays(1);

            return(new EnrollmentResponse
            {
                ConfirmationKey = entity.ConfirmationKey,
                BucketId = entity.BucketId,
                LabConfirmationId = entity.LabConfirmationId,
                ValidUntil = new DateTime(validDate.Year, validDate.Month, validDate.Day, 4, 0, 0, DateTimeKind.Local)
            });
        }
 public bool Valid(byte[] signature, KeyReleaseWorkflowState workflow, byte[] data) => signature != null && workflow != null && data != null;
 public bool Valid(byte[] signature, KeyReleaseWorkflowState workflow, byte[] data) => true;