Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Clase SecurityTokenService

.NET Framework (current version)
 

Publicado: octubre de 2016

La clase base abstracta que define las propiedades y métodos de un servicio de token de seguridad (STS).

Espacio de nombres:   System.IdentityModel
Ensamblado:  System.IdentityModel (en System.IdentityModel.dll)

System.Object
  System.IdentityModel.SecurityTokenService

public abstract class SecurityTokenService

NombreDescripción
System_CAPS_protmethodSecurityTokenService(SecurityTokenServiceConfiguration)

Llamar desde clases derivadas para inicializar la SecurityTokenService clase utilizando la configuración especificada.

NombreDescripción
System_CAPS_pubpropertyPrincipal

Obtiene o establece la entidad de seguridad asociado a la instancia actual.

System_CAPS_pubpropertyRequest

Obtiene o establece la solicitud de token de seguridad (RST) asociada a la instancia actual.

System_CAPS_pubpropertyScope

Obtiene o establece el ámbito asociado con la instancia actual.

System_CAPS_protpropertySecurityTokenDescriptor

Obtiene o establece el SecurityTokenDescriptor asociado a la instancia actual.

System_CAPS_pubpropertySecurityTokenServiceConfiguration

Obtiene al propietario de la instancia de configuración.

NombreDescripción
System_CAPS_pubmethodBeginCancel(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object)

Cuando se invalida en una clase derivada, inicia una solicitud asincrónica de WS-Trust Cancelar.

System_CAPS_protmethodBeginGetOutputClaimsIdentity(ClaimsPrincipal, RequestSecurityToken, Scope, AsyncCallback, Object)

Cuando se invalida en una clase derivada, comienza una llamada asincrónica a la GetOutputClaimsIdentity (método).

System_CAPS_protmethodBeginGetScope(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object)

Cuando se invalida en una clase derivada, comienza una llamada asincrónica para el GetScope (método).

System_CAPS_pubmethodBeginIssue(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object)

Cuando se invalida en una clase derivada, inicia una solicitud asincrónica de problema de WS-Trust.

System_CAPS_pubmethodBeginRenew(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object)

Cuando se invalida en una clase derivada, inicia una solicitud asincrónica de renovación de WS-Trust.

System_CAPS_pubmethodBeginValidate(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object)

Cuando se invalida en una clase derivada, inicia una solicitud asincrónica de validación de WS-Trust.

System_CAPS_pubmethodCancel(ClaimsPrincipal, RequestSecurityToken)

Cuando se invalida en una clase derivada, procesa una solicitud de WS-Trust Cancelar.

System_CAPS_protmethodCreateSecurityTokenDescriptor(RequestSecurityToken, Scope)

Crea una instancia de un SecurityTokenDescriptor.

System_CAPS_pubmethodEndCancel(IAsyncResult)

Cuando se invalida en una clase derivada, finaliza la solicitud asincrónica de WS-Trust Cancelar.

System_CAPS_protmethodEndGetOutputClaimsIdentity(IAsyncResult)

Cuando se invalida en una clase derivada, finaliza la llamada asincrónica a la BeginGetOutputClaimsIdentity (método).

System_CAPS_protmethodEndGetScope(IAsyncResult)

Cuando se invalida en una clase derivada, finaliza la llamada asincrónica a la BeginGetScope (método).

System_CAPS_pubmethodEndIssue(IAsyncResult)

Cuando se invalida en una clase derivada, finaliza la solicitud asincrónica de problema de WS-Trust.

System_CAPS_pubmethodEndRenew(IAsyncResult)

Cuando se invalida en una clase derivada, finaliza la solicitud asincrónica de renovación de WS-Trust.

System_CAPS_pubmethodEndValidate(IAsyncResult)

Cuando se invalida en una clase derivada, finaliza la solicitud asincrónica de validación de WS-Trust.

System_CAPS_pubmethodEquals(Object)

Determina si el objeto especificado es igual al objeto actual.(Heredado de Object).

System_CAPS_protmethodFinalize()

