예제 #1
0
        public async Task RunAsync()
        {
            try
            {
#if DEBUG
                ECDsa = System.Security.Cryptography.ECDsaCng.Create(ECCurve.NamedCurves.nistP256);
#else
                if (KeyVaultKey == null)
                {
                    KeyVaultKey = await KeyVault.GetKeyAsync(TekExportKeyVaultKeyUrl);

                    SigInfo.VerificationKeyId      = KeyVaultKey.Key.Kid;
                    SigInfo.VerificationKeyVersion = KeyVaultKey.KeyIdentifier.Version;
                    ECDsa = KeyVaultKey.Key.ToECDsa(true);
                }
#endif

                var items = await TekRepository.GetNextAsync();
                await CreateAsync(items);
            }
            catch (Exception ex)
            {
                Logger.LogError(ex, $"Error on {nameof(TemporaryExposureKeyService)}");
                throw;
            }
        }
예제 #2
0
        public async Task RunAsync()
        {
            try
            {
#if !DEBUG
                KeyVaultKey = await KeyVault.GetKeyAsync(TekExportKeyVaultKeyUrl);

                SigInfo.VerificationKeyId      = KeyVaultKey.Key.Kid;
                SigInfo.VerificationKeyVersion = KeyVaultKey.KeyIdentifier.Version;
#endif

                var items = await TekRepository.GetNextAsync();

                foreach (var kv in items.GroupBy(_ => new { _.RollingStartUnixTimeSeconds, _.RollingPeriodSeconds }))
                {
                    await CreateAsync((ulong)kv.Key.RollingStartUnixTimeSeconds,
                                      (ulong)(kv.Key.RollingStartUnixTimeSeconds + kv.Key.RollingPeriodSeconds),
                                      kv.ToArray());
                }
            }
            catch (Exception ex)
            {
                Logger.LogError(ex, $"Error on {nameof(TemporaryExposureKeyService)}");
                throw;
            }
        }
예제 #3
0
        public async Task RunAsync()
        {
            try
            {
                Logger.LogInformation($"start {nameof(RunAsync)}");
                var items = await TekRepository.GetNextAsync();

                foreach (var kv in items.GroupBy(_ => new {
                    RollingStartUnixTimeSeconds = _.GetRollingStartUnixTimeSeconds(),
                    RollingPeriodSeconds = _.GetRollingPeriodSeconds(),
                    _.Region
                }))
                {
                    // Security considerations: Random Order TemporaryExposureKey
                    var sorted = kv.OrderBy(_ => RandomNumberGenerator.GetInt32(int.MaxValue));
                    await CreateAsync((ulong)kv.Key.RollingStartUnixTimeSeconds,
                                      (ulong)(kv.Key.RollingStartUnixTimeSeconds + kv.Key.RollingPeriodSeconds),
                                      kv.Key.Region,
                                      sorted.ToArray());
                }
            }
            catch (Exception ex)
            {
                Logger.LogError(ex, $"Error on {nameof(TemporaryExposureKeyExportBatchService)}");
                throw;
            }
        }
예제 #4
0
 public async Task RunAsync()
 {
     try
     {
         var items = await TekRepository.GetNextAsync();
         await CreateAsync(items);
     }
     catch (Exception ex)
     {
         Logger.LogError(ex, $"Error on {nameof(TemporaryExposureKeyService)}");
         throw;
     }
 }
        public async Task RunAsync()
        {
            try
            {
                Logger.LogInformation($"start {nameof(RunAsync)}");
                var batchTimestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
                var items          = await TekRepository.GetNextAsync();

                foreach (var kv in items.GroupBy(_ => new
                {
                    RollingStartUnixTimeSeconds = _.GetRollingStartUnixTimeSeconds(),
                    RollingPeriodSeconds = _.GetRollingPeriodSeconds()
                }))
                {
                    var batchNum = (int)await Sequence.GetNextAsync(SequenceName, 1);

                    batchTimestamp++;
                    foreach (var region in Regions)
                    {
                        // Security considerations: Random Order TemporaryExposureKey
                        var sorted = kv
                                     .OrderBy(_ => RandomNumberGenerator.GetInt32(int.MaxValue));
                        await CreateAsync((ulong)kv.Key.RollingStartUnixTimeSeconds,
                                          (ulong)(kv.Key.RollingStartUnixTimeSeconds + kv.Key.RollingPeriodSeconds),
                                          region,
                                          batchNum,
                                          batchTimestamp,
                                          sorted.ToArray());
                    }

                    foreach (var key in kv)
                    {
                        key.Exported = true;
                        await TekRepository.UpsertAsync(key);
                    }
                }

                // Write Export Files json
                var models = await TekExportRepository.GetKeysAsync(0);

                await BlobService.WriteFilesJsonAsync(models);
            }
            catch (Exception ex)
            {
                Logger.LogError(ex, $"Error on {nameof(TemporaryExposureKeyExportBatchService)}");
                throw;
            }
        }
        public async Task RunAsync()
        {
            try
            {
                var items = await TekRepository.GetNextAsync();

                foreach (var kv in items.GroupBy(_ => new { _.RollingStartUnixTimeSeconds, _.RollingPeriodSeconds, _.Region }))
                {
                    await CreateAsync((ulong)kv.Key.RollingStartUnixTimeSeconds,
                                      (ulong)(kv.Key.RollingStartUnixTimeSeconds + kv.Key.RollingPeriodSeconds),
                                      kv.Key.Region,
                                      kv.ToArray());
                }
            }
            catch (Exception ex)
            {
                Logger.LogError(ex, $"Error on {nameof(TemporaryExposureKeyService)}");
                throw;
            }
        }
        public async Task RunAsync()
        {
            try
            {
#if DEBUG
#else
                var keyVaultKey = await KeyVault.GetKeyAsync(TekExportKeyVaultKeyUrl);

                SigInfo.VerificationKeyId      = keyVaultKey.Key.Kid;
                SigInfo.VerificationKeyVersion = keyVaultKey.KeyIdentifier.Version;
#endif

                var items = await TekRepository.GetNextAsync();
                await CreateAsync(items);
            }
            catch (Exception ex)
            {
                Logger.LogError(ex, $"Error on {nameof(TemporaryExposureKeyService)}");
                throw;
            }
        }
예제 #8
0
        public async Task RunAsync()
        {
            var items = await TekRepository.GetNextAsync();

            await CreateAsync(items);
        }