< Summary - CoreWCF Coverage — PR #1766

Information
Class: CoreWCF.Security.WSSecurityTokenSerializer
Assembly: CoreWCF.Primitives
File(s): /home/runner/work/CoreWCF/CoreWCF/src/CoreWCF.Primitives/src/CoreWCF/Security/WSSecurityTokenSerializer.cs
Line coverage
43%
Covered lines: 93
Uncovered lines: 123
Coverable lines: 216
Total lines: 578
Line coverage: 43%
Branch coverage
30%
Covered branches: 33
Total branches: 110
Branch coverage: 30%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Cyclomatic complexity NPath complexity Sequence coverage
.ctor(...)68.18%222286.36%
.ctor()100%11100%
.ctor(...)100%110%
.ctor(...)100%11100%
.ctor(...)100%11100%
.ctor(...)100%11100%
.ctor(...)100%11100%
.ctor(...)100%11100%
.ctor(...)100%11100%
ShouldWrapException(...)0%660%
CanReadTokenCore(...)0%440%
ReadTokenCore(...)50%6654.54%
CanWriteTokenCore(...)0%440%
WriteTokenCore(...)62.5%8870.58%
CanReadKeyIdentifierCore(...)100%110%
ReadKeyIdentifierCore(...)100%1150%
CanWriteKeyIdentifierCore(...)100%110%
WriteKeyIdentifierCore(...)100%110%
CanReadKeyIdentifierClauseCore(...)100%1150%
ReadKeyIdentifierClauseCore(...)100%1150%
CanWriteKeyIdentifierClauseCore(...)100%110%
WriteKeyIdentifierClauseCore(...)100%1160%
GetTokenTypes(...)0%660%
GetTokenTypeUri(...)0%660%
TryCreateKeyIdentifierClauseFromTokenXml(...)0%220%
CreateKeyIdentifierClauseFromTokenXml(...)0%880%
GetTokenTypes()100%22100%
SupportsCore(...)100%44100%
SupportsTokenTypeUri(...)100%110%
CreateDirectReference(...)0%220%
CanReadTokenCore(...)0%660%
CanReadTokenCore(...)100%22100%
ReadTokenCoreAsync(...)100%110%
PopulateTokenEntries(...)100%110%
.ctor(...)0%220%
TryLookup(...)0%660%
TryLookup(...)0%440%
TryLookup(...)0%880%

File(s)

