zoukankan      html  css  js  c++  java
  • AES加密解密 加密解密使用

    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.Linq;
    using System.Security.Cryptography;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace Mask
    {
        public class AESEncryptHelper
        {
    
            /// <summary>
            /// 获取密钥
            /// </summary>
            private static string Key
            {
                get { return @")O[NB]6,YF}+efcaj{+oESb9d8>Z'e9M"; }
            }
    
            /// <summary>
            /// 获取向量
            /// </summary>
            private static string IV
            {
                get { return @"L+~f4,Ir)b$=pkf"; }
            }
    
            #region 参数是byte[]类型
            /// <summary>
            /// AES加密
            /// </summary>
            /// <param name="Data">被加密的明文</param>
            /// <param name="Key">密钥</param>
            /// <param name="Vector">向量</param>
            /// <returns>密文</returns>
            public static Byte[] AESEncrypt(Byte[] Data, String Key, String Vector)
            {
                Byte[] bKey = new Byte[32];
                Array.Copy(Encoding.UTF8.GetBytes(Key.PadRight(bKey.Length)), bKey, bKey.Length);
                Byte[] bVector = new Byte[16];
                Array.Copy(Encoding.UTF8.GetBytes(Vector.PadRight(bVector.Length)), bVector, bVector.Length);
                Byte[] Cryptograph = null; // 加密后的密文
                Rijndael Aes = Rijndael.Create();
                try
                {
                    // 开辟一块内存流
                    using (MemoryStream Memory = new MemoryStream())
                    {
                        // 把内存流对象包装成加密流对象
                        using (CryptoStream Encryptor = new CryptoStream(Memory,
                         Aes.CreateEncryptor(bKey, bVector),
                         CryptoStreamMode.Write))
                        {
                            // 明文数据写入加密流
                            Encryptor.Write(Data, 0, Data.Length);
                            Encryptor.FlushFinalBlock();
    
                            Cryptograph = Memory.ToArray();
                        }
                    }
                }
                catch
                {
                    Cryptograph = null;
                }
                return Cryptograph;
            }
    
            /// <summary>
            /// AES解密
            /// </summary>
            /// <param name="Data">被解密的密文</param>
            /// <param name="Key">密钥</param>
            /// <param name="Vector">向量</param>
            /// <returns>明文</returns>
            public static Byte[] AESDecrypt(Byte[] Data, String Key, String Vector)
            {
                Byte[] bKey = new Byte[32];
                Array.Copy(Encoding.UTF8.GetBytes(Key.PadRight(bKey.Length)), bKey, bKey.Length);
                Byte[] bVector = new Byte[16];
                Array.Copy(Encoding.UTF8.GetBytes(Vector.PadRight(bVector.Length)), bVector, bVector.Length);
    
                Byte[] original = null; // 解密后的明文
    
                Rijndael Aes = Rijndael.Create();
                try
                {
                    // 开辟一块内存流,存储密文
                    using (MemoryStream Memory = new MemoryStream(Data))
                    {
                        // 把内存流对象包装成加密流对象
                        using (CryptoStream Decryptor = new CryptoStream(Memory,
                        Aes.CreateDecryptor(bKey, bVector),
                        CryptoStreamMode.Read))
                        {
                            // 明文存储区
                            using (MemoryStream originalMemory = new MemoryStream())
                            {
                                Byte[] Buffer = new Byte[1024];
                                Int32 readBytes = 0;
                                while ((readBytes = Decryptor.Read(Buffer, 0, Buffer.Length)) > 0)
                                {
                                    originalMemory.Write(Buffer, 0, readBytes);
                                }
    
                                original = originalMemory.ToArray();
                            }
                        }
                    }
                }
                catch
                {
                    original = null;
                }
                return original;
            }
    
            #endregion
    
            #region 参数是string类型
    
    
    
            /// <summary>
            /// AES加密
            /// </summary>
            /// <param name="plainStr">明文字符串</param>
            /// <returns>密文</returns>
            public static string AESEncrypt(string plainStr)
            {
                byte[] bKey = Encoding.UTF8.GetBytes(Key);
                byte[] bIV = Encoding.UTF8.GetBytes(IV);
                byte[] byteArray = Encoding.UTF8.GetBytes(plainStr);
    
                string encrypt = null;
                Rijndael aes = Rijndael.Create();
                using (MemoryStream mStream = new MemoryStream())
                {
                    using (CryptoStream cStream = new CryptoStream(mStream, aes.CreateEncryptor(bKey, bIV), CryptoStreamMode.Write))
                    {
                        cStream.Write(byteArray, 0, byteArray.Length);
                        cStream.FlushFinalBlock();
                        encrypt = Convert.ToBase64String(mStream.ToArray());
                    }
                }
                aes.Clear();
                return encrypt;
            }
    
            /// <summary>
            /// AES加密
            /// </summary>
            /// <param name="plainStr">明文字符串</param>
            /// <param name="returnNull">加密失败时是否返回 null,false 返回 String.Empty</param>
            /// <returns>密文</returns>
            public static string AESEncrypt(string plainStr, bool returnNull)
            {
                string encrypt = AESEncrypt(plainStr);
                return returnNull ? encrypt : (encrypt == null ? String.Empty : encrypt);
            }
    
            /// <summary>
            /// AES解密
            /// </summary>
            /// <param name="encryptStr">密文字符串</param>
            /// <returns>明文</returns>
            public static string AESDecrypt(string encryptStr)
            {
                byte[] bKey = Encoding.UTF8.GetBytes(Key);
                byte[] bIV = Encoding.UTF8.GetBytes(IV);
                byte[] byteArray = Convert.FromBase64String(encryptStr);
    
                string decrypt = null;
                Rijndael aes = Rijndael.Create();
                using (MemoryStream mStream = new MemoryStream())
                {
                    using (CryptoStream cStream = new CryptoStream(mStream, aes.CreateDecryptor(bKey, bIV), CryptoStreamMode.Write))
                    {
                        cStream.Write(byteArray, 0, byteArray.Length);
                        cStream.FlushFinalBlock();
                        decrypt = Encoding.UTF8.GetString(mStream.ToArray());
                    }
                }
                aes.Clear();
                return decrypt;
            }
    
            /// <summary>
            /// AES解密
            /// </summary>
            /// <param name="encryptStr">密文字符串</param>
            /// <param name="returnNull">解密失败时是否返回 null,false 返回 String.Empty</param>
            /// <returns>明文</returns>
            public static string AESDecrypt(string encryptStr, bool returnNull)
            {
                string decrypt = AESDecrypt(encryptStr);
                return returnNull ? decrypt : (decrypt == null ? String.Empty : decrypt);
            }
    
    
            #endregion
    
            #region 256位AES加密算法
    
            /// <summary>
            /// 256位AES加密
            /// </summary>
            /// <param name="toEncrypt"></param>
            /// <returns></returns>
            public static string Encrypt(string toEncrypt)
            {
                // 256-AES key    
                byte[] keyArray = UTF8Encoding.UTF8.GetBytes(Key);
                byte[] toEncryptArray = UTF8Encoding.UTF8.GetBytes(toEncrypt);
    
                RijndaelManaged rDel = new RijndaelManaged();
                rDel.Key = keyArray;
                rDel.Mode = CipherMode.ECB;
                rDel.Padding = PaddingMode.PKCS7;
    
                ICryptoTransform cTransform = rDel.CreateEncryptor();
                byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
    
                return Convert.ToBase64String(resultArray, 0, resultArray.Length);
            }
    
            /// <summary>
            /// 256位AES解密
            /// </summary>
            /// <param name="toDecrypt"></param>
            /// <returns></returns>
            public static string Decrypt(string toDecrypt)
            {
                // 256-AES key    
                byte[] keyArray = UTF8Encoding.UTF8.GetBytes(Key);
                byte[] toEncryptArray = Convert.FromBase64String(toDecrypt);
    
                RijndaelManaged rDel = new RijndaelManaged();
                rDel.Key = keyArray;
                rDel.Mode = CipherMode.ECB;
                rDel.Padding = PaddingMode.PKCS7;
    
                ICryptoTransform cTransform = rDel.CreateDecryptor();
                byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
    
                return UTF8Encoding.UTF8.GetString(resultArray);
            }
            #endregion
        }
    }
    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using System.Windows.Forms;
    
    namespace Mask
    {
        public partial class Form1 : Form
        {
            public Form1()
            {
                InitializeComponent();
            }
            /// <summary>
            /// 加密
            /// </summary>
            /// <param name="sender"></param>
            /// <param name="e"></param>
            private void btnEncrypt_Click(object sender, EventArgs e)
            {
                if (string.IsNullOrEmpty(txtSourceText.Text))
                {
                    MessageBox.Show("没数据加毛密-_-!");
                    return;
                }
                else
                {
                    txtResultText.Text = AESEncryptHelper.Encrypt(txtSourceText.Text);
                }
            }
            /// <summary>
            /// 解密
            /// </summary>
            /// <param name="sender"></param>
            /// <param name="e"></param>
            private void btnDecrypt_Click(object sender, EventArgs e)
            {
                if (string.IsNullOrEmpty(txtSourceText.Text))
                {
                    MessageBox.Show("没数据解毛密-_-!");
                    return;
                }
                else if (!IsBase64Formatted(txtSourceText.Text))
                {
                    MessageBox.Show("别逗了,我只认识被我加过密的?");
                    return;
                }
                else
                {
                    txtResultText.Text = AESEncryptHelper.Decrypt(txtSourceText.Text);
                }
            }
    
            public static bool IsBase64Formatted(string input)
            {
                try
                {
                    Convert.FromBase64String(input);
                    return true;
                }
                catch
                {
                    return false;
                }
            }
        }
    }
  • 相关阅读:
    VS2008 环境中完美搭建 Qt 4.7.4 静态编译的调试与发布 Inchroy's Blog 博客频道 CSDN.NET
    编写可丢弃的代码
    c++ using namespace std; 海明威 博客园
    解决MySQL server has gone away
    nginx upstream 调度策略
    (2006, 'MySQL server has gone away') 错误解决 dba007的空间 51CTO技术博客
    Linux IO模型漫谈(2) 轩脉刃 博客园
    redis源码笔记 initServer 刘浩de技术博客 博客园
    MySQLdb批量插入数据
    词库的扩充百度百科的抓取你知道这些热词吗? rabbit9898 ITeye技术网站
  • 原文地址:https://www.cnblogs.com/Jeely/p/11721461.html
Copyright © 2011-2022 走看看