Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.IdentityModel/System/ServiceModel/Security/EncryptedKey.cs

@@ -0,0 +1,131 @@
+//------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//------------------------------------------------------------
+
+namespace System.ServiceModel.Security
+{
+    using System.IdentityModel;
+    using System.Runtime.CompilerServices;
+    using System.Xml;
+
+    [TypeForwardedFrom("System.ServiceModel, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
+    sealed class EncryptedKey : EncryptedType
+    {
+        internal static readonly XmlDictionaryString CarriedKeyElementName = XD.XmlEncryptionDictionary.CarriedKeyName;
+        internal static readonly XmlDictionaryString ElementName = XD.XmlEncryptionDictionary.EncryptedKey;
+        internal static readonly XmlDictionaryString RecipientAttribute = XD.XmlEncryptionDictionary.Recipient;
+
+        string carriedKeyName;
+        string recipient;
+        ReferenceList referenceList;
+        byte[] wrappedKey;
+
+        public string CarriedKeyName
+        {
+            get { return this.carriedKeyName; }
+            set { this.carriedKeyName = value; }
+        }
+
+        public string Recipient
+        {
+            get { return this.recipient; }
+            set { this.recipient = value; }
+        }
+
+        public ReferenceList ReferenceList
+        {
+            get { return this.referenceList; }
+            set { this.referenceList = value; }
+        }
+
+        protected override XmlDictionaryString OpeningElementName
+        {
+            get { return ElementName; }
+        }
+
+        protected override void ForceEncryption()
+        {
+            // no work to be done here since, unlike bulk encryption, key wrapping is done eagerly
+        }
+
+        public byte[] GetWrappedKey()
+        {
+            if (this.State == EncryptionState.New)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.BadEncryptionState)));
+            }
+            return this.wrappedKey;
+        }
+
+        public void SetUpKeyWrap(byte[] wrappedKey)
+        {
+            if (this.State != EncryptionState.New)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.BadEncryptionState)));
+            }
+            if (wrappedKey == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("wrappedKey");
+            }
+            this.wrappedKey = wrappedKey;
+            this.State = EncryptionState.Encrypted;
+        }
+
+        protected override void ReadAdditionalAttributes(XmlDictionaryReader reader)
+        {
+            this.recipient = reader.GetAttribute(RecipientAttribute, null);
+        }
+
+        protected override void ReadAdditionalElements(XmlDictionaryReader reader)
+        {
+            if (reader.IsStartElement(ReferenceList.ElementName, EncryptedType.NamespaceUri))
+            {
+                this.referenceList = new ReferenceList();
+                this.referenceList.ReadFrom(reader);
+            }
+            if (reader.IsStartElement(CarriedKeyElementName, EncryptedType.NamespaceUri))
+            {
+                reader.ReadStartElement(CarriedKeyElementName, EncryptedType.NamespaceUri);
+                this.carriedKeyName = reader.ReadString();
+                reader.ReadEndElement();
+            }
+        }
+
+        protected override void ReadCipherData(XmlDictionaryReader reader)
+        {
+            this.wrappedKey = reader.ReadContentAsBase64();
+        }
+
+        protected override void ReadCipherData(XmlDictionaryReader reader, long maxBufferSize)
+        {
+            this.wrappedKey = SecurityUtils.ReadContentAsBase64(reader, maxBufferSize);
+        }
+
+        protected override void WriteAdditionalAttributes(XmlDictionaryWriter writer, DictionaryManager dictionaryManager)
+        {
+            if (this.recipient != null)
+            {
+                writer.WriteAttributeString(RecipientAttribute, null, this.recipient);
+            }
+        }
+
+        protected override void WriteAdditionalElements(XmlDictionaryWriter writer, DictionaryManager dictionaryManager)
+        {
+            if (this.carriedKeyName != null)
+            {
+                writer.WriteStartElement(CarriedKeyElementName, EncryptedType.NamespaceUri);
+                writer.WriteString(this.carriedKeyName);
+                writer.WriteEndElement(); // CarriedKeyName
+            }
+            if (this.referenceList != null)
+            {
+                this.referenceList.WriteTo(writer, dictionaryManager);
+            }
+        }
+
+        protected override void WriteCipherData(XmlDictionaryWriter writer)
+        {
+            writer.WriteBase64(this.wrappedKey, 0, this.wrappedKey.Length);
+        }
+    }
+}