SignInResponseMessage Class

namespace SimplePassiveSTS
{
    public partial class _Default : System.Web.UI.Page
    {
        /// <summary>
        /// Returns whether the user is authenticated or not. 
        /// </summary>
        bool IsAuthenticatedUser
        {
            get
            {
            return ( ( Page.User != null ) && ( Page.User.Identity != null ) && ( Page.User.Identity.IsAuthenticated ) );
            }
        }

        /// <summary>
        /// Helper function that processes the incoming request message
        /// and creates a response message
        /// </summary>
        private SignInResponseMessage ProcessSignInRequest(SignInRequestMessage requestMessage )
        {
            if ( requestMessage == null )
            {
                throw new ArgumentNullException( "requestMessage" );
            }

            // Ensure that the requestMessage has the required ‘wtrealm’ 
            // parameter
            if ( String.IsNullOrEmpty( requestMessage.Realm ) )
            {
                throw new InvalidOperationException(
                    "Incoming Passive Request message didn't contain the wtrealm parameter." );
            }

             // Create a SecurityTokenServiceConfiguration instance

             SecurityTokenServiceConfiguration stsconfig = new SecurityTokenServiceConfiguration( "SimplePassiveSTS" );

            // Create the STS.
            SecurityTokenService sts = new MySecurityTokenService(stsconfig); 

            // Create the WS-Federation serializer to process the request and
            // create the response.
            // This creates the default WSFederationSerializer that handles 
            // the WS-Trust Feb 2005 specification.
            WSFederationSerializer federationSerializer = new WSFederationSerializer();

             // Create RST from the request
             RequestSecurityToken request = federationSerializer.CreateRequest (requestMessage, new WSTrustSerializationContext() );

            // Get RSTR from the STS.
            RequestSecurityTokenResponse response = sts.Issue(ClaimsPrincipal.Current, request );

            // Create WS-Federation Response message from the RSTR
            return new SignInResponseMessage( new Uri( response.ReplyTo ),
                federationSerializer.GetResponseAsString(response, new WSTrustSerializationContext() ) );

        }

        /// <summary>
        /// We perform WS-Federation passive protocol logic in this method 
        ///and call out to the appropriate request handlers. 
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void Page_PreRender( object sender, EventArgs e )
        {
            if ( IsAuthenticatedUser )
            {
                // Use WSFederationMessage.CreateFromUri to parse the request and create a WSFederationMessage. 
                WSFederationMessage federationMessage = WSFederationMessage.CreateFromUri( Request.Url );

                if ( federationMessage.Action == WSFederationConstants.Actions.SignIn )
                {
                    // Process the sign in request. 
                    SignInResponseMessage responseMessage = ProcessSignInRequest(
                        federationMessage as SignInRequestMessage );

                    // Always Echo back the Context (wctx) which came on the // request.
                    responseMessage.Context = federationMessage.Context;

                    // Write the response message.     
                    responseMessage.Write( Page.Response.Output );
                    Response.Flush();
                    Response.End();
                }
                else if ( federationMessage.Action == WSFederationConstants.Actions.SignOut ||
                          federationMessage.Action == WSFederationConstants.Actions.SignOutCleanup )
                {
                   // Perform the clean-up operation here
                }
                else
                {
                    throw new InvalidOperationException( String.Format(
                                  CultureInfo.InvariantCulture, "Unsupported Action: {0}", federationMessage.Action ) );
                }
            }

        }

    }

}