RequestSecurityToken Klass

Definition

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

Arv

Object

OpenObject

WSTrustMessage

RequestSecurityToken

Exempel

Kodexemplet som används i det här avsnittet tas från Custom Token exemplet. Det här exemplet innehåller anpassade klasser som möjliggör bearbetning av enkla webbtoken (SWT) och innehåller en implementering av en passiv STS som kan hantera en SWT-token. STS implementeras av en klass som härleds från SecurityTokenService. Många av metoderna i SecurityTokenService klassen som anropas från dess tokenutfärdningspipeline tar ett objekt som ett RequestSecurityToken om deras parametrar. Information om det här exemplet och andra exempel som är tillgängliga för WIF och var du kan ladda ned dem finns i WIF Code Sample Index.

I följande kodexempel visas en implementering av SecurityTokenService.GetScope metoden. Metoden tar en RequestSecurityToken som en av dess parametrar och egenskaperna för den här parametern används för att ange egenskaper för objektet Scope som returneras av metoden.

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

Kommentarer

Elementet wst:RequestSecurityToken (meddelande) innehåller de parametrar och egenskaper som används för att begära en säkerhetstoken från en säkerhetstokentjänst (STS). Meddelandet (eller elementet) förkortas som RST. Klassen RequestSecurityToken innehåller egenskaper som representerar elementen i RST. En RST kan bilda en begäran som motsvarar någon av de begärandebindningar som definieras av WS-Trust. Till exempel utfärdandebindningen, förnyelsebindningen, Verifieringsbindningen eller Avbryt bindningen. Många av egenskaperna i RequestSecurityToken klassen motsvarar element som endast finns i specifika typer av begäranden enligt definitionen i dessa bindningar. Beroende på vilken typ av begäran ett visst RequestSecurityToken objekt representerar eller parametrarna som finns i den specifika begäran som det representerar, kan vissa egenskaper för objektet vara null.

STS returnerar ett svar på begäran i ett meddelande som innehåller ett WST:RequestSecurityTokenResponse-element (RSTR). Det här meddelandet representeras av RequestSecurityTokenResponse klassen.

Mer information om elementet som den här klassen representerar finns i WS-Trust specifikation som gäller för ditt scenario: WS-Trust februari 2005, WS-Trust 1.3 eller WS-Trust 1.4.

Se även

• SecurityTokenService
• RequestedSecurityToken
• RequestSecurityTokenResponse