SecurityTokenService Třída

Reference

Definice

Obor názvů:: System.IdentityModel

Sestavení:: System.IdentityModel.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Abstraktní základní třída, která definuje vlastnosti a metody služby tokenů zabezpečení (STS).

public ref class SecurityTokenService abstract

public abstract class SecurityTokenService

type SecurityTokenService = class

Public MustInherit Class SecurityTokenService

Dědičnost: Object
SecurityTokenService

Příklady

Příklady kódu, které se používají v tématech SecurityTokenService , jsou převzaty z ukázky Custom Token . Tato ukázka poskytuje vlastní třídy, které umožňují zpracování jednoduchých webových tokenů (SWT), a obsahuje implementaci pasivního tokenu STS, který je schopen obsluhovat token SWT. Příklad implementace aktivní služby STS najdete v ukázce Federation Metadata . Informace o těchto ukázkách a dalších ukázkách dostupných pro WIF a o tom, kde je stáhnout, najdete v tématu Index ukázek kódu WIF. Následující kód ukazuje implementaci pasivní služby STS pomocí SecurityTokenService třídy .

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

    }
}

Následující kód ukazuje, jak vyvolat vlastní pasivní stS pro zpracování požadavku WS-Federation voláním FederatedPassiveSecurityTokenServiceOperations.ProcessRequest(HttpRequest, ClaimsPrincipal, SecurityTokenService, HttpResponse) metody z kódu v default.aspx.cs souboru.

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

Poznámky

Chcete-li vytvořit služby STS, musíte odvodit z SecurityTokenService třídy . Ve vlastní třídě musíte alespoň přepsat GetScope metody a GetOutputClaimsIdentity . S těmito přepsáním je služba ZABEZPEČENÍ vytvořená pomocí výchozí implementace všech ostatních metod definovaných ve třídě schopna vydávat tokeny zabezpečení v reakci na požadavky tokenů zabezpečení (RST). To znamená, že se implementuje vazba Problému definovaná ve specifikaci WS-Trust. Tato vazba je implementována Issue v metodě. Ve výchozím případě nejsou implementovány žádné další vazby WS-Trust (Obnovit, Zrušit a Ověřit) a volajícímu se vrátí odpovídající chyba, pokud dojde k RST, který odpovídá jedné z těchto vazeb. Můžete samozřejmě přepsat příslušné metody (Renew, Cancela Validate) k implementaci těchto vazeb ve službě STS.

Důležité

Implementace služby zabezpečení připravené pro produkční prostředí zahrnuje pečlivé plánování a značné prostředky ke zmírnění potenciálních bezpečnostních rizik spojených s vystavením takové služby. Většina vývojářů používajících Windows Identity Foundation (WIF) bude vyvíjet aplikace, které budou správu identit outsourcovat do služby STS, a nebude vyvíjet samotnou službu STS. WIF poskytuje rozšíření sady Visual Studio, nástroj identit a přístup pro Visual Studio 2012, které vývojářům pomáhá testovat řešení ve vývojovém prostředí. Tento nástroj obsahuje službu STS, kterou můžete nakonfigurovat tak, LocalSTSaby poskytovala konkrétní deklarace identity do aplikace, kterou vyvíjíte. Další informace o nástroji Identita a přístup najdete v tématu Nástroj identit a přístup pro Visual Studio 2012. V některých scénářích LocalSTS nemusí poskytovat funkce potřebné k odpovídajícímu otestování vaší aplikace, například ve scénáři, který zahrnuje vývoj vlastní obslužné rutiny tokenu pro použití aplikací. V těchto případech můžete vytvořit SecurityTokenService jednu nebo více jednoduchých tokenů clusteru, které se dají nasadit ve vývojovém prostředí a které se dají použít k testování takových funkcí ve vaší aplikaci. Zbývající část této části se zaměřuje na metody vystavené SecurityTokenService třídou, které umožňují implementovat jednoduchou službu STS a rozšířit kanál vystavování tokenů.

Následující seznam obsahuje stručný přehled metod, které jsou pro vývojáře nejdůležitější pro použití v testovacím nebo vývojovém prostředí.

Metoda GetScope . Tato metoda vrátí Scope objekt, který obsahuje informace o RP. Tento objekt se používá ve zbytku kanálu vystavování tokenů a obsahuje informace o přihlašovacích údajích pro podepisování a šifrování, které se mají použít v odpovědi, a AppliesTo také adresy a ReplyTo (v případě potřeby). Tuto metodu musíte přepsat.
Metoda GetOutputClaimsIdentity . Tato metoda vrátí ClaimsIdentity objekt, který obsahuje deklarace identity, které se mají vrátit do rp. Tuto metodu musíte přepsat.
Metoda Issue . Tato metoda implementuje kanál žádosti o token, který zpracovává příchozí žádost o token zabezpečení (RST) a vrací volajícímu odpověď (RSTR), která obsahuje token, který lze použít k ověření pomocí rp. Mnoho dalších metod definovaných ve SecurityTokenService třídě je volána z této metody, včetně GetScope metod a GetOutputClaimsIdentity . Tuto metodu nemusíte přepsat, ale pochopení kanálu žádosti o token, který implementuje, může být užitečné.

Služba STS se konfiguruje prostřednictvím SecurityTokenServiceConfiguration třídy .

Poznámky pro implementátory

