Cryptography、CRC32、MD5、BASE64：加密解密类库集

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

namespace Beasyer.Lib
{
    /// <summary>
    /// Cryptography 的摘要说明。
    /// </summary>
    public class Cryptography
    {
        //加密KEY
        private static SymmetricAlgorithm key;

        static Cryptography()
        {
            key = new DESCryptoServiceProvider();
        }
        public Cryptography(SymmetricAlgorithm inKey)
        {
            key = inKey;
        }
        /// <summary>
        /// 哈希字符串
        /// </summary>
        /// <param name="pwd"></param>
        /// <returns></returns>
        public static string GetPWDHash(string pwd)
        {
            string ret = "";
            byte[] bpwd = Encoding.ASCII.GetBytes(pwd.Trim());
            byte[] edata;
            SHA256 sha = new SHA256Managed();
            edata = sha.ComputeHash(bpwd);
            ret = Convert.ToBase64String(edata);
            return ret.Trim();
        }

        /// <summary>
        /// 对字符串做对称加密返回加密后的数据
        /// </summary>
        /// <param name="original"></param>
        /// <returns></returns>
        public static string GetEncrypt(string original)
        {
            return Convert.ToBase64String(Encrypt(original, key));
        }
        private static byte[] Encrypt(string PlainText, SymmetricAlgorithm key)
        {
            MemoryStream ms = new MemoryStream();
            CryptoStream encStream = new CryptoStream(ms, key.CreateEncryptor(), CryptoStreamMode.Write);
            StreamWriter sw = new StreamWriter(encStream);
            sw.WriteLine(PlainText);
            sw.Close();
            encStream.Close();
            byte[] buffer = ms.ToArray();
            ms.Close();
            return buffer;
        }

        /// <summary>
        /// 对字符串做对称解密返回解密后的数据
        /// </summary>
        /// <param name="encrypt"></param>
        /// <returns></returns>
        public static string GetDecrypt(string encrypt)
        {
            return Decrypt(Convert.FromBase64String(encrypt), key);
        }
        private static string Decrypt(byte[] CypherText, SymmetricAlgorithm key)
        {
            MemoryStream ms = new MemoryStream(CypherText);
            CryptoStream encStream = new CryptoStream(ms, key.CreateDecryptor(), CryptoStreamMode.Read);
            StreamReader sr = new StreamReader(encStream);
            string val = sr.ReadLine();
            sr.Close();
            encStream.Close();
            ms.Close();
            return val;
        }

        public static string BytesToString(byte[] bs)
        {
            StringBuilder sb = new StringBuilder();
            foreach (byte b in bs)
            {
                sb.Append(b.ToString("000"));
            }
            return sb.ToString();
        }
        public static byte[] StringToBytes(string s)
        {
            int bl = s.Length / 3;
            byte[] bs = new byte[bl];
            for (int i = 0; i < bl; i++)
            {
                bs[i] = byte.Parse(s.Substring(3 * i, 3));
            }
            return bs;
        }
    }
    /// <summary>
    /// CRC 效验
    /// 快速检测算法
    /// </summary>
    public class CRC32
    {
        protected ulong[] crc32Table;

        /// <summary>
        /// 构造：初始化效验表
        /// </summary>
        public CRC32()
        {
            const ulong ulPolynomial = 0xEDB88320;
            ulong dwCrc;
            crc32Table = new ulong[256];
            int i, j;
            for (i = 0; i < 256; i++)
            {
                dwCrc = (ulong)i;
                for (j = 8; j > 0; j--)
                {
                    if ((dwCrc & 1) == 1)
                        dwCrc = (dwCrc >> 1) ^ ulPolynomial;
                    else
                        dwCrc >>= 1;
                }
                crc32Table[i] = dwCrc;
            }
        }

        /// <summary>
        /// 字节数组效验
        /// </summary>
        /// <param name="buffer">ref 字节数组</param>
        /// <returns></returns>
        public ulong ByteCRC(ref byte[] buffer)
        {
            ulong ulCRC = 0xffffffff;
            ulong len;
            len = (ulong)buffer.Length;
            for (ulong buffptr = 0; buffptr < len; buffptr++)
            {
                ulong tabPtr = ulCRC & 0xFF;
                tabPtr = tabPtr ^ buffer[buffptr];
                ulCRC = ulCRC >> 8;
                ulCRC = ulCRC ^ crc32Table[tabPtr];
            }
            return ulCRC ^ 0xffffffff;
        }

        /// <summary>
        /// 字符串效验
        /// </summary>
        /// <param name="sInputString">字符串</param>
        /// <returns></returns>
        public ulong StringCRC(string sInputString)
        {
            byte[] buffer = Encoding.Default.GetBytes(sInputString);
            return ByteCRC(ref buffer);
        }

        /// <summary>
        /// 文件效验
        /// </summary>
        /// <param name="sInputFilename">输入文件</param>
        /// <returns></returns>
        public ulong FileCRC(string sInputFilename)
        {
            FileStream inFile = new FileStream(sInputFilename, FileMode.Open, FileAccess.Read);
            byte[] bInput = new byte[inFile.Length];
            inFile.Read(bInput, 0, bInput.Length);
            inFile.Close();
            return ByteCRC(ref bInput);
        }
    }

    /// <summary>
    /// MD5 无逆向编码
    /// 获取唯一特征串，可用于密码加密
    /// (无法还原)
    /// </summary>
    public class MD5
    {
        public MD5() { }

