WCF 进阶: 对称加密传输

  大家使用WCF的时候，会不会觉得使用SSL通道传输太麻烦，使用明文传输又觉得不安全呢？ 特别是当传递的消息中带有比较敏感，机密的身份信息的时候更是如此呢？我们在上文实现了压缩编码传输，详见WCF进阶:将编码后的字节流压缩传输，本文照葫芦画瓢，实现一个可能大家更为需要的功能，将数据对称加密后传输，好处就是加密速度嗷嗷快，使用起来嗷嗷方便。

  工作原理和压缩传输一致所以本文不做赘述，详细的实现机理会单开一篇详细去谈，本文重点看看实现代码和实现效果。要实现对称机密传输的功能，我们主要要实现的有如下几个类：CryptEncodingBindingElement，CryptEncoderFactory，CryptEncoder，DESCryption，前面三项都是WCF扩展所必须的，后面是工具类，主要是用于DES加解密和生成密钥和IV。

CryptEncodingBindingElement

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Xml;

using System.ServiceModel.Channels;



namespace RobinLib

{

    public class CryptEncodingBindingElement: MessageEncodingBindingElement

    { 

        private XmlDictionaryReaderQuotas readerQuotas;

        private MessageEncodingBindingElement innerMessageEncodingBindingElement;

        string key;

        string iv; 

        public MessageEncodingBindingElement InnerMessageEncodingBindingElement

        {

            get

            {

                return innerMessageEncodingBindingElement;

            }

        }



        public string Key

        {

            get

            {

                return key;

            }

        }

        public string IV

        {

            get

            {

                return iv;

            }

        }



        public CryptEncodingBindingElement(MessageEncodingBindingElement innerMessageEncodingBindingElement, string key,string iv)

        {

            this.readerQuotas = new XmlDictionaryReaderQuotas();

            this.key = key;

            this.iv = iv;

            this.innerMessageEncodingBindingElement = innerMessageEncodingBindingElement;

        }



        public override IChannelFactory<TChannel> BuildChannelFactory<TChannel>(BindingContext context)

        {

            context.BindingParameters.Add(this);

            return context.BuildInnerChannelFactory<TChannel>();

        }

        public override IChannelListener<TChannel> BuildChannelListener<TChannel>(BindingContext context)

        {

            context.BindingParameters.Add(this);

            return context.BuildInnerChannelListener<TChannel>();

        }

        public override bool CanBuildChannelFactory<TChannel>(BindingContext context)

        {

            context.BindingParameters.Add(this);

            return context.CanBuildInnerChannelFactory<TChannel>();

        }

        public override bool CanBuildChannelListener<TChannel>(BindingContext context)

        {

            context.BindingParameters.Add(this);

            return context.CanBuildInnerChannelListener<TChannel>();

        }

        public override MessageEncoderFactory CreateMessageEncoderFactory()

        {

            return new CryptEncoderFactory(innerMessageEncodingBindingElement,key,iv);

        }

        public override T GetProperty<T>(BindingContext context)  

        {

            if (typeof(T) == typeof(XmlDictionaryReaderQuotas))

            {

                return this.readerQuotas as T;

            }

            return base.GetProperty<T>(context);



        }

        public override MessageVersion MessageVersion

        {

            get

            {

                return innerMessageEncodingBindingElement.MessageVersion;

            }

            set

            {

                innerMessageEncodingBindingElement.MessageVersion = value;

            }

        }

        

        public override BindingElement Clone()

        {

            return new CryptEncodingBindingElement(innerMessageEncodingBindingElement,key,iv);

        } 

    }

}

CryptEncoderFactory

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.ServiceModel.Channels;



namespace RobinLib

{

    public class CryptEncoderFactory : MessageEncoderFactory

    {

        private MessageEncodingBindingElement innerMessageEncodingBindingElement;

        CryptEncoder messageEncoder;

        string key;

        string iv; 

        public CryptEncoderFactory(MessageEncodingBindingElement innerMessageEncodingBindingElement, string key,string iv)

