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 }); }
public async Task ValidateShouldReturnTrueOnValidTIHJwt() { var validToken = "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOiIxNTk5NzUzMTk5IiwiYWNjZXNzX3Rva2VuIjoidGVzdF9hY2Nlc3NfdG9rZW4iLCJpZCI6IjAifQ.osL8kyPx90gUapZzz6Iv-H8DPwgtJTMSKTJA1VtMirU"; var validExp = _DateTimeProvider.Now().AddHours(_ClaimLifetimeHours - .1).ToUnixTimeU64(); var testClaims = new Dictionary <string, string> { { "id", "0" }, { "exp", validExp.ToString() }, { "access_token", validToken } }; _Server.Reset(); _Server.Given( Request.Create() .WithHeader("Authorization", "Bearer " + validToken) .WithPath("/ggdghornl_test/oauth2/v1/verify").UsingGet() ) .RespondWith( Response.Create() .WithStatusCode(200) .WithHeader("Content-Type", "application/json") .WithBody("{\"audience\":1234}") ); Assert.True(await _JwtClaimValidator.ValidateAsync(testClaims)); }
public async Task <SnapshotEksInputResult> Execute(DateTime snapshotStart) { _Logger.LogDebug("Snapshot publishable TEKs."); _SnapshotStart = snapshotStart; var stopwatchStart = _DateTimeProvider.Now(); const int pagesize = 10000; var index = 0; using var tx = _WorkflowDbContext.BeginTransaction(); var page = ReadTeksFromWorkflow(index, pagesize); while (page.Count > 0) { var db = _PublishingDbContextFactory(); await db.BulkInsertAsync2(page.ToList(), new SubsetBulkArgs()); index += page.Count; page = ReadTeksFromWorkflow(index, pagesize); } var result = new SnapshotEksInputResult { SnapshotSeconds = (_DateTimeProvider.Now() - stopwatchStart).TotalSeconds, TekInputCount = index }; _Logger.LogInformation($"TEKs to publish - Count:{index}."); return(result); }
/// <summary> /// Generate Icc with configuration length and A-Z, 0-9 characters /// </summary> /// <param name="userId"></param> /// <param name="save"></param> /// <param name="batchId"></param> /// <returns></returns> public async Task <InfectionConfirmationCodeEntity> GenerateIcc(string userId, string batchId) { var length = Convert.ToInt32(_Configuration.GetSection("IccConfig:Code:Length").Value); var generatedIcc = _RandomGenerator.GenerateToken(length); var icc = new InfectionConfirmationCodeEntity { Code = generatedIcc, GeneratedBy = userId, Created = _DateTimeProvider.Now(), BatchId = batchId }; await _DbContext.InfectionConfirmationCodes.AddAsync(icc); return(icc); }
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); }
public async Task Execute(HttpContext httpContext) { //if (httpContext.Request.Headers.TryGetValue("if-none-match", out var etagValue)) //{ // httpContext.Response.ContentLength = 0; // httpContext.Response.StatusCode = 400; //} var now = _DateTimeProvider.Now(); var e = await _ContentDb.SafeGetLatestContent(ContentTypes.Manifest, now); if (e == null) { httpContext.Response.StatusCode = 200; httpContext.Response.ContentLength = 0; return; } //if (etagValue == content.PublishingId) //{ // httpContext.Response.ContentLength = 0; // httpContext.Response.StatusCode = 304; // return; //} httpContext.Response.Headers.Add("etag", e.PublishingId); httpContext.Response.Headers.Add("last-modified", e.Release.ToUniversalTime().ToString("r")); httpContext.Response.Headers.Add("content-type", e.ContentTypeName); httpContext.Response.Headers.Add("cache-control", _HttpResponseHeaderConfig.ManifestCacheControl); httpContext.Response.Headers.Add("x-vws-signed", true.ToString()); httpContext.Response.StatusCode = 200; httpContext.Response.ContentLength = e.Content?.Length ?? throw new InvalidOperationException("SignedContent empty."); await httpContext.Response.Body.WriteAsync(e.Content); }
public async Task Execute(WorkflowArgs args) { var e = args.ToEntity(); e.Created = _UtcDateTimeProvider.Now(); await _DbContextProvider.Current.AddAsync(e); }
public ManifestEntity Execute() { _DbContext.BeginTransaction(); //TODO should be using WebDbContentProvider var now = _DateTimeProvider.Now(); var releaseCutoff = now - TimeSpan.FromHours(_GaenContentConfig.ManifestLifetimeHours); var e = _DbContext.ManifestContent .Where(x => x.Release > releaseCutoff) .OrderByDescending(x => x.Release) .Take(1) .SingleOrDefault(); if (e != null) { return(e); } _DbContext.BulkDelete(_DbContext.Set <ManifestEntity>().ToList()); //TODO execute sql. var content = JsonConvert.SerializeObject(_ManifestBuilder.Execute()); var bytes = Encoding.UTF8.GetBytes(content); e = new ManifestEntity { Release = now, ContentTypeName = ContentHeaderValues.Json, Content = bytes, }; e.PublishingId = _PublishingId.Create(e.Content); _DbContext.ManifestContent.Add(e); _DbContext.SaveAndCommit(); return(e); }
public ContentDatabaseCreateCommand(ContentDbContext dbContextProvider, IUtcDateTimeProvider dateTimeProvider, ContentValidator validator, ContentInsertDbCommand insertDbCommand) { _DbContextProvider = dbContextProvider ?? throw new ArgumentNullException(nameof(dbContextProvider)); _DateTimeProvider = dateTimeProvider ?? throw new ArgumentNullException(nameof(dateTimeProvider)); _Validator = validator ?? throw new ArgumentNullException(nameof(validator)); _InsertDbCommand = insertDbCommand ?? throw new ArgumentNullException(nameof(insertDbCommand)); _Snapshot = _DateTimeProvider.Now(); }
public async Task AddExampleContent() { await using var tx = await _DbContextProvider.Database.BeginTransactionAsync(); await Write( new ResourceBundleArgs { Release = _DateTimeProvider.Now(), Text = new Dictionary <string, Dictionary <string, string> > { { "en-GB", new Dictionary <string, string>() { { "InfectedMessage", "You're possibly infected" } } }, { "nl-NL", new Dictionary <string, string> { { "InfectedMessage", "U bent mogelijk geinvecteerd" } } } } } ); var rbd = ReadFromResource <ResourceBundleArgs>("RiskCalcDefaults.json"); rbd.Release = _DateTimeProvider.Now(); await Write(rbd); var rcd = ReadFromResource <RiskCalculationConfigArgs>("RiskCalcDefaults.json"); rcd.Release = _DateTimeProvider.Now(); await Write(rcd); var acd = ReadFromResource <AppConfigArgs>("AppConfigDefaults.json"); acd.Release = _DateTimeProvider.Now(); await Write(acd); _DbContextProvider.SaveAndCommit(); }
public string Next() { return(_JwtService.Generate( _DateTimeProvider.Now().AddSeconds(30).ToUnixTimeU64(), //TODO setting? new Dictionary <string, object> { [PayloadElement] = Guid.NewGuid().ToString() // make polltoken unique //TODO use RNG here instead cos index clustering })); }
public string Next() { return(_JwtService.Generate( _DateTimeProvider.Now().AddSeconds(30).ToUnixTimeU64(), new Dictionary <string, object> { [PayloadElement] = Guid.NewGuid().ToString() })); }
public string GenerateToken() { return(_JwtService.Generate( _DateTimeProvider.Now().AddSeconds(30).ToUnixTime(), new Dictionary <string, object> { [PayloadElement] = Guid.NewGuid().ToString() // make polltoken unique })); }
public async Task Execute() { var now = _UtcDateTimeProvider.Now(); var hushNow = _Context.Set <KeyReleaseWorkflowState>() .Where(x => x.Created < now - TimeSpan.FromDays(_GaenContentConfig.KeysLastSecretLifetimeDays)) .ToArray(); await _Context.BulkDeleteAsync(hushNow); }
public RiskCalculationContentEntity Execute() { var now = _DateTimeProvider.Now(); return(_DbConfig.Set <RiskCalculationContentEntity>() .Where(x => x.Release <= now) .OrderByDescending(x => x.Release) .Take(1) .SingleOrDefault()); }
public async Task <EksEngineResult> Execute() { if (_Fired) { throw new InvalidOperationException("One use only."); } _Fired = true; _Logger.LogInformation("Started - JobName:{_JobName}", _JobName); if (!WindowsIdentityStuff.CurrentUserIsAdministrator()) //TODO remove warning when UAC is not in play { _Logger.LogWarning("{JobName} started WITHOUT elevated privileges - errors may occur when signing content.", _JobName); } _EksEngineResult.Started = _DateTimeProvider.Snapshot; //Not strictly true but we need the jobname for the dispose. await ClearJobTables(); var snapshotResult = await _Snapshotter.Execute(_EksEngineResult.Started); _EksEngineResult.InputCount = snapshotResult.TekInputCount; _EksEngineResult.SnapshotSeconds = snapshotResult.SnapshotSeconds; _EksEngineResult.TransmissionRiskNoneCount = await GetTransmissionRiskNoneCount(); if (snapshotResult.TekInputCount != 0) { await Stuff(); await BuildOutput(); await CommitResults(); } _EksEngineResult.TotalSeconds = (_DateTimeProvider.Now() - _EksEngineResult.Started).TotalSeconds; _EksEngineResult.EksInfo = _EksResults.ToArray(); _Logger.LogInformation("Reconciliation - Teks in EKSs matches usable input and stuffing - Delta:{ReconcileOutputCount}", _EksEngineResult.ReconcileOutputCount); _Logger.LogInformation("Reconciliation - Teks in EKSs matches output count - Delta:{ReconcileEksSumCount}", _EksEngineResult.ReconcileEksSumCount); _Logger.LogInformation("{JobName} complete.", _JobName); return(_EksEngineResult); }
public async Task Execute() { var now = _UtcDateTimeProvider.Now(); var timeToDie = _DbConfig.Set <ExposureKeySetContentEntity>() .Where(x => x.Release < now - TimeSpan.FromDays(_GaenContentConfig.ExposureKeySetLifetimeDays)) .ToList(); await _DbConfig.BulkDeleteAsync(timeToDie); }
public async Task Execute() { var now = _UtcDateTimeProvider.Now(); var hushNow = _DbConfig.Current.Set <KeysFirstWorkflowEntity>() .Where(x => x.Created < now - TimeSpan.FromDays(_AgConfig.WorkflowSecretLifetimeDays)) .ToArray(); await _DbConfig.Current.BulkDeleteAsync(hushNow); }
public void Execute(string token) { var e = new TokenFirstWorkflowEntity { Created = _DateTimeProvider.Now(), SecretToken = token, State = TokenFirstWorkflowState.Unauthorised }; _DbContextProvider.Current.TokenFirstWorkflows.Add(e); }
public string Execute() { var now = _DateTimeProvider.Now(); return(_DbConfig.Current.Set <RivmAdviceContentEntity>() .Where(x => x.Release <= now) .OrderByDescending(x => x.Release) .Take(1) .Select(x => x.PublishingId) .SingleOrDefault()); }
public void Execute() { var expired = _DateTimeProvider.Now() - TimeSpan.FromDays(_TokenFirstWorkflowConfig.WorkflowWriteWindowDurationMinutes); _DbContextProvider.BeginTransaction(); var q = _DbContextProvider.Current.TokenFirstWorkflows .Where(x => x.State == TokenFirstWorkflowState.Receiving && x.ReceivingStarted < expired); _DbContextProvider.Current.TokenFirstWorkflows.RemoveRange(q); _DbContextProvider.Current.SaveChanges(); _DbContextProvider.SaveAndCommit(); }
public async Task <ManifestEntity?> Execute(string _) { var e = new ManifestEntity { Release = _DateTimeProvider.Now(), }; var content = _ManifestBuilder.Execute(); var formatter = new StandardContentEntityFormatter(new ZippedSignedContentFormatter(_Signer), new StandardPublishingIdFormatter(_Signer)); await formatter.Fill(e, content); return(e); }
public async Task <ManifestContent> Execute() { var now = _DateTimeProvider.Now(); var lo = now - TimeSpan.FromDays(_GaenContentConfig.ExposureKeySetLifetimeDays); return(new ManifestContent { ExposureKeySets = await _ContentDbContext.SafeGetActiveContentIdList <ExposureKeySetContentEntity>(lo, now), RiskCalculationParameters = await _ContentDbContext.SafeGetLatestContentId(ContentTypes.RiskCalculationParameters, now), AppConfig = await _ContentDbContext.SafeGetLatestContentId(ContentTypes.AppConfig, now) }); }
public void Execute() { var expired = _DateTimeProvider.Now() - TimeSpan.FromDays(_TokenFirstWorkflowConfig.WorkflowTokenTtlDays); _DbContextProvider.BeginTransaction(); var q = _DbContextProvider.Current.TokenFirstWorkflows .Where(x => x.State == TokenFirstWorkflowState.Unauthorised && x.Created < expired); _DbContextProvider.Current.TokenFirstWorkflows.RemoveRange(q); _DbContextProvider.Current.SaveChanges(); _DbContextProvider.SaveAndCommit(); }
public ExposureKeySetBatchJobMk2(/*IExposureKeySetBatchJobConfig jobConfig,*/ IGaenContentConfig gaenContentConfig, IExposureKeySetBuilder builder, WorkflowDbContext workflowDbContext, ExposureContentDbContext contentDbContext, IUtcDateTimeProvider dateTimeProvider, IPublishingId publishingId) { //_JobConfig = jobConfig; _GaenContentConfig = gaenContentConfig; _SetBuilder = builder; _WorkflowDbContext = workflowDbContext; _ContentDbContext = contentDbContext; _PublishingId = publishingId; _Used = new List <EksCreateJobInputEntity>(_GaenContentConfig.ExposureKeySetCapacity); // _Start = dateTimeProvider.Now(); JobName = $"ExposureKeySetsJob_{_Start:u}".Replace(" ", "_").Replace(":", "_"); }
public void Execute(string secretToken) { var e = new TokenFirstWorkflowEntity { Created = _DateTimeProvider.Now(), SecretToken = secretToken, State = TokenFirstWorkflowState.Unauthorised }; //TODO secret token already exists... _DbContextProvider.Current.TokenFirstWorkflows.AddAsync(e); _DbContextProvider.Current.SaveChangesAsync(); }
public ExposureKeySetBatchJobMk2(/*IExposureKeySetBatchJobConfig jobConfig,*/ IGaenContentConfig gaenContentConfig, IExposureKeySetBuilder builder, WorkflowDbContext workflowDbContext, PublishingJobDbContext publishingDbContext, ContentDbContext contentDbContext, IUtcDateTimeProvider dateTimeProvider, IPublishingId publishingId, ILogger <ExposureKeySetBatchJobMk2> logger) { //_JobConfig = jobConfig; _GaenContentConfig = gaenContentConfig ?? throw new ArgumentNullException(nameof(gaenContentConfig)); _SetBuilder = builder ?? throw new ArgumentNullException(nameof(builder)); _WorkflowDbContext = workflowDbContext ?? throw new ArgumentNullException(nameof(workflowDbContext)); _PublishingDbContext = publishingDbContext ?? throw new ArgumentNullException(nameof(publishingDbContext)); _ContentDbContext = contentDbContext ?? throw new ArgumentNullException(nameof(contentDbContext)); _PublishingId = publishingId; _Logger = logger ?? throw new ArgumentNullException(nameof(logger)); _Used = new List <EksCreateJobInputEntity>(_GaenContentConfig.ExposureKeySetCapacity); // _Start = dateTimeProvider.Now(); _JobName = $"ExposureKeySetsJob_{_Start:u}".Replace(" ", "_").Replace(":", "_"); }
public async Task Execute() { var now = _UtcDateTimeProvider.Now(); var timeToDie = _DbConfig.Set <ExposureKeySetContentEntity>() .Where(x => x.Release < now - TimeSpan.FromDays(_GaenContentConfig.ExposureKeySetLifetimeDays)) .ToList(); foreach (var i in timeToDie) { _Logger.LogInformation($"Deleting EKS - {i.PublishingId}."); } await _DbConfig.BulkDeleteAsync(timeToDie); }
public void Execute() { var expired = _DateTimeProvider.Now() - TimeSpan.FromMinutes(_KeysLastWorkflowConfig.AuthorisationWindowDurationMinutes); _DbContextProvider.BeginTransaction(); throw new NotImplementedException(); //var q = _DbContextProvider.KeysLastWorkflows // .Where(x => x.State == KeysLastWorkflowState.Receiving && x.AuthorisationWindowStart < expired); //_DbContextProvider.KeysLastWorkflows.RemoveRange(q); _DbContextProvider.SaveChanges(); _DbContextProvider.SaveAndCommit(); }
public string Generate(ClaimsPrincipal claimsPrincipal) { if (claimsPrincipal == null) { throw new ArgumentNullException(nameof(claimsPrincipal)); } var builder = CreateBuilder(); builder.AddClaim("exp", _DateTimeProvider.Now().AddHours(_IccPortalConfig.ClaimLifetimeHours).ToUnixTime()); builder.AddClaim("id", GetClaimValue(claimsPrincipal, ClaimTypes.NameIdentifier)); builder.AddClaim("email", GetClaimValue(claimsPrincipal, ClaimTypes.Email)); builder.AddClaim("access_token", GetClaimValue(claimsPrincipal, "http://schemas.u2uconsult.com/ws/2014/03/identity/claims/accesstoken")); builder.AddClaim("name", GetClaimValue(claimsPrincipal, "http://schemas.u2uconsult.com/ws/2014/04/identity/claims/displayname")); return(builder.Encode()); }