< Summary - CoreWCF Coverage — PR #1766

Information
Class: CoreWCF.IdentityModel.Tokens.XmlDsigSep2000
Assembly: CoreWCF.Primitives
File(s): /home/runner/work/CoreWCF/CoreWCF/src/CoreWCF.Primitives/src/CoreWCF/IdentityModel/Tokens/XmlDsigSep2000.cs
Line coverage
15%
Covered lines: 13
Uncovered lines: 69
Coverable lines: 82
Total lines: 213
Line coverage: 15.8%
Branch coverage
0%
Covered branches: 0
Total branches: 32
Branch coverage: 0%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Cyclomatic complexity NPath complexity Sequence coverage
.ctor(...)100%11100%
PopulateKeyIdentifierEntries(...)100%11100%
PopulateKeyIdentifierClauseEntries(...)100%11100%
.ctor(...)100%11100%
ReadKeyIdentifierCore(...)0%660%
SupportsCore(...)100%110%
WriteKeyIdentifierCore(...)0%440%
ReadKeyIdentifierClauseCore(...)0%16160%
SupportsCore(...)100%11100%
WriteKeyIdentifierClauseCore(...)0%660%

File(s)

/home/runner/work/CoreWCF/CoreWCF/src/CoreWCF.Primitives/src/CoreWCF/IdentityModel/Tokens/XmlDsigSep2000.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.Collections.Generic;
 5using System.Security.Cryptography.X509Certificates;
 6using System.Xml;
 7using CoreWCF.IdentityModel.Selectors;
 8using CoreWCF.Security;
 9using KeyIdentifierEntry = CoreWCF.IdentityModel.Selectors.SecurityTokenSerializer.KeyIdentifierEntry;
 10
 11namespace CoreWCF.IdentityModel.Tokens
 12{
 13    internal class XmlDsigSep2000 : SecurityTokenSerializer.SerializerEntries
 14    {
 15        private readonly KeyInfoSerializer _securityTokenSerializer;
 16
 13417        public XmlDsigSep2000(KeyInfoSerializer securityTokenSerializer)
 18        {
 13419            _securityTokenSerializer = securityTokenSerializer;
 13420        }
 21
 22        public override void PopulateKeyIdentifierEntries(IList<KeyIdentifierEntry> keyIdentifierEntries)
 23        {
 13424            keyIdentifierEntries.Add(new KeyInfoEntry(_securityTokenSerializer));
 13425        }
 26
 27        public override void PopulateKeyIdentifierClauseEntries(IList<SecurityTokenSerializer.KeyIdentifierClauseEntry> 
 28        {
 13429            keyIdentifierClauseEntries.Add(new X509CertificateClauseEntry());
 13430        }
 31
 32        internal class KeyInfoEntry : KeyIdentifierEntry
 33        {
 34            private readonly KeyInfoSerializer _securityTokenSerializer;
 35
 13436            public KeyInfoEntry(KeyInfoSerializer securityTokenSerializer)
 37            {
 13438                _securityTokenSerializer = securityTokenSerializer;
 13439            }
 40
 41            protected override XmlDictionaryString LocalName
 42            {
 43                get
 44                {
 045                    return CoreWCF.XD.XmlSignatureDictionary.KeyInfo;
 46                }
 47            }
 48
 49            protected override XmlDictionaryString NamespaceUri
 50            {
 51                get
 52                {
 053                    return CoreWCF.XD.XmlSignatureDictionary.Namespace;
 54                }
 55            }
 56
 57            public override SecurityKeyIdentifier ReadKeyIdentifierCore(XmlDictionaryReader reader)
 58            {
 059                reader.ReadStartElement(LocalName, NamespaceUri);
 060                SecurityKeyIdentifier keyIdentifier = new SecurityKeyIdentifier();
 061                while (reader.IsStartElement())
 62                {
 063                    SecurityKeyIdentifierClause clause = _securityTokenSerializer.ReadKeyIdentifierClause(reader);
 064                    if (clause == null)
 65                    {
 066                        reader.Skip();
 67                    }
 68                    else
 69                    {
 070                        keyIdentifier.Add(clause);
 71                    }
 72                }
 073                if (keyIdentifier.Count == 0)
 74                {
 075                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.ErrorDeserializingKeyI
 76                }
 077                reader.ReadEndElement();
 078                return keyIdentifier;
 79            }
 80
 81            public override bool SupportsCore(SecurityKeyIdentifier keyIdentifier)
 82            {
 083                return true;
 84            }
 85
 86            public override void WriteKeyIdentifierCore(XmlDictionaryWriter writer, SecurityKeyIdentifier keyIdentifier)
 87            {
 088                writer.WriteStartElement(CoreWCF.XD.XmlSignatureDictionary.Prefix.Value, LocalName, NamespaceUri);
 089                bool clauseWritten = false;
 090                foreach (SecurityKeyIdentifierClause clause in keyIdentifier)
 91                {
 092                    _securityTokenSerializer.InnerSecurityTokenSerializer.WriteKeyIdentifierClause(writer, clause);
 093                    clauseWritten = true;
 94                }
 095                writer.WriteEndElement(); // KeyInfo
 096                if (!clauseWritten)
 97                {
 098                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityMessageSerializationException(
 99                }
 0100            }
 101        }
 102
 103        // so far, we only support two types of X509Data directly under KeyInfo  - X509Certificate and X509SKI
 104        //   <ds:X509Data>
 105        //     <ds:X509Certificate>...</ds:X509Certificate>
 106        //      or
 107        //     <X509SKI>... </X509SKI>
 108        //   </ds:X509Data>
 109        // only support 1 certificate right now
 110        internal class X509CertificateClauseEntry : SecurityTokenSerializer.KeyIdentifierClauseEntry
 111        {
 112            protected override XmlDictionaryString LocalName
 113            {
 114                get
 115                {
 45116                    return CoreWCF.XD.XmlSignatureDictionary.X509Data;
 117                }
 118            }
 119
 120            protected override XmlDictionaryString NamespaceUri
 121            {
 122                get
 123                {
 45124                    return CoreWCF.XD.XmlSignatureDictionary.Namespace;
 125                }
 126            }
 127
 128            public override SecurityKeyIdentifierClause ReadKeyIdentifierClauseCore(XmlDictionaryReader reader)
 129            {
 0130                SecurityKeyIdentifierClause ski = null;
 0131                reader.ReadStartElement(CoreWCF.XD.XmlSignatureDictionary.X509Data, NamespaceUri);
 0132                while (reader.IsStartElement())
 133                {
 0134                    if (ski == null && reader.IsStartElement(CoreWCF.XD.XmlSignatureDictionary.X509Certificate, Namespac
 135                    {
 0136                        if (!SecurityUtils.TryCreateX509CertificateFromRawData(reader.ReadElementContentAsBase64(), out 
 137                        {
 0138                            throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SecurityMessageSerializationEx
 139                        }
 0140                        ski = new X509RawDataKeyIdentifierClause(certificate);
 141                    }
 0142                    else if (ski == null && reader.IsStartElement(XmlSignatureStrings.X509Ski, NamespaceUri.ToString()))
 143                    {
 0144                        ski = new X509SubjectKeyIdentifierClause(reader.ReadElementContentAsBase64());
 145                    }
 0146                    else if ((ski == null) && reader.IsStartElement(CoreWCF.XD.XmlSignatureDictionary.X509IssuerSerial, 
 147                    {
 0148                        reader.ReadStartElement(CoreWCF.XD.XmlSignatureDictionary.X509IssuerSerial, CoreWCF.XD.XmlSignat
 0149                        reader.ReadStartElement(CoreWCF.XD.XmlSignatureDictionary.X509IssuerName, CoreWCF.XD.XmlSignatur
 0150                        string issuerName = reader.ReadContentAsString();
 0151                        reader.ReadEndElement();
 0152                        reader.ReadStartElement(CoreWCF.XD.XmlSignatureDictionary.X509SerialNumber, CoreWCF.XD.XmlSignat
 0153                        string serialNumber = reader.ReadContentAsString();
 0154                        reader.ReadEndElement();
 0155                        reader.ReadEndElement();
 156
 0157                        ski = new X509IssuerSerialKeyIdentifierClause(issuerName, serialNumber);
 158                    }
 159                    else
 160                    {
 0161                        reader.Skip();
 162                    }
 163                }
 0164                reader.ReadEndElement();
 0165                return ski;
 166            }
 167
 168            public override bool SupportsCore(SecurityKeyIdentifierClause keyIdentifierClause)
 169            {
 20170                return (keyIdentifierClause is X509RawDataKeyIdentifierClause);
 171                // This method should not write X509IssuerSerialKeyIdentifierClause or X509SubjectKeyIdentifierClause as
 172                // The XmlDsig entries are written by the X509SecurityTokenHandler.
 173            }
 174
 175            public override void WriteKeyIdentifierClauseCore(XmlDictionaryWriter writer, SecurityKeyIdentifierClause ke
 176            {
 0177                if (keyIdentifierClause is X509RawDataKeyIdentifierClause x509Clause)
 178                {
 0179                    writer.WriteStartElement(CoreWCF.XD.XmlSignatureDictionary.Prefix.Value, CoreWCF.XD.XmlSignatureDict
 180
 0181                    writer.WriteStartElement(CoreWCF.XD.XmlSignatureDictionary.Prefix.Value, CoreWCF.XD.XmlSignatureDict
 0182                    byte[] certBytes = x509Clause.GetX509RawData();
 0183                    writer.WriteBase64(certBytes, 0, certBytes.Length);
 0184                    writer.WriteEndElement();
 185
 0186                    writer.WriteEndElement();
 187                }
 188
 0189                if (keyIdentifierClause is X509IssuerSerialKeyIdentifierClause issuerSerialClause)
 190                {
 0191                    writer.WriteStartElement(CoreWCF.XD.XmlSignatureDictionary.Prefix.Value, CoreWCF.XD.XmlSignatureDict
 0192                    writer.WriteStartElement(CoreWCF.XD.XmlSignatureDictionary.Prefix.Value, CoreWCF.XD.XmlSignatureDict
 0193                    writer.WriteElementString(CoreWCF.XD.XmlSignatureDictionary.Prefix.Value, CoreWCF.XD.XmlSignatureDic
 0194                    writer.WriteElementString(CoreWCF.XD.XmlSignatureDictionary.Prefix.Value, CoreWCF.XD.XmlSignatureDic
 0195                    writer.WriteEndElement();
 0196                    writer.WriteEndElement();
 0197                    return;
 198                }
 199
 0200                if (keyIdentifierClause is X509SubjectKeyIdentifierClause skiClause)
 201                {
 0202                    writer.WriteStartElement(XmlSignatureConstants.Prefix, XmlSignatureConstants.Elements.X509Data, XmlS
 0203                    writer.WriteStartElement(XmlSignatureConstants.Prefix, XmlSignatureConstants.Elements.X509SKI, XmlSi
 0204                    byte[] ski = skiClause.GetX509SubjectKeyIdentifier();
 0205                    writer.WriteBase64(ski, 0, ski.Length);
 0206                    writer.WriteEndElement();
 0207                    writer.WriteEndElement();
 0208                    return;
 209                }
 0210            }
 211        }
 212    }
 213}
Generated by: ReportGenerator 5.5.11.0
08/09/2026 - 10:15:49
GitHub | reportgenerator.io

Methods/Properties

.ctor(CoreWCF.IdentityModel.Tokens.KeyInfoSerializer)
PopulateKeyIdentifierEntries(System.Collections.Generic.IList`1<CoreWCF.IdentityModel.Selectors.SecurityTokenSerializer/KeyIdentifierEntry>)
PopulateKeyIdentifierClauseEntries(System.Collections.Generic.IList`1<CoreWCF.IdentityModel.Selectors.SecurityTokenSerializer/KeyIdentifierClauseEntry>)
.ctor(CoreWCF.IdentityModel.Tokens.KeyInfoSerializer)
LocalName()
NamespaceUri()
ReadKeyIdentifierCore(System.Xml.XmlDictionaryReader)
SupportsCore(CoreWCF.IdentityModel.Tokens.SecurityKeyIdentifier)
WriteKeyIdentifierCore(System.Xml.XmlDictionaryWriter,CoreWCF.IdentityModel.Tokens.SecurityKeyIdentifier)
LocalName()
NamespaceUri()
ReadKeyIdentifierClauseCore(System.Xml.XmlDictionaryReader)
SupportsCore(CoreWCF.IdentityModel.SecurityKeyIdentifierClause)
WriteKeyIdentifierClauseCore(System.Xml.XmlDictionaryWriter,CoreWCF.IdentityModel.SecurityKeyIdentifierClause)