        {

            this.innerMessageEncodingBindingElement = innerMessageEncodingBindingElement;

            this.key = key;

            this.iv = iv;

            messageEncoder = new CryptEncoder(this,key, iv);

        }

        public override MessageEncoder CreateSessionEncoder()

        {

            return base.CreateSessionEncoder();

        }

        public override MessageEncoder Encoder

        {

            get { return messageEncoder; }

        }

        public override MessageVersion MessageVersion

        {

            get { return innerMessageEncodingBindingElement.MessageVersion; }

        }

        public MessageEncodingBindingElement InnerMessageEncodingBindingElement

        {

            get

            {

                return innerMessageEncodingBindingElement;

            }

        }

    }

}

CryptEncoder

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.ServiceModel.Channels;

using System.IO;



namespace RobinLib

{

    public class CryptEncoder : MessageEncoder

    {

        CryptEncoderFactory factory;

        MessageEncoder innserEncoder;

        string key;

        string iv;

        public CryptEncoder(CryptEncoderFactory encoderFactory,string key,string iv)

        {

            factory = encoderFactory;

            this.key = key;

            this.iv = iv;

            innserEncoder = factory.InnerMessageEncodingBindingElement.CreateMessageEncoderFactory().Encoder;

        }

        public override string ContentType

        {

            get { return innserEncoder.ContentType; }

        }

        public override string MediaType

        {

            get { return innserEncoder.MediaType; }

        }

        public override MessageVersion MessageVersion

        {

            get { return innserEncoder.MessageVersion; }

        }

        public override bool IsContentTypeSupported(string contentType)

        {

            return innserEncoder.IsContentTypeSupported(contentType);

        }

        public override T GetProperty<T>()

        {

            return innserEncoder.GetProperty<T>();

        }

        public override Message ReadMessage(ArraySegment<byte> buffer, BufferManager bufferManager, string contentType)

        {

            ArraySegment<byte> bytes = new DESCryption(key,iv).Decrypt(buffer);

            int totalLength = bytes.Count;

            byte[] totalBytes = bufferManager.TakeBuffer(totalLength);

            Array.Copy(bytes.Array, 0, totalBytes, 0, bytes.Count);

            ArraySegment<byte> byteArray = new ArraySegment<byte>(totalBytes, 0, bytes.Count);

            bufferManager.ReturnBuffer(byteArray.Array); 

            Message msg = innserEncoder.ReadMessage(byteArray, bufferManager, contentType);

            return msg;



        }

        public override Message ReadMessage(System.IO.Stream stream, int maxSizeOfHeaders, string contentType)

        {

            //读取消息的时候，二进制流为加密的，需要解压

            Stream ms = new DESCryption(key,iv).Decrypt(stream); 

            Message msg = innserEncoder.ReadMessage(ms, maxSizeOfHeaders, contentType);

            return msg;

        }

        public override ArraySegment<byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset)

        { 

            ArraySegment<byte> bytes = innserEncoder.WriteMessage(message, maxMessageSize, bufferManager);

            ArraySegment<byte> buffer = new DESCryption(key,iv).Encrypt(bytes);

            int totalLength = buffer.Count + messageOffset;

            byte[] totalBytes = bufferManager.TakeBuffer(totalLength);

            Array.Copy(buffer.Array, 0, totalBytes, messageOffset, buffer.Count);

            ArraySegment<byte> byteArray = new ArraySegment<byte>(totalBytes, messageOffset, buffer.Count);

            Console.WriteLine(",原来字节流大小:"+bytes.Count+",压缩后字节流大小:"+byteArray.Count);

            return byteArray;

        }

        public override void WriteMessage(Message message, System.IO.Stream stream)

        {

            System.IO.MemoryStream ms = new System.IO.MemoryStream();

            innserEncoder.WriteMessage(message, ms);

            stream = new DESCryption(key,iv).Encrypt(ms);

        }

    }

}

DESCryption

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Security.Cryptography;

using System.IO;



namespace RobinLib

{

    public class DESCryption : IDisposable

    {

        DESCryptoServiceProvider des;

        Encoding encoding = new UnicodeEncoding();

        public DESCryption()

        {



        }

