SecurityTokenService Klass

Definition

public ref class SecurityTokenService abstract

public abstract class SecurityTokenService

type SecurityTokenService = class

Public MustInherit Class SecurityTokenService

Arv

Object

SecurityTokenService

Exempel

Kodexemplen som används i ämnena SecurityTokenService tas från Custom Token exemplet. Det här exemplet innehåller anpassade klasser som möjliggör bearbetning av enkla webbtoken (SWT) och innehåller en implementering av en passiv STS som kan hantera en SWT-token. Ett exempel på hur du implementerar en aktiv STS kan du se Federation Metadata exemplet. Information om dessa exempel och andra exempel som är tillgängliga för WIF och var du kan ladda ned dem finns i WIF Code Sample Index. Följande kod visar implementeringen av en passiv STS med hjälp av SecurityTokenService klassen .

using System;
using System.IdentityModel;
using System.IdentityModel.Configuration;
using System.IdentityModel.Protocols.WSTrust;
using System.IdentityModel.Tokens;
using System.Security.Claims;
using System.Security.Cryptography.X509Certificates;

namespace PassiveSTS
{
    /// <summary>
    /// Overrides the SecurityTokenService class to provide
    /// the relying party related information, such as encryption credentials to encrypt the issued
    /// token, signing credentials to sign the issued token, claims that the STS wants to issue for a 
    /// certain token request, as well as the claim types that this STS is capable
    /// of issuing.
    /// </summary>
    public class CustomSecurityTokenService : SecurityTokenService
    {
        // Certificate Constants
        private const string SIGNING_CERTIFICATE_NAME = "CN=localhost";
        private const string ENCRYPTING_CERTIFICATE_NAME = "CN=localhost";

        private SigningCredentials _signingCreds;
        private EncryptingCredentials _encryptingCreds;
        // Used for validating applies to address, set to URI used in RP app of application, could also have been done via config
        private string _addressExpected = "http://localhost:19851/";
        public CustomSecurityTokenService(SecurityTokenServiceConfiguration configuration)
            : base(configuration)
        {
            // Setup the certificate our STS is going to use to sign the issued tokens
            _signingCreds = new X509SigningCredentials(CertificateUtil.GetCertificate(StoreName.My, StoreLocation.LocalMachine, SIGNING_CERTIFICATE_NAME));

            // Note: In this sample app only a si   ngle RP identity is shown, which is localhost, and the certificate of that RP is 
            // populated as _encryptingCreds
            // If you have multiple RPs for the STS you would select the certificate that is specific to 
            // the RP that requests the token and then use that for _encryptingCreds
            _encryptingCreds = new X509EncryptingCredentials(CertificateUtil.GetCertificate(StoreName.My, StoreLocation.LocalMachine, ENCRYPTING_CERTIFICATE_NAME));
        }

        /// <summary>
        /// This method returns the configuration for the token issuance request. The configuration
        /// is represented by the Scope class. In our case, we are only capable of issuing a token to a
        /// single RP identity represented by the _encryptingCreds field.
        /// </summary>
        /// <param name="principal">The caller's principal</param>
        /// <param name="request">The incoming RST</param>
        /// <returns></returns>
        protected override Scope GetScope(ClaimsPrincipal principal, RequestSecurityToken request)
        {
            // Validate the AppliesTo address
            ValidateAppliesTo( request.AppliesTo );

            // Create the scope using the request AppliesTo address and the RP identity
            Scope scope = new Scope( request.AppliesTo.Uri.AbsoluteUri, _signingCreds );

            if (Uri.IsWellFormedUriString(request.ReplyTo, UriKind.Absolute))
            {
                if (request.AppliesTo.Uri.Host != new Uri(request.ReplyTo).Host)
                    scope.ReplyToAddress = request.AppliesTo.Uri.AbsoluteUri;
                else
                    scope.ReplyToAddress = request.ReplyTo;
            }
            else
            {
                Uri resultUri = null;
                if (Uri.TryCreate(request.AppliesTo.Uri, request.ReplyTo, out resultUri))
                    scope.ReplyToAddress = resultUri.AbsoluteUri;
                else
                    scope.ReplyToAddress = request.AppliesTo.Uri.ToString() ;
            }

            // Note: In this sample app only a single RP identity is shown, which is localhost, and the certificate of that RP is 
            // populated as _encryptingCreds
            // If you have multiple RPs for the STS you would select the certificate that is specific to 
            // the RP that requests the token and then use that for _encryptingCreds
            scope.EncryptingCredentials = _encryptingCreds;

            return scope;
        }
        /// <summary>
        /// This method returns the content of the issued token. The content is represented as a set of
        /// IClaimIdentity intances, each instance corresponds to a single issued token. Currently, the Windows Identity Foundation only
        /// supports a single token issuance, so the returned collection must always contain only a single instance.
        /// </summary>
        /// <param name="scope">The scope that was previously returned by GetScope method</param>
        /// <param name="principal">The caller's principal</param>
        /// <param name="request">The incoming RST, we don't use this in our implementation</param>
        /// <returns></returns>
        protected override ClaimsIdentity GetOutputClaimsIdentity( ClaimsPrincipal principal, RequestSecurityToken request, Scope scope )
        {
            //
            // Return a default claim set which contains a custom decision claim
            // Here you can actually examine the user by looking at the IClaimsPrincipal and 
            // return the right decision based on that. 
            //
            ClaimsIdentity outgoingIdentity = new ClaimsIdentity();
            outgoingIdentity.AddClaims(principal.Claims);

            return outgoingIdentity;
        }
        /// <summary>
        /// Validates the appliesTo and throws an exception if the appliesTo is null or appliesTo contains some unexpected address.
        /// </summary>
        /// <param name="appliesTo">The AppliesTo parameter in the request that came in (RST)</param>
        /// <returns></returns>
        void ValidateAppliesTo(EndpointReference appliesTo)
        {
            if (appliesTo == null)
            {
                throw new InvalidRequestException("The appliesTo is null.");
            }

            if (!appliesTo.Uri.Equals(new Uri(_addressExpected)))
            {
                throw new InvalidRequestException(String.Format("The relying party address is not valid. Expected value is {0}, the actual value is {1}.", _addressExpected, appliesTo.Uri.AbsoluteUri));
            }
        }

    }
}

