SecurityTokenService Classe

Riferimento

Definizione

Spazio dei nomi:: System.IdentityModel

Assembly:: System.IdentityModel.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

La classe di base astratta che definisce le proprietà e i metodi del servizio token di sicurezza (STS).

public ref class SecurityTokenService abstract

public abstract class SecurityTokenService

type SecurityTokenService = class

Public MustInherit Class SecurityTokenService

Ereditarietà: Object
SecurityTokenService

Esempio

Gli esempi di codice usati negli SecurityTokenService argomenti sono tratti dall'esempio Custom Token . Questo esempio fornisce classi personalizzate che consentono l'elaborazione di token Web semplici (SWT) e include un'implementazione di un servizio token di sicurezza passivo in grado di gestire un token SWT. Per un esempio di come implementare un servizio token di sicurezza attivo, è possibile visualizzare l'esempio Federation Metadata . Per informazioni su questi esempi e altri esempi disponibili per WIF e su dove scaricarli, vedere Indice di esempio di codice WIF. Il codice seguente illustra l'implementazione di un servizio token di sicurezza passivo usando 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));
            }
        }

    }
}

Il codice seguente illustra come richiamare un servizio token di sicurezza passivo personalizzato per elaborare una richiesta di WS-Federation chiamando il FederatedPassiveSecurityTokenServiceOperations.ProcessRequest(HttpRequest, ClaimsPrincipal, SecurityTokenService, HttpResponse) metodo dal code-behind nel default.aspx.cs file.

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

Commenti

Per creare un servizio token di sicurezza, è necessario derivare dalla SecurityTokenService classe . Nella classe personalizzata è necessario eseguire almeno l'override dei GetScope metodi e GetOutputClaimsIdentity . Con queste sostituzioni, il servizio token di sicurezza creato usando l'implementazione predefinita di tutti gli altri metodi definiti nella classe è in grado di emettere token di sicurezza in risposta alle richieste del token di sicurezza (RST). Ovvero, viene implementata l'associazione Problema definita nella specifica WS-Trust. Questa associazione viene implementata nel Issue metodo . Nessuna delle altre associazioni WS-Trust (Renew, Cancel e Validate) viene implementata nel caso predefinito e viene restituito un errore appropriato al chiamante se viene rilevato un RST che corrisponde a una di queste associazioni. È possibile, naturalmente, eseguire l'override dei metodi appropriati (Renew, Cancele Validate) per implementare queste associazioni nel servizio token di sicurezza.

Importante

L'implementazione di un servizio token di sicurezza pronto per la produzione comporta un'attenta pianificazione e notevoli risorse per attenuare i potenziali rischi di sicurezza correlati all'esposizione di un servizio di questo tipo. La maggior parte degli sviluppatori che usano Windows Identity Foundation (WIF) sta sviluppando applicazioni che esternalizzano la gestione delle identità a un servizio token di sicurezza, anziché sviluppare un servizio token di sicurezza stesso. WIF offre un'estensione di Visual Studio, lo strumento di gestione delle identità e dell'accesso per Visual Studio 2012, per aiutare gli sviluppatori a testare le soluzioni nell'ambiente di sviluppo. Questo strumento include un servizio token di sicurezza, LocalSTS, che è possibile configurare per gestire attestazioni specifiche per l'applicazione in fase di sviluppo. Per altre informazioni sullo strumento Identity and Access, vedere Identity and Access Tool per Visual Studio 2012. In alcuni scenari, LocalSTS potrebbe non fornire le funzionalità necessarie per testare adeguatamente l'applicazione, ad esempio in uno scenario che prevede lo sviluppo di un gestore di token personalizzato da usare da un'applicazione. In questi casi, è possibile derivare da SecurityTokenService per creare uno o più servizi token di sicurezza semplici che possono essere distribuiti nell'ambiente di sviluppo e che possono essere usati per testare tali funzionalità nell'applicazione. La parte restante di questa sezione è incentrata sui metodi esposti dalla SecurityTokenService classe che consentono di implementare un servizio token di sicurezza semplice ed estendere la pipeline di rilascio dei token.

L'elenco seguente offre una breve panoramica dei metodi di importanza primaria per lo sviluppatore per l'uso in un ambiente di test o sviluppo.

Metodo GetScope . Questo metodo restituisce un Scope oggetto che contiene informazioni sul punto di ripristino. Questo oggetto viene usato nella parte restante della pipeline di rilascio dei token e include informazioni sulla firma e la crittografia delle credenziali da usare nella risposta, nonché gli AppliesTo indirizzi e ReplyTo (se necessario). È necessario eseguire l'override di questo metodo.
Metodo GetOutputClaimsIdentity . Questo metodo restituisce un ClaimsIdentity oggetto che contiene le attestazioni da restituire al punto di ripristino. È necessario eseguire l'override di questo metodo.
Metodo Issue . Questo metodo implementa la pipeline di richiesta di token, che elabora una richiesta di token di sicurezza in ingresso (RST) e restituisce una risposta (RSTR) al chiamante che contiene un token che può essere usato per l'autenticazione con un punto di ripristino. Molti degli altri metodi definiti nella SecurityTokenService classe vengono chiamati da questo metodo, inclusi i GetScope metodi e GetOutputClaimsIdentity . Non è necessario eseguire l'override di questo metodo, ma può essere utile conoscere la pipeline di richiesta di token implementata.