        public DESCryption(string key, string iv)

        {

            des = new DESCryptoServiceProvider();

            des.Key = Convert.FromBase64String(key);

            des.IV = Convert.FromBase64String(iv);

        }

        public void Dispose()

        {

            des.Clear();

        }

        public void GenerateKey(out string key, out string iv)

        {

            key = "";

            iv = "";

            using (DESCryptoServiceProvider des_o = new DESCryptoServiceProvider())

            {

                des_o.GenerateIV();

                des_o.GenerateKey();

                iv = Convert.ToBase64String(des_o.IV);

                key = Convert.ToBase64String(des_o.Key);

            }

        }

        #region ========加密========

        /// <summary> 

        /// 加密数据 

        /// </summary> 

        /// <param name="Text"></param> 

        /// <param name="sKey"></param> 

        /// <returns></returns> 

        public string Encrypt(string Text)

        {

            MemoryStream ms = new MemoryStream();

            CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write);

            StreamWriter sw = new StreamWriter(cs);

            sw.Write(Text);

            sw.Close();

            cs.Close();

            byte[] buffer = ms.ToArray();

            ms.Close();

            return Convert.ToBase64String(buffer);

        }



        public ArraySegment<byte> Encrypt(ArraySegment<byte> buffers)

        { 

            MemoryStream ms = new MemoryStream();

            CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write);

            cs.Write(buffers.Array, 0, buffers.Count); 

            cs.Close();

            byte[] buffer = ms.ToArray();

            ms.Close(); 

            ArraySegment<byte> bytes = new ArraySegment<byte>(buffer); 

            return bytes;

        }



        public Stream Encrypt(Stream stream)

        {

            MemoryStream ms = new MemoryStream(); 

            CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write);

            byte[] buffer = new byte[stream.Length];

            stream.Read(buffer, 0, buffer.Length);

            cs.Write(buffer, 0, buffer.Length);

            cs.Close(); 

            return ms;

        }



        #endregion



        #region ========解密========

        /// <summary> 

        /// 解密数据 

        /// </summary> 

        /// <param name="Text"></param> 

        /// <param name="sKey"></param> 

        /// <returns></returns> 

        public string Decrypt(string Text)

        {

            byte[] inputByteArray = Convert.FromBase64String(Text);

            System.IO.MemoryStream ms = new System.IO.MemoryStream(inputByteArray);

            CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Read);

            StreamReader sr = new StreamReader(cs);

            string val = sr.ReadLine();

            cs.Close();

            ms.Close();

            des.Clear();

            return val;

        }

        public ArraySegment<byte> Decrypt(ArraySegment<byte> buffers)

        {

            MemoryStream ms = new MemoryStream();

            ms.Write(buffers.Array, 0, buffers.Count);

            ms.Seek(0, SeekOrigin.Begin);

            CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Read);

            byte[] buffer = RetrieveBytesFromStream(cs, 1024);

            ms.Close();

            ArraySegment<byte> bytes = new ArraySegment<byte>(buffer);

            return bytes;

        }

        public Stream Decrypt(Stream stream)

        {

            stream.Seek(0, SeekOrigin.Begin);

            MemoryStream ms = new MemoryStream();

            Stream compressStream = new CryptoStream(stream, des.CreateDecryptor(), CryptoStreamMode.Read);

            byte[] newByteArray = RetrieveBytesFromStream(compressStream, 1);

            compressStream.Close();

            return new MemoryStream(newByteArray);

        }

        public static byte[] RetrieveBytesFromStream(Stream stream, int bytesblock)

        {



            List<byte> lst = new List<byte>();

            byte[] data = new byte[1024];

            int totalCount = 0;

            while (true)

            {

                int bytesRead = stream.Read(data, 0, data.Length);

                if (bytesRead == 0)

                {

                    break;

                }

                byte[] buffers = new byte[bytesRead];

                Array.Copy(data, buffers, bytesRead);

                lst.AddRange(buffers);

                totalCount += bytesRead;

            }

            return lst.ToArray();

        }

        #endregion



        #region IDisposable 成员



        void IDisposable.Dispose()

        {

            if (des != null)

            {

                des.Clear();

            }

        }



        #endregion

    }

}

