< Summary - CoreWCF Coverage — PR #1766

Information
Class: CoreWCF.Security.WSKeyInfoSerializer
Assembly: CoreWCF.Primitives
File(s): /home/runner/work/CoreWCF/CoreWCF/src/CoreWCF.Primitives/src/CoreWCF/Security/WSKeyInfoSerializer.cs
Line coverage
78%
Covered lines: 108
Uncovered lines: 30
Coverable lines: 138
Total lines: 315
Line coverage: 78.2%
Branch coverage
62%
Covered branches: 25
Total branches: 40
Branch coverage: 62.5%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Cyclomatic complexity NPath complexity Sequence coverage
CreateAdditionalEntries(...)75%8893.75%
.ctor(...)100%11100%
.ctor(...)100%11100%
PopulateTokenEntries(...)50%2280%
.ctor(...)100%11100%
GetTokenType(...)100%110%
GetTokenTypeUri()100%110%
CanReadClause(...)56.25%161676.92%
ReadClause(...)50%4477.77%
SupportsCore(...)100%11100%
WriteContent(...)100%11100%
.ctor(...)100%11100%
GetTokenTypesCore()100%22100%
.ctor(...)50%22100%
GetTokenTypesCore()100%22100%
.ctor(...)100%11100%
PopulateStrEntries(...)100%11100%
.ctor(...)100%11100%
ReadGeneration(...)100%11100%
WriteGeneration(...)50%2225%
.ctor(...)100%11100%
PopulateStrEntries(...)100%11100%
.ctor(...)100%11100%
ReadGeneration(...)100%11100%
WriteGeneration(...)50%2225%

File(s)

