public override bool Add(TicketCacheEntry entry) { var cacheEntry = new CacheEntry(entry.Computed, entry.Value, this.Logger); if (entry.Expires > DateTimeOffset.UtcNow) { cacheEntry.MarkLifetime(entry.Expires, entry.RenewUntil); } bool added = false; if (this.BlockUpdates) { var got = this.GetInternal(cacheEntry.Key); if (got == null) { added = this.cache.TryAdd(cacheEntry.Key, cacheEntry); } } else { this.cache.AddOrUpdate(cacheEntry.Key, cacheEntry, (_, __) => cacheEntry); added = true; } return(added); }
public async Task <bool> Add(TicketCacheEntry entry) { var cacheEntry = new CacheEntry(entry.Computed, entry.Value, logger); var lifetime = entry.Expires - DateTimeOffset.UtcNow; if (lifetime > TimeSpan.Zero) { cacheEntry.MarkLifetime(lifetime); } bool added = false; if (BlockUpdates) { var got = await GetInternal(cacheEntry.Key); if (got == null) { added = cache.TryAdd(cacheEntry.Key, cacheEntry); } } else { cache.AddOrUpdate(cacheEntry.Key, cacheEntry, (_, __) => cacheEntry); added = true; } return(added); }
public Task <object> Get(string key, string container = null) { if (cache.TryGetValue(TicketCacheEntry.GenerateKey(key: key, container: container), out CacheEntry entry)) { return(Task.FromResult(entry.Value)); } return(Task.FromResult <object>(null)); }
public override ValueTask <bool> AddAsync(TicketCacheEntry entry) { if (this.Add(entry)) { return(new ValueTask <bool>(true)); } return(new ValueTask <bool>(false)); }
public Task <bool> Contains(TicketCacheEntry entry) { if (!CacheRegions.TryGetValue(entry.Container, out ObjectCache cache)) { return(Task.FromResult(false)); } return(Task.FromResult(cache.Contains(entry.Key))); }
public async Task <bool> Add(TicketCacheEntry entry) { if (entry == null) { throw new ArgumentNullException(nameof(entry)); } return(await this.cache.AddAsync(entry).ConfigureAwait(true)); }
public async Task <bool> Add(TicketCacheEntry entry) { if (await Contains(entry)) { return(false); } await cache.Add(entry); return(true); }
public Task <bool> Add(TicketCacheEntry entry) { var tokenCache = GetOrCreate(entry.Container); var cacheItem = new CacheItem(entry.Key, entry.Key, entry.Container); var result = tokenCache.Add( cacheItem, new CacheItemPolicy { AbsoluteExpiration = entry.Expires } ); return(Task.FromResult(result)); }
public Task <bool> Add(TicketCacheEntry entry) { bool added = false; var cacheEntry = new CacheEntry(cache, entry.Computed, entry.Value, logger); if (cache.TryAdd(cacheEntry.Key, cacheEntry)) { var lifetime = entry.Expires - DateTimeOffset.UtcNow; if (lifetime > TimeSpan.Zero) { cacheEntry.BeginTriggerDelay(lifetime, cancel.Token); added = true; } } return(Task.FromResult(added)); }
protected virtual async Task Validate(DecryptedKrbApReq decryptedToken) { if (decryptedToken == null) { throw new ArgumentNullException(nameof(decryptedToken)); } var sequence = this.ObscureSequence(decryptedToken.Authenticator.SequenceNumber ?? 0); var container = this.ObscureContainer(decryptedToken.Ticket.CRealm); var entry = new TicketCacheEntry { Key = sequence, Container = container, Expires = decryptedToken.Ticket.EndTime }; var replayDetected = true; var detectReplay = this.ValidateAfterDecrypt.HasFlag(ValidationActions.Replay); if (!detectReplay) { decryptedToken.Validate(this.ValidateAfterDecrypt); replayDetected = false; } else if (!await this.tokenCache.Contains(entry).ConfigureAwait(true)) { decryptedToken.Validate(this.ValidateAfterDecrypt); if (await this.tokenCache.Add(entry).ConfigureAwait(true)) { replayDetected = false; } } if (replayDetected) { throw new ReplayException($"Replay detected in container '{entry.Container}' with key {entry.Key}."); } }
protected virtual async Task Validate(DecryptedData decryptedToken) { var sequence = ObscureSequence(decryptedToken.Authenticator.SequenceNumber); var container = ObscureContainer(decryptedToken.Ticket.CRealm); var entry = new TicketCacheEntry { Key = sequence, Container = container, Expires = decryptedToken.Ticket.EndTime }; var replayDetected = true; var detectReplay = ValidateAfterDecrypt.HasFlag(ValidationActions.Replay); if (!detectReplay) { decryptedToken.Validate(ValidateAfterDecrypt); replayDetected = false; } else if (!(await TokenCache.Contains(entry))) { decryptedToken.Validate(ValidateAfterDecrypt); if (await TokenCache.Add(entry)) { replayDetected = false; } } if (replayDetected) { throw new ReplayException($"Replay detected in container '{entry.Container}' with key {entry.Key}."); } }
public async Task <bool> Add(TicketCacheEntry entry) { return(await cache.Add(entry)); }
public async Task <bool> Contains(TicketCacheEntry entry) { return(await cache.Contains(entry)); }
public override ValueTask <bool> ContainsAsync(TicketCacheEntry entry) { var exists = this.cache.ContainsKey(entry.Computed); return(new ValueTask <bool>(exists)); }
public override bool Contains(TicketCacheEntry entry) { return(this.cache.ContainsKey(entry.Computed)); }
public Task <bool> Contains(TicketCacheEntry entry) { var exists = cache.ContainsKey(entry.Computed); return(Task.FromResult(exists)); }
public abstract bool Contains(TicketCacheEntry entry);
public abstract ValueTask <bool> ContainsAsync(TicketCacheEntry entry);
public abstract bool Add(TicketCacheEntry entry);
public abstract ValueTask <bool> AddAsync(TicketCacheEntry entry);
public async Task <bool> Contains(TicketCacheEntry entry) { var got = await this.cache.GetCacheItemAsync(entry?.Key).ConfigureAwait(true); return(got != null); }
public async Task <bool> Contains(TicketCacheEntry entry) { var got = await cache.Get(entry.Key); return(got != null); }
public override object GetCacheItem(string key, string container = null) { var entryKey = TicketCacheEntry.GenerateKey(key: key, container: container); return(this.GetInternal(entryKey)); }
public Task <object> Get(string key, string container = null) { var entryKey = TicketCacheEntry.GenerateKey(key: key, container: container); return(GetInternal(entryKey)); }