Imported Upstream version 4.8.0.309

Former-commit-id: 5f9c6ae75f295e057a7d2971f3a6df4656fa8850

mcs/class/System.IdentityModel/Assembly/AssemblyInfo.cs

@@ -61,6 +61,7 @@ using System.Runtime.InteropServices;
 [assembly: ComCompatibleVersion (1, 0, 3300, 0)]
 [assembly: AllowPartiallyTrustedCallers]
 
-#if !NET_2_1
+#if !MOBILE
 [assembly: SecurityCritical (SecurityCriticalScope.Explicit)]
-#endif
+[assembly: InternalsVisibleTo ("System.ServiceModel, PublicKey=00000000000000000400000000000000")]
+#endif

mcs/class/System.IdentityModel/Makefile

@@ -2,8 +2,12 @@ thisdir = class/System.IdentityModel
 SUBDIRS = 
 include ../../build/rules.make
 
+ifndef NO_MONO_SECURITY
+MONO_SECURITY=Mono.Security
+endif
+
 LIBRARY = System.IdentityModel.dll
-LIB_REFS = System System.Xml System.Security Mono.Security System.Runtime.Serialization
+LIB_REFS = System System.Xml System.Security $(MONO_SECURITY) System.Runtime.Serialization
 LIB_MCS_FLAGS = \
 		/d:NET_3_0	\
 	        $(OTHER_LIB_MCS_FLAGS)

mcs/class/System.IdentityModel/System.ServiceModel.Security.Tokens/BinarySecretSecurityToken.cs

@@ -0,0 +1,119 @@
+//
+// BinarySecretSecurityToken.cs
+//
+// Author:
+//	Atsushi Enomoto <atsushi@ximian.com>
+//
+// Copyright (C) 2006 Novell, Inc.  http://www.novell.com
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+using System;
+using System.Collections.ObjectModel;
+using System.Xml;
+using System.IdentityModel.Policy;
+using System.IdentityModel.Tokens;
+
+namespace System.ServiceModel.Security.Tokens
+{
+	public class BinarySecretSecurityToken : SecurityToken
+	{
+		ReadOnlyCollection<SecurityKey> keys;
+
+		string id;
+		byte [] key;
+		bool allow_crypto;
+		DateTime valid_from = DateTime.Now.ToUniversalTime ();
+
+		BinarySecretSecurityToken (string id, bool allowCrypto)
+		{
+			this.id = id;
+			allow_crypto = allowCrypto;
+		}
+
+		public BinarySecretSecurityToken (byte [] key)
+			: this ("uuid:" + Guid.NewGuid ().ToString (), key)
+		{
+		}
+
+		public BinarySecretSecurityToken (string id, byte [] key)
+			: this (id, key, false)
+		{
+		}
+
+		protected BinarySecretSecurityToken (string id, byte [] key, bool allowCrypto)
+			: this (id, allowCrypto)
+		{
+			if (key == null)
+				throw new ArgumentNullException ("key");
+			this.key = key;
+
+			SecurityKey [] arr = new SecurityKey [] {new InMemorySymmetricSecurityKey (key)};
+			keys = new ReadOnlyCollection<SecurityKey> (arr);
+		}
+
+		public BinarySecretSecurityToken (int keySizeInBits)
+			: this ("uuid:" + Guid.NewGuid ().ToString (), keySizeInBits)
+		{
+		}
+
+		public BinarySecretSecurityToken (string id, int keySizeInBits)
+			: this (id, keySizeInBits, false)
+		{
+		}
+
+		protected BinarySecretSecurityToken (string id, int keySizeInBits, bool allowCrypto)
+			: this (id, allowCrypto)
+		{
+			if (keySizeInBits < 0)
+				throw new ArgumentOutOfRangeException ("keySizeInBits");
+
+			this.key = new byte [keySizeInBits >> 3 + (keySizeInBits % 8 == 0 ? 0 : 1)];
+
+			SecurityKey [] arr = new SecurityKey [] {new InMemorySymmetricSecurityKey (key)};
+			keys = new ReadOnlyCollection<SecurityKey> (arr);
+		}
+
+		public override DateTime ValidFrom {
+			get { return valid_from; }
+		}
+
+		public override DateTime ValidTo {
+			get { return DateTime.MaxValue.AddDays (-1); }
+		}
+
+		public override string Id {
+			get { return id; }
+		}
+
+		public int KeySize {
+			get { return key.Length; }
+		}
+
+		public override ReadOnlyCollection<SecurityKey> SecurityKeys {
+			get { return keys; }
+		}
+
+		public byte [] GetKeyBytes ()
+		{
+			return (byte []) key.Clone ();
+		}
+	}
+}

