简单的顺序问题 C# 序列化加密

gaogaohui09 2010-11-25 11:04:48

问题：

1.我现在做的是一个传输文件，发送方是先序列化再加密，还是先加密再序列化。这个有要求吗，那种更好？

接收文件也是同样的问题，反序列化和解密的先后顺序。

2. 如果是大文件传输，我需要对小包进行加密和解密，这个顺序呢，是把总的文件加密后，再加密小包吗？同理，接收方！

这是发送文件的代码



 /// <param name="socket" >要发送数据且已经连接到远程主机的 socket</param>                                                        

        /// <param name="fileName">待发送的文件名称</param>                                                                              

        /// <param name="maxBufferLength">文件发送时的缓冲区大小</param>                                                                 

        /// <param name="outTime">发送缓冲区中的数据的超时时间</param>                                                                   

        /// <returns>0:发送文件成功；-1:超时；-2:发送文件出现错误；-3:发送文件出现异常；-4:读取待发送文件发生错误</returns>              

        /// <remarks >                                                                                                                   

        /// 当 outTime 指定为-1时，将一直等待直到有数据需要发送                                                                          

        /// </remarks>  static                                                                                                                 

        public static int SendFile(Socket socket, string fileName, int maxBufferLength, int outTime)

        {

            if (fileName == null || maxBufferLength <= 0)

            {

                throw new ArgumentException("待发送的文件名称为空或发送缓冲区的大小设置不正确.");

            }



            int flag = 0;

            try

            {

                FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read);

                long fileLen = fs.Length;                        // 文件长度     

                long leftLen = fileLen;                          // 未读取部分      

                int readLen = 0;                                 // 已读取部分                                                            

                byte[] buffer = null;



                if (fileLen <= maxBufferLength)

                {            /**//* 文件可以一次读取*/

                    buffer = new byte[fileLen];

                    readLen = fs.Read(buffer, 0, (int)fileLen);

                    flag = SendData(socket, buffer, outTime);

                }

                else

                {                                    /**//* 循环读取文件,并发送 */

                    buffer = new byte[maxBufferLength];

                    while (leftLen != 0)

                    {

                        readLen = fs.Read(buffer, 0, maxBufferLength);

                        if ((flag = SendData(socket, buffer, outTime)) < 0)

                        {

                            break;

                        }

                        leftLen -= readLen;

                    }

                }

                fs.Close();

            }

            catch (IOException e)

            {

                Log.WriteLog(e);

                flag = -4;

            }

            return flag;

        }



        #endregion

这个是序列化和反序列化的类



 public class BufferHelper

    {

        public static byte[] Serialize(object obj)

        {

            BinaryFormatter bf = new BinaryFormatter();

            MemoryStream stream = new MemoryStream();

            bf.Serialize(stream,obj);

            byte[] datas = stream.ToArray();

            stream.Dispose();

            return datas;

        }



        public static object Deserialize(byte[] datas, int index)

        {

            BinaryFormatter bf = new BinaryFormatter();

            MemoryStream stream = new MemoryStream(datas,index,datas.Length - index);

            object obj = bf.Deserialize(stream);

            stream.Dispose();

            return obj;

        }

    }

这是MD5加密类



 public static class MD5Helper

    {

        public static string CretaeMD5(string fileName)

        {

            string hashStr = string.Empty;

            try

            {

                FileStream fs = new FileStream(

                    fileName,

                    FileMode.Open,

                    FileAccess.Read,

                    FileShare.Read);

                MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();

                byte[] hash = md5.ComputeHash(fs);

                hashStr = ByteArrayToHexString(hash);

                fs.Close();

                fs.Dispose();

            }

            catch (Exception ex)

            {

                throw ex;

            }

            return hashStr;

        }



        public static string CretaeMD5(Stream stream)

        {

            MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();

            byte[] hash = md5.ComputeHash(stream);

            return ByteArrayToHexString(hash);

        }



        public static string CretaeMD5(byte[] buffer, int offset, int count)

        {

            MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();

            byte[] hash = md5.ComputeHash(buffer, offset, count);

            return ByteArrayToHexString(hash);

        }



        private static string ByteArrayToHexString(byte[] values)

        {

            StringBuilder sb = new StringBuilder();

            foreach (byte value in values)

            {

                sb.AppendFormat("{0:X2}", value);

            }

            return sb.ToString();

        }

    }