|
//-----------------------------------------------------------------------
// <copyright file="Saml2SubjectConfirmation.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//-----------------------------------------------------------------------
namespace System.IdentityModel.Tokens
{
using System;
using System.Collections.ObjectModel;
/// <summary>
/// A security token backed by a SAML2 assertion.
/// </summary>
public class Saml2SecurityToken : SecurityToken
{
private Saml2Assertion assertion;
private ReadOnlyCollection<SecurityKey> keys;
private SecurityToken issuerToken;
/// <summary>
/// Initializes an instance of <see cref="Saml2SecurityToken"/> from a <see cref="Saml2Assertion"/>.
/// </summary>
/// <param name="assertion">A <see cref="Saml2Assertion"/> to initialize from.</param>
public Saml2SecurityToken(Saml2Assertion assertion)
: this(assertion, EmptyReadOnlyCollection<SecurityKey>.Instance, null)
{
}
/// <summary>
/// Initializes an instance of <see cref="Saml2SecurityToken"/> from a <see cref="Saml2Assertion"/>.
/// </summary>
/// <param name="assertion">A <see cref="Saml2Assertion"/> to initialize from.</param>
/// <param name="keys">A collection of <see cref="SecurityKey"/> to include in the token.</param>
/// <param name="issuerToken">A <see cref="SecurityToken"/> representing the issuer.</param>
public Saml2SecurityToken(Saml2Assertion assertion, ReadOnlyCollection<SecurityKey> keys, SecurityToken issuerToken)
{
if (null == assertion)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("assertion");
}
if (null == keys)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("keys");
}
this.assertion = assertion;
this.keys = keys;
this.issuerToken = issuerToken;
}
/// <summary>
/// Gets the <see cref="Saml2Assertion"/> for this token.
/// </summary>
public Saml2Assertion Assertion
{
get { return this.assertion; }
}
/// <summary>
/// Gets the SecurityToken id.
/// </summary>
public override string Id
{
get { return this.assertion.Id.Value; }
}
/// <summary>
/// Gets the <see cref="SecurityToken"/> of the issuer.
/// </summary>
public SecurityToken IssuerToken
{
get { return this.issuerToken; }
}
/// <summary>
/// Gets the collection of <see cref="SecurityKey"/> contained in this token.
/// </summary>
public override ReadOnlyCollection<SecurityKey> SecurityKeys
{
get { return this.keys; }
}
/// <summary>
/// Gets the time the token is valid from.
/// </summary>
public override DateTime ValidFrom
{
get
{
if (null != this.assertion.Conditions && null != this.assertion.Conditions.NotBefore)
{
return this.assertion.Conditions.NotBefore.Value;
}
else
{
return DateTime.MinValue;
}
}
}
/// <summary>
/// Gets the time the token is valid to.
/// </summary>
public override DateTime ValidTo
{
get
{
if (null != this.assertion.Conditions && null != this.assertion.Conditions.NotOnOrAfter)
{
return this.assertion.Conditions.NotOnOrAfter.Value;
}
else
{
return DateTime.MaxValue;
}
}
}
/// <summary>
/// Determines if this token matches the keyIdentifierClause.
/// </summary>
/// <param name="keyIdentifierClause"><see cref="SecurityKeyIdentifierClause"/> to match.</param>
/// <returns>True if the keyIdentifierClause is matched. False otherwise.</returns>
public override bool MatchesKeyIdentifierClause(SecurityKeyIdentifierClause keyIdentifierClause)
{
return Saml2AssertionKeyIdentifierClause.Matches(this.Id, keyIdentifierClause)
|| base.MatchesKeyIdentifierClause(keyIdentifierClause);
}
/// <summary>
/// Determines is this token can create a <see cref="SecurityKeyIdentifierClause"/>.
/// </summary>
/// <typeparam name="T">The type of <see cref="SecurityKeyIdentifierClause"/> to check if creation is possible.</typeparam>
/// <returns>'True' if this token can create a <see cref="SecurityKeyIdentifierClause"/> of type T. 'False' otherwise.</returns>
public override bool CanCreateKeyIdentifierClause<T>()
{
return (typeof(T) == typeof(Saml2AssertionKeyIdentifierClause))
|| base.CanCreateKeyIdentifierClause<T>();
}
/// <summary>
/// Creates a <see cref="SecurityKeyIdentifierClause"/> that represents this token.
/// </summary>
/// <typeparam name="T">The type of the <see cref="SecurityKeyIdentifierClause"/> to create.</typeparam>
/// <returns>A <see cref="SecurityKeyIdentifierClause"/> for this token.</returns>
public override T CreateKeyIdentifierClause<T>()
{
if (typeof(T) == typeof(Saml2AssertionKeyIdentifierClause))
{
return new Saml2AssertionKeyIdentifierClause(this.assertion.Id.Value) as T;
}
else if (typeof(T) == typeof(SamlAssertionKeyIdentifierClause))
{
return new WrappedSaml2AssertionKeyIdentifierClause(new Saml2AssertionKeyIdentifierClause(this.assertion.Id.Value)) as T;
}
else
{
return base.CreateKeyIdentifierClause<T>();
}
}
}
}
|