Permite que un objeto intente liberar recursos y realizar otras operaciones de limpieza antes de ser reclamado por el recolector de basura. (Heredado de Object).

System_CAPS_pubmethodGetHashCode()

Sirve como la función hash predeterminada.(Heredado de Object).

System_CAPS_protmethodGetIssuerName()

Obtiene el nombre del servicio de token de seguridad (STS).

System_CAPS_protmethodGetOutputClaimsIdentity(ClaimsPrincipal, RequestSecurityToken, Scope)

Cuando se invalida en una clase derivada, este método devuelve una colección de asuntos de salida que se incluirán en el token emitido.

System_CAPS_protmethodGetProofToken(RequestSecurityToken, Scope)

Obtiene el token de prueba que se incluirán en la respuesta (RSTR).

System_CAPS_protmethodGetRequestorProofEncryptingCredentials(RequestSecurityToken)

Obtiene la prueba del solicitante cifrar las credenciales.

System_CAPS_protmethodGetResponse(RequestSecurityToken, SecurityTokenDescriptor)

Crea la respuesta (RSTR) que contiene el token emitido con la solicitud especificada (RST) y el descriptor de seguridad del token.

System_CAPS_protmethodGetScope(ClaimsPrincipal, RequestSecurityToken)

Obtiene un Scope objeto que contiene información sobre el usuario de confianza (RP) asociado a la solicitud especificada (RST). Debe invalidar este método en su implementación de la SecurityTokenService clase.

System_CAPS_protmethodGetSecurityTokenHandler(String)

Obtiene el controlador de token de seguridad adecuado para la emisión de un token de seguridad del tipo especificado.

System_CAPS_protmethodGetTokenLifetime(Lifetime)

Obtiene la duración del token emitido.

System_CAPS_pubmethodGetType()

Obtiene el Type de la instancia actual.(Heredado de Object).

System_CAPS_pubmethodIssue(ClaimsPrincipal, RequestSecurityToken)

Emite un token de seguridad.

System_CAPS_protmethodMemberwiseClone()

Crea una copia superficial del Object actual.(Heredado de Object).

System_CAPS_pubmethodRenew(ClaimsPrincipal, RequestSecurityToken)

Cuando se invalida en una clase derivada, procesa una solicitud de renovación de WS-Trust.

System_CAPS_pubmethodToString()

Devuelve una cadena que representa al objeto actual. (Heredado de Object).

System_CAPS_pubmethodValidate(ClaimsPrincipal, RequestSecurityToken)

Cuando se invalida en una clase derivada, procesa una solicitud de WS-Trust validar.

System_CAPS_protmethodValidateRequest(RequestSecurityToken)

Valida la solicitud de token de seguridad (RST) encapsulada por esta instancia.

Para crear un STS debe derivar de la SecurityTokenService clase. En la clase personalizada debe, como mínimo, invalidar el GetScope y GetOutputClaimsIdentity métodos. Con estas invalidaciones, es capaz de emitir tokens de seguridad en respuesta a la seguridad (RST) de las solicitudes de token STS creado mediante la implementación predeterminada de todos los demás métodos definidos en la clase. Es decir, se implementa el enlace de problema definido en la especificación WS-Trust. Este enlace se implementa en el Issue (método). Ninguno de los otros enlaces de WS-Trust (renovar, Cancelar y validar) se implementan en el caso predeterminado y se devuelve un error adecuado al llamador si se encuentra una RST que corresponde a uno de estos enlaces. Por supuesto, puede invalidar los métodos adecuados (Renew, Cancel, y Validate) para implementar estos enlaces en su STS.

System_CAPS_importantImportante

