SecurityTokenService Klas

Definitie

public ref class SecurityTokenService abstract

public abstract class SecurityTokenService

type SecurityTokenService = class

Public MustInherit Class SecurityTokenService

Overname

Object

SecurityTokenService

Voorbeelden

De codevoorbeelden die in de SecurityTokenService onderwerpen worden gebruikt, worden uit het Custom Token voorbeeld genomen. Dit voorbeeld biedt aangepaste klassen die verwerking van Eenvoudige webtokens (SWT) mogelijk maken en bevat een implementatie van een passieve STS die een SWT-token kan leveren. Voor een voorbeeld van hoe u een actieve STS implementeert, ziet u het Federation Metadata voorbeeld. Zie de WIF-codevoorbeeldindex voor informatie over deze voorbeelden en andere voorbeelden die beschikbaar zijn voor WIF en waar u ze kunt downloaden. De volgende code toont de implementatie van een passieve STS met behulp van de SecurityTokenService klasse.

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));
            }
        }

    }
}

De volgende code laat zien hoe u een aangepaste passieve STS aanroept om een WS-Federation aanvraag te verwerken door de FederatedPassiveSecurityTokenServiceOperations.ProcessRequest(HttpRequest, ClaimsPrincipal, SecurityTokenService, HttpResponse) methode aan te roepen vanuit de code achter in het default.aspx.cs bestand.

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 );
        }
    }
}

Opmerkingen

Als u een STS wilt maken, moet u afgeleid zijn van de SecurityTokenService klasse. In uw aangepaste klasse moet u minimaal de GetScope en GetOutputClaimsIdentity methoden overschrijven. Met deze onderdrukkingen kan de STS die is gemaakt met behulp van de standaard implementatie van alle andere methoden die in de klasse zijn gedefinieerd, beveiligingstokens uitgeven als reactie op aanvragen voor beveiligingstokens (RST). Dat wil gezegd: de probleembinding die is gedefinieerd in de specificatie WS-Trust wordt geïmplementeerd. Deze binding wordt geïmplementeerd in de Issue methode. Geen van de andere WS-Trust bindingen (vernieuwen, annuleren en valideren) worden geïmplementeerd in het standaardscenario en er wordt een juiste fout geretourneerd naar de aanroeper als er een RST wordt aangetroffen die overeenkomt met een van deze bindingen. U kunt natuurlijk de juiste methoden (Renew, Cancelen Validate) overschrijven om deze bindingen in uw STS te implementeren.

De volgende lijst bevat een kort overzicht van de methoden van primair belang voor de ontwikkelaar voor gebruik in een test- of ontwikkelomgeving.

• De GetScope methode. Met deze methode wordt een Scope object geretourneerd dat informatie over de RP bevat. Dit object wordt gebruikt in de rest van de tokenuitgiftepijplijn en bevat informatie over de ondertekening en versleuteling van referenties die in het antwoord moeten worden gebruikt, evenals de AppliesTo en ReplyTo (indien nodig) adressen. U moet deze methode overschrijven.

• De GetOutputClaimsIdentity methode. Met deze methode wordt een ClaimsIdentity object geretourneerd dat de claims bevat die moeten worden geretourneerd naar de RP. U moet deze methode overschrijven.

• De Issue methode. Met deze methode wordt de tokenaanvraagpijplijn geïmplementeerd, die een binnenkomende RST (Security Token Request) verwerkt en een antwoord (RSTR) retourneert naar de aanroeper die een token bevat dat kan worden gebruikt voor verificatie met een RP. Veel van de andere methoden die in de SecurityTokenService klasse zijn gedefinieerd, worden aangeroepen vanuit deze methode, inclusief de GetScope en GetOutputClaimsIdentity methoden. U hoeft deze methode niet te overschrijven, maar een goed begrip van de tokenaanvraagpijplijn die wordt geïmplementeerd, kan nuttig zijn.

Een STS wordt geconfigureerd via de SecurityTokenServiceConfiguration klasse.

Notities voor uitvoerders

U moet zowel de GetScope(ClaimsPrincipal, RequestSecurityToken) als de GetOutputClaimsIdentity(ClaimsPrincipal, RequestSecurityToken, Scope) methoden overschrijven.

Zie ook

• Scope
• SecurityTokenServiceConfiguration
• FederatedPassiveSecurityTokenServiceOperations