宿主

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.ServiceModel;

using Robin_Wcf_CustomMessageEncoder_SvcLib;

using System.ServiceModel.Channels;

using RobinLib;



namespace Robin_Wcf_CustomMessageEncoder_Host

{

    class Program

    {

        static void Main(string[] args)

        {

            //服务地址

            Uri baseAddress = new Uri("http://127.0.0.1:8081/Robin_Wcf_Formatter");

            ServiceHost host = new ServiceHost(typeof(Service1), new Uri[] { baseAddress });

            //服务绑定

            ICollection<BindingElement> bindingElements = new List<BindingElement>();

            HttpTransportBindingElement httpBindingElement = new HttpTransportBindingElement();

            string key = "JggkieIw7JM=";

            string iv = "XdTkT85fZ0U=";

            CryptEncodingBindingElement textBindingElement = new CryptEncodingBindingElement(new BinaryMessageEncodingBindingElement(), key,iv);

            bindingElements.Add(textBindingElement);

            bindingElements.Add(httpBindingElement);

            CustomBinding bind = new CustomBinding(bindingElements);  

            host.AddServiceEndpoint(typeof(IService1), bind, "");

            if (host.Description.Behaviors.Find<System.ServiceModel.Description.ServiceMetadataBehavior>() == null)

            {

                System.ServiceModel.Description.ServiceMetadataBehavior svcMetaBehavior = new System.ServiceModel.Description.ServiceMetadataBehavior();

                svcMetaBehavior.HttpGetEnabled = true;

                svcMetaBehavior.HttpGetUrl = new Uri("http://127.0.0.1:8001/Mex");

                host.Description.Behaviors.Add(svcMetaBehavior);

            }

            host.Opened += new EventHandler(delegate(object obj, EventArgs e)

            {

                Console.WriteLine("服务已经启动！");

            }); 

            host.Open();

            Console.Read();

        }

    }

}

客户端

 

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using RobinLib;

using System.ServiceModel.Channels;

using Robin_Wcf_CustomMessageEncoder_ClientApp.ServiceReference1;



namespace Robin_Wcf_CustomMessageEncoder_ClientApp

{

    class Program

    {

        static void Main(string[] args)

        {

            System.Threading.Thread.Sleep(5300);

            ICollection<BindingElement> bindingElements = new List<BindingElement>();

            HttpTransportBindingElement httpBindingElement = new HttpTransportBindingElement();

            string key = "JggkieIw7JM=";

            string iv = "XdTkT85fZ0U=";

            CryptEncodingBindingElement textBindingElement = new CryptEncodingBindingElement(new BinaryMessageEncodingBindingElement(), key, iv);

            bindingElements.Add(textBindingElement);

            bindingElements.Add(httpBindingElement); 

            CustomBinding bind = new CustomBinding(bindingElements);  

            ServiceReference1.IService1 svc = new ServiceReference1.Service1Client(bind, new System.ServiceModel.EndpointAddress("http://127.0.0.1:8081/Robin_Wcf_Formatter"));

            string pres = svc.GetData(10);

            Console.WriteLine(pres);

            CompositeType ct = svc.GetDataUsingDataContract(new CompositeType());

            System.IO.MemoryStream ms = new System.IO.MemoryStream();

            for (int i = 0; i < 1000000; i++)

            {

                byte[] buffer = BitConverter.GetBytes(i);

                ms.Write(buffer, 0, buffer.Length);

            }

            System.IO.Stream stream = svc.GetStream(ms);

            Console.Read();

        }

    }

}

运行效果图：

 

生成key和iv的方法为：

public void GenerateKey(out string key, out string iv)

{

    key = "";

    iv = "";

    using (DESCryptoServiceProvider des_o = new DESCryptoServiceProvider())

    {

        des_o.GenerateIV();

        des_o.GenerateKey();

        iv = Convert.ToBase64String(des_o.IV);

        key = Convert.ToBase64String(des_o.Key);

    }

}

项目文档：点击这里下载