AES128加解密(SBOX+Rijndael)两种方法

最新推荐文章于 2024-07-17 09:03:39 发布
最新推荐文章于 2024-07-17 09:03:39 发布
阅读量2.7k 收藏 3
点赞数
分类专栏： 加密解密 文章标签： AES 128 加密解密 C# net

AESEncryption.cs

 public class AESEncryption
    {
        //默认密钥向量
        //36649AF26DDE0C3A0F1E2D3C4B5A6978
        private static byte[] _key1 = { 0x36, 0x64, 0x9A, 0xF2, 0x6D, 0xDE, 0x0C, 0x3A, 0x0F, 0x1E, 0x2D, 0x3C, 0x4B, 0x5A, 0x69, 0x78 };

        /// <summary>  
        /// AES加密算法  
        /// </summary>  
        /// <param name="plainText">明文字符串</param>  
        /// <param name="strKey">密钥</param>  
        /// <returns>返回加密后的密文字节数组</returns>  
        public static byte[] AESEncrypt(byte[] inputByteArray)
        {
            //分组加密算法  
            SymmetricAlgorithm des = Rijndael.Create();
            //byte[] inputByteArray = Encoding.UTF8.GetBytes(plainText);//得到需要加密的字节数组      
            //设置密钥及密钥向量  
            des.Key = _key1;//Encoding.UTF8.GetBytes(strKey);
            des.IV = _key1;
            MemoryStream ms = new MemoryStream();
            CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write);
            cs.Write(inputByteArray, 0, inputByteArray.Length);
            cs.FlushFinalBlock();
            byte[] cipherBytes = ms.ToArray();//得到加密后的字节数组  
            cs.Close();
            ms.Close();
            return cipherBytes;
        }

        /// <summary>  
        /// AES解密  
        /// </summary>  
        /// <param name="cipherText">密文字节数组</param>  
        /// <param name="strKey">密钥</param>  
        /// <returns>返回解密后的字符串</returns>  
        public static byte[] AESDecrypt(byte[] cipherText)
        {
            SymmetricAlgorithm des = Rijndael.Create();
            des.Key = _key1;//Encoding.UTF8.GetBytes(strKey);
            des.IV = _key1;
            byte[] decryptBytes = new byte[cipherText.Length];
            MemoryStream ms = new MemoryStream(cipherText);
            CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Read);
            cs.Read(decryptBytes, 0, decryptBytes.Length);
            cs.Close();
            ms.Close();
            return decryptBytes;
        }
    }

