< Summary - CoreWCF Coverage — PR #1766

Information
Class: CoreWCF.Security.Tokens.SecurityContextSecurityToken
Assembly: CoreWCF.Primitives
File(s): /home/runner/work/CoreWCF/CoreWCF/src/CoreWCF.Primitives/src/CoreWCF/Security/Tokens/SecurityContextSecurityToken.cs
Line coverage
59%
Covered lines: 61
Uncovered lines: 42
Coverable lines: 103
Total lines: 282
Line coverage: 59.2%
Branch coverage
47%
Covered branches: 16
Total branches: 34
Branch coverage: 47%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Cyclomatic complexity NPath complexity Sequence coverage
.ctor(...)100%110%
.ctor(...)100%110%
.ctor(...)100%110%
.ctor(...)100%11100%
.ctor(...)100%110%
.ctor(...)0%220%
.ctor(...)100%110%
.ctor(...)100%110%
.ctor(...)50%22100%
GetBase64KeyString()0%220%
GetKeyBytes()100%110%
ToString()100%110%
Initialize(...)50%161684.61%
CanCreateKeyIdentifierClause()0%220%
CreateKeyIdentifierClause()100%22100%
MatchesKeyIdentifierClause(...)50%2266.66%
Clone()100%11100%
Dispose()75%4483.33%
ThrowIfDisposed()50%2266.66%

File(s)

/home/runner/work/CoreWCF/CoreWCF/src/CoreWCF.Primitives/src/CoreWCF/Security/Tokens/SecurityContextSecurityToken.cs