Följande kod visar hur du anropar en anpassad passiv STS för att bearbeta en WS-Federation begäran genom att anropa FederatedPassiveSecurityTokenServiceOperations.ProcessRequest(HttpRequest, ClaimsPrincipal, SecurityTokenService, HttpResponse) metoden från koden bakom i default.aspx.cs filen.

using System;
using System.IdentityModel.Services;
using System.Security.Claims;

namespace PassiveSTS
{
    public partial class _Default : System.Web.UI.Page
    {
        /// <summary>
        /// We perform the WS-Federation Passive Protocol processing in this method. 
        /// </summary>
        protected void Page_PreRender( object sender, EventArgs e ) 
        {
            FederatedPassiveSecurityTokenServiceOperations.ProcessRequest( Request, User as ClaimsPrincipal, CustomSecurityTokenServiceConfiguration.Current.CreateSecurityTokenService(), Response );
        }
    }
}

Kommentarer

Om du vill skapa en STS måste du härleda SecurityTokenService från klassen. I din anpassade klass måste du åtminstone åsidosätta GetScope metoderna och GetOutputClaimsIdentity . Med dessa åsidosättningar kan den STS som skapats med standardimplementeringen av alla andra metoder som definierats i klassen utfärda säkerhetstoken som svar på begäranden om säkerhetstoken (RST). Det innebär att problembindningen som definierats i WS-Trust-specifikationen implementeras. Den här bindningen implementeras i Issue -metoden. Ingen av de andra WS-Trust bindningar (Förnya, Avbryt och Verifiera) implementeras i standardfallet och ett lämpligt fel returneras till anroparen om en RST som motsvarar en av dessa bindningar påträffas. Du kan naturligtvis åsidosätta lämpliga metoder (Renew, Canceloch Validate) för att implementera dessa bindningar i din STS.

Följande lista innehåller en kort översikt över de metoder som är av primär betydelse för utvecklaren för användning i en test- eller utvecklingsmiljö.

• GetScope-metoden. Den här metoden returnerar ett Scope objekt som innehåller information om RP. Det här objektet används i resten av pipelinen för tokenutfärdande och innehåller information om signering och kryptering av autentiseringsuppgifter som ska användas i svaret, samt adresserna AppliesTo och ReplyTo (om det behövs). Du måste åsidosätta den här metoden.

• GetOutputClaimsIdentity-metoden. Den här metoden returnerar ett ClaimsIdentity objekt som innehåller anspråken för att återgå till RP. Du måste åsidosätta den här metoden.

• Issue-metoden. Den här metoden implementerar pipelinen för tokenbegäran, som bearbetar en inkommande begäran om säkerhetstoken (RST) och returnerar ett svar (RSTR) till anroparen som innehåller en token som kan användas för att autentisera med en RP. Många av de andra metoderna som definieras i SecurityTokenService klassen anropas från den här metoden, inklusive GetScope metoderna och GetOutputClaimsIdentity . Du behöver inte åsidosätta den här metoden, men en förståelse för pipelinen för tokenbegäran som implementeras kan vara till hjälp.

En STS konfigureras via SecurityTokenServiceConfiguration klassen.

Anteckningar till implementerare

Du måste åsidosätta både GetScope(ClaimsPrincipal, RequestSecurityToken) metoderna och GetOutputClaimsIdentity(ClaimsPrincipal, RequestSecurityToken, Scope) .

Se även

• Scope
• SecurityTokenServiceConfiguration
• FederatedPassiveSecurityTokenServiceOperations