Aes.cs

  public class Aes // 高级加密标准
    {
        public enum KeySize
        {
            Bits128,
            Bits192,
            Bits256
        };

        private readonly byte[] key; // 种子 key. 大小将为 4 * keySize 来自 构造函数.
        private byte[,] Dbox;
        // key大小，以位为单位，用于构造函数

        private int Nb; // 块大小为32位字节。 AES总是4 (128 bits).
        private int Nk; // key大小为32位字。 4, 6, 8. （128,192,256位）
        private int Nr; // 轮数. 10, 12, 14.

        private byte[,] Rcon; // Round constants.
        private byte[,] Sbox; // Substitution box
        private char Source;
        private byte[,] State; // State 矩阵
        private byte[,] iDbox;
        private byte[,] iSbox; // 逆替换盒
        private bool mode = true;

        private int round;
        private byte size;
        private byte[,] w; // 密钥计划 数组. 

        public Aes(KeySize keySize, byte[] keyBytes)
        {
            SetNbNkNr(keySize);

            key = new byte[Nk*4]; // 16, 24, 32 字节
            keyBytes.CopyTo(key, 0);

            BuildSbox();
            BuildInvSbox();
            InitdBox();
            BuildRcon();
            KeyExpansion(); // 将种子密钥扩展到密钥计划并存储在w中
        }

        private void InitdBox()
        {
            Dbox = new byte[16, 16];
            iDbox = new byte[16, 16];
        }  

        private void BuildDbox(byte[,] statebox, int round)
        {
            var Temp = new byte[16];

            BuildLCS(ref Temp, round);
            byte AddByte = 0, t = 0;

            for (byte k = 0; k < 16; k += 2)
            {
                AddByte <<= 1;
                t = (byte) (Temp[k] & 0x01);
                AddByte |= t;
            }

            for (byte i = 0; i < 16; i++)
            {
                for (byte r = 0; r < 4; ++r) // copy Key into temp[]
                    for (byte c = 0; c < 4; Temp[r*4 + c] = w[((Nr - round)*4) + c, r], ++c) ;


                for (byte j = 0; j < 16; j++)
                {
                    byte row, col, y = 0;
                    Dbox[i, j] = (byte) (statebox[i, j] ^ AddByte);
                    row = (byte) (Dbox[i, j] >> 4);
                    col = (byte) (Dbox[i, j] & 0x0f);

                    iDbox[row, col] = (byte) (i << 4 | j);
                }
            }
        }


        private void BuildLCS(ref byte[] Data, int times)
        {
            for (int i = 0; i < times; i++)
            {
                byte temp = Data[0];
                for (int j = 0; j < 15; Data[j] = Data[j + 1], j++) ;
                Data[15] = temp;
            }
        }

        //Aes加密函数
        public void Cipher(byte[] input, byte[] output) // 加密16位输入
        {
            // state = input
            State = new byte[4, Nb]; // always [4,4]  //这里是先写列后写行的，即输入是一列一列的进来的  
            for (int i = 0; i < (4*Nb); ++i)
            {
                State[i % 4, i / 4] = input[i]; //换成先写行后写列也是可以的，只要在输出时也是这样就可以了  
            }

            AddRoundKey(0); //轮密钥加 
            int round;
            for (round = 1; round <= (Nr - 1); ++round) // main round loop
            {
                SubBytes(round);//字节代换 
                ShiftRows();  //行移位  
                MixColumns();
                AddRoundKey(round); //轮密钥加 
            } 


            SubBytes(Nr);
            ShiftRows();
            AddRoundKey(Nr);

            // output = state
            for (int i = 0; i < (4*Nb); ++i)
            {
                output[i] = State[i%4, i/4];
            }
        } 


        //Aes解密函数 
        public void InvCipher(byte[] input, byte[] output) // 解密16位输入
        {
            // state = input
            State = new byte[4, Nb]; // always [4,4]
            for (int i = 0; i < (4*Nb); ++i)
            {
                State[i%4, i/4] = input[i];
            }

            AddRoundKey(Nr);

            for (int round = Nr - 1; round >= 1; --round) // main round loop
            {
                InvShiftRows();
                InvSubBytes(round + 1);
                AddRoundKey(round);
                InvMixColumns();
            } // end main round loop for InvCipher

            InvShiftRows();
            InvSubBytes(1);
            AddRoundKey(0);

            // output = state
            for (int i = 0; i < (4*Nb); ++i)
            {
                output[i] = State[i%4, i/4];
            }
        } 

        private void SetNbNkNr(KeySize keySize)
        {
            Nb = 4; // 块大小总是= 4个字= 16字节= 128位 for AES

            if (keySize == KeySize.Bits128)
            {
                Nk = 4;   //4*4字节，128位密钥，10轮加密   
                Nr = 10; 
            }
            else if (keySize == KeySize.Bits192)
            {
                Nk = 6; //6*4字节，192位密钥，12轮加密  
                Nr = 12;
            }
            else if (keySize == KeySize.Bits256)
            {
                Nk = 8; //8*4字节，256位密钥，14轮加密  
                Nr = 14;
            }
        } 

        private void BuildSbox()
        {
            Sbox = new byte[16, 16]
            {
                // 填充Sbox矩阵
                /* 0     1     2     3     4     5     6     7     8     9     a     b     c     d     e     f */
                /*0*/  {0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76},
                /*1*/  {0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0},
                /*2*/  {0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15},
                /*3*/  {0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75},
                /*4*/  {0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84},
                /*5*/  {0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf},
                /*6*/  {0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8},
                /*7*/  {0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2},
                /*8*/  {0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73},
                /*9*/  {0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb},
                /*a*/  {0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79},
                /*b*/  {0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08},
                /*c*/  {0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a},
                /*d*/  {0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e},
                /*e*/  {0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf},
                /*f*/  {0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16}
            };
        } 

        private void BuildInvSbox()
        {
            iSbox = new byte[16, 16]
            {
                //填充iSbox矩阵
                /* 0     1     2     3     4     5     6     7     8     9     a     b     c     d     e     f */
                /*0*/  {0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb},
                /*1*/  {0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb},
                /*2*/  {0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e},
                /*3*/  {0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25},
                /*4*/  {0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92},
                /*5*/  {0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84},
                /*6*/  {0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06},
                /*7*/  {0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b},
                /*8*/  {0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73},
                /*9*/  {0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e},
                /*a*/  {0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b},
                /*b*/  {0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4},
                /*c*/  {0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f},
                /*d*/  {0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef},
                /*e*/  {0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61},
                /*f*/  {0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d}
            };
        }  

        private void BuildRcon()
        {
            Rcon = new byte[11, 4]
            {
                {0x00, 0x00, 0x00, 0x00},
                {0x01, 0x00, 0x00, 0x00},
                {0x02, 0x00, 0x00, 0x00},
                {0x04, 0x00, 0x00, 0x00},
                {0x08, 0x00, 0x00, 0x00},
                {0x10, 0x00, 0x00, 0x00},
                {0x20, 0x00, 0x00, 0x00},
                {0x40, 0x00, 0x00, 0x00},
                {0x80, 0x00, 0x00, 0x00},
                {0x1b, 0x00, 0x00, 0x00},
                {0x36, 0x00, 0x00, 0x00}
            };
        }  
        //轮密钥加
        private void AddRoundKey(int round)
        {
            //i行 j列           //因为密钥w是一列一列排列的，即 k0 k4  k8  k12  
                                //                              k1 k5  k9  k13 
                                //                              k2 k6  k10 k14
                                //                              k3 k7  k11 k15
            for (int r = 0; r < 4; ++r)
            {
                for (int c = 0; c < 4; ++c)
                {
                    // 所以i行j列的下标是4*((round*4)+j)+i即16*round+4*j+i  
                    State[r, c] = (byte) (State[r, c] ^ w[(round*4) + c, r]);
                }
            }
        } // AddRoundKey()

        //字节代换函数 
        private void SubBytes(int round)
        {
            if (mode)
                BuildDbox(Sbox, round);


            for (int r = 0; r < 4; ++r)
            {
                for (int c = 0; c < 4; ++c)
                {
                    if (mode)
                        State[r, c] = Dbox[(State[r, c] >> 4), (State[r, c] & 0x0f)];
                    else
                        State[r, c] = Sbox[(State[r, c] >> 4), (State[r, c] & 0x0f)];
                      //因为 16*(State[i][j]>>4)+State[i][j]&0x0f=State[i][j]  
                }
            }
        } // SubBytes

        private void InvSubBytes(int round)
        {
            if (mode)
                BuildDbox(Sbox, round);
            for (int r = 0; r < 4; ++r)
            {
                for (int c = 0; c < 4; ++c)
                {
                    if (mode)
                        State[r, c] = iDbox[(State[r, c] >> 4), (State[r, c] & 0x0f)];
                    else
                        State[r, c] = iSbox[(State[r, c] >> 4), (State[r, c] & 0x0f)];
                }
            }
        } // InvSubBytes

        private void ShiftRows()
        {
            var temp = new byte[4, 4];
            for (int r = 0; r < 4; ++r) // copy State into temp[]
            {
                for (int c = 0; c < 4; ++c)
                {
                    temp[r, c] = State[r, c];
                }
            }

            for (int r = 1; r < 4; ++r) // shift temp into State
            {

                //第一行左移1位  
                //第二行左移2位  
                //第三行左移3位  
                for (int c = 0; c < 4; ++c)
                {
                    State[r, c] = temp[r, (c + r)%Nb];
                }
            }
        } // ShiftRows()

        private void InvShiftRows()
        {
            var temp = new byte[4, 4];
            for (int r = 0; r < 4; ++r) // copy State into temp[]
            {
                for (int c = 0; c < 4; ++c)
                {
                    temp[r, c] = State[r, c];
                }
            }
            for (int r = 1; r < 4; ++r) // shift temp into State
            {
                for (int c = 0; c < 4; ++c)
                {
                       //第一行右移1位 j-1+4=j+3  
                       //第二行右移2位 j-2+4=j+2  
                       //第三行右移3位 j-3+4=j+2  

                    State[r, (c + r)%Nb] = temp[r, c];
                }
            }
        }  

        private void MixColumns()
        {
            var temp = new byte[4, 4];

            //2 3 1 1  列混淆矩阵 
            //1 2 3 1 
            //1 1 2 3  
            //3 1 1 2
            for (int r = 0; r < 4; ++r) // copy State into temp[]
            {
                for (int c = 0; c < 4; ++c)
                {
                    temp[r, c] = State[r, c];
                }
            }

            for (int c = 0; c < 4; ++c)
            {
                State[0, c] = (byte) (gfmultby02(temp[0, c]) ^ gfmultby03(temp[1, c]) ^
                                      gfmultby01(temp[2, c]) ^ gfmultby01(temp[3, c]));
                State[1, c] = (byte) (gfmultby01(temp[0, c]) ^ gfmultby02(temp[1, c]) ^
                                      gfmultby03(temp[2, c]) ^ gfmultby01(temp[3, c]));
                State[2, c] = (byte) (gfmultby01(temp[0, c]) ^ gfmultby01(temp[1, c]) ^
                                      gfmultby02(temp[2, c]) ^ gfmultby03(temp[3, c]));
                State[3, c] = (byte) (gfmultby03(temp[0, c]) ^ gfmultby01(temp[1, c]) ^
                                      gfmultby01(temp[2, c]) ^ gfmultby02(temp[3, c]));
            }
        }  

        private void InvMixColumns()
        {
            var temp = new byte[4, 4];
            for (int r = 0; r < 4; ++r) // copy State into temp[]
            {

                //0e 0b 0d 09   逆变换矩阵 
                //09 0e 0b 0d  
                //0d 09 0e 0b  
                //0b 0d 09 0e  
                for (int c = 0; c < 4; ++c)
                {
                    temp[r, c] = State[r, c];
                }
            }

            for (int c = 0; c < 4; ++c)
            {
                State[0, c] = (byte) (gfmultby0e(temp[0, c]) ^ gfmultby0b(temp[1, c]) ^
                                      gfmultby0d(temp[2, c]) ^ gfmultby09(temp[3, c]));
                State[1, c] = (byte) (gfmultby09(temp[0, c]) ^ gfmultby0e(temp[1, c]) ^
                                      gfmultby0b(temp[2, c]) ^ gfmultby0d(temp[3, c]));
                State[2, c] = (byte) (gfmultby0d(temp[0, c]) ^ gfmultby09(temp[1, c]) ^
                                      gfmultby0e(temp[2, c]) ^ gfmultby0b(temp[3, c]));
                State[3, c] = (byte) (gfmultby0b(temp[0, c]) ^ gfmultby0d(temp[1, c]) ^
                                      gfmultby09(temp[2, c]) ^ gfmultby0e(temp[3, c]));
            }
        }  

        private static byte gfmultby01(byte b)
        {
            return b;
        }

        private static byte gfmultby02(byte b)
        {
            if (b < 0x80)
                return (byte) (b << 1);
            return (byte) (b << 1 ^ 0x1b);
        }

        private static byte gfmultby03(byte b)
        {
            return (byte) (gfmultby02(b) ^ b);
        }

        private static byte gfmultby09(byte b)
        {
            return (byte) (gfmultby02(gfmultby02(gfmultby02(b))) ^
                           b);
        }

        private static byte gfmultby0b(byte b)
        {
            return (byte) (gfmultby02(gfmultby02(gfmultby02(b))) ^
                           gfmultby02(b) ^
                           b);
        }

        private static byte gfmultby0d(byte b)
        {
            return (byte) (gfmultby02(gfmultby02(gfmultby02(b))) ^
                           gfmultby02(gfmultby02(b)) ^
                           b);
        }

        private static byte gfmultby0e(byte b)
        {
            return (byte) (gfmultby02(gfmultby02(gfmultby02(b))) ^
                           gfmultby02(gfmultby02(b)) ^
                           gfmultby02(b));
        }

        private void KeyExpansion()
        {
            w = new byte[Nb*(Nr + 1), 4]; // 4 columns of bytes corresponds to a word

            for (int row = 0; row < Nk; ++row)//拷贝seed 密钥
            {
                w[row, 0] = key[4*row];
                w[row, 1] = key[4*row + 1];
                w[row, 2] = key[4*row + 2];
                w[row, 3] = key[4*row + 3];
            }

            var temp = new byte[4];

            for (int row = Nk; row < Nb*(Nr + 1); ++row)
            {
                temp[0] = w[row - 1, 0]; //当前列的前一列  
                temp[1] = w[row - 1, 1];
                temp[2] = w[row - 1, 2];
                temp[3] = w[row - 1, 3];

                if (row % Nk == 0)  //逢nk时，对当前列的前一列作特殊处理 
                {
                    temp = SubWord(RotWord(temp));  //先移位，再代换，最后和轮常量异或 

                    temp[0] = (byte) (temp[0] ^ Rcon[row/Nk, 0]);
                    temp[1] = (byte) (temp[1] ^ Rcon[row/Nk, 1]);
                    temp[2] = (byte) (temp[2] ^ Rcon[row/Nk, 2]);
                    temp[3] = (byte) (temp[3] ^ Rcon[row/Nk, 3]);
                }
                else if (Nk > 6 && (row%Nk == 4))
                {
                    temp = SubWord(temp);
                }

                // w[row] = w[row-Nk] xor temp
                w[row, 0] = (byte) (w[row - Nk, 0] ^ temp[0]);
                w[row, 1] = (byte) (w[row - Nk, 1] ^ temp[1]);
                w[row, 2] = (byte) (w[row - Nk, 2] ^ temp[2]);
                w[row, 3] = (byte) (w[row - Nk, 3] ^ temp[3]);
            } // for loop
        }  

        //密钥字代换函数 
        private byte[] SubWord(byte[] word)
        {
            var result = new byte[4];
            result[0] = Sbox[word[0] >> 4, word[0] & 0x0f];
            result[1] = Sbox[word[1] >> 4, word[1] & 0x0f];
            result[2] = Sbox[word[2] >> 4, word[2] & 0x0f];
            result[3] = Sbox[word[3] >> 4, word[3] & 0x0f];
            return result;
        }

        //密钥移位函数
        private byte[] RotWord(byte[] word)
        {
            var result = new byte[4];
            result[0] = word[1];
            result[1] = word[2];
            result[2] = word[3];
            result[3] = word[0];
            return result;
        }

        public void Dump()
        {
            Console.WriteLine("Nb = " + Nb + " Nk = " + Nk + " Nr = " + Nr);
            Console.WriteLine("\nThe key is \n" + DumpKey());
            Console.WriteLine("\nThe Sbox is \n" + DumpTwoByTwo(Sbox));
            Console.WriteLine("\nThe w array is \n" + DumpTwoByTwo(w));
            Console.WriteLine("\nThe State array is \n" + DumpTwoByTwo(State));
        }

        public string DumpKey()
        {
            string s = "";
            for (int i = 0; i < key.Length; ++i)
                s += key[i].ToString("x2") + " ";
            return s;
        }

        public string DumpTwoByTwo(byte[,] a)
        {
            string s = "";
            for (int r = 0; r < a.GetLength(0); ++r)
            {
                s += "[" + r + "]" + " ";
                for (int c = 0; c < a.GetLength(1); ++c)
                {
                    s += a[r, c].ToString("x2") + " ";
                }
                s += "\n";
            }
            return s;
        }
    }