#LineLine coverage
 1// Licensed to the .NET Foundation under one or more agreements.
 2// The .NET Foundation licenses this file to you under the MIT license.
 3
 4using System;
 5using System.Collections.Generic;
 6using System.Collections.ObjectModel;
 7using System.Globalization;
 8using System.Xml;
 9using CoreWCF.IdentityModel;
 10using CoreWCF.IdentityModel.Policy;
 11using CoreWCF.IdentityModel.Tokens;
 12
 13namespace CoreWCF.Security.Tokens
 14{
 15    public class SecurityContextSecurityToken : SecurityToken, IDisposable, TimeBoundedCache.IExpirableItem
 16    {
 17        private DateTime _tokenEffectiveTime;
 18        private DateTime _tokenExpirationTime;
 19        private byte[] _key;
 20        private string _keyString;
 21        private ReadOnlyCollection<IAuthorizationPolicy> _authorizationPolicies;
 22        private ReadOnlyCollection<SecurityKey> _securityKeys;
 23        private readonly string _id;
 24        private bool _disposed = false;
 25
 26        public SecurityContextSecurityToken(UniqueId contextId, byte[] key, DateTime validFrom, DateTime validTo)
 027            : this(contextId, SecurityUtils.GenerateId(), key, validFrom, validTo)
 028        { }
 29
 30        public SecurityContextSecurityToken(UniqueId contextId, string id, byte[] key, DateTime validFrom, DateTime vali
 031            : this(contextId, id, key, validFrom, validTo, null)
 032        { }
 33
 34        public SecurityContextSecurityToken(UniqueId contextId, string id, byte[] key, DateTime validFrom, DateTime vali
 035            : base()
 36        {
 037            _id = id;
 038            Initialize(contextId, key, validFrom, validTo, authorizationPolicies, false, null, validFrom, validTo);
 039        }
 40
 41        public SecurityContextSecurityToken(UniqueId contextId, string id, byte[] key, DateTime validFrom, DateTime vali
 1042            : base()
 43        {
 1044            _id = id;
 1045            Initialize(contextId, key, validFrom, validTo, authorizationPolicies, false, keyGeneration, keyEffectiveTime
 1046        }
 47
 48        internal SecurityContextSecurityToken(SecurityContextSecurityToken sourceToken, string id)
 049            : this(sourceToken, id, sourceToken._key, sourceToken.KeyGeneration, sourceToken.KeyEffectiveTime, sourceTok
 50        {
 051        }
 52
 53        internal SecurityContextSecurityToken(SecurityContextSecurityToken sourceToken, string id, byte[] key, UniqueId 
 054            : base()
 55        {
 056            _id = id;
 057            Initialize(sourceToken.ContextId, key, sourceToken.ValidFrom, sourceToken.ValidTo, authorizationPolicies, so
 058            CookieBlob = sourceToken.CookieBlob;
 059            BootstrapMessageProperty = (sourceToken.BootstrapMessageProperty == null) ? null : (SecurityMessageProperty)
 060        }
 61
 62        internal SecurityContextSecurityToken(UniqueId contextId, string id, byte[] key, DateTime validFrom, DateTime va
 063            : this(contextId, id, key, validFrom, validTo, authorizationPolicies, isCookieMode, cookieBlob, null, validF
 64        {
 065        }
 66
 67        internal SecurityContextSecurityToken(UniqueId contextId, string id, byte[] key, DateTime validFrom, DateTime va
 68            UniqueId keyGeneration, DateTime keyEffectiveTime, DateTime keyExpirationTime)
 069            : base()
 70        {
 071            _id = id;
 072            Initialize(contextId, key, validFrom, validTo, authorizationPolicies, isCookieMode, keyGeneration, keyEffect
 073            CookieBlob = cookieBlob;
 074        }
 75
 3076        private SecurityContextSecurityToken(SecurityContextSecurityToken from)
 77        {
 3078            ReadOnlyCollection<IAuthorizationPolicy> authorizationPolicies = SecurityUtils.CloneAuthorizationPoliciesIfN
 3079            _id = from._id;
 3080            Initialize(from.ContextId, from._key, from._tokenEffectiveTime, from._tokenExpirationTime, authorizationPoli
 3081            CookieBlob = from.CookieBlob;
 3082            BootstrapMessageProperty = (from.BootstrapMessageProperty == null) ? null : (SecurityMessageProperty)from.Bo
 3083        }
 84
 85        /// <summary>
 86        /// Gets or Sets the SecurityMessageProperty extracted from
 87        /// the Bootstrap message. This will contain the original tokens
 88        /// that the client used to Authenticate with the service. By
 89        /// default, this is turned off. To turn this feature on, add a custom
 90        /// ServiceCredentialsSecurityTokenManager and override
 91        /// CreateSecurityTokenManager. Create the SecurityContextToken Authenticator by calling
 92        /// ServiceCredentialsSecurityTokenManager.CreateSecureConversationTokenAuthenticator
 93        /// with 'preserveBootstrapTokens' parameter to true.
 94        /// If there are any UserNameSecurityToken in the bootstrap message, the password in
 95        /// these tokens will be removed. When 'Cookie' mode SCT is enabled the BootstrapMessageProperty
 96        /// is not preserved in the Cookie. To preserve the bootstrap tokens in the CookieMode case
 97        /// write a custom Serializer and serialize the property as part of the cookie.
 98        /// </summary>
 7099        public SecurityMessageProperty BootstrapMessageProperty { get; set; }
 100
 100101        public override string Id => _id;
 102
 230103        public UniqueId ContextId { get; private set; } = null;
 104
 120105        public UniqueId KeyGeneration { get; private set; } = null;
 106
 160107        public DateTime KeyEffectiveTime { get; private set; }
 108
 190109        public DateTime KeyExpirationTime { get; private set; }
 110
 111        public ReadOnlyCollection<IAuthorizationPolicy> AuthorizationPolicies
 112        {
 113            get
 114            {
 30115                ThrowIfDisposed();
 30116                return _authorizationPolicies;
 117            }
 118
 119            internal set
 120            {
 0121                _authorizationPolicies = value;
 0122            }
 123        }
 124
 40125        public override ReadOnlyCollection<SecurityKey> SecurityKeys => _securityKeys;
 126
 10127        public override DateTime ValidFrom => _tokenEffectiveTime;
 128
 40129        public override DateTime ValidTo => _tokenExpirationTime;
 130
 30131        internal byte[] CookieBlob { get; }
 132
 133        /// <summary>
 134        /// This is set by the issuer when creating the SCT to be sent in the RSTR
 135        /// The SecurityContextTokenManager examines this property to determine how to write
 136        /// out the SCT
 137        /// This field is set to true when the issuer reads in a cookie mode SCT
 138        /// </summary>
 90139        public bool IsCookieMode { get; private set; } = false;
 140
 30141        DateTime TimeBoundedCache.IExpirableItem.ExpirationTime => ValidTo;
 142
 143        internal string GetBase64KeyString()
 144        {
 0145            if (_keyString == null)
 146            {
 0147                _keyString = Convert.ToBase64String(_key);
 148            }
 0149            return _keyString;
 150        }
 151
 152        internal byte[] GetKeyBytes()
 153        {
 0154            byte[] retval = new byte[_key.Length];
 0155            Buffer.BlockCopy(_key, 0, retval, 0, _key.Length);
 0156            return retval;
 157        }
 158
 159        public override string ToString()
 160        {
 0161            return string.Format(CultureInfo.CurrentCulture, "SecurityContextSecurityToken(Identifier='{0}', KeyGenerati
 162        }
 163
 164        private void Initialize(UniqueId contextId, byte[] key, DateTime validFrom, DateTime validTo, ReadOnlyCollection
 165            UniqueId keyGeneration, DateTime keyEffectiveTime, DateTime keyExpirationTime)
 166        {
 40167            if (key == null || key.Length == 0)
 168            {
 0169                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(key));
 170            }
 171
 40172            DateTime tokenEffectiveTimeUtc = validFrom.ToUniversalTime();
 40173            DateTime tokenExpirationTimeUtc = validTo.ToUniversalTime();
 40174            if (tokenEffectiveTimeUtc > tokenExpirationTimeUtc)
 175            {
 0176                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(nameof(validFrom), SR.EffectiveGreaterThanE
 177            }
 40178            _tokenEffectiveTime = tokenEffectiveTimeUtc;
 40179            _tokenExpirationTime = tokenExpirationTimeUtc;
 180
 40181            KeyEffectiveTime = keyEffectiveTime.ToUniversalTime();
 40182            KeyExpirationTime = keyExpirationTime.ToUniversalTime();
 40183            if (KeyEffectiveTime > KeyExpirationTime)
 184            {
 0185                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(nameof(keyEffectiveTime), SR.EffectiveGreat
 186            }
 40187            if ((KeyEffectiveTime < tokenEffectiveTimeUtc) || (KeyExpirationTime > tokenExpirationTimeUtc))
 188            {
 0189                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(SR.Format(SR.KeyLifetimeNotWithinTokenLifet
 190            }
 191
 40192            _key = new byte[key.Length];
 40193            Buffer.BlockCopy(key, 0, _key, 0, key.Length);
 40194            ContextId = contextId ?? throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(contextId))
 40195            KeyGeneration = keyGeneration;
 40196            _authorizationPolicies = authorizationPolicies ?? EmptyReadOnlyCollection<IAuthorizationPolicy>.Instance;
 40197            List<SecurityKey> temp = new List<SecurityKey>(1)
 40198            {
 40199                new InMemorySymmetricSecurityKey(_key, false)
 40200            };
 40201            _securityKeys = temp.AsReadOnly();
 40202            IsCookieMode = isCookieMode;
 40203        }
 204
 205        public override bool CanCreateKeyIdentifierClause<T>()
 206        {
 0207            if (typeof(T) == typeof(SecurityContextKeyIdentifierClause))
 208            {
 0209                return true;
 210            }
 211
 0212            return base.CanCreateKeyIdentifierClause<T>();
 213        }
 214
 215        public override T CreateKeyIdentifierClause<T>()
 216        {
 30217            if (typeof(T) == typeof(SecurityContextKeyIdentifierClause))
 218            {
 20219                return new SecurityContextKeyIdentifierClause(ContextId, KeyGeneration) as T;
 220            }
 221
 10222            return base.CreateKeyIdentifierClause<T>();
 223        }
 224
 225        public override bool MatchesKeyIdentifierClause(SecurityKeyIdentifierClause keyIdentifierClause)
 226        {
 20227            if (keyIdentifierClause is SecurityContextKeyIdentifierClause sctKeyIdentifierClause)
 228            {
 0229                return sctKeyIdentifierClause.Matches(ContextId, KeyGeneration);
 230            }
 231
 20232            return base.MatchesKeyIdentifierClause(keyIdentifierClause);
 233        }
 234
 235        /*
 236        public static SecurityContextSecurityToken CreateCookieSecurityContextToken(UniqueId contextId, string id, byte[
 237            DateTime validFrom, DateTime validTo, ReadOnlyCollection<IAuthorizationPolicy> authorizationPolicies, Securi
 238        {
 239            return CreateCookieSecurityContextToken(contextId, id, key, validFrom, validTo, null, validFrom, validTo, au
 240        }
 241
 242
 243        public static SecurityContextSecurityToken CreateCookieSecurityContextToken(UniqueId contextId, string id, byte[
 244            DateTime validFrom, DateTime validTo, UniqueId keyGeneration, DateTime keyEffectiveTime,
 245            DateTime keyExpirationTime, ReadOnlyCollection<IAuthorizationPolicy> authorizationPolicies, SecurityStateEnc
 246        {
 247            SecurityContextCookieSerializer cookieSerializer = new SecurityContextCookieSerializer(securityStateEncoder,
 248            byte[] cookieBlob = cookieSerializer.CreateCookieFromSecurityContext(contextId, id, key, validFrom, validTo,
 249                                keyEffectiveTime, keyExpirationTime, authorizationPolicies);
 250
 251            return new SecurityContextSecurityToken(contextId, id, key, validFrom, validTo,
 252                authorizationPolicies, true, cookieBlob, keyGeneration, keyEffectiveTime, keyExpirationTime);
 253        }*/
 254
 255        internal SecurityContextSecurityToken Clone()
 256        {
 30257            ThrowIfDisposed();
 30258            return new SecurityContextSecurityToken(this);
 259        }
 260
 261        public void Dispose()
 262        {
 10263            if (!_disposed)
 264            {
 10265                _disposed = true;
 10266                SecurityUtils.DisposeAuthorizationPoliciesIfNecessary(_authorizationPolicies);
 10267                if (BootstrapMessageProperty != null)
 268                {
 0269                    BootstrapMessageProperty.Dispose();
 270                }
 271            }
 10272        }
 273
 274        private void ThrowIfDisposed()
 275        {
 60276            if (_disposed)
 277            {
 0278                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ObjectDisposedException(GetType().FullName
 279            }
 60280        }
 281    }
 282}
Generated by: ReportGenerator 5.5.11.0
08/09/2026 - 10:15:50
GitHub | reportgenerator.io

Methods/Properties

.ctor(System.Xml.UniqueId,System.Byte[],System.DateTime,System.DateTime)
.ctor(System.Xml.UniqueId,System.String,System.Byte[],System.DateTime,System.DateTime)
.ctor(System.Xml.UniqueId,System.String,System.Byte[],System.DateTime,System.DateTime,System.Collections.ObjectModel.ReadOnlyCollection`1<CoreWCF.IdentityModel.Policy.IAuthorizationPolicy>)
.ctor(System.Xml.UniqueId,System.String,System.Byte[],System.DateTime,System.DateTime,System.Xml.UniqueId,System.DateTime,System.DateTime,System.Collections.ObjectModel.ReadOnlyCollection`1<CoreWCF.IdentityModel.Policy.IAuthorizationPolicy>)
.ctor(CoreWCF.Security.Tokens.SecurityContextSecurityToken,System.String)
.ctor(CoreWCF.Security.Tokens.SecurityContextSecurityToken,System.String,System.Byte[],System.Xml.UniqueId,System.DateTime,System.DateTime,System.Collections.ObjectModel.ReadOnlyCollection`1<CoreWCF.IdentityModel.Policy.IAuthorizationPolicy>)
.ctor(System.Xml.UniqueId,System.String,System.Byte[],System.DateTime,System.DateTime,System.Collections.ObjectModel.ReadOnlyCollection`1<CoreWCF.IdentityModel.Policy.IAuthorizationPolicy>,System.Boolean,System.Byte[])
.ctor(System.Xml.UniqueId,System.String,System.Byte[],System.DateTime,System.DateTime,System.Collections.ObjectModel.ReadOnlyCollection`1<CoreWCF.IdentityModel.Policy.IAuthorizationPolicy>,System.Boolean,System.Byte[],System.Xml.UniqueId,System.DateTime,System.DateTime)
.ctor(CoreWCF.Security.Tokens.SecurityContextSecurityToken)
BootstrapMessageProperty()
Id()
ContextId()
KeyGeneration()
KeyEffectiveTime()
KeyExpirationTime()
AuthorizationPolicies()
AuthorizationPolicies(System.Collections.ObjectModel.ReadOnlyCollection`1<CoreWCF.IdentityModel.Policy.IAuthorizationPolicy>)
SecurityKeys()
ValidFrom()
ValidTo()
CookieBlob()
IsCookieMode()
WCF.Security.TimeBoundedCache.IExpirableItem.get_ExpirationTime()
GetBase64KeyString()
GetKeyBytes()
ToString()
Initialize(System.Xml.UniqueId,System.Byte[],System.DateTime,System.DateTime,System.Collections.ObjectModel.ReadOnlyCollection`1<CoreWCF.IdentityModel.Policy.IAuthorizationPolicy>,System.Boolean,System.Xml.UniqueId,System.DateTime,System.DateTime)
CanCreateKeyIdentifierClause()
CreateKeyIdentifierClause()
MatchesKeyIdentifierClause(CoreWCF.IdentityModel.SecurityKeyIdentifierClause)
Clone()
Dispose()
ThrowIfDisposed()