        /// <summary>
        /// 获取字符串的特征串
        /// </summary>
        /// <param name="sInputString">输入文本</param>
        /// <returns></returns>
        public static string HashString(string sInputString)
        {
            System.Security.Cryptography.MD5 md5 = System.Security.Cryptography.MD5.Create();
            string encoded = BitConverter.ToString(md5.ComputeHash(Encoding.Default.GetBytes(sInputString))).Replace("-", "");
            return encoded;
        }

        /// <summary>
        /// 获取文件的特征串
        /// </summary>
        /// <param name="sInputFilename">输入文件</param>
        /// <returns></returns>
        public string HashFile(string sInputFilename)
        {
            System.Security.Cryptography.MD5 md5 = System.Security.Cryptography.MD5.Create();
            FileStream inFile = new FileStream(sInputFilename, FileMode.Open, FileAccess.Read);
            byte[] bInput = new byte[inFile.Length];
            inFile.Read(bInput, 0, bInput.Length);
            inFile.Close();
            string encoded = BitConverter.ToString(md5.ComputeHash(bInput)).Replace("-", "");
            return encoded;
        }
    }

    /// <summary>
    /// Base64 UUEncoded 编码
    /// 将二进制编码为ASCII文本，用于网络传输
    /// (可还原)
    /// </summary>
    public class BASE64
    {
        public BASE64() { }

        /// <summary>
        /// 解码字符串
        /// </summary>
        /// <param name="sInputString">输入文本</param>
        /// <returns></returns>
        public string DecryptString(string sInputString)
        {
            char[] sInput = sInputString.ToCharArray();
            try
            {
                byte[] bOutput = Convert.FromBase64String(sInputString);
                return Encoding.Default.GetString(bOutput);
            }
            catch (ArgumentNullException)
            {//base 64 字符数组为null
                return "";
            }
            catch (FormatException)
            {//长度错误，无法整除4
                return "";
            }
        }

        /// <summary>
        /// 编码字符串
        /// </summary>
        /// <param name="sInputString">输入文本</param>
        /// <returns></returns>
        public string EncryptString(string sInputString)
        {
            byte[] bInput = Encoding.Default.GetBytes(sInputString);
            try
            {
                return Convert.ToBase64String(bInput, 0, bInput.Length);
            }
            catch (ArgumentNullException)
            {//二进制数组为NULL.
                return "";
            }
            catch (ArgumentOutOfRangeException)
            {//长度不够
                return "";
            }
        }

        /// <summary>
        /// 解码文件
        /// </summary>
        /// <param name="sInputFilename">输入文件</param>
        /// <param name="sOutputFilename">输出文件</param>
        public void DecryptFile(string sInputFilename, string sOutputFilename)
        {
            StreamReader inFile;
            char[] base64CharArray;
            try
            {
                inFile = new StreamReader(sInputFilename, Encoding.ASCII);
                base64CharArray = new char[inFile.BaseStream.Length];
                inFile.Read(base64CharArray, 0, (int)inFile.BaseStream.Length);
                inFile.Close();
            }
            catch //(System.Exception exp)
            {
                return;
            }

            // 转换Base64 UUEncoded为二进制输出
            byte[] binaryData;
            try
            {
                binaryData = Convert.FromBase64CharArray(base64CharArray, 0, base64CharArray.Length);
            }
            catch (ArgumentNullException)
            {//base 64 字符数组为null
                return;
            }
            catch (FormatException)
            {//长度错误，无法整除4
                return;
            }

            // 写输出数据
            FileStream outFile;
            try
            {
                outFile = new FileStream(sOutputFilename, FileMode.Create, FileAccess.Write);
                outFile.Write(binaryData, 0, binaryData.Length);
                outFile.Close();
            }
            catch //(System.Exception exp)
            {//流错误

            }
        }

        /// <summary>
        /// 编码文件
        /// </summary>
        /// <param name="sInputFilename">输入文件</param>
        /// <param name="sOutputFilename">输出文件</param>
        public void EncryptFile(string sInputFilename, string sOutputFilename)
        {
            FileStream inFile;
            byte[] binaryData;
            try
            {
                inFile = new FileStream(sInputFilename, FileMode.Open, FileAccess.Read);
                binaryData = new Byte[inFile.Length];
                long bytesRead = inFile.Read(binaryData, 0,
                    (int)inFile.Length);
                inFile.Close();
            }
            catch //(System.Exception exp)
            {
                return;
            }

            //转换二进制输入为Base64 UUEncoded输出
            //每3个字节在源数据里作为4个字节 
            long arrayLength = (long)((4.0d / 3.0d) * binaryData.Length);

            //如果无法整除4
            if (arrayLength % 4 != 0)
            {
                arrayLength += 4 - arrayLength % 4;
            }

            char[] base64CharArray = new char[arrayLength];
            try
            {
                Convert.ToBase64CharArray(binaryData, 0, binaryData.Length, base64CharArray, 0);
            }
            catch (ArgumentNullException)
            {//二进制数组为NULL.
                return;
            }
            catch (ArgumentOutOfRangeException)
            {//长度不够
                return;
            }

            //写UUEncoded数据到文件内
            StreamWriter outFile;
            try
            {
                outFile = new StreamWriter(sOutputFilename, false, Encoding.ASCII);
                outFile.Write(base64CharArray);
                outFile.Close();
            }
            catch //(System.Exception exp)
            {//文件流出错

            }
        }
    }
}