Program.cs

 class Program
    {
        //
        private static void pause()
        {
            Console.Write("按任意键继续 . . . ");
            Console.ReadKey(true);
        }

        public static string ToHexString(byte[] bytes, String flag = ",") // 0xae00cf => "AE00CF "
        {
            string hexString = string.Empty;

            if (bytes != null)
            {
                var strB = new StringBuilder();


                for (int i = 0; i < bytes.Length; i++)
                {
                    strB.Append(bytes[i].ToString("X2"));
                    strB.Append(flag);
                }

                hexString = strB.ToString();
            }

            return hexString;
        }

        private static void Main(string[] args)
        {
            /*
            byte[] inputByteArray = { 0xAA, 0x55, 0xBB, 0x66, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
            byte[] outputByteArray = AESEncryption.AESEncrypt(inputByteArray);
            byte[] outputByteArray1 = AESEncryption.AESDecrypt(outputByteArray);
            */

            byte[] inputByteArrayOne =
            {
                0xAA, 0x55, 0xBB, 0x66, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                0x00, 0x00, 0x00
            };
            byte[] outputByteArrayOne = AESEncryption.AESEncrypt(inputByteArrayOne);
            byte[] outputByteArrayTwo = AESEncryption.AESDecrypt(outputByteArrayOne);
            Console.WriteLine("输入值 - " + ToHexString(outputByteArrayTwo));
            Console.WriteLine("输出值 - " + ToHexString(outputByteArrayOne));
            Console.WriteLine();


            Aes.KeySize keysize;
            keysize = Aes.KeySize.Bits128;
            byte[] inputByteArray =
            {
                0xAA, 0x55, 0xBB, 0x66, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                0x00, 0x00
            };
            byte[] _key1 =
            {
                0x36, 0x64, 0x9A, 0xF2, 0x6D, 0xDE, 0x0C, 0x3A, 0x0F, 0x1E, 0x2D, 0x3C, 0x4B, 0x5A, 0x69,
                0x78
            };
            var a = new Aes(keysize, _key1);
            var outputByteArray = new byte[16];
            //加密16位输入
            a.Cipher(inputByteArray, outputByteArray);

            var outputByteArray1 = new byte[16];
            //解密16位输入
            a.InvCipher(outputByteArray, outputByteArray1);

            string hex2 = ToHexString(outputByteArray);
            string hex1 = ToHexString(outputByteArray1);
            Console.WriteLine("输入值 - " + hex1);
            Console.WriteLine("输出值 - " + hex2);

            pause();
        }
    }

