< Summary - CoreWCF Coverage — PR #1766

Information
Class: CoreWCF.Security.SendSecurityHeader
Assembly: CoreWCF.Primitives
File(s): /home/runner/work/CoreWCF/CoreWCF/src/CoreWCF.Primitives/src/CoreWCF/Security/SendSecurityHeader.cs
Line coverage
25%
Covered lines: 111
Uncovered lines: 327
Coverable lines: 438
Total lines: 1031
Line coverage: 25.3%
Branch coverage
24%
Covered branches: 69
Total branches: 280
Branch coverage: 24.6%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Cyclomatic complexity NPath complexity Sequence coverage
.ctor(...)100%11100%
.cctor()100%11100%
AddPrerequisiteToken(...)0%220%
AddParameters(...)0%220%
SetSigningToken(...)0%880%
SetEncryptionToken(...)0%880%
AddBasicSupportingToken(...)0%660%
AddEndorsingSupportingToken(...)0%440%
AddSignedEndorsingSupportingToken(...)0%660%
AddSignedSupportingToken(...)0%440%
AddSignatureConfirmations(...)100%110%
AddTimestamp(...)50%22100%
AddTimestamp(...)50%4480%
CreateSignatureConfirmationElements(...)100%110%
StartEncryption()5.55%18185.26%
CompleteEncryption()25%4458.82%
StartSecurityApplication()50%2250%
CompleteSecurityApplication()50%4460%
RemoveSignatureEncryptionIfAppropriate()38.88%181887.5%
GenerateId()50%4466.66%
GetSignatureValues()100%110%
OnWriteStartHeader(...)100%11100%
ShouldSerializeToken(...)0%550%
OnWriteHeaderContents(...)52.38%848447.05%
SetupExecution()25%8860%
GetTokenReferenceStyle(...)0%220%
StartSignature()5.55%18186.89%
CompleteSignature()50%2238.46%
SignWithSupportingToken(...)0%14140%
SignWithSupportingTokens()20%202013.51%
ShouldUseStrTransformForToken(...)0%11110%
AddGeneratedSignatureValue(...)0%660%

File(s)

