< Summary - CoreWCF Coverage — PR #1766

Information
Class: CoreWCF.Security.WSSecurityPolicy
Assembly: CoreWCF.Primitives
File(s): /home/runner/work/CoreWCF/CoreWCF/src/CoreWCF.Primitives/src/CoreWCF/Security/WSSecurityPolicy.cs
Line coverage
66%
Covered lines: 286
Uncovered lines: 144
Coverable lines: 430
Total lines: 1081
Line coverage: 66.5%
Branch coverage
63%
Covered branches: 142
Total branches: 223
Branch coverage: 63.6%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Cyclomatic complexity NPath complexity Sequence coverage
.cctor()100%11100%
CreateWsspAssertion(...)100%11100%
IsWsspAssertion(...)100%11100%
CreateMsspAssertion(...)100%110%
CreateWspPolicyWrapper(...)100%66100%
CreateWsspSignedPartsAssertion(...)75%8880%
CreateWsspEncryptedPartsAssertion(...)62.5%8870%
CreateWsspHeaderAssertion(...)100%11100%
CreateWsspTransportBindingAssertion(...)100%11100%
CreateWsspWssAssertion(...)50%8855.55%
CreateWsspWss10Assertion(...)100%110%
CreateWsspWss11Assertion(...)100%11100%
CreateWsspAssertionMustSupportRefKeyIdentifierName()50%2266.66%
CreateWsspAssertionMustSupportRefIssuerSerialName()50%2266.66%
CreateWsspAssertionMustSupportRefThumbprintName()100%22100%
CreateWsspAssertionMustSupportRefEncryptedKeyName()50%2266.66%
CreateWsspRequireSignatureConformationAssertion(...)50%2266.66%
CreateWsspTrustAssertion(...)100%11100%
CreateWsspRequireClientEntropyAssertion(...)75%4466.66%
CreateWsspRequireServerEntropyAssertion(...)75%4466.66%
CreateWsspSupportingTokensAssertion(...)100%110%
CreateWsspSupportingTokensAssertion(...)83.33%6690.9%
CreateWsspSignedSupportingTokensAssertion(...)90.62%323285.71%
CreateWsspEndorsingSupportingTokensAssertion(...)100%11100%
CreateWsspSignedEndorsingSupportingTokensAssertion(...)100%11100%
CreateWsspiSupportingTokensAssertion(...)88.46%262686.95%
CreateWsspIncludeTimestampAssertion(...)100%22100%
CreateWsspLayoutAssertion(...)100%11100%
CreateLayoutAssertion(...)20%5520%
CreateWsspAlgorithmSuiteAssertion(...)100%11100%
CreateAlgorithmSuiteAssertion(...)50%343452.77%
CreateWsspTransportTokenAssertion(...)50%2288.88%
CreateTokenAssertion(...)100%11100%
CreateTokenAssertion(...)68.75%161672.22%
SetIncludeTokenValue(...)20%5522.22%
CreateWsspRequireDerivedKeysAssertion(...)50%2266.66%
CreateX509ReferenceStyleAssertion(...)20%5518.18%
CreateWsspX509TokenAssertion(...)100%11100%
CreateWsspUsernameTokenAssertion(...)100%11100%
CreateReferenceStyleAssertion(...)0%440%
CreateWsspIssuerElement(...)0%880%
CreateWsspIssuedTokenAssertion(...)0%440%
CreateWsspMustNotSendCancelAssertion(...)0%220%
CreateWsspSpnegoContextTokenAssertion(...)100%11100%
CreateMsspRequireClientCertificateAssertion(...)0%220%
CreateMsspSslContextTokenAssertion(...)100%110%
CreateWsspBootstrapPolicyAssertion(...)91.66%121297.29%
FilterWsspPolicyAssertions(...)100%44100%
CreateWsspSecureConversationTokenAssertion(...)100%11100%
GetSecurityPolicyDriver(...)100%11100%
.ctor()100%11100%
Initialize()100%11100%
GetSecurityPolicyDriver(...)50%4475%

File(s)