运行结果如图:

这里写图片描述

.NET跨平台
关注
专栏目录
C语言AES加密解密字符串与16进制数据
m0_60352504的博客
09-07 518
密码学中的高级加密标准
移位密码加密 matlab,AES加密算法的matlab实现
weixin_39618339的博客
03-16 2000
最近一直在学习加密算法，上上一个星期学习了RSA公钥密码算法，公式挺简单的，本来想着把RSA算法用FPGA实现的，但是自己实际编码之后，发现FPGA本身自带的加法器，乘法器...都是32位的，那么问题就来了，要是使用1024位的加密算法时，直接运算fpga是吃不消的，也不可能综合的过去，于是网上搜了好几篇论文，用来用FPGA实现的，但是看得好吃力，先放一放了。还是先从简单的入手吧，对称加密算法AE...
数据aes加密sbox
09-05
数据aes加密sbox
AES中Sbox的生成
人生如棋
04-08 1万+
转载请注明来源：http://blog.csdn.net/zhangyang0402/archive/2010/04/08/5465032.aspx一、概述在整个AES加密中，SBox被使用到了两次：一次是在密钥(Cipher Key)扩展生成轮密钥(Round Key)的时候，另一次是轮加密的第一步字节替换(SubByte)。根据FIPS 197，SBox的生成分两步：
AES SBox的构造（python）
weixin_30621919的博客
10-20 607
几点需要注意的，求解逆元的时候使用的是拓展欧几里得，但是那些运算规则需要变一变，模2的加减乘除（或者可以理解为多项式的运算） 在进行字节的仿射变换不用进行矩阵的运算。 一个矩阵和一个列向量进行运算的时候可以视为矩阵的列向量的线性组合 代码如下： 1 #使用拓展欧几里得求解乘法矩阵的逆元 2 #求一个数的二进制位的长度 3 def length(a): 4 ...
AES的S-BOX构造
dieseng6571的博客
10-23 1339
利用GF(2^8)乘法逆元，以及矩阵运算，可以构造出AES的SBOX。 求乘法逆元的一般方法是利用扩展欧几里得定理，在这里我取了个巧。 因为我已经有了GF的指数表（见上一篇文），利用指数表可以轻易地构造出乘法逆元表。具体方法如下： 若 x = 3^m, y = 3^n, x 与 y 互为乘法逆元，则有x * y = 3^m * 3^n = 1 = 3^255（任意乘法逆元的255次...
AES加密算法
metersun的专栏
10-06 3774
和DES加密算法相比，AES提供了更高的安全性，在TLS握手后的数据传输阶段，所使用的共享密钥算法就是AES加密模式。
AES(高级加密标准)：AES的加解密过程分析
kkchenjj的博客
07-17 1654
AES, 或称高级加密标准，是由美国国家标准与技术研究院(NIST)在2001年正式采纳的一种对称密钥加密算法。它取代了之前的DES和3DES标准，成为全球广泛使用的加密标准。AES的开发始于1997年，由比利时密码学家Joan Daemen和Vincent Rijmen设计，最初称为Rijndael算法。NIST在经过一系列的评估和测试后，选择了Rijndael作为新的加密标准，主要因为它在安全性、效率、灵活性和易于实现方面表现优异。
AES.rar_AES_AES 加密_AES图片加密_aes 图片加密_c++实现AES加密
09-23
4. **AES加密循环**：AES算法包含多轮（10轮对于128位密钥）的加密过程，每轮包括字节替换(Sbox)、行移位、列混淆和轮密钥加四个步骤。 5. **解密过程**：解密过程与加密类似，但使用了逆向的混淆和置换操作，以及...
AES(高级加密标准)：AES算法的实现与编程
最新发布
kkchenjj的博客
07-17 728
AES (Advanced Encryption Standard)，即高级加密标准，是由美国国家标准与技术研究院（NIST）在2001年正式公布的一种对称加密算法。它取代了之前的DES和3DES标准，成为新的数据加密标准。AES的开发始于1997年，NIST发起了一项公开竞赛，邀请全球的密码学家提交他们的加密算法。最终，比利时密码学家Joan Daemen和Vincent Rijmen设计的Rijndael算法被选中，并经过一些修改后，成为了AES算法。
AES s盒生成代码
04-22
AES的S盒可以用扩展的欧几里德和费马定理来写，这里我采用费马定理。要注意的是S盒的求逆过程是在加瓦罗域下进行的，所以里面的所有乘法、除法、加法、减法都是在加瓦罗域下进行。
AES算法中Sbox和列混合单元的优化及FPGA实现
03-09
由于AES算法的硬件实现较为复杂，在此提出一种优化算法中S—box和列混合单元的方法。其中S—box通过组合和有限域映射的方法进行优化，列混合单元使用算式重组的方法进行优化。这些优化设计通过组合逻辑实现，经过仿真并在Xilinx Spartan 3系列FPGA上进行综合验证，可以将结构简化，使AES电路面积得到优化，明显节约硬件资源。
Rijndael的设计 中文扫描版+英文清晰版
03-28
AES前身 Rijndael设计 中文扫描版 英文清晰版 对其设计精巧之处进行了详细分析，可以一起探讨学习
AES基于扩展欧几里德求逆元的S-Box生成
jaymegs的博客
11-28 1960
#define _CRT_SECURE_NO_WARNINGS #include<cstdio> #include<iostream> using namespace std; const int Bit_Num = sizeof(int)* 8;//求解非零最高位 int GF_index_of_max(int value){ int index = 0; for (int
AES的S-BOX构造优化
dieseng6571的博客
10-29 473
之前写过SBOX的构造，后来看到别人的优秀思路，借鉴过来重新改了一点。 原文地址：http://www.cnblogs.com/7hat/p/3383546.html 主要是将矩阵运算改为列运算之和，提高了效率。 #include<iostream> #include<fstream> #include <iomanip> usin...
【算法】AES（Rijndael算法）
热门推荐
行路中
01-23 2万+
上周好几天都在搞AES，总算是把Rijndael算法搞明白了。本片会仔细介绍AES（Rijndael算法），后两篇会介绍AES的java和php实现。 AES（Rijndael算法） Rijndael算法首先是一个密钥分组加密的算法，通过置换（permutations ）和替换(substitutions）迭代加密，进过多轮操作形成密文。AES算是Rijndael算法的一种特殊实现，选的分组为
AES-Rijndael加密_192bit
赤城封雪的博客
10-13 1158
AES-Rijndael加密_192bit 写在前面： 高级加密标准 (AES, Advanced Encryption Standard) 为最常见的对称加密算法 由于涉及到的一些数论知识和密码学原理实在不是我等蒟蒻可以理解的，只能是不求甚解了，知实现而不知原理。 吐了！！！ AES 密钥长度Nk（32位比特字) 分组长度(32位比特字) 加密轮数Nr AES-128 4 4 10 AES-192 6 4 12 AES-256 8 4 14 0x01 S-box生成 1.
NTL加密---Rijndael:对称密码(可逆)(AES)(加密数据)
qq_38798147的博客
10-23 1383
2)执行L_r-1常规轮变换(一个常规轮变换包含以下四步骤:1.替换:使用S盒(非线性操作，提供了一个近似理想的抗差分攻击)替换分组的每个字节.2.置换:行位移变换(shiftRows)中置换分组的字节3.扩散:执行列混合(MixColumns)变换，4.轮密钥加:用当前的轮密钥与分组进行异或)可以通过使用如下算法加法:令g(x)为 上的一个生成多项式(g的幂可遍历其域中的所有元素)，则存在m和n，使得 和 ,因此 . 在程序设计时可采用两个表，一个是g(x)的255个幂，一个是255个对数。
AES - Rijndael 算法(二)
weixin_34384557的博客
02-14 211
三：Rijndael算法实现(C++版本) /*-------------------- Rijndael round subkeys ---------------------*/u8 roundKeys[11][4][4];/*--------------------- Rijndael S box table ----------------------*/u8 S[256] = {99,...
aes128加解密的纯C语言实现
05-11
AES是一种对称加密算法，可以用于加密和解密数据。以下是AES128加解密的纯C语言实现示例： ``` #include <stdio.h> #include <string.h> #include <stdint.h> #define Nb 4 #define Nk 4 #define Nr 10 static uint8_t Sbox[256] = { 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76, 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15, 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75, 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf, 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8, 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73, 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb, 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08, 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f,
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值