Un servizio token di sicurezza viene configurato tramite la SecurityTokenServiceConfiguration classe .

Note per gli implementatori

È necessario eseguire l'override GetScope(ClaimsPrincipal, RequestSecurityToken) dei metodi e GetOutputClaimsIdentity(ClaimsPrincipal, RequestSecurityToken, Scope) .

Costruttori

SecurityTokenService(SecurityTokenServiceConfiguration)

Chiamato dalle classi derivate per inizializzare la classe di SecurityTokenService utilizzando le impostazioni di configurazione specificate.

Proprietà

Principal	Ottiene o imposta l'oggetto principale associato all'istanza corrente.
Request	Ottiene o imposta la richiesta del token di sicurezza associato all'istanza corrente.
Scope	Ottiene o imposta l'ambito associato all'istanza corrente.
SecurityTokenDescriptor	Ottiene o imposta SecurityTokenDescriptor associati all'istanza corrente.
SecurityTokenServiceConfiguration	Ottiene l'istanza di configurazione del proprietario.

Metodi

BeginCancel(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object)	Una volta eseguito l'override in una classe derivata, avvia una richiesta di annullamento WS-Trust asincrona.
BeginGetOutputClaimsIdentity(ClaimsPrincipal, RequestSecurityToken, Scope, AsyncCallback, Object)	Una volta sottoposto a override in una classe derivata, inizia la chiamata asincrona al metodo GetOutputClaimsIdentity(ClaimsPrincipal, RequestSecurityToken, Scope).
BeginGetScope(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object)	Una volta sottoposto a override in una classe derivata, inizia la chiamata asincrona del metodo GetScope(ClaimsPrincipal, RequestSecurityToken).
BeginIssue(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object)	Una volta eseguito l'override in una classe derivata, avvia una richiesta di problema WS-Trust asincrona.
BeginRenew(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object)	Una volta eseguito l'override in una classe derivata, avvia una richiesta di rinnovo WS-Trust asincrona.
BeginValidate(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object)	Una volta eseguito l'override in una classe derivata, avvia una richiesta di convalida WS-Trust asincrona.
Cancel(ClaimsPrincipal, RequestSecurityToken)	Una volta eseguito l'override in una classe derivata, elabora una richiesta di annullamento WS-Trust.
CreateSecurityTokenDescriptor(RequestSecurityToken, Scope)	Crea un'istanza di un oggetto SecurityTokenDescriptor.
EndCancel(IAsyncResult)	Una volta eseguito l'override in una classe derivata, completa la richiesta di annullamento WS-Trust asincrona.
EndGetOutputClaimsIdentity(IAsyncResult)	Una volta eseguito l'override in una classe derivata, complete la chiamata asincrona nel metodo BeginGetOutputClaimsIdentity(ClaimsPrincipal, RequestSecurityToken, Scope, AsyncCallback, Object).
EndGetScope(IAsyncResult)	Una volta eseguito l'override in una classe derivata, complete la chiamata asincrona nel metodo BeginGetScope(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object).
EndIssue(IAsyncResult)	Una volta eseguito l'override in una classe derivata, completa la richiesta di problema WS-Trust asincrona.
EndRenew(IAsyncResult)	Una volta eseguito l'override in una classe derivata, completa la richiesta di rinnovamento WS-Trust asincrona.
EndValidate(IAsyncResult)	Una volta eseguito l'override in una classe derivata, completa la richiesta di convalida WS-Trust asincrona.
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetIssuerName()	Ottiene il nome del servizio token di sicurezza.
GetOutputClaimsIdentity(ClaimsPrincipal, RequestSecurityToken, Scope)	Una volta eseguito l'override in una classe derivata, questo metodo restituisce una raccolta di oggetti di output da includere nel token emesso.
GetProofToken(RequestSecurityToken, Scope)	Ottiene il token di prova da includere nella risposta (RSTR).
GetRequestorProofEncryptingCredentials(RequestSecurityToken)	Ottiene le credenziali di crittografia di prova del richiedente.
GetResponse(RequestSecurityToken, SecurityTokenDescriptor)	Crea la risposta (RSTR) che contiene il token rilasciato utilizzando il descrittore specificato della richiesta (RST) e del token di sicurezza.
GetScope(ClaimsPrincipal, RequestSecurityToken)	Ottiene un oggetto Scope contenente informazioni sul relying party (RP) associato alla richiesta specificata (RST). È necessario eseguire l'override di questo metodo nell'implementazione della classe SecurityTokenService.
GetSecurityTokenHandler(String)	Ottiene il gestore di token di sicurezza appropriato per l'emissione di un token di sicurezza per il tipo specificato.
GetTokenLifetime(Lifetime)	Ottiene la durata per il token emesso.
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
Issue(ClaimsPrincipal, RequestSecurityToken)	Rilascia un token di sicurezza.
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
Renew(ClaimsPrincipal, RequestSecurityToken)	Una volta eseguito l'override in una classe derivata, elabora una richiesta di rinnovamento WS-Trust.
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)
Validate(ClaimsPrincipal, RequestSecurityToken)	Una volta eseguito l'override in una classe derivata, elabora una richiesta di convalida WS-Trust.
ValidateRequest(RequestSecurityToken)	Convalida la richiesta del token di sicurezza (RST) incapsulata da questa istanza.

Si applica a

Condividi tramite