< Summary - CoreWCF Coverage — PR #1766

Information
Class: CoreWCF.Security.WSUtilitySpecificationVersion
Assembly: CoreWCF.Primitives
File(s): /home/runner/work/CoreWCF/CoreWCF/src/CoreWCF.Primitives/src/CoreWCF/Security/WSUtilitySpecificationVersion.cs
Line coverage
55%
Covered lines: 42
Uncovered lines: 34
Coverable lines: 76
Total lines: 182
Line coverage: 55.2%
Branch coverage
87%
Covered branches: 7
Total branches: 8
Branch coverage: 87.5%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Cyclomatic complexity NPath complexity Sequence coverage
.cctor()100%110%
.ctor(...)100%11100%
.ctor()100%11100%
IsReaderAtTimestamp(...)100%11100%
ReadTimestamp(...)87.5%8895.45%
WriteTimestamp(...)100%11100%
WriteTimestampCanonicalForm(...)100%110%
.ctor()100%110%
WriteCanonicalForm(...)100%110%

File(s)

/home/runner/work/CoreWCF/CoreWCF/src/CoreWCF.Primitives/src/CoreWCF/Security/WSUtilitySpecificationVersion.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
 4namespace CoreWCF.Security
 5{
 6    using System;
 7    using System.IO;
 8    using System.Text;
 9    using System.Xml;
 10    using CoreWCF;
 11    using CanonicalFormWriter = CoreWCF.IdentityModel.CanonicalFormWriter;
 12    using HashStream = IdentityModel.HashStream;
 13    using SignatureResourcePool = CoreWCF.IdentityModel.SignatureResourcePool;
 14
 15    internal abstract class WSUtilitySpecificationVersion
 16    {
 017        internal static readonly string[] AcceptedDateTimeFormats = new string[]
 018        {
 019            "yyyy-MM-ddTHH:mm:ss.fffffffZ",
 020            "yyyy-MM-ddTHH:mm:ss.ffffffZ",
 021            "yyyy-MM-ddTHH:mm:ss.fffffZ",
 022            "yyyy-MM-ddTHH:mm:ss.ffffZ",
 023            "yyyy-MM-ddTHH:mm:ss.fffZ",
 024            "yyyy-MM-ddTHH:mm:ss.ffZ",
 025            "yyyy-MM-ddTHH:mm:ss.fZ",
 026            "yyyy-MM-ddTHH:mm:ssZ"
 027        };
 28
 329        internal WSUtilitySpecificationVersion(XmlDictionaryString namespaceUri)
 30        {
 331            NamespaceUri = namespaceUri;
 332        }
 33
 34        public static WSUtilitySpecificationVersion Default
 35        {
 13136            get { return OneDotZero; }
 37        }
 38
 039        internal XmlDictionaryString NamespaceUri { get; }
 40
 41        public static WSUtilitySpecificationVersion OneDotZero
 42        {
 13143            get { return WSUtilitySpecificationVersionOneDotZero.Instance; }
 44        }
 45
 46        internal abstract bool IsReaderAtTimestamp(XmlDictionaryReader reader);
 47
 48        internal abstract SecurityTimestamp ReadTimestamp(XmlDictionaryReader reader, string digestAlgorithm, SignatureR
 49
 50        internal abstract void WriteTimestamp(XmlDictionaryWriter writer, SecurityTimestamp timestamp);
 51
 52        internal abstract void WriteTimestampCanonicalForm(Stream stream, SecurityTimestamp timestamp, byte[] buffer);
 53
 54        private sealed class WSUtilitySpecificationVersionOneDotZero : WSUtilitySpecificationVersion
 55        {
 56            private WSUtilitySpecificationVersionOneDotZero()
 357                : base(XD.UtilityDictionary.Namespace)
 58            {
 359            }
 60
 13461            public static WSUtilitySpecificationVersionOneDotZero Instance { get; } = new WSUtilitySpecificationVersionO
 62
 63            internal override bool IsReaderAtTimestamp(XmlDictionaryReader reader)
 64            {
 18865                return reader.IsStartElement(XD.UtilityDictionary.Timestamp, XD.UtilityDictionary.Namespace);
 66            }
 67
 68            internal override SecurityTimestamp ReadTimestamp(XmlDictionaryReader reader, string digestAlgorithm, Signat
 69            {
 9470                bool canonicalize = digestAlgorithm != null && reader.CanCanonicalize;
 9471                HashStream hashStream = null;
 72
 9473                reader.MoveToStartElement(XD.UtilityDictionary.Timestamp, XD.UtilityDictionary.Namespace);
 9474                if (canonicalize)
 75                {
 2376                    hashStream = resourcePool.TakeHashStream(digestAlgorithm);
 2377                    reader.StartCanonicalization(hashStream, false, null);
 78                }
 9479                string id = reader.GetAttribute(XD.UtilityDictionary.IdAttribute, XD.UtilityDictionary.Namespace);
 9480                reader.ReadStartElement();
 81
 9482                reader.ReadStartElement(XD.UtilityDictionary.CreatedElement, XD.UtilityDictionary.Namespace);
 9483                DateTime creationTimeUtc = reader.ReadContentAsDateTime().ToUniversalTime();
 9484                reader.ReadEndElement();
 85
 86                DateTime expiryTimeUtc;
 9487                if (reader.IsStartElement(XD.UtilityDictionary.ExpiresElement, XD.UtilityDictionary.Namespace))
 88                {
 9489                    reader.ReadStartElement();
 9490                    expiryTimeUtc = reader.ReadContentAsDateTime().ToUniversalTime();
 9491                    reader.ReadEndElement();
 92                }
 93                else
 94                {
 095                    expiryTimeUtc = SecurityUtils.MaxUtcDateTime;
 96                }
 97
 9498                reader.ReadEndElement();
 99
 100                byte[] digest;
 94101                if (canonicalize)
 102                {
 23103                    reader.EndCanonicalization();
 23104                    digest = hashStream.FlushHashAndGetValue();
 105                }
 106                else
 107                {
 71108                    digest = null;
 109                }
 94110                return new SecurityTimestamp(creationTimeUtc, expiryTimeUtc, id, digestAlgorithm, digest);
 111            }
 112
 113            internal override void WriteTimestamp(XmlDictionaryWriter writer, SecurityTimestamp timestamp)
 114            {
 63115                writer.WriteStartElement(XD.UtilityDictionary.Prefix.Value, XD.UtilityDictionary.Timestamp, XD.UtilityDi
 63116                writer.WriteAttributeString(XD.UtilityDictionary.IdAttribute, XD.UtilityDictionary.Namespace, timestamp.
 117
 63118                writer.WriteStartElement(XD.UtilityDictionary.CreatedElement, XD.UtilityDictionary.Namespace);
 63119                char[] creationTime = timestamp.GetCreationTimeChars();
 63120                writer.WriteChars(creationTime, 0, creationTime.Length);
 63121                writer.WriteEndElement(); // wsu:Created
 122
 63123                writer.WriteStartElement(XD.UtilityDictionary.ExpiresElement, XD.UtilityDictionary.Namespace);
 63124                char[] expiryTime = timestamp.GetExpiryTimeChars();
 63125                writer.WriteChars(expiryTime, 0, expiryTime.Length);
 63126                writer.WriteEndElement(); // wsu:Expires
 127
 63128                writer.WriteEndElement();
 63129            }
 130
 131            internal override void WriteTimestampCanonicalForm(Stream stream, SecurityTimestamp timestamp, byte[] workBu
 132            {
 0133                TimestampCanonicalFormWriter.Instance.WriteCanonicalForm(
 0134                    stream,
 0135                    timestamp.Id, timestamp.GetCreationTimeChars(), timestamp.GetExpiryTimeChars(),
 0136                    workBuffer);
 0137            }
 138        }
 139
 140        private sealed class TimestampCanonicalFormWriter : CanonicalFormWriter
 141        {
 142            private const string timestamp = UtilityStrings.Prefix + ":" + UtilityStrings.Timestamp;
 143            private const string created = UtilityStrings.Prefix + ":" + UtilityStrings.CreatedElement;
 144            private const string expires = UtilityStrings.Prefix + ":" + UtilityStrings.ExpiresElement;
 145            private const string idAttribute = UtilityStrings.Prefix + ":" + UtilityStrings.IdAttribute;
 146            private const string ns = "xmlns:" + UtilityStrings.Prefix + "=\"" + UtilityStrings.Namespace + "\"";
 147
 148            private const string xml1 = "<" + timestamp + " " + ns + " " + idAttribute + "=\"";
 149            private const string xml2 = "\"><" + created + ">";
 150            private const string xml3 = "</" + created + "><" + expires + ">";
 151            private const string xml4 = "</" + expires + "></" + timestamp + ">";
 152
 153            private readonly byte[] _fragment1;
 154            private readonly byte[] _fragment2;
 155            private readonly byte[] _fragment3;
 156            private readonly byte[] _fragment4;
 157
 0158            private TimestampCanonicalFormWriter()
 159            {
 0160                Encoding encoding = Utf8WithoutPreamble;
 0161                _fragment1 = encoding.GetBytes(xml1);
 0162                _fragment2 = encoding.GetBytes(xml2);
 0163                _fragment3 = encoding.GetBytes(xml3);
 0164                _fragment4 = encoding.GetBytes(xml4);
 0165            }
 166
 0167            public static TimestampCanonicalFormWriter Instance { get; } = new TimestampCanonicalFormWriter();
 168
 169            public void WriteCanonicalForm(Stream stream, string id, char[] created, char[] expires, byte[] workBuffer)
 170            {
 0171                stream.Write(_fragment1, 0, _fragment1.Length);
 0172                EncodeAndWrite(stream, workBuffer, id);
 0173                stream.Write(_fragment2, 0, _fragment2.Length);
 0174                EncodeAndWrite(stream, workBuffer, created);
 0175                stream.Write(_fragment3, 0, _fragment3.Length);
 0176                EncodeAndWrite(stream, workBuffer, expires);
 0177                stream.Write(_fragment4, 0, _fragment4.Length);
 0178            }
 179        }
 180    }
 181}
 182
Generated by: ReportGenerator 5.5.11.0
08/09/2026 - 10:15:50
GitHub | reportgenerator.io

Methods/Properties

.cctor()
.ctor(System.Xml.XmlDictionaryString)
Default()
NamespaceUri()
OneDotZero()
.ctor()
Instance()
IsReaderAtTimestamp(System.Xml.XmlDictionaryReader)
ReadTimestamp(System.Xml.XmlDictionaryReader,System.String,CoreWCF.IdentityModel.SignatureResourcePool)
WriteTimestamp(System.Xml.XmlDictionaryWriter,CoreWCF.Security.SecurityTimestamp)
WriteTimestampCanonicalForm(System.IO.Stream,CoreWCF.Security.SecurityTimestamp,System.Byte[])
.ctor()
Instance()
WriteCanonicalForm(System.IO.Stream,System.String,System.Char[],System.Char[],System.Byte[])