mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
346 lines
13 KiB
C#
346 lines
13 KiB
C#
//-----------------------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
namespace System.ServiceModel.Security
|
|
{
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Runtime;
|
|
using System.ServiceModel.Diagnostics;
|
|
using System.ServiceModel.Security.Tokens;
|
|
using System.Xml;
|
|
|
|
// This is the in-memory cache used for caching SCTs
|
|
sealed class SecurityContextTokenCache : TimeBoundedCache
|
|
{
|
|
// if there are less than lowWaterMark entries, no purging is done
|
|
static int lowWaterMark = 50;
|
|
// frequency of purging the cache of stale entries
|
|
// this is set to 10 mins as SCTs are expected to have long lifetimes
|
|
static TimeSpan purgingInterval = TimeSpan.FromMinutes(10);
|
|
static double pruningFactor = 0.20;
|
|
bool replaceOldestEntries = true;
|
|
static SctEffectiveTimeComparer sctEffectiveTimeComparer = new SctEffectiveTimeComparer();
|
|
TimeSpan clockSkew;
|
|
|
|
public SecurityContextTokenCache( int capacity, bool replaceOldestEntries )
|
|
: this( capacity, replaceOldestEntries, SecurityProtocolFactory.defaultMaxClockSkew )
|
|
{
|
|
}
|
|
|
|
public SecurityContextTokenCache(int capacity, bool replaceOldestEntries, TimeSpan clockSkew)
|
|
: base(lowWaterMark, capacity, null, PurgingMode.TimerBasedPurge, purgingInterval, true)
|
|
|
|
{
|
|
this.replaceOldestEntries = replaceOldestEntries;
|
|
this.clockSkew = clockSkew;
|
|
}
|
|
|
|
public void AddContext(SecurityContextSecurityToken token)
|
|
{
|
|
TryAddContext(token, true);
|
|
}
|
|
|
|
public bool TryAddContext(SecurityContextSecurityToken token)
|
|
{
|
|
return TryAddContext(token, false);
|
|
}
|
|
|
|
bool TryAddContext(SecurityContextSecurityToken token, bool throwOnFailure)
|
|
{
|
|
if (token == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("token");
|
|
}
|
|
|
|
if ( !SecurityUtils.IsCurrentlyTimeEffective( token.ValidFrom, token.ValidTo, this.clockSkew ) )
|
|
{
|
|
if (token.KeyGeneration == null)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SR.GetString(SR.SecurityContextExpiredNoKeyGeneration, token.ContextId));
|
|
else
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SR.GetString(SR.SecurityContextExpired, token.ContextId, token.KeyGeneration.ToString()));
|
|
}
|
|
|
|
if ( !SecurityUtils.IsCurrentlyTimeEffective( token.KeyEffectiveTime, token.KeyExpirationTime, this.clockSkew ) )
|
|
{
|
|
if (token.KeyGeneration == null)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SR.GetString(SR.SecurityContextKeyExpiredNoKeyGeneration, token.ContextId));
|
|
else
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SR.GetString(SR.SecurityContextKeyExpired, token.ContextId, token.KeyGeneration.ToString()));
|
|
}
|
|
|
|
object hashKey = GetHashKey(token.ContextId, token.KeyGeneration);
|
|
bool wasTokenAdded = base.TryAddItem(hashKey, (SecurityContextSecurityToken)token.Clone(), false);
|
|
if (!wasTokenAdded)
|
|
{
|
|
if (throwOnFailure)
|
|
{
|
|
if (token.KeyGeneration == null)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ContextAlreadyRegisteredNoKeyGeneration, token.ContextId)));
|
|
else
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ContextAlreadyRegistered, token.ContextId, token.KeyGeneration.ToString())));
|
|
}
|
|
}
|
|
return wasTokenAdded;
|
|
}
|
|
|
|
object GetHashKey(UniqueId contextId, UniqueId generation)
|
|
{
|
|
if (generation == null)
|
|
{
|
|
return contextId;
|
|
}
|
|
else
|
|
{
|
|
return new ContextAndGenerationKey(contextId, generation);
|
|
}
|
|
}
|
|
|
|
public void ClearContexts()
|
|
{
|
|
base.ClearItems();
|
|
}
|
|
|
|
public SecurityContextSecurityToken GetContext(UniqueId contextId, UniqueId generation)
|
|
{
|
|
if (contextId == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("contextId");
|
|
}
|
|
object hashKey = GetHashKey(contextId, generation);
|
|
SecurityContextSecurityToken sct = (SecurityContextSecurityToken)base.GetItem(hashKey);
|
|
return sct != null ? (SecurityContextSecurityToken)sct.Clone() : null;
|
|
}
|
|
|
|
public void RemoveContext(UniqueId contextId, UniqueId generation, bool throwIfNotPresent)
|
|
{
|
|
if (contextId == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("contextId");
|
|
}
|
|
object hashKey = GetHashKey(contextId, generation);
|
|
if (!base.TryRemoveItem(hashKey) && throwIfNotPresent)
|
|
{
|
|
if (generation == null)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ContextNotPresentNoKeyGeneration, contextId)));
|
|
else
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ContextNotPresent, contextId, generation.ToString())));
|
|
}
|
|
}
|
|
|
|
ArrayList GetMatchingKeys(UniqueId contextId)
|
|
{
|
|
if (contextId == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("contextId");
|
|
}
|
|
ArrayList matchingKeys = new ArrayList(2);
|
|
|
|
bool lockHeld = false;
|
|
try
|
|
{
|
|
try { }
|
|
finally
|
|
{
|
|
base.CacheLock.AcquireReaderLock(-1);
|
|
lockHeld = true;
|
|
}
|
|
foreach (object key in this.Entries.Keys)
|
|
{
|
|
bool isMatch = false;
|
|
if (key is UniqueId)
|
|
{
|
|
isMatch = (((UniqueId)key) == contextId);
|
|
}
|
|
else
|
|
{
|
|
isMatch = (((ContextAndGenerationKey)key).ContextId == contextId);
|
|
}
|
|
if (isMatch)
|
|
{
|
|
matchingKeys.Add(key);
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
if (lockHeld)
|
|
{
|
|
base.CacheLock.ReleaseReaderLock();
|
|
}
|
|
}
|
|
return matchingKeys;
|
|
}
|
|
|
|
public void RemoveAllContexts(UniqueId contextId)
|
|
{
|
|
ArrayList matchingKeys = GetMatchingKeys(contextId);
|
|
for (int i = 0; i < matchingKeys.Count; ++i)
|
|
{
|
|
base.TryRemoveItem(matchingKeys[i]);
|
|
}
|
|
|
|
}
|
|
|
|
public void UpdateContextCachingTime(SecurityContextSecurityToken token, DateTime expirationTime)
|
|
{
|
|
if (token.ValidTo <= expirationTime.ToUniversalTime())
|
|
{
|
|
return;
|
|
}
|
|
base.TryReplaceItem(GetHashKey(token.ContextId, token.KeyGeneration), token, expirationTime);
|
|
}
|
|
|
|
public Collection<SecurityContextSecurityToken> GetAllContexts(UniqueId contextId)
|
|
{
|
|
ArrayList matchingKeys = GetMatchingKeys(contextId);
|
|
|
|
Collection<SecurityContextSecurityToken> matchingContexts = new Collection<SecurityContextSecurityToken>();
|
|
for (int i = 0; i < matchingKeys.Count; ++i)
|
|
{
|
|
SecurityContextSecurityToken token = base.GetItem(matchingKeys[i]) as SecurityContextSecurityToken;
|
|
if (token != null)
|
|
{
|
|
matchingContexts.Add(token);
|
|
}
|
|
}
|
|
return matchingContexts;
|
|
}
|
|
|
|
protected override ArrayList OnQuotaReached(Hashtable cacheTable)
|
|
{
|
|
if (!this.replaceOldestEntries)
|
|
{
|
|
SecurityTraceRecordHelper.TraceSecurityContextTokenCacheFull(this.Capacity, 0);
|
|
return base.OnQuotaReached(cacheTable);
|
|
}
|
|
else
|
|
{
|
|
List<SecurityContextSecurityToken> tokens = new List<SecurityContextSecurityToken>(cacheTable.Count);
|
|
foreach (IExpirableItem value in cacheTable.Values)
|
|
{
|
|
SecurityContextSecurityToken token = (SecurityContextSecurityToken)ExtractItem(value);
|
|
tokens.Add(token);
|
|
}
|
|
tokens.Sort(sctEffectiveTimeComparer);
|
|
int pruningAmount = (int)(((double)this.Capacity) * pruningFactor);
|
|
pruningAmount = pruningAmount <= 0 ? this.Capacity : pruningAmount;
|
|
ArrayList keys = new ArrayList(pruningAmount);
|
|
for (int i = 0; i < pruningAmount; ++i)
|
|
{
|
|
keys.Add(GetHashKey(tokens[i].ContextId, tokens[i].KeyGeneration));
|
|
OnRemove(tokens[i]);
|
|
}
|
|
SecurityTraceRecordHelper.TraceSecurityContextTokenCacheFull(this.Capacity, pruningAmount);
|
|
return keys;
|
|
}
|
|
}
|
|
|
|
sealed class SctEffectiveTimeComparer : IComparer<SecurityContextSecurityToken>
|
|
{
|
|
public int Compare(SecurityContextSecurityToken sct1, SecurityContextSecurityToken sct2)
|
|
{
|
|
if (sct1 == sct2)
|
|
{
|
|
return 0;
|
|
}
|
|
if (sct1.ValidFrom.ToUniversalTime() < sct2.ValidFrom.ToUniversalTime())
|
|
{
|
|
return -1;
|
|
}
|
|
else if (sct1.ValidFrom.ToUniversalTime() > sct2.ValidFrom.ToUniversalTime())
|
|
{
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
// compare the key effective times
|
|
if (sct1.KeyEffectiveTime.ToUniversalTime() < sct2.KeyEffectiveTime.ToUniversalTime())
|
|
{
|
|
return -1;
|
|
}
|
|
else if (sct1.KeyEffectiveTime.ToUniversalTime() > sct2.KeyEffectiveTime.ToUniversalTime())
|
|
{
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
protected override void OnRemove(object item)
|
|
{
|
|
((IDisposable)item).Dispose();
|
|
base.OnRemove(item);
|
|
}
|
|
|
|
struct ContextAndGenerationKey
|
|
{
|
|
UniqueId contextId;
|
|
UniqueId generation;
|
|
|
|
public ContextAndGenerationKey(UniqueId contextId, UniqueId generation)
|
|
{
|
|
Fx.Assert(contextId != null && generation != null, "");
|
|
this.contextId = contextId;
|
|
this.generation = generation;
|
|
}
|
|
|
|
public UniqueId ContextId
|
|
{
|
|
get
|
|
{
|
|
return this.contextId;
|
|
}
|
|
}
|
|
|
|
public UniqueId Generation
|
|
{
|
|
get
|
|
{
|
|
return this.generation;
|
|
}
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
return this.contextId.GetHashCode() ^ this.generation.GetHashCode();
|
|
}
|
|
|
|
public override bool Equals(object obj)
|
|
{
|
|
if (obj is ContextAndGenerationKey)
|
|
{
|
|
ContextAndGenerationKey key2 = ((ContextAndGenerationKey)obj);
|
|
return (key2.ContextId == this.contextId && key2.Generation == this.generation);
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public static bool operator ==(ContextAndGenerationKey a, ContextAndGenerationKey b)
|
|
{
|
|
if (object.ReferenceEquals(a, null))
|
|
{
|
|
return object.ReferenceEquals(b, null);
|
|
}
|
|
|
|
return (a.Equals(b));
|
|
}
|
|
|
|
public static bool operator !=(ContextAndGenerationKey a, ContextAndGenerationKey b)
|
|
{
|
|
return !(a == b);
|
|
}
|
|
}
|
|
}
|
|
}
|