/home/runner/work/CoreWCF/CoreWCF/src/CoreWCF.Primitives/src/CoreWCF/Security/WSSecurityTokenSerializer.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.Threading.Tasks;
 7using System.Xml;
 8using CoreWCF.IdentityModel;
 9using CoreWCF.IdentityModel.Selectors;
 10using CoreWCF.IdentityModel.Tokens;
 11using CoreWCF.Runtime;
 12using CoreWCF.Security.Tokens;
 13
 14namespace CoreWCF.Security
 15{
 16    public class WSSecurityTokenSerializer : SecurityTokenSerializer
 17    {
 18        private const int DefaultMaximumKeyDerivationOffset = 64; // bytes
 19        private const int DefaultMaximumKeyDerivationLabelLength = 128; // bytes
 20        private const int DefaultMaximumKeyDerivationNonceLength = 128; // bytes
 21
 22        private static WSSecurityTokenSerializer s_instance;
 23        private readonly List<SerializerEntries> _serializerEntries;
 24        private readonly WSSecureConversation _secureConversation;
 13225        private readonly List<TokenEntry> _tokenEntries = new List<TokenEntry>();
 26        private readonly KeyInfoSerializer _keyInfoSerializer;
 27
 28        public WSSecurityTokenSerializer()
 429            : this(SecurityVersion.WSSecurity11)
 30        {
 431        }
 32
 33        public WSSecurityTokenSerializer(bool emitBspRequiredAttributes)
 034            : this(SecurityVersion.WSSecurity11, emitBspRequiredAttributes)
 35        {
 036        }
 37
 38        public WSSecurityTokenSerializer(SecurityVersion securityVersion)
 439            : this(securityVersion, false)
 40        {
 441        }
 42
 43        public WSSecurityTokenSerializer(SecurityVersion securityVersion, bool emitBspRequiredAttributes)
 444            : this(securityVersion, emitBspRequiredAttributes, null)
 45        {
 446        }
 47
 48        public WSSecurityTokenSerializer(SecurityVersion securityVersion, bool emitBspRequiredAttributes, SamlSerializer
 449            : this(securityVersion, emitBspRequiredAttributes, samlSerializer, null, null)
 50        {
 451        }
 52
 53        public WSSecurityTokenSerializer(SecurityVersion securityVersion, bool emitBspRequiredAttributes, SamlSerializer
 454            : this(securityVersion, emitBspRequiredAttributes, samlSerializer, securityStateEncoder, knownTypes, Default
 55        {
 456        }
 57
 58        public WSSecurityTokenSerializer(SecurityVersion securityVersion, TrustVersion trustVersion, SecureConversationV
 12859            : this(securityVersion, trustVersion, secureConversationVersion, emitBspRequiredAttributes, samlSerializer, 
 60        {
 12861        }
 62
 63        public WSSecurityTokenSerializer(SecurityVersion securityVersion, bool emitBspRequiredAttributes, SamlSerializer
 64            int maximumKeyDerivationOffset, int maximumKeyDerivationLabelLength, int maximumKeyDerivationNonceLength)
 465            : this(securityVersion, TrustVersion.Default, SecureConversationVersion.Default, emitBspRequiredAttributes, 
 66        {
 467        }
 68
 13269        public WSSecurityTokenSerializer(SecurityVersion securityVersion, TrustVersion trustVersion, SecureConversationV
 13270            int maximumKeyDerivationOffset, int maximumKeyDerivationLabelLength, int maximumKeyDerivationNonceLength)
 71        {
 13272            if (maximumKeyDerivationOffset < 0)
 73            {
 074                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException(nameof(maximum
 75            }
 13276            if (maximumKeyDerivationLabelLength < 0)
 77            {
 078                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException(nameof(maximum
 79            }
 13280            if (maximumKeyDerivationNonceLength <= 0)
 81            {
 082                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException(nameof(maximum
 83            }
 84
 13285            SecurityVersion = securityVersion ?? throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentN
 13286            EmitBspRequiredAttributes = emitBspRequiredAttributes;
 13287            MaximumKeyDerivationOffset = maximumKeyDerivationOffset;
 13288            MaximumKeyDerivationNonceLength = maximumKeyDerivationNonceLength;
 13289            MaximumKeyDerivationLabelLength = maximumKeyDerivationLabelLength;
 90
 13291            _serializerEntries = new List<SerializerEntries>();
 92
 13293            if (secureConversationVersion == SecureConversationVersion.WSSecureConversationFeb2005)
 94            {
 6595                _secureConversation = new WSSecureConversationFeb2005(this, securityStateEncoder, knownTypes, maximumKey
 96            }
 6797            else if (secureConversationVersion == SecureConversationVersion.WSSecureConversation13)
 98            {
 6799                _secureConversation = new WSSecureConversationDec2005(this, securityStateEncoder, knownTypes, maximumKey
 100            }
 101            else
 102            {
 0103                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException());
 104            }
 105
 132106            if (securityVersion == SecurityVersion.WSSecurity10)
 107            {
 6108                _serializerEntries.Add(new WSSecurityJan2004(this, samlSerializer));
 109            }
 126110            else if (securityVersion == SecurityVersion.WSSecurity11)
 111            {
 126112                _serializerEntries.Add(new WSSecurityXXX2005(this, samlSerializer));
 113            }
 114            else
 115            {
 0116                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException(nameof(securit
 117            }
 132118            _serializerEntries.Add(_secureConversation);
 119            //TODO later
 120            TrustDictionary trustDictionary;
 132121            if (trustVersion == TrustVersion.WSTrustFeb2005)
 122            {
 65123                _serializerEntries.Add(new WSTrustFeb2005(this));
 65124                trustDictionary = DXD.TrustDec2005Dictionary;
 125            }
 67126            else if (trustVersion == TrustVersion.WSTrust13)
 127            {
 67128                _serializerEntries.Add(new WSTrustDec2005(this));
 67129                trustDictionary = DXD.TrustDec2005Dictionary;
 130            }
 131            else
 132            {
 0133                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException());
 134            }
 135
 132136            _tokenEntries = new List<TokenEntry>();
 137
 1056138            for (int i = 0; i < _serializerEntries.Count; ++i)
 139            {
 396140                SerializerEntries serializerEntry = _serializerEntries[i];
 396141                serializerEntry.PopulateTokenEntries(_tokenEntries);
 142            }
 143
 132144            DictionaryManager dictionaryManager = new DictionaryManager(ServiceModelDictionary.CurrentVersion)
 132145            {
 132146                SecureConversationDec2005Dictionary = DXD.SecureConversationDec2005Dictionary,
 132147                SecurityAlgorithmDec2005Dictionary = DXD.SecurityAlgorithmDec2005Dictionary
 132148            };
 149
 132150            _keyInfoSerializer = new WSKeyInfoSerializer(EmitBspRequiredAttributes, dictionaryManager, trustDictionary, 
 132151        }
 152
 153        public static WSSecurityTokenSerializer DefaultInstance
 154        {
 155            get
 156            {
 6157                if (s_instance == null)
 158                {
 4159                    s_instance = new WSSecurityTokenSerializer();
 160                }
 161
 6162                return s_instance;
 163            }
 164        }
 165
 132166        public bool EmitBspRequiredAttributes { get; }
 167
 0168        public SecurityVersion SecurityVersion { get; }
 169
 0170        public int MaximumKeyDerivationOffset { get; }
 171
 0172        public int MaximumKeyDerivationLabelLength { get; }
 173
 0174        public int MaximumKeyDerivationNonceLength { get; }
 175
 176        private bool ShouldWrapException(Exception e)
 177        {
 0178            if (Fx.IsFatal(e))
 179            {
 0180                return false;
 181            }
 0182            return ((e is ArgumentException) || (e is FormatException) || (e is InvalidOperationException));
 183        }
 184
 185        protected override bool CanReadTokenCore(XmlReader reader)
 186        {
 0187            XmlDictionaryReader localReader = XmlDictionaryReader.CreateDictionaryReader(reader);
 0188            for (int i = 0; i < _tokenEntries.Count; i++)
 189            {
 0190                TokenEntry tokenEntry = _tokenEntries[i];
 0191                if (tokenEntry.CanReadTokenCore(localReader))
 192                {
 0193                    return true;
 194                }
 195            }
 0196            return false;
 197        }
 198
 199        protected override SecurityToken ReadTokenCore(XmlReader reader, SecurityTokenResolver tokenResolver)
 200        {
 51201            XmlDictionaryReader localReader = XmlDictionaryReader.CreateDictionaryReader(reader);
 530202            for (int i = 0; i < _tokenEntries.Count; i++)
 203            {
 265204                TokenEntry tokenEntry = _tokenEntries[i];
 265205                if (tokenEntry.CanReadTokenCore(localReader))
 206                {
 207                    try
 208                    {
 51209                        return tokenEntry.ReadTokenCore(localReader, tokenResolver);
 210                    }
 0211                    catch (Exception e)
 212                    {
 0213                        if (!ShouldWrapException(e))
 214                        {
 0215                            throw;
 216                        }
 0217                        throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.ErrorDeserializing
 218                    }
 219                }
 220            }
 0221            throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.Format(SR.CannotReadToken, rea
 51222        }
 223
 224        protected override bool CanWriteTokenCore(SecurityToken token)
 225        {
 0226            for (int i = 0; i < _tokenEntries.Count; i++)
 227            {
 0228                TokenEntry tokenEntry = _tokenEntries[i];
 0229                if (tokenEntry.SupportsCore(token.GetType()))
 230                {
 0231                    return true;
 232                }
 233            }
 0234            return false;
 235        }
 236
 237        protected override void WriteTokenCore(XmlWriter writer, SecurityToken token)
 238        {
 20239            bool wroteToken = false;
 20240            XmlDictionaryWriter localWriter = XmlDictionaryWriter.CreateDictionaryWriter(writer);
 300241            for (int i = 0; i < _tokenEntries.Count; i++)
 242            {
 150243                TokenEntry tokenEntry = _tokenEntries[i];
 150244                if (tokenEntry.SupportsCore(token.GetType()))
 245                {
 246                    try
 247                    {
 20248                        tokenEntry.WriteTokenCore(localWriter, token);
 20249                    }
 0250                    catch (Exception e)
 251                    {
 0252                        if (!ShouldWrapException(e))
 253                        {
 0254                            throw;
 255                        }
 0256                        throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.Format(SR.ErrorSer
 257                    }
 20258                    wroteToken = true;
 20259                    break;
 260                }
 261            }
 262
 20263            if (!wroteToken)
 264            {
 0265                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR.Sta
 266            }
 267
 20268            localWriter.Flush();
 20269        }
 270
 271        protected override bool CanReadKeyIdentifierCore(XmlReader reader)
 272        {
 0273            throw new PlatformNotSupportedException();
 274        }
 275
 276        protected override SecurityKeyIdentifier ReadKeyIdentifierCore(XmlReader reader)
 277        {
 278            try
 279            {
 23280                return _keyInfoSerializer.ReadKeyIdentifier(reader);
 281            }
 0282            catch (Exception ex)
 283            {
 0284                throw Fx.Exception.AsError(new MessageSecurityException(ex.Message));
 285            }
 23286        }
 287
 288        protected override bool CanWriteKeyIdentifierCore(SecurityKeyIdentifier keyIdentifier)
 289        {
 0290            throw new PlatformNotSupportedException();
 291        }
 292
 293        protected override void WriteKeyIdentifierCore(XmlWriter writer, SecurityKeyIdentifier keyIdentifier)
 294        {
 295            try
 296            {
 0297                _keyInfoSerializer.WriteKeyIdentifier(writer, keyIdentifier);
 0298            }
 0299            catch (Exception ex)
 300            {
 0301                throw Fx.Exception.AsError(new MessageSecurityException(ex.Message));
 302            }
 0303        }
 304
 305        protected override bool CanReadKeyIdentifierClauseCore(XmlReader reader)
 306        {
 307            try
 308            {
 6309                return _keyInfoSerializer.CanReadKeyIdentifierClause(reader);
 310            }
 0311            catch (Exception ex)
 312            {
 0313                throw Fx.Exception.AsError(new MessageSecurityException(ex.Message));
 314            }
 6315        }
 316
 317        protected override SecurityKeyIdentifierClause ReadKeyIdentifierClauseCore(XmlReader reader)
 318        {
 319            try
 320            {
 39321                return _keyInfoSerializer.ReadKeyIdentifierClause(reader);
 322            }
 0323            catch (Exception ex)
 324            {
 0325                throw Fx.Exception.AsError(new MessageSecurityException(ex.Message));
 326            }
 39327        }
 328
 329        protected override bool CanWriteKeyIdentifierClauseCore(SecurityKeyIdentifierClause keyIdentifierClause)
 330        {
 0331            throw new PlatformNotSupportedException();
 332        }
 333
 334        protected override void WriteKeyIdentifierClauseCore(XmlWriter writer, SecurityKeyIdentifierClause keyIdentifier
 335        {
 336            try
 337            {
 20338                _keyInfoSerializer.WriteKeyIdentifierClause(writer, keyIdentifierClause);
 20339            }
 0340            catch (Exception ex)
 341            {
 0342                throw Fx.Exception.AsError(new MessageSecurityException(ex.Message));
 343            }
 20344        }
 345
 346        internal Type[] GetTokenTypes(string tokenTypeUri)
 347        {
 0348            if (tokenTypeUri != null)
 349            {
 0350                for (int i = 0; i < _tokenEntries.Count; i++)
 351                {
 0352                    TokenEntry tokenEntry = _tokenEntries[i];
 353
 0354                    if (tokenEntry.SupportsTokenTypeUri(tokenTypeUri))
 355                    {
 0356                        return tokenEntry.GetTokenTypes();
 357                    }
 358                }
 359            }
 0360            return null;
 361        }
 362
 363        protected internal virtual string GetTokenTypeUri(Type tokenType)
 364        {
 0365            if (tokenType != null)
 366            {
 0367                for (int i = 0; i < _tokenEntries.Count; i++)
 368                {
 0369                    TokenEntry tokenEntry = _tokenEntries[i];
 370
 0371                    if (tokenEntry.SupportsCore(tokenType))
 372                    {
 0373                        return tokenEntry.TokenTypeUri;
 374                    }
 375                }
 376            }
 0377            return null;
 378        }
 379
 380        public virtual bool TryCreateKeyIdentifierClauseFromTokenXml(XmlElement element, SecurityTokenReferenceStyle tok
 381        {
 0382            if (element == null)
 383            {
 0384                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(element));
 385            }
 386
 0387            securityKeyIdentifierClause = null;
 388
 389            try
 390            {
 0391                securityKeyIdentifierClause = CreateKeyIdentifierClauseFromTokenXml(element, tokenReferenceStyle);
 0392            }
 0393            catch (XmlException)
 394            {
 0395                return false;
 396            }
 397
 0398            return true;
 0399        }
 400
 401        public virtual SecurityKeyIdentifierClause CreateKeyIdentifierClauseFromTokenXml(XmlElement element, SecurityTok
 402        {
 0403            if (element == null)
 404            {
 0405                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(element));
 406            }
 407
 0408            for (int i = 0; i < _tokenEntries.Count; i++)
 409            {
 0410                TokenEntry tokenEntry = _tokenEntries[i];
 0411                if (tokenEntry.CanReadTokenCore(element))
 412                {
 413                    try
 414                    {
 0415                        return tokenEntry.CreateKeyIdentifierClauseFromTokenXmlCore(element, tokenReferenceStyle);
 416                    }
 0417                    catch (Exception e)
 418                    {
 0419                        if (!ShouldWrapException(e))
 420                        {
 0421                            throw;
 422                        }
 0423                        throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.ErrorDeserializing
 424                    }
 425                }
 426            }
 427
 0428            throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.Format(SR.CannotReadToken, ele
 0429        }
 430
 431        internal new abstract class TokenEntry
 432        {
 433            private Type[] _tokenTypes = null;
 434            protected abstract XmlDictionaryString LocalName { get; }
 435            protected abstract XmlDictionaryString NamespaceUri { get; }
 0436            public Type TokenType => GetTokenTypes()[0];
 437            public abstract string TokenTypeUri { get; }
 438            protected abstract string ValueTypeUri { get; }
 439
 440            protected abstract Type[] GetTokenTypesCore();
 441
 442            public Type[] GetTokenTypes()
 443            {
 150444                if (_tokenTypes == null)
 445                {
 80446                    _tokenTypes = GetTokenTypesCore();
 447                }
 448
 150449                return _tokenTypes;
 450            }
 451
 452            public bool SupportsCore(Type tokenType)
 453            {
 150454                Type[] tokenTypes = GetTokenTypes();
 560455                for (int i = 0; i < tokenTypes.Length; ++i)
 456                {
 150457                    if (tokenTypes[i].IsAssignableFrom(tokenType))
 458                    {
 20459                        return true;
 460                    }
 461                }
 130462                return false;
 463            }
 464
 465            public virtual bool SupportsTokenTypeUri(string tokenTypeUri)
 466            {
 0467                return (TokenTypeUri == tokenTypeUri);
 468            }
 469
 470            protected static SecurityKeyIdentifierClause CreateDirectReference(XmlElement issuedTokenXml, string idAttri
 471            {
 0472                string id = issuedTokenXml.GetAttribute(idAttributeLocalName, idAttributeNamespace);
 0473                if (id == null)
 474                {
 0475                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.Format(SR.RequiredAttr
 476                }
 0477                return new LocalIdKeyIdentifierClause(id, tokenType);
 478            }
 479
 480            public virtual bool CanReadTokenCore(XmlElement element)
 481            {
 0482                string valueTypeUri = null;
 483
 0484                if (element.HasAttribute(SecurityJan2004Strings.ValueType, null))
 485                {
 0486                    valueTypeUri = element.GetAttribute(SecurityJan2004Strings.ValueType, null);
 487                }
 488
 0489                return element.LocalName == LocalName.Value && element.NamespaceURI == NamespaceUri.Value && valueTypeUr
 490            }
 491
 492            public virtual bool CanReadTokenCore(XmlDictionaryReader reader)
 493            {
 204494                return reader.IsStartElement(LocalName, NamespaceUri) &&
 204495                       reader.GetAttribute(XD.SecurityJan2004Dictionary.ValueType, null) == ValueTypeUri;
 496            }
 497
 498            public virtual Task<SecurityToken> ReadTokenCoreAsync(XmlDictionaryReader reader, SecurityTokenResolver toke
 499            {
 0500                return Task.FromResult(ReadTokenCore(reader, tokenResolver));
 501            }
 502
 503            public abstract SecurityKeyIdentifierClause CreateKeyIdentifierClauseFromTokenXmlCore(XmlElement issuedToken
 504
 505            public abstract SecurityToken ReadTokenCore(XmlDictionaryReader reader, SecurityTokenResolver tokenResolver)
 506
 507            public abstract void WriteTokenCore(XmlDictionaryWriter writer, SecurityToken token);
 508        }
 509
 510        internal new abstract class SerializerEntries
 511        {
 0512            public virtual void PopulateTokenEntries(IList<TokenEntry> tokenEntries) { }
 513        }
 514
 515        internal class CollectionDictionary : IXmlDictionary
 516        {
 517            private readonly List<XmlDictionaryString> _dictionaryStrings;
 518
 0519            public CollectionDictionary(List<XmlDictionaryString> dictionaryStrings)
 520            {
 0521                _dictionaryStrings = dictionaryStrings ?? throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new 
 0522            }
 523
 524            public bool TryLookup(string value, out XmlDictionaryString result)
 525            {
 0526                if (value == null)
 527                {
 0528                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException(nameof(value)));
 529                }
 530
 0531                for (int i = 0; i < _dictionaryStrings.Count; ++i)
 532                {
 0533                    if (_dictionaryStrings[i].Value.Equals(value))
 534                    {
 0535                        result = _dictionaryStrings[i];
 0536                        return true;
 537                    }
 538                }
 0539                result = null;
 0540                return false;
 541            }
 542
 543            public bool TryLookup(int key, out XmlDictionaryString result)
 544            {
 0545                for (int i = 0; i < _dictionaryStrings.Count; ++i)
 546                {
 0547                    if (_dictionaryStrings[i].Key == key)
 548                    {
 0549                        result = _dictionaryStrings[i];
 0550                        return true;
 551                    }
 552                }
 0553                result = null;
 0554                return false;
 555            }
 556
 557            public bool TryLookup(XmlDictionaryString value, out XmlDictionaryString result)
 558            {
 0559                if (value == null)
 560                {
 0561                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException(nameof(value)));
 562                }
 563
 0564                for (int i = 0; i < _dictionaryStrings.Count; ++i)
 565                {
 0566                    if ((_dictionaryStrings[i].Key == value.Key) &&
 0567                        (_dictionaryStrings[i].Value.Equals(value.Value)))
 568                    {
 0569                        result = _dictionaryStrings[i];
 0570                        return true;
 571                    }
 572                }
 0573                result = null;
 0574                return false;
 575            }
 576        }
 577    }
 578}
Generated by: ReportGenerator 5.5.11.0
08/09/2026 - 10:15:50
GitHub | reportgenerator.io

Methods/Properties

.ctor(CoreWCF.Security.SecurityVersion,CoreWCF.Security.TrustVersion,CoreWCF.Security.SecureConversationVersion,System.Boolean,CoreWCF.Security.SamlSerializer,CoreWCF.Security.SecurityStateEncoder,System.Collections.Generic.IEnumerable`1<System.Type>,System.Int32,System.Int32,System.Int32)
.ctor()
.ctor(System.Boolean)
.ctor(CoreWCF.Security.SecurityVersion)
.ctor(CoreWCF.Security.SecurityVersion,System.Boolean)
.ctor(CoreWCF.Security.SecurityVersion,System.Boolean,CoreWCF.Security.SamlSerializer)
.ctor(CoreWCF.Security.SecurityVersion,System.Boolean,CoreWCF.Security.SamlSerializer,CoreWCF.Security.SecurityStateEncoder,System.Collections.Generic.IEnumerable`1<System.Type>)
.ctor(CoreWCF.Security.SecurityVersion,CoreWCF.Security.TrustVersion,CoreWCF.Security.SecureConversationVersion,System.Boolean,CoreWCF.Security.SamlSerializer,CoreWCF.Security.SecurityStateEncoder,System.Collections.Generic.IEnumerable`1<System.Type>)
.ctor(CoreWCF.Security.SecurityVersion,System.Boolean,CoreWCF.Security.SamlSerializer,CoreWCF.Security.SecurityStateEncoder,System.Collections.Generic.IEnumerable`1<System.Type>,System.Int32,System.Int32,System.Int32)
DefaultInstance()
EmitBspRequiredAttributes()
SecurityVersion()
MaximumKeyDerivationOffset()
MaximumKeyDerivationLabelLength()
MaximumKeyDerivationNonceLength()
ShouldWrapException(System.Exception)
CanReadTokenCore(System.Xml.XmlReader)
ReadTokenCore(System.Xml.XmlReader,CoreWCF.IdentityModel.Selectors.SecurityTokenResolver)
CanWriteTokenCore(CoreWCF.IdentityModel.Tokens.SecurityToken)
WriteTokenCore(System.Xml.XmlWriter,CoreWCF.IdentityModel.Tokens.SecurityToken)
CanReadKeyIdentifierCore(System.Xml.XmlReader)
ReadKeyIdentifierCore(System.Xml.XmlReader)
CanWriteKeyIdentifierCore(CoreWCF.IdentityModel.Tokens.SecurityKeyIdentifier)
WriteKeyIdentifierCore(System.Xml.XmlWriter,CoreWCF.IdentityModel.Tokens.SecurityKeyIdentifier)
CanReadKeyIdentifierClauseCore(System.Xml.XmlReader)
ReadKeyIdentifierClauseCore(System.Xml.XmlReader)
CanWriteKeyIdentifierClauseCore(CoreWCF.IdentityModel.SecurityKeyIdentifierClause)
WriteKeyIdentifierClauseCore(System.Xml.XmlWriter,CoreWCF.IdentityModel.SecurityKeyIdentifierClause)
GetTokenTypes(System.String)
GetTokenTypeUri(System.Type)
TryCreateKeyIdentifierClauseFromTokenXml(System.Xml.XmlElement,CoreWCF.Security.Tokens.SecurityTokenReferenceStyle,CoreWCF.IdentityModel.SecurityKeyIdentifierClause&)
CreateKeyIdentifierClauseFromTokenXml(System.Xml.XmlElement,CoreWCF.Security.Tokens.SecurityTokenReferenceStyle)
TokenType()
GetTokenTypes()
SupportsCore(System.Type)
SupportsTokenTypeUri(System.String)
CreateDirectReference(System.Xml.XmlElement,System.String,System.String,System.Type)
CanReadTokenCore(System.Xml.XmlElement)
CanReadTokenCore(System.Xml.XmlDictionaryReader)
ReadTokenCoreAsync(System.Xml.XmlDictionaryReader,CoreWCF.IdentityModel.Selectors.SecurityTokenResolver)
PopulateTokenEntries(System.Collections.Generic.IList`1<CoreWCF.Security.WSSecurityTokenSerializer/TokenEntry>)
.ctor(System.Collections.Generic.List`1<System.Xml.XmlDictionaryString>)
TryLookup(System.String,System.Xml.XmlDictionaryString&)
TryLookup(System.Int32,System.Xml.XmlDictionaryString&)
TryLookup(System.Xml.XmlDictionaryString,System.Xml.XmlDictionaryString&)