作业要求：

构造256字节的表格X2，使得X2[i] ={02}*i，i是GF(2^8)中的元素。将此表运用于GF(2^8)的乘法，与之前作业的乘法对比，看谁的速度快？

直奔主题吧。

先看看主函数：

int main()
{   //  -- 构造乘法表X2 --createX2();//  -- 进入乘法运算程序 --int abin[8], bbin[8], c[8];LARGE_INTEGER start_t, stop_t, freq; // start_t表示计时开始时间，stop_t表示计时结束时间，freq为计时器的时钟频率double exe_time;QueryPerformanceFrequency(&freq);// fprintf(stdout, "The frequency of your pc is %d.\n", freq.QuadPart);char choose='y';while(choose=='y'||choose=='Y'){//  -- 清空之前的计算结果 --for(int i=0; i<8; i++){c[i]=0; // 清空结果}state=0; // 清空当前查表次数//  -- 输入乘数a和b --if(input(abin, 'a')==0) // 如果输入a没有出错{if(input(bbin, 'b')==0) // 如果输入b没有出错{//  -- 程序开始执行，开始计时 --QueryPerformanceCounter(&start_t);// -- 将输入的二进制数组转换为十进制数组并保存到temp中 --int temp[2];temp[0]=binToDec(abin, 0);temp[1]=binToDec(abin, 1);//  -- 执行乘法运算 --for(i=7; i>=0; i--){if(bbin[i]==1){xor(c, leftshift(abin, 7-i, temp)); // 求和}            }//  -- 输出运算结果 --cout<<"运算结果为：";for(i=0; i<8; i++){cout<<c[i];}//  -- 程序结束执行，结束计时 --QueryPerformanceCounter(&stop_t);exe_time = 1e3*(stop_t.QuadPart-start_t.QuadPart)/freq.QuadPart;cout<<endl;fprintf(stdout, "计算用时：%fms.\n", exe_time);}}//  -- 是否继续执行程序 --cout<<endl<<"是否继续?y/n:";choose=cin.get();if(cin.get()==10){// 跳过输入y/n后的回车键，防止影响下面的输入}}return 0;
}

程序流程：构造乘法表X2 —— 初始化工作 —— 输入数a和数b —— 用查表法计算乘法结果 —— 输出运算结果和运算所用时间 —— 是否循环执行程序。

下面分段来看。

1.构造乘法表X2

为了便于使用该表，将其声明为全局静态变量：

static int *xtable[16][16]; // 乘法表X2

构造表的函数：

/* 建造乘法表X2 */
void createX2()
{int temp=0, arr[2], bin[8];int j, k;// 初始化xtable前半部分：00-7Ffor(j=0; j<8; j++){for(k=0; k<16; k++){intToArr(temp*2, arr);temp++;xtable[j][k]=new int[2];xtable[j][k][0]=arr[0];xtable[j][k][1]=arr[1];}}// 初始化xtable后半部分：80-FFfor(j=8; j<16; j++){for(k=0; k<16; k++){intToArr(temp, arr);decToBin(arr, bin);leftshift1(bin);arr[0]=binToDec(bin, 0);arr[1]=binToDec(bin, 1);xtable[j][k]=new int[2];xtable[j][k][0]=arr[0];xtable[j][k][1]=arr[1];temp++;}}
}

由于00-7F的运算结果为00-FE，没有溢出，所以可以作为表的前半部分初始化。80-FF全部溢出，需要先左移1位再异或1BH，所以作为表的后半部分初始化。

注意由于xtable二维数组中的元素均为指针类型，如果对于每一次赋值都使用xtable[j][k]=arr;那么xtable中所有指针都指向同一块内存块arr，由于arr[2]最后的结果为14 5，所以所有xtable中的元素都指向{14, 5}数组，因此必须首先new一个xtable[j][k]指针，其长度为2，然后分别对其中的两个元素赋值。

在后半部分初始化中，例如255，先要用intToArr函数将其转化为两位的16进制数组（每一位都是十进制数），即{15，15}：

/* 将整数转换为数组，例如78=4 14* 参数temp为要转换的整数* 参数a[]为转换结果*/
void intToArr(int temp, int a[])
{a[1]=temp%16;a[0]=(temp-a[1])/16;
}

