class/System.ServiceModel/System.ServiceModel.Security.Tokens/SecurityContextSecurityToken.cs

   1 //
   2 // SecurityContextSecretSecurityToken.cs
   3 //
   4 // Author:
   5 //      Atsushi Enomoto <atsushi@ximian.com>
   6 //
   7 // Copyright (C) 2006-2007 Novell, Inc.  http://www.novell.com
   8 //
   9 // Permission is hereby granted, free of charge, to any person obtaining
  10 // a copy of this software and associated documentation files (the
  11 // "Software"), to deal in the Software without restriction, including
  12 // without limitation the rights to use, copy, modify, merge, publish,
  13 // distribute, sublicense, and/or sell copies of the Software, and to
  14 // permit persons to whom the Software is furnished to do so, subject to
  15 // the following conditions:
  16 //
  17 // The above copyright notice and this permission notice shall be
  18 // included in all copies or substantial portions of the Software.
  19 //
  20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27 //
  28 using System;
  29 using System.Collections.ObjectModel;
  30 using System.Xml;
  31 using System.IdentityModel.Policy;
  32 using System.IdentityModel.Tokens;
  33
  34 namespace System.ServiceModel.Security.Tokens
  35 {
  36         public class SecurityContextSecurityToken : SecurityToken
  37         {
  38                 #region Static members
  39
  40                 public static SecurityContextSecurityToken CreateCookieSecurityContextToken (
  41                         UniqueId contextId,
  42                         string id,
  43                         byte [] key,
  44                         DateTime validFrom,
  45                         DateTime validTo,
  46                         ReadOnlyCollection<IAuthorizationPolicy> authorizationPolicies,
  47                         SecurityStateEncoder securityStateEncoder)
  48                 {
  49                         return CreateCookieSecurityContextToken (
  50                                 contextId, id, key, validFrom, validTo, new UniqueId (Guid.NewGuid ()), validFrom, validTo, authorizationPolicies, securityStateEncoder);
  51                 }
  52
  53                 public static SecurityContextSecurityToken CreateCookieSecurityContextToken (
  54                         UniqueId contextId,
  55                         string id,
  56                         byte [] key,
  57                         DateTime validFrom,
  58                         DateTime validTo,
  59                         UniqueId keyGeneration,
  60                         DateTime keyEffectiveTime,
  61                         DateTime keyExpirationTime,
  62                         ReadOnlyCollection<IAuthorizationPolicy> authorizationPolicies,
  63                         SecurityStateEncoder securityStateEncoder)
  64                 {
  65                         if (securityStateEncoder == null)
  66                                 throw new ArgumentNullException ("securityStateEncoder");
  67
  68                         SecurityContextSecurityToken sct = new SecurityContextSecurityToken (
  69                                 contextId, id, key, validFrom, validTo,
  70                                 keyGeneration, keyEffectiveTime,
  71                                 keyExpirationTime,  authorizationPolicies);
  72                         byte [] rawdata = SslnegoCookieResolver.CreateData (
  73                                 contextId, keyGeneration, key,
  74                                 validFrom, validTo,
  75                                 keyEffectiveTime, keyExpirationTime);
  76                         sct.cookie = securityStateEncoder.EncodeSecurityState (rawdata);
  77                         return sct;
  78                 }
  79
  80                 #endregion
  81
  82                 string id;
  83                 InMemorySymmetricSecurityKey key;
  84                 ReadOnlyCollection<SecurityKey> keys;
  85                 DateTime token_since, token_until, key_since, key_until;
  86                 UniqueId context_id, key_generation;
  87                 ReadOnlyCollection<IAuthorizationPolicy> policies;
  88                 byte [] cookie;
  89
  90                 public SecurityContextSecurityToken (
  91                         UniqueId contextId,
  92                         byte[] key,
  93                         DateTime validFrom,
  94                         DateTime validTo)
  95                         : this (contextId, new UniqueId ().ToString (), key, validFrom, validTo)
  96                 {
  97                 }
  98
  99                 public SecurityContextSecurityToken (
 100                         UniqueId contextId,
 101                         string id,
 102                         byte[] key,
 103                         DateTime validFrom,
 104                         DateTime validTo)
 105                         : this (contextId, id, key, validFrom, validTo, null)
 106                 {
 107                 }
 108
 109                 public SecurityContextSecurityToken (
 110                         UniqueId contextId,
 111                         string id,
 112                         byte[] key,
 113                         DateTime validFrom,
 114                         DateTime validTo,
 115                         ReadOnlyCollection<IAuthorizationPolicy> authorizationPolicies)
 116                 {
 117                         context_id = contextId;
 118                         this.id = id;
 119                         this.key = new InMemorySymmetricSecurityKey (key);
 120                         token_since = validFrom;
 121                         token_until = validTo;
 122                         if (authorizationPolicies == null)
 123                                 authorizationPolicies = new ReadOnlyCollection<IAuthorizationPolicy> (new Collection<IAuthorizationPolicy> ());
 124                         policies = authorizationPolicies;
 125                 }
 126
 127                 public SecurityContextSecurityToken (
 128                         UniqueId contextId,
 129                         string id,
 130                         byte[] key,
 131                         DateTime validFrom,
 132                         DateTime validTo,
 133                         UniqueId keyGeneration,
 134                         DateTime keyEffectiveTime,
 135                         DateTime keyExpirationTime,
 136                         ReadOnlyCollection<IAuthorizationPolicy> authorizationPolicies)
 137                         : this (contextId, id, key, validFrom, validTo, authorizationPolicies)
 138                 {
 139                         key_generation = keyGeneration;
 140                         key_since = keyEffectiveTime;
 141                         key_until = keyExpirationTime;
 142                 }
 143
 144                 public ReadOnlyCollection<IAuthorizationPolicy> AuthorizationPolicies {
 145                         get { return policies; }
 146                 }
 147
 148                 public UniqueId ContextId {
 149                         get { return context_id; }
 150                 }
 151
 152                 public UniqueId KeyGeneration {
 153                         get { return key_generation; }
 154                 }
 155
 156                 public DateTime KeyEffectiveTime {
 157                         get { return key_since; }
 158                 }
 159
 160                 public DateTime KeyExpirationTime {
 161                         get { return key_until; }
 162                 }
 163
 164                 public override DateTime ValidFrom {
 165                         get { return token_since; }
 166                 }
 167
 168                 public override DateTime ValidTo {
 169                         get { return token_until; }
 170                 }
 171
 172                 public override string Id {
 173                         get { return id; }
 174                 }
 175
 176                 public override ReadOnlyCollection<SecurityKey> SecurityKeys {
 177                         get {
 178                                 if (keys == null)
 179                                         keys = new ReadOnlyCollection<SecurityKey> (new SecurityKey [] {key});
 180                                 return keys;
 181                         }
 182                 }
 183
 184                 internal byte [] Cookie {
 185                         get { return cookie; }
 186                         set { cookie = value; }
 187                 }
 188
 189                 public override bool CanCreateKeyIdentifierClause<T> ()
 190                 {
 191                         return typeof (T) == typeof (SecurityContextKeyIdentifierClause);
 192                 }
 193
 194                 public override T CreateKeyIdentifierClause<T> ()
 195                 {
 196                         Type t = typeof (T);
 197                         if (t == typeof (SecurityContextKeyIdentifierClause))
 198                                 return (T) (object) new SecurityContextKeyIdentifierClause (ContextId, KeyGeneration);
 199
 200                         throw new NotSupportedException (String.Format ("X509SecurityToken does not support creation of {0}.", t));
 201                 }
 202
 203                 public override bool MatchesKeyIdentifierClause (SecurityKeyIdentifierClause clause)
 204                 {
 205                         SecurityContextKeyIdentifierClause sctic =
 206                                 clause as SecurityContextKeyIdentifierClause;
 207                         return sctic != null && sctic.ContextId == ContextId &&
 208                                sctic.Generation == KeyGeneration;
 209                 }
 210
 211                 [MonoTODO]
 212                 public override string ToString ()
 213                 {
 214                         return base.ToString ();
 215                 }
 216         }
 217 }