devbox
算法构造者
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

AES-128-ECB/CBC 查表法 C#实现_c# aes ecb 128

作者：算法构造者 | 2024-01-31 19:45:13

赞

踩

c# aes ecb 128

遇到一段汇编代码，没认出来是查表法的AES。这里完全用字节处理，来实现AES加密计算，来加深一下对查表法AES的印象。

由于采用对字节的操作，会造成很多无畏的内存读写，运算速度肯定没有对uint（4字节）来的快。本来反汇编出来的就是uint的，这边只是想学习具体细节，才转换成字节的。后续有空了，再把整理后的uint操作的代码贴出来吧。

主要参考了：

查表法的理论计算过程

部分代码参考

部分代码参考2

字节操作函数

  1.         /// <summary>
  2.         /// 字节数组->uint，大端模式
  3.         /// </summary>
  4.         /// <param name="buf"></param>
  5.         /// <param name="index"></param>
  6.         /// <returns></returns>
  7.         public static uint ReadUint_BE(byte[] buf, int index)
  8.         {
  9.             uint d1 = buf[index + 3]; // buf的高位，成为retData的尾端
  10.             uint d2 = (uint)(buf[index + 2] << 8);
  11.             uint d3 = (uint)(buf[index + 1] << 16);
  12.             uint d4 = (uint)(buf[index] << 24);
  13.             return d1 | d2 | d3 | d4;
  14.         }
  15.         public static void WriteUint_BE(byte[] buf, int index, uint data)
  16.         {
  17.             buf[index + 3] = (byte)(data); // data低8位（尾端）写到buf的高位
  18.             buf[index + 2] = (byte)(data >> 8);
  19.             buf[index + 1] = (byte)(data >> 16);
  20.             buf[index + 0] = (byte)(data >> 24); // data高8位写到buf的低位
  21.         }
  22.         /// <summary>
  23.         /// 字节数组->uint，小端模式
  24.         /// </summary>
  25.         /// <param name="buf"></param>
  26.         /// <param name="index"></param>
  27.         /// <returns></returns>
  28.         public static uint ReadUint_LE(byte[] buf, int index)
  29.         {
  30.             uint d1 = buf[index]; // buf的低位，成为retData的尾端
  31.             uint d2 = (uint)(buf[index + 1] << 8);
  32.             uint d3 = (uint)(buf[index + 2] << 16);
  33.             uint d4 = (uint)(buf[index + 3] << 24);
  34.             return d1 | d2 | d3 | d4;
  35.         }
  36.         public static void WriteUint_LE(byte[] buf, int index, uint data)
  37.         {
  38.             buf[index] = (byte)data; // data低8位（尾端）写道buf的低位
  39.             buf[index + 1] = (byte)(data >> 8);
  40.             buf[index + 2] = (byte)(data >> 16);
  41.             buf[index + 3] = (byte)(data >> 24);
  42.         }
  43.         public static byte HIBYTE(uint data) => (byte)((data >> 24) & 0xff);
  44.         public static byte BYTE2(uint data) => (byte)((data >> 16) & 0xff);
  45.         public static byte BYTE1(uint data) => (byte)((data >> 8) & 0xff);
  46.         public static byte LOWBYTE(uint data) => (byte)(data & 0xff);

生成SBOX

