.NET 常用加密、解密& 数字签名算法

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.Serialization.Formatters.Binary;
using System.Security.Cryptography;
using System.Text;

//xlding, 2013/07/25

namespace Gemr.Utils
{
    public class CommonAlgorithms
    {
        #region Sort

        public static string[] BubbleSort(string[] array)
        {
            int length = array.Length;
            for (int i = ; i <= length - ; i++)
            {
                for (int j = length - ; j > i; j--)
                {
                    if (array[j].CompareTo(array[j - ]) < )
                    {
                        string temp = array[j];
                        array[j] = array[j - ];

                        array[j - ] = temp;
                    }
                }
            }
            return array;
        }

        #endregion Sort

        private static char[] constant =
        {
            'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z',
            'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'
        };

        public byte[] ConvertStringToByteArray(string str)
        {
            if (string.IsNullOrEmpty(str)) return null;

            byte[] byteArray = System.Text.Encoding.Default.GetBytes(str);

            return byteArray;

        }

        public static string GenerateRandom(int Length)
        {
            System.Text.StringBuilder newRandom = new System.Text.StringBuilder();
            Random rd = new Random();
            for (int i = ; i < Length; i++)
            {
                newRandom.Append(constant[rd.Next()]);
            }
            return newRandom.ToString();
        }

        /// <summary>
        /// Put the object serialization for byte array
        /// </summary>
        public static byte[] SerializeObject(object obj)
        {
            if (obj == null)
                return null;
            MemoryStream ms = new MemoryStream();
            BinaryFormatter formatter = new BinaryFormatter();
            formatter.Serialize(ms, obj);
            ms.Position = ;
            byte[] bytes = new byte[ms.Length];
            ms.Read(bytes, , bytes.Length);
            ms.Close();
            return bytes;
        }

        /// <summary>
        /// Byte array reverse serialized into object
        /// </summary>
        public static object DeserializeObject(byte[] bytes)
        {
            object obj = null;
            if (bytes == null)
                return obj;
            MemoryStream ms = new MemoryStream(bytes);
            ms.Position = ;
            BinaryFormatter formatter = new BinaryFormatter();
            obj = formatter.Deserialize(ms);
            ms.Close();
            return obj;
        }

        public static string ConvertByteArrayToString(byte[] byteArray)
        {
            if (byteArray == null || byteArray.Length == ) return null;

            string str = System.Text.Encoding.Default.GetString(byteArray);

            return str;
        }

        //public static string ByteToString(byte[] value)
        //{
        //    StringBuilder sb = new StringBuilder();
        //    for (int i = 0; i < value.Length; i++)
        //    {
        //        sb.Append(value[i].ToString("x2"));
        //    }
        //    return sb.ToString();
        //}

        #region SHA1 (数字签名)

        public static string GetSHA1(string strSource)
        {
            string strResult = "";

            //Create
            System.Security.Cryptography.SHA1 sha = System.Security.Cryptography.SHA1.Create();
            byte[] bytResult = sha.ComputeHash(System.Text.Encoding.UTF8.GetBytes(strSource));
            for (int i = ; i < bytResult.Length; i++)
            {
                strResult = strResult + bytResult[i].ToString("X2");
            }
            return strResult;
        }

        public static byte[] GetSHA1(byte[] value)
        {
            System.Security.Cryptography.SHA1 sha = System.Security.Cryptography.SHA1.Create();
            return sha.ComputeHash(value);
        }

        #endregion SHA1

        #region DES

        /**/
        /// <summary>
        /// DES加密
        /// </summary>
        /// <param name="encryptString"></param>
        /// <returns></returns>
        public static string DesEncrypt(string encryptString, string sKey)
        {

            using (DESCryptoServiceProvider des = new DESCryptoServiceProvider())
            {
                byte[] inputByteArray = Encoding.UTF8.GetBytes(encryptString);
                des.Key = ASCIIEncoding.ASCII.GetBytes(sKey);
                des.IV = ASCIIEncoding.ASCII.GetBytes(sKey);
                System.IO.MemoryStream ms = new System.IO.MemoryStream();
                using (CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write))
                {
                    cs.Write(inputByteArray, , inputByteArray.Length);
                    cs.FlushFinalBlock();
                    cs.Close();
                }
                string str = Convert.ToBase64String(ms.ToArray());
                ms.Close();
                return str;
            }

        }

        /**/
        /// <summary>
        /// DES解密
        /// </summary>
        /// <param name="decryptString"></param>
        /// <returns></returns>
        public static string DesDecrypt(string decryptString, string sKey)
        {

            byte[] inputByteArray = Convert.FromBase64String(decryptString);
            using (DESCryptoServiceProvider des = new DESCryptoServiceProvider())
            {
                des.Key = ASCIIEncoding.ASCII.GetBytes(sKey);
                des.IV = ASCIIEncoding.ASCII.GetBytes(sKey);
                System.IO.MemoryStream ms = new System.IO.MemoryStream();
                using (CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write))
                {
                    cs.Write(inputByteArray, , inputByteArray.Length);
                    cs.FlushFinalBlock();
                    cs.Close();
                }
                string str = Encoding.UTF8.GetString(ms.ToArray());
                ms.Close();
                return str;
            }

        }

        #endregion DES

        #region AES

        #region Use static key

        private static readonly byte[] aesKey = { 0x03, 0x00, 0x52, 0xc3, 0x03, 0x00, 0x52, 0xc3, 0x03, 0x00, 0x52, 0xc3, 

                                                    0x03, 0x00, 0x52, 0xc3 };

        public static string StaticAeskey
        {
            get { return System.Text.Encoding.Default.GetString(aesKey); }
        }

        /// <summary>
        /// AES encode.
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public static string AesEncode(string value)
        {
            using (Aes aes = Aes.Create())
            {
                using (ICryptoTransform encryptor = aes.CreateEncryptor(aesKey, aesKey))
                {
                    byte[] buffer = Encoding.UTF8.GetBytes(value);
                    buffer = encryptor.TransformFinalBlock(buffer, , buffer.Length);
                    return Convert.ToBase64String(buffer);
                }
            }
        }

        /// <summary>
        /// AES decode.
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public static string AesDecode(string value)
        {
            using (Aes aes = Aes.Create())
            {
                using (ICryptoTransform decryptor = aes.CreateDecryptor(aesKey, aesKey))
                {
                    byte[] buffer = Convert.FromBase64String(value);
                    buffer = decryptor.TransformFinalBlock(buffer, , buffer.Length);
                    return Encoding.UTF8.GetString(buffer);
                }
            }
        }

        #endregion Use static key

        public static byte[] GetKey()
        {

            Random rd = new Random();
            byte[] key = new byte[];
            rd.NextBytes(key);
            return key;
        }

        public static byte[] AesEncode(byte[] key, byte[] value)
        {
            using (Aes aes = Aes.Create())
            {
                using (ICryptoTransform encryptor = aes.CreateEncryptor(key, key))
                {
                    return encryptor.TransformFinalBlock(value, , value.Length);
                }
            }
        }

        public static byte[] AesDecode(byte[] key, byte[] value)
        {
            using (Aes aes = Aes.Create())
            {
                using (ICryptoTransform decryptor = aes.CreateDecryptor(key, key))
                {
                    return decryptor.TransformFinalBlock(value, , value.Length);
                }
            }
        }

        #endregion AES

    }
}