SecurityTokenService Clase
Definición
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
La clase base abstracta que define las propiedades y los métodos de un servicio de token de seguridad (STS).
public ref class SecurityTokenService abstractpublic abstract class SecurityTokenServicetype SecurityTokenService = classPublic MustInherit Class SecurityTokenService- Herencia
-
SecurityTokenService
Ejemplos
Los ejemplos de código que se usan en los SecurityTokenService temas se toman del Custom Token ejemplo. En este ejemplo se proporcionan clases personalizadas que permiten el procesamiento de tokens web simples (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 sobre dónde descargarlos, consulte Índice de ejemplo de código WIF. En el código siguiente se muestra la implementación de un STS pasivo mediante la SecurityTokenService clase .
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));
}
}
}
}
En el código siguiente se muestra cómo invocar un STS pasivo personalizado para procesar una solicitud de WS-Federation llamando al 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 );
}
}
}
Comentarios
Para crear un STS, debe derivar de la SecurityTokenService clase . En la clase personalizada, debe, como mínimo, invalidar los GetScope métodos y GetOutputClaimsIdentity . Con estas invalidaciones, el STS creado con la implementación predeterminada de todos los demás métodos definidos en la clase es capaz de emitir tokens de seguridad en respuesta a las solicitudes de token de seguridad (RST). Es decir, se implementa el enlace Issue definido en la especificación WS-Trust. Este enlace se implementa en el Issue método . Ninguno de los demás enlaces de WS-Trust (Renovar, Cancelar y Validar) se implementa en el caso predeterminado y se devuelve un error adecuado al autor de la llamada si se encuentra un RST que corresponde a uno de estos enlaces. Por supuesto, puede invalidar los métodos adecuados (Renew, Cancely Validate) para implementar estos enlaces en el STS.
Importante
La implementación de un STS listo para producción implica una planificación cuidadosa y recursos considerables para mitigar los posibles riesgos de seguridad inherentes a la exposición de este tipo de servicio. La mayoría de los desarrolladores que usan Windows Identity Foundation (WIF) desarrollarán aplicaciones que externalicen la administración de identidades a un STS, en lugar de desarrollar un STS. WIF proporciona una extensión de Visual Studio, la Herramienta de identidad y acceso para Visual Studio 2012, para ayudar a los desarrolladores a probar soluciones en el entorno de desarrollo. Esta herramienta incluye un STS, LocalSTS, que puede configurar para atender notificaciones específicas a la aplicación que está desarrollando. Para obtener más información sobre la herramienta Identidad y acceso, vea Identity and Access Tool for Visual Studio 2012( Herramienta de identidad y acceso para Visual Studio 2012). En algunos escenarios, LocalSTS es posible que no proporcione la funcionalidad necesaria para probar adecuadamente la aplicación; por ejemplo, en un escenario que implique el desarrollo de un controlador de tokens personalizado para su uso por parte de una aplicación. En estos casos, puede derivar de SecurityTokenService para crear uno o varios STS simples que se pueden implementar en el entorno de desarrollo y que se pueden usar para probar estas características en 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 se proporciona una breve introducción a los métodos de importancia principal para el desarrollador para su uso en un entorno de prueba o desarrollo.
El método GetScope . Este método devuelve un Scope objeto que contiene información sobre el RP. Este objeto se usa en el resto de la canalización de emisión de tokens e incluye información sobre la firma y el cifrado de credenciales que se usarán en la respuesta, así como las
AppliesTodirecciones yReplyTo(si es necesario). Debe invalidar este método.El método GetOutputClaimsIdentity . Este método devuelve un ClaimsIdentity objeto que contiene las notificaciones para volver al RP. Debe invalidar este método.
El método Issue . Este método implementa la canalización de solicitudes de token, que procesa una solicitud de token de seguridad entrante (RST) y devuelve una respuesta (RSTR) al autor de la llamada que contiene un token que se puede usar para autenticarse con un RP. Se llama a muchos de los otros métodos definidos en la SecurityTokenService clase desde este método, incluidos los GetScope métodos y GetOutputClaimsIdentity . No es necesario invalidar este método, pero comprender la canalización de solicitud de token que implementa puede resultar útil.
Un STS se configura a través de la SecurityTokenServiceConfiguration clase .
Notas a los implementadores
Debe invalidar los GetScope(ClaimsPrincipal, RequestSecurityToken) métodos y GetOutputClaimsIdentity(ClaimsPrincipal, RequestSecurityToken, Scope) .
Constructores
| SecurityTokenService(SecurityTokenServiceConfiguration) |
Llamado desde las clases derivadas para inicializar la clase SecurityTokenService mediante las opciones de configuración especificadas. |
Propiedades
| Principal |
Obtiene o establece la entidad de seguridad adjuntada a la instancia actual. |
| Request |
Obtiene y establece la solicitud de token de seguridad (RST) con la instancia actual. |
| Scope |
Obtiene o establece el ámbito asociado a la instancia actual. |
| SecurityTokenDescriptor |
Obtiene o establece la SecurityTokenDescriptor adjuntada a la instancia actual. |
| SecurityTokenServiceConfiguration |
Obtiene la instancia de configuración del propietario. |
Métodos
| BeginCancel(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object) |
Cuando se reemplaza en una clase derivada, comienza una solicitud asincrónica de WS-Trust Cancel. |
| BeginGetOutputClaimsIdentity(ClaimsPrincipal, RequestSecurityToken, Scope, AsyncCallback, Object) |
Cuando se invalida en una clase derivada, comienza una llamada asincrónica para el método GetOutputClaimsIdentity(ClaimsPrincipal, RequestSecurityToken, Scope). |
| BeginGetScope(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object) |
Cuando se invalida en una clase derivada, comienza una llamada asincrónica para el método GetScope(ClaimsPrincipal, RequestSecurityToken). |
| BeginIssue(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object) |
Cuando se reemplaza en una clase derivada, comienza una solicitud asincrónica de WS-Trust Issue. |
| BeginRenew(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object) |
Cuando se reemplaza en una clase derivada, comienza una solicitud asincrónica de WS-Trust Renew. |
| BeginValidate(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object) |
Cuando se reemplaza en una clase derivada, comienza una solicitud asincrónica de WS-Trust Validate. |
| Cancel(ClaimsPrincipal, RequestSecurityToken) |
Cuando se reemplaza en una clase derivada, procesa una solicitud WS-Trust Cancel. |
| CreateSecurityTokenDescriptor(RequestSecurityToken, Scope) |
Crea una instancia de SecurityTokenDescriptor. |
| EndCancel(IAsyncResult) |
Cuando se reemplaza en una clase derivada, completa la solicitud asincrónica de WS-Trust Cancel. |
| EndGetOutputClaimsIdentity(IAsyncResult) |
Cuando se invalida en una clase derivada, completa la llamada asincrónica para el método BeginGetOutputClaimsIdentity(ClaimsPrincipal, RequestSecurityToken, Scope, AsyncCallback, Object). |
| EndGetScope(IAsyncResult) |
Cuando se invalida en una clase derivada, completa la llamada asincrónica para el método BeginGetScope(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object). |
| EndIssue(IAsyncResult) |
Cuando se reemplaza en una clase derivada, completa la solicitud asincrónica de WS-Trust Issue. |
| EndRenew(IAsyncResult) |
Cuando se reemplaza en una clase derivada, completa la solicitud asincrónica de WS-Trust Renew. |
| EndValidate(IAsyncResult) |
Cuando se reemplaza en una clase derivada, completa la solicitud asincrónica de WS-Trust Validate. |
| Equals(Object) |
Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object) |
| GetHashCode() |
Sirve como la función hash predeterminada. (Heredado de Object) |
| GetIssuerName() |
Obtiene el nombre del servicio de token de seguridad (STS). |
| GetOutputClaimsIdentity(ClaimsPrincipal, RequestSecurityToken, Scope) |
Cuando se reemplaza en una clase derivada, este método devuelve una colección de asuntos de salida que se incluirán en el token emitido. |
| GetProofToken(RequestSecurityToken, Scope) |
Obtiene el token de prueba que se incluirá en la respuesta (RSTR). |
| GetRequestorProofEncryptingCredentials(RequestSecurityToken) |
Obtiene las credenciales de cifrado de prueba del solicitante. |
| GetResponse(RequestSecurityToken, SecurityTokenDescriptor) |
Crea la respuesta (RSTR) que contiene el token emitido mediante la solicitud especificada (RST) y el descriptor del token de seguridad. |
| GetScope(ClaimsPrincipal, RequestSecurityToken) |
Obtiene un objeto Scope que contiene información sobre el usuario de confianza (RP) asociado a la solicitud especificada (RST). Debe reemplazar este método en la implementación de la clase SecurityTokenService. |
| GetSecurityTokenHandler(String) |
Obtiene el controlador adecuado de token de seguridad para emitir un token de seguridad del tipo especificado. |
| GetTokenLifetime(Lifetime) |
Obtiene la información de duración del token emitido. |
| GetType() |
Obtiene el Type de la instancia actual. (Heredado de Object) |
| Issue(ClaimsPrincipal, RequestSecurityToken) |
Emite un token de seguridad. |
| MemberwiseClone() |
Crea una copia superficial del Object actual. (Heredado de Object) |
| Renew(ClaimsPrincipal, RequestSecurityToken) |
Cuando se reemplaza en una clase derivada, procesa una solicitud WS-Trust Renew. |
| ToString() |
Devuelve una cadena que representa el objeto actual. (Heredado de Object) |
| Validate(ClaimsPrincipal, RequestSecurityToken) |
Cuando se reemplaza en una clase derivada, procesa una solicitud WS-Trust Validate. |
| ValidateRequest(RequestSecurityToken) |
Valida la solicitud de token de seguridad (RST) encapsulada por esta instancia. |
Se aplica a
Consulte también
Comentarios
Próximamente: A lo largo de 2024 iremos eliminando gradualmente GitHub Issues como mecanismo de comentarios sobre el contenido y lo sustituiremos por un nuevo sistema de comentarios. Para más información, vea: https://aka.ms/ContentUserFeedback.
Enviar y ver comentarios de