RequestSecurityToken Classe

Definição

public ref class RequestSecurityToken : System::IdentityModel::Protocols::WSTrust::WSTrustMessage

public class RequestSecurityToken : System.IdentityModel.Protocols.WSTrust.WSTrustMessage

type RequestSecurityToken = class
    inherit WSTrustMessage

Public Class RequestSecurityToken
Inherits WSTrustMessage

Herança

Object

OpenObject

WSTrustMessage

RequestSecurityToken

Exemplos

O exemplo de código utilizado neste tópico é retirado da Custom Token amostra. Este exemplo fornece classes personalizadas que permitem o processamento de Simples Web Tokens (SWT) e inclui uma implementação de um STS passivo capaz de servir um token SWT. O STS é implementado por uma classe derivada de SecurityTokenService. Muitos dos métodos da SecurityTokenService classe que são chamados do seu pipeline de emissão de tokens aceitam um RequestSecurityToken objeto como um dos seus parâmetros. Para informações sobre esta amostra e outras amostras disponíveis para WIF e sobre onde as descarregar, consulte o Índice de Exemplos de Código WIF.

O exemplo de código seguinte mostra uma implementação do SecurityTokenService.GetScope método. O método toma a RequestSecurityToken como um dos seus parâmetros e as propriedades desse parâmetro são usadas para definir propriedades no Scope objeto que é devolvido pelo método.

// 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/";

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

Observações

O elemento wst:RequestSecurityToken (mensagem) contém os parâmetros e propriedades usados para solicitar um token de segurança a um serviço de token de segurança (STS). A mensagem (ou elemento) é abreviada como RST. A RequestSecurityToken classe contém propriedades que representam os elementos da RST. Um RST pode formar um pedido que corresponda a qualquer uma das vinculações de pedido definidas pelo WS-Trust; por exemplo, a ligação Emissão, a vinculação Renovação, a vinculação Validar ou a vinculação Cancelar. Muitas das propriedades da RequestSecurityToken classe correspondem a elementos que estão presentes apenas em tipos específicos de pedidos, conforme definido por estas ligações. Dependendo do tipo de pedido que um determinado RequestSecurityToken objeto representa ou dos parâmetros presentes no pedido específico que representa, algumas propriedades do objeto podem ser null.

O STS devolve uma resposta ao pedido numa mensagem que contém um elemento wst:RequestSecurityTokenResponse (RSTR). Esta mensagem é representada pela RequestSecurityTokenResponse classe.

Para mais informações sobre o elemento que esta classe representa, consulte a especificação WS-Trust aplicável ao seu cenário: WS-Trust fevereiro de 2005, WS-Trust 1.3 ou WS-Trust 1.4.

Ver também

• SecurityTokenService
• RequestedSecurityToken
• RequestSecurityTokenResponse