为了避免位移运算，这里对sbox进行偏移，得到4个uint[]的sbox

  1.         public static byte[] create_sbox()
  2.         {
  3.             byte[] a = { 0xf1, 0xe3, 0xc7, 0x8f, 0x1f, 0x3e, 0x7c, 0xf8 };
  4.             byte b = 0x63, x1, x, y, z, i = 0x00;
  5.  
  6.             byte[] sbox = new byte[0x100];
  7.             int j, k;
  8.             do
  9.             {
  10.                 z = 0x00;
  11.                 x = calc_inverse(i);
  12.                 for (j = 0; j < 8; j++)
  13.                 {
  14.                     z = (byte)(z >> 1);
  15.                     y = (byte)(a[j] & x);
  16.                     x1 = 0x00;
  17.                     for (k = 0; k < 8; k++)
  18.                     {
  19.                         x1 ^= (byte)(y & 0x80);
  20.                         y = (byte)(y << 1);
  21.                     }
  22.                     z ^= x1;
  23.                 }
  24.                 z ^= b;
  25.                 sbox[i] = z;
  26.                 i++;
  27.             } while (i != 0x00);
  28.  
  29.             return sbox;
  30.         }
  31.         public static void create_shift_sbox(byte[] oriSbox, out uint[] sbox0, out uint[] sbox1, out uint[] sbox2, out uint[] sbox3)
  32.         {
  33.             sbox0 = new uint[256];
  34.             for (int idx = 0; idx < 0x100; idx++)
  35.                 sbox0[idx] = oriSbox[idx];
  36.             sbox1 = new uint[256];
  37.             for (int idx = 0; idx < 0x100; idx++)
  38.                 sbox1[idx] = (uint)(oriSbox[idx] << 8);
  39.             sbox2 = new uint[256];
  40.             for (int idx = 0; idx < 0x100; idx++)
  41.                 sbox2[idx] = (uint)(oriSbox[idx] << 0x10);
  42.             sbox3 = new uint[256];
  43.             for (int idx = 0; idx < 0x100; idx++)
  44.                 sbox3[idx] = (uint)(oriSbox[idx] << 0x18);
  45.         }
  46.  
  47.         /// <summary>
  48.         /// 计算逆元
  49.         /// </summary>
  50.         private static byte calc_inverse(byte tar)
  51.         {
  52.             if (tar == 0x00)
  53.                 return 0x00;
  54.  
  55.             for (byte i = 0x01; i != 0x00; i++)
  56.                 if (gf_mul(tar, i) == 0x01)
  57.                     return i;
  58.  
  59.             throw new Exception("不对劲，没有正常return");
  60.         }
  61.         /// <summary>
  62.         /// 乘法运算
  63.         /// </summary>
  64.         /// <param name="a"></param>
  65.         /// <param name="b"></param>
  66.         /// <returns></returns>
  67.         private static byte gf_mul(byte a, byte b)
  68.         {
  69.             byte[] data = new byte[8];
  70.             data[0] = a;
  71.             data[1] = (byte)(data[0] << 1);
  72.             if ((data[0] & 0x80) == 0x80) data[1] ^= 0x1b;
  73.             data[2] = (byte)(data[1] << 1);
  74.             if ((data[1] & 0x80) == 0x80) data[2] ^= 0x1b;
  75.             data[3] = (byte)(data[2] << 1);
  76.             if ((data[2] & 0x80) == 0x80) data[3] ^= 0x1b;
  77.             data[4] = (byte)(data[3] << 1);
  78.             if ((data[3] & 0x80) == 0x80) data[4] ^= 0x1b;
  79.             data[5] = (byte)(data[4] << 1);
  80.             if ((data[4] & 0x80) == 0x80) data[5] ^= 0x1b;
  81.             data[6] = (byte)(data[5] << 1);
  82.             if ((data[5] & 0x80) == 0x80) data[6] ^= 0x1b;
  83.             data[7] = (byte)(data[6] << 1);
  84.             if ((data[6] & 0x80) == 0x80) data[7] ^= 0x1b;
  85.  
  86.             byte dat = 0x00;
  87.             if ((b & 0x01) == 0x01) dat ^= data[0];
  88.             if ((b & 0x02) == 0x02) dat ^= data[1];
  89.             if ((b & 0x04) == 0x04) dat ^= data[2];
  90.             if ((b & 0x08) == 0x08) dat ^= data[3];
  91.             if ((b & 0x10) == 0x10) dat ^= data[4];
  92.             if ((b & 0x20) == 0x20) dat ^= data[5];
  93.             if ((b & 0x40) == 0x40) dat ^= data[6];
  94.             if ((b & 0x80) == 0x80) dat ^= data[7];
  95.  
  96.             return dat;
  97.         }

生成TBOX

  1.         /// <summary>
  2.         /// 2 1 1 3
  3.         /// 3 2 1 1
  4.         /// 1 3 2 1
  5.         /// 1 1 3 2
  6.         /// </summary>
  7.         /// <param name="sbox"></param>
  8.         /// <param name="tbox0">2 1 1 3</param>
  9.         /// <param name="tbox1">3 2 1 1</param>
  10.         /// <param name="tbox2">1 3 2 1</param>
  11.         /// <param name="tbox3">1 1 3 2</param>
  12.         public static void create_tbox(byte[] sbox, out uint[] tbox0, out uint[] tbox1, out uint[] tbox2, out uint[] tbox3)
  13.         {
  14.             tbox0 = new uint[256];
  15.             tbox1 = new uint[256];
  16.             tbox2 = new uint[256];
  17.             tbox3 = new uint[256];
  18.  
  19.             for (int i = 0; i < 0x100; i++)
  20.             {
  21.                 //byte mul1 = gf_mul(sbox[i], 1);
  22.                 byte mul1 = sbox[i];
  23.                 byte mul2 = gf_mul(sbox[i], 2);
  24.                 byte mul3 = gf_mul(sbox[i], 3);
  25.  
  26.                 tbox0[i] = (uint)((mul2 << 0x18) | (mul1 << 0x10) | (mul1 << 8) | mul3);
  27.                 tbox1[i] = (uint)((mul3 << 0x18) | (mul2 << 0x10) | (mul1 << 8) | mul1);
  28.                 tbox2[i] = (uint)((mul1 << 0x18) | (mul3 << 0x10) | (mul2 << 8) | mul1);
  29.                 tbox3[i] = (uint)((mul1 << 0x18) | (mul1 << 0x10) | (mul3 << 8) | mul2);
  30.             }
  31.         }

