使用C#加密及解密字符串

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

 namespace Utility
 {
     /// <summary>
     /// http://stackoverflow.com/questions/202011/encrypt-and-decrypt-a-string
     /// </summary>
     public class Encryptor
     {
         private static byte[] _salt = Encoding.ASCII.GetBytes("o6806642kbM7c5"); // update by yourself

         public static string Encrypt(string text)
         {
             var s = DateTime.Now.Year.ToString().Substring(, );
             return EncryptStringAES(text, s);
         }

         public static string Decrypt(string text)
         {
             var s = DateTime.Now.Year.ToString().Substring(, );
             return DecryptStringAES(text, s);
         }

         /// <summary>
         /// Encrypt the given string using AES.  The string can be decrypted using
         /// DecryptStringAES().  The sharedSecret parameters must match.
         /// </summary>
         /// <param name="plainText">The text to encrypt.</param>
         /// <param name="sharedSecret">A password used to generate a key for encryption.</param>
         public static string EncryptStringAES(string plainText, string sharedSecret)
         {
             if (string.IsNullOrEmpty(plainText))
                 throw new ArgumentNullException("plainText");
             if (string.IsNullOrEmpty(sharedSecret))
                 throw new ArgumentNullException("sharedSecret");

             string outStr = null;                       // Encrypted string to return
             RijndaelManaged aesAlg = null;              // RijndaelManaged object used to encrypt the data.

             try
             {
                 // generate the key from the shared secret and the salt
                 Rfc2898DeriveBytes key = new Rfc2898DeriveBytes(sharedSecret, _salt);

                 // Create a RijndaelManaged object
                 aesAlg = new RijndaelManaged();
                 aesAlg.Key = key.GetBytes(aesAlg.KeySize / );

                 // Create a decryptor to perform the stream transform.
                 ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);

                 // Create the streams used for encryption.
                 using (MemoryStream msEncrypt = new MemoryStream())
                 {
                     // prepend the IV
                     msEncrypt.Write(BitConverter.GetBytes(aesAlg.IV.Length), , sizeof(int));
                     msEncrypt.Write(aesAlg.IV, , aesAlg.IV.Length);
                     using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                     {
                         using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                         {
                             //Write all data to the stream.
                             swEncrypt.Write(plainText);
                         }
                     }
                     outStr = Convert.ToBase64String(msEncrypt.ToArray());
                 }
             }
             finally
             {
                 // Clear the RijndaelManaged object.
                 if (aesAlg != null)
                     aesAlg.Clear();
             }

             // Return the encrypted bytes from the memory stream.
             return outStr;
         }

         /// <summary>
         /// Decrypt the given string.  Assumes the string was encrypted using
         /// EncryptStringAES(), using an identical sharedSecret.
         /// </summary>
         /// <param name="cipherText">The text to decrypt.</param>
         /// <param name="sharedSecret">A password used to generate a key for decryption.</param>
         public static string DecryptStringAES(string cipherText, string sharedSecret)
         {
             if (string.IsNullOrEmpty(cipherText))
                 throw new ArgumentNullException("cipherText");
             if (string.IsNullOrEmpty(sharedSecret))
                 throw new ArgumentNullException("sharedSecret");

             // Declare the RijndaelManaged object
             // used to decrypt the data.
             RijndaelManaged aesAlg = null;

             // Declare the string used to hold
             // the decrypted text.
             string plaintext = null;

             try
             {
                 // generate the key from the shared secret and the salt
                 Rfc2898DeriveBytes key = new Rfc2898DeriveBytes(sharedSecret, _salt);

                 // Create the streams used for decryption.
                 byte[] bytes = Convert.FromBase64String(cipherText);
                 using (MemoryStream msDecrypt = new MemoryStream(bytes))
                 {
                     // Create a RijndaelManaged object
                     // with the specified key and IV.
                     aesAlg = new RijndaelManaged();
                     aesAlg.Key = key.GetBytes(aesAlg.KeySize / );
                     // Get the initialization vector from the encrypted stream
                     aesAlg.IV = ReadByteArray(msDecrypt);
                     // Create a decrytor to perform the stream transform.
                     ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);
                     using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
                     {
                         using (StreamReader srDecrypt = new StreamReader(csDecrypt))

                             // Read the decrypted bytes from the decrypting stream
                             // and place them in a string.
                             plaintext = srDecrypt.ReadToEnd();
                     }
                 }
             }
             finally
             {
                 // Clear the RijndaelManaged object.
                 if (aesAlg != null)
                     aesAlg.Clear();
             }

             return plaintext;
         }

         private static byte[] ReadByteArray(Stream s)
         {
             byte[] rawLength = new byte[sizeof(int)];
             if (s.Read(rawLength, , rawLength.Length) != rawLength.Length)
             {
                 throw new SystemException("Stream did not contain properly formatted byte array");
             }

             byte[] buffer = new byte[BitConverter.ToInt32(rawLength, )];
             if (s.Read(buffer, , buffer.Length) != buffer.Length)
             {
                 throw new SystemException("Did not read byte array properly");
             }

             return buffer;
         }
     }
 }

Encryp and decrypt a string via C#