mcs/class/System.IdentityModel/System.ServiceModel.Security.Tokens/InternalEncryptedKeyIdentifierClause.cs

@@ -0,0 +1,51 @@
+//
+// InternalEncryptedKeyIdentifierClause.cs
+//
+// Author:
+//	Atsushi Enomoto <atsushi@ximian.com>
+//
+// Copyright (C) 2007 Novell, Inc.  http://www.novell.com
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+using System;
+using System.Collections.ObjectModel;
+using System.Security.Cryptography.Xml;
+using System.Xml;
+using System.IdentityModel.Tokens;
+
+namespace System.ServiceModel.Security.Tokens
+{
+	internal class InternalEncryptedKeyIdentifierClause : BinaryKeyIdentifierClause
+	{
+		public InternalEncryptedKeyIdentifierClause (byte [] hash)
+			: base (null, hash, false)
+		{
+		}
+
+		public override bool Matches (SecurityKeyIdentifierClause keyIdentifierClause)
+		{
+			InternalEncryptedKeyIdentifierClause kic = keyIdentifierClause as InternalEncryptedKeyIdentifierClause;
+			if (kic == null)
+				return false;
+			return Matches (kic.GetRawBuffer ());
+		}
+	}
+}

mcs/class/System.IdentityModel/System.ServiceModel.Security.Tokens/WrappedKeySecurityToken.cs

@@ -0,0 +1,176 @@
+//
+// WrappedKeySecurityToken.cs
+//
+// Author:
+//	Atsushi Enomoto <atsushi@ximian.com>
+//
+// Copyright (C) 2006 Novell, Inc.  http://www.novell.com
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+using System;
+using System.Collections.ObjectModel;
+using System.Security.Cryptography;
+using System.Security.Cryptography.Xml;
+using System.Xml;
+using System.IdentityModel.Policy;
+using System.IdentityModel.Tokens;
+
+namespace System.ServiceModel.Security.Tokens
+{
+	public class WrappedKeySecurityToken : SecurityToken
+	{
+		string id;
+		byte [] raw_key;
+		byte [] wrapped_key;
+		string wrap_alg;
+		SecurityToken wrap_token;
+		SecurityKeyIdentifier wrap_token_ref;
+		DateTime valid_from = DateTime.Now.ToUniversalTime ();
+		ReadOnlyCollection<SecurityKey> keys;
+		ReferenceList reference_list;
+		byte [] keyhash;
+
+		public WrappedKeySecurityToken (
+			string id,
+			byte [] keyToWrap,
+			string wrappingAlgorithm,
+			SecurityToken wrappingToken,
+			SecurityKeyIdentifier wrappingTokenReference)
+		{
+			if (id == null)
+				throw new ArgumentNullException ("id");
+			if (keyToWrap == null)
+				throw new ArgumentNullException ("keyToWrap");
+			if (wrappingAlgorithm == null)
+				throw new ArgumentNullException ("wrappingAlgorithm");
+			if (wrappingToken == null)
+				throw new ArgumentNullException ("wrappingToken");
+
+			raw_key = keyToWrap;
+			this.id = id;
+			wrap_alg = wrappingAlgorithm;
+			wrap_token = wrappingToken;
+			wrap_token_ref = wrappingTokenReference;
+			Collection<SecurityKey> l = new Collection<SecurityKey> ();
+			foreach (SecurityKey sk in wrappingToken.SecurityKeys) {
+				if (sk.IsSupportedAlgorithm (wrappingAlgorithm)) {
+					wrapped_key = sk.EncryptKey (wrappingAlgorithm, keyToWrap);
+					l.Add (new InMemorySymmetricSecurityKey (keyToWrap));
+					break;
+				}
+			}
+			keys = new ReadOnlyCollection<SecurityKey> (l);
+			if (wrapped_key == null)
+				throw new ArgumentException (String.Format ("None of the security keys in the argument token supports specified wrapping algorithm '{0}'", wrappingAlgorithm));
+		}
+
+		internal byte [] RawKey {
+			get { return raw_key; }
+		}
+
+		// It is kind of compromised solution to output
+		// ReferenceList inside e:EncryptedKey and might disappear
+		// when non-wrapped key is represented by another token type.
+		internal ReferenceList ReferenceList {
+			get { return reference_list; }
+			set { reference_list = value; }
+		}
+
+		public override DateTime ValidFrom {
+			get { return valid_from; }
+		}
+
+		public override DateTime ValidTo {
+			get { return DateTime.MaxValue.AddDays (-1); }
+		}
+
+		public override string Id {
+			get { return id; }
+		}
+
+		public override ReadOnlyCollection<SecurityKey> SecurityKeys {
+			get { return keys; }
+		}
+
+		public string WrappingAlgorithm {
+			get { return wrap_alg; }
+		}
+
+		public SecurityToken WrappingToken {
+			get { return wrap_token; }
+		}
+
+		public SecurityKeyIdentifier WrappingTokenReference {
+			get { return wrap_token_ref; }
+		}
+
+		public byte [] GetWrappedKey ()
+		{
+			return (byte []) wrapped_key.Clone ();
+		}
+
+		internal void SetWrappedKey (byte [] value)
+		{
+			wrapped_key = (byte []) value.Clone ();
+		}
+
+		[MonoTODO]
+		public override bool CanCreateKeyIdentifierClause<T> ()
+		{
+			/*
+			foreach (SecurityKeyIdentifierClause k in WrappingTokenReference) {
+				Type t = k.GetType ();
+				if (t == typeof (T) || t.IsSubclassOf (typeof (T)))
+					return true;
+			}
+			*/
+			return false;
+		}
+
+		[MonoTODO]
+		public override T CreateKeyIdentifierClause<T> ()
+		{
+			/*
+			foreach (SecurityKeyIdentifierClause k in WrappingTokenReference) {
+				Type t = k.GetType ();
+				if (t == typeof (T) || t.IsSubclassOf (typeof (T)))
+					return (T) k;
+			}
+			*/
+			throw new NotSupportedException (String.Format ("WrappedKeySecurityToken cannot create '{0}'", typeof (T)));
+		}
+
+		public override bool MatchesKeyIdentifierClause (SecurityKeyIdentifierClause keyIdentifierClause)
+		{
+			LocalIdKeyIdentifierClause lkic = keyIdentifierClause as LocalIdKeyIdentifierClause;
+			if (lkic != null && lkic.LocalId == Id)
+				return true;
+
+			InternalEncryptedKeyIdentifierClause khic = keyIdentifierClause as InternalEncryptedKeyIdentifierClause;
+			if (keyhash == null)
+				keyhash = SHA1.Create ().ComputeHash (wrapped_key);
+			if (khic != null && khic.Matches (keyhash))
+				return true;
+
+			return false;
+		}
+	}
+}

