加密与解密 base64图片转换

 public sealed class EncryptHelper
    {
        const string sou = "hellowor";
        static byte[] rgbKey = null;
        static byte[] rgbIV = null;
        static EncryptHelper()
        {
            rgbKey = Encoding.ASCII.GetBytes(sou);
            rgbIV = rgbKey;
        }

        public static string Key
        {
            set { rgbKey = Encoding.ASCII.GetBytes(value); }
        }

        public static string IV
        {
            set { rgbIV = Encoding.ASCII.GetBytes(value); }
        }

        public static string GetBase64FromImageFile(string imagePath)
        {
            if (!File.Exists(imagePath)) return string.Empty;
            byte[] buffer = File.ReadAllBytes(imagePath);
            return Convert.ToBase64String(buffer);
        }

        public static string GetBase64FromImage(Image img)
        {
            if (img == null) return null;
            Bitmap bmp = new Bitmap(img);
            MemoryStream ms = new MemoryStream();
            bmp.Save(ms, ImageFormat.Bmp);
            byte[] buf = ms.ToArray();
            ms.Close();
            return Convert.ToBase64String(buf);
        }

        public static Image GetImageFromBase64(string imageString)
        {
            if (string.IsNullOrWhiteSpace(imageString)) return null;
            byte[] buf = Convert.FromBase64String(imageString);
            MemoryStream ms = new MemoryStream(buf);
            Bitmap bmp = new Bitmap(ms);
            ms.Close();
            return bmp;
        }

        public static string Encode(string data)
        {
            MemoryStream ms = new MemoryStream();
            DESCryptoServiceProvider des = new DESCryptoServiceProvider();
            CryptoStream cst = new CryptoStream(ms, des.CreateEncryptor(rgbKey, rgbIV), CryptoStreamMode.Write);
            StreamWriter sw = new StreamWriter(cst);
            sw.WriteLine(data);
            sw.Close();
            cst.Close();
            byte[] ret = ms.ToArray();
            ms.Close();
            return Convert.ToBase64String(ret);
        }

        public static string Decode(string data)
        {
            byte[] by = Convert.FromBase64String(data);
            MemoryStream ms = new MemoryStream(by);
            DESCryptoServiceProvider des = new DESCryptoServiceProvider();
            CryptoStream cst = new CryptoStream(ms, des.CreateDecryptor(rgbKey, rgbIV), CryptoStreamMode.Read);
            StreamReader sr = new StreamReader(cst);
            string ret = sr.ReadLine();
            sr.Close();
            cst.Close();
            ms.Close();
            return ret;
        }

        //MD5不可逆加密   //32位加密   
        public static string GetMD5_32(string s, string charset)
        {
            MD5 md5 = new MD5CryptoServiceProvider();
            byte[] t = md5.ComputeHash(Encoding.GetEncoding(charset).GetBytes(s));
            StringBuilder sb = new StringBuilder(32);
            for (int i = 0; i < t.Length; i++)
                sb.Append(t[i].ToString("x2"));
            return sb.ToString();
        }

        //MD5不可逆加密 //16位加密   
        public static string GetMd5_16(string ConvertString)
        {
            MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
            string t2 = BitConverter.ToString(md5.ComputeHash(UTF8Encoding.Default.GetBytes(ConvertString)), 4, 8);
            t2 = t2.Replace("-", "");
            return t2;
        }

        /// <summary>
        /// Base64加密
        /// </summary>
        /// <param name="codeName">加密采用的编码方式</param>
        /// <param name="source">待加密的明文</param>
        /// <returns></returns>
        public static string EncodeBase64(Encoding encode, string source)
        {
            string tmp = string.Empty;
            byte[] bytes = encode.GetBytes(source);
            try
            {
                tmp = Convert.ToBase64String(bytes);
            }
            catch
            {
                tmp = source;
            }
            return tmp;
        }

        /// <summary>
        /// Base64加密，采用utf8编码方式加密
        /// </summary>
        /// <param name="source">待加密的明文</param>
        /// <returns>加密后的字符串</returns>
        public static string EncodeBase64(string source)
        {
            return EncodeBase64(Encoding.UTF8, source);
        }

        /// <summary>
        /// Base64解密
        /// </summary>
        /// <param name="codeName">解密采用的编码方式，注意和加密时采用的方式一致</param>
        /// <param name="result">待解密的密文</param>
        /// <returns>解密后的字符串</returns>
        public static string DecodeBase64(Encoding encode, string result)
        {
            string decode = "";
            byte[] bytes = Convert.FromBase64String(result);
            try
            {
                decode = encode.GetString(bytes);
            }
            catch
            {
                decode = result;
            }
            return decode;
        }

        /// <summary>
        /// Base64解密，采用utf8编码方式解密
        /// </summary>
        /// <param name="result">待解密的密文</param>
        /// <returns>解密后的字符串</returns>
        public static string DecodeBase64(string result)
        {
            return DecodeBase64(Encoding.UTF8, result);
        }
    }