SecurityToken Classe
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
Rappresenta una classe di base utilizzata per implementare tutti i token di sicurezza.
public ref class SecurityToken abstractpublic abstract class SecurityTokentype SecurityToken = classPublic MustInherit Class SecurityToken- Ereditarietà
-
SecurityToken
- Derivato
Esempio
Gli esempi di codice usati negli SecurityToken argomenti vengono acquisiti dall'esempio Custom Token . Questo esempio fornisce classi personalizzate che consentono l'elaborazione di token Web semplici (SWT). Include un'implementazione di una classe e una SimpleWebTokenSimpleWebTokenHandler classe, nonché altre classi che supportano i token SWT. Per informazioni su questo esempio e altri esempi disponibili per WIF e su dove scaricarli, vedere Indice di esempio di codice WIF. Il codice seguente mostra l'implementazione della SimpleWebToken classe. Questa classe estende SecurityToken.
/// <summary>
/// Defines the set of constants for the Simple Web Token.
/// </summary>
public static class SimpleWebTokenConstants
{
public const string Audience = "Audience";
public const string ExpiresOn = "ExpiresOn";
public const string Id = "Id";
public const string Issuer = "Issuer";
public const string Signature = "HMACSHA256";
public const string ValidFrom = "ValidFrom";
public const string ValueTypeUri = "http://schemas.xmlsoap.org/ws/2009/11/swt-token-profile-1.0";
}
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.IdentityModel.Tokens;
namespace SimpleWebToken
{
/// <summary>
/// This class represents the token format for the SimpleWebToken.
/// </summary>
public class SimpleWebToken : SecurityToken
{
public static DateTime SwtBaseTime = new DateTime( 1970, 1, 1, 0, 0, 0, 0 ); // per SWT psec
NameValueCollection _properties;
string _serializedToken;
/// <summary>
/// Initializes a new instance of the <see cref="SimpleWebToken"/> class.
/// This is an internal constructor that is only called from the <see cref="SimpleWebTokenHandler"/> when reading a token received from the wire.
/// </summary>
/// <param name="properties">The collection representing all the key value pairs in the token.</param>
/// <param name="serializedToken">The serialized form of the token.</param>
internal SimpleWebToken( NameValueCollection properties, string serializedToken )
: this(properties)
{
_serializedToken = serializedToken;
}
/// <summary>
/// Initializes a new instance of the <see cref="SimpleWebToken"/> class.
/// </summary>
/// <param name="properties">The collection representing all the key value pairs in the token.</param>
public SimpleWebToken( NameValueCollection properties )
{
if ( properties == null )
{
throw new ArgumentNullException( "properties" );
}
_properties = properties;
}
/// <summary>
/// Gets the Id of the token.
/// </summary>
/// <value>The Id of the token.</value>
public override string Id
{
get
{
return _properties[SimpleWebTokenConstants.Id];
}
}
/// <summary>
/// Gets the keys associated with this token.
/// </summary>
/// <value>The keys associated with this token.</value>
public override ReadOnlyCollection<SecurityKey> SecurityKeys
{
get
{
return new ReadOnlyCollection<SecurityKey>( new List<SecurityKey>() );
}
}
/// <summary>
/// Gets the time from when the token is valid.
/// </summary>
/// <value>The time from when the token is valid.</value>
public override DateTime ValidFrom
{
get
{
string validFrom = _properties[SimpleWebTokenConstants.ValidFrom];
return GetTimeAsDateTime( String.IsNullOrEmpty( validFrom ) ? "0" : validFrom );
}
}
/// <summary>
/// Gets the time when the token expires.
/// </summary>
/// <value>The time up to which the token is valid.</value>
public override DateTime ValidTo
{
get
{
string expiryTime = _properties[SimpleWebTokenConstants.ExpiresOn];
return GetTimeAsDateTime( String.IsNullOrEmpty( expiryTime ) ? "0" : expiryTime );
}
}
/// <summary>
/// Gets the Audience for the token.
/// </summary>
/// <value>The audience of the token.</value>
public string Audience
{
get
{
return _properties[SimpleWebTokenConstants.Audience];
}
}
/// <summary>
/// Gets the Issuer for the token.
/// </summary>
/// <value>The issuer for the token.</value>
public string Issuer
{
get
{
return _properties[SimpleWebTokenConstants.Issuer];
}
}
/// <summary>
/// Gets the signature for the token.
/// </summary>
/// <value>The signature for the token.</value>
public string Signature
{
get
{
return _properties[SimpleWebTokenConstants.Signature];
}
}
/// <summary>
/// Gets the serialized form of the token if the token was created from its serialized form by the token handler.
/// </summary>
/// <value>The serialized form of the token.</value>
public string SerializedToken
{
get
{
return _serializedToken;
}
}
/// <summary>
/// Creates a copy of all key value pairs of the token.
/// </summary>
/// <returns>A copy of all the key value pairs in the token.</returns>
public NameValueCollection GetAllProperties()
{
return new NameValueCollection( _properties );
}
/// <summary>
/// Converts the time in seconds to a <see cref="DateTime"/> object based on the base time
/// defined by the Simple Web Token.
/// </summary>
/// <param name="expiryTime">The time in seconds.</param>
/// <returns>The time as a <see cref="DateTime"/> object.</returns>
protected virtual DateTime GetTimeAsDateTime( string expiryTime )
{
long totalSeconds = 0;
if ( !long.TryParse( expiryTime, out totalSeconds ) )
{
throw new SecurityTokenException("Invalid expiry time. Expected the time to be in seconds passed from 1 January 1970.");
}
long maxSeconds = (long)( DateTime.MaxValue - SwtBaseTime ).TotalSeconds - 1;
if ( totalSeconds > maxSeconds )
{
totalSeconds = maxSeconds;
}
return SwtBaseTime.AddSeconds( totalSeconds );
}
}
}
Commenti
Utilizzare un token di sicurezza per fornire credenziali di autenticazione o proteggere un messaggio.
Un token di sicurezza può essere usato per fornire credenziali di autenticazione, materiale della chiave crittografica o, nel caso di un token di sicurezza rilasciato da un servizio token di sicurezza (STS), una raccolta di attestazioni su un soggetto. Tutti i token di sicurezza derivano dalla SecurityToken classe .
A partire da .NET 4.5, Windows Identity Foundation (WIF) è stato completamente integrato in .NET Framework e le classi esposte da WIF sono il metodo preferito per gestire i token di sicurezza nel codice. In WIF, i token di sicurezza vengono serializzati e deserializzati da e verso la SecurityTokenHandler relativa rappresentazione XML e vengono convalidati usando classi derivate dalla classe base. La convalida di un token implica non solo garantire che il token sia valido, ma anche la restituzione di un'istanza ClaimsIdentity dal token che può essere usato per prendere decisioni di autenticazione e autorizzazione. Viene ClaimsIdentity costruito dall'implementazione del gestore del token del ValidateToken metodo dalle attestazioni contenute nel token e dalle attestazioni intrinseche al tipo di token stesso.
WIF viene fornito con supporto per i tipi seguenti di token di sicurezza:
Saml2SecurityToken: rappresenta un token di sicurezza basato su un'asserzione SAML 2.0. Questo tipo di token viene in genere rilasciato da un servizio token di sicurezza in risposta a un WS-Trust o WS-Federation richiesta di token di sicurezza (RST).
SamlSecurityToken: rappresenta un token di sicurezza basato su un'asserzione SAML 1.1. Questo tipo di token viene in genere rilasciato da un servizio token di sicurezza in risposta a un WS-Trust o WS-Federation richiesta di token di sicurezza (RST).
KerberosRequestorSecurityToken e KerberosReceiverSecurityToken: rappresenta un token di sicurezza basato su un ticket Kerberos ricevuto o inviato in un messaggio SOAP
RsaSecurityToken: rappresenta un token di sicurezza basato sulla chiave creata usando l'algoritmo RSA.
SessionSecurityToken: rappresenta un token di sicurezza che contiene informazioni su una sessione.
UserNameSecurityToken: rappresenta un token di sicurezza basato su un nome utente e una password.
WindowsSecurityToken: rappresenta un token di sicurezza basato sull'identità di un dominio o di un account utente di Windows.
X509SecurityToken: rappresenta un token di sicurezza basato su un certificato X.509.
X509WindowsSecurityToken: rappresenta un token di sicurezza basato su un certificato X.509 mappato a un utente di dominio Windows o a un account utente del computer locale.
È possibile usare due altre classi GenericXmlSecurityToken di token di sicurezza e EncryptedSecurityToken, per gestire i casi generali.
In generale i token di sicurezza rientrano in tre categorie principali:
Token che contengono o fanno riferimento al materiale della chiave crittografica. Ad esempio, i RsaSecurityToken tipi e X509SecurityToken vengono spesso usati per questo scopo.
Token che rappresentano le credenziali per gli utenti che sono già stati autenticati. Ad esempio, , UserNameSecurityTokenWindowsSecurityTokene, nel caso di un utente autenticato usando un certificato, i X509SecurityToken tipi.
Token rilasciati da un servizio token di sicurezza (STS) in risposta a una richiesta di token di sicurezza usando il protocollo WS-Trust o WS-Federation. Questi vengono in genere restituiti in un
wst:RequestSecurityTokenResponseframmento XML. I Saml2SecurityToken tipi e SamlSecurityToken vengono spesso usati per rappresentare questi token.
Un tipo di token speciale, il , contiene informazioni necessarie per ricreare un'entità SessionSecurityTokenquando si usano sessioni in scenari attivi o passivi.
Per aggiungere funzionalità ai tipi di token esistenti, è possibile derivare dal tipo specifico e dal gestore token associato per supportare eventuali nuovi elementi aggiunti al token. Per aggiungere il supporto per i nuovi tipi di token, è possibile derivare direttamente dalla SecurityToken classe. A tale scopo, sarà anche necessario creare una classe del gestore token derivando dalla SecurityTokenHandler classe . A seconda del modo in cui deve essere usato il token, è anche necessario creare un resolver token personalizzato derivando dalla IssuerTokenResolver classe e da uno o più tipi di clausola identificatore di chiave personalizzata derivando dalla SecurityKeyIdentifierClause classe.
Note per gli implementatori
È necessario eseguire l'override delle Idproprietà , SecurityKeys, ValidFrome ValidTo . I CanCreateKeyIdentifierClause<T>()metodi , CreateKeyIdentifierClause<T>(), MatchesKeyIdentifierClause(SecurityKeyIdentifierClause)e ResolveKeyIdentifierClause(SecurityKeyIdentifierClause) supportano tutti gli identificatori di chiave di tipo LocalIdKeyIdentifierClause. È necessario eseguire l'override di questi metodi per supportare altri tipi di identificatore di chiave nella classe derivata.
Costruttori
| SecurityToken() |
Chiamato dai costruttori nelle classi derivate per inizializzare la classe SecurityToken. |
Proprietà
| Id |
Ottiene un identificatore univoco del token di sicurezza. |
| SecurityKeys |
Ottiene le chiavi di crittografia associate al token di sicurezza. |
| ValidFrom |
Ottiene l'indicazione del momento a partire dal quale il token di sicurezza è valido. |
| ValidTo |
Ottiene l'indicazione del momento fino al quale il token di sicurezza è valido. |
Metodi
| CanCreateKeyIdentifierClause<T>() |
Ottiene un valore che indica se questo token di sicurezza è in grado di creare l'identificatore di chiave specificato. |
| CreateKeyIdentifierClause<T>() |
Crea la clausola identificatore di chiave specificata. |
| Equals(Object) |
Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object) |
| GetHashCode() |
Funge da funzione hash predefinita. (Ereditato da Object) |
| GetType() |
Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object) |
| MatchesKeyIdentifierClause(SecurityKeyIdentifierClause) |
Restituisce un valore che indica se l'identificatore di chiave per l'istanza può essere risolto nell'identificatore di chiave specificato. |
| MemberwiseClone() |
Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object) |
| ResolveKeyIdentifierClause(SecurityKeyIdentifierClause) |
Ottiene la chiave per la clausola dell'identificatore di chiave specificata. |
| ToString() |
Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object) |
Si applica a
Vedi anche
Commenti e suggerimenti
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedere https://aka.ms/ContentUserFeedback.
Invia e visualizza il feedback per