然后用decToBin函数将两位16进制数组转换为二进制数组，即11111111：

/* 将2位十进制数组转换为8位二进制数组 * 参数d[]为要转换的十进制数组* 参数bin[]为转换后的二进制数组*/
void decToBin(int d[], int bin[])
{int h0=d[0];int h1=d[1];int i=3;while(i>=0){bin[i--]=h0%2;h0/=2;}i=7;while(i>=4){bin[i--]=h1%2;h1/=2;}
}

先将转换后的数组bin左移1位，再作溢出处理，即使用leftshift1函数：

/* 乘2，左移1位，如果溢出则异或1BH */
void leftshift1(int a[])
{int temp=a[0];for(int i=0; i<7; i++){a[i]=a[i+1];}a[7]=0;if(temp==1) // 溢出处理{int mod[8]={0, 0, 0, 1, 1, 0, 1, 1};xor(a, mod);}
}

将转换的二进制数组转换为两位16进制数组：

/* 将4位二进制数组转换为十进制数 * 参数b[]为要进行转换的数组* 参数bit用于判断高低位，0为高位，1为低位* 返回结果为转换后的十进制数*/
int binToDec(int b[], int bit)
{int n=8, i=0, sum=0;if(bit==0) // 高四位二进制转换十进制i=0;else if(bit==1) // 低四位二进制转换十进制i=4;else return -1;// 4位二进制转换十进制，例如1011=11while(n>=1){sum+=(n*b[i]);i++;n/=2;}return sum;
}

注意，为什么每一位都是十进制数呢（例如F对应15），原因是查表时行号和列号是直接用十进制查的，这样便于迭代查表。虽然转换麻烦了点，但是在做乘法查表时不用再转换。

如果表格为两位16进制字符数组，那么结果为：

static char *sbox[16][16]={ {"00", "02", "04", "06", "08", "0A", "0C", "0E", "10", "12", "14", "16", "18", "1A", "1C", "1E"}, // 0{"20", "22", "24", "26", "28", "2A", "2C", "2E", "30", "32", "34", "36", "38", "3A", "3C", "3E"}, // 1{"40", "42", "44", "46", "48", "4A", "4C", "4E", "50", "52", "54", "56", "58", "5A", "5C", "5E"}, // 2{"60", "62", "64", "66", "68", "6A", "6C", "6E", "70", "72", "74", "76", "78", "7A", "7C", "7E"}, // 3{"80", "82", "84", "86", "88", "8A", "8C", "8E", "90", "92", "94", "96", "98", "9A", "9C", "9E"}, // 4{"A0", "A2", "A4", "A6", "A8", "AA", "AC", "AE", "B0", "B2", "B4", "B6", "B8", "BA", "BC", "BE"}, // 5{"C0", "C2", "C4", "C6", "C8", "CA", "CC", "CE", "D0", "D2", "D4", "D6", "D8", "DA", "DC", "DE"}, // 6{"E0", "E2", "E4", "E6", "E8", "EA", "EC", "EE", "F0", "F2", "F4", "F6", "F8", "FA", "FC", "FE"}, // 7{"1B", "19", "1F", "1D", "13", "11", "17", "15", "0B", "09", "0F", "0D", "03", "01", "07", "05"}, // 8{"3B", "39", "3F", "3D", "33", "31", "37", "35", "2B", "29", "2F", "2D", "23", "21", "27", "25"}, // 9{"5B", "59", "5F", "5D", "53", "51", "57", "55", "4B", "49", "4F", "4D", "43", "41", "47", "45"}, // A{"7B", "79", "7F", "7D", "73", "71", "77", "75", "6B", "69", "6F", "6D", "63", "61", "67", "65"}, // B{"9B", "99", "9F", "9D", "93", "91", "97", "95", "8B", "89", "8F", "8D", "83", "81", "87", "85"}, // C{"BB", "B9", "BF", "BD", "B3", "B1", "B7", "B5", "AB", "A9", "AF", "AD", "A3", "A1", "A7", "A5"}, // D{"DB", "D9", "DF", "DD", "D3", "D1", "D7", "D5", "CB", "C9", "CF", "CD", "C3", "C1", "C7", "C5"}, // E{"FB", "F9", "FF", "FD", "F3", "F1", "F7", "F5", "EB", "E9", "EF", "ED", "E3", "E1", "E7", "E5"}  // F//  0     1     2     3     4     5     6     7     8     9     A     B     C     D     E     F
};

