用C#自已封装的对称加密算法（VS.Net2005）

前几天发送的是在.Net2003下平台下封装的类，今天拿到２００５下竟有错误发生。提示如：

"要解密的数据的长度无效。的错误信息 ",　经过跟踪调试发现，在加密返回字符串前的字节长度与解密字符变成字节数组的长度却不相等，开始百思不得其解，为什么在２００３下面可以用却在２００５下面出现这样的情况，于是继续查找关于编码方面的关相资料。问题原来确实出在编码方式上，原来２００５下加密返回的是Ｂａｓｅ６４编码（即简单讲是所谓３字节变４节的编码方式，即３＊８变成４＊８），我在加密返回字符串时用 Convert.ToBase64String(output);解密字符串前用 byte[] input = Convert.FromBase64String(password);问题得到完美解决（附代码如下：）

using  System;
using  System.Collections.Generic;
using  System.Text;
using  System.Security.Cryptography;
using  System.IO;

namespace  PV.BLL.Security
... {
    /**//// <summary>
    /// 对称加密接口
    /// </summary>
    interface IEncrypt
    ...{
        /**//// <summary>
        /// 加密
        /// </summary>
        /// <param name="password">需加密的字符串</param>
        /// <returns>加密后的字符串</returns>
        string Encrypt(string password);
        /**//// <summary>
        /// 解密
        /// </summary>
        /// <param name="password">需解密的字符串</param>
        /// <returns>解密后的字符串</returns>
        string Decrypt(string password);
        /**//// <summary>
        /// 字节数组加密
        /// </summary>
        /// <param name="passowrd">字节数组</param>
        /// <returns>字节数组</returns>
        byte[] Encrypt(ref byte[] passowrd);
        /**//// <summary>
        /// 字节数组解密
        /// </summary>
        /// <param name="password">字节数组</param>
        /// <returns>字节数组</returns>
        byte[] Decrypt(ref byte[] password);
    }

    /**//// <summary>
    /// 枚举
    /// </summary>
    public enum EncryptType ...{ Rijndael = 0, SHA1 = 1, DES = 2,};

    /**//// <summary>
    /// 对称加密类
    /// </summary>
    public class RijndaelEncrypt : IEncrypt
    ...{
        //加密常量
        private byte[] Key = ...{ 23, 81, 10, 23, 19, 46, 64, 32, 92, 144, 164, 01, 189, 76, 32, 16, 198, 110, 23, 27, 22, 163, 11, 28, 133, 122, 108, 24, 78, 67, 89, 16};
        //加密密钥
        private  byte[] IV = ...{198,110,23,27,22,163,11,28,133,122,108,24,78,67,89,16};
        //加密类成员
        private RijndaelManaged _rijndael;

         public RijndaelEncrypt()
        ...{
            _rijndael = new RijndaelManaged();
        }

        IEncrypt 字符串成员#region IEncrypt 字符串成员       

        /**//// <summary>
        /// 字符串加密
        /// </summary>
        /// <param name="password">密码</param>
        /// <returns>加密字符串</returns>
        public string Encrypt(string password)
        ...{
            byte[] input = UTF8Encoding.UTF8.GetBytes(password);

            byte[] output = this.Encrypt(ref input);
            
            //return UnicodeEncoding.UTF8.GetString(output);
            return Convert.ToBase64String(output);
        }

        /**//// <summary>
        /// 字符串解密
        /// </summary>
        /// <param name="password">需解密的字符串</param>
        /// <returns>返回明文</returns>
        public string Decrypt(string password)
        ...{
            //byte[] input = UTF8Encoding.UTF8.GetBytes(password);
            byte[] input = Convert.FromBase64String(password);

            byte[] output = this.Decrypt(ref input);

            return UnicodeEncoding.UTF8.GetString(output);
        }

        #endregion     
    
        IEncrypt 字节成员#region IEncrypt 字节成员

        /**//// <summary>
        /// 字节数组加密
        /// </summary>
        /// <param name="passowrd">输入字节数组</param>
        /// <returns>返回加密后的数组</returns>
        public byte[] Encrypt(ref byte[] passowrd)
        ...{
            MemoryStream memStream = new MemoryStream();
            CryptoStream cStream = new CryptoStream(memStream, _rijndael.CreateEncryptor(Key, IV), CryptoStreamMode.Write);

            try
            ...{
                cStream.Write(passowrd, 0, passowrd.Length);

                cStream.FlushFinalBlock();
                
                return memStream.ToArray();
            }
            catch (Exception ex)
            ...{
                throw new Exception("加密发生错误:" + ex.Message);
            }
            finally
            ...{
                cStream.Close();
                memStream.Close();
            }
        }

        /**//// <summary>
        /// 字节数组解密
        /// </summary>
        /// <param name="password">输入已加密的字节数组</param>
        /// <returns>返回解密后的数组</returns>
        public byte[] Decrypt(ref byte[] password)
        ...{
            MemoryStream memStream = new MemoryStream(password, 0, password.Length);
            CryptoStream cStream = new CryptoStream(memStream, _rijndael.CreateDecryptor(Key, IV), CryptoStreamMode.Read);
            StreamReader sr = new StreamReader(cStream);

            try
            ...{
                byte[] result = UnicodeEncoding.UTF8.GetBytes(sr.ReadToEnd());

                return result;
            }
            catch (Exception ex)
            ...{
                throw new Exception("解密发生错误:" + ex.Message);
            }
            finally
            ...{
                sr.Close();
                cStream.Close();
                memStream.Close();
            }
        }
        #endregion
    }

    /**//// <summary>
    /// 对应加解密类　采用策略模式
    /// </summary>
    public class PVEncrypt : IEncrypt 
    ...{
        private  IEncrypt _encrypt;
        private  RijndaelEncrypt _rijndael;

        public PVEncrypt()
        ...{
            _rijndael = new RijndaelEncrypt();
            _encrypt = (IEncrypt)_rijndael;
        }

        public PVEncrypt(EncryptType type)
        ...{
            switch (type)
            ...{               
                case EncryptType.SHA1:
                    throw new Exception("还未实现ＳＨＡ１加密算法");
                case EncryptType.DES:
                    throw new Exception("还未实现ＤＥＳ加密算法");
                case EncryptType.Rijndael:           
                default:
                    _rijndael = new RijndaelEncrypt();
                    _encrypt = (IEncrypt)_rijndael;
                    break;
            }
        }

        IEncrypt 成员#region IEncrypt 成员

        public string Encrypt(string password)
        ...{
            return _encrypt.Encrypt(password);
        }

        public string Decrypt(string password)
        ...{
            return _encrypt.Decrypt(password);
        }

        public byte[] Encrypt(ref byte[] passowrd)
        ...{
            return _encrypt.Encrypt(ref passowrd);
        }

        public byte[] Decrypt(ref byte[] password)
        ...{
            return _encrypt.Decrypt(ref password);
        }

        #endregion
    }
}