SecurityToken Classe
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Représente une classe de base utilisée pour implémenter tous les jetons de sécurité.
public ref class SecurityToken abstractpublic abstract class SecurityTokentype SecurityToken = classPublic MustInherit Class SecurityToken- Héritage
-
SecurityToken
- Dérivé
Exemples
Les exemples de code utilisés dans les SecurityToken rubriques sont tirés de l’exemple Custom Token . Cet exemple fournit des classes personnalisées qui permettent le traitement des jetons web simples (SWT). Il inclut une implémentation d’une SimpleWebToken classe et d’une SimpleWebTokenHandler classe, ainsi que d’autres classes qui prennent en charge les jetons SWT. Pour plus d’informations sur cet exemple et d’autres exemples disponibles pour WIF et sur l’emplacement où les télécharger, consultez Index d’exemple de code WIF. Le code suivant montre l’implémentation de la SimpleWebToken classe . Cette classe étend 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 );
}
}
}
Remarques
Utilisez un jeton de sécurité pour fournir les informations d'identification de l'authentification ou pour protéger un message.
Un jeton de sécurité peut être utilisé pour fournir des informations d’identification d’authentification, du matériel de clé de chiffrement ou, dans le cas d’un jeton de sécurité émis par un service de jeton de sécurité (STS), une collection de revendications sur un sujet. Tous les jetons de sécurité dérivent de la SecurityToken classe .
À compter de .NET 4.5, Windows Identity Foundation (WIF) a été entièrement intégré au .NET Framework et les classes exposées par WIF sont la méthode préférée pour gérer les jetons de sécurité dans votre code. Dans WIF, les jetons de sécurité sont sérialisés et désérialisés vers et depuis leur représentation XML et sont validés à l’aide de classes dérivées de la SecurityTokenHandler classe de base. La validation d’un jeton implique non seulement de s’assurer que le jeton est valide, mais également de retourner un ClaimsIdentity instance à partir du jeton qui peut être utilisé pour prendre des décisions d’authentification et d’autorisation. Le ClaimsIdentity est construit par l’implémentation par le gestionnaire de jetons de la ValidateToken méthode à partir des revendications contenues dans le jeton ainsi que des revendications intrinsèques au type de jeton lui-même.
WIF est fourni avec la prise en charge des types de jetons de sécurité suivants :
Saml2SecurityToken: représente un jeton de sécurité basé sur une assertion SAML 2.0. Ce type de jeton est généralement émis par un service de jeton de sécurité en réponse à une WS-Trust ou WS-Federation demande de jeton de sécurité (RST).
SamlSecurityToken: représente un jeton de sécurité basé sur une assertion SAML 1.1. Ce type de jeton est généralement émis par un service de jeton de sécurité en réponse à une WS-Trust ou WS-Federation demande de jeton de sécurité (RST).
KerberosRequestorSecurityToken et KerberosReceiverSecurityToken: représente un jeton de sécurité basé sur un ticket Kerberos reçu ou envoyé dans un message SOAP
RsaSecurityToken: représente un jeton de sécurité basé sur la clé créée à l’aide de l’algorithme RSA.
SessionSecurityToken: représente un jeton de sécurité qui contient des informations sur une session.
UserNameSecurityToken: représente un jeton de sécurité basé sur un nom d’utilisateur et un mot de passe.
WindowsSecurityToken: représente un jeton de sécurité basé sur l’identité d’un domaine ou d’un compte d’utilisateur Windows.
X509SecurityToken: représente un jeton de sécurité basé sur un certificat X.509.
X509WindowsSecurityToken: représente un jeton de sécurité basé sur un certificat X.509 mappé à un utilisateur de domaine Windows ou à un compte d’utilisateur d’ordinateur local.
Deux autres classes de jetons de sécurité, GenericXmlSecurityToken et EncryptedSecurityToken, peuvent être utilisées pour faciliter la gestion des cas généraux.
Globalement, les jetons de sécurité se répartissent en trois catégories principales :
Jetons qui contiennent ou référencent du matériel de clé de chiffrement. Par exemple, les RsaSecurityToken types et X509SecurityToken sont souvent utilisés à cette fin.
Jetons qui représentent les informations d’identification des utilisateurs qui ont déjà été authentifiés. Par exemple, , UserNameSecurityTokenWindowsSecurityTokenet, dans le cas d’un utilisateur authentifié à l’aide d’un certificat, les X509SecurityToken types .
Jetons émis par un service de jeton de sécurité (STS) en réponse à une demande de jeton de sécurité à l’aide du protocole WS-Trust ou WS-Federation. Elles sont généralement retournées dans un
wst:RequestSecurityTokenResponsefragment XML. Les Saml2SecurityToken types et SamlSecurityToken sont le plus souvent utilisés pour représenter ces jetons.
Un type de jeton spécial, le SessionSecurityToken, contient les informations nécessaires pour recréer un principal lors de l’utilisation de sessions dans des scénarios actifs ou passifs.
Pour ajouter des fonctionnalités aux types de jetons existants, vous pouvez dériver du type spécifique et de son gestionnaire de jetons associé pour prendre en charge tous les nouveaux éléments que vous ajoutez au jeton. Pour ajouter la prise en charge de nouveaux types de jetons, vous pouvez dériver directement de la SecurityToken classe . Dans ce cas, vous devez également créer une classe de gestionnaire de jetons en dérivant de la SecurityTokenHandler classe . Selon la façon dont votre jeton doit être utilisé, vous devrez peut-être également créer un programme de résolution de jeton personnalisé en dérivant de la IssuerTokenResolver classe ainsi qu’un ou plusieurs types de clauses d’identificateur de clé personnalisés en dérivant de la SecurityKeyIdentifierClause classe .
Notes pour les responsables de l’implémentation
Vous devez remplacer les Idpropriétés , SecurityKeys, ValidFromet ValidTo . Les CanCreateKeyIdentifierClause<T>()méthodes , CreateKeyIdentifierClause<T>(), MatchesKeyIdentifierClause(SecurityKeyIdentifierClause)et ResolveKeyIdentifierClause(SecurityKeyIdentifierClause) prennent toutes en charge les identificateurs de clé de type LocalIdKeyIdentifierClause. Vous devez remplacer ces méthodes pour prendre en charge d’autres types d’identificateur de clé dans votre classe dérivée.
Constructeurs
| SecurityToken() |
Appelé par les constructeurs dans les classes dérivées pour initialiser la classe SecurityToken. |
Propriétés
| Id |
Obtient un identificateur unique du jeton de sécurité. |
| SecurityKeys |
Obtient les clés de chiffrement associées au jeton de sécurité. |
| ValidFrom |
Obtient le premier instant auquel ce jeton de sécurité est valide. |
| ValidTo |
Obtient le dernier instant auquel ce jeton de sécurité est valide. |
Méthodes
| CanCreateKeyIdentifierClause<T>() |
Obtient une valeur qui indique si ce jeton de sécurité est capable de créer l'identificateur de clé spécifié. |
| CreateKeyIdentifierClause<T>() |
Crée la clause d'identificateur de clé spécifiée. |
| Equals(Object) |
Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object) |
| GetHashCode() |
Fait office de fonction de hachage par défaut. (Hérité de Object) |
| GetType() |
Obtient le Type de l'instance actuelle. (Hérité de Object) |
| MatchesKeyIdentifierClause(SecurityKeyIdentifierClause) |
Retourne une valeur qui indique si l'identificateur de clé pour cette instance peut être résolu à la clause d'identificateur de clé spécifiée. |
| MemberwiseClone() |
Crée une copie superficielle du Object actuel. (Hérité de Object) |
| ResolveKeyIdentifierClause(SecurityKeyIdentifierClause) |
Obtient la clé pour la clause d'identificateur de clé spécifiée. |
| ToString() |
Retourne une chaîne qui représente l'objet actuel. (Hérité de Object) |
S’applique à
Voir aussi
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour