Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.WorkflowServices/System/ServiceModel/Security/SerializableAuthorizationContext.cs

@@ -0,0 +1,255 @@
+//------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//------------------------------------------------------------
+
+namespace System.ServiceModel.Security
+{
+    using System.IdentityModel.Policy;
+    using System.Collections.ObjectModel;
+    using System.IdentityModel.Claims;
+    using System.Collections.Generic;
+    using System.Runtime.Serialization;
+    using System.IO;
+    using System.Xml;
+    using System.ServiceModel.Dispatcher;
+    using System.Security.Principal;
+    using System.ServiceModel.Security.Tokens;
+
+    [Serializable]
+    class SerializableAuthorizationContext
+    {
+        static readonly IList<Type> redBitsKnownType = new List<Type>(
+            new Type[]
+            {
+                typeof(DefaultClaimSet),
+                typeof(WindowsClaimSet),
+                typeof(X509CertificateClaimSet),
+                typeof(Claim)
+            });
+
+        byte[] contextBlob;
+        DateTime expirationTime;
+        string id;
+        IList<Type> knownTypes;
+
+        SerializableAuthorizationContext(byte[] contextBlob, DateTime expirationTime, string id, IList<Type> knownTypes)
+        {
+            if (contextBlob == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("contextBlob");
+            }
+
+            this.expirationTime = expirationTime;
+            this.id = id;
+            this.contextBlob = contextBlob;
+            this.knownTypes = knownTypes;
+        }
+
+        public static SerializableAuthorizationContext From(AuthorizationContext authorizationContext)
+        {
+            if (authorizationContext == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("authorizationContext");
+            }
+
+            IList<Type> knownTypes = BuildKnownClaimTypes(authorizationContext);
+            byte[] contextBlob = CreateSerializableBlob(authorizationContext, knownTypes);
+
+            return new SerializableAuthorizationContext(contextBlob, authorizationContext.ExpirationTime, authorizationContext.Id, knownTypes);
+        }
+
+        public AuthorizationContext Retrieve()
+        {
+            List<IAuthorizationPolicy> authorizationPolicies = new List<IAuthorizationPolicy>(1);
+            authorizationPolicies.Add(RetrievePolicyFromBlob(this.contextBlob, this.id, this.expirationTime, this.knownTypes));
+            return AuthorizationContext.CreateDefaultAuthorizationContext(authorizationPolicies);
+        }
+
+        static IList<Type> BuildKnownClaimTypes(AuthorizationContext authorizationContext)
+        {
+            List<Type> knownTypes = new List<Type>();
+
+            foreach (ClaimSet claimSet in authorizationContext.ClaimSets)
+            {
+                Type claimSetType = claimSet.GetType();
+
+                if (!redBitsKnownType.Contains(claimSetType) && !knownTypes.Contains(claimSetType))
+                {
+                    knownTypes.Add(claimSetType);
+                }
+
+                foreach (Claim claim in claimSet)
+                {
+                    Type claimType = claim.GetType();
+
+                    if (!redBitsKnownType.Contains(claimType) && !knownTypes.Contains(claimType))
+                    {
+                        knownTypes.Add(claimType);
+                    }
+                }
+            }
+
+            if (knownTypes.Count != 0)
+            {
+                return knownTypes;
+            }
+
+            return null;
+        }
+
+        static byte[] CreateSerializableBlob(AuthorizationContext authorizationContext, IList<Type> knownTypes)
+        {
+            if (authorizationContext == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("authorizationContext");
+            }
+
+            MemoryStream stream = new MemoryStream();
+            XmlDictionaryWriter writer = XmlDictionaryWriter.CreateBinaryWriter(stream, SctClaimDictionary.Instance, null);
+            SctClaimDictionary claimDictionary = SctClaimDictionary.Instance;
+
+
+            writer.WriteStartElement(claimDictionary.SecurityContextSecurityToken, claimDictionary.EmptyString);
+            writer.WriteStartElement(claimDictionary.Version, claimDictionary.EmptyString);
+            writer.WriteValue(1);
+            writer.WriteEndElement();
+
+            if ((authorizationContext != null) && (authorizationContext.ClaimSets.Count != 0))
+            {
+                DataContractSerializer identitySerializer = DataContractSerializerDefaults.CreateSerializer(typeof(IIdentity), knownTypes, 0x7fffffff);
+                DataContractSerializer claimSetSerializer = DataContractSerializerDefaults.CreateSerializer(typeof(ClaimSet), knownTypes, 0x7fffffff);
+                DataContractSerializer claimSerializer = DataContractSerializerDefaults.CreateSerializer(typeof(Claim), knownTypes, 0x7fffffff);
+                SctClaimSerializer.SerializeIdentities(authorizationContext, claimDictionary, writer, identitySerializer);
+
+                writer.WriteStartElement(claimDictionary.ClaimSets, claimDictionary.EmptyString);
+                for (int i = 0; i < authorizationContext.ClaimSets.Count; i++)
+                {
+                    SctClaimSerializer.SerializeClaimSet(authorizationContext.ClaimSets[i], claimDictionary, writer, claimSetSerializer, claimSerializer);
+                }
+                writer.WriteEndElement();
+            }
+
+            writer.WriteEndElement();
+            writer.Flush();
+            return stream.ToArray();
+        }
+
+        static IAuthorizationPolicy RetrievePolicyFromBlob(byte[] contextBlob, string id, DateTime expirationTime, IList<Type> knownTypes)
+        {
+            if (contextBlob == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("contextBlob");
+            }
+
+            if (id == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("id");
+            }
+
+            SctClaimDictionary claimDictionary = SctClaimDictionary.Instance;
+            XmlDictionaryReader reader = XmlDictionaryReader.CreateBinaryReader(contextBlob, 0, contextBlob.Length, claimDictionary, XmlDictionaryReaderQuotas.Max, null, null);
+            IList<IIdentity> identities = null;
+            IList<ClaimSet> claimSets = null;
+            int versionNumber = -1;
+
+            reader.ReadFullStartElement(claimDictionary.SecurityContextSecurityToken, claimDictionary.EmptyString);
+
+            while (reader.IsStartElement())
+            {
+                if (reader.IsStartElement(claimDictionary.Version, claimDictionary.EmptyString))
+                {
+                    versionNumber = reader.ReadElementContentAsInt();
+
+                    if (versionNumber != 1)
+                    {
+                        throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR2.GetString(SR2.SerializedAuthorizationContextVersionUnsupported, versionNumber)));
+                    }
+                }
+                else
+                {
+                    if (reader.IsStartElement(claimDictionary.Identities, claimDictionary.EmptyString))
+                    {
+                        identities = SctClaimSerializer.DeserializeIdentities(reader, claimDictionary, DataContractSerializerDefaults.CreateSerializer(typeof(IIdentity), knownTypes, 0x7fffffff));
+                        continue;
+                    }
+                    if (reader.IsStartElement(claimDictionary.ClaimSets, claimDictionary.EmptyString))
+                    {
+                        reader.ReadStartElement();
+                        DataContractSerializer claimSetSerializer = DataContractSerializerDefaults.CreateSerializer(typeof(ClaimSet), knownTypes, 0x7fffffff);
+                        DataContractSerializer claimSerializer = DataContractSerializerDefaults.CreateSerializer(typeof(Claim), knownTypes, 0x7fffffff);
+                        claimSets = new List<ClaimSet>(1);
+
+                        while (reader.IsStartElement())
+                        {
+                            claimSets.Add(SctClaimSerializer.DeserializeClaimSet(reader, claimDictionary, claimSetSerializer, claimSerializer));
+                        }
+
+                        reader.ReadEndElement();
+                        continue;
+                    }
+                }
+            }
+            reader.ReadEndElement();
+            return new SctUnconditionalPolicy(identities, id, claimSets, expirationTime);
+        }
+
+        class SctUnconditionalPolicy : IAuthorizationPolicy, IAuthorizationComponent
+        {
+
+            IList<ClaimSet> claimSets;
+            DateTime expirationTime;
+            string id;
+            IList<IIdentity> identities;
+
+            public SctUnconditionalPolicy(IList<IIdentity> identities, string id, IList<ClaimSet> claimSets, DateTime expirationTime)
+            {
+                this.identities = identities;
+                this.claimSets = claimSets;
+                this.expirationTime = expirationTime;
+                this.id = id;
+            }
+
+            public string Id
+            {
+                get
+                {
+                    return this.id;
+                }
+            }
+
+            public ClaimSet Issuer
+            {
+                get
+                {
+                    return ClaimSet.System;
+                }
+            }
+
+            public bool Evaluate(EvaluationContext evaluationContext, ref object state)
+            {
+                for (int num1 = 0; num1 < this.claimSets.Count; num1++)
+                {
+                    evaluationContext.AddClaimSet(this, this.claimSets[num1]);
+                }
+                if (this.identities != null)
+                {
+                    object obj;
+                    if (!evaluationContext.Properties.TryGetValue("Identities", out obj))
+                    {
+                        evaluationContext.Properties.Add("Identities", (object)this.identities);
+                    }
+                    else
+                    {
+                        List<IIdentity> identities = obj as List<IIdentity>;
+                        if (identities != null)
+                        {
+                            identities.AddRange(this.identities);
+                        }
+                    }
+                }
+                evaluationContext.RecordExpirationTime(this.expirationTime);
+                return true;
+            }
+        }
+    }
+}