//------------------------------------------------------------ // Copyright (c) Microsoft Corporation. All rights reserved. //------------------------------------------------------------ namespace System.ServiceModel.Security { using System; using System.Collections; using System.Collections.Generic; using System.Diagnostics; using System.IdentityModel; using System.IdentityModel.Configuration; using System.IdentityModel.Diagnostics; using System.IdentityModel.Protocols.WSTrust; using System.IdentityModel.Selectors; using System.IdentityModel.Tokens; using System.IO; using System.Security.Claims; using System.ServiceModel; using System.ServiceModel.Activation; using System.ServiceModel.Channels; using System.ServiceModel.Description; using System.Threading; using System.Web.Services.Description; using System.Xml; using System.Xml.Schema; using DiagnosticUtility = System.IdentityModel.DiagnosticUtility; using Message = System.ServiceModel.Channels.Message; using RequestContext = System.ServiceModel.Channels.RequestContext; using RST = System.IdentityModel.Protocols.WSTrust.RequestSecurityToken; using RSTR = System.IdentityModel.Protocols.WSTrust.RequestSecurityTokenResponse; using SR = System.ServiceModel.SR; using STS = System.IdentityModel.SecurityTokenService; using Fx = System.Runtime.Fx; /// /// Definition of Trust Contract Implementation. Implements the following ServiceContract interfaces, /// 1. IWSTrustFeb2005SyncContract /// 2. IWSTrust13SyncContract /// 3. IWSTrustFeb2005AsyncContract /// 4. IWSTrust13AsyncContract /// [ServiceBehavior(Name = WSTrustServiceContractConstants.ServiceBehaviorName, Namespace = WSTrustServiceContractConstants.Namespace, InstanceContextMode = InstanceContextMode.Single, ConcurrencyMode = ConcurrencyMode.Multiple)] [AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)] public class WSTrustServiceContract : IWSTrustFeb2005SyncContract, IWSTrust13SyncContract, IWSTrustFeb2005AsyncContract, IWSTrust13AsyncContract, IWsdlExportExtension, IContractBehavior { const string soap11Namespace = "http://schemas.xmlsoap.org/soap/envelope/"; const string soap12Namespace = "http://www.w3.org/2003/05/soap-envelope"; SecurityTokenServiceConfiguration _securityTokenServiceConfiguration; event EventHandler _requestFailed; /// /// Initializes an instance of /// /// Configuration object that initializes this instance. public WSTrustServiceContract(SecurityTokenServiceConfiguration securityTokenServiceConfiguration) { if (securityTokenServiceConfiguration == null) { throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("securityTokenServiceConfiguration"); } _securityTokenServiceConfiguration = securityTokenServiceConfiguration; } /// /// Occurs when a Failure happens processing a Trust request from the /// client. /// public event EventHandler RequestFailed { add { _requestFailed += value; } remove { _requestFailed -= value; } } /// /// Returns the that resolves the following security tokens contained /// in the current WCF message request's security header: protection token, endorsing, or signed endorsing /// supporting tokens. /// /// /// This is used to resolve any SecurityTokenIdentifiers /// when deserializing RST UseKey elements or RST RenewTarget elements. /// /// is null. protected virtual SecurityTokenResolver GetSecurityHeaderTokenResolver(RequestContext requestContext) { if (requestContext == null) { throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("requestContext"); } List tokenList = new List(); if (requestContext.RequestMessage != null && requestContext.RequestMessage.Properties != null && requestContext.RequestMessage.Properties.Security != null) { // Add tokens in message SecurityMessageProperty msgProperty = requestContext.RequestMessage.Properties.Security; if (msgProperty.ProtectionToken != null) { tokenList.Add(msgProperty.ProtectionToken.SecurityToken); } if (msgProperty.HasIncomingSupportingTokens) { foreach (SupportingTokenSpecification tokenSpec in msgProperty.IncomingSupportingTokens) { if (tokenSpec != null && (tokenSpec.SecurityTokenAttachmentMode == SecurityTokenAttachmentMode.Endorsing || tokenSpec.SecurityTokenAttachmentMode == SecurityTokenAttachmentMode.SignedEndorsing)) { tokenList.Add(tokenSpec.SecurityToken); } } } if (msgProperty.InitiatorToken != null) { tokenList.Add(msgProperty.InitiatorToken.SecurityToken); } } if (tokenList.Count > 0) { return SecurityTokenResolver.CreateDefaultSecurityTokenResolver(tokenList.AsReadOnly(), true); } else { return EmptySecurityTokenResolver.Instance; } } /// /// Returns the that will be used when resolving tokens and keys in the /// Trust message body. /// /// A instance. /// protected virtual SecurityTokenResolver GetRstSecurityTokenResolver() { if (_securityTokenServiceConfiguration != null) { SecurityTokenResolver tokenResolver = _securityTokenServiceConfiguration.SecurityTokenHandlers.Configuration.ServiceTokenResolver; if (tokenResolver != null && (!Object.ReferenceEquals(tokenResolver, EmptySecurityTokenResolver.Instance))) { return tokenResolver; } } if (OperationContext.Current != null && OperationContext.Current.Host != null && OperationContext.Current.Host.Description != null) { ServiceCredentials serviceCreds = OperationContext.Current.Host.Description.Behaviors.Find(); if (serviceCreds != null && serviceCreds.ServiceCertificate != null && serviceCreds.ServiceCertificate.Certificate != null) { List serviceTokens = new List(1); serviceTokens.Add(new X509SecurityToken(serviceCreds.ServiceCertificate.Certificate)); return SecurityTokenResolver.CreateDefaultSecurityTokenResolver(serviceTokens.AsReadOnly(), false); } } return EmptySecurityTokenResolver.Instance; } /// /// Creates a WSTrustSerializationContext using the local resolver information /// of the WSTrustServiceClient. /// /// A WSTrustSerializationContext initialized with the current resolver information. protected virtual WSTrustSerializationContext CreateSerializationContext() { return new WSTrustSerializationContext(_securityTokenServiceConfiguration.SecurityTokenHandlerCollectionManager, this.GetRstSecurityTokenResolver(), this.GetSecurityHeaderTokenResolver(OperationContext.Current.RequestContext) ); } /// /// Begins an asynchronous call to . /// /// Defines the request parameters to process and exposes properties /// that determine the response message and action. /// An optional asynchronous callback, to be called when the /// dispatch is complete. /// A user-provided object that distinguishes this particular asynchronous /// dispatch request from other requests. /// that represents the asynchronous operation. Used as the input /// to . protected virtual IAsyncResult BeginDispatchRequest(DispatchContext dispatchContext, AsyncCallback asyncCallback, object asyncState) { return new DispatchRequestAsyncResult(dispatchContext, asyncCallback, asyncState); } /// /// Completes an asynchronous call to . /// /// that was returned by the /// call to . /// The that exposes properties which determine the response /// message and action. protected virtual DispatchContext EndDispatchRequest(IAsyncResult ar) { return DispatchRequestAsyncResult.End(ar); } /// /// Processes a WS-Trust request message, and optionally determines the appropriate /// response message and the WS-Addressing action for the response message. /// /// Defines the request parameters to process and exposes properties /// that determine the response message and action. protected virtual void DispatchRequest(DispatchContext dispatchContext) { RST rst = dispatchContext.RequestMessage as RST; STS sts = dispatchContext.SecurityTokenService; ClaimsPrincipal icp = dispatchContext.Principal; if (rst != null) { switch (rst.RequestType) { case RequestTypes.Cancel: dispatchContext.ResponseMessage = sts.Cancel(icp, rst); break; case RequestTypes.Issue: dispatchContext.ResponseMessage = sts.Issue(icp, rst); break; case RequestTypes.Renew: dispatchContext.ResponseMessage = sts.Renew(icp, rst); break; case RequestTypes.Validate: dispatchContext.ResponseMessage = sts.Validate(icp, rst); break; default: throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ID3112, rst.RequestType))); } } else { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidRequestException(SR.GetString(SR.ID3022))); } } /// /// Handles Synchronous calls to the STS. /// /// Incoming Request message. /// Trust Request Serializer. /// Trust Response Serializer. /// Request SOAP action. /// Response SOAP action. /// Namespace URI of the trust version of the incoming request. /// Response message that contains the serialized RSTR. /// One of the argument is null. protected virtual Message ProcessCore(Message requestMessage, WSTrustRequestSerializer requestSerializer, WSTrustResponseSerializer responseSerializer, string requestAction, string responseAction, string trustNamespace) { if (requestMessage == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("requestMessage"); } if (requestSerializer == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("requestSerializer"); } if (responseSerializer == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("responseSerializer"); } if (String.IsNullOrEmpty(requestAction)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("requestAction"); } if (String.IsNullOrEmpty(responseAction)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("responseAction"); } if (String.IsNullOrEmpty(trustNamespace)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("trustNamespace"); } Message response = null; try { Fx.Assert(OperationContext.Current != null, ""); Fx.Assert(OperationContext.Current.RequestContext != null, ""); // // Create the Serialization and Dispatch context objects. // WSTrustSerializationContext serializationContext = CreateSerializationContext(); DispatchContext dispatchContext = CreateDispatchContext(requestMessage, requestAction, responseAction, trustNamespace, requestSerializer, responseSerializer, serializationContext); // // Validate the dispatch context. // ValidateDispatchContext(dispatchContext); // // Dispatch the STS message. // DispatchRequest(dispatchContext); // // Create the response Message object with the appropriate action. // response = Message.CreateMessage(OperationContext.Current.RequestContext.RequestMessage.Version, dispatchContext.ResponseAction, new WSTrustResponseBodyWriter(dispatchContext.ResponseMessage, responseSerializer, serializationContext)); } catch (Exception ex) { if (!HandleException(ex, trustNamespace, requestAction, requestMessage.Version.Envelope)) { throw; } } return response; } /// /// Creates a object for use by the method. /// /// The incoming request message. /// The SOAP action of the request. /// The default SOAP action of the response. /// Namespace URI of the trust version of the incoming request. /// The used to deserialize /// incoming RST messages. /// The used to deserialize /// incoming RSTR messages. /// The to use /// when deserializing incoming messages. /// A object. protected virtual DispatchContext CreateDispatchContext(Message requestMessage, string requestAction, string responseAction, string trustNamespace, WSTrustRequestSerializer requestSerializer, WSTrustResponseSerializer responseSerializer, WSTrustSerializationContext serializationContext) { DispatchContext dispatchContext = new DispatchContext() { Principal = OperationContext.Current.ClaimsPrincipal as ClaimsPrincipal, RequestAction = requestAction, ResponseAction = responseAction, TrustNamespace = trustNamespace }; XmlReader requestBodyReader = requestMessage.GetReaderAtBodyContents(); // // Take a peek at the request with the serializers to figure out if this is a standard incoming // RST or if this is an instance of a challenge-response style message pattern where an RSTR comes in. // if (requestSerializer.CanRead(requestBodyReader)) { dispatchContext.RequestMessage = requestSerializer.ReadXml(requestBodyReader, serializationContext); } else if (responseSerializer.CanRead(requestBodyReader)) { dispatchContext.RequestMessage = responseSerializer.ReadXml(requestBodyReader, serializationContext); } else { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new InvalidRequestException(SR.GetString(SR.ID3114))); } // // CAUTION: Don't create the STS until after the RST or RSTR is deserialized or the test team // has major infrastructure problems. // dispatchContext.SecurityTokenService = CreateSTS(); return dispatchContext; } /// /// Validates the DispatchContext. /// /// The to validate. /// /// This routine ensures that the represents a legal request /// prior to being passed into . This routine's default implementation /// is to reject incoming RST messages with RSTR actions and vice versa. /// protected virtual void ValidateDispatchContext(DispatchContext dispatchContext) { if (dispatchContext.RequestMessage is RST && !IsValidRSTAction(dispatchContext)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new InvalidRequestException( SR.GetString(SR.ID3113, "RequestSecurityToken", dispatchContext.RequestAction))); } if (dispatchContext.RequestMessage is RSTR && !IsValidRSTRAction(dispatchContext)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError( new InvalidRequestException( SR.GetString(SR.ID3113, "RequestSecurityTokenResponse", dispatchContext.RequestAction))); } } /// /// Determines if the DispatchContext contains a valid request action for incoming RST messages. /// private static bool IsValidRSTAction(DispatchContext dispatchContext) { bool valid = false; string action = dispatchContext.RequestAction; if (dispatchContext.TrustNamespace == WSTrust13Constants.NamespaceURI) { switch (action) { case WSTrust13Constants.Actions.Cancel: case WSTrust13Constants.Actions.Issue: case WSTrust13Constants.Actions.Renew: case WSTrust13Constants.Actions.Validate: valid = true; break; } } if (dispatchContext.TrustNamespace == WSTrustFeb2005Constants.NamespaceURI) { switch (action) { case WSTrustFeb2005Constants.Actions.Cancel: case WSTrustFeb2005Constants.Actions.Issue: case WSTrustFeb2005Constants.Actions.Renew: case WSTrustFeb2005Constants.Actions.Validate: valid = true; break; } } return valid; } /// /// Determines if the DispatchContext contains a valid request action for incoming RSTR messages. /// private static bool IsValidRSTRAction(DispatchContext dispatchContext) { bool valid = false; string action = dispatchContext.RequestAction; if (dispatchContext.TrustNamespace == WSTrust13Constants.NamespaceURI) { switch (action) { case WSTrust13Constants.Actions.CancelFinalResponse: case WSTrust13Constants.Actions.CancelResponse: case WSTrust13Constants.Actions.IssueFinalResponse: case WSTrust13Constants.Actions.IssueResponse: case WSTrust13Constants.Actions.RenewFinalResponse: case WSTrust13Constants.Actions.RenewResponse: case WSTrust13Constants.Actions.ValidateFinalResponse: case WSTrust13Constants.Actions.ValidateResponse: valid = true; break; } } if (dispatchContext.TrustNamespace == WSTrustFeb2005Constants.NamespaceURI) { switch (action) { case WSTrustFeb2005Constants.Actions.CancelResponse: case WSTrustFeb2005Constants.Actions.IssueResponse: case WSTrustFeb2005Constants.Actions.RenewResponse: case WSTrustFeb2005Constants.Actions.ValidateResponse: valid = true; break; } } return valid; } private STS CreateSTS() { STS sts = _securityTokenServiceConfiguration.CreateSecurityTokenService(); if (sts == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ID3002))); } return sts; } /// /// Handles Asynchronous call to the STS. /// /// Incoming Request message. /// Trust Request Serializer. /// Trust Response Serializer. /// Request SOAP action. /// Response SOAP action. /// Namespace URI of the trust version of the incoming request. /// Callback that gets invoked when the Asynchronous call ends. /// state information of the Asynchronous call. /// IAsyncResult that should be passed back to the End method to complete the Asynchronous call. /// One of the argument is null. protected virtual IAsyncResult BeginProcessCore(Message requestMessage, WSTrustRequestSerializer requestSerializer, WSTrustResponseSerializer responseSerializer, string requestAction, string responseAction, string trustNamespace, AsyncCallback callback, object state) { if (requestMessage == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("request"); } if (requestSerializer == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("requestSerializer"); } if (responseSerializer == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("responseSerializer"); } if (String.IsNullOrEmpty(requestAction)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("requestAction"); } if (String.IsNullOrEmpty(responseAction)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("responseAction"); } if (String.IsNullOrEmpty(trustNamespace)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("trustNamespace"); } IAsyncResult result = null; try { Fx.Assert(OperationContext.Current != null, ""); Fx.Assert(OperationContext.Current.RequestContext != null, ""); // // Create the Serialization and Dispatch context objects. // WSTrustSerializationContext serializationContext = CreateSerializationContext(); DispatchContext dispatchContext = CreateDispatchContext(requestMessage, requestAction, responseAction, trustNamespace, requestSerializer, responseSerializer, serializationContext); // // Validate the dispatch context. // ValidateDispatchContext(dispatchContext); // // Dispatch the message asynchronously. // result = new ProcessCoreAsyncResult(this, dispatchContext, OperationContext.Current.RequestContext.RequestMessage.Version, responseSerializer, serializationContext, callback, state); } catch (Exception ex) { if (!HandleException(ex, trustNamespace, requestAction, requestMessage.Version.Envelope)) { throw; } } return result; } /// /// Completes an Asynchronous call to the STS. /// /// IAsyncResult that was returned by the call to the Asynchronous Begin method. /// Request SOAP Action. /// Response SOAP Action. /// Namespace URI of the current trust version. /// Message that contains the serialized RST message. /// One of the argument is null. protected virtual Message EndProcessCore(IAsyncResult ar, string requestAction, string responseAction, string trustNamespace) { if (ar == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("ar"); } ProcessCoreAsyncResult asyncResult = ar as ProcessCoreAsyncResult; if (asyncResult == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.ID2004, typeof(ProcessCoreAsyncResult), ar.GetType()), "ar")); } Message message = null; try { message = ProcessCoreAsyncResult.End(ar); } catch (Exception ex) { if (!HandleException(ex, trustNamespace, requestAction, asyncResult.MessageVersion.Envelope)) { throw; } } return message; } /// /// Raises the Error Event and converts the given exception to a FaultException if required. If the original /// exception was a FaultException or PreserveOriginalException flag is set to true then the conversion to /// FaultException is not done. /// /// The original exception. /// Trust Namespace of the current trust version. /// The Trust action that caused the exception. /// Version of the request envolope. protected virtual bool HandleException(Exception ex, string trustNamespace, string action, EnvelopeVersion requestEnvelopeVersion) { if (System.Runtime.Fx.IsFatal(ex)) { return false; } if (DiagnosticUtility.ShouldTrace(TraceEventType.Warning)) { TraceUtility.TraceString( TraceEventType.Warning, "RequestFailed: TrustNamespace={0}, Action={1}, Exception={2}", trustNamespace, action, ex); } // raise the exception events. if (_requestFailed != null) { _requestFailed(this, new WSTrustRequestProcessingErrorEventArgs(action, ex)); } bool preserveOriginalException = false; ServiceDebugBehavior debugBehavior = OperationContext.Current.Host.Description.Behaviors.Find(); if (debugBehavior != null) { preserveOriginalException = debugBehavior.IncludeExceptionDetailInFaults; } if (String.IsNullOrEmpty(trustNamespace) || String.IsNullOrEmpty(action) || preserveOriginalException || ex is FaultException) { // Just throw the original exception. return false; } else { FaultException faultException = OperationContext.Current.Host.Credentials.ExceptionMapper.FromException(ex, (requestEnvelopeVersion == EnvelopeVersion.Soap11) ? soap11Namespace : soap12Namespace, trustNamespace); if (faultException != null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(faultException); } // The exception is not one of the recognized exceptions. Just throw the original exception. return false; } } #region IWSTrustFeb2005SyncContract and IWSTrust13SyncContract Methods /// /// Processes a Trust 1.3 Cancel message synchronously. /// /// Incoming Request message. /// Message with the serialized response. public Message ProcessTrust13Cancel(Message message) { return ProcessCore(message, _securityTokenServiceConfiguration.WSTrust13RequestSerializer, _securityTokenServiceConfiguration.WSTrust13ResponseSerializer, WSTrust13Constants.Actions.Cancel, WSTrust13Constants.Actions.CancelFinalResponse, WSTrust13Constants.NamespaceURI); } /// /// Processes a Trust 1.3 Issue message synchronously. /// /// Incoming Request message. /// Message with the serialized response. public Message ProcessTrust13Issue(Message message) { return ProcessCore(message, _securityTokenServiceConfiguration.WSTrust13RequestSerializer, _securityTokenServiceConfiguration.WSTrust13ResponseSerializer, WSTrust13Constants.Actions.Issue, WSTrust13Constants.Actions.IssueFinalResponse, WSTrust13Constants.NamespaceURI); } /// /// Processes a Trust 1.3 Renew message synchronously. /// /// Incoming Request message. /// Message with the serialized response. public Message ProcessTrust13Renew(Message message) { return ProcessCore(message, _securityTokenServiceConfiguration.WSTrust13RequestSerializer, _securityTokenServiceConfiguration.WSTrust13ResponseSerializer, WSTrust13Constants.Actions.Renew, WSTrust13Constants.Actions.RenewFinalResponse, WSTrust13Constants.NamespaceURI); } /// /// Processes a Trust 1.3 Validate message synchronously. /// /// Incoming Request message. /// Message with the serialized response. public Message ProcessTrust13Validate(Message message) { return ProcessCore(message, _securityTokenServiceConfiguration.WSTrust13RequestSerializer, _securityTokenServiceConfiguration.WSTrust13ResponseSerializer, WSTrust13Constants.Actions.Validate, WSTrust13Constants.Actions.ValidateFinalResponse, WSTrust13Constants.NamespaceURI); } /// /// Processes a Trust 1.3 RSTR/Cancel message synchronously. /// /// Incoming Request message. /// Message with the serialized response. public Message ProcessTrust13CancelResponse(Message message) { return ProcessCore(message, _securityTokenServiceConfiguration.WSTrust13RequestSerializer, _securityTokenServiceConfiguration.WSTrust13ResponseSerializer, WSTrust13Constants.Actions.CancelResponse, WSTrust13Constants.Actions.CancelFinalResponse, WSTrust13Constants.NamespaceURI); } /// /// Processes a Trust 1.3 RSTR/Issue message synchronously. /// /// Incoming Request message. /// Message with the serialized response. public Message ProcessTrust13IssueResponse(Message message) { return ProcessCore(message, _securityTokenServiceConfiguration.WSTrust13RequestSerializer, _securityTokenServiceConfiguration.WSTrust13ResponseSerializer, WSTrust13Constants.Actions.IssueResponse, WSTrust13Constants.Actions.IssueFinalResponse, WSTrust13Constants.NamespaceURI); } /// /// Processes a Trust 1.3 RSTR/Renew message synchronously. /// /// Incoming Request message. /// Message with the serialized response. public Message ProcessTrust13RenewResponse(Message message) { return ProcessCore(message, _securityTokenServiceConfiguration.WSTrust13RequestSerializer, _securityTokenServiceConfiguration.WSTrust13ResponseSerializer, WSTrust13Constants.Actions.RenewResponse, WSTrust13Constants.Actions.RenewFinalResponse, WSTrust13Constants.NamespaceURI); } /// /// Processes a Trust 1.3 RSTR/Validate message synchronously. /// /// Incoming Request message. /// Message with the serialized response. public Message ProcessTrust13ValidateResponse(Message message) { return ProcessCore(message, _securityTokenServiceConfiguration.WSTrust13RequestSerializer, _securityTokenServiceConfiguration.WSTrust13ResponseSerializer, WSTrust13Constants.Actions.ValidateResponse, WSTrust13Constants.Actions.ValidateFinalResponse, WSTrust13Constants.NamespaceURI); } /// /// Processes a Trust Feb 2005 Cancel message synchronously. /// /// Incoming Request message. /// Message with the serialized response. public Message ProcessTrustFeb2005Cancel(Message message) { return ProcessCore(message, _securityTokenServiceConfiguration.WSTrustFeb2005RequestSerializer, _securityTokenServiceConfiguration.WSTrustFeb2005ResponseSerializer, WSTrustFeb2005Constants.Actions.Cancel, WSTrustFeb2005Constants.Actions.CancelResponse, WSTrustFeb2005Constants.NamespaceURI); } /// /// Processes a Trust Feb 2005 Issue message synchronously. /// /// Incoming Request message. /// Message with the serialized response. public Message ProcessTrustFeb2005Issue(Message message) { return ProcessCore(message, _securityTokenServiceConfiguration.WSTrustFeb2005RequestSerializer, _securityTokenServiceConfiguration.WSTrustFeb2005ResponseSerializer, WSTrustFeb2005Constants.Actions.Issue, WSTrustFeb2005Constants.Actions.IssueResponse, WSTrustFeb2005Constants.NamespaceURI); } /// /// Processes a Trust Feb 2005 Renew message synchronously. /// /// Incoming Request message. /// Message with the serialized response. public Message ProcessTrustFeb2005Renew(Message message) { return ProcessCore(message, _securityTokenServiceConfiguration.WSTrustFeb2005RequestSerializer, _securityTokenServiceConfiguration.WSTrustFeb2005ResponseSerializer, WSTrustFeb2005Constants.Actions.Renew, WSTrustFeb2005Constants.Actions.RenewResponse, WSTrustFeb2005Constants.NamespaceURI); } /// /// Processes a Trust Feb 2005 Validate message synchronously. /// /// Incoming Request message. /// Message with the serialized response. public Message ProcessTrustFeb2005Validate(Message message) { return ProcessCore(message, _securityTokenServiceConfiguration.WSTrustFeb2005RequestSerializer, _securityTokenServiceConfiguration.WSTrustFeb2005ResponseSerializer, WSTrustFeb2005Constants.Actions.Validate, WSTrustFeb2005Constants.Actions.ValidateResponse, WSTrustFeb2005Constants.NamespaceURI); } /// /// Processes a Trust Feb 2005 RSTR/Cancel message synchronously. /// /// Incoming Request message. /// Message with the serialized response. public Message ProcessTrustFeb2005CancelResponse(Message message) { return ProcessCore(message, _securityTokenServiceConfiguration.WSTrustFeb2005RequestSerializer, _securityTokenServiceConfiguration.WSTrustFeb2005ResponseSerializer, WSTrustFeb2005Constants.Actions.CancelResponse, WSTrustFeb2005Constants.Actions.CancelResponse, WSTrustFeb2005Constants.NamespaceURI); } /// /// Processes a Trust Feb 2005 RSTR/Issue message synchronously. /// /// Incoming Request message. /// Message with the serialized response. public Message ProcessTrustFeb2005IssueResponse(Message message) { return ProcessCore(message, _securityTokenServiceConfiguration.WSTrustFeb2005RequestSerializer, _securityTokenServiceConfiguration.WSTrustFeb2005ResponseSerializer, WSTrustFeb2005Constants.Actions.IssueResponse, WSTrustFeb2005Constants.Actions.IssueResponse, WSTrustFeb2005Constants.NamespaceURI); } /// /// Processes a Trust Feb 2005 RSTR/Renew message synchronously. /// /// Incoming Request message. /// Message with the serialized response. public Message ProcessTrustFeb2005RenewResponse(Message message) { return ProcessCore(message, _securityTokenServiceConfiguration.WSTrustFeb2005RequestSerializer, _securityTokenServiceConfiguration.WSTrustFeb2005ResponseSerializer, WSTrustFeb2005Constants.Actions.RenewResponse, WSTrustFeb2005Constants.Actions.RenewResponse, WSTrustFeb2005Constants.NamespaceURI); } /// /// Processes a Trust Feb 2005 RSTR/Validate message synchronously. /// /// Incoming Request message. /// Message with the serialized response. public Message ProcessTrustFeb2005ValidateResponse(Message message) { return ProcessCore(message, _securityTokenServiceConfiguration.WSTrustFeb2005RequestSerializer, _securityTokenServiceConfiguration.WSTrustFeb2005ResponseSerializer, WSTrustFeb2005Constants.Actions.ValidateResponse, WSTrustFeb2005Constants.Actions.ValidateResponse, WSTrustFeb2005Constants.NamespaceURI); } /// /// Gets the SecurityTokenServiceConfiguration /// public SecurityTokenServiceConfiguration SecurityTokenServiceConfiguration { get { return _securityTokenServiceConfiguration; } } #endregion #region IWSTrustFeb2005AsyncContract and IWSTrust13AsyncContract Methods /// /// Processes an Asynchronous call to Trust Feb 1.3 Cancel message. /// /// Incoming Request message. /// Callback to be invoked when the Asynchronous operation ends. /// Asynchronous state. /// IAsyncResult that should be passed back to the End method to complete the Asynchronous call. public IAsyncResult BeginTrust13Cancel(Message request, AsyncCallback callback, object state) { return BeginProcessCore(request, _securityTokenServiceConfiguration.WSTrust13RequestSerializer, _securityTokenServiceConfiguration.WSTrust13ResponseSerializer, WSTrust13Constants.Actions.Cancel, WSTrust13Constants.Actions.CancelFinalResponse, WSTrust13Constants.NamespaceURI, callback, state); } /// /// Completes an Asynchronous call to Trust 1.3 Cancel message. /// /// IAsyncResult object returned by the Begin method that started the Asynchronous call. /// Message containing the Serialized RSTR. public Message EndTrust13Cancel(IAsyncResult ar) { return EndProcessCore(ar, WSTrust13Constants.Actions.Cancel, WSTrust13Constants.Actions.CancelFinalResponse, WSTrust13Constants.NamespaceURI); } /// /// Processes an Asynchronous call to Trust 1.3 Issue message. /// /// Incoming Request message. /// Callback to be invoked when the Asynchronous operation ends. /// Asynchronous state. /// IAsyncResult that should be passed back to the End method to complete the Asynchronous call. public IAsyncResult BeginTrust13Issue(Message request, AsyncCallback callback, object state) { return BeginProcessCore(request, _securityTokenServiceConfiguration.WSTrust13RequestSerializer, _securityTokenServiceConfiguration.WSTrust13ResponseSerializer, WSTrust13Constants.Actions.Issue, WSTrust13Constants.Actions.IssueFinalResponse, WSTrust13Constants.NamespaceURI, callback, state); } /// /// Completes an Asynchronous call to Trust 1.3 Issue message. /// /// IAsyncResult object returned by the Begin method that started the Asynchronous call. /// Message containing the Serialized RSTR. public Message EndTrust13Issue(IAsyncResult ar) { return EndProcessCore(ar, WSTrust13Constants.Actions.Issue, WSTrust13Constants.Actions.IssueFinalResponse, WSTrust13Constants.NamespaceURI); } /// /// Processes an Asynchronous call to Trust 1.3 Renew message. /// /// Incoming Request message. /// Callback to be invoked when the Asynchronous operation ends. /// Asynchronous state. /// IAsyncResult that should be passed back to the End method to complete the Asynchronous call. public IAsyncResult BeginTrust13Renew(Message request, AsyncCallback callback, object state) { return BeginProcessCore(request, _securityTokenServiceConfiguration.WSTrust13RequestSerializer, _securityTokenServiceConfiguration.WSTrust13ResponseSerializer, WSTrust13Constants.Actions.Renew, WSTrust13Constants.Actions.RenewFinalResponse, WSTrust13Constants.NamespaceURI, callback, state); } /// /// Completes an Asynchronous call to Trust 1.3 Renew message. /// /// IAsyncResult object returned by the Begin method that started the Asynchronous call. /// Message containing the Serialized RSTR. public Message EndTrust13Renew(IAsyncResult ar) { return EndProcessCore(ar, WSTrust13Constants.Actions.Renew, WSTrust13Constants.Actions.RenewFinalResponse, WSTrust13Constants.NamespaceURI); } /// /// Processes an Asynchronous call to Trust 1.3 Validate message. /// /// Incoming Request message. /// Callback to be invoked when the Asynchronous operation ends. /// Asynchronous state. /// IAsyncResult that should be passed back to the End method to complete the Asynchronous call. public IAsyncResult BeginTrust13Validate(Message request, AsyncCallback callback, object state) { return BeginProcessCore(request, _securityTokenServiceConfiguration.WSTrust13RequestSerializer, _securityTokenServiceConfiguration.WSTrust13ResponseSerializer, WSTrust13Constants.Actions.Validate, WSTrust13Constants.Actions.ValidateFinalResponse, WSTrust13Constants.NamespaceURI, callback, state); } /// /// Completes an Asynchronous call to Trust 1.3 Validate message. /// /// IAsyncResult object returned by the Begin method that started the Asynchronous call. /// Message containing the Serialized RSTR. public Message EndTrust13Validate(IAsyncResult ar) { return EndProcessCore(ar, WSTrust13Constants.Actions.Validate, WSTrust13Constants.Actions.ValidateFinalResponse, WSTrust13Constants.NamespaceURI); } /// /// Processes an Asynchronous call to Trust 1.3 RSTR/Cancel message. /// /// Incoming Request message. /// Callback to be invoked when the Asynchronous operation ends. /// Asynchronous state. /// IAsyncResult that should be passed back to the End method to complete the Asynchronous call. public IAsyncResult BeginTrust13CancelResponse(Message request, AsyncCallback callback, object state) { return BeginProcessCore(request, _securityTokenServiceConfiguration.WSTrust13RequestSerializer, _securityTokenServiceConfiguration.WSTrust13ResponseSerializer, WSTrust13Constants.Actions.CancelResponse, WSTrust13Constants.Actions.CancelFinalResponse, WSTrust13Constants.NamespaceURI, callback, state); } /// /// Completes an Asynchronous call to Trust 1.3 RSTR/Cancel message. /// /// IAsyncResult object returned by the Begin method that started the Asynchronous call. /// Message containing the Serialized RSTR. public Message EndTrust13CancelResponse(IAsyncResult ar) { return EndProcessCore(ar, WSTrust13Constants.Actions.CancelResponse, WSTrust13Constants.Actions.CancelFinalResponse, WSTrust13Constants.NamespaceURI); } /// /// Processes an Asynchronous call to Trust 1.3 RSTR/Issue message. /// /// Incoming Request message. /// Callback to be invoked when the Asynchronous operation ends. /// Asynchronous state. /// IAsyncResult that should be passed back to the End method to complete the Asynchronous call. public IAsyncResult BeginTrust13IssueResponse(Message request, AsyncCallback callback, object state) { return BeginProcessCore(request, _securityTokenServiceConfiguration.WSTrust13RequestSerializer, _securityTokenServiceConfiguration.WSTrust13ResponseSerializer, WSTrust13Constants.Actions.IssueResponse, WSTrust13Constants.Actions.IssueFinalResponse, WSTrust13Constants.NamespaceURI, callback, state); } /// /// Completes an Asynchronous call to Trust 1.3 RSTR/Issue message. /// /// IAsyncResult object returned by the Begin method that started the Asynchronous call. /// Message containing the Serialized RSTR. public Message EndTrust13IssueResponse(IAsyncResult ar) { return EndProcessCore(ar, WSTrust13Constants.Actions.IssueResponse, WSTrust13Constants.Actions.IssueFinalResponse, WSTrust13Constants.NamespaceURI); } /// /// Processes an Asynchronous call to Trust 1.3 RSTR/Renew message. /// /// Incoming Request message. /// Callback to be invoked when the Asynchronous operation ends. /// Asynchronous state. /// IAsyncResult that should be passed back to the End method to complete the Asynchronous call. public IAsyncResult BeginTrust13RenewResponse(Message request, AsyncCallback callback, object state) { return BeginProcessCore(request, _securityTokenServiceConfiguration.WSTrust13RequestSerializer, _securityTokenServiceConfiguration.WSTrust13ResponseSerializer, WSTrust13Constants.Actions.RenewResponse, WSTrust13Constants.Actions.RenewFinalResponse, WSTrust13Constants.NamespaceURI, callback, state); } /// /// Completes an Asynchronous call to Trust 1.3 RSTR/Renew message. /// /// IAsyncResult object returned by the Begin method that started the Asynchronous call. /// Message containing the Serialized RSTR. public Message EndTrust13RenewResponse(IAsyncResult ar) { return EndProcessCore(ar, WSTrust13Constants.Actions.RenewResponse, WSTrust13Constants.Actions.RenewFinalResponse, WSTrust13Constants.NamespaceURI); } /// /// Processes an Asynchronous call to Trust 1.3 RSTR/Validate message. /// /// Incoming Request message. /// Callback to be invoked when the Asynchronous operation ends. /// Asynchronous state. /// IAsyncResult that should be passed back to the End method to complete the Asynchronous call. public IAsyncResult BeginTrust13ValidateResponse(Message request, AsyncCallback callback, object state) { return BeginProcessCore(request, _securityTokenServiceConfiguration.WSTrust13RequestSerializer, _securityTokenServiceConfiguration.WSTrust13ResponseSerializer, WSTrust13Constants.Actions.ValidateResponse, WSTrust13Constants.Actions.ValidateFinalResponse, WSTrust13Constants.NamespaceURI, callback, state); } /// /// Completes an Asynchronous call to Trust 1.3 RSTR/Validate message. /// /// IAsyncResult object returned by the Begin method that started the Asynchronous call. /// Message containing the Serialized RSTR. public Message EndTrust13ValidateResponse(IAsyncResult ar) { return EndProcessCore(ar, WSTrust13Constants.Actions.ValidateResponse, WSTrust13Constants.Actions.ValidateFinalResponse, WSTrust13Constants.NamespaceURI); } /// /// Processes an Asynchronous call to Trust 2005 Cancel message. /// /// Incoming Request message. /// Callback to be invoked when the Asynchronous operation ends. /// Asynchronous state. /// IAsyncResult that should be passed back to the End method to complete the Asynchronous call. public IAsyncResult BeginTrustFeb2005Cancel(Message request, AsyncCallback callback, object state) { return BeginProcessCore(request, _securityTokenServiceConfiguration.WSTrustFeb2005RequestSerializer, _securityTokenServiceConfiguration.WSTrustFeb2005ResponseSerializer, WSTrustFeb2005Constants.Actions.Cancel, WSTrustFeb2005Constants.Actions.CancelResponse, WSTrustFeb2005Constants.NamespaceURI, callback, state); } /// /// Completes an Asynchronous call to Trust Feb 2005 Cancel message. /// /// IAsyncResult object returned by the Begin method that started the Asynchronous call. /// Message containing the Serialized RSTR. public Message EndTrustFeb2005Cancel(IAsyncResult ar) { return EndProcessCore(ar, WSTrustFeb2005Constants.Actions.Cancel, WSTrustFeb2005Constants.Actions.CancelResponse, WSTrustFeb2005Constants.NamespaceURI); } /// /// Processes an Asynchronous call to Trust Feb 2005 Issue message. /// /// Incoming Request message. /// Callback to be invoked when the Asynchronous operation ends. /// Asynchronous state. /// IAsyncResult that should be passed back to the End method to complete the Asynchronous call. public IAsyncResult BeginTrustFeb2005Issue(Message request, AsyncCallback callback, object state) { return BeginProcessCore(request, _securityTokenServiceConfiguration.WSTrustFeb2005RequestSerializer, _securityTokenServiceConfiguration.WSTrustFeb2005ResponseSerializer, WSTrustFeb2005Constants.Actions.Issue, WSTrustFeb2005Constants.Actions.IssueResponse, WSTrustFeb2005Constants.NamespaceURI, callback, state); } /// /// Completes an Asynchronous call to Trust Feb 2005 Issue message. /// /// IAsyncResult object returned by the Begin method that started the Asynchronous call. /// Message containing the Serialized RSTR. public Message EndTrustFeb2005Issue(IAsyncResult ar) { return EndProcessCore(ar, WSTrustFeb2005Constants.Actions.Issue, WSTrustFeb2005Constants.Actions.IssueResponse, WSTrustFeb2005Constants.NamespaceURI); } /// /// Processes an Asynchronous call to Trust Feb 2005 Renew message. /// /// Incoming Request message. /// Callback to be invoked when the Asynchronous operation ends. /// Asynchronous state. /// IAsyncResult that should be passed back to the End method to complete the Asynchronous call. public IAsyncResult BeginTrustFeb2005Renew(Message request, AsyncCallback callback, object state) { return BeginProcessCore(request, _securityTokenServiceConfiguration.WSTrustFeb2005RequestSerializer, _securityTokenServiceConfiguration.WSTrustFeb2005ResponseSerializer, WSTrustFeb2005Constants.Actions.Renew, WSTrustFeb2005Constants.Actions.RenewResponse, WSTrustFeb2005Constants.NamespaceURI, callback, state); } /// /// Completes an Asynchronous call to Trust Feb 2005 Renew message. /// /// IAsyncResult object returned by the Begin method that started the Asynchronous call. /// Message containing the Serialized RSTR. public Message EndTrustFeb2005Renew(IAsyncResult ar) { return EndProcessCore(ar, WSTrustFeb2005Constants.Actions.Renew, WSTrustFeb2005Constants.Actions.RenewResponse, WSTrustFeb2005Constants.NamespaceURI); } /// /// Processes an Asynchronous call to Trust Feb 2005 Validate message. /// /// Incoming Request message. /// Callback to be invoked when the Asynchronous operation ends. /// Asynchronous state. /// IAsyncResult that should be passed back to the End method to complete the Asynchronous call. public IAsyncResult BeginTrustFeb2005Validate(Message request, AsyncCallback callback, object state) { return BeginProcessCore(request, _securityTokenServiceConfiguration.WSTrustFeb2005RequestSerializer, _securityTokenServiceConfiguration.WSTrustFeb2005ResponseSerializer, WSTrustFeb2005Constants.Actions.Validate, WSTrustFeb2005Constants.Actions.ValidateResponse, WSTrustFeb2005Constants.NamespaceURI, callback, state); } /// /// Completes an Asynchronous call to Trust Feb 2005 Validate message. /// /// IAsyncResult object returned by the Begin method that started the Asynchronous call. /// Message containing the Serialized RSTR. public Message EndTrustFeb2005Validate(IAsyncResult ar) { return EndProcessCore(ar, WSTrustFeb2005Constants.Actions.Validate, WSTrustFeb2005Constants.Actions.ValidateResponse, WSTrustFeb2005Constants.NamespaceURI); } /// /// Processes an Asynchronous call to Trust Feb 2005 RSTR/Cancel message. /// /// Incoming Request message. /// Callback to be invoked when the Asynchronous operation ends. /// Asynchronous state. /// IAsyncResult that should be passed back to the End method to complete the Asynchronous call. public IAsyncResult BeginTrustFeb2005CancelResponse(Message request, AsyncCallback callback, object state) { return BeginProcessCore(request, _securityTokenServiceConfiguration.WSTrustFeb2005RequestSerializer, _securityTokenServiceConfiguration.WSTrustFeb2005ResponseSerializer, WSTrustFeb2005Constants.Actions.CancelResponse, WSTrustFeb2005Constants.Actions.CancelResponse, WSTrustFeb2005Constants.NamespaceURI, callback, state); } /// /// Completes an Asynchronous call to Trust Feb 2005 RSTR/Cancel message. /// /// IAsyncResult object returned by the Begin method that started the Asynchronous call. /// Message containing the Serialized RSTR. public Message EndTrustFeb2005CancelResponse(IAsyncResult ar) { return EndProcessCore(ar, WSTrustFeb2005Constants.Actions.CancelResponse, WSTrustFeb2005Constants.Actions.CancelResponse, WSTrustFeb2005Constants.NamespaceURI); } /// /// Processes an Asynchronous call to Trust Feb 2005 RSTR/Issue message. /// /// Incoming Request message. /// Callback to be invoked when the Asynchronous operation ends. /// Asynchronous state. /// IAsyncResult that should be passed back to the End method to complete the Asynchronous call. public IAsyncResult BeginTrustFeb2005IssueResponse(Message request, AsyncCallback callback, object state) { return BeginProcessCore(request, _securityTokenServiceConfiguration.WSTrustFeb2005RequestSerializer, _securityTokenServiceConfiguration.WSTrustFeb2005ResponseSerializer, WSTrustFeb2005Constants.Actions.IssueResponse, WSTrustFeb2005Constants.Actions.IssueResponse, WSTrustFeb2005Constants.NamespaceURI, callback, state); } /// /// Completes an Asynchronous call to Trust Feb 2005 RSTR/Issue message. /// /// IAsyncResult object returned by the Begin method that started the Asynchronous call. /// Message containing the Serialized RSTR. public Message EndTrustFeb2005IssueResponse(IAsyncResult ar) { return EndProcessCore(ar, WSTrustFeb2005Constants.Actions.IssueResponse, WSTrustFeb2005Constants.Actions.IssueResponse, WSTrustFeb2005Constants.NamespaceURI); } /// /// Processes an Asynchronous call to Trust Feb 2005 RSTR/Renew message. /// /// Incoming Request message. /// Callback to be invoked when the Asynchronous operation ends. /// Asynchronous state. /// IAsyncResult that should be passed back to the End method to complete the Asynchronous call. public IAsyncResult BeginTrustFeb2005RenewResponse(Message request, AsyncCallback callback, object state) { return BeginProcessCore(request, _securityTokenServiceConfiguration.WSTrustFeb2005RequestSerializer, _securityTokenServiceConfiguration.WSTrustFeb2005ResponseSerializer, WSTrustFeb2005Constants.Actions.RenewResponse, WSTrustFeb2005Constants.Actions.RenewResponse, WSTrustFeb2005Constants.NamespaceURI, callback, state); } /// /// Completes an Asynchronous call to Trust Feb 2005 RSTR/Renew message. /// /// IAsyncResult object returned by the Begin method that started the Asynchronous call. /// Message containing the Serialized RSTR. public Message EndTrustFeb2005RenewResponse(IAsyncResult ar) { return EndProcessCore(ar, WSTrustFeb2005Constants.Actions.RenewResponse, WSTrustFeb2005Constants.Actions.RenewResponse, WSTrustFeb2005Constants.NamespaceURI); } /// /// Processes an Asynchronous call to Trust Feb 2005 RSTR/Validate message. /// /// Incoming Request message. /// Callback to be invoked when the Asynchronous operation ends. /// Asynchronous state. /// IAsyncResult that should be passed back to the End method to complete the Asynchronous call. public IAsyncResult BeginTrustFeb2005ValidateResponse(Message request, AsyncCallback callback, object state) { return BeginProcessCore(request, _securityTokenServiceConfiguration.WSTrustFeb2005RequestSerializer, _securityTokenServiceConfiguration.WSTrustFeb2005ResponseSerializer, WSTrustFeb2005Constants.Actions.ValidateResponse, WSTrustFeb2005Constants.Actions.ValidateResponse, WSTrustFeb2005Constants.NamespaceURI, callback, state); } /// /// Completes an Asynchronous call to Trust Feb 2005 RSTR/Validate message. /// /// IAsyncResult object returned by the Begin method that started the Asynchronous call. /// Message containing the Serialized RSTR. public Message EndTrustFeb2005ValidateResponse(IAsyncResult ar) { return EndProcessCore(ar, WSTrustFeb2005Constants.Actions.ValidateResponse, WSTrustFeb2005Constants.Actions.ValidateResponse, WSTrustFeb2005Constants.NamespaceURI); } #endregion // // An async result class that represents the async version of the ProcessCore method. // internal class ProcessCoreAsyncResult : AsyncResult { // // Encapsulate the local variables in the sync version of ProcessCore as fields. // WSTrustServiceContract _trustServiceContract; DispatchContext _dispatchContext; MessageVersion _messageVersion; WSTrustResponseSerializer _responseSerializer; WSTrustSerializationContext _serializationContext; public ProcessCoreAsyncResult(WSTrustServiceContract contract, DispatchContext dispatchContext, MessageVersion messageVersion, WSTrustResponseSerializer responseSerializer, WSTrustSerializationContext serializationContext, AsyncCallback asyncCallback, object asyncState) : base(asyncCallback, asyncState) { if (contract == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("contract"); } if (dispatchContext == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("dispatchContext"); } if (responseSerializer == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("responseSerializer"); } if (serializationContext == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("serializationContext"); } _trustServiceContract = contract; _dispatchContext = dispatchContext; _messageVersion = messageVersion; _responseSerializer = responseSerializer; _serializationContext = serializationContext; contract.BeginDispatchRequest(dispatchContext, OnDispatchRequestCompleted, null); } public WSTrustServiceContract TrustServiceContract { get { return _trustServiceContract; } } public DispatchContext DispatchContext { get { return _dispatchContext; } } public MessageVersion MessageVersion { get { return _messageVersion; } } public WSTrustResponseSerializer ResponseSerializer { get { return _responseSerializer; } } public WSTrustSerializationContext SerializationContext { get { return _serializationContext; } } public new static Message End(IAsyncResult ar) { AsyncResult.End(ar); ProcessCoreAsyncResult pcar = ar as ProcessCoreAsyncResult; if (pcar == null) { throw DiagnosticUtility.ThrowHelperInvalidOperation(SR.GetString(SR.ID2004, typeof(ProcessCoreAsyncResult), ar.GetType())); } // // Create the response Message object with the appropriate action. // return Message.CreateMessage(OperationContext.Current.RequestContext.RequestMessage.Version, pcar.DispatchContext.ResponseAction, new WSTrustResponseBodyWriter(pcar.DispatchContext.ResponseMessage, pcar.ResponseSerializer, pcar.SerializationContext)); } // // Asynchronously invoked when WSTrustServiceContract.BeginDispatchRequest completes. // private void OnDispatchRequestCompleted(IAsyncResult ar) { try { _dispatchContext = _trustServiceContract.EndDispatchRequest(ar); this.Complete(false); } catch (Exception ex) { if (System.Runtime.Fx.IsFatal(ex)) { throw; } this.Complete(false, ex); } } } // // AsyncResult to encapsulate the default async implementation of DispatchRequest // internal class DispatchRequestAsyncResult : AsyncResult { DispatchContext _dispatchContext; public DispatchContext DispatchContext { get { return _dispatchContext; } } public DispatchRequestAsyncResult(DispatchContext dispatchContext, AsyncCallback asyncCallback, object asyncState) : base(asyncCallback, asyncState) { _dispatchContext = dispatchContext; ClaimsPrincipal icp = dispatchContext.Principal; RST rst = dispatchContext.RequestMessage as RST; STS sts = dispatchContext.SecurityTokenService; if (rst == null) { this.Complete(true, DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidRequestException(SR.GetString(SR.ID3023)))); return; } switch (rst.RequestType) { case RequestTypes.Cancel: sts.BeginCancel(icp, rst, OnCancelComplete, null); break; case RequestTypes.Issue: sts.BeginIssue(icp, rst, OnIssueComplete, null); break; case RequestTypes.Renew: sts.BeginRenew(icp, rst, OnRenewComplete, null); break; case RequestTypes.Validate: sts.BeginValidate(icp, rst, OnValidateComplete, null); break; default: this.Complete(true, DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.ID3112, rst.RequestType)))); break; } } public new static DispatchContext End(IAsyncResult ar) { AsyncResult.End(ar); DispatchRequestAsyncResult dcar = ar as DispatchRequestAsyncResult; if (dcar == null) { throw DiagnosticUtility.ThrowHelperInvalidOperation(SR.GetString(SR.ID2004, typeof(DispatchRequestAsyncResult), ar.GetType())); } return dcar.DispatchContext; } void OnCancelComplete(IAsyncResult ar) { try { _dispatchContext.ResponseMessage = _dispatchContext.SecurityTokenService.EndCancel(ar); Complete(false); } catch (Exception e) { System.ServiceModel.DiagnosticUtility.TraceHandledException(e, TraceEventType.Error); if (Fx.IsFatal(e)) throw; Complete(false, e); } } void OnIssueComplete(IAsyncResult ar) { try { _dispatchContext.ResponseMessage = _dispatchContext.SecurityTokenService.EndIssue(ar); Complete(false); } catch (Exception e) { System.ServiceModel.DiagnosticUtility.TraceHandledException(e, TraceEventType.Error); if (Fx.IsFatal(e)) throw; Complete(false, e); } } void OnRenewComplete(IAsyncResult ar) { try { _dispatchContext.ResponseMessage = _dispatchContext.SecurityTokenService.EndRenew(ar); Complete(false); } catch (Exception e) { System.ServiceModel.DiagnosticUtility.TraceHandledException(e, TraceEventType.Error); if (Fx.IsFatal(e)) throw; Complete(false, e); } } void OnValidateComplete(IAsyncResult ar) { try { _dispatchContext.ResponseMessage = _dispatchContext.SecurityTokenService.EndValidate(ar); Complete(false); } catch (Exception e) { System.ServiceModel.DiagnosticUtility.TraceHandledException(e, TraceEventType.Error); if (Fx.IsFatal(e)) throw; Complete(false, e); } } } #region IContractBehavior Members /// /// Configures any binding elements to support the contract behavior. /// /// /// Inherited from IContractBehavior /// public void AddBindingParameters(ContractDescription contractDescription, ServiceEndpoint endpoint, BindingParameterCollection bindingParameters) { return; } /// /// Implements a modification or extension of the client across a contract. /// /// /// Inherited from IContractBehavior /// public void ApplyClientBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint, System.ServiceModel.Dispatcher.ClientRuntime clientRuntime) { return; } /// /// Implements a modification or extension of the client across a contract. /// /// /// Inherited from IContractBehavior /// public void ApplyDispatchBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint, System.ServiceModel.Dispatcher.DispatchRuntime dispatchRuntime) { return; } /// /// Implement to confirm that the contract and endpoint can support the contract /// behavior. /// /// /// Inherited from IContractBehavior /// public void Validate(ContractDescription contractDescription, ServiceEndpoint endpoint) { return; } #endregion #region IWsdlExportExtension Members /// /// Implementation for IWsdlExportExtension.ExportContract. The default implementation /// does nothing. Can be overriden in the derived class for specific behavior. /// /// The WsdlExporter that exports the contract information. /// Provides mappings from exported WSDL elements to the contract description. public virtual void ExportContract(WsdlExporter exporter, WsdlContractConversionContext context) { return; } /// /// Implements IWsdlExportExtensions.ExportEndpoint. The default implementation does the following, /// For every Trust contract found, /// 1. It includes the appropriate trust namespace in the WSDL. /// 2. Imports the appropriate Trust schema and all dependent schemas. /// 3. Fixes the Messages of each operation to it appropriate WS-Trust equivalent. /// Trust Contract exposed by the Framework takes a System.ServiceModel.Channels.Message in and /// returns a System.ServiceModel.Channels.Message out. But Trust messages expects and RST and /// returns an RSTR/RSTRC. This method fixes the message names with the appropriate WS-Trust /// messages. /// /// The WsdlExporter that exports the contract information. /// Provides mappings from exported WSDL elements to the endpoint description. /// The input argument 'exporter' or 'context' is null. public virtual void ExportEndpoint(WsdlExporter exporter, WsdlEndpointConversionContext context) { if (exporter == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("exporter"); } if (context == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context"); } if (context.WsdlPort == null) { throw DiagnosticUtility.ThrowHelperInvalidOperation(SR.GetString(SR.ID3146)); } if (context.WsdlPort.Service == null) { throw DiagnosticUtility.ThrowHelperInvalidOperation(SR.GetString(SR.ID3147)); } if (context.WsdlPort.Service.ServiceDescription == null) { throw DiagnosticUtility.ThrowHelperInvalidOperation(SR.GetString(SR.ID3148)); } System.Web.Services.Description.ServiceDescription serviceDescription = context.WsdlPort.Service.ServiceDescription; // Iterate throught the Ports and for each of our contracts fix the input and output messages // of the contract and import the required schemas. foreach (PortType portType in serviceDescription.PortTypes) { if (StringComparer.Ordinal.Equals(portType.Name, WSTrustServiceContractConstants.Contracts.IWSTrustFeb2005Sync)) { IncludeNamespace(context, WSTrustFeb2005Constants.Prefix, WSTrustFeb2005Constants.NamespaceURI); ImportSchema(exporter, context, WSTrustFeb2005Constants.NamespaceURI); FixMessageElement( serviceDescription, portType, context, WSTrustServiceContractConstants.Operations.TrustFeb2005Cancel, new XmlQualifiedName( WSTrustFeb2005Constants.ElementNames.RequestSecurityToken, WSTrustFeb2005Constants.NamespaceURI), new XmlQualifiedName(WSTrustFeb2005Constants.ElementNames.RequestSecurityTokenResponse, WSTrustFeb2005Constants.NamespaceURI)); FixMessageElement( serviceDescription, portType, context, WSTrustServiceContractConstants.Operations.TrustFeb2005Issue, new XmlQualifiedName( WSTrustFeb2005Constants.ElementNames.RequestSecurityToken, WSTrustFeb2005Constants.NamespaceURI), new XmlQualifiedName( WSTrustFeb2005Constants.ElementNames.RequestSecurityTokenResponse, WSTrustFeb2005Constants.NamespaceURI)); FixMessageElement( serviceDescription, portType, context, WSTrustServiceContractConstants.Operations.TrustFeb2005Renew, new XmlQualifiedName( WSTrustFeb2005Constants.ElementNames.RequestSecurityToken, WSTrustFeb2005Constants.NamespaceURI), new XmlQualifiedName( WSTrustFeb2005Constants.ElementNames.RequestSecurityTokenResponse, WSTrustFeb2005Constants.NamespaceURI)); FixMessageElement( serviceDescription, portType, context, WSTrustServiceContractConstants.Operations.TrustFeb2005Validate, new XmlQualifiedName( WSTrustFeb2005Constants.ElementNames.RequestSecurityToken, WSTrustFeb2005Constants.NamespaceURI), new XmlQualifiedName( WSTrustFeb2005Constants.ElementNames.RequestSecurityTokenResponse, WSTrustFeb2005Constants.NamespaceURI)); } else if (StringComparer.OrdinalIgnoreCase.Equals(portType.Name, WSTrustServiceContractConstants.Contracts.IWSTrust13Sync)) { IncludeNamespace(context, WSTrust13Constants.Prefix, WSTrust13Constants.NamespaceURI); ImportSchema(exporter, context, WSTrust13Constants.NamespaceURI); FixMessageElement( serviceDescription, portType, context, WSTrustServiceContractConstants.Operations.Trust13Cancel, new XmlQualifiedName( WSTrust13Constants.ElementNames.RequestSecurityToken, WSTrust13Constants.NamespaceURI), new XmlQualifiedName( WSTrust13Constants.ElementNames.RequestSecurityTokenResponseCollection, WSTrust13Constants.NamespaceURI)); FixMessageElement( serviceDescription, portType, context, WSTrustServiceContractConstants.Operations.Trust13Issue, new XmlQualifiedName( WSTrust13Constants.ElementNames.RequestSecurityToken, WSTrust13Constants.NamespaceURI), new XmlQualifiedName( WSTrust13Constants.ElementNames.RequestSecurityTokenResponseCollection, WSTrust13Constants.NamespaceURI)); FixMessageElement( serviceDescription, portType, context, WSTrustServiceContractConstants.Operations.Trust13Renew, new XmlQualifiedName( WSTrust13Constants.ElementNames.RequestSecurityToken, WSTrust13Constants.NamespaceURI), new XmlQualifiedName( WSTrust13Constants.ElementNames.RequestSecurityTokenResponseCollection, WSTrust13Constants.NamespaceURI)); FixMessageElement( serviceDescription, portType, context, WSTrustServiceContractConstants.Operations.Trust13Validate, new XmlQualifiedName( WSTrust13Constants.ElementNames.RequestSecurityToken, WSTrust13Constants.NamespaceURI), new XmlQualifiedName( WSTrust13Constants.ElementNames.RequestSecurityTokenResponseCollection, WSTrust13Constants.NamespaceURI)); } else if (StringComparer.OrdinalIgnoreCase.Equals(portType.Name, WSTrustServiceContractConstants.Contracts.IWSTrustFeb2005Async)) { IncludeNamespace(context, WSTrustFeb2005Constants.Prefix, WSTrustFeb2005Constants.NamespaceURI); ImportSchema(exporter, context, WSTrustFeb2005Constants.NamespaceURI); FixMessageElement( serviceDescription, portType, context, WSTrustServiceContractConstants.Operations.TrustFeb2005CancelAsync, new XmlQualifiedName( WSTrustFeb2005Constants.ElementNames.RequestSecurityToken, WSTrustFeb2005Constants.NamespaceURI), new XmlQualifiedName( WSTrustFeb2005Constants.ElementNames.RequestSecurityTokenResponse, WSTrustFeb2005Constants.NamespaceURI)); FixMessageElement( serviceDescription, portType, context, WSTrustServiceContractConstants.Operations.TrustFeb2005IssueAsync, new XmlQualifiedName( WSTrustFeb2005Constants.ElementNames.RequestSecurityToken, WSTrustFeb2005Constants.NamespaceURI), new XmlQualifiedName( WSTrustFeb2005Constants.ElementNames.RequestSecurityTokenResponse, WSTrustFeb2005Constants.NamespaceURI)); FixMessageElement( serviceDescription, portType, context, WSTrustServiceContractConstants.Operations.TrustFeb2005RenewAsync, new XmlQualifiedName( WSTrustFeb2005Constants.ElementNames.RequestSecurityToken, WSTrustFeb2005Constants.NamespaceURI), new XmlQualifiedName( WSTrustFeb2005Constants.ElementNames.RequestSecurityTokenResponse, WSTrustFeb2005Constants.NamespaceURI)); FixMessageElement( serviceDescription, portType, context, WSTrustServiceContractConstants.Operations.TrustFeb2005ValidateAsync, new XmlQualifiedName( WSTrustFeb2005Constants.ElementNames.RequestSecurityToken, WSTrustFeb2005Constants.NamespaceURI), new XmlQualifiedName( WSTrustFeb2005Constants.ElementNames.RequestSecurityTokenResponse, WSTrustFeb2005Constants.NamespaceURI)); } else if (StringComparer.OrdinalIgnoreCase.Equals(portType.Name, WSTrustServiceContractConstants.Contracts.IWSTrust13Async)) { IncludeNamespace(context, WSTrust13Constants.Prefix, WSTrust13Constants.NamespaceURI); ImportSchema(exporter, context, WSTrust13Constants.NamespaceURI); FixMessageElement( serviceDescription, portType, context, WSTrustServiceContractConstants.Operations.Trust13CancelAsync, new XmlQualifiedName( WSTrust13Constants.ElementNames.RequestSecurityToken, WSTrust13Constants.NamespaceURI), new XmlQualifiedName( WSTrust13Constants.ElementNames.RequestSecurityTokenResponseCollection, WSTrust13Constants.NamespaceURI)); FixMessageElement( serviceDescription, portType, context, WSTrustServiceContractConstants.Operations.Trust13IssueAsync, new XmlQualifiedName( WSTrust13Constants.ElementNames.RequestSecurityToken, WSTrust13Constants.NamespaceURI), new XmlQualifiedName( WSTrust13Constants.ElementNames.RequestSecurityTokenResponseCollection, WSTrust13Constants.NamespaceURI)); FixMessageElement( serviceDescription, portType, context, WSTrustServiceContractConstants.Operations.Trust13RenewAsync, new XmlQualifiedName( WSTrust13Constants.ElementNames.RequestSecurityToken, WSTrust13Constants.NamespaceURI), new XmlQualifiedName( WSTrust13Constants.ElementNames.RequestSecurityTokenResponseCollection, WSTrust13Constants.NamespaceURI)); FixMessageElement( serviceDescription, portType, context, WSTrustServiceContractConstants.Operations.Trust13ValidateAsync, new XmlQualifiedName( WSTrust13Constants.ElementNames.RequestSecurityToken, WSTrust13Constants.NamespaceURI), new XmlQualifiedName( WSTrust13Constants.ElementNames.RequestSecurityTokenResponseCollection, WSTrust13Constants.NamespaceURI)); } } } #endregion /// /// Adds the required WS-Trust namespaces to the WSDL if not already present. /// /// Provides mappings from exported WSDL elements to the endpoint description. /// The prefix of the namespace to be included. /// Namespace to be included. /// Either 'prefix' or 'ns' is null or empty string. /// The 'context' parameter is null. protected virtual void IncludeNamespace(WsdlEndpointConversionContext context, string prefix, string ns) { if (context == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context"); } if (String.IsNullOrEmpty(prefix)) { throw DiagnosticUtility.ThrowHelperArgumentNullOrEmptyString("prefix"); } if (String.IsNullOrEmpty(ns)) { throw DiagnosticUtility.ThrowHelperArgumentNullOrEmptyString("ns"); } bool alreadyPresent = false; XmlQualifiedName[] namespaces = context.WsdlBinding.ServiceDescription.Namespaces.ToArray(); for (int i = 0; i < namespaces.Length; ++i) { if (StringComparer.Ordinal.Equals(namespaces[i].Namespace, ns)) { alreadyPresent = true; break; } } if (!alreadyPresent) { context.WsdlBinding.ServiceDescription.Namespaces.Add(prefix, ns); } } /// /// Imports all the required schema if not already present in the WSDL. /// The default implementation will import the following schemas, /// (a) WS-Trust Feb 2005. /// (b) WS-Trust 1.3 /// Derived classes can override this method to import other schemas. /// /// The WsdlExporter that exports the contract information. /// Provides mappings from exported WSDL elements to the endpoint description. /// The current WS-Trust namespace for which the schemas are imported. /// The parameter 'exporter' or 'context' is null. /// The parameter 'ns' is either null or String.Empty. /// The namespace 'ns' is not a recognized WS-Trust namespace. protected virtual void ImportSchema(WsdlExporter exporter, WsdlEndpointConversionContext context, string ns) { if (exporter == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("exporter"); } if (context == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context"); } if (String.IsNullOrEmpty(ns)) { throw DiagnosticUtility.ThrowHelperArgumentNullOrEmptyString("ns"); } foreach (XmlSchema xmlSchema in context.WsdlPort.Service.ServiceDescription.Types.Schemas) { foreach (XmlSchemaObject include in xmlSchema.Includes) { XmlSchemaImport schemaImport = include as XmlSchemaImport; if ((schemaImport != null) && StringComparer.Ordinal.Equals(schemaImport.Namespace, ns)) { // The schema is already imported. Just return. return; } } } XmlSchema schema = GetXmlSchema(exporter, ns); if (schema == null) { throw DiagnosticUtility.ThrowHelperInvalidOperation(SR.GetString(SR.ID3004, ns)); } XmlSchema importedSchema = null; if (context.WsdlPort.Service.ServiceDescription.Types.Schemas.Count == 0) { importedSchema = new XmlSchema(); context.WsdlPort.Service.ServiceDescription.Types.Schemas.Add(importedSchema); } else { importedSchema = context.WsdlPort.Service.ServiceDescription.Types.Schemas[0]; } XmlSchemaImport import = new XmlSchemaImport(); import.Namespace = ns; exporter.GeneratedXmlSchemas.Add(schema); importedSchema.Includes.Add(import); } /// /// For a given namespace this method looks up the WsdlExporter to see if an XmlSchema has been cached and returns that. /// Else it loads the schema for that given namespace and returns the loaded XmlSchema. /// /// The WsdlExporter that exports the contract information. /// The namespace for which the schema is to be obtained. /// The parameter 'exporter' is null. /// The parameter 'ns' is either null or String.Empty. /// The namespace 'ns' is not a recognized WS-Trust namespace. static XmlSchema GetXmlSchema(WsdlExporter exporter, string ns) { if (exporter == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("exporter"); } if (String.IsNullOrEmpty(ns)) { throw DiagnosticUtility.ThrowHelperArgumentNullOrEmptyString("ns"); } ICollection schemas = exporter.GeneratedXmlSchemas.Schemas(ns); if ((schemas != null) && (schemas.Count > 0)) { foreach (XmlSchema s in schemas) { return s; } } string xmlSchema = null; switch (ns) { case WSTrustFeb2005Constants.NamespaceURI: xmlSchema = WSTrustFeb2005Constants.Schema; break; case WSTrust13Constants.NamespaceURI: xmlSchema = WSTrust13Constants.Schema; break; default: throw DiagnosticUtility.ThrowHelperInvalidOperation(SR.GetString(SR.ID5004, ns)); } StringReader reader = new StringReader(xmlSchema); return XmlSchema.Read(new XmlTextReader(reader) { DtdProcessing = DtdProcessing.Prohibit }, null); } /// /// During WSDL generation, the method fixes a given operation message element to refer to the /// RST and RSTR elements of the appropriate WS-Trust version. /// /// The ServiceDescription that has the current state of the exported /// WSDL. /// The WSDL PortType whose messages are to be fixed. /// Provides mappings from exported WSDL elements to the endpoint description. /// The operation name inside the PortType. /// The XmlQualifiedName of the input message element. /// The XmlQualifiedName of the output message element. /// The parameter 'serviceDescription', 'portType', 'inputMessageType' /// or 'outputMessageType' is null. /// The parameter 'operationName' is null or Empty. /// /// Trust Contract exposed by the Framework takes a System.ServiceModel.Channels.Message in and /// returns a System.ServiceModel.Channels.Message out. But Trust messages expects and RST and /// returns an RSTR/RSTRC. This method fixes the message elements with the appropriate WS-Trust /// messages specified by the XmlQualified names 'inputMessageElement' and 'outputMessageElement'. /// protected virtual void FixMessageElement( System.Web.Services.Description.ServiceDescription serviceDescription, PortType portType, WsdlEndpointConversionContext context, string operationName, XmlQualifiedName inputMessageElement, XmlQualifiedName outputMessageElement) { if (serviceDescription == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("serviceDescription"); } if (portType == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("portType"); } if (context == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context"); } if (String.IsNullOrEmpty(operationName)) { throw DiagnosticUtility.ThrowHelperArgumentNullOrEmptyString("operationName"); } if (inputMessageElement == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("inputMessageElement"); } if (outputMessageElement == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("outputMessageElement"); } Operation operation = null; System.Web.Services.Description.Message inputMessage = null; System.Web.Services.Description.Message outputMessage = null; foreach (Operation op in portType.Operations) { if (StringComparer.Ordinal.Equals(op.Name, operationName)) { operation = op; // Find the correspinding message in the messages collection. foreach (System.Web.Services.Description.Message message in serviceDescription.Messages) { if (StringComparer.Ordinal.Equals(message.Name, op.Messages.Input.Message.Name)) { if (message.Parts.Count != 1) { throw DiagnosticUtility.ThrowHelperInvalidOperation( SR.GetString(SR.ID3144, portType.Name, op.Name, message.Name, message.Parts.Count)); } inputMessage = message; } else if (StringComparer.Ordinal.Equals(message.Name, op.Messages.Output.Message.Name)) { if (message.Parts.Count != 1) { throw DiagnosticUtility.ThrowHelperInvalidOperation( SR.GetString(SR.ID3144, portType.Name, op.Name, message.Name, message.Parts.Count)); } outputMessage = message; } if ((inputMessage != null) && (outputMessage != null)) { break; } } } if (operation != null) { break; } } if (operation == null) { // This operation is missing. This might be due to another Behavior that has modified the WSDL as // well. Ignore this and return. return; } if (inputMessage == null) { throw DiagnosticUtility.ThrowHelperInvalidOperation( SR.GetString(SR.ID3149, portType.Name, portType.Namespaces, operationName)); } if (outputMessage == null) { throw DiagnosticUtility.ThrowHelperInvalidOperation( SR.GetString(SR.ID3150, portType.Name, portType.Namespaces, operationName)); } inputMessage.Parts[0].Element = inputMessageElement; outputMessage.Parts[0].Element = outputMessageElement; inputMessage.Parts[0].Type = null; outputMessage.Parts[0].Type = null; } } }