SecurityTokenService Classe

Définition

Espace de noms:

System.IdentityModel

Assembly:

System.IdentityModel.dll

Classe de base abstraite qui définit les propriétés et les méthodes d'un service d'émission de jeton de sécurité (STS).

public ref class SecurityTokenService abstract

public abstract class SecurityTokenService

type SecurityTokenService = class

Public MustInherit Class SecurityTokenService

Héritage

Object

SecurityTokenService

Exemples

Les exemples de code utilisés dans les SecurityTokenService rubriques sont tirés de l’exemple Custom Token . Cet exemple fournit des classes personnalisées qui permettent le traitement des jetons web simples (SWT) et inclut une implémentation d’un STS passif capable de servir un jeton SWT. Pour obtenir un exemple d’implémentation d’un STS actif, vous pouvez voir l’exemple Federation Metadata . Pour plus d’informations sur ces exemples et d’autres exemples disponibles pour WIF et sur l’emplacement où les télécharger, consultez Index d’exemple de code WIF. Le code suivant montre l’implémentation d’un STS passif à l’aide de la SecurityTokenService classe .

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

    }
}

Le code suivant montre comment appeler un STS passif personnalisé pour traiter une demande de WS-Federation en appelant la FederatedPassiveSecurityTokenServiceOperations.ProcessRequest(HttpRequest, ClaimsPrincipal, SecurityTokenService, HttpResponse) méthode à partir du code derrière dans le default.aspx.cs fichier.

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

Remarques

Pour créer un STS, vous devez dériver de la SecurityTokenService classe . Dans votre classe personnalisée, vous devez, au minimum, remplacer les GetScope méthodes et GetOutputClaimsIdentity . Avec ces remplacements, le STS créé à l’aide de l’implémentation par défaut de toutes les autres méthodes définies dans la classe est capable d’émettre des jetons de sécurité en réponse à des demandes de jeton de sécurité (RST). Autrement dit, la liaison de problème définie dans la spécification WS-Trust est implémentée. Cette liaison est implémentée dans la Issue méthode . Aucune des autres liaisons WS-Trust (Renew, Cancel et Validate) n’est implémentée dans le cas par défaut et une erreur appropriée est retournée à l’appelant si un RST correspondant à l’une de ces liaisons est rencontré. Vous pouvez, bien sûr, remplacer les méthodes appropriées (Renew, Cancel, et Validate) pour implémenter ces liaisons dans votre STS.

Important

L’implémentation d’un STS prêt pour la production implique une planification minutieuse et des ressources considérables pour atténuer les risques de sécurité potentiels inhérents à l’exposition d’un tel service. La plupart des développeurs utilisant Windows Identity Foundation (WIF) développent des applications qui externalisent la gestion des identités à un STS, plutôt que de développer un STS lui-même. WIF fournit une extension Visual Studio, l’outil Identity and Access pour Visual Studio 2012, pour aider les développeurs à tester des solutions dans l’environnement de développement. Cet outil inclut un STS, LocalSTS, que vous pouvez configurer pour fournir des revendications spécifiques à l’application que vous développez. Pour plus d’informations sur l’outil Identity and Access, consultez Identity and Access Tool for Visual Studio 2012. Dans certains scénarios, LocalSTS peut ne pas fournir les fonctionnalités nécessaires pour tester correctement votre application, par exemple, dans un scénario qui implique le développement d’un gestionnaire de jetons personnalisé pour une utilisation par une application. Dans ce cas, vous pouvez dériver de SecurityTokenService pour créer un ou plusieurs STS simples qui peuvent être déployés dans votre environnement de développement et qui peuvent être utilisés pour tester ces fonctionnalités dans votre application. Le reste de cette section se concentre sur les méthodes exposées par la SecurityTokenService classe qui vous permettent d’implémenter un STS simple et d’étendre le pipeline d’émission de jetons.

La liste suivante fournit une brève vue d’ensemble des méthodes de première importance pour le développeur à utiliser dans un environnement de test ou de développement.

• Méthode GetScope Cette méthode retourne un Scope objet qui contient des informations sur le RP. Cet objet est utilisé dans le reste du pipeline d’émission de jetons et inclut des informations sur les informations d’identification de signature et de chiffrement à utiliser dans la réponse, ainsi que les AppliesTo adresses et ReplyTo (si nécessaire). Vous devez remplacer cette méthode.

• Méthode GetOutputClaimsIdentity Cette méthode retourne un ClaimsIdentity objet qui contient les revendications à retourner au rp. Vous devez remplacer cette méthode.

• Méthode Issue Cette méthode implémente le pipeline de demande de jeton, qui traite une demande de jeton de sécurité entrante (RST) et retourne une réponse (RSTR) à l’appelant qui contient un jeton qui peut être utilisé pour s’authentifier auprès d’un fournisseur de ressources. De nombreuses autres méthodes définies dans la SecurityTokenService classe sont appelées à partir de cette méthode, y compris les GetScope méthodes et GetOutputClaimsIdentity . Vous n’avez pas besoin de remplacer cette méthode, mais une compréhension du pipeline de demande de jeton qu’elle implémente peut être utile.

Un STS est configuré via la SecurityTokenServiceConfiguration classe .