秘钥拓展

  1.         /// <summary>
  2.         /// Rcon
  3.         /// </summary>
  4.         public static uint[] ROUND_PARAMS_B = new uint[10]
  5.         {
  6.             0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1B, 0x36,
  7.         };
  8.  
  9.         public static byte[] create_round_keys_bytes(byte[] keys)
  10.         {
  11.             byte[] expKey = new byte[0xb0];
  12.             for (int i = 0; i < 0x10; i += 4) // mem copy
  13.             {
  14.                 // 大小端转换
  15.                 expKey[i] = keys[i + 3];
  16.                 expKey[i + 1] = keys[i + 2];
  17.                 expKey[i + 2] = keys[i + 1];
  18.                 expKey[i + 3] = keys[i];
  19.             }
  20.  
  21.             for (int i = 0x10, rounds = 0; i < 0xb0; i += 0x10, rounds++)
  22.             {
  23.                 // 前一个4字节uint
  24.                 byte b0 = expKey[i - 4];
  25.                 byte b1 = expKey[i - 3];
  26.                 byte b2 = expKey[i - 2];
  27.                 byte b3 = expKey[i - 1];
  28.  
  29.                 expKey[i] = (byte)(expKey[i - 0x10] ^ SBOX0[b3]);
  30.                 expKey[i + 1] = (byte)(expKey[i - 0x10 + 1] ^ SBOX0[b0]);
  31.                 expKey[i + 2] = (byte)(expKey[i - 0x10 + 2] ^ SBOX0[b1]);
  32.                 expKey[i + 3] = (byte)(expKey[i - 0x10 + 3] ^ SBOX0[b2] ^ ROUND_PARAMS_B[rounds]);
  33.  
  34.                 // 分组后12B，循环处理
  35.                 for (int j = 4; j < 0x10; j++)
  36.                     expKey[i + j] = (byte)(expKey[i + j - 4] ^ expKey[i + j - 0x10]);
  37.             }
  38.  
  39.             return expKey;
  40.         }