mcs/class/System.IdentityModel/System.ServiceModel.Security/BinarySecretKeyIdentifierClause.cs

@@ -0,0 +1,87 @@
+//
+// BinarySecretKeyIdentifierClause.cs
+//
+// Author:
+//	Atsushi Enomoto <atsushi@ximian.com>
+//
+// Copyright (C) 2006 Novell, Inc.  http://www.novell.com
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+using System;
+using System.Collections.Generic;
+using System.Xml;
+using System.IdentityModel.Policy;
+using System.IdentityModel.Tokens;
+
+namespace System.ServiceModel.Security
+{
+	public class BinarySecretKeyIdentifierClause : BinaryKeyIdentifierClause
+	{
+		public BinarySecretKeyIdentifierClause (byte [] key)
+			: this (key, true)
+		{
+		}
+
+		[MonoTODO ("ClauseType")]
+		public BinarySecretKeyIdentifierClause (byte [] key, bool cloneBuffer)
+			: base ("", key, cloneBuffer)
+		{
+		}
+
+		[MonoTODO ("ClauseType")]
+		public BinarySecretKeyIdentifierClause (byte [] key, bool cloneBuffer, byte [] derivationNonce, int derivationLength)
+			: base ("", key, cloneBuffer, derivationNonce, derivationLength)
+		{
+		}
+
+		public override bool CanCreateKey {
+			get { return true; }
+		}
+
+		public byte [] GetKeyBytes ()
+		{
+			return GetBuffer ();
+		}
+
+		public override SecurityKey CreateKey ()
+		{
+			return new InMemorySymmetricSecurityKey (GetRawBuffer (), true);
+		}
+
+		public override bool Matches (SecurityKeyIdentifierClause clause)
+		{
+			if (clause == null)
+				throw new ArgumentNullException ("clause");
+			BinarySecretKeyIdentifierClause other =
+				clause as BinarySecretKeyIdentifierClause;
+			if (other == null)
+				return false;
+			byte [] b1 = GetRawBuffer ();
+			byte [] b2 = other.GetRawBuffer ();
+			if (b1.Length != b2.Length)
+				return false;
+			for (int i = 0; i < b1.Length; i++)
+				if (b1 [i] != b2 [i])
+					return false;
+			return true;
+		}
+	}
+}

mcs/class/System.IdentityModel/System.ServiceModel.Security/KeyNameIdentifierClause.cs

