void IPolicyExportExtension.ExportPolicy(MetadataExporter exporter, PolicyConversionContext context) { if (exporter == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context"); } if (context == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context"); } if (context.BindingElements != null) { BindingElementCollection bindingElements = context.BindingElements; ReliableSessionBindingElement settings = bindingElements.Find <ReliableSessionBindingElement>(); if (settings != null) { // ReliableSession assertion XmlElement assertion = settings.CreateReliabilityAssertion(exporter.PolicyVersion, bindingElements); context.GetBindingAssertions().Add(assertion); } } }
internal virtual void OnExportPolicy(MetadataExporter exporter, PolicyConversionContext policyContext) { string localName = null; switch (this.AuthenticationScheme) { case AuthenticationSchemes.Digest: localName = "DigestAuthentication"; break; case AuthenticationSchemes.Negotiate: localName = "NegotiateAuthentication"; break; case AuthenticationSchemes.Ntlm: localName = "NtlmAuthentication"; break; case AuthenticationSchemes.Basic: localName = "BasicAuthentication"; break; } if (localName != null) { policyContext.GetBindingAssertions().Add(new XmlDocument().CreateElement("http", localName, "http://schemas.microsoft.com/ws/06/2004/policy/http")); } }
void IPolicyExportExtension.ExportPolicy(MetadataExporter exporter, PolicyConversionContext context) { if (exporter == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("exporter"); } if (context == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context"); } ICollection <XmlElement> policyAssertions = context.GetBindingAssertions(); if (TransferModeHelper.IsRequestStreamed(this.TransferMode) || TransferModeHelper.IsResponseStreamed(this.TransferMode)) { policyAssertions.Add(new XmlDocument().CreateElement(TransportPolicyConstants.DotNetFramingPrefix, TransportPolicyConstants.StreamedName, TransportPolicyConstants.DotNetFramingNamespace)); } bool createdNew; MessageEncodingBindingElement encodingBindingElement = FindMessageEncodingBindingElement(context.BindingElements, out createdNew); if (createdNew && encodingBindingElement is IPolicyExportExtension) { encodingBindingElement = new BinaryMessageEncodingBindingElement(); ((IPolicyExportExtension)encodingBindingElement).ExportPolicy(exporter, context); } WsdlExporter.WSAddressingHelper.AddWSAddressingAssertion(exporter, context, encodingBindingElement.MessageVersion.Addressing); }
public override XmlElement CreateWsspHttpsTokenAssertion(MetadataExporter exporter, HttpsTransportBindingElement httpsBinding) { Fx.Assert(httpsBinding != null, "httpsBinding must not be null."); Fx.Assert(httpsBinding.AuthenticationScheme.IsSingleton(), "authenticationScheme must be a singleton value for security-mode TransportWithMessageCredential."); XmlElement result = CreateWsspAssertion(WSSecurityPolicy.HttpsTokenName); if (httpsBinding.RequireClientCertificate || httpsBinding.AuthenticationScheme == AuthenticationSchemes.Basic || httpsBinding.AuthenticationScheme == AuthenticationSchemes.Digest) { XmlElement policy = CreateWspPolicyWrapper(exporter); if (httpsBinding.RequireClientCertificate) { policy.AppendChild(CreateWsspAssertion(WSSecurityPolicy.RequireClientCertificateName)); } if (httpsBinding.AuthenticationScheme == AuthenticationSchemes.Basic) { policy.AppendChild(CreateWsspAssertion(WSSecurityPolicy.HttpBasicAuthenticationName)); } else if (httpsBinding.AuthenticationScheme == AuthenticationSchemes.Digest) { policy.AppendChild(CreateWsspAssertion(WSSecurityPolicy.HttpDigestAuthenticationName)); } result.AppendChild(policy); } return(result); }
public override Collection <XmlElement> CreateWsspSupportingTokensAssertion(MetadataExporter exporter, Collection <SecurityTokenParameters> signed, Collection <SecurityTokenParameters> signedEncrypted, Collection <SecurityTokenParameters> endorsing, Collection <SecurityTokenParameters> signedEndorsing, Collection <SecurityTokenParameters> optionalSigned, Collection <SecurityTokenParameters> optionalSignedEncrypted, Collection <SecurityTokenParameters> optionalEndorsing, Collection <SecurityTokenParameters> optionalSignedEndorsing, AddressingVersion addressingVersion) { Collection <XmlElement> collection = new Collection <XmlElement>(); XmlElement item = this.CreateWsspSignedSupportingTokensAssertion(exporter, signed, optionalSigned); if (item != null) { collection.Add(item); } item = this.CreateWsspSignedEncryptedSupportingTokensAssertion(exporter, signedEncrypted, optionalSignedEncrypted); if (item != null) { collection.Add(item); } item = base.CreateWsspEndorsingSupportingTokensAssertion(exporter, endorsing, optionalEndorsing, addressingVersion); if (item != null) { collection.Add(item); } item = base.CreateWsspSignedEndorsingSupportingTokensAssertion(exporter, signedEndorsing, optionalSignedEndorsing, addressingVersion); if (item != null) { collection.Add(item); } return(collection); }
public override XmlElement CreateWsspHttpsTokenAssertion(MetadataExporter exporter, HttpsTransportBindingElement httpsBinding) { XmlElement element = this.CreateWsspAssertion("HttpsToken"); element.SetAttribute("RequireClientCertificate", httpsBinding.RequireClientCertificate ? "true" : "false"); return(element); }
public override Collection <XmlElement> CreateWsspSupportingTokensAssertion(MetadataExporter exporter, Collection <SecurityTokenParameters> signed, Collection <SecurityTokenParameters> signedEncrypted, Collection <SecurityTokenParameters> endorsing, Collection <SecurityTokenParameters> signedEndorsing, Collection <SecurityTokenParameters> optionalSigned, Collection <SecurityTokenParameters> optionalSignedEncrypted, Collection <SecurityTokenParameters> optionalEndorsing, Collection <SecurityTokenParameters> optionalSignedEndorsing, AddressingVersion addressingVersion) { Collection <XmlElement> supportingTokenAssertions = new Collection <XmlElement>(); // Signed Supporting Tokens XmlElement supportingTokenAssertion = CreateWsspSignedSupportingTokensAssertion(exporter, signed, optionalSigned); if (supportingTokenAssertion != null) { supportingTokenAssertions.Add(supportingTokenAssertion); } // Signed Encrypted Supporting Tokens supportingTokenAssertion = CreateWsspSignedEncryptedSupportingTokensAssertion(exporter, signedEncrypted, optionalSignedEncrypted); if (supportingTokenAssertion != null) { supportingTokenAssertions.Add(supportingTokenAssertion); } // Endorsing Supporting Tokens. supportingTokenAssertion = CreateWsspEndorsingSupportingTokensAssertion(exporter, endorsing, optionalEndorsing, addressingVersion); if (supportingTokenAssertion != null) { supportingTokenAssertions.Add(supportingTokenAssertion); } // Signed Endorsing Supporting Tokens. supportingTokenAssertion = CreateWsspSignedEndorsingSupportingTokensAssertion(exporter, signedEndorsing, optionalSignedEndorsing, addressingVersion); if (supportingTokenAssertion != null) { supportingTokenAssertions.Add(supportingTokenAssertion); } return(supportingTokenAssertions); }
void IPolicyExportExtension.ExportPolicy(MetadataExporter exporter, PolicyConversionContext context) { if (context == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context"); } if (context.BindingElements != null) { UseManagedPresentationBindingElement settings = context.BindingElements.Find <UseManagedPresentationBindingElement>(); if (settings != null) { XmlDocument doc = new XmlDocument(); // UseUseManagedPresentation assertion XmlElement assertion = doc.CreateElement(UseManagedPresentationPolicyStrings.UseManagedPresentationPrefix, UseManagedPresentationPolicyStrings.RequireFederatedIdentityProvisioningName, UseManagedPresentationPolicyStrings.UseManagedPresentationNamespace); context.GetBindingAssertions().Add(assertion); } } }
public override XmlElement CreateWsspHttpsTokenAssertion(MetadataExporter exporter, HttpsTransportBindingElement httpsBinding) { XmlElement result = CreateWsspAssertion(HttpsTokenName); result.SetAttribute(RequireClientCertificateName, httpsBinding.RequireClientCertificate ? TrueName : FalseName); return(result); }
void IPolicyExportExtension.ExportPolicy(MetadataExporter exporter, PolicyConversionContext context) { bool flag; if (exporter == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("exporter"); } if (context == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context"); } ICollection <XmlElement> bindingAssertions = context.GetBindingAssertions(); if (TransferModeHelper.IsRequestStreamed(this.TransferMode) || TransferModeHelper.IsResponseStreamed(this.TransferMode)) { bindingAssertions.Add(new XmlDocument().CreateElement("msf", "Streamed", "http://schemas.microsoft.com/ws/2006/05/framing/policy")); } MessageEncodingBindingElement element = this.FindMessageEncodingBindingElement(context.BindingElements, out flag); if (flag && (element is IPolicyExportExtension)) { element = new BinaryMessageEncodingBindingElement(); ((IPolicyExportExtension)element).ExportPolicy(exporter, context); } WsdlExporter.WSAddressingHelper.AddWSAddressingAssertion(exporter, context, element.MessageVersion.Addressing); }
void IPolicyExportExtension.ExportPolicy(MetadataExporter exporter, PolicyConversionContext context) { if (exporter == null) { throw new ArgumentNullException("exporter"); } if (context == null) { throw new ArgumentNullException("context"); } ICollection <XmlElement> bindingAssertions = context.GetBindingAssertions(); XmlDocument xmlDocument = new XmlDocument(); bindingAssertions.Add(xmlDocument.CreateElement( SsbConstants.SsbNsPrefix, SsbConstants.SsbTransportAssertion, SsbConstants.SsbNs)); bool createdNew = false; MessageEncodingBindingElement encodingBindingElement = context.BindingElements.Find <MessageEncodingBindingElement>(); if (encodingBindingElement == null) { createdNew = true; encodingBindingElement = SsbConstants.DefaultMessageEncodingBindingElement; } if (createdNew && encodingBindingElement is IPolicyExportExtension) { ((IPolicyExportExtension)encodingBindingElement).ExportPolicy(exporter, context); } AddWSAddressingAssertion(context, encodingBindingElement.MessageVersion.Addressing); }
void IPolicyExportExtension.ExportPolicy(MetadataExporter exporter, PolicyConversionContext context) { if (exporter == null) { throw new ArgumentNullException("exporter"); } if (context == null) { throw new ArgumentNullException("context"); } PolicyAssertionCollection assertions = context.GetBindingAssertions(); XmlDocument doc = new XmlDocument(); var messageEncodingElement = ExportAddressingPolicy(context); if (messageEncodingElement == null) { assertions.Add(doc.CreateElement( "msb", "BinaryEncoding", "http://schemas.microsoft.com/ws/06/2004/mspolicy/netbinary1")); } if (transfer_mode == TransferMode.Streamed || transfer_mode == TransferMode.StreamedRequest || transfer_mode == TransferMode.StreamedResponse) { assertions.Add(doc.CreateElement("msf", "Streamed", "http://schemas.microsoft.com/ws/2006/05/framing/policy")); } }
static void Main(string[] args) { try { ParseArguments(args); SAMLConfiguration samlConfiguration = LoadSAMLConfiguration(); X509Certificate2 x509Certificate = null; if (!string.IsNullOrEmpty(certificateFileName)) { x509Certificate = LoadCertificate(); } EntityDescriptor entityDescriptor = MetadataExporter.Export(samlConfiguration, x509Certificate, partnerName); SaveMetadata(entityDescriptor); } catch (Exception exception) { Console.Error.WriteLine(exception.ToString()); if (exception is ArgumentException) { ShowUsage(); } } }
void IPolicyExportExtension.ExportPolicy(MetadataExporter exporter, PolicyConversionContext context) { if (context == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context"); } if (context.BindingElements != null) { OneWayBindingElement oneWay = context.BindingElements.Find <OneWayBindingElement>(); if (oneWay != null) { // base assertion XmlDocument doc = new XmlDocument(); XmlElement assertion = doc.CreateElement(OneWayPolicyConstants.Prefix, OneWayPolicyConstants.OneWay, OneWayPolicyConstants.Namespace); if (oneWay.PacketRoutable) { // add nested packet routable assertion XmlElement child = doc.CreateElement(OneWayPolicyConstants.Prefix, OneWayPolicyConstants.PacketRoutable, OneWayPolicyConstants.Namespace); assertion.AppendChild(child); } context.GetBindingAssertions().Add(assertion); } } }
void IPolicyExportExtension.ExportPolicy(MetadataExporter exporter, PolicyConversionContext context) { if (exporter == null) { throw new NullReferenceException("exporter"); } if (context == null) { throw new NullReferenceException("context"); } XmlElement mhscElement = xmlDocument.CreateElement(HttpCookiePolicyStrings.Prefix, HttpCookiePolicyStrings.HttpCookiePolicyElement, HttpCookiePolicyStrings.Namespace); if (exchangeTerminateMessage) { XmlAttribute attribute = xmlDocument.CreateAttribute( HttpCookiePolicyStrings.ExchangeTerminateAttribute); attribute.Value = "true"; mhscElement.Attributes.Append(attribute); } context.GetBindingAssertions().Add(mhscElement); }
/// <summary> /// Implement to include for exporting a custom policy assertion about bindings. /// </summary> /// <param name="exporter">The <see cref="T:System.ServiceModel.Description.MetadataExporter" /> that you can use to modify the exporting process.</param> /// <param name="context">The <see cref="T:System.ServiceModel.Description.PolicyConversionContext" /> that you can use to insert your custom policy assertion.</param> public void ExportPolicy(MetadataExporter exporter, PolicyConversionContext context) { if (exporter == null) { throw new ArgumentNullException("exporter"); } if (context == null) { throw new ArgumentNullException("context"); } bool createdNew = false; MessageEncodingBindingElement encodingBindingElement = context.BindingElements.Find <MessageEncodingBindingElement>(); if (encodingBindingElement == null) { createdNew = true; encodingBindingElement = new TextMessageEncodingBindingElement(); } if (createdNew && encodingBindingElement is IPolicyExportExtension) { ((IPolicyExportExtension)encodingBindingElement).ExportPolicy(exporter, context); } AddWSAddressingAssertion(context, encodingBindingElement.MessageVersion.Addressing); }
internal void OnExportPolicy(MetadataExporter exporter, PolicyConversionContext context) { string assertion = ""; switch (this.Mode) { case SecurityMode.None: assertion = PeerTransportPolicyConstants.PeerTransportSecurityModeNone; break; case SecurityMode.Transport: assertion = PeerTransportPolicyConstants.PeerTransportSecurityModeTransport; break; case SecurityMode.Message: assertion = PeerTransportPolicyConstants.PeerTransportSecurityModeMessage; break; case SecurityMode.TransportWithMessageCredential: assertion = PeerTransportPolicyConstants.PeerTransportSecurityModeTransportWithMessageCredential; break; default: Fx.Assert("Unsupported value for PeerSecuritySettings.Mode"); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException()); } XmlDocument doc = new XmlDocument(); XmlElement element = doc.CreateElement(PeerTransportPolicyConstants.PeerTransportPrefix, PeerTransportPolicyConstants.PeerTransportSecurityMode, TransportPolicyConstants.PeerTransportUri); element.InnerText = assertion; context.GetBindingAssertions().Add(element); transportSecurity.OnExportPolicy(exporter, context); }
//<snippet14> #region IPolicyExporter Members public void ExportPolicy(MetadataExporter exporter, PolicyConversionContext policyContext) { if (exporter == null) { throw new NullReferenceException("The MetadataExporter object passed to the ExporterBindingElement is null."); } if (policyContext == null) { throw new NullReferenceException("The PolicyConversionContext object passed to the ExporterBindingElement is null."); } XmlElement elem = doc.CreateElement(name1, ns1); elem.InnerText = "My custom text."; XmlAttribute att = doc.CreateAttribute("MyCustomAttribute", ns1); att.Value = "ExampleValue"; elem.Attributes.Append(att); XmlElement subElement = doc.CreateElement("MyCustomSubElement", ns1); subElement.InnerText = "Custom Subelement Text."; elem.AppendChild(subElement); policyContext.GetBindingAssertions().Add(elem); Console.WriteLine("The custom policy exporter was called."); }
private static EntityDescriptor ExportServiceProviderMetadata(SAMLConfiguration samlConfiguration) { Console.Write("X.509 signature certificate .CER file [None]: "); string fileName = Console.ReadLine(); X509Certificate2 signatureCertificate = LoadCertificate(fileName); Console.Write("X.509 encryption certificate .CER file [None]: "); fileName = Console.ReadLine(); X509Certificate2 encryptionCertificate = LoadCertificate(fileName); Console.Write("Assertion Consumer Service URL: "); string assertionConsumerServiceURL = Console.ReadLine(); if (string.IsNullOrEmpty(assertionConsumerServiceURL)) { throw new ArgumentException("An assertion consumer service URL must be specified."); } Console.Write("Single Logout Service URL [None]: "); string singleLogoutServiceURL = Console.ReadLine(); Console.Write("Partner Identity Provider Name [None]: "); string partnerName = Console.ReadLine(); return(MetadataExporter.Export(samlConfiguration, signatureCertificate, encryptionCertificate, assertionConsumerServiceURL, singleLogoutServiceURL, partnerName)); }
internal void OnExportPolicy(MetadataExporter exporter, PolicyConversionContext context) { string assertion = ""; switch (this.CredentialType) { case PeerTransportCredentialType.Password: assertion = PeerTransportPolicyConstants.PeerTransportCredentialTypePassword; break; case PeerTransportCredentialType.Certificate: assertion = PeerTransportPolicyConstants.PeerTransportCredentialTypeCertificate; break; default: Fx.Assert("Unsupported value for PeerTransportSecuritySettings.CredentialType"); throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException()); } XmlDocument doc = new XmlDocument(); XmlElement element = doc.CreateElement(PeerTransportPolicyConstants.PeerTransportPrefix, PeerTransportPolicyConstants.PeerTransportCredentialType, TransportPolicyConstants.PeerTransportUri); element.InnerText = assertion; context.GetBindingAssertions().Add(element); }
private XmlElement CreateWsspSignedEncryptedSupportingTokensAssertion(MetadataExporter exporter, Collection <SecurityTokenParameters> signedEncrypted, Collection <SecurityTokenParameters> optionalSignedEncrypted) { XmlElement result; if ((signedEncrypted == null || signedEncrypted.Count == 0) && (optionalSignedEncrypted == null || optionalSignedEncrypted.Count == 0)) { result = null; } else { XmlElement policy = CreateWspPolicyWrapper(exporter); if (signedEncrypted != null) { foreach (SecurityTokenParameters p in signedEncrypted) { policy.AppendChild(CreateTokenAssertion(exporter, p)); } } if (optionalSignedEncrypted != null) { foreach (SecurityTokenParameters p in optionalSignedEncrypted) { policy.AppendChild(CreateTokenAssertion(exporter, p, true)); } } result = CreateWsspAssertion(SignedEncryptedSupportingTokensName); result.AppendChild(policy); } return(result); }
void IPolicyExportExtension.ExportPolicy( MetadataExporter exporter, PolicyConversionContext context) { if (exporter == null) { throw new ArgumentNullException("exporter"); } if (context == null) { throw new ArgumentNullException("context"); } PolicyAssertionCollection assertions = context.GetBindingAssertions(); XmlDocument doc = new XmlDocument(); assertions.Add(doc.CreateElement("wsaw", "UsingAddressing", "http://www.w3.org/2006/05/addressing/wsdl")); switch (auth_scheme) { case AuthenticationSchemes.Basic: case AuthenticationSchemes.Digest: case AuthenticationSchemes.Negotiate: case AuthenticationSchemes.Ntlm: assertions.Add(doc.CreateElement("http", auth_scheme.ToString() + "Authentication", "http://schemas.microsoft.com/ws/06/2004/policy/http")); break; } }
internal void OnExportPolicy(MetadataExporter exporter, PolicyConversionContext context) { string str = ""; switch (this.Mode) { case SecurityMode.None: str = "PeerTransportSecurityModeNone"; break; case SecurityMode.Transport: str = "PeerTransportSecurityModeTransport"; break; case SecurityMode.Message: str = "PeerTransportSecurityModeMessage"; break; case SecurityMode.TransportWithMessageCredential: str = "PeerTransportSecurityModeTransportWithMessageCredential"; break; default: throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException()); } XmlElement item = new XmlDocument().CreateElement("pc", "PeerTransportSecurityMode", "http://schemas.microsoft.com/soap/peer"); item.InnerText = str; context.GetBindingAssertions().Add(item); this.transportSecurity.OnExportPolicy(exporter, context); }
void IPolicyExportExtension.ExportPolicy(MetadataExporter exporter, PolicyConversionContext context) { if (context == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context"); } }
void IPolicyExportExtension.ExportPolicy(MetadataExporter exporter, PolicyConversionContext context) { if (exporter == null) { throw new ArgumentNullException("exporter"); } if (context == null) { throw new ArgumentNullException("context"); } PolicyAssertionCollection assertions = context.GetBindingAssertions(); var doc = new System.Xml.XmlDocument(); ExportAddressingPolicy(context); switch (auth_scheme) { case AuthenticationSchemes.Basic: case AuthenticationSchemes.Digest: case AuthenticationSchemes.Negotiate: case AuthenticationSchemes.Ntlm: assertions.Add(doc.CreateElement("http", auth_scheme.ToString() + "Authentication", "http://schemas.microsoft.com/ws/06/2004/policy/http")); break; } var transportProvider = this as ITransportTokenAssertionProvider; if (transportProvider != null) { var token = transportProvider.GetTransportTokenAssertion(); assertions.Add(CreateTransportBinding(token)); } }
void IPolicyExportExtension.ExportPolicy(MetadataExporter exporter, PolicyConversionContext context) { if (context == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context"); } if (context.BindingElements != null) { PrivacyNoticeBindingElement settings = context.BindingElements.Find <PrivacyNoticeBindingElement>(); if (settings != null) { XmlDocument doc = new XmlDocument(); // PrivacyNotice assertion XmlElement assertion = doc.CreateElement(PrivacyNoticePolicyStrings.PrivacyNoticePrefix, PrivacyNoticePolicyStrings.PrivacyNoticeName, PrivacyNoticePolicyStrings.PrivacyNoticeNamespace); assertion.InnerText = settings.Url.ToString(); assertion.SetAttribute(PrivacyNoticePolicyStrings.PrivacyNoticeVersionAttributeName, PrivacyNoticePolicyStrings.PrivacyNoticeNamespace, XmlConvert.ToString(settings.Version)); context.GetBindingAssertions().Add(assertion); } } }
private XmlElement CreateWsspSignedEncryptedSupportingTokensAssertion(MetadataExporter exporter, Collection <SecurityTokenParameters> signedEncrypted, Collection <SecurityTokenParameters> optionalSignedEncrypted) { if (((signedEncrypted == null) || (signedEncrypted.Count == 0)) && ((optionalSignedEncrypted == null) || (optionalSignedEncrypted.Count == 0))) { return(null); } XmlElement newChild = this.CreateWspPolicyWrapper(exporter, new XmlElement[0]); if (signedEncrypted != null) { foreach (SecurityTokenParameters parameters in signedEncrypted) { newChild.AppendChild(this.CreateTokenAssertion(exporter, parameters)); } } if (optionalSignedEncrypted != null) { foreach (SecurityTokenParameters parameters2 in optionalSignedEncrypted) { newChild.AppendChild(this.CreateTokenAssertion(exporter, parameters2, true)); } } XmlElement element = this.CreateWsspAssertion("SignedEncryptedSupportingTokens"); element.AppendChild(newChild); return(element); }
void IPolicyExportExtension.ExportPolicy(MetadataExporter exporter, PolicyConversionContext context) { PolicyAssertionCollection assertions = context.GetBindingAssertions(); XmlDocument doc = new XmlDocument(); assertions.Add(doc.CreateElement("msb", "BinaryEncoding", "http://schemas.microsoft.com/ws/06/2004/mspolicy/netbinary1")); }
public override XmlElement CreateWsspSecureConversationTokenAssertion(MetadataExporter exporter, SecureConversationSecurityTokenParameters parameters) { XmlElement tokenAssertion = this.CreateWsspAssertion("SecureConversationToken"); this.SetIncludeTokenValue(tokenAssertion, parameters.InclusionMode); tokenAssertion.AppendChild(this.CreateWspPolicyWrapper(exporter, new XmlElement[] { this.CreateWsspRequireDerivedKeysAssertion(parameters.RequireDerivedKeys), this.CreateWsspMustNotSendCancelAssertion(parameters.RequireCancellation), this.CreateWsspBootstrapPolicyAssertion(exporter, parameters.BootstrapSecurityBindingElement), this.CreateWsspMustNotSendAmendAssertion(), (!parameters.RequireCancellation || !parameters.CanRenewSession) ? this.CreateWsspMustNotSendRenewAssertion() : null })); return(tokenAssertion); }
public override XmlElement CreateMsspSslContextTokenAssertion(MetadataExporter exporter, SslSecurityTokenParameters parameters) { XmlElement tokenAssertion = this.CreateMsspAssertion("SslContextToken"); this.SetIncludeTokenValue(tokenAssertion, parameters.InclusionMode); tokenAssertion.AppendChild(this.CreateWspPolicyWrapper(exporter, new XmlElement[] { this.CreateWsspRequireDerivedKeysAssertion(parameters.RequireDerivedKeys), this.CreateWsspMustNotSendCancelAssertion(false), this.CreateMsspRequireClientCertificateAssertion(parameters.RequireClientCertificate), this.CreateWsspMustNotSendAmendAssertion(), this.CreateWsspMustNotSendRenewAssertion() })); return(tokenAssertion); }