分组加密

  1.         /// <summary>
  2.         /// 4个SBOX，分别对应：
  3.         /// SBOX0[i]: SBOX_ori[i]
  4.         /// SBOX1[i]: SBOX_ori[i] << 8
  5.         /// SBOX2[i]: SBOX_ori[i] << 0x10
  6.         /// SBOX3[i]: SBOX_ori[i] << 0x18
  7.         /// </summary>
  8.         public static uint[] SBOX0;
  9.         public static uint[] SBOX1;
  10.         public static uint[] SBOX2;
  11.         public static uint[] SBOX3;
  12.         /// <summary>
  13.         /// 4个TBOX，根据矩阵运算得到
  14.         /// </summary>
  15.         public static uint[] TBOX0;
  16.         public static uint[] TBOX1;
  17.         public static uint[] TBOX2;
  18.         public static uint[] TBOX3;
  19.  
  20.         public static void init_box()
  21.         {
  22.             byte[] oriSbox = create_sbox();
  23.             create_shift_sbox(oriSbox, out SBOX0, out SBOX1, out SBOX2, out SBOX3);
  24.             create_tbox(oriSbox, out TBOX0, out TBOX1, out TBOX2, out TBOX3);
  25.         }
  26.  
  27.         /// <summary>
  28.         /// 分组加密运算，aes-128，没个分组计算10轮
  29.         /// </summary>
  30.         public static void round_encrypt(byte[] data, byte[] expKey)
  31.         {
  32.             byte A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15;
  33.             byte D0, D1, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, D12, D13, D14, D15;
  34.  
  35.             uint u0 = ReadUint_LE(expKey, 0) ^ ReadUint_BE(data, 0);
  36.             uint u1 = ReadUint_LE(expKey, 4) ^ ReadUint_BE(data, 4);
  37.             uint u2 = ReadUint_LE(expKey, 8) ^ ReadUint_BE(data, 8);
  38.             uint u3 = ReadUint_LE(expKey, 0xc) ^ ReadUint_BE(data, 0xc);
  39.  
  40.             uint wa0, wa1, wa2, wa3;
  41.             int halfRound = (0xa >> 1) - 1; // 一重循环做两次
  42.             for (int i = 0x10; ; i += 0x20)
  43.             {
  44.                 // 因为大小端的原因，这里的高位字节，其实是字节数组中的低位，高尾端模式：HI在低位。
  45.                 A0 = HIBYTE(u0);
  46.                 A1 = BYTE2(u0);
  47.                 A2 = BYTE1(u0);
  48.                 A3 = LOWBYTE(u0);
  49.  
  50.                 A4 = HIBYTE(u1);
  51.                 A5 = BYTE2(u1);
  52.                 A6 = BYTE1(u1);
  53.                 A7 = LOWBYTE(u1);
  54.  
  55.                 A8 = HIBYTE(u2);
  56.                 A9 = BYTE2(u2);
  57.                 A10 = BYTE1(u2);
  58.                 A11 = LOWBYTE(u2);
  59.  
  60.                 A12 = HIBYTE(u3);
  61.                 A13 = BYTE2(u3);
  62.                 A14 = BYTE1(u3);
  63.                 A15 = LOWBYTE(u3);
  64.  
  65.                 wa0 = TBOX0[A0] ^ TBOX1[A5] ^ TBOX2[A10] ^ TBOX3[A15] ^ ReadUint_LE(expKey, i);
  66.                 wa1 = TBOX0[A4] ^ TBOX1[A9] ^ TBOX2[A14] ^ TBOX3[A3] ^ ReadUint_LE(expKey, i + 4);
  67.                 wa2 = TBOX0[A8] ^ TBOX1[A13] ^ TBOX2[A2] ^ TBOX3[A7] ^ ReadUint_LE(expKey, i + 8);
  68.                 wa3 = TBOX0[A12] ^ TBOX1[A1] ^ TBOX2[A6] ^ TBOX3[A11] ^ ReadUint_LE(expKey, i + 0xc);
  69.  
  70.                 // 还是要注意大小端。小端模式下：尾部LO在低位0
  71.                 D0 = HIBYTE(wa0);
  72.                 D1 = BYTE2(wa0);
  73.                 D2 = BYTE1(wa0);
  74.                 D3 = LOWBYTE(wa0);
  75.  
  76.                 D4 = HIBYTE(wa1);
  77.                 D5 = BYTE2(wa1);
  78.                 D6 = BYTE1(wa1);
  79.                 D7 = LOWBYTE(wa1);
  80.  
  81.                 D8 = HIBYTE(wa2);
  82.                 D9 = BYTE2(wa2);
  83.                 D10 = BYTE1(wa2);
  84.                 D11 = LOWBYTE(wa2);
  85.  
  86.                 D12 = HIBYTE(wa3);
  87.                 D13 = BYTE2(wa3);
  88.                 D14 = BYTE1(wa3);
  89.                 D15 = LOWBYTE(wa3);
  90.  
  91.                 if (halfRound == 0) break; // 为了循环能写简单一点、为了能精简汇编代码，原来的9轮循环，改成了现在2*4 + 1轮循环。实际上感觉这是汇编代码优化后的结果。不是刻意写成这样的。
  92.  
  93.                 u0 = TBOX0[D0] ^ TBOX1[D5] ^ TBOX2[D10] ^ TBOX3[D15] ^ ReadUint_LE(expKey, i + 0x10);
  94.                 u1 = TBOX0[D4] ^ TBOX1[D9] ^ TBOX2[D14] ^ TBOX3[D3] ^ ReadUint_LE(expKey, i + 0x14);
  95.                 u2 = TBOX0[D8] ^ TBOX1[D13] ^ TBOX2[D2] ^ TBOX3[D7] ^ ReadUint_LE(expKey, i + 0x18);
  96.                 u3 = TBOX0[D12] ^ TBOX1[D1] ^ TBOX2[D6] ^ TBOX3[D11] ^ ReadUint_LE(expKey, i + 0x1c);
  97.  
  98.                 halfRound = halfRound - 1;
  99.             }
  100.  
  101.             uint v39 = SBOX0[D15] ^ SBOX1[D10] ^ SBOX2[D5] ^ SBOX3[D0] ^ ReadUint_LE(expKey, 0xa0);
  102.             uint v40 = SBOX0[D3] ^ SBOX1[D14] ^ SBOX2[D9] ^ SBOX3[D4] ^ ReadUint_LE(expKey, 0xa4);
  103.             uint v42 = SBOX0[D7] ^ SBOX1[D2] ^ SBOX2[D13] ^ SBOX3[D8] ^ ReadUint_LE(expKey, 0xa8);
  104.             uint v35 = SBOX0[D11] ^ SBOX1[D6] ^ SBOX2[D1] ^ SBOX3[D12] ^ ReadUint_LE(expKey, 0xac);
  105.  
  106.             data[0] = HIBYTE(v39);
  107.             data[1] = BYTE2(v39);
  108.             data[2] = BYTE1(v39);
  109.             data[3] = LOWBYTE(v39);
  110.  
  111.             data[4] = HIBYTE(v40);
  112.             data[5] = BYTE2(v40);
  113.             data[6] = BYTE1(v40);
  114.             data[7] = LOWBYTE(v40);
  115.  
  116.             data[8] = HIBYTE(v42);
  117.             data[9] = BYTE2(v42);
  118.             data[10] = BYTE1(v42);
  119.             data[11] = LOWBYTE(v42);
  120.  
  121.             data[12] = HIBYTE(v35);
  122.             data[13] = BYTE2(v35);
  123.             data[14] = BYTE1(v35);
  124.             data[15] = LOWBYTE(v35);
  125.         }