2.用查表法计算乘法结果

这里沿用了移位乘法的程序框架，只是计算的方法不同而已：

               //  -- 执行乘法运算 --for(i=7; i>=0; i--){if(bbin[i]==1){xor(c, leftshift(abin, 7-i, temp)); // 求和}            }

leftshift函数为：

/* 计算a[]乘上2的len次幂的结果* 参数bin[]为要进行移位的数组* 参数len为查表的次数* 参数temp[]用于保存乘法运算结果* 返回结果为乘2的运算结果*/
int *leftshift(int bin[], int len, int temp[])
{if(len==0){state=0;return bin;}int row, column;for(state; state<len; state++){row=temp[0];column=temp[1];temp[0]=xtable[row][column][0];temp[1]=xtable[row][column][1];}decToBin(temp, bin); // 将16进制的temp转换为二进制数组binreturn bin;
}

state为全局静态变量：

static int state=0; // 用于记录左移的位数，也就是已经查表的次数

其中一次查表就相当于一次左移（包括溢出处理）运算。

这里优化程序的思想和在GF(2^8)下可做任意两个数乘法的程序（一）中的乘法思想是一样的，为了避免每次都要从头开始查表，每次运算结果都用temp保存起来，用于下一次运算的查表。

例如：求a * 00000110，从右边开始，由于b[6]=1，所以先查表一次计算得到a * 2，并用temp保存a * 2的结果，在求a * 4的时候，可以直接用temp（也就是a * 2的结果）查表一次得到结果，如果没有用到temp的话，那么* 4必须要查表2次。最后将a * 2和 a * 4异或即可。

如果a中1的个数越多，那么优化后的程序效率更高（单纯就乘法该过程看），例如如果是a * 11111111，那么不优化的情况下要查表（每次查表对应一次乘2）1+2+3+4+5+6+7=28次。如果按以上的方法优化了，只需要查表7次就可以了。

至于输入数a和数b ，异或加运算等函数和在GF(2^8)下可做任意两个数乘法的程序（一）给出的一样，不再赘述。

运行一下，比较两者的运行效率：

乘法表运算时间结果：

直接乘法运算时间结果：

首先有一点要强调的是，由于CPU每个时刻工作的速度和时钟频率等都处于动态变化当中，所以以上数据不能算绝对准确，加上程序员不同的算法也会导致程序运行的时间出现差异，因此以上数据仅仅用于对比，而且也不能算得上绝对准确。

比较之下，乘法表运算多了一些转换的工作（包括leftshift函数，因为其中的异或运算必须要使用二进制数组，而且输出结果形式也是二进制形式），也就是在乘法表的条件差于移位乘法的情况下其效率仍然高于后者，所以也得出了老师想向我们传递的信息：GF(2^8)中的乘法运算查表运算的效率高于直接运算。

当初AES的设计者就是用该方法来对乘法进行加速（另外乘法可能会受到时间分析攻击），另外表所使用的空间开销并不大，用查表计算乘法结果的方法优于直接使用乘法。

最后，小结一个问题：

对于调用函数，如果传入参数的是数组指针并且在函数中修改了参数的值，那么数组的值将相应变化。如果传入参数的是基本类型并且在函数中修改了参数的值，基本类型变量的值却不会相应发生变化。例如：

#include <iostream>
using namespace std;void setTemp(int temp)
{temp=1;
}void setArr(int a[])
{a[0]=1;a[1]=1;
}void setBool(bool b)
{b=false;
}int main()
{int temp=0;bool b=true;int arr[2]={0,0};setTemp(temp);setArr(arr);cout<<"temp="<<temp<<endl;cout<<"b="<<b<<endl;cout<<"arr[0]="<<arr[0]<<endl;cout<<"arr[1]="<<arr[1]<<endl;
}

运行结果：

道理很简单，因为在传入指针到参数后，若参数值被修改，那么指针所指向的内存块的值也相应被修改。而基本类型变量的参数传入则是另外复制一份传值。