@@ -0,0 +1,69 @@
+//
+// KeyNameIdentifierClause.cs
+//
+// Author:
+//	Atsushi Enomoto <atsushi@ximian.com>
+//
+// Copyright (C) 2006 Novell, Inc.  http://www.novell.com
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+using System;
+using System.Collections.Generic;
+using System.Xml;
+using System.IdentityModel.Policy;
+using System.IdentityModel.Tokens;
+
+namespace System.ServiceModel.Security
+{
+	public class KeyNameIdentifierClause : SecurityKeyIdentifierClause
+	{
+		public KeyNameIdentifierClause (string keyName)
+			: base (null)
+		{
+			key_name = keyName;
+		}
+
+		string key_name;
+
+		public string KeyName {
+			get { return key_name; }
+		}
+
+		public override bool Matches (SecurityKeyIdentifierClause clause)
+		{
+			if (clause == null)
+				throw new ArgumentNullException ("clause");
+			KeyNameIdentifierClause knic =
+				clause as KeyNameIdentifierClause;
+			return knic != null && Matches (knic.KeyName);
+		}
+
+		public bool Matches (string keyName)
+		{
+			return key_name == keyName;
+		}
+
+		public override string ToString ()
+		{
+			return String.Concat ("KeyNameIdentifierClause(KeyName = '", KeyName, "')");
+		}
+	}
+}

mcs/class/System.IdentityModel/System.ServiceModel.Security/SecurityContextKeyIdentifierClause.cs

@@ -0,0 +1,84 @@
+//
+// SecurityContextKeyIdentifierClause.cs
+//
+// Author:
+//	Atsushi Enomoto <atsushi@ximian.com>
+//
+// Copyright (C) 2006 Novell, Inc.  http://www.novell.com
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System.IdentityModel.Selectors;
+using System.IdentityModel.Tokens;
+using System.Xml;
+
+namespace System.ServiceModel.Security
+{
+	public class SecurityContextKeyIdentifierClause : SecurityKeyIdentifierClause
+	{
+		public SecurityContextKeyIdentifierClause (UniqueId contextId)
+			: this (contextId, new UniqueId ())
+		{
+		}
+
+		public SecurityContextKeyIdentifierClause (UniqueId contextId, UniqueId generation)
+			: this (contextId, generation, null, 0)
+		{
+		}
+
+		public SecurityContextKeyIdentifierClause (UniqueId contextId, UniqueId generation, byte [] derivationNonce, int derivationLength)
+			: base (null, derivationNonce, derivationLength)
+		{
+			this.context = contextId;
+			this.generation = generation;
+		}
+
+		UniqueId context, generation;
+
+		public UniqueId ContextId {
+			get { return context; }
+		}
+
+		public UniqueId Generation {
+			get { return generation; }
+		}
+
+		public override bool Matches (
+			SecurityKeyIdentifierClause keyIdentifierClause)
+		{
+			SecurityContextKeyIdentifierClause other =
+				keyIdentifierClause as SecurityContextKeyIdentifierClause;
+			return  other != null && Matches (other.context, other.generation);
+		}
+
+		public bool Matches (UniqueId contextId, UniqueId generation)
+		{
+			return context == contextId &&
+				this.generation == generation;
+		}
+
+		[MonoTODO]
+		public override string ToString ()
+		{
+			return base.ToString ();
+		}
+	}
+}

mcs/class/System.IdentityModel/Test/System.IdentityModel.Tokens/BootstrapContextTest.cs

@@ -2,7 +2,6 @@
 // BootstrapContextTest.cs - NUnit Test Cases for System.IdentityModel.Tokens.BootstrapContext
 //
 
-#if NET_4_5
 using System;
 using System.IO;
 using System.IdentityModel.Tokens;
@@ -248,4 +247,3 @@ namespace MonoTests.System.IdentityModel.Tokens.net_4_5 {
 		}
 	}
 }
-#endif

mcs/class/System.IdentityModel/net_4_x_System.IdentityModel.dll.sources

@@ -128,4 +128,10 @@ System.IdentityModel.Tokens/X509SubjectKeyIdentifierClause.cs
 System.IdentityModel.Tokens/X509ThumbprintKeyIdentifierClause.cs
 System.IdentityModel.Tokens/X509WindowsSecurityToken.cs
 System.Security.Claims/AuthenticationTypes.cs
+System.ServiceModel.Security/BinarySecretKeyIdentifierClause.cs
+System.ServiceModel.Security/KeyNameIdentifierClause.cs
+System.ServiceModel.Security/SecurityContextKeyIdentifierClause.cs
 System.ServiceModel.Security/X509CertificateValidationMode.cs
+System.ServiceModel.Security.Tokens/BinarySecretSecurityToken.cs
+System.ServiceModel.Security.Tokens/InternalEncryptedKeyIdentifierClause.cs
+System.ServiceModel.Security.Tokens/WrappedKeySecurityToken.cs