Notes pour les responsables de l’implémentation

Vous devez remplacer les GetScope(ClaimsPrincipal, RequestSecurityToken) méthodes et .GetOutputClaimsIdentity(ClaimsPrincipal, RequestSecurityToken, Scope)

Constructeurs

SecurityTokenService(SecurityTokenServiceConfiguration)

Appelé à partir des classes dérivées pour initialiser la classe SecurityTokenService à l'aide des paramètres de configuration spécifiés.

Propriétés

Principal	Obtient ou définit le principal associé à l'instance actuelle.
Request	Obtient ou définit la demande de jeton de sécurité (RST) associée à l'instance actuelle.
Scope	Obtient ou définit la portée associée à l'instance actuelle.
SecurityTokenDescriptor	Obtient ou définit le SecurityTokenDescriptor associé à l'instance actuelle.
SecurityTokenServiceConfiguration	Obtient l'instance de configuration du propriétaire.

Méthodes

BeginCancel(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object)	En cas de substitution dans une classe dérivée, démarre une demande WS-Trust Cancel asynchrone.
BeginGetOutputClaimsIdentity(ClaimsPrincipal, RequestSecurityToken, Scope, AsyncCallback, Object)	En cas de substitution dans une classe dérivée, lance un appel asynchrone à la méthode de GetOutputClaimsIdentity(ClaimsPrincipal, RequestSecurityToken, Scope).
BeginGetScope(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object)	En cas de substitution dans une classe dérivée, lance un appel asynchrone pour la méthode de GetScope(ClaimsPrincipal, RequestSecurityToken).
BeginIssue(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object)	En cas de substitution dans une classe dérivée, démarre une demande WS-Trust Issue asynchrone.
BeginRenew(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object)	En cas de substitution dans une classe dérivée, démarre une demande WS-Trust Renew asynchrone.
BeginValidate(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object)	En cas de substitution dans une classe dérivée, démarre une demande WS-Trust Validate asynchrone.
Cancel(ClaimsPrincipal, RequestSecurityToken)	En cas de substitution dans une classe dérivée, traite une demande WS-Trust Cancel.
CreateSecurityTokenDescriptor(RequestSecurityToken, Scope)	Crée une instance d'un SecurityTokenDescriptor.
EndCancel(IAsyncResult)	En cas de substitution dans une classe dérivée, met fin à la demande WS-Trust Cancel asynchrone.
EndGetOutputClaimsIdentity(IAsyncResult)	En cas de substitution dans une classe dérivée, met fin à l'appel asynchrone à la méthode BeginGetOutputClaimsIdentity(ClaimsPrincipal, RequestSecurityToken, Scope, AsyncCallback, Object).
EndGetScope(IAsyncResult)	En cas de substitution dans une classe dérivée, met fin à l'appel asynchrone à la méthode BeginGetScope(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object).
EndIssue(IAsyncResult)	En cas de substitution dans une classe dérivée, met fin à la demande WS-Trust Issue asynchrone.
EndRenew(IAsyncResult)	En cas de substitution dans une classe dérivée, met fin à la demande WS-Trust Renew asynchrone.
EndValidate(IAsyncResult)	En cas de substitution dans une classe dérivée, met fin à la demande WS-Trust Validate asynchrone.
Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetIssuerName()	Obtient le nom du service de jeton de sécurité (STS).
GetOutputClaimsIdentity(ClaimsPrincipal, RequestSecurityToken, Scope)	En cas de substitution dans une classe dérivée, cette méthode retourne une collection de sujets de sortie à inclure dans le jeton émis.
GetProofToken(RequestSecurityToken, Scope)	Obtient le jeton de preuve à inclure dans la réponse (RSTR).
GetRequestorProofEncryptingCredentials(RequestSecurityToken)	Obtient les informations d'identification de chiffrement de la preuve du demandeur.
GetResponse(RequestSecurityToken, SecurityTokenDescriptor)	Crée la réponse (RSTR) qui contient le jeton émis à l'aide de la requête spécifiée (RST) et du descripteur de jeton de sécurité.
GetScope(ClaimsPrincipal, RequestSecurityToken)	Obtient un objet Scope qui contient des informations sur la partie de confiance (RP) associée à la demande spécifiée (RST). Vous devez substituer cette méthode dans votre implémentation de la classe de SecurityTokenService.
GetSecurityTokenHandler(String)	Obtient le gestionnaire de jetons de sécurité approprié pour émettre un jeton de sécurité du type spécifié.
GetTokenLifetime(Lifetime)	Obtient la durée de vie du jeton émis.
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
Issue(ClaimsPrincipal, RequestSecurityToken)	Émet un jeton de sécurité.
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
Renew(ClaimsPrincipal, RequestSecurityToken)	En cas de substitution dans une classe dérivée, traite une demande WS-Trust Renew.
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)
Validate(ClaimsPrincipal, RequestSecurityToken)	En cas de substitution dans une classe dérivée, traite une demande WS-Trust Validate.
ValidateRequest(RequestSecurityToken)	Valide la demande de jeton de sécurité (RST) encapsulée par cette instance.

Voir aussi

• Scope
• SecurityTokenServiceConfiguration
• FederatedPassiveSecurityTokenServiceOperations