Implementación de un STS listo para producción conlleva una cuidadosa planeación y recursos considerables para mitigar los posibles riesgos de seguridad inherentes a exponer este tipo de servicio. Mayoría de los desarrolladores con Windows Identity Foundation (WIF) se pueden desarrollar aplicaciones que externalizar la administración de identidades a un STS, en lugar de desarrollar a un STS propio. WIF proporciona una extensión de Visual Studio, la herramienta de identidades y acceso para Visual Studio 2012, para ayudar a los desarrolladores probar soluciones en el entorno de desarrollo. Esta herramienta incluye un STS, LocalSTS, que se pueden configurar para servir notificaciones específicas a la aplicación que está desarrollando. Para obtener más información acerca de la herramienta de identidades y acceso, consulte Identity and Access Tool para Visual Studio 2012. En algunos escenarios, LocalSTS no se puede proporcionar la funcionalidad necesaria para probar la aplicación de forma adecuada; por ejemplo, en un escenario que implica desarrollar un controlador de token personalizado para su uso por una aplicación. En estos casos, puede derivar de SecurityTokenService para crear uno o más STS simples que puede implementarse en el entorno de desarrollo y que se puede utilizar para probar las características de la aplicación. El resto de esta sección se centra en los métodos expuestos por la SecurityTokenService clase que le permiten implementar un STS simple y ampliar la canalización de emisión de tokens.

En la lista siguiente proporciona una breve descripción de los métodos de importancia para el desarrollador para su uso en un entorno de prueba o desarrollo.

  • Método GetScope. Este método devuelve un Scope objeto que contiene información sobre el punto de reunión. Este objeto se utiliza en el resto de la canalización de emisión de tokens e incluye información acerca de la firma y cifrado de credenciales para usar en la respuesta, así como el AppliesTo y ReplyTo (si es necesario) las direcciones. Debe invalidar este método.

  • Método GetOutputClaimsIdentity. Este método devuelve un ClaimsIdentity objeto que contiene las notificaciones para volver al punto de reunión. Debe invalidar este método.

  • Método Issue. Este método implementa la canalización de solicitud de token, que se procesa una solicitud de token de seguridad de entrada (RST) y devuelve una respuesta (RSTR) para el llamador que contiene un token que se puede utilizar para autenticar con un punto de reunión. Muchos de los otros métodos definidos en la SecurityTokenService clase se llaman desde este método, incluidos los GetScope y GetOutputClaimsIdentity métodos. No es necesario invalidar este método, pero una comprensión de la canalización de solicitud de token que se implementa puede resultar útil.

Un STS se configura mediante la SecurityTokenServiceConfiguration clase.

Notas para desarrolladores de herederos:

Es necesario reemplazar ambos el GetScope y el GetOutputClaimsIdentitymétodos.

Los ejemplos de código que se usan en el SecurityTokenService temas se toman de la Custom Token ejemplo. Este ejemplo proporciona las clases personalizadas que permitan el procesamiento de Tokens de Web Simple (SWT) e incluye una implementación de un STS pasivo que es capaz de atender un token SWT. Para obtener un ejemplo de cómo implementar un STS activo, puede ver el Federation Metadata ejemplo. Para obtener información sobre estos ejemplos y otros ejemplos disponibles para WIF y dónde descargarlas, consulte índice de ejemplo de código WIF. El siguiente código muestra la implementación de un STS pasivo utilizando la SecurityTokenService clase.

using System;
using System.Collections.Generic;
using System.IdentityModel;
using System.IdentityModel.Configuration;
using System.IdentityModel.Protocols.WSTrust;
using System.IdentityModel.Tokens;
using System.Linq;
using System.Security.Claims;
using System.Security.Cryptography.X509Certificates;
using System.Security.Principal;

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


    }
}

El código siguiente muestra cómo invocar un STS personalizado pasivo para procesar una solicitud de WS-Federation llamando el FederatedPassiveSecurityTokenServiceOperations.ProcessRequest(HttpRequest, ClaimsPrincipal, SecurityTokenService, HttpResponse) método desde el código subyacente en el default.aspx.cs archivo.

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

.NET Framework
Disponible desde 4.5

Cualquier miembro ( Compartido en Visual Basic) estático público de este tipo es seguro para subprocesos. No se garantiza que los miembros de instancia sean seguros para subprocesos.

Volver al principio
Mostrar: