< Summary - CoreWCF Coverage — PR #1766

Information
Class: CoreWCF.Channels.TransportSecurityBindingElement
Assembly: CoreWCF.Primitives
File(s): /home/runner/work/CoreWCF/CoreWCF/src/CoreWCF.Primitives/src/CoreWCF/Channels/TransportSecurityBindingElement.cs
Line coverage
78%
Covered lines: 74
Uncovered lines: 20
Coverable lines: 94
Total lines: 225
Line coverage: 78.7%
Branch coverage
70%
Covered branches: 24
Total branches: 34
Branch coverage: 70.5%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Cyclomatic complexity NPath complexity Sequence coverage
.ctor()100%11100%
.ctor(...)100%11100%
GetIndividualISecurityCapabilities()100%11100%
CreateSecurityProtocolFactory(...)50%4475%
BuildServiceDispatcherCore(...)83.33%181879.66%
GetProperty(...)75%8890.9%
Clone()100%11100%

File(s)

/home/runner/work/CoreWCF/CoreWCF/src/CoreWCF.Primitives/src/CoreWCF/Channels/TransportSecurityBindingElement.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.Net.Security;
 6using CoreWCF.Configuration;
 7using CoreWCF.Description;
 8using CoreWCF.Dispatcher;
 9using CoreWCF.Security;
 10using CoreWCF.Security.Tokens;
 11
 12namespace CoreWCF.Channels
 13{
 14    public sealed class TransportSecurityBindingElement : SecurityBindingElement //, IPolicyExportExtension
 15    {
 37216        public TransportSecurityBindingElement() : base()
 17        {
 37218        }
 19
 139220        private TransportSecurityBindingElement(TransportSecurityBindingElement elementToBeCloned) : base(elementToBeClo
 21        {
 22            // empty
 139223        }
 24
 25        internal override ISecurityCapabilities GetIndividualISecurityCapabilities()
 26        {
 18527            GetSupportingTokensCapabilities(out bool supportsClientAuthentication, out bool supportsClientWindowsIdentit
 18528            return new SecurityCapabilities(supportsClientAuthentication, false, supportsClientWindowsIdentity,
 18529                ProtectionLevel.None, ProtectionLevel.None);
 30        }
 31
 32        internal override bool SessionMode
 33        {
 34            get
 35            {
 036                SecureConversationSecurityTokenParameters scParameters = null;
 037                if (EndpointSupportingTokenParameters.Endorsing.Count > 0)
 38                {
 039                    scParameters = EndpointSupportingTokenParameters.Endorsing[0] as SecureConversationSecurityTokenPara
 40                }
 41
 042                if (scParameters != null)
 43                {
 044                    return scParameters.RequireCancellation;
 45                }
 46                else
 47                {
 048                    return false;
 49                }
 50            }
 51        }
 52
 53        internal override bool SupportsDuplex
 54        {
 6655            get { return true; }
 56        }
 57
 58        internal override bool SupportsRequestReply
 59        {
 6060            get { return true; }
 61        }
 62
 63
 64        internal override SecurityProtocolFactory CreateSecurityProtocolFactory<TChannel>(BindingContext context, Securi
 65        {
 3366            if (context == null)
 67            {
 068                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(context));
 69            }
 70
 3371            if (credentialsManager == null)
 72            {
 073                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(credentialsManager));
 74            }
 75
 3376            TransportSecurityProtocolFactory protocolFactory = new TransportSecurityProtocolFactory();
 77            // if (isForService)
 78            //     base.ApplyAuditBehaviorSettings(context, protocolFactory);
 3379            ConfigureProtocolFactory(protocolFactory, credentialsManager, isForService, issuerBindingContext, context.Bi
 3380            protocolFactory.DetectReplays = false;
 81
 3382            return protocolFactory;
 83        }
 84
 85        protected override IServiceDispatcher BuildServiceDispatcherCore<TChannel>(BindingContext context, IServiceDispa
 86        {
 3387            SecurityServiceDispatcher securityServiceDispatcher = new SecurityServiceDispatcher(context, serviceDispatch
 3388            SecurityCredentialsManager credentialsManager = serviceDispatcher.Host.Description.Behaviors.Find<SecurityCr
 3389            if (credentialsManager == null)
 90            {
 191                credentialsManager = ServiceCredentials.CreateDefaultCredentials();
 92            }
 93
 94            SecureConversationSecurityTokenParameters scParameters;
 3395            if (EndpointSupportingTokenParameters.Endorsing.Count > 0)
 96            {
 2497                scParameters = EndpointSupportingTokenParameters.Endorsing[0] as SecureConversationSecurityTokenParamete
 98            }
 99            else
 100            {
 9101                scParameters = null;
 102            }
 103
 33104            bool requireDemuxer = RequiresChannelDemuxer();
 33105            ChannelBuilder channelBuilder = new ChannelBuilder(context, requireDemuxer);
 106
 33107            if (requireDemuxer)
 108            {
 22109                ApplyPropertiesOnDemuxer(channelBuilder, context);
 110            }
 111
 33112            BindingContext issuerBindingContext = context.Clone();
 33113            issuerBindingContext.BindingParameters.Add(credentialsManager);
 33114            if (scParameters != null)
 115            {
 22116                if (scParameters.BootstrapSecurityBindingElement == null)
 117                {
 0118                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR
 119                }
 120
 22121                AddDemuxerForSecureConversation(channelBuilder, issuerBindingContext);
 122
 22123                if (scParameters.RequireCancellation)
 124                {
 22125                    SessionSymmetricTransportSecurityProtocolFactory sessionFactory = new SessionSymmetricTransportSecur
 22126                    {
 22127                        // base.ApplyAuditBehaviorSettings(context, sessionFactory);
 22128                        SecurityTokenParameters = scParameters.Clone()
 22129                    };
 22130                    ((SecureConversationSecurityTokenParameters)sessionFactory.SecurityTokenParameters).IssuerBindingCon
 22131                    EndpointSupportingTokenParameters.Endorsing.RemoveAt(0);
 132                    try
 133                    {
 22134                        ConfigureProtocolFactory(sessionFactory, credentialsManager, true, issuerBindingContext, context
 22135                    }
 136                    finally
 137                    {
 22138                        EndpointSupportingTokenParameters.Endorsing.Insert(0, scParameters);
 22139                    }
 140
 22141                    securityServiceDispatcher.SessionMode = true;
 22142                    securityServiceDispatcher.SessionServerSettings.InactivityTimeout = LocalServiceSettings.InactivityT
 22143                    securityServiceDispatcher.SessionServerSettings.KeyRolloverInterval = LocalServiceSettings.SessionKe
 22144                    securityServiceDispatcher.SessionServerSettings.MaximumPendingSessions = LocalServiceSettings.MaxPen
 22145                    securityServiceDispatcher.SessionServerSettings.MaximumKeyRenewalInterval = LocalServiceSettings.Ses
 22146                    securityServiceDispatcher.SessionServerSettings.TolerateTransportFailures = LocalServiceSettings.Rec
 22147                    securityServiceDispatcher.SessionServerSettings.CanRenewSession = scParameters.CanRenewSession;
 22148                    securityServiceDispatcher.SessionServerSettings.IssuedSecurityTokenParameters = scParameters.Clone()
 22149                    ((SecureConversationSecurityTokenParameters)securityServiceDispatcher.SessionServerSettings.IssuedSe
 22150                    securityServiceDispatcher.SessionServerSettings.SecurityStandardsManager = sessionFactory.StandardsM
 22151                    securityServiceDispatcher.SessionServerSettings.SessionProtocolFactory = sessionFactory;
 22152                    securityServiceDispatcher.SecurityProtocolFactory = sessionFactory;
 153
 154                    // pass in the error handler for handling unknown security sessions - dont do this if the underlying
 155                    // back faults in response to badly secured requests over duplex can result in DoS.
 22156                    if (context.BindingParameters != null && context.BindingParameters.Find<IChannelDemuxFailureHandler>
 22157                        && !IsUnderlyingDispatcherDuplex<TChannel>(context))
 158                    {
 22159                        context.BindingParameters.Add(new SecuritySessionServerSettings.SecuritySessionDemuxFailureHandl
 160                    }
 161                }
 162                else
 163                {
 164                    //TODO later
 0165                    TransportSecurityProtocolFactory protocolFactory = new TransportSecurityProtocolFactory();
 166                    // base.ApplyAuditBehaviorSettings(context, protocolFactory);
 0167                    EndpointSupportingTokenParameters.Endorsing.RemoveAt(0);
 168                    try
 169                    {
 0170                        ConfigureProtocolFactory(protocolFactory, credentialsManager, true, issuerBindingContext, contex
 0171                        SecureConversationSecurityTokenParameters acceleratedTokenParameters = (SecureConversationSecuri
 0172                        acceleratedTokenParameters.IssuerBindingContext = issuerBindingContext;
 0173                        protocolFactory.SecurityBindingElement.EndpointSupportingTokenParameters.Endorsing.Insert(0, acc
 0174                    }
 175                    finally
 176                    {
 0177                        EndpointSupportingTokenParameters.Endorsing.Insert(0, scParameters);
 0178                    }
 179
 0180                    securityServiceDispatcher.SecurityProtocolFactory = protocolFactory;
 181                }
 182            }
 183            else
 184            {
 11185                SecurityProtocolFactory protocolFactory = CreateSecurityProtocolFactory<TChannel>(context, credentialsMa
 11186                securityServiceDispatcher.SecurityProtocolFactory = protocolFactory;
 187            }
 33188            securityServiceDispatcher.InitializeSecurityDispatcher(channelBuilder, typeof(TChannel));
 189            //return channelListener;
 33190            channelBuilder.BuildServiceDispatcher<TChannel>(context, securityServiceDispatcher);
 33191            return securityServiceDispatcher;
 192        }
 193
 194        public override T GetProperty<T>(BindingContext context)
 195        {
 441196            if (context == null)
 197            {
 0198                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(context));
 199            }
 200
 441201            if (typeof(T) == typeof(ChannelProtectionRequirements))
 202            {
 9203                AddressingVersion addressing = MessageVersion.Default.Addressing;
 9204                MessageEncodingBindingElement encoding = context.Binding.Elements.Find<MessageEncodingBindingElement>();
 9205                if (encoding != null)
 206                {
 9207                    addressing = encoding.MessageVersion.Addressing;
 208                }
 209
 9210                ChannelProtectionRequirements myRequirements = GetProtectionRequirements(addressing, ProtectionLevel.Enc
 9211                myRequirements.Add(context.GetInnerProperty<ChannelProtectionRequirements>() ?? new ChannelProtectionReq
 9212                return (T)(object)myRequirements;
 213            }
 214            else
 215            {
 432216                return base.GetProperty<T>(context);
 217            }
 218        }
 219
 220        public override BindingElement Clone()
 221        {
 1392222            return new TransportSecurityBindingElement(this);
 223        }
 224    }
 225}
Generated by: ReportGenerator 5.5.11.0
08/09/2026 - 10:15:49
GitHub | reportgenerator.io

Methods/Properties

.ctor()
.ctor(CoreWCF.Channels.TransportSecurityBindingElement)
GetIndividualISecurityCapabilities()
SessionMode()
SupportsDuplex()
SupportsRequestReply()
CreateSecurityProtocolFactory(CoreWCF.Channels.BindingContext,CoreWCF.Security.SecurityCredentialsManager,System.Boolean,CoreWCF.Channels.BindingContext)
BuildServiceDispatcherCore(CoreWCF.Channels.BindingContext,CoreWCF.Configuration.IServiceDispatcher)
GetProperty(CoreWCF.Channels.BindingContext)
Clone()