RequestSecurityToken Klas

Definitie

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

Overname

Object

OpenObject

WSTrustMessage

RequestSecurityToken

Voorbeelden

Het codevoorbeeld dat in dit onderwerp wordt gebruikt, wordt uit het Custom Token voorbeeld genomen. Dit voorbeeld biedt aangepaste klassen die verwerking van Eenvoudige webtokens (SWT) mogelijk maken en bevat een implementatie van een passieve STS die een SWT-token kan leveren. De STS wordt geïmplementeerd door een klasse die is afgeleid van SecurityTokenService. Veel van de methoden van de klasse die worden aangeroepen vanuit de SecurityTokenService tokenuitgiftepijplijn, nemen een RequestSecurityToken object als één als hun parameters. Zie de WIF-codevoorbeeldindex voor informatie over dit voorbeeld en andere voorbeelden die beschikbaar zijn voor WIF en waar u ze kunt downloaden.

In het volgende codevoorbeeld ziet u een implementatie van de SecurityTokenService.GetScope methode. De methode gebruikt een RequestSecurityToken van de parameters en eigenschappen van deze parameter om eigenschappen in te stellen voor het Scope object dat door de methode wordt geretourneerd.

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

Opmerkingen

Het element wst:RequestSecurityToken (bericht) bevat de parameters en eigenschappen die worden gebruikt om een beveiligingstoken aan te vragen bij een beveiligingstokenservice (STS). Het bericht (of element) wordt afgekort als RST. De RequestSecurityToken klasse bevat eigenschappen die de elementen van de RST vertegenwoordigen. Een RST kan een aanvraag vormen die overeenkomt met een van de aanvraagbindingen die zijn gedefinieerd door WS-Trust; Bijvoorbeeld de uitgiftebinding, de verlengingsbinding, de binding Valideren of de binding Annuleren. Veel van de eigenschappen in de RequestSecurityToken klasse komen overeen met elementen die alleen aanwezig zijn in specifieke soorten aanvragen, zoals gedefinieerd door deze bindingen. Afhankelijk van het soort aanvraag dat een bepaald RequestSecurityToken object vertegenwoordigt of de parameters die aanwezig zijn in de specifieke aanvraag die het voorstelt, kunnen sommige eigenschappen van het object zijn null.

De STS retourneert een antwoord op de aanvraag in een bericht dat een wst:RequestSecurityTokenResponse-element (RSTR) bevat. Dit bericht wordt vertegenwoordigd door de RequestSecurityTokenResponse klasse.

Zie de WS-Trust specificatie die van toepassing is op uw scenario voor meer informatie over het element dat deze klasse voorstelt: WS-Trust februari 2005, WS-Trust 1.3 of WS-Trust 1.4.

Zie ook

• SecurityTokenService
• RequestedSecurityToken
• RequestSecurityTokenResponse