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

最新推荐文章于 2025-03-20 22:47:34 发布
最新推荐文章于 2025-03-20 22:47:34 发布
阅读量2.9k 收藏 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();
        }
    }

运行结果如图:

这里写图片描述

C语言AES加密解密字符串与16进制数据
m0_60352504的博客
09-07 633
密码学中的高级加密标准
AES基于扩展欧几里德求逆元的S-Box生成
jaymegs的博客
11-28 2063
#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加密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算法介绍
最新发布
sky的博客
03-20 1388
希望大佬们可以关注下博主微信公众号，后续微信公众号会持续更新相关文章：AES(Advanced Encryption Standard)算法是一种对称加密算法，是由美国国家标准与技术研究院(NIST)在 2001 年发布，旨在取代早期的数据加密标准(DES)，并提供更高的安全性，目前该算法被广泛用于各种安全需求中，AES算法以其高度的安全性核效率成为目前最流行的对称加密算法之一。字节替换：属于非线性替换，具体为通过一个替换表(S 盒)对每个字节进行查表替换，查表时将每一个字节。
AES SBox的构造（python）
weixin_30621919的博客
10-20 644
几点需要注意的，求解逆元的时候使用的是拓展欧几里得，但是那些运算规则需要变一变，模2的加减乘除（或者可以理解为多项式的运算） 在进行字节的仿射变换不用进行矩阵的运算。 一个矩阵和一个列向量进行运算的时候可以视为矩阵的列向量的线性组合 代码如下： 1 #使用拓展欧几里得求解乘法矩阵的逆元 2 #求一个数的二进制位的长度 3 def length(a): 4 ...
AES的S-BOX构造
dieseng6571的博客
10-23 1513
利用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 4110
和DES加密算法相比，AES提供了更高的安全性，在TLS握手后的数据传输阶段，所使用的共享密钥算法就是AES加密模式。
AES(高级加密标准)：AES的加解密过程分析
kkchenjj的博客
07-17 2234
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加密算法与Rijndael详细研究资料
- 在文件描述中提到了两种版本的FIPS197文档（一种是中文版“FIPS197(chs).pdf”），这表明了该算法被广泛认可和使用的重要性。 4. Rijndael算法与AES的关系： - Rijndael算法是AES算法的基础，Rijndael算法流程...
C语言实现AES加密解密：成都信息工程学院课程设计
AES是一种广泛应用于数据加密的标准，基于Rijndael算法，其工作流程包括多个迭代的加密和解密过程。在C语言中实现AES，主要涉及以下几个关键步骤： 1. **SubBytes**：这是非线性变换，使用了一个称为S盒（S-box）的...
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构造优化
dieseng6571的博客
10-29 604
之前写过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 1432
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.
白盒AES--从0到1
weixin_73270563的博客
01-19 3514
AES白盒
C++实现的AES-128加密解密库
"AES C++ 128位 - 一个简单的C++实现，用于AES 128位加密解密算法" AES（Advanced Encryption Standard）是目前广泛使用的对称加密标准，它提供了高安全性和高效性。在这个C++实现中，AES 128位算法被封装在一个名...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值