/home/runner/work/CoreWCF/CoreWCF/src/CoreWCF.Primitives/src/CoreWCF/Security/SendSecurityHeader.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.Threading.Tasks;
 7using System.Xml;
 8using CoreWCF.Channels;
 9using CoreWCF.Description;
 10using CoreWCF.Diagnostics;
 11using CoreWCF.IdentityModel;
 12using CoreWCF.IdentityModel.Tokens;
 13using CoreWCF.Security.Tokens;
 14using DictionaryManager = CoreWCF.IdentityModel.DictionaryManager;
 15using IPrefixGenerator = CoreWCF.IdentityModel.IPrefixGenerator;
 16using ISecurityElement = CoreWCF.IdentityModel.ISecurityElement;
 17using ISignatureValueSecurityElement = CoreWCF.IdentityModel.ISignatureValueSecurityElement;
 18
 19namespace CoreWCF.Security
 20{
 21    internal abstract class SendSecurityHeader : SecurityHeader, IMessageHeaderWithSharedNamespace
 22    {
 23        private bool _basicTokenEncrypted;
 24        private bool _primarySignatureDone;
 25        private bool _encryptSignature;
 26        private SignatureConfirmations _signatureValuesGenerated;
 27        private SignatureConfirmations _signatureConfirmationsToSend;
 28        private int _idCounter;
 29        private string _idPrefix;
 30        private MessagePartSpecification _signatureParts;
 31        private MessagePartSpecification _encryptionParts;
 32        private SecurityTokenParameters _encryptingTokenParameters;
 33        private List<SecurityToken> _basicTokens = null;
 34        private List<SecurityTokenParameters> _basicSupportingTokenParameters = null;
 35        private List<SecurityTokenParameters> _endorsingTokenParameters = null;
 36        private List<SecurityTokenParameters> _signedEndorsingTokenParameters = null;
 37        private List<SecurityTokenParameters> _signedTokenParameters = null;
 38        private SecurityToken _encryptingToken;
 39        private bool _skipKeyInfoForEncryption;
 40        private bool _shouldProtectTokens;
 41        private BufferManager _bufferManager;
 42        private SecurityProtocolCorrelationState _correlationState;
 6343        private bool _signThenEncrypt = true;
 244        private static readonly string[] s_ids = new string[] { "_0", "_1", "_2", "_3", "_4", "_5", "_6", "_7", "_8", "_
 45
 46        protected SendSecurityHeader(Message message, string actor, bool mustUnderstand, bool relay,
 47            SecurityStandardsManager standardsManager,
 48            SecurityAlgorithmSuite algorithmSuite,
 49            MessageDirection transferDirection)
 6350            : base(message, actor, mustUnderstand, relay, standardsManager, algorithmSuite, transferDirection)
 51        {
 6352            ElementContainer = new SendSecurityHeaderElementContainer();
 6353        }
 54
 239455        public SendSecurityHeaderElementContainer ElementContainer { get; }
 56
 57        public SecurityProtocolCorrelationState CorrelationState
 58        {
 059            get { return _correlationState; }
 60            set
 61            {
 062                ThrowIfProcessingStarted();
 063                _correlationState = value;
 064            }
 65        }
 66
 67        public BufferManager StreamBufferManager
 68        {
 69            get
 70            {
 071                if (_bufferManager == null)
 72                {
 073                    _bufferManager = BufferManager.CreateBufferManager(0, int.MaxValue);
 74                }
 75
 076                return _bufferManager;
 77            }
 78            set
 79            {
 6380                _bufferManager = value;
 6381            }
 82        }
 83
 84        public MessagePartSpecification EncryptionParts
 85        {
 086            get { return _encryptionParts; }
 87            set
 88            {
 089                ThrowIfProcessingStarted();
 090                if (value == null)
 91                {
 092                    throw TraceUtility.ThrowHelperError(new ArgumentNullException(nameof(value)), Message);
 93                }
 094                if (!value.IsReadOnly)
 95                {
 096                    throw TraceUtility.ThrowHelperError(new InvalidOperationException(SR.MessagePartSpecificationMustBeI
 97                }
 098                _encryptionParts = value;
 099            }
 100        }
 101
 102        public bool EncryptPrimarySignature
 103        {
 63104            get { return _encryptSignature; }
 105            set
 106            {
 0107                ThrowIfProcessingStarted();
 0108                _encryptSignature = value;
 0109            }
 110        }
 111
 0112        internal byte[] PrimarySignatureValue { get; private set; } = null;
 113
 0114        protected internal SecurityTokenParameters SigningTokenParameters { get; private set; }
 115
 185116        protected bool ShouldSignToHeader { get; private set; } = false;
 117
 118        public string IdPrefix
 119        {
 0120            get { return _idPrefix; }
 121            set
 122            {
 0123                ThrowIfProcessingStarted();
 0124                _idPrefix = string.IsNullOrEmpty(value) || value == "_" ? null : value;
 0125            }
 126        }
 127
 0128        public override string Name => StandardsManager.SecurityVersion.HeaderName.Value;
 129
 68130        public override string Namespace => StandardsManager.SecurityVersion.HeaderNamespace.Value;
 131
 63132        protected SecurityAppliedMessage SecurityAppliedMessage => (SecurityAppliedMessage)Message;
 133
 134        public bool SignThenEncrypt
 135        {
 378136            get { return _signThenEncrypt; }
 137            set
 138            {
 0139                ThrowIfProcessingStarted();
 0140                _signThenEncrypt = value;
 0141            }
 142        }
 143
 144        public bool ShouldProtectTokens
 145        {
 0146            get { return _shouldProtectTokens; }
 147            set
 148            {
 0149                ThrowIfProcessingStarted();
 0150                _shouldProtectTokens = value;
 0151            }
 152        }
 153
 154        public MessagePartSpecification SignatureParts
 155        {
 0156            get { return _signatureParts; }
 157            set
 158            {
 0159                ThrowIfProcessingStarted();
 0160                if (value == null)
 161                {
 0162                    throw TraceUtility.ThrowHelperError(new ArgumentNullException(nameof(value)), Message);
 163                }
 0164                if (!value.IsReadOnly)
 165                {
 0166                    throw TraceUtility.ThrowHelperError(new InvalidOperationException(
 0167                        SR.MessagePartSpecificationMustBeImmutable), Message);
 168                }
 0169                _signatureParts = value;
 0170            }
 171        }
 172
 0173        public SecurityTimestamp Timestamp => ElementContainer.Timestamp;
 174
 0175        public bool HasSignedTokens { get; private set; }
 176
 0177        public bool HasEncryptedTokens { get; private set; }
 178
 179        public void AddPrerequisiteToken(SecurityToken token)
 180        {
 0181            ThrowIfProcessingStarted();
 0182            ElementContainer.PrerequisiteToken = token ?? throw TraceUtility.ThrowHelperError(new Exception(nameof(token
 0183        }
 184
 185        private void AddParameters(ref List<SecurityTokenParameters> list, SecurityTokenParameters item)
 186        {
 0187            if (list == null)
 188            {
 0189                list = new List<SecurityTokenParameters>();
 190            }
 0191            list.Add(item);
 0192        }
 193
 194        public abstract void ApplyBodySecurity(XmlDictionaryWriter writer, IPrefixGenerator prefixGenerator);
 195
 196        public abstract ValueTask ApplyBodySecurityAsync(XmlDictionaryWriter writer, IPrefixGenerator prefixGenerator);
 197
 198        public abstract void ApplySecurityAndWriteHeaders(MessageHeaders headers, XmlDictionaryWriter writer, IPrefixGen
 199
 200        public abstract ValueTask ApplySecurityAndWriteHeadersAsync(MessageHeaders headers, XmlDictionaryWriter writer, 
 201
 0202        protected virtual bool HasSignedEncryptedMessagePart => false;
 203
 204        public void SetSigningToken(SecurityToken token, SecurityTokenParameters tokenParameters)
 205        {
 0206            ThrowIfProcessingStarted();
 0207            if ((token == null && tokenParameters != null) || (token != null && tokenParameters == null))
 208            {
 0209                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.Format(SR.TokenMustBe
 210            }
 0211            ElementContainer.SourceSigningToken = token;
 0212            SigningTokenParameters = tokenParameters;
 0213        }
 214
 215        public void SetEncryptionToken(SecurityToken token, SecurityTokenParameters tokenParameters)
 216        {
 0217            ThrowIfProcessingStarted();
 0218            if ((token == null && tokenParameters != null) || (token != null && tokenParameters == null))
 219            {
 0220                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.Format(SR.TokenMustBe
 221            }
 0222            ElementContainer.SourceEncryptionToken = token;
 0223            _encryptingTokenParameters = tokenParameters;
 0224        }
 225
 226        public void AddBasicSupportingToken(SecurityToken token, SecurityTokenParameters parameters)
 227        {
 0228            if (token == null)
 229            {
 0230                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(token));
 231            }
 232
 0233            if (parameters == null)
 234            {
 0235                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(parameters));
 236            }
 237
 0238            ThrowIfProcessingStarted();
 0239            SendSecurityHeaderElement tokenElement = new SendSecurityHeaderElement(token.Id, new TokenElement(token, Sta
 0240            {
 0241                MarkedForEncryption = true
 0242            };
 0243            ElementContainer.AddBasicSupportingToken(tokenElement);
 0244            HasEncryptedTokens = true;
 0245            HasSignedTokens = true;
 0246            AddParameters(ref _basicSupportingTokenParameters, parameters);
 0247            if (_basicTokens == null)
 248            {
 0249                _basicTokens = new List<SecurityToken>();
 250            }
 251            //  We maintain a list of the basic tokens for the SignThenEncrypt case as we will
 252            //  need this token to write STR entry on OnWriteHeaderContents.
 0253            _basicTokens.Add(token);
 0254        }
 255
 256        public void AddEndorsingSupportingToken(SecurityToken token, SecurityTokenParameters parameters)
 257        {
 0258            if (token == null)
 259            {
 0260                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(token));
 261            }
 262
 0263            if (parameters == null)
 264            {
 0265                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(parameters));
 266            }
 267
 0268            ThrowIfProcessingStarted();
 0269            ElementContainer.AddEndorsingSupportingToken(token);
 270            // The ProviderBackedSecurityToken was added for the ChannelBindingToken (CBT) effort for win7.
 271            // We can assume the key is of type symmetric key.
 272            //
 273            // Asking for the key type from the token will cause the ProviderBackedSecurityToken
 274            // to attempt to resolve the token and the nego will start.
 275            //
 276            // We don't want that.
 277            // We want to defer the nego until after the CBT is available in SecurityAppliedMessage.OnWriteMessage.
 278            //TODO
 279            //if (!(token is ProviderBackedSecurityToken))
 280            //{
 281            //    this.shouldSignToHeader |= (!this.RequireMessageProtection) && (SecurityUtils.GetSecurityKey<Asymmetri
 282            //}
 0283            AddParameters(ref _endorsingTokenParameters, parameters);
 0284        }
 285
 286        public void AddSignedEndorsingSupportingToken(SecurityToken token, SecurityTokenParameters parameters)
 287        {
 0288            if (token == null)
 289            {
 0290                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(token));
 291            }
 292
 0293            if (parameters == null)
 294            {
 0295                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(parameters));
 296            }
 297
 0298            ThrowIfProcessingStarted();
 0299            ElementContainer.AddSignedEndorsingSupportingToken(token);
 0300            HasSignedTokens = true;
 0301            ShouldSignToHeader |= (!RequireMessageProtection) && (SecurityUtils.GetSecurityKey<AsymmetricSecurityKey>(to
 0302            AddParameters(ref _signedEndorsingTokenParameters, parameters);
 0303        }
 304
 305        public void AddSignedSupportingToken(SecurityToken token, SecurityTokenParameters parameters)
 306        {
 0307            if (token == null)
 308            {
 0309                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(token));
 310            }
 311
 0312            if (parameters == null)
 313            {
 0314                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(parameters));
 315            }
 316
 0317            ThrowIfProcessingStarted();
 0318            ElementContainer.AddSignedSupportingToken(token);
 0319            HasSignedTokens = true;
 0320            AddParameters(ref _signedTokenParameters, parameters);
 0321        }
 322
 323        public void AddSignatureConfirmations(SignatureConfirmations confirmations)
 324        {
 0325            ThrowIfProcessingStarted();
 0326            _signatureConfirmationsToSend = confirmations;
 0327        }
 328
 329        public void AddTimestamp(TimeSpan timestampValidityDuration)
 330        {
 63331            DateTime now = DateTime.UtcNow;
 63332            string id = RequireMessageProtection ? SecurityUtils.GenerateId() : GenerateId();
 63333            AddTimestamp(new SecurityTimestamp(now, now + timestampValidityDuration, id));
 63334        }
 335
 336        public void AddTimestamp(SecurityTimestamp timestamp)
 337        {
 63338            ThrowIfProcessingStarted();
 63339            if (ElementContainer.Timestamp != null)
 340            {
 0341                throw TraceUtility.ThrowHelperError(new InvalidOperationException(SR.TimestampAlreadySetForSecurityHeade
 342            }
 343
 63344            ElementContainer.Timestamp = timestamp ?? throw TraceUtility.ThrowHelperArgumentNull(nameof(timestamp), Mess
 63345        }
 346
 347        protected virtual ISignatureValueSecurityElement[] CreateSignatureConfirmationElements(SignatureConfirmations si
 348        {
 0349            throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
 0350                SR.Format(SR.SignatureConfirmationNotSupported)));
 351        }
 352
 353        private void StartEncryption()
 354        {
 63355            if (ElementContainer.SourceEncryptionToken == null)
 356            {
 63357                return;
 358            }
 359            // determine the key identifier clause to use for the source
 0360            SecurityTokenReferenceStyle sourceEncryptingKeyReferenceStyle = GetTokenReferenceStyle(_encryptingTokenParam
 0361            bool encryptionTokenSerialized = sourceEncryptingKeyReferenceStyle == SecurityTokenReferenceStyle.Internal;
 0362            SecurityKeyIdentifierClause sourceEncryptingKeyIdentifierClause = _encryptingTokenParameters.CreateKeyIdenti
 0363            if (sourceEncryptingKeyIdentifierClause == null)
 364            {
 0365                throw TraceUtility.ThrowHelperError(new MessageSecurityException(SR.TokenManagerCannotCreateTokenReferen
 366            }
 367            SecurityToken sourceToken;
 368            SecurityKeyIdentifierClause sourceTokenIdentifierClause;
 369
 370            // if the source token cannot do symmetric crypto, create a wrapped key
 0371            if (!SecurityUtils.HasSymmetricSecurityKey(ElementContainer.SourceEncryptionToken))
 372            {
 0373                int keyLength = Math.Max(128, AlgorithmSuite.DefaultSymmetricKeyLength);
 0374                CryptoHelper.ValidateSymmetricKeyLength(keyLength, AlgorithmSuite);
 0375                byte[] key = new byte[keyLength / 8];
 0376                CryptoHelper.FillRandomBytes(key);
 0377                AlgorithmSuite.GetKeyWrapAlgorithm(ElementContainer.SourceEncryptionToken, out string keyWrapAlgorithm, 
 0378                WrappedKeySecurityToken wrappedKey = new WrappedKeySecurityToken(GenerateId(), key, keyWrapAlgorithm, ke
 0379                    ElementContainer.SourceEncryptionToken, new SecurityKeyIdentifier(sourceEncryptingKeyIdentifierClaus
 0380                ElementContainer.WrappedEncryptionToken = wrappedKey;
 0381                sourceToken = wrappedKey;
 0382                sourceTokenIdentifierClause = new LocalIdKeyIdentifierClause(wrappedKey.Id, wrappedKey.GetType());
 0383                encryptionTokenSerialized = true;
 384            }
 385            else
 386            {
 0387                sourceToken = ElementContainer.SourceEncryptionToken;
 0388                sourceTokenIdentifierClause = sourceEncryptingKeyIdentifierClause;
 389            }
 390
 391            // determine if a key needs to be derived
 392            SecurityKeyIdentifierClause encryptingKeyIdentifierClause;
 393            // determine if a token needs to be derived
 0394            if (_encryptingTokenParameters.RequireDerivedKeys)
 395            {
 0396                string derivationAlgorithm = AlgorithmSuite.GetEncryptionKeyDerivationAlgorithm(sourceToken, StandardsMa
 0397                string expectedDerivationAlgorithm = SecurityUtils.GetKeyDerivationAlgorithm(StandardsManager.MessageSec
 0398                if (derivationAlgorithm == expectedDerivationAlgorithm)
 399                {
 0400                    DerivedKeySecurityToken derivedEncryptingToken = new DerivedKeySecurityToken(-1, 0,
 0401                        AlgorithmSuite.GetEncryptionKeyDerivationLength(sourceToken, StandardsManager.MessageSecurityVer
 0402                    _encryptingToken = ElementContainer.DerivedEncryptionToken = derivedEncryptingToken;
 0403                    encryptingKeyIdentifierClause = new LocalIdKeyIdentifierClause(derivedEncryptingToken.Id, derivedEnc
 404                }
 405                else
 406                {
 0407                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR.Format(SR.Uns
 408                }
 409            }
 410            else
 411            {
 0412                _encryptingToken = sourceToken;
 0413                encryptingKeyIdentifierClause = sourceTokenIdentifierClause;
 414            }
 415
 0416            _skipKeyInfoForEncryption = encryptionTokenSerialized && EncryptedKeyContainsReferenceList && (_encryptingTo
 417            SecurityKeyIdentifier identifier;
 0418            if (_skipKeyInfoForEncryption)
 419            {
 0420                identifier = null;
 421            }
 422            else
 423            {
 0424                identifier = new SecurityKeyIdentifier(encryptingKeyIdentifierClause);
 425            }
 426
 0427            StartEncryptionCore(_encryptingToken, identifier);
 0428        }
 429
 430        private void CompleteEncryption()
 431        {
 63432            ISecurityElement referenceList = CompleteEncryptionCore(
 63433                ElementContainer.PrimarySignature,
 63434                ElementContainer.GetBasicSupportingTokens(),
 63435                ElementContainer.GetSignatureConfirmations(),
 63436                ElementContainer.GetEndorsingSignatures());
 437
 63438            if (referenceList == null)
 439            {
 440                // null out all the encryption fields since there is no encryption needed
 63441                ElementContainer.SourceEncryptionToken = null;
 63442                ElementContainer.WrappedEncryptionToken = null;
 63443                ElementContainer.DerivedEncryptionToken = null;
 63444                return;
 445            }
 446
 0447            if (_skipKeyInfoForEncryption)
 448            {
 0449                WrappedKeySecurityToken wrappedKeyToken = _encryptingToken as WrappedKeySecurityToken;
 0450                wrappedKeyToken.EnsureEncryptedKeySetUp();
 0451                wrappedKeyToken.EncryptedKey.ReferenceList = (ReferenceList)referenceList;
 452            }
 453            else
 454            {
 0455                ElementContainer.ReferenceList = referenceList;
 456            }
 0457            _basicTokenEncrypted = true;
 0458        }
 459
 460        internal void StartSecurityApplication()
 461        {
 63462            if (SignThenEncrypt)
 463            {
 63464                StartSignature();
 63465                StartEncryption();
 466            }
 467            else
 468            {
 0469                StartEncryption();
 0470                StartSignature();
 471            }
 0472        }
 473
 474        internal void CompleteSecurityApplication()
 475        {
 63476            if (SignThenEncrypt)
 477            {
 63478                CompleteSignature();
 63479                SignWithSupportingTokens();
 63480                CompleteEncryption();
 481            }
 482            else
 483            {
 0484                CompleteEncryption();
 0485                CompleteSignature();
 0486                SignWithSupportingTokens();
 487            }
 488
 63489            if (_correlationState != null)
 490            {
 0491                _correlationState.SignatureConfirmations = GetSignatureValues();
 492            }
 63493        }
 494
 495        public void RemoveSignatureEncryptionIfAppropriate()
 496        {
 63497            if (SignThenEncrypt &&
 63498                EncryptPrimarySignature &&
 63499                (SecurityAppliedMessage.BodyProtectionMode != MessagePartProtectionMode.SignThenEncrypt) &&
 63500                (_basicSupportingTokenParameters == null || _basicSupportingTokenParameters.Count == 0) &&
 63501                (_signatureConfirmationsToSend == null || _signatureConfirmationsToSend.Count == 0 || !_signatureConfirm
 63502                !HasSignedEncryptedMessagePart)
 503            {
 0504                _encryptSignature = false;
 505            }
 63506        }
 507
 508        public string GenerateId()
 509        {
 63510            int id = _idCounter++;
 511
 63512            if (_idPrefix != null)
 513            {
 0514                return _idPrefix + id;
 515            }
 516
 63517            if (id < s_ids.Length)
 518            {
 63519                return s_ids[id];
 520            }
 521            else
 522            {
 0523                return "_" + id;
 524            }
 525        }
 526
 527        private SignatureConfirmations GetSignatureValues()
 528        {
 0529            return _signatureValuesGenerated;
 530        }
 531
 532        protected override void OnWriteStartHeader(XmlDictionaryWriter writer, MessageVersion messageVersion)
 533        {
 63534            StandardsManager.SecurityVersion.WriteStartHeader(writer);
 63535            WriteHeaderAttributes(writer, messageVersion);
 63536        }
 537
 538        internal static bool ShouldSerializeToken(SecurityTokenParameters parameters, MessageDirection transferDirection
 539        {
 0540            switch (parameters.InclusionMode)
 541            {
 542                case SecurityTokenInclusionMode.AlwaysToInitiator:
 0543                    return (transferDirection == MessageDirection.Output);
 544                case SecurityTokenInclusionMode.Once:
 545                case SecurityTokenInclusionMode.AlwaysToRecipient:
 0546                    return (transferDirection == MessageDirection.Input);
 547                case SecurityTokenInclusionMode.Never:
 0548                    return false;
 549                default:
 0550                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR.Format(SR.Uns
 551            }
 552        }
 553
 554        protected override void OnWriteHeaderContents(XmlDictionaryWriter writer, MessageVersion messageVersion)
 555        {
 63556            if (_basicSupportingTokenParameters != null && _basicSupportingTokenParameters.Count > 0
 63557                && RequireMessageProtection && !_basicTokenEncrypted)
 558            {
 0559                throw TraceUtility.ThrowHelperError(new InvalidOperationException(SR.BasicTokenCannotBeWrittenWithoutEnc
 560            }
 561
 63562            if (ElementContainer.Timestamp != null && Layout != SecurityHeaderLayout.LaxTimestampLast)
 563            {
 63564                StandardsManager.WSUtilitySpecificationVersion.WriteTimestamp(writer, ElementContainer.Timestamp);
 565            }
 63566            if (ElementContainer.PrerequisiteToken != null)
 567            {
 0568                StandardsManager.SecurityTokenSerializer.WriteToken(writer, ElementContainer.PrerequisiteToken);
 569            }
 63570            if (ElementContainer.SourceSigningToken != null)
 571            {
 0572                if (ShouldSerializeToken(SigningTokenParameters, MessageDirection))
 573                {
 0574                    StandardsManager.SecurityTokenSerializer.WriteToken(writer, ElementContainer.SourceSigningToken);
 575
 576                    // Implement Protect token
 577                    // NOTE: The spec says sign the primary token if it is not included in the message. But we currently
 578                    // as we do not support STR-Transform for external references. Hence we can not sign the token which
 579                    // This only affects the messages from service to client where
 580                    // 1. allowSerializedSigningTokenOnReply is false.
 581                    // 2. SymmetricSecurityBindingElement with IssuedTokens binding where the issued token has a symmetr
 582
 0583                    if (ShouldProtectTokens)
 584                    {
 0585                        WriteSecurityTokenReferencyEntry(writer, ElementContainer.SourceSigningToken, SigningTokenParame
 586                    }
 587                }
 588            }
 63589            if (ElementContainer.DerivedSigningToken != null)
 590            {
 0591                StandardsManager.SecurityTokenSerializer.WriteToken(writer, ElementContainer.DerivedSigningToken);
 592            }
 63593            if (ElementContainer.SourceEncryptionToken != null && ElementContainer.SourceEncryptionToken != ElementConta
 594            {
 0595                StandardsManager.SecurityTokenSerializer.WriteToken(writer, ElementContainer.SourceEncryptionToken);
 596            }
 63597            if (ElementContainer.WrappedEncryptionToken != null)
 598            {
 0599                StandardsManager.SecurityTokenSerializer.WriteToken(writer, ElementContainer.WrappedEncryptionToken);
 600            }
 63601            if (ElementContainer.DerivedEncryptionToken != null)
 602            {
 0603                StandardsManager.SecurityTokenSerializer.WriteToken(writer, ElementContainer.DerivedEncryptionToken);
 604            }
 63605            if (SignThenEncrypt)
 606            {
 63607                if (ElementContainer.ReferenceList != null)
 608                {
 0609                    ElementContainer.ReferenceList.WriteTo(writer, ServiceModelDictionaryManager.Instance);
 610                }
 611            }
 612
 63613            SecurityToken[] signedTokens = ElementContainer.GetSignedSupportingTokens();
 63614            if (signedTokens != null)
 615            {
 0616                for (int i = 0; i < signedTokens.Length; ++i)
 617                {
 0618                    StandardsManager.SecurityTokenSerializer.WriteToken(writer, signedTokens[i]);
 0619                    WriteSecurityTokenReferencyEntry(writer, signedTokens[i], _signedTokenParameters[i]);
 620                }
 621            }
 63622            SendSecurityHeaderElement[] basicTokensXml = ElementContainer.GetBasicSupportingTokens();
 63623            if (basicTokensXml != null)
 624            {
 0625                for (int i = 0; i < basicTokensXml.Length; ++i)
 626                {
 0627                    basicTokensXml[i].Item.WriteTo(writer, ServiceModelDictionaryManager.Instance);
 0628                    if (SignThenEncrypt)
 629                    {
 0630                        WriteSecurityTokenReferencyEntry(writer, _basicTokens[i], _basicSupportingTokenParameters[i]);
 631                    }
 632                }
 633            }
 63634            SecurityToken[] endorsingTokens = ElementContainer.GetEndorsingSupportingTokens();
 63635            if (endorsingTokens != null)
 636            {
 0637                for (int i = 0; i < endorsingTokens.Length; ++i)
 638                {
 0639                    if (ShouldSerializeToken(_endorsingTokenParameters[i], MessageDirection))
 640                    {
 0641                        StandardsManager.SecurityTokenSerializer.WriteToken(writer, endorsingTokens[i]);
 642                    }
 643                }
 644            }
 63645            SecurityToken[] endorsingDerivedTokens = ElementContainer.GetEndorsingDerivedSupportingTokens();
 63646            if (endorsingDerivedTokens != null)
 647            {
 0648                for (int i = 0; i < endorsingDerivedTokens.Length; ++i)
 649                {
 0650                    StandardsManager.SecurityTokenSerializer.WriteToken(writer, endorsingDerivedTokens[i]);
 651                }
 652            }
 63653            SecurityToken[] signedEndorsingTokens = ElementContainer.GetSignedEndorsingSupportingTokens();
 63654            if (signedEndorsingTokens != null)
 655            {
 0656                for (int i = 0; i < signedEndorsingTokens.Length; ++i)
 657                {
 0658                    StandardsManager.SecurityTokenSerializer.WriteToken(writer, signedEndorsingTokens[i]);
 0659                    WriteSecurityTokenReferencyEntry(writer, signedEndorsingTokens[i], _signedEndorsingTokenParameters[i
 660                }
 661            }
 63662            SecurityToken[] signedEndorsingDerivedTokens = ElementContainer.GetSignedEndorsingDerivedSupportingTokens();
 63663            if (signedEndorsingDerivedTokens != null)
 664            {
 0665                for (int i = 0; i < signedEndorsingDerivedTokens.Length; ++i)
 666                {
 0667                    StandardsManager.SecurityTokenSerializer.WriteToken(writer, signedEndorsingDerivedTokens[i]);
 668                }
 669            }
 63670            SendSecurityHeaderElement[] signatureConfirmations = ElementContainer.GetSignatureConfirmations();
 63671            if (signatureConfirmations != null)
 672            {
 0673                for (int i = 0; i < signatureConfirmations.Length; ++i)
 674                {
 0675                    signatureConfirmations[i].Item.WriteTo(writer, ServiceModelDictionaryManager.Instance);
 676                }
 677            }
 63678            if (ElementContainer.PrimarySignature != null && ElementContainer.PrimarySignature.Item != null)
 679            {
 0680                ElementContainer.PrimarySignature.Item.WriteTo(writer, ServiceModelDictionaryManager.Instance);
 681            }
 63682            SendSecurityHeaderElement[] endorsingSignatures = ElementContainer.GetEndorsingSignatures();
 63683            if (endorsingSignatures != null)
 684            {
 0685                for (int i = 0; i < endorsingSignatures.Length; ++i)
 686                {
 0687                    endorsingSignatures[i].Item.WriteTo(writer, ServiceModelDictionaryManager.Instance);
 688                }
 689            }
 63690            if (!SignThenEncrypt)
 691            {
 0692                if (ElementContainer.ReferenceList != null)
 693                {
 0694                    ElementContainer.ReferenceList.WriteTo(writer, ServiceModelDictionaryManager.Instance);
 695                }
 696            }
 63697            if (ElementContainer.Timestamp != null && Layout == SecurityHeaderLayout.LaxTimestampLast)
 698            {
 0699                StandardsManager.WSUtilitySpecificationVersion.WriteTimestamp(writer, ElementContainer.Timestamp);
 700            }
 63701        }
 702
 703        protected abstract void WriteSecurityTokenReferencyEntry(XmlDictionaryWriter writer, SecurityToken securityToken
 704
 705        public Message SetupExecution()
 706        {
 63707            ThrowIfProcessingStarted();
 63708            SetProcessingStarted();
 709
 63710            bool signBody = false;
 63711            if (ElementContainer.SourceSigningToken != null)
 712            {
 0713                if (_signatureParts == null)
 714                {
 0715                    throw TraceUtility.ThrowHelperError(new ArgumentNullException(nameof(SignatureParts)), Message);
 716                }
 0717                signBody = _signatureParts.IsBodyIncluded;
 718            }
 719
 63720            bool encryptBody = false;
 63721            if (ElementContainer.SourceEncryptionToken != null)
 722            {
 0723                if (_encryptionParts == null)
 724                {
 0725                    throw TraceUtility.ThrowHelperError(new ArgumentNullException(nameof(EncryptionParts)), Message);
 726                }
 0727                encryptBody = _encryptionParts.IsBodyIncluded;
 728            }
 729
 63730            SecurityAppliedMessage message = new SecurityAppliedMessage(Message, this, signBody, encryptBody);
 63731            Message = message;
 63732            return message;
 733        }
 734
 735        protected internal SecurityTokenReferenceStyle GetTokenReferenceStyle(SecurityTokenParameters parameters)
 736        {
 0737            return (ShouldSerializeToken(parameters, MessageDirection)) ? SecurityTokenReferenceStyle.Internal : Securit
 738        }
 739
 740        private void StartSignature()
 741        {
 63742            if (ElementContainer.SourceSigningToken == null)
 743            {
 63744                return;
 745            }
 746
 747            // determine the key identifier clause to use for the source
 0748            SecurityTokenReferenceStyle sourceSigningKeyReferenceStyle = GetTokenReferenceStyle(SigningTokenParameters);
 0749            SecurityKeyIdentifierClause sourceSigningKeyIdentifierClause = SigningTokenParameters.CreateKeyIdentifierCla
 0750            if (sourceSigningKeyIdentifierClause == null)
 751            {
 0752                throw TraceUtility.ThrowHelperError(new MessageSecurityException(SR.TokenManagerCannotCreateTokenReferen
 753            }
 754
 755            SecurityToken signingToken;
 756            SecurityKeyIdentifierClause signingKeyIdentifierClause;
 757
 758            // determine if a token needs to be derived
 0759            if (SigningTokenParameters.RequireDerivedKeys && !SigningTokenParameters.HasAsymmetricKey)
 760            {
 0761                string derivationAlgorithm = AlgorithmSuite.GetSignatureKeyDerivationAlgorithm(ElementContainer.SourceSi
 0762                string expectedDerivationAlgorithm = SecurityUtils.GetKeyDerivationAlgorithm(StandardsManager.MessageSec
 0763                if (derivationAlgorithm == expectedDerivationAlgorithm)
 764                {
 0765                    DerivedKeySecurityToken derivedSigningToken = new DerivedKeySecurityToken(-1, 0, AlgorithmSuite.GetS
 0766                        sourceSigningKeyIdentifierClause, derivationAlgorithm, GenerateId());
 0767                    signingToken = ElementContainer.DerivedSigningToken = derivedSigningToken;
 0768                    signingKeyIdentifierClause = new LocalIdKeyIdentifierClause(signingToken.Id, signingToken.GetType())
 769                }
 770                else
 771                {
 0772                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR.Format(SR.Uns
 773                }
 774            }
 775            else
 776            {
 0777                signingToken = ElementContainer.SourceSigningToken;
 0778                signingKeyIdentifierClause = sourceSigningKeyIdentifierClause;
 779            }
 780
 0781            SecurityKeyIdentifier signingKeyIdentifier = new SecurityKeyIdentifier(signingKeyIdentifierClause);
 782
 0783            if (_signatureConfirmationsToSend != null && _signatureConfirmationsToSend.Count > 0)
 784            {
 785                ISecurityElement[] signatureConfirmationElements;
 0786                signatureConfirmationElements = CreateSignatureConfirmationElements(_signatureConfirmationsToSend);
 0787                for (int i = 0; i < signatureConfirmationElements.Length; ++i)
 788                {
 0789                    SendSecurityHeaderElement sigConfElement = new SendSecurityHeaderElement(signatureConfirmationElemen
 0790                    {
 0791                        MarkedForEncryption = _signatureConfirmationsToSend.IsMarkedForEncryption
 0792                    };
 0793                    ElementContainer.AddSignatureConfirmation(sigConfElement);
 794                }
 795            }
 796
 0797            bool generateTargettablePrimarySignature = ((_endorsingTokenParameters != null) || (_signedEndorsingTokenPar
 0798            StartPrimarySignatureCore(signingToken, signingKeyIdentifier, _signatureParts, generateTargettablePrimarySig
 0799        }
 800
 801        private void CompleteSignature()
 802        {
 63803            ISignatureValueSecurityElement signedXml = CompletePrimarySignatureCore(
 63804                ElementContainer.GetSignatureConfirmations(), ElementContainer.GetSignedEndorsingSupportingTokens(),
 63805                ElementContainer.GetSignedSupportingTokens(), ElementContainer.GetBasicSupportingTokens(), true);
 63806            if (signedXml == null)
 807            {
 63808                return;
 809            }
 0810            ElementContainer.PrimarySignature = new SendSecurityHeaderElement(signedXml.Id, signedXml)
 0811            {
 0812                MarkedForEncryption = _encryptSignature
 0813            };
 0814            AddGeneratedSignatureValue(signedXml.GetSignatureValue(), EncryptPrimarySignature);
 0815            _primarySignatureDone = true;
 0816            PrimarySignatureValue = signedXml.GetSignatureValue();
 0817        }
 818
 819        protected abstract void StartPrimarySignatureCore(SecurityToken token, SecurityKeyIdentifier identifier, Message
 820
 821        protected abstract ISignatureValueSecurityElement CompletePrimarySignatureCore(SendSecurityHeaderElement[] signa
 822           SecurityToken[] signedEndorsingTokens, SecurityToken[] signedTokens, SendSecurityHeaderElement[] basicTokens,
 823
 824        protected abstract ISignatureValueSecurityElement CreateSupportingSignature(SecurityToken token, SecurityKeyIden
 825
 826        protected abstract ISignatureValueSecurityElement CreateSupportingSignature(SecurityToken token, SecurityKeyIden
 827
 828        protected abstract void StartEncryptionCore(SecurityToken token, SecurityKeyIdentifier keyIdentifier);
 829
 830        protected abstract ISecurityElement CompleteEncryptionCore(SendSecurityHeaderElement primarySignature,
 831            SendSecurityHeaderElement[] basicTokens, SendSecurityHeaderElement[] signatureConfirmations, SendSecurityHea
 832
 833        private void SignWithSupportingToken(SecurityToken token, SecurityKeyIdentifierClause identifierClause)
 834        {
 0835            if (token == null)
 836            {
 0837                throw TraceUtility.ThrowHelperArgumentNull(nameof(token), Message);
 838            }
 0839            if (identifierClause == null)
 840            {
 0841                throw TraceUtility.ThrowHelperError(new MessageSecurityException(SR.TokenManagerCannotCreateTokenReferen
 842            }
 0843            if (!RequireMessageProtection)
 844            {
 0845                if (ElementContainer.Timestamp == null)
 846                {
 0847                    throw TraceUtility.ThrowHelperError(new InvalidOperationException(
 0848                        SR.SigningWithoutPrimarySignatureRequiresTimestamp), Message);
 849                }
 850            }
 851            else
 852            {
 0853                if (!_primarySignatureDone)
 854                {
 0855                    throw TraceUtility.ThrowHelperError(new InvalidOperationException(
 0856                        SR.PrimarySignatureMustBeComputedBeforeSupportingTokenSignatures), Message);
 857                }
 0858                if (ElementContainer.PrimarySignature.Item == null)
 859                {
 0860                    throw TraceUtility.ThrowHelperError(new InvalidOperationException(
 0861                        SR.Format(SR.SupportingTokenSignaturesNotExpected)), Message);
 862                }
 863            }
 864
 0865            SecurityKeyIdentifier identifier = new SecurityKeyIdentifier(identifierClause);
 866            ISignatureValueSecurityElement supportingSignature;
 0867            if (!RequireMessageProtection)
 868            {
 0869                supportingSignature = CreateSupportingSignature(token, identifier);
 870            }
 871            else
 872            {
 0873                supportingSignature = CreateSupportingSignature(token, identifier, ElementContainer.PrimarySignature.Ite
 874            }
 0875            AddGeneratedSignatureValue(supportingSignature.GetSignatureValue(), _encryptSignature);
 0876            SendSecurityHeaderElement supportingSignatureElement = new SendSecurityHeaderElement(supportingSignature.Id,
 0877            {
 0878                MarkedForEncryption = _encryptSignature
 0879            };
 0880            ElementContainer.AddEndorsingSignature(supportingSignatureElement);
 0881        }
 882
 883        private void SignWithSupportingTokens()
 884        {
 63885            SecurityToken[] endorsingTokens = ElementContainer.GetEndorsingSupportingTokens();
 63886            if (endorsingTokens != null)
 887            {
 0888                for (int i = 0; i < endorsingTokens.Length; ++i)
 889                {
 0890                    SecurityToken source = endorsingTokens[i];
 0891                    SecurityKeyIdentifierClause sourceKeyClause = _endorsingTokenParameters[i].CreateKeyIdentifierClause
 0892                    if (sourceKeyClause == null)
 893                    {
 0894                        throw TraceUtility.ThrowHelperError(new MessageSecurityException(SR.Format(SR.TokenManagerCannot
 895                    }
 896                    SecurityToken signingToken;
 897                    SecurityKeyIdentifierClause signingKeyClause;
 0898                    if (_endorsingTokenParameters[i].RequireDerivedKeys && !_endorsingTokenParameters[i].HasAsymmetricKe
 899                    {
 0900                        string derivationAlgorithm = SecurityUtils.GetKeyDerivationAlgorithm(StandardsManager.MessageSec
 0901                        DerivedKeySecurityToken dkt = new DerivedKeySecurityToken(-1, 0,
 0902                            AlgorithmSuite.GetSignatureKeyDerivationLength(source, StandardsManager.MessageSecurityVersi
 0903                            DerivedKeySecurityToken.DefaultNonceLength, source, sourceKeyClause, derivationAlgorithm, Ge
 0904                        signingToken = dkt;
 0905                        signingKeyClause = new LocalIdKeyIdentifierClause(dkt.Id, dkt.GetType());
 0906                        ElementContainer.AddEndorsingDerivedSupportingToken(dkt);
 907                    }
 908                    else
 909                    {
 0910                        signingToken = source;
 0911                        signingKeyClause = sourceKeyClause;
 912                    }
 0913                    SignWithSupportingToken(signingToken, signingKeyClause);
 914                }
 915            }
 63916            SecurityToken[] signedEndorsingSupportingTokens = ElementContainer.GetSignedEndorsingSupportingTokens();
 63917            if (signedEndorsingSupportingTokens != null)
 918            {
 0919                for (int i = 0; i < signedEndorsingSupportingTokens.Length; ++i)
 920                {
 0921                    SecurityToken source = signedEndorsingSupportingTokens[i];
 0922                    SecurityKeyIdentifierClause sourceKeyClause = _signedEndorsingTokenParameters[i].CreateKeyIdentifier
 0923                    if (sourceKeyClause == null)
 924                    {
 0925                        throw TraceUtility.ThrowHelperError(new MessageSecurityException(SR.Format(SR.TokenManagerCannot
 926                    }
 927                    SecurityToken signingToken;
 928                    SecurityKeyIdentifierClause signingKeyClause;
 0929                    if (_signedEndorsingTokenParameters[i].RequireDerivedKeys && !_signedEndorsingTokenParameters[i].Has
 930                    {
 0931                        string derivationAlgorithm = SecurityUtils.GetKeyDerivationAlgorithm(StandardsManager.MessageSec
 0932                        DerivedKeySecurityToken dkt = new DerivedKeySecurityToken(-1, 0,
 0933                            AlgorithmSuite.GetSignatureKeyDerivationLength(source, StandardsManager.MessageSecurityVersi
 0934                            DerivedKeySecurityToken.DefaultNonceLength, source, sourceKeyClause, derivationAlgorithm, Ge
 0935                        signingToken = dkt;
 0936                        signingKeyClause = new LocalIdKeyIdentifierClause(dkt.Id, dkt.GetType());
 0937                        ElementContainer.AddSignedEndorsingDerivedSupportingToken(dkt);
 938                    }
 939                    else
 940                    {
 0941                        signingToken = source;
 0942                        signingKeyClause = sourceKeyClause;
 943                    }
 0944                    SignWithSupportingToken(signingToken, signingKeyClause);
 945                }
 946            }
 63947        }
 948
 949        protected bool ShouldUseStrTransformForToken(SecurityToken securityToken, int position, SecurityTokenAttachmentM
 950        {
 0951            keyIdentifierClause = null;
 952
 953            IssuedSecurityTokenParameters tokenParams;
 954            switch (mode)
 955            {
 956                case SecurityTokenAttachmentMode.SignedEndorsing:
 0957                    tokenParams = _signedEndorsingTokenParameters[position] as IssuedSecurityTokenParameters;
 0958                    break;
 959                case SecurityTokenAttachmentMode.Signed:
 0960                    tokenParams = _signedTokenParameters[position] as IssuedSecurityTokenParameters;
 0961                    break;
 962                case SecurityTokenAttachmentMode.SignedEncrypted:
 0963                    tokenParams = _basicSupportingTokenParameters[position] as IssuedSecurityTokenParameters;
 0964                    break;
 965                default:
 0966                    return false;
 967            }
 968
 0969            if (tokenParams != null && tokenParams.UseStrTransform)
 970            {
 0971                keyIdentifierClause = tokenParams.CreateKeyIdentifierClause(securityToken, GetTokenReferenceStyle(tokenP
 0972                if (keyIdentifierClause == null)
 973                {
 0974                    throw TraceUtility.ThrowHelperError(new MessageSecurityException(SR.Format(SR.TokenManagerCannotCrea
 975                }
 976
 0977                return true;
 978            }
 0979            return false;
 980        }
 981
 63982        XmlDictionaryString IMessageHeaderWithSharedNamespace.SharedNamespace => XD.UtilityDictionary.Namespace;
 983
 63984        XmlDictionaryString IMessageHeaderWithSharedNamespace.SharedPrefix => XD.UtilityDictionary.Prefix;
 985
 986        private void AddGeneratedSignatureValue(byte[] signatureValue, bool wasEncrypted)
 987        {
 988            // cache outgoing signatures only on the client side
 0989            if (MaintainSignatureConfirmationState && (_signatureConfirmationsToSend == null))
 990            {
 0991                if (_signatureValuesGenerated == null)
 992                {
 0993                    _signatureValuesGenerated = new SignatureConfirmations();
 994                }
 0995                _signatureValuesGenerated.AddConfirmation(signatureValue, wasEncrypted);
 996            }
 0997        }
 998    }
 999
 1000    internal class TokenElement : ISecurityElement
 1001    {
 1002        private readonly SecurityStandardsManager _standardsManager;
 1003
 1004        public TokenElement(SecurityToken token, SecurityStandardsManager standardsManager)
 1005        {
 1006            Token = token;
 1007            _standardsManager = standardsManager;
 1008        }
 1009
 1010        public override bool Equals(object item)
 1011        {
 1012            return (item is TokenElement element && Token == element.Token && _standardsManager == element._standardsMan
 1013        }
 1014
 1015        public override int GetHashCode()
 1016        {
 1017            return Token.GetHashCode() ^ _standardsManager.GetHashCode();
 1018        }
 1019
 1020        public bool HasId => true;
 1021
 1022        public string Id => Token.Id;
 1023
 1024        public SecurityToken Token { get; }
 1025
 1026        public void WriteTo(XmlDictionaryWriter writer, DictionaryManager dictionaryManager)
 1027        {
 1028            _standardsManager.SecurityTokenSerializer.WriteToken(writer, Token);
 1029        }
 1030    }
 1031}
Generated by: ReportGenerator 5.5.11.0
08/09/2026 - 10:15:50
GitHub | reportgenerator.io

Methods/Properties

.ctor(CoreWCF.Channels.Message,System.String,System.Boolean,System.Boolean,CoreWCF.Security.SecurityStandardsManager,CoreWCF.Security.SecurityAlgorithmSuite,CoreWCF.Description.MessageDirection)
.cctor()
ElementContainer()
CorrelationState()
CorrelationState(CoreWCF.Security.SecurityProtocolCorrelationState)
StreamBufferManager()
StreamBufferManager(CoreWCF.Channels.BufferManager)
EncryptionParts()
EncryptionParts(CoreWCF.Security.MessagePartSpecification)
EncryptPrimarySignature()
EncryptPrimarySignature(System.Boolean)
PrimarySignatureValue()
SigningTokenParameters()
ShouldSignToHeader()
IdPrefix()
IdPrefix(System.String)
Name()
Namespace()
SecurityAppliedMessage()
SignThenEncrypt()
SignThenEncrypt(System.Boolean)
ShouldProtectTokens()
ShouldProtectTokens(System.Boolean)
SignatureParts()
SignatureParts(CoreWCF.Security.MessagePartSpecification)
Timestamp()
HasSignedTokens()
HasEncryptedTokens()
AddPrerequisiteToken(CoreWCF.IdentityModel.Tokens.SecurityToken)
AddParameters(System.Collections.Generic.List`1<CoreWCF.Security.Tokens.SecurityTokenParameters>&,CoreWCF.Security.Tokens.SecurityTokenParameters)
HasSignedEncryptedMessagePart()
SetSigningToken(CoreWCF.IdentityModel.Tokens.SecurityToken,CoreWCF.Security.Tokens.SecurityTokenParameters)
SetEncryptionToken(CoreWCF.IdentityModel.Tokens.SecurityToken,CoreWCF.Security.Tokens.SecurityTokenParameters)
AddBasicSupportingToken(CoreWCF.IdentityModel.Tokens.SecurityToken,CoreWCF.Security.Tokens.SecurityTokenParameters)
AddEndorsingSupportingToken(CoreWCF.IdentityModel.Tokens.SecurityToken,CoreWCF.Security.Tokens.SecurityTokenParameters)
AddSignedEndorsingSupportingToken(CoreWCF.IdentityModel.Tokens.SecurityToken,CoreWCF.Security.Tokens.SecurityTokenParameters)
AddSignedSupportingToken(CoreWCF.IdentityModel.Tokens.SecurityToken,CoreWCF.Security.Tokens.SecurityTokenParameters)
AddSignatureConfirmations(CoreWCF.Security.SignatureConfirmations)
AddTimestamp(System.TimeSpan)
AddTimestamp(CoreWCF.Security.SecurityTimestamp)
CreateSignatureConfirmationElements(CoreWCF.Security.SignatureConfirmations)
StartEncryption()
CompleteEncryption()
StartSecurityApplication()
CompleteSecurityApplication()
RemoveSignatureEncryptionIfAppropriate()
GenerateId()
GetSignatureValues()
OnWriteStartHeader(System.Xml.XmlDictionaryWriter,CoreWCF.Channels.MessageVersion)
ShouldSerializeToken(CoreWCF.Security.Tokens.SecurityTokenParameters,CoreWCF.Description.MessageDirection)
OnWriteHeaderContents(System.Xml.XmlDictionaryWriter,CoreWCF.Channels.MessageVersion)
SetupExecution()
GetTokenReferenceStyle(CoreWCF.Security.Tokens.SecurityTokenParameters)
StartSignature()
CompleteSignature()
SignWithSupportingToken(CoreWCF.IdentityModel.Tokens.SecurityToken,CoreWCF.IdentityModel.SecurityKeyIdentifierClause)
SignWithSupportingTokens()
ShouldUseStrTransformForToken(CoreWCF.IdentityModel.Tokens.SecurityToken,System.Int32,CoreWCF.Security.SecurityTokenAttachmentMode,CoreWCF.IdentityModel.SecurityKeyIdentifierClause&)
WCF.Channels.IMessageHeaderWithSharedNamespace.get_SharedNamespace()
WCF.Channels.IMessageHeaderWithSharedNamespace.get_SharedPrefix()
AddGeneratedSignatureValue(System.Byte[],System.Boolean)