加密部分

这里采用in-place计算，加密结果直接写回到data。

  1.         /// <summary>
  2.         /// ECB模式
  3.         /// </summary>
  4.         /// <param name="data">数据部分保证16字节对齐</param>
  5.         /// <param name="key">秘钥长度为16字节</param>
  6.         public static void aes_128_ecb_encrypt(byte[] data, byte[] key)
  7.         {
  8.             byte[] expKey = create_round_keys_bytes(key);
  9.  
  10.             byte[] buf = new byte[0x10];
  11.             for (int i = 0; i < data.Length; i += 0x10)
  12.             {
  13.                 Array.Copy(data, i, buf, 0, 0x10);
  14.                 round_encrypt(buf, expKey);
  15.                 Array.Copy(buf, 0, data, i, 0x10);
  16.             }
  17.         }
  18.         /// <summary>
  19.         /// CBC模式
  20.         /// </summary>
  21.         /// <param name="data">数据部分保证16字节对齐</param>
  22.         /// <param name="key">秘钥长度为16字节</param>
  23.         public static void aes_128_cbc_encrypt(byte[] data, byte[] key, byte[] iv)
  24.         {
  25.             byte[] expKey = create_round_keys_bytes(key);
  26.  
  27.             byte[] buf = new byte[0x10];
  28.             for (int i = 0; i < data.Length; i += 0x10)
  29.             {
  30.                 Array.Copy(data, i, buf, 0, 0x10);
  31.  
  32.                 for (int j = 0; j < 16; j++)
  33.                     buf[j] = (byte)(iv[j] ^ buf[j]);
  34.  
  35.                 round_encrypt(buf, expKey);
  36.  
  37.                 Array.Copy(buf, 0, data, i, 0x10);
  38.                 Array.Copy(buf, 0, iv, i, 0x10);
  39.             }
  40.         }

测试程序

  1.     class Program
  2.     {
  3.         static void Main(string[] args)
  4.         {
  5.             MyAes.init_box();
  6.             byte[] keys = ByteUtils.FromHexString("2E82BFAFF4E0C26D1D032A8F90803EAE");
  7.             byte[] iv = ByteUtils.FromHexString("7315254F862899A133B3A832C2F78E0E");
  8.  
  9.             // ecb测试
  10.             byte[] testData = new byte[0x10] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
  11.             Console.WriteLine(ByteUtils.ToHexString(testData));
  12.             Console.WriteLine(ByteUtils.ToHexString(keys));
  13.             MyAes.aes_128_ecb_encrypt(testData, keys);
  14.             Console.WriteLine(ByteUtils.ToHexString(testData));
  15.  
  16.             Console.WriteLine();
  17.  
  18.             // cbc测试
  19.             testData = new byte[0x10] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
  20.             Console.WriteLine(ByteUtils.ToHexString(testData));
  21.             Console.WriteLine(ByteUtils.ToHexString(keys));
  22.             Console.WriteLine(ByteUtils.ToHexString(iv));
  23.             MyAes.aes_128_cbc_encrypt(testData, keys, iv);
  24.             Console.WriteLine(ByteUtils.ToHexString(testData));
  25.  
  26.             Console.ReadKey();
  27.         }
  28.     }

测试结果

 实际计算结果，和采用公共加密库计算得到的结果一致。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/article/detail/51814
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号