/home/runner/work/CoreWCF/CoreWCF/src/CoreWCF.Primitives/src/CoreWCF/Security/WSSecurityPolicy.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.IO;
 8using System.Xml;
 9using CoreWCF.Channels;
 10using CoreWCF.Description;
 11using CoreWCF.Security.Tokens;
 12
 13namespace CoreWCF.Security
 14{
 15    internal abstract class WSSecurityPolicy
 16    {
 117        public static ContractDescription NullContract = new ContractDescription("null");
 118        public static ServiceEndpoint NullServiceEndpoint = new ServiceEndpoint(NullContract);
 119        public static XmlDocument doc = new XmlDocument();
 20        public const string WsspPrefix = "sp";
 21        public const string WspNamespace = MetadataStrings.WSPolicy.NamespaceUri; //@"http://schemas.xmlsoap.org/ws/2004
 22        public const string Wsp15Namespace = MetadataStrings.WSPolicy.NamespaceUri15;
 23        public const string WspPrefix = MetadataStrings.WSPolicy.Prefix; //"wsp";
 24        public const string MsspNamespace = @"http://schemas.microsoft.com/ws/2005/07/securitypolicy";
 25        public const string MsspPrefix = "mssp";
 26        public const string PolicyName = MetadataStrings.WSPolicy.Elements.Policy; //"Policy";
 27        public const string OptionalName = "Optional";
 28        public const string TrueName = "true";
 29        public const string FalseName = "false";
 30        public const string SymmetricBindingName = "SymmetricBinding";
 31        public const string AsymmetricBindingName = "AsymmetricBinding";
 32        public const string TransportBindingName = "TransportBinding";
 33        public const string OnlySignEntireHeadersAndBodyName = "OnlySignEntireHeadersAndBody";
 34        public const string ProtectionTokenName = "ProtectionToken";
 35        public const string InitiatorTokenName = "InitiatorToken";
 36        public const string RecipientTokenName = "RecipientToken";
 37        public const string TransportTokenName = "TransportToken";
 38        public const string AlgorithmSuiteName = "AlgorithmSuite";
 39        public const string LaxName = "Lax";
 40        public const string LaxTsLastName = "LaxTsLast";
 41        public const string LaxTsFirstName = "LaxTsFirst";
 42        public const string StrictName = "Strict";
 43        public const string IncludeTimestampName = "IncludeTimestamp";
 44        public const string EncryptBeforeSigningName = "EncryptBeforeSigning";
 45        public const string ProtectTokens = "ProtectTokens";
 46        public const string EncryptSignatureName = "EncryptSignature";
 47        public const string SignedSupportingTokensName = "SignedSupportingTokens";
 48        public const string EndorsingSupportingTokensName = "EndorsingSupportingTokens";
 49        public const string SignedEndorsingSupportingTokensName = "SignedEndorsingSupportingTokens";
 50        public const string Wss10Name = "Wss10";
 51        public const string MustSupportRefKeyIdentifierName = "MustSupportRefKeyIdentifier";
 52        public const string MustSupportRefIssuerSerialName = "MustSupportRefIssuerSerial";
 53        public const string MustSupportRefThumbprintName = "MustSupportRefThumbprint";
 54        public const string MustSupportRefEncryptedKeyName = "MustSupportRefEncryptedKey";
 55        public const string RequireSignatureConfirmationName = "RequireSignatureConfirmation";
 56        public const string MustSupportIssuedTokensName = "MustSupportIssuedTokens";
 57        public const string RequireClientEntropyName = "RequireClientEntropy";
 58        public const string RequireServerEntropyName = "RequireServerEntropy";
 59        public const string Wss11Name = "Wss11";
 60        public const string Trust10Name = "Trust10";
 61        public const string Trust13Name = "Trust13";
 62        public const string RequireAppliesTo = "RequireAppliesTo";
 63        public const string SignedPartsName = "SignedParts";
 64        public const string EncryptedPartsName = "EncryptedParts";
 65        public const string BodyName = "Body";
 66        public const string HeaderName = "Header";
 67        public const string NameName = "Name";
 68        public const string NamespaceName = "Namespace";
 69        public const string Basic128Name = "Basic128";
 70        public const string Basic192Name = "Basic192";
 71        public const string Basic256Name = "Basic256";
 72        public const string TripleDesName = "TripleDes";
 73        public const string Basic128Rsa15Name = "Basic128Rsa15";
 74        public const string Basic192Rsa15Name = "Basic192Rsa15";
 75        public const string Basic256Rsa15Name = "Basic256Rsa15";
 76        public const string TripleDesRsa15Name = "TripleDesRsa15";
 77        public const string Basic128Sha256Name = "Basic128Sha256";
 78        public const string Basic192Sha256Name = "Basic192Sha256";
 79        public const string Basic256Sha256Name = "Basic256Sha256";
 80        public const string TripleDesSha256Name = "TripleDesSha256";
 81        public const string Basic128Sha256Rsa15Name = "Basic128Sha256Rsa15";
 82        public const string Basic192Sha256Rsa15Name = "Basic192Sha256Rsa15";
 83        public const string Basic256Sha256Rsa15Name = "Basic256Sha256Rsa15";
 84        public const string TripleDesSha256Rsa15Name = "TripleDesSha256Rsa15";
 85        public const string IncludeTokenName = "IncludeToken";
 86        public const string KerberosTokenName = "KerberosToken";
 87        public const string X509TokenName = "X509Token";
 88        public const string IssuedTokenName = "IssuedToken";
 89        public const string UsernameTokenName = "UsernameToken";
 90        public const string RsaTokenName = "RsaToken";
 91        public const string KeyValueTokenName = "KeyValueToken";
 92        public const string SpnegoContextTokenName = "SpnegoContextToken";
 93        public const string SslContextTokenName = "SslContextToken";
 94        public const string SecureConversationTokenName = "SecureConversationToken";
 95        public const string WssGssKerberosV5ApReqToken11Name = "WssGssKerberosV5ApReqToken11";
 96        public const string RequireDerivedKeysName = "RequireDerivedKeys";
 97        public const string RequireIssuerSerialReferenceName = "RequireIssuerSerialReference";
 98        public const string RequireKeyIdentifierReferenceName = "RequireKeyIdentifierReference";
 99        public const string RequireThumbprintReferenceName = "RequireThumbprintReference";
 100        public const string WssX509V3Token10Name = "WssX509V3Token10";
 101        public const string WssUsernameToken10Name = "WssUsernameToken10";
 102        public const string RequestSecurityTokenTemplateName = "RequestSecurityTokenTemplate";
 103        public const string RequireExternalReferenceName = "RequireExternalReference";
 104        public const string RequireInternalReferenceName = "RequireInternalReference";
 105        public const string IssuerName = "Issuer";
 106        public const string RequireClientCertificateName = "RequireClientCertificate";
 107        public const string MustNotSendCancelName = "MustNotSendCancel";
 108        public const string MustNotSendAmendName = "MustNotSendAmend";
 109        public const string MustNotSendRenewName = "MustNotSendRenew";
 110        public const string LayoutName = "Layout";
 111        public const string BootstrapPolicyName = "BootstrapPolicy";
 112        public const string HttpsTokenName = "HttpsToken";
 113        public const string HttpBasicAuthenticationName = "HttpBasicAuthentication";
 114        public const string HttpDigestAuthenticationName = "HttpDigestAuthentication";
 115
 116        bool _mustSupportRefKeyIdentifierName = false;
 117        bool _mustSupportRefIssuerSerialName = false;
 118        bool _mustSupportRefThumbprintName = false;
 119        bool _protectionTokenHasAsymmetricKey = false;
 120
 121        public virtual XmlElement CreateWsspAssertion(string name)
 122        {
 433123            return doc.CreateElement(WsspPrefix, name, WsspNamespaceUri);
 124        }
 125
 126        public virtual bool IsWsspAssertion(XmlElement assertion)
 127        {
 45128            return assertion.NamespaceURI == WsspNamespaceUri;
 129        }
 130
 131        public virtual XmlElement CreateMsspAssertion(string name)
 132        {
 0133            return doc.CreateElement(MsspPrefix, name, MsspNamespace);
 134        }
 135
 136        public abstract bool IsSecurityVersionSupported(MessageSecurityVersion version);
 137
 138        public abstract string WsspNamespaceUri { get; }
 139        public abstract TrustDriver TrustDriver { get; }
 19140        public virtual string AlwaysToRecipientUri => WsspNamespaceUri + @"/IncludeToken/AlwaysToRecipient";
 0141        public virtual string NeverUri => WsspNamespaceUri + @"/IncludeToken/Never";
 0142        public virtual string OnceUri => WsspNamespaceUri + @"/IncludeToken/Once";
 0143        public virtual string AlwaysToInitiatorUri => WsspNamespaceUri + @"/IncludeToken/AlwaysToInitiator";
 144
 145        public virtual XmlElement CreateWspPolicyWrapper(MetadataExporter exporter, params XmlElement[] nestedAssertions
 146        {
 173147            XmlElement result = doc.CreateElement(WspPrefix, PolicyName, exporter.PolicyVersion.Namespace);
 148
 173149            if (nestedAssertions != null)
 150            {
 1102151                foreach (XmlElement e in nestedAssertions)
 152                {
 378153                    if (e != null)
 154                    {
 260155                        result.AppendChild(e);
 156                    }
 157                }
 158            }
 159
 173160            return result;
 161        }
 162
 163        public virtual XmlElement CreateWsspSignedPartsAssertion(MessagePartSpecification parts)
 164        {
 17165            if (parts == null)
 166            {
 0167                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(parts));
 168            }
 169
 170            XmlElement result;
 171
 17172            if (parts.IsEmpty())
 173            {
 0174                result = null;
 175            }
 176            else
 177            {
 17178                result = CreateWsspAssertion(SignedPartsName);
 17179                if (parts.IsBodyIncluded)
 180                {
 9181                    result.AppendChild(CreateWsspAssertion(BodyName));
 182                }
 176183                foreach (XmlQualifiedName header in parts.HeaderTypes)
 184                {
 71185                    result.AppendChild(CreateWsspHeaderAssertion(header));
 186                }
 187            }
 17188            return result;
 189        }
 190
 191        public virtual XmlElement CreateWsspEncryptedPartsAssertion(MessagePartSpecification parts)
 192        {
 9193            if (parts == null)
 194            {
 0195                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(parts));
 196            }
 197
 198            XmlElement result;
 199
 9200            if (parts.IsEmpty())
 201            {
 0202                result = null;
 203            }
 204            else
 205            {
 9206                result = CreateWsspAssertion(EncryptedPartsName);
 9207                if (parts.IsBodyIncluded)
 208                {
 9209                    result.AppendChild(CreateWsspAssertion(BodyName));
 210                }
 18211                foreach (XmlQualifiedName header in parts.HeaderTypes)
 212                {
 0213                    result.AppendChild(CreateWsspHeaderAssertion(header));
 214                }
 215            }
 9216            return result;
 217        }
 218
 219        public virtual XmlElement CreateWsspHeaderAssertion(XmlQualifiedName header)
 220        {
 71221            XmlElement result = CreateWsspAssertion(HeaderName);
 71222            result.SetAttribute(NameName, header.Name);
 71223            result.SetAttribute(NamespaceName, header.Namespace);
 224
 71225            return result;
 226        }
 227
 228        public virtual XmlElement CreateWsspTransportBindingAssertion(MetadataExporter exporter, TransportSecurityBindin
 229        {
 22230            XmlElement result = CreateWsspAssertion(TransportBindingName);
 22231            result.AppendChild(
 22232                CreateWspPolicyWrapper(
 22233                    exporter,
 22234                    CreateWsspTransportTokenAssertion(exporter, transportTokenAssertion),
 22235                    CreateWsspAlgorithmSuiteAssertion(exporter, binding.DefaultAlgorithmSuite),
 22236                    CreateWsspLayoutAssertion(exporter, binding.SecurityHeaderLayout),
 22237                    CreateWsspIncludeTimestampAssertion(binding.IncludeTimestamp)
 22238            ));
 239
 22240            return result;
 241        }
 242
 243        public virtual XmlElement CreateWsspWssAssertion(MetadataExporter exporter, SecurityBindingElement binding)
 244        {
 19245            if (binding == null)
 246            {
 0247                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(binding));
 248            }
 249
 19250            if (binding.MessageSecurityVersion.SecurityVersion == SecurityVersion.WSSecurity10)
 251            {
 0252                return CreateWsspWss10Assertion(exporter);
 253            }
 19254            else if (binding.MessageSecurityVersion.SecurityVersion == SecurityVersion.WSSecurity11)
 255            {
 19256                if (binding is SymmetricSecurityBindingElement)
 257                {
 0258                    return CreateWsspWss11Assertion(exporter, ((SymmetricSecurityBindingElement)binding).RequireSignatur
 259                }
 260                /*else if (binding is AsymmetricSecurityBindingElement)
 261                {
 262                    return CreateWsspWss11Assertion(exporter, ((AsymmetricSecurityBindingElement)binding).RequireSignatu
 263                }*/
 264                else
 265                {
 19266                    return CreateWsspWss11Assertion(exporter, false);
 267                }
 268            }
 269            else
 270            {
 0271                return null;
 272            }
 273        }
 274
 275        public virtual XmlElement CreateWsspWss10Assertion(MetadataExporter exporter)
 276        {
 0277            XmlElement result = CreateWsspAssertion(Wss10Name);
 0278            result.AppendChild(
 0279                CreateWspPolicyWrapper(
 0280                    exporter,
 0281                    CreateWsspAssertionMustSupportRefKeyIdentifierName(),
 0282                    CreateWsspAssertionMustSupportRefIssuerSerialName()
 0283            ));
 284
 0285            return result;
 286        }
 287
 288        public virtual XmlElement CreateWsspWss11Assertion(MetadataExporter exporter, bool requireSignatureConfirmation)
 289        {
 19290            XmlElement result = CreateWsspAssertion(Wss11Name);
 19291            result.AppendChild(
 19292                CreateWspPolicyWrapper(
 19293                    exporter,
 19294                    CreateWsspAssertionMustSupportRefKeyIdentifierName(),
 19295                    CreateWsspAssertionMustSupportRefIssuerSerialName(),
 19296                    CreateWsspAssertionMustSupportRefThumbprintName(),
 19297                    CreateWsspAssertionMustSupportRefEncryptedKeyName(),
 19298                    CreateWsspRequireSignatureConformationAssertion(requireSignatureConfirmation)
 19299            ));
 300
 19301            return result;
 302        }
 303
 304        public virtual XmlElement CreateWsspAssertionMustSupportRefKeyIdentifierName()
 305        {
 19306            if (_mustSupportRefKeyIdentifierName)
 307            {
 0308                return CreateWsspAssertion(MustSupportRefKeyIdentifierName);
 309            }
 310            else
 311            {
 19312                return null;
 313            }
 314        }
 315
 316        public virtual XmlElement CreateWsspAssertionMustSupportRefIssuerSerialName()
 317        {
 19318            if (_mustSupportRefIssuerSerialName)
 319            {
 0320                return CreateWsspAssertion(MustSupportRefIssuerSerialName);
 321            }
 322            else
 323            {
 19324                return null;
 325            }
 326        }
 327
 328        public virtual XmlElement CreateWsspAssertionMustSupportRefThumbprintName()
 329        {
 19330            if (_mustSupportRefThumbprintName)
 331            {
 8332                return CreateWsspAssertion(MustSupportRefThumbprintName);
 333            }
 334            else
 335            {
 11336                return null;
 337            }
 338        }
 339
 340        public virtual XmlElement CreateWsspAssertionMustSupportRefEncryptedKeyName()
 341        {
 342            // protectionTokenHasAsymmetricKey is only set to true for a SymmetricBindingElement having an asymmetric ke
 19343            if (_protectionTokenHasAsymmetricKey)
 344            {
 0345                return CreateWsspAssertion(MustSupportRefEncryptedKeyName);
 346            }
 347            else
 348            {
 19349                return null;
 350            }
 351        }
 352
 353        public virtual XmlElement CreateWsspRequireSignatureConformationAssertion(bool requireSignatureConfirmation)
 354        {
 19355            if (requireSignatureConfirmation)
 356            {
 0357                return CreateWsspAssertion(RequireSignatureConfirmationName);
 358            }
 359            else
 360            {
 19361                return null;
 362            }
 363        }
 364
 365        public abstract XmlElement CreateWsspTrustAssertion(MetadataExporter exporter, SecurityKeyEntropyMode keyEntropy
 366
 367        protected XmlElement CreateWsspTrustAssertion(string trustName, MetadataExporter exporter, SecurityKeyEntropyMod
 368        {
 19369            XmlElement result = CreateWsspAssertion(trustName);
 19370            result.AppendChild(
 19371                CreateWspPolicyWrapper(
 19372                    exporter,
 19373                    CreateWsspAssertion(MustSupportIssuedTokensName),
 19374                    CreateWsspRequireClientEntropyAssertion(keyEntropyMode),
 19375                    CreateWsspRequireServerEntropyAssertion(keyEntropyMode)
 19376            ));
 377
 19378            return result;
 379        }
 380
 381        public virtual XmlElement CreateWsspRequireClientEntropyAssertion(SecurityKeyEntropyMode keyEntropyMode)
 382        {
 19383            if (keyEntropyMode == SecurityKeyEntropyMode.ClientEntropy || keyEntropyMode == SecurityKeyEntropyMode.Combi
 384            {
 19385                return CreateWsspAssertion(RequireClientEntropyName);
 386            }
 387            else
 388            {
 0389                return null;
 390            }
 391        }
 392
 393        public virtual XmlElement CreateWsspRequireServerEntropyAssertion(SecurityKeyEntropyMode keyEntropyMode)
 394        {
 19395            if (keyEntropyMode == SecurityKeyEntropyMode.ServerEntropy || keyEntropyMode == SecurityKeyEntropyMode.Combi
 396            {
 19397                return CreateWsspAssertion(RequireServerEntropyName);
 398            }
 399            else
 400            {
 0401                return null;
 402            }
 403        }
 404
 405        public virtual Collection<XmlElement> CreateWsspSupportingTokensAssertion(MetadataExporter exporter, Collection<
 406        {
 0407            return CreateWsspSupportingTokensAssertion(exporter, signed, signedEncrypted, endorsing, signedEndorsing, op
 408        }
 409
 410        public virtual Collection<XmlElement> CreateWsspSupportingTokensAssertion(MetadataExporter exporter, Collection<
 411        {
 22412            Collection<XmlElement> supportingTokenAssertions = new Collection<XmlElement>();
 413
 414            // Signed Supporting Tokens
 22415            XmlElement supportingTokenAssertion = CreateWsspSignedSupportingTokensAssertion(exporter, signed, signedEncr
 22416            if (supportingTokenAssertion != null)
 1417                supportingTokenAssertions.Add(supportingTokenAssertion);
 418
 419            // Endorsing Supporting Tokens.
 22420            supportingTokenAssertion = CreateWsspEndorsingSupportingTokensAssertion(exporter, endorsing, optionalEndorsi
 22421            if (supportingTokenAssertion != null)
 18422                supportingTokenAssertions.Add(supportingTokenAssertion);
 423
 424            // Signed Endorsing Supporting Tokens.
 22425            supportingTokenAssertion = CreateWsspSignedEndorsingSupportingTokensAssertion(exporter, signedEndorsing, opt
 22426            if (supportingTokenAssertion != null)
 0427                supportingTokenAssertions.Add(supportingTokenAssertion);
 428
 22429            return supportingTokenAssertions;
 430        }
 431
 432        protected XmlElement CreateWsspSignedSupportingTokensAssertion(MetadataExporter exporter, Collection<SecurityTok
 433        {
 434            XmlElement result;
 435
 22436            if ((signed == null || signed.Count == 0)
 22437                && (signedEncrypted == null || signedEncrypted.Count == 0)
 22438                && (optionalSigned == null || optionalSigned.Count == 0)
 22439                && (optionalSignedEncrypted == null || optionalSignedEncrypted.Count == 0))
 440            {
 21441                result = null;
 442            }
 443            else
 444            {
 1445                XmlElement policy = CreateWspPolicyWrapper(exporter);
 446
 1447                if (signed != null)
 448                {
 2449                    foreach (SecurityTokenParameters p in signed)
 450                    {
 0451                        policy.AppendChild(CreateTokenAssertion(exporter, p));
 452                    }
 453                }
 1454                if (signedEncrypted != null)
 455                {
 4456                    foreach (SecurityTokenParameters p in signedEncrypted)
 457                    {
 1458                        policy.AppendChild(CreateTokenAssertion(exporter, p));
 459                    }
 460                }
 1461                if (optionalSigned != null)
 462                {
 2463                    foreach (SecurityTokenParameters p in optionalSigned)
 464                    {
 0465                        policy.AppendChild(CreateTokenAssertion(exporter, p, true));
 466                    }
 467                }
 1468                if (optionalSignedEncrypted != null)
 469                {
 2470                    foreach (SecurityTokenParameters p in optionalSignedEncrypted)
 471                    {
 0472                        policy.AppendChild(CreateTokenAssertion(exporter, p, true));
 473                    }
 474                }
 475
 1476                result = CreateWsspAssertion(SignedSupportingTokensName);
 1477                result.AppendChild(policy);
 478            }
 479
 22480            return result;
 481        }
 482
 483        protected XmlElement CreateWsspEndorsingSupportingTokensAssertion(MetadataExporter exporter, Collection<Security
 484        {
 22485            return CreateWsspiSupportingTokensAssertion(exporter, endorsing, optionalEndorsing, addressingVersion, Endor
 486        }
 487
 488        protected XmlElement CreateWsspSignedEndorsingSupportingTokensAssertion(MetadataExporter exporter, Collection<Se
 489        {
 22490            return CreateWsspiSupportingTokensAssertion(exporter, signedEndorsing, optionalSignedEndorsing, addressingVe
 491        }
 492
 493        protected XmlElement CreateWsspiSupportingTokensAssertion(MetadataExporter exporter, Collection<SecurityTokenPar
 494        {
 495            XmlElement result;
 44496            bool hasAssymetricKey = false;
 497
 44498            if ((endorsing == null || endorsing.Count == 0)
 44499                && (optionalEndorsing == null || optionalEndorsing.Count == 0))
 500            {
 26501                result = null;
 502            }
 503            else
 504            {
 18505                XmlElement policy = CreateWspPolicyWrapper(exporter);
 506
 18507                if (endorsing != null)
 508                {
 72509                    foreach (SecurityTokenParameters p in endorsing)
 510                    {
 18511                        if (p.HasAsymmetricKey)
 8512                            hasAssymetricKey = true;
 513
 18514                        policy.AppendChild(CreateTokenAssertion(exporter, p));
 515                    }
 516                }
 18517                if (optionalEndorsing != null)
 518                {
 36519                    foreach (SecurityTokenParameters p in optionalEndorsing)
 520                    {
 0521                        if (p.HasAsymmetricKey)
 0522                            hasAssymetricKey = true;
 523
 0524                        policy.AppendChild(CreateTokenAssertion(exporter, p, true));
 525                    }
 526                }
 18527                if (addressingVersion != null && AddressingVersion.None != addressingVersion)
 528                {
 529                    // only add assertion to sign the 'To' only if an assymetric key is found
 18530                    if (hasAssymetricKey)
 531                    {
 8532                        policy.AppendChild(
 8533                            CreateWsspSignedPartsAssertion(
 8534                                new MessagePartSpecification(new XmlQualifiedName(AddressingStrings.To, addressingVersio
 535                    }
 536                }
 537
 18538                result = CreateWsspAssertion(assertionName);
 18539                result.AppendChild(policy);
 540            }
 541
 44542            return result;
 543        }
 544
 545        public virtual XmlElement CreateWsspIncludeTimestampAssertion(bool includeTimestamp)
 546        {
 22547            if (includeTimestamp)
 548            {
 19549                return CreateWsspAssertion(IncludeTimestampName);
 550            }
 551            else
 552            {
 3553                return null;
 554            }
 555        }
 556
 557        public virtual XmlElement CreateWsspLayoutAssertion(MetadataExporter exporter, SecurityHeaderLayout layout)
 558        {
 22559            XmlElement result = CreateWsspAssertion(LayoutName);
 22560            result.AppendChild(
 22561                CreateWspPolicyWrapper(
 22562                    exporter,
 22563                    CreateLayoutAssertion(layout)
 22564            ));
 565
 22566            return result;
 567        }
 568
 569        public virtual XmlElement CreateLayoutAssertion(SecurityHeaderLayout layout)
 570        {
 571            switch (layout)
 572            {
 573                default:
 0574                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException(nameof(lay
 575                case SecurityHeaderLayout.Lax:
 0576                    return CreateWsspAssertion(LaxName);
 577                case SecurityHeaderLayout.LaxTimestampFirst:
 0578                    return CreateWsspAssertion(LaxTsFirstName);
 579                case SecurityHeaderLayout.LaxTimestampLast:
 0580                    return CreateWsspAssertion(LaxTsLastName);
 581                case SecurityHeaderLayout.Strict:
 22582                    return CreateWsspAssertion(StrictName);
 583            }
 584        }
 585
 586        public virtual XmlElement CreateWsspAlgorithmSuiteAssertion(MetadataExporter exporter, SecurityAlgorithmSuite su
 587        {
 22588            XmlElement result = CreateWsspAssertion(AlgorithmSuiteName);
 22589            result.AppendChild(
 22590                CreateWspPolicyWrapper(
 22591                    exporter,
 22592                    CreateAlgorithmSuiteAssertion(suite)
 22593            ));
 594
 22595            return result;
 596        }
 597
 598        public virtual XmlElement CreateAlgorithmSuiteAssertion(SecurityAlgorithmSuite suite)
 599        {
 22600            if (suite == null)
 601            {
 0602                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(suite));
 603            }
 604
 605            XmlElement result;
 606
 22607            if (suite == SecurityAlgorithmSuite.Basic256)
 12608                result = CreateWsspAssertion(Basic256Name);
 10609            else if (suite == SecurityAlgorithmSuite.Basic192)
 2610                result = CreateWsspAssertion(Basic192Name);
 8611            else if (suite == SecurityAlgorithmSuite.Basic128)
 2612                result = CreateWsspAssertion(Basic128Name);
 6613            else if (suite == SecurityAlgorithmSuite.TripleDes)
 0614                result = CreateWsspAssertion(TripleDesName);
 6615            else if (suite == SecurityAlgorithmSuite.Basic256Rsa15)
 0616                result = CreateWsspAssertion(Basic256Rsa15Name);
 6617            else if (suite == SecurityAlgorithmSuite.Basic192Rsa15)
 0618                result = CreateWsspAssertion(Basic192Rsa15Name);
 6619            else if (suite == SecurityAlgorithmSuite.Basic128Rsa15)
 0620                result = CreateWsspAssertion(Basic128Rsa15Name);
 6621            else if (suite == SecurityAlgorithmSuite.TripleDesRsa15)
 0622                result = CreateWsspAssertion(TripleDesRsa15Name);
 6623            else if (suite == SecurityAlgorithmSuite.Basic256Sha256)
 2624                result = CreateWsspAssertion(Basic256Sha256Name);
 4625            else if (suite == SecurityAlgorithmSuite.Basic192Sha256)
 2626                result = CreateWsspAssertion(Basic192Sha256Name);
 2627            else if (suite == SecurityAlgorithmSuite.Basic128Sha256)
 2628                result = CreateWsspAssertion(Basic128Sha256Name);
 0629            else if (suite == SecurityAlgorithmSuite.TripleDesSha256)
 0630                result = CreateWsspAssertion(TripleDesSha256Name);
 0631            else if (suite == SecurityAlgorithmSuite.Basic256Sha256Rsa15)
 0632                result = CreateWsspAssertion(Basic256Sha256Rsa15Name);
 0633            else if (suite == SecurityAlgorithmSuite.Basic192Sha256Rsa15)
 0634                result = CreateWsspAssertion(Basic192Sha256Rsa15Name);
 0635            else if (suite == SecurityAlgorithmSuite.Basic128Sha256Rsa15)
 0636                result = CreateWsspAssertion(Basic128Sha256Rsa15Name);
 0637            else if (suite == SecurityAlgorithmSuite.TripleDesSha256Rsa15)
 0638                result = CreateWsspAssertion(TripleDesSha256Rsa15Name);
 639            else
 640            {
 0641                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException(nameof(suite))
 642            }
 643
 22644            return result;
 645        }
 646
 647        public virtual XmlElement CreateWsspTransportTokenAssertion(MetadataExporter exporter, XmlElement transportToken
 648        {
 22649            if (transportTokenAssertion == null)
 650            {
 0651                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(transportTokenAssertion));
 652            }
 653
 22654            XmlElement result = CreateWsspAssertion(TransportTokenName);
 655
 22656            result.AppendChild(
 22657                CreateWspPolicyWrapper(
 22658                    exporter,
 22659                    (XmlElement)(doc.ImportNode(transportTokenAssertion, true))
 22660            ));
 661
 22662            return result;
 663        }
 664
 665        public virtual XmlElement CreateTokenAssertion(MetadataExporter exporter, SecurityTokenParameters parameters)
 666        {
 19667            return CreateTokenAssertion(exporter, parameters, false);
 668        }
 669
 670        public virtual XmlElement CreateTokenAssertion(MetadataExporter exporter, SecurityTokenParameters parameters, bo
 671        {
 19672            if (parameters == null)
 673            {
 0674                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(parameters));
 675            }
 676
 677            XmlElement result;
 678
 679            /*if (parameters is KerberosSecurityTokenParameters)
 680            {
 681                result = CreateWsspKerberosTokenAssertion(exporter, (KerberosSecurityTokenParameters)parameters);
 682            }
 683            else */
 684
 19685            if (parameters is X509SecurityTokenParameters)
 686            {
 8687                result = CreateWsspX509TokenAssertion(exporter, (X509SecurityTokenParameters)parameters);
 688            }
 11689            else if (parameters is UserNameSecurityTokenParameters)
 690            {
 1691                result = CreateWsspUsernameTokenAssertion(exporter, (UserNameSecurityTokenParameters)parameters);
 692            }
 10693            else if (parameters is IssuedSecurityTokenParameters)
 694            {
 0695                result = CreateWsspIssuedTokenAssertion(exporter, (IssuedSecurityTokenParameters)parameters);
 696            }
 10697            else if (parameters is SspiSecurityTokenParameters)
 698            {
 1699                result = CreateWsspSpnegoContextTokenAssertion(exporter, (SspiSecurityTokenParameters)parameters);
 700            }
 9701            else if (parameters is SslSecurityTokenParameters)
 702            {
 0703                result = CreateMsspSslContextTokenAssertion(exporter, (SslSecurityTokenParameters)parameters);
 704            }
 9705            else if (parameters is SecureConversationSecurityTokenParameters)
 706            {
 9707                result = CreateWsspSecureConversationTokenAssertion(exporter, (SecureConversationSecurityTokenParameters
 708            }
 709            /*else if (parameters is RsaSecurityTokenParameters) // If this is enabled, CreateWsspRsaTokenAssertion need
 710            {
 711                result = CreateWsspRsaTokenAssertion((RsaSecurityTokenParameters)parameters);
 712            }*/
 713            else
 714            {
 0715                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException(nameof(paramet
 716            }
 717
 19718            if (result != null && isOptional)
 719            {
 0720                result.SetAttribute(OptionalName, exporter.PolicyVersion.Namespace, TrueName);
 721            }
 722
 19723            return result;
 724        }
 725
 726        public virtual void SetIncludeTokenValue(XmlElement tokenAssertion, SecurityTokenInclusionMode inclusionMode)
 727        {
 728            switch (inclusionMode)
 729            {
 730                default:
 0731                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("inclusion
 732                case SecurityTokenInclusionMode.AlwaysToInitiator:
 0733                    tokenAssertion.SetAttribute(IncludeTokenName, WsspNamespaceUri, AlwaysToInitiatorUri);
 0734                    break;
 735                case SecurityTokenInclusionMode.AlwaysToRecipient:
 19736                    tokenAssertion.SetAttribute(IncludeTokenName, WsspNamespaceUri, AlwaysToRecipientUri);
 19737                    break;
 738                case SecurityTokenInclusionMode.Never:
 0739                    tokenAssertion.SetAttribute(IncludeTokenName, WsspNamespaceUri, NeverUri);
 0740                    break;
 741                case SecurityTokenInclusionMode.Once:
 0742                    tokenAssertion.SetAttribute(IncludeTokenName, WsspNamespaceUri, OnceUri);
 743                    break;
 744            }
 0745        }
 746
 747        public virtual XmlElement CreateWsspRequireDerivedKeysAssertion(bool requireDerivedKeys)
 748        {
 18749            if (requireDerivedKeys)
 750            {
 0751                return CreateWsspAssertion(RequireDerivedKeysName);
 752            }
 753            else
 754            {
 18755                return null;
 756            }
 757        }
 758
 759        public virtual XmlElement CreateX509ReferenceStyleAssertion(X509KeyIdentifierClauseType referenceStyle)
 760        {
 761            switch (referenceStyle)
 762            {
 763                default:
 0764                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException(nameof(ref
 765                case X509KeyIdentifierClauseType.IssuerSerial:
 0766                    _mustSupportRefIssuerSerialName = true;
 0767                    return CreateWsspAssertion(RequireIssuerSerialReferenceName);
 768                case X509KeyIdentifierClauseType.SubjectKeyIdentifier:
 0769                    _mustSupportRefKeyIdentifierName = true;
 0770                    return CreateWsspAssertion(RequireKeyIdentifierReferenceName);
 771                case X509KeyIdentifierClauseType.Thumbprint:
 8772                    _mustSupportRefThumbprintName = true;
 8773                    return CreateWsspAssertion(RequireThumbprintReferenceName);
 774                case X509KeyIdentifierClauseType.Any:
 0775                    _mustSupportRefIssuerSerialName = true;
 0776                    _mustSupportRefKeyIdentifierName = true;
 0777                    _mustSupportRefThumbprintName = true;
 0778                    return null;
 779            }
 780        }
 781
 782        public virtual XmlElement CreateWsspX509TokenAssertion(MetadataExporter exporter, X509SecurityTokenParameters pa
 783        {
 8784            XmlElement result = CreateWsspAssertion(X509TokenName);
 8785            SetIncludeTokenValue(result, parameters.InclusionMode);
 8786            result.AppendChild(
 8787                CreateWspPolicyWrapper(
 8788                    exporter,
 8789                    CreateWsspRequireDerivedKeysAssertion(parameters.RequireDerivedKeys),
 8790                    CreateX509ReferenceStyleAssertion(parameters.X509ReferenceStyle),
 8791                    CreateWsspAssertion(WssX509V3Token10Name)
 8792            ));
 8793            return result;
 794        }
 795
 796        public virtual XmlElement CreateWsspUsernameTokenAssertion(MetadataExporter exporter, UserNameSecurityTokenParam
 797        {
 1798            XmlElement result = CreateWsspAssertion(UsernameTokenName);
 1799            SetIncludeTokenValue(result, parameters.InclusionMode);
 1800            result.AppendChild(
 1801                CreateWspPolicyWrapper(
 1802                    exporter,
 1803                    CreateWsspAssertion(WssUsernameToken10Name)
 1804            ));
 1805            return result;
 806        }
 807
 808        public virtual XmlElement CreateReferenceStyleAssertion(SecurityTokenReferenceStyle referenceStyle)
 809        {
 810            switch (referenceStyle)
 811            {
 812                default:
 0813                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException(nameof(ref
 814                case SecurityTokenReferenceStyle.External:
 0815                    return CreateWsspAssertion(RequireExternalReferenceName);
 816                case SecurityTokenReferenceStyle.Internal:
 0817                    return CreateWsspAssertion(RequireInternalReferenceName);
 818            }
 819        }
 820
 821        public virtual XmlElement CreateWsspIssuerElement(EndpointAddress issuerAddress, EndpointAddress issuerMetadataA
 822        {
 823            XmlElement result;
 0824            if (issuerAddress == null && issuerMetadataAddress == null)
 825            {
 0826                result = null;
 827            }
 828            else
 829            {
 830                EndpointAddress addressToSerialize;
 0831                addressToSerialize = issuerAddress == null ? EndpointAddress.AnonymousAddress : issuerAddress;
 832
 833                MemoryStream stream;
 834                XmlWriter writer;
 835
 0836                if (issuerMetadataAddress != null)
 837                {
 0838                    MetadataSet metadataSet = new MetadataSet();
 0839                    metadataSet.MetadataSections.Add(new MetadataSection(null, null, new MetadataReference(issuerMetadat
 840
 0841                    stream = new MemoryStream();
 0842                    writer = new XmlTextWriter(stream, System.Text.Encoding.UTF8);
 0843                    metadataSet.WriteTo(XmlDictionaryWriter.CreateDictionaryWriter(writer));
 0844                    writer.Flush();
 0845                    stream.Seek(0, SeekOrigin.Begin);
 846
 0847                    addressToSerialize = new EndpointAddress(
 0848                        addressToSerialize.Uri,
 0849                        addressToSerialize.Identity,
 0850                        addressToSerialize.Headers,
 0851                        XmlDictionaryReader.CreateDictionaryReader(XmlReader.Create(stream)),
 0852                        addressToSerialize.GetReaderAtExtensions());
 853                }
 854
 0855                stream = new MemoryStream();
 0856                writer = new XmlTextWriter(stream, System.Text.Encoding.UTF8);
 0857                writer.WriteStartElement(IssuerName, WsspNamespaceUri);
 0858                addressToSerialize.WriteContentsTo(AddressingVersion.WSAddressing10, writer);
 0859                writer.WriteEndElement();
 0860                writer.Flush();
 0861                stream.Seek(0, SeekOrigin.Begin);
 0862                result = (XmlElement)doc.ReadNode(new XmlTextReader(stream) { DtdProcessing = DtdProcessing.Prohibit });
 863            }
 0864            return result;
 865        }
 866
 867        public virtual XmlElement CreateWsspIssuedTokenAssertion(MetadataExporter exporter, IssuedSecurityTokenParameter
 868        {
 0869            XmlElement result = CreateWsspAssertion(IssuedTokenName);
 0870            SetIncludeTokenValue(result, parameters.InclusionMode);
 0871            XmlElement issuerAssertion = CreateWsspIssuerElement(parameters.IssuerAddress, parameters.IssuerMetadataAddr
 0872            if (issuerAssertion != null)
 873            {
 0874                result.AppendChild(issuerAssertion);
 875            }
 0876            XmlElement tokenTemplate = CreateWsspAssertion(RequestSecurityTokenTemplateName);
 0877            TrustDriver driver = TrustDriver;
 0878            foreach (XmlElement p in parameters.CreateRequestParameters(driver))
 879            {
 0880                tokenTemplate.AppendChild(doc.ImportNode(p, true));
 881            }
 0882            result.AppendChild(tokenTemplate);
 0883            result.AppendChild(
 0884                CreateWspPolicyWrapper(
 0885                    exporter,
 0886                    CreateWsspRequireDerivedKeysAssertion(parameters.RequireDerivedKeys),
 0887                    CreateReferenceStyleAssertion(parameters.ReferenceStyle)
 0888            ));
 0889            return result;
 890        }
 891
 892        public virtual XmlElement CreateWsspMustNotSendCancelAssertion(bool requireCancel)
 893        {
 0894            if (!requireCancel)
 895            {
 0896                XmlElement result = CreateWsspAssertion(MustNotSendCancelName);
 0897                return result;
 898            }
 899            else
 900            {
 0901                return null;
 902            }
 903        }
 904
 905        public virtual XmlElement CreateWsspSpnegoContextTokenAssertion(MetadataExporter exporter, SspiSecurityTokenPara
 906        {
 1907            XmlElement result = CreateWsspAssertion(SpnegoContextTokenName);
 1908            SetIncludeTokenValue(result, parameters.InclusionMode);
 1909            result.AppendChild(
 1910                CreateWspPolicyWrapper(
 1911                    exporter,
 1912                    CreateWsspRequireDerivedKeysAssertion(parameters.RequireDerivedKeys),
 1913                    CreateWsspMustNotSendCancelAssertion(parameters.RequireCancellation)
 1914            ));
 1915            return result;
 916        }
 917
 918        public virtual XmlElement CreateMsspRequireClientCertificateAssertion(bool requireClientCertificate)
 919        {
 0920            if (requireClientCertificate)
 921            {
 0922                return CreateMsspAssertion(RequireClientCertificateName);
 923            }
 924            else
 925            {
 0926                return null;
 927            }
 928        }
 929
 930        public virtual XmlElement CreateMsspSslContextTokenAssertion(MetadataExporter exporter, SslSecurityTokenParamete
 931        {
 0932            XmlElement result = CreateMsspAssertion(SslContextTokenName);
 0933            SetIncludeTokenValue(result, parameters.InclusionMode);
 0934            result.AppendChild(
 0935                CreateWspPolicyWrapper(
 0936                    exporter,
 0937                    CreateWsspRequireDerivedKeysAssertion(parameters.RequireDerivedKeys),
 0938                    CreateWsspMustNotSendCancelAssertion(parameters.RequireCancellation),
 0939                    CreateMsspRequireClientCertificateAssertion(parameters.RequireClientCertificate)
 0940            ));
 0941            return result;
 942        }
 943
 944        public virtual XmlElement CreateWsspBootstrapPolicyAssertion(MetadataExporter exporter, SecurityBindingElement b
 945        {
 9946            if (bootstrapSecurity == null)
 0947                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(bootstrapSecurity));
 948
 9949            WSSecurityPolicy sp = WSSecurityPolicy.GetSecurityPolicyDriver(bootstrapSecurity.MessageSecurityVersion);
 950
 951            // create complete bootstrap binding
 952
 9953            CustomBinding bootstrapBinding = new CustomBinding(bootstrapSecurity);
 9954            if (exporter.State.ContainsKey(SecurityPolicyStrings.SecureConversationBootstrapBindingElementsBelowSecurity
 955            {
 9956                BindingElementCollection bindingElementsBelowSecurity = exporter.State[SecurityPolicyStrings.SecureConve
 9957                if (bindingElementsBelowSecurity != null)
 958                {
 54959                    foreach (BindingElement be in bindingElementsBelowSecurity)
 960                    {
 18961                        bootstrapBinding.Elements.Add(be);
 962                    }
 963                }
 964            }
 965
 966            // generate policy for the "how" of security
 967
 9968            ServiceEndpoint bootstrapEndpoint = new ServiceEndpoint(NullContract);
 9969            bootstrapEndpoint.Binding = bootstrapBinding;
 9970            PolicyConversionContext policyContext = exporter.ExportPolicy(bootstrapEndpoint);
 971
 972            // generate policy for the "what" of security (protection assertions)
 973
 974            // hard-coded requirements in V1: sign and encrypt RST and RSTR body
 9975            ChannelProtectionRequirements bootstrapProtection = new ChannelProtectionRequirements();
 9976            bootstrapProtection.IncomingEncryptionParts.AddParts(new MessagePartSpecification(true));
 9977            bootstrapProtection.OutgoingEncryptionParts.AddParts(new MessagePartSpecification(true));
 9978            bootstrapProtection.IncomingSignatureParts.AddParts(new MessagePartSpecification(true));
 9979            bootstrapProtection.OutgoingSignatureParts.AddParts(new MessagePartSpecification(true));
 980
 981            // add boostrap binding protection requirements (e.g. addressing headers)
 9982            ChannelProtectionRequirements cpr = bootstrapBinding.GetProperty<ChannelProtectionRequirements>(new BindingP
 9983            if (cpr != null)
 984            {
 9985                bootstrapProtection.Add(cpr);
 986            }
 987
 988            // extract channel-scope protection requirements and union them across request and response
 9989            MessagePartSpecification encryption = new MessagePartSpecification();
 9990            encryption.Union(bootstrapProtection.IncomingEncryptionParts.ChannelParts);
 9991            encryption.Union(bootstrapProtection.OutgoingEncryptionParts.ChannelParts);
 9992            encryption.MakeReadOnly();
 9993            MessagePartSpecification signature = new MessagePartSpecification();
 9994            signature.Union(bootstrapProtection.IncomingSignatureParts.ChannelParts);
 9995            signature.Union(bootstrapProtection.OutgoingSignatureParts.ChannelParts);
 9996            signature.MakeReadOnly();
 997
 998            // create final boostrap policy assertion
 999
 91000            XmlElement nestedPolicy = CreateWspPolicyWrapper(
 91001                    exporter,
 91002                    sp.CreateWsspSignedPartsAssertion(signature),
 91003                    sp.CreateWsspEncryptedPartsAssertion(encryption));
 901004            foreach (XmlElement e in sp.FilterWsspPolicyAssertions(policyContext.GetBindingAssertions()))
 1005            {
 361006                nestedPolicy.AppendChild(e);
 1007            }
 91008            XmlElement result = CreateWsspAssertion(BootstrapPolicyName);
 91009            result.AppendChild(nestedPolicy);
 1010
 91011            return result;
 1012        }
 1013
 1014        public virtual ICollection<XmlElement> FilterWsspPolicyAssertions(ICollection<XmlElement> policyAssertions)
 1015        {
 91016            Collection<XmlElement> result = new Collection<XmlElement>();
 1017
 1081018            foreach (XmlElement assertion in policyAssertions)
 451019                if (IsWsspAssertion(assertion))
 361020                    result.Add(assertion);
 1021
 91022            return result;
 1023        }
 1024
 1025        public virtual XmlElement CreateWsspSecureConversationTokenAssertion(MetadataExporter exporter, SecureConversati
 1026        {
 91027            XmlElement result = CreateWsspAssertion(SecureConversationTokenName);
 91028            SetIncludeTokenValue(result, parameters.InclusionMode);
 91029            result.AppendChild(
 91030                CreateWspPolicyWrapper(
 91031                    exporter,
 91032                    CreateWsspRequireDerivedKeysAssertion(parameters.RequireDerivedKeys),
 91033                    CreateWsspMustNotSendCancelAssertion(parameters.RequireCancellation),
 91034                    CreateWsspBootstrapPolicyAssertion(exporter, parameters.BootstrapSecurityBindingElement)
 91035            ));
 91036            return result;
 1037        }
 1038
 1039        public static WSSecurityPolicy GetSecurityPolicyDriver(MessageSecurityVersion version)
 1040        {
 501041            SecurityPolicyManager policyManager = new SecurityPolicyManager();
 501042            return policyManager.GetSecurityPolicyDriver(version);
 1043        }
 1044
 1045        private class SecurityPolicyManager
 1046        {
 1047            private readonly List<WSSecurityPolicy> _drivers;
 1048
 501049            public SecurityPolicyManager()
 1050            {
 501051                _drivers = new List<WSSecurityPolicy>();
 501052                Initialize();
 501053            }
 1054
 1055            public void Initialize()
 1056            {
 501057                _drivers.Add(new WSSecurityPolicy11());
 501058                _drivers.Add(new WSSecurityPolicy12());
 501059            }
 1060
 1061            public WSSecurityPolicy GetSecurityPolicyDriver(MessageSecurityVersion version)
 1062            {
 1001063                for (int i = 0; i < _drivers.Count; ++i)
 1064                {
 501065                    if (_drivers[i].IsSecurityVersionSupported(version))
 1066                    {
 501067                        return _drivers[i];
 1068                    }
 1069                }
 1070
 01071                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException());
 1072            }
 1073
 1074        }
 1075    }
 1076
 1077    internal static class SecurityPolicyStrings
 1078    {
 1079        public const string SecureConversationBootstrapBindingElementsBelowSecurityKey = "SecureConversationBootstrapBin
 1080    }
 1081}
Generated by: ReportGenerator 5.5.11.0
08/09/2026 - 10:15:50
GitHub | reportgenerator.io

Methods/Properties

.cctor()
CreateWsspAssertion(System.String)
IsWsspAssertion(System.Xml.XmlElement)
CreateMsspAssertion(System.String)
AlwaysToRecipientUri()
NeverUri()
OnceUri()
AlwaysToInitiatorUri()
CreateWspPolicyWrapper(CoreWCF.Description.MetadataExporter,System.Xml.XmlElement[])
CreateWsspSignedPartsAssertion(CoreWCF.Security.MessagePartSpecification)
CreateWsspEncryptedPartsAssertion(CoreWCF.Security.MessagePartSpecification)
CreateWsspHeaderAssertion(System.Xml.XmlQualifiedName)
CreateWsspTransportBindingAssertion(CoreWCF.Description.MetadataExporter,CoreWCF.Channels.TransportSecurityBindingElement,System.Xml.XmlElement)
CreateWsspWssAssertion(CoreWCF.Description.MetadataExporter,CoreWCF.Channels.SecurityBindingElement)
CreateWsspWss10Assertion(CoreWCF.Description.MetadataExporter)
CreateWsspWss11Assertion(CoreWCF.Description.MetadataExporter,System.Boolean)
CreateWsspAssertionMustSupportRefKeyIdentifierName()
CreateWsspAssertionMustSupportRefIssuerSerialName()
CreateWsspAssertionMustSupportRefThumbprintName()
CreateWsspAssertionMustSupportRefEncryptedKeyName()
CreateWsspRequireSignatureConformationAssertion(System.Boolean)
CreateWsspTrustAssertion(System.String,CoreWCF.Description.MetadataExporter,CoreWCF.Security.SecurityKeyEntropyMode)
CreateWsspRequireClientEntropyAssertion(CoreWCF.Security.SecurityKeyEntropyMode)
CreateWsspRequireServerEntropyAssertion(CoreWCF.Security.SecurityKeyEntropyMode)
CreateWsspSupportingTokensAssertion(CoreWCF.Description.MetadataExporter,System.Collections.ObjectModel.Collection`1<CoreWCF.Security.Tokens.SecurityTokenParameters>,System.Collections.ObjectModel.Collection`1<CoreWCF.Security.Tokens.SecurityTokenParameters>,System.Collections.ObjectModel.Collection`1<CoreWCF.Security.Tokens.SecurityTokenParameters>,System.Collections.ObjectModel.Collection`1<CoreWCF.Security.Tokens.SecurityTokenParameters>,System.Collections.ObjectModel.Collection`1<CoreWCF.Security.Tokens.SecurityTokenParameters>,System.Collections.ObjectModel.Collection`1<CoreWCF.Security.Tokens.SecurityTokenParameters>,System.Collections.ObjectModel.Collection`1<CoreWCF.Security.Tokens.SecurityTokenParameters>,System.Collections.ObjectModel.Collection`1<CoreWCF.Security.Tokens.SecurityTokenParameters>)
CreateWsspSupportingTokensAssertion(CoreWCF.Description.MetadataExporter,System.Collections.ObjectModel.Collection`1<CoreWCF.Security.Tokens.SecurityTokenParameters>,System.Collections.ObjectModel.Collection`1<CoreWCF.Security.Tokens.SecurityTokenParameters>,System.Collections.ObjectModel.Collection`1<CoreWCF.Security.Tokens.SecurityTokenParameters>,System.Collections.ObjectModel.Collection`1<CoreWCF.Security.Tokens.SecurityTokenParameters>,System.Collections.ObjectModel.Collection`1<CoreWCF.Security.Tokens.SecurityTokenParameters>,System.Collections.ObjectModel.Collection`1<CoreWCF.Security.Tokens.SecurityTokenParameters>,System.Collections.ObjectModel.Collection`1<CoreWCF.Security.Tokens.SecurityTokenParameters>,System.Collections.ObjectModel.Collection`1<CoreWCF.Security.Tokens.SecurityTokenParameters>,CoreWCF.Channels.AddressingVersion)
CreateWsspSignedSupportingTokensAssertion(CoreWCF.Description.MetadataExporter,System.Collections.ObjectModel.Collection`1<CoreWCF.Security.Tokens.SecurityTokenParameters>,System.Collections.ObjectModel.Collection`1<CoreWCF.Security.Tokens.SecurityTokenParameters>,System.Collections.ObjectModel.Collection`1<CoreWCF.Security.Tokens.SecurityTokenParameters>,System.Collections.ObjectModel.Collection`1<CoreWCF.Security.Tokens.SecurityTokenParameters>)
CreateWsspEndorsingSupportingTokensAssertion(CoreWCF.Description.MetadataExporter,System.Collections.ObjectModel.Collection`1<CoreWCF.Security.Tokens.SecurityTokenParameters>,System.Collections.ObjectModel.Collection`1<CoreWCF.Security.Tokens.SecurityTokenParameters>,CoreWCF.Channels.AddressingVersion)
CreateWsspSignedEndorsingSupportingTokensAssertion(CoreWCF.Description.MetadataExporter,System.Collections.ObjectModel.Collection`1<CoreWCF.Security.Tokens.SecurityTokenParameters>,System.Collections.ObjectModel.Collection`1<CoreWCF.Security.Tokens.SecurityTokenParameters>,CoreWCF.Channels.AddressingVersion)
CreateWsspiSupportingTokensAssertion(CoreWCF.Description.MetadataExporter,System.Collections.ObjectModel.Collection`1<CoreWCF.Security.Tokens.SecurityTokenParameters>,System.Collections.ObjectModel.Collection`1<CoreWCF.Security.Tokens.SecurityTokenParameters>,CoreWCF.Channels.AddressingVersion,System.String)
CreateWsspIncludeTimestampAssertion(System.Boolean)
CreateWsspLayoutAssertion(CoreWCF.Description.MetadataExporter,CoreWCF.Channels.SecurityHeaderLayout)
CreateLayoutAssertion(CoreWCF.Channels.SecurityHeaderLayout)
CreateWsspAlgorithmSuiteAssertion(CoreWCF.Description.MetadataExporter,CoreWCF.Security.SecurityAlgorithmSuite)
CreateAlgorithmSuiteAssertion(CoreWCF.Security.SecurityAlgorithmSuite)
CreateWsspTransportTokenAssertion(CoreWCF.Description.MetadataExporter,System.Xml.XmlElement)
CreateTokenAssertion(CoreWCF.Description.MetadataExporter,CoreWCF.Security.Tokens.SecurityTokenParameters)
CreateTokenAssertion(CoreWCF.Description.MetadataExporter,CoreWCF.Security.Tokens.SecurityTokenParameters,System.Boolean)
SetIncludeTokenValue(System.Xml.XmlElement,CoreWCF.Security.Tokens.SecurityTokenInclusionMode)
CreateWsspRequireDerivedKeysAssertion(System.Boolean)
CreateX509ReferenceStyleAssertion(CoreWCF.Security.Tokens.X509KeyIdentifierClauseType)
CreateWsspX509TokenAssertion(CoreWCF.Description.MetadataExporter,CoreWCF.Security.Tokens.X509SecurityTokenParameters)
CreateWsspUsernameTokenAssertion(CoreWCF.Description.MetadataExporter,CoreWCF.Security.Tokens.UserNameSecurityTokenParameters)
CreateReferenceStyleAssertion(CoreWCF.Security.Tokens.SecurityTokenReferenceStyle)
CreateWsspIssuerElement(CoreWCF.EndpointAddress,CoreWCF.EndpointAddress)
CreateWsspIssuedTokenAssertion(CoreWCF.Description.MetadataExporter,CoreWCF.Security.Tokens.IssuedSecurityTokenParameters)
CreateWsspMustNotSendCancelAssertion(System.Boolean)
CreateWsspSpnegoContextTokenAssertion(CoreWCF.Description.MetadataExporter,CoreWCF.Security.Tokens.SspiSecurityTokenParameters)
CreateMsspRequireClientCertificateAssertion(System.Boolean)
CreateMsspSslContextTokenAssertion(CoreWCF.Description.MetadataExporter,CoreWCF.Security.Tokens.SslSecurityTokenParameters)
CreateWsspBootstrapPolicyAssertion(CoreWCF.Description.MetadataExporter,CoreWCF.Channels.SecurityBindingElement)
FilterWsspPolicyAssertions(System.Collections.Generic.ICollection`1<System.Xml.XmlElement>)
CreateWsspSecureConversationTokenAssertion(CoreWCF.Description.MetadataExporter,CoreWCF.Security.Tokens.SecureConversationSecurityTokenParameters)
GetSecurityPolicyDriver(CoreWCF.MessageSecurityVersion)
.ctor()
Initialize()
GetSecurityPolicyDriver(CoreWCF.MessageSecurityVersion)