/home/runner/work/CoreWCF/CoreWCF/src/CoreWCF.Primitives/src/CoreWCF/Security/WSKeyInfoSerializer.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.Xml;
 7using CoreWCF.IdentityModel;
 8using CoreWCF.IdentityModel.Selectors;
 9using CoreWCF.IdentityModel.Tokens;
 10using CoreWCF.Security.Tokens;
 11
 12namespace CoreWCF.Security
 13{
 14    internal class WSKeyInfoSerializer : KeyInfoSerializer
 15    {
 16        private static Func<KeyInfoSerializer, IEnumerable<SecurityTokenSerializer.SerializerEntries>> CreateAdditionalE
 17        {
 13218            return (KeyInfoSerializer keyInfoSerializer) =>
 13219            {
 13220                List<SecurityTokenSerializer.SerializerEntries> serializerEntries = new List<SecurityTokenSerializer.Ser
 13221
 13222                if (securityVersion == SecurityVersion.WSSecurity10)
 13223                {
 624                    serializerEntries.Add(new CoreWCF.IdentityModel.Tokens.WSSecurityJan2004(keyInfoSerializer));
 13225                }
 12626                else if (securityVersion == SecurityVersion.WSSecurity11)
 13227                {
 12628                    serializerEntries.Add(new CoreWCF.IdentityModel.Tokens.WSSecurityXXX2005(keyInfoSerializer));
 13229                }
 13230                else
 13231                {
 032                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException(nameof(sec
 13233                }
 13234
 13235                if (secureConversationVersion == SecureConversationVersion.WSSecureConversationFeb2005)
 13236                {
 6537                    serializerEntries.Add(new WSSecureConversationFeb2005(keyInfoSerializer));
 13238                }
 6739                else if (secureConversationVersion == SecureConversationVersion.WSSecureConversation13)
 13240                {
 6741                    serializerEntries.Add(new WSSecureConversationDec2005(keyInfoSerializer));
 13242                }
 13243                else
 13244                {
 045                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException());
 13246                }
 13247
 13248                return serializerEntries;
 13249            };
 50        }
 51
 52        public WSKeyInfoSerializer(bool emitBspRequiredAttributes, DictionaryManager dictionaryManager, TrustDictionary 
 13253            : base(emitBspRequiredAttributes, dictionaryManager, trustDictionary, innerSecurityTokenSerializer, CreateAd
 54        {
 13255        }
 56
 57        #region WSSecureConversation classes
 58
 59        public abstract class WSSecureConversation : SecurityTokenSerializer.SerializerEntries
 60        {
 13261            protected WSSecureConversation(KeyInfoSerializer securityTokenSerializer)
 62            {
 13263                SecurityTokenSerializer = securityTokenSerializer;
 13264            }
 65
 12866            public KeyInfoSerializer SecurityTokenSerializer { get; }
 67
 68            public abstract SecureConversationDictionary SerializerDictionary { get; }
 69
 070            public virtual string DerivationAlgorithm => SecurityAlgorithms.Psha1KeyDerivation;
 71
 72            public override void PopulateTokenEntries(IList<TokenEntry> tokenEntryList)
 73            {
 13274                if (tokenEntryList == null)
 75                {
 076                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(tokenEntryList));
 77                }
 13278                tokenEntryList.Add(new DerivedKeyTokenEntry(this));
 13279                tokenEntryList.Add(new SecurityContextTokenEntry(this));
 13280            }
 81
 82            protected abstract class SctStrEntry : StrEntry
 83            {
 13284                public SctStrEntry(WSSecureConversation parent)
 85                {
 13286                    Parent = parent;
 13287                }
 88
 8089                protected WSSecureConversation Parent { get; }
 90
 91                public override Type GetTokenType(SecurityKeyIdentifierClause clause)
 92                {
 093                    return null;
 94                }
 95
 96                public override string GetTokenTypeUri()
 97                {
 098                    return null;
 99                }
 100
 101                public override bool CanReadClause(XmlDictionaryReader reader, string tokenType)
 102                {
 10103                    if (tokenType != null && tokenType != Parent.SerializerDictionary.SecurityContextTokenType.Value)
 104                    {
 0105                        return false;
 106                    }
 10107                    if (reader.IsStartElement(
 10108                        Parent.SecurityTokenSerializer.DictionaryManager.SecurityJan2004Dictionary.Reference,
 10109                        Parent.SecurityTokenSerializer.DictionaryManager.SecurityJan2004Dictionary.Namespace))
 110                    {
 10111                        string valueType = reader.GetAttribute(Parent.SecurityTokenSerializer.DictionaryManager.Security
 10112                        if (valueType != null && valueType != Parent.SerializerDictionary.SecurityContextTokenReferenceV
 113                        {
 0114                            return false;
 115                        }
 10116                        string uri = reader.GetAttribute(Parent.SecurityTokenSerializer.DictionaryManager.SecurityJan200
 10117                        if (uri != null)
 118                        {
 10119                            if (uri.Length > 0 && uri[0] != '#')
 120                            {
 10121                                return true;
 122                            }
 123                        }
 124                    }
 0125                    return false;
 126                }
 127
 128                public override SecurityKeyIdentifierClause ReadClause(XmlDictionaryReader reader, byte[] derivationNonc
 129                {
 10130                    System.Xml.UniqueId uri = XmlHelper.GetAttributeAsUniqueId(reader, XD.SecurityJan2004Dictionary.URI,
 10131                    System.Xml.UniqueId generation = ReadGeneration(reader);
 132
 10133                    if (reader.IsEmptyElement)
 134                    {
 0135                        reader.Read();
 136                    }
 137                    else
 138                    {
 10139                        reader.ReadStartElement();
 10140                        while (reader.IsStartElement())
 141                        {
 0142                            reader.Skip();
 143                        }
 10144                        reader.ReadEndElement();
 145                    }
 146
 10147                    return new SecurityContextKeyIdentifierClause(uri, generation, derivationNonce, derivationLength);
 148                }
 149
 150                protected abstract System.Xml.UniqueId ReadGeneration(XmlDictionaryReader reader);
 151
 152                public override bool SupportsCore(SecurityKeyIdentifierClause clause)
 153                {
 20154                    return clause is SecurityContextKeyIdentifierClause;
 155                }
 156
 157                public override void WriteContent(XmlDictionaryWriter writer, SecurityKeyIdentifierClause clause)
 158                {
 10159                    SecurityContextKeyIdentifierClause sctClause = clause as SecurityContextKeyIdentifierClause;
 10160                    writer.WriteStartElement(XD.SecurityJan2004Dictionary.Prefix.Value, XD.SecurityJan2004Dictionary.Ref
 10161                    XmlHelper.WriteAttributeStringAsUniqueId(writer, null, XD.SecurityJan2004Dictionary.URI, null, sctCl
 10162                    WriteGeneration(writer, sctClause);
 10163                    writer.WriteAttributeString(XD.SecurityJan2004Dictionary.ValueType, null, Parent.SerializerDictionar
 10164                    writer.WriteEndElement();
 10165                }
 166
 167                protected abstract void WriteGeneration(XmlDictionaryWriter writer, SecurityContextKeyIdentifierClause c
 168            }
 169
 170            protected class SecurityContextTokenEntry : SecurityTokenSerializer.TokenEntry
 171            {
 172                private Type[] _tokenTypes;
 173
 132174                public SecurityContextTokenEntry(WSSecureConversation parent)
 175                {
 132176                    Parent = parent;
 132177                }
 178
 32179                protected WSSecureConversation Parent { get; }
 180
 0181                protected override XmlDictionaryString LocalName => Parent.SerializerDictionary.SecurityContextToken;
 0182                protected override XmlDictionaryString NamespaceUri => Parent.SerializerDictionary.Namespace;
 183                protected override Type[] GetTokenTypesCore()
 184                {
 16185                    if (_tokenTypes == null)
 186                    {
 16187                        _tokenTypes = new Type[] { typeof(SecurityContextSecurityToken) };
 188                    }
 189
 16190                    return _tokenTypes;
 191                }
 32192                public override string TokenTypeUri => Parent.SerializerDictionary.SecurityContextTokenType.Value;
 0193                protected override string ValueTypeUri => null;
 194            }
 195
 196            protected class DerivedKeyTokenEntry : SecurityTokenSerializer.TokenEntry
 197            {
 198                public const string DefaultLabel = "WS-SecureConversation";
 199                private readonly WSSecureConversation _parent;
 200                private Type[] _tokenTypes;
 201
 132202                public DerivedKeyTokenEntry(WSSecureConversation parent)
 203                {
 132204                    _parent = parent ?? throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(parent))
 132205                }
 206
 0207                protected override XmlDictionaryString LocalName => _parent.SerializerDictionary.DerivedKeyToken;
 0208                protected override XmlDictionaryString NamespaceUri => _parent.SerializerDictionary.Namespace;
 209                protected override Type[] GetTokenTypesCore()
 210                {
 8211                    if (_tokenTypes == null)
 212                    {
 8213                        _tokenTypes = new Type[] { typeof(DerivedKeySecurityToken) };
 214                    }
 215
 8216                    return _tokenTypes;
 217                }
 218
 16219                public override string TokenTypeUri => _parent.SerializerDictionary.DerivedKeyTokenType.Value;
 0220                protected override string ValueTypeUri => null;
 221            }
 222        }
 223
 224        private class WSSecureConversationFeb2005 : WSSecureConversation
 225        {
 226            public WSSecureConversationFeb2005(KeyInfoSerializer securityTokenSerializer)
 65227                : base(securityTokenSerializer)
 228            {
 65229            }
 230
 36231            public override SecureConversationDictionary SerializerDictionary => SecurityTokenSerializer.DictionaryManag
 232
 233            public override void PopulateStrEntries(IList<StrEntry> strEntries)
 234            {
 65235                strEntries.Add(new SctStrEntryFeb2005(this));
 65236            }
 237
 238            private class SctStrEntryFeb2005 : SctStrEntry
 239            {
 240                public SctStrEntryFeb2005(WSSecureConversationFeb2005 parent)
 65241                    : base(parent)
 242                {
 65243                }
 244
 245                protected override System.Xml.UniqueId ReadGeneration(XmlDictionaryReader reader)
 246                {
 6247                    return XmlHelper.GetAttributeAsUniqueId(
 6248                        reader,
 6249                        Parent.SecurityTokenSerializer.DictionaryManager.SecureConversationDec2005Dictionary.Instance,
 6250                        Parent.SecurityTokenSerializer.DictionaryManager.SecureConversationFeb2005Dictionary.Namespace);
 251                }
 252
 253                protected override void WriteGeneration(XmlDictionaryWriter writer, SecurityContextKeyIdentifierClause c
 254                {
 255                    // serialize the generation
 6256                    if (clause.Generation != null)
 257                    {
 0258                        XmlHelper.WriteAttributeStringAsUniqueId(
 0259                            writer,
 0260                            Parent.SecurityTokenSerializer.DictionaryManager.SecureConversationFeb2005Dictionary.Prefix.
 0261                            Parent.SecurityTokenSerializer.DictionaryManager.SecureConversationDec2005Dictionary.Instanc
 0262                            Parent.SecurityTokenSerializer.DictionaryManager.SecureConversationFeb2005Dictionary.Namespa
 0263                            clause.Generation);
 264                    }
 6265                }
 266            }
 267        }
 268
 269        private class WSSecureConversationDec2005 : WSSecureConversation
 270        {
 67271            public WSSecureConversationDec2005(KeyInfoSerializer securityTokenSerializer) : base(securityTokenSerializer
 272            {
 67273            }
 274
 32275            public override SecureConversationDictionary SerializerDictionary => SecurityTokenSerializer.DictionaryManag
 276
 277            public override void PopulateStrEntries(IList<StrEntry> strEntries)
 278            {
 67279                strEntries.Add(new SctStrEntryDec2005(this));
 67280            }
 281
 0282            public override string DerivationAlgorithm => SecurityAlgorithms.Psha1KeyDerivationDec2005;
 283
 284            private class SctStrEntryDec2005 : SctStrEntry
 285            {
 286                public SctStrEntryDec2005(WSSecureConversationDec2005 parent)
 67287                    : base(parent)
 288                {
 67289                }
 290
 291                protected override System.Xml.UniqueId ReadGeneration(XmlDictionaryReader reader)
 292                {
 4293                    return XmlHelper.GetAttributeAsUniqueId(reader, Parent.SecurityTokenSerializer.DictionaryManager.Sec
 4294                        Parent.SecurityTokenSerializer.DictionaryManager.SecureConversationDec2005Dictionary.Namespace);
 295                }
 296
 297                protected override void WriteGeneration(XmlDictionaryWriter writer, SecurityContextKeyIdentifierClause c
 298                {
 299                    // serialize the generation
 4300                    if (clause.Generation != null)
 301                    {
 0302                        XmlHelper.WriteAttributeStringAsUniqueId(
 0303                            writer,
 0304                            Parent.SecurityTokenSerializer.DictionaryManager.SecureConversationDec2005Dictionary.Prefix.
 0305                            Parent.SecurityTokenSerializer.DictionaryManager.SecureConversationDec2005Dictionary.Instanc
 0306                            Parent.SecurityTokenSerializer.DictionaryManager.SecureConversationDec2005Dictionary.Namespa
 0307                            clause.Generation);
 308                    }
 4309                }
 310            }
 311        }
 312
 313        #endregion
 314    }
 315}
Generated by: ReportGenerator 5.5.11.0
08/09/2026 - 10:15:50
GitHub | reportgenerator.io

Methods/Properties

CreateAdditionalEntries(CoreWCF.Security.SecurityVersion,CoreWCF.Security.SecureConversationVersion)
.ctor(System.Boolean,CoreWCF.IdentityModel.DictionaryManager,CoreWCF.TrustDictionary,CoreWCF.IdentityModel.Selectors.SecurityTokenSerializer,CoreWCF.Security.SecurityVersion,CoreWCF.Security.SecureConversationVersion)
.ctor(CoreWCF.IdentityModel.Tokens.KeyInfoSerializer)
SecurityTokenSerializer()
DerivationAlgorithm()
PopulateTokenEntries(System.Collections.Generic.IList`1<CoreWCF.IdentityModel.Selectors.SecurityTokenSerializer/TokenEntry>)
.ctor(CoreWCF.Security.WSKeyInfoSerializer/WSSecureConversation)
Parent()
GetTokenType(CoreWCF.IdentityModel.SecurityKeyIdentifierClause)
GetTokenTypeUri()
CanReadClause(System.Xml.XmlDictionaryReader,System.String)
ReadClause(System.Xml.XmlDictionaryReader,System.Byte[],System.Int32,System.String)
SupportsCore(CoreWCF.IdentityModel.SecurityKeyIdentifierClause)
WriteContent(System.Xml.XmlDictionaryWriter,CoreWCF.IdentityModel.SecurityKeyIdentifierClause)
.ctor(CoreWCF.Security.WSKeyInfoSerializer/WSSecureConversation)
Parent()
LocalName()
NamespaceUri()
GetTokenTypesCore()
TokenTypeUri()
ValueTypeUri()
.ctor(CoreWCF.Security.WSKeyInfoSerializer/WSSecureConversation)
LocalName()
NamespaceUri()
GetTokenTypesCore()
TokenTypeUri()
ValueTypeUri()
.ctor(CoreWCF.IdentityModel.Tokens.KeyInfoSerializer)
SerializerDictionary()
PopulateStrEntries(System.Collections.Generic.IList`1<CoreWCF.IdentityModel.Selectors.SecurityTokenSerializer/StrEntry>)
.ctor(CoreWCF.Security.WSKeyInfoSerializer/WSSecureConversationFeb2005)
ReadGeneration(System.Xml.XmlDictionaryReader)
WriteGeneration(System.Xml.XmlDictionaryWriter,CoreWCF.Security.SecurityContextKeyIdentifierClause)
.ctor(CoreWCF.IdentityModel.Tokens.KeyInfoSerializer)
SerializerDictionary()
PopulateStrEntries(System.Collections.Generic.IList`1<CoreWCF.IdentityModel.Selectors.SecurityTokenSerializer/StrEntry>)
DerivationAlgorithm()
.ctor(CoreWCF.Security.WSKeyInfoSerializer/WSSecureConversationDec2005)
ReadGeneration(System.Xml.XmlDictionaryReader)
WriteGeneration(System.Xml.XmlDictionaryWriter,CoreWCF.Security.SecurityContextKeyIdentifierClause)