protected virtual SecurityBindingElement ApplyMessageSecurity(SecurityBindingElement securityBindingElement)
 {
     if (securityBindingElement == null)
     {
         throw new ArgumentNullException("securityBindingElement");
     }
     
     if (TrustVersion.WSTrustFeb2005 == _trustVersion)
     {
         securityBindingElement.MessageSecurityVersion = MessageSecurityVersion.WSSecurity11WSTrustFebruary2005WSSecureConversationFebruary2005WSSecurityPolicy11BasicSecurityProfile10;
     }
     else
     {
         securityBindingElement.MessageSecurityVersion = MessageSecurityVersion.WSSecurity11WSTrust13WSSecureConversation13WSSecurityPolicy12BasicSecurityProfile10;
     }
     
     if (_enableRsaProofKeys)
     {
         RsaSecurityTokenParameters item = new RsaSecurityTokenParameters
         {
             InclusionMode = SecurityTokenInclusionMode.Never,
             RequireDerivedKeys = false
         };
         securityBindingElement.OptionalEndpointSupportingTokenParameters.Endorsing.Add(item);
     }
     
     return securityBindingElement;
 }

 internal static bool TryCreate(SecurityBindingElement sbe, out MessageSecurityOverMsmq messageSecurity)
 {
     MessageCredentialType none;
     messageSecurity = null;
     if (sbe == null)
     {
         return false;
     }
     SymmetricSecurityBindingElement element = sbe as SymmetricSecurityBindingElement;
     if (element == null)
     {
         return false;
     }
     if ((sbe.MessageSecurityVersion != MessageSecurityVersion.WSSecurity11WSTrustFebruary2005WSSecureConversationFebruary2005WSSecurityPolicy11BasicSecurityProfile10) && (sbe.MessageSecurityVersion != MessageSecurityVersion.WSSecurity11WSTrustFebruary2005WSSecureConversationFebruary2005WSSecurityPolicy11))
     {
         return false;
     }
     if (element.IncludeTimestamp)
     {
         return false;
     }
     bool flag = false;
     if (SecurityBindingElement.IsAnonymousForCertificateBinding(sbe))
     {
         none = MessageCredentialType.None;
     }
     else if (SecurityBindingElement.IsUserNameForCertificateBinding(sbe))
     {
         none = MessageCredentialType.UserName;
     }
     else if (SecurityBindingElement.IsMutualCertificateBinding(sbe))
     {
         none = MessageCredentialType.Certificate;
     }
     else if (SecurityBindingElement.IsKerberosBinding(sbe))
     {
         none = MessageCredentialType.Windows;
         flag = true;
     }
     else
     {
         IssuedSecurityTokenParameters parameters;
         if (!SecurityBindingElement.IsIssuedTokenForCertificateBinding(sbe, out parameters))
         {
             return false;
         }
         if (!IssuedSecurityTokenParameters.IsInfoCardParameters(parameters, new SecurityStandardsManager(sbe.MessageSecurityVersion, new WSSecurityTokenSerializer(sbe.MessageSecurityVersion.SecurityVersion, sbe.MessageSecurityVersion.TrustVersion, sbe.MessageSecurityVersion.SecureConversationVersion, true, null, null, null))))
         {
             return false;
         }
         none = MessageCredentialType.IssuedToken;
     }
     messageSecurity = new MessageSecurityOverMsmq();
     messageSecurity.ClientCredentialType = none;
     if ((none != MessageCredentialType.IssuedToken) && !flag)
     {
         messageSecurity.AlgorithmSuite = element.DefaultAlgorithmSuite;
     }
     return true;
 }

 internal static bool TryCreate(SecurityBindingElement sbe, TransportBindingElement transport, PrivacyNoticeBindingElement privacy, ReliableSessionBindingElement rsbe, TransactionFlowBindingElement tfbe, out Binding binding)
 {
     WSFederationHttpSecurityMode mode;
     WSFederationHttpSecurity security2;
     bool isReliableSession = rsbe != null;
     binding = null;
     HttpTransportSecurity transportSecurity = new HttpTransportSecurity();
     if (!WSFederationHttpBinding.GetSecurityModeFromTransport(transport, transportSecurity, out mode))
     {
         return false;
     }
     HttpsTransportBindingElement element = transport as HttpsTransportBindingElement;
     if (((element != null) && (element.MessageSecurityVersion != null)) && (element.MessageSecurityVersion.SecurityPolicyVersion != WS2007MessageSecurityVersion.SecurityPolicyVersion))
     {
         return false;
     }
     if (TryCreateSecurity(sbe, mode, transportSecurity, isReliableSession, out security2))
     {
         binding = new WS2007FederationHttpBinding(security2, privacy, isReliableSession);
     }
     if ((rsbe != null) && (rsbe.ReliableMessagingVersion != ReliableMessagingVersion.WSReliableMessaging11))
     {
         return false;
     }
     if ((tfbe != null) && (tfbe.TransactionProtocol != TransactionProtocol.WSAtomicTransaction11))
     {
         return false;
     }
     return (binding != null);
 }

 public SpnegoTokenProvider(System.IdentityModel.SafeFreeCredentials credentialsHandle, SecurityBindingElement securityBindingElement) : base(securityBindingElement)
 {
     this.allowedImpersonationLevel = TokenImpersonationLevel.Identification;
     this.identityVerifier = System.ServiceModel.Security.IdentityVerifier.CreateDefault();
     this.allowNtlm = true;
     this.authenticateServer = true;
     this.interactiveNegoExLogonEnabled = true;
     this.credentialsHandle = credentialsHandle;
 }

        private void Initialize()
        {
            _securityBindingElement = CreateSecurityBindingElement();

            _textEncodingBindingElement = CreateTextEncodingBindingElement();

            //_httpsTransportBindingElement = CreateHttpsTransportBindingElement();
            _httpTransportBindingElement = CreateHttpTransportBindingElement();
        }

        private void Initialize()
        {
            _securityBindingElement = CreateSecurityBindingElement();

            _reliableSessionBindingElement = CreateReliableSessionBindingElement();

            _mtomEncodingBindingElement = CreateMtomEncodingBindingElement();

            _httpsTransportBindingElement = CreateHttpsTransportBindingElement() as HttpsTransportBindingElement;
        }

        protected SecureConversationSecurityTokenParameters(SecureConversationSecurityTokenParameters other)
            : base(other)
        {
            _requireCancellation = other._requireCancellation;
            _canRenewSession = other._canRenewSession;
            if (other._bootstrapSecurityBindingElement != null)
                _bootstrapSecurityBindingElement = (SecurityBindingElement)other._bootstrapSecurityBindingElement.Clone();

            if (other._issuerBindingContext != null)
                _issuerBindingContext = other._issuerBindingContext.Clone();
        }

 protected SecureConversationSecurityTokenParameters(SecureConversationSecurityTokenParameters other)
     : base(other)
 {
     this.requireCancellation = other.requireCancellation;
     this.canRenewSession = other.canRenewSession;
     if (other.bootstrapSecurityBindingElement != null)
         this.bootstrapSecurityBindingElement = (SecurityBindingElement)other.bootstrapSecurityBindingElement.Clone();
     if (other.bootstrapProtectionRequirements != null)
         this.bootstrapProtectionRequirements = new ChannelProtectionRequirements(other.bootstrapProtectionRequirements);
     if (other.issuerBindingContext != null)
         this.issuerBindingContext = other.issuerBindingContext.Clone();
 }

		public SecureConversationSecurityTokenParameters (
			SecurityBindingElement element,
			bool requireCancellation,
			ChannelProtectionRequirements requirements)
		{
			this.element = element;
			this.cancellable = requireCancellation;
			if (requirements == null)
				this.requirements = new ChannelProtectionRequirements (default_channel_protection_requirements);
			else
				this.requirements = new ChannelProtectionRequirements (requirements);
		}

 static IEnumerable<SecurityTokenParameters> EnumerateNestedTokenParameters(SecurityBindingElement element)
 {
     foreach (SecurityTokenParameters parameters in EnumerateTokenParameters(element))
     {
         if (parameters is SecureConversationSecurityTokenParameters)
         {
             SecurityBindingElement nestedElement = ((SecureConversationSecurityTokenParameters)parameters).BootstrapSecurityBindingElement;
             foreach (SecurityTokenParameters nestedParameters in EnumerateTokenParameters(nestedElement))
             {
                 yield return nestedParameters;
             }
         }
     }
 }

        // This is effectively just a copy of WSHttpBinding.TryCreate(), only it news up the 2007 version
        internal new static bool TryCreate(SecurityBindingElement sbe, TransportBindingElement transport, ReliableSessionBindingElement rsbe, TransactionFlowBindingElement tfbe, out Binding binding)
        {
            bool isReliableSession = (rsbe != null);
            binding = null;

            // reverse GetTransport
            HttpTransportSecurity transportSecurity = WSHttpSecurity.GetDefaultHttpTransportSecurity();
            UnifiedSecurityMode mode;
            if (!WSHttpBinding.GetSecurityModeFromTransport(transport, transportSecurity, out mode))
            {
                return false;
            }

            HttpsTransportBindingElement httpsBinding = transport as HttpsTransportBindingElement;
            if (httpsBinding != null && httpsBinding.MessageSecurityVersion != null)
            {
                if (httpsBinding.MessageSecurityVersion.SecurityPolicyVersion != WS2007MessageSecurityVersion.SecurityPolicyVersion)
                {
                    return false;
                }
            }

            WSHttpSecurity security;
            if (WS2007HttpBinding.TryCreateSecurity(sbe, mode, transportSecurity, isReliableSession, out security))
            {
                WS2007HttpBinding ws2007HttpBinding = new WS2007HttpBinding(security, isReliableSession);

                bool allowCookies;
                if (!WSHttpBinding.TryGetAllowCookiesFromTransport(transport, out allowCookies))
                {
                    return false;
                }

                ws2007HttpBinding.AllowCookies = allowCookies;
                binding = ws2007HttpBinding;
            }

            if (rsbe != null && rsbe.ReliableMessagingVersion != ReliableMessagingVersion.WSReliableMessaging11)
            {
                return false;
            }

            if (tfbe != null && tfbe.TransactionProtocol != TransactionProtocol.WSAtomicTransaction11)
            {
                return false;
            }

            return binding != null;
        }

 internal static bool TryCreate(SecurityBindingElement sbe, NetMsmqSecurityMode mode, out NetMsmqSecurity security)
 {
     MessageSecurityOverMsmq msmq;
     security = null;
     if (!MessageSecurityOverMsmq.TryCreate(sbe, out msmq))
     {
         msmq = null;
     }
     security = new NetMsmqSecurity(mode, null, msmq);
     if (sbe != null)
     {
         return SecurityElementBase.AreBindingsMatching(security.CreateMessageSecurity(), sbe, false);
     }
     return true;
 }

 private static bool HasSupportingTokens(SecurityBindingElement binding)
 {
     if (((binding.EndpointSupportingTokenParameters.Endorsing.Count > 0) || (binding.EndpointSupportingTokenParameters.SignedEndorsing.Count > 0)) || ((binding.EndpointSupportingTokenParameters.SignedEncrypted.Count > 0) || (binding.EndpointSupportingTokenParameters.Signed.Count > 0)))
     {
         return true;
     }
     foreach (SupportingTokenParameters parameters in binding.OperationSupportingTokenParameters.Values)
     {
         if (((parameters.Endorsing.Count > 0) || (parameters.SignedEndorsing.Count > 0)) || ((parameters.SignedEncrypted.Count > 0) || (parameters.Signed.Count > 0)))
         {
             return true;
         }
     }
     return false;
 }

 internal static bool TryCreate(SecurityBindingElement sbe, out WSDualHttpSecurity security)
 {
     security = null;
     if (sbe == null)
         security = new WSDualHttpSecurity(WSDualHttpSecurityMode.None, null);
     else
     {
         MessageSecurityOverHttp messageSecurity;
         if (!MessageSecurityOverHttp.TryCreate(sbe, false, true, out messageSecurity))
             return false;
         security = new WSDualHttpSecurity(WSDualHttpSecurityMode.Message, messageSecurity);
     }
     // the last check: make sure that security binding element match the incoming security
     return SecurityElement.AreBindingsMatching(security.CreateMessageSecurity(), sbe);
 }

        void ImportOperationScopeSupportingTokensPolicy(MetadataImporter importer, PolicyConversionContext policyContext, SecurityBindingElement binding)
        {
            foreach (OperationDescription operation in policyContext.Contract.Operations)
            {
                string requestAction = null;
                foreach (MessageDescription message in operation.Messages)
                {
                    if (message.Direction == MessageDirection.Input)
                    {
                        requestAction = message.Action;
                        break;
                    }
                }

                SupportingTokenParameters requirements = new SupportingTokenParameters();
                SupportingTokenParameters optionalRequirements = new SupportingTokenParameters();
                ICollection<XmlElement> operationBindingAssertions = policyContext.GetOperationBindingAssertions(operation);
                this.ImportSupportingTokenAssertions(importer, policyContext, operationBindingAssertions, requirements, optionalRequirements);
                if (requirements.Endorsing.Count > 0
                    || requirements.Signed.Count > 0
                    || requirements.SignedEncrypted.Count > 0
                    || requirements.SignedEndorsing.Count > 0)
                {
                    if (requestAction != null)
                    {
                        binding.OperationSupportingTokenParameters[requestAction] = requirements;
                    }
                    else
                    {
                        throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.CannotImportSupportingTokensForOperationWithoutRequestAction)));
                    }
                }
                if (optionalRequirements.Endorsing.Count > 0
                    || optionalRequirements.Signed.Count > 0
                    || optionalRequirements.SignedEncrypted.Count > 0
                    || optionalRequirements.SignedEndorsing.Count > 0)
                {
                    if (requestAction != null)
                    {
                        binding.OptionalOperationSupportingTokenParameters[requestAction] = optionalRequirements;
                    }
                    else
                    {
                        throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.CannotImportSupportingTokensForOperationWithoutRequestAction)));
                    }
                }
            }
        }

 internal static bool TryCreate(SecurityBindingElement sbe, out BasicHttpMessageSecurity security, out bool isSecureTransportMode)
 {
     BasicHttpMessageCredentialType userName;
     security = null;
     isSecureTransportMode = false;
     if (!sbe.DoNotEmitTrust)
     {
         return false;
     }
     if (!sbe.IsSetKeyDerivation(false))
     {
         return false;
     }
     if (sbe.SecurityHeaderLayout != SecurityHeaderLayout.Lax)
     {
         return false;
     }
     if (sbe.MessageSecurityVersion != MessageSecurityVersion.WSSecurity10WSTrustFebruary2005WSSecureConversationFebruary2005WSSecurityPolicy11BasicSecurityProfile10)
     {
         return false;
     }
     if (!SecurityBindingElement.IsMutualCertificateBinding(sbe, true))
     {
         isSecureTransportMode = true;
         if (!SecurityBindingElement.IsCertificateOverTransportBinding(sbe))
         {
             if (!SecurityBindingElement.IsUserNameOverTransportBinding(sbe))
             {
                 return false;
             }
             userName = BasicHttpMessageCredentialType.UserName;
         }
         else
         {
             userName = BasicHttpMessageCredentialType.Certificate;
         }
     }
     else
     {
         userName = BasicHttpMessageCredentialType.Certificate;
     }
     security = new BasicHttpMessageSecurity();
     security.ClientCredentialType = userName;
     security.AlgorithmSuite = sbe.DefaultAlgorithmSuite;
     return true;
 }

 internal static bool TryCreate(SecurityBindingElement wsSecurity, SecurityMode mode, bool isReliableSessionEnabled, BindingElement transportSecurity, TcpTransportSecurity tcpTransportSecurity, out NetTcpSecurity security)
 {
     security = null;
     MessageSecurityOverTcp messageSecurity = null;
     if (mode == SecurityMode.Message)
     {
         if (!MessageSecurityOverTcp.TryCreate(wsSecurity, isReliableSessionEnabled, null, out messageSecurity))
         {
             return false;
         }
     }
     else if ((mode == SecurityMode.TransportWithMessageCredential) && !MessageSecurityOverTcp.TryCreate(wsSecurity, isReliableSessionEnabled, transportSecurity, out messageSecurity))
     {
         return false;
     }
     security = new NetTcpSecurity(mode, tcpTransportSecurity, messageSecurity);
     return SecurityElementBase.AreBindingsMatching(security.CreateMessageSecurity(isReliableSessionEnabled), wsSecurity, false);
 }

 internal static bool TryCreate(SecurityBindingElement sbe, out WSDualHttpSecurity security)
 {
     security = null;
     if (sbe == null)
     {
         security = new WSDualHttpSecurity(WSDualHttpSecurityMode.None, null);
     }
     else
     {
         MessageSecurityOverHttp http;
         if (!MessageSecurityOverHttp.TryCreate<MessageSecurityOverHttp>(sbe, false, true, out http))
         {
             return false;
         }
         security = new WSDualHttpSecurity(WSDualHttpSecurityMode.Message, http);
     }
     return SecurityElementBase.AreBindingsMatching(security.CreateMessageSecurity(), sbe);
 }

 internal static bool TryCreate(SecurityBindingElement sbe, WSFederationHttpSecurityMode mode, HttpTransportSecurity transportSecurity, bool isReliableSessionEnabled, MessageSecurityVersion version, out WSFederationHttpSecurity security)
 {
     security = null;
     FederatedMessageSecurityOverHttp messageSecurity = null;
     if (sbe == null)
     {
         mode = WSFederationHttpSecurityMode.None;
     }
     else
     {
         mode &= WSFederationHttpSecurityMode.TransportWithMessageCredential | WSFederationHttpSecurityMode.Message;
         if (!FederatedMessageSecurityOverHttp.TryCreate(sbe, mode == WSFederationHttpSecurityMode.TransportWithMessageCredential, isReliableSessionEnabled, version, out messageSecurity))
         {
             return false;
         }
     }
     security = new WSFederationHttpSecurity(mode, messageSecurity);
     return true;
 }

 private void ImportEndpointScopeMessageBindingAssertions(MetadataImporter importer, PolicyConversionContext policyContext, SecurityBindingElement binding)
 {
     XmlElement assertion = null;
     WSSecurityPolicy policy;
     this.ImportSupportingTokenAssertions(importer, policyContext, policyContext.GetBindingAssertions(), binding.EndpointSupportingTokenParameters, binding.OptionalEndpointSupportingTokenParameters);
     if (WSSecurityPolicy.TryGetSecurityPolicyDriver(policyContext.GetBindingAssertions(), out policy))
     {
         if (!policy.TryImportWsspWssAssertion(importer, policyContext.GetBindingAssertions(), binding, out assertion) && (assertion != null))
         {
             throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("UnsupportedSecurityPolicyAssertion", new object[] { assertion.OuterXml })));
         }
         if (!policy.TryImportWsspTrustAssertion(importer, policyContext.GetBindingAssertions(), binding, out assertion) && (assertion != null))
         {
             throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("UnsupportedSecurityPolicyAssertion", new object[] { assertion.OuterXml })));
         }
     }
     if (assertion == null)
     {
         binding.DoNotEmitTrust = true;
     }
 }