< Summary - CoreWCF Coverage — PR #1766

Information
Class: CoreWCF.Security.TransportSecurityProtocol
Assembly: CoreWCF.Primitives
File(s): /home/runner/work/CoreWCF/CoreWCF/src/CoreWCF.Primitives/src/CoreWCF/Security/TransportSecurityProtocol.cs
Line coverage
78%
Covered lines: 59
Uncovered lines: 16
Coverable lines: 75
Total lines: 170
Line coverage: 78.6%
Branch coverage
44%
Covered branches: 16
Total branches: 36
Branch coverage: 44.4%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Cyclomatic complexity NPath complexity Sequence coverage
.ctor(...)100%11100%
SecureOutgoingMessage(...)75%4466.66%
SecureOutgoingMessageAtResponder(...)100%44100%
VerifyIncomingMessageAsync()50%4485.71%
AttachRecipientSecurityProperty(...)100%11100%
VerifyIncomingMessageCoreAsync()29.16%242474.35%

File(s)

/home/runner/work/CoreWCF/CoreWCF/src/CoreWCF.Primitives/src/CoreWCF/Security/TransportSecurityProtocol.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.Threading;
 8using System.Threading.Tasks;
 9using CoreWCF.Channels;
 10using CoreWCF.Description;
 11using CoreWCF.IdentityModel.Policy;
 12using CoreWCF.IdentityModel.Selectors;
 13using CoreWCF.IdentityModel.Tokens;
 14using CoreWCF.Runtime;
 15
 16namespace CoreWCF.Security
 17{
 18    internal class TransportSecurityProtocol : SecurityProtocol
 19    {
 3420        public TransportSecurityProtocol(TransportSecurityProtocolFactory factory, EndpointAddress target, Uri via) : ba
 21        {
 3422        }
 23
 24        public override Message SecureOutgoingMessage(Message message, CancellationToken token)
 25        {
 6326            if (message == null)
 27            {
 028                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(message));
 29            }
 6330            CommunicationObject.ThrowIfClosedOrNotOpen();
 6331            string actor = string.Empty; // message.Version.Envelope.UltimateDestinationActor;
 32            try
 33            {
 6334                if (SecurityProtocolFactory.ActAsInitiator)
 35                {
 36                    Fx.Assert(false, "Server side code");
 37                }
 38                else
 39                {
 6340                    message = SecureOutgoingMessageAtResponder(message, actor);
 41                }
 6342                base.OnOutgoingMessageSecured(message);
 6343            }
 044            catch
 45            {
 046                base.OnSecureOutgoingMessageFailure(message);
 047                throw;
 48            }
 49
 6350            return message;
 51        }
 52
 53        protected virtual Message SecureOutgoingMessageAtResponder(Message message, string actor)
 54        {
 6355            if (SecurityProtocolFactory.AddTimestamp && !SecurityProtocolFactory.SecurityBindingElement.EnableUnsecuredR
 56            {
 6357                SendSecurityHeader securityHeader = CreateSendSecurityHeaderForTransportProtocol(message, actor, Securit
 6358                message = securityHeader.SetupExecution();
 59            }
 6360            return message;
 61        }
 62
 63        public sealed override async ValueTask<Message> VerifyIncomingMessageAsync(Message message, TimeSpan timeout)
 64        {
 9465            if (message == null)
 66            {
 067                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(message));
 68            }
 9469            CommunicationObject.ThrowIfClosedOrNotOpen();
 70            try
 71            {
 9472                Message verifiedMessage = await VerifyIncomingMessageCoreAsync(message, timeout);
 6373                return verifiedMessage;
 74
 75            }
 276            catch (MessageSecurityException e)
 77            {
 278                base.OnVerifyIncomingMessageFailure(message, e);
 279                throw;
 80            }
 2981            catch (Exception e)
 82            {
 83                // Always immediately rethrow fatal exceptions.
 2984                if (Fx.IsFatal(e))
 85                {
 086                    throw;
 87                }
 88
 2989                base.OnVerifyIncomingMessageFailure(message, e);
 2990                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new MessageSecurityException(SR.MessageSecurit
 91            }
 6392        }
 93
 94        protected void AttachRecipientSecurityProperty(Message message, IList<SecurityToken> basicTokens, IList<Security
 95           IList<SecurityToken> signedEndorsingTokens, IList<SecurityToken> signedTokens, Dictionary<SecurityToken, Read
 96        {
 6397            SecurityMessageProperty security = SecurityMessageProperty.GetOrCreate(message);
 6398            AddSupportingTokenSpecification(security, basicTokens, endorsingTokens, signedEndorsingTokens, signedTokens,
 6399            security.ServiceSecurityContext = new ServiceSecurityContext(security.GetInitiatorTokenAuthorizationPolicies
 63100        }
 101
 102        protected virtual async ValueTask<Message> VerifyIncomingMessageCoreAsync(Message message, TimeSpan timeout)
 103        {
 74104            TransportSecurityProtocolFactory factory = (TransportSecurityProtocolFactory)SecurityProtocolFactory;
 74105            string actor = string.Empty; // message.Version.Envelope.UltimateDestinationActor;
 106
 74107            ReceiveSecurityHeader securityHeader = factory.StandardsManager.TryCreateReceiveSecurityHeader(message, acto
 74108                factory.IncomingAlgorithmSuite, (factory.ActAsInitiator) ? MessageDirection.Output : MessageDirection.In
 74109            IList<SupportingTokenAuthenticatorSpecification> supportingAuthenticators = factory.GetSupportingTokenAuthen
 74110                out bool expectSignedTokens, out bool expectBasicTokens, out bool expectEndorsingTokens);
 74111            if (securityHeader == null)
 112            {
 0113                bool expectSupportingTokens = expectEndorsingTokens || expectSignedTokens || expectBasicTokens;
 0114                if ((factory.ActAsInitiator && (!factory.AddTimestamp || factory.SecurityBindingElement.EnableUnsecuredR
 0115                    || (!factory.ActAsInitiator && !factory.AddTimestamp && !expectSupportingTokens))
 116                {
 0117                    return message;
 118                }
 119                else
 120                {
 0121                    if (string.IsNullOrEmpty(actor))
 122                    {
 0123                        throw Diagnostics.TraceUtility.ThrowHelperError(new MessageSecurityException(
 0124                            SR.Format(SR.UnableToFindSecurityHeaderInMessageNoActor)), message);
 125                    }
 126                    else
 127                    {
 0128                        throw Diagnostics.TraceUtility.ThrowHelperError(new MessageSecurityException(
 0129                            SR.Format(SR.UnableToFindSecurityHeaderInMessage, actor)), message);
 130                    }
 131                }
 132            }
 133
 74134            securityHeader.RequireMessageProtection = false;
 74135            securityHeader.ExpectBasicTokens = expectBasicTokens;
 74136            securityHeader.ExpectSignedTokens = expectSignedTokens;
 74137            securityHeader.ExpectEndorsingTokens = expectEndorsingTokens;
 74138            securityHeader.MaxReceivedMessageSize = factory.SecurityBindingElement.MaxReceivedMessageSize;
 74139            securityHeader.ReaderQuotas = factory.SecurityBindingElement.ReaderQuotas;
 140
 141            // This was behind an app setting on WCF. If this breaks someone, it's because they are setting SecurityHead
 142            // wasn't being applied. The customer fix is to not set the SecurityHeaderLayout as that's what they were ef
 74143             securityHeader.Layout = factory.SecurityHeaderLayout;
 144
 74145            TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
 74146            if (!factory.ActAsInitiator)
 147            {
 74148                securityHeader.ConfigureTransportBindingServerReceiveHeader(supportingAuthenticators);
 74149                securityHeader.ConfigureOutOfBandTokenResolver(MergeOutOfBandResolvers(supportingAuthenticators, EmptyRe
 74150                if (factory.ExpectKeyDerivation)
 151                {
 0152                    securityHeader.DerivedTokenAuthenticator = factory.DerivedKeyTokenAuthenticator;
 153                }
 154            }
 74155            securityHeader.ReplayDetectionEnabled = factory.DetectReplays;
 74156            securityHeader.SetTimeParameters(factory.NonceCache, factory.ReplayWindow, factory.MaxClockSkew);
 74157            await securityHeader.ProcessAsync(timeoutHelper.RemainingTime(), SecurityUtils.GetChannelBindingFromMessage(
 43158            Message processedMessage = securityHeader.ProcessedMessage;
 43159            if (!factory.ActAsInitiator)
 160            {
 43161                AttachRecipientSecurityProperty(processedMessage, securityHeader.BasicSupportingTokens, securityHeader.E
 43162                    securityHeader.SignedSupportingTokens, securityHeader.SecurityTokenAuthorizationPoliciesMapping);
 163            }
 164
 43165            base.OnIncomingMessageVerified(processedMessage);
 166
 43167            return processedMessage;
 43168        }
 169    }
 170}
Generated by: ReportGenerator 5.5.11.0
08/09/2026 - 10:15:50
GitHub | reportgenerator.io

Methods/Properties

.ctor(CoreWCF.Security.TransportSecurityProtocolFactory,CoreWCF.EndpointAddress,System.Uri)
SecureOutgoingMessage(CoreWCF.Channels.Message,System.Threading.CancellationToken)
SecureOutgoingMessageAtResponder(CoreWCF.Channels.Message,System.String)
VerifyIncomingMessageAsync()
AttachRecipientSecurityProperty(CoreWCF.Channels.Message,System.Collections.Generic.IList`1<CoreWCF.IdentityModel.Tokens.SecurityToken>,System.Collections.Generic.IList`1<CoreWCF.IdentityModel.Tokens.SecurityToken>,System.Collections.Generic.IList`1<CoreWCF.IdentityModel.Tokens.SecurityToken>,System.Collections.Generic.IList`1<CoreWCF.IdentityModel.Tokens.SecurityToken>,System.Collections.Generic.Dictionary`2<CoreWCF.IdentityModel.Tokens.SecurityToken,System.Collections.ObjectModel.ReadOnlyCollection`1<CoreWCF.IdentityModel.Policy.IAuthorizationPolicy>>)
VerifyIncomingMessageCoreAsync()