Je nutné přepsat metody i GetScope(ClaimsPrincipal, RequestSecurityToken)GetOutputClaimsIdentity(ClaimsPrincipal, RequestSecurityToken, Scope) metody.

Konstruktory

SecurityTokenService(SecurityTokenServiceConfiguration)

Volána z odvozených tříd k inicializaci SecurityTokenService třídy pomocí zadaného nastavení konfigurace.

Vlastnosti

Principal	Získá nebo nastaví objekt zabezpečení přidružený k aktuální instanci.
Request	Získá nebo nastaví požadavek tokenu zabezpečení (RST) přidružený k aktuální instanci.
Scope	Získá nebo nastaví obor přidružený k aktuální instanci.
SecurityTokenDescriptor	Získá nebo nastaví SecurityTokenDescriptor přidružené k aktuální instanci.
SecurityTokenServiceConfiguration	Získá instanci konfigurace vlastníka.

Metody

BeginCancel(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object)	Při přepsání v odvozené třídě začne asynchronní WS-Trust Zrušit požadavek.
BeginGetOutputClaimsIdentity(ClaimsPrincipal, RequestSecurityToken, Scope, AsyncCallback, Object)	Při přepsání v odvozené třídě začne asynchronní volání GetOutputClaimsIdentity(ClaimsPrincipal, RequestSecurityToken, Scope) metody.
BeginGetScope(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object)	Při přepsání v odvozené třídě začne asynchronní volání metody GetScope(ClaimsPrincipal, RequestSecurityToken) .
BeginIssue(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object)	Při přepsání v odvozené třídě začne asynchronní WS-Trust problém požadavek.
BeginRenew(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object)	Při přepsání v odvozené třídě začne asynchronní WS-Trust Obnovit požadavek.
BeginValidate(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object)	Při přepsání v odvozené třídě začne asynchronní WS-Trust Ověřit požadavek.
Cancel(ClaimsPrincipal, RequestSecurityToken)	Při přepsání v odvozené třídě zpracuje požadavek WS-Trust Cancel.
CreateSecurityTokenDescriptor(RequestSecurityToken, Scope)	Vytvoří instanci objektu SecurityTokenDescriptor.
EndCancel(IAsyncResult)	Při přepsání v odvozené třídě dokončí asynchronní WS-Trust Zrušit požadavek.
EndGetOutputClaimsIdentity(IAsyncResult)	Při přepsání v odvozené třídě dokončí asynchronní volání BeginGetOutputClaimsIdentity(ClaimsPrincipal, RequestSecurityToken, Scope, AsyncCallback, Object) metody.
EndGetScope(IAsyncResult)	Při přepsání v odvozené třídě dokončí asynchronní volání BeginGetScope(ClaimsPrincipal, RequestSecurityToken, AsyncCallback, Object) metody.
EndIssue(IAsyncResult)	Při přepsání v odvozené třídě dokončí asynchronní WS-Trust problém požadavek.
EndRenew(IAsyncResult)	Při přepsání v odvozené třídě dokončí asynchronní požadavek WS-Trust Renew.
EndValidate(IAsyncResult)	Při přepsání v odvozené třídě dokončí asynchronní požadavek WS-Trust Validate.
Equals(Object)	Určí, zda se zadaný objekt rovná aktuálnímu objektu. (Zděděno od Object)
GetHashCode()	Slouží jako výchozí hashovací funkce. (Zděděno od Object)
GetIssuerName()	Získá název služby tokenů zabezpečení (STS).
GetOutputClaimsIdentity(ClaimsPrincipal, RequestSecurityToken, Scope)	Při přepsání v odvozené třídě tato metoda vrátí kolekci výstupních předmětů, které mají být zahrnuty do vystaveného tokenu.
GetProofToken(RequestSecurityToken, Scope)	Získá token proof, který se má zahrnout do odpovědi (RSTR).
GetRequestorProofEncryptingCredentials(RequestSecurityToken)	Získá důkaz žadatele o šifrování přihlašovacích údajů.
GetResponse(RequestSecurityToken, SecurityTokenDescriptor)	Vytvoří odpověď (RSTR), která obsahuje vystavený token pomocí zadaného požadavku (RST) a popisovače tokenu zabezpečení.
GetScope(ClaimsPrincipal, RequestSecurityToken)	Scope Získá objekt, který obsahuje informace o předávající straně (RP) přidružené k zadanému požadavku (RST). Tuto metodu musíte přepsat v implementaci SecurityTokenService třídy.
GetSecurityTokenHandler(String)	Získá příslušnou obslužnou rutinu tokenu zabezpečení pro vydání tokenu zabezpečení zadaného typu.
GetTokenLifetime(Lifetime)	Získá životnost vydaného tokenu.
GetType()	Získá aktuální Type instanci. (Zděděno od Object)
Issue(ClaimsPrincipal, RequestSecurityToken)	Vydá token zabezpečení.
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Objectsouboru . (Zděděno od Object)
Renew(ClaimsPrincipal, RequestSecurityToken)	Při přepsání v odvozené třídě zpracuje požadavek WS-Trust Renew.
ToString()	Vrátí řetězec, který představuje aktuální objekt. (Zděděno od Object)
Validate(ClaimsPrincipal, RequestSecurityToken)	Při přepsání v odvozené třídě zpracuje požadavek WS-Trust Validate.
ValidateRequest(RequestSecurityToken)	Ověří požadavek tokenu zabezpečení (RST